@serve.zone/interfaces 32.36.1 → 32.38.0

package/changelog.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## 2026-09-30 - 32.38.0
+
+### Features
+
+- Rollout: controllers must run this interfaces release before any node sends `discardedCaptures`
+  or a `not-kept` loss. A receiver on 32.37.0 or earlier reads a batch by its exact schema and
+  refuses such a batch on every retry.
+- A node may now discard workload log captures it cannot deliver, so a crash-looping workload no
+  longer fills its RAM-backed runtime directory. A `not-kept` answer to
+  `reportRuntimeAssignmentLogs` is the node's permission to discard for that session: it may drop
+  every ended capture completely, and each one that ends later under the answer, and may drop a
+  running capture's output, stating it as the new `not-kept` loss (`TRuntimeAssignmentLogLossReason`)
+  where a later session that keeps logs resumes. While a controller is away or slow, a node keeps
+  at most `runtimeAssignmentLogContract.maximumEndedCaptures` (64) ended captures awaiting
+  acknowledgement, holding at most `maximumEndedCaptureBytes` (64 MiB) together; past either bound
+  it discards the oldest completely. Every capture discarded whole, under either rule, is counted
+  in the optional batch field `discardedCaptures`, carried by the next batch it creates; the count
+  is node-level evidence that a controller keeping logs records against the node and the session,
+  and a lost acknowledgement can repeat it.
+- A log `sequence` number, once sent, is never sent again with other content. When `not-kept` lets
+  a node drop a batch it sent that is still unacknowledged, the capture's next batch takes a higher
+  number and opens with a `not-kept` loss, so a controller tells the node's discard from its own
+  loss by the batch after the gap.
+- `runtimeConfigContract.maximumLogBufferedBytes` (64 MiB) publishes the largest
+  `logs.maximumBufferedBytes`; `runtimeAssignmentLogContract.maximumEndedCaptureBytes` is the same
+  bound from the same source.
+
+### Maintenance
+
+- Release tooling currency: pnpm 12.6.0; `@git.zone/*` are already at their latest releases and
+  `@types/node` stays at 26.6.2. The 23 lockfile entries a mirror had rewritten to `sha1` integrity are restored to the
+  npmjs `sha512` integrity, each checked against its npmjs shasum first.
+
+## 2026-09-29 - 32.37.0
+
+### Features
+
+- A controller that keeps no workload logs answers a batch of `reportRuntimeAssignmentLogs` with
+  the named refusal `not-kept` (`TRuntimeAssignmentLogsStatus`, alongside `accepted` and `replay`):
+  it holds nothing, and the node sends no more batches on that session. The contract now states
+  that a controller answers every batch with one of the three and never leaves the method
+  unhandled, so a node tells such a controller from a failure worth retrying; a controller must
+  handle the method before a node that captures logs runs against it.
+
 ## 2026-09-29 - 32.36.1
 
 ### Fixes

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '32.36.1',
+    version: '32.38.0',
     description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFNBQVM7SUFDbEIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=

package/dist_ts/data/runtimeassignmentlogs.d.ts

@@ -30,17 +30,21 @@ export interface IRuntimeAssignmentLogLine {
  * - `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.
+ *   available; how much there was is unknown;
+ * - `not-kept`: the node dropped this output while its controller kept no logs. Once a session
+ *   answered `not-kept`, the node may drop a running capture's output instead of holding it,
+ *   including a batch it sent that is still unacknowledged; a later session that keeps logs
+ *   receives the capture from where it stands, after this loss.
  */
-export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured';
+export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured' | 'not-kept';
 /**
  * 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.
+ * the stream of that line. A `buffer-overflow` or `not-kept` loss 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';
@@ -57,10 +61,23 @@ export type TRuntimeAssignmentLogEntry = IRuntimeAssignmentLogLine | IRuntimeAss
  *
  * `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.
+ * `capture-restart` loss. Within a capture `sequence` counts batches from 1, 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.
+ *
+ * A sequence number, once sent, is never sent again with other content: a retry resends the batch
+ * unchanged, `discardedCaptures` included. Reusing a number would lose data silently, because a
+ * controller that stored the earlier batch while its acknowledgement was lost answers `replay` and
+ * drops the new content with its loss evidence. The node skips numbers only after dropping a
+ * running capture's batch it sent that is still unacknowledged, which only a `not-kept` answer
+ * permits: the next batch it
+ * sends of that capture takes a higher number it never sent and opens with a `not-kept` loss that
+ * counts what was dropped. Where the controller holds the dropped batch, because only its
+ * acknowledgement was lost, it sees no gap, and that loss also counts content it holds.
+ *
+ * `discardedCaptures` is node-level loss evidence, not part of this capture (see
+ * `runtimeAssignmentLogContract.maximumEndedCaptures`).
  */
 export interface IRuntimeAssignmentLogBatch {
     assignmentId: string;
@@ -69,6 +86,24 @@ export interface IRuntimeAssignmentLogBatch {
     sequence: number;
     entries: TRuntimeAssignmentLogEntry[];
     final: boolean;
+    /**
+     * How many ended captures the node discarded whole and unacknowledged since it last stated a
+     * count: past its ended-capture bound, or while a `not-kept` answer stood. The node states the
+     * count on the next batch it creates, of any capture, and counts afresh from there. The batch is
+     * then the unit of retry for the count: if the node discards that batch unacknowledged, the count
+     * passes on to the next batch, so a count whose acknowledgement was lost may reach the controller
+     * again inside a later count. It never names the discarded captures, because remembering them
+     * would grow without bound while the controller is away. Absent means none; stated, it is at
+     * least 1.
+     *
+     * The count belongs to the node, not to the assignment, attempt or capture of the batch that
+     * carries it. A controller that keeps logs records it against the node and the session the batch
+     * arrived on, once for each batch it accepts and never for a batch it answers `replay`, which it
+     * recorded when it accepted it. Counts are not idempotent: a lost acknowledgement can repeat a
+     * count, so their sum may exceed the captures discarded. A controller that keeps no logs does
+     * nothing with the count beyond answering `not-kept`; the node keeps it for a later session.
+     */
+    discardedCaptures?: number;
 }
 /** Pallet push over its current authenticated session. */
 export interface IReportRuntimeAssignmentLogsRequest {
@@ -76,20 +111,66 @@ export interface IReportRuntimeAssignmentLogsRequest {
     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.
+ * How a controller answers one batch.
+ *
+ * - `accepted`: it holds the batch durably;
+ * - `replay`: it already holds this batch and does not store it again;
+ * - `not-kept`: it keeps no workload logs. It holds nothing, and the node sends no more batches on
+ *   this session; a later session may be answered differently. The answer is the node's permission
+ *   to discard for that session: it may discard every ended capture completely, its content and
+ *   identity, and each capture that ends later while the answer stands, counting them in
+ *   `discardedCaptures`. A running capture stays within `logs.maximumBufferedBytes`, whose overflow
+ *   is a `buffer-overflow` loss, or the node drops its output, a sent and unacknowledged batch
+ *   included, and states a `not-kept` loss where delivery resumes.
+ *
+ * A controller answers every batch with one of these; it never leaves the method unhandled, so a
+ * node can tell a controller that keeps no logs from a failure worth retrying. It never refuses a
+ * batch for a gap in `sequence`. Every gap the node leaves by discarding carries evidence: the
+ * batch after numbers it skipped opens with a `not-kept` loss (see `IRuntimeAssignmentLogBatch`),
+ * and a capture it discarded whole is counted in `discardedCaptures`. A controller therefore reads
+ * a gap before a batch that opens with a `not-kept` loss as the node's discard, which that loss
+ * counts, and a gap before any other batch as its own loss, which it records. A capture whose
+ * final batch never arrives leaves no gap to read: it may still be running, and one discarded whole
+ * is counted but never named.
  */
+export type TRuntimeAssignmentLogsStatus = 'accepted' | 'replay' | 'not-kept';
 export interface IReportRuntimeAssignmentLogsResponse {
-    status: 'accepted' | 'replay';
+    status: TRuntimeAssignmentLogsStatus;
     assignmentId: string;
     captureId: string;
     sequence: number;
 }
+/**
+ * Rollout: a receiver on interfaces 32.37.0 or earlier reads a batch by its exact schema and
+ * refuses one that carries `discardedCaptures` or a `not-kept` loss, on every retry. A controller
+ * must therefore run a later release before any node sends either.
+ */
 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";
+    /**
+     * A controller that keeps no logs answers `not-kept`, and the node stops for that session. It may
+     * then discard ended captures completely, counted in `discardedCaptures`, and drop running
+     * output, stated as a `not-kept` loss.
+     */
+    readonly notKept: "node-stops-for-the-session";
+    /**
+     * The most ended captures a node keeps awaiting acknowledgement, while its controller is away or
+     * slow. An ended capture holds its buffer, cursor record and waiting batch in the node's RAM-backed
+     * runtime directory, and a crash-looping workload ends one per restart; 64 covers a burst of
+     * restarts across the node's workloads before any of them loses its tail. Past this bound, or past
+     * `maximumEndedCaptureBytes`, the node discards the oldest ended captures completely and counts
+     * them in the next batch's `discardedCaptures`.
+     */
+    readonly maximumEndedCaptures: 64;
+    /**
+     * The most bytes all ended captures awaiting acknowledgement hold together, measured as the node
+     * measures its `logs.maximumBufferedBytes` buffer. It equals the largest buffer a runtime config
+     * may set (`runtimeConfigContract.maximumLogBufferedBytes`), so one capture always fits whole, and
+     * it keeps the node's RAM-backed runtime directory from growing with the number of restarts.
+     */
+    readonly maximumEndedCaptureBytes: 67108864;
     /** 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. */

package/dist_ts/data/runtimeassignmentlogs.js

@@ -1,11 +1,38 @@
 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';
+import { isRuntimeLogPolicy, runtimePolicyLimits } from '../private/runtimepolicy.js';
+/**
+ * Rollout: a receiver on interfaces 32.37.0 or earlier reads a batch by its exact schema and
+ * refuses one that carries `discardedCaptures` or a `not-kept` loss, on every retry. A controller
+ * must therefore run a later release before any node sends either.
+ */
 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',
+    /**
+     * A controller that keeps no logs answers `not-kept`, and the node stops for that session. It may
+     * then discard ended captures completely, counted in `discardedCaptures`, and drop running
+     * output, stated as a `not-kept` loss.
+     */
+    notKept: 'node-stops-for-the-session',
+    /**
+     * The most ended captures a node keeps awaiting acknowledgement, while its controller is away or
+     * slow. An ended capture holds its buffer, cursor record and waiting batch in the node's RAM-backed
+     * runtime directory, and a crash-looping workload ends one per restart; 64 covers a burst of
+     * restarts across the node's workloads before any of them loses its tail. Past this bound, or past
+     * `maximumEndedCaptureBytes`, the node discards the oldest ended captures completely and counts
+     * them in the next batch's `discardedCaptures`.
+     */
+    maximumEndedCaptures: 64,
+    /**
+     * The most bytes all ended captures awaiting acknowledgement hold together, measured as the node
+     * measures its `logs.maximumBufferedBytes` buffer. It equals the largest buffer a runtime config
+     * may set (`runtimeConfigContract.maximumLogBufferedBytes`), so one capture always fits whole, and
+     * it keeps the node's RAM-backed runtime directory from growing with the number of restarts.
+     */
+    maximumEndedCaptureBytes: runtimePolicyLimits.maximumLogBufferedBytes,
     /** 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. */
@@ -25,8 +52,8 @@ catch {
 } };
 const encoder = new TextEncoder();
 const streams = ['stdout', 'stderr'];
-const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured'];
-const statuses = ['accepted', 'replay'];
+const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured', 'not-kept'];
+const statuses = ['accepted', 'replay', 'not-kept'];
 const literalOf = (valueArg, allowedArg) => {
     requireNetwork(allowedArg.includes(valueArg));
     return valueArg;
@@ -72,12 +99,13 @@ const entryOf = (valueArg) => {
     return valueArg.kind === 'lost' ? lossOf(valueArg) : lineOf(valueArg);
 };
 const batchOf = (valueArg) => {
-    const value = networkRecord(valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final']);
+    const value = networkRecord(valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final'], ['discardedCaptures']);
     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,
+        ...(Object.hasOwn(value, 'discardedCaptures') ? { discardedCaptures: networkCounter(value.discardedCaptures) } : {}),
     };
 };
 /** Detached exact-schema snapshot of one batch, bounded like a whole report. */
@@ -136,4 +164,4 @@ export const bindReportRuntimeAssignmentLogsResponse = (valueArg, requestArg) =>
         && response.sequence === batch.sequence);
     return response;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignmentlogs.js","sourceRoot":"","sources":["../../ts/data/runtimeassignmentlogs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAG9F,OAAO,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EACL,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,GACpG,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AA+FjE,MAAM,CAAC,MAAM,4BAA4B,GAAG,MAAM,CAAC,MAAM,CAAC;IACxD,KAAK,EAAE,2CAA2C;IAClD,iGAAiG;IACjG,QAAQ,EAAE,gDAAgD;IAC1D,qCAAqC;IACrC,sBAAsB,EAAE,IAAI;IAC5B,8FAA8F;IAC9F,qBAAqB,EAAE,MAAM;IAC7B;;;OAGG;IACH,2BAA2B,EAAE,SAAS;CAC9B,CAAC,CAAC;AAEZ,MAAM,IAAI,GAAG,GAAU,EAAE,GAAG,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACnF,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,OAAO,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAU,CAAC;AAC9C,MAAM,WAAW,GAAG,CAAC,iBAAiB,EAAE,UAAU,EAAE,iBAAiB,EAAE,cAAc,CAAU,CAAC;AAChG,MAAM,QAAQ,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAU,CAAC;AAEjD,MAAM,SAAS,GAAG,CAA0B,QAAiB,EAAE,UAA+B,EAAY,EAAE;IAC1G,cAAc,CAAE,UAAiC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtE,OAAO,QAAoB,CAAC;AAC9B,CAAC,CAAC;AACF,8FAA8F;AAC9F,MAAM,WAAW,GAAG,CAAC,QAAiB,EAAU,EAAE;IAChD,cAAc,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,oBAAoB,CAAC,IAAI,CAAC,QAAQ,CAAC;WAC7E,MAAM,CAAC,QAAQ,CAAC,IAAI,qBAA2B,CAAC,CAAC;IACtD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AACF,MAAM,OAAO,GAAG,CAAC,QAAiB,EAAU,EAAE;IAC5C,cAAc,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC;WACzF,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,MAAM,GAAG,CAAC,QAAiB,EAA6B,EAAE;IAC9D,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAC5F,cAAc,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;WAC/F,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,IAAI,4BAA4B,CAAC,qBAAqB;WAC3F,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC;IACzC,OAAO;QACL,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC;QACnG,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO;KACzC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,MAAM,GAAG,CAAC,QAAiB,EAA6B,EAAE;IAC9D,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IACrG,cAAc,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/E,MAAM,aAAa,GAAG,MAAM,KAAK,iBAAiB,IAAI,MAAM,KAAK,cAAc,CAAC;IAChF,IAAI,aAAa,EAAE,CAAC;QAClB,cAAc,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,CAAC,CAAC;QAChF,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACjH,CAAC;IACD,MAAM,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACnC,cAAc,CAAC,MAAM,KAAK,UAAU,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1E,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AACrG,CAAC,CAAC;AAEF,MAAM,OAAO,GAAG,CAAC,QAAiB,EAA8B,EAAE;IAChE,cAAc,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC;IAClE,OAAQ,QAAoC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AACrG,CAAC,CAAC;AAEF,MAAM,OAAO,GAAG,CAAC,QAAiB,EAA8B,EAAE;IAChE,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,cAAc,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;IAClH,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,4BAA4B,CAAC,sBAAsB,EAAE,OAAO,CAAC,CAAC;IACzG,cAAc,CAAC,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACxF,OAAO;QACL,YAAY,EAAE,SAAS,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QAClF,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK;KAC7G,CAAC;AACJ,CAAC,CAAC;AAEF,gFAAgF;AAChF,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,QAAiB,EAA8B,EAAE,CACjG,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEhD,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,OAAO,CAAC,CAAC,CAAC;IAC5E,OAAO,EAAE,OAAO,EAAE,6BAA6B,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;AAChG,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,EAAE,cAAc,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;IAC3G,OAAO;QACL,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,SAAS,CAAC,KAAK,CAAC,YAAY,CAAC;QACtF,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC;KAChF,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,KAAK,EACzD,QAAiB,EAAE,aAAsB,EAAE,YAAqC,EAAE,iBAA0B,EACjB,EAAE;IAC7F,MAAM,OAAO,GAAG,0CAA0C,CAAC,QAAQ,CAAC,CAAC;IACrE,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC,aAAa,CAAC,CAAC,CAAC;IACxE,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,6BAA6B,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACpF,IAAI,CAAC,MAAM,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM;QAAE,IAAI,EAAE,CAAC;IACjE,IAAI,CAAC,GAAG,EAAE;QACR,cAAc,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC,CAAC;QACjD,cAAc,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC;eACvD,YAAY,CAAC,UAAU,CAAC,UAAU,EAAE,cAAc,CAAC,UAAU,CAAC;eAC9D,UAAU,CAAC,MAAM,KAAK,cAAc,CAAC,MAAM;eAC3C,UAAU,CAAC,gBAAgB,KAAK,cAAc,CAAC,gBAAgB;eAC/D,UAAU,CAAC,YAAY,KAAK,OAAO,CAAC,KAAK,CAAC,YAAY;eACtD,UAAU,CAAC,SAAS,KAAK,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACvD,MAAM,MAAM,GAAgD,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QACrF,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YAC1C,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM;gBAAE,SAAS;YACpC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC;YAC9D,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,gBAAgB,CAAC,CAAC;YACtE,IAAI,CAAC,KAAK,CAAC,OAAO;gBAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,mEAAmE;AACnE,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,MAAM,EAAE,KAAK,EAAE,GAAG,0CAA0C,CAAC,UAAU,CAAC,CAAC;IACzE,cAAc,CAAC,QAAQ,CAAC,YAAY,KAAK,KAAK,CAAC,YAAY,IAAI,QAAQ,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS;WAChG,QAAQ,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC3C,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,CAAC"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignmentlogs.js","sourceRoot":"","sources":["../../ts/data/runtimeassignmentlogs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAG9F,OAAO,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EACL,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,GACpG,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAuJtF;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,MAAM,CAAC,MAAM,CAAC;IACxD,KAAK,EAAE,2CAA2C;IAClD,iGAAiG;IACjG,QAAQ,EAAE,gDAAgD;IAC1D;;;;OAIG;IACH,OAAO,EAAE,4BAA4B;IACrC;;;;;;;OAOG;IACH,oBAAoB,EAAE,EAAE;IACxB;;;;;OAKG;IACH,wBAAwB,EAAE,mBAAmB,CAAC,uBAAuB;IACrE,qCAAqC;IACrC,sBAAsB,EAAE,IAAI;IAC5B,8FAA8F;IAC9F,qBAAqB,EAAE,MAAM;IAC7B;;;OAGG;IACH,2BAA2B,EAAE,SAAS;CAC9B,CAAC,CAAC;AAEZ,MAAM,IAAI,GAAG,GAAU,EAAE,GAAG,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACnF,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,OAAO,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAU,CAAC;AAC9C,MAAM,WAAW,GAAG,CAAC,iBAAiB,EAAE,UAAU,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,CAAU,CAAC;AAC5G,MAAM,QAAQ,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE,UAAU,CAAU,CAAC;AAE7D,MAAM,SAAS,GAAG,CAA0B,QAAiB,EAAE,UAA+B,EAAY,EAAE;IAC1G,cAAc,CAAE,UAAiC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtE,OAAO,QAAoB,CAAC;AAC9B,CAAC,CAAC;AACF,8FAA8F;AAC9F,MAAM,WAAW,GAAG,CAAC,QAAiB,EAAU,EAAE;IAChD,cAAc,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,oBAAoB,CAAC,IAAI,CAAC,QAAQ,CAAC;WAC7E,MAAM,CAAC,QAAQ,CAAC,IAAI,qBAA2B,CAAC,CAAC;IACtD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AACF,MAAM,OAAO,GAAG,CAAC,QAAiB,EAAU,EAAE;IAC5C,cAAc,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC;WACzF,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,MAAM,GAAG,CAAC,QAAiB,EAA6B,EAAE;IAC9D,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAC5F,cAAc,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;WAC/F,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,IAAI,4BAA4B,CAAC,qBAAqB;WAC3F,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC;IACzC,OAAO;QACL,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC;QACnG,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO;KACzC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,MAAM,GAAG,CAAC,QAAiB,EAA6B,EAAE;IAC9D,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IACrG,cAAc,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/E,MAAM,aAAa,GAAG,MAAM,KAAK,iBAAiB,IAAI,MAAM,KAAK,cAAc,CAAC;IAChF,IAAI,aAAa,EAAE,CAAC;QAClB,cAAc,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,CAAC,CAAC;QAChF,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACjH,CAAC;IACD,MAAM,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACnC,cAAc,CAAC,MAAM,KAAK,UAAU,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1E,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AACrG,CAAC,CAAC;AAEF,MAAM,OAAO,GAAG,CAAC,QAAiB,EAA8B,EAAE;IAChE,cAAc,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC;IAClE,OAAQ,QAAoC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AACrG,CAAC,CAAC;AAEF,MAAM,OAAO,GAAG,CAAC,QAAiB,EAA8B,EAAE;IAChE,MAAM,KAAK,GAAG,aAAa,CACzB,QAAQ,EAAE,CAAC,cAAc,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,mBAAmB,CAAC,CAC5G,CAAC;IACF,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,4BAA4B,CAAC,sBAAsB,EAAE,OAAO,CAAC,CAAC;IACzG,cAAc,CAAC,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACxF,OAAO;QACL,YAAY,EAAE,SAAS,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QAClF,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK;QAC5G,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,cAAc,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACrH,CAAC;AACJ,CAAC,CAAC;AAEF,gFAAgF;AAChF,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,QAAiB,EAA8B,EAAE,CACjG,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEhD,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,OAAO,CAAC,CAAC,CAAC;IAC5E,OAAO,EAAE,OAAO,EAAE,6BAA6B,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;AAChG,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,EAAE,cAAc,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;IAC3G,OAAO;QACL,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,SAAS,CAAC,KAAK,CAAC,YAAY,CAAC;QACtF,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC;KAChF,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,KAAK,EACzD,QAAiB,EAAE,aAAsB,EAAE,YAAqC,EAAE,iBAA0B,EACjB,EAAE;IAC7F,MAAM,OAAO,GAAG,0CAA0C,CAAC,QAAQ,CAAC,CAAC;IACrE,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC,aAAa,CAAC,CAAC,CAAC;IACxE,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,6BAA6B,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACpF,IAAI,CAAC,MAAM,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM;QAAE,IAAI,EAAE,CAAC;IACjE,IAAI,CAAC,GAAG,EAAE;QACR,cAAc,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC,CAAC;QACjD,cAAc,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC;eACvD,YAAY,CAAC,UAAU,CAAC,UAAU,EAAE,cAAc,CAAC,UAAU,CAAC;eAC9D,UAAU,CAAC,MAAM,KAAK,cAAc,CAAC,MAAM;eAC3C,UAAU,CAAC,gBAAgB,KAAK,cAAc,CAAC,gBAAgB;eAC/D,UAAU,CAAC,YAAY,KAAK,OAAO,CAAC,KAAK,CAAC,YAAY;eACtD,UAAU,CAAC,SAAS,KAAK,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACvD,MAAM,MAAM,GAAgD,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QACrF,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YAC1C,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM;gBAAE,SAAS;YACpC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC;YAC9D,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,gBAAgB,CAAC,CAAC;YACtE,IAAI,CAAC,KAAK,CAAC,OAAO;gBAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,mEAAmE;AACnE,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,MAAM,EAAE,KAAK,EAAE,GAAG,0CAA0C,CAAC,UAAU,CAAC,CAAC;IACzE,cAAc,CAAC,QAAQ,CAAC,YAAY,KAAK,KAAK,CAAC,YAAY,IAAI,QAAQ,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS;WAChG,QAAQ,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC3C,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist_ts/data/runtimeconfig.d.ts

@@ -112,6 +112,7 @@ export declare const runtimeConfigContract: Readonly<{
     readonly maximumTargetPorts: 64;
     readonly maximumReadinessDurationMs: 3600000;
     readonly maximumLogRetentionMs: 31536000000;
+    readonly maximumLogBufferedBytes: 67108864;
 }>;
 /**
  * Detached exact-schema snapshot for synchronous persistence assertions. Digest

package/dist_ts/data/runtimeconfig.js

@@ -9,6 +9,7 @@ export const runtimeConfigContract = Object.freeze({
     maximumTargetPorts: 64,
     maximumReadinessDurationMs: runtimePolicyLimits.maximumReadinessDurationMs,
     maximumLogRetentionMs: runtimePolicyLimits.maximumLogRetentionMs,
+    maximumLogBufferedBytes: runtimePolicyLimits.maximumLogBufferedBytes,
 });
 const fail = (messageArg) => { throw new Error(messageArg); };
 const encoder = new TextEncoder();
@@ -212,4 +213,4 @@ export const bindRuntimeConfigToAssignment = async (configArg, assignmentArg) =>
         fail('runtime config lacks exact assignment platform evidence');
     return { config, assignment, platformEvidence };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeconfig.js","sourceRoot":"","sources":["../../ts/data/runtimeconfig.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,+BAA+B,EAC/B,cAAc,EACd,oCAAoC,EACpC,wCAAwC,GACzC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAC9F,OAAO,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAC;AACnG,OAAO,EACL,sBAAsB,EAAE,gBAAgB,EAAE,aAAa,EAAE,kBAAkB,EAAE,uBAAuB,EACpG,kBAAkB,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,mBAAmB,GACjF,MAAM,6BAA6B,CAAC;AA+GrC,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC;IACjD,YAAY,EAAE,2BAA2B;IACzC,qBAAqB,EAAE,OAAO;IAC9B,yBAAyB,EAAE,GAAG;IAC9B,kBAAkB,EAAE,EAAE;IACtB,0BAA0B,EAAE,mBAAmB,CAAC,0BAA0B;IAC1E,qBAAqB,EAAE,mBAAmB,CAAC,qBAAqB;CACxD,CAAC,CAAC;AAEZ,MAAM,IAAI,GAAkC,CAAC,UAAU,EAAE,EAAE,GAAG,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7F,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;AAClC,MAAM,YAAY,GAAG,CAAC,QAAiB,EAAsB,EAAE,CAC7D,OAAO,QAAQ,KAAK,QAAQ,IAAI,qCAAqC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AACvF,MAAM,QAAQ,GAAG,CAAC,QAAiB,EAA6B,EAAE,CAChE,OAAO,QAAQ,KAAK,QAAQ,IAAI,cAAc,CAAC,QAAQ,CAAC,CAAC;AAE3D;;;;GAIG;AACH,MAAM,mBAAmB,GAAG,CAAC,QAAiB,EAAW,EAAE;IACzD,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;IACpC,MAAM,aAAa,GAAG,CAAC,KAAa,EAAQ,EAAE;QAC5C,IAAI,KAAK,CAAC,MAAM,GAAG,qBAAqB,CAAC,qBAAqB;YAAE,IAAI,CAAC,oCAAoC,CAAC,CAAC;QAC3G,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC;QAChD,IAAI,WAAW,GAAG,qBAAqB,CAAC,qBAAqB;YAAE,IAAI,CAAC,6BAA6B,CAAC,CAAC;IACrG,CAAC,CAAC;IACF,MAAM,IAAI,GAAG,CAAC,KAAc,EAAE,KAAa,EAAW,EAAE;QACtD,IAAI,EAAE,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,EAAE;YAAE,IAAI,CAAC,0CAA0C,CAAC,CAAC;QACnF,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YAAC,OAAO,KAAK,CAAC;QAAC,CAAC;QACtE,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAC5F,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,IAAI,CAAC,0CAA0C,CAAC,CAAC;QAC1F,IAAI,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,IAAI,CAAC,iCAAiC,CAAC,CAAC;QAClE,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACrB,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACnC,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAC/C,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;gBACjG,IAAI,CAAC,kDAAkD,CAAC,CAAC;YAC3D,CAAC;YACD,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACpC,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG;gBAAE,IAAI,CAAC,0CAA0C,CAAC,CAAC;YACxE,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,gBAAgB,GAAG,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;gBAC1E,MAAM,MAAM,GAAG,gBAAgB,EAAE,KAAK,CAAC;gBACvC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,GAAG,CAAC,EAAE,CAAC;oBACpE,IAAI,CAAC,8CAA8C,CAAC,CAAC;gBACvD,CAAC;gBACD,MAAM,MAAM,GAAc,EAAE,CAAC;gBAC7B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;oBAC5C,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;oBACzE,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,CAAC;wBACjF,IAAI,CAAC,2DAA2D,CAAC,CAAC;oBACpE,CAAC;oBACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;gBACjD,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,MAAM,GAA4B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC5D,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,IAAI,OAAO,GAAG,KAAK,QAAQ;oBAAE,IAAI,CAAC,sCAAsC,CAAC,CAAC;gBAC1E,aAAa,CAAC,GAAG,CAAC,CAAC;gBACnB,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBAC/D,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,CAAC;oBACjF,IAAI,CAAC,oDAAoD,CAAC,CAAC;gBAC7D,CAAC;gBACD,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;gBAAS,CAAC;YAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAAC,CAAC;IACxC,CAAC,CAAC;IACF,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IAClE,IAAI,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,UAAU,GAAG,qBAAqB,CAAC,qBAAqB,EAAE,CAAC;QACvF,IAAI,CAAC,4CAA4C,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;AAC/B,CAAC,CAAC;AAEF,MAAM,YAAY,GAAG,CAAC,QAAiB,EAAkB,EAAE;IACzD,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,gBAAgB,EAAE,WAAW;QAC7E,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB;QACxF,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;WACtE,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;WAC1B,CAAC,gBAAgB,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC,EAAE,MAAM,CAAC,gBAAgB,CAAC;WAClE,CAAC,YAAY,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC;WAC3E,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,IAAI,CAAC,0CAA0C,CAAC,CAAC;IAClF,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;IAC7B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC;WACjF,OAAO,KAAK,CAAC,YAAY,KAAK,QAAQ,IAAI,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,GAAG;WACzE,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,GAAG,GAAG;WACrE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC;WAC5B,oCAAoC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzE,IAAI,CAAC,uEAAuE,CAAC,CAAC;IAChF,CAAC;IACD,+BAA+B,CAAC,KAAK,CAAC,YAAsB,EAAE,KAAK,CAAC,UAAoB,EACtF,KAAK,CAAC,WAA4B,CAAC,CAAC;IACtC,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;IACzC,IAAI,CAAC,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;WAC5E,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,qBAAqB,CAAC,yBAAyB,EAAE,CAAC;QACvF,IAAI,CAAC,mEAAmE,CAAC,CAAC;IAC5E,CAAC;IACD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;QACvD,IAAI,CAAC,gCAAgC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ;eACvE,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,UAAU,GAAG,IAAI,EAAE,CAAC;YACzE,IAAI,CAAC,gEAAgE,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;IACD,MAAM,SAAS,GAAG,QAAQ,CAAC,gBAAgB,CAAC;IAC5C,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC;WAC1D,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,UAAU,GAAG,IAAI,IAAI,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC;WACtF,CAAC,SAAS,KAAK,GAAG,IAAI,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,IAAI,OAAO,KAAK,GAAG,IAAI,OAAO,KAAK,IAAI,CAAC,CAAC;WACvH,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC;WACvC,CAAC,oBAAoB,CAAC,QAAQ,CAAC,WAAW,CAAC;WAC3C,OAAO,QAAQ,CAAC,cAAc,KAAK,SAAS;WAC5C,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,KAAK,IAAI,IAAI,QAAQ,CAAC,UAAU,KAAK,IAAI,CAAC;eAC7D,CAAC,uBAAuB,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,uBAAuB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;QACtG,IAAI,CAAC,yFAAyF,CAAC,CAAC;IAClG,CAAC;IACD,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,CAAC;IACnC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,qBAAqB,CAAC,kBAAkB,EAAE,CAAC;QACrF,IAAI,CAAC,qDAAqD,CAAC,CAAC;IAC9D,CAAC;IACD,IAAI,YAAY,GAAG,EAAE,CAAC;IACtB,MAAM,cAAc,GAA+B,EAAE,CAAC;IACtD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;eAC5D,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,IAAI,YAAY;eAC1D,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC;eAC3F,CAAC,IAAI,CAAC,QAAQ,KAAK,KAAK,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,CAAC;eACpD,cAAc,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ;mBACxE,IAAI,CAAC,IAAe,IAAI,WAAW,CAAC,OAAO,IAAK,IAAI,CAAC,OAAkB,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;YACrG,IAAI,CAAC,6FAA6F,CAAC,CAAC;QACtG,CAAC;QACD,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC;QACzB,cAAc,CAAC,IAAI,CAAC,IAA2C,CAAC,CAAC;IACnE,CAAC;IACD,sBAAsB,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,aAAa,EAAE,OAAO,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CACvG,SAAS,CAAC,IAAI,KAAK,aAAa,IAAI,SAAS,CAAC,QAAQ,KAAK,KAAK;WAC7D,OAAO,IAAI,SAAS,CAAC,IAAI,IAAI,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;IACvE,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACvC,IAAI,CAAC,gFAAgF,CAAC,CAAC;IACzF,CAAC;IACD,OAAO,QAAqC,CAAC;AAC/C,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,QAAiB,EAAkB,EAAE,CACzE,YAAY,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE9C,6EAA6E;AAC7E,MAAM,CAAC,MAAM,0BAA0B,GAAG,KAAK,EAAE,SAAyB,EAA0B,EAAE;IACpG,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACzE,OAAO,UAAU,MAAM,4BAA4B,CAAC,sBAAsB,CAAC;QACzE,MAAM,EAAE,qBAAqB,CAAC,YAAY,EAAE,OAAO;KACpD,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;AACpB,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,KAAK,EAAE,SAAyB,EAAqB,EAAE;IAC9E,IAAI,CAAC,MAAM,wCAAwC,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;QAChF,OAAO,CAAC,2DAA2D,CAAC,CAAC;IACvE,CAAC;IACD,OAAO,SAAS,CAAC,MAAM,KAAK,MAAM,0BAA0B,CAAC,SAAS,CAAC;QACrE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,sCAAsC,CAAC,CAAC;AACpD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EAAE,QAAiB,EAAqB,EAAE;IAClF,IAAI,CAAC;QAAC,OAAO,MAAM,gBAAgB,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CAAC;IAAC,CAAC;IACvE,MAAM,CAAC;QAAC,OAAO,CAAC,oDAAoD,CAAC,CAAC;IAAC,CAAC;AAC1E,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,KAAK,EAChD,SAAkB,EAAE,aAAsB,EACA,EAAE;IAC5C,MAAM,MAAM,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAChD,MAAM,UAAU,GAAG,yBAAyB,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC,CAAC;IACjF,IAAI,CAAC,MAAM,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC;WAC5C,CAAC,MAAM,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChE,IAAI,CAAC,iFAAiF,CAAC,CAAC;IAC1F,CAAC;IACD,MAAM,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC;IAC7C,IAAI,SAAS,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,IAAI,SAAS,CAAC,UAAU,KAAK,MAAM,CAAC,UAAU;WACvE,SAAS,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,IAAI,UAAU,CAAC,cAAc,KAAK,MAAM,CAAC,cAAc;WACzF,UAAU,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS;WACzC,UAAU,CAAC,QAAQ,CAAC,YAAY,KAAK,MAAM,CAAC,KAAK,CAAC,YAAY;WAC9D,UAAU,CAAC,QAAQ,CAAC,UAAU,KAAK,MAAM,CAAC,KAAK,CAAC,UAAU;WAC1D,UAAU,CAAC,QAAQ,CAAC,WAAW,KAAK,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAClE,IAAI,CAAC,mFAAmF,CAAC,CAAC;IAC5F,CAAC;IACD,MAAM,gBAAgB,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAC5D,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,KAAK,UAAU,CAAC,QAAQ,CAAC,QAAQ,CACjE,CAAC;IACF,IAAI,CAAC,gBAAgB;QAAE,IAAI,CAAC,yDAAyD,CAAC,CAAC;IACvF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC;AAClD,CAAC,CAAC"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeconfig.js","sourceRoot":"","sources":["../../ts/data/runtimeconfig.ts"],"names":[],"mappings":"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"}

package/dist_ts/private/runtimepolicy.d.ts

@@ -14,6 +14,8 @@ export declare const runtimePolicyLimits: Readonly<{
     readonly maximumIdentityNumber: number;
     readonly maximumReadinessDurationMs: 3600000;
     readonly maximumLogRetentionMs: 31536000000;
+    /** The largest `logs.maximumBufferedBytes`; a node's ended captures share the same bound. */
+    readonly maximumLogBufferedBytes: 67108864;
 }>;
 export type TRuntimePolicyFailure = (messageArg: string) => never;
 export declare const isBoundedInteger: (valueArg: unknown, minimumArg: number, maximumArg: number) => valueArg is number;

package/dist_ts/private/runtimepolicy.js

@@ -13,6 +13,8 @@ export const runtimePolicyLimits = Object.freeze({
     maximumIdentityNumber: 2 ** 31 - 1,
     maximumReadinessDurationMs: 3_600_000,
     maximumLogRetentionMs: 31_536_000_000,
+    /** The largest `logs.maximumBufferedBytes`; a node's ended captures share the same bound. */
+    maximumLogBufferedBytes: 67_108_864,
 });
 export const isBoundedInteger = (valueArg, minimumArg, maximumArg) => typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && !Object.is(valueArg, -0)
     && valueArg >= minimumArg && valueArg <= maximumArg;
@@ -29,7 +31,7 @@ export const isRuntimeMemoryBytes = (valueArg) => isBoundedInteger(valueArg, run
 export const isRuntimeIdentityNumber = (valueArg) => isBoundedInteger(valueArg, 0, runtimePolicyLimits.maximumIdentityNumber);
 export const isRuntimeLogPolicy = (valueArg) => isExactRecord(valueArg, ['maximumLineBytes', 'maximumBufferedBytes', 'retentionMs'])
     && isBoundedInteger(valueArg.maximumLineBytes, 1, 1_048_576)
-    && isBoundedInteger(valueArg.maximumBufferedBytes, 1, 67_108_864)
+    && isBoundedInteger(valueArg.maximumBufferedBytes, 1, runtimePolicyLimits.maximumLogBufferedBytes)
     && valueArg.maximumBufferedBytes >= valueArg.maximumLineBytes
     && isBoundedInteger(valueArg.retentionMs, 1, runtimePolicyLimits.maximumLogRetentionMs);
 const timingKeys = ['initialDelayMs', 'startupGraceMs', 'intervalMs', 'timeoutMs',
@@ -87,4 +89,4 @@ export const assertRuntimeReadiness = (valueArg, selectsTcpTargetArg, failArg) =
         previousCode = code;
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.36.1",
+  "version": "32.38.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {

package/readme.md

@@ -1241,7 +1241,8 @@ pushes one `IRuntimeAssignmentLogBatch { assignmentId, attemptId, captureId, seq
 final }` from the node to its controller. Logs are the controller's to keep
 (`IRuntimeConfig.logs`); the node's capture files are disposable transport artifacts, so the node
 pushes and the controller persists. The node discards a batch only after the controller
-acknowledged it, and sends the next one only then.
+acknowledged it, and sends the next one only then. Two rules below let it discard more: a
+`not-kept` answer, and its bound on ended captures awaiting acknowledgement.
 
 - `entries` are in capture order. A `line` entry `{ stream, timestampNs, text, partial }` is one
   piece of one line: `text` holds no `\n`, invalid UTF-8 becomes U+FFFD, and a line longer than
@@ -1250,17 +1251,70 @@ acknowledged it, and sends the next one only then.
 - A `lost` entry `{ reason, stream, timestampNs, bytes, lines }` is evidence of output that did not
   arrive, placed where it was lost: `buffer-overflow` (the node's buffer reached
   `logs.maximumBufferedBytes` and it dropped the oldest bytes), `line-cut` (the rest of a line
-  beyond `maximumLineBytes`, right after that line's last piece), `capture-restart` and
-  `not-captured` (a container started without capture). The last two cannot know how much was
+  beyond `maximumLineBytes`, right after that line's last piece), `capture-restart`,
+  `not-captured` (a container started without capture) and `not-kept` (output the node dropped
+  while its controller kept no logs). `capture-restart` and `not-captured` cannot know how much was
   lost and state `bytes` and `lines` as `null`; the others count exactly.
-- `captureId` names one capture of the attempt. `sequence` counts that capture's batches from 1.
-  `final` states that the container is gone and its output drained; only a final batch may be
-  empty. A report is at most 1 024 entries and one mebibyte of canonical JSON, and timestamps are
-  nanoseconds since the Unix epoch as decimal digits.
-
-The answer `{ status, assignmentId, captureId, sequence }` is `accepted`, or `replay` for a batch
-the controller already holds. The controller never refuses a batch for a gap in `sequence`: the
-node only discards what was acknowledged, so a gap is the controller's own loss, which it records.
+- `captureId` names one capture of the attempt. `sequence` counts that capture's batches from 1,
+  and a number once sent is never sent again with other content (below). `final` states that the
+  container is gone and its output drained; only a final batch may be empty. A report is at most 1 024
+  entries and one mebibyte of canonical JSON, and timestamps are nanoseconds since the Unix epoch
+  as decimal digits.
+- `discardedCaptures`, optional, is node-level loss evidence carried by whichever batch the node
+  creates next: how many ended captures it discarded whole, under its ended-capture bound or a
+  `not-kept` answer (below), since it last stated a count. It is absent for none and at least 1
+  when stated.
+
+The answer `{ status, assignmentId, captureId, sequence }` (`TRuntimeAssignmentLogsStatus`) is
+`accepted`, `replay` for a batch the controller already holds, or `not-kept` from a controller that
+keeps no workload logs: it holds nothing, and the node sends no more batches on that session (a
+later session may be answered differently). A controller answers every batch with one of the
+three and never leaves the method unhandled, so a node tells a controller that keeps no logs from
+a failure worth retrying. A controller must therefore handle the method before a node that
+captures logs runs against it. Likewise, a receiver on interfaces 32.37.0 or earlier reads a batch
+by its exact schema and refuses one that carries `discardedCaptures` or a `not-kept` loss, on every
+retry: controllers must run a later interfaces release before any node sends either.
+
+A sequence number, once sent, is never sent again with other content; a retry resends the batch
+unchanged, its `discardedCaptures` included. Reuse would lose data silently: a controller that
+stored the batch while its acknowledgement was lost answers `replay` and drops the new content
+with its loss evidence. So when the node drops a running capture's batch it sent that is still
+unacknowledged, which only `not-kept` permits, the next batch it sends of that capture takes a higher number it never
+sent and opens with a `not-kept` loss that counts what was dropped. A controller that holds the
+dropped batch sees no gap, and that loss also counts content it holds.
+
+The controller never refuses a batch for a gap in `sequence`. Every gap the node leaves by
+discarding carries evidence: the batch after skipped numbers opens with a `not-kept` loss, and a
+capture discarded whole is counted in `discardedCaptures`. A gap before a batch that opens with a
+`not-kept` loss is therefore the node's discard, which that loss counts; a gap before any other
+batch is the controller's own loss, which it records. A capture whose final batch never arrives
+leaves no gap to read: it may still be running, and one discarded whole is counted, never named.
+
+`not-kept` is the node's permission to discard for the session that answered it. The node may
+discard every ended capture completely, content and identity, and each capture that ends later
+while the answer stands, counting them in `discardedCaptures`. A running capture stays within
+`logs.maximumBufferedBytes` (overflow is a `buffer-overflow` loss), or the node drops its output,
+a sent and unacknowledged batch included. A later session that keeps logs receives each running
+capture from where it stands, after a `not-kept` loss that counts what was dropped.
+
+While a controller is away or slow, ended captures wait for their final batch to be acknowledged,
+and a crash-looping workload ends one per restart. A node therefore keeps at most
+`runtimeAssignmentLogContract.maximumEndedCaptures` (64) ended captures awaiting acknowledgement,
+holding at most `maximumEndedCaptureBytes` (64 MiB, the largest `logs.maximumBufferedBytes` a
+config may set, `runtimeConfigContract.maximumLogBufferedBytes`, so one capture always fits)
+together. Past either bound it discards the oldest
+ended captures completely and counts them in the next batch's `discardedCaptures`. It does not name
+them: remembering them would grow without bound while the controller is away. The batch is the
+unit of retry for the count: a batch the node discards unacknowledged passes its count on to the
+next batch, so a count whose acknowledgement was lost may arrive again inside a later one.
+
+The count belongs to the node, not to the assignment, attempt or capture of the batch that carries
+it. A controller that keeps logs records it against the node and the session the batch arrived on,
+once for each batch it accepts and never for a batch it answers `replay`. Counts are not
+idempotent: a lost acknowledgement can repeat a count, so their sum may exceed the captures
+discarded. A controller that keeps no logs does nothing with the count beyond answering
+`not-kept`; the node keeps it for a later session.
+
 `bindReportRuntimeAssignmentLogsRequest(request, assignment, logPolicy, trustedSession)` checks the
 session, that the assignment is this node's and carries the batch's attempt, and every line's
 joined length against the policy. `bindReportRuntimeAssignmentLogsResponse(response, request)`

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/interfaces',
-  version: '32.36.1',
+  version: '32.38.0',
   description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 }

package/ts/data/runtimeassignmentlogs.ts

@@ -6,7 +6,7 @@ import { snapshotRuntimeSessionBinding } from './runtimesession.js';
 import {
   captureNetwork, networkCounter, networkEqual, networkId, networkList, networkRecord, requireNetwork,
 } from '../private/networkcontract.js';
-import { isRuntimeLogPolicy } from '../private/runtimepolicy.js';
+import { isRuntimeLogPolicy, runtimePolicyLimits } from '../private/runtimepolicy.js';
 
 /** The container output a log line was written to. */
 export type TRuntimeAssignmentLogStream = 'stdout' | 'stderr';
@@ -39,9 +39,14 @@ export interface IRuntimeAssignmentLogLine {
  * - `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.
+ *   available; how much there was is unknown;
+ * - `not-kept`: the node dropped this output while its controller kept no logs. Once a session
+ *   answered `not-kept`, the node may drop a running capture's output instead of holding it,
+ *   including a batch it sent that is still unacknowledged; a later session that keeps logs
+ *   receives the capture from where it stands, after this loss.
  */
-export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured';
+export type TRuntimeAssignmentLogLossReason =
+  | 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured' | 'not-kept';
 
 /**
  * Evidence of output that was lost, in the position of the stream where it was lost.
@@ -49,8 +54,8 @@ export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | '
  * `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.
+ * the stream of that line. A `buffer-overflow` or `not-kept` loss 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';
@@ -69,10 +74,23 @@ export type TRuntimeAssignmentLogEntry = IRuntimeAssignmentLogLine | IRuntimeAss
  *
  * `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.
+ * `capture-restart` loss. Within a capture `sequence` counts batches from 1, 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.
+ *
+ * A sequence number, once sent, is never sent again with other content: a retry resends the batch
+ * unchanged, `discardedCaptures` included. Reusing a number would lose data silently, because a
+ * controller that stored the earlier batch while its acknowledgement was lost answers `replay` and
+ * drops the new content with its loss evidence. The node skips numbers only after dropping a
+ * running capture's batch it sent that is still unacknowledged, which only a `not-kept` answer
+ * permits: the next batch it
+ * sends of that capture takes a higher number it never sent and opens with a `not-kept` loss that
+ * counts what was dropped. Where the controller holds the dropped batch, because only its
+ * acknowledgement was lost, it sees no gap, and that loss also counts content it holds.
+ *
+ * `discardedCaptures` is node-level loss evidence, not part of this capture (see
+ * `runtimeAssignmentLogContract.maximumEndedCaptures`).
  */
 export interface IRuntimeAssignmentLogBatch {
   assignmentId: string;
@@ -81,6 +99,24 @@ export interface IRuntimeAssignmentLogBatch {
   sequence: number;
   entries: TRuntimeAssignmentLogEntry[];
   final: boolean;
+  /**
+   * How many ended captures the node discarded whole and unacknowledged since it last stated a
+   * count: past its ended-capture bound, or while a `not-kept` answer stood. The node states the
+   * count on the next batch it creates, of any capture, and counts afresh from there. The batch is
+   * then the unit of retry for the count: if the node discards that batch unacknowledged, the count
+   * passes on to the next batch, so a count whose acknowledgement was lost may reach the controller
+   * again inside a later count. It never names the discarded captures, because remembering them
+   * would grow without bound while the controller is away. Absent means none; stated, it is at
+   * least 1.
+   *
+   * The count belongs to the node, not to the assignment, attempt or capture of the batch that
+   * carries it. A controller that keeps logs records it against the node and the session the batch
+   * arrived on, once for each batch it accepts and never for a batch it answers `replay`, which it
+   * recorded when it accepted it. Counts are not idempotent: a lost acknowledgement can repeat a
+   * count, so their sum may exceed the captures discarded. A controller that keeps no logs does
+   * nothing with the count beyond answering `not-kept`; the node keeps it for a later session.
+   */
+  discardedCaptures?: number;
 }
 
 /** Pallet push over its current authenticated session. */
@@ -90,21 +126,68 @@ export interface IReportRuntimeAssignmentLogsRequest {
 }
 
 /**
- * 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.
+ * How a controller answers one batch.
+ *
+ * - `accepted`: it holds the batch durably;
+ * - `replay`: it already holds this batch and does not store it again;
+ * - `not-kept`: it keeps no workload logs. It holds nothing, and the node sends no more batches on
+ *   this session; a later session may be answered differently. The answer is the node's permission
+ *   to discard for that session: it may discard every ended capture completely, its content and
+ *   identity, and each capture that ends later while the answer stands, counting them in
+ *   `discardedCaptures`. A running capture stays within `logs.maximumBufferedBytes`, whose overflow
+ *   is a `buffer-overflow` loss, or the node drops its output, a sent and unacknowledged batch
+ *   included, and states a `not-kept` loss where delivery resumes.
+ *
+ * A controller answers every batch with one of these; it never leaves the method unhandled, so a
+ * node can tell a controller that keeps no logs from a failure worth retrying. It never refuses a
+ * batch for a gap in `sequence`. Every gap the node leaves by discarding carries evidence: the
+ * batch after numbers it skipped opens with a `not-kept` loss (see `IRuntimeAssignmentLogBatch`),
+ * and a capture it discarded whole is counted in `discardedCaptures`. A controller therefore reads
+ * a gap before a batch that opens with a `not-kept` loss as the node's discard, which that loss
+ * counts, and a gap before any other batch as its own loss, which it records. A capture whose
+ * final batch never arrives leaves no gap to read: it may still be running, and one discarded whole
+ * is counted but never named.
  */
+export type TRuntimeAssignmentLogsStatus = 'accepted' | 'replay' | 'not-kept';
+
 export interface IReportRuntimeAssignmentLogsResponse {
-  status: 'accepted' | 'replay';
+  status: TRuntimeAssignmentLogsStatus;
   assignmentId: string;
   captureId: string;
   sequence: number;
 }
 
+/**
+ * Rollout: a receiver on interfaces 32.37.0 or earlier reads a batch by its exact schema and
+ * refuses one that carries `discardedCaptures` or a `not-kept` loss, on every retry. A controller
+ * must therefore run a later release before any node sends either.
+ */
 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',
+  /**
+   * A controller that keeps no logs answers `not-kept`, and the node stops for that session. It may
+   * then discard ended captures completely, counted in `discardedCaptures`, and drop running
+   * output, stated as a `not-kept` loss.
+   */
+  notKept: 'node-stops-for-the-session',
+  /**
+   * The most ended captures a node keeps awaiting acknowledgement, while its controller is away or
+   * slow. An ended capture holds its buffer, cursor record and waiting batch in the node's RAM-backed
+   * runtime directory, and a crash-looping workload ends one per restart; 64 covers a burst of
+   * restarts across the node's workloads before any of them loses its tail. Past this bound, or past
+   * `maximumEndedCaptureBytes`, the node discards the oldest ended captures completely and counts
+   * them in the next batch's `discardedCaptures`.
+   */
+  maximumEndedCaptures: 64,
+  /**
+   * The most bytes all ended captures awaiting acknowledgement hold together, measured as the node
+   * measures its `logs.maximumBufferedBytes` buffer. It equals the largest buffer a runtime config
+   * may set (`runtimeConfigContract.maximumLogBufferedBytes`), so one capture always fits whole, and
+   * it keeps the node's RAM-backed runtime directory from growing with the number of restarts.
+   */
+  maximumEndedCaptureBytes: runtimePolicyLimits.maximumLogBufferedBytes,
   /** 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. */
@@ -120,8 +203,8 @@ const fail = (): never => { throw new Error(runtimeAssignmentLogContract.error);
 const safe = <T>(operationArg: () => T): T => { try { return operationArg(); } catch { return fail(); } };
 const encoder = new TextEncoder();
 const streams = ['stdout', 'stderr'] as const;
-const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured'] as const;
-const statuses = ['accepted', 'replay'] as const;
+const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured', 'not-kept'] as const;
+const statuses = ['accepted', 'replay', 'not-kept'] as const;
 
 const literalOf = <TLiteral extends string>(valueArg: unknown, allowedArg: readonly TLiteral[]): TLiteral => {
   requireNetwork((allowedArg as readonly unknown[]).includes(valueArg));
@@ -172,12 +255,15 @@ const entryOf = (valueArg: unknown): TRuntimeAssignmentLogEntry => {
 };
 
 const batchOf = (valueArg: unknown): IRuntimeAssignmentLogBatch => {
-  const value = networkRecord(valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final']);
+  const value = networkRecord(
+    valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final'], ['discardedCaptures'],
+  );
   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,
+    ...(Object.hasOwn(value, 'discardedCaptures') ? { discardedCaptures: networkCounter(value.discardedCaptures) } : {}),
   };
 };
 

package/ts/data/runtimeconfig.ts

@@ -133,6 +133,7 @@ export const runtimeConfigContract = Object.freeze({
   maximumTargetPorts: 64,
   maximumReadinessDurationMs: runtimePolicyLimits.maximumReadinessDurationMs,
   maximumLogRetentionMs: runtimePolicyLimits.maximumLogRetentionMs,
+  maximumLogBufferedBytes: runtimePolicyLimits.maximumLogBufferedBytes,
 } as const);
 
 const fail: (messageArg: string) => never = (messageArg) => { throw new Error(messageArg); };

package/ts/private/runtimepolicy.ts

@@ -15,6 +15,8 @@ export const runtimePolicyLimits = Object.freeze({
   maximumIdentityNumber: 2 ** 31 - 1,
   maximumReadinessDurationMs: 3_600_000,
   maximumLogRetentionMs: 31_536_000_000,
+  /** The largest `logs.maximumBufferedBytes`; a node's ended captures share the same bound. */
+  maximumLogBufferedBytes: 67_108_864,
 } as const);
 
 export type TRuntimePolicyFailure = (messageArg: string) => never;
@@ -43,7 +45,7 @@ export const isRuntimeIdentityNumber = (valueArg: unknown): valueArg is number =
 export const isRuntimeLogPolicy = (valueArg: unknown): valueArg is IRuntimeConfigLogPolicy =>
   isExactRecord(valueArg, ['maximumLineBytes', 'maximumBufferedBytes', 'retentionMs'])
   && isBoundedInteger(valueArg.maximumLineBytes, 1, 1_048_576)
-  && isBoundedInteger(valueArg.maximumBufferedBytes, 1, 67_108_864)
+  && isBoundedInteger(valueArg.maximumBufferedBytes, 1, runtimePolicyLimits.maximumLogBufferedBytes)
   && valueArg.maximumBufferedBytes >= valueArg.maximumLineBytes
   && isBoundedInteger(valueArg.retentionMs, 1, runtimePolicyLimits.maximumLogRetentionMs);