@shipfox/api-logs-dto 10.2.0 → 16.0.0

package/.turbo/turbo-build.log

@@ -1,2 +1,2 @@
 $ shipfox-swc
-Successfully compiled: 7 files with swc (189.29ms)
+Successfully compiled: 8 files with swc (265.13ms)

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @shipfox/api-logs-dto
 
+## 16.0.0
+
+### Minor Changes
+
+- 64155fb: Adds the server-origin log append contract and enforces bounded, validated writes.
+
+## 12.0.0
+
+### Patch Changes
+
+- f78740d: Remove Unicode dash punctuation from package prose and source comments.
+
 ## 10.2.0
 
 ### Minor Changes

package/dist/events.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const LOG_STREAM_CLOSED: "logs.stream.closed";
+export declare const LOG_STREAM_CLOSED: 'logs.stream.closed';
 export declare const logStreamClosedEventSchema: z.ZodObject<{
     workspaceId: z.ZodString;
     jobId: z.ZodString;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { LOG_STREAM_CLOSED, type LogStreamClosedEvent, type LogsEventMap, logStreamClosedEventSchema, logsEventSchemas, } from './events.js';
-export { type AppendLogsQueryDto, type AppendLogsResponseDto, appendLogsQuerySchema, appendLogsResponseSchema, type LogRecord, logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, type OffsetGapResponseDto, offsetGapResponseSchema, parseLogRecordLine, parseRawLogRecordLine, type RawLogRecord, type ReadLogsQueryDto, type ReadLogsResponseDto, rawLogRecordSchema, readLogsQuerySchema, readLogsResponseSchema, SESSION_VIEW_VERSION, type SessionViewDto, type SessionViewLifecycleRow, type SessionViewMessageRow, type SessionViewRawRow, type SessionViewRow, type SessionViewRowMeta, type SessionViewThinkingRow, type SessionViewToolCallRow, type SessionViewToolResultRow, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema, } from './schemas/index.js';
+export { type AppendLogsQueryDto, type AppendLogsResponseDto, appendLogsQuerySchema, appendLogsResponseSchema, type LogRecord, type LogWriterConflictResponseDto, logRecordSchema, logWriterConflictResponseSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, type OffsetGapResponseDto, offsetGapResponseSchema, parseLogRecordLine, parseRawLogRecordLine, type RawLogRecord, type ReadLogsQueryDto, type ReadLogsResponseDto, rawLogRecordSchema, readLogsQuerySchema, readLogsResponseSchema, SESSION_VIEW_VERSION, type ServerLogRecord, type SessionViewDto, type SessionViewLifecycleRow, type SessionViewMessageRow, type SessionViewRawRow, type SessionViewRow, type SessionViewRowMeta, type SessionViewThinkingRow, type SessionViewToolCallRow, type SessionViewToolResultRow, serverLogRecordSchema, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema, } from './schemas/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,0BAA0B,EAC1B,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,SAAS,EACd,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,6BAA6B,EAC7B,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,4BAA4B,EAC5B,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,0BAA0B,EAC1B,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,SAAS,EACd,KAAK,4BAA4B,EACjC,eAAe,EACf,+BAA+B,EAC/B,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,qBAAqB,EACrB,6BAA6B,EAC7B,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,4BAA4B,EAC5B,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -1,4 +1,4 @@
 export { LOG_STREAM_CLOSED, logStreamClosedEventSchema, logsEventSchemas } from './events.js';
-export { appendLogsQuerySchema, appendLogsResponseSchema, logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, offsetGapResponseSchema, parseLogRecordLine, parseRawLogRecordLine, rawLogRecordSchema, readLogsQuerySchema, readLogsResponseSchema, SESSION_VIEW_VERSION, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema } from './schemas/index.js';
+export { appendLogsQuerySchema, appendLogsResponseSchema, logRecordSchema, logWriterConflictResponseSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, offsetGapResponseSchema, parseLogRecordLine, parseRawLogRecordLine, rawLogRecordSchema, readLogsQuerySchema, readLogsResponseSchema, SESSION_VIEW_VERSION, serverLogRecordSchema, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema } from './schemas/index.js';
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  LOG_STREAM_CLOSED,\n  type LogStreamClosedEvent,\n  type LogsEventMap,\n  logStreamClosedEventSchema,\n  logsEventSchemas,\n} from './events.js';\nexport {\n  type AppendLogsQueryDto,\n  type AppendLogsResponseDto,\n  appendLogsQuerySchema,\n  appendLogsResponseSchema,\n  type LogRecord,\n  logRecordSchema,\n  MAX_RECORD_DATA_BYTES,\n  MAX_RECORD_NAME_BYTES,\n  type OffsetGapResponseDto,\n  offsetGapResponseSchema,\n  parseLogRecordLine,\n  parseRawLogRecordLine,\n  type RawLogRecord,\n  type ReadLogsQueryDto,\n  type ReadLogsResponseDto,\n  rawLogRecordSchema,\n  readLogsQuerySchema,\n  readLogsResponseSchema,\n  SESSION_VIEW_VERSION,\n  type SessionViewDto,\n  type SessionViewLifecycleRow,\n  type SessionViewMessageRow,\n  type SessionViewRawRow,\n  type SessionViewRow,\n  type SessionViewRowMeta,\n  type SessionViewThinkingRow,\n  type SessionViewToolCallRow,\n  type SessionViewToolResultRow,\n  sessionViewLifecycleRowSchema,\n  sessionViewMessageRowSchema,\n  sessionViewRawRowSchema,\n  sessionViewRowMetaSchema,\n  sessionViewRowSchema,\n  sessionViewSchema,\n  sessionViewThinkingRowSchema,\n  sessionViewToolCallRowSchema,\n  sessionViewToolResultRowSchema,\n} from './schemas/index.js';\n"],"names":["LOG_STREAM_CLOSED","logStreamClosedEventSchema","logsEventSchemas","appendLogsQuerySchema","appendLogsResponseSchema","logRecordSchema","MAX_RECORD_DATA_BYTES","MAX_RECORD_NAME_BYTES","offsetGapResponseSchema","parseLogRecordLine","parseRawLogRecordLine","rawLogRecordSchema","readLogsQuerySchema","readLogsResponseSchema","SESSION_VIEW_VERSION","sessionViewLifecycleRowSchema","sessionViewMessageRowSchema","sessionViewRawRowSchema","sessionViewRowMetaSchema","sessionViewRowSchema","sessionViewSchema","sessionViewThinkingRowSchema","sessionViewToolCallRowSchema","sessionViewToolResultRowSchema"],"mappings":"AAAA,SACEA,iBAAiB,EAGjBC,0BAA0B,EAC1BC,gBAAgB,QACX,cAAc;AACrB,SAGEC,qBAAqB,EACrBC,wBAAwB,EAExBC,eAAe,EACfC,qBAAqB,EACrBC,qBAAqB,EAErBC,uBAAuB,EACvBC,kBAAkB,EAClBC,qBAAqB,EAIrBC,kBAAkB,EAClBC,mBAAmB,EACnBC,sBAAsB,EACtBC,oBAAoB,EAUpBC,6BAA6B,EAC7BC,2BAA2B,EAC3BC,uBAAuB,EACvBC,wBAAwB,EACxBC,oBAAoB,EACpBC,iBAAiB,EACjBC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,8BAA8B,QACzB,qBAAqB"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  LOG_STREAM_CLOSED,\n  type LogStreamClosedEvent,\n  type LogsEventMap,\n  logStreamClosedEventSchema,\n  logsEventSchemas,\n} from './events.js';\nexport {\n  type AppendLogsQueryDto,\n  type AppendLogsResponseDto,\n  appendLogsQuerySchema,\n  appendLogsResponseSchema,\n  type LogRecord,\n  type LogWriterConflictResponseDto,\n  logRecordSchema,\n  logWriterConflictResponseSchema,\n  MAX_RECORD_DATA_BYTES,\n  MAX_RECORD_NAME_BYTES,\n  type OffsetGapResponseDto,\n  offsetGapResponseSchema,\n  parseLogRecordLine,\n  parseRawLogRecordLine,\n  type RawLogRecord,\n  type ReadLogsQueryDto,\n  type ReadLogsResponseDto,\n  rawLogRecordSchema,\n  readLogsQuerySchema,\n  readLogsResponseSchema,\n  SESSION_VIEW_VERSION,\n  type ServerLogRecord,\n  type SessionViewDto,\n  type SessionViewLifecycleRow,\n  type SessionViewMessageRow,\n  type SessionViewRawRow,\n  type SessionViewRow,\n  type SessionViewRowMeta,\n  type SessionViewThinkingRow,\n  type SessionViewToolCallRow,\n  type SessionViewToolResultRow,\n  serverLogRecordSchema,\n  sessionViewLifecycleRowSchema,\n  sessionViewMessageRowSchema,\n  sessionViewRawRowSchema,\n  sessionViewRowMetaSchema,\n  sessionViewRowSchema,\n  sessionViewSchema,\n  sessionViewThinkingRowSchema,\n  sessionViewToolCallRowSchema,\n  sessionViewToolResultRowSchema,\n} from './schemas/index.js';\n"],"names":["LOG_STREAM_CLOSED","logStreamClosedEventSchema","logsEventSchemas","appendLogsQuerySchema","appendLogsResponseSchema","logRecordSchema","logWriterConflictResponseSchema","MAX_RECORD_DATA_BYTES","MAX_RECORD_NAME_BYTES","offsetGapResponseSchema","parseLogRecordLine","parseRawLogRecordLine","rawLogRecordSchema","readLogsQuerySchema","readLogsResponseSchema","SESSION_VIEW_VERSION","serverLogRecordSchema","sessionViewLifecycleRowSchema","sessionViewMessageRowSchema","sessionViewRawRowSchema","sessionViewRowMetaSchema","sessionViewRowSchema","sessionViewSchema","sessionViewThinkingRowSchema","sessionViewToolCallRowSchema","sessionViewToolResultRowSchema"],"mappings":"AAAA,SACEA,iBAAiB,EAGjBC,0BAA0B,EAC1BC,gBAAgB,QACX,cAAc;AACrB,SAGEC,qBAAqB,EACrBC,wBAAwB,EAGxBC,eAAe,EACfC,+BAA+B,EAC/BC,qBAAqB,EACrBC,qBAAqB,EAErBC,uBAAuB,EACvBC,kBAAkB,EAClBC,qBAAqB,EAIrBC,kBAAkB,EAClBC,mBAAmB,EACnBC,sBAAsB,EACtBC,oBAAoB,EAWpBC,qBAAqB,EACrBC,6BAA6B,EAC7BC,2BAA2B,EAC3BC,uBAAuB,EACvBC,wBAAwB,EACxBC,oBAAoB,EACpBC,iBAAiB,EACjBC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,8BAA8B,QACzB,qBAAqB"}

package/dist/inter-module.d.ts

@@ -0,0 +1,132 @@
+import { type InterModuleClient } from '@shipfox/inter-module';
+import { z } from 'zod';
+/**
+ * Producer-owned Logs commands used by synchronous callers. The only method
+ * today is the server-origin append for server-executed steps (the tool step
+ * executor): it writes already-normalized stored records through the same
+ * offset-CAS and budget pipeline as the lease-bound runner route, but with
+ * chunk `origin` `server` and a tail-derived CAS offset (the caller owns no
+ * spool cursor). This is a trusted internal boundary, not an authorization
+ * boundary: the caller must derive the identity fields from its execution
+ * context rather than pass through arbitrary external input.
+ */
+export declare const logsInterModuleContract: import("@shipfox/inter-module").InterModuleContract<{
+    readonly module: "logs";
+    readonly methods: {
+        appendServerRecords: {
+            input: z.ZodObject<{
+                jobId: z.ZodString;
+                workspaceId: z.ZodString;
+                projectId: z.ZodString;
+                workflowRunAttemptId: z.ZodString;
+                stepId: z.ZodString;
+                attempt: z.ZodNumber;
+                records: z.ZodArray<z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
+                    v: z.ZodLiteral<1>;
+                    ts: z.ZodNumber;
+                    type: z.ZodLiteral<"output">;
+                    stream: z.ZodEnum<{
+                        stderr: "stderr";
+                        stdout: "stdout";
+                    }>;
+                    data: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    v: z.ZodLiteral<1>;
+                    ts: z.ZodNumber;
+                    type: z.ZodLiteral<"group_start">;
+                    group_id: z.ZodString;
+                    parent_group_id: z.ZodNullable<z.ZodString>;
+                    name: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    v: z.ZodLiteral<1>;
+                    ts: z.ZodNumber;
+                    type: z.ZodLiteral<"group_end">;
+                    group_id: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    v: z.ZodLiteral<1>;
+                    ts: z.ZodNumber;
+                    type: z.ZodLiteral<"end">;
+                    total_bytes: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    v: z.ZodLiteral<1>;
+                    ts: z.ZodNumber;
+                    type: z.ZodLiteral<"gap">;
+                    dropped_bytes: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    v: z.ZodLiteral<1>;
+                    ts: z.ZodNumber;
+                    type: z.ZodLiteral<"agent_session">;
+                    row: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        timestamp: z.ZodNumber;
+                        kind: z.ZodLiteral<"message">;
+                        role: z.ZodString;
+                        label: z.ZodString;
+                        meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                            label: z.ZodString;
+                            value: z.ZodString;
+                            inline: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>>>;
+                        text: z.ZodString;
+                        terminalFailure: z.ZodBoolean;
+                    }, z.core.$strip>, z.ZodObject<{
+                        timestamp: z.ZodNumber;
+                        kind: z.ZodLiteral<"thinking">;
+                        text: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        timestamp: z.ZodNumber;
+                        kind: z.ZodLiteral<"tool-call">;
+                        id: z.ZodNullable<z.ZodString>;
+                        name: z.ZodString;
+                        input: z.ZodString;
+                        summary: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        timestamp: z.ZodNumber;
+                        kind: z.ZodLiteral<"tool-result">;
+                        toolCallId: z.ZodNullable<z.ZodString>;
+                        toolName: z.ZodString;
+                        output: z.ZodString;
+                        isError: z.ZodBoolean;
+                    }, z.core.$strip>, z.ZodObject<{
+                        timestamp: z.ZodNumber;
+                        kind: z.ZodLiteral<"lifecycle">;
+                        label: z.ZodString;
+                        detail: z.ZodNullable<z.ZodString>;
+                        meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                            label: z.ZodString;
+                            value: z.ZodString;
+                            inline: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>>>;
+                        tone: z.ZodEnum<{
+                            default: "default";
+                            error: "error";
+                            warning: "warning";
+                        }>;
+                        terminalFailure: z.ZodBoolean;
+                    }, z.core.$strip>, z.ZodObject<{
+                        timestamp: z.ZodNumber;
+                        kind: z.ZodLiteral<"raw">;
+                        label: z.ZodString;
+                        raw: z.ZodString;
+                    }, z.core.$strip>], "kind">;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>;
+            output: z.ZodObject<{
+                committedLength: z.ZodNumber;
+                capped: z.ZodBoolean;
+            }, z.core.$strip>;
+            errors: {
+                'lease-stream-mismatch': z.ZodObject<{}, z.core.$strip>;
+                'malformed-log-chunk': z.ZodObject<{}, z.core.$strip>;
+                'append-body-too-large': z.ZodObject<{
+                    maxBytes: z.ZodNumber;
+                }, z.core.$strip>;
+                'runner-writer-active': z.ZodObject<{}, z.core.$strip>;
+                'offset-gap': z.ZodObject<{
+                    committedLength: z.ZodNumber;
+                }, z.core.$strip>;
+            };
+        };
+    };
+}>;
+export type LogsModuleClient = InterModuleClient<typeof logsInterModuleContract>;
+//# sourceMappingURL=inter-module.d.ts.map

package/dist/inter-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inter-module.d.ts","sourceRoot":"","sources":["../src/inter-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxF,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAKtB;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB;;;QAGhC,mBAAmB;YACjB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuBL,MAAM;;;;YAcN,MAAM;gBACJ,uBAAuB;gBACvB,qBAAqB;gBACrB,uBAAuB;;;gBACvB,sBAAsB;gBACtB,YAAY;;;;;;EAIlB,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/inter-module.js

@@ -0,0 +1,54 @@
+import { defineInterModuleContract } from '@shipfox/inter-module';
+import { z } from 'zod';
+import { serverLogRecordSchema } from './schemas/index.js';
+const idSchema = z.string().uuid();
+/**
+ * Producer-owned Logs commands used by synchronous callers. The only method
+ * today is the server-origin append for server-executed steps (the tool step
+ * executor): it writes already-normalized stored records through the same
+ * offset-CAS and budget pipeline as the lease-bound runner route, but with
+ * chunk `origin` `server` and a tail-derived CAS offset (the caller owns no
+ * spool cursor). This is a trusted internal boundary, not an authorization
+ * boundary: the caller must derive the identity fields from its execution
+ * context rather than pass through arbitrary external input.
+ */ export const logsInterModuleContract = defineInterModuleContract({
+    module: 'logs',
+    methods: {
+        appendServerRecords: {
+            input: z.object({
+                jobId: idSchema,
+                workspaceId: idSchema,
+                projectId: idSchema,
+                workflowRunAttemptId: idSchema,
+                stepId: idSchema,
+                attempt: z.number().int().min(1).max(2_147_483_647).describe('Attempt number of the step this batch belongs to.'),
+                /**
+         * Already-normalized server-writable stored records (the read union
+         * without server-only tombstones), serialized to whole newline-terminated
+         * NDJSON lines on ingest. Server-origin records skip the raw-to-stored
+         * normalization the runner path applies: they are stored verbatim. Callers should
+         * coalesce records into batches up to (but never over) `LOG_APPEND_BODY_LIMIT_BYTES`;
+         * an empty batch is reserved for a heartbeat. A server-origin writer owns its stream;
+         * it cannot be mixed with a lease-bound runner writer because their byte cursors differ.
+         */ records: z.array(serverLogRecordSchema)
+            }),
+            output: z.object({
+                committedLength: z.number().int().min(0).describe('New server-held byte position of the stream after this batch was applied (the tail the next call continues from).'),
+                capped: z.boolean().describe('When true, the per-job log budget is exhausted and further output is dropped.')
+            }),
+            errors: {
+                'lease-stream-mismatch': z.object({}),
+                'malformed-log-chunk': z.object({}),
+                'append-body-too-large': z.object({
+                    maxBytes: z.number().int().positive()
+                }),
+                'runner-writer-active': z.object({}),
+                'offset-gap': z.object({
+                    committedLength: z.number().int().nonnegative()
+                })
+            }
+        }
+    }
+});
+
+//# sourceMappingURL=inter-module.js.map

package/dist/inter-module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/inter-module.ts"],"sourcesContent":["import {defineInterModuleContract, type InterModuleClient} from '@shipfox/inter-module';\nimport {z} from 'zod';\nimport {serverLogRecordSchema} from './schemas/index.js';\n\nconst idSchema = z.string().uuid();\n\n/**\n * Producer-owned Logs commands used by synchronous callers. The only method\n * today is the server-origin append for server-executed steps (the tool step\n * executor): it writes already-normalized stored records through the same\n * offset-CAS and budget pipeline as the lease-bound runner route, but with\n * chunk `origin` `server` and a tail-derived CAS offset (the caller owns no\n * spool cursor). This is a trusted internal boundary, not an authorization\n * boundary: the caller must derive the identity fields from its execution\n * context rather than pass through arbitrary external input.\n */\nexport const logsInterModuleContract = defineInterModuleContract({\n  module: 'logs',\n  methods: {\n    appendServerRecords: {\n      input: z.object({\n        jobId: idSchema,\n        workspaceId: idSchema,\n        projectId: idSchema,\n        workflowRunAttemptId: idSchema,\n        stepId: idSchema,\n        attempt: z\n          .number()\n          .int()\n          .min(1)\n          .max(2_147_483_647)\n          .describe('Attempt number of the step this batch belongs to.'),\n        /**\n         * Already-normalized server-writable stored records (the read union\n         * without server-only tombstones), serialized to whole newline-terminated\n         * NDJSON lines on ingest. Server-origin records skip the raw-to-stored\n         * normalization the runner path applies: they are stored verbatim. Callers should\n         * coalesce records into batches up to (but never over) `LOG_APPEND_BODY_LIMIT_BYTES`;\n         * an empty batch is reserved for a heartbeat. A server-origin writer owns its stream;\n         * it cannot be mixed with a lease-bound runner writer because their byte cursors differ.\n         */\n        records: z.array(serverLogRecordSchema),\n      }),\n      output: z.object({\n        committedLength: z\n          .number()\n          .int()\n          .min(0)\n          .describe(\n            'New server-held byte position of the stream after this batch was applied (the tail the next call continues from).',\n          ),\n        capped: z\n          .boolean()\n          .describe(\n            'When true, the per-job log budget is exhausted and further output is dropped.',\n          ),\n      }),\n      errors: {\n        'lease-stream-mismatch': z.object({}),\n        'malformed-log-chunk': z.object({}),\n        'append-body-too-large': z.object({maxBytes: z.number().int().positive()}),\n        'runner-writer-active': z.object({}),\n        'offset-gap': z.object({committedLength: z.number().int().nonnegative()}),\n      },\n    },\n  },\n});\n\nexport type LogsModuleClient = InterModuleClient<typeof logsInterModuleContract>;\n"],"names":["defineInterModuleContract","z","serverLogRecordSchema","idSchema","string","uuid","logsInterModuleContract","module","methods","appendServerRecords","input","object","jobId","workspaceId","projectId","workflowRunAttemptId","stepId","attempt","number","int","min","max","describe","records","array","output","committedLength","capped","boolean","errors","maxBytes","positive","nonnegative"],"mappings":"AAAA,SAAQA,yBAAyB,QAA+B,wBAAwB;AACxF,SAAQC,CAAC,QAAO,MAAM;AACtB,SAAQC,qBAAqB,QAAO,qBAAqB;AAEzD,MAAMC,WAAWF,EAAEG,MAAM,GAAGC,IAAI;AAEhC;;;;;;;;;CASC,GACD,OAAO,MAAMC,0BAA0BN,0BAA0B;IAC/DO,QAAQ;IACRC,SAAS;QACPC,qBAAqB;YACnBC,OAAOT,EAAEU,MAAM,CAAC;gBACdC,OAAOT;gBACPU,aAAaV;gBACbW,WAAWX;gBACXY,sBAAsBZ;gBACtBa,QAAQb;gBACRc,SAAShB,EACNiB,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJC,GAAG,CAAC,eACJC,QAAQ,CAAC;gBACZ;;;;;;;;SAQC,GACDC,SAAStB,EAAEuB,KAAK,CAACtB;YACnB;YACAuB,QAAQxB,EAAEU,MAAM,CAAC;gBACfe,iBAAiBzB,EACdiB,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CACP;gBAEJK,QAAQ1B,EACL2B,OAAO,GACPN,QAAQ,CACP;YAEN;YACAO,QAAQ;gBACN,yBAAyB5B,EAAEU,MAAM,CAAC,CAAC;gBACnC,uBAAuBV,EAAEU,MAAM,CAAC,CAAC;gBACjC,yBAAyBV,EAAEU,MAAM,CAAC;oBAACmB,UAAU7B,EAAEiB,MAAM,GAAGC,GAAG,GAAGY,QAAQ;gBAAE;gBACxE,wBAAwB9B,EAAEU,MAAM,CAAC,CAAC;gBAClC,cAAcV,EAAEU,MAAM,CAAC;oBAACe,iBAAiBzB,EAAEiB,MAAM,GAAGC,GAAG,GAAGa,WAAW;gBAAE;YACzE;QACF;IACF;AACF,GAAG"}

package/dist/schemas/append.d.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
  * Append endpoint contract: `POST .../steps/:stepId/logs?attempt=N&offset=B`.
  *
  * The body is raw NDJSON bytes (whole records, newline-terminated), not a
- * Zod-validated object — it is parsed line by line against the raw log record
+ * Zod-validated object: it is parsed line by line against the raw log record
  * union (`rawLogRecordSchema`). `offset` is a position in the raw
  * NDJSON spool stream; both `offset` and the returned `committed_length` are
  * bounded far below 2^53 by the accrual budget, so JavaScript `number` is safe.
@@ -26,4 +26,9 @@ export declare const offsetGapResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type OffsetGapResponseDto = z.infer<typeof offsetGapResponseSchema>;
+/** A lease append was attempted on a stream owned by a server-origin writer. */
+export declare const logWriterConflictResponseSchema: z.ZodObject<{
+    code: z.ZodLiteral<"log-writer-conflict">;
+}, z.core.$strip>;
+export type LogWriterConflictResponseDto = z.infer<typeof logWriterConflictResponseSchema>;
 //# sourceMappingURL=append.d.ts.map

package/dist/schemas/append.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"append.d.ts","sourceRoot":"","sources":["../../src/schemas/append.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;iBAchC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,eAAO,MAAM,wBAAwB;;;iBASnC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE7E,yFAAyF;AACzF,eAAO,MAAM,uBAAuB;;;;;iBASlC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"append.d.ts","sourceRoot":"","sources":["../../src/schemas/append.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;iBAchC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,eAAO,MAAM,wBAAwB;;;iBASnC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE7E,yFAAyF;AACzF,eAAO,MAAM,uBAAuB;;;;;iBASlC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,gFAAgF;AAChF,eAAO,MAAM,+BAA+B;;iBAE1C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/schemas/append.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
  * Append endpoint contract: `POST .../steps/:stepId/logs?attempt=N&offset=B`.
  *
  * The body is raw NDJSON bytes (whole records, newline-terminated), not a
- * Zod-validated object — it is parsed line by line against the raw log record
+ * Zod-validated object: it is parsed line by line against the raw log record
  * union (`rawLogRecordSchema`). `offset` is a position in the raw
  * NDJSON spool stream; both `offset` and the returned `committed_length` are
  * bounded far below 2^53 by the accrual budget, so JavaScript `number` is safe.
@@ -21,5 +21,8 @@ export const appendLogsResponseSchema = z.object({
         committed_length: z.number().int().min(0).describe('Current server-held committed length the runner should rewind to.')
     })
 });
+/** A lease append was attempted on a stream owned by a server-origin writer. */ export const logWriterConflictResponseSchema = z.object({
+    code: z.literal('log-writer-conflict')
+});
 
 //# sourceMappingURL=append.js.map

package/dist/schemas/append.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/schemas/append.ts"],"sourcesContent":["import {z} from 'zod';\n\n/**\n * Append endpoint contract: `POST .../steps/:stepId/logs?attempt=N&offset=B`.\n *\n * The body is raw NDJSON bytes (whole records, newline-terminated), not a\n * Zod-validated object — it is parsed line by line against the raw log record\n * union (`rawLogRecordSchema`). `offset` is a position in the raw\n * NDJSON spool stream; both `offset` and the returned `committed_length` are\n * bounded far below 2^53 by the accrual budget, so JavaScript `number` is safe.\n */\nexport const appendLogsQuerySchema = z.object({\n  attempt: z.coerce\n    .number()\n    .int()\n    .min(1)\n    .max(2_147_483_647)\n    .describe('Attempt number of the step this chunk belongs to.'),\n  offset: z.coerce\n    .number()\n    .int()\n    .min(0)\n    .describe(\n      'Byte position of this chunk in the raw NDJSON spool. Must equal the server-held committed length: an earlier offset is acknowledged as already applied, a later offset returns 409 so the runner rewinds.',\n    ),\n});\n\nexport type AppendLogsQueryDto = z.infer<typeof appendLogsQuerySchema>;\n\nexport const appendLogsResponseSchema = z.object({\n  committed_length: z\n    .number()\n    .int()\n    .min(0)\n    .describe('New server-held byte position after this chunk was applied.'),\n  capped: z\n    .boolean()\n    .describe('When true, the per-job log budget is exhausted and further output is dropped.'),\n});\n\nexport type AppendLogsResponseDto = z.infer<typeof appendLogsResponseSchema>;\n\n/** Body of the 409 returned on an offset gap, so the runner rewinds its spool cursor. */\nexport const offsetGapResponseSchema = z.object({\n  code: z.literal('offset-gap'),\n  details: z.object({\n    committed_length: z\n      .number()\n      .int()\n      .min(0)\n      .describe('Current server-held committed length the runner should rewind to.'),\n  }),\n});\n\nexport type OffsetGapResponseDto = z.infer<typeof offsetGapResponseSchema>;\n"],"names":["z","appendLogsQuerySchema","object","attempt","coerce","number","int","min","max","describe","offset","appendLogsResponseSchema","committed_length","capped","boolean","offsetGapResponseSchema","code","literal","details"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB;;;;;;;;CAQC,GACD,OAAO,MAAMC,wBAAwBD,EAAEE,MAAM,CAAC;IAC5CC,SAASH,EAAEI,MAAM,CACdC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJC,GAAG,CAAC,eACJC,QAAQ,CAAC;IACZC,QAAQV,EAAEI,MAAM,CACbC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CACP;AAEN,GAAG;AAIH,OAAO,MAAME,2BAA2BX,EAAEE,MAAM,CAAC;IAC/CU,kBAAkBZ,EACfK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACZI,QAAQb,EACLc,OAAO,GACPL,QAAQ,CAAC;AACd,GAAG;AAIH,uFAAuF,GACvF,OAAO,MAAMM,0BAA0Bf,EAAEE,MAAM,CAAC;IAC9Cc,MAAMhB,EAAEiB,OAAO,CAAC;IAChBC,SAASlB,EAAEE,MAAM,CAAC;QAChBU,kBAAkBZ,EACfK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACd;AACF,GAAG"}
+{"version":3,"sources":["../../src/schemas/append.ts"],"sourcesContent":["import {z} from 'zod';\n\n/**\n * Append endpoint contract: `POST .../steps/:stepId/logs?attempt=N&offset=B`.\n *\n * The body is raw NDJSON bytes (whole records, newline-terminated), not a\n * Zod-validated object: it is parsed line by line against the raw log record\n * union (`rawLogRecordSchema`). `offset` is a position in the raw\n * NDJSON spool stream; both `offset` and the returned `committed_length` are\n * bounded far below 2^53 by the accrual budget, so JavaScript `number` is safe.\n */\nexport const appendLogsQuerySchema = z.object({\n  attempt: z.coerce\n    .number()\n    .int()\n    .min(1)\n    .max(2_147_483_647)\n    .describe('Attempt number of the step this chunk belongs to.'),\n  offset: z.coerce\n    .number()\n    .int()\n    .min(0)\n    .describe(\n      'Byte position of this chunk in the raw NDJSON spool. Must equal the server-held committed length: an earlier offset is acknowledged as already applied, a later offset returns 409 so the runner rewinds.',\n    ),\n});\n\nexport type AppendLogsQueryDto = z.infer<typeof appendLogsQuerySchema>;\n\nexport const appendLogsResponseSchema = z.object({\n  committed_length: z\n    .number()\n    .int()\n    .min(0)\n    .describe('New server-held byte position after this chunk was applied.'),\n  capped: z\n    .boolean()\n    .describe('When true, the per-job log budget is exhausted and further output is dropped.'),\n});\n\nexport type AppendLogsResponseDto = z.infer<typeof appendLogsResponseSchema>;\n\n/** Body of the 409 returned on an offset gap, so the runner rewinds its spool cursor. */\nexport const offsetGapResponseSchema = z.object({\n  code: z.literal('offset-gap'),\n  details: z.object({\n    committed_length: z\n      .number()\n      .int()\n      .min(0)\n      .describe('Current server-held committed length the runner should rewind to.'),\n  }),\n});\n\nexport type OffsetGapResponseDto = z.infer<typeof offsetGapResponseSchema>;\n\n/** A lease append was attempted on a stream owned by a server-origin writer. */\nexport const logWriterConflictResponseSchema = z.object({\n  code: z.literal('log-writer-conflict'),\n});\n\nexport type LogWriterConflictResponseDto = z.infer<typeof logWriterConflictResponseSchema>;\n"],"names":["z","appendLogsQuerySchema","object","attempt","coerce","number","int","min","max","describe","offset","appendLogsResponseSchema","committed_length","capped","boolean","offsetGapResponseSchema","code","literal","details","logWriterConflictResponseSchema"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB;;;;;;;;CAQC,GACD,OAAO,MAAMC,wBAAwBD,EAAEE,MAAM,CAAC;IAC5CC,SAASH,EAAEI,MAAM,CACdC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJC,GAAG,CAAC,eACJC,QAAQ,CAAC;IACZC,QAAQV,EAAEI,MAAM,CACbC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CACP;AAEN,GAAG;AAIH,OAAO,MAAME,2BAA2BX,EAAEE,MAAM,CAAC;IAC/CU,kBAAkBZ,EACfK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACZI,QAAQb,EACLc,OAAO,GACPL,QAAQ,CAAC;AACd,GAAG;AAIH,uFAAuF,GACvF,OAAO,MAAMM,0BAA0Bf,EAAEE,MAAM,CAAC;IAC9Cc,MAAMhB,EAAEiB,OAAO,CAAC;IAChBC,SAASlB,EAAEE,MAAM,CAAC;QAChBU,kBAAkBZ,EACfK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACd;AACF,GAAG;AAIH,8EAA8E,GAC9E,OAAO,MAAMU,kCAAkCnB,EAAEE,MAAM,CAAC;IACtDc,MAAMhB,EAAEiB,OAAO,CAAC;AAClB,GAAG"}

package/dist/schemas/index.d.ts

@@ -1,5 +1,5 @@
-export { type AppendLogsQueryDto, type AppendLogsResponseDto, appendLogsQuerySchema, appendLogsResponseSchema, type OffsetGapResponseDto, offsetGapResponseSchema, } from './append.js';
+export { type AppendLogsQueryDto, type AppendLogsResponseDto, appendLogsQuerySchema, appendLogsResponseSchema, type LogWriterConflictResponseDto, logWriterConflictResponseSchema, type OffsetGapResponseDto, offsetGapResponseSchema, } from './append.js';
 export { type ReadLogsQueryDto, type ReadLogsResponseDto, readLogsQuerySchema, readLogsResponseSchema, } from './read.js';
-export { type LogRecord, logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, parseLogRecordLine, parseRawLogRecordLine, type RawLogRecord, rawLogRecordSchema, } from './record.js';
+export { type LogRecord, logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, parseLogRecordLine, parseRawLogRecordLine, type RawLogRecord, rawLogRecordSchema, type ServerLogRecord, serverLogRecordSchema, } from './record.js';
 export { SESSION_VIEW_VERSION, type SessionViewDto, type SessionViewLifecycleRow, type SessionViewMessageRow, type SessionViewRawRow, type SessionViewRow, type SessionViewRowMeta, type SessionViewThinkingRow, type SessionViewToolCallRow, type SessionViewToolResultRow, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema, } from './session-view.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,oBAAoB,EACzB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,SAAS,EACd,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,YAAY,EACjB,kBAAkB,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,6BAA6B,EAC7B,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,4BAA4B,EAC5B,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,4BAA4B,EACjC,+BAA+B,EAC/B,KAAK,oBAAoB,EACzB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,SAAS,EACd,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,eAAe,EACpB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,6BAA6B,EAC7B,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,4BAA4B,EAC5B,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,mBAAmB,CAAC"}

package/dist/schemas/index.js

@@ -1,6 +1,6 @@
-export { appendLogsQuerySchema, appendLogsResponseSchema, offsetGapResponseSchema } from './append.js';
+export { appendLogsQuerySchema, appendLogsResponseSchema, logWriterConflictResponseSchema, offsetGapResponseSchema } from './append.js';
 export { readLogsQuerySchema, readLogsResponseSchema } from './read.js';
-export { logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, parseLogRecordLine, parseRawLogRecordLine, rawLogRecordSchema } from './record.js';
+export { logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, parseLogRecordLine, parseRawLogRecordLine, rawLogRecordSchema, serverLogRecordSchema } from './record.js';
 export { SESSION_VIEW_VERSION, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema } from './session-view.js';
 
 //# sourceMappingURL=index.js.map

package/dist/schemas/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/schemas/index.ts"],"sourcesContent":["export {\n  type AppendLogsQueryDto,\n  type AppendLogsResponseDto,\n  appendLogsQuerySchema,\n  appendLogsResponseSchema,\n  type OffsetGapResponseDto,\n  offsetGapResponseSchema,\n} from './append.js';\nexport {\n  type ReadLogsQueryDto,\n  type ReadLogsResponseDto,\n  readLogsQuerySchema,\n  readLogsResponseSchema,\n} from './read.js';\nexport {\n  type LogRecord,\n  logRecordSchema,\n  MAX_RECORD_DATA_BYTES,\n  MAX_RECORD_NAME_BYTES,\n  parseLogRecordLine,\n  parseRawLogRecordLine,\n  type RawLogRecord,\n  rawLogRecordSchema,\n} from './record.js';\nexport {\n  SESSION_VIEW_VERSION,\n  type SessionViewDto,\n  type SessionViewLifecycleRow,\n  type SessionViewMessageRow,\n  type SessionViewRawRow,\n  type SessionViewRow,\n  type SessionViewRowMeta,\n  type SessionViewThinkingRow,\n  type SessionViewToolCallRow,\n  type SessionViewToolResultRow,\n  sessionViewLifecycleRowSchema,\n  sessionViewMessageRowSchema,\n  sessionViewRawRowSchema,\n  sessionViewRowMetaSchema,\n  sessionViewRowSchema,\n  sessionViewSchema,\n  sessionViewThinkingRowSchema,\n  sessionViewToolCallRowSchema,\n  sessionViewToolResultRowSchema,\n} from './session-view.js';\n"],"names":["appendLogsQuerySchema","appendLogsResponseSchema","offsetGapResponseSchema","readLogsQuerySchema","readLogsResponseSchema","logRecordSchema","MAX_RECORD_DATA_BYTES","MAX_RECORD_NAME_BYTES","parseLogRecordLine","parseRawLogRecordLine","rawLogRecordSchema","SESSION_VIEW_VERSION","sessionViewLifecycleRowSchema","sessionViewMessageRowSchema","sessionViewRawRowSchema","sessionViewRowMetaSchema","sessionViewRowSchema","sessionViewSchema","sessionViewThinkingRowSchema","sessionViewToolCallRowSchema","sessionViewToolResultRowSchema"],"mappings":"AAAA,SAGEA,qBAAqB,EACrBC,wBAAwB,EAExBC,uBAAuB,QAClB,cAAc;AACrB,SAGEC,mBAAmB,EACnBC,sBAAsB,QACjB,YAAY;AACnB,SAEEC,eAAe,EACfC,qBAAqB,EACrBC,qBAAqB,EACrBC,kBAAkB,EAClBC,qBAAqB,EAErBC,kBAAkB,QACb,cAAc;AACrB,SACEC,oBAAoB,EAUpBC,6BAA6B,EAC7BC,2BAA2B,EAC3BC,uBAAuB,EACvBC,wBAAwB,EACxBC,oBAAoB,EACpBC,iBAAiB,EACjBC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,8BAA8B,QACzB,oBAAoB"}
+{"version":3,"sources":["../../src/schemas/index.ts"],"sourcesContent":["export {\n  type AppendLogsQueryDto,\n  type AppendLogsResponseDto,\n  appendLogsQuerySchema,\n  appendLogsResponseSchema,\n  type LogWriterConflictResponseDto,\n  logWriterConflictResponseSchema,\n  type OffsetGapResponseDto,\n  offsetGapResponseSchema,\n} from './append.js';\nexport {\n  type ReadLogsQueryDto,\n  type ReadLogsResponseDto,\n  readLogsQuerySchema,\n  readLogsResponseSchema,\n} from './read.js';\nexport {\n  type LogRecord,\n  logRecordSchema,\n  MAX_RECORD_DATA_BYTES,\n  MAX_RECORD_NAME_BYTES,\n  parseLogRecordLine,\n  parseRawLogRecordLine,\n  type RawLogRecord,\n  rawLogRecordSchema,\n  type ServerLogRecord,\n  serverLogRecordSchema,\n} from './record.js';\nexport {\n  SESSION_VIEW_VERSION,\n  type SessionViewDto,\n  type SessionViewLifecycleRow,\n  type SessionViewMessageRow,\n  type SessionViewRawRow,\n  type SessionViewRow,\n  type SessionViewRowMeta,\n  type SessionViewThinkingRow,\n  type SessionViewToolCallRow,\n  type SessionViewToolResultRow,\n  sessionViewLifecycleRowSchema,\n  sessionViewMessageRowSchema,\n  sessionViewRawRowSchema,\n  sessionViewRowMetaSchema,\n  sessionViewRowSchema,\n  sessionViewSchema,\n  sessionViewThinkingRowSchema,\n  sessionViewToolCallRowSchema,\n  sessionViewToolResultRowSchema,\n} from './session-view.js';\n"],"names":["appendLogsQuerySchema","appendLogsResponseSchema","logWriterConflictResponseSchema","offsetGapResponseSchema","readLogsQuerySchema","readLogsResponseSchema","logRecordSchema","MAX_RECORD_DATA_BYTES","MAX_RECORD_NAME_BYTES","parseLogRecordLine","parseRawLogRecordLine","rawLogRecordSchema","serverLogRecordSchema","SESSION_VIEW_VERSION","sessionViewLifecycleRowSchema","sessionViewMessageRowSchema","sessionViewRawRowSchema","sessionViewRowMetaSchema","sessionViewRowSchema","sessionViewSchema","sessionViewThinkingRowSchema","sessionViewToolCallRowSchema","sessionViewToolResultRowSchema"],"mappings":"AAAA,SAGEA,qBAAqB,EACrBC,wBAAwB,EAExBC,+BAA+B,EAE/BC,uBAAuB,QAClB,cAAc;AACrB,SAGEC,mBAAmB,EACnBC,sBAAsB,QACjB,YAAY;AACnB,SAEEC,eAAe,EACfC,qBAAqB,EACrBC,qBAAqB,EACrBC,kBAAkB,EAClBC,qBAAqB,EAErBC,kBAAkB,EAElBC,qBAAqB,QAChB,cAAc;AACrB,SACEC,oBAAoB,EAUpBC,6BAA6B,EAC7BC,2BAA2B,EAC3BC,uBAAuB,EACvBC,wBAAwB,EACxBC,oBAAoB,EACpBC,iBAAiB,EACjBC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,8BAA8B,QACzB,oBAAoB"}

package/dist/schemas/read.d.ts

@@ -18,8 +18,8 @@ export declare const readLogsResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     next_cursor: z.ZodNumber;
     has_more: z.ZodBoolean;
     state: z.ZodEnum<{
-        open: "open";
         closed: "closed";
+        open: "open";
     }>;
     truncated: z.ZodBoolean;
 }, z.core.$strip>, z.ZodObject<{

package/dist/schemas/read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/schemas/read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;iBAS9B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAwDnE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;2BAGjC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/schemas/read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;iBAS9B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AA0DnE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;2BAGjC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/schemas/read.js

@@ -37,7 +37,7 @@ import { z } from 'zod';
     expires_at: z.string().datetime({
         offset: true
     }).describe('ISO 8601 instant after which the presigned URL stops working.'),
-    total_bytes: z.number().int().min(0).describe('Committed append byte position for the attempt. This is the runner CAS axis.'),
+    total_bytes: z.number().int().min(0).describe('Committed append byte position for the attempt. This is the active writer CAS axis.'),
     truncated: z.boolean().describe('True when the stream was force-closed because the runner stopped reporting.')
 });
 export const readLogsResponseSchema = z.discriminatedUnion('mode', [

package/dist/schemas/read.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/schemas/read.ts"],"sourcesContent":["import {z} from 'zod';\n\n/**\n * Read endpoint contract: `GET .../steps/:stepId/attempts/:attempt/logs?cursor=N`.\n *\n * `cursor` is an opaque chunk-sequence position, not a byte offset. Server-injected\n * control tombstones (`capped`, `runner_lost`) do not advance the runner byte axis, so\n * the read walks chunks by insertion `seq` to keep every record in stream order. The\n * same `seq` walk backs compaction, so the inline `ndjson` is byte-identical to the\n * decompressed compacted object. Start at 0 and echo back `next_cursor` to page forward.\n */\nexport const readLogsQuerySchema = z.object({\n  cursor: z.coerce\n    .number()\n    .int()\n    .min(0)\n    .default(0)\n    .describe(\n      'Opaque chunk-sequence cursor. Start at 0; echo back the previous response next_cursor to page forward. Not a byte offset.',\n    ),\n});\n\nexport type ReadLogsQueryDto = z.infer<typeof readLogsQuerySchema>;\n\n/**\n * Inline shape: stored NDJSON bytes from `cursor`, parsed client-side with\n * `parseLogRecordLine`. Served while the stream is open or closed but not yet compacted.\n * The bytes carry every record of every type for the `(step, attempt)`; the client\n * filters by record type for display.\n */\nconst readLogsInlineSchema = z.object({\n  mode: z.literal('inline'),\n  ndjson: z\n    .string()\n    .describe('Stored NDJSON: every record for this (step, attempt) from cursor, in stream order.'),\n  next_cursor: z\n    .number()\n    .int()\n    .min(0)\n    .describe('Cursor to pass on the next poll to fetch records after this page.'),\n  has_more: z\n    .boolean()\n    .describe(\n      'True when more buffered records remain past this page; re-poll immediately to drain before tailing at the refresh interval.',\n    ),\n  state: z\n    .enum(['open', 'closed'])\n    .describe('Stream lifecycle: open still accepts appends, closed is terminal.'),\n  truncated: z\n    .boolean()\n    .describe('True when the stream was force-closed because the runner stopped reporting.'),\n});\n\n/**\n * Presigned shape: a short-lived GET URL to the compacted object, fetched directly by\n * the browser (API egress bypassed). Served once the stream is compacted (`object_key`\n * set). The object is the same NDJSON the inline shape streams, gzip-compressed.\n */\nconst readLogsPresignedSchema = z.object({\n  mode: z.literal('presigned'),\n  url: z.string().url().describe('Presigned GET URL for the compacted NDJSON object.'),\n  state: z\n    .literal('closed')\n    .describe('Compacted streams are closed before they are served by URL.'),\n  expires_at: z\n    .string()\n    .datetime({offset: true})\n    .describe('ISO 8601 instant after which the presigned URL stops working.'),\n  total_bytes: z\n    .number()\n    .int()\n    .min(0)\n    .describe('Committed append byte position for the attempt. This is the runner CAS axis.'),\n  truncated: z\n    .boolean()\n    .describe('True when the stream was force-closed because the runner stopped reporting.'),\n});\n\nexport const readLogsResponseSchema = z.discriminatedUnion('mode', [\n  readLogsInlineSchema,\n  readLogsPresignedSchema,\n]);\n\nexport type ReadLogsResponseDto = z.infer<typeof readLogsResponseSchema>;\n"],"names":["z","readLogsQuerySchema","object","cursor","coerce","number","int","min","default","describe","readLogsInlineSchema","mode","literal","ndjson","string","next_cursor","has_more","boolean","state","enum","truncated","readLogsPresignedSchema","url","expires_at","datetime","offset","total_bytes","readLogsResponseSchema","discriminatedUnion"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB;;;;;;;;CAQC,GACD,OAAO,MAAMC,sBAAsBD,EAAEE,MAAM,CAAC;IAC1CC,QAAQH,EAAEI,MAAM,CACbC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJC,OAAO,CAAC,GACRC,QAAQ,CACP;AAEN,GAAG;AAIH;;;;;CAKC,GACD,MAAMC,uBAAuBV,EAAEE,MAAM,CAAC;IACpCS,MAAMX,EAAEY,OAAO,CAAC;IAChBC,QAAQb,EACLc,MAAM,GACNL,QAAQ,CAAC;IACZM,aAAaf,EACVK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACZO,UAAUhB,EACPiB,OAAO,GACPR,QAAQ,CACP;IAEJS,OAAOlB,EACJmB,IAAI,CAAC;QAAC;QAAQ;KAAS,EACvBV,QAAQ,CAAC;IACZW,WAAWpB,EACRiB,OAAO,GACPR,QAAQ,CAAC;AACd;AAEA;;;;CAIC,GACD,MAAMY,0BAA0BrB,EAAEE,MAAM,CAAC;IACvCS,MAAMX,EAAEY,OAAO,CAAC;IAChBU,KAAKtB,EAAEc,MAAM,GAAGQ,GAAG,GAAGb,QAAQ,CAAC;IAC/BS,OAAOlB,EACJY,OAAO,CAAC,UACRH,QAAQ,CAAC;IACZc,YAAYvB,EACTc,MAAM,GACNU,QAAQ,CAAC;QAACC,QAAQ;IAAI,GACtBhB,QAAQ,CAAC;IACZiB,aAAa1B,EACVK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACZW,WAAWpB,EACRiB,OAAO,GACPR,QAAQ,CAAC;AACd;AAEA,OAAO,MAAMkB,yBAAyB3B,EAAE4B,kBAAkB,CAAC,QAAQ;IACjElB;IACAW;CACD,EAAE"}
+{"version":3,"sources":["../../src/schemas/read.ts"],"sourcesContent":["import {z} from 'zod';\n\n/**\n * Read endpoint contract: `GET .../steps/:stepId/attempts/:attempt/logs?cursor=N`.\n *\n * `cursor` is an opaque chunk-sequence position, not a byte offset. Server-injected\n * control tombstones (`capped`, `runner_lost`) do not advance the runner byte axis, so\n * the read walks chunks by insertion `seq` to keep every record in stream order. The\n * same `seq` walk backs compaction, so the inline `ndjson` is byte-identical to the\n * decompressed compacted object. Start at 0 and echo back `next_cursor` to page forward.\n */\nexport const readLogsQuerySchema = z.object({\n  cursor: z.coerce\n    .number()\n    .int()\n    .min(0)\n    .default(0)\n    .describe(\n      'Opaque chunk-sequence cursor. Start at 0; echo back the previous response next_cursor to page forward. Not a byte offset.',\n    ),\n});\n\nexport type ReadLogsQueryDto = z.infer<typeof readLogsQuerySchema>;\n\n/**\n * Inline shape: stored NDJSON bytes from `cursor`, parsed client-side with\n * `parseLogRecordLine`. Served while the stream is open or closed but not yet compacted.\n * The bytes carry every record of every type for the `(step, attempt)`; the client\n * filters by record type for display.\n */\nconst readLogsInlineSchema = z.object({\n  mode: z.literal('inline'),\n  ndjson: z\n    .string()\n    .describe('Stored NDJSON: every record for this (step, attempt) from cursor, in stream order.'),\n  next_cursor: z\n    .number()\n    .int()\n    .min(0)\n    .describe('Cursor to pass on the next poll to fetch records after this page.'),\n  has_more: z\n    .boolean()\n    .describe(\n      'True when more buffered records remain past this page; re-poll immediately to drain before tailing at the refresh interval.',\n    ),\n  state: z\n    .enum(['open', 'closed'])\n    .describe('Stream lifecycle: open still accepts appends, closed is terminal.'),\n  truncated: z\n    .boolean()\n    .describe('True when the stream was force-closed because the runner stopped reporting.'),\n});\n\n/**\n * Presigned shape: a short-lived GET URL to the compacted object, fetched directly by\n * the browser (API egress bypassed). Served once the stream is compacted (`object_key`\n * set). The object is the same NDJSON the inline shape streams, gzip-compressed.\n */\nconst readLogsPresignedSchema = z.object({\n  mode: z.literal('presigned'),\n  url: z.string().url().describe('Presigned GET URL for the compacted NDJSON object.'),\n  state: z\n    .literal('closed')\n    .describe('Compacted streams are closed before they are served by URL.'),\n  expires_at: z\n    .string()\n    .datetime({offset: true})\n    .describe('ISO 8601 instant after which the presigned URL stops working.'),\n  total_bytes: z\n    .number()\n    .int()\n    .min(0)\n    .describe(\n      'Committed append byte position for the attempt. This is the active writer CAS axis.',\n    ),\n  truncated: z\n    .boolean()\n    .describe('True when the stream was force-closed because the runner stopped reporting.'),\n});\n\nexport const readLogsResponseSchema = z.discriminatedUnion('mode', [\n  readLogsInlineSchema,\n  readLogsPresignedSchema,\n]);\n\nexport type ReadLogsResponseDto = z.infer<typeof readLogsResponseSchema>;\n"],"names":["z","readLogsQuerySchema","object","cursor","coerce","number","int","min","default","describe","readLogsInlineSchema","mode","literal","ndjson","string","next_cursor","has_more","boolean","state","enum","truncated","readLogsPresignedSchema","url","expires_at","datetime","offset","total_bytes","readLogsResponseSchema","discriminatedUnion"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB;;;;;;;;CAQC,GACD,OAAO,MAAMC,sBAAsBD,EAAEE,MAAM,CAAC;IAC1CC,QAAQH,EAAEI,MAAM,CACbC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJC,OAAO,CAAC,GACRC,QAAQ,CACP;AAEN,GAAG;AAIH;;;;;CAKC,GACD,MAAMC,uBAAuBV,EAAEE,MAAM,CAAC;IACpCS,MAAMX,EAAEY,OAAO,CAAC;IAChBC,QAAQb,EACLc,MAAM,GACNL,QAAQ,CAAC;IACZM,aAAaf,EACVK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACZO,UAAUhB,EACPiB,OAAO,GACPR,QAAQ,CACP;IAEJS,OAAOlB,EACJmB,IAAI,CAAC;QAAC;QAAQ;KAAS,EACvBV,QAAQ,CAAC;IACZW,WAAWpB,EACRiB,OAAO,GACPR,QAAQ,CAAC;AACd;AAEA;;;;CAIC,GACD,MAAMY,0BAA0BrB,EAAEE,MAAM,CAAC;IACvCS,MAAMX,EAAEY,OAAO,CAAC;IAChBU,KAAKtB,EAAEc,MAAM,GAAGQ,GAAG,GAAGb,QAAQ,CAAC;IAC/BS,OAAOlB,EACJY,OAAO,CAAC,UACRH,QAAQ,CAAC;IACZc,YAAYvB,EACTc,MAAM,GACNU,QAAQ,CAAC;QAACC,QAAQ;IAAI,GACtBhB,QAAQ,CAAC;IACZiB,aAAa1B,EACVK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CACP;IAEJW,WAAWpB,EACRiB,OAAO,GACPR,QAAQ,CAAC;AACd;AAEA,OAAO,MAAMkB,yBAAyB3B,EAAE4B,kBAAkB,CAAC,QAAQ;IACjElB;IACAW;CACD,EAAE"}