@valancex/mesh-compiler 0.4.0 → 0.5.0

package/README.md

@@ -2,7 +2,9 @@
 
 The [MESH](https://github.com/ValanceX/Mesh) compiler, built for WebAssembly. Check MPRX, with or without a component manifest, and get back exactly the diagnostics `mesh check --format json` prints for the same inputs.
 
-It's the Rust compiler itself, compiled to WebAssembly, not a reimplementation: this package adds no rule of its own. It returns diagnostics only.
+Or compile it, and also get the component's **template**, exactly what `mesh compile` writes: the checked MPRX with every name resolved and no values, which the MESH runtime renders.
+
+It's the Rust compiler itself, compiled to WebAssembly, not a reimplementation: this package adds no rule of its own.
 
 ```js
 import { check } from "@valancex/mesh-compiler";
@@ -28,6 +30,8 @@ The [Using MESH from JavaScript](https://github.com/ValanceX/Mesh/blob/main/docs
 ## The API
 
 - **`check(input)`** returns a promise of the diagnostics document, the one [`schemas/diagnostics-v1.schema.json`](https://github.com/ValanceX/Mesh/blob/main/schemas/diagnostics-v1.schema.json) describes. Anything wrong with your MPRX or your manifest is a diagnostic in it, never an exception. Diagnostics about the manifest carry the manifest's `path`. Each position has a `byte` offset, a 1-based `line` and `column`, and, for JavaScript, `utf16` (an offset into your string) and `utf16Column`.
+- **`compile(input)`** takes `check`'s input, with `model` required, and returns a promise of `{ diagnostics, template? }`. `diagnostics` is the document `check` returns for the same input. `template` is the `template-v1` document ([`schemas/template-v1.schema.json`](https://github.com/ValanceX/Mesh/blob/main/schemas/template-v1.schema.json)), present exactly when the diagnostics have no error; warnings don't stop it. A template is data to store and pass to the runtime, not to interpret. The `Template` type describes it.
+- **`checkProgram({ model, root, templates })`** checks a program of templates: the manifest's text, the root component, and the templates' texts in order. It returns a promise of the runtime diagnostics document ([`schemas/runtime-diagnostics-v1.schema.json`](https://github.com/ValanceX/Mesh/blob/main/schemas/runtime-diagnostics-v1.schema.json)), empty when the program is valid: exactly what `mesh check-program --format json` prints, and what the runtime's render reports for the same program. The `RuntimeDiagnosticsDocument` type describes it.
 - **`init(module)`** loads the WebAssembly module: a URL, its bytes, or a compiled `WebAssembly.Module`. In Node you don't need it; the package loads its own. In a browser, call it once before the first check, with the URL of `@valancex/mesh-compiler/mesh.wasm` as your setup serves it. Automatic loading by bundlers isn't part of this package's contract.
 - **`version`**: the package's version.
 - **`MeshVersionError`**: the WebAssembly module isn't this version's. No check runs against it.

package/dist/engine.d.ts

@@ -4,12 +4,15 @@
  * out of it, and discarding it after a failure.
  *
  * Deliberately boring (outline v0.4 I6): nothing here knows MPRX, the
- * manifest, positions or diagnostics. It transfers UTF-8 in and the
- * diagnostics document out, and checks only that what came out is a
- * document at all. Not public API (D11): the package's `exports` map
+ * manifest, positions, diagnostics or templates. It transfers UTF-8 in
+ * and the result out (a diagnostics document, or for a compile, that
+ * document and a template), and checks only that what came out has that
+ * shape at all. Not public API (D11): the package's `exports` map
  * doesn't expose this file.
  */
 import type { DiagnosticsDocument } from "./document.js";
+import type { RuntimeDiagnosticsDocument } from "./runtime-document.js";
+import type { Template } from "./template.js";
 /**
  * A failure at the boundary with the compiler: a trap (a Rust panic, or
  * running out of memory), or a result that isn't a diagnostics document.
@@ -45,6 +48,40 @@ export interface CheckInput {
         component: string;
     };
 }
+/** One compile's inputs: a check's, with the model required. */
+export interface CompileInput {
+    /** The MPRX source text. */
+    source: string;
+    /** An opaque identifier for the source, used only to name it in diagnostics. Never read. */
+    path: string;
+    /** The model to check against: a template is always a component's. */
+    model: {
+        /** The manifest's text. */
+        manifest: string;
+        /** An opaque identifier for the manifest, used only to name it in diagnostics. Never read. */
+        path: string;
+        /** The component whose template the source is. Always explicit. */
+        component: string;
+    };
+}
+/**
+ * What a compile gives: the diagnostics document `check` would return for
+ * the same inputs, and, only when it has no error, the template.
+ */
+export interface CompileResult {
+    diagnostics: DiagnosticsDocument;
+    /** The `template-v1` document. Absent when the diagnostics have an error. */
+    template?: Template;
+}
+/** One program check's inputs. */
+export interface ProgramInput {
+    /** The manifest's text: the model the templates were compiled against. */
+    model: string;
+    /** The root component: the one the program renders. */
+    root: string;
+    /** The program's templates (`template-v1` documents, as text), in order. */
+    templates: readonly string[];
+}
 /**
  * Loads the module from `source` and checks its version. In Node, the
  * package loads its own module on the first check, so this is only
@@ -54,6 +91,10 @@ export interface CheckInput {
 export declare function init(source: ModuleSource): Promise<void>;
 /** Checks `input`. See the package's `check`. */
 export declare function check(input: CheckInput): Promise<DiagnosticsDocument>;
+/** Compiles `input`. See the package's `compile`. */
+export declare function compile(input: CompileInput): Promise<CompileResult>;
+/** Checks a program. See the package's `checkProgram`. */
+export declare function checkProgram(input: ProgramInput): Promise<RuntimeDiagnosticsDocument>;
 /**
  * The instance in use, if any, for the package's own memory and failure
  * tests. Not API.

package/dist/engine.js

@@ -4,9 +4,10 @@
  * out of it, and discarding it after a failure.
  *
  * Deliberately boring (outline v0.4 I6): nothing here knows MPRX, the
- * manifest, positions or diagnostics. It transfers UTF-8 in and the
- * diagnostics document out, and checks only that what came out is a
- * document at all. Not public API (D11): the package's `exports` map
+ * manifest, positions, diagnostics or templates. It transfers UTF-8 in
+ * and the result out (a diagnostics document, or for a compile, that
+ * document and a template), and checks only that what came out has that
+ * shape at all. Not public API (D11): the package's `exports` map
  * doesn't expose this file.
  */
 import { version } from "./version.js";
@@ -31,6 +32,8 @@ const CHECK_EXPORTS = [
     "mesh_alloc",
     "mesh_free",
     "mesh_check",
+    "mesh_compile",
+    "mesh_check_program",
     "mesh_result_ptr",
     "mesh_result_len",
     "mesh_result_clear",
@@ -57,7 +60,7 @@ async function bytesOf(location) {
     }
     return response.arrayBuffer();
 }
-async function compile(source) {
+async function compileModule(source) {
     if (source instanceof WebAssembly.Module) {
         return source;
     }
@@ -113,7 +116,7 @@ export function init(source) {
     const run = queue.then(async () => {
         compiled = undefined;
         instance = undefined;
-        const module = await compile(source);
+        const module = await compileModule(source);
         instance = await instantiate(module);
         compiled = module;
     });
@@ -128,7 +131,7 @@ async function current() {
         if (!isNode()) {
             throw new Error("@valancex/mesh-compiler: call init() with the URL of mesh.wasm before the first check");
         }
-        const module = await compile(new URL("./mesh.wasm", import.meta.url));
+        const module = await compileModule(new URL("./mesh.wasm", import.meta.url));
         instance = await instantiate(module);
         compiled = module;
         return instance;
@@ -149,18 +152,21 @@ function isDocument(value) {
         "version" in value &&
         Array.isArray(value.diagnostics));
 }
-/** One check on `exports`. Any exception means the instance failed. */
-function transfer(exports, input) {
-    const model = input.model;
-    const texts = [
-        input.source,
-        input.path,
-        model?.manifest ?? "",
-        model?.path ?? "",
-        model?.component ?? "",
-    ].map((text) => encoder.encode(text));
-    const buffers = texts.map((bytes) => ({ ptr: put(exports, bytes), len: bytes.length }));
-    const status = exports.mesh_check(...buffers.flatMap(({ ptr, len }) => [ptr, len]), model ? 1 : 0);
+function isCompileResult(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const { diagnostics, template } = value;
+    return isDocument(diagnostics) && (template === null || (typeof template === "object" && template !== undefined));
+}
+/**
+ * One call on `exports`: copies `inputs` into the module, calls `call`
+ * with each one's address and length, frees them, and returns the
+ * result, parsed. Any exception means the instance failed.
+ */
+function transfer(exports, inputs, call) {
+    const buffers = inputs.map((bytes) => ({ ptr: put(exports, bytes), len: bytes.length }));
+    const status = call(buffers.flatMap(({ ptr, len }) => [ptr, len]));
     for (const { ptr, len } of buffers) {
         exports.mesh_free(ptr, len);
     }
@@ -169,20 +175,70 @@ function transfer(exports, input) {
     }
     const bytes = new Uint8Array(exports.memory.buffer, exports.mesh_result_ptr(), exports.mesh_result_len()).slice();
     exports.mesh_result_clear();
-    const document = JSON.parse(decoder.decode(bytes));
-    if (!isDocument(document)) {
+    return JSON.parse(decoder.decode(bytes));
+}
+/** A check's or compile's five texts, as the module takes them. */
+function checkInputs(input) {
+    const model = input.model;
+    return [
+        input.source,
+        input.path,
+        model?.manifest ?? "",
+        model?.path ?? "",
+        model?.component ?? "",
+    ].map((text) => encoder.encode(text));
+}
+/**
+ * A text list, as the module reads one: a u32 count, then each text as a
+ * u32 byte length and its UTF-8 bytes, little-endian.
+ */
+function textList(texts) {
+    const encoded = texts.map((text) => encoder.encode(text));
+    const size = 4 + encoded.reduce((sum, bytes) => sum + 4 + bytes.length, 0);
+    const list = new Uint8Array(size);
+    const view = new DataView(list.buffer);
+    view.setUint32(0, encoded.length, true);
+    let at = 4;
+    for (const bytes of encoded) {
+        view.setUint32(at, bytes.length, true);
+        list.set(bytes, at + 4);
+        at += 4 + bytes.length;
+    }
+    return list;
+}
+function checkResult(value) {
+    if (!isDocument(value)) {
         throw new MeshInternalError("the compiler's result isn't a diagnostics document");
     }
-    return document;
+    return value;
+}
+function programResult(value) {
+    if (!isDocument(value)) {
+        throw new MeshInternalError("the compiler's result isn't a runtime diagnostics document");
+    }
+    return value;
 }
-function validate(input) {
+function compileResult(value) {
+    if (!isCompileResult(value)) {
+        throw new MeshInternalError("the compiler's result isn't a compile result");
+    }
+    const diagnostics = value.diagnostics;
+    return value.template === null
+        ? { diagnostics }
+        : { diagnostics, template: value.template };
+}
+function validate(input, compiling) {
+    const what = compiling ? "compile() takes an object: { source, path, model }" : "check() takes an object: { source, path, model? }";
     if (typeof input !== "object" || input === null) {
-        throw new TypeError("check() takes an object: { source, path, model? }");
+        throw new TypeError(what);
     }
     const strings = [
         ["source", input.source],
         ["path", input.path],
     ];
+    if (compiling && input.model === undefined) {
+        throw new TypeError("compile() needs a model: { manifest, path, component }");
+    }
     if (input.model !== undefined) {
         const model = input.model;
         if (typeof model !== "object" || model === null) {
@@ -196,11 +252,25 @@ function validate(input) {
         }
     }
 }
-async function checkNow(input) {
-    validate(input);
+function validateProgram(input) {
+    if (typeof input !== "object" || input === null) {
+        throw new TypeError("checkProgram() takes an object: { model, root, templates }");
+    }
+    if (typeof input.model !== "string") {
+        throw new TypeError("model must be a string");
+    }
+    if (typeof input.root !== "string") {
+        throw new TypeError("root must be a string");
+    }
+    if (!Array.isArray(input.templates) || !input.templates.every((t) => typeof t === "string")) {
+        throw new TypeError("templates must be an array of strings");
+    }
+}
+/** One call, on the current instance, discarding it if it fails. */
+async function runNow(inputs, call, shape) {
     const exports = await current();
     try {
-        return transfer(exports, input);
+        return shape(transfer(exports, inputs, (pointers) => call(exports, pointers)));
     }
     catch (cause) {
         // The instance may be half-updated: never call it again (outline D6).
@@ -213,12 +283,32 @@ async function checkNow(input) {
         throw new MeshInternalError("the compiler failed", { cause });
     }
 }
-/** Checks `input`. See the package's `check`. */
-export function check(input) {
-    const run = queue.then(() => checkNow(input));
+function enqueue(work) {
+    const run = queue.then(work);
     queue = run.catch(() => undefined);
     return run;
 }
+/** Checks `input`. See the package's `check`. */
+export function check(input) {
+    return enqueue(async () => {
+        validate(input, false);
+        return runNow(checkInputs(input), (exports, pointers) => exports.mesh_check(...pointers, input.model ? 1 : 0), checkResult);
+    });
+}
+/** Compiles `input`. See the package's `compile`. */
+export function compile(input) {
+    return enqueue(async () => {
+        validate(input, true);
+        return runNow(checkInputs(input), (exports, pointers) => exports.mesh_compile(...pointers), compileResult);
+    });
+}
+/** Checks a program. See the package's `checkProgram`. */
+export function checkProgram(input) {
+    return enqueue(async () => {
+        validateProgram(input);
+        return runNow([encoder.encode(input.model), encoder.encode(input.root), textList(input.templates)], (exports, pointers) => exports.mesh_check_program(...pointers), programResult);
+    });
+}
 /**
  * The instance in use, if any, for the package's own memory and failure
  * tests. Not API.

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 /**
  * The MESH compiler, in WebAssembly: check MPRX against a component
  * manifest, and get back exactly the diagnostics `mesh check --format
- * json` prints for the same inputs.
+ * json` prints for the same inputs; compile it, and get the template
+ * `mesh compile` writes too; or check a program of templates, as
+ * `mesh check-program` does.
  *
  * ```js
  * import { check } from "@valancex/mesh-compiler";
@@ -19,10 +21,13 @@
  *
  * @packageDocumentation
  */
-import type { CheckInput, ModuleSource } from "./engine.js";
+import type { CheckInput, CompileInput, CompileResult, ModuleSource, ProgramInput } from "./engine.js";
 import type { DiagnosticsDocument } from "./document.js";
+import type { RuntimeDiagnosticsDocument } from "./runtime-document.js";
 export type { Diagnostic, DiagnosticsDocument, Position, Severity, Span, Suggestion, } from "./document.js";
-export type { CheckInput, ModuleSource } from "./engine.js";
+export type { CheckInput, CompileInput, CompileResult, ModuleSource, ProgramInput } from "./engine.js";
+export type { ModelPosition, ModelSpan, RuntimeDiagnostic, RuntimeDiagnosticsDocument, RuntimeLocation, SourceOffset, SourceSpan, } from "./runtime-document.js";
+export type { Offset, Template, TemplateChild, TemplateElement, TemplateExpression, TemplateSpan, } from "./template.js";
 export { MeshInternalError, MeshVersionError } from "./engine.js";
 export { version } from "./version.js";
 /**
@@ -36,6 +41,28 @@ export { version } from "./version.js";
  * call {@link init} first.
  */
 export declare function check(input: CheckInput): Promise<DiagnosticsDocument>;
+/**
+ * Checks `input.source` as the template of `input.model.component`, as
+ * {@link check} does, and, only when that finds no error, compiles it to
+ * a template (`template-v1`): exactly what `mesh compile` reports and
+ * writes for the same inputs. Warnings don't stop it. A model is
+ * required, since a template is always a component's.
+ *
+ * `diagnostics` is the document `check` returns; `template` is absent
+ * when it has an error. It rejects as `check` does.
+ */
+export declare function compile(input: CompileInput): Promise<CompileResult>;
+/**
+ * Checks a program: the manifest `input.model`, then each of
+ * `input.templates` (well-formed, of a format version this MESH reads,
+ * and compiled against this model), then the assembly rules, with
+ * `input.root` as the root component. Returns the runtime diagnostics
+ * document, which is empty when the program is valid: exactly what
+ * `mesh check-program --format json` prints, and what the runtime's
+ * render reports for the same program before it looks at a snapshot.
+ * It produces nothing else. It rejects as `check` does.
+ */
+export declare function checkProgram(input: ProgramInput): Promise<RuntimeDiagnosticsDocument>;
 /**
  * Loads the WebAssembly module from `source`: a URL (or a string resolved
  * against the page), its bytes, or a compiled `WebAssembly.Module`, and

package/dist/index.js

@@ -1,7 +1,9 @@
 /**
  * The MESH compiler, in WebAssembly: check MPRX against a component
  * manifest, and get back exactly the diagnostics `mesh check --format
- * json` prints for the same inputs.
+ * json` prints for the same inputs; compile it, and get the template
+ * `mesh compile` writes too; or check a program of templates, as
+ * `mesh check-program` does.
  *
  * ```js
  * import { check } from "@valancex/mesh-compiler";
@@ -19,7 +21,7 @@
  *
  * @packageDocumentation
  */
-import { check as checkWith, init as initWith } from "./engine.js";
+import { check as checkWith, checkProgram as checkProgramWith, compile as compileWith, init as initWith, } from "./engine.js";
 export { MeshInternalError, MeshVersionError } from "./engine.js";
 export { version } from "./version.js";
 /**
@@ -35,6 +37,32 @@ export { version } from "./version.js";
 export function check(input) {
     return checkWith(input);
 }
+/**
+ * Checks `input.source` as the template of `input.model.component`, as
+ * {@link check} does, and, only when that finds no error, compiles it to
+ * a template (`template-v1`): exactly what `mesh compile` reports and
+ * writes for the same inputs. Warnings don't stop it. A model is
+ * required, since a template is always a component's.
+ *
+ * `diagnostics` is the document `check` returns; `template` is absent
+ * when it has an error. It rejects as `check` does.
+ */
+export function compile(input) {
+    return compileWith(input);
+}
+/**
+ * Checks a program: the manifest `input.model`, then each of
+ * `input.templates` (well-formed, of a format version this MESH reads,
+ * and compiled against this model), then the assembly rules, with
+ * `input.root` as the root component. Returns the runtime diagnostics
+ * document, which is empty when the program is valid: exactly what
+ * `mesh check-program --format json` prints, and what the runtime's
+ * render reports for the same program before it looks at a snapshot.
+ * It produces nothing else. It rejects as `check` does.
+ */
+export function checkProgram(input) {
+    return checkProgramWith(input);
+}
 /**
  * Loads the WebAssembly module from `source`: a URL (or a string resolved
  * against the page), its bytes, or a compiled `WebAssembly.Module`, and

package/dist/runtime-document.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The runtime diagnostics document, as
+ * `schemas/runtime-diagnostics-v1.schema.json` describes it: what
+ * `mesh check-program --format json` prints, what {@link checkProgram}
+ * returns, and what the runtime's render and dispatch report. A later
+ * version may add properties; ignore any you don't know.
+ */
+export interface RuntimeDiagnosticsDocument {
+    /** The version of the document's shape. */
+    version: 1;
+    /** Every diagnostic, in the order MESH reports them. */
+    diagnostics: RuntimeDiagnostic[];
+}
+export interface RuntimeDiagnostic {
+    /** Always `error`: the runtime has no warnings. */
+    severity: "error";
+    /** The stable code, such as `"assembly-cycle"`. Match on this, not on `message`. */
+    code: string;
+    /** The human-readable message. It may change between versions. */
+    message: string;
+    location: RuntimeLocation;
+}
+/** Where a runtime diagnostic is: one of six forms, by `kind`. */
+export type RuntimeLocation = 
+/** In the model: a span in the manifest's text. */
+{
+    kind: "model";
+    span: ModelSpan;
+}
+/** The program as a whole. */
+ | {
+    kind: "program";
+}
+/** A template, by its 0-based position in the list given, with its component when it can be read. */
+ | {
+    kind: "template";
+    index: number;
+    component?: string;
+}
+/** A place in a template: its component, and a span in the source it was compiled from. */
+ | {
+    kind: "source";
+    component: string;
+    span: SourceSpan;
+}
+/** A value the host gave: a path from a scope name, or from `$event`. */
+ | {
+    kind: "input";
+    path: (string | number)[];
+}
+/** The handler identifier dispatch was given. */
+ | {
+    kind: "handler";
+};
+export interface ModelSpan {
+    start: ModelPosition;
+    end: ModelPosition;
+}
+/** A position in the manifest, as the diagnostics document gives one. */
+export interface ModelPosition {
+    /** 0-based byte offset into the UTF-8 text. */
+    byte: number;
+    /** 1-based line. */
+    line: number;
+    /** 1-based column, in characters. */
+    column: number;
+    /** 0-based offset in UTF-16 code units. */
+    utf16: number;
+    /** 1-based column, in UTF-16 code units. */
+    utf16Column: number;
+}
+export interface SourceSpan {
+    start: SourceOffset;
+    end: SourceOffset;
+}
+/** An offset into MPRX source, as a template records it. */
+export interface SourceOffset {
+    byte: number;
+    utf16: number;
+}

package/dist/runtime-document.js

@@ -0,0 +1 @@
+export {};

package/dist/template.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The types of a `template-v1` document: one component's MPRX, checked
+ * clean and compiled (see the MESH repository's
+ * `docs/manual/templates.md` and `schemas/template-v1.schema.json`).
+ *
+ * A template is data to store and hand to the MESH runtime, not to
+ * interpret: nothing in this package reads one. The format may gain
+ * properties without changing `version`; readers ignore ones they don't
+ * know.
+ */
+/** A place in the source: UTF-8 bytes, and UTF-16 code units, from its start. */
+export interface Offset {
+    byte: number;
+    utf16: number;
+}
+/** Where a construct was in the source. Nothing depends on it for meaning. */
+export interface TemplateSpan {
+    start: Offset;
+    end: Offset;
+}
+export interface Template {
+    format: "mesh-template";
+    version: 1;
+    /** The component whose template this is. */
+    component: string;
+    /** `sha256:` and 64 hexadecimal digits: the model it was checked against. */
+    fingerprint: string;
+    /** The compiler version that produced it: provenance only. */
+    compiler: string;
+    root: TemplateElement;
+}
+export interface TemplateElement {
+    component: string;
+    props: {
+        prop: string;
+        value: TemplateExpression;
+        span: TemplateSpan;
+    }[];
+    events: {
+        event: string;
+        command: string;
+        arguments: TemplateExpression[];
+        span: TemplateSpan;
+    }[];
+    children: TemplateChild[];
+    span: TemplateSpan;
+}
+export type TemplateChild = {
+    kind: "text";
+    value: string;
+    span: TemplateSpan;
+} | {
+    kind: "expression";
+    expression: TemplateExpression;
+} | {
+    kind: "element";
+    element: TemplateElement;
+};
+export type TemplateExpression = {
+    kind: "literal";
+    value: string | number | boolean | null;
+    span: TemplateSpan;
+} | {
+    kind: "scope";
+    name: string;
+    span: TemplateSpan;
+} | {
+    kind: "member";
+    object: TemplateExpression;
+    field: string;
+    span: TemplateSpan;
+} | {
+    kind: "unary";
+    operator: "not" | "negate";
+    operand: TemplateExpression;
+    span: TemplateSpan;
+} | {
+    kind: "binary";
+    operator: "add" | "subtract" | "multiply" | "divide" | "remainder" | "equal" | "not-equal" | "less" | "less-equal" | "greater" | "greater-equal" | "and" | "or";
+    left: TemplateExpression;
+    right: TemplateExpression;
+    span: TemplateSpan;
+} | {
+    kind: "conditional";
+    condition: TemplateExpression;
+    consequent: TemplateExpression;
+    alternate: TemplateExpression;
+    span: TemplateSpan;
+} | {
+    kind: "list";
+    elements: TemplateExpression[];
+    span: TemplateSpan;
+} | {
+    kind: "record";
+    fields: {
+        name: string;
+        value: TemplateExpression;
+        span: TemplateSpan;
+    }[];
+    span: TemplateSpan;
+} | {
+    kind: "event";
+    span: TemplateSpan;
+};

package/dist/template.js

@@ -0,0 +1,11 @@
+/**
+ * The types of a `template-v1` document: one component's MPRX, checked
+ * clean and compiled (see the MESH repository's
+ * `docs/manual/templates.md` and `schemas/template-v1.schema.json`).
+ *
+ * A template is data to store and hand to the MESH runtime, not to
+ * interpret: nothing in this package reads one. The format may gain
+ * properties without changing `version`; readers ignore ones they don't
+ * know.
+ */
+export {};

package/dist/version.d.ts

@@ -3,4 +3,4 @@
  * (outline v0.4 I10). `crates/mesh-cli/tests/packages.rs` pins it to
  * `package.json` and to the Rust workspace.
  */
-export declare const version = "0.4.0";
+export declare const version = "0.5.0";

package/dist/version.js

@@ -3,4 +3,4 @@
  * (outline v0.4 I10). `crates/mesh-cli/tests/packages.rs` pins it to
  * `package.json` and to the Rust workspace.
  */
-export const version = "0.4.0";
+export const version = "0.5.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valancex/mesh-compiler",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "The MESH compiler, built for WebAssembly: checks MPRX against a component manifest and returns its diagnostics.",
   "type": "module",
   "license": "MIT",