@modelprofile.com/flexharness 11.1.1 → 11.3.0

package/dist_ts_chat_harness_server/classes.chatsubscription.js

@@ -9,6 +9,10 @@ const emptyPending = () => ({
     history: false,
     steers: [],
 });
+/** Resolves after the time; its timer keeps no process alive. */
+const delay = (msArg) => new Promise((resolve) => {
+    setTimeout(resolve, msArg).unref?.();
+});
 const hasPending = (pendingArg) => pendingArg.reset
     || pendingArg.rows
     || pendingArg.deltas.length > 0
@@ -19,8 +23,9 @@ const hasPending = (pendingArg) => pendingArg.reset
     || pendingArg.steers.length > 0;
 /**
  * One tab following one conversation. A `FlexHarnessTranscript` takes every event of the harness
- * instance; what changed reaches the tab as numbered updates, one at a time. A transcript that
- * loses track, or an update the tab does not acknowledge, makes the next update a `reset`.
+ * instance; what changed reaches the tab as numbered updates, one at a time and at most one per
+ * `minUpdateIntervalMs`. A transcript that loses track, or an update the tab does not acknowledge,
+ * makes the next update a `reset`.
  */
 export class FlexHarnessChatSubscription {
     id;
@@ -40,6 +45,8 @@ export class FlexHarnessChatSubscription {
     sentRows = new Map();
     pending = emptyPending();
     sending = false;
+    /** when the last update was taken to be sent, by `performance.now()` */
+    lastUpdateAt = Number.NEGATIVE_INFINITY;
     closed = false;
     constructor(optionsArg) {
         this.id = optionsArg.id;
@@ -142,7 +149,7 @@ export class FlexHarnessChatSubscription {
             this.closeSelf();
         }
     }
-    /** Sends what is pending, one update at a time, in seq order. */
+    /** Sends what is pending, one update at a time, in seq order, `minUpdateIntervalMs` apart. */
     async pump() {
         if (this.sending)
             return;
@@ -150,6 +157,12 @@ export class FlexHarnessChatSubscription {
         let inFlight = null;
         try {
             while (!this.closed && this.state === 'live' && hasPending(this.pending)) {
+                const wait = this.lastUpdateAt + this.limits.minUpdateIntervalMs - performance.now();
+                if (wait > 0) {
+                    // what changes meanwhile goes into this update
+                    await delay(wait);
+                    continue;
+                }
                 const peer = await this.peers.find(this.tab);
                 if (!peer) {
                     this.closeSelf();
@@ -158,6 +171,7 @@ export class FlexHarnessChatSubscription {
                 if (this.closed || this.state !== 'live')
                     return;
                 inFlight = await this.takeUpdate();
+                this.lastUpdateAt = performance.now();
                 await peer.update(inFlight);
                 inFlight = null;
             }
@@ -233,4 +247,4 @@ export class FlexHarnessChatSubscription {
         this.onClosed(this);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.chatsubscription.js","sourceRoot":"","sources":["../ts_chat_harness_server/classes.chatsubscription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAiBxC,MAAM,YAAY,GAAG,GAAmB,EAAE,CAAC,CAAC;IAC1C,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,KAAK;IACX,MAAM,EAAE,EAAE;IACV,MAAM,EAAE,KAAK;IACb,KAAK,EAAE,KAAK;IACZ,WAAW,EAAE,KAAK;IAClB,OAAO,EAAE,KAAK;IACd,MAAM,EAAE,EAAE;CACX,CAAC,CAAC;AAEH,MAAM,UAAU,GAAG,CAAC,UAA0B,EAAW,EAAE,CACzD,UAAU,CAAC,KAAK;OACb,UAAU,CAAC,IAAI;OACf,UAAU,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;OAC5B,UAAU,CAAC,MAAM;OACjB,UAAU,CAAC,KAAK;OAChB,UAAU,CAAC,WAAW;OACtB,UAAU,CAAC,OAAO;OAClB,UAAU,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;AAsBlC;;;;GAIG;AACH,MAAM,OAAO,2BAA2B;IACtB,EAAE,CAAS;IACX,GAAG,CAAyB;IAC5B,OAAO,CAAS;IAChB,SAAS,CAAS;IAEjB,OAAO,CAAsC;IAC7C,KAAK,CAAwB;IAC7B,MAAM,CAAyB;IAC/B,QAAQ,CAAyD;IACjE,UAAU,CAAgC;IAC3D,8EAA8E;IACtE,KAAK,GAAuB,SAAS,CAAC;IACtC,QAAQ,GAA+E,EAAE,CAAC;IAC1F,GAAG,GAAG,CAAC,CAAC;IAChB,6DAA6D;IACrD,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IACrC,OAAO,GAAmB,YAAY,EAAE,CAAC;IACzC,OAAO,GAAG,KAAK,CAAC;IAChB,MAAM,GAAG,KAAK,CAAC;IAEvB,YAAY,UAA+C;QACzD,IAAI,CAAC,EAAE,GAAG,UAAU,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;QACpC,IAAI,CAAC,UAAU,GAAG,IAAI,OAAO,CAAC,qBAAqB,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;IAC5G,CAAC;IAED,sFAAsF;IAC/E,SAAS,CAAC,QAAmC,EAAE,YAAgC;QACpF,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACxB,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS;YAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;;YAC1F,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;IAC/C,CAAC;IAED,+FAA+F;IACxF,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC7E,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,WAAW,EAAE,IAAI,CAAC,kBAAkB;YACpC,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;QACpB,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QAC/E,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;gBAC1B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1B,SAAS;YACX,CAAC;YACD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;QAChD,CAAC;QACD,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;IACnB,CAAC;IAED,qDAAqD;IAC9C,KAAK;QACV,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAEO,UAAU,CAAC,QAAmC,EAAE,YAAgC;QACtF,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC,CAAC;QACzF,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,QAAQ,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO,IAAI,QAAQ,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/E,IAAI,QAAQ,CAAC,IAAI,KAAK,sBAAsB,EAAE,CAAC;gBAC7C,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;YACzE,CAAC;iBAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;gBAC5C,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,iBAAiB;oBAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC,CAAC;gBACzG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;YACzB,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;YACpB,8EAA8E;YAC9E,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;YACpB,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC;QACtB,CAAC;aAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACjD,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;YACtC,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;gBACzD,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;gBACpB,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC;YACtB,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,MAAM;YAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;QACzC,IAAI,MAAM,CAAC,KAAK;YAAE,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;QACvC,IAAI,MAAM,CAAC,WAAW;YAAE,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;QACnD,IAAI,UAAU,CAAC,OAAO,CAAC;YAAE,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5C,CAAC;IAED,qFAAqF;IAC7E,KAAK,CAAC,MAAM;QAClB,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACpD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QACpB,CAAC;QAAC,MAAM,CAAC;YACP,mFAAmF;YACnF,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC;IACH,CAAC;IAED,iEAAiE;IACzD,KAAK,CAAC,IAAI;QAChB,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QACzB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,QAAQ,GAAmB,IAAI,CAAC;QACpC,IAAI,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC7C,IAAI,CAAC,IAAI,EAAE,CAAC;oBACV,IAAI,CAAC,SAAS,EAAE,CAAC;oBACjB,OAAO;gBACT,CAAC;gBACD,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM;oBAAE,OAAO;gBACjD,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;gBACnC,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBAC5B,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,oFAAoF;YACpF,IAAI,CAAC,OAAO,GAAG;gBACb,GAAG,YAAY,EAAE;gBACjB,KAAK,EAAE,IAAI;gBACX,MAAM,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;aAC9D,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,UAAU;QACtB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,YAAY,EAAE,CAAC;QAC9B,MAAM,MAAM,GAAY,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;QACrE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC5B,MAAM,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,WAAW;YAC1F,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE;YACxB,CAAC,CAAC,IAAI,CAAC;QACT,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACxB,CAAC;QACD,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;YACvC,MAAM,OAAO,GAA8B,EAAE,CAAC;YAC9C,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;gBACjC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI;oBAAE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC1D,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;YACzB,CAAC;YACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,MAAM,CAAC,IAAI,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;QACvE,CAAC;aAAM,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACjC,MAAM,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QACjC,CAAC;QACD,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;YAAE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACnE,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC;YAAE,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAChE,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,WAAW,CAAC;YAAE,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QAClF,IAAI,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YAC7B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;YACzC,IAAI,OAAO;gBAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;QACxC,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM;YAAE,MAAM,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC1D,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,WAAW;QACvB,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YACtF,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC;QAClF,CAAC;QAAC,MAAM,CAAC;YACP,wFAAwF;YACxF,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAEO,SAAS;QACf,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACxB,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.chatsubscription.js","sourceRoot":"","sources":["../ts_chat_harness_server/classes.chatsubscription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAiBxC,MAAM,YAAY,GAAG,GAAmB,EAAE,CAAC,CAAC;IAC1C,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,KAAK;IACX,MAAM,EAAE,EAAE;IACV,MAAM,EAAE,KAAK;IACb,KAAK,EAAE,KAAK;IACZ,WAAW,EAAE,KAAK;IAClB,OAAO,EAAE,KAAK;IACd,MAAM,EAAE,EAAE;CACX,CAAC,CAAC;AAEH,iEAAiE;AACjE,MAAM,KAAK,GAAG,CAAC,KAAa,EAAiB,EAAE,CAC7C,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;IAC5B,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;AACvC,CAAC,CAAC,CAAC;AAEL,MAAM,UAAU,GAAG,CAAC,UAA0B,EAAW,EAAE,CACzD,UAAU,CAAC,KAAK;OACb,UAAU,CAAC,IAAI;OACf,UAAU,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;OAC5B,UAAU,CAAC,MAAM;OACjB,UAAU,CAAC,KAAK;OAChB,UAAU,CAAC,WAAW;OACtB,UAAU,CAAC,OAAO;OAClB,UAAU,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;AAsBlC;;;;;GAKG;AACH,MAAM,OAAO,2BAA2B;IACtB,EAAE,CAAS;IACX,GAAG,CAAyB;IAC5B,OAAO,CAAS;IAChB,SAAS,CAAS;IAEjB,OAAO,CAAsC;IAC7C,KAAK,CAAwB;IAC7B,MAAM,CAAyB;IAC/B,QAAQ,CAAyD;IACjE,UAAU,CAAgC;IAC3D,8EAA8E;IACtE,KAAK,GAAuB,SAAS,CAAC;IACtC,QAAQ,GAA+E,EAAE,CAAC;IAC1F,GAAG,GAAG,CAAC,CAAC;IAChB,6DAA6D;IACrD,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IACrC,OAAO,GAAmB,YAAY,EAAE,CAAC;IACzC,OAAO,GAAG,KAAK,CAAC;IACxB,wEAAwE;IAChE,YAAY,GAAG,MAAM,CAAC,iBAAiB,CAAC;IACxC,MAAM,GAAG,KAAK,CAAC;IAEvB,YAAY,UAA+C;QACzD,IAAI,CAAC,EAAE,GAAG,UAAU,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;QACpC,IAAI,CAAC,UAAU,GAAG,IAAI,OAAO,CAAC,qBAAqB,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;IAC5G,CAAC;IAED,sFAAsF;IAC/E,SAAS,CAAC,QAAmC,EAAE,YAAgC;QACpF,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACxB,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS;YAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;;YAC1F,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;IAC/C,CAAC;IAED,+FAA+F;IACxF,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC7E,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,WAAW,EAAE,IAAI,CAAC,kBAAkB;YACpC,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;QACpB,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QAC/E,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;gBAC1B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1B,SAAS;YACX,CAAC;YACD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;QAChD,CAAC;QACD,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;IACnB,CAAC;IAED,qDAAqD;IAC9C,KAAK;QACV,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAEO,UAAU,CAAC,QAAmC,EAAE,YAAgC;QACtF,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC,CAAC;QACzF,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,QAAQ,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO,IAAI,QAAQ,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/E,IAAI,QAAQ,CAAC,IAAI,KAAK,sBAAsB,EAAE,CAAC;gBAC7C,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;YACzE,CAAC;iBAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;gBAC5C,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,iBAAiB;oBAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC,CAAC;gBACzG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;YACzB,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;YACpB,8EAA8E;YAC9E,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;YACpB,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC;QACtB,CAAC;aAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACjD,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;YACtC,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;gBACzD,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;gBACpB,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC;YACtB,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,MAAM;YAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;QACzC,IAAI,MAAM,CAAC,KAAK;YAAE,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;QACvC,IAAI,MAAM,CAAC,WAAW;YAAE,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;QACnD,IAAI,UAAU,CAAC,OAAO,CAAC;YAAE,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5C,CAAC;IAED,qFAAqF;IAC7E,KAAK,CAAC,MAAM;QAClB,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACpD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QACpB,CAAC;QAAC,MAAM,CAAC;YACP,mFAAmF;YACnF,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC;IACH,CAAC;IAED,8FAA8F;IACtF,KAAK,CAAC,IAAI;QAChB,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QACzB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,QAAQ,GAAmB,IAAI,CAAC;QACpC,IAAI,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzE,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;gBACrF,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;oBACb,+CAA+C;oBAC/C,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC;oBAClB,SAAS;gBACX,CAAC;gBACD,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC7C,IAAI,CAAC,IAAI,EAAE,CAAC;oBACV,IAAI,CAAC,SAAS,EAAE,CAAC;oBACjB,OAAO;gBACT,CAAC;gBACD,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM;oBAAE,OAAO;gBACjD,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;gBACnC,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;gBACtC,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBAC5B,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,oFAAoF;YACpF,IAAI,CAAC,OAAO,GAAG;gBACb,GAAG,YAAY,EAAE;gBACjB,KAAK,EAAE,IAAI;gBACX,MAAM,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;aAC9D,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,UAAU;QACtB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,YAAY,EAAE,CAAC;QAC9B,MAAM,MAAM,GAAY,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;QACrE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC5B,MAAM,IAAI,GAAG,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,WAAW;YAC1F,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE;YACxB,CAAC,CAAC,IAAI,CAAC;QACT,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACxB,CAAC;QACD,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;YACvC,MAAM,OAAO,GAA8B,EAAE,CAAC;YAC9C,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;gBACjC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI;oBAAE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC1D,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;YACzB,CAAC;YACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,MAAM,CAAC,IAAI,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;QACvE,CAAC;aAAM,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACjC,MAAM,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QACjC,CAAC;QACD,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;YAAE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACnE,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC;YAAE,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAChE,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,WAAW,CAAC;YAAE,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QAClF,IAAI,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YAC7B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;YACzC,IAAI,OAAO;gBAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;QACxC,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM;YAAE,MAAM,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC1D,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,WAAW;QACvB,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YACtF,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC;QAClF,CAAC;QAAC,MAAM,CAAC;YACP,wFAAwF;YACxF,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAEO,SAAS;QACf,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACxB,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;CACF"}

package/dist_ts_chat_harness_server/interfaces.d.ts

@@ -70,6 +70,12 @@ export interface IFlexHarnessChatLimits {
     toolTimeoutMs: number;
     /** Deltas one update may carry; a tab further behind gets the changed rows. Default: 2000. */
     maxPendingDeltas: number;
+    /**
+     * The least time between two updates of one subscription; what changes meanwhile goes into the
+     * next. It bounds the requests a streaming turn costs a transport that answers every update with
+     * one, as TypedSocket pulls do. Default: 100 ms.
+     */
+    minUpdateIntervalMs: number;
     /** Characters of a message's text. Default: 100 000. */
     maxMessageChars: number;
     /** Attachments of one message. Default: 16. */

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness",
-  "version": "11.1.1",
+  "version": "11.3.0",
   "type": "module",
   "description": "Managed agent sessions with tools, MCP, chat, OCR, documents and browser control through focused subpath imports.",
   "main": "./dist_ts/index.js",
@@ -87,8 +87,8 @@
   },
   "dependencies": {
     "@cfworker/json-schema": "^4.1.1",
-    "@modelprofile.com/flexharness-agent": "11.1.1",
-    "@modelprofile.com/flexharness-models": "11.1.1",
+    "@modelprofile.com/flexharness-agent": "11.3.0",
+    "@modelprofile.com/flexharness-models": "11.3.0",
     "@push.rocks/smartrequest": "^5.5.1",
     "ai": "^7.0.111",
     "zod": "^4.6.5"

package/readme.md

@@ -1065,6 +1065,9 @@ const unsubscribe = harness.subscribe((event) => {
         event.textUtf8Bytes,
       );
       break;
+    case 'part.removed':
+      removePart(event.sessionId, event.messageIndex, event.partIndex);
+      break;
     case 'permission.requested':
       showPermission(event.request);
       break;
@@ -1100,13 +1103,13 @@ const unsubscribe = harness.subscribe((event) => {
 unsubscribe();
 ```
 
-Events are discriminated, deeply immutable values with one global sequence within each `FlexHarness` instance. Every `IFlexEventBase` carries the exact source `sessionGenerationId` and `sessionGenerationSequence`; `session.deleted` retains the deleted generation after live metadata is removed. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Every accepted steer emits `prompt.steer.accepted`, and `prompt.steer.applied`, after the `message.*` events of its user message, once the run took it in; `run.finished` lists it in `unappliedSteerIds` unless it is in the model context of later turns. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part emits exactly one `part.completed` event before the corresponding `run.finished` event: once the model step that streamed it is committed, so its text is final and saved, or with the run's terminal projection when that step did not commit. Text a later model step streams starts a new part. Every `part.started`, `part.delta`, `part.updated`, and `part.completed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences.
+Events are discriminated, deeply immutable values with one global sequence within each `FlexHarness` instance. Every `IFlexEventBase` carries the exact source `sessionGenerationId` and `sessionGenerationSequence`; `session.deleted` retains the deleted generation after live metadata is removed. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Every accepted steer emits `prompt.steer.accepted`, and `prompt.steer.applied`, after the `message.*` events of its user message, once the run took it in; `run.finished` lists it in `unappliedSteerIds` unless it is in the model context of later turns. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part that stays in its message emits exactly one `part.completed` event before the corresponding `run.finished` event: once the model step that streamed it is committed, so its text is final and saved, or with the run's terminal projection when that step did not commit. Text a later model step streams starts a new part. When a model call fails and is retried, the text and reasoning parts it streamed are not in the session: `part.removed` takes each of them out of its message, last part first, and the retry streams its own parts. Its `partIndex` is the part's position before it left; the parts after it move up by one. A removed part has no further events, and `part.removed` does not count against `callbackLimits`. The tool parts of calls the failed model call executed stay. Every `part.started`, `part.delta`, `part.updated`, `part.completed`, and `part.removed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences.
 
 `getSessionView(scopeId, sessionId)` reads a session's metadata, visible messages and pending permission requests in one step, together with the instance's event `sequence` they include. The messages include what a running turn has streamed so far, so a consumer that applies every event of the instance with a greater `sequence` follows the session exactly from the view on; events up to `sequence` are already in it. The read waits while a queued write or a change that emits events for the session is in progress; a session that keeps changing through 64 consecutive waits is refused with `FlexHarnessSessionBusyError`, and the read can be repeated. Session metadata is current: status changes such as `waiting_permission` emit no event. A permission request its run leaves unanswered leaves `pendingPermissions` without an event of its own; the run's `run.finished` follows.
 
 `part.started`, `part.updated`, and `part.completed` are snapshot events with a complete immutable `part`. Tool and reasoning parts carry `startedAt` (ISO time the call or reasoning began) and, once they reach a terminal status, `completedAt`; parts recorded by earlier versions have neither, so a consumer falls back to the message times for them. A newly streamed text part emits `part.started` with empty text before its first delta; reasoning parts also start empty. `part.delta` is a separate delta-only event: it has no cumulative `part`, and carries `partType`, the required exact source `delta`, and `baseTextUtf8Bytes`/`textUtf8Bytes` for the cumulative text before and after that delta. The counters remain correct when a UTF-16 surrogate pair is split across callbacks. Exact deltas are never truncated, including a single delta above the 96 KiB message-transfer text limit. `part.updated` remains a cumulative replacement snapshot for running tool output or metadata, not a text delta. `session.history.changed` carries `direction: 'undo' | 'redo' | 'branch'`; `runId` is present for undo and redo. Events contain public IDs, exact delta payloads, and public snapshots only; they do not expose prompt payloads, the resolved scope object, storage key, model object, provider options, or raw storage key.
 
-Part events narrow through the exported `TFlexPartEvent` union. `IFlexPartEventBase` contains their shared coordinates, `IFlexPartSnapshotEvent` owns snapshot events and their complete `part`, and `IFlexPartDeltaEvent` owns exact delta-only events and their UTF-8 counters.
+Part events narrow through the exported `TFlexPartEvent` union. `IFlexPartEventBase` contains their shared coordinates, `IFlexPartSnapshotEvent` owns snapshot events and their complete `part`, `IFlexPartDeltaEvent` owns exact delta-only events and their UTF-8 counters, and `IFlexPartRemovedEvent` is `part.removed`, which carries only the coordinates.
 
 ### Migrating Part Events to 5.x
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '11.1.1',
+  version: '11.3.0',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }

package/ts/classes.codesandbox.ts

@@ -1,5 +1,5 @@
 import * as plugins from './plugins.js';
-import { FlexHarnessValidationError } from './errors.js';
+import { FlexHarnessClosedError, FlexHarnessValidationError } from './errors.js';
 import type { IFlexCodeModeLimits, IFlexCodeRunFailure, TJsonValue } from './interfaces.js';
 import type { TCodeWorkerPhase, TCodeWorkerReport, TCodeWorkerRequest } from './classes.codesandbox.worker.js';
 import { maxTransferMetadataBytes, truncateUtf8 } from './utils.transfer.js';
@@ -27,11 +27,44 @@ export type TFlexCodeRunResult =
   | { ok: true; value: TJsonValue; calls: number; logs?: string }
   | { ok: false; failure: IFlexCodeRunFailure };
 
+/**
+ * When a sandbox replaces its workers. A worker runs programs one after another, each in a QuickJS
+ * runtime of its own that it frees after the program, and is ended after a limit stopped a program,
+ * when it fails, after `maxPrograms`, once its WebAssembly memory grew past `maxMemoryBytes`, or after
+ * waiting `idleMs` for a program.
+ */
+export interface IFlexCodeSandboxPolicy {
+  /** Programs one worker runs before it is replaced. */
+  maxPrograms: number;
+  /** The WebAssembly memory a worker may have grown to and still run another program; it never shrinks. */
+  maxMemoryBytes: number;
+  /** How long a worker waits for its next program before it ends. */
+  idleMs: number;
+  /** Workers kept waiting for programs, across scopes; the one that waited longest goes first. */
+  maxWaiting: number;
+}
+
+export const FLEX_CODE_SANDBOX_DEFAULT_POLICY: Readonly<IFlexCodeSandboxPolicy> = Object.freeze({
+  maxPrograms: 100,
+  maxMemoryBytes: 64 * 1024 * 1024,
+  idleMs: 60_000,
+  maxWaiting: 4,
+});
+
 type TStop =
   | { kind: 'limit'; limit: NonNullable<IFlexCodeRunFailure['limit']>; message: string }
   | { kind: 'aborted'; message: string }
   | { kind: 'host'; error: unknown };
 
+/** What a worker hands the program it serves: everything but its own bookkeeping. */
+type TCodeRunReport = Exclude<TCodeWorkerReport, { kind: 'released' }>;
+
+interface ICodeWorkerClient {
+  report(report: TCodeRunReport): void;
+  /** The worker failed or exited by itself; it is ended. */
+  fail(error: unknown): void;
+}
+
 /** How long calls in flight get to settle after their program stopped and their signal aborted. */
 const stopGraceMs = 5_000;
 /**
@@ -40,6 +73,8 @@ const stopGraceMs = 5_000;
  * array many times over, can run far longer.
  */
 const cpuGraceMs = 250;
+/** How long a worker gets to free the runtime of a program that ended by itself before it is ended. */
+const releaseGraceMs = 1_000;
 
 const programPrefix = 'globalThis.__flexMain = async function () {\n';
 const programSuffix = '\n};';
@@ -50,16 +85,32 @@ const workerUrl = new URL(`./classes.codesandbox.worker${plugins.path.extname(im
 let enginePromise: Promise<plugins.ICodeSandboxEngine> | undefined;
 
 /**
- * Runs `run_code` programs in QuickJS-ng compiled to WebAssembly: every program in a worker thread and
- * WebAssembly instance of its own, with no globals beyond the language, `api`, `ApiError` and
- * `console`, and every limit of `IFlexCodeModeLimits` enforced. Program types are stripped with amaro
- * first.
+ * Runs `run_code` programs in QuickJS-ng compiled to WebAssembly, with no globals beyond the language,
+ * `api`, `ApiError` and `console`, and every limit of `IFlexCodeModeLimits` enforced. Program types are
+ * stripped with amaro first.
+ *
+ * The sandbox owns its worker threads. Each runs one program at a time, in a QuickJS runtime and
+ * context of its own that it frees once the program ended, so nothing of a program reaches the next,
+ * and serves only programs of one scope: programs of different scopes never share a WebAssembly
+ * instance. `IFlexCodeSandboxPolicy` says when a worker is replaced; `dispose()` stops the programs
+ * running and ends every worker.
  */
 export class FlexCodeSandbox {
-  private constructor(private readonly engine: plugins.ICodeSandboxEngine) {}
+  private readonly workers = new Set<CodeWorker>();
+  /** Workers waiting for a program, the one that waited longest first. */
+  private readonly waiting: CodeWorker[] = [];
+  private readonly runs = new Map<CodeRun, Promise<unknown>>();
+  private started = 0;
+  private closed = false;
+  private disposal?: Promise<void>;
+
+  private constructor(
+    private readonly engine: plugins.ICodeSandboxEngine,
+    private readonly policy: Readonly<IFlexCodeSandboxPolicy>,
+  ) {}
 
-  /** Loads QuickJS and amaro, once per process. */
-  public static async load(): Promise<FlexCodeSandbox> {
+  /** Loads QuickJS and amaro, once per process, into a sandbox with workers of its own. */
+  public static async load(policy: Partial<IFlexCodeSandboxPolicy> = {}): Promise<FlexCodeSandbox> {
     enginePromise ??= plugins.importCodeSandboxEngine().catch((error: unknown) => {
       enginePromise = undefined;
       throw new FlexHarnessValidationError(
@@ -68,22 +119,224 @@ export class FlexCodeSandbox {
         { cause: error },
       );
     });
-    return new FlexCodeSandbox(await enginePromise);
+    return new FlexCodeSandbox(await enginePromise, { ...FLEX_CODE_SANDBOX_DEFAULT_POLICY, ...policy });
   }
 
-  public run(
+  /** Workers started so far, alive now, and waiting for a program. */
+  public get workerCounts(): { started: number; live: number; waiting: number } {
+    return { started: this.started, live: this.workers.size, waiting: this.waiting.length };
+  }
+
+  /** Starts a worker for the scope's next program, unless one waits for it already. */
+  public prewarm(scope?: string): void {
+    if (this.closed || this.policy.maxWaiting === 0) return;
+    if (this.waiting.some((worker) => worker.programs === 0 || worker.scope === scope)) return;
+    this.park(this.spawn());
+  }
+
+  /** Runs a program on a worker that waits for the scope, or on a new one. */
+  public async run(
     source: string,
     host: IFlexCodeHost,
     limits: Readonly<IFlexCodeModeLimits>,
     signal?: AbortSignal,
+    scope?: string,
   ): Promise<TFlexCodeRunResult> {
-    return new CodeRun(this.engine, source, host, limits, signal).start();
+    if (this.closed) throw new FlexHarnessClosedError();
+    const run = new CodeRun(this.engine, source, host, limits, signal, () => this.lease(scope));
+    const outcome = run.start();
+    this.runs.set(run, outcome);
+    try {
+      return await outcome;
+    } finally {
+      this.runs.delete(run);
+    }
+  }
+
+  /** Stops the programs running, and ends every worker once they settled. */
+  public dispose(): Promise<void> {
+    if (!this.disposal) {
+      this.closed = true;
+      this.disposal = this.endAll();
+    }
+    return this.disposal;
+  }
+
+  private async endAll(): Promise<void> {
+    for (const run of this.runs.keys()) run.abort('The code sandbox was disposed.');
+    await Promise.allSettled(this.runs.values());
+    await Promise.all([...this.workers].map((worker) => worker.end(false)));
+  }
+
+  /** A waiting worker of the scope, the one that waited least; else one that has served no scope yet. */
+  private lease(scope: string | undefined): CodeWorker {
+    let index = this.lastWaiting((worker) => worker.programs > 0 && worker.scope === scope);
+    if (index === -1) index = this.lastWaiting((worker) => worker.programs === 0);
+    const worker = index === -1 ? this.spawn() : this.waiting.splice(index, 1)[0]!;
+    worker.claim(scope);
+    return worker;
+  }
+
+  private lastWaiting(matches: (worker: CodeWorker) => boolean): number {
+    for (let index = this.waiting.length - 1; index >= 0; index -= 1) {
+      if (matches(this.waiting[index]!)) return index;
+    }
+    return -1;
+  }
+
+  private spawn(): CodeWorker {
+    const worker = new CodeWorker({
+      returned: (returned) => this.returned(returned),
+      ended: (ended, replace) => this.ended(ended, replace),
+    });
+    this.workers.add(worker);
+    this.started += 1;
+    return worker;
+  }
+
+  /** A worker freed its program's runtime: it waits for the next program, or is replaced. */
+  private returned(worker: CodeWorker): void {
+    if (this.closed) {
+      void worker.end(false);
+      return;
+    }
+    if (worker.programs >= this.policy.maxPrograms || worker.memoryBytes > this.policy.maxMemoryBytes) {
+      void worker.end(true);
+      return;
+    }
+    this.park(worker);
+  }
+
+  private park(worker: CodeWorker): void {
+    worker.wait(this.policy.idleMs);
+    this.waiting.push(worker);
+    while (this.waiting.length > this.policy.maxWaiting) void this.waiting.shift()!.end(false);
+  }
+
+  /** A worker that served programs and was ended before its time is replaced in the background. */
+  private ended(worker: CodeWorker, replace: boolean): void {
+    this.workers.delete(worker);
+    const index = this.waiting.indexOf(worker);
+    if (index !== -1) this.waiting.splice(index, 1);
+    if (replace) this.prewarm(worker.scope);
   }
 }
 
-class CodeRun {
-  private worker?: plugins.Worker;
+/**
+ * A worker thread of a sandbox, and the WebAssembly instance it loads QuickJS into. It is `waiting`
+ * for a program, `serving` one, `releasing` the runtime of a program that ended by itself, or `ended`.
+ * Once it served a program, it serves only programs of that program's scope.
+ */
+class CodeWorker {
+  public state: 'waiting' | 'serving' | 'releasing' | 'ended' = 'waiting';
+  public programs = 0;
+  public scope?: string;
+  /** Its WebAssembly memory after the last program, which never shrinks. */
+  public memoryBytes = 0;
+  private ready = false;
+  private readonly thread: plugins.Worker;
+  private client?: ICodeWorkerClient;
+  private idleTimer?: ReturnType<typeof setTimeout>;
+  private releaseTimer?: ReturnType<typeof setTimeout>;
+  /** Settles the `leave()` of the program it releases, once it is returned or ended. */
+  private handedBack?: () => void;
   private terminated?: Promise<unknown>;
+
+  constructor(private readonly owner: {
+    returned(worker: CodeWorker): void;
+    ended(worker: CodeWorker, replace: boolean): void;
+  }) {
+    this.thread = new plugins.Worker(workerUrl);
+    this.thread.on('message', (report: TCodeWorkerReport) => this.receive(report));
+    this.thread.on('error', (error: unknown) => this.fail(error));
+    this.thread.on('exit', (code: number) => this.fail(new Error(`The code mode worker exited with code ${code}.`)));
+  }
+
+  /** Takes the worker out of waiting for a program of the scope. */
+  public claim(scope: string | undefined): void {
+    clearTimeout(this.idleTimer);
+    this.thread.ref();
+    this.state = 'serving';
+    this.programs += 1;
+    this.scope = scope;
+  }
+
+  /** Hands the worker's reports to the program it serves, starting with `ready` once QuickJS is loaded. */
+  public serve(client: ICodeWorkerClient): void {
+    this.client = client;
+    if (this.ready) client.report({ kind: 'ready' });
+  }
+
+  public send(request: TCodeWorkerRequest): void {
+    this.thread.postMessage(request);
+  }
+
+  /**
+   * The program is over. A worker whose program ended by itself frees its runtime and is returned to
+   * the sandbox, or ended if that takes `releaseGraceMs`; any other is ended now, whatever it computes.
+   * Settles once the worker is returned or ended, so the program's next one finds it waiting.
+   */
+  public leave(reusable: boolean): Promise<unknown> {
+    this.client = undefined;
+    if (!reusable || this.state !== 'serving') return this.end(true);
+    this.state = 'releasing';
+    this.releaseTimer = setTimeout(() => void this.end(true), releaseGraceMs);
+    return new Promise<void>((resolve) => {
+      this.handedBack = resolve;
+    });
+  }
+
+  /** Waits for the next program, keeping the process alive no longer than its own work does. */
+  public wait(idleMs: number): void {
+    this.state = 'waiting';
+    this.thread.unref();
+    this.idleTimer = setTimeout(() => void this.end(false), idleMs);
+    this.idleTimer.unref();
+  }
+
+  /** Terminates the thread, which frees its WebAssembly instance; `replace` asks for a successor. */
+  public end(replace: boolean): Promise<unknown> {
+    if (!this.terminated) {
+      this.state = 'ended';
+      this.client = undefined;
+      clearTimeout(this.idleTimer);
+      clearTimeout(this.releaseTimer);
+      this.terminated = this.thread.terminate();
+      const handedBack = this.handedBack;
+      this.handedBack = undefined;
+      if (handedBack) void this.terminated.then(handedBack);
+      this.owner.ended(this, replace && this.programs > 0);
+    }
+    return this.terminated;
+  }
+
+  private receive(report: TCodeWorkerReport): void {
+    if (report.kind === 'released') {
+      if (this.state !== 'releasing') return;
+      clearTimeout(this.releaseTimer);
+      this.memoryBytes = report.memoryBytes;
+      this.owner.returned(this);
+      this.handedBack?.();
+      this.handedBack = undefined;
+      return;
+    }
+    if (report.kind === 'ready') this.ready = true;
+    this.client?.report(report);
+  }
+
+  private fail(error: unknown): void {
+    if (this.terminated) return;
+    const client = this.client;
+    void this.end(true);
+    client?.fail(error);
+  }
+}
+
+class CodeRun {
+  private worker?: CodeWorker;
+  private left?: Promise<unknown>;
+  /** The program ended by itself, so its worker can run the next one. */
+  private reusable = false;
   private program = '';
   private readonly calls = new AbortController();
   private readonly queue: Array<() => void> = [];
@@ -111,6 +364,7 @@ class CodeRun {
     private readonly host: IFlexCodeHost,
     private readonly limits: Readonly<IFlexCodeModeLimits>,
     private readonly signal: AbortSignal | undefined,
+    private readonly lease: () => CodeWorker,
   ) {}
 
   public async start(): Promise<TFlexCodeRunResult> {
@@ -139,7 +393,7 @@ class CodeRun {
     this.signal?.addEventListener('abort', onAbort, { once: true });
     try {
       if (this.signal?.aborted) onAbort();
-      else this.spawn();
+      else this.attach();
       return await outcome;
     } finally {
       this.signal?.removeEventListener('abort', onAbort);
@@ -147,17 +401,20 @@ class CodeRun {
     }
   }
 
-  private spawn(): void {
-    const worker = new plugins.Worker(workerUrl);
-    this.worker = worker;
-    worker.on('message', (report: TCodeWorkerReport) => this.receive(report));
-    worker.on('error', (error: unknown) => this.halt({ kind: 'host', error }));
-    worker.on('exit', (code: number) => {
-      this.halt({ kind: 'host', error: new Error(`The code mode worker exited with code ${code}.`) });
+  /** Stops the program from outside, as an abort. */
+  public abort(message: string): void {
+    this.halt({ kind: 'aborted', message });
+  }
+
+  private attach(): void {
+    this.worker = this.lease();
+    this.worker.serve({
+      report: (report) => this.receive(report),
+      fail: (error) => this.halt({ kind: 'host', error }),
     });
   }
 
-  private receive(report: TCodeWorkerReport): void {
+  private receive(report: TCodeRunReport): void {
     if (this.closing) return;
     switch (report.kind) {
       case 'ready':
@@ -190,7 +447,7 @@ class CodeRun {
           this.halt({ kind: 'host', error: new Error(`The code mode prelude failed: ${report.dumped}`) });
           return;
         }
-        this.done(this.failure(this.classify(report, report.phase)));
+        this.finish(this.failure(this.classify(report, report.phase)));
         return;
       case 'stopped':
         this.halt(report.limit === 'cpu'
@@ -203,7 +460,7 @@ class CodeRun {
   /** Has the worker compute: start the program, or go on with an answer. */
   private send(request: TCodeWorkerRequest): void {
     this.busy += 1;
-    this.worker!.postMessage(request);
+    this.worker!.send(request);
     this.armWatchdog();
   }
 
@@ -295,13 +552,13 @@ class CodeRun {
     if (outcome.ok) {
       if (unawaited > 0) {
         // Calls the program did not await are not part of its result: it fails, and proposes nothing.
-        this.done(this.failure({
+        this.finish(this.failure({
           error: 'program_error',
           message: `The program returned with ${unawaited} call${unawaited === 1 ? '' : 's'} it did not await; await every call.`,
         }));
         return;
       }
-      this.done({
+      this.finish({
         ok: true,
         value: outcome.value ?? null,
         calls: Math.min(this.callCount, this.limits.maxCalls),
@@ -309,7 +566,7 @@ class CodeRun {
       });
       return;
     }
-    this.done(this.failure(this.classify(outcome, 'program')));
+    this.finish(this.failure(this.classify(outcome, 'program')));
   }
 
   private classify(
@@ -363,12 +620,21 @@ class CodeRun {
       : { error: 'aborted', message: reason.message }));
   }
 
+  /**
+   * The program ended by itself with this outcome. Its worker runs the next program, unless the
+   * program reached a limit: such a worker is not trusted with another.
+   */
+  private finish(result: TFlexCodeRunResult): void {
+    this.reusable = result.ok || result.failure.error !== 'limit_exceeded';
+    this.done(result);
+  }
+
   private done(result: TFlexCodeRunResult): void {
     this.close(() => this.settle(result));
   }
 
   /**
-   * Decides the run's outcome and ends the program's worker. Calls not started yet never start. Calls
+   * Decides the run's outcome and leaves the program's worker. Calls not started yet never start. Calls
    * in flight are told to stop through their signal, and the outcome is delivered once they settled,
    * so no call runs on after its program; a host call that ignores its signal gets `stopGraceMs`, and
    * its answer is dropped.
@@ -377,7 +643,7 @@ class CodeRun {
     if (this.closing) return;
     this.closing = true;
     this.queue.length = 0;
-    void this.terminate();
+    void this.leave();
     if (this.inFlight.size === 0) {
       deliver();
       return;
@@ -408,11 +674,14 @@ class CodeRun {
     this.wallTimer = setTimeout(check, Math.max(10, Math.min(250, this.limits.wallMs)));
   }
 
-  /** Ends the program's worker, whatever it computes, which frees its WebAssembly instance with it. */
-  private terminate(): Promise<unknown> {
+  /**
+   * Hands the worker back: for the next program if this one ended by itself, ended otherwise, whatever
+   * it computes, which frees its WebAssembly instance with it.
+   */
+  private leave(): Promise<unknown> {
     clearTimeout(this.watchdog);
-    this.terminated ??= this.worker?.terminate() ?? Promise.resolve();
-    return this.terminated;
+    this.left ??= this.worker?.leave(this.reusable) ?? Promise.resolve();
+    return this.left;
   }
 
   private async dispose(): Promise<void> {
@@ -420,6 +689,6 @@ class CodeRun {
     if (this.wallTimer) clearTimeout(this.wallTimer);
     this.queue.length = 0;
     this.calls.abort();
-    await this.terminate();
+    await this.leave();
   }
 }