@shipfox/api-logs 2.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAOnE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyD,CAAC;AAE7E,MAAM,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,MAAM,CAAC,CAAC;AACrD,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAIhF,wBAAgB,EAAE,aAGjB;AAED,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}

package/dist/db/db.js

@@ -0,0 +1,24 @@
+import { drizzle } from '@shipfox/node-drizzle';
+import { pgClient } from '@shipfox/node-postgres';
+import { attemptStreams } from './schema/attempt-streams.js';
+import { logChunks } from './schema/chunks.js';
+import { jobAccounting } from './schema/job-accounting.js';
+import { logsOutbox } from './schema/outbox.js';
+export const schema = {
+    jobAccounting,
+    attemptStreams,
+    logChunks,
+    logsOutbox
+};
+let _db;
+export function db() {
+    if (!_db) _db = drizzle(pgClient(), {
+        schema
+    });
+    return _db;
+}
+export function closeDb() {
+    _db = undefined;
+}
+
+//# sourceMappingURL=db.js.map

package/dist/db/db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/db.ts"],"sourcesContent":["import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';\nimport {pgClient} from '@shipfox/node-postgres';\nimport {attemptStreams} from './schema/attempt-streams.js';\nimport {logChunks} from './schema/chunks.js';\nimport {jobAccounting} from './schema/job-accounting.js';\nimport {logsOutbox} from './schema/outbox.js';\n\nexport const schema = {jobAccounting, attemptStreams, logChunks, logsOutbox};\n\nexport type Database = NodePgDatabase<typeof schema>;\nexport type Transaction = Parameters<Parameters<Database['transaction']>[0]>[0];\n\nlet _db: Database | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n"],"names":["drizzle","pgClient","attemptStreams","logChunks","jobAccounting","logsOutbox","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,cAAc,QAAO,8BAA8B;AAC3D,SAAQC,SAAS,QAAO,qBAAqB;AAC7C,SAAQC,aAAa,QAAO,6BAA6B;AACzD,SAAQC,UAAU,QAAO,qBAAqB;AAE9C,OAAO,MAAMC,SAAS;IAACF;IAAeF;IAAgBC;IAAWE;AAAU,EAAE;AAK7E,IAAIE;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMP,QAAQC,YAAY;QAACK;IAAM;IAC3C,OAAOC;AACT;AAEA,OAAO,SAASE;IACdF,MAAMG;AACR"}

package/dist/db/index.d.ts

@@ -0,0 +1,2 @@
+export declare const migrationsPath: string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,QAAoE,CAAC"}

package/dist/db/index.js

@@ -0,0 +1,5 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');
+
+//# sourceMappingURL=index.js.map

package/dist/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,OAAO,MAAMC,iBAAiBF,QAAQD,QAAQE,cAAc,YAAYE,GAAG,IAAI,iBAAiB"}

package/dist/db/schema/attempt-streams.d.ts

@@ -0,0 +1,304 @@
+import type { AttemptStream } from '#core/entities/attempt-stream.js';
+/**
+ * One stream per (job, step, attempt). Identity is scoped by `job_id` (from the
+ * lease), so a lease can only ever reach its own job's streams — cross-job log
+ * injection is structurally impossible. `workspace_id`, `project_id`, and `workflow_run_attempt_id`
+ * are stamped from the lease at create time; they are functionally determined by
+ * `job_id` via workflows FKs, so they are denormalized here for self-contained
+ * authorization (per-project read filtering, audit) without joining back to
+ * workflows. `committed_length` 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; the `AttemptStream` entity is the
+ * canonical reference for what it means.
+ *
+ * Per-row `committed_length` and `declared_total_bytes` are 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 attemptStreams: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "attempt_streams";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "attempt_streams";
+            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;
+        }, {}, {}>;
+        jobId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_id";
+            tableName: "attempt_streams";
+            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;
+        }, {}, {}>;
+        stepId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "step_id";
+            tableName: "attempt_streams";
+            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;
+        }, {}, {}>;
+        attempt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempt";
+            tableName: "attempt_streams";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "attempt_streams";
+            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;
+        }, {}, {}>;
+        projectId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project_id";
+            tableName: "attempt_streams";
+            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;
+        }, {}, {}>;
+        workflowRunAttemptId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workflow_run_attempt_id";
+            tableName: "attempt_streams";
+            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;
+        }, {}, {}>;
+        committedLength: import("drizzle-orm/pg-core").PgColumn<{
+            name: "committed_length";
+            tableName: "attempt_streams";
+            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;
+        }, {}, {}>;
+        state: import("drizzle-orm/pg-core").PgColumn<{
+            name: "state";
+            tableName: "attempt_streams";
+            dataType: "string";
+            columnType: "PgText";
+            data: "open" | "closed";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["open", "closed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        closeReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "close_reason";
+            tableName: "attempt_streams";
+            dataType: "string";
+            columnType: "PgText";
+            data: "declared" | "timeout";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["declared", "timeout"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        declaredTotalBytes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "declared_total_bytes";
+            tableName: "attempt_streams";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        truncated: import("drizzle-orm/pg-core").PgColumn<{
+            name: "truncated";
+            tableName: "attempt_streams";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        objectKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "object_key";
+            tableName: "attempt_streams";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "attempt_streams";
+            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: "attempt_streams";
+            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;
+        }, {}, {}>;
+        closedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "closed_at";
+            tableName: "attempt_streams";
+            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";
+}>;
+export type AttemptStreamDb = typeof attemptStreams.$inferSelect;
+export type AttemptStreamInsertDb = typeof attemptStreams.$inferInsert;
+export declare function toAttemptStream(row: AttemptStreamDb): AttemptStream;
+//# sourceMappingURL=attempt-streams.d.ts.map

package/dist/db/schema/attempt-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt-streams.d.ts","sourceRoot":"","sources":["../../../src/db/schema/attempt-streams.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAGpE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8C1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AACjE,MAAM,MAAM,qBAAqB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAEvE,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,CAmBnE"}

package/dist/db/schema/attempt-streams.js

@@ -0,0 +1,100 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { bigint, boolean, index, integer, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+/**
+ * One stream per (job, step, attempt). Identity is scoped by `job_id` (from the
+ * lease), so a lease can only ever reach its own job's streams — cross-job log
+ * injection is structurally impossible. `workspace_id`, `project_id`, and `workflow_run_attempt_id`
+ * are stamped from the lease at create time; they are functionally determined by
+ * `job_id` via workflows FKs, so they are denormalized here for self-contained
+ * authorization (per-project read filtering, audit) without joining back to
+ * workflows. `committed_length` 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; the `AttemptStream` entity is the
+ * canonical reference for what it means.
+ *
+ * Per-row `committed_length` and `declared_total_bytes` are 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 attemptStreams = pgTable('attempt_streams', {
+    id: uuidv7PrimaryKey(),
+    jobId: uuid('job_id').notNull(),
+    stepId: uuid('step_id').notNull(),
+    attempt: integer('attempt').notNull(),
+    workspaceId: uuid('workspace_id').notNull(),
+    projectId: uuid('project_id').notNull(),
+    workflowRunAttemptId: uuid('workflow_run_attempt_id').notNull(),
+    committedLength: bigint('committed_length', {
+        mode: 'number'
+    }).notNull().default(0),
+    state: text('state', {
+        enum: [
+            'open',
+            'closed'
+        ]
+    }).notNull().default('open'),
+    closeReason: text('close_reason', {
+        enum: [
+            'declared',
+            'timeout'
+        ]
+    }),
+    declaredTotalBytes: bigint('declared_total_bytes', {
+        mode: 'number'
+    }),
+    truncated: boolean('truncated').notNull().default(false),
+    objectKey: text('object_key'),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    closedAt: timestamp('closed_at', {
+        withTimezone: true
+    })
+}, (table)=>[
+        uniqueIndex('logs_attempt_streams_identity_unique').on(table.jobId, table.stepId, table.attempt),
+        // The session read path looks up a stream by (step, attempt) without the job id, so the
+        // identity unique (which leads with job_id) can't serve it. This index keeps that lookup
+        // off a sequential scan as the table grows.
+        index('logs_attempt_streams_step_attempt_idx').on(table.stepId, table.attempt),
+        // Timeout-close sweeps an open job's streams by job_id; the partial index keeps
+        // it off the closed tail.
+        index('logs_attempt_streams_open_by_job_idx').on(table.jobId).where(sql`"state" = 'open'`),
+        // Open-age reaping needs an index that stays off the closed tail; created_at is
+        // immutable, so appends do not churn it.
+        index('logs_attempt_streams_open_age_idx').on(table.createdAt).where(sql`"state" = 'open'`),
+        // Retention scans closed streams by close age; partial so it never carries the
+        // open (in-flight) set.
+        index('logs_attempt_streams_retention_idx').on(table.closedAt).where(sql`"state" = 'closed'`),
+        // Reconcile re-drives closed streams that never got an object key.
+        index('logs_attempt_streams_uncompacted_idx').on(table.closedAt).where(sql`"state" = 'closed' and "object_key" is null`)
+    ]);
+export function toAttemptStream(row) {
+    return {
+        id: row.id,
+        jobId: row.jobId,
+        stepId: row.stepId,
+        attempt: row.attempt,
+        workspaceId: row.workspaceId,
+        projectId: row.projectId,
+        workflowRunAttemptId: row.workflowRunAttemptId,
+        committedLength: row.committedLength,
+        state: row.state,
+        closeReason: row.closeReason,
+        declaredTotalBytes: row.declaredTotalBytes,
+        truncated: row.truncated,
+        objectKey: row.objectKey,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        closedAt: row.closedAt
+    };
+}
+
+//# sourceMappingURL=attempt-streams.js.map

package/dist/db/schema/attempt-streams.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/attempt-streams.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {\n  bigint,\n  boolean,\n  index,\n  integer,\n  text,\n  timestamp,\n  uniqueIndex,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport type {AttemptStream} from '#core/entities/attempt-stream.js';\nimport {pgTable} from './common.js';\n\n/**\n * One stream per (job, step, attempt). Identity is scoped by `job_id` (from the\n * lease), so a lease can only ever reach its own job's streams — cross-job log\n * injection is structurally impossible. `workspace_id`, `project_id`, and `workflow_run_attempt_id`\n * are stamped from the lease at create time; they are functionally determined by\n * `job_id` via workflows FKs, so they are denormalized here for self-contained\n * authorization (per-project read filtering, audit) without joining back to\n * workflows. `committed_length` is the offset-CAS axis (raw NDJSON spool bytes the\n * server has durably accepted from 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; the `AttemptStream` entity is the\n * canonical reference for what it means.\n *\n * Per-row `committed_length` and `declared_total_bytes` are bounded by the\n * per-job budget, so `mode: 'number'` is safe on the hot path. Any cross-row\n * aggregate (workspace or system-wide totals) MUST read as bigint at the\n * query site — the global sum is unbounded and would silently lose precision\n * past 2^53 as a JS number.\n */\nexport const attemptStreams = pgTable(\n  'attempt_streams',\n  {\n    id: uuidv7PrimaryKey(),\n    jobId: uuid('job_id').notNull(),\n    stepId: uuid('step_id').notNull(),\n    attempt: integer('attempt').notNull(),\n    workspaceId: uuid('workspace_id').notNull(),\n    projectId: uuid('project_id').notNull(),\n    workflowRunAttemptId: uuid('workflow_run_attempt_id').notNull(),\n    committedLength: bigint('committed_length', {mode: 'number'}).notNull().default(0),\n    state: text('state', {enum: ['open', 'closed']})\n      .notNull()\n      .default('open'),\n    closeReason: text('close_reason', {enum: ['declared', 'timeout']}),\n    declaredTotalBytes: bigint('declared_total_bytes', {mode: 'number'}),\n    truncated: boolean('truncated').notNull().default(false),\n    objectKey: text('object_key'),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n    closedAt: timestamp('closed_at', {withTimezone: true}),\n  },\n  (table) => [\n    uniqueIndex('logs_attempt_streams_identity_unique').on(\n      table.jobId,\n      table.stepId,\n      table.attempt,\n    ),\n    // The session read path looks up a stream by (step, attempt) without the job id, so the\n    // identity unique (which leads with job_id) can't serve it. This index keeps that lookup\n    // off a sequential scan as the table grows.\n    index('logs_attempt_streams_step_attempt_idx').on(table.stepId, table.attempt),\n    // Timeout-close sweeps an open job's streams by job_id; the partial index keeps\n    // it off the closed tail.\n    index('logs_attempt_streams_open_by_job_idx').on(table.jobId).where(sql`\"state\" = 'open'`),\n    // Open-age reaping needs an index that stays off the closed tail; created_at is\n    // immutable, so appends do not churn it.\n    index('logs_attempt_streams_open_age_idx').on(table.createdAt).where(sql`\"state\" = 'open'`),\n    // Retention scans closed streams by close age; partial so it never carries the\n    // open (in-flight) set.\n    index('logs_attempt_streams_retention_idx').on(table.closedAt).where(sql`\"state\" = 'closed'`),\n    // Reconcile re-drives closed streams that never got an object key.\n    index('logs_attempt_streams_uncompacted_idx')\n      .on(table.closedAt)\n      .where(sql`\"state\" = 'closed' and \"object_key\" is null`),\n  ],\n);\n\nexport type AttemptStreamDb = typeof attemptStreams.$inferSelect;\nexport type AttemptStreamInsertDb = typeof attemptStreams.$inferInsert;\n\nexport function toAttemptStream(row: AttemptStreamDb): AttemptStream {\n  return {\n    id: row.id,\n    jobId: row.jobId,\n    stepId: row.stepId,\n    attempt: row.attempt,\n    workspaceId: row.workspaceId,\n    projectId: row.projectId,\n    workflowRunAttemptId: row.workflowRunAttemptId,\n    committedLength: row.committedLength,\n    state: row.state,\n    closeReason: row.closeReason,\n    declaredTotalBytes: row.declaredTotalBytes,\n    truncated: row.truncated,\n    objectKey: row.objectKey,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n    closedAt: row.closedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","bigint","boolean","index","integer","text","timestamp","uniqueIndex","uuid","pgTable","attemptStreams","id","jobId","notNull","stepId","attempt","workspaceId","projectId","workflowRunAttemptId","committedLength","mode","default","state","enum","closeReason","declaredTotalBytes","truncated","objectKey","createdAt","withTimezone","defaultNow","updatedAt","closedAt","table","on","where","toAttemptStream","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SACEC,MAAM,EACNC,OAAO,EACPC,KAAK,EACLC,OAAO,EACPC,IAAI,EACJC,SAAS,EACTC,WAAW,EACXC,IAAI,QACC,sBAAsB;AAE7B,SAAQC,OAAO,QAAO,cAAc;AAEpC;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,MAAMC,iBAAiBD,QAC5B,mBACA;IACEE,IAAIZ;IACJa,OAAOJ,KAAK,UAAUK,OAAO;IAC7BC,QAAQN,KAAK,WAAWK,OAAO;IAC/BE,SAASX,QAAQ,WAAWS,OAAO;IACnCG,aAAaR,KAAK,gBAAgBK,OAAO;IACzCI,WAAWT,KAAK,cAAcK,OAAO;IACrCK,sBAAsBV,KAAK,2BAA2BK,OAAO;IAC7DM,iBAAiBlB,OAAO,oBAAoB;QAACmB,MAAM;IAAQ,GAAGP,OAAO,GAAGQ,OAAO,CAAC;IAChFC,OAAOjB,KAAK,SAAS;QAACkB,MAAM;YAAC;YAAQ;SAAS;IAAA,GAC3CV,OAAO,GACPQ,OAAO,CAAC;IACXG,aAAanB,KAAK,gBAAgB;QAACkB,MAAM;YAAC;YAAY;SAAU;IAAA;IAChEE,oBAAoBxB,OAAO,wBAAwB;QAACmB,MAAM;IAAQ;IAClEM,WAAWxB,QAAQ,aAAaW,OAAO,GAAGQ,OAAO,CAAC;IAClDM,WAAWtB,KAAK;IAChBuB,WAAWtB,UAAU,cAAc;QAACuB,cAAc;IAAI,GAAGhB,OAAO,GAAGiB,UAAU;IAC7EC,WAAWzB,UAAU,cAAc;QAACuB,cAAc;IAAI,GAAGhB,OAAO,GAAGiB,UAAU;IAC7EE,UAAU1B,UAAU,aAAa;QAACuB,cAAc;IAAI;AACtD,GACA,CAACI,QAAU;QACT1B,YAAY,wCAAwC2B,EAAE,CACpDD,MAAMrB,KAAK,EACXqB,MAAMnB,MAAM,EACZmB,MAAMlB,OAAO;QAEf,wFAAwF;QACxF,yFAAyF;QACzF,4CAA4C;QAC5CZ,MAAM,yCAAyC+B,EAAE,CAACD,MAAMnB,MAAM,EAAEmB,MAAMlB,OAAO;QAC7E,gFAAgF;QAChF,0BAA0B;QAC1BZ,MAAM,wCAAwC+B,EAAE,CAACD,MAAMrB,KAAK,EAAEuB,KAAK,CAACnC,GAAG,CAAC,gBAAgB,CAAC;QACzF,gFAAgF;QAChF,yCAAyC;QACzCG,MAAM,qCAAqC+B,EAAE,CAACD,MAAML,SAAS,EAAEO,KAAK,CAACnC,GAAG,CAAC,gBAAgB,CAAC;QAC1F,+EAA+E;QAC/E,wBAAwB;QACxBG,MAAM,sCAAsC+B,EAAE,CAACD,MAAMD,QAAQ,EAAEG,KAAK,CAACnC,GAAG,CAAC,kBAAkB,CAAC;QAC5F,mEAAmE;QACnEG,MAAM,wCACH+B,EAAE,CAACD,MAAMD,QAAQ,EACjBG,KAAK,CAACnC,GAAG,CAAC,2CAA2C,CAAC;KAC1D,EACD;AAKF,OAAO,SAASoC,gBAAgBC,GAAoB;IAClD,OAAO;QACL1B,IAAI0B,IAAI1B,EAAE;QACVC,OAAOyB,IAAIzB,KAAK;QAChBE,QAAQuB,IAAIvB,MAAM;QAClBC,SAASsB,IAAItB,OAAO;QACpBC,aAAaqB,IAAIrB,WAAW;QAC5BC,WAAWoB,IAAIpB,SAAS;QACxBC,sBAAsBmB,IAAInB,oBAAoB;QAC9CC,iBAAiBkB,IAAIlB,eAAe;QACpCG,OAAOe,IAAIf,KAAK;QAChBE,aAAaa,IAAIb,WAAW;QAC5BC,oBAAoBY,IAAIZ,kBAAkB;QAC1CC,WAAWW,IAAIX,SAAS;QACxBC,WAAWU,IAAIV,SAAS;QACxBC,WAAWS,IAAIT,SAAS;QACxBG,WAAWM,IAAIN,SAAS;QACxBC,UAAUK,IAAIL,QAAQ;IACxB;AACF"}

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

@@ -0,0 +1,166 @@
+/**
+ * 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 declare const logChunks: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "chunks";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "chunks";
+            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;
+        }, {}, {}>;
+        streamId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stream_id";
+            tableName: "chunks";
+            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;
+        }, {}, {}>;
+        seq: import("drizzle-orm/pg-core").PgColumn<{
+            name: "seq";
+            tableName: "chunks";
+            dataType: "number";
+            columnType: "PgBigSerial53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        streamOffset: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stream_offset";
+            tableName: "chunks";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        byteLen: import("drizzle-orm/pg-core").PgColumn<{
+            name: "byte_len";
+            tableName: "chunks";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        data: import("drizzle-orm/pg-core").PgColumn<{
+            name: "data";
+            tableName: "chunks";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: Buffer<ArrayBufferLike>;
+            driverParam: Buffer<ArrayBufferLike>;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+        }>;
+        origin: import("drizzle-orm/pg-core").PgColumn<{
+            name: "origin";
+            tableName: "chunks";
+            dataType: "string";
+            columnType: "PgText";
+            data: "runner" | "control";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["runner", "control"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "chunks";
+            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 LogChunkDb = typeof logChunks.$inferSelect;
+export type LogChunkInsertDb = typeof logChunks.$inferInsert;
+export type ChunkOrigin = 'runner' | 'control';
+//# sourceMappingURL=chunks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunks.d.ts","sourceRoot":"","sources":["../../../src/db/schema/chunks.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAerB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AACvD,MAAM,MAAM,gBAAgB,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AAE7D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC"}