@serve.zone/interfaces 32.46.0 → 32.47.0

package/changelog.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 2026-10-05 - 32.47.0
+
+### Features
+
+- Operators can read the workload logs a controller keeps. `requests.service.getServiceRuntimeLogAttempts
+  { identity, serviceId, cursor, limit }` pages a service's attempts, newest issued first, as
+  `IRuntimeAssignmentLogAttemptView`s (identity, `issuedAt`, `lastAcceptedAt`, capture counts,
+  `keptBytes`, `truncatedBatches`, and `expiresAt`: the latest of issue, last accepted batch and
+  release plus `logs.retentionMs`, null while the slot still holds the attempt), replaced and
+  released attempts included until their logs expire. `requests.service.getRuntimeAssignmentLogs { identity, serviceId, assignmentId, cursor,
+  limit }` pages one attempt's `TRuntimeAssignmentLogRecord`s in delivery order: `batch` as the node
+  sent it, `gap` for numbers whose batches the controller did not receive or no longer holds (its own
+  loss), and `truncated` for batches the controller dropped (`batch-cap`, `byte-cap` or `retention`,
+  in that canonical order) with exact counts.
+  `runtimeAssignmentLogReadContract` bounds a read: 256 attempts or records, 4 096 entries and 2 MiB
+  of canonical JSON per page, one batch always fitting. `snapshotRuntimeAssignmentLogAttemptView`,
+  `snapshotRuntimeAssignmentLogAttemptPage` and `snapshotRuntimeAssignmentLogPage` read the answers
+  exactly, the last enforcing delivery order; `bindRuntimeAssignmentLogAttemptPage` and
+  `bindRuntimeAssignmentLogPage` match an answer to its read. Refusals travel as
+  `IRuntimeAssignmentLogReadErrorData` (`attempt-not-found`, `cursor-invalid`, `limit-invalid`).
+  Lab RUN 7b: a failed CoreTraffic run's output was lost because no controller kept workload logs.
+
+### Maintenance
+
+- Release tooling: pnpm 12.7.0 → 12.8.0.
+
 ## 2026-10-05 - 32.46.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '32.46.0',
+    version: '32.47.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

@@ -200,3 +200,139 @@ export declare const bindReportRuntimeAssignmentLogsRequest: (valueArg: unknown,
 }>;
 /** Matches an acknowledgement to the exact batch that was sent. */
 export declare const bindReportRuntimeAssignmentLogsResponse: (valueArg: unknown, requestArg: unknown) => IReportRuntimeAssignmentLogsResponse;
+/**
+ * Why a controller no longer holds batches it accepted: `batch-cap`, its bound on how many batches
+ * it keeps of one attempt; `byte-cap`, its bound on the text it keeps of one attempt; both drop
+ * the oldest batches first; `retention`, the config's `logs.retentionMs` since it accepted them.
+ * A node delivers about once a second, so a workload that writes now and then sends many small
+ * batches, which the batch bound holds where the text bound would not.
+ */
+export type TRuntimeAssignmentLogTruncationReason = 'batch-cap' | 'byte-cap' | 'retention';
+/** One batch the controller accepted and still holds, as the node sent it. */
+export interface IRuntimeAssignmentLogBatchRecord {
+    kind: 'batch';
+    captureId: string;
+    sequence: number;
+    /** When the controller accepted the batch, in milliseconds since the Unix epoch. */
+    acceptedAt: number;
+    final: boolean;
+    entries: TRuntimeAssignmentLogEntry[];
+}
+/**
+ * Sequence numbers of one capture whose batches the controller did not receive or no longer holds
+ * (its own loss): numbers that never arrived and that the node did not account for, and batches it
+ * accepted whose payload it has lost. A gap the node left by discarding is not one: the batch
+ * after it opens with the `not-kept` loss that counts it.
+ */
+export interface IRuntimeAssignmentLogGapRecord {
+    kind: 'gap';
+    captureId: string;
+    fromSequence: number;
+    toSequence: number;
+}
+/**
+ * Batches of one capture the controller accepted and has since dropped: every batch it held of the
+ * capture up to and including `throughSequence`, oldest first, so a truncation is always the start
+ * of what remains of a capture. Gaps inside that range are no longer stated. The counts are exact.
+ */
+export interface IRuntimeAssignmentLogTruncationRecord {
+    kind: 'truncated';
+    captureId: string;
+    throughSequence: number;
+    /** In the canonical order `batch-cap`, `byte-cap`, `retention`; duplicate-free, at least one. */
+    reasons: TRuntimeAssignmentLogTruncationReason[];
+    /** The accepted batches dropped, at least one and at most `throughSequence`. */
+    batches: number;
+    /** The UTF-8 bytes of `text` the dropped batches held. */
+    bytes: number;
+    /** The entries, lines and losses alike, the dropped batches held. */
+    entries: number;
+}
+export type TRuntimeAssignmentLogRecord = IRuntimeAssignmentLogBatchRecord | IRuntimeAssignmentLogGapRecord | IRuntimeAssignmentLogTruncationRecord;
+/**
+ * One attempt whose logs the controller keeps, as an operator reads it. The controller keeps an
+ * attempt's logs from the moment it issues the attempt, so an attempt that failed before writing a
+ * line is listed with nothing held, and an attempt its slot released stays readable until
+ * `expiresAt`.
+ */
+export interface IRuntimeAssignmentLogAttemptView {
+    serviceId: string;
+    replicaId: string;
+    nodeId: string;
+    assignmentId: string;
+    attemptId: string;
+    /** When the controller issued the attempt, in milliseconds since the Unix epoch. */
+    issuedAt: number;
+    /** When it last accepted a batch of the attempt; null until it accepted one. */
+    lastAcceptedAt: number | null;
+    /**
+     * When the controller drops the attempt's logs whole: the latest of `issuedAt`, `lastAcceptedAt`
+     * and the time the attempt's slot released it, plus the attempt's `logs.retentionMs`. Null while
+     * the slot still holds the attempt: no expiry is scheduled, however quiet the attempt is.
+     */
+    expiresAt: number | null;
+    /** The captures of the attempt the controller accepted a batch of. */
+    captures: number;
+    /** Those of them whose final batch it accepted. */
+    capturesEnded: number;
+    /** The UTF-8 bytes of `text` the controller holds of the attempt. */
+    keptBytes: number;
+    /** The accepted batches of the attempt it has since dropped, stated in truncation records. */
+    truncatedBatches: number;
+}
+/** One page of a service's attempts, newest issued first, ties in `assignmentId` order. */
+export interface IRuntimeAssignmentLogAttemptPage {
+    attempts: IRuntimeAssignmentLogAttemptView[];
+    /** Where the next page starts; null when this page is the last. Opaque to the reader. */
+    nextCursor: string | null;
+}
+/**
+ * One page of one attempt's kept logs, in delivery order: captures in the order the controller
+ * first accepted a batch of each, and within a capture by sequence. A capture's truncation record
+ * comes first, a gap record directly before the batch that follows it.
+ */
+export interface IRuntimeAssignmentLogPage {
+    attempt: IRuntimeAssignmentLogAttemptView;
+    records: TRuntimeAssignmentLogRecord[];
+    /** Where the next page starts; null when this page is the last. Opaque to the reader. */
+    nextCursor: string | null;
+}
+/**
+ * Why a controller refuses a log read: `attempt-not-found` (it keeps no logs of that attempt for
+ * that service, never did or no longer does), `cursor-invalid` (a cursor it did not hand out for
+ * this read) and `limit-invalid` (a `limit` outside its bound).
+ */
+export type TRuntimeAssignmentLogReadRefusal = 'attempt-not-found' | 'cursor-invalid' | 'limit-invalid';
+/** The named refusal of a log read, sent as `TypedResponseError.errorData`. */
+export interface IRuntimeAssignmentLogReadErrorData {
+    code: TRuntimeAssignmentLogReadRefusal;
+    retryable: false;
+}
+export declare const runtimeAssignmentLogReadContract: Readonly<{
+    readonly error: "Runtime assignment log read contract rejected.";
+    /** The largest `limit` `getServiceRuntimeLogAttempts` accepts; a controller refuses a larger one. */
+    readonly maximumAttemptPageSize: 256;
+    /** The largest `limit` `getRuntimeAssignmentLogs` accepts, counted in records. */
+    readonly maximumPageRecords: 256;
+    /**
+     * The most entries the records of one log page hold together: four full batches. It keeps a page
+     * within the node count every captured value is held to; one batch always fits.
+     */
+    readonly maximumPageEntries: number;
+    /**
+     * The canonical JSON of a whole log page is at most two mebibytes, and the controller closes a
+     * page before the next record would cross it. One batch always fits: its record is smaller than
+     * the report that carried it, which `maximumReportCanonicalBytes` bounded.
+     */
+    readonly maximumPageCanonicalBytes: number;
+}>;
+/** Detached exact-schema snapshot of one attempt view. */
+export declare const snapshotRuntimeAssignmentLogAttemptView: (valueArg: unknown) => IRuntimeAssignmentLogAttemptView;
+/** Detached exact-schema snapshot of one attempt page, in its one order. */
+export declare const snapshotRuntimeAssignmentLogAttemptPage: (valueArg: unknown) => IRuntimeAssignmentLogAttemptPage;
+/** Detached exact-schema snapshot of one log page, bounded and in delivery order. */
+export declare const snapshotRuntimeAssignmentLogPage: (valueArg: unknown) => IRuntimeAssignmentLogPage;
+/** Matches an attempt page to the read that asked for it: that service's attempts, within its limit. */
+export declare const bindRuntimeAssignmentLogAttemptPage: (valueArg: unknown, serviceIdArg: string, limitArg: number) => IRuntimeAssignmentLogAttemptPage;
+/** Matches a log page to the read that asked for it: that attempt of that service, within its limit. */
+export declare const bindRuntimeAssignmentLogPage: (valueArg: unknown, serviceIdArg: string, assignmentIdArg: string, limitArg: number) => IRuntimeAssignmentLogPage;

package/dist_ts/data/runtimeassignmentlogs.js

@@ -1,6 +1,7 @@
-import { snapshotRuntimeAssignment, validateRuntimeAssignment } from './runtimeassignment.js';
+import { isRuntimeReplicaId, snapshotRuntimeAssignment, validateRuntimeAssignment } from './runtimeassignment.js';
 import { snapshotRuntimeSessionBinding } from './runtimesession.js';
-import { captureNetwork, networkCounter, networkEqual, networkId, networkList, networkRecord, requireNetwork, } from '../private/networkcontract.js';
+import { captureNetwork, networkCounter, networkEqual, networkId, networkList, networkNodeId, networkRecord, networkSorted, requireNetwork, } from '../private/networkcontract.js';
+import { isOneOf, variantOf } from '../private/producercontract.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
@@ -164,4 +165,168 @@ 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":"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"}
+export const runtimeAssignmentLogReadContract = Object.freeze({
+    error: 'Runtime assignment log read contract rejected.',
+    /** The largest `limit` `getServiceRuntimeLogAttempts` accepts; a controller refuses a larger one. */
+    maximumAttemptPageSize: 256,
+    /** The largest `limit` `getRuntimeAssignmentLogs` accepts, counted in records. */
+    maximumPageRecords: 256,
+    /**
+     * The most entries the records of one log page hold together: four full batches. It keeps a page
+     * within the node count every captured value is held to; one batch always fits.
+     */
+    maximumPageEntries: 4 * runtimeAssignmentLogContract.maximumEntriesPerBatch,
+    /**
+     * The canonical JSON of a whole log page is at most two mebibytes, and the controller closes a
+     * page before the next record would cross it. One batch always fits: its record is smaller than
+     * the report that carried it, which `maximumReportCanonicalBytes` bounded.
+     */
+    maximumPageCanonicalBytes: 2 * runtimeAssignmentLogContract.maximumReportCanonicalBytes,
+});
+const readFail = () => { throw new Error(runtimeAssignmentLogReadContract.error); };
+const readSafe = (operationArg) => { try {
+    return operationArg();
+}
+catch {
+    return readFail();
+} };
+/** The canonical order of `reasons`. */
+const truncationReasons = ['batch-cap', 'byte-cap', 'retention'];
+const cursorOf = (valueArg) => valueArg === null ? null : networkId(valueArg);
+const batchRecordOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['kind', 'captureId', 'sequence', 'acceptedAt', 'final', 'entries']);
+    const entries = networkList(value.entries, runtimeAssignmentLogContract.maximumEntriesPerBatch, entryOf);
+    requireNetwork(value.kind === 'batch' && typeof value.final === 'boolean' && (entries.length > 0 || value.final));
+    return {
+        kind: 'batch', captureId: networkId(value.captureId), sequence: networkCounter(value.sequence),
+        acceptedAt: networkCounter(value.acceptedAt), final: value.final, entries,
+    };
+};
+const gapRecordOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['kind', 'captureId', 'fromSequence', 'toSequence']);
+    const fromSequence = networkCounter(value.fromSequence), toSequence = networkCounter(value.toSequence);
+    requireNetwork(value.kind === 'gap' && fromSequence <= toSequence);
+    return { kind: 'gap', captureId: networkId(value.captureId), fromSequence, toSequence };
+};
+const truncationRecordOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['kind', 'captureId', 'throughSequence', 'reasons', 'batches', 'bytes', 'entries']);
+    requireNetwork(value.kind === 'truncated');
+    const throughSequence = networkCounter(value.throughSequence);
+    const reasons = networkSorted(networkList(value.reasons, truncationReasons.length, (reasonArg) => {
+        requireNetwork(isOneOf(truncationReasons, reasonArg));
+        return reasonArg;
+    }), (reasonArg) => String(truncationReasons.indexOf(reasonArg)));
+    requireNetwork(reasons.length > 0);
+    return {
+        kind: 'truncated', captureId: networkId(value.captureId), throughSequence, reasons,
+        batches: networkCounter(value.batches, throughSequence), bytes: countOf(value.bytes), entries: countOf(value.entries),
+    };
+};
+const recordOf = (valueArg) => {
+    const kind = variantOf(valueArg, 'kind');
+    if (kind === 'batch')
+        return batchRecordOf(valueArg);
+    if (kind === 'gap')
+        return gapRecordOf(valueArg);
+    return truncationRecordOf(valueArg);
+};
+const opensWithNotKept = (recordArg) => {
+    const first = recordArg.entries[0];
+    return first !== undefined && first.kind === 'lost' && first.reason === 'not-kept';
+};
+/**
+ * Delivery order within a page. Each capture's records are contiguous and never return once
+ * another capture's began. A truncation only opens its capture. Every other record continues where
+ * the one before it ended: a gap at the next number, never right after another gap, and a batch at
+ * the next number or, past numbers the node skipped, opening with the `not-kept` loss that counts
+ * them. Nothing follows a final batch.
+ */
+const requireDeliveryOrder = (recordsArg) => {
+    const begun = new Set();
+    let previous = null;
+    for (const record of recordsArg) {
+        const continues = previous !== null && previous.captureId === record.captureId;
+        if (!continues) {
+            requireNetwork(!begun.has(record.captureId));
+            begun.add(record.captureId);
+        }
+        if (previous === null || !continues) {
+            previous = record;
+            continue;
+        }
+        requireNetwork(record.kind !== 'truncated' && !(previous.kind === 'batch' && previous.final));
+        const next = (previous.kind === 'batch' ? previous.sequence
+            : previous.kind === 'gap' ? previous.toSequence : previous.throughSequence) + 1;
+        if (record.kind === 'gap') {
+            requireNetwork(previous.kind !== 'gap' && record.fromSequence === next);
+        }
+        else {
+            requireNetwork(record.sequence === next || (record.sequence > next && opensWithNotKept(record)));
+        }
+        previous = record;
+    }
+};
+const attemptOf = (valueArg) => {
+    const value = networkRecord(valueArg, [
+        'serviceId', 'replicaId', 'nodeId', 'assignmentId', 'attemptId', 'issuedAt', 'lastAcceptedAt', 'expiresAt',
+        'captures', 'capturesEnded', 'keptBytes', 'truncatedBatches',
+    ]);
+    requireNetwork(isRuntimeReplicaId(value.replicaId));
+    const issuedAt = networkCounter(value.issuedAt);
+    const lastAcceptedAt = value.lastAcceptedAt === null ? null : networkCounter(value.lastAcceptedAt);
+    const expiresAt = value.expiresAt === null ? null : networkCounter(value.expiresAt);
+    const captures = countOf(value.captures), capturesEnded = countOf(value.capturesEnded);
+    const keptBytes = countOf(value.keptBytes), truncatedBatches = countOf(value.truncatedBatches);
+    requireNetwork((expiresAt === null || expiresAt > Math.max(issuedAt, lastAcceptedAt ?? issuedAt))
+        && capturesEnded <= captures);
+    // Nothing accepted means nothing captured, held or dropped.
+    requireNetwork(lastAcceptedAt !== null || (captures === 0 && keptBytes === 0 && truncatedBatches === 0));
+    return {
+        serviceId: networkId(value.serviceId), replicaId: value.replicaId, nodeId: networkNodeId(value.nodeId),
+        assignmentId: networkId(value.assignmentId), attemptId: networkId(value.attemptId), issuedAt, lastAcceptedAt,
+        expiresAt, captures, capturesEnded, keptBytes, truncatedBatches,
+    };
+};
+const pageLimitOf = (limitArg, maximumArg) => networkCounter(limitArg, maximumArg);
+/** Detached exact-schema snapshot of one attempt view. */
+export const snapshotRuntimeAssignmentLogAttemptView = (valueArg) => readSafe(() => attemptOf(captureNetwork(valueArg)));
+/** Detached exact-schema snapshot of one attempt page, in its one order. */
+export const snapshotRuntimeAssignmentLogAttemptPage = (valueArg) => readSafe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['attempts', 'nextCursor']);
+    const attempts = networkList(value.attempts, runtimeAssignmentLogReadContract.maximumAttemptPageSize, attemptOf);
+    attempts.forEach((attemptArg, indexArg) => {
+        const before = attempts[indexArg - 1];
+        requireNetwork(before === undefined || before.issuedAt > attemptArg.issuedAt
+            || (before.issuedAt === attemptArg.issuedAt && before.assignmentId < attemptArg.assignmentId));
+    });
+    const nextCursor = cursorOf(value.nextCursor);
+    requireNetwork(nextCursor === null || attempts.length > 0);
+    return { attempts, nextCursor };
+});
+/** Detached exact-schema snapshot of one log page, bounded and in delivery order. */
+export const snapshotRuntimeAssignmentLogPage = (valueArg) => readSafe(() => {
+    const value = networkRecord(captureNetwork(valueArg, runtimeAssignmentLogReadContract.maximumPageCanonicalBytes), ['attempt', 'records', 'nextCursor']);
+    const records = networkList(value.records, runtimeAssignmentLogReadContract.maximumPageRecords, recordOf);
+    requireNetwork(records.reduce((totalArg, recordArg) => totalArg + (recordArg.kind === 'batch' ? recordArg.entries.length : 0), 0)
+        <= runtimeAssignmentLogReadContract.maximumPageEntries);
+    requireDeliveryOrder(records);
+    const nextCursor = cursorOf(value.nextCursor);
+    requireNetwork(nextCursor === null || records.length > 0);
+    return { attempt: attemptOf(value.attempt), records, nextCursor };
+});
+/** Matches an attempt page to the read that asked for it: that service's attempts, within its limit. */
+export const bindRuntimeAssignmentLogAttemptPage = (valueArg, serviceIdArg, limitArg) => readSafe(() => {
+    const page = snapshotRuntimeAssignmentLogAttemptPage(valueArg);
+    const limit = pageLimitOf(limitArg, runtimeAssignmentLogReadContract.maximumAttemptPageSize);
+    requireNetwork(page.attempts.length <= limit && page.attempts.every((attemptArg) => attemptArg.serviceId === serviceIdArg));
+    return page;
+});
+/** Matches a log page to the read that asked for it: that attempt of that service, within its limit. */
+export const bindRuntimeAssignmentLogPage = (valueArg, serviceIdArg, assignmentIdArg, limitArg) => readSafe(() => {
+    const page = snapshotRuntimeAssignmentLogPage(valueArg);
+    const limit = pageLimitOf(limitArg, runtimeAssignmentLogReadContract.maximumPageRecords);
+    requireNetwork(page.records.length <= limit && page.attempt.serviceId === serviceIdArg
+        && page.attempt.assignmentId === assignmentIdArg);
+    return page;
+});
+//# 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/private/networkcontract.d.ts

@@ -25,8 +25,14 @@ export declare class RuntimeNetworkAddressPlanStructureError extends Error {
     constructor(violationArg: IRuntimeNetworkAddressPlanStructureViolation);
 }
 export declare const networkSafe: <T>(operation: () => T) => T;
-/** Bound decoded transport input before canonicalization; never execute getters/toJSON. */
-export declare const captureNetwork: (value: unknown) => unknown;
+/** The canonical JSON bound every runtime network contract captures with, unless it states its own. */
+export declare const networkMaximumCanonicalBytes = 1048576;
+/**
+ * Bound decoded transport input before canonicalization; never execute getters/toJSON.
+ * `maximumBytes` bounds the whole value's canonical JSON; a single string stays within
+ * `networkMaximumCanonicalBytes` whatever the whole may hold.
+ */
+export declare const captureNetwork: (value: unknown, maximumBytes?: number) => unknown;
 export declare const networkRecord: (value: unknown, keys: string[], optionalKeys?: string[]) => Record<string, unknown>;
 export declare const networkList: <T>(value: unknown, maximum: number, read: (item: unknown) => T) => T[];
 export declare const networkSorted: <T>(values: T[], key: (item: T) => string) => T[];

package/dist_ts/private/networkcontract.js

@@ -28,14 +28,20 @@ export const networkSafe = (operation) => {
         return failNetwork();
     }
 };
-/** Bound decoded transport input before canonicalization; never execute getters/toJSON. */
-export const captureNetwork = (value) => networkSafe(() => {
+/** The canonical JSON bound every runtime network contract captures with, unless it states its own. */
+export const networkMaximumCanonicalBytes = 1_048_576;
+/**
+ * Bound decoded transport input before canonicalization; never execute getters/toJSON.
+ * `maximumBytes` bounds the whole value's canonical JSON; a single string stays within
+ * `networkMaximumCanonicalBytes` whatever the whole may hold.
+ */
+export const captureNetwork = (value, maximumBytes = networkMaximumCanonicalBytes) => networkSafe(() => {
     const encoder = new TextEncoder(), ancestors = new Set();
     let nodes = 0, bytes = 0;
     const account = (text) => {
-        requireNetwork(text.length <= 1_048_576);
+        requireNetwork(text.length <= networkMaximumCanonicalBytes);
         bytes += encoder.encode(text).length;
-        requireNetwork(bytes <= 1_048_576);
+        requireNetwork(bytes <= maximumBytes);
     };
     const copy = (item, depth) => {
         requireNetwork(++nodes <= 65_536 && depth <= 24);
@@ -81,7 +87,7 @@ export const captureNetwork = (value) => networkSafe(() => {
         }
     };
     const result = copy(value, 0);
-    requireNetwork(encoder.encode(networkCanonical(result)).length <= 1_048_576);
+    requireNetwork(encoder.encode(networkCanonical(result)).length <= maximumBytes);
     return result;
 });
 export const networkRecord = (value, keys, optionalKeys = []) => {
@@ -247,4 +253,4 @@ export const networkCoveredBy = (prefixes, prefix) => {
     }, 0);
     return covered === last - first + 1;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkcontract.js","sourceRoot":"","sources":["../../ts/private/networkcontract.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkcontract.js","sourceRoot":"","sources":["../../ts/private/networkcontract.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/service.d.ts

@@ -11,6 +11,7 @@ import type { IDeploymentReservationInput, IServiceDeploymentOperation, IService
 import type { TSha256Digest } from '../data/immutableimage.js';
 import type { ILegacyServiceRuntimeAttestation } from '../data/deploymentlegacyimport.js';
 import type { IProtocolOffer } from '../protocol.js';
+import type { IRuntimeAssignmentLogAttemptPage, IRuntimeAssignmentLogPage } from '../data/runtimeassignmentlogs.js';
 import type { IServiceRuntimeAssignmentView, IServiceRuntimeSpec, IServiceRuntimeStatus, TServiceRuntimeSpecWritableData } from '../data/serviceruntime.js';
 import type { IServiceDeploymentAdoptionInput, IServiceDeploymentAdoptionImagePromotionInput, IServiceDeploymentAdoptionImagePromotionResult, IServiceDeploymentAdoptionRolloutInput, IServiceDeploymentAdoptionRolloutResult, IServiceDeploymentAdoptionPreflightInput, IServiceDeploymentAdoptionReport, IServiceDeploymentAdoptionResult } from '../data/deploymentadoption.js';
 export interface IRequest_Any_Cloudly_BootstrapServiceDeploymentAdoptionRollout extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IRequest_Any_Cloudly_BootstrapServiceDeploymentAdoptionRollout> {
@@ -466,6 +467,42 @@ export interface IRequest_Any_Cloudly_GetServiceRuntimeAssignments extends plugi
         assignments: IServiceRuntimeAssignmentView[];
     };
 }
+/**
+ * The attempts of one service whose workload logs Cloudly keeps, newest issued first, a page at a
+ * time: a slot's replaced and released attempts stay readable until their logs expire, which no
+ * single response bounds. `limit` runs from 1 to
+ * `runtimeAssignmentLogReadContract.maximumAttemptPageSize`; Cloudly refuses any other with
+ * `IRuntimeAssignmentLogReadErrorData`. `cursor` is null for the first page, then the page's own
+ * `nextCursor`. `bindRuntimeAssignmentLogAttemptPage` checks an answer against its read.
+ */
+export interface IRequest_Any_Cloudly_GetServiceRuntimeLogAttempts extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IRequest_Any_Cloudly_GetServiceRuntimeLogAttempts> {
+    method: 'getServiceRuntimeLogAttempts';
+    request: {
+        identity: IIdentity;
+        serviceId: string;
+        cursor: string | null;
+        limit: number;
+    };
+    response: IRuntimeAssignmentLogAttemptPage;
+}
+/**
+ * One attempt's kept workload logs, a page at a time in delivery order, with the gaps Cloudly found
+ * and the truncations it made stated in place. `limit` counts records and runs from 1 to
+ * `runtimeAssignmentLogReadContract.maximumPageRecords`; a page also ends before it would cross
+ * `maximumPageEntries` or `maximumPageCanonicalBytes`, so it may hold fewer records than `limit`
+ * while `nextCursor` still names more. `bindRuntimeAssignmentLogPage` checks an answer against its read.
+ */
+export interface IRequest_Any_Cloudly_GetRuntimeAssignmentLogs extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IRequest_Any_Cloudly_GetRuntimeAssignmentLogs> {
+    method: 'getRuntimeAssignmentLogs';
+    request: {
+        identity: IIdentity;
+        serviceId: string;
+        assignmentId: string;
+        cursor: string | null;
+        limit: number;
+    };
+    response: IRuntimeAssignmentLogPage;
+}
 /**
  * Cloudly -> admin UIs: a service's runtime spec, status or assignments changed. It carries no
  * state, so a late or repeated push can never overwrite a newer read; the UI reads the views again.

package/package.json

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

package/readme.md

@@ -1553,6 +1553,62 @@ session, that the assignment is this node's and carries the batch's attempt, and
 joined length against the policy. `bindReportRuntimeAssignmentLogsResponse(response, request)`
 binds the acknowledgement to the batch.
 
+**Reading kept logs.** An operator reads what Cloudly keeps through two service requests, which
+take `{ identity, serviceId }` and are authorized like every other read of that service. Cloudly
+keeps an attempt's logs from the moment it issues the attempt, so an attempt that failed before
+writing a line is listed with nothing held, and an attempt whose slot was replaced or released stays
+readable until its logs expire.
+
+- `requests.service.getServiceRuntimeLogAttempts { identity, serviceId, cursor, limit }` answers an
+  `IRuntimeAssignmentLogAttemptPage { attempts, nextCursor }`: the service's attempts, newest issued
+  first and ties in `assignmentId` order. An `IRuntimeAssignmentLogAttemptView` states `serviceId`,
+  `replicaId`, `nodeId`, `assignmentId`, `attemptId`, `issuedAt`, `lastAcceptedAt` (null until a
+  batch was accepted), `expiresAt` (when the attempt's logs are dropped whole: the latest of
+  `issuedAt`, `lastAcceptedAt` and the time the attempt's slot released it, plus the config's
+  `logs.retentionMs`; null while the slot still holds the attempt, which schedules no expiry however
+  quiet it is), `captures` and `capturesEnded` (captures with a batch, and
+  those whose final batch arrived), `keptBytes` (UTF-8 bytes of `text` held) and `truncatedBatches`.
+  `limit` runs from 1 to `runtimeAssignmentLogReadContract.maximumAttemptPageSize` (256).
+- `requests.service.getRuntimeAssignmentLogs { identity, serviceId, assignmentId, cursor, limit }`
+  answers an `IRuntimeAssignmentLogPage { attempt, records, nextCursor }`: one attempt's records in
+  delivery order, captures in the order the first batch of each was accepted and each capture by
+  sequence. `limit` counts records, from 1 to `maximumPageRecords` (256). A page also ends before
+  its records would hold more than `maximumPageEntries` (4 096, four full batches) entries or its
+  canonical JSON would cross `maximumPageCanonicalBytes` (2 MiB), so it may hold fewer than `limit`
+  while `nextCursor` names more. One batch always fits: its record is smaller than the report that
+  carried it.
+
+A `TRuntimeAssignmentLogRecord` is one of three, so nothing is ever dropped silently:
+
+- `batch { captureId, sequence, acceptedAt, final, entries }`: a batch as the node sent it, its
+  lines and loss entries unchanged;
+- `gap { captureId, fromSequence, toSequence }`: sequence numbers whose batches Cloudly did not
+  receive or no longer holds, its own loss: numbers that never arrived and that the node did not
+  account for, and accepted batches whose payload Cloudly has lost. Numbers the node skipped are not
+  a gap: the batch after them opens with the `not-kept` loss that counts them;
+- `truncated { captureId, throughSequence, reasons, batches, bytes, entries }`: every batch Cloudly
+  held of the capture up to `throughSequence` and has since dropped, oldest first, with exact counts.
+  `reasons` (`TRuntimeAssignmentLogTruncationReason`, duplicate-free, in the canonical order
+  `batch-cap`, `byte-cap`, `retention`) are `batch-cap`, Cloudly's bound on how many batches it
+  keeps of one attempt, `byte-cap`, its bound on the text it keeps of one attempt, and `retention`,
+  the config's `logs.retentionMs`. A node delivers about once a second, so a workload that writes
+  now and then sends many small batches, which the batch bound holds where the text bound would
+  not. Gaps inside the range are no longer stated.
+
+`snapshotRuntimeAssignmentLogPage` enforces that order: a capture's records are contiguous and never
+return, a truncation only opens its capture, a gap starts at the number after the record before it,
+a gap never directly follows another gap (the controller states adjacent losses, received or not,
+as one gap, across pages too), a batch continues at the next number or, past numbers the node
+skipped, opens with a `not-kept` loss, and nothing follows a final batch. A page may resume inside a
+capture, so a capture's first record on a page is not judged against what came before it. A `nextCursor` is
+an opaque identifier, null on the last page, and never follows an empty page.
+`snapshotRuntimeAssignmentLogAttemptView` and `snapshotRuntimeAssignmentLogAttemptPage` read the
+attempt side. `bindRuntimeAssignmentLogAttemptPage(page, serviceId, limit)` and
+`bindRuntimeAssignmentLogPage(page, serviceId, assignmentId, limit)` match an answer to its read. A
+refused read carries `IRuntimeAssignmentLogReadErrorData { code, retryable: false }`, where
+`TRuntimeAssignmentLogReadRefusal` is `attempt-not-found` (no logs of that attempt for that
+service), `cursor-invalid` or `limit-invalid`.
+
 **Stats.** `IReq_Controller_Pallet_ReadRuntimeAssignmentStats` (`readRuntimeAssignmentStats`)
 reads one sample of one attempt: `{ session, assignment }` names the exact current revision, and
 the answer is `{ status: 'sampled', assignment, sample }` or `{ status: 'not-running', assignment,
@@ -2009,6 +2065,9 @@ through every slot on a cluster's nodes; `limit` runs from 1 to
 `serviceRuntimeContract.maximumAssignmentPageSize` (256), and Cloudly refuses any other.
 `requests.service.pushServiceRuntimeChanged { serviceId }` tells admin UIs that a service's spec,
 status or assignments changed; it carries no state, so a late push never overwrites a newer read.
+A slot's replaced and released attempts leave these views; their kept workload logs stay readable
+through `getServiceRuntimeLogAttempts` and `getRuntimeAssignmentLogs` (see
+[Runtime Workload Logs, Stats, Exec And Volume Archives](#runtime-workload-logs-stats-exec-and-volume-archives)).
 
 ### Node Retirement
 

package/ts/00_commitinfo_data.ts

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

package/ts/data/runtimeassignmentlogs.ts

@@ -1,11 +1,13 @@
 import type { IRuntimeAssignment } from './runtimeassignment.js';
-import { snapshotRuntimeAssignment, validateRuntimeAssignment } from './runtimeassignment.js';
+import { isRuntimeReplicaId, snapshotRuntimeAssignment, validateRuntimeAssignment } from './runtimeassignment.js';
 import type { IRuntimeConfigLogPolicy } from './runtimeconfig.js';
 import type { IRuntimeSessionBinding } from './runtimesession.js';
 import { snapshotRuntimeSessionBinding } from './runtimesession.js';
 import {
-  captureNetwork, networkCounter, networkEqual, networkId, networkList, networkRecord, requireNetwork,
+  captureNetwork, networkCounter, networkEqual, networkId, networkList, networkNodeId, networkRecord, networkSorted,
+  requireNetwork,
 } from '../private/networkcontract.js';
+import { isOneOf, variantOf } from '../private/producercontract.js';
 import { isRuntimeLogPolicy, runtimePolicyLimits } from '../private/runtimepolicy.js';
 
 /** The container output a log line was written to. */
@@ -333,3 +335,306 @@ export const bindReportRuntimeAssignmentLogsResponse = (
     && response.sequence === batch.sequence);
   return response;
 });
+
+// Reading kept logs
+
+/**
+ * Why a controller no longer holds batches it accepted: `batch-cap`, its bound on how many batches
+ * it keeps of one attempt; `byte-cap`, its bound on the text it keeps of one attempt; both drop
+ * the oldest batches first; `retention`, the config's `logs.retentionMs` since it accepted them.
+ * A node delivers about once a second, so a workload that writes now and then sends many small
+ * batches, which the batch bound holds where the text bound would not.
+ */
+export type TRuntimeAssignmentLogTruncationReason = 'batch-cap' | 'byte-cap' | 'retention';
+
+/** One batch the controller accepted and still holds, as the node sent it. */
+export interface IRuntimeAssignmentLogBatchRecord {
+  kind: 'batch';
+  captureId: string;
+  sequence: number;
+  /** When the controller accepted the batch, in milliseconds since the Unix epoch. */
+  acceptedAt: number;
+  final: boolean;
+  entries: TRuntimeAssignmentLogEntry[];
+}
+
+/**
+ * Sequence numbers of one capture whose batches the controller did not receive or no longer holds
+ * (its own loss): numbers that never arrived and that the node did not account for, and batches it
+ * accepted whose payload it has lost. A gap the node left by discarding is not one: the batch
+ * after it opens with the `not-kept` loss that counts it.
+ */
+export interface IRuntimeAssignmentLogGapRecord {
+  kind: 'gap';
+  captureId: string;
+  fromSequence: number;
+  toSequence: number;
+}
+
+/**
+ * Batches of one capture the controller accepted and has since dropped: every batch it held of the
+ * capture up to and including `throughSequence`, oldest first, so a truncation is always the start
+ * of what remains of a capture. Gaps inside that range are no longer stated. The counts are exact.
+ */
+export interface IRuntimeAssignmentLogTruncationRecord {
+  kind: 'truncated';
+  captureId: string;
+  throughSequence: number;
+  /** In the canonical order `batch-cap`, `byte-cap`, `retention`; duplicate-free, at least one. */
+  reasons: TRuntimeAssignmentLogTruncationReason[];
+  /** The accepted batches dropped, at least one and at most `throughSequence`. */
+  batches: number;
+  /** The UTF-8 bytes of `text` the dropped batches held. */
+  bytes: number;
+  /** The entries, lines and losses alike, the dropped batches held. */
+  entries: number;
+}
+
+export type TRuntimeAssignmentLogRecord =
+  | IRuntimeAssignmentLogBatchRecord | IRuntimeAssignmentLogGapRecord | IRuntimeAssignmentLogTruncationRecord;
+
+/**
+ * One attempt whose logs the controller keeps, as an operator reads it. The controller keeps an
+ * attempt's logs from the moment it issues the attempt, so an attempt that failed before writing a
+ * line is listed with nothing held, and an attempt its slot released stays readable until
+ * `expiresAt`.
+ */
+export interface IRuntimeAssignmentLogAttemptView {
+  serviceId: string;
+  replicaId: string;
+  nodeId: string;
+  assignmentId: string;
+  attemptId: string;
+  /** When the controller issued the attempt, in milliseconds since the Unix epoch. */
+  issuedAt: number;
+  /** When it last accepted a batch of the attempt; null until it accepted one. */
+  lastAcceptedAt: number | null;
+  /**
+   * When the controller drops the attempt's logs whole: the latest of `issuedAt`, `lastAcceptedAt`
+   * and the time the attempt's slot released it, plus the attempt's `logs.retentionMs`. Null while
+   * the slot still holds the attempt: no expiry is scheduled, however quiet the attempt is.
+   */
+  expiresAt: number | null;
+  /** The captures of the attempt the controller accepted a batch of. */
+  captures: number;
+  /** Those of them whose final batch it accepted. */
+  capturesEnded: number;
+  /** The UTF-8 bytes of `text` the controller holds of the attempt. */
+  keptBytes: number;
+  /** The accepted batches of the attempt it has since dropped, stated in truncation records. */
+  truncatedBatches: number;
+}
+
+/** One page of a service's attempts, newest issued first, ties in `assignmentId` order. */
+export interface IRuntimeAssignmentLogAttemptPage {
+  attempts: IRuntimeAssignmentLogAttemptView[];
+  /** Where the next page starts; null when this page is the last. Opaque to the reader. */
+  nextCursor: string | null;
+}
+
+/**
+ * One page of one attempt's kept logs, in delivery order: captures in the order the controller
+ * first accepted a batch of each, and within a capture by sequence. A capture's truncation record
+ * comes first, a gap record directly before the batch that follows it.
+ */
+export interface IRuntimeAssignmentLogPage {
+  attempt: IRuntimeAssignmentLogAttemptView;
+  records: TRuntimeAssignmentLogRecord[];
+  /** Where the next page starts; null when this page is the last. Opaque to the reader. */
+  nextCursor: string | null;
+}
+
+/**
+ * Why a controller refuses a log read: `attempt-not-found` (it keeps no logs of that attempt for
+ * that service, never did or no longer does), `cursor-invalid` (a cursor it did not hand out for
+ * this read) and `limit-invalid` (a `limit` outside its bound).
+ */
+export type TRuntimeAssignmentLogReadRefusal = 'attempt-not-found' | 'cursor-invalid' | 'limit-invalid';
+
+/** The named refusal of a log read, sent as `TypedResponseError.errorData`. */
+export interface IRuntimeAssignmentLogReadErrorData {
+  code: TRuntimeAssignmentLogReadRefusal;
+  retryable: false;
+}
+
+export const runtimeAssignmentLogReadContract = Object.freeze({
+  error: 'Runtime assignment log read contract rejected.',
+  /** The largest `limit` `getServiceRuntimeLogAttempts` accepts; a controller refuses a larger one. */
+  maximumAttemptPageSize: 256,
+  /** The largest `limit` `getRuntimeAssignmentLogs` accepts, counted in records. */
+  maximumPageRecords: 256,
+  /**
+   * The most entries the records of one log page hold together: four full batches. It keeps a page
+   * within the node count every captured value is held to; one batch always fits.
+   */
+  maximumPageEntries: 4 * runtimeAssignmentLogContract.maximumEntriesPerBatch,
+  /**
+   * The canonical JSON of a whole log page is at most two mebibytes, and the controller closes a
+   * page before the next record would cross it. One batch always fits: its record is smaller than
+   * the report that carried it, which `maximumReportCanonicalBytes` bounded.
+   */
+  maximumPageCanonicalBytes: 2 * runtimeAssignmentLogContract.maximumReportCanonicalBytes,
+} as const);
+
+const readFail = (): never => { throw new Error(runtimeAssignmentLogReadContract.error); };
+const readSafe = <T>(operationArg: () => T): T => { try { return operationArg(); } catch { return readFail(); } };
+/** The canonical order of `reasons`. */
+const truncationReasons = ['batch-cap', 'byte-cap', 'retention'] as const;
+const cursorOf = (valueArg: unknown): string | null => valueArg === null ? null : networkId(valueArg);
+
+const batchRecordOf = (valueArg: unknown): IRuntimeAssignmentLogBatchRecord => {
+  const value = networkRecord(valueArg, ['kind', 'captureId', 'sequence', 'acceptedAt', 'final', 'entries']);
+  const entries = networkList(value.entries, runtimeAssignmentLogContract.maximumEntriesPerBatch, entryOf);
+  requireNetwork(value.kind === 'batch' && typeof value.final === 'boolean' && (entries.length > 0 || value.final));
+  return {
+    kind: 'batch', captureId: networkId(value.captureId), sequence: networkCounter(value.sequence),
+    acceptedAt: networkCounter(value.acceptedAt), final: value.final, entries,
+  };
+};
+
+const gapRecordOf = (valueArg: unknown): IRuntimeAssignmentLogGapRecord => {
+  const value = networkRecord(valueArg, ['kind', 'captureId', 'fromSequence', 'toSequence']);
+  const fromSequence = networkCounter(value.fromSequence), toSequence = networkCounter(value.toSequence);
+  requireNetwork(value.kind === 'gap' && fromSequence <= toSequence);
+  return { kind: 'gap', captureId: networkId(value.captureId), fromSequence, toSequence };
+};
+
+const truncationRecordOf = (valueArg: unknown): IRuntimeAssignmentLogTruncationRecord => {
+  const value = networkRecord(
+    valueArg, ['kind', 'captureId', 'throughSequence', 'reasons', 'batches', 'bytes', 'entries'],
+  );
+  requireNetwork(value.kind === 'truncated');
+  const throughSequence = networkCounter(value.throughSequence);
+  const reasons = networkSorted(networkList(value.reasons, truncationReasons.length, (reasonArg) => {
+    requireNetwork(isOneOf(truncationReasons, reasonArg));
+    return reasonArg;
+  }), (reasonArg) => String(truncationReasons.indexOf(reasonArg)));
+  requireNetwork(reasons.length > 0);
+  return {
+    kind: 'truncated', captureId: networkId(value.captureId), throughSequence, reasons,
+    batches: networkCounter(value.batches, throughSequence), bytes: countOf(value.bytes), entries: countOf(value.entries),
+  };
+};
+
+const recordOf = (valueArg: unknown): TRuntimeAssignmentLogRecord => {
+  const kind = variantOf(valueArg, 'kind');
+  if (kind === 'batch') return batchRecordOf(valueArg);
+  if (kind === 'gap') return gapRecordOf(valueArg);
+  return truncationRecordOf(valueArg);
+};
+
+const opensWithNotKept = (recordArg: IRuntimeAssignmentLogBatchRecord): boolean => {
+  const first = recordArg.entries[0];
+  return first !== undefined && first.kind === 'lost' && first.reason === 'not-kept';
+};
+
+/**
+ * Delivery order within a page. Each capture's records are contiguous and never return once
+ * another capture's began. A truncation only opens its capture. Every other record continues where
+ * the one before it ended: a gap at the next number, never right after another gap, and a batch at
+ * the next number or, past numbers the node skipped, opening with the `not-kept` loss that counts
+ * them. Nothing follows a final batch.
+ */
+const requireDeliveryOrder = (recordsArg: TRuntimeAssignmentLogRecord[]): void => {
+  const begun = new Set<string>();
+  let previous: TRuntimeAssignmentLogRecord | null = null;
+  for (const record of recordsArg) {
+    const continues: boolean = previous !== null && previous.captureId === record.captureId;
+    if (!continues) {
+      requireNetwork(!begun.has(record.captureId));
+      begun.add(record.captureId);
+    }
+    if (previous === null || !continues) {
+      previous = record;
+      continue;
+    }
+    requireNetwork(record.kind !== 'truncated' && !(previous.kind === 'batch' && previous.final));
+    const next = (previous.kind === 'batch' ? previous.sequence
+      : previous.kind === 'gap' ? previous.toSequence : previous.throughSequence) + 1;
+    if (record.kind === 'gap') {
+      requireNetwork(previous.kind !== 'gap' && record.fromSequence === next);
+    } else {
+      requireNetwork(record.sequence === next || (record.sequence > next && opensWithNotKept(record)));
+    }
+    previous = record;
+  }
+};
+
+const attemptOf = (valueArg: unknown): IRuntimeAssignmentLogAttemptView => {
+  const value = networkRecord(valueArg, [
+    'serviceId', 'replicaId', 'nodeId', 'assignmentId', 'attemptId', 'issuedAt', 'lastAcceptedAt', 'expiresAt',
+    'captures', 'capturesEnded', 'keptBytes', 'truncatedBatches',
+  ]);
+  requireNetwork(isRuntimeReplicaId(value.replicaId));
+  const issuedAt = networkCounter(value.issuedAt);
+  const lastAcceptedAt = value.lastAcceptedAt === null ? null : networkCounter(value.lastAcceptedAt);
+  const expiresAt = value.expiresAt === null ? null : networkCounter(value.expiresAt);
+  const captures = countOf(value.captures), capturesEnded = countOf(value.capturesEnded);
+  const keptBytes = countOf(value.keptBytes), truncatedBatches = countOf(value.truncatedBatches);
+  requireNetwork((expiresAt === null || expiresAt > Math.max(issuedAt, lastAcceptedAt ?? issuedAt))
+    && capturesEnded <= captures);
+  // Nothing accepted means nothing captured, held or dropped.
+  requireNetwork(lastAcceptedAt !== null || (captures === 0 && keptBytes === 0 && truncatedBatches === 0));
+  return {
+    serviceId: networkId(value.serviceId), replicaId: value.replicaId, nodeId: networkNodeId(value.nodeId),
+    assignmentId: networkId(value.assignmentId), attemptId: networkId(value.attemptId), issuedAt, lastAcceptedAt,
+    expiresAt, captures, capturesEnded, keptBytes, truncatedBatches,
+  };
+};
+
+const pageLimitOf = (limitArg: unknown, maximumArg: number): number => networkCounter(limitArg, maximumArg);
+
+/** Detached exact-schema snapshot of one attempt view. */
+export const snapshotRuntimeAssignmentLogAttemptView = (valueArg: unknown): IRuntimeAssignmentLogAttemptView =>
+  readSafe(() => attemptOf(captureNetwork(valueArg)));
+
+/** Detached exact-schema snapshot of one attempt page, in its one order. */
+export const snapshotRuntimeAssignmentLogAttemptPage = (valueArg: unknown): IRuntimeAssignmentLogAttemptPage =>
+  readSafe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['attempts', 'nextCursor']);
+    const attempts = networkList(value.attempts, runtimeAssignmentLogReadContract.maximumAttemptPageSize, attemptOf);
+    attempts.forEach((attemptArg, indexArg) => {
+      const before = attempts[indexArg - 1];
+      requireNetwork(before === undefined || before.issuedAt > attemptArg.issuedAt
+        || (before.issuedAt === attemptArg.issuedAt && before.assignmentId < attemptArg.assignmentId));
+    });
+    const nextCursor = cursorOf(value.nextCursor);
+    requireNetwork(nextCursor === null || attempts.length > 0);
+    return { attempts, nextCursor };
+  });
+
+/** Detached exact-schema snapshot of one log page, bounded and in delivery order. */
+export const snapshotRuntimeAssignmentLogPage = (valueArg: unknown): IRuntimeAssignmentLogPage => readSafe(() => {
+  const value = networkRecord(
+    captureNetwork(valueArg, runtimeAssignmentLogReadContract.maximumPageCanonicalBytes),
+    ['attempt', 'records', 'nextCursor'],
+  );
+  const records = networkList(value.records, runtimeAssignmentLogReadContract.maximumPageRecords, recordOf);
+  requireNetwork(records.reduce((totalArg, recordArg) => totalArg + (recordArg.kind === 'batch' ? recordArg.entries.length : 0), 0)
+    <= runtimeAssignmentLogReadContract.maximumPageEntries);
+  requireDeliveryOrder(records);
+  const nextCursor = cursorOf(value.nextCursor);
+  requireNetwork(nextCursor === null || records.length > 0);
+  return { attempt: attemptOf(value.attempt), records, nextCursor };
+});
+
+/** Matches an attempt page to the read that asked for it: that service's attempts, within its limit. */
+export const bindRuntimeAssignmentLogAttemptPage = (
+  valueArg: unknown, serviceIdArg: string, limitArg: number,
+): IRuntimeAssignmentLogAttemptPage => readSafe(() => {
+  const page = snapshotRuntimeAssignmentLogAttemptPage(valueArg);
+  const limit = pageLimitOf(limitArg, runtimeAssignmentLogReadContract.maximumAttemptPageSize);
+  requireNetwork(page.attempts.length <= limit && page.attempts.every((attemptArg) => attemptArg.serviceId === serviceIdArg));
+  return page;
+});
+
+/** Matches a log page to the read that asked for it: that attempt of that service, within its limit. */
+export const bindRuntimeAssignmentLogPage = (
+  valueArg: unknown, serviceIdArg: string, assignmentIdArg: string, limitArg: number,
+): IRuntimeAssignmentLogPage => readSafe(() => {
+  const page = snapshotRuntimeAssignmentLogPage(valueArg);
+  const limit = pageLimitOf(limitArg, runtimeAssignmentLogReadContract.maximumPageRecords);
+  requireNetwork(page.records.length <= limit && page.attempt.serviceId === serviceIdArg
+    && page.attempt.assignmentId === assignmentIdArg);
+  return page;
+});

package/ts/private/networkcontract.ts

@@ -46,14 +46,23 @@ export const networkSafe = <T>(operation: () => T): T => {
   }
 };
 
-/** Bound decoded transport input before canonicalization; never execute getters/toJSON. */
-export const captureNetwork = (value: unknown): unknown => networkSafe(() => {
+/** The canonical JSON bound every runtime network contract captures with, unless it states its own. */
+export const networkMaximumCanonicalBytes = 1_048_576;
+
+/**
+ * Bound decoded transport input before canonicalization; never execute getters/toJSON.
+ * `maximumBytes` bounds the whole value's canonical JSON; a single string stays within
+ * `networkMaximumCanonicalBytes` whatever the whole may hold.
+ */
+export const captureNetwork = (
+  value: unknown, maximumBytes = networkMaximumCanonicalBytes,
+): unknown => networkSafe(() => {
   const encoder = new TextEncoder(), ancestors = new Set<object>();
   let nodes = 0, bytes = 0;
   const account = (text: string) => {
-    requireNetwork(text.length <= 1_048_576);
+    requireNetwork(text.length <= networkMaximumCanonicalBytes);
     bytes += encoder.encode(text).length;
-    requireNetwork(bytes <= 1_048_576);
+    requireNetwork(bytes <= maximumBytes);
   };
   const copy = (item: unknown, depth: number): unknown => {
     requireNetwork(++nodes <= 65_536 && depth <= 24);
@@ -90,7 +99,7 @@ export const captureNetwork = (value: unknown): unknown => networkSafe(() => {
     } finally { ancestors.delete(item); }
   };
   const result = copy(value, 0);
-  requireNetwork(encoder.encode(networkCanonical(result)).length <= 1_048_576);
+  requireNetwork(encoder.encode(networkCanonical(result)).length <= maximumBytes);
   return result;
 });
 

package/ts/requests/service.ts

@@ -19,6 +19,10 @@ import type {
 import type { TSha256Digest } from '../data/immutableimage.js';
 import type { ILegacyServiceRuntimeAttestation } from '../data/deploymentlegacyimport.js';
 import type { IProtocolOffer } from '../protocol.js';
+import type {
+  IRuntimeAssignmentLogAttemptPage,
+  IRuntimeAssignmentLogPage,
+} from '../data/runtimeassignmentlogs.js';
 import type {
   IServiceRuntimeAssignmentView,
   IServiceRuntimeSpec,
@@ -629,6 +633,52 @@ extends plugins.typedrequestInterfaces.implementsTR<
   };
 }
 
+/**
+ * The attempts of one service whose workload logs Cloudly keeps, newest issued first, a page at a
+ * time: a slot's replaced and released attempts stay readable until their logs expire, which no
+ * single response bounds. `limit` runs from 1 to
+ * `runtimeAssignmentLogReadContract.maximumAttemptPageSize`; Cloudly refuses any other with
+ * `IRuntimeAssignmentLogReadErrorData`. `cursor` is null for the first page, then the page's own
+ * `nextCursor`. `bindRuntimeAssignmentLogAttemptPage` checks an answer against its read.
+ */
+export interface IRequest_Any_Cloudly_GetServiceRuntimeLogAttempts
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Any_Cloudly_GetServiceRuntimeLogAttempts
+> {
+  method: 'getServiceRuntimeLogAttempts';
+  request: {
+    identity: IIdentity;
+    serviceId: string;
+    cursor: string | null;
+    limit: number;
+  };
+  response: IRuntimeAssignmentLogAttemptPage;
+}
+
+/**
+ * One attempt's kept workload logs, a page at a time in delivery order, with the gaps Cloudly found
+ * and the truncations it made stated in place. `limit` counts records and runs from 1 to
+ * `runtimeAssignmentLogReadContract.maximumPageRecords`; a page also ends before it would cross
+ * `maximumPageEntries` or `maximumPageCanonicalBytes`, so it may hold fewer records than `limit`
+ * while `nextCursor` still names more. `bindRuntimeAssignmentLogPage` checks an answer against its read.
+ */
+export interface IRequest_Any_Cloudly_GetRuntimeAssignmentLogs
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Any_Cloudly_GetRuntimeAssignmentLogs
+> {
+  method: 'getRuntimeAssignmentLogs';
+  request: {
+    identity: IIdentity;
+    serviceId: string;
+    assignmentId: string;
+    cursor: string | null;
+    limit: number;
+  };
+  response: IRuntimeAssignmentLogPage;
+}
+
 /**
  * Cloudly -> admin UIs: a service's runtime spec, status or assignments changed. It carries no
  * state, so a late or repeated push can never overwrite a newer read; the UI reads the views again.