@modelprofile.com/flexharness 11.1.1 → 11.3.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 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.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwrQkFBK0I7SUFDckMsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLDBFQUEwRTtDQUN4RixDQUFBIn0=

package/dist_ts/classes.codesandbox.d.ts

@@ -33,15 +33,66 @@ export type TFlexCodeRunResult = {
     failure: IFlexCodeRunFailure;
 };
 /**
- * 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.
+ * 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 declare const FLEX_CODE_SANDBOX_DEFAULT_POLICY: Readonly<IFlexCodeSandboxPolicy>;
+/**
+ * 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 declare class FlexCodeSandbox {
     private readonly engine;
+    private readonly policy;
+    private readonly workers;
+    /** Workers waiting for a program, the one that waited longest first. */
+    private readonly waiting;
+    private readonly runs;
+    private started;
+    private closed;
+    private disposal?;
     private constructor();
-    /** Loads QuickJS and amaro, once per process. */
-    static load(): Promise<FlexCodeSandbox>;
-    run(source: string, host: IFlexCodeHost, limits: Readonly<IFlexCodeModeLimits>, signal?: AbortSignal): Promise<TFlexCodeRunResult>;
+    /** Loads QuickJS and amaro, once per process, into a sandbox with workers of its own. */
+    static load(policy?: Partial<IFlexCodeSandboxPolicy>): Promise<FlexCodeSandbox>;
+    /** Workers started so far, alive now, and waiting for a program. */
+    get workerCounts(): {
+        started: number;
+        live: number;
+        waiting: number;
+    };
+    /** Starts a worker for the scope's next program, unless one waits for it already. */
+    prewarm(scope?: string): void;
+    /** Runs a program on a worker that waits for the scope, or on a new one. */
+    run(source: string, host: IFlexCodeHost, limits: Readonly<IFlexCodeModeLimits>, signal?: AbortSignal, scope?: string): Promise<TFlexCodeRunResult>;
+    /** Stops the programs running, and ends every worker once they settled. */
+    dispose(): Promise<void>;
+    private endAll;
+    /** A waiting worker of the scope, the one that waited least; else one that has served no scope yet. */
+    private lease;
+    private lastWaiting;
+    private spawn;
+    /** A worker freed its program's runtime: it waits for the next program, or is replaced. */
+    private returned;
+    private park;
+    /** A worker that served programs and was ended before its time is replaced in the background. */
+    private ended;
 }

package/dist_ts/classes.codesandbox.js

@@ -1,6 +1,12 @@
 import * as plugins from './plugins.js';
-import { FlexHarnessValidationError } from './errors.js';
+import { FlexHarnessClosedError, FlexHarnessValidationError } from './errors.js';
 import { maxTransferMetadataBytes, truncateUtf8 } from './utils.transfer.js';
+export const FLEX_CODE_SANDBOX_DEFAULT_POLICY = Object.freeze({
+    maxPrograms: 100,
+    maxMemoryBytes: 64 * 1024 * 1024,
+    idleMs: 60_000,
+    maxWaiting: 4,
+});
 /** How long calls in flight get to settle after their program stopped and their signal aborted. */
 const stopGraceMs = 5_000;
 /**
@@ -9,33 +15,243 @@ 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};';
 /** The worker module beside this one, compiled or, where the package runs uncompiled, its source. */
 const workerUrl = new URL(`./classes.codesandbox.worker${plugins.path.extname(import.meta.url)}`, import.meta.url);
 let enginePromise;
 /**
- * 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 {
     engine;
-    constructor(engine) {
+    policy;
+    workers = new Set();
+    /** Workers waiting for a program, the one that waited longest first. */
+    waiting = [];
+    runs = new Map();
+    started = 0;
+    closed = false;
+    disposal;
+    constructor(engine, policy) {
         this.engine = engine;
+        this.policy = policy;
     }
-    /** Loads QuickJS and amaro, once per process. */
-    static async load() {
+    /** Loads QuickJS and amaro, once per process, into a sandbox with workers of its own. */
+    static async load(policy = {}) {
         enginePromise ??= plugins.importCodeSandboxEngine().catch((error) => {
             enginePromise = undefined;
             throw new FlexHarnessValidationError('Code mode needs the optional peers quickjs-emscripten-core, '
                 + '@jitl/quickjs-ng-wasmfile-release-sync and amaro.', { cause: error });
         });
-        return new FlexCodeSandbox(await enginePromise);
+        return new FlexCodeSandbox(await enginePromise, { ...FLEX_CODE_SANDBOX_DEFAULT_POLICY, ...policy });
     }
-    run(source, host, limits, signal) {
-        return new CodeRun(this.engine, source, host, limits, signal).start();
+    /** Workers started so far, alive now, and waiting for a program. */
+    get workerCounts() {
+        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. */
+    prewarm(scope) {
+        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. */
+    async run(source, host, limits, signal, scope) {
+        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. */
+    dispose() {
+        if (!this.disposal) {
+            this.closed = true;
+            this.disposal = this.endAll();
+        }
+        return this.disposal;
+    }
+    async endAll() {
+        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. */
+    lease(scope) {
+        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;
+    }
+    lastWaiting(matches) {
+        for (let index = this.waiting.length - 1; index >= 0; index -= 1) {
+            if (matches(this.waiting[index]))
+                return index;
+        }
+        return -1;
+    }
+    spawn() {
+        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. */
+    returned(worker) {
+        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);
+    }
+    park(worker) {
+        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. */
+    ended(worker, replace) {
+        this.workers.delete(worker);
+        const index = this.waiting.indexOf(worker);
+        if (index !== -1)
+            this.waiting.splice(index, 1);
+        if (replace)
+            this.prewarm(worker.scope);
+    }
+}
+/**
+ * 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 {
+    owner;
+    state = 'waiting';
+    programs = 0;
+    scope;
+    /** Its WebAssembly memory after the last program, which never shrinks. */
+    memoryBytes = 0;
+    ready = false;
+    thread;
+    client;
+    idleTimer;
+    releaseTimer;
+    /** Settles the `leave()` of the program it releases, once it is returned or ended. */
+    handedBack;
+    terminated;
+    constructor(owner) {
+        this.owner = owner;
+        this.thread = new plugins.Worker(workerUrl);
+        this.thread.on('message', (report) => this.receive(report));
+        this.thread.on('error', (error) => this.fail(error));
+        this.thread.on('exit', (code) => this.fail(new Error(`The code mode worker exited with code ${code}.`)));
+    }
+    /** Takes the worker out of waiting for a program of the scope. */
+    claim(scope) {
+        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. */
+    serve(client) {
+        this.client = client;
+        if (this.ready)
+            client.report({ kind: 'ready' });
+    }
+    send(request) {
+        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.
+     */
+    leave(reusable) {
+        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((resolve) => {
+            this.handedBack = resolve;
+        });
+    }
+    /** Waits for the next program, keeping the process alive no longer than its own work does. */
+    wait(idleMs) {
+        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. */
+    end(replace) {
+        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;
+    }
+    receive(report) {
+        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);
+    }
+    fail(error) {
+        if (this.terminated)
+            return;
+        const client = this.client;
+        void this.end(true);
+        client?.fail(error);
     }
 }
 class CodeRun {
@@ -44,8 +260,11 @@ class CodeRun {
     host;
     limits;
     signal;
+    lease;
     worker;
-    terminated;
+    left;
+    /** The program ended by itself, so its worker can run the next one. */
+    reusable = false;
     program = '';
     calls = new AbortController();
     queue = [];
@@ -66,12 +285,13 @@ class CodeRun {
     closing = false;
     wallTimer;
     startedAt = performance.now();
-    constructor(engine, source, host, limits, signal) {
+    constructor(engine, source, host, limits, signal, lease) {
         this.engine = engine;
         this.source = source;
         this.host = host;
         this.limits = limits;
         this.signal = signal;
+        this.lease = lease;
     }
     async start() {
         if (Buffer.byteLength(this.source, 'utf8') > this.limits.maxSourceBytes) {
@@ -102,7 +322,7 @@ class CodeRun {
             if (this.signal?.aborted)
                 onAbort();
             else
-                this.spawn();
+                this.attach();
             return await outcome;
         }
         finally {
@@ -110,13 +330,15 @@ class CodeRun {
             await this.dispose();
         }
     }
-    spawn() {
-        const worker = new plugins.Worker(workerUrl);
-        this.worker = worker;
-        worker.on('message', (report) => this.receive(report));
-        worker.on('error', (error) => this.halt({ kind: 'host', error }));
-        worker.on('exit', (code) => {
-            this.halt({ kind: 'host', error: new Error(`The code mode worker exited with code ${code}.`) });
+    /** Stops the program from outside, as an abort. */
+    abort(message) {
+        this.halt({ kind: 'aborted', message });
+    }
+    attach() {
+        this.worker = this.lease();
+        this.worker.serve({
+            report: (report) => this.receive(report),
+            fail: (error) => this.halt({ kind: 'host', error }),
         });
     }
     receive(report) {
@@ -153,7 +375,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'
@@ -165,7 +387,7 @@ class CodeRun {
     /** Has the worker compute: start the program, or go on with an answer. */
     send(request) {
         this.busy += 1;
-        this.worker.postMessage(request);
+        this.worker.send(request);
         this.armWatchdog();
     }
     idle(cpuMs) {
@@ -253,13 +475,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),
@@ -267,7 +489,7 @@ class CodeRun {
             });
             return;
         }
-        this.done(this.failure(this.classify(outcome, 'program')));
+        this.finish(this.failure(this.classify(outcome, 'program')));
     }
     classify(error, phase) {
         const message = typeof error.message === 'string'
@@ -313,11 +535,19 @@ class CodeRun {
             ? { error: 'limit_exceeded', limit: reason.limit, message: reason.message }
             : { 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.
+     */
+    finish(result) {
+        this.reusable = result.ok || result.failure.error !== 'limit_exceeded';
+        this.done(result);
+    }
     done(result) {
         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.
@@ -327,7 +557,7 @@ class CodeRun {
             return;
         this.closing = true;
         this.queue.length = 0;
-        void this.terminate();
+        void this.leave();
         if (this.inFlight.size === 0) {
             deliver();
             return;
@@ -357,11 +587,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. */
-    terminate() {
+    /**
+     * 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.
+     */
+    leave() {
         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;
     }
     async dispose() {
         this.closing = true;
@@ -369,7 +602,7 @@ class CodeRun {
             clearTimeout(this.wallTimer);
         this.queue.length = 0;
         this.calls.abort();
-        await this.terminate();
+        await this.leave();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codesandbox.js","sourceRoot":"","sources":["../ts/classes.codesandbox.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codesandbox.js","sourceRoot":"","sources":["../ts/classes.codesandbox.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.codesandbox.worker.d.ts

@@ -20,10 +20,15 @@ export type TCodeWorkerRequest = {
 /**
  * What a program's worker reports. `ready` comes once QuickJS is loaded; every `start` and `answer`
  * ends in `idle`, with the milliseconds computed so far, unless the program stopped. `done` counts the
- * calls the program had no answer to when it returned.
+ * calls the program had no answer to when it returned. `released` follows a program that ended by
+ * itself (`done`, or `failed` short of a limit): its runtime is freed, and the worker's WebAssembly
+ * memory, which never shrinks, has `memoryBytes`.
  */
 export type TCodeWorkerReport = {
     kind: 'ready';
+} | {
+    kind: 'released';
+    memoryBytes: number;
 } | {
     kind: 'call';
     id: number;