@nimbus-sh/worker 0.2.0 → 0.2.2

package/dist/facets/manager.d.ts

@@ -573,6 +573,16 @@ export interface FacetManagerHooks {
      * a fresh CPU budget, and a launch needs each for a different reason.
      */
     requestLaunchTurn?: () => void;
+    /**
+     * Put a line in front of the user, whether or not a terminal is attached.
+     *
+     * Distinct from writing to a process's output: what this reports happened to
+     * the SESSION, and the socket that would have shown it is typically the one
+     * the event destroyed. The session satisfies it with the live terminal when
+     * there is one and the persisted scrollback when there is not, so the line
+     * survives until someone reconnects to read it.
+     */
+    notify?: (line: string) => void;
 }
 export interface LongRunningWorkerSpawnOptions {
     port?: number;
@@ -634,10 +644,14 @@ export declare class FacetManager {
      *
      * In-memory on purpose: a launch is only meaningful while the process table
      * entry it is building for exists, and both are lost together if the isolate
-     * resets. Persisting the queue would resurrect launches for pids that no
-     * longer exist.
+     * resets. What survives a reset is the journal, which names the launch's
+     * INPUTS rather than its position — a resumed queue would be resurrecting
+     * half-built work for pids that no longer exist, where re-driving a launch
+     * from its inputs is the same idempotent work again.
      */
     private launchWaiters;
+    /** Whether this instance has already read the journal a reset leaves behind. */
+    private launchesRecovered;
     private timedOutProcessIds;
     private _pairedServeFacet;
     /**
@@ -979,6 +993,31 @@ export declare class FacetManager {
      * the runtime may tear the context down mid-chunk.
      */
     pumpResidentLaunches(): Promise<void>;
+    /**
+     * Re-drive the launches a previous instance was building when it was reset.
+     *
+     * The platform resets a session Durable Object over what one turn has
+     * outstanding in storage ("Internal error in Durable Object storage caused
+     * object to be reset"), and a launch is the largest writer this session has.
+     * Everything the launch held was in memory, so the process it was building
+     * and the terminal watching it both went with the instance, and until now
+     * the user was told nothing at all.
+     *
+     * Sited on the pump because the pump is what an alarm calls, and a launch
+     * that was suspended has an alarm armed for it — a reset during a chunk
+     * fails that alarm, and the platform re-delivers it to the instance that
+     * replaces this one. So the first turn after a reset is already this one.
+     *
+     * Runs once per instance: the journal only changes when a launch of THIS
+     * instance starts or settles, and those are rows this instance wrote.
+     */
+    private _recoverInterruptedLaunches;
+    /**
+     * Record a launch as in flight, so an instance that replaces this one knows
+     * it never finished. Best-effort: a launch that cannot be journalled still
+     * runs, and a reset then costs exactly what it cost before the journal.
+     */
+    private _journalLaunch;
     /** Whether any launch is suspended waiting for a turn. */
     get hasPendingLaunchTurns(): boolean;
     /** Allocate a free loopback port for a resident server facet (from 4096 up). */
@@ -1024,6 +1063,12 @@ export declare class FacetManager {
     spawnNode(code: string, opts?: ResidentSpawnOptions): Promise<{
         pid: number;
     }>;
+    /**
+     * `attempt` distinguishes the launch the user asked for from the one re-drive
+     * an instance reset earns it, and is carried in the journal rather than in
+     * the caller's options because no caller has an opinion about it.
+     */
+    private _spawnResident;
     /**
      * Build and boot a resident process across as many turns as it takes.
      *

package/dist/facets/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/facets/manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAC7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AAUjG,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAE7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAM7E,OAAO,EAAE,WAAW,EAAiD,MAAM,mBAAmB,CAAC;AAC/F,OAAO,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAI5E,OAAO,EAOL,KAAK,kBAAkB,EAIxB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,2CAA2C,CAAC;AAenD,6CAA6C;AAC7C,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzE;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B;;;;;OAKG;IACH,IAAI,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CACvE;AAED;;;;;GAKG;AACH,MAAM,WAAW,wBAAyB,SAAQ,eAAe;IAC/D,GAAG,EAAE,MAAM,CAAC;IACZ,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAmHD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,QAA8C,CAAC;AAEtF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,qBAAqB,0pHA4EjC,CAAC;AA4HF;;;GAGG;AACH,UAAU,sBAAsB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,OAAO,EACnB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,sBAAsB,CAAC,CA0QjC;AAED;;;;;;GAMG;AACH,wBAAsB,2BAA2B,CAC/C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE;IACJ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;CAC5B,EACD,UAAU,EAAE,OAAO,EACnB,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,sBAAsB,CAAC,CAkZjC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,KAAK,cAAc,GAAG;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,CAAC;AAC1C,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,cAAc,CAAC,CAAC;AAC3E,KAAK,gBAAgB,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC;AAEhF,UAAU,aAAa;IAQrB,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC3C;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,6EAA6E;IAC7E,cAAc,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,SAAS,EAAE,OAAO,CAAC;IACnB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,uEAAuE;IACvE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,sFAAsF;IACtF,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,CAItE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,CAK1E;AA6CD,UAAU,oBAAoB;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAqID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;cAK9E,MAAM,QAAQ,cAAc,CAAC,MAAM,CAAC,GAAG,IAAI;iBAMxC,MAAM,GAAG,IAAI;oBAMb,MAAM;EAOtB;AA6ID;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,cAAc,EACtB,gBAAgB,UAAQ,EACxB,KAAK,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,oBAAoB,CAAC,CAqH/B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACrB,IAAI,CAaN;AAoKD;;;;;;;;GAQG;AAKH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,EAC3C,WAAW,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CA+InB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,EAC3C,WAAW,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CA2FnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,oCAAoC,CAClD,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,EAC3C,WAAW,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAsHnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,eAAe,EACpB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,EAC3C,WAAW,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EACtD,aAAa,EAAE,kBAAkB,GAChC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAgGnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,eAAe,EACpB,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,EACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,EAC3C,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,WAAW,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CA4BnB;AAwSD;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAG7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,CAIxE;AA4GD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,eAAe,EACpB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,cAAc,EACxB,aAAa,GAAE,kBAAiD,EAChE,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,KAAK,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,aAAa,CAAC,CAiBxB;AA4ND;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACrE,wFAAwF;IACxF,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,KAAK,IAAI,CAAC;IACvE;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC;IACzD;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,uDAAuD;IACvD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAID,0EAA0E;AAC1E,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,kBAAkB,CAAC;CACpC;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,GAAG,CAAqB;IAChC,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,KAAK,CAAoB;IACjC;;;;;OAKG;IACH,OAAO,CAAC,aAAa,CAAgB;IACrC;;;;OAIG;IACH,OAAO,CAAC,WAAW,CAAc;IACjC,wEAAwE;IACxE,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,mBAAmB,CAA0C;IACrE,8EAA8E;IAC9E,OAAO,CAAC,cAAc,CAA+B;IACrD;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa,CAAgE;IACrF,OAAO,CAAC,kBAAkB,CAAqB;IAI/C,OAAO,CAAC,iBAAiB,CAA6B;IACtD;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,CAA+B;IAE9C;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,mBAAmB,CAKtB;IACL,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAM;IAChD,8EAA8E;IAC9E,OAAO,CAAC,kBAAkB,CAAK;IAE/B;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,6BAA6B,CAAM;IAC3D;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,2BAA2B,CAAQ;gBAUzD,GAAG,EAAE,kBAAkB,EACvB,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,wBAAwB,EACnC,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,kBAAkB,EACxB,KAAK,GAAE,iBAAsB;IAe/B,MAAM,CAAC,GAAG,EAAE,SAAS;IAErB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,kBAAkB,CAAS;IACnC;;;;OAIG;IACH,iBAAiB,CAAC,OAAO,EAAE,cAAc;IAEzC;;;;;;;;;OASG;IACH;;;;;;;;;;;;;;;;;;;;;OAqBG;YACW,wBAAwB;YA4BxB,0BAA0B;IAmExC;;;;;;;;;OASG;IACH;;;;;;;;OAQG;IACH,OAAO,CAAC,sBAAsB;IA2B9B,mFAAmF;IACnF,OAAO,CAAC,wBAAwB;IAqChC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,0BAA0B;IAOlC,OAAO,CAAC,uBAAuB;IAI/B;;;;OAIG;IACH,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIxC,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAa5D;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IAOjC,8DAA8D;IACxD,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE;QACJ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf;;;;;;;;;;;;;WAaG;QACH,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,wEAAwE;QACxE,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,gEAAgE;QAChE,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,kBAAkB,CAAC;QACnC;8DACsD;QACtD,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,GACA,OAAO,CAAC,eAAe,CAAC;IAkI3B;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;YA+Bd,cAAc;IAiH5B;;;;;;;;;OASG;IACG,kBAAkB,CACtB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,IAAI,CAAC,qBAAqB,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,GAAG,aAAa,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,CAAC,GAAG;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GACzK,OAAO,CAAC,wBAAwB,CAAC;IA4CpC;;;;;;;;OAQG;YACW,mBAAmB;IAuEjC;;;;;;;OAOG;YACW,2BAA2B;IAuDzC;;;;;;;OAOG;IACG,wBAAwB,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAClG,OAAO,CAAC,wBAAwB,CAAC;IAcpC;;;;;;;OAOG;IACG,sBAAsB,CAC1B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GACnF,OAAO,CAAC,wBAAwB,CAAC;YA8CtB,uBAAuB;IA0DrC;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;;;;;;;;OASG;IACH,OAAO,CAAC,aAAa;IASrB;;;;;;;;;;;;;OAaG;YACW,uBAAuB;IA8CrC;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAK/B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,iBAAiB;IAiBzB;;;;OAIG;YACW,qBAAqB;IAuBnC,OAAO,CAAC,yBAAyB;IAUjC;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAS9B;IAEF;;;;;;;OAOG;IACG,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3C,0DAA0D;IAC1D,IAAI,qBAAqB,IAAI,OAAO,CAEnC;IAED,gFAAgF;IAChF,OAAO,CAAC,qBAAqB;IAO7B;;;;;;;OAOG;YACW,yBAAyB;IAsDvC;;;;;;;;;;OAUG;YACW,mBAAmB;IA0BjC,sEAAsE;IACtE,OAAO,CAAC,eAAe;IAUvB,sEAAsE;IACtE,OAAO,CAAC,eAAe;IAiBvB,yBAAyB;YACX,gBAAgB;IAgC9B;;;;;;;;;;OAUG;IACG,SAAS,CACb,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IAyC3B;;;;;;;;;OASG;YACW,kBAAkB;YAmBlB,mBAAmB;IAsLjC;;;;;;;;;;;;OAYG;IACG,WAAW,CACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,6BAAkC,GACvC,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;IA2D1C,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAM7C,qBAAqB,CACnB,GAAG,EAAE,MAAM,EACX,SAAS,SAAmC,GAC3C,OAAO,CAAC,MAAM,EAAE,CAAC;IAIpB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAW,GAAG,IAAI;IAYrE,qCAAqC;IACrC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAc1B,IAAI,KAAK;;;;;;MAAmC;CAC7C"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/facets/manager.ts"],"names":[],"mappings":"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"}

package/dist/facets/manager.js

@@ -37,7 +37,8 @@ import { createLoadedWorkerEntrypoint, getNimbusCtxExports, } from '../loaders/w
 import { SQLITE_WASM_MODULE_NAME, } from '../runtime/opencode-facet-runner.js';
 import { parsePortFromArgv, resolveLongRunningPort } from '@nimbus-sh/core/runtime/long-running-handle.js';
 import { DEFAULT_FACET_BUNDLE_PROFILE, } from '@nimbus-sh/core/runtime/bundle-profile.js';
-import { BUNDLE_BUILD_DEADLINE_MS, CF_COMPAT_DATE, FACET_TIMEOUT_MS, VFS_BUNDLE_MAX_FILES, VFS_BUNDLE_MAX_BYTES, CWD_SNAPSHOT_MAX_FILE_BYTES, BUNDLE_MAX_ENCODED_BYTES, MAX_RPC_SAFE_PAYLOAD_BYTES, PREFETCH_CACHE_MAX_BYTES, } from '@nimbus-sh/core/constants.js';
+import { BUNDLE_BUILD_DEADLINE_MS, CF_COMPAT_DATE, CHUNK_SIZE, FACET_TIMEOUT_MS, VFS_BUNDLE_MAX_FILES, VFS_BUNDLE_MAX_BYTES, CWD_SNAPSHOT_MAX_FILE_BYTES, BUNDLE_MAX_ENCODED_BYTES, MAX_RPC_SAFE_PAYLOAD_BYTES, MAX_TX_BLOB_BYTES, PREFETCH_CACHE_MAX_BYTES, } from '@nimbus-sh/core/constants.js';
+import { RESIDENT_LAUNCH_KEY_PREFIX } from '../session/keys.js';
 import { CRED_KERNEL } from '@nimbus-sh/core/runtime/os-contracts.js';
 import { acquireSupervisorAllocation } from '@nimbus-sh/core/observability/heavy-alloc-coord.js';
 import { prefetchBundleStart, prefetchBundleEnd, setPrefetchCacheBytes, } from '@nimbus-sh/core/observability/diag-counters.js';
@@ -3146,6 +3147,19 @@ async function _buildPrefetchBundle(vfs, scriptPath, cwd, entryCode, esbuild, bu
     };
 }
 const ROUTEABLE_PORT_ATTACH_TIMEOUT_MS = 1_000;
+/**
+ * Bytes of an image written in one storage transaction.
+ *
+ * The bound is the VFS's own, not a knob: a `writeRange` whose chunks fit
+ * inside one transaction is committed in place, and one that does not falls
+ * back to copy-on-write — which rewrites every chunk of the file, per slice,
+ * making a sliced write quadratic in its size. A whole number of chunks is
+ * the other half of that: a slice that ends mid-chunk makes the next one read
+ * the partial chunk back to complete it.
+ */
+const FACET_IMAGE_WRITE_SLICE_BYTES = Math.floor(MAX_TX_BLOB_BYTES / CHUNK_SIZE) * CHUNK_SIZE;
+/** A launch is re-driven once. A reset that recurs is not the transient one. */
+const RESIDENT_LAUNCH_MAX_ATTEMPT = 1;
 export class FacetManager {
     ctx;
     env;
@@ -3176,10 +3190,14 @@ export class FacetManager {
      *
      * In-memory on purpose: a launch is only meaningful while the process table
      * entry it is building for exists, and both are lost together if the isolate
-     * resets. Persisting the queue would resurrect launches for pids that no
-     * longer exist.
+     * resets. What survives a reset is the journal, which names the launch's
+     * INPUTS rather than its position — a resumed queue would be resurrecting
+     * half-built work for pids that no longer exist, where re-driving a launch
+     * from its inputs is the same idempotent work again.
      */
     launchWaiters = [];
+    /** Whether this instance has already read the journal a reset leaves behind. */
+    launchesRecovered = false;
     timedOutProcessIds = new Set();
     // attach-pid → serve-pid: the resident serve facet a bare-`opencode` dual
     // spawn created as an OS-child of the attach TUI. When the attach process
@@ -4180,8 +4198,7 @@ export class FacetManager {
             const path = facetImagePath(await facetImageDigest(source));
             images[moduleName] = path;
             sources.set(path, source);
-            if (pacer)
-                await pacer.spend(source.length);
+            await pacer.spend(source.length);
         }
         // Register the WHOLE root set here, in one synchronous step, before any
         // byte of it exists on disk. That ordering is the entire protocol between
@@ -4196,15 +4213,32 @@ export class FacetManager {
         for (const [path, source] of sources) {
             const stored = path.replace(/^\/+/, '');
             const bytes = new TextEncoder().encode(source);
-            // A whole-file write is atomic against the DO's single thread, so an
-            // image already present at the right size cannot be a torn one, and
-            // rewriting it would only cost the disk. Size is enough of a check here
+            // An image at its full size is a COMPLETE one: a write only ever grows
+            // the file from offset zero, so a write cut short by a reset leaves a
+            // strictly shorter file and fails this test. Size is enough of a check
             // because the reader verifies the digest before the loader sees it.
-            if (!(fs.exists(stored) && fs.lstat(stored).size === bytes.byteLength)) {
-                fs.writeFile(stored, bytes, { mode: 0o644 });
-            }
-            if (pacer)
+            if (fs.exists(stored) && fs.lstat(stored).size === bytes.byteLength) {
                 await pacer.spend(bytes.byteLength);
+                continue;
+            }
+            // Sliced because the platform resets the object over what ONE TURN has
+            // outstanding, not over what it eventually writes — pi's 22.9 MB map
+            // went in as a single write and took the session down with it ~25% of
+            // the time. Spending between slices is what puts the rest of the image
+            // on later turns; the slice bound is what keeps any one of them small.
+            let offset = 0;
+            do {
+                const slice = bytes.subarray(offset, offset + FACET_IMAGE_WRITE_SLICE_BYTES);
+                // The first slice REPLACES the file, so an interrupted write's remains
+                // are truncated to a known length rather than left as a tail past this
+                // content — and the mode is chosen here, at creation, as POSIX has it.
+                if (offset === 0)
+                    fs.writeFile(stored, slice, { mode: 0o644 });
+                else
+                    fs.writeRange(stored, offset, slice);
+                offset += slice.byteLength;
+                await pacer.spend(slice.byteLength);
+            } while (offset < bytes.byteLength);
         }
         this._sweepFacetImages(fs);
         return images;
@@ -4318,6 +4352,7 @@ export class FacetManager {
      * the runtime may tear the context down mid-chunk.
      */
     async pumpResidentLaunches() {
+        await this._recoverInterruptedLaunches();
         const waiting = this.launchWaiters;
         if (waiting.length === 0)
             return;
@@ -4326,6 +4361,70 @@ export class FacetManager {
             waiter.resume();
         await Promise.all(waiting.map((waiter) => waiter.chunkEnded));
     }
+    /**
+     * Re-drive the launches a previous instance was building when it was reset.
+     *
+     * The platform resets a session Durable Object over what one turn has
+     * outstanding in storage ("Internal error in Durable Object storage caused
+     * object to be reset"), and a launch is the largest writer this session has.
+     * Everything the launch held was in memory, so the process it was building
+     * and the terminal watching it both went with the instance, and until now
+     * the user was told nothing at all.
+     *
+     * Sited on the pump because the pump is what an alarm calls, and a launch
+     * that was suspended has an alarm armed for it — a reset during a chunk
+     * fails that alarm, and the platform re-delivers it to the instance that
+     * replaces this one. So the first turn after a reset is already this one.
+     *
+     * Runs once per instance: the journal only changes when a launch of THIS
+     * instance starts or settles, and those are rows this instance wrote.
+     */
+    async _recoverInterruptedLaunches() {
+        if (this.launchesRecovered)
+            return;
+        this.launchesRecovered = true;
+        const journal = await this.ctx.storage.list({
+            prefix: RESIDENT_LAUNCH_KEY_PREFIX,
+        });
+        for (const [key, record] of journal) {
+            // A pid at or below this instance's base was allocated by a PREVIOUS one
+            // (process-table.ts, PID_GEN_STRIDE), so its launch never finished; above
+            // the base is this instance's own, still running. Same predicate as
+            // `session/rpc.ts` uses to attribute a prior generation's pid.
+            if (!(record.pid > 0 && record.pid <= this.processes.pidBase))
+                continue;
+            await this.ctx.storage.delete(key);
+            if (record.attempt >= RESIDENT_LAUNCH_MAX_ATTEMPT) {
+                this.hooks.notify?.('\x1b[2m[nimbus: the session restarted again while '
+                    + `"${record.command}" was starting — leaving it stopped]\x1b[0m\r\n`);
+                continue;
+            }
+            this.hooks.notify?.('\x1b[2m[nimbus: the session restarted while '
+                + `"${record.command}" was starting — restarting it]\x1b[0m\r\n`);
+            // Not awaited: this call is running inside the alarm that granted the
+            // turn, and the launch it starts asks for turns of its own through that
+            // same alarm — awaiting it here would be waiting on an alarm that cannot
+            // be scheduled until this one returns.
+            this.ctx.waitUntil(this._spawnResident(record.code, record.opts, record.attempt + 1)
+                .catch((e) => {
+                this.hooks.notify?.(`\x1b[2m[nimbus: "${record.command}" could not be restarted: `
+                    + `${errorMessage(e)}]\x1b[0m\r\n`);
+            }));
+        }
+    }
+    /**
+     * Record a launch as in flight, so an instance that replaces this one knows
+     * it never finished. Best-effort: a launch that cannot be journalled still
+     * runs, and a reset then costs exactly what it cost before the journal.
+     */
+    async _journalLaunch(record) {
+        try {
+            await this.ctx.storage.put(`${RESIDENT_LAUNCH_KEY_PREFIX}${record.pid}`, record);
+        }
+        catch (e) {
+            console.warn('[nimbus] resident launch journal write failed:', errorMessage(e));
+        }
+    }
     /** Whether any launch is suspended waiting for a turn. */
     get hasPendingLaunchTurns() {
         return this.launchWaiters.length > 0;
@@ -4501,7 +4600,15 @@ export class FacetManager {
      * is the largest thing Nimbus generates, so it travels by VFS path rather
      * than inside the boot spec and is read only when the facet loads.
      */
-    async spawnNode(code, opts = {}) {
+    spawnNode(code, opts = {}) {
+        return this._spawnResident(code, opts, 0);
+    }
+    /**
+     * `attempt` distinguishes the launch the user asked for from the one re-drive
+     * an instance reset earns it, and is carried in the journal rather than in
+     * the caller's options because no caller has an opinion about it.
+     */
+    async _spawnResident(code, opts, attempt) {
         this.processes.reap();
         const command = opts.command || (opts.filename ? `node ${opts.filename}` : 'node <script>');
         const cwd = opts.cwd || '/home/user';
@@ -4525,7 +4632,7 @@ export class FacetManager {
             }
             catch { }
         }
-        const launch = this._runResidentLaunch(entry, code, command, opts);
+        const launch = this._runResidentLaunch(entry, code, command, opts, attempt);
         if (!opts.attachedTty) {
             // A server's caller is told a port is bound, so it has to wait for the
             // boot that binds it. The wait costs this turn nothing: every chunk of
@@ -4555,14 +4662,31 @@ export class FacetManager {
      * terminal WebSocket needs to survive a launch, and what no amount of making
      * the launch faster would have given it.
      */
-    async _runResidentLaunch(entry, code, command, opts) {
+    async _runResidentLaunch(entry, code, command, opts, attempt) {
         const cwd = opts.cwd || '/home/user';
         const pacer = new LaunchPacer(this.launchScheduler, launchChunkMaxBytes(this.env), () => this._assertLaunchStillOwned(entry.pid));
+        // Journalled before the first byte of work and removed when the launch
+        // settles either way, so a row that outlives its instance means one thing:
+        // the launch was still running when the object was reset. A re-drive owns
+        // its own process, so the caller's pid goes with the instance that had it.
+        await this._journalLaunch({
+            pid: entry.pid,
+            command,
+            code,
+            opts: { ...opts, skipSpawn: undefined, callerPid: undefined },
+            attempt,
+        });
         try {
             await this._residentLaunchBody(entry, code, command, cwd, opts, pacer);
         }
         finally {
             pacer.settle();
+            try {
+                await this.ctx.storage.delete(`${RESIDENT_LAUNCH_KEY_PREFIX}${entry.pid}`);
+            }
+            catch (e) {
+                console.warn('[nimbus] resident launch journal delete failed:', errorMessage(e));
+            }
         }
     }
     async _residentLaunchBody(entry, code, command, cwd, opts, pacer) {

package/dist/loaders/generated-workers.d.ts

@@ -2,7 +2,7 @@
  * generated-workers.ts — AUTO-GENERATED. DO NOT EDIT.
  *
  * Produced by scripts/bundle-facet-workers.mjs from:
- *   - src/npm/tarball-stream.ts (streaming tar primitives)
+ *   - @nimbus-sh/core src/_shared/tarball-stream.ts (streaming tar primitives)
  *   - @nimbus-sh/core src/_shared/w7-frame.ts (W7 streaming bulk-write encoder)
  *
  * Consumed by src/loaders/loader-pool.ts callers via the `preamble`
@@ -15,7 +15,7 @@
  * W7-frame symbols:   encodeWriteBatchStream, decodeWriteBatchStream,
  *   W7_MAGIC, W7_MAX_RECORD_BYTES.
  *
- * Tar size: 4.14 KiB
+ * Tar size: 4.15 KiB
  * W7 size:  29.18 KiB
  */
 export declare const TAR_STREAM_PREAMBLE: string;

package/dist/loaders/generated-workers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generated-workers.d.ts","sourceRoot":"","sources":["../../src/loaders/generated-workers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,mBAAmB,EAAE,MAAm1I,CAAC;AAEt3I,eAAO,MAAM,iBAAiB,EAAE,MAAyt8B,CAAC"}
+{"version":3,"file":"generated-workers.d.ts","sourceRoot":"","sources":["../../src/loaders/generated-workers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,mBAAmB,EAAE,MAA+1I,CAAC;AAEl4I,eAAO,MAAM,iBAAiB,EAAE,MAAyt8B,CAAC"}

package/dist/loaders/generated-workers.js

@@ -2,7 +2,7 @@
  * generated-workers.ts — AUTO-GENERATED. DO NOT EDIT.
  *
  * Produced by scripts/bundle-facet-workers.mjs from:
- *   - src/npm/tarball-stream.ts (streaming tar primitives)
+ *   - @nimbus-sh/core src/_shared/tarball-stream.ts (streaming tar primitives)
  *   - @nimbus-sh/core src/_shared/w7-frame.ts (W7 streaming bulk-write encoder)
  *
  * Consumed by src/loaders/loader-pool.ts callers via the `preamble`
@@ -15,8 +15,8 @@
  * W7-frame symbols:   encodeWriteBatchStream, decodeWriteBatchStream,
  *   W7_MAGIC, W7_MAX_RECORD_BYTES.
  *
- * Tar size: 4.14 KiB
+ * Tar size: 4.15 KiB
  * W7 size:  29.18 KiB
  */
-export const TAR_STREAM_PREAMBLE = "// src/npm/tarball-stream.ts\nvar MAX_FILE_BYTES = 2e7;\nfunction canonicalTarName(name) {\n  const out = [];\n  for (const seg of name.split(\"/\")) {\n    if (seg === \"..\") {\n      if (out.length === 0) return \"\";\n      out.pop();\n    } else if (seg !== \"\" && seg !== \".\") {\n      out.push(seg);\n    }\n  }\n  return out.join(\"/\");\n}\nfunction parseTarHeader(block) {\n  if (block[0] === 0) return null;\n  let name = \"\";\n  for (let i = 0; i < 100 && block[i] !== 0; i++) {\n    name += String.fromCharCode(block[i]);\n  }\n  let prefix = \"\";\n  for (let i = 345; i < 500 && block[i] !== 0; i++) {\n    prefix += String.fromCharCode(block[i]);\n  }\n  if (prefix) name = prefix + \"/\" + name;\n  name = name.replace(/^package\\//, \"\");\n  name = canonicalTarName(name);\n  let sizeStr = \"\";\n  for (let i = 124; i < 136 && block[i] !== 0; i++) {\n    sizeStr += String.fromCharCode(block[i]);\n  }\n  const size = parseInt(sizeStr.trim(), 8) || 0;\n  const typeFlag = block[156];\n  return { name, size, typeFlag };\n}\nasync function* readableStreamToAsyncIterable(rs) {\n  const reader = rs.getReader();\n  try {\n    while (true) {\n      const { value, done } = await reader.read();\n      if (done) return;\n      if (value && value.length > 0) yield value;\n    }\n  } finally {\n    try {\n      reader.releaseLock();\n    } catch {\n    }\n  }\n}\nasync function* streamTarEntries(source, onSkip) {\n  let carry = new Uint8Array(0);\n  let state = { kind: \"header\" };\n  function concat(a, b) {\n    if (a.length === 0) return b;\n    if (b.length === 0) return a;\n    const out = new Uint8Array(a.length + b.length);\n    out.set(a, 0);\n    out.set(b, a.length);\n    return out;\n  }\n  for await (const chunkRaw of source) {\n    let buf = concat(carry, chunkRaw);\n    let cursor = 0;\n    while (true) {\n      if (state.kind === \"header\") {\n        if (buf.length - cursor < 512) break;\n        const header = buf.subarray(cursor, cursor + 512);\n        const parsed = parseTarHeader(header);\n        cursor += 512;\n        if (!parsed) return;\n        const { name, size, typeFlag } = parsed;\n        const pad = size === 0 ? 0 : (512 - size % 512) % 512;\n        const isRegularFile = typeFlag === 48 || typeFlag === 0;\n        if (size === 0) {\n          if (isRegularFile && name) {\n            yield { name, data: new Uint8Array(0) };\n          }\n          state = { kind: \"header\" };\n          continue;\n        }\n        if (!isRegularFile || !name || size > MAX_FILE_BYTES) {\n          if (onSkip) {\n            const reason = !isRegularFile ? \"non-regular\" : !name ? \"no-name\" : \"too-large\";\n            try {\n              onSkip(name, size, reason);\n            } catch {\n            }\n          }\n          state = { kind: \"skip\", remaining: size + pad };\n          continue;\n        }\n        state = {\n          kind: \"file\",\n          name,\n          remaining: size,\n          fileBuf: new Uint8Array(size),\n          fileOffset: 0,\n          pad,\n          skip: false\n        };\n        continue;\n      }\n      if (state.kind === \"file\") {\n        const avail2 = buf.length - cursor;\n        if (avail2 === 0) break;\n        if (state.remaining > 0) {\n          const take2 = Math.min(state.remaining, avail2);\n          state.fileBuf.set(buf.subarray(cursor, cursor + take2), state.fileOffset);\n          state.fileOffset += take2;\n          state.remaining -= take2;\n          cursor += take2;\n          if (state.remaining > 0) break;\n        }\n        if (state.pad > 0) {\n          const avail22 = buf.length - cursor;\n          if (avail22 === 0) break;\n          const take2 = Math.min(state.pad, avail22);\n          state.pad -= take2;\n          cursor += take2;\n          if (state.pad > 0) break;\n        }\n        yield { name: state.name, data: state.fileBuf };\n        state = { kind: \"header\" };\n        continue;\n      }\n      const avail = buf.length - cursor;\n      if (avail === 0) break;\n      const take = Math.min(state.remaining, avail);\n      cursor += take;\n      state.remaining -= take;\n      if (state.remaining > 0) break;\n      state = { kind: \"header\" };\n    }\n    if (cursor >= buf.length) {\n      carry = new Uint8Array(0);\n    } else if (cursor === 0) {\n      carry = buf;\n    } else {\n      carry = buf.slice(cursor);\n    }\n  }\n}";
+export const TAR_STREAM_PREAMBLE = "// ../core/src/_shared/tarball-stream.ts\nvar MAX_FILE_BYTES = 2e7;\nfunction canonicalTarName(name) {\n  const out = [];\n  for (const seg of name.split(\"/\")) {\n    if (seg === \"..\") {\n      if (out.length === 0) return \"\";\n      out.pop();\n    } else if (seg !== \"\" && seg !== \".\") {\n      out.push(seg);\n    }\n  }\n  return out.join(\"/\");\n}\nfunction parseTarHeader(block) {\n  if (block[0] === 0) return null;\n  let name = \"\";\n  for (let i = 0; i < 100 && block[i] !== 0; i++) {\n    name += String.fromCharCode(block[i]);\n  }\n  let prefix = \"\";\n  for (let i = 345; i < 500 && block[i] !== 0; i++) {\n    prefix += String.fromCharCode(block[i]);\n  }\n  if (prefix) name = prefix + \"/\" + name;\n  name = name.replace(/^package\\//, \"\");\n  name = canonicalTarName(name);\n  let sizeStr = \"\";\n  for (let i = 124; i < 136 && block[i] !== 0; i++) {\n    sizeStr += String.fromCharCode(block[i]);\n  }\n  const size = parseInt(sizeStr.trim(), 8) || 0;\n  const typeFlag = block[156];\n  return { name, size, typeFlag };\n}\nasync function* readableStreamToAsyncIterable(rs) {\n  const reader = rs.getReader();\n  try {\n    while (true) {\n      const { value, done } = await reader.read();\n      if (done) return;\n      if (value && value.length > 0) yield value;\n    }\n  } finally {\n    try {\n      reader.releaseLock();\n    } catch {\n    }\n  }\n}\nasync function* streamTarEntries(source, onSkip) {\n  let carry = new Uint8Array(0);\n  let state = { kind: \"header\" };\n  function concat(a, b) {\n    if (a.length === 0) return b;\n    if (b.length === 0) return a;\n    const out = new Uint8Array(a.length + b.length);\n    out.set(a, 0);\n    out.set(b, a.length);\n    return out;\n  }\n  for await (const chunkRaw of source) {\n    let buf = concat(carry, chunkRaw);\n    let cursor = 0;\n    while (true) {\n      if (state.kind === \"header\") {\n        if (buf.length - cursor < 512) break;\n        const header = buf.subarray(cursor, cursor + 512);\n        const parsed = parseTarHeader(header);\n        cursor += 512;\n        if (!parsed) return;\n        const { name, size, typeFlag } = parsed;\n        const pad = size === 0 ? 0 : (512 - size % 512) % 512;\n        const isRegularFile = typeFlag === 48 || typeFlag === 0;\n        if (size === 0) {\n          if (isRegularFile && name) {\n            yield { name, data: new Uint8Array(0) };\n          }\n          state = { kind: \"header\" };\n          continue;\n        }\n        if (!isRegularFile || !name || size > MAX_FILE_BYTES) {\n          if (onSkip) {\n            const reason = !isRegularFile ? \"non-regular\" : !name ? \"no-name\" : \"too-large\";\n            try {\n              onSkip(name, size, reason);\n            } catch {\n            }\n          }\n          state = { kind: \"skip\", remaining: size + pad };\n          continue;\n        }\n        state = {\n          kind: \"file\",\n          name,\n          remaining: size,\n          fileBuf: new Uint8Array(size),\n          fileOffset: 0,\n          pad,\n          skip: false\n        };\n        continue;\n      }\n      if (state.kind === \"file\") {\n        const avail2 = buf.length - cursor;\n        if (avail2 === 0) break;\n        if (state.remaining > 0) {\n          const take2 = Math.min(state.remaining, avail2);\n          state.fileBuf.set(buf.subarray(cursor, cursor + take2), state.fileOffset);\n          state.fileOffset += take2;\n          state.remaining -= take2;\n          cursor += take2;\n          if (state.remaining > 0) break;\n        }\n        if (state.pad > 0) {\n          const avail22 = buf.length - cursor;\n          if (avail22 === 0) break;\n          const take2 = Math.min(state.pad, avail22);\n          state.pad -= take2;\n          cursor += take2;\n          if (state.pad > 0) break;\n        }\n        yield { name: state.name, data: state.fileBuf };\n        state = { kind: \"header\" };\n        continue;\n      }\n      const avail = buf.length - cursor;\n      if (avail === 0) break;\n      const take = Math.min(state.remaining, avail);\n      cursor += take;\n      state.remaining -= take;\n      if (state.remaining > 0) break;\n      state = { kind: \"header\" };\n    }\n    if (cursor >= buf.length) {\n      carry = new Uint8Array(0);\n    } else if (cursor === 0) {\n      carry = buf;\n    } else {\n      carry = buf.slice(cursor);\n    }\n  }\n}";
 export const W7_FRAME_PREAMBLE = "// ../core/src/constants.ts\nvar CHUNK_SIZE = 65536;\nvar VFS_CAPACITY = 10 * 1024 * 1024 * 1024;\nvar MAX_TX_BLOB_BYTES = 1 * 1024 * 1024;\nvar MAX_GLOBAL_WRITE_STREAM_CREDIT_BYTES = 8 * 1024 * 1024;\nvar MAX_RPC_SAFE_PAYLOAD_BYTES = 28 * 1024 * 1024;\nvar FS_READ_BATCH_REQUEST_BYTES = 4 * 1024 * 1024;\nvar VFS_BUNDLE_MAX_BYTES = 24 * 1024 * 1024;\nvar BUNDLE_MAX_ENCODED_BYTES = 22 * 1024 * 1024;\nvar PREFETCH_CACHE_MAX_BYTES = 16 * 1024 * 1024;\nvar CWD_SNAPSHOT_MAX_FILE_BYTES = 2 * 1024 * 1024;\nvar SUPERVISOR_HEAP_CEILING_BYTES = 64 * 1024 * 1024;\nvar SUPERVISOR_IN_FLIGHT_ALLOCATION_BUDGET_BYTES = 40 * 1024 * 1024;\nvar SUPERVISOR_READ_RESERVE_BYTES = 1024 * 1024;\n\n// ../core/src/_shared/w7-frame.ts\nvar W7_MAGIC = new Uint8Array([78, 87, 55, 3]);\nvar ENCODER_QUEUE_HWM = 0;\nvar MAX_METADATA_BYTES = 64 * 1024;\nvar MAX_PATH_BYTES = 64 * 1024;\nvar MAX_BATCH_ID_BYTES = 128;\nvar MAX_CONTENT_ID_BYTES = 256;\nvar W7_MAX_PATHS_PER_BATCH = 128;\nvar W7_MAX_OWNED_PATH_BYTES = 64 * 1024;\nvar W7_MAX_RECORD_BYTES = 5 + 4 + MAX_CONTENT_ID_BYTES + 8 + CHUNK_SIZE;\nvar MODE = \"path-atomic-committed-prefix\";\nfunction encodeWriteBatchStream(payload) {\n  const batchId = crypto.randomUUID();\n  const { deletes, directories, files } = preparePayload(payload, batchId);\n  const iterator = encodeRecords(batchId, deletes, directories, files);\n  let closed = false;\n  let magicEmitted = false;\n  const source = {\n    type: \"bytes\",\n    pull(controller) {\n      if (closed) return;\n      try {\n        if (!magicEmitted) {\n          magicEmitted = true;\n          controller.enqueue(W7_MAGIC.slice());\n          return;\n        }\n        const next = iterator.next();\n        if (next.done) {\n          closed = true;\n          controller.close();\n          return;\n        }\n        for (const part of next.value) controller.enqueue(part);\n      } catch (error) {\n        closed = true;\n        controller.error(error);\n      }\n    },\n    cancel() {\n      closed = true;\n      iterator.return?.(void 0);\n    }\n  };\n  return new ReadableStream(source, {\n    highWaterMark: ENCODER_QUEUE_HWM\n  });\n}\nasync function decodeWriteBatchStream(stream, options = {}) {\n  let reader;\n  try {\n    reader = stream.getReader({ mode: \"byob\" });\n  } catch {\n    throw new Error(\"w7-frame: stream must be a byte-oriented ReadableStream\");\n  }\n  const buffer = new ExactByteReader(reader);\n  let handedOff = false;\n  try {\n    throwIfAborted(options.signal);\n    const magic = await buffer.readExact(W7_MAGIC.length, \"magic\");\n    if (!bytesEqual(magic, W7_MAGIC)) {\n      const version = magic.length === 4 && magic[0] === 78 && magic[1] === 87 && magic[2] === 55 ? magic[3] : null;\n      if (version !== null) {\n        throw new Error(`w7-frame: unsupported protocol version ${version}; expected 3`);\n      }\n      throw new Error(`w7-frame: bad magic, expected NW7\\\\x03, got ${hex(magic)}`);\n    }\n    const beginEnvelope = await readEnvelope(buffer, \"batch-begin\");\n    if (beginEnvelope.tag !== 1 /* BatchBegin */) {\n      throw new Error(`w7-frame: first record must be batch-begin, got tag ${beginEnvelope.tag}`);\n    }\n    if (beginEnvelope.length > MAX_METADATA_BYTES) {\n      throw new Error(\n        `w7-frame: batch-begin length ${beginEnvelope.length} exceeds ${MAX_METADATA_BYTES}`\n      );\n    }\n    const beginPayload = await buffer.readExact(beginEnvelope.length, \"batch-begin payload\");\n    const begin = parseBatchBegin(beginPayload);\n    const initialCheck = updateRecordCheck(CRC_SEED, beginEnvelope.header, beginPayload);\n    handedOff = true;\n    return {\n      batchId: begin.id,\n      mode: begin.mode,\n      records: decodeRecords(stream, reader, buffer, options, initialCheck)\n    };\n  } catch (error) {\n    if (!handedOff) await cancelReader(reader, error);\n    throw error;\n  }\n}\nasync function* decodeRecords(stream, reader, buffer, options, initialCheck) {\n  const ownedPaths = new PathOwnership();\n  const contentIds = /* @__PURE__ */ new Set();\n  let active = null;\n  let batchCheck = initialCheck;\n  const summary = {\n    recordCount: 1,\n    pathCount: 0,\n    deleteCount: 0,\n    directoryCount: 0,\n    fileCount: 0,\n    chunkCount: 0,\n    byteCount: 0\n  };\n  let completed = false;\n  let failure = new DOMException(\"W7 consumer cancelled\", \"AbortError\");\n  try {\n    while (true) {\n      throwIfAborted(options.signal);\n      const envelope = await readEnvelope(buffer, \"record\");\n      if (active && envelope.tag !== 5 /* FileChunk */ && envelope.tag !== 6 /* FileEnd */) {\n        throw new Error(`w7-frame: file ${active.inode.path} ended without file-end`);\n      }\n      if (envelope.tag === 5 /* FileChunk */) {\n        if (!active) throw new Error(\"w7-frame: file-chunk without active file\");\n        const prefixLength = Math.min(envelope.length, 4 + MAX_CONTENT_ID_BYTES + 8);\n        const idLengthBytes = await buffer.readExact(4, \"file-chunk content-id length\");\n        const idLength = readU32LE(idLengthBytes, 0);\n        if (idLength === 0 || idLength > MAX_CONTENT_ID_BYTES) {\n          throw new Error(`w7-frame: invalid file-chunk content-id length ${idLength}`);\n        }\n        const remainingPrefixLength = idLength + 8;\n        if (4 + remainingPrefixLength > prefixLength || 4 + remainingPrefixLength > envelope.length) {\n          throw new Error(\"w7-frame: malformed file-chunk record length\");\n        }\n        const rest = await buffer.readExact(remainingPrefixLength, \"file-chunk header\");\n        const contentId = decodeText(rest.subarray(0, idLength), \"file-chunk content id\");\n        const chunkId = readU32LE(rest, idLength);\n        const dataLength = readU32LE(rest, idLength + 4);\n        if (envelope.length !== 4 + idLength + 8 + dataLength) {\n          throw new Error(\"w7-frame: file-chunk payload length mismatch\");\n        }\n        if (contentId !== active.metadata.contentId) {\n          throw new Error(`w7-frame: file-chunk content id ${contentId} does not own ${active.inode.path}`);\n        }\n        if (chunkId !== active.nextChunkId) {\n          throw new Error(\n            `w7-frame: ${active.inode.path}: expected chunk ${active.nextChunkId}, got ${chunkId}`\n          );\n        }\n        if (chunkId >= active.inode.chunkCount) {\n          throw new Error(`w7-frame: ${active.inode.path}: chunk ${chunkId} is out of range`);\n        }\n        const expectedBytes = Math.min(\n          CHUNK_SIZE,\n          active.inode.size - chunkId * CHUNK_SIZE\n        );\n        if (dataLength !== expectedBytes || dataLength > CHUNK_SIZE) {\n          throw new Error(\n            `w7-frame: ${active.inode.path}: chunk ${chunkId} has ${dataLength} bytes; expected ${expectedBytes}`\n          );\n        }\n        const headerPayload = concatBytes(idLengthBytes, rest);\n        let retention = null;\n        try {\n          retention = options.retainChunk ? await options.retainChunk(dataLength, options.signal) : noopRetention(dataLength);\n          throwIfAborted(options.signal);\n          const data = await buffer.readExact(dataLength, \"file-chunk data\");\n          batchCheck = updateRecordCheck(batchCheck, envelope.header, headerPayload, data);\n          active.check = crc32Update(active.check, data);\n          active.nextChunkId++;\n          active.receivedBytes += dataLength;\n          summary.recordCount++;\n          summary.chunkCount++;\n          summary.byteCount += dataLength;\n          const record = {\n            type: \"file-chunk\",\n            streamContentId: contentId,\n            path: active.inode.path,\n            chunkId,\n            data,\n            retention\n          };\n          retention = null;\n          yield record;\n        } finally {\n          retention?.release();\n        }\n        continue;\n      }\n      if (envelope.length > MAX_METADATA_BYTES) {\n        throw new Error(`w7-frame: metadata record length ${envelope.length} exceeds ${MAX_METADATA_BYTES}`);\n      }\n      const payload = await buffer.readExact(envelope.length, \"record payload\");\n      if (envelope.tag !== 7 /* BatchEnd */) {\n        batchCheck = updateRecordCheck(batchCheck, envelope.header, payload);\n        summary.recordCount++;\n      }\n      switch (envelope.tag) {\n        case 2 /* Delete */: {\n          const metadata = parseDelete(payload);\n          claimPath(ownedPaths, metadata.path);\n          summary.pathCount++;\n          summary.deleteCount++;\n          yield { type: \"delete\", path: metadata.path };\n          break;\n        }\n        case 3 /* Directory */: {\n          const metadata = parseDirectory(payload);\n          claimPath(ownedPaths, metadata.path);\n          summary.pathCount++;\n          summary.directoryCount++;\n          yield { type: \"directory\", inode: directoryInode(metadata) };\n          break;\n        }\n        case 4 /* FileBegin */: {\n          const metadata = parseFileBegin(payload);\n          claimPath(ownedPaths, metadata.path);\n          if (contentIds.has(metadata.contentId)) {\n            throw new Error(`w7-frame: duplicate stream content id ${metadata.contentId}`);\n          }\n          contentIds.add(metadata.contentId);\n          const inode = fileInode(metadata);\n          summary.pathCount++;\n          summary.fileCount++;\n          active = {\n            metadata,\n            inode,\n            nextChunkId: 0,\n            receivedBytes: 0,\n            check: CRC_SEED\n          };\n          yield { type: \"file-begin\", streamContentId: metadata.contentId, inode };\n          break;\n        }\n        case 6 /* FileEnd */: {\n          if (!active) throw new Error(\"w7-frame: file-end without active file\");\n          const metadata = parseFileEnd(payload);\n          const actualCheck = crc32Finish(active.check);\n          if (metadata.contentId !== active.metadata.contentId) {\n            throw new Error(`w7-frame: file-end content id mismatch for ${active.inode.path}`);\n          }\n          if (metadata.size !== active.receivedBytes || metadata.size !== active.inode.size) {\n            throw new Error(`w7-frame: file-end byte total mismatch for ${active.inode.path}`);\n          }\n          if (metadata.chunkCount !== active.nextChunkId || metadata.chunkCount !== active.inode.chunkCount) {\n            throw new Error(`w7-frame: file-end chunk count mismatch for ${active.inode.path}`);\n          }\n          if (metadata.check !== actualCheck) {\n            throw new Error(`w7-frame: file-end check mismatch for ${active.inode.path}`);\n          }\n          const record = {\n            type: \"file-end\",\n            streamContentId: metadata.contentId,\n            path: active.inode.path,\n            size: metadata.size,\n            chunkCount: metadata.chunkCount,\n            check: metadata.check\n          };\n          active = null;\n          yield record;\n          break;\n        }\n        case 7 /* BatchEnd */: {\n          if (active) throw new Error(`w7-frame: batch-end while file ${active.inode.path} is active`);\n          const actual = parseBatchEnd(payload);\n          const expected = { ...summary, check: crc32Finish(batchCheck) };\n          if (!sameSummary(actual, expected)) {\n            throw new Error(\n              `w7-frame: batch-end summary mismatch; expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`\n            );\n          }\n          await buffer.ensureEof(stream);\n          completed = true;\n          yield { type: \"batch-end\", summary: actual };\n          return;\n        }\n        case 1 /* BatchBegin */:\n          throw new Error(\"w7-frame: duplicate batch-begin\");\n        default:\n          throw new Error(`w7-frame: unknown record tag ${envelope.tag}`);\n      }\n    }\n  } catch (error) {\n    failure = error;\n    throw error;\n  } finally {\n    if (completed) {\n      try {\n        reader.releaseLock();\n      } catch {\n      }\n    } else {\n      await cancelReader(reader, failure);\n    }\n  }\n}\nfunction* encodeRecords(batchId, deletes, directories, files) {\n  const state = {\n    batchCheck: CRC_SEED,\n    summary: {\n      recordCount: 0,\n      pathCount: 0,\n      deleteCount: 0,\n      directoryCount: 0,\n      fileCount: 0,\n      chunkCount: 0,\n      byteCount: 0\n    }\n  };\n  yield encodeMetadataRecord(1 /* BatchBegin */, { id: batchId, mode: MODE }, state);\n  for (const path of deletes) {\n    state.summary.pathCount++;\n    state.summary.deleteCount++;\n    yield encodeMetadataRecord(2 /* Delete */, { path }, state);\n  }\n  for (const inode of directories) {\n    state.summary.pathCount++;\n    state.summary.directoryCount++;\n    yield encodeMetadataRecord(3 /* Directory */, {\n      ...inodeMetadata(inode),\n      kind: inode.kind\n    }, state);\n  }\n  for (const file of files) {\n    state.summary.pathCount++;\n    state.summary.fileCount++;\n    yield encodeMetadataRecord(4 /* FileBegin */, {\n      ...inodeMetadata(file.inode),\n      kind: file.inode.kind,\n      contentId: file.contentId,\n      size: file.inode.size,\n      chunkCount: file.inode.chunkCount\n    }, state);\n    let fileCheck = CRC_SEED;\n    for (const chunk of file.chunks) {\n      const data = chunk.data;\n      const contentBytes = new TextEncoder().encode(file.contentId);\n      const prefix = new Uint8Array(4 + contentBytes.length + 8);\n      writeU32LE(prefix, 0, contentBytes.length);\n      prefix.set(contentBytes, 4);\n      writeU32LE(prefix, 4 + contentBytes.length, chunk.chunkId);\n      writeU32LE(prefix, 8 + contentBytes.length, data.byteLength);\n      const header = recordHeader(5 /* FileChunk */, prefix.byteLength + data.byteLength);\n      state.batchCheck = updateRecordCheck(state.batchCheck, header, prefix, data);\n      state.summary.recordCount++;\n      state.summary.chunkCount++;\n      state.summary.byteCount += data.byteLength;\n      fileCheck = crc32Update(fileCheck, data);\n      yield [concatBytes(header, prefix), data];\n    }\n    yield encodeMetadataRecord(6 /* FileEnd */, {\n      contentId: file.contentId,\n      size: file.inode.size,\n      chunkCount: file.inode.chunkCount,\n      check: crc32Finish(fileCheck)\n    }, state);\n  }\n  const end = {\n    ...state.summary,\n    check: crc32Finish(state.batchCheck)\n  };\n  yield encodeMetadataRecord(7 /* BatchEnd */, end);\n}\nfunction encodeMetadataRecord(tag, value, state) {\n  const payload = new TextEncoder().encode(JSON.stringify(value));\n  if (payload.byteLength > MAX_METADATA_BYTES) {\n    throw new Error(`w7-frame: metadata record exceeds ${MAX_METADATA_BYTES} bytes`);\n  }\n  const header = recordHeader(tag, payload.byteLength);\n  if (state && tag !== 7 /* BatchEnd */) {\n    state.batchCheck = updateRecordCheck(state.batchCheck, header, payload);\n    state.summary.recordCount++;\n  }\n  return [concatBytes(header, payload)];\n}\nfunction preparePayload(payload, batchId) {\n  if (!payload || !Array.isArray(payload.inodes) || !Array.isArray(payload.chunks)) {\n    throw new Error(\"w7-frame: payload must contain inode and chunk arrays\");\n  }\n  const ownedPaths = new PathOwnership();\n  const deletes = [...payload.deletePaths ?? []];\n  for (const path of deletes) claimPath(ownedPaths, canonicalPath(path, \"delete path\"));\n  const chunksByPath = /* @__PURE__ */ new Map();\n  for (const chunk of payload.chunks) {\n    const path = canonicalPath(chunk.path, \"chunk path\");\n    const list = chunksByPath.get(path);\n    if (list) list.push(chunk);\n    else chunksByPath.set(path, [chunk]);\n  }\n  const directories = [];\n  const files = [];\n  let fileIndex = 0;\n  for (const inode of payload.inodes) {\n    const path = canonicalPath(inode.path, \"inode path\");\n    if (path !== inode.path) throw new Error(`w7-frame: noncanonical inode path ${inode.path}`);\n    claimPath(ownedPaths, path);\n    const normalizedInode = normalizeInode(inode);\n    const fileChunks = chunksByPath.get(path) ?? [];\n    if (normalizedInode.kind === \"directory\") {\n      if (fileChunks.length > 0) throw new Error(`w7-frame: directory ${path} has chunks`);\n      directories.push(normalizedInode);\n    } else {\n      validateChunks(normalizedInode, fileChunks);\n      files.push({\n        inode: normalizedInode,\n        contentId: `${batchId}:${fileIndex++}`,\n        chunks: fileChunks\n      });\n    }\n    chunksByPath.delete(path);\n  }\n  if (chunksByPath.size > 0) {\n    throw new Error(`w7-frame: chunk has no inode: ${chunksByPath.keys().next().value}`);\n  }\n  return { deletes, directories, files };\n}\nfunction parseBatchBegin(bytes) {\n  const value = parseObject(bytes, \"batch-begin\", [\"id\", \"mode\"]);\n  const id = boundedString(value.id, \"batch id\", MAX_BATCH_ID_BYTES);\n  if (value.mode !== MODE) throw new Error(`w7-frame: unsupported batch mode ${String(value.mode)}`);\n  return { id, mode: MODE };\n}\nfunction parseDelete(bytes) {\n  const value = parseObject(bytes, \"delete\", [\"path\"]);\n  return { path: canonicalPath(value.path, \"delete path\") };\n}\nfunction parseDirectory(bytes) {\n  const value = parseObject(bytes, \"directory\", [\"path\", \"kind\", \"mtime\", \"mode\"], [\"atime\"]);\n  if (value.kind !== \"directory\") {\n    throw new Error(`w7-frame: unsupported directory kind ${String(value.kind)}`);\n  }\n  return { ...parseInodeMetadata(value, \"directory\"), kind: \"directory\" };\n}\nfunction parseFileBegin(bytes) {\n  const value = parseObject(\n    bytes,\n    \"file-begin\",\n    [\"path\", \"kind\", \"contentId\", \"size\", \"chunkCount\", \"mtime\", \"mode\"],\n    [\"atime\"]\n  );\n  const base = parseInodeMetadata(value, \"file-begin\");\n  if (value.kind !== \"file\" && value.kind !== \"symlink\") {\n    throw new Error(`w7-frame: unsupported file-begin kind ${String(value.kind)}`);\n  }\n  const contentId = boundedString(value.contentId, \"stream content id\", MAX_CONTENT_ID_BYTES);\n  if (!/^[A-Za-z0-9._:-]+$/.test(contentId)) {\n    throw new Error(`w7-frame: invalid stream content id ${contentId}`);\n  }\n  const size = safeInteger(value.size, \"file size\");\n  const chunkCount = u32(value.chunkCount, \"file chunk count\");\n  const expected = size === 0 ? 0 : Math.ceil(size / CHUNK_SIZE);\n  if (chunkCount !== expected) {\n    throw new Error(`w7-frame: ${base.path}: expected ${expected} chunks, got ${chunkCount}`);\n  }\n  return { ...base, kind: value.kind, contentId, size, chunkCount };\n}\nfunction parseFileEnd(bytes) {\n  const value = parseObject(bytes, \"file-end\", [\"contentId\", \"size\", \"chunkCount\", \"check\"]);\n  return {\n    contentId: boundedString(value.contentId, \"stream content id\", MAX_CONTENT_ID_BYTES),\n    size: safeInteger(value.size, \"file-end size\"),\n    chunkCount: u32(value.chunkCount, \"file-end chunk count\"),\n    check: u32(value.check, \"file-end check\")\n  };\n}\nfunction parseBatchEnd(bytes) {\n  const keys = [\n    \"recordCount\",\n    \"pathCount\",\n    \"deleteCount\",\n    \"directoryCount\",\n    \"fileCount\",\n    \"chunkCount\",\n    \"byteCount\",\n    \"check\"\n  ];\n  const value = parseObject(bytes, \"batch-end\", keys);\n  return {\n    recordCount: safeInteger(value.recordCount, \"batch record count\"),\n    pathCount: safeInteger(value.pathCount, \"batch path count\"),\n    deleteCount: safeInteger(value.deleteCount, \"batch delete count\"),\n    directoryCount: safeInteger(value.directoryCount, \"batch directory count\"),\n    fileCount: safeInteger(value.fileCount, \"batch file count\"),\n    chunkCount: safeInteger(value.chunkCount, \"batch chunk count\"),\n    byteCount: safeInteger(value.byteCount, \"batch byte count\"),\n    check: u32(value.check, \"batch check\")\n  };\n}\nfunction parseInodeMetadata(value, label) {\n  return {\n    path: canonicalPath(value.path, `${label} path`),\n    ...value.atime === void 0 ? {} : { atime: safeInteger(value.atime, `${label} atime`) },\n    mtime: safeInteger(value.mtime, `${label} mtime`),\n    mode: u32(value.mode, `${label} mode`)\n  };\n}\nfunction parseObject(bytes, label, required, optional = []) {\n  let value;\n  try {\n    value = JSON.parse(decodeText(bytes, label));\n  } catch (error) {\n    if (error instanceof Error && error.message.startsWith(\"w7-frame:\")) throw error;\n    throw new Error(`w7-frame: invalid ${label} JSON: ${errorMessage(error)}`);\n  }\n  if (!isObject(value) || Array.isArray(value)) throw new Error(`w7-frame: ${label} must be an object`);\n  const allowed = /* @__PURE__ */ new Set([...required, ...optional]);\n  for (const key of required) {\n    if (!Object.hasOwn(value, key)) throw new Error(`w7-frame: ${label} missing ${key}`);\n  }\n  for (const key of Object.keys(value)) {\n    if (!allowed.has(key)) throw new Error(`w7-frame: ${label} has unknown field ${key}`);\n  }\n  return value;\n}\nfunction normalizeInode(inode) {\n  canonicalPath(inode.path, \"inode path\");\n  if (inode.parentPath !== parentPath(inode.path)) {\n    throw new Error(`w7-frame: ${inode.path}: noncanonical parent path ${inode.parentPath}`);\n  }\n  safeInteger(inode.size, `${inode.path} size`);\n  u32(inode.chunkCount, `${inode.path} chunk count`);\n  safeInteger(inode.mtime, `${inode.path} mtime`);\n  if (inode.atime !== void 0) safeInteger(inode.atime, `${inode.path} atime`);\n  u32(inode.mode, `${inode.path} mode`);\n  const rawKind = inode.kind ?? (inode.isDir ? \"directory\" : \"file\");\n  if (rawKind !== \"file\" && rawKind !== \"directory\" && rawKind !== \"symlink\") {\n    throw new Error(`w7-frame: unsupported inode kind ${String(rawKind)}`);\n  }\n  const kind = rawKind;\n  if (kind === \"directory\" && !inode.isDir) {\n    throw new Error(`w7-frame: directory inode ${inode.path} must be a directory`);\n  }\n  if (kind !== \"directory\" && inode.isDir) {\n    throw new Error(`w7-frame: ${kind} inode ${inode.path} cannot be a directory`);\n  }\n  if (kind === \"directory\" && (inode.size !== 0 || inode.chunkCount !== 0)) {\n    throw new Error(`w7-frame: directory ${inode.path} must have zero size and chunks`);\n  }\n  if (kind !== \"directory\") {\n    const expected = inode.size === 0 ? 0 : Math.ceil(inode.size / CHUNK_SIZE);\n    if (inode.chunkCount !== expected) {\n      throw new Error(`w7-frame: ${inode.path}: expected ${expected} chunks, got ${inode.chunkCount}`);\n    }\n    return { ...inode, kind, isDir: false };\n  }\n  return { ...inode, kind, isDir: true };\n}\nfunction validateChunks(inode, chunks) {\n  if (chunks.length !== inode.chunkCount) {\n    throw new Error(`w7-frame: ${inode.path}: expected ${inode.chunkCount} chunks, got ${chunks.length}`);\n  }\n  chunks.sort((left, right) => left.chunkId - right.chunkId);\n  for (let index = 0; index < chunks.length; index++) {\n    const chunk = chunks[index];\n    if (chunk.chunkId !== index) {\n      throw new Error(`w7-frame: ${inode.path}: expected chunk ${index}, got ${chunk.chunkId}`);\n    }\n    const expected = Math.min(CHUNK_SIZE, inode.size - index * CHUNK_SIZE);\n    if (!(chunk.data instanceof Uint8Array) || chunk.data.byteLength !== expected) {\n      throw new Error(`w7-frame: ${inode.path}: chunk ${index} must contain ${expected} bytes`);\n    }\n  }\n}\nfunction directoryInode(metadata) {\n  return {\n    path: metadata.path,\n    parentPath: parentPath(metadata.path),\n    kind: metadata.kind,\n    isDir: true,\n    size: 0,\n    atime: metadata.atime,\n    mtime: metadata.mtime,\n    mode: metadata.mode,\n    chunkCount: 0\n  };\n}\nfunction fileInode(metadata) {\n  return {\n    path: metadata.path,\n    parentPath: parentPath(metadata.path),\n    kind: metadata.kind,\n    isDir: false,\n    size: metadata.size,\n    atime: metadata.atime,\n    mtime: metadata.mtime,\n    mode: metadata.mode,\n    chunkCount: metadata.chunkCount\n  };\n}\nfunction inodeMetadata(inode) {\n  return {\n    path: inode.path,\n    ...inode.atime === void 0 ? {} : { atime: inode.atime },\n    mtime: inode.mtime,\n    mode: inode.mode\n  };\n}\nfunction canonicalPath(value, label) {\n  const path = boundedString(value, label, MAX_PATH_BYTES);\n  if (path.includes(\"\\0\")) throw new Error(`w7-frame: ${label} contains NUL`);\n  const normalized = normalizePath(path);\n  if (!path || normalized !== path) throw new Error(`w7-frame: noncanonical ${label}: ${path}`);\n  return path;\n}\nvar PathOwnership = class {\n  paths = /* @__PURE__ */ new Set();\n  pathBytes = 0;\n  claim(path) {\n    if (this.paths.has(path)) throw new Error(`w7-frame: duplicate path ownership: ${path}`);\n    if (this.paths.size >= W7_MAX_PATHS_PER_BATCH) {\n      throw new Error(`w7-frame: batch exceeds ${W7_MAX_PATHS_PER_BATCH} owned paths`);\n    }\n    const nextPathBytes = this.pathBytes + new TextEncoder().encode(path).byteLength;\n    if (nextPathBytes > W7_MAX_OWNED_PATH_BYTES) {\n      throw new Error(\n        `w7-frame: owned path bytes exceed ${W7_MAX_OWNED_PATH_BYTES}`\n      );\n    }\n    this.paths.add(path);\n    this.pathBytes = nextPathBytes;\n  }\n};\nfunction claimPath(paths, path) {\n  paths.claim(path);\n}\nfunction normalizePath(path) {\n  const out = [];\n  for (const segment of path.split(\"/\")) {\n    if (segment === \"..\") {\n      if (out.length > 0) out.pop();\n    } else if (segment !== \"\" && segment !== \".\") {\n      out.push(segment);\n    }\n  }\n  return out.join(\"/\");\n}\nfunction parentPath(path) {\n  const index = path.lastIndexOf(\"/\");\n  return index < 0 ? \"\" : path.slice(0, index);\n}\nfunction boundedString(value, label, maxBytes) {\n  if (typeof value !== \"string\" || value.length === 0) {\n    throw new Error(`w7-frame: ${label} must be a non-empty string`);\n  }\n  const length = new TextEncoder().encode(value).byteLength;\n  if (length > maxBytes) throw new Error(`w7-frame: ${label} exceeds ${maxBytes} bytes`);\n  return value;\n}\nfunction safeInteger(value, label) {\n  if (!Number.isSafeInteger(value) || value < 0) {\n    throw new Error(`w7-frame: ${label} must be a non-negative safe integer`);\n  }\n  return value;\n}\nfunction u32(value, label) {\n  const integer = safeInteger(value, label);\n  if (integer > 4294967295) throw new Error(`w7-frame: ${label} exceeds uint32`);\n  return integer;\n}\nfunction sameSummary(left, right) {\n  return left.recordCount === right.recordCount && left.pathCount === right.pathCount && left.deleteCount === right.deleteCount && left.directoryCount === right.directoryCount && left.fileCount === right.fileCount && left.chunkCount === right.chunkCount && left.byteCount === right.byteCount && left.check === right.check;\n}\nasync function readEnvelope(buffer, label) {\n  const header = await buffer.readExact(5, `${label} header`);\n  return { tag: header[0], length: readU32LE(header, 1), header };\n}\nfunction recordHeader(tag, length) {\n  const header = new Uint8Array(5);\n  header[0] = tag;\n  writeU32LE(header, 1, length);\n  return header;\n}\nfunction writeU32LE(out, offset, value) {\n  out[offset] = value & 255;\n  out[offset + 1] = value >>> 8 & 255;\n  out[offset + 2] = value >>> 16 & 255;\n  out[offset + 3] = value >>> 24 & 255;\n}\nfunction readU32LE(bytes, offset) {\n  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;\n}\nfunction updateRecordCheck(seed, ...parts) {\n  let check = seed;\n  for (const part of parts) check = crc32Update(check, part);\n  return check;\n}\nvar CRC_SEED = 4294967295;\nvar crcTable = null;\nfunction crc32Update(check, bytes) {\n  const table = crcTable ??= createCrcTable();\n  let value = check;\n  for (const byte of bytes) value = table[(value ^ byte) & 255] ^ value >>> 8;\n  return value >>> 0;\n}\nfunction crc32Finish(check) {\n  return (check ^ 4294967295) >>> 0;\n}\nfunction createCrcTable() {\n  const table = new Uint32Array(256);\n  for (let index = 0; index < table.length; index++) {\n    let value = index;\n    for (let bit = 0; bit < 8; bit++) {\n      value = (value & 1) !== 0 ? 3988292384 ^ value >>> 1 : value >>> 1;\n    }\n    table[index] = value >>> 0;\n  }\n  return table;\n}\nfunction noopRetention(bytes) {\n  return { bytes, release() {\n  } };\n}\nfunction decodeText(bytes, label) {\n  try {\n    return new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes);\n  } catch (error) {\n    throw new Error(`w7-frame: invalid UTF-8 in ${label}: ${errorMessage(error)}`);\n  }\n}\nfunction concatBytes(...parts) {\n  const output = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));\n  let offset = 0;\n  for (const part of parts) {\n    output.set(part, offset);\n    offset += part.byteLength;\n  }\n  return output;\n}\nfunction bytesEqual(left, right) {\n  return left.length === right.length && left.every((byte, index) => byte === right[index]);\n}\nfunction hex(bytes) {\n  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\")).join(\" \");\n}\nfunction isObject(value) {\n  return typeof value === \"object\" && value !== null;\n}\nfunction errorMessage(error) {\n  return error instanceof Error ? error.message : String(error);\n}\nfunction throwIfAborted(signal) {\n  if (!signal?.aborted) return;\n  throw new DOMException(\n    signal.reason instanceof Error ? signal.reason.message : String(signal.reason ?? \"Aborted\"),\n    \"AbortError\"\n  );\n}\nasync function cancelReader(reader, reason) {\n  try {\n    await reader.cancel(reason);\n  } catch {\n  }\n  try {\n    reader.releaseLock();\n  } catch {\n  }\n}\nvar ExactByteReader = class {\n  constructor(reader) {\n    this.reader = reader;\n  }\n  reader;\n  done = false;\n  async readExact(length, label) {\n    if (length === 0) return new Uint8Array(0);\n    const output = new Uint8Array(length);\n    let offset = 0;\n    while (offset < length) {\n      if (this.done) {\n        throw new Error(\n          `w7-frame: stream ended ${offset} bytes into expected ${length}-byte ${label}`\n        );\n      }\n      const next = await this.reader.read(new Uint8Array(length - offset));\n      if (next.done) this.done = true;\n      else if (next.value.byteLength > 0) {\n        output.set(next.value, offset);\n        offset += next.value.byteLength;\n      }\n    }\n    return output;\n  }\n  async ensureEof(stream) {\n    if (this.done) return;\n    this.reader.releaseLock();\n    const reader = stream.getReader();\n    try {\n      const next = await reader.read();\n      if (!next.done && next.value.byteLength > 0) {\n        await reader.cancel(new Error(\"w7-frame: trailing bytes after batch-end\"));\n        throw new Error(\"w7-frame: trailing bytes after batch-end\");\n      }\n      this.done = true;\n    } finally {\n      try {\n        reader.releaseLock();\n      } catch {\n      }\n    }\n  }\n};";

package/dist/runtime/bash-repl.d.ts

@@ -3,7 +3,7 @@ import type { WebSocketTerminal } from '../facets/ws-terminal.js';
 import type { SqliteVFS } from '@nimbus-sh/core/vfs/sqlite-vfs.js';
 import type { Shell } from '@nimbus-sh/core/substrate/lifo/shell/Shell.js';
 import type { VfsCred } from '@nimbus-sh/core/runtime/os-contracts.js';
-import type { RuntimeManifest } from './runtime-catalog.js';
+import type { RuntimeManifest } from '@nimbus-sh/core/runtime/runtime-manifest.js';
 export interface BashReplDeps {
     facetMgr: FacetManager;
     vfs: SqliteVFS;

package/dist/runtime/bash-repl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash-repl.d.ts","sourceRoot":"","sources":["../../src/runtime/bash-repl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,+CAA+C,CAAC;AAE3E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAS5D,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,YAAY,CAAC;IACvB,GAAG,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,eAAe,CAAC;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;CACpC;AA4JD,wBAAsB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAGrE"}
+{"version":3,"file":"bash-repl.d.ts","sourceRoot":"","sources":["../../src/runtime/bash-repl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,+CAA+C,CAAC;AAE3E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAUnF,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,YAAY,CAAC;IACvB,GAAG,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,eAAe,CAAC;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;CACpC;AA4JD,wBAAsB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAGrE"}

package/dist/runtime/bash-repl.js

@@ -1,5 +1,6 @@
 import { formatShellPrompt } from '@nimbus-sh/core/substrate/lifo/shell/Shell.js';
-import { createBashFacetSession } from './bash-runner.js';
+import { createBashFacetSession } from '@nimbus-sh/core/runtime/bash-runner.js';
+import { facetHostForManager } from './facet-loader-host.js';
 import { ReplSession, } from './repl-session.js';
 class BashReplAdapter {
     deps;
@@ -49,7 +50,7 @@ class BashReplAdapter {
         if (this.session)
             return null;
         this.session = await createBashFacetSession({
-            facetMgr: this.deps.facetMgr,
+            facets: facetHostForManager(this.deps.facetMgr),
             vfs: this.deps.vfs.as(this.deps.cred),
             manifest: this.deps.manifest,
             installRoot: this.deps.installRoot,

package/dist/runtime/cpython-resident.d.ts

@@ -0,0 +1,27 @@
+/**
+ * cpython-resident.ts — a Python program that keeps serving, as a Durable
+ * Object facet.
+ *
+ * The half of the CPython runtime that names workerd. Everything about running
+ * the interpreter is in `@nimbus-sh/core`; this is the substrate a program that
+ * outlives its invocation needs — an actor that stays alive between requests,
+ * with inbound HTTP routed into the socket the program bound. A host without
+ * one supplies no {@link CPythonResidentStart} and such a program is refused
+ * rather than quietly run as a one-shot that dies with the call.
+ */
+import { type CPythonResidentStart } from '@nimbus-sh/core/runtime/cpython-runner.js';
+import type { FacetManager } from '../facets/manager.js';
+/**
+ * The worker source for a resident Python process. Same shape as
+ * buildRubySocketProcessWorker: the socket kernel and the interpreter live in a
+ * DurableObject, startProcess runs the program until it stops, and inbound
+ * requests arrive on handleHttpRequest and are dispatched into the server the
+ * program registered before exiting.
+ */
+export declare function buildCPythonSocketProcessWorker(preamble: string): string;
+/**
+ * Start a program that binds a port as its own process, so it outlives the
+ * invocation that started it. Mirrors spawnRubySocketProcess.
+ */
+export declare function cpythonResidentStart(facetMgr: FacetManager): CPythonResidentStart;
+//# sourceMappingURL=cpython-resident.d.ts.map

package/dist/runtime/cpython-resident.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpython-resident.d.ts","sourceRoot":"","sources":["../../src/runtime/cpython-resident.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAwDxE;AAeD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,GAAG,oBAAoB,CA8CjF"}