@shipfox/api-logs 2.0.0

package/dist/db/schema/chunks.js

@@ -0,0 +1,47 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { bigint, bigserial, index, integer, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { attemptStreams } from './attempt-streams.js';
+import { bytea, pgTable } from './common.js';
+/**
+ * Hot, append-only log bytes for open streams, pending compaction.
+ *
+ * Two byte axes meet here and MUST stay distinct:
+ *
+ *   Runner spool (CAS axis)          Stored chunk stream (read axis, by seq)
+ *   offset 0 ┌────────────┐  ───►  seq 1 │ normalized chunk A │ origin=runner
+ *      100   ├─ chunk A ──┤  ───►  seq 2 │ normalized chunk B │ origin=runner
+ *      250   ├─ chunk B ──┤  ───►  seq 3 │ {capped}           │ origin=control ← server-injected;
+ *            └────────────┘                                      does NOT advance committed_length
+ *
+ * `origin` is `runner` for bytes accepted from a runner append after ingest normalization, and
+ * `control` for a server-injected tombstone. `stream_offset` is the runner-axis position of a
+ * runner chunk; for a server `control` chunk it is informational. `seq` (insertion order) is the
+ * read axis the reader walks, so server records interleave correctly with normalized runner
+ * records.
+ */ export const logChunks = pgTable('chunks', {
+    id: uuidv7PrimaryKey(),
+    streamId: uuid('stream_id').notNull().references(()=>attemptStreams.id, {
+        onDelete: 'cascade'
+    }),
+    seq: bigserial('seq', {
+        mode: 'number'
+    }).notNull(),
+    streamOffset: bigint('stream_offset', {
+        mode: 'number'
+    }).notNull(),
+    byteLen: integer('byte_len').notNull(),
+    data: bytea('data').notNull(),
+    origin: text('origin', {
+        enum: [
+            'runner',
+            'control'
+        ]
+    }).notNull(),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        index('logs_chunks_stream_seq_idx').on(table.streamId, table.seq)
+    ]);
+
+//# sourceMappingURL=chunks.js.map

package/dist/db/schema/chunks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/chunks.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {bigint, bigserial, index, integer, text, timestamp, uuid} from 'drizzle-orm/pg-core';\nimport {attemptStreams} from './attempt-streams.js';\nimport {bytea, pgTable} from './common.js';\n\n/**\n * Hot, append-only log bytes for open streams, pending compaction.\n *\n * Two byte axes meet here and MUST stay distinct:\n *\n *   Runner spool (CAS axis)          Stored chunk stream (read axis, by seq)\n *   offset 0 ┌────────────┐  ───►  seq 1 │ normalized chunk A │ origin=runner\n *      100   ├─ chunk A ──┤  ───►  seq 2 │ normalized chunk B │ origin=runner\n *      250   ├─ chunk B ──┤  ───►  seq 3 │ {capped}           │ origin=control ← server-injected;\n *            └────────────┘                                      does NOT advance committed_length\n *\n * `origin` is `runner` for bytes accepted from a runner append after ingest normalization, and\n * `control` for a server-injected tombstone. `stream_offset` is the runner-axis position of a\n * runner chunk; for a server `control` chunk it is informational. `seq` (insertion order) is the\n * read axis the reader walks, so server records interleave correctly with normalized runner\n * records.\n */\nexport const logChunks = pgTable(\n  'chunks',\n  {\n    id: uuidv7PrimaryKey(),\n    streamId: uuid('stream_id')\n      .notNull()\n      .references(() => attemptStreams.id, {onDelete: 'cascade'}),\n    seq: bigserial('seq', {mode: 'number'}).notNull(),\n    streamOffset: bigint('stream_offset', {mode: 'number'}).notNull(),\n    byteLen: integer('byte_len').notNull(),\n    data: bytea('data').notNull(),\n    origin: text('origin', {enum: ['runner', 'control']}).notNull(),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [index('logs_chunks_stream_seq_idx').on(table.streamId, table.seq)],\n);\n\nexport type LogChunkDb = typeof logChunks.$inferSelect;\nexport type LogChunkInsertDb = typeof logChunks.$inferInsert;\n\nexport type ChunkOrigin = 'runner' | 'control';\n"],"names":["uuidv7PrimaryKey","bigint","bigserial","index","integer","text","timestamp","uuid","attemptStreams","bytea","pgTable","logChunks","id","streamId","notNull","references","onDelete","seq","mode","streamOffset","byteLen","data","origin","enum","createdAt","withTimezone","defaultNow","table","on"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,MAAM,EAAEC,SAAS,EAAEC,KAAK,EAAEC,OAAO,EAAEC,IAAI,EAAEC,SAAS,EAAEC,IAAI,QAAO,sBAAsB;AAC7F,SAAQC,cAAc,QAAO,uBAAuB;AACpD,SAAQC,KAAK,EAAEC,OAAO,QAAO,cAAc;AAE3C;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAMC,YAAYD,QACvB,UACA;IACEE,IAAIZ;IACJa,UAAUN,KAAK,aACZO,OAAO,GACPC,UAAU,CAAC,IAAMP,eAAeI,EAAE,EAAE;QAACI,UAAU;IAAS;IAC3DC,KAAKf,UAAU,OAAO;QAACgB,MAAM;IAAQ,GAAGJ,OAAO;IAC/CK,cAAclB,OAAO,iBAAiB;QAACiB,MAAM;IAAQ,GAAGJ,OAAO;IAC/DM,SAAShB,QAAQ,YAAYU,OAAO;IACpCO,MAAMZ,MAAM,QAAQK,OAAO;IAC3BQ,QAAQjB,KAAK,UAAU;QAACkB,MAAM;YAAC;YAAU;SAAU;IAAA,GAAGT,OAAO;IAC7DU,WAAWlB,UAAU,cAAc;QAACmB,cAAc;IAAI,GAAGX,OAAO,GAAGY,UAAU;AAC/E,GACA,CAACC,QAAU;QAACxB,MAAM,8BAA8ByB,EAAE,CAACD,MAAMd,QAAQ,EAAEc,MAAMV,GAAG;KAAE,EAC9E"}

package/dist/db/schema/common.d.ts

@@ -0,0 +1,29 @@
+import type { Buffer } from 'node:buffer';
+export declare const pgTable: import("drizzle-orm/pg-core").PgTableFn<undefined>;
+export declare const bytea: {
+    (): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Buffer<ArrayBufferLike>;
+        driverParam: Buffer<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Buffer<ArrayBufferLike>;
+        driverParam: Buffer<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig?: unknown): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: TName;
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Buffer<ArrayBufferLike>;
+        driverParam: Buffer<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+};
+//# sourceMappingURL=common.d.ts.map

package/dist/db/schema/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/db/schema/common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGxC,eAAO,MAAM,OAAO,oDAA2C,CAAC;AAIhE,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAC"}

package/dist/db/schema/common.js

@@ -0,0 +1,11 @@
+import { customType, pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>`logs_${name}`);
+// drizzle-orm 0.45 has no native bytea column; the node-postgres driver returns
+// and accepts Buffer for bytea, so a customType is the supported path.
+export const bytea = customType({
+    dataType () {
+        return 'bytea';
+    }
+});
+
+//# sourceMappingURL=common.js.map

package/dist/db/schema/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/common.ts"],"sourcesContent":["import type {Buffer} from 'node:buffer';\nimport {customType, pgTableCreator} from 'drizzle-orm/pg-core';\n\nexport const pgTable = pgTableCreator((name) => `logs_${name}`);\n\n// drizzle-orm 0.45 has no native bytea column; the node-postgres driver returns\n// and accepts Buffer for bytea, so a customType is the supported path.\nexport const bytea = customType<{data: Buffer; driverData: Buffer}>({\n  dataType() {\n    return 'bytea';\n  },\n});\n"],"names":["customType","pgTableCreator","pgTable","name","bytea","dataType"],"mappings":"AACA,SAAQA,UAAU,EAAEC,cAAc,QAAO,sBAAsB;AAE/D,OAAO,MAAMC,UAAUD,eAAe,CAACE,OAAS,CAAC,KAAK,EAAEA,MAAM,EAAE;AAEhE,gFAAgF;AAChF,uEAAuE;AACvE,OAAO,MAAMC,QAAQJ,WAA+C;IAClEK;QACE,OAAO;IACT;AACF,GAAG"}

package/dist/db/schema/job-accounting.d.ts

@@ -0,0 +1,143 @@
+import type { JobAccounting } from '#core/entities/job-accounting.js';
+/**
+ * Accrual-budget state per job run, keyed by the job id carried in the lease.
+ * `stored_bytes_used` counts the normalized NDJSON bytes the server has stored for the job
+ * (envelope and control records included), so the budget bounds exactly what lands in Postgres.
+ * `started_at` is the budget clock origin (first append).
+ * `capped_at`, once set, makes every later append a no-op drop.
+ *
+ * Per-row `stored_bytes_used` is bounded by the per-job budget, so `mode:
+ * 'number'` is safe on the hot path. Any cross-row aggregate (workspace or
+ * system-wide totals) MUST read as bigint at the query site — the global sum
+ * is unbounded and would silently lose precision past 2^53 as a JS number.
+ */
+export declare const jobAccounting: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "job_accounting";
+    schema: undefined;
+    columns: {
+        jobId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_id";
+            tableName: "job_accounting";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "job_accounting";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        storedBytesUsed: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stored_bytes_used";
+            tableName: "job_accounting";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "job_accounting";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        cappedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "capped_at";
+            tableName: "job_accounting";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "job_accounting";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "job_accounting";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type JobAccountingDb = typeof jobAccounting.$inferSelect;
+export type JobAccountingInsertDb = typeof jobAccounting.$inferInsert;
+export declare function toJobAccounting(row: JobAccountingDb): JobAccounting;
+//# sourceMappingURL=job-accounting.d.ts.map

package/dist/db/schema/job-accounting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-accounting.d.ts","sourceRoot":"","sources":["../../../src/db/schema/job-accounting.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAGpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQxB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AAEtE,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,CAQnE"}

package/dist/db/schema/job-accounting.js

@@ -0,0 +1,43 @@
+import { bigint, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+/**
+ * Accrual-budget state per job run, keyed by the job id carried in the lease.
+ * `stored_bytes_used` counts the normalized NDJSON bytes the server has stored for the job
+ * (envelope and control records included), so the budget bounds exactly what lands in Postgres.
+ * `started_at` is the budget clock origin (first append).
+ * `capped_at`, once set, makes every later append a no-op drop.
+ *
+ * Per-row `stored_bytes_used` is bounded by the per-job budget, so `mode:
+ * 'number'` is safe on the hot path. Any cross-row aggregate (workspace or
+ * system-wide totals) MUST read as bigint at the query site — the global sum
+ * is unbounded and would silently lose precision past 2^53 as a JS number.
+ */ export const jobAccounting = pgTable('job_accounting', {
+    jobId: uuid('job_id').primaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    storedBytesUsed: bigint('stored_bytes_used', {
+        mode: 'number'
+    }).notNull().default(0),
+    startedAt: timestamp('started_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    cappedAt: timestamp('capped_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+});
+export function toJobAccounting(row) {
+    return {
+        jobId: row.jobId,
+        workspaceId: row.workspaceId,
+        storedBytesUsed: row.storedBytesUsed,
+        startedAt: row.startedAt,
+        cappedAt: row.cappedAt
+    };
+}
+
+//# sourceMappingURL=job-accounting.js.map

package/dist/db/schema/job-accounting.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/job-accounting.ts"],"sourcesContent":["import {bigint, timestamp, uuid} from 'drizzle-orm/pg-core';\nimport type {JobAccounting} from '#core/entities/job-accounting.js';\nimport {pgTable} from './common.js';\n\n/**\n * Accrual-budget state per job run, keyed by the job id carried in the lease.\n * `stored_bytes_used` counts the normalized NDJSON bytes the server has stored for the job\n * (envelope and control records included), so the budget bounds exactly what lands in Postgres.\n * `started_at` is the budget clock origin (first append).\n * `capped_at`, once set, makes every later append a no-op drop.\n *\n * Per-row `stored_bytes_used` is bounded by the per-job budget, so `mode:\n * 'number'` is safe on the hot path. Any cross-row aggregate (workspace or\n * system-wide totals) MUST read as bigint at the query site — the global sum\n * is unbounded and would silently lose precision past 2^53 as a JS number.\n */\nexport const jobAccounting = pgTable('job_accounting', {\n  jobId: uuid('job_id').primaryKey(),\n  workspaceId: uuid('workspace_id').notNull(),\n  storedBytesUsed: bigint('stored_bytes_used', {mode: 'number'}).notNull().default(0),\n  startedAt: timestamp('started_at', {withTimezone: true}).notNull().defaultNow(),\n  cappedAt: timestamp('capped_at', {withTimezone: true}),\n  createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n});\n\nexport type JobAccountingDb = typeof jobAccounting.$inferSelect;\nexport type JobAccountingInsertDb = typeof jobAccounting.$inferInsert;\n\nexport function toJobAccounting(row: JobAccountingDb): JobAccounting {\n  return {\n    jobId: row.jobId,\n    workspaceId: row.workspaceId,\n    storedBytesUsed: row.storedBytesUsed,\n    startedAt: row.startedAt,\n    cappedAt: row.cappedAt,\n  };\n}\n"],"names":["bigint","timestamp","uuid","pgTable","jobAccounting","jobId","primaryKey","workspaceId","notNull","storedBytesUsed","mode","default","startedAt","withTimezone","defaultNow","cappedAt","createdAt","updatedAt","toJobAccounting","row"],"mappings":"AAAA,SAAQA,MAAM,EAAEC,SAAS,EAAEC,IAAI,QAAO,sBAAsB;AAE5D,SAAQC,OAAO,QAAO,cAAc;AAEpC;;;;;;;;;;;CAWC,GACD,OAAO,MAAMC,gBAAgBD,QAAQ,kBAAkB;IACrDE,OAAOH,KAAK,UAAUI,UAAU;IAChCC,aAAaL,KAAK,gBAAgBM,OAAO;IACzCC,iBAAiBT,OAAO,qBAAqB;QAACU,MAAM;IAAQ,GAAGF,OAAO,GAAGG,OAAO,CAAC;IACjFC,WAAWX,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO,GAAGM,UAAU;IAC7EC,UAAUd,UAAU,aAAa;QAACY,cAAc;IAAI;IACpDG,WAAWf,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO,GAAGM,UAAU;IAC7EG,WAAWhB,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO,GAAGM,UAAU;AAC/E,GAAG;AAKH,OAAO,SAASI,gBAAgBC,GAAoB;IAClD,OAAO;QACLd,OAAOc,IAAId,KAAK;QAChBE,aAAaY,IAAIZ,WAAW;QAC5BE,iBAAiBU,IAAIV,eAAe;QACpCG,WAAWO,IAAIP,SAAS;QACxBG,UAAUI,IAAIJ,QAAQ;IACxB;AACF"}

package/dist/db/schema/outbox.d.ts

@@ -0,0 +1,195 @@
+export declare const logsOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "outbox";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_type";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        orderingKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ordering_key";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dispatchedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatched_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dispatchAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatch_attempts";
+            tableName: "outbox";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextDispatchAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_dispatch_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_error";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchFailedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_failed_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deadLetteredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dead_lettered_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=outbox.d.ts.map

package/dist/db/schema/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../../src/db/schema/outbox.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAC"}

package/dist/db/schema/outbox.js

@@ -0,0 +1,5 @@
+import { createOutboxTable } from '@shipfox/node-outbox';
+import { pgTable } from './common.js';
+export const logsOutbox = createOutboxTable(pgTable);
+
+//# sourceMappingURL=outbox.js.map

package/dist/db/schema/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/outbox.ts"],"sourcesContent":["import {createOutboxTable} from '@shipfox/node-outbox';\nimport {pgTable} from './common.js';\n\nexport const logsOutbox = createOutboxTable(pgTable);\n"],"names":["createOutboxTable","pgTable","logsOutbox"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,uBAAuB;AACvD,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,aAAaF,kBAAkBC,SAAS"}

package/dist/db/streams.d.ts

@@ -0,0 +1,141 @@
+import type { AttemptStream, StreamCloseReason } from '#core/entities/attempt-stream.js';
+import { type Transaction } from './db.js';
+export interface AttemptStreamIdentity {
+    jobId: string;
+    stepId: string;
+    attempt: number;
+    workspaceId: string;
+    projectId: string;
+    workflowRunAttemptId: string;
+}
+export interface AttemptStreamLookup {
+    jobId: string;
+    stepId: string;
+    attempt: number;
+}
+/**
+ * Reads the stream for `(job, step, attempt)` without creating it. Used by the
+ * empty-body heartbeat path so a runner cannot mint rows with empty appends.
+ */
+export declare function getAttemptStream(tx: Transaction, lookup: AttemptStreamLookup): Promise<AttemptStream | null>;
+/**
+ * Reads the stream for `(step, attempt)` for the session read path, which holds no lease
+ * and so has no `jobId`. `stepId` is a globally unique uuidv7, so `(stepId, attempt)`
+ * selects at most one row even though stream identity is `(jobId, stepId, attempt)`. The
+ * caller authorizes against the row's denormalized `workspaceId`.
+ */
+export declare function getStreamByStepAttempt(lookup: {
+    stepId: string;
+    attempt: number;
+}): Promise<AttemptStream | null>;
+export interface GetOrCreateAttemptStreamResult {
+    stream: AttemptStream;
+    created: boolean;
+}
+/**
+ * Loads the stream for `(job, step, attempt)`, creating it on first append.
+ * Scoped by `jobId` from the lease, so a lease never reaches another job's stream.
+ * The create path reports whether the row was inserted so callers can record
+ * first-open side effects only after their enclosing transaction commits.
+ */
+export declare function getOrCreateAttemptStreamWithStatus(tx: Transaction, identity: AttemptStreamIdentity): Promise<GetOrCreateAttemptStreamResult>;
+export declare function getOrCreateAttemptStream(tx: Transaction, identity: AttemptStreamIdentity): Promise<AttemptStream>;
+export type CasOutcome = 'extended' | 'retry' | 'gap';
+export interface CasResult {
+    outcome: CasOutcome;
+    committedLength: number;
+}
+/**
+ * Offset-CAS extend: advances `committed_length` by `byteLen` iff it currently
+ * equals `offset`. On mismatch, re-reads the committed length and classifies the
+ * caller's chunk: a retry (fully already applied) only when `offset + byteLen`
+ * does not run past the committed length; otherwise a gap. A chunk that straddles
+ * the committed point (offset behind it, but extending past it) is a gap too, so
+ * the runner rewinds rather than getting a 200 that silently drops its tail.
+ */
+export declare function casExtendCommittedLength(tx: Transaction, params: {
+    streamId: string;
+    offset: number;
+    byteLen: number;
+}): Promise<CasResult>;
+export declare function setDeclaredTotalBytes(tx: Transaction, params: {
+    streamId: string;
+    declaredTotalBytes: number;
+}): Promise<void>;
+/**
+ * Guarded close: flips `open → closed` and stamps `closed_at` iff the stream is
+ * still open, returning the closed row (or null when another path already closed
+ * it). The `WHERE state='open'` predicate is both the row lock and the
+ * exactly-once gate. `committed_length` is left untouched; it stays equal to the
+ * runner spool bytes. `truncated` is set only on the timeout path.
+ */
+export declare function markStreamClosed(tx: Transaction, params: {
+    streamId: string;
+    reason: StreamCloseReason;
+    markTruncated: boolean;
+}): Promise<AttemptStream | null>;
+/** Open streams of a job, for the timeout sweep to force-close after the grace period. */
+export declare function listOpenStreamsByJob(jobId: string): Promise<AttemptStream[]>;
+/** For compaction, which is driven by the closed event that carries the stream id. */
+export declare function getAttemptStreamById(streamId: string): Promise<AttemptStream | null>;
+export declare function getAttemptStreamByIdInTransaction(tx: Transaction, streamId: string): Promise<AttemptStream | null>;
+/**
+ * Final compaction step: records the object key and deletes the now-cold chunk rows in one
+ * transaction. The guard is `state='closed' AND object_key IS NULL`, so the publish is a
+ * single winner even when two compaction attempts (e.g. a heartbeat-timed-out run and its
+ * retry) race: each uploads to its own key, and only the first to land here writes a key and
+ * drops the chunks. A 0-row result means the row was either hard-deleted by retention or
+ * already published by another attempt; the caller re-reads to tell those apart and deletes
+ * its own now-orphaned upload either way. Returns whether this attempt won the publish.
+ */
+export declare function setObjectKeyAndDeleteChunks(tx: Transaction, params: {
+    streamId: string;
+    objectKey: string;
+}): Promise<{
+    updated: boolean;
+}>;
+/**
+ * Closed streams that never got an object key and have sat that way past the stale
+ * window: the reconcile cron re-drives compaction for these. Hits the partial index
+ * `logs_attempt_streams_uncompacted_idx`; ordered by `closed_at` so the oldest backlog
+ * drains first, bounded by `limit` per tick.
+ */
+export declare function listStaleUncompactedStreams(params: {
+    olderThanSeconds: number;
+    limit: number;
+}): Promise<AttemptStream[]>;
+/**
+ * Lists open streams old enough to force-close. The age check is safe only when
+ * `olderThanSeconds` exceeds the lease TTL: leases are minted before a stream can
+ * be created, so no valid append can arrive after `created_at + leaseTTL`.
+ */
+export declare function listStaleOpenStreams(params: {
+    olderThanSeconds: number;
+    limit: number;
+}): Promise<AttemptStream[]>;
+export declare function getOpenStreamCount(): Promise<bigint>;
+/**
+ * Lists expired closed streams for retention. `excludeIds` keeps failed or raced rows from
+ * starving younger rows in the same run, and avoids cursoring on `closed_at`, whose microsecond
+ * precision would be lost through JS `Date`.
+ *
+ * No `object_key` filter: retention deletes compacted and never-compacted streams alike.
+ */
+export declare function listExpiredClosedStreams(params: {
+    retentionDays: number;
+    limit: number;
+    excludeIds?: string[] | undefined;
+}): Promise<AttemptStream[]>;
+/**
+ * Hard-deletes one expired stream row, guarded on the observed `object_key` so a racing
+ * compaction publish leaves the row for the next sweep.
+ */
+export declare function deleteExpiredStream(tx: Transaction, params: {
+    streamId: string;
+    observedObjectKey: string | null;
+}): Promise<{
+    deleted: boolean;
+    jobId: string | null;
+}>;
+export declare function accountingHasNoStreams(tx: Transaction, jobId: string): Promise<boolean>;
+//# sourceMappingURL=streams.d.ts.map

package/dist/db/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../src/db/streams.ts"],"names":[],"mappings":"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"}