WASM Component Model

This document defines WIT (WebAssembly Interface Types) interfaces for implementing Morphir backends and extensions as portable, sandboxed WASM components.

Design Principles

Strongly Typed IR: Full IR types modeled in WIT, not JSON strings
Attributes as Document: Since WIT lacks generics, attributes use our document-value AST type
Full Pipeline: Support both frontend (source → IR) and backend (IR → target) flows
Multi-Granularity: Support operations at distribution, module, and definition levels
Capability-Based: Components declare which interfaces they implement
Sandboxed: Components have no implicit access to filesystem or network

Benefits

Benefit	Description
Language-agnostic	Backends can be written in Rust, Go, C, AssemblyScript, etc.
Sandboxed	Secure execution with explicit capability grants
Portable	Run anywhere WASM runs (CLI, browser, edge)
Hot-reloadable	Swap components without restarting the daemon
Type-safe	Full IR types at component boundary

WIT Package Structure

wit/
├── morphir-ir/
│   ├── document.wit       # Document AST (for attributes)
│   ├── naming.wit         # Name, Path, FQName
│   ├── types.wit          # Type expressions
│   ├── values.wit         # Value expressions, literals, patterns
│   ├── modules.wit        # Module specs and defs
│   ├── packages.wit       # Package specs and defs
│   └── distributions.wit  # Distribution types
├── morphir-extension/
│   ├── info.wit           # Required info interface (all extensions)
│   └── capabilities.wit   # Capability query interface
├── morphir-frontend/
│   ├── compiler.wit       # Source → IR compilation (basic)
│   ├── streaming.wit      # Streaming compilation capability
│   ├── incremental.wit    # Incremental compilation capability
│   └── fragment.wit       # Fragment/REPL compilation capability
├── morphir-backend/
│   ├── generator.wit      # IR → target code generation (basic)
│   ├── streaming.wit      # Streaming generation capability
│   ├── incremental.wit    # Incremental generation capability
│   ├── validator.wit      # Validation interface
│   └── transform.wit      # IR → IR transformation interface
├── morphir-vfs/
│   ├── reader.wit         # VFS read access
│   ├── writer.wit         # VFS write access
│   └── workspace.wit      # Workspace management
└── morphir-component/
    └── worlds.wit         # World definitions

Document Type (`document.wit`)

package morphir:ir@0.4.0;

/// Document AST for schema-less data and attributes
interface document {
    /// Recursive document value (JSON-like AST)
    variant document-value {
        /// null
        doc-null,
        /// Boolean
        doc-bool(bool),
        /// Integer
        doc-int(s64),
        /// Float
        doc-float(float64),
        /// String
        doc-string(string),
        /// Array
        doc-array(list<document-value>),
        /// Object (list of key-value pairs)
        doc-object(list<tuple<string, document-value>>),
    }

    /// Empty document (convenience)
    empty: func() -> document-value;

    /// Create object from pairs
    object: func(pairs: list<tuple<string, document-value>>) -> document-value;

    /// Get field from object
    get: func(doc: document-value, key: string) -> option<document-value>;

    /// Merge two documents (second wins on conflict)
    merge: func(base: document-value, overlay: document-value) -> document-value;
}

Naming Types (`naming.wit`)

package morphir:ir@0.4.0;

use document.{document-value};

/// Core naming types
interface naming {
    /// Type-level attributes (optional metadata, no type info needed)
    /// Types don't carry type annotations on themselves
    variant type-attributes {
        /// No attributes
        none,
        /// Custom metadata only
        meta(document-value),
    }

    /// A single name segment in kebab-case
    /// Examples: "user", "order-id", "get-user-by-email"
    type name = string;

    /// A path is a list of names representing hierarchy
    /// Serialized as slash-separated: "main/domain/users"
    type path = string;

    /// Module path within a package
    type module-path = string;

    /// Package path (organization/project)
    type package-path = string;

    /// Qualified name: module path + local name
    /// Format: "module/path#local-name"
    record qname {
        module-path: module-path,
        local-name: name,
    }

    /// Fully qualified name: package + module + local name
    /// Format: "package:module#name"
    record fqname {
        package-path: package-path,
        module-path: module-path,
        local-name: name,
    }

    /// Type variable name
    type type-variable = string;

    /// Parse FQName from canonical string
    /// "my-org/project:domain/users#user" -> FQName
    fqname-from-string: func(s: string) -> option<fqname>;

    /// Render FQName to canonical string
    fqname-to-string: func(fqn: fqname) -> string;
}

Type Expressions (`types.wit`)

package morphir:ir@0.4.0;

use document.{document-value};
use naming.{type-attributes, name, fqname, type-variable};

/// Type system definitions
interface types {
    /// Record field
    record field {
        field-name: name,
        field-type: ir-type,
    }

    /// Constructor for custom types
    record constructor {
        ctor-name: name,
        args: list<tuple<name, ir-type>>,
    }

    /// Type expression (uses type-attributes: none or metadata)
    variant ir-type {
        /// Type variable: `a`, `comparable`
        variable(tuple<type-attributes, type-variable>),

        /// Reference to named type: `String`, `List a`
        reference(tuple<type-attributes, fqname, list<ir-type>>),

        /// Tuple: `(Int, String)`
        %tuple(tuple<type-attributes, list<ir-type>>),

        /// Record: `{ name: String, age: Int }`
        record(tuple<type-attributes, list<field>>),

        /// Extensible record: `{ a | name: String }`
        extensible-record(tuple<type-attributes, type-variable, list<field>>),

        /// Function: `Int -> String`
        %function(tuple<type-attributes, ir-type, ir-type>),

        /// Unit type: `()`
        unit(type-attributes),
    }

    /// Value-level attributes (expressions carry their type)
    variant value-attributes {
        /// Just the inferred/checked type
        typed(ir-type),
        /// Type plus custom metadata
        typed-with-meta(tuple<ir-type, document-value>),
    }

    /// Access control
    enum access {
        public,
        private,
    }

    /// Access-controlled wrapper
    record access-controlled-constructors {
        access: access,
        constructors: list<constructor>,
    }

    /// Type specification (public interface)
    variant type-specification {
        /// Type alias visible to consumers
        type-alias-specification(tuple<list<type-variable>, ir-type>),

        /// Opaque type (no structure visible)
        opaque-type-specification(list<type-variable>),

        /// Custom type with public constructors
        custom-type-specification(tuple<list<type-variable>, list<constructor>>),

        /// Derived type with conversion functions
        derived-type-specification(tuple<list<type-variable>, derived-type-details>),
    }

    /// Details for derived types
    record derived-type-details {
        base-type: ir-type,
        from-base-type: fqname,
        to-base-type: fqname,
    }

    /// Hole reason for incomplete types
    variant hole-reason {
        unresolved-reference(fqname),
        deleted-during-refactor(string),
        type-mismatch(tuple<string, string>),
    }

    /// Incompleteness marker
    variant incompleteness {
        hole(hole-reason),
        draft(option<string>),
    }

    /// Type definition (implementation)
    variant type-definition {
        /// Custom type (sum type)
        custom-type-definition(tuple<list<type-variable>, access-controlled-constructors>),

        /// Type alias
        type-alias-definition(tuple<list<type-variable>, ir-type>),

        /// Incomplete type (v4)
        incomplete-type-definition(tuple<list<type-variable>, incompleteness, option<ir-type>>),
    }
}

Literals (`values.wit` - Part 1)

package morphir:ir@0.4.0;

/// Literal values
interface literals {
    /// Document value for schema-less data
    variant document-value {
        doc-null,
        doc-bool(bool),
        doc-int(s64),
        doc-float(float64),
        doc-string(string),
        doc-array(list<document-value>),
        doc-object(list<tuple<string, document-value>>),
    }

    /// Literal constant values
    variant literal {
        /// Boolean: true, false
        bool-literal(bool),

        /// Single character
        char-literal(string),

        /// Text string
        string-literal(string),

        /// Integer (includes negatives)
        integer-literal(s64),

        /// Floating-point
        float-literal(float64),

        /// Arbitrary-precision decimal (stored as string)
        decimal-literal(string),

        /// Document literal (schema-less JSON-like)
        document-literal(document-value),
    }
}

Patterns (`values.wit` - Part 2)

package morphir:ir@0.4.0;

use naming.{attributes, name, fqname};
use literals.{literal};

/// Pattern matching
interface patterns {
    use naming.{type-attributes};

    /// Pattern for destructuring and matching
    /// Patterns use type-attributes (no type info, just optional metadata)
    variant pattern {
        /// Wildcard: `_`
        wildcard-pattern(type-attributes),

        /// As pattern: `x` or `(a, b) as pair`
        as-pattern(tuple<type-attributes, pattern, name>),

        /// Tuple pattern: `(a, b, c)`
        tuple-pattern(tuple<type-attributes, list<pattern>>),

        /// Constructor pattern: `Just x`
        constructor-pattern(tuple<type-attributes, fqname, list<pattern>>),

        /// Empty list: `[]`
        empty-list-pattern(type-attributes),

        /// Head :: tail: `x :: xs`
        head-tail-pattern(tuple<type-attributes, pattern, pattern>),

        /// Literal match: `42`, `"hello"`
        literal-pattern(tuple<type-attributes, literal>),

        /// Unit: `()`
        unit-pattern(type-attributes),
    }
}

Value Expressions (`values.wit` - Part 3)

package morphir:ir@0.4.0;

use naming.{name, fqname};
use types.{ir-type, value-attributes, hole-reason, incompleteness};
use literals.{literal};
use patterns.{pattern};

/// Value expressions
interface values {
    /// Native operation hint
    variant native-hint {
        arithmetic,
        comparison,
        string-op,
        collection-op,
        platform-specific(string),
    }

    /// Native operation info
    record native-info {
        hint: native-hint,
        description: option<string>,
    }

    /// Value expression
    /// Values use value-attributes (carry their type, optionally with metadata)
    variant value {
        // === Literals & Data Construction ===

        /// Literal constant
        %literal(tuple<value-attributes, literal>),

        /// Constructor reference: `Just`
        %constructor(tuple<value-attributes, fqname>),

        /// Tuple: `(1, "hello")`
        %tuple(tuple<value-attributes, list<value>>),

        /// List: `[1, 2, 3]`
        %list(tuple<value-attributes, list<value>>),

        /// Record: `{ name = "Alice" }`
        %record(tuple<value-attributes, list<tuple<name, value>>>),

        /// Unit: `()`
        %unit(value-attributes),

        // === References ===

        /// Variable: `x`
        variable(tuple<value-attributes, name>),

        /// Reference to defined value: `List.map`
        reference(tuple<value-attributes, fqname>),

        // === Field Access ===

        /// Field access: `record.field`
        field(tuple<value-attributes, value, name>),

        /// Field function: `.field`
        field-function(tuple<value-attributes, name>),

        // === Function Application ===

        /// Apply: `f x`
        apply(tuple<value-attributes, value, value>),

        /// Lambda: `\x -> x + 1`
        lambda(tuple<value-attributes, pattern, value>),

        // === Let Bindings ===

        /// Let: `let x = 1 in x + 1`
        let-definition(tuple<value-attributes, name, value-definition-body, value>),

        /// Recursive let: `let f = ... g ...; g = ... f ... in ...`
        let-recursion(tuple<value-attributes, list<tuple<name, value-definition-body>>, value>),

        /// Destructure: `let (a, b) = pair in a + b`
        destructure(tuple<value-attributes, pattern, value, value>),

        // === Control Flow ===

        /// If-then-else
        if-then-else(tuple<value-attributes, value, value, value>),

        /// Pattern match: `case x of ...`
        pattern-match(tuple<value-attributes, value, list<tuple<pattern, value>>>),

        // === Record Update ===

        /// Update: `{ record | field = new }`
        update-record(tuple<value-attributes, value, list<tuple<name, value>>>),

        // === Special (v4) ===

        /// Incomplete/broken reference
        hole(tuple<value-attributes, hole-reason, option<ir-type>>),

        /// Native operation
        native(tuple<value-attributes, fqname, native-info>),

        /// External FFI
        external(tuple<value-attributes, string, string>),
    }

    /// Value definition body
    variant value-definition-body {
        /// Expression body
        expression-body(tuple<list<tuple<name, ir-type>>, ir-type, value>),

        /// Native body
        native-body(tuple<list<tuple<name, ir-type>>, ir-type, native-info>),

        /// External body
        external-body(tuple<list<tuple<name, ir-type>>, ir-type, string, string>),

        /// Incomplete body (v4)
        incomplete-body(tuple<list<tuple<name, ir-type>>, option<ir-type>, incompleteness, option<value>>),
    }

    /// Value specification (signature only)
    record value-specification {
        inputs: list<tuple<name, ir-type>>,
        output: ir-type,
    }

    /// Access-controlled value definition
    record value-definition {
        access: types.access,
        body: value-definition-body,
    }
}

Modules (`modules.wit`)

package morphir:ir@0.4.0;

use naming.{name, module-path};
use types.{type-specification, type-definition, access};
use values.{value-specification, value-definition};

/// Module definitions
interface modules {
    /// Documentation (opaque string or list of strings)
    variant documentation {
        single-line(string),
        multi-line(list<string>),
    }

    /// Documented wrapper
    record documented-type-spec {
        doc: option<documentation>,
        value: type-specification,
    }

    /// Module specification (public interface)
    record module-specification {
        types: list<tuple<name, documented-type-spec>>,
        values: list<tuple<name, value-specification>>,
    }

    /// Documented type definition with access
    record access-controlled-documented-type-def {
        access: access,
        doc: option<documentation>,
        definition: type-definition,
    }

    /// Documented value definition with access
    record access-controlled-documented-value-def {
        access: access,
        doc: option<documentation>,
        definition: value-definition,
    }

    /// Module definition (implementation)
    record module-definition {
        types: list<tuple<name, access-controlled-documented-type-def>>,
        values: list<tuple<name, access-controlled-documented-value-def>>,
    }

    /// Access-controlled module definition
    record access-controlled-module-definition {
        access: access,
        definition: module-definition,
    }
}

Packages (`packages.wit`)

package morphir:ir@0.4.0;

use naming.{module-path};
use modules.{module-specification, access-controlled-module-definition};

/// Package definitions
interface packages {
    /// Package specification (public interface)
    record package-specification {
        modules: list<tuple<module-path, module-specification>>,
    }

    /// Package definition (implementation)
    record package-definition {
        modules: list<tuple<module-path, access-controlled-module-definition>>,
    }
}

Distributions (`distributions.wit`)

package morphir:ir@0.4.0;

use naming.{name, fqname, package-path};
use modules.{documentation};
use packages.{package-specification, package-definition};

/// Distribution types
interface distributions {
    /// Semantic version
    record semver {
        major: u32,
        minor: u32,
        patch: u32,
        pre-release: option<string>,
        build-metadata: option<string>,
    }

    /// Package info
    record package-info {
        name: package-path,
        version: semver,
    }

    /// Entry point kind
    enum entry-point-kind {
        main,
        command,
        handler,
        job,
        policy,
    }

    /// Entry point
    record entry-point {
        target: fqname,
        kind: entry-point-kind,
        doc: option<documentation>,
    }

    /// Library distribution
    record library-distribution {
        package: package-info,
        definition: package-definition,
        dependencies: list<tuple<package-path, package-specification>>,
    }

    /// Specs distribution
    record specs-distribution {
        package: package-info,
        specification: package-specification,
        dependencies: list<tuple<package-path, package-specification>>,
    }

    /// Application distribution
    record application-distribution {
        package: package-info,
        definition: package-definition,
        dependencies: list<tuple<package-path, package-definition>>,
        entry-points: list<tuple<name, entry-point>>,
    }

    /// Distribution variant
    variant distribution {
        library(library-distribution),
        specs(specs-distribution),
        application(application-distribution),
    }
}

Extension Info Interface (`info.wit`)

Every extension must implement this interface - it’s the only required interface:

package morphir:extension@0.4.0;

/// Required interface - all extensions must implement this
interface info {
    /// Extension type classification
    enum extension-type {
        /// Frontend/compiler (source → IR)
        frontend,
        /// Backend/code generator (IR → target)
        codegen,
        /// Validator/analyzer
        validator,
        /// IR transformer (IR → IR)
        transformer,
        /// General purpose
        general,
    }

    /// Extension metadata
    record extension-info {
        /// Unique identifier (e.g., "spark-codegen")
        id: string,
        /// Human-readable name
        name: string,
        /// Version (semver)
        version: string,
        /// Description
        description: string,
        /// Author/maintainer
        author: option<string>,
        /// Homepage/repository URL
        homepage: option<string>,
        /// License identifier (SPDX)
        license: option<string>,
        /// Extension types (can fulfill multiple roles)
        types: list<extension-type>,
    }

    /// Return extension metadata
    get-info: func() -> extension-info;

    /// Health check - return true if extension is ready
    ping: func() -> bool;
}

/// Capability discovery interface
interface capabilities {
    use info.{extension-type};

    /// Capability identifier (e.g., "codegen/generate-streaming")
    type capability-id = string;

    /// Capability info
    record capability-info {
        /// Capability identifier
        id: capability-id,
        /// Human-readable description
        description: string,
        /// Whether this capability is available
        available: bool,
    }

    /// Options schema for configurable extensions
    record option-schema {
        /// Option name
        name: string,
        /// Option type
        option-type: option-type,
        /// Default value (as JSON string)
        default-value: option<string>,
        /// Description
        description: string,
        /// Whether this option is required
        required: bool,
    }

    /// Option type
    enum option-type {
        %string,
        integer,
        float,
        boolean,
        array,
        object,
    }

    /// Query all capabilities this extension provides
    list-capabilities: func() -> list<capability-info>;

    /// Check if a specific capability is available
    has-capability: func(id: capability-id) -> bool;

    /// Get targets this extension supports (for codegen)
    get-targets: func() -> list<string>;

    /// Get languages this extension supports (for frontend)
    get-languages: func() -> list<string>;

    /// Get configurable options schema
    get-options-schema: func() -> list<option-schema>;
}

Frontend Compiler Interface (`compiler.wit`)

package morphir:frontend@0.4.0;

use morphir:ir@0.4.0.{
    naming.{name, module-path, package-path, fqname},
    types.{type-definition},
    values.{value-definition},
    modules.{module-definition},
    packages.{package-definition},
    distributions.{distribution, semver},
};

/// Frontend compiler interface (source → IR)
interface compiler {
    /// Source language
    enum source-language {
        elm,
        morphir-dsl,
        custom,
    }

    /// Compilation granularity capability
    flags compiler-capabilities {
        /// Can compile entire workspace
        workspace,
        /// Can compile single project
        project,
        /// Can compile single module
        module,
        /// Can compile individual files
        file,
        /// Can compile code fragments
        fragment,
    }

    /// Compiler metadata
    record compiler-info {
        name: string,
        description: string,
        version: string,
        source-language: source-language,
        custom-language: option<string>,
        capabilities: compiler-capabilities,
    }

    /// Source file
    record source-file {
        /// File path (relative to project root)
        path: string,
        /// File content
        content: string,
    }

    /// Project configuration
    record project-config {
        /// Project name
        name: package-path,
        /// Project version
        version: semver,
        /// Source directory
        source-dir: string,
        /// Dependencies
        dependencies: list<tuple<package-path, semver>>,
        /// Custom configuration as document
        custom: option<morphir:ir@0.4.0.document.document-value>,
    }

    /// Workspace configuration
    record workspace-config {
        /// Workspace root path
        root: string,
        /// Projects in workspace
        projects: list<project-config>,
    }

    /// Fragment context (for incremental/editor compilation)
    record fragment-context {
        /// Module this fragment belongs to
        module-path: module-path,
        /// Imports available in scope
        imports: list<fqname>,
        /// Local bindings in scope
        locals: list<tuple<name, morphir:ir@0.4.0.types.ir-type>>,
    }

    /// Diagnostic severity
    enum severity {
        error,
        warning,
        info,
        hint,
    }

    /// Source location
    record source-location {
        file: string,
        start-line: u32,
        start-col: u32,
        end-line: u32,
        end-col: u32,
    }

    /// Compiler diagnostic
    record diagnostic {
        severity: severity,
        code: string,
        message: string,
        location: option<source-location>,
        hints: list<string>,
    }

    /// Compilation result for workspace
    variant workspace-result {
        ok(list<distribution>),
        partial(tuple<list<distribution>, list<diagnostic>>),
        failed(list<diagnostic>),
    }

    /// Compilation result for project
    variant project-result {
        ok(distribution),
        partial(tuple<distribution, list<diagnostic>>),
        failed(list<diagnostic>),
    }

    /// Compilation result for files
    variant files-result {
        ok(package-definition),
        partial(tuple<package-definition, list<diagnostic>>),
        failed(list<diagnostic>),
    }

    /// Compilation result for module
    variant module-result {
        ok(module-definition),
        partial(tuple<module-definition, list<diagnostic>>),
        failed(list<diagnostic>),
    }

    /// Compilation result for fragment
    variant fragment-result {
        /// Compiled to type definition
        type-def(type-definition),
        /// Compiled to value definition
        value-def(value-definition),
        /// Compiled to expression (for REPL)
        expression(morphir:ir@0.4.0.values.value),
        /// Failed
        failed(list<diagnostic>),
    }

    /// Get compiler metadata
    info: func() -> compiler-info;

    /// Compile entire workspace to IR
    compile-workspace: func(
        config: workspace-config,
        files: list<source-file>,
    ) -> workspace-result;

    /// Compile single project to IR
    compile-project: func(
        config: project-config,
        files: list<source-file>,
    ) -> project-result;

    /// Compile list of files to IR (incremental)
    compile-files: func(
        config: project-config,
        files: list<source-file>,
        /// Existing IR to merge with (for incremental)
        existing: option<package-definition>,
    ) -> files-result;

    /// Compile a single module to IR
    compile-module: func(
        config: project-config,
        /// Module path within the project
        module-path: module-path,
        /// Source files for this module
        files: list<source-file>,
        /// Existing module to merge with (for incremental)
        existing: option<module-definition>,
    ) -> module-result;

    /// Compile a code fragment (for editor/REPL)
    compile-fragment: func(
        source: string,
        context: fragment-context,
    ) -> fragment-result;

    /// Parse without full compilation (for syntax checking)
    parse-file: func(
        file: source-file,
    ) -> result<_, list<diagnostic>>;

    /// Get completions at position (for editor integration)
    completions: func(
        file: source-file,
        line: u32,
        column: u32,
        context: fragment-context,
    ) -> list<completion-item>;

    /// Completion item
    record completion-item {
        label: string,
        kind: completion-kind,
        detail: option<string>,
        insert-text: option<string>,
    }

    /// Completion kind
    enum completion-kind {
        %function,
        variable,
        %type,
        %constructor,
        module,
        keyword,
    }
}

Generator Interface (`generator.wit`)

package morphir:backend@0.4.0;

use morphir:ir@0.4.0.{
    naming.{fqname, module-path},
    types.{type-definition},
    values.{value-definition},
    modules.{module-definition},
    packages.{package-specification},
    distributions.{distribution},
};

/// Code generation interface
interface generator {
    /// Target language
    enum target-language {
        typescript,
        scala,
        java,
        go,
        python,
        rust,
        elm,
        custom,
    }

    /// Granularity level
    enum granularity {
        distribution,
        module,
        definition,
    }

    /// Generator metadata
    record generator-info {
        name: string,
        description: string,
        version: string,
        target: target-language,
        custom-target: option<string>,
        supported-granularities: list<granularity>,
    }

    /// Generation options
    record generation-options {
        output-dir: string,
        indent: option<string>,
        source-maps: bool,
        custom: option<string>,
    }

    /// Generated artifact
    record artifact {
        path: string,
        content: string,
        source-map: option<string>,
    }

    /// Diagnostic severity
    enum severity {
        error,
        warning,
        info,
        hint,
    }

    /// Source location
    record source-location {
        uri: string,
        start-line: u32,
        start-col: u32,
        end-line: u32,
        end-col: u32,
    }

    /// Diagnostic message
    record diagnostic {
        severity: severity,
        code: string,
        message: string,
        location: option<source-location>,
    }

    /// Generation result
    variant generation-result {
        /// Success
        ok(list<artifact>),
        /// Partial success with warnings
        degraded(tuple<list<artifact>, list<diagnostic>>),
        /// Failure
        failed(list<diagnostic>),
    }

    /// Get generator metadata
    info: func() -> generator-info;

    /// Generate code for entire distribution
    generate-distribution: func(
        dist: distribution,
        options: generation-options,
    ) -> generation-result;

    /// Generate code for a single module
    generate-module: func(
        path: module-path,
        module: module-definition,
        deps: package-specification,
        options: generation-options,
    ) -> generation-result;

    /// Generate code for a single type
    generate-type: func(
        fqn: fqname,
        def: type-definition,
        deps: package-specification,
        options: generation-options,
    ) -> generation-result;

    /// Generate code for a single value
    generate-value: func(
        fqn: fqname,
        def: value-definition,
        deps: package-specification,
        options: generation-options,
    ) -> generation-result;
}

Validator Interface (`validator.wit`)

package morphir:backend@0.4.0;

use morphir:ir@0.4.0.{
    naming.{fqname, module-path},
    types.{type-definition},
    values.{value-definition},
    modules.{module-definition},
    packages.{package-specification},
    distributions.{distribution},
};
use generator.{severity, diagnostic, granularity};

/// Validation interface
interface validator {
    /// Validator metadata
    record validator-info {
        name: string,
        description: string,
        version: string,
        categories: list<string>,
        supported-granularities: list<granularity>,
    }

    /// Validation options
    record validation-options {
        min-severity: option<severity>,
        enabled-rules: list<string>,
        disabled-rules: list<string>,
        custom: option<string>,
    }

    /// Validation result
    record validation-result {
        diagnostics: list<diagnostic>,
        passed: bool,
        error-count: u32,
        warning-count: u32,
    }

    /// Get validator metadata
    info: func() -> validator-info;

    /// Validate entire distribution
    validate-distribution: func(
        dist: distribution,
        options: validation-options,
    ) -> validation-result;

    /// Validate a single module
    validate-module: func(
        path: module-path,
        module: module-definition,
        deps: package-specification,
        options: validation-options,
    ) -> validation-result;

    /// Validate a single type
    validate-type: func(
        fqn: fqname,
        def: type-definition,
        deps: package-specification,
        options: validation-options,
    ) -> validation-result;

    /// Validate a single value
    validate-value: func(
        fqn: fqname,
        def: value-definition,
        deps: package-specification,
        options: validation-options,
    ) -> validation-result;
}

Frontend Streaming Interface (`frontend/streaming.wit`)

Optional capability for streaming compilation results:

package morphir:frontend@0.4.0;

use compiler.{source-file, project-config, diagnostic};
use morphir:ir@0.4.0.modules.{module-definition};
use morphir:ir@0.4.0.naming.{module-path};

/// Streaming compilation interface (optional capability)
interface streaming {
    /// Streaming module result
    record module-compile-result {
        /// Module path
        path: module-path,
        /// Compiled module (if successful)
        module: option<module-definition>,
        /// Diagnostics for this module
        diagnostics: list<diagnostic>,
    }

    /// Compile project with streaming results
    /// Returns a stream handle for polling results
    compile-streaming: func(
        config: project-config,
        files: list<source-file>,
    ) -> stream-handle;

    /// Stream handle for polling results
    type stream-handle = u64;

    /// Poll for next result (non-blocking)
    /// Returns none when stream is complete
    poll-result: func(handle: stream-handle) -> option<module-compile-result>;

    /// Check if stream is complete
    is-complete: func(handle: stream-handle) -> bool;

    /// Cancel streaming compilation
    cancel: func(handle: stream-handle);
}

Frontend Incremental Interface (`frontend/incremental.wit`)

Optional capability for incremental compilation:

package morphir:frontend@0.4.0;

use compiler.{source-file, project-config, diagnostic};
use morphir:ir@0.4.0.packages.{package-definition};
use morphir:ir@0.4.0.naming.{module-path};

/// Incremental compilation interface (optional capability)
interface incremental {
    /// File change event
    variant file-change {
        /// File was created
        created(source-file),
        /// File was modified
        modified(source-file),
        /// File was deleted
        deleted(string),
        /// File was renamed
        renamed(tuple<string, string>),
    }

    /// Incremental compilation result
    record incremental-result {
        /// Updated package definition
        package: package-definition,
        /// Modules that were recompiled
        recompiled-modules: list<module-path>,
        /// Modules that were invalidated (dependents)
        invalidated-modules: list<module-path>,
        /// Diagnostics from recompilation
        diagnostics: list<diagnostic>,
    }

    /// Apply incremental changes to existing IR
    compile-incremental: func(
        config: project-config,
        /// Existing compiled IR
        existing: package-definition,
        /// File changes since last compilation
        changes: list<file-change>,
    ) -> incremental-result;

    /// Get dependency graph for invalidation analysis
    get-module-dependencies: func(
        existing: package-definition,
    ) -> list<tuple<module-path, list<module-path>>>;
}

Backend Streaming Interface (`backend/streaming.wit`)

Optional capability for streaming code generation:

package morphir:backend@0.4.0;

use generator.{generation-options, artifact, diagnostic};
use morphir:ir@0.4.0.distributions.{distribution};
use morphir:ir@0.4.0.naming.{module-path};

/// Streaming generation interface (optional capability)
interface streaming {
    /// Module generation result
    record module-generation-result {
        /// Module path that was generated
        module-path: module-path,
        /// Generated artifacts for this module
        artifacts: list<artifact>,
        /// Diagnostics for this module
        diagnostics: list<diagnostic>,
    }

    /// Generate with streaming results
    generate-streaming: func(
        dist: distribution,
        options: generation-options,
    ) -> stream-handle;

    /// Stream handle for polling results
    type stream-handle = u64;

    /// Poll for next result (non-blocking)
    poll-result: func(handle: stream-handle) -> option<module-generation-result>;

    /// Check if stream is complete
    is-complete: func(handle: stream-handle) -> bool;

    /// Cancel streaming generation
    cancel: func(handle: stream-handle);
}

Backend Incremental Interface (`backend/incremental.wit`)

Optional capability for incremental code generation:

package morphir:backend@0.4.0;

use generator.{generation-options, artifact, diagnostic};
use morphir:ir@0.4.0.distributions.{distribution};
use morphir:ir@0.4.0.naming.{module-path};

/// Incremental generation interface (optional capability)
interface incremental {
    /// Module change notification
    record module-change {
        /// Module path that changed
        path: module-path,
        /// Type of change
        change-type: change-type,
    }

    /// Change type
    enum change-type {
        /// Module was added
        added,
        /// Module was modified
        modified,
        /// Module was removed
        removed,
    }

    /// Incremental generation result
    record incremental-generation-result {
        /// Generated/updated artifacts
        artifacts: list<artifact>,
        /// Artifacts to delete (paths)
        deleted-artifacts: list<string>,
        /// Diagnostics
        diagnostics: list<diagnostic>,
    }

    /// Generate incrementally for changed modules only
    generate-incremental: func(
        dist: distribution,
        changed-modules: list<module-change>,
        options: generation-options,
    ) -> incremental-generation-result;
}

Transform Interface (`backend/transform.wit`)

Standalone interface for IR-to-IR transformations:

package morphir:backend@0.4.0;

use generator.{diagnostic};
use morphir:ir@0.4.0.{
    naming.{fqname, module-path},
    types.{type-definition},
    values.{value-definition},
    modules.{module-definition},
    packages.{package-definition},
    distributions.{distribution},
    document.{document-value},
};

/// IR transformation interface
interface transform {
    /// Transformation metadata
    record transform-info {
        /// Transform name
        name: string,
        /// Description
        description: string,
        /// Version
        version: string,
        /// Whether transform preserves semantics
        semantic-preserving: bool,
    }

    /// Transformation options
    record transform-options {
        /// Dry run (report changes without applying)
        dry-run: bool,
        /// Custom options (JSON-like)
        custom: option<document-value>,
    }

    /// Transformation result
    record transform-result {
        /// Whether transformation succeeded
        success: bool,
        /// Number of definitions modified
        definitions-modified: u32,
        /// Diagnostics (warnings, info)
        diagnostics: list<diagnostic>,
    }

    /// Get transform metadata
    info: func() -> transform-info;

    /// Transform entire distribution
    transform-distribution: func(
        dist: distribution,
        options: transform-options,
    ) -> tuple<distribution, transform-result>;

    /// Transform a single module
    transform-module: func(
        path: module-path,
        module: module-definition,
        options: transform-options,
    ) -> tuple<module-definition, transform-result>;

    /// Transform a single type definition
    transform-type: func(
        fqn: fqname,
        def: type-definition,
        options: transform-options,
    ) -> tuple<type-definition, transform-result>;

    /// Transform a single value definition
    transform-value: func(
        fqn: fqname,
        def: value-definition,
        options: transform-options,
    ) -> tuple<value-definition, transform-result>;
}

VFS Interfaces (`reader.wit` / `writer.wit`)

package morphir:vfs@0.4.0;

use morphir:ir@0.4.0.{
    naming.{fqname, module-path, package-path},
    types.{type-definition},
    values.{value-definition},
    modules.{module-definition},
    distributions.{distribution},
};
use morphir:backend@0.4.0.generator.{diagnostic};

/// VFS read-only access
interface reader {
    /// Read error
    variant read-error {
        not-found(string),
        permission-denied(string),
        parse-error(string),
    }

    /// Read a type definition
    read-type: func(fqn: fqname) -> result<type-definition, read-error>;

    /// Read a value definition
    read-value: func(fqn: fqname) -> result<value-definition, read-error>;

    /// Read a module definition
    read-module: func(path: module-path) -> result<module-definition, read-error>;

    /// Read entire distribution
    read-distribution: func() -> result<distribution, read-error>;

    /// List modules in a package
    list-modules: func(pkg: package-path) -> result<list<module-path>, read-error>;

    /// List types in a module
    list-types: func(path: module-path) -> result<list<fqname>, read-error>;

    /// List values in a module
    list-values: func(path: module-path) -> result<list<fqname>, read-error>;
}

/// VFS write access
interface writer {
    /// Write error
    variant write-error {
        permission-denied(string),
        validation-failed(list<diagnostic>),
        conflict(string),
    }

    /// Transaction handle
    type transaction = u64;

    /// Begin transaction
    begin-transaction: func() -> transaction;

    /// Commit transaction
    commit: func(tx: transaction) -> result<_, write-error>;

    /// Rollback transaction
    rollback: func(tx: transaction) -> result<_, write-error>;

    /// Write a type definition
    write-type: func(
        tx: transaction,
        fqn: fqname,
        def: type-definition,
    ) -> result<_, write-error>;

    /// Write a value definition
    write-value: func(
        tx: transaction,
        fqn: fqname,
        def: value-definition,
    ) -> result<_, write-error>;

    /// Delete a type
    delete-type: func(tx: transaction, fqn: fqname) -> result<_, write-error>;

    /// Delete a value
    delete-value: func(tx: transaction, fqn: fqname) -> result<_, write-error>;

    /// Rename a type
    rename-type: func(
        tx: transaction,
        old-fqn: fqname,
        new-fqn: fqname,
    ) -> result<_, write-error>;

    /// Rename a value
    rename-value: func(
        tx: transaction,
        old-fqn: fqname,
        new-fqn: fqname,
    ) -> result<_, write-error>;
}

/// Workspace management
interface workspace {
    use morphir:ir@0.4.0.{
        naming.{package-path},
        distributions.{semver, distribution},
        document.{document-value},
    };

    // ============================================================
    // Types
    // ============================================================

    /// Workspace state
    enum workspace-state {
        /// Workspace is closed
        closed,
        /// Workspace is open and ready
        open,
        /// Workspace is being initialized
        initializing,
        /// Workspace has errors
        error,
    }

    /// Project state within workspace
    enum project-state {
        /// Project not yet loaded
        unloaded,
        /// Project is loading
        loading,
        /// Project is loaded and ready
        ready,
        /// Project has compilation errors
        error,
        /// Project is stale (needs recompilation)
        stale,
    }

    /// Workspace info
    record workspace-info {
        /// Workspace root path
        root: string,
        /// Workspace name (derived from root or config)
        name: string,
        /// Current state
        state: workspace-state,
        /// Projects in workspace
        projects: list<project-info>,
        /// Workspace-level configuration
        config: option<document-value>,
    }

    /// Project info
    record project-info {
        /// Project name (package path)
        name: package-path,
        /// Project version
        version: semver,
        /// Project root path (relative to workspace)
        path: string,
        /// Current state
        state: project-state,
        /// Source directory
        source-dir: string,
        /// Dependencies
        dependencies: list<dependency-info>,
    }

    /// Dependency info
    record dependency-info {
        /// Dependency name
        name: package-path,
        /// Required version
        version: semver,
        /// Whether dependency is resolved
        resolved: bool,
    }

    /// Workspace error
    variant workspace-error {
        /// Workspace not found
        not-found(string),
        /// Workspace already exists
        already-exists(string),
        /// Workspace is not open
        not-open,
        /// Project not found
        project-not-found(string),
        /// Project already exists
        project-already-exists(string),
        /// Invalid configuration
        invalid-config(string),
        /// IO error
        io-error(string),
    }

    /// Watch event type
    enum watch-event-type {
        /// File created
        created,
        /// File modified
        modified,
        /// File deleted
        deleted,
        /// File renamed
        renamed,
    }

    /// Watch event
    record watch-event {
        /// Event type
        event-type: watch-event-type,
        /// Affected path
        path: string,
        /// New path (for rename events)
        new-path: option<string>,
        /// Affected project (if determinable)
        project: option<package-path>,
    }

    // ============================================================
    // Workspace Lifecycle
    // ============================================================

    /// Create a new workspace
    create-workspace: func(
        /// Workspace root path
        root: string,
        /// Initial configuration
        config: option<document-value>,
    ) -> result<workspace-info, workspace-error>;

    /// Open an existing workspace
    open-workspace: func(
        /// Workspace root path
        root: string,
    ) -> result<workspace-info, workspace-error>;

    /// Close the current workspace
    close-workspace: func() -> result<_, workspace-error>;

    /// Get current workspace info
    get-workspace-info: func() -> result<workspace-info, workspace-error>;

    /// Update workspace configuration
    update-workspace-config: func(
        config: document-value,
    ) -> result<_, workspace-error>;

    // ============================================================
    // Project Management
    // ============================================================

    /// Add a project to the workspace
    add-project: func(
        /// Project name
        name: package-path,
        /// Project path (relative to workspace root)
        path: string,
        /// Initial version
        version: semver,
        /// Source directory
        source-dir: string,
    ) -> result<project-info, workspace-error>;

    /// Remove a project from the workspace
    remove-project: func(
        name: package-path,
    ) -> result<_, workspace-error>;

    /// Get project info
    get-project-info: func(
        name: package-path,
    ) -> result<project-info, workspace-error>;

    /// List all projects
    list-projects: func() -> result<list<project-info>, workspace-error>;

    /// Load a project (parse and compile)
    load-project: func(
        name: package-path,
    ) -> result<distribution, workspace-error>;

    /// Unload a project (free resources)
    unload-project: func(
        name: package-path,
    ) -> result<_, workspace-error>;

    /// Reload a project (recompile)
    reload-project: func(
        name: package-path,
    ) -> result<distribution, workspace-error>;

    // ============================================================
    // Dependency Management
    // ============================================================

    /// Add a dependency to a project
    add-dependency: func(
        project: package-path,
        dependency: package-path,
        version: semver,
    ) -> result<_, workspace-error>;

    /// Remove a dependency from a project
    remove-dependency: func(
        project: package-path,
        dependency: package-path,
    ) -> result<_, workspace-error>;

    /// Resolve all dependencies for a project
    resolve-dependencies: func(
        project: package-path,
    ) -> result<list<dependency-info>, workspace-error>;

    /// Resolve all dependencies for entire workspace
    resolve-all-dependencies: func() -> result<list<tuple<package-path, list<dependency-info>>>, workspace-error>;

    // ============================================================
    // File Watching
    // ============================================================

    /// Start watching workspace for changes
    start-watching: func() -> result<_, workspace-error>;

    /// Stop watching workspace
    stop-watching: func() -> result<_, workspace-error>;

    /// Poll for watch events (non-blocking)
    poll-events: func() -> list<watch-event>;

    // ============================================================
    // Workspace Operations
    // ============================================================

    /// Build all projects in workspace
    build-all: func() -> result<list<tuple<package-path, distribution>>, workspace-error>;

    /// Clean build artifacts
    clean: func(
        /// Specific project, or all if none
        project: option<package-path>,
    ) -> result<_, workspace-error>;

    /// Get workspace-wide diagnostics
    get-diagnostics: func() -> list<tuple<package-path, list<morphir:frontend@0.4.0.compiler.diagnostic>>>;
}

World Definitions (`worlds.wit`)

package morphir:component@0.4.0;

use morphir:extension@0.4.0.{info, capabilities};
use morphir:frontend@0.4.0.{compiler};
use morphir:frontend@0.4.0 as frontend;
use morphir:backend@0.4.0.{generator, validator, transform};
use morphir:backend@0.4.0 as backend;
use morphir:vfs@0.4.0.{reader, writer, workspace};

// ============================================================
// MINIMAL EXTENSION (Info Only)
// ============================================================

/// Minimal extension - just provides info and health check
/// All extensions should start here before adding capabilities
world info-component {
    export info;
}

/// Extension with capability discovery
world discoverable-component {
    export info;
    export capabilities;
}

// ============================================================
// FRONTEND COMPONENTS (Source → IR)
// ============================================================

/// Minimal frontend compiler component (basic compilation only)
world minimal-compiler-component {
    export info;
    export compiler;
}

/// Frontend compiler component with capability discovery
world compiler-component {
    export info;
    export capabilities;
    export compiler;
}

/// Frontend with VFS access (for reading dependencies)
world compiler-with-vfs-component {
    import reader;
    export info;
    export compiler;
}

/// Frontend with streaming support
world streaming-compiler-component {
    export info;
    export capabilities;
    export compiler;
    export frontend:streaming;
}

/// Frontend with incremental support
world incremental-compiler-component {
    import reader;
    export info;
    export capabilities;
    export compiler;
    export frontend:incremental;
}

/// Full-featured frontend (all capabilities)
world full-compiler-component {
    import reader;
    export info;
    export capabilities;
    export compiler;
    export frontend:streaming;
    export frontend:incremental;
}

// ============================================================
// BACKEND COMPONENTS (IR → Target)
// ============================================================

/// Minimal code generator component
world minimal-generator-component {
    export info;
    export generator;
}

/// Code generator component with capability discovery
world generator-component {
    export info;
    export capabilities;
    export generator;
}

/// Generator with streaming support
world streaming-generator-component {
    export info;
    export capabilities;
    export generator;
    export backend:streaming;
}

/// Generator with incremental support
world incremental-generator-component {
    export info;
    export capabilities;
    export generator;
    export backend:incremental;
}

/// Full-featured generator (all capabilities)
world full-generator-component {
    export info;
    export capabilities;
    export generator;
    export backend:streaming;
    export backend:incremental;
}

/// Validator component
world validator-component {
    export info;
    export validator;
}

/// Full backend (generator + validator)
world backend-component {
    export info;
    export capabilities;
    export generator;
    export validator;
}

// ============================================================
// TRANSFORMER COMPONENTS (IR → IR)
// ============================================================

/// Standalone transformer (pure IR transformation)
world transform-component {
    export info;
    export transform;
}

/// Transformer with VFS access
world transformer-component {
    import reader;
    import writer;
    export info;
    export capabilities;
    export transform;
}

// ============================================================
// WORKSPACE COMPONENTS
// ============================================================

/// Workspace management component (daemon-side)
world workspace-manager-component {
    export info;
    export workspace;
}

/// Workspace-aware compiler
world workspace-compiler-component {
    import workspace;
    import reader;
    export info;
    export capabilities;
    export compiler;
}

// ============================================================
// FULL PIPELINE COMPONENTS
// ============================================================

/// Full toolchain component (frontend + backend)
world toolchain-component {
    import reader;
    export info;
    export capabilities;
    export compiler;
    export generator;
    export validator;
}

/// Toolchain with workspace support
world workspace-toolchain-component {
    import workspace;
    import reader;
    import writer;
    export info;
    export capabilities;
    export compiler;
    export generator;
    export validator;
}

/// Full plugin with all capabilities
world plugin-component {
    import reader;
    import writer;
    import workspace;
    export info;
    export capabilities;
    export compiler;
    export generator;
    export validator;
    export transform;
    export frontend:streaming;
    export frontend:incremental;
    export backend:streaming;
    export backend:incremental;
}

Component Manifest

{
  "name": "morphir-typescript-backend",
  "version": "1.0.0",
  "description": "TypeScript code generator for Morphir IR",
  "world": "morphir:component/backend-component@0.4.0",
  "exports": {
    "generator": {
      "target": "typescript",
      "granularities": ["distribution", "module", "definition"]
    },
    "validator": {
      "categories": ["typescript-compat", "naming"]
    }
  },
  "wasm": {
    "path": "morphir-typescript-backend.wasm",
    "sha256": "abc123..."
  }
}

Security Model

World	Imports	Access Level
`info-component`	None	Metadata only (minimal)
`discoverable-component`	None	Metadata + capability query
`minimal-compiler-component`	None	Pure function (source → IR)
`compiler-component`	None	Pure function with capabilities
`compiler-with-vfs-component`	VFS reader	Read-only (for dependencies)
`streaming-compiler-component`	None	Streaming compilation
`incremental-compiler-component`	VFS reader	Incremental with dependency graph
`full-compiler-component`	VFS reader	All frontend capabilities
`minimal-generator-component`	None	Pure function (IR → target)
`generator-component`	None	Pure function with capabilities
`streaming-generator-component`	None	Streaming generation
`incremental-generator-component`	None	Incremental generation
`full-generator-component`	None	All codegen capabilities
`validator-component`	None	Pure function
`backend-component`	None	Generator + validator
`transform-component`	None	Pure IR transformation
`transformer-component`	VFS reader, writer	Scoped to distribution
`workspace-manager-component`	None (exports only)	Workspace lifecycle management
`workspace-compiler-component`	Workspace, VFS reader	Workspace-aware compilation
`toolchain-component`	VFS reader	Full compilation pipeline
`workspace-toolchain-component`	Workspace, VFS r/w	Full pipeline with workspace
`plugin-component`	Full VFS + workspace	Maximum access (all capabilities)

Components are sandboxed:

No filesystem access outside VFS
No network access
No environment variables
Memory and CPU limits enforced

Morphir Rust Design Documents

Morphir Extensions - Extension system overview
Tasks - Task system definition
Morphir Daemon - Workspace and build management

Main Morphir Documentation

Morphir Documentation - Main Morphir documentation site
Morphir LLMs.txt - Machine-readable documentation index
Morphir IR v4 Design - IR v4 design documents
Morphir IR Specification - Complete IR specification
WIT Type Mapping - WIT to Morphir IR mapping
WIT Commands - WIT command reference

WASM Component Model

Design Principles

Benefits

WIT Package Structure

Document Type (document.wit)

Naming Types (naming.wit)

Type Expressions (types.wit)

Literals (values.wit - Part 1)

Patterns (values.wit - Part 2)

Value Expressions (values.wit - Part 3)

Modules (modules.wit)

Packages (packages.wit)

Distributions (distributions.wit)

Extension Info Interface (info.wit)

Frontend Compiler Interface (compiler.wit)

Generator Interface (generator.wit)

Validator Interface (validator.wit)

Frontend Streaming Interface (frontend/streaming.wit)

Frontend Incremental Interface (frontend/incremental.wit)

Backend Streaming Interface (backend/streaming.wit)

Backend Incremental Interface (backend/incremental.wit)

Transform Interface (backend/transform.wit)

VFS Interfaces (reader.wit / writer.wit)

World Definitions (worlds.wit)