@serve.zone/interfaces 32.35.0 → 32.36.0

package/dist_ts/data/runtimeassignmentexec.d.ts

@@ -0,0 +1,110 @@
+import type { IRuntimeAssignment, IRuntimeAssignmentReference } from './runtimeassignment.js';
+import type { IRuntimeSessionBinding } from './runtimesession.js';
+/** A terminal's size in character cells. */
+export interface IRuntimeTerminalSize {
+    columns: number;
+    rows: number;
+}
+/**
+ * A controller's request to run one command inside one running attempt's container.
+ *
+ * `command` is the argument vector the runtime executes directly: no shell parses it unless its
+ * first element names one. With `tty` the process runs on a terminal of `terminalSize`, which is
+ * stated exactly then; its output arrives on one stream. Without it stdout and stderr arrive on
+ * separate streams. Standard input is the optional stream the TypedRequest carries beside this
+ * body; its end is the process's end of input.
+ */
+export interface IOpenRuntimeAssignmentExecRequest {
+    session: IRuntimeSessionBinding;
+    /** The exact current revision of a `run` assignment on this node. */
+    assignment: IRuntimeAssignmentReference;
+    command: string[];
+    tty: boolean;
+    terminalSize: IRuntimeTerminalSize | null;
+}
+/**
+ * The node's answer once the process runs. `execId` names the session in later requests;
+ * `idleTimeoutMs` is how long the session may carry no byte in either direction before the node
+ * ends it.
+ */
+export interface IOpenRuntimeAssignmentExecResponse {
+    execId: string;
+    assignment: IRuntimeAssignmentReference;
+    tty: boolean;
+    idleTimeoutMs: number;
+}
+/** A new terminal size for a `tty` session. */
+export interface IResizeRuntimeAssignmentExecRequest {
+    session: IRuntimeSessionBinding;
+    execId: string;
+    terminalSize: IRuntimeTerminalSize;
+}
+export interface IResizeRuntimeAssignmentExecResponse {
+    execId: string;
+}
+/** Ends a session and releases its slot, whether or not its process has exited. */
+export interface ICloseRuntimeAssignmentExecRequest {
+    session: IRuntimeSessionBinding;
+    execId: string;
+}
+/**
+ * Why the node ended a process before it exited: `closed` by this request, `idle-timeout` after
+ * `idleTimeoutMs` without a byte, `container-stopped` because its container stopped.
+ */
+export type TRuntimeAssignmentExecTermination = 'closed' | 'idle-timeout' | 'container-stopped';
+/**
+ * How the session ended. `exited` carries the process's `exitCode`, 128 plus the signal number
+ * for a process a signal ended; `terminated` states why the node ended it and carries no code.
+ */
+export interface ICloseRuntimeAssignmentExecResponse {
+    execId: string;
+    outcome: 'exited' | 'terminated';
+    exitCode: number | null;
+    termination: TRuntimeAssignmentExecTermination | null;
+}
+/**
+ * Exec runs only for a controller on the node's own host (`controller.kind: 'onebox'`, which only a
+ * local controller binding carries), and only on the connection that holds its session. A session
+ * lives until it is closed, or until the node ends it: after `idleTimeoutMs` without a byte, when
+ * its container stops, or when the controller session it was opened under ends, in which case its
+ * `execId` is gone with it. An ended session keeps its slot and its outcome until it is closed.
+ */
+export declare const runtimeAssignmentExecContract: Readonly<{
+    readonly error: "Runtime assignment exec contract rejected.";
+    readonly controllerKind: "onebox";
+    /** Open sessions per node, ended ones not yet closed included; one more is refused. */
+    readonly maximumSessions: 4;
+    readonly idleTimeoutMs: 900000;
+    readonly maximumCommandArguments: 256;
+    /** The UTF-8 bytes of every argument together. */
+    readonly maximumCommandBytes: 65536;
+    /** The largest terminal dimension, the width of the runtime's own size field. */
+    readonly maximumTerminalDimension: 65535;
+    readonly maximumExitCode: 255;
+}>;
+export declare const snapshotOpenRuntimeAssignmentExecRequest: (valueArg: unknown) => IOpenRuntimeAssignmentExecRequest;
+export declare const snapshotOpenRuntimeAssignmentExecResponse: (valueArg: unknown) => IOpenRuntimeAssignmentExecResponse;
+export declare const snapshotResizeRuntimeAssignmentExecRequest: (valueArg: unknown) => IResizeRuntimeAssignmentExecRequest;
+export declare const snapshotResizeRuntimeAssignmentExecResponse: (valueArg: unknown) => IResizeRuntimeAssignmentExecResponse;
+export declare const snapshotCloseRuntimeAssignmentExecRequest: (valueArg: unknown) => ICloseRuntimeAssignmentExecRequest;
+export declare const snapshotCloseRuntimeAssignmentExecResponse: (valueArg: unknown) => ICloseRuntimeAssignmentExecResponse;
+/**
+ * Node-side content binding, not authentication. `trustedSessionArg` is the node's CURRENT
+ * session, the request must have arrived on that session's own connection, and that session must
+ * be a local controller's. `assignmentArg` is the node's current admitted revision of the named
+ * assignment: the request must name exactly it, it must be a `run` assignment, and it must belong
+ * to the session's controller, node and runtime namespace. Whether its container runs is the
+ * node's own check.
+ */
+export declare const bindOpenRuntimeAssignmentExecRequest: (valueArg: unknown, assignmentArg: unknown, trustedSessionArg: unknown) => Promise<{
+    request: IOpenRuntimeAssignmentExecRequest;
+    assignment: IRuntimeAssignment;
+}>;
+/** Matches an opened session to the request: the same assignment revision and terminal mode. */
+export declare const bindOpenRuntimeAssignmentExecResponse: (valueArg: unknown, requestArg: unknown) => IOpenRuntimeAssignmentExecResponse;
+/** Node-side content binding of a resize; which sessions exist and are `tty` is the node's check. */
+export declare const bindResizeRuntimeAssignmentExecRequest: (valueArg: unknown, trustedSessionArg: unknown) => IResizeRuntimeAssignmentExecRequest;
+export declare const bindResizeRuntimeAssignmentExecResponse: (valueArg: unknown, requestArg: unknown) => IResizeRuntimeAssignmentExecResponse;
+/** Node-side content binding of a close; which sessions exist is the node's check. */
+export declare const bindCloseRuntimeAssignmentExecRequest: (valueArg: unknown, trustedSessionArg: unknown) => ICloseRuntimeAssignmentExecRequest;
+export declare const bindCloseRuntimeAssignmentExecResponse: (valueArg: unknown, requestArg: unknown) => ICloseRuntimeAssignmentExecResponse;

package/dist_ts/data/runtimeassignmentexec.js

@@ -0,0 +1,164 @@
+import { getRuntimeAssignmentReference, snapshotRuntimeAssignment, validateRuntimeAssignment } from './runtimeassignment.js';
+import { snapshotRuntimeSessionBinding } from './runtimesession.js';
+import { captureNetwork, networkCounter, networkDigest, networkEqual, networkId, networkRecord, requireNetwork, } from '../private/networkcontract.js';
+/**
+ * Exec runs only for a controller on the node's own host (`controller.kind: 'onebox'`, which only a
+ * local controller binding carries), and only on the connection that holds its session. A session
+ * lives until it is closed, or until the node ends it: after `idleTimeoutMs` without a byte, when
+ * its container stops, or when the controller session it was opened under ends, in which case its
+ * `execId` is gone with it. An ended session keeps its slot and its outcome until it is closed.
+ */
+export const runtimeAssignmentExecContract = Object.freeze({
+    error: 'Runtime assignment exec contract rejected.',
+    controllerKind: 'onebox',
+    /** Open sessions per node, ended ones not yet closed included; one more is refused. */
+    maximumSessions: 4,
+    idleTimeoutMs: 900_000,
+    maximumCommandArguments: 256,
+    /** The UTF-8 bytes of every argument together. */
+    maximumCommandBytes: 65_536,
+    /** The largest terminal dimension, the width of the runtime's own size field. */
+    maximumTerminalDimension: 65_535,
+    maximumExitCode: 255,
+});
+const fail = () => { throw new Error(runtimeAssignmentExecContract.error); };
+const safe = (operationArg) => { try {
+    return operationArg();
+}
+catch {
+    return fail();
+} };
+const encoder = new TextEncoder();
+const terminations = ['closed', 'idle-timeout', 'container-stopped'];
+const referenceOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['assignmentId', 'generation', 'digest']);
+    return {
+        assignmentId: networkId(value.assignmentId), generation: networkCounter(value.generation),
+        digest: networkDigest(value.digest),
+    };
+};
+const terminalSizeOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['columns', 'rows']);
+    return {
+        columns: networkCounter(value.columns, runtimeAssignmentExecContract.maximumTerminalDimension),
+        rows: networkCounter(value.rows, runtimeAssignmentExecContract.maximumTerminalDimension),
+    };
+};
+const commandOf = (valueArg) => {
+    requireNetwork(Array.isArray(valueArg) && valueArg.length > 0
+        && valueArg.length <= runtimeAssignmentExecContract.maximumCommandArguments);
+    let bytes = 0;
+    const command = valueArg.map((argumentArg) => {
+        requireNetwork(typeof argumentArg === 'string' && !argumentArg.includes('\0'));
+        bytes += encoder.encode(argumentArg).byteLength;
+        return argumentArg;
+    });
+    requireNetwork(command[0].length > 0 && bytes <= runtimeAssignmentExecContract.maximumCommandBytes);
+    return command;
+};
+export const snapshotOpenRuntimeAssignmentExecRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['session', 'assignment', 'command', 'tty', 'terminalSize']);
+    requireNetwork(typeof value.tty === 'boolean' && (value.tty === (value.terminalSize !== null)));
+    return {
+        session: snapshotRuntimeSessionBinding(value.session), assignment: referenceOf(value.assignment),
+        command: commandOf(value.command), tty: value.tty,
+        terminalSize: value.terminalSize === null ? null : terminalSizeOf(value.terminalSize),
+    };
+});
+export const snapshotOpenRuntimeAssignmentExecResponse = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['execId', 'assignment', 'tty', 'idleTimeoutMs']);
+    requireNetwork(typeof value.tty === 'boolean'
+        && value.idleTimeoutMs === runtimeAssignmentExecContract.idleTimeoutMs);
+    return {
+        execId: networkId(value.execId), assignment: referenceOf(value.assignment), tty: value.tty,
+        idleTimeoutMs: runtimeAssignmentExecContract.idleTimeoutMs,
+    };
+});
+export const snapshotResizeRuntimeAssignmentExecRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['session', 'execId', 'terminalSize']);
+    return {
+        session: snapshotRuntimeSessionBinding(value.session), execId: networkId(value.execId),
+        terminalSize: terminalSizeOf(value.terminalSize),
+    };
+});
+export const snapshotResizeRuntimeAssignmentExecResponse = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['execId']);
+    return { execId: networkId(value.execId) };
+});
+export const snapshotCloseRuntimeAssignmentExecRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['session', 'execId']);
+    return { session: snapshotRuntimeSessionBinding(value.session), execId: networkId(value.execId) };
+});
+export const snapshotCloseRuntimeAssignmentExecResponse = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['execId', 'outcome', 'exitCode', 'termination']);
+    const execId = networkId(value.execId);
+    if (value.outcome === 'exited') {
+        requireNetwork(typeof value.exitCode === 'number' && Number.isSafeInteger(value.exitCode)
+            && value.exitCode >= 0 && !Object.is(value.exitCode, -0)
+            && value.exitCode <= runtimeAssignmentExecContract.maximumExitCode && value.termination === null);
+        return { execId, outcome: 'exited', exitCode: value.exitCode, termination: null };
+    }
+    requireNetwork(value.outcome === 'terminated' && value.exitCode === null
+        && terminations.includes(value.termination));
+    return {
+        execId, outcome: 'terminated', exitCode: null,
+        termination: value.termination,
+    };
+});
+/** Exec is a local controller's alone; `trustedSessionArg` decides, never a request field. */
+const requireLocalSession = (requestSessionArg, trustedSessionArg) => {
+    const trustedSession = safe(() => snapshotRuntimeSessionBinding(trustedSessionArg));
+    safe(() => requireNetwork(networkEqual(requestSessionArg, trustedSession)
+        && trustedSession.controller.kind === runtimeAssignmentExecContract.controllerKind));
+};
+/**
+ * Node-side content binding, not authentication. `trustedSessionArg` is the node's CURRENT
+ * session, the request must have arrived on that session's own connection, and that session must
+ * be a local controller's. `assignmentArg` is the node's current admitted revision of the named
+ * assignment: the request must name exactly it, it must be a `run` assignment, and it must belong
+ * to the session's controller, node and runtime namespace. Whether its container runs is the
+ * node's own check.
+ */
+export const bindOpenRuntimeAssignmentExecRequest = async (valueArg, assignmentArg, trustedSessionArg) => {
+    const request = snapshotOpenRuntimeAssignmentExecRequest(valueArg);
+    requireLocalSession(request.session, trustedSessionArg);
+    const assignment = safe(() => snapshotRuntimeAssignment(assignmentArg));
+    if ((await validateRuntimeAssignment(assignment)).length)
+        fail();
+    safe(() => requireNetwork(assignment.disposition === 'run'
+        && networkEqual(assignment.controller, request.session.controller)
+        && assignment.nodeId === request.session.nodeId
+        && assignment.runtimeNamespace === request.session.runtimeNamespace
+        && networkEqual(request.assignment, getRuntimeAssignmentReference(assignment))));
+    return { request, assignment };
+};
+/** Matches an opened session to the request: the same assignment revision and terminal mode. */
+export const bindOpenRuntimeAssignmentExecResponse = (valueArg, requestArg) => safe(() => {
+    const response = snapshotOpenRuntimeAssignmentExecResponse(valueArg);
+    const request = snapshotOpenRuntimeAssignmentExecRequest(requestArg);
+    requireNetwork(networkEqual(response.assignment, request.assignment) && response.tty === request.tty);
+    return response;
+});
+/** Node-side content binding of a resize; which sessions exist and are `tty` is the node's check. */
+export const bindResizeRuntimeAssignmentExecRequest = (valueArg, trustedSessionArg) => {
+    const request = snapshotResizeRuntimeAssignmentExecRequest(valueArg);
+    requireLocalSession(request.session, trustedSessionArg);
+    return request;
+};
+export const bindResizeRuntimeAssignmentExecResponse = (valueArg, requestArg) => safe(() => {
+    const response = snapshotResizeRuntimeAssignmentExecResponse(valueArg);
+    requireNetwork(response.execId === snapshotResizeRuntimeAssignmentExecRequest(requestArg).execId);
+    return response;
+});
+/** Node-side content binding of a close; which sessions exist is the node's check. */
+export const bindCloseRuntimeAssignmentExecRequest = (valueArg, trustedSessionArg) => {
+    const request = snapshotCloseRuntimeAssignmentExecRequest(valueArg);
+    requireLocalSession(request.session, trustedSessionArg);
+    return request;
+};
+export const bindCloseRuntimeAssignmentExecResponse = (valueArg, requestArg) => safe(() => {
+    const response = snapshotCloseRuntimeAssignmentExecResponse(valueArg);
+    requireNetwork(response.execId === snapshotCloseRuntimeAssignmentExecRequest(requestArg).execId);
+    return response;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignmentexec.js","sourceRoot":"","sources":["../../ts/data/runtimeassignmentexec.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAE7H,OAAO,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EACL,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,GACtG,MAAM,+BAA+B,CAAC;AAwEvC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,MAAM,CAAC;IACzD,KAAK,EAAE,4CAA4C;IACnD,cAAc,EAAE,QAAQ;IACxB,uFAAuF;IACvF,eAAe,EAAE,CAAC;IAClB,aAAa,EAAE,OAAO;IACtB,uBAAuB,EAAE,GAAG;IAC5B,kDAAkD;IAClD,mBAAmB,EAAE,MAAM;IAC3B,iFAAiF;IACjF,wBAAwB,EAAE,MAAM;IAChC,eAAe,EAAE,GAAG;CACZ,CAAC,CAAC;AAEZ,MAAM,IAAI,GAAG,GAAU,EAAE,GAAG,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACpF,MAAM,IAAI,GAAG,CAAI,YAAqB,EAAK,EAAE,GAAG,IAAI,CAAC;IAAC,OAAO,YAAY,EAAE,CAAC;AAAC,CAAC;AAAC,MAAM,CAAC;IAAC,OAAO,IAAI,EAAE,CAAC;AAAC,CAAC,CAAC,CAAC,CAAC;AAC1G,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;AAClC,MAAM,YAAY,GAAG,CAAC,QAAQ,EAAE,cAAc,EAAE,mBAAmB,CAAU,CAAC;AAE9E,MAAM,WAAW,GAAG,CAAC,QAAiB,EAA+B,EAAE;IACrE,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,cAAc,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC;IAChF,OAAO;QACL,YAAY,EAAE,SAAS,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,UAAU,EAAE,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC;QACzF,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC;KACpC,CAAC;AACJ,CAAC,CAAC;AACF,MAAM,cAAc,GAAG,CAAC,QAAiB,EAAwB,EAAE;IACjE,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3D,OAAO;QACL,OAAO,EAAE,cAAc,CAAC,KAAK,CAAC,OAAO,EAAE,6BAA6B,CAAC,wBAAwB,CAAC;QAC9F,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,6BAA6B,CAAC,wBAAwB,CAAC;KACzF,CAAC;AACJ,CAAC,CAAC;AACF,MAAM,SAAS,GAAG,CAAC,QAAiB,EAAY,EAAE;IAChD,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;WACxD,QAAQ,CAAC,MAAM,IAAI,6BAA6B,CAAC,uBAAuB,CAAC,CAAC;IAC/E,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,OAAO,GAAI,QAAsB,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE;QAC1D,cAAc,CAAC,OAAO,WAAW,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAC/E,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,UAAU,CAAC;QAChD,OAAO,WAAW,CAAC;IACrB,CAAC,CAAC,CAAC;IACH,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,IAAI,6BAA6B,CAAC,mBAAmB,CAAC,CAAC;IACpG,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,wCAAwC,GAAG,CACtD,QAAiB,EACkB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAChD,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC;IACnH,cAAc,CAAC,OAAO,KAAK,CAAC,GAAG,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;IAChG,OAAO;QACL,OAAO,EAAE,6BAA6B,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC,UAAU,CAAC;QAChG,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG;QACjD,YAAY,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,YAAY,CAAC;KACtF,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yCAAyC,GAAG,CACvD,QAAiB,EACmB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IACjD,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC;IACxG,cAAc,CAAC,OAAO,KAAK,CAAC,GAAG,KAAK,SAAS;WACxC,KAAK,CAAC,aAAa,KAAK,6BAA6B,CAAC,aAAa,CAAC,CAAC;IAC1E,OAAO;QACL,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG;QAC1F,aAAa,EAAE,6BAA6B,CAAC,aAAa;KAC3D,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,0CAA0C,GAAG,CACxD,QAAiB,EACoB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAClD,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC;IAC7F,OAAO;QACL,OAAO,EAAE,6BAA6B,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC;QACtF,YAAY,EAAE,cAAc,CAAC,KAAK,CAAC,YAAY,CAAC;KACjD,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,2CAA2C,GAAG,CACzD,QAAiB,EACqB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IACnD,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAClE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;AAC7C,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yCAAyC,GAAG,CACvD,QAAiB,EACmB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IACjD,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC7E,OAAO,EAAE,OAAO,EAAE,6BAA6B,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;AACpG,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,0CAA0C,GAAG,CACxD,QAAiB,EACoB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAClD,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC;IACxG,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACvC,IAAI,KAAK,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;QAC/B,cAAc,CAAC,OAAO,KAAK,CAAC,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC;eACpF,KAAK,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;eACrD,KAAK,CAAC,QAAQ,IAAI,6BAA6B,CAAC,eAAe,IAAI,KAAK,CAAC,WAAW,KAAK,IAAI,CAAC,CAAC;QACpG,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;IACpF,CAAC;IACD,cAAc,CAAC,KAAK,CAAC,OAAO,KAAK,YAAY,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI;WAClE,YAAmC,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;IACvE,OAAO;QACL,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI;QAC7C,WAAW,EAAE,KAAK,CAAC,WAAgD;KACpE,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,8FAA8F;AAC9F,MAAM,mBAAmB,GAAG,CAAC,iBAAyC,EAAE,iBAA0B,EAAQ,EAAE;IAC1G,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,6BAA6B,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACpF,IAAI,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC;WACpE,cAAc,CAAC,UAAU,CAAC,IAAI,KAAK,6BAA6B,CAAC,cAAc,CAAC,CAAC,CAAC;AACzF,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,KAAK,EACvD,QAAiB,EAAE,aAAsB,EAAE,iBAA0B,EACoB,EAAE;IAC3F,MAAM,OAAO,GAAG,wCAAwC,CAAC,QAAQ,CAAC,CAAC;IACnE,mBAAmB,CAAC,OAAO,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IACxD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC,aAAa,CAAC,CAAC,CAAC;IACxE,IAAI,CAAC,MAAM,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM;QAAE,IAAI,EAAE,CAAC;IACjE,IAAI,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,UAAU,CAAC,WAAW,KAAK,KAAK;WACrD,YAAY,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;WAC/D,UAAU,CAAC,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,MAAM;WAC5C,UAAU,CAAC,gBAAgB,KAAK,OAAO,CAAC,OAAO,CAAC,gBAAgB;WAChE,YAAY,CAAC,OAAO,CAAC,UAAU,EAAE,6BAA6B,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IACnF,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,gGAAgG;AAChG,MAAM,CAAC,MAAM,qCAAqC,GAAG,CACnD,QAAiB,EAAE,UAAmB,EACF,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IACjD,MAAM,QAAQ,GAAG,yCAAyC,CAAC,QAAQ,CAAC,CAAC;IACrE,MAAM,OAAO,GAAG,wCAAwC,CAAC,UAAU,CAAC,CAAC;IACrE,cAAc,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,IAAI,QAAQ,CAAC,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACtG,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,CAAC;AAEH,qGAAqG;AACrG,MAAM,CAAC,MAAM,sCAAsC,GAAG,CACpD,QAAiB,EAAE,iBAA0B,EACR,EAAE;IACvC,MAAM,OAAO,GAAG,0CAA0C,CAAC,QAAQ,CAAC,CAAC;IACrE,mBAAmB,CAAC,OAAO,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IACxD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,uCAAuC,GAAG,CACrD,QAAiB,EAAE,UAAmB,EACA,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IACnD,MAAM,QAAQ,GAAG,2CAA2C,CAAC,QAAQ,CAAC,CAAC;IACvE,cAAc,CAAC,QAAQ,CAAC,MAAM,KAAK,0CAA0C,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;IAClG,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,CAAC;AAEH,sFAAsF;AACtF,MAAM,CAAC,MAAM,qCAAqC,GAAG,CACnD,QAAiB,EAAE,iBAA0B,EACT,EAAE;IACtC,MAAM,OAAO,GAAG,yCAAyC,CAAC,QAAQ,CAAC,CAAC;IACpE,mBAAmB,CAAC,OAAO,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IACxD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sCAAsC,GAAG,CACpD,QAAiB,EAAE,UAAmB,EACD,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAClD,MAAM,QAAQ,GAAG,0CAA0C,CAAC,QAAQ,CAAC,CAAC;IACtE,cAAc,CAAC,QAAQ,CAAC,MAAM,KAAK,yCAAyC,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;IACjG,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist_ts/data/runtimeassignmentlogs.d.ts

@@ -0,0 +1,121 @@
+import type { IRuntimeAssignment } from './runtimeassignment.js';
+import type { IRuntimeConfigLogPolicy } from './runtimeconfig.js';
+import type { IRuntimeSessionBinding } from './runtimesession.js';
+/** The container output a log line was written to. */
+export type TRuntimeAssignmentLogStream = 'stdout' | 'stderr';
+/**
+ * One piece of one line a container wrote, as the runtime captured it.
+ *
+ * `text` holds no line terminator and no `\n`; the node decodes the captured bytes as UTF-8 and
+ * replaces an invalid sequence with U+FFFD. A line longer than one entry travels as consecutive
+ * entries of the same stream: every piece but the last states `partial: true`, and the receiver
+ * joins them. The joined line is at most the config's `logs.maximumLineBytes` UTF-8 bytes; the node
+ * cuts a longer one there and follows its last piece with a `line-cut` loss of the same stream.
+ */
+export interface IRuntimeAssignmentLogLine {
+    kind: 'line';
+    stream: TRuntimeAssignmentLogStream;
+    /** When the runtime captured the piece, in nanoseconds since the Unix epoch, as decimal digits. */
+    timestampNs: string;
+    text: string;
+    /** The line continues in the next `line` entry of the same stream. */
+    partial: boolean;
+}
+/**
+ * Why output did not reach the controller.
+ *
+ * - `buffer-overflow`: the node's buffer held `logs.maximumBufferedBytes` unacknowledged bytes and
+ *   the oldest were dropped to keep capturing;
+ * - `line-cut`: the rest of a line beyond `logs.maximumLineBytes`;
+ * - `capture-restart`: the node's capture restarted without its buffer, for example after a reboot
+ *   emptied its disposable capture directory; how much was lost is unknown;
+ * - `not-captured`: the container was started without output capture, so none of its output is
+ *   available; how much there was is unknown.
+ */
+export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured';
+/**
+ * Evidence of output that was lost, in the position of the stream where it was lost.
+ *
+ * `bytes` and `lines` count exactly what was dropped; both are `null` for `capture-restart` and
+ * `not-captured`, whose extent the node cannot know, and both are stated for the other reasons.
+ * A `line-cut` counts the cut bytes and no line, because the line itself was delivered; it names
+ * the stream of that line. A `buffer-overflow` counts the dropped bytes and the whole lines among
+ * them, and names a stream only when every dropped byte came from it.
+ */
+export interface IRuntimeAssignmentLogLoss {
+    kind: 'lost';
+    reason: TRuntimeAssignmentLogLossReason;
+    stream: TRuntimeAssignmentLogStream | null;
+    /** When the node detected the loss, in nanoseconds since the Unix epoch, as decimal digits. */
+    timestampNs: string;
+    bytes: number | null;
+    lines: number | null;
+}
+export type TRuntimeAssignmentLogEntry = IRuntimeAssignmentLogLine | IRuntimeAssignmentLogLoss;
+/**
+ * One delivery of one attempt's captured output, in capture order.
+ *
+ * `captureId` names one capture of the attempt on its node: the node starts a new capture, with a
+ * new id and `sequence` 1, whenever it cannot continue the previous one, and opens it with a
+ * `capture-restart` loss. Within a capture `sequence` counts batches from 1 without gaps, and the
+ * node sends the next batch only after the controller acknowledged the previous one, so a batch is
+ * the one unit of retry. `final` states that no batch follows in this capture: the container is gone
+ * and its output is drained. Only a final batch may be empty.
+ */
+export interface IRuntimeAssignmentLogBatch {
+    assignmentId: string;
+    attemptId: string;
+    captureId: string;
+    sequence: number;
+    entries: TRuntimeAssignmentLogEntry[];
+    final: boolean;
+}
+/** Pallet push over its current authenticated session. */
+export interface IReportRuntimeAssignmentLogsRequest {
+    session: IRuntimeSessionBinding;
+    batch: IRuntimeAssignmentLogBatch;
+}
+/**
+ * The controller holds the batch durably. `replay` answers a batch it already holds, which it does
+ * not store again. It never refuses a batch for a gap in `sequence`: the node discards only what
+ * was acknowledged, so a missing batch can only be the controller's own loss, which it records.
+ */
+export interface IReportRuntimeAssignmentLogsResponse {
+    status: 'accepted' | 'replay';
+    assignmentId: string;
+    captureId: string;
+    sequence: number;
+}
+export declare const runtimeAssignmentLogContract: Readonly<{
+    readonly error: "Runtime assignment log contract rejected.";
+    /** Pallet pushes; the controller persists metadata and payloads and acknowledges by sequence. */
+    readonly delivery: "node-pushes-controller-acknowledges-each-batch";
+    /** The most entries in one batch. */
+    readonly maximumEntriesPerBatch: 1024;
+    /** The most UTF-8 bytes of `text` in one entry; a longer line travels as `partial` pieces. */
+    readonly maximumEntryTextBytes: 65536;
+    /**
+     * The canonical JSON of a whole report is at most one mebibyte, the bound every runtime network
+     * contract captures with; the node closes a batch before the next entry would cross it.
+     */
+    readonly maximumReportCanonicalBytes: 1048576;
+}>;
+/** Detached exact-schema snapshot of one batch, bounded like a whole report. */
+export declare const snapshotRuntimeAssignmentLogBatch: (valueArg: unknown) => IRuntimeAssignmentLogBatch;
+export declare const snapshotReportRuntimeAssignmentLogsRequest: (valueArg: unknown) => IReportRuntimeAssignmentLogsRequest;
+export declare const snapshotReportRuntimeAssignmentLogsResponse: (valueArg: unknown) => IReportRuntimeAssignmentLogsResponse;
+/**
+ * Controller-side content binding, not authentication. `trustedSessionArg` is the controller's
+ * CURRENT session with the node the report arrived on, never read from the request. `assignmentArg`
+ * is the controller's own record of the batch's assignment, any generation of it, and
+ * `logPolicyArg` the `logs` policy of the config it runs with. The request's session must equal the
+ * trusted one, the assignment must be this node's and carry the batch's attempt, and every line
+ * the batch holds, its pieces joined, must fit the policy's `maximumLineBytes`. A line whose first
+ * pieces travelled in an earlier batch is judged by the pieces this batch holds.
+ */
+export declare const bindReportRuntimeAssignmentLogsRequest: (valueArg: unknown, assignmentArg: unknown, logPolicyArg: IRuntimeConfigLogPolicy, trustedSessionArg: unknown) => Promise<{
+    request: IReportRuntimeAssignmentLogsRequest;
+    assignment: IRuntimeAssignment;
+}>;
+/** Matches an acknowledgement to the exact batch that was sent. */
+export declare const bindReportRuntimeAssignmentLogsResponse: (valueArg: unknown, requestArg: unknown) => IReportRuntimeAssignmentLogsResponse;

package/dist_ts/data/runtimeassignmentlogs.js

@@ -0,0 +1,139 @@
+import { snapshotRuntimeAssignment, validateRuntimeAssignment } from './runtimeassignment.js';
+import { snapshotRuntimeSessionBinding } from './runtimesession.js';
+import { captureNetwork, networkCounter, networkEqual, networkId, networkList, networkRecord, requireNetwork, } from '../private/networkcontract.js';
+import { isRuntimeLogPolicy } from '../private/runtimepolicy.js';
+export const runtimeAssignmentLogContract = Object.freeze({
+    error: 'Runtime assignment log contract rejected.',
+    /** Pallet pushes; the controller persists metadata and payloads and acknowledges by sequence. */
+    delivery: 'node-pushes-controller-acknowledges-each-batch',
+    /** The most entries in one batch. */
+    maximumEntriesPerBatch: 1024,
+    /** The most UTF-8 bytes of `text` in one entry; a longer line travels as `partial` pieces. */
+    maximumEntryTextBytes: 65_536,
+    /**
+     * The canonical JSON of a whole report is at most one mebibyte, the bound every runtime network
+     * contract captures with; the node closes a batch before the next entry would cross it.
+     */
+    maximumReportCanonicalBytes: 1_048_576,
+});
+const fail = () => { throw new Error(runtimeAssignmentLogContract.error); };
+const safe = (operationArg) => { try {
+    return operationArg();
+}
+catch {
+    return fail();
+} };
+const encoder = new TextEncoder();
+const streams = ['stdout', 'stderr'];
+const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured'];
+const statuses = ['accepted', 'replay'];
+const literalOf = (valueArg, allowedArg) => {
+    requireNetwork(allowedArg.includes(valueArg));
+    return valueArg;
+};
+/** Nanoseconds since the Unix epoch as canonical decimal digits: no sign, no leading zero. */
+const timestampOf = (valueArg) => {
+    requireNetwork(typeof valueArg === 'string' && /^[1-9][0-9]{0,19}$/.test(valueArg)
+        && BigInt(valueArg) <= 18446744073709551615n);
+    return valueArg;
+};
+const countOf = (valueArg) => {
+    requireNetwork(typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && valueArg >= 0
+        && !Object.is(valueArg, -0));
+    return valueArg;
+};
+const lineOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['kind', 'stream', 'timestampNs', 'text', 'partial']);
+    requireNetwork(value.kind === 'line' && typeof value.text === 'string' && !value.text.includes('\n')
+        && encoder.encode(value.text).byteLength <= runtimeAssignmentLogContract.maximumEntryTextBytes
+        && typeof value.partial === 'boolean');
+    return {
+        kind: 'line', stream: literalOf(value.stream, streams), timestampNs: timestampOf(value.timestampNs),
+        text: value.text, partial: value.partial,
+    };
+};
+const lossOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['kind', 'reason', 'stream', 'timestampNs', 'bytes', 'lines']);
+    requireNetwork(value.kind === 'lost');
+    const reason = literalOf(value.reason, lossReasons);
+    const stream = value.stream === null ? null : literalOf(value.stream, streams);
+    const unknownExtent = reason === 'capture-restart' || reason === 'not-captured';
+    if (unknownExtent) {
+        requireNetwork(value.bytes === null && value.lines === null && stream === null);
+        return { kind: 'lost', reason, stream, timestampNs: timestampOf(value.timestampNs), bytes: null, lines: null };
+    }
+    const bytes = networkCounter(value.bytes);
+    const lines = countOf(value.lines);
+    requireNetwork(reason !== 'line-cut' || (stream !== null && lines === 0));
+    return { kind: 'lost', reason, stream, timestampNs: timestampOf(value.timestampNs), bytes, lines };
+};
+const entryOf = (valueArg) => {
+    requireNetwork(valueArg !== null && typeof valueArg === 'object');
+    return valueArg.kind === 'lost' ? lossOf(valueArg) : lineOf(valueArg);
+};
+const batchOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final']);
+    const entries = networkList(value.entries, runtimeAssignmentLogContract.maximumEntriesPerBatch, entryOf);
+    requireNetwork(typeof value.final === 'boolean' && (entries.length > 0 || value.final));
+    return {
+        assignmentId: networkId(value.assignmentId), attemptId: networkId(value.attemptId),
+        captureId: networkId(value.captureId), sequence: networkCounter(value.sequence), entries, final: value.final,
+    };
+};
+/** Detached exact-schema snapshot of one batch, bounded like a whole report. */
+export const snapshotRuntimeAssignmentLogBatch = (valueArg) => safe(() => batchOf(captureNetwork(valueArg)));
+export const snapshotReportRuntimeAssignmentLogsRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['session', 'batch']);
+    return { session: snapshotRuntimeSessionBinding(value.session), batch: batchOf(value.batch) };
+});
+export const snapshotReportRuntimeAssignmentLogsResponse = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['status', 'assignmentId', 'captureId', 'sequence']);
+    return {
+        status: literalOf(value.status, statuses), assignmentId: networkId(value.assignmentId),
+        captureId: networkId(value.captureId), sequence: networkCounter(value.sequence),
+    };
+});
+/**
+ * Controller-side content binding, not authentication. `trustedSessionArg` is the controller's
+ * CURRENT session with the node the report arrived on, never read from the request. `assignmentArg`
+ * is the controller's own record of the batch's assignment, any generation of it, and
+ * `logPolicyArg` the `logs` policy of the config it runs with. The request's session must equal the
+ * trusted one, the assignment must be this node's and carry the batch's attempt, and every line
+ * the batch holds, its pieces joined, must fit the policy's `maximumLineBytes`. A line whose first
+ * pieces travelled in an earlier batch is judged by the pieces this batch holds.
+ */
+export const bindReportRuntimeAssignmentLogsRequest = async (valueArg, assignmentArg, logPolicyArg, trustedSessionArg) => {
+    const request = snapshotReportRuntimeAssignmentLogsRequest(valueArg);
+    const assignment = safe(() => snapshotRuntimeAssignment(assignmentArg));
+    const trustedSession = safe(() => snapshotRuntimeSessionBinding(trustedSessionArg));
+    if ((await validateRuntimeAssignment(assignment)).length)
+        fail();
+    safe(() => {
+        requireNetwork(isRuntimeLogPolicy(logPolicyArg));
+        requireNetwork(networkEqual(request.session, trustedSession)
+            && networkEqual(assignment.controller, trustedSession.controller)
+            && assignment.nodeId === trustedSession.nodeId
+            && assignment.runtimeNamespace === trustedSession.runtimeNamespace
+            && assignment.assignmentId === request.batch.assignmentId
+            && assignment.attemptId === request.batch.attemptId);
+        const joined = { stdout: 0, stderr: 0 };
+        for (const entry of request.batch.entries) {
+            if (entry.kind !== 'line')
+                continue;
+            joined[entry.stream] += encoder.encode(entry.text).byteLength;
+            requireNetwork(joined[entry.stream] <= logPolicyArg.maximumLineBytes);
+            if (!entry.partial)
+                joined[entry.stream] = 0;
+        }
+    });
+    return { request, assignment };
+};
+/** Matches an acknowledgement to the exact batch that was sent. */
+export const bindReportRuntimeAssignmentLogsResponse = (valueArg, requestArg) => safe(() => {
+    const response = snapshotReportRuntimeAssignmentLogsResponse(valueArg);
+    const { batch } = snapshotReportRuntimeAssignmentLogsRequest(requestArg);
+    requireNetwork(response.assignmentId === batch.assignmentId && response.captureId === batch.captureId
+        && response.sequence === batch.sequence);
+    return response;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignmentlogs.js","sourceRoot":"","sources":["../../ts/data/runtimeassignmentlogs.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/runtimeassignmentstats.d.ts

@@ -0,0 +1,60 @@
+import type { IRuntimeAssignment, IRuntimeAssignmentReference } from './runtimeassignment.js';
+import type { IRuntimeSessionBinding } from './runtimesession.js';
+/** Bytes the workload's network namespace received and sent since the sandbox started. */
+export interface IRuntimeAssignmentNetworkStats {
+    receivedBytes: number;
+    transmittedBytes: number;
+}
+/**
+ * One resource sample of one running attempt, as the runtime reports it.
+ *
+ * `cpuUsageCoreNanoseconds` is cumulative CPU time across every core since the container started,
+ * as decimal digits because it outgrows a JSON number; a reader derives utilisation from two
+ * samples and their `timestampNs`. `memoryLimitBytes` is the limit the node enforces, the sealed
+ * config's `memoryBytes`. `network` is `null` when the runtime reports no interface of the
+ * sandbox, and `writableLayerBytes` is `null` when it reports no usage of the container's writable
+ * layer.
+ */
+export interface IRuntimeAssignmentStatsSample {
+    /** When the runtime took the sample, in nanoseconds since the Unix epoch, as decimal digits. */
+    timestampNs: string;
+    cpuUsageCoreNanoseconds: string;
+    memoryWorkingSetBytes: number;
+    memoryLimitBytes: number;
+    network: IRuntimeAssignmentNetworkStats | null;
+    writableLayerBytes: number | null;
+}
+/** Controller read over the node's current authenticated session. */
+export interface IReadRuntimeAssignmentStatsRequest {
+    session: IRuntimeSessionBinding;
+    /** The exact current revision of an assignment on this node. */
+    assignment: IRuntimeAssignmentReference;
+}
+/**
+ * `sampled` carries one sample; `not-running` states that the attempt has no running container to
+ * sample, and carries none.
+ */
+export interface IReadRuntimeAssignmentStatsResponse {
+    status: 'sampled' | 'not-running';
+    assignment: IRuntimeAssignmentReference;
+    sample: IRuntimeAssignmentStatsSample | null;
+}
+export declare const runtimeAssignmentStatsContract: Readonly<{
+    readonly error: "Runtime assignment stats contract rejected.";
+    /** The node answers one read per assignment at a time and refuses a concurrent one. */
+    readonly concurrency: "one-read-per-assignment";
+}>;
+export declare const snapshotReadRuntimeAssignmentStatsRequest: (valueArg: unknown) => IReadRuntimeAssignmentStatsRequest;
+export declare const snapshotReadRuntimeAssignmentStatsResponse: (valueArg: unknown) => IReadRuntimeAssignmentStatsResponse;
+/**
+ * Node-side content binding, not authentication. `trustedSessionArg` is the node's CURRENT
+ * session, and the request must have arrived on that session's own connection. `assignmentArg` is
+ * the node's current admitted revision of the named assignment: the request must name exactly it,
+ * and it must belong to the session's controller, node and runtime namespace.
+ */
+export declare const bindReadRuntimeAssignmentStatsRequest: (valueArg: unknown, assignmentArg: unknown, trustedSessionArg: unknown) => Promise<{
+    request: IReadRuntimeAssignmentStatsRequest;
+    assignment: IRuntimeAssignment;
+}>;
+/** Matches a sample to the exact assignment revision the read named. */
+export declare const bindReadRuntimeAssignmentStatsResponse: (valueArg: unknown, requestArg: unknown) => IReadRuntimeAssignmentStatsResponse;