@modelprofile.com/flexharness 11.0.1 → 11.1.0

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

@@ -0,0 +1,52 @@
+/** Evaluating the prelude, the program's text, or running the program. */
+export type TCodeWorkerPhase = 'prelude' | 'parse' | 'program';
+/** The limits of a program that its worker enforces itself. */
+export interface ICodeWorkerLimits {
+    cpuMs: number;
+    memoryBytes: number;
+    stackBytes: number;
+    maxLogBytes: number;
+}
+/** What the host sends a program's worker. */
+export type TCodeWorkerRequest = {
+    kind: 'start';
+    program: string;
+    limits: ICodeWorkerLimits;
+} | {
+    kind: 'answer';
+    id: number;
+    text: string;
+};
+/**
+ * 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.
+ */
+export type TCodeWorkerReport = {
+    kind: 'ready';
+} | {
+    kind: 'call';
+    id: number;
+    method: string;
+    params: string;
+} | {
+    kind: 'log';
+    text: string;
+} | {
+    kind: 'idle';
+    cpuMs: number;
+} | {
+    kind: 'done';
+    text: string;
+    unawaited: number;
+} | {
+    kind: 'failed';
+    phase: TCodeWorkerPhase;
+    name?: string;
+    message?: string;
+    stack?: string;
+    dumped?: string;
+} | {
+    kind: 'stopped';
+    limit: 'cpu' | 'stack';
+};

package/dist_ts/classes.codesandbox.worker.js

@@ -0,0 +1,310 @@
+/**
+ * The QuickJS side of a `run_code` program. `FlexCodeSandbox` runs every program in a worker thread of
+ * its own with this module, and ends it by terminating the worker, which frees its WebAssembly instance
+ * too: a native operation that never reaches QuickJS's interrupt handler cannot outlast its limits, and
+ * a program never blocks the host's event loop.
+ *
+ * Written in erasable TypeScript that imports nothing of the package at run time, so the module loads
+ * uncompiled as well.
+ */
+import { parentPort } from 'node:worker_threads';
+/** The file name the program's text is evaluated as: the host reads a failure's line in it from the stack. */
+const programFile = 'program.ts';
+/**
+ * Runs in the context before the program: it takes the host functions off the global object and
+ * defines `api`, `ApiError` and `console`. Only strings cross the boundary.
+ */
+const prelude = `'use strict';
+(() => {
+  const call = globalThis.__flexCall;
+  const log = globalThis.__flexLog;
+  const done = globalThis.__flexDone;
+  delete globalThis.__flexCall;
+  delete globalThis.__flexLog;
+  delete globalThis.__flexDone;
+  class ApiError extends Error {
+    constructor(details) {
+      const message = details && typeof details.message === 'string' ? details.message : JSON.stringify(details);
+      super(message);
+      this.name = 'ApiError';
+      this.details = details;
+    }
+  }
+  const invoke = (path, args) => {
+    if (!path) return Promise.reject(new TypeError('Call a method as api.<namespace>.<method>(params).'));
+    let params;
+    try {
+      // api.results.get(handle, { page, path }) reads a stored result.
+      const argument = path === 'results.get' && typeof args[0] === 'string'
+        ? Object.assign({}, args[1], { handle: args[0] })
+        : args[0];
+      params = JSON.stringify(args.length === 0 || argument === undefined ? {} : argument);
+    } catch (error) {
+      return Promise.reject(new TypeError('The params of ' + path + ' are not JSON: ' + error.message));
+    }
+    return call(path, params === undefined ? 'null' : params).then((text) => {
+      const outcome = JSON.parse(text);
+      if (outcome.ok) return outcome.value;
+      throw new ApiError(outcome.error);
+    });
+  };
+  const target = (path) => new Proxy(function () {}, {
+    get: (_target, key) => typeof key === 'string' && key !== 'then' ? target(path ? path + '.' + key : key) : undefined,
+    apply: (_target, _this, args) => invoke(path, args),
+    set: () => false,
+    defineProperty: () => false,
+    deleteProperty: () => false,
+  });
+  const format = (value) => {
+    if (typeof value === 'string') return value;
+    try {
+      const text = JSON.stringify(value);
+      return text === undefined ? String(value) : text;
+    } catch {
+      return String(value);
+    }
+  };
+  const writer = (level) => (...values) => { log(level, values.map(format).join(' ')); };
+  const fixed = (value) => ({ value, enumerable: false, writable: false, configurable: false });
+  Object.defineProperty(globalThis, 'api', fixed(target('')));
+  Object.defineProperty(globalThis, 'ApiError', fixed(ApiError));
+  Object.defineProperty(globalThis, 'console', fixed(Object.freeze({
+    log: writer('log'), info: writer('info'), warn: writer('warn'), error: writer('error'), debug: writer('debug'),
+  })));
+  const settle = (value) => {
+    try {
+      const text = JSON.stringify({ ok: true, value: value === undefined ? null : value });
+      return text === undefined ? JSON.stringify({ ok: true, value: null }) : text;
+    } catch (error) {
+      return JSON.stringify({ ok: false, name: 'TypeError', message: 'The return value is not JSON: ' + error.message });
+    }
+  };
+  const fail = (error) => JSON.stringify({
+    ok: false,
+    name: error && typeof error.name === 'string' ? error.name : 'Error',
+    message: error && typeof error.message === 'string' ? error.message : String(error),
+    stack: error && typeof error.stack === 'string' ? error.stack : '',
+    ...(error instanceof ApiError ? { details: error.details } : {}),
+  });
+  Object.defineProperty(globalThis, '__flexStart', {
+    configurable: true,
+    value: () => {
+      const main = globalThis.__flexMain;
+      delete globalThis.__flexStart;
+      delete globalThis.__flexMain;
+      main().then(settle, fail).then(done);
+    },
+  });
+})();
+`;
+/**
+ * One program in its QuickJS runtime. It enforces the limits QuickJS can see: memory, stack, console
+ * output, and computing time at every interrupt point. The host enforces the rest, and ends the worker
+ * when the program computes past its time between two interrupt points.
+ */
+class CodeWorkerRun {
+    report;
+    limits;
+    runtime;
+    vm;
+    deferreds = new Map();
+    nextCallId = 0;
+    cpuMs = 0;
+    enteredAt;
+    stopped;
+    ended = false;
+    logBytes = 0;
+    logsCut = false;
+    constructor(module, limits, report) {
+        this.limits = limits;
+        this.report = report;
+        this.runtime = module.newRuntime();
+        this.runtime.setMemoryLimit(limits.memoryBytes);
+        this.runtime.setMaxStackSize(limits.stackBytes);
+        this.runtime.setInterruptHandler(() => this.interrupted());
+        this.vm = this.runtime.newContext();
+        this.define('__flexCall', (pathHandle, paramsHandle) => this.call(this.vm.getString(pathHandle), this.vm.getString(paramsHandle)));
+        this.define('__flexLog', (levelHandle, textHandle) => {
+            this.log(this.vm.getString(levelHandle), this.vm.getString(textHandle));
+        });
+        this.define('__flexDone', (textHandle) => {
+            this.ended = true;
+            this.report({ kind: 'done', text: this.vm.getString(textHandle), unawaited: this.deferreds.size });
+        });
+    }
+    start(program) {
+        if (this.evaluate(prelude, 'prelude.js', 'prelude')
+            && this.evaluate(program, programFile, 'parse')
+            && this.evaluate('__flexStart();', 'start.js', 'program')) {
+            this.pump();
+        }
+        this.idle();
+    }
+    /** Settles a call of the program with the host's outcome, and runs what it unblocked. */
+    answer(id, text) {
+        const deferred = this.deferreds.get(id);
+        if (!deferred || this.ended)
+            return;
+        this.deferreds.delete(id);
+        const value = this.vm.newString(text);
+        deferred.resolve(value);
+        value.dispose();
+        this.pump();
+        this.idle();
+    }
+    define(name, implementation) {
+        const handle = this.vm.newFunction(name, implementation);
+        this.vm.setProp(this.vm.global, name, handle);
+        handle.dispose();
+    }
+    call(method, params) {
+        const deferred = this.vm.newPromise();
+        const id = this.nextCallId++;
+        this.deferreds.set(id, deferred);
+        this.report({ kind: 'call', id, method, params });
+        return deferred.handle;
+    }
+    log(level, text) {
+        if (this.logsCut)
+            return;
+        const line = `${level === 'log' ? '' : `[${level}] `}${text}\n`;
+        const bytes = Buffer.byteLength(line, 'utf8');
+        if (this.logBytes + bytes > this.limits.maxLogBytes) {
+            this.logsCut = true;
+            this.report({ kind: 'log', text: '[console output cut off]\n' });
+            return;
+        }
+        this.logBytes += bytes;
+        this.report({ kind: 'log', text: line });
+    }
+    evaluate(code, file, phase) {
+        if (this.over())
+            return false;
+        let result;
+        this.enter();
+        try {
+            result = this.vm.evalCode(code, file);
+        }
+        catch (error) {
+            this.hostThrow(error);
+            return false;
+        }
+        finally {
+            this.leave();
+        }
+        if (result.error) {
+            this.failWith(result.error, phase);
+            return false;
+        }
+        result.value.dispose();
+        return true;
+    }
+    /** Runs the program's pending jobs after a call settled or the program started. */
+    pump() {
+        if (this.over())
+            return;
+        let result;
+        this.enter();
+        try {
+            result = this.runtime.executePendingJobs();
+        }
+        catch (error) {
+            this.hostThrow(error);
+            return;
+        }
+        finally {
+            this.leave();
+        }
+        if (result.error)
+            this.failWith(result.error, 'program');
+    }
+    /** The worker's own stack ran out under deep recursion; anything else is a failure of the worker. */
+    hostThrow(error) {
+        if (!(error instanceof RangeError))
+            throw error;
+        this.stop('stack');
+    }
+    failWith(handle, phase) {
+        let dumped;
+        // Reading the thrown value can run program code, such as a toJSON: it counts as computing.
+        this.enter();
+        try {
+            dumped = this.vm.dump(handle);
+        }
+        catch {
+            dumped = undefined;
+        }
+        finally {
+            this.leave();
+        }
+        if (this.stopped) {
+            this.stop(this.stopped);
+            return;
+        }
+        this.ended = true;
+        const error = (dumped && typeof dumped === 'object' ? dumped : { message: String(dumped) });
+        this.report({
+            kind: 'failed',
+            phase,
+            ...(typeof error.name === 'string' ? { name: error.name } : {}),
+            ...(typeof error.message === 'string' ? { message: error.message } : {}),
+            ...(typeof error.stack === 'string' ? { stack: error.stack } : {}),
+            ...(phase === 'prelude' ? { dumped: JSON.stringify(dumped) } : {}),
+        });
+    }
+    stop(limit) {
+        this.stopped = limit;
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.report({ kind: 'stopped', limit });
+    }
+    over() {
+        return this.ended || this.stopped !== undefined;
+    }
+    idle() {
+        if (!this.over())
+            this.report({ kind: 'idle', cpuMs: this.cpuMs });
+    }
+    enter() {
+        this.enteredAt = performance.now();
+    }
+    leave() {
+        if (this.enteredAt === undefined)
+            return;
+        this.cpuMs += performance.now() - this.enteredAt;
+        this.enteredAt = undefined;
+    }
+    interrupted() {
+        if (this.stopped)
+            return true;
+        if (this.enteredAt !== undefined && this.cpuMs + performance.now() - this.enteredAt > this.limits.cpuMs) {
+            this.stopped = 'cpu';
+            return true;
+        }
+        return false;
+    }
+}
+const port = parentPort;
+if (port) {
+    // The variant's typings resolve as CommonJS; at run time the default export is the variant.
+    const [core, variant] = await Promise.all([
+        import('quickjs-emscripten-core'),
+        import('@jitl/quickjs-ng-wasmfile-release-sync'),
+    ]);
+    const quickjsVariant = variant.default;
+    const module = await core.newQuickJSWASMModuleFromVariant(quickjsVariant);
+    const report = (message) => port.postMessage(message);
+    let run;
+    port.on('message', (request) => {
+        if (request.kind === 'start') {
+            run = new CodeWorkerRun(module, request.limits, report);
+            run.start(request.program);
+        }
+        else {
+            run?.answer(request.id, request.text);
+        }
+    });
+    report({ kind: 'ready' });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codesandbox.worker.js","sourceRoot":"","sources":["../ts/classes.codesandbox.worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAiCjD,8GAA8G;AAC9G,MAAM,WAAW,GAAG,YAAY,CAAC;AAEjC;;;GAGG;AACH,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFf,CAAC;AAEF;;;;GAIG;AACH,MAAM,aAAa;IACA,MAAM,CAAsC;IAC5C,MAAM,CAAoB;IAC1B,OAAO,CAA0B;IACjC,EAAE,CAA0B;IAC5B,SAAS,GAAG,IAAI,GAAG,EAA2C,CAAC;IACxE,UAAU,GAAG,CAAC,CAAC;IACf,KAAK,GAAG,CAAC,CAAC;IACV,SAAS,CAAU;IACnB,OAAO,CAAmB;IAC1B,KAAK,GAAG,KAAK,CAAC;IACd,QAAQ,GAAG,CAAC,CAAC;IACb,OAAO,GAAG,KAAK,CAAC;IAExB,YAAY,MAA8B,EAAE,MAAyB,EAAE,MAA2C;QAChH,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;QACnC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;QACpC,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,UAAU,EAAE,YAAY,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACnI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE;YACnD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,UAAU,EAAE,EAAE;YACvC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAClB,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;QACrG,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,OAAe;QAC1B,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,EAAE,SAAS,CAAC;eAC9C,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC;eAC5C,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,CAAC;YAC5D,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,yFAAyF;IAClF,MAAM,CAAC,EAAU,EAAE,IAAY;QACpC,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO;QACpC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACtC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACxB,KAAK,CAAC,OAAO,EAAE,CAAC;QAChB,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAEO,MAAM,CAAC,IAAY,EAAE,cAAoF;QAC/G,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;QACzD,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QAC9C,MAAM,CAAC,OAAO,EAAE,CAAC;IACnB,CAAC;IAEO,IAAI,CAAC,MAAc,EAAE,MAAc;QACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC;QACtC,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAC7B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QAClD,OAAO,QAAQ,CAAC,MAAM,CAAC;IACzB,CAAC;IAEO,GAAG,CAAC,KAAa,EAAE,IAAY;QACrC,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QACzB,MAAM,IAAI,GAAG,GAAG,KAAK,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,GAAG,IAAI,IAAI,CAAC;QAChE,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC9C,IAAI,IAAI,CAAC,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YACpD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAC;YACjE,OAAO;QACT,CAAC;QACD,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC;QACvB,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC3C,CAAC;IAEO,QAAQ,CAAC,IAAY,EAAE,IAAY,EAAE,KAAuB;QAClE,IAAI,IAAI,CAAC,IAAI,EAAE;YAAE,OAAO,KAAK,CAAC;QAC9B,IAAI,MAA8B,CAAC;QACnC,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACxC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACtB,OAAO,KAAK,CAAC;QACf,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,CAAC;QACD,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YACjB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACnC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,mFAAmF;IAC3E,IAAI;QACV,IAAI,IAAI,CAAC,IAAI,EAAE;YAAE,OAAO;QACxB,IAAI,MAA0C,CAAC;QAC/C,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,CAAC;QAC7C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACtB,OAAO;QACT,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,CAAC;QACD,IAAI,MAAM,CAAC,KAAK;YAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAC3D,CAAC;IAED,qGAAqG;IAC7F,SAAS,CAAC,KAAc;QAC9B,IAAI,CAAC,CAAC,KAAK,YAAY,UAAU,CAAC;YAAE,MAAM,KAAK,CAAC;QAChD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrB,CAAC;IAEO,QAAQ,CAAC,MAA8B,EAAE,KAAuB;QACtE,IAAI,MAAe,CAAC;QACpB,2FAA2F;QAC3F,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,GAAG,SAAS,CAAC;QACrB,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACxB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,MAAM,KAAK,GAAG,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAEzF,CAAC;QACF,IAAI,CAAC,MAAM,CAAC;YACV,IAAI,EAAE,QAAQ;YACd,KAAK;YACL,GAAG,CAAC,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/D,GAAG,CAAC,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxE,GAAG,CAAC,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAClE,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACnE,CAAC,CAAC;IACL,CAAC;IAEO,IAAI,CAAC,KAAsB;QACjC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO;QACvB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;IAC1C,CAAC;IAEO,IAAI;QACV,OAAO,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC;IAClD,CAAC;IAEO,IAAI;QACV,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YAAE,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IACrE,CAAC;IAEO,KAAK;QACX,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IACrC,CAAC;IAEO,KAAK;QACX,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO;QACzC,IAAI,CAAC,KAAK,IAAI,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;QACjD,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAC9B,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACxG,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AAED,MAAM,IAAI,GAAG,UAAU,CAAC;AACxB,IAAI,IAAI,EAAE,CAAC;IACT,4FAA4F;IAC5F,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QACxC,MAAM,CAAC,yBAAyB,CAAC;QACjC,MAAM,CAAC,wCAAwC,CAAC;KACjD,CAAC,CAAC;IACH,MAAM,cAAc,GAAI,OAAgC,CAAC,OAAqE,CAAC;IAC/H,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,cAAc,CAAsC,CAAC;IAC/G,MAAM,MAAM,GAAG,CAAC,OAA0B,EAAQ,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAC/E,IAAI,GAA8B,CAAC;IACnC,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAA2B,EAAE,EAAE;QACjD,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC7B,GAAG,GAAG,IAAI,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YACxD,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,GAAG,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QACxC,CAAC;IACH,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAC5B,CAAC"}

package/dist_ts/classes.flexharness.callbacks.d.ts

@@ -1,7 +1,7 @@
 import * as plugins from './plugins.js';
 import { type TFlexAgentToolCallUpdateEvent, type TFlexAgentToolCallFinishEvent } from './interfaces.js';
 import { type ISessionMetricsOperation } from './utils.sessionmetrics.js';
-import type { IStoredSessionState, IStorageState, IActiveRun } from './interfaces.flexharness.js';
+import type { IStoredSessionState, IStorageState, IActiveRun, IProgramCallbackShare } from './interfaces.flexharness.js';
 import type { FlexHarnessCore } from './classes.flexharness.core.js';
 /** The model stream callbacks of a run: text, reasoning, tool, retry and usage events. */
 export declare class FlexHarnessRunCallbacks<TScope> {
@@ -11,6 +11,13 @@ export declare class FlexHarnessRunCallbacks<TScope> {
     onReasoningStart(state: IStorageState, sessionId: string, id: string): void;
     onReasoningDelta(state: IStorageState, sessionId: string, id: string, delta: string): void;
     onReasoningEnd(state: IStorageState, sessionId: string, id: string, text: string): void;
+    /**
+     * Completes the text parts of a committed model step: their text is final and saved. A text part
+     * completes once, so the terminal projection completes only the text parts of a step that did
+     * not commit. Like the terminal's completions, these events are outside the callback limits:
+     * their number is bounded by the run's parts.
+     */
+    onStepCommitted(state: IStorageState, sessionId: string): void;
     private textAppendAccounting;
     onToolStart(state: IStorageState, sessionId: string, event: {
         toolCallId: string;
@@ -19,6 +26,32 @@ export declare class FlexHarnessRunCallbacks<TScope> {
         parentToolCallId?: string;
     }): void;
     onToolFinish(state: IStorageState, sessionId: string, event: TFlexAgentToolCallFinishEvent): void;
+    /**
+     * The room a `run_code` program's calls get in the run's callback limits: half of what the run
+     * has left once its program's answer is set aside. The rest stays for the model's next steps.
+     */
+    programCallbackShare(state: IStorageState, sessionId: string): IProgramCallbackShare;
+    /**
+     * Records the start of a call a program made, in the program's share. The call takes the room of
+     * its input, its two events and at least a truncated output now. A call the share or the run
+     * cannot hold is not recorded, and the answer is false: the program stops, the run goes on.
+     */
+    onProgramCallStart(state: IStorageState, sessionId: string, share: IProgramCallbackShare, event: {
+        toolCallId: string;
+        toolName: string;
+        input: unknown;
+        parentToolCallId: string;
+    }): boolean;
+    /**
+     * Records how a call `onProgramCallStart` recorded ended. Its output or error is recorded in what
+     * is left of the share, cut to fit: the program gets the call's answer whole all the same.
+     */
+    onProgramCallFinish(state: IStorageState, sessionId: string, share: IProgramCallbackShare, event: TFlexAgentToolCallFinishEvent): void;
+    private startToolPart;
+    private runningToolPart;
+    /** A finished call's output in at most `maxOutputBytes`, or its projected error. */
+    private toolOutcome;
+    private completeToolPart;
     onToolUpdate(state: IStorageState, sessionId: string, event: TFlexAgentToolCallUpdateEvent): void;
     onRetry(state: IStorageState, sessionId: string, retry: plugins.IAgentRetryEvent): void;
     /**
@@ -33,6 +66,9 @@ export declare class FlexHarnessRunCallbacks<TScope> {
     onModelCallUsage(state: IStorageState, stored: IStoredSessionState, event: plugins.TAgentModelCallUsageEvent): void;
     settleMetricsOperation(state: IStorageState, stored: IStoredSessionState, operation: ISessionMetricsOperation): Promise<void>;
     private callbackRun;
+    /** Reserves room in the run's callback limits; a reservation past them fails the run. */
     reserveCallbackCapacity(run: IActiveRun, eventCount: number, outputBytes: number, partCount: number): boolean;
+    /** Reserves room in the run's callback limits; false, reserving nothing, when it does not fit. */
+    private tryReserveCallbackCapacity;
     private failCallback;
 }