@nimbus-sh/worker 0.1.4 → 0.1.6

package/dist/runtime/runtime-catalog.d.ts

@@ -10,7 +10,7 @@
  *
  *   catalog/v1.json                          ← top-level catalog
  *   manifests/<name>-<version>.json          ← per-version manifest
- *   blobs/<name>-<version>/<file>            ← content-addressed blobs
+ *   blobs/<name>-<version>/<sha256>/<file>   ← content-addressed blobs
  *
  * Catalog schema (RuntimeCatalog):
  *   { version: 1, runtimes: { <name>: { default, versions: { <ver>: { manifest, size_bytes, license } } } } }
@@ -18,7 +18,8 @@
  * Manifest schema (RuntimeManifest):
  *   { name, version, license, wasi_namespace, memfs_companion,
  *     files: [{ path, content, sha256, size, mode? }],
- *     entrypoints: [{ binName, runner, args[], kind? }] }
+ *     entrypoints: [{ binName, runner, args[], kind? }],
+ *     runtime_artifacts?: [{ path, kind, id, source_sha256?, sha256 }] }
  *
  * R2 and Cache API failures throw; the shell verb formats the diagnostic for
  * the user.
@@ -70,6 +71,13 @@ export interface ManifestEntrypoint {
     /** Optional secondary classification (e.g. "linker" for wasm-ld). */
     kind?: string;
 }
+export interface RuntimeArtifactMetadata {
+    path: string;
+    kind: string;
+    id: string;
+    source_sha256?: string;
+    sha256: string;
+}
 export interface RuntimeManifest {
     name: string;
     version: string;
@@ -82,6 +90,7 @@ export interface RuntimeManifest {
     memfs_companion: string | null;
     files: ManifestFile[];
     entrypoints: ManifestEntrypoint[];
+    runtime_artifacts?: RuntimeArtifactMetadata[];
 }
 /** Fetch the top-level catalog. Throws if neither L2 nor R2 has it. */
 export declare function fetchCatalog(env: RuntimeCatalogEnv): Promise<RuntimeCatalog>;
@@ -89,8 +98,11 @@ export declare function fetchCatalog(env: RuntimeCatalogEnv): Promise<RuntimeCat
 export declare function fetchManifest(env: RuntimeCatalogEnv, manifestKey: string): Promise<RuntimeManifest>;
 /**
  * Fetch a content-addressed blob by R2 key. Bytes are eternally
- * cacheable because the key encodes the version. Verifies sha256 if
- * `expectedSha256` is provided.
+ * cacheable when the manifest key includes the content digest. Older
+ * manifests used version-only keys, so L2 can contain stale bytes after
+ * a corrected runtime sync. A cached sha mismatch is therefore treated
+ * as a stale cache entry and refetched from R2; an R2 mismatch remains
+ * a hard integrity failure.
  */
 export declare function fetchBlob(env: RuntimeCatalogEnv, blobKey: string, expectedSha256?: string): Promise<Uint8Array>;
 export {};

package/dist/runtime/runtime-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-catalog.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,2CAA2C;AAC3C,KAAK,YAAY,GAAG;IAClB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QACxB,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;QACpC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;KACzB,GAAG,IAAI,CAAC,CAAC;CACX,GAAG,IAAI,GAAG,SAAS,CAAC;AAErB,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,CAAC,EAAE,YAAY,CAAC;CACrC;AAID,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,CAAC,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB;4CACwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;oEACgE;IAChE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B;iEAC6D;IAC7D,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,WAAW,EAAE,kBAAkB,EAAE,CAAC;CACnC;AAaD,uEAAuE;AACvE,wBAAsB,YAAY,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAoBlF;AAED,kDAAkD;AAClD,wBAAsB,aAAa,CACjC,GAAG,EAAE,iBAAiB,EACtB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CAoB1B;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,iBAAiB,EACtB,OAAO,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,UAAU,CAAC,CAwBrB"}
+{"version":3,"file":"runtime-catalog.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,2CAA2C;AAC3C,KAAK,YAAY,GAAG;IAClB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QACxB,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;QACpC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;KACzB,GAAG,IAAI,CAAC,CAAC;CACX,GAAG,IAAI,GAAG,SAAS,CAAC;AAErB,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,CAAC,EAAE,YAAY,CAAC;CACrC;AAID,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,CAAC,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB;4CACwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;oEACgE;IAChE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B;iEAC6D;IAC7D,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAClC,iBAAiB,CAAC,EAAE,uBAAuB,EAAE,CAAC;CAC/C;AAaD,uEAAuE;AACvE,wBAAsB,YAAY,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAoBlF;AAED,kDAAkD;AAClD,wBAAsB,aAAa,CACjC,GAAG,EAAE,iBAAiB,EACtB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CAoB1B;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,iBAAiB,EACtB,OAAO,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,UAAU,CAAC,CA0BrB"}

package/dist/runtime/runtime-catalog.js

@@ -10,7 +10,7 @@
  *
  *   catalog/v1.json                          ← top-level catalog
  *   manifests/<name>-<version>.json          ← per-version manifest
- *   blobs/<name>-<version>/<file>            ← content-addressed blobs
+ *   blobs/<name>-<version>/<sha256>/<file>   ← content-addressed blobs
  *
  * Catalog schema (RuntimeCatalog):
  *   { version: 1, runtimes: { <name>: { default, versions: { <ver>: { manifest, size_bytes, license } } } } }
@@ -18,7 +18,8 @@
  * Manifest schema (RuntimeManifest):
  *   { name, version, license, wasi_namespace, memfs_companion,
  *     files: [{ path, content, sha256, size, mode? }],
- *     entrypoints: [{ binName, runner, args[], kind? }] }
+ *     entrypoints: [{ binName, runner, args[], kind? }],
+ *     runtime_artifacts?: [{ path, kind, id, source_sha256?, sha256 }] }
  *
  * R2 and Cache API failures throw; the shell verb formats the diagnostic for
  * the user.
@@ -77,16 +78,19 @@ export async function fetchManifest(env, manifestKey) {
 }
 /**
  * Fetch a content-addressed blob by R2 key. Bytes are eternally
- * cacheable because the key encodes the version. Verifies sha256 if
- * `expectedSha256` is provided.
+ * cacheable when the manifest key includes the content digest. Older
+ * manifests used version-only keys, so L2 can contain stale bytes after
+ * a corrected runtime sync. A cached sha mismatch is therefore treated
+ * as a stale cache entry and refetched from R2; an R2 mismatch remains
+ * a hard integrity failure.
  */
 export async function fetchBlob(env, blobKey, expectedSha256) {
     // L2 hot path.
     const cached = await l2GetBytes(blobL2Key(blobKey));
     if (cached) {
-        if (expectedSha256)
-            await assertSha256(cached, expectedSha256, blobKey);
-        return cached;
+        if (!expectedSha256 || await bytesMatchSha256(cached, expectedSha256)) {
+            return cached;
+        }
     }
     // R2 path.
     const r2 = env.NIMBUS_RUNTIME_CACHE;
@@ -101,18 +105,25 @@ export async function fetchBlob(env, blobKey, expectedSha256) {
     const bytes = new Uint8Array(ab);
     if (expectedSha256)
         await assertSha256(bytes, expectedSha256, blobKey);
-    // Eternal-immutable write-back (content-addressed; never changes).
+    // Eternal-immutable write-back. Integrity has already been verified
+    // against the manifest before writing to L2.
     await l2PutBytes(blobL2Key(blobKey), bytes);
     return bytes;
 }
 // ── sha256 verifier ──────────────────────────────────────────────────
 async function assertSha256(bytes, expected, label) {
-    const digest = await crypto.subtle.digest('SHA-256', bytes);
-    const hex = bytesToHex(new Uint8Array(digest));
+    const hex = await sha256Hex(bytes);
     if (hex !== expected.toLowerCase()) {
         throw new Error(`sha256 mismatch for ${label}: expected ${expected} got ${hex}`);
     }
 }
+async function bytesMatchSha256(bytes, expected) {
+    return await sha256Hex(bytes) === expected.toLowerCase();
+}
+async function sha256Hex(bytes) {
+    const digest = await crypto.subtle.digest('SHA-256', bytes);
+    return bytesToHex(new Uint8Array(digest));
+}
 function bytesToHex(b) {
     let s = '';
     for (let i = 0; i < b.length; i++)

package/dist/runtime/runtime-registry.d.ts

@@ -63,6 +63,9 @@ export interface RuntimeRunOpts {
      *  runtimes ignore them safely. */
     skipSpawn?: boolean;
     callerPid?: number;
+    /** Capture stdout/stderr in the result instead of streaming to the
+     *  terminal supervisor. Used by child_process pipe semantics. */
+    captureOutput?: boolean;
 }
 export interface RuntimeSpec {
     /** Shell-command name: 'node' / 'bun' / 'wasm-runner' / 'python'. */

package/dist/runtime/runtime-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-registry.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACxC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;uCACmC;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb;oEACgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC3F;;;;;OAKG;IACH,aAAa,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IACzD;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,aAAa,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IACrF;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;CAC3C;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE;IACJ,GAAG,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC;IACvB;yDACqD;IACrD,UAAU,IAAI,cAAc,CAAC;IAC7B,QAAQ,EAAE,aAAa,CAAC;CACzB,GACA,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,MAAM,CAAC,CAyR/B"}
+{"version":3,"file":"runtime-registry.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACxC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;uCACmC;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;qEACiE;IACjE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb;oEACgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC3F;;;;;OAKG;IACH,aAAa,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IACzD;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,aAAa,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IACrF;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;CAC3C;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE;IACJ,GAAG,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC;IACvB;yDACqD;IACrD,UAAU,IAAI,cAAc,CAAC;IAC7B,QAAQ,EAAE,aAAa,CAAC;CACzB,GACA,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,MAAM,CAAC,CA6R/B"}

package/dist/runtime/runtime-registry.js

@@ -49,6 +49,7 @@ export function buildRuntimeHandler(spec, ctx0) {
     return async function runtimeHandler(ctx) {
         const args = ctx.args || [];
         const name = spec.name;
+        const captureOutput = !!ctx.__nimbusCaptureOutput;
         // ── Subcommand dispatch ──
         //
         // BEFORE flag-span computation: subcommands like `bun install`
@@ -103,6 +104,7 @@ export function buildRuntimeHandler(spec, ctx0) {
                 filename: '<eval>',
                 dirname: ctx.cwd || '/home/user',
                 command: `${name} -e ...`,
+                ...(captureOutput ? { captureOutput: true } : {}),
             });
             if (result.stdout)
                 ctx.stdout.write(result.stdout);
@@ -160,6 +162,7 @@ export function buildRuntimeHandler(spec, ctx0) {
                 filename,
                 dirname,
                 command: `${name} ${args.slice(0, scriptIdx + 1).join(' ')}`,
+                ...(captureOutput ? { captureOutput: true } : {}),
             });
             if (result.stdout)
                 ctx.stdout.write(result.stdout);
@@ -308,6 +311,7 @@ export function buildRuntimeHandler(spec, ctx0) {
             dirname,
             command: binSpawn?.command || `${name} ${args.slice(0, scriptIdx + 1).join(' ')}`,
             ...(binSpawn ? { skipSpawn: true, callerPid: binSpawn.callerPid } : {}),
+            ...(captureOutput ? { captureOutput: true } : {}),
         });
         if (result.stdout)
             ctx.stdout.write(result.stdout);

package/dist/runtime/sqlite-runtime-fs-bridge.d.ts

@@ -0,0 +1,43 @@
+import type { SqliteVFS } from '../vfs/sqlite-vfs.js';
+import type { RuntimeFileHandle, RuntimeFsBridge, RuntimeOpenFlags, RuntimeVfsDirEntry, RuntimeVfsStat } from './os-contracts.js';
+export declare class SqliteRuntimeFsBridge implements RuntimeFsBridge {
+    private readonly vfs;
+    private nextHandleId;
+    private handles;
+    private symlinks;
+    constructor(vfs: SqliteVFS);
+    stat(path: string, options?: {
+        followSymlinks?: boolean;
+    }): Promise<RuntimeVfsStat | null>;
+    readFile(path: string, options?: {
+        followSymlinks?: boolean;
+    }): Promise<Uint8Array | null>;
+    writeFile(path: string, bytes: string | Uint8Array, options?: {
+        createParents?: boolean;
+        expectedRevision?: number;
+    }): Promise<void>;
+    open(path: string, flags: RuntimeOpenFlags): Promise<RuntimeFileHandle>;
+    read(handleId: number, offset: number | null, length: number): Promise<Uint8Array>;
+    write(handleId: number, offset: number | null, bytes: Uint8Array): Promise<number>;
+    close(handleId: number): Promise<void>;
+    readdir(path: string, options?: {
+        followSymlinks?: boolean;
+    }): Promise<RuntimeVfsDirEntry[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number;
+    }): Promise<void>;
+    unlink(path: string): Promise<void>;
+    rmdir(path: string): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    readlink(path: string): Promise<string | null>;
+    symlink(target: string, path: string): Promise<void>;
+    fsync(): Promise<void>;
+    revision(): Promise<number>;
+    subscribe(path: string, listener: Parameters<NonNullable<RuntimeFsBridge['subscribe']>>[1]): () => void;
+    private resolveDataPath;
+    private ensureParent;
+    private assertExpectedRevision;
+    private getHandle;
+}
+//# sourceMappingURL=sqlite-runtime-fs-bridge.d.ts.map

package/dist/runtime/sqlite-runtime-fs-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-runtime-fs-bridge.d.ts","sourceRoot":"","sources":["../../src/runtime/sqlite-runtime-fs-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,qBAAsB,YAAW,eAAe;IAK/C,OAAO,CAAC,QAAQ,CAAC,GAAG;IAJhC,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,OAAO,CAAwC;IACvD,OAAO,CAAC,QAAQ,CAAkB;gBAEL,GAAG,EAAE,SAAS;IAIrC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IA6B9F,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAU9F,SAAS,CACb,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GAAG,UAAU,EAC1B,OAAO,GAAE;QAAE,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAO,GACnE,OAAO,CAAC,IAAI,CAAC;IAOV,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA4BvE,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAWlF,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAmBlF,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAehG,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMnC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa/C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAI9C,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC;IAIjC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,WAAW,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAIvG,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,SAAS;CAKlB"}

package/dist/runtime/sqlite-runtime-fs-bridge.js

@@ -0,0 +1,224 @@
+import { normalizeVfsPath, parentVfsPath } from '../vfs/path.js';
+import { getSymlinkRegistry } from '../vfs/symlink-registry.js';
+export class SqliteRuntimeFsBridge {
+    vfs;
+    nextHandleId = 1;
+    handles = new Map();
+    symlinks;
+    constructor(vfs) {
+        this.vfs = vfs;
+        this.symlinks = getSymlinkRegistry(vfs);
+    }
+    async stat(path, options = {}) {
+        const p = this.resolveDataPath(path, options.followSymlinks !== false);
+        if (!p)
+            return null;
+        if (this.symlinks.isSymlink(p) && options.followSymlinks === false) {
+            const target = this.symlinks.readlink(p) || '';
+            return {
+                type: 'symlink',
+                size: new TextEncoder().encode(target).byteLength,
+                ctime: Date.now(),
+                mtime: Date.now(),
+                mode: 0o777,
+                revision: this.vfs.revision(),
+            };
+        }
+        try {
+            const st = this.vfs.stat(p);
+            return {
+                type: st.type === 'directory' ? 'directory' : 'file',
+                size: st.size,
+                ctime: st.ctime,
+                mtime: st.mtime,
+                mode: st.mode,
+                revision: this.vfs.revision(),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async readFile(path, options = {}) {
+        const p = this.resolveDataPath(path, options.followSymlinks !== false);
+        if (!p)
+            return null;
+        try {
+            return this.vfs.readFile(p);
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeFile(path, bytes, options = {}) {
+        this.assertExpectedRevision(options.expectedRevision);
+        const p = this.resolveDataPath(path, true) || normalizeVfsPath(path);
+        if (options.createParents !== false)
+            this.ensureParent(p);
+        this.vfs.writeFile(p, bytes);
+    }
+    async open(path, flags) {
+        const normalizedFlags = normalizeOpenFlags(flags);
+        const p = this.resolveDataPath(path, normalizedFlags.followSymlinks) || normalizeVfsPath(path);
+        this.assertExpectedRevision(normalizedFlags.expectedRevision);
+        const exists = this.vfs.exists(p);
+        if (!exists && !normalizedFlags.create)
+            throw fsError('ENOENT', 'open', path);
+        if (exists && this.vfs.isDirectory(p))
+            throw fsError('EISDIR', 'open', path);
+        if (!exists) {
+            this.ensureParent(p);
+            this.vfs.writeFile(p, new Uint8Array(0));
+        }
+        else if (normalizedFlags.truncate) {
+            this.vfs.writeFile(p, new Uint8Array(0));
+        }
+        const stat = this.vfs.stat(p);
+        const handle = {
+            id: this.nextHandleId++,
+            path: p,
+            flags: normalizedFlags,
+            position: normalizedFlags.append ? stat.size : 0,
+            baseRevision: this.vfs.revision(),
+            closed: false,
+        };
+        this.handles.set(handle.id, handle);
+        return { ...handle };
+    }
+    async read(handleId, offset, length) {
+        const handle = this.getHandle(handleId);
+        if (!handle.flags.read)
+            throw fsError('EBADF', 'read', handle.path);
+        const data = this.vfs.readFile(handle.path);
+        const start = offset == null ? handle.position : Math.max(0, offset);
+        const end = Math.min(data.byteLength, start + Math.max(0, length));
+        const out = data.slice(start, end);
+        if (offset == null)
+            handle.position = end;
+        return out;
+    }
+    async write(handleId, offset, bytes) {
+        const handle = this.getHandle(handleId);
+        if (!handle.flags.write)
+            throw fsError('EBADF', 'write', handle.path);
+        if (handle.baseRevision < this.vfs.revision()) {
+            throw fsError('ESTALE', 'write', handle.path);
+        }
+        const prior = this.vfs.exists(handle.path) ? this.vfs.readFile(handle.path) : new Uint8Array(0);
+        const start = handle.flags.append ? prior.byteLength : offset == null ? handle.position : Math.max(0, offset);
+        const size = Math.max(prior.byteLength, start + bytes.byteLength);
+        const next = new Uint8Array(size);
+        next.set(prior.subarray(0, Math.min(prior.byteLength, size)), 0);
+        next.set(bytes, start);
+        this.vfs.writeFile(handle.path, next);
+        const end = start + bytes.byteLength;
+        if (offset == null || handle.flags.append)
+            handle.position = end;
+        handle.baseRevision = this.vfs.revision();
+        return bytes.byteLength;
+    }
+    async close(handleId) {
+        const handle = this.getHandle(handleId);
+        handle.closed = true;
+        this.handles.delete(handleId);
+    }
+    async readdir(path, options = {}) {
+        const p = this.resolveDataPath(path, options.followSymlinks !== false);
+        if (!p)
+            return [];
+        const entries = this.vfs.readdir(p).map((entry) => ({
+            name: entry.name,
+            type: entry.type === 'directory' ? 'directory' : 'file',
+        }));
+        const prefix = p ? `${p}/` : '';
+        for (const link of this.symlinks.list()) {
+            if (parentVfsPath(link.link) !== p)
+                continue;
+            entries.push({ name: link.link.slice(prefix.length), type: 'symlink' });
+        }
+        return entries.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async mkdir(path, options = {}) {
+        this.vfs.mkdir(normalizeVfsPath(path), { recursive: !!options.recursive });
+    }
+    async unlink(path) {
+        const p = normalizeVfsPath(path);
+        if (this.symlinks.delete(p))
+            return;
+        this.vfs.unlink(p);
+    }
+    async rmdir(path) {
+        this.vfs.rmdir(normalizeVfsPath(path));
+    }
+    async rename(from, to) {
+        const oldPath = normalizeVfsPath(from);
+        const newPath = normalizeVfsPath(to);
+        const linkTarget = this.symlinks.readlink(oldPath);
+        if (linkTarget !== null) {
+            this.symlinks.delete(oldPath);
+            this.symlinks.set(newPath, linkTarget);
+            return;
+        }
+        this.ensureParent(newPath);
+        this.vfs.rename(oldPath, newPath);
+    }
+    async readlink(path) {
+        return this.symlinks.readlink(normalizeVfsPath(path));
+    }
+    async symlink(target, path) {
+        const p = normalizeVfsPath(path);
+        this.ensureParent(p);
+        this.symlinks.set(p, target);
+    }
+    async fsync() {
+        this.vfs.flushAll();
+    }
+    async revision() {
+        return this.vfs.revision();
+    }
+    subscribe(path, listener) {
+        return this.vfs.events.onPath(normalizeVfsPath(path), listener);
+    }
+    resolveDataPath(path, followSymlinks) {
+        const p = normalizeVfsPath(path);
+        if (!followSymlinks)
+            return p;
+        return this.symlinks.resolveChain(p);
+    }
+    ensureParent(path) {
+        const parent = parentVfsPath(path);
+        if (parent && !this.vfs.exists(parent))
+            this.vfs.mkdir(parent, { recursive: true });
+    }
+    assertExpectedRevision(expectedRevision) {
+        if (expectedRevision === undefined)
+            return;
+        if (expectedRevision !== this.vfs.revision()) {
+            throw fsError('ESTALE', 'write', `revision ${expectedRevision}`);
+        }
+    }
+    getHandle(handleId) {
+        const handle = this.handles.get(handleId);
+        if (!handle || handle.closed)
+            throw fsError('EBADF', 'fd', String(handleId));
+        return handle;
+    }
+}
+function normalizeOpenFlags(flags) {
+    return {
+        read: !!flags.read || !flags.write,
+        write: !!flags.write,
+        append: !!flags.append,
+        create: !!flags.create,
+        truncate: !!flags.truncate,
+        followSymlinks: flags.followSymlinks !== false,
+        expectedRevision: flags.expectedRevision,
+    };
+}
+function fsError(code, syscall, path) {
+    const err = new Error(`${code}: ${syscall} '${path}'`);
+    err.code = code;
+    err.syscall = syscall;
+    err.path = path;
+    return err;
+}

package/dist/runtime/static-server.d.ts

@@ -0,0 +1,3 @@
+export declare function parsePort(value: string | undefined, fallback: number): number;
+export declare function createLiveStaticServerCode(root: string): string;
+//# sourceMappingURL=static-server.d.ts.map

package/dist/runtime/static-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-server.d.ts","sourceRoot":"","sources":["../../src/runtime/static-server.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAK7E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA6G/D"}

package/dist/runtime/static-server.js

@@ -0,0 +1,121 @@
+function jsString(value) {
+    return JSON.stringify(value);
+}
+export function parsePort(value, fallback) {
+    if (!value)
+        return fallback;
+    const n = Number(value);
+    if (!Number.isInteger(n) || n <= 0 || n >= 65536)
+        return fallback;
+    return n;
+}
+export function createLiveStaticServerCode(root) {
+    const normalizedRoot = root.replace(/^\/+/, '').replace(/\/+$/, '') || 'home/user';
+    return `
+import { WorkerEntrypoint } from "cloudflare:workers";
+
+const ROOT = ${jsString(normalizedRoot)};
+const TEXT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".svg": "image/svg+xml; charset=utf-8",
+  ".wasm": "application/wasm",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+};
+
+function cleanPath(pathname) {
+  const parts = [];
+  for (const raw of pathname.split("/")) {
+    if (!raw || raw === ".") continue;
+    if (raw === "..") { parts.pop(); continue; }
+    parts.push(raw);
+  }
+  return parts.join("/");
+}
+
+function joinRoot(rel) {
+  return rel ? ROOT + "/" + rel : ROOT;
+}
+
+function contentType(path) {
+  const idx = path.lastIndexOf(".");
+  const ext = idx >= 0 ? path.slice(idx).toLowerCase() : "";
+  return TEXT_TYPES[ext] || "application/octet-stream";
+}
+
+function htmlEscape(s) {
+  return String(s).replace(/[&<>"]/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[ch]));
+}
+
+async function resolveFile(supervisor, rel) {
+  const base = joinRoot(rel);
+  const stat = await supervisor.stat(base);
+  const isDirectory = stat && (stat.type === "directory" || stat.isDir || stat.isDirectory);
+  if (stat && !isDirectory) return { path: base, stat };
+  if (isDirectory) {
+    for (const index of ["index.html", "index.htm"]) {
+      const candidate = base.replace(/\\/+$/, "") + "/" + index;
+      const s = await supervisor.stat(candidate);
+      if (s && !(s.type === "directory" || s.isDir || s.isDirectory)) return { path: candidate, stat: s };
+    }
+    return { directory: base };
+  }
+  return null;
+}
+
+async function renderDirectory(supervisor, path, rel, url) {
+  const entries = await supervisor.readdir(path);
+  const rows = entries
+    .sort((a, b) => (a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1))
+    .map((entry) => {
+      const suffix = entry.type === "directory" ? "/" : "";
+      const href = new URL(url);
+      href.pathname = href.pathname.replace(/\\/?$/, "/") + encodeURIComponent(entry.name) + suffix;
+      return '<li><a href="' + href.pathname + href.search + '">' + htmlEscape(entry.name + suffix) + '</a></li>';
+    })
+    .join("");
+  return new Response(
+    '<!doctype html><meta charset="utf-8"><title>Index of /' + htmlEscape(rel) + '</title>' +
+    '<h1>Index of /' + htmlEscape(rel) + '</h1><ul>' + rows + '</ul>',
+    { headers: { "Content-Type": "text/html; charset=utf-8" } }
+  );
+}
+
+export default class NimbusStaticServer extends WorkerEntrypoint {
+  async fetch(request) {
+    return this.handleHttpRequest(request);
+  }
+
+  async handleHttpRequest(request) {
+    const supervisor = this.env && this.env.SUPERVISOR;
+    if (!supervisor) {
+      return new Response("Nimbus static server: SUPERVISOR binding missing", { status: 500 });
+    }
+    const url = new URL(request.url);
+    const rel = cleanPath(decodeURIComponent(url.pathname));
+    const resolved = await resolveFile(supervisor, rel);
+    if (!resolved) return new Response("Not found", { status: 404 });
+    if (resolved.directory) return renderDirectory(supervisor, resolved.directory, rel, url);
+    const bytes = await supervisor.readFileBytes(resolved.path);
+    if (!bytes) return new Response("Not found", { status: 404 });
+    return new Response(bytes, {
+      headers: {
+        "Content-Type": contentType(resolved.path),
+        "Cache-Control": "no-store",
+      },
+    });
+  }
+}
+`;
+}

package/dist/runtime/vfs-snapshot.d.ts

@@ -0,0 +1,57 @@
+import type { WasiFsDiff, WasiFsSnapshot } from './wasi-instance.js';
+/**
+ * Minimal VFS shape runtime bridges need. Kept separate from SqliteVFS's
+ * concrete type so runtime helpers do not pull supervisor modules into facet
+ * preambles or create import cycles.
+ */
+export interface VfsLike {
+    exists(path: string): boolean;
+    isDirectory(path: string): boolean;
+    readFile(path: string): Uint8Array;
+    writeFile(path: string, content: Uint8Array | string): void;
+    readdir(path: string): {
+        name: string;
+        type: string;
+    }[];
+    mkdir(path: string, opts?: {
+        recursive?: boolean;
+    }): void;
+    unlink(path: string): void;
+    rmdir(path: string): void;
+}
+export interface VfsSnapshotCaps {
+    maxBytes?: number;
+    maxFiles?: number;
+    skipSubdirs?: Iterable<string>;
+    extraRoots?: Iterable<string>;
+}
+export interface VfsSnapshotResult {
+    snapshot: WasiFsSnapshot;
+    bytes: number;
+    files: number;
+}
+export declare function bytesToB64(bytes: Uint8Array): string;
+export declare function b64ToBytes(b64: string): Uint8Array;
+/**
+ * Snapshot a VFS subtree into a JSON-serializable WASI-shaped filesystem.
+ *
+ * The snapshot is intentionally bounded. Runtimes that need incremental or
+ * lazy file IO should add a streaming bridge; a single request payload is the
+ * right primitive only for normal source trees and small app state.
+ */
+export declare function snapshotVfs(vfs: VfsLike, vfsRoot: string, caps?: VfsSnapshotCaps): VfsSnapshotResult | {
+    error: string;
+};
+/**
+ * Apply a runtime-produced filesystem diff back into the supervisor VFS.
+ * Operations are independent so one bad path never loses the rest of a run.
+ */
+export declare function flushVfsDiff(vfs: VfsLike, diff: WasiFsDiff): {
+    written: number;
+    deleted: number;
+    mkdirs: number;
+    rmdirs: number;
+    timesTouched: number;
+    symlinks: number;
+};
+//# sourceMappingURL=vfs-snapshot.d.ts.map

package/dist/runtime/vfs-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfs-snapshot.d.ts","sourceRoot":"","sources":["../../src/runtime/vfs-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IACnC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC;IAC5D,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACxD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/B,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,cAAc,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIpD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAKlD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,eAAoB,GACzB,iBAAiB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAmEvC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,UAAU,GACf;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA4C9G"}