@nanobpm/nano-ide-app-embedded-nano 1.0.0

package/nano-ide.ext.json

@@ -0,0 +1,10 @@
+{
+  "id": "embedded-nano",
+  "kind": "app",
+  "displayName": "Embedded μ-nano app",
+  "fileTypes": [],
+  "templates": [
+    { "id": "embedded-starter", "label": "Embedded engine — self-contained binary, no gateway (ADR 0005)" }
+  ],
+  "toolchain": {}
+}

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@nanobpm/nano-ide-app-embedded-nano",
+  "version": "1.0.0",
+  "description": "Embedded μ-nano app pack for the Nano RAD IDE: compile a self-contained Deno binary with the Nano BPMN engine running in-process (ADR 0005), no gateway required.",
+  "license": "Apache-2.0",
+  "keywords": ["nano-ide-ext", "nano-ide-app", "nanobpm", "embedded"],
+  "publishConfig": { "access": "public" },
+  "repository": { "type": "git", "url": "https://github.com/jwulf/nano-ide.git", "directory": "packages/app-embedded-nano" },
+  "files": ["nano-ide.ext.json", "templates"]
+}

package/templates/embedded-starter/README.md

@@ -0,0 +1,27 @@
+# Embedded μ-nano starter
+
+A self-contained process app: the Nano BPMN engine runs **in this process** via
+WebAssembly (ADR 0005). No gateway, no sockets. `deno compile` ships engine + app
+as one binary.
+
+## Run
+
+```sh
+deno task start        # N=1000 by default; override with N=5000 deno task start
+```
+
+## Compile to a single binary
+
+```sh
+deno task compile      # -> ./embedded-app (includes engine wasm + BPMN)
+./embedded-app
+```
+
+## How it works
+
+- `engine/unano_bg.wasm` is `engine-core` compiled to wasm; `engine/host.ts` wraps it
+  as an `EmbeddedHost` (deploy / createInstance / activateJobs / complete / tick).
+- `@nanobpm/nano-sdk` with `CAMUNDA_TRANSPORT=embedded` binds the host directly, so the
+  same SDK code that talks to a real cluster drives the in-process engine.
+- The host injects `Date.now()` via `tickNow`, so the clock-free engine-core runs as a
+  real wall-clock runtime.

package/templates/embedded-starter/deno.json

@@ -0,0 +1,7 @@
+{
+  "imports": { "@nanobpm/nano-sdk": "npm:@nanobpm/nano-sdk@^1" },
+  "tasks": {
+    "start": "deno run --allow-read --allow-env main.ts",
+    "compile": "deno compile --allow-read --allow-env --include engine --include resources --output embedded-app main.ts"
+  }
+}

package/templates/embedded-starter/engine/host.ts

@@ -0,0 +1,73 @@
+// EmbeddedHost (ADR 0005, realization (a) "in-process direct"). Wraps μ-nano.wasm
+// (engine-core compiled to wasm) and implements the EmbeddedHost contract the
+// nano-sdk-js embedded transport binds to. engine-core stays clock-free; this host
+// injects Date.now() via tickNow so the engine runs as a real, wall-clock runtime.
+import { TestEngine } from "./unano.js";
+
+export interface EmbeddedJob {
+  jobKey: string;
+  type: string;
+  processInstanceKey: string;
+  elementId: string;
+  retries: number;
+  variables: Record<string, unknown>;
+}
+
+export class EmbeddedHost {
+  private engine: TestEngine;
+  private constructor(engine: TestEngine) {
+    this.engine = engine;
+  }
+
+  /** Boot the wasm engine. The deno-target unano.js instantiates μ-nano.wasm at
+   *  import time (top-level await), so there is nothing else to load. */
+  static async create(): Promise<EmbeddedHost> {
+    return new EmbeddedHost(new TestEngine());
+  }
+
+  async deploy(xml: string): Promise<{ processIds: string[] }> {
+    const r = JSON.parse(this.engine.deploy(xml));
+    return { processIds: r.processIds ?? [] };
+  }
+
+  async createInstance(input: { processDefinitionId?: string; variables?: Record<string, unknown> }): Promise<{ processInstanceKey: string }> {
+    const snap = JSON.parse(this.engine.createInstance(input.processDefinitionId ?? "", JSON.stringify(input.variables ?? {})));
+    return { processInstanceKey: String(snap.created) };
+  }
+
+  async activateJobs(type: string, max: number, timeoutMs: number, worker: string): Promise<EmbeddedJob[]> {
+    const jobs = JSON.parse(this.engine.activateJobs(type, max, timeoutMs, worker)) as any[];
+    return jobs.map((j) => ({
+      jobKey: String(j.key),
+      type: j.type,
+      processInstanceKey: String(j.instanceKey ?? ""),
+      elementId: j.elementId ?? "",
+      retries: j.retries ?? 3,
+      variables: j.variables ?? {},
+    }));
+  }
+
+  async completeJob(jobKey: string, variables?: Record<string, unknown>): Promise<void> {
+    this.engine.completeJob(jobKey, JSON.stringify(variables ?? {}));
+  }
+
+  async failJob(jobKey: string, retries: number, errorMessage?: string): Promise<void> {
+    this.engine.failJob(jobKey, retries, errorMessage ?? "");
+  }
+
+  instanceCompleted(key: string): boolean {
+    const snap = JSON.parse(this.engine.snapshot());
+    const inst = (snap.instances ?? []).find((i: any) => String(i.key) === key);
+    return !inst || inst.completed === true;
+  }
+
+  instanceVariables(key: string): Record<string, unknown> {
+    const snap = JSON.parse(this.engine.snapshot());
+    const inst = (snap.instances ?? []).find((i: any) => String(i.key) === key);
+    return inst?.variables ?? {};
+  }
+
+  tick(): void {
+    this.engine.tickNow(Date.now());
+  }
+}

package/templates/embedded-starter/engine/unano.d.ts

@@ -0,0 +1,70 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A simulated engine instance bound to one modeler session.
+ */
+export class TestEngine {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Activate up to `max_jobs` `Created` jobs of `job_type`, locking them to
+     * `worker` until `now + timeout_ms`. Returns a JSON array of activated jobs
+     * (key, type, instance/element, retries, variables) for the dispatch loop to
+     * hand to worker handlers. The host owns the wall clock via `tickNow`.
+     */
+    activateJobs(job_type: string, max_jobs: number, timeout_ms: number, worker: string): string;
+    /**
+     * Advance the virtual clock by `by_ms` milliseconds, firing any timers that
+     * become due and expiring any lapsed job locks.
+     */
+    advanceTime(by_ms: number): string;
+    /**
+     * Complete a waiting job by key, merging `variables_json` (a JSON object
+     * string) into the instance. The job is activated first if it has not been
+     * already, so the UI can complete a freshly-created job directly.
+     */
+    completeJob(job_key: string, variables_json: string): string;
+    /**
+     * Start a new instance of `process_id`, seeding it with the given variables
+     * (a JSON object string; pass `"{}"` or `""` for none). Returns the
+     * post-run [`Snapshot`] with a top-level `created` field holding the new
+     * instance key.
+     */
+    createInstance(process_id: string, variables_json: string): string;
+    /**
+     * Parse and deploy a BPMN resource. Returns a JSON object
+     * `{ "processIds": [...], "snapshot": {...} }` on success, or throws a
+     * JS error carrying the parse/deploy failure message.
+     */
+    deploy(xml: string): string;
+    /**
+     * The full ordered event log emitted so far, as a JSON array of
+     * `{ seq, now, type, ...payload }`. Useful for a step-through / trace view.
+     */
+    events(): string;
+    /**
+     * Fail a waiting job by key with the given remaining `retries` and message.
+     * With no retries left this raises an incident (visible in the snapshot).
+     */
+    failJob(job_key: string, retries: number, message: string): string;
+    /**
+     * Create a fresh, empty simulated engine. The virtual clock starts at 0.
+     */
+    constructor();
+    /**
+     * The current simulation state as a JSON [`Snapshot`].
+     */
+    snapshot(): string;
+    /**
+     * Set the engine clock to a wall-clock instant (ms), then trigger due timers
+     * and expire lapsed job locks. The embedded host calls this with `Date.now()`
+     * so `engine-core` stays clock-free while running as a real runtime. The
+     * clock never moves backwards. Returns the snapshot.
+     */
+    tickNow(now_ms: number): string;
+    /**
+     * The current virtual clock (milliseconds).
+     */
+    readonly now: number;
+}

package/templates/embedded-starter/engine/unano.js

@@ -0,0 +1,456 @@
+/* @ts-self-types="./unano.d.ts" */
+
+/**
+ * A simulated engine instance bound to one modeler session.
+ */
+export class TestEngine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TestEngineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_testengine_free(ptr, 0);
+    }
+    /**
+     * Activate up to `max_jobs` `Created` jobs of `job_type`, locking them to
+     * `worker` until `now + timeout_ms`. Returns a JSON array of activated jobs
+     * (key, type, instance/element, retries, variables) for the dispatch loop to
+     * hand to worker handlers. The host owns the wall clock via `tickNow`.
+     * @param {string} job_type
+     * @param {number} max_jobs
+     * @param {number} timeout_ms
+     * @param {string} worker
+     * @returns {string}
+     */
+    activateJobs(job_type, max_jobs, timeout_ms, worker) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(job_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(worker, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.testengine_activateJobs(retptr, this.__wbg_ptr, ptr0, len0, max_jobs, timeout_ms, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Advance the virtual clock by `by_ms` milliseconds, firing any timers that
+     * become due and expiring any lapsed job locks.
+     * @param {number} by_ms
+     * @returns {string}
+     */
+    advanceTime(by_ms) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.testengine_advanceTime(retptr, this.__wbg_ptr, by_ms);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Complete a waiting job by key, merging `variables_json` (a JSON object
+     * string) into the instance. The job is activated first if it has not been
+     * already, so the UI can complete a freshly-created job directly.
+     * @param {string} job_key
+     * @param {string} variables_json
+     * @returns {string}
+     */
+    completeJob(job_key, variables_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(job_key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(variables_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.testengine_completeJob(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Start a new instance of `process_id`, seeding it with the given variables
+     * (a JSON object string; pass `"{}"` or `""` for none). Returns the
+     * post-run [`Snapshot`] with a top-level `created` field holding the new
+     * instance key.
+     * @param {string} process_id
+     * @param {string} variables_json
+     * @returns {string}
+     */
+    createInstance(process_id, variables_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(process_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(variables_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.testengine_createInstance(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Parse and deploy a BPMN resource. Returns a JSON object
+     * `{ "processIds": [...], "snapshot": {...} }` on success, or throws a
+     * JS error carrying the parse/deploy failure message.
+     * @param {string} xml
+     * @returns {string}
+     */
+    deploy(xml) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.testengine_deploy(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * The full ordered event log emitted so far, as a JSON array of
+     * `{ seq, now, type, ...payload }`. Useful for a step-through / trace view.
+     * @returns {string}
+     */
+    events() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.testengine_events(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Fail a waiting job by key with the given remaining `retries` and message.
+     * With no retries left this raises an incident (visible in the snapshot).
+     * @param {string} job_key
+     * @param {number} retries
+     * @param {string} message
+     * @returns {string}
+     */
+    failJob(job_key, retries, message) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(job_key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.testengine_failJob(retptr, this.__wbg_ptr, ptr0, len0, retries, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Create a fresh, empty simulated engine. The virtual clock starts at 0.
+     */
+    constructor() {
+        const ret = wasm.testengine_new();
+        this.__wbg_ptr = ret;
+        TestEngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * The current virtual clock (milliseconds).
+     * @returns {number}
+     */
+    get now() {
+        const ret = wasm.testengine_now(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The current simulation state as a JSON [`Snapshot`].
+     * @returns {string}
+     */
+    snapshot() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.testengine_snapshot(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Set the engine clock to a wall-clock instant (ms), then trigger due timers
+     * and expire lapsed job locks. The embedded host calls this with `Date.now()`
+     * so `engine-core` stays clock-free while running as a real runtime. The
+     * clock never moves backwards. Returns the snapshot.
+     * @param {number} now_ms
+     * @returns {string}
+     */
+    tickNow(now_ms) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.testengine_tickNow(retptr, this.__wbg_ptr, now_ms);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) TestEngine.prototype[Symbol.dispose] = TestEngine.prototype.free;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_ea4887a5f8f9a9db: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+    };
+    return {
+        __proto__: null,
+        "./unano_bg.js": import0,
+    };
+}
+
+const TestEngineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_testengine_free(ptr, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+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 takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmUrl = new URL('unano_bg.wasm', import.meta.url);
+const wasmInstantiated = await WebAssembly.instantiateStreaming(fetch(wasmUrl), __wbg_get_imports());
+const wasmInstance = wasmInstantiated.instance;
+const wasm = wasmInstance.exports;

package/templates/embedded-starter/engine/unano_bg.wasm.d.ts

@@ -0,0 +1,19 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_testengine_free: (a: number, b: number) => void;
+export const testengine_activateJobs: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const testengine_advanceTime: (a: number, b: number, c: number) => void;
+export const testengine_completeJob: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const testengine_createInstance: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const testengine_deploy: (a: number, b: number, c: number, d: number) => void;
+export const testengine_events: (a: number, b: number) => void;
+export const testengine_failJob: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const testengine_new: () => number;
+export const testengine_now: (a: number) => number;
+export const testengine_snapshot: (a: number, b: number) => void;
+export const testengine_tickNow: (a: number, b: number, c: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number) => void;

package/templates/embedded-starter/main.ts

@@ -0,0 +1,30 @@
+// Embedded μ-nano starter (ADR 0005). The Nano engine runs IN this process via
+// wasm — no gateway, no sockets. The nano-sdk-js "embedded" transport binds to the
+// host directly, so the same SDK code that talks to a real cluster also drives the
+// in-process engine. `deno compile --include engine` ships engine + app as one binary.
+import { createCamundaClient } from "@nanobpm/nano-sdk";
+import { EmbeddedHost } from "./engine/host.ts";
+
+const BPMN = await Deno.readTextFile(new URL("./resources/processes/throughput.bpmn", import.meta.url));
+
+const host = await EmbeddedHost.create();
+await host.deploy(BPMN);
+
+const camunda = createCamundaClient({ config: { CAMUNDA_TRANSPORT: "embedded" }, embeddedHost: host });
+
+camunda.createJobWorker({
+  jobType: "work",
+  workerName: "embedded-worker",
+  maxParallelJobs: 16,
+  jobHandler: async (job: { complete: (v?: Record<string, unknown>) => Promise<unknown> }) => job.complete({ done: true }),
+});
+
+const N = Number(Deno.env.get("N") ?? 1000);
+const t0 = performance.now();
+await Promise.all(
+  Array.from({ length: N }, () =>
+    camunda.createProcessInstance({ processDefinitionId: "throughput", variables: {}, awaitCompletion: true })),
+);
+const dt = (performance.now() - t0) / 1000;
+console.log(`embedded: ${N} instances in ${dt.toFixed(2)}s — ${(N / dt).toFixed(0)}/s`);
+camunda.stopAllWorkers?.();

package/templates/embedded-starter/resources/processes/throughput.bpmn

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+             xmlns:zeebe="http://camunda.org/schema/zeebe/1.0"
+             targetNamespace="http://nanobpm/embedded">
+  <process id="throughput" isExecutable="true">
+    <startEvent id="start"/>
+    <sequenceFlow id="f1" sourceRef="start" targetRef="work"/>
+    <serviceTask id="work">
+      <extensionElements>
+        <zeebe:taskDefinition type="work"/>
+      </extensionElements>
+    </serviceTask>
+    <sequenceFlow id="f2" sourceRef="work" targetRef="end"/>
+    <endEvent id="end"/>
+  </process>
+</definitions>