@shipfox/api-logs 2.0.0

package/dist/core/close-stream.d.ts

@@ -0,0 +1,27 @@
+import { Buffer } from 'node:buffer';
+import type { AttemptStream, StreamCloseReason } from '#core/entities/attempt-stream.js';
+import type { Transaction } from '#db/db.js';
+export type TombstoneKind = 'capped' | 'runner_lost';
+/**
+ * Frames a server tombstone as one newline-terminated record. Typed against the
+ * shared contract so an envelope change breaks this at compile time. Stored as a
+ * `control`-origin chunk; like every server record it does NOT advance
+ * `committed_length`, so the CAS axis stays equal to runner spool bytes.
+ */
+export declare function controlTombstone(kind: TombstoneKind): Buffer;
+export interface CloseStreamParams {
+    streamId: string;
+    reason: StreamCloseReason;
+}
+/**
+ * The guarded UPDATE (`WHERE state='open'`) in `markStreamClosed` is the lock and
+ * the idempotency gate: a stream already closed by the other path (append-time
+ * declared close vs the job-terminated timeout sweep) returns null, so no duplicate
+ * `LOG_STREAM_CLOSED` is written and no second tombstone lands. A timeout close sets
+ * `truncated` and injects a `runner_lost` tombstone in-band (a `capped` tombstone,
+ * if any, was injected earlier at the append that tripped the cap).
+ *
+ * The event drives compaction; it is written in the same transaction as the flip.
+ */
+export declare function closeStream(tx: Transaction, params: CloseStreamParams): Promise<AttemptStream | null>;
+//# sourceMappingURL=close-stream.d.ts.map

package/dist/core/close-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-stream.d.ts","sourceRoot":"","sources":["../../src/core/close-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGnC,OAAO,KAAK,EAAC,aAAa,EAAE,iBAAiB,EAAC,MAAM,kCAAkC,CAAC;AAEvF,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAI3C,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,aAAa,CAAC;AAErD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAG5D;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,EAAE,EAAE,WAAW,EACf,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CA+B/B"}

package/dist/core/close-stream.js

@@ -0,0 +1,59 @@
+import { Buffer } from 'node:buffer';
+import { LOG_STREAM_CLOSED } from '@shipfox/api-logs-dto';
+import { writeOutboxEvent } from '@shipfox/node-outbox';
+import { insertChunk } from '#db/chunks.js';
+import { logsOutbox } from '#db/schema/outbox.js';
+import { markStreamClosed } from '#db/streams.js';
+/**
+ * Frames a server tombstone as one newline-terminated record. Typed against the
+ * shared contract so an envelope change breaks this at compile time. Stored as a
+ * `control`-origin chunk; like every server record it does NOT advance
+ * `committed_length`, so the CAS axis stays equal to runner spool bytes.
+ */ export function controlTombstone(kind) {
+    const record = {
+        v: 1,
+        ts: Date.now(),
+        type: kind
+    };
+    return Buffer.from(`${JSON.stringify(record)}\n`, 'utf8');
+}
+/**
+ * The guarded UPDATE (`WHERE state='open'`) in `markStreamClosed` is the lock and
+ * the idempotency gate: a stream already closed by the other path (append-time
+ * declared close vs the job-terminated timeout sweep) returns null, so no duplicate
+ * `LOG_STREAM_CLOSED` is written and no second tombstone lands. A timeout close sets
+ * `truncated` and injects a `runner_lost` tombstone in-band (a `capped` tombstone,
+ * if any, was injected earlier at the append that tripped the cap).
+ *
+ * The event drives compaction; it is written in the same transaction as the flip.
+ */ export async function closeStream(tx, params) {
+    const closed = await markStreamClosed(tx, {
+        streamId: params.streamId,
+        reason: params.reason,
+        markTruncated: params.reason === 'timeout'
+    });
+    if (!closed) return null;
+    if (params.reason === 'timeout') {
+        const tombstone = controlTombstone('runner_lost');
+        await insertChunk(tx, {
+            streamId: closed.id,
+            streamOffset: closed.committedLength,
+            byteLen: tombstone.length,
+            data: tombstone,
+            origin: 'control'
+        });
+    }
+    await writeOutboxEvent(tx, logsOutbox, {
+        type: LOG_STREAM_CLOSED,
+        payload: {
+            workspaceId: closed.workspaceId,
+            jobId: closed.jobId,
+            stepId: closed.stepId,
+            attempt: closed.attempt,
+            streamId: closed.id
+        }
+    });
+    return closed;
+}
+
+//# sourceMappingURL=close-stream.js.map

package/dist/core/close-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/close-stream.ts"],"sourcesContent":["import {Buffer} from 'node:buffer';\nimport {LOG_STREAM_CLOSED, type LogRecord, type LogsEventMap} from '@shipfox/api-logs-dto';\nimport {writeOutboxEvent} from '@shipfox/node-outbox';\nimport type {AttemptStream, StreamCloseReason} from '#core/entities/attempt-stream.js';\nimport {insertChunk} from '#db/chunks.js';\nimport type {Transaction} from '#db/db.js';\nimport {logsOutbox} from '#db/schema/outbox.js';\nimport {markStreamClosed} from '#db/streams.js';\n\nexport type TombstoneKind = 'capped' | 'runner_lost';\n\n/**\n * Frames a server tombstone as one newline-terminated record. Typed against the\n * shared contract so an envelope change breaks this at compile time. Stored as a\n * `control`-origin chunk; like every server record it does NOT advance\n * `committed_length`, so the CAS axis stays equal to runner spool bytes.\n */\nexport function controlTombstone(kind: TombstoneKind): Buffer {\n  const record: LogRecord = {v: 1, ts: Date.now(), type: kind};\n  return Buffer.from(`${JSON.stringify(record)}\\n`, 'utf8');\n}\n\nexport interface CloseStreamParams {\n  streamId: string;\n  reason: StreamCloseReason;\n}\n\n/**\n * The guarded UPDATE (`WHERE state='open'`) in `markStreamClosed` is the lock and\n * the idempotency gate: a stream already closed by the other path (append-time\n * declared close vs the job-terminated timeout sweep) returns null, so no duplicate\n * `LOG_STREAM_CLOSED` is written and no second tombstone lands. A timeout close sets\n * `truncated` and injects a `runner_lost` tombstone in-band (a `capped` tombstone,\n * if any, was injected earlier at the append that tripped the cap).\n *\n * The event drives compaction; it is written in the same transaction as the flip.\n */\nexport async function closeStream(\n  tx: Transaction,\n  params: CloseStreamParams,\n): Promise<AttemptStream | null> {\n  const closed = await markStreamClosed(tx, {\n    streamId: params.streamId,\n    reason: params.reason,\n    markTruncated: params.reason === 'timeout',\n  });\n  if (!closed) return null;\n\n  if (params.reason === 'timeout') {\n    const tombstone = controlTombstone('runner_lost');\n    await insertChunk(tx, {\n      streamId: closed.id,\n      streamOffset: closed.committedLength,\n      byteLen: tombstone.length,\n      data: tombstone,\n      origin: 'control',\n    });\n  }\n\n  await writeOutboxEvent<LogsEventMap>(tx, logsOutbox, {\n    type: LOG_STREAM_CLOSED,\n    payload: {\n      workspaceId: closed.workspaceId,\n      jobId: closed.jobId,\n      stepId: closed.stepId,\n      attempt: closed.attempt,\n      streamId: closed.id,\n    },\n  });\n\n  return closed;\n}\n"],"names":["Buffer","LOG_STREAM_CLOSED","writeOutboxEvent","insertChunk","logsOutbox","markStreamClosed","controlTombstone","kind","record","v","ts","Date","now","type","from","JSON","stringify","closeStream","tx","params","closed","streamId","reason","markTruncated","tombstone","id","streamOffset","committedLength","byteLen","length","data","origin","payload","workspaceId","jobId","stepId","attempt"],"mappings":"AAAA,SAAQA,MAAM,QAAO,cAAc;AACnC,SAAQC,iBAAiB,QAA0C,wBAAwB;AAC3F,SAAQC,gBAAgB,QAAO,uBAAuB;AAEtD,SAAQC,WAAW,QAAO,gBAAgB;AAE1C,SAAQC,UAAU,QAAO,uBAAuB;AAChD,SAAQC,gBAAgB,QAAO,iBAAiB;AAIhD;;;;;CAKC,GACD,OAAO,SAASC,iBAAiBC,IAAmB;IAClD,MAAMC,SAAoB;QAACC,GAAG;QAAGC,IAAIC,KAAKC,GAAG;QAAIC,MAAMN;IAAI;IAC3D,OAAOP,OAAOc,IAAI,CAAC,GAAGC,KAAKC,SAAS,CAACR,QAAQ,EAAE,CAAC,EAAE;AACpD;AAOA;;;;;;;;;CASC,GACD,OAAO,eAAeS,YACpBC,EAAe,EACfC,MAAyB;IAEzB,MAAMC,SAAS,MAAMf,iBAAiBa,IAAI;QACxCG,UAAUF,OAAOE,QAAQ;QACzBC,QAAQH,OAAOG,MAAM;QACrBC,eAAeJ,OAAOG,MAAM,KAAK;IACnC;IACA,IAAI,CAACF,QAAQ,OAAO;IAEpB,IAAID,OAAOG,MAAM,KAAK,WAAW;QAC/B,MAAME,YAAYlB,iBAAiB;QACnC,MAAMH,YAAYe,IAAI;YACpBG,UAAUD,OAAOK,EAAE;YACnBC,cAAcN,OAAOO,eAAe;YACpCC,SAASJ,UAAUK,MAAM;YACzBC,MAAMN;YACNO,QAAQ;QACV;IACF;IAEA,MAAM7B,iBAA+BgB,IAAId,YAAY;QACnDS,MAAMZ;QACN+B,SAAS;YACPC,aAAab,OAAOa,WAAW;YAC/BC,OAAOd,OAAOc,KAAK;YACnBC,QAAQf,OAAOe,MAAM;YACrBC,SAAShB,OAAOgB,OAAO;YACvBf,UAAUD,OAAOK,EAAE;QACrB;IACF;IAEA,OAAOL;AACT"}

package/dist/core/compaction.d.ts

@@ -0,0 +1,28 @@
+import { Readable } from 'node:stream';
+export interface CompactionStreamStats {
+    chunkCount: number;
+    lastSeq: number;
+    uncompressedBytes: number;
+}
+export interface CompactedGzipStream {
+    body: Readable;
+    stats: CompactionStreamStats;
+}
+export interface CompactedGzipStreamParams {
+    streamId: string;
+    /**
+     * Invoked once per fetched chunk page (after the read, before the page's bytes flow on).
+     * Lets the caller heartbeat off read progress, so the pre-upload phase and a slow first
+     * part still emit liveness instead of waiting on the upload's per-part progress event.
+     */
+    onPage?: () => void;
+}
+/**
+ * Builds a gzip stream of a closed stream's chunk bytes in `seq` order. Keyset-paginates
+ * so memory stays flat at any stream size, and fills `stats` as bytes flow so the caller
+ * can check the streamed totals against the table before deleting the source rows. A
+ * source error is forwarded to the gzip stream, so the upload consuming it rejects rather
+ * than silently truncating.
+ */
+export declare function compactedGzipStream(params: CompactedGzipStreamParams): CompactedGzipStream;
+//# sourceMappingURL=compaction.d.ts.map

package/dist/core/compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.d.ts","sourceRoot":"","sources":["../../src/core/compaction.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AAQrC,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,qBAAqB,CAAC;CAC9B;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,mBAAmB,CA8B1F"}

package/dist/core/compaction.js

@@ -0,0 +1,49 @@
+import { Readable } from 'node:stream';
+import { createGzip } from 'node:zlib';
+import { readChunksKeyset } from '#db/chunks.js';
+// Chunks are capped at ~256KB each by the runner flush, so a small fixed page count gives a
+// predictable memory bound (page x ~256KB) without a byte-budgeted query.
+const CHUNK_PAGE_SIZE = 64;
+/**
+ * Builds a gzip stream of a closed stream's chunk bytes in `seq` order. Keyset-paginates
+ * so memory stays flat at any stream size, and fills `stats` as bytes flow so the caller
+ * can check the streamed totals against the table before deleting the source rows. A
+ * source error is forwarded to the gzip stream, so the upload consuming it rejects rather
+ * than silently truncating.
+ */ export function compactedGzipStream(params) {
+    const stats = {
+        chunkCount: 0,
+        lastSeq: 0,
+        uncompressedBytes: 0
+    };
+    async function* chunks() {
+        let afterSeq = 0;
+        while(true){
+            const page = await readChunksKeyset({
+                streamId: params.streamId,
+                afterSeq,
+                limit: CHUNK_PAGE_SIZE
+            });
+            if (page.length === 0) break;
+            params.onPage?.();
+            for (const row of page){
+                stats.chunkCount += 1;
+                stats.lastSeq = row.seq;
+                stats.uncompressedBytes += row.data.length;
+                yield row.data;
+            }
+            afterSeq = page.at(-1)?.seq ?? afterSeq;
+            if (page.length < CHUNK_PAGE_SIZE) break;
+        }
+    }
+    const source = Readable.from(chunks());
+    const gzip = createGzip();
+    source.once('error', (error)=>gzip.destroy(error));
+    source.pipe(gzip);
+    return {
+        body: gzip,
+        stats
+    };
+}
+
+//# sourceMappingURL=compaction.js.map

package/dist/core/compaction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/compaction.ts"],"sourcesContent":["import type {Buffer} from 'node:buffer';\nimport {Readable} from 'node:stream';\nimport {createGzip} from 'node:zlib';\nimport {readChunksKeyset} from '#db/chunks.js';\n\n// Chunks are capped at ~256KB each by the runner flush, so a small fixed page count gives a\n// predictable memory bound (page x ~256KB) without a byte-budgeted query.\nconst CHUNK_PAGE_SIZE = 64;\n\nexport interface CompactionStreamStats {\n  chunkCount: number;\n  lastSeq: number;\n  uncompressedBytes: number;\n}\n\nexport interface CompactedGzipStream {\n  body: Readable;\n  stats: CompactionStreamStats;\n}\n\nexport interface CompactedGzipStreamParams {\n  streamId: string;\n  /**\n   * Invoked once per fetched chunk page (after the read, before the page's bytes flow on).\n   * Lets the caller heartbeat off read progress, so the pre-upload phase and a slow first\n   * part still emit liveness instead of waiting on the upload's per-part progress event.\n   */\n  onPage?: () => void;\n}\n\n/**\n * Builds a gzip stream of a closed stream's chunk bytes in `seq` order. Keyset-paginates\n * so memory stays flat at any stream size, and fills `stats` as bytes flow so the caller\n * can check the streamed totals against the table before deleting the source rows. A\n * source error is forwarded to the gzip stream, so the upload consuming it rejects rather\n * than silently truncating.\n */\nexport function compactedGzipStream(params: CompactedGzipStreamParams): CompactedGzipStream {\n  const stats: CompactionStreamStats = {chunkCount: 0, lastSeq: 0, uncompressedBytes: 0};\n\n  async function* chunks(): AsyncGenerator<Buffer> {\n    let afterSeq = 0;\n    while (true) {\n      const page = await readChunksKeyset({\n        streamId: params.streamId,\n        afterSeq,\n        limit: CHUNK_PAGE_SIZE,\n      });\n      if (page.length === 0) break;\n      params.onPage?.();\n      for (const row of page) {\n        stats.chunkCount += 1;\n        stats.lastSeq = row.seq;\n        stats.uncompressedBytes += row.data.length;\n        yield row.data;\n      }\n      afterSeq = page.at(-1)?.seq ?? afterSeq;\n      if (page.length < CHUNK_PAGE_SIZE) break;\n    }\n  }\n\n  const source = Readable.from(chunks());\n  const gzip = createGzip();\n  source.once('error', (error) => gzip.destroy(error));\n  source.pipe(gzip);\n\n  return {body: gzip, stats};\n}\n"],"names":["Readable","createGzip","readChunksKeyset","CHUNK_PAGE_SIZE","compactedGzipStream","params","stats","chunkCount","lastSeq","uncompressedBytes","chunks","afterSeq","page","streamId","limit","length","onPage","row","seq","data","at","source","from","gzip","once","error","destroy","pipe","body"],"mappings":"AACA,SAAQA,QAAQ,QAAO,cAAc;AACrC,SAAQC,UAAU,QAAO,YAAY;AACrC,SAAQC,gBAAgB,QAAO,gBAAgB;AAE/C,4FAA4F;AAC5F,0EAA0E;AAC1E,MAAMC,kBAAkB;AAuBxB;;;;;;CAMC,GACD,OAAO,SAASC,oBAAoBC,MAAiC;IACnE,MAAMC,QAA+B;QAACC,YAAY;QAAGC,SAAS;QAAGC,mBAAmB;IAAC;IAErF,gBAAgBC;QACd,IAAIC,WAAW;QACf,MAAO,KAAM;YACX,MAAMC,OAAO,MAAMV,iBAAiB;gBAClCW,UAAUR,OAAOQ,QAAQ;gBACzBF;gBACAG,OAAOX;YACT;YACA,IAAIS,KAAKG,MAAM,KAAK,GAAG;YACvBV,OAAOW,MAAM;YACb,KAAK,MAAMC,OAAOL,KAAM;gBACtBN,MAAMC,UAAU,IAAI;gBACpBD,MAAME,OAAO,GAAGS,IAAIC,GAAG;gBACvBZ,MAAMG,iBAAiB,IAAIQ,IAAIE,IAAI,CAACJ,MAAM;gBAC1C,MAAME,IAAIE,IAAI;YAChB;YACAR,WAAWC,KAAKQ,EAAE,CAAC,CAAC,IAAIF,OAAOP;YAC/B,IAAIC,KAAKG,MAAM,GAAGZ,iBAAiB;QACrC;IACF;IAEA,MAAMkB,SAASrB,SAASsB,IAAI,CAACZ;IAC7B,MAAMa,OAAOtB;IACboB,OAAOG,IAAI,CAAC,SAAS,CAACC,QAAUF,KAAKG,OAAO,CAACD;IAC7CJ,OAAOM,IAAI,CAACJ;IAEZ,OAAO;QAACK,MAAML;QAAMjB;IAAK;AAC3B"}

package/dist/core/entities/attempt-stream.d.ts

@@ -0,0 +1,37 @@
+/** Lifecycle state of an attempt's log stream. */
+export type StreamState = 'open' | 'closed';
+/** Why a stream was closed, once it is. */
+export type StreamCloseReason = 'declared' | 'timeout';
+/**
+ * A single `(job, step, attempt)` log stream. Identity is scoped to the lease's
+ * job. `workspaceId`, `projectId`, and `workflowRunAttemptId` are stamped from the lease on
+ * stream creation and asserted on subsequent appends, so reads can authorize
+ * per-project without joining back to workflows. `committedLength` is the
+ * offset-CAS axis: raw NDJSON spool bytes the server has durably accepted from
+ * the runner.
+ *
+ * `truncated` is an out-of-band terminal flag set when the timeout sweep
+ * force-closes a stream the runner never ended. Budget exhaustion ("capped") is a
+ * job-level signal recorded in `job_accounting` and surfaced in-band by a `capped`
+ * tombstone record, not on the stream row.
+ */
+export interface AttemptStream {
+    id: string;
+    jobId: string;
+    stepId: string;
+    attempt: number;
+    workspaceId: string;
+    projectId: string;
+    workflowRunAttemptId: string;
+    committedLength: number;
+    state: StreamState;
+    closeReason: StreamCloseReason | null;
+    declaredTotalBytes: number | null;
+    truncated: boolean;
+    objectKey: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    /** When the stream was closed (either close path); null while open. Retention anchor. */
+    closedAt: Date | null;
+}
+//# sourceMappingURL=attempt-stream.d.ts.map

package/dist/core/entities/attempt-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt-stream.d.ts","sourceRoot":"","sources":["../../../src/core/entities/attempt-stream.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE5C,2CAA2C;AAC3C,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,SAAS,CAAC;AAEvD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,WAAW,CAAC;IACnB,WAAW,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACtC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,yFAAyF;IACzF,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;CACvB"}

package/dist/core/entities/attempt-stream.js

@@ -0,0 +1,15 @@
+/** Lifecycle state of an attempt's log stream. */ /**
+ * A single `(job, step, attempt)` log stream. Identity is scoped to the lease's
+ * job. `workspaceId`, `projectId`, and `workflowRunAttemptId` are stamped from the lease on
+ * stream creation and asserted on subsequent appends, so reads can authorize
+ * per-project without joining back to workflows. `committedLength` is the
+ * offset-CAS axis: raw NDJSON spool bytes the server has durably accepted from
+ * the runner.
+ *
+ * `truncated` is an out-of-band terminal flag set when the timeout sweep
+ * force-closes a stream the runner never ended. Budget exhaustion ("capped") is a
+ * job-level signal recorded in `job_accounting` and surfaced in-band by a `capped`
+ * tombstone record, not on the stream row.
+ */ export { };
+
+//# sourceMappingURL=attempt-stream.js.map

package/dist/core/entities/attempt-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/entities/attempt-stream.ts"],"sourcesContent":["/** Lifecycle state of an attempt's log stream. */\nexport type StreamState = 'open' | 'closed';\n\n/** Why a stream was closed, once it is. */\nexport type StreamCloseReason = 'declared' | 'timeout';\n\n/**\n * A single `(job, step, attempt)` log stream. Identity is scoped to the lease's\n * job. `workspaceId`, `projectId`, and `workflowRunAttemptId` are stamped from the lease on\n * stream creation and asserted on subsequent appends, so reads can authorize\n * per-project without joining back to workflows. `committedLength` is the\n * offset-CAS axis: raw NDJSON spool bytes the server has durably accepted from\n * the runner.\n *\n * `truncated` is an out-of-band terminal flag set when the timeout sweep\n * force-closes a stream the runner never ended. Budget exhaustion (\"capped\") is a\n * job-level signal recorded in `job_accounting` and surfaced in-band by a `capped`\n * tombstone record, not on the stream row.\n */\nexport interface AttemptStream {\n  id: string;\n  jobId: string;\n  stepId: string;\n  attempt: number;\n  workspaceId: string;\n  projectId: string;\n  workflowRunAttemptId: string;\n  committedLength: number;\n  state: StreamState;\n  closeReason: StreamCloseReason | null;\n  declaredTotalBytes: number | null;\n  truncated: boolean;\n  objectKey: string | null;\n  createdAt: Date;\n  updatedAt: Date;\n  /** When the stream was closed (either close path); null while open. Retention anchor. */\n  closedAt: Date | null;\n}\n"],"names":[],"mappings":"AAAA,gDAAgD,GAMhD;;;;;;;;;;;;CAYC,GACD,WAkBC"}

package/dist/core/entities/job-accounting.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Per-job accrual-budget state: how many stored bytes a job has used, the budget
+ * clock origin, and whether it has been capped.
+ */
+export interface JobAccounting {
+    jobId: string;
+    workspaceId: string;
+    storedBytesUsed: number;
+    startedAt: Date;
+    cappedAt: Date | null;
+}
+//# sourceMappingURL=job-accounting.d.ts.map

package/dist/core/entities/job-accounting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-accounting.d.ts","sourceRoot":"","sources":["../../../src/core/entities/job-accounting.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;CACvB"}

package/dist/core/entities/job-accounting.js

@@ -0,0 +1,6 @@
+/**
+ * Per-job accrual-budget state: how many stored bytes a job has used, the budget
+ * clock origin, and whether it has been capped.
+ */ export { };
+
+//# sourceMappingURL=job-accounting.js.map

package/dist/core/entities/job-accounting.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/entities/job-accounting.ts"],"sourcesContent":["/**\n * Per-job accrual-budget state: how many stored bytes a job has used, the budget\n * clock origin, and whether it has been capped.\n */\nexport interface JobAccounting {\n  jobId: string;\n  workspaceId: string;\n  storedBytesUsed: number;\n  startedAt: Date;\n  cappedAt: Date | null;\n}\n"],"names":[],"mappings":"AAAA;;;CAGC,GACD,WAMC"}

package/dist/core/entities/log-object.d.ts

@@ -0,0 +1,13 @@
+export interface LogObjectKeyParams {
+    workspaceId: string;
+    jobId: string;
+    stepId: string;
+    attempt: number;
+}
+/**
+ * Object layout `{prefix}/{workspace}/{job}/{step}/{attempt}` so retention and workspace
+ * deletion are prefix operations. `prefix` is the configurable bucket prefix
+ * (`LOG_STORAGE_S3_PREFIX`, default `logs`), so one bucket can host several modules.
+ */
+export declare function logObjectKey(prefix: string, { workspaceId, jobId, stepId, attempt }: LogObjectKeyParams): string;
+//# sourceMappingURL=log-object.d.ts.map

package/dist/core/entities/log-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-object.d.ts","sourceRoot":"","sources":["../../../src/core/entities/log-object.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,EAAC,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAC,EAAE,kBAAkB,GACxD,MAAM,CAER"}

package/dist/core/entities/log-object.js

@@ -0,0 +1,9 @@
+/**
+ * Object layout `{prefix}/{workspace}/{job}/{step}/{attempt}` so retention and workspace
+ * deletion are prefix operations. `prefix` is the configurable bucket prefix
+ * (`LOG_STORAGE_S3_PREFIX`, default `logs`), so one bucket can host several modules.
+ */ export function logObjectKey(prefix, { workspaceId, jobId, stepId, attempt }) {
+    return `${prefix}/${workspaceId}/${jobId}/${stepId}/${attempt}`;
+}
+
+//# sourceMappingURL=log-object.js.map

package/dist/core/entities/log-object.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/entities/log-object.ts"],"sourcesContent":["export interface LogObjectKeyParams {\n  workspaceId: string;\n  jobId: string;\n  stepId: string;\n  attempt: number;\n}\n\n/**\n * Object layout `{prefix}/{workspace}/{job}/{step}/{attempt}` so retention and workspace\n * deletion are prefix operations. `prefix` is the configurable bucket prefix\n * (`LOG_STORAGE_S3_PREFIX`, default `logs`), so one bucket can host several modules.\n */\nexport function logObjectKey(\n  prefix: string,\n  {workspaceId, jobId, stepId, attempt}: LogObjectKeyParams,\n): string {\n  return `${prefix}/${workspaceId}/${jobId}/${stepId}/${attempt}`;\n}\n"],"names":["logObjectKey","prefix","workspaceId","jobId","stepId","attempt"],"mappings":"AAOA;;;;CAIC,GACD,OAAO,SAASA,aACdC,MAAc,EACd,EAACC,WAAW,EAAEC,KAAK,EAAEC,MAAM,EAAEC,OAAO,EAAqB;IAEzD,OAAO,GAAGJ,OAAO,CAAC,EAAEC,YAAY,CAAC,EAAEC,MAAM,CAAC,EAAEC,OAAO,CAAC,EAAEC,SAAS;AACjE"}

package/dist/core/errors.d.ts

@@ -0,0 +1,26 @@
+/** The append offset is ahead of the committed length: the runner must rewind its spool cursor. */
+export declare class OffsetGapError extends Error {
+    readonly committedLength: number;
+    constructor(committedLength: number);
+}
+/**
+ * The append body is not whole, newline-terminated records of the raw log
+ * record contract. `forgedType` is set only for the detectable forgery case — a
+ * line that is a valid server-only record (`capped`/`runner_lost`) under the read
+ * union but is not valid on the raw write path — so the append path can emit a narrowed audit warn
+ * without logging the payload.
+ */
+export declare class MalformedLogChunkError extends Error {
+    readonly forgedType?: string | undefined;
+    constructor(message: string, forgedType?: string | undefined);
+}
+/**
+ * The lease's `(workspaceId, projectId, workflowRunAttemptId)` does not match the values
+ * stamped on the existing stream row. Since these are functionally determined
+ * by `jobId` via workflows FKs, a mismatch implies a forged token or a
+ * cross-job lease confusion — never a legitimate request.
+ */
+export declare class LeaseStreamMismatchError extends Error {
+    constructor();
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"AAAA,mGAAmG;AACnG,qBAAa,cAAe,SAAQ,KAAK;aACX,eAAe,EAAE,MAAM;gBAAvB,eAAe,EAAE,MAAM;CAIpD;AAED;;;;;;GAMG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;aAG7B,UAAU,CAAC,EAAE,MAAM;gBADnC,OAAO,EAAE,MAAM,EACC,UAAU,CAAC,EAAE,MAAM,YAAA;CAKtC;AAED;;;;;GAKG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;;CAKlD"}

package/dist/core/errors.js

@@ -0,0 +1,31 @@
+/** The append offset is ahead of the committed length: the runner must rewind its spool cursor. */ export class OffsetGapError extends Error {
+    constructor(committedLength){
+        super(`Append offset is ahead of the committed length (${committedLength})`), this.committedLength = committedLength;
+        this.name = 'OffsetGapError';
+    }
+}
+/**
+ * The append body is not whole, newline-terminated records of the raw log
+ * record contract. `forgedType` is set only for the detectable forgery case — a
+ * line that is a valid server-only record (`capped`/`runner_lost`) under the read
+ * union but is not valid on the raw write path — so the append path can emit a narrowed audit warn
+ * without logging the payload.
+ */ export class MalformedLogChunkError extends Error {
+    constructor(message, forgedType){
+        super(message), this.forgedType = forgedType;
+        this.name = 'MalformedLogChunkError';
+    }
+}
+/**
+ * The lease's `(workspaceId, projectId, workflowRunAttemptId)` does not match the values
+ * stamped on the existing stream row. Since these are functionally determined
+ * by `jobId` via workflows FKs, a mismatch implies a forged token or a
+ * cross-job lease confusion — never a legitimate request.
+ */ export class LeaseStreamMismatchError extends Error {
+    constructor(){
+        super('Lease identity does not match the existing stream row');
+        this.name = 'LeaseStreamMismatchError';
+    }
+}
+
+//# sourceMappingURL=errors.js.map

package/dist/core/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/errors.ts"],"sourcesContent":["/** The append offset is ahead of the committed length: the runner must rewind its spool cursor. */\nexport class OffsetGapError extends Error {\n  constructor(public readonly committedLength: number) {\n    super(`Append offset is ahead of the committed length (${committedLength})`);\n    this.name = 'OffsetGapError';\n  }\n}\n\n/**\n * The append body is not whole, newline-terminated records of the raw log\n * record contract. `forgedType` is set only for the detectable forgery case — a\n * line that is a valid server-only record (`capped`/`runner_lost`) under the read\n * union but is not valid on the raw write path — so the append path can emit a narrowed audit warn\n * without logging the payload.\n */\nexport class MalformedLogChunkError extends Error {\n  constructor(\n    message: string,\n    public readonly forgedType?: string,\n  ) {\n    super(message);\n    this.name = 'MalformedLogChunkError';\n  }\n}\n\n/**\n * The lease's `(workspaceId, projectId, workflowRunAttemptId)` does not match the values\n * stamped on the existing stream row. Since these are functionally determined\n * by `jobId` via workflows FKs, a mismatch implies a forged token or a\n * cross-job lease confusion — never a legitimate request.\n */\nexport class LeaseStreamMismatchError extends Error {\n  constructor() {\n    super('Lease identity does not match the existing stream row');\n    this.name = 'LeaseStreamMismatchError';\n  }\n}\n"],"names":["OffsetGapError","Error","committedLength","name","MalformedLogChunkError","message","forgedType","LeaseStreamMismatchError"],"mappings":"AAAA,iGAAiG,GACjG,OAAO,MAAMA,uBAAuBC;IAClC,YAAY,AAAgBC,eAAuB,CAAE;QACnD,KAAK,CAAC,CAAC,gDAAgD,EAAEA,gBAAgB,CAAC,CAAC,QADjDA,kBAAAA;QAE1B,IAAI,CAACC,IAAI,GAAG;IACd;AACF;AAEA;;;;;;CAMC,GACD,OAAO,MAAMC,+BAA+BH;IAC1C,YACEI,OAAe,EACf,AAAgBC,UAAmB,CACnC;QACA,KAAK,CAACD,eAFUC,aAAAA;QAGhB,IAAI,CAACH,IAAI,GAAG;IACd;AACF;AAEA;;;;;CAKC,GACD,OAAO,MAAMI,iCAAiCN;IAC5C,aAAc;QACZ,KAAK,CAAC;QACN,IAAI,CAACE,IAAI,GAAG;IACd;AACF"}

package/dist/core/finalize-attempt-stream.d.ts

@@ -0,0 +1,22 @@
+import type { LogOutcomeDto } from '@shipfox/api-workflows-dto';
+import type { AttemptStream } from '#core/entities/attempt-stream.js';
+import { type AttemptStreamIdentity } from '#db/streams.js';
+export interface FinalizeAttemptLogStreamParams extends AttemptStreamIdentity {
+    logOutcome: LogOutcomeDto;
+}
+interface FinalizeMetrics {
+    recordAppendedCount: {
+        add: (value: number, attributes: {
+            kind: 'runner_lost';
+        }) => void;
+    };
+    streamClosedCount: {
+        add: (value: number, attributes: {
+            reason: 'declared' | 'timeout';
+        }) => void;
+    };
+}
+export declare function createFinalizeAttemptLogStream(metrics?: FinalizeMetrics): (params: FinalizeAttemptLogStreamParams) => Promise<AttemptStream>;
+export declare const finalizeAttemptLogStream: (params: FinalizeAttemptLogStreamParams) => Promise<AttemptStream>;
+export {};
+//# sourceMappingURL=finalize-attempt-stream.d.ts.map

package/dist/core/finalize-attempt-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize-attempt-stream.d.ts","sourceRoot":"","sources":["../../src/core/finalize-attempt-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAEpE,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,gBAAgB,CAAC;AAIxB,MAAM,WAAW,8BAA+B,SAAQ,qBAAqB;IAC3E,UAAU,EAAE,aAAa,CAAC;CAC3B;AAOD,UAAU,eAAe;IACvB,mBAAmB,EAAE;QAAC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE;YAAC,IAAI,EAAE,aAAa,CAAA;SAAC,KAAK,IAAI,CAAA;KAAC,CAAC;IACvF,iBAAiB,EAAE;QACjB,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE;YAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;SAAC,KAAK,IAAI,CAAC;KAC5E,CAAC;CACH;AAOD,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,eAAgC,IACxE,QAAQ,8BAA8B,KAAG,OAAO,CAAC,aAAa,CAAC,CAuB9E;AAED,eAAO,MAAM,wBAAwB,WAzBb,8BAA8B,KAAG,OAAO,CAAC,aAAa,CAyBN,CAAC"}

package/dist/core/finalize-attempt-stream.js

@@ -0,0 +1,48 @@
+import { db } from '#db/db.js';
+import { getAttemptStreamByIdInTransaction, getOrCreateAttemptStreamWithStatus } from '#db/streams.js';
+import { recordAppendedCount, streamClosedCount } from '#metrics/instance.js';
+import { closeStream } from './close-stream.js';
+const defaultMetrics = {
+    recordAppendedCount,
+    streamClosedCount
+};
+export function createFinalizeAttemptLogStream(metrics = defaultMetrics) {
+    return async (params)=>{
+        const result = await db().transaction(async (tx)=>{
+            const { stream } = await getOrCreateAttemptStreamWithStatus(tx, params);
+            if (stream.state === 'closed') return {
+                stream,
+                closedReason: null
+            };
+            const reason = params.logOutcome === 'abandoned' ? 'timeout' : 'declared';
+            const closed = await closeStream(tx, {
+                streamId: stream.id,
+                reason
+            });
+            if (closed) return {
+                stream: closed,
+                closedReason: reason
+            };
+            const current = await getAttemptStreamByIdInTransaction(tx, stream.id);
+            if (!current) throw new Error(`Log stream disappeared during finalization: ${stream.id}`);
+            return {
+                stream: current,
+                closedReason: null
+            };
+        });
+        if (result.closedReason) {
+            if (result.closedReason === 'timeout') {
+                metrics.recordAppendedCount.add(1, {
+                    kind: 'runner_lost'
+                });
+            }
+            metrics.streamClosedCount.add(1, {
+                reason: result.closedReason
+            });
+        }
+        return result.stream;
+    };
+}
+export const finalizeAttemptLogStream = createFinalizeAttemptLogStream();
+
+//# sourceMappingURL=finalize-attempt-stream.js.map

package/dist/core/finalize-attempt-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/finalize-attempt-stream.ts"],"sourcesContent":["import type {LogOutcomeDto} from '@shipfox/api-workflows-dto';\nimport type {AttemptStream} from '#core/entities/attempt-stream.js';\nimport {db} from '#db/db.js';\nimport {\n  type AttemptStreamIdentity,\n  getAttemptStreamByIdInTransaction,\n  getOrCreateAttemptStreamWithStatus,\n} from '#db/streams.js';\nimport {recordAppendedCount, streamClosedCount} from '#metrics/instance.js';\nimport {closeStream} from './close-stream.js';\n\nexport interface FinalizeAttemptLogStreamParams extends AttemptStreamIdentity {\n  logOutcome: LogOutcomeDto;\n}\n\ninterface FinalizeAttemptLogStreamResult {\n  stream: AttemptStream;\n  closedReason: 'declared' | 'timeout' | null;\n}\n\ninterface FinalizeMetrics {\n  recordAppendedCount: {add: (value: number, attributes: {kind: 'runner_lost'}) => void};\n  streamClosedCount: {\n    add: (value: number, attributes: {reason: 'declared' | 'timeout'}) => void;\n  };\n}\n\nconst defaultMetrics: FinalizeMetrics = {\n  recordAppendedCount,\n  streamClosedCount,\n};\n\nexport function createFinalizeAttemptLogStream(metrics: FinalizeMetrics = defaultMetrics) {\n  return async (params: FinalizeAttemptLogStreamParams): Promise<AttemptStream> => {\n    const result: FinalizeAttemptLogStreamResult = await db().transaction(async (tx) => {\n      const {stream} = await getOrCreateAttemptStreamWithStatus(tx, params);\n      if (stream.state === 'closed') return {stream, closedReason: null};\n\n      const reason = params.logOutcome === 'abandoned' ? 'timeout' : 'declared';\n      const closed = await closeStream(tx, {streamId: stream.id, reason});\n      if (closed) return {stream: closed, closedReason: reason};\n\n      const current = await getAttemptStreamByIdInTransaction(tx, stream.id);\n      if (!current) throw new Error(`Log stream disappeared during finalization: ${stream.id}`);\n      return {stream: current, closedReason: null};\n    });\n\n    if (result.closedReason) {\n      if (result.closedReason === 'timeout') {\n        metrics.recordAppendedCount.add(1, {kind: 'runner_lost'});\n      }\n      metrics.streamClosedCount.add(1, {reason: result.closedReason});\n    }\n\n    return result.stream;\n  };\n}\n\nexport const finalizeAttemptLogStream = createFinalizeAttemptLogStream();\n"],"names":["db","getAttemptStreamByIdInTransaction","getOrCreateAttemptStreamWithStatus","recordAppendedCount","streamClosedCount","closeStream","defaultMetrics","createFinalizeAttemptLogStream","metrics","params","result","transaction","tx","stream","state","closedReason","reason","logOutcome","closed","streamId","id","current","Error","add","kind","finalizeAttemptLogStream"],"mappings":"AAEA,SAAQA,EAAE,QAAO,YAAY;AAC7B,SAEEC,iCAAiC,EACjCC,kCAAkC,QAC7B,iBAAiB;AACxB,SAAQC,mBAAmB,EAAEC,iBAAiB,QAAO,uBAAuB;AAC5E,SAAQC,WAAW,QAAO,oBAAoB;AAkB9C,MAAMC,iBAAkC;IACtCH;IACAC;AACF;AAEA,OAAO,SAASG,+BAA+BC,UAA2BF,cAAc;IACtF,OAAO,OAAOG;QACZ,MAAMC,SAAyC,MAAMV,KAAKW,WAAW,CAAC,OAAOC;YAC3E,MAAM,EAACC,MAAM,EAAC,GAAG,MAAMX,mCAAmCU,IAAIH;YAC9D,IAAII,OAAOC,KAAK,KAAK,UAAU,OAAO;gBAACD;gBAAQE,cAAc;YAAI;YAEjE,MAAMC,SAASP,OAAOQ,UAAU,KAAK,cAAc,YAAY;YAC/D,MAAMC,SAAS,MAAMb,YAAYO,IAAI;gBAACO,UAAUN,OAAOO,EAAE;gBAAEJ;YAAM;YACjE,IAAIE,QAAQ,OAAO;gBAACL,QAAQK;gBAAQH,cAAcC;YAAM;YAExD,MAAMK,UAAU,MAAMpB,kCAAkCW,IAAIC,OAAOO,EAAE;YACrE,IAAI,CAACC,SAAS,MAAM,IAAIC,MAAM,CAAC,4CAA4C,EAAET,OAAOO,EAAE,EAAE;YACxF,OAAO;gBAACP,QAAQQ;gBAASN,cAAc;YAAI;QAC7C;QAEA,IAAIL,OAAOK,YAAY,EAAE;YACvB,IAAIL,OAAOK,YAAY,KAAK,WAAW;gBACrCP,QAAQL,mBAAmB,CAACoB,GAAG,CAAC,GAAG;oBAACC,MAAM;gBAAa;YACzD;YACAhB,QAAQJ,iBAAiB,CAACmB,GAAG,CAAC,GAAG;gBAACP,QAAQN,OAAOK,YAAY;YAAA;QAC/D;QAEA,OAAOL,OAAOG,MAAM;IACtB;AACF;AAEA,OAAO,MAAMY,2BAA2BlB,iCAAiC"}

package/dist/core/read-logs.d.ts

@@ -0,0 +1,33 @@
+import type { AttemptStream, StreamState } from '#core/entities/attempt-stream.js';
+export interface InlineLogRead {
+    mode: 'inline';
+    ndjson: string;
+    nextCursor: number;
+    hasMore: boolean;
+    state: StreamState;
+    truncated: boolean;
+}
+export interface PresignedLogRead {
+    mode: 'presigned';
+    url: string;
+    state: 'closed';
+    expiresAt: Date;
+    totalBytes: number;
+    truncated: boolean;
+}
+export type LogReadResult = InlineLogRead | PresignedLogRead;
+/**
+ * Compaction-boundary guard: a stream can be loaded with no `objectKey`, then compaction
+ * publishes the key and deletes the chunks before the chunk read runs, which would yield a
+ * spurious empty inline frame on a closed stream. On that exact shape (closed stream, empty
+ * page) the row is re-read once; if it has since compacted, the presigned object is served
+ * instead.
+ *
+ * The re-read is scoped to a closed snapshot on purpose. An open stream returns empty pages
+ * on every idle tail poll, so re-reading each would add a row read to the hot path; and an
+ * open snapshot cannot have compacted (compaction runs only after close, seconds later via
+ * Temporal), so the open-empty-compacted window is too small to hit. If it ever did, the
+ * client's next poll reloads the now-compacted row and self-corrects.
+ */
+export declare function buildLogReadResult(stream: AttemptStream, cursor: number): Promise<LogReadResult>;
+//# sourceMappingURL=read-logs.d.ts.map

package/dist/core/read-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-logs.d.ts","sourceRoot":"","sources":["../../src/core/read-logs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,EAAE,WAAW,EAAC,MAAM,kCAAkC,CAAC;AAIjF,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,QAAQ,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,gBAAgB,CAAC;AAc7D;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,aAAa,CAAC,CAsBxB"}

package/dist/core/read-logs.js

@@ -0,0 +1,49 @@
+import { presignedGetUrl } from '#api/object-storage.js';
+import { config } from '#config.js';
+import { readChunkPageBySeq } from '#db/chunks.js';
+import { getAttemptStreamById } from '#db/streams.js';
+async function presignedRead(stream, objectKey) {
+    const { url, expiresAt } = await presignedGetUrl(objectKey);
+    return {
+        mode: 'presigned',
+        url,
+        state: 'closed',
+        expiresAt,
+        totalBytes: stream.committedLength,
+        truncated: stream.truncated
+    };
+}
+/**
+ * Compaction-boundary guard: a stream can be loaded with no `objectKey`, then compaction
+ * publishes the key and deletes the chunks before the chunk read runs, which would yield a
+ * spurious empty inline frame on a closed stream. On that exact shape (closed stream, empty
+ * page) the row is re-read once; if it has since compacted, the presigned object is served
+ * instead.
+ *
+ * The re-read is scoped to a closed snapshot on purpose. An open stream returns empty pages
+ * on every idle tail poll, so re-reading each would add a row read to the hot path; and an
+ * open snapshot cannot have compacted (compaction runs only after close, seconds later via
+ * Temporal), so the open-empty-compacted window is too small to hit. If it ever did, the
+ * client's next poll reloads the now-compacted row and self-corrects.
+ */ export async function buildLogReadResult(stream, cursor) {
+    if (stream.objectKey) return presignedRead(stream, stream.objectKey);
+    const page = await readChunkPageBySeq({
+        streamId: stream.id,
+        afterSeq: cursor,
+        maxBytes: config.LOG_READ_INLINE_MAX_BYTES
+    });
+    if (page.data.length === 0 && stream.state === 'closed') {
+        const refreshed = await getAttemptStreamById(stream.id);
+        if (refreshed?.objectKey) return presignedRead(refreshed, refreshed.objectKey);
+    }
+    return {
+        mode: 'inline',
+        ndjson: page.data.toString('utf8'),
+        nextCursor: page.nextSeq,
+        hasMore: page.hasMore,
+        state: stream.state,
+        truncated: stream.truncated
+    };
+}
+
+//# sourceMappingURL=read-logs.js.map

package/dist/core/read-logs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/read-logs.ts"],"sourcesContent":["import {presignedGetUrl} from '#api/object-storage.js';\nimport {config} from '#config.js';\nimport type {AttemptStream, StreamState} from '#core/entities/attempt-stream.js';\nimport {readChunkPageBySeq} from '#db/chunks.js';\nimport {getAttemptStreamById} from '#db/streams.js';\n\nexport interface InlineLogRead {\n  mode: 'inline';\n  ndjson: string;\n  nextCursor: number;\n  hasMore: boolean;\n  state: StreamState;\n  truncated: boolean;\n}\n\nexport interface PresignedLogRead {\n  mode: 'presigned';\n  url: string;\n  state: 'closed';\n  expiresAt: Date;\n  totalBytes: number;\n  truncated: boolean;\n}\n\nexport type LogReadResult = InlineLogRead | PresignedLogRead;\n\nasync function presignedRead(stream: AttemptStream, objectKey: string): Promise<PresignedLogRead> {\n  const {url, expiresAt} = await presignedGetUrl(objectKey);\n  return {\n    mode: 'presigned',\n    url,\n    state: 'closed',\n    expiresAt,\n    totalBytes: stream.committedLength,\n    truncated: stream.truncated,\n  };\n}\n\n/**\n * Compaction-boundary guard: a stream can be loaded with no `objectKey`, then compaction\n * publishes the key and deletes the chunks before the chunk read runs, which would yield a\n * spurious empty inline frame on a closed stream. On that exact shape (closed stream, empty\n * page) the row is re-read once; if it has since compacted, the presigned object is served\n * instead.\n *\n * The re-read is scoped to a closed snapshot on purpose. An open stream returns empty pages\n * on every idle tail poll, so re-reading each would add a row read to the hot path; and an\n * open snapshot cannot have compacted (compaction runs only after close, seconds later via\n * Temporal), so the open-empty-compacted window is too small to hit. If it ever did, the\n * client's next poll reloads the now-compacted row and self-corrects.\n */\nexport async function buildLogReadResult(\n  stream: AttemptStream,\n  cursor: number,\n): Promise<LogReadResult> {\n  if (stream.objectKey) return presignedRead(stream, stream.objectKey);\n\n  const page = await readChunkPageBySeq({\n    streamId: stream.id,\n    afterSeq: cursor,\n    maxBytes: config.LOG_READ_INLINE_MAX_BYTES,\n  });\n\n  if (page.data.length === 0 && stream.state === 'closed') {\n    const refreshed = await getAttemptStreamById(stream.id);\n    if (refreshed?.objectKey) return presignedRead(refreshed, refreshed.objectKey);\n  }\n\n  return {\n    mode: 'inline',\n    ndjson: page.data.toString('utf8'),\n    nextCursor: page.nextSeq,\n    hasMore: page.hasMore,\n    state: stream.state,\n    truncated: stream.truncated,\n  };\n}\n"],"names":["presignedGetUrl","config","readChunkPageBySeq","getAttemptStreamById","presignedRead","stream","objectKey","url","expiresAt","mode","state","totalBytes","committedLength","truncated","buildLogReadResult","cursor","page","streamId","id","afterSeq","maxBytes","LOG_READ_INLINE_MAX_BYTES","data","length","refreshed","ndjson","toString","nextCursor","nextSeq","hasMore"],"mappings":"AAAA,SAAQA,eAAe,QAAO,yBAAyB;AACvD,SAAQC,MAAM,QAAO,aAAa;AAElC,SAAQC,kBAAkB,QAAO,gBAAgB;AACjD,SAAQC,oBAAoB,QAAO,iBAAiB;AAsBpD,eAAeC,cAAcC,MAAqB,EAAEC,SAAiB;IACnE,MAAM,EAACC,GAAG,EAAEC,SAAS,EAAC,GAAG,MAAMR,gBAAgBM;IAC/C,OAAO;QACLG,MAAM;QACNF;QACAG,OAAO;QACPF;QACAG,YAAYN,OAAOO,eAAe;QAClCC,WAAWR,OAAOQ,SAAS;IAC7B;AACF;AAEA;;;;;;;;;;;;CAYC,GACD,OAAO,eAAeC,mBACpBT,MAAqB,EACrBU,MAAc;IAEd,IAAIV,OAAOC,SAAS,EAAE,OAAOF,cAAcC,QAAQA,OAAOC,SAAS;IAEnE,MAAMU,OAAO,MAAMd,mBAAmB;QACpCe,UAAUZ,OAAOa,EAAE;QACnBC,UAAUJ;QACVK,UAAUnB,OAAOoB,yBAAyB;IAC5C;IAEA,IAAIL,KAAKM,IAAI,CAACC,MAAM,KAAK,KAAKlB,OAAOK,KAAK,KAAK,UAAU;QACvD,MAAMc,YAAY,MAAMrB,qBAAqBE,OAAOa,EAAE;QACtD,IAAIM,WAAWlB,WAAW,OAAOF,cAAcoB,WAAWA,UAAUlB,SAAS;IAC/E;IAEA,OAAO;QACLG,MAAM;QACNgB,QAAQT,KAAKM,IAAI,CAACI,QAAQ,CAAC;QAC3BC,YAAYX,KAAKY,OAAO;QACxBC,SAASb,KAAKa,OAAO;QACrBnB,OAAOL,OAAOK,KAAK;QACnBG,WAAWR,OAAOQ,SAAS;IAC7B;AACF"}

package/dist/core/reap-stale-open-streams.d.ts

@@ -0,0 +1,27 @@
+export interface ReapStaleOpenStreamsResult {
+    /** Streams force-closed by this run. */
+    reaped: number;
+    /** Streams whose guarded close threw; logged, skipped, retried next run. */
+    failed: number;
+}
+export interface ReapStaleOpenStreamsParams {
+    /**
+     * A stream open longer than this since `created_at` can no longer be appended to: its job
+     * holds one lease minted at-or-before the stream's creation, so once the lease TTL has
+     * elapsed no append can land and the close is safe. Set above `AUTH_JOB_LEASE_TOKEN_EXPIRES_IN`.
+     */
+    olderThanSeconds: number;
+    batchLimit: number;
+}
+/**
+ * Force-closes open streams the one-shot job-terminal sweep missed: a stream whose first append
+ * landed after that sweep's snapshot would otherwise stay `open` forever, invisible to
+ * compaction and retention (both partial on `state = 'closed'`). Reusing the guarded
+ * `closeStream` re-drives each into the normal closed -> compact -> retention lifecycle.
+ *
+ * Each row closes in its own transaction, so a tick/retry overlap is idempotent (the guarded
+ * `markStreamClosed` lets only one close win) and one failed row is logged and skipped instead
+ * of aborting the batch.
+ */
+export declare function reapStaleOpenStreams(params: ReapStaleOpenStreamsParams): Promise<ReapStaleOpenStreamsResult>;
+//# sourceMappingURL=reap-stale-open-streams.d.ts.map

package/dist/core/reap-stale-open-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reap-stale-open-streams.d.ts","sourceRoot":"","sources":["../../src/core/reap-stale-open-streams.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,0BAA0B;IACzC,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,0BAA0B,CAAC,CAwBrC"}