@vincentt-xr/editor-engine 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2026 Vincentt. All rights reserved.
+
+This software and its accompanying files (the "Software") are proprietary to
+Vincentt and are licensed, not sold.
+
+You may install and run the Software only to build, preview, and publish
+projects with Vincentt services, under the terms of service that govern your
+use of those services.
+
+You may not, except where applicable law expressly permits it despite this
+restriction:
+
+  1. copy, redistribute, sublicense, sell, or otherwise make the Software
+     available to any third party;
+  2. modify, adapt, translate, or create derivative works of the Software;
+  3. reverse engineer, decompile, or disassemble the Software, or attempt to
+     recover its source code;
+  4. use the Software with any service other than Vincentt services.
+
+Projects you create with the Software belong to you. This license grants no
+rights in the Software itself beyond those stated above.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+VINCENTT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Contact: hello@vincentt.studio

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# @vincentt-xr/editor-engine
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Vincentt editor's write-back engine compiled to WebAssembly, with typed ES module access. It is
+consumed by the Vincentt console at an exact version; it is not meant to be imported by apps.
+
+| File | What it is |
+|---|---|
+| `dist/index.js` | The binding: `initEngine`, `initEngineSync`, `EditorEngine`, `rebindValueKey`, `isWritableFile`, `EngineInputError`, `EngineCrashedError`. |
+| `dist/index.d.ts`, `dist/types.d.ts` | Its types and the engine's JSON shapes. |
+| `pkg/editor_engine_wasm.js` | The wasm-bindgen glue (`--target web`). |
+| `pkg/editor_engine_wasm_bg.wasm` | The engine. Also exported as `@vincentt-xr/editor-engine/editor_engine_wasm_bg.wasm`. |
+
+In a browser, `await initEngine()` fetches the `.wasm` beside the glue (a page CSP needs
+`'wasm-unsafe-eval'`); pass a URL or bytes to load it from elsewhere. In Node or a worker,
+`initEngineSync(bytes)`. Malformed input throws `EngineInputError` and leaves the instance usable;
+any other failure throws `EngineCrashedError` on that call and every later one, and the instance
+must be reloaded.
+
+The package has no install scripts and no runtime dependencies. It is published from
+`vincentt-xr/editor` by `.github/workflows/engine-publish.yml` through npm trusted publishing.

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import * as wasm from "../pkg/editor_engine_wasm.js";
+import type { EditResult, FileUpdate, SettingDecl, SettingsStatus, TweakableMap, Unanalysed, WriteRequest } from "./types.js";
+export type * from "./types.js";
+/**
+ * The instance stopped in the middle of a call (call stack exhausted, or a trap). Its memory may
+ * be inconsistent, so every later call refuses; load a fresh instance (a page reload).
+ */
+export declare class EngineCrashedError extends Error {
+    constructor(cause: unknown);
+}
+/** The caller's input was malformed; the instance is unaffected. */
+export declare class EngineInputError extends Error {
+    constructor(message: string);
+}
+/** Loads the module. In a browser with no argument it fetches the `.wasm` beside this file. */
+export declare function initEngine(input?: wasm.InitInput | Promise<wasm.InitInput>): Promise<void>;
+/** Loads the module from bytes or a compiled module (Node, tests, workers). */
+export declare function initEngineSync(module: BufferSource | WebAssembly.Module): void;
+export declare class EditorEngine {
+    private readonly p;
+    private constructor();
+    /**
+     * `files`: root-relative posix paths to their contents. Files outside the writable set, over
+     * 2 MiB, or past 5000 files are ignored. `settings`: the SDK's `settings.json` text, if any.
+     */
+    static open(files: Record<string, string>, settings?: string | null): EditorEngine;
+    map(): TweakableMap;
+    unanalysed(): Unanalysed[];
+    settingsStatus(): SettingsStatus;
+    /** A source stamp (1-based line, UTF-16 column) to the object key it belongs to. */
+    anchor(file: string, line: number, column: number): string | null;
+    /** Call when the frame loads a new generation of the code. */
+    resetRemaps(): void;
+    decl(id: string): SettingDecl | null;
+    computedExpression(valueKey: string): string | null;
+    /** The edit a write would make; the project is unchanged. */
+    plan(req: WriteRequest): EditResult;
+    /** As `plan`, and the edited text becomes the file's current content. */
+    apply(req: WriteRequest): EditResult;
+    /** Replaces one file with what the source holds now (`null`: the file is gone). */
+    setFile(file: string, text: string | null): FileUpdate;
+    free(): void;
+}
+/** A `"<object key>:<path>"` held across `setFile`; null when its object no longer resolves. */
+export declare function rebindValueKey(valueKey: string, update: FileUpdate): string | null;
+/** The writable-file allowlist (security F5) the engine applies. */
+export declare function isWritableFile(rel: string): boolean;

package/dist/index.js

@@ -0,0 +1,116 @@
+// Typed access to the write-back engine compiled to WebAssembly. Marshalling only: every decision
+// is made by the Rust engine (editor-app/engine), the same code the desktop app links.
+import init, * as wasm from "../pkg/editor_engine_wasm.js";
+/**
+ * The instance stopped in the middle of a call (call stack exhausted, or a trap). Its memory may
+ * be inconsistent, so every later call refuses; load a fresh instance (a page reload).
+ */
+export class EngineCrashedError extends Error {
+    constructor(cause) {
+        super("editor engine instance crashed; reload it", { cause });
+        this.name = "EngineCrashedError";
+    }
+}
+/** The caller's input was malformed; the instance is unaffected. */
+export class EngineInputError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EngineInputError";
+    }
+}
+/** Must equal `INPUT_ERROR_PREFIX` in editor-app/engine-wasm/src/lib.rs. */
+const INPUT_ERROR_PREFIX = "editor-engine input: ";
+let crashed;
+/**
+ * Runs one call into the module. Only the binding's own input errors pass through; any other
+ * exception (stack exhaustion is `RangeError` in V8 and JavaScriptCore but `InternalError` in
+ * Firefox; a trap is `WebAssembly.RuntimeError`) leaves the instance unusable.
+ */
+function guard(call) {
+    if (crashed !== undefined)
+        throw new EngineCrashedError(crashed);
+    try {
+        return call();
+    }
+    catch (e) {
+        if (e instanceof Error && e.constructor === Error && e.message.startsWith(INPUT_ERROR_PREFIX)) {
+            throw new EngineInputError(e.message.slice(INPUT_ERROR_PREFIX.length));
+        }
+        crashed = e ?? new Error("unknown");
+        throw new EngineCrashedError(e);
+    }
+}
+/** Loads the module. In a browser with no argument it fetches the `.wasm` beside this file. */
+export async function initEngine(input) {
+    await init(input === undefined ? undefined : { module_or_path: input });
+}
+/** Loads the module from bytes or a compiled module (Node, tests, workers). */
+export function initEngineSync(module) {
+    wasm.initSync({ module });
+}
+export class EditorEngine {
+    p;
+    constructor(p) {
+        this.p = p;
+    }
+    /**
+     * `files`: root-relative posix paths to their contents. Files outside the writable set, over
+     * 2 MiB, or past 5000 files are ignored. `settings`: the SDK's `settings.json` text, if any.
+     */
+    static open(files, settings) {
+        const json = JSON.stringify(files);
+        return guard(() => new EditorEngine(new wasm.Project(json, settings ?? undefined)));
+    }
+    map() {
+        return guard(() => JSON.parse(this.p.map()));
+    }
+    unanalysed() {
+        return guard(() => JSON.parse(this.p.unanalysed()));
+    }
+    settingsStatus() {
+        return guard(() => JSON.parse(this.p.settingsStatus()));
+    }
+    /** A source stamp (1-based line, UTF-16 column) to the object key it belongs to. */
+    anchor(file, line, column) {
+        return guard(() => this.p.anchor(file, line, column) ?? null);
+    }
+    /** Call when the frame loads a new generation of the code. */
+    resetRemaps() {
+        guard(() => this.p.resetRemaps());
+    }
+    decl(id) {
+        return guard(() => {
+            const d = this.p.decl(id);
+            return d === undefined ? null : JSON.parse(d);
+        });
+    }
+    computedExpression(valueKey) {
+        return guard(() => this.p.computedExpression(valueKey) ?? null);
+    }
+    /** The edit a write would make; the project is unchanged. */
+    plan(req) {
+        const json = JSON.stringify(req);
+        return guard(() => JSON.parse(this.p.plan(json)));
+    }
+    /** As `plan`, and the edited text becomes the file's current content. */
+    apply(req) {
+        const json = JSON.stringify(req);
+        return guard(() => JSON.parse(this.p.apply(json)));
+    }
+    /** Replaces one file with what the source holds now (`null`: the file is gone). */
+    setFile(file, text) {
+        return guard(() => JSON.parse(this.p.setFile(file, text ?? undefined)));
+    }
+    free() {
+        guard(() => this.p.free());
+    }
+}
+/** A `"<object key>:<path>"` held across `setFile`; null when its object no longer resolves. */
+export function rebindValueKey(valueKey, update) {
+    const json = JSON.stringify(update);
+    return guard(() => wasm.rebindValueKey(valueKey, json) ?? null);
+}
+/** The writable-file allowlist (security F5) the engine applies. */
+export function isWritableFile(rel) {
+    return guard(() => wasm.isWritableFile(rel));
+}

package/dist/types.d.ts

@@ -0,0 +1,123 @@
+export type Json = null | boolean | number | string | Json[] | {
+    [k: string]: Json;
+};
+export type SettingType = "number" | "color" | "boolean" | "vec2" | "vec3" | "euler" | "enum";
+export type Unit = "px" | "m" | "deg" | "rad" | "ratio";
+export type ObjectKind = "host" | "sdk" | "component";
+export type ReadonlyReason = "computed" | "imported" | "spread" | "conditional" | "outside_project" | "generated" | "unsupported";
+export type RefusalReason = "invalid_value" | "outside_project" | "unresolvable" | "ambiguous" | "conflict" | "moved_on" | "verify_failed" | "write_failed" | "no_gesture";
+/** Byte offsets into the UTF-8 text; 1-based line and UTF-16 column. */
+export interface SourceRef {
+    file: string;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+}
+export interface Constraints {
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: Unit;
+}
+export interface TweakValue {
+    /** `"position"`, `"position.1"`, `"screenTransform.position.x"` */
+    path: string;
+    type: SettingType;
+    value: Json;
+    editable: true | {
+        readonly: ReadonlyReason;
+    };
+    constraints?: Constraints;
+    /** `"@vincentt-xr/sdk:ScreenText.fontSize"` */
+    decl?: string;
+    source?: SourceRef;
+    sharedBy?: number;
+}
+export interface TweakObject {
+    key: string;
+    /** From the static parse: control, bidi and ANSI characters stripped, at most 80 characters. */
+    label: string;
+    kind: ObjectKind;
+    type: string;
+    source: SourceRef;
+    parent?: string;
+    values: TweakValue[];
+}
+export interface TweakableMap {
+    schema: "vincentt.tweakables/1";
+    objects: TweakObject[];
+}
+export interface SettingDecl {
+    type: SettingType;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: Unit;
+    enum?: string[];
+    default?: Json;
+    label?: string;
+}
+export type SettingsStatus = {
+    status: "loaded";
+    version: string;
+} | {
+    status: "missing";
+} | {
+    status: "unknownSchema";
+    detail: string;
+} | {
+    status: "invalid";
+    detail: string;
+};
+export interface Unanalysed {
+    file: string;
+    /** `too_deep_for_browser`: wasm only; the file would need more call stack than a browser gives. */
+    reason: "syntax_error" | "too_deeply_nested" | "too_deep_for_browser" | "map_budget" | "project_map_budget" | "analysis_failed";
+}
+export type Precision = "typed" | {
+    step: number;
+};
+export interface WriteRequest {
+    /** `"<object key>:<path>"`, from the map. */
+    valueKey: string;
+    value: Json;
+    precision: Precision;
+    /**
+     * Required (D-S1): the value (or literal text) the edit started from, never null. A source that
+     * no longer holds it is `conflict`.
+     */
+    started: Exclude<Json, null>;
+    /**
+     * A literal reached through a const that other code also reads is not written there: this use
+     * takes its own copy of the const, in place, with the new value. A const that is not plain
+     * literals is refused; one read only by this use is edited where it is.
+     */
+    inline?: boolean;
+}
+export interface Edit {
+    result: "edit";
+    valueKey: string;
+    file: string;
+    /** The literal's text before and after. Equal when the value is already written. */
+    before: string;
+    after: string;
+    beforeValue: Json;
+    afterValue: Json;
+    /** Where the literal sat before the edit. */
+    range: SourceRef;
+    /** The whole file after the edit. */
+    text: string;
+}
+export interface Refused {
+    result: "refused";
+    valueKey: string;
+    reason: RefusalReason;
+}
+export type EditResult = Edit | Refused;
+export interface FileUpdate {
+    /** [old, new] object keys that re-bound to a different key. */
+    rebinds: [string, string][];
+    /** Object keys of the file's old parse that no longer resolve. */
+    removed: string[];
+}

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@vincentt-xr/editor-engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "The Vincentt editor's write-back engine compiled to WebAssembly, for the Vincentt console",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vincentt-xr/editor.git",
+    "directory": "editor-engine"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/types.d.ts",
+    "pkg/editor_engine_wasm.js",
+    "pkg/editor_engine_wasm.d.ts",
+    "pkg/editor_engine_wasm_bg.wasm",
+    "pkg/editor_engine_wasm_bg.wasm.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./editor_engine_wasm_bg.wasm": "./pkg/editor_engine_wasm_bg.wasm",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "node build.mjs && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/pkg/editor_engine_wasm.d.ts

@@ -0,0 +1,77 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class Project {
+    free(): void;
+    [Symbol.dispose](): void;
+    anchor(file: string, line: number, column: number): string | undefined;
+    apply(request_json: string): string;
+    computedExpression(value_key: string): string | undefined;
+    decl(id: string): string | undefined;
+    map(): string;
+    /**
+     * `files_json`: `{"<root-relative path>": "<content>", ...}`. `settings`: the SDK's
+     * `settings.json` text, if any.
+     */
+    constructor(files_json: string, settings?: string | null);
+    plan(request_json: string): string;
+    resetRemaps(): void;
+    setFile(file: string, text?: string | null): string;
+    settingsStatus(): string;
+    unanalysed(): string;
+}
+
+/**
+ * The writable-file allowlist (security F5) the engine applies.
+ */
+export function isWritableFile(rel: string): boolean;
+
+export function rebindValueKey(value_key: string, update_json: string): string | undefined;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_project_free: (a: number, b: number) => void;
+    readonly isWritableFile: (a: number, b: number) => number;
+    readonly project_anchor: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly project_apply: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly project_computedExpression: (a: number, b: number, c: number) => [number, number];
+    readonly project_decl: (a: number, b: number, c: number) => [number, number];
+    readonly project_map: (a: number) => [number, number];
+    readonly project_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly project_plan: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly project_resetRemaps: (a: number) => void;
+    readonly project_setFile: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly project_settingsStatus: (a: number) => [number, number];
+    readonly project_unanalysed: (a: number) => [number, number];
+    readonly rebindValueKey: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/pkg/editor_engine_wasm.js

@@ -0,0 +1,477 @@
+/* @ts-self-types="./editor_engine_wasm.d.ts" */
+
+export class Project {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProjectFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_project_free(ptr, 0);
+    }
+    /**
+     * @param {string} file
+     * @param {number} line
+     * @param {number} column
+     * @returns {string | undefined}
+     */
+    anchor(file, line, column) {
+        const val2 = +line;
+        const val3 = +column;
+        const ptr0 = passStringToWasm0(file, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_anchor(this.__wbg_ptr, ptr0, len0, val2, val3);
+        let v4;
+        if (ret[0] !== 0) {
+            v4 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v4;
+    }
+    /**
+     * @param {string} request_json
+     * @returns {string}
+     */
+    apply(request_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.project_apply(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} value_key
+     * @returns {string | undefined}
+     */
+    computedExpression(value_key) {
+        const ptr0 = passStringToWasm0(value_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_computedExpression(this.__wbg_ptr, ptr0, len0);
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
+    }
+    /**
+     * @param {string} id
+     * @returns {string | undefined}
+     */
+    decl(id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_decl(this.__wbg_ptr, ptr0, len0);
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
+    }
+    /**
+     * @returns {string}
+     */
+    map() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.project_map(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * `files_json`: `{"<root-relative path>": "<content>", ...}`. `settings`: the SDK's
+     * `settings.json` text, if any.
+     * @param {string} files_json
+     * @param {string | null} [settings]
+     */
+    constructor(files_json, settings) {
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(files_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = isLikeNone(settings) ? 0 : passStringToWasm0(settings, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.project_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        ProjectFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} request_json
+     * @returns {string}
+     */
+    plan(request_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.project_plan(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    resetRemaps() {
+        wasm.project_resetRemaps(this.__wbg_ptr);
+    }
+    /**
+     * @param {string} file
+     * @param {string | null} [text]
+     * @returns {string}
+     */
+    setFile(file, text) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            let ptr0, len0, ptr1, len1;
+            try {
+                ptr0 = passStringToWasm0(file, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+                len0 = WASM_VECTOR_LEN;
+                ptr1 = isLikeNone(text) ? 0 : passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+                len1 = WASM_VECTOR_LEN;
+            } catch (e) {
+                if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+                if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+                throw e;
+            }
+            const ret = wasm.project_setFile(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            deferred3_0 = ret[0];
+            deferred3_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    settingsStatus() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.project_settingsStatus(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    unanalysed() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.project_unanalysed(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Project.prototype[Symbol.dispose] = Project.prototype.free;
+
+/**
+ * The writable-file allowlist (security F5) the engine applies.
+ * @param {string} rel
+ * @returns {boolean}
+ */
+export function isWritableFile(rel) {
+    const ptr0 = passStringToWasm0(rel, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.isWritableFile(ptr0, len0);
+    return ret !== 0;
+}
+
+/**
+ * @param {string} value_key
+ * @param {string} update_json
+ * @returns {string | undefined}
+ */
+export function rebindValueKey(value_key, update_json) {
+    let ptr0, len0, ptr1, len1;
+    try {
+        ptr0 = passStringToWasm0(value_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len0 = WASM_VECTOR_LEN;
+        ptr1 = passStringToWasm0(update_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len1 = WASM_VECTOR_LEN;
+    } catch (e) {
+        if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+        if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+        throw e;
+    }
+    const ret = wasm.rebindValueKey(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    let v3;
+    if (ret[0] !== 0) {
+        v3 = getStringFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v3;
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_208446807d0d1e30: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg___wbindgen_throw_4c88d8bf264fd984: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            table.set(0, undefined);
+            table.set(1024, undefined);
+            table.set(1025, null);
+            table.set(1026, true);
+            table.set(1027, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./editor_engine_wasm_bg.js": import0,
+    };
+}
+
+const ProjectFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_project_free(ptr, 1));
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(bytes) {
+    numBytesDecoded += bytes.length;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = bytes.length;
+    }
+    return cachedTextDecoder.decode(bytes);
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+let __wbg_init_promise;
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+    if (__wbg_init_promise === undefined) {
+        __wbg_init_promise = __wbg_init_once(module_or_path);
+        __wbg_init_promise.catch(() => { __wbg_init_promise = undefined; });
+    }
+    return __wbg_init_promise;
+}
+
+async function __wbg_init_once(module_or_path) {
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('editor_engine_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/pkg/editor_engine_wasm_bg.wasm.d.ts

@@ -0,0 +1,23 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_project_free: (a: number, b: number) => void;
+export const isWritableFile: (a: number, b: number) => number;
+export const project_anchor: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const project_apply: (a: number, b: number, c: number) => [number, number, number, number];
+export const project_computedExpression: (a: number, b: number, c: number) => [number, number];
+export const project_decl: (a: number, b: number, c: number) => [number, number];
+export const project_map: (a: number) => [number, number];
+export const project_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const project_plan: (a: number, b: number, c: number) => [number, number, number, number];
+export const project_resetRemaps: (a: number) => void;
+export const project_setFile: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const project_settingsStatus: (a: number) => [number, number];
+export const project_unanalysed: (a: number) => [number, number];
+export const rebindValueKey: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;