@shipfox/api-logs 2.0.0

package/dist/core/session/pi-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/session/pi-parser.ts"],"sourcesContent":["import type {SessionViewRow} from '@shipfox/api-logs-dto';\nimport {parseSessionEntry, sessionMessageEntrySchema} from './entry-schema.js';\nimport {toJson} from './object.js';\nimport {expandMessageEntry} from './pi/message-rows.js';\nimport {\n  branchSummaryDetail,\n  branchSummaryMeta,\n  compactionDetail,\n  compactionMeta,\n  customEntryLabel,\n  customEntryMeta,\n  customEntryText,\n  entryDetail,\n  labelDetail,\n  labelMeta,\n  modelChangeDetail,\n  sessionDetail,\n} from './pi/metadata.js';\nimport {lifecycleRow, messageRow, rawRecordRow} from './rows.js';\nimport type {AgentSessionRecord} from './session-record.js';\n\nexport type {AgentSessionRecord} from './session-record.js';\n\nexport function parsePiSessionRecord(record: AgentSessionRecord): readonly SessionViewRow[] {\n  const parsed = parseSessionEntry(record.data);\n  if (!parsed.ok) {\n    return [\n      rawRecordRow(\n        record,\n        parsed.reason === 'invalid-json' ? 'Malformed session entry' : 'Unsupported entry',\n      ),\n    ];\n  }\n\n  const entry = parsed.entry;\n  switch (entry.type) {\n    case 'message': {\n      const parsedEntry = sessionMessageEntrySchema.safeParse(entry);\n      if (!parsedEntry.success) {\n        return [\n          {kind: 'raw', timestamp: record.ts, label: 'Unsupported message entry', raw: record.data},\n        ];\n      }\n      return expandMessageEntry(record.ts, parsedEntry.data.message);\n    }\n    case 'session':\n      return [lifecycleRow(record.ts, 'Session started', sessionDetail(entry), 'default', false)];\n    case 'session_info':\n      return [lifecycleRow(record.ts, 'Session info', entryDetail(entry), 'default', false)];\n    case 'thinking_level_change':\n      return [\n        lifecycleRow(record.ts, 'Thinking level changed', entryDetail(entry), 'default', false),\n      ];\n    case 'model_change':\n      return [lifecycleRow(record.ts, 'Model changed', modelChangeDetail(entry), 'default', false)];\n    case 'compaction':\n      return [\n        lifecycleRow(\n          record.ts,\n          'Context compacted',\n          compactionDetail(entry),\n          'default',\n          false,\n          compactionMeta(entry),\n        ),\n      ];\n    case 'branch_summary':\n      return [\n        messageRow(\n          record.ts,\n          'system',\n          'branch summary',\n          branchSummaryDetail(entry) ?? toJson(entry),\n          false,\n          branchSummaryMeta(entry),\n        ),\n      ];\n    case 'custom':\n      return [\n        messageRow(\n          record.ts,\n          'custom',\n          customEntryLabel('custom'),\n          customEntryText(entry) ?? toJson(entry),\n          false,\n          customEntryMeta(entry),\n        ),\n      ];\n    case 'custom_message':\n      return [\n        messageRow(\n          record.ts,\n          'custom',\n          customEntryLabel('custom message'),\n          customEntryText(entry) ?? toJson(entry),\n          false,\n          customEntryMeta(entry),\n        ),\n      ];\n    case 'label':\n      return [\n        lifecycleRow(record.ts, 'Label', labelDetail(entry), 'default', false, labelMeta(entry)),\n      ];\n    default:\n      return [rawRecordRow(record, `Unknown session entry: ${entry.type}`)];\n  }\n}\n"],"names":["parseSessionEntry","sessionMessageEntrySchema","toJson","expandMessageEntry","branchSummaryDetail","branchSummaryMeta","compactionDetail","compactionMeta","customEntryLabel","customEntryMeta","customEntryText","entryDetail","labelDetail","labelMeta","modelChangeDetail","sessionDetail","lifecycleRow","messageRow","rawRecordRow","parsePiSessionRecord","record","parsed","data","ok","reason","entry","type","parsedEntry","safeParse","success","kind","timestamp","ts","label","raw","message"],"mappings":"AACA,SAAQA,iBAAiB,EAAEC,yBAAyB,QAAO,oBAAoB;AAC/E,SAAQC,MAAM,QAAO,cAAc;AACnC,SAAQC,kBAAkB,QAAO,uBAAuB;AACxD,SACEC,mBAAmB,EACnBC,iBAAiB,EACjBC,gBAAgB,EAChBC,cAAc,EACdC,gBAAgB,EAChBC,eAAe,EACfC,eAAe,EACfC,WAAW,EACXC,WAAW,EACXC,SAAS,EACTC,iBAAiB,EACjBC,aAAa,QACR,mBAAmB;AAC1B,SAAQC,YAAY,EAAEC,UAAU,EAAEC,YAAY,QAAO,YAAY;AAKjE,OAAO,SAASC,qBAAqBC,MAA0B;IAC7D,MAAMC,SAASrB,kBAAkBoB,OAAOE,IAAI;IAC5C,IAAI,CAACD,OAAOE,EAAE,EAAE;QACd,OAAO;YACLL,aACEE,QACAC,OAAOG,MAAM,KAAK,iBAAiB,4BAA4B;SAElE;IACH;IAEA,MAAMC,QAAQJ,OAAOI,KAAK;IAC1B,OAAQA,MAAMC,IAAI;QAChB,KAAK;YAAW;gBACd,MAAMC,cAAc1B,0BAA0B2B,SAAS,CAACH;gBACxD,IAAI,CAACE,YAAYE,OAAO,EAAE;oBACxB,OAAO;wBACL;4BAACC,MAAM;4BAAOC,WAAWX,OAAOY,EAAE;4BAAEC,OAAO;4BAA6BC,KAAKd,OAAOE,IAAI;wBAAA;qBACzF;gBACH;gBACA,OAAOnB,mBAAmBiB,OAAOY,EAAE,EAAEL,YAAYL,IAAI,CAACa,OAAO;YAC/D;QACA,KAAK;YACH,OAAO;gBAACnB,aAAaI,OAAOY,EAAE,EAAE,mBAAmBjB,cAAcU,QAAQ,WAAW;aAAO;QAC7F,KAAK;YACH,OAAO;gBAACT,aAAaI,OAAOY,EAAE,EAAE,gBAAgBrB,YAAYc,QAAQ,WAAW;aAAO;QACxF,KAAK;YACH,OAAO;gBACLT,aAAaI,OAAOY,EAAE,EAAE,0BAA0BrB,YAAYc,QAAQ,WAAW;aAClF;QACH,KAAK;YACH,OAAO;gBAACT,aAAaI,OAAOY,EAAE,EAAE,iBAAiBlB,kBAAkBW,QAAQ,WAAW;aAAO;QAC/F,KAAK;YACH,OAAO;gBACLT,aACEI,OAAOY,EAAE,EACT,qBACA1B,iBAAiBmB,QACjB,WACA,OACAlB,eAAekB;aAElB;QACH,KAAK;YACH,OAAO;gBACLR,WACEG,OAAOY,EAAE,EACT,UACA,kBACA5B,oBAAoBqB,UAAUvB,OAAOuB,QACrC,OACApB,kBAAkBoB;aAErB;QACH,KAAK;YACH,OAAO;gBACLR,WACEG,OAAOY,EAAE,EACT,UACAxB,iBAAiB,WACjBE,gBAAgBe,UAAUvB,OAAOuB,QACjC,OACAhB,gBAAgBgB;aAEnB;QACH,KAAK;YACH,OAAO;gBACLR,WACEG,OAAOY,EAAE,EACT,UACAxB,iBAAiB,mBACjBE,gBAAgBe,UAAUvB,OAAOuB,QACjC,OACAhB,gBAAgBgB;aAEnB;QACH,KAAK;YACH,OAAO;gBACLT,aAAaI,OAAOY,EAAE,EAAE,SAASpB,YAAYa,QAAQ,WAAW,OAAOZ,UAAUY;aAClF;QACH;YACE,OAAO;gBAACP,aAAaE,QAAQ,CAAC,uBAAuB,EAAEK,MAAMC,IAAI,EAAE;aAAE;IACzE;AACF"}

package/dist/core/session/rows.d.ts

@@ -0,0 +1,7 @@
+import type { SessionViewLifecycleRow, SessionViewMessageRow, SessionViewRow, SessionViewRowMeta, SessionViewThinkingRow } from '@shipfox/api-logs-dto';
+import type { AgentSessionRecord } from './session-record.js';
+export declare function messageRow(timestamp: number, role: string, label: string, text: string, terminalFailure: boolean, meta?: readonly SessionViewRowMeta[]): SessionViewMessageRow;
+export declare function thinkingRow(timestamp: number, text: string): SessionViewThinkingRow;
+export declare function lifecycleRow(timestamp: number, label: string, detail: string | null, tone: SessionViewLifecycleRow['tone'], terminalFailure: boolean, meta?: readonly SessionViewRowMeta[]): SessionViewLifecycleRow;
+export declare function rawRecordRow(record: AgentSessionRecord, label: string): SessionViewRow;
+//# sourceMappingURL=rows.d.ts.map

package/dist/core/session/rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../../../src/core/session/rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,qBAAqB,CAAC;AAE5D,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,OAAO,EACxB,IAAI,GAAE,SAAS,kBAAkB,EAAO,GACvC,qBAAqB,CAEvB;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,sBAAsB,CAEnF;AAED,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,IAAI,EAAE,uBAAuB,CAAC,MAAM,CAAC,EACrC,eAAe,EAAE,OAAO,EACxB,IAAI,GAAE,SAAS,kBAAkB,EAAO,GACvC,uBAAuB,CAEzB;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,CAEtF"}

package/dist/core/session/rows.js

@@ -0,0 +1,39 @@
+export function messageRow(timestamp, role, label, text, terminalFailure, meta = []) {
+    return {
+        kind: 'message',
+        timestamp,
+        role,
+        label,
+        meta,
+        text,
+        terminalFailure
+    };
+}
+export function thinkingRow(timestamp, text) {
+    return {
+        kind: 'thinking',
+        timestamp,
+        text
+    };
+}
+export function lifecycleRow(timestamp, label, detail, tone, terminalFailure, meta = []) {
+    return {
+        kind: 'lifecycle',
+        timestamp,
+        label,
+        detail,
+        meta,
+        tone,
+        terminalFailure
+    };
+}
+export function rawRecordRow(record, label) {
+    return {
+        kind: 'raw',
+        timestamp: record.ts,
+        label,
+        raw: record.data
+    };
+}
+
+//# sourceMappingURL=rows.js.map

package/dist/core/session/rows.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/session/rows.ts"],"sourcesContent":["import type {\n  SessionViewLifecycleRow,\n  SessionViewMessageRow,\n  SessionViewRow,\n  SessionViewRowMeta,\n  SessionViewThinkingRow,\n} from '@shipfox/api-logs-dto';\nimport type {AgentSessionRecord} from './session-record.js';\n\nexport function messageRow(\n  timestamp: number,\n  role: string,\n  label: string,\n  text: string,\n  terminalFailure: boolean,\n  meta: readonly SessionViewRowMeta[] = [],\n): SessionViewMessageRow {\n  return {kind: 'message', timestamp, role, label, meta, text, terminalFailure};\n}\n\nexport function thinkingRow(timestamp: number, text: string): SessionViewThinkingRow {\n  return {kind: 'thinking', timestamp, text};\n}\n\nexport function lifecycleRow(\n  timestamp: number,\n  label: string,\n  detail: string | null,\n  tone: SessionViewLifecycleRow['tone'],\n  terminalFailure: boolean,\n  meta: readonly SessionViewRowMeta[] = [],\n): SessionViewLifecycleRow {\n  return {kind: 'lifecycle', timestamp, label, detail, meta, tone, terminalFailure};\n}\n\nexport function rawRecordRow(record: AgentSessionRecord, label: string): SessionViewRow {\n  return {kind: 'raw', timestamp: record.ts, label, raw: record.data};\n}\n"],"names":["messageRow","timestamp","role","label","text","terminalFailure","meta","kind","thinkingRow","lifecycleRow","detail","tone","rawRecordRow","record","ts","raw","data"],"mappings":"AASA,OAAO,SAASA,WACdC,SAAiB,EACjBC,IAAY,EACZC,KAAa,EACbC,IAAY,EACZC,eAAwB,EACxBC,OAAsC,EAAE;IAExC,OAAO;QAACC,MAAM;QAAWN;QAAWC;QAAMC;QAAOG;QAAMF;QAAMC;IAAe;AAC9E;AAEA,OAAO,SAASG,YAAYP,SAAiB,EAAEG,IAAY;IACzD,OAAO;QAACG,MAAM;QAAYN;QAAWG;IAAI;AAC3C;AAEA,OAAO,SAASK,aACdR,SAAiB,EACjBE,KAAa,EACbO,MAAqB,EACrBC,IAAqC,EACrCN,eAAwB,EACxBC,OAAsC,EAAE;IAExC,OAAO;QAACC,MAAM;QAAaN;QAAWE;QAAOO;QAAQJ;QAAMK;QAAMN;IAAe;AAClF;AAEA,OAAO,SAASO,aAAaC,MAA0B,EAAEV,KAAa;IACpE,OAAO;QAACI,MAAM;QAAON,WAAWY,OAAOC,EAAE;QAAEX;QAAOY,KAAKF,OAAOG,IAAI;IAAA;AACpE"}

package/dist/core/session/session-record.d.ts

@@ -0,0 +1,5 @@
+export interface AgentSessionRecord {
+    data: string;
+    ts: number;
+}
+//# sourceMappingURL=session-record.d.ts.map

package/dist/core/session/session-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-record.d.ts","sourceRoot":"","sources":["../../../src/core/session/session-record.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ"}

package/dist/core/session/session-record.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=session-record.js.map

package/dist/core/session/session-record.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/session/session-record.ts"],"sourcesContent":["export interface AgentSessionRecord {\n  data: string;\n  ts: number;\n}\n"],"names":[],"mappings":"AAAA,WAGC"}

package/dist/db/accounting.d.ts

@@ -0,0 +1,33 @@
+import type { Transaction } from './db.js';
+/** Creates the per-job accounting row on first append; a no-op once it exists. */
+export declare function ensureJobAccounting(tx: Transaction, params: {
+    jobId: string;
+    workspaceId: string;
+}): Promise<void>;
+export interface AccrualResult {
+    used: number;
+    startedAt: Date;
+}
+/**
+ * Atomically adds `delta` stored bytes to the job's accrual, returning the new
+ * total and the budget clock origin. Returns null when the job is already capped
+ * (the `capped_at IS NULL` guard matched no row), so the caller drops the append.
+ */
+export declare function accrueStoredBytes(tx: Transaction, params: {
+    jobId: string;
+    delta: number;
+}): Promise<AccrualResult | null>;
+/** Claims the cap for a job. Returns true for the single caller that wins the race. */
+export declare function claimCap(tx: Transaction, jobId: string): Promise<boolean>;
+export declare function isJobCapped(tx: Transaction, jobId: string): Promise<boolean>;
+/**
+ * Prunes accounting only after the job has no recent budget activity. A live job re-touches
+ * `updated_at` on append, so this guard keeps retention from resetting its cap state.
+ */
+export declare function deleteJobAccounting(tx: Transaction, params: {
+    jobId: string;
+    retentionDays: number;
+}): Promise<{
+    deleted: boolean;
+}>;
+//# sourceMappingURL=accounting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accounting.d.ts","sourceRoot":"","sources":["../../src/db/accounting.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,SAAS,CAAC;AAGzC,kFAAkF;AAClF,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,WAAW,EACf,MAAM,EAAE;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,GAC3C,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,WAAW,EACf,MAAM,EAAE;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,GACrC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAW/B;AAED,uFAAuF;AACvF,wBAAsB,QAAQ,CAAC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ/E;AAED,wBAAsB,WAAW,CAAC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOlF;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,WAAW,EACf,MAAM,EAAE;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC,GAC7C,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CAAC,CAY7B"}

package/dist/db/accounting.js

@@ -0,0 +1,52 @@
+import { and, eq, isNull, lt, sql } from 'drizzle-orm';
+import { jobAccounting } from './schema/job-accounting.js';
+/** Creates the per-job accounting row on first append; a no-op once it exists. */ export async function ensureJobAccounting(tx, params) {
+    await tx.insert(jobAccounting).values({
+        jobId: params.jobId,
+        workspaceId: params.workspaceId
+    }).onConflictDoNothing({
+        target: jobAccounting.jobId
+    });
+}
+/**
+ * Atomically adds `delta` stored bytes to the job's accrual, returning the new
+ * total and the budget clock origin. Returns null when the job is already capped
+ * (the `capped_at IS NULL` guard matched no row), so the caller drops the append.
+ */ export async function accrueStoredBytes(tx, params) {
+    const [row] = await tx.update(jobAccounting).set({
+        storedBytesUsed: sql`${jobAccounting.storedBytesUsed} + ${params.delta}`,
+        updatedAt: sql`now()`
+    }).where(and(eq(jobAccounting.jobId, params.jobId), isNull(jobAccounting.cappedAt))).returning({
+        used: jobAccounting.storedBytesUsed,
+        startedAt: jobAccounting.startedAt
+    });
+    return row ?? null;
+}
+/** Claims the cap for a job. Returns true for the single caller that wins the race. */ export async function claimCap(tx, jobId) {
+    const [row] = await tx.update(jobAccounting).set({
+        cappedAt: sql`now()`,
+        updatedAt: sql`now()`
+    }).where(and(eq(jobAccounting.jobId, jobId), isNull(jobAccounting.cappedAt))).returning({
+        jobId: jobAccounting.jobId
+    });
+    return Boolean(row);
+}
+export async function isJobCapped(tx, jobId) {
+    const [row] = await tx.select({
+        cappedAt: jobAccounting.cappedAt
+    }).from(jobAccounting).where(eq(jobAccounting.jobId, jobId));
+    return Boolean(row?.cappedAt);
+}
+/**
+ * Prunes accounting only after the job has no recent budget activity. A live job re-touches
+ * `updated_at` on append, so this guard keeps retention from resetting its cap state.
+ */ export async function deleteJobAccounting(tx, params) {
+    const [row] = await tx.delete(jobAccounting).where(and(eq(jobAccounting.jobId, params.jobId), lt(jobAccounting.updatedAt, sql`now() - make_interval(days => ${params.retentionDays})`))).returning({
+        jobId: jobAccounting.jobId
+    });
+    return {
+        deleted: Boolean(row)
+    };
+}
+
+//# sourceMappingURL=accounting.js.map

package/dist/db/accounting.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/accounting.ts"],"sourcesContent":["import {and, eq, isNull, lt, sql} from 'drizzle-orm';\nimport type {Transaction} from './db.js';\nimport {jobAccounting} from './schema/job-accounting.js';\n\n/** Creates the per-job accounting row on first append; a no-op once it exists. */\nexport async function ensureJobAccounting(\n  tx: Transaction,\n  params: {jobId: string; workspaceId: string},\n): Promise<void> {\n  await tx\n    .insert(jobAccounting)\n    .values({jobId: params.jobId, workspaceId: params.workspaceId})\n    .onConflictDoNothing({target: jobAccounting.jobId});\n}\n\nexport interface AccrualResult {\n  used: number;\n  startedAt: Date;\n}\n\n/**\n * Atomically adds `delta` stored bytes to the job's accrual, returning the new\n * total and the budget clock origin. Returns null when the job is already capped\n * (the `capped_at IS NULL` guard matched no row), so the caller drops the append.\n */\nexport async function accrueStoredBytes(\n  tx: Transaction,\n  params: {jobId: string; delta: number},\n): Promise<AccrualResult | null> {\n  const [row] = await tx\n    .update(jobAccounting)\n    .set({\n      storedBytesUsed: sql`${jobAccounting.storedBytesUsed} + ${params.delta}`,\n      updatedAt: sql`now()`,\n    })\n    .where(and(eq(jobAccounting.jobId, params.jobId), isNull(jobAccounting.cappedAt)))\n    .returning({used: jobAccounting.storedBytesUsed, startedAt: jobAccounting.startedAt});\n\n  return row ?? null;\n}\n\n/** Claims the cap for a job. Returns true for the single caller that wins the race. */\nexport async function claimCap(tx: Transaction, jobId: string): Promise<boolean> {\n  const [row] = await tx\n    .update(jobAccounting)\n    .set({cappedAt: sql`now()`, updatedAt: sql`now()`})\n    .where(and(eq(jobAccounting.jobId, jobId), isNull(jobAccounting.cappedAt)))\n    .returning({jobId: jobAccounting.jobId});\n\n  return Boolean(row);\n}\n\nexport async function isJobCapped(tx: Transaction, jobId: string): Promise<boolean> {\n  const [row] = await tx\n    .select({cappedAt: jobAccounting.cappedAt})\n    .from(jobAccounting)\n    .where(eq(jobAccounting.jobId, jobId));\n\n  return Boolean(row?.cappedAt);\n}\n\n/**\n * Prunes accounting only after the job has no recent budget activity. A live job re-touches\n * `updated_at` on append, so this guard keeps retention from resetting its cap state.\n */\nexport async function deleteJobAccounting(\n  tx: Transaction,\n  params: {jobId: string; retentionDays: number},\n): Promise<{deleted: boolean}> {\n  const [row] = await tx\n    .delete(jobAccounting)\n    .where(\n      and(\n        eq(jobAccounting.jobId, params.jobId),\n        lt(jobAccounting.updatedAt, sql`now() - make_interval(days => ${params.retentionDays})`),\n      ),\n    )\n    .returning({jobId: jobAccounting.jobId});\n\n  return {deleted: Boolean(row)};\n}\n"],"names":["and","eq","isNull","lt","sql","jobAccounting","ensureJobAccounting","tx","params","insert","values","jobId","workspaceId","onConflictDoNothing","target","accrueStoredBytes","row","update","set","storedBytesUsed","delta","updatedAt","where","cappedAt","returning","used","startedAt","claimCap","Boolean","isJobCapped","select","from","deleteJobAccounting","delete","retentionDays","deleted"],"mappings":"AAAA,SAAQA,GAAG,EAAEC,EAAE,EAAEC,MAAM,EAAEC,EAAE,EAAEC,GAAG,QAAO,cAAc;AAErD,SAAQC,aAAa,QAAO,6BAA6B;AAEzD,gFAAgF,GAChF,OAAO,eAAeC,oBACpBC,EAAe,EACfC,MAA4C;IAE5C,MAAMD,GACHE,MAAM,CAACJ,eACPK,MAAM,CAAC;QAACC,OAAOH,OAAOG,KAAK;QAAEC,aAAaJ,OAAOI,WAAW;IAAA,GAC5DC,mBAAmB,CAAC;QAACC,QAAQT,cAAcM,KAAK;IAAA;AACrD;AAOA;;;;CAIC,GACD,OAAO,eAAeI,kBACpBR,EAAe,EACfC,MAAsC;IAEtC,MAAM,CAACQ,IAAI,GAAG,MAAMT,GACjBU,MAAM,CAACZ,eACPa,GAAG,CAAC;QACHC,iBAAiBf,GAAG,CAAC,EAAEC,cAAcc,eAAe,CAAC,GAAG,EAAEX,OAAOY,KAAK,CAAC,CAAC;QACxEC,WAAWjB,GAAG,CAAC,KAAK,CAAC;IACvB,GACCkB,KAAK,CAACtB,IAAIC,GAAGI,cAAcM,KAAK,EAAEH,OAAOG,KAAK,GAAGT,OAAOG,cAAckB,QAAQ,IAC9EC,SAAS,CAAC;QAACC,MAAMpB,cAAcc,eAAe;QAAEO,WAAWrB,cAAcqB,SAAS;IAAA;IAErF,OAAOV,OAAO;AAChB;AAEA,qFAAqF,GACrF,OAAO,eAAeW,SAASpB,EAAe,EAAEI,KAAa;IAC3D,MAAM,CAACK,IAAI,GAAG,MAAMT,GACjBU,MAAM,CAACZ,eACPa,GAAG,CAAC;QAACK,UAAUnB,GAAG,CAAC,KAAK,CAAC;QAAEiB,WAAWjB,GAAG,CAAC,KAAK,CAAC;IAAA,GAChDkB,KAAK,CAACtB,IAAIC,GAAGI,cAAcM,KAAK,EAAEA,QAAQT,OAAOG,cAAckB,QAAQ,IACvEC,SAAS,CAAC;QAACb,OAAON,cAAcM,KAAK;IAAA;IAExC,OAAOiB,QAAQZ;AACjB;AAEA,OAAO,eAAea,YAAYtB,EAAe,EAAEI,KAAa;IAC9D,MAAM,CAACK,IAAI,GAAG,MAAMT,GACjBuB,MAAM,CAAC;QAACP,UAAUlB,cAAckB,QAAQ;IAAA,GACxCQ,IAAI,CAAC1B,eACLiB,KAAK,CAACrB,GAAGI,cAAcM,KAAK,EAAEA;IAEjC,OAAOiB,QAAQZ,KAAKO;AACtB;AAEA;;;CAGC,GACD,OAAO,eAAeS,oBACpBzB,EAAe,EACfC,MAA8C;IAE9C,MAAM,CAACQ,IAAI,GAAG,MAAMT,GACjB0B,MAAM,CAAC5B,eACPiB,KAAK,CACJtB,IACEC,GAAGI,cAAcM,KAAK,EAAEH,OAAOG,KAAK,GACpCR,GAAGE,cAAcgB,SAAS,EAAEjB,GAAG,CAAC,8BAA8B,EAAEI,OAAO0B,aAAa,CAAC,CAAC,CAAC,IAG1FV,SAAS,CAAC;QAACb,OAAON,cAAcM,KAAK;IAAA;IAExC,OAAO;QAACwB,SAASP,QAAQZ;IAAI;AAC/B"}

package/dist/db/chunks.d.ts

@@ -0,0 +1,62 @@
+import { Buffer } from 'node:buffer';
+import { type Transaction } from './db.js';
+import { type ChunkOrigin } from './schema/chunks.js';
+export interface InsertChunkParams {
+    streamId: string;
+    streamOffset: number;
+    byteLen: number;
+    data: Buffer;
+    origin: ChunkOrigin;
+}
+export declare function insertChunk(tx: Transaction, params: InsertChunkParams): Promise<void>;
+export interface ChunkPageRow {
+    seq: number;
+    data: Buffer;
+}
+/**
+ * One keyset page of a stream's chunk bytes in `seq` order. Compaction walks pages
+ * with `afterSeq = lastSeqOfPreviousPage`, so memory stays flat regardless of stream
+ * size, and reads run outside any transaction (no tx is pinned for the long upload).
+ * Safe against late writers because a closed stream never accepts another chunk.
+ */
+export declare function readChunksKeyset(params: {
+    streamId: string;
+    afterSeq: number;
+    limit: number;
+}): Promise<ChunkPageRow[]>;
+export interface ChunkPage {
+    /** Concatenated chunk bytes for the page, in `seq` order: ready-to-serve NDJSON. */
+    data: Buffer;
+    /** The last `seq` included; the next read passes this as `afterSeq`. */
+    nextSeq: number;
+    /** Whether at least one more chunk exists past `nextSeq`. */
+    hasMore: boolean;
+}
+/**
+ * A byte-bounded page of a stream's chunk bytes in `seq` order, for the inline read path.
+ * Walking by `seq` (not the runner byte offset) is what makes server-injected control tombstones
+ * interleave with normalized runner records exactly as compaction concatenates them, so the inline
+ * NDJSON is byte-identical to the compacted object.
+ *
+ * Returns at most ~`maxBytes`, but always at least one whole chunk so the cursor advances
+ * even when a single chunk exceeds `maxBytes`. The cheap `(seq, byte_len)` scan picks the
+ * prefix first, so the heavy `data` column is only materialized for the chunks actually
+ * returned.
+ */
+export declare function readChunkPageBySeq(params: {
+    streamId: string;
+    afterSeq: number;
+    maxBytes: number;
+}): Promise<ChunkPage>;
+export interface ChunkStats {
+    count: number;
+    maxSeq: number;
+    uncompressedBytes: number;
+}
+/**
+ * Aggregate of a stream's chunks: row count, highest `seq`, and total stored bytes.
+ * Compaction reads this once before uploading, both to stamp object metadata and as the
+ * baseline its streamed totals are checked against before the chunk rows are deleted.
+ */
+export declare function chunkStats(streamId: string): Promise<ChunkStats>;
+//# sourceMappingURL=chunks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunks.d.ts","sourceRoot":"","sources":["../../src/db/chunks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAEnC,OAAO,EAAK,KAAK,WAAW,EAAC,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAC,KAAK,WAAW,EAAY,MAAM,oBAAoB,CAAC;AAE/D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,wBAAsB,WAAW,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ3F;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAQ1B;AAED,MAAM,WAAW,SAAS;IACxB,oFAAoF;IACpF,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,OAAO,EAAE,OAAO,CAAC;CAClB;AAMD;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,SAAS,CAAC,CAsCrB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAetE"}

package/dist/db/chunks.js

@@ -0,0 +1,88 @@
+import { Buffer } from 'node:buffer';
+import { and, asc, eq, gt, lte, sql } from 'drizzle-orm';
+import { db } from './db.js';
+import { logChunks } from './schema/chunks.js';
+export async function insertChunk(tx, params) {
+    await tx.insert(logChunks).values({
+        streamId: params.streamId,
+        streamOffset: params.streamOffset,
+        byteLen: params.byteLen,
+        data: params.data,
+        origin: params.origin
+    });
+}
+/**
+ * One keyset page of a stream's chunk bytes in `seq` order. Compaction walks pages
+ * with `afterSeq = lastSeqOfPreviousPage`, so memory stays flat regardless of stream
+ * size, and reads run outside any transaction (no tx is pinned for the long upload).
+ * Safe against late writers because a closed stream never accepts another chunk.
+ */ export async function readChunksKeyset(params) {
+    const rows = await db().select({
+        seq: logChunks.seq,
+        data: logChunks.data
+    }).from(logChunks).where(and(eq(logChunks.streamId, params.streamId), gt(logChunks.seq, params.afterSeq))).orderBy(asc(logChunks.seq)).limit(params.limit);
+    return rows;
+}
+// Caps the per-read metadata scan so a stream with pathologically many tiny chunks
+// can't make one read walk the whole stream; the client re-polls (hasMore) past it.
+const CHUNK_PAGE_SCAN_CAP = 4096;
+/**
+ * A byte-bounded page of a stream's chunk bytes in `seq` order, for the inline read path.
+ * Walking by `seq` (not the runner byte offset) is what makes server-injected control tombstones
+ * interleave with normalized runner records exactly as compaction concatenates them, so the inline
+ * NDJSON is byte-identical to the compacted object.
+ *
+ * Returns at most ~`maxBytes`, but always at least one whole chunk so the cursor advances
+ * even when a single chunk exceeds `maxBytes`. The cheap `(seq, byte_len)` scan picks the
+ * prefix first, so the heavy `data` column is only materialized for the chunks actually
+ * returned.
+ */ export async function readChunkPageBySeq(params) {
+    const meta = await db().select({
+        seq: logChunks.seq,
+        byteLen: logChunks.byteLen
+    }).from(logChunks).where(and(eq(logChunks.streamId, params.streamId), gt(logChunks.seq, params.afterSeq))).orderBy(asc(logChunks.seq)).limit(CHUNK_PAGE_SCAN_CAP + 1);
+    if (meta.length === 0) {
+        return {
+            data: Buffer.alloc(0),
+            nextSeq: params.afterSeq,
+            hasMore: false
+        };
+    }
+    let accumulatedBytes = 0;
+    let includedCount = 0;
+    let nextSeq = params.afterSeq;
+    for (const row of meta){
+        if (includedCount > 0 && accumulatedBytes + row.byteLen > params.maxBytes) break;
+        accumulatedBytes += row.byteLen;
+        nextSeq = row.seq;
+        includedCount += 1;
+        if (includedCount >= CHUNK_PAGE_SCAN_CAP) break;
+    }
+    const hasMore = includedCount < meta.length;
+    const rows = await db().select({
+        data: logChunks.data
+    }).from(logChunks).where(and(eq(logChunks.streamId, params.streamId), gt(logChunks.seq, params.afterSeq), lte(logChunks.seq, nextSeq))).orderBy(asc(logChunks.seq));
+    return {
+        data: Buffer.concat(rows.map((row)=>row.data)),
+        nextSeq,
+        hasMore
+    };
+}
+/**
+ * Aggregate of a stream's chunks: row count, highest `seq`, and total stored bytes.
+ * Compaction reads this once before uploading, both to stamp object metadata and as the
+ * baseline its streamed totals are checked against before the chunk rows are deleted.
+ */ export async function chunkStats(streamId) {
+    const [row] = await db().select({
+        count: sql`count(*)::int`,
+        maxSeq: sql`coalesce(max(${logChunks.seq}), 0)::int`,
+        uncompressedBytes: sql`coalesce(sum(${logChunks.byteLen}), 0)::text`
+    }).from(logChunks).where(eq(logChunks.streamId, streamId));
+    return {
+        count: row?.count ?? 0,
+        maxSeq: row?.maxSeq ?? 0,
+        uncompressedBytes: Number(row?.uncompressedBytes ?? '0')
+    };
+}
+
+//# sourceMappingURL=chunks.js.map

package/dist/db/chunks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/chunks.ts"],"sourcesContent":["import {Buffer} from 'node:buffer';\nimport {and, asc, eq, gt, lte, sql} from 'drizzle-orm';\nimport {db, type Transaction} from './db.js';\nimport {type ChunkOrigin, logChunks} from './schema/chunks.js';\n\nexport interface InsertChunkParams {\n  streamId: string;\n  streamOffset: number;\n  byteLen: number;\n  data: Buffer;\n  origin: ChunkOrigin;\n}\n\nexport async function insertChunk(tx: Transaction, params: InsertChunkParams): Promise<void> {\n  await tx.insert(logChunks).values({\n    streamId: params.streamId,\n    streamOffset: params.streamOffset,\n    byteLen: params.byteLen,\n    data: params.data,\n    origin: params.origin,\n  });\n}\n\nexport interface ChunkPageRow {\n  seq: number;\n  data: Buffer;\n}\n\n/**\n * One keyset page of a stream's chunk bytes in `seq` order. Compaction walks pages\n * with `afterSeq = lastSeqOfPreviousPage`, so memory stays flat regardless of stream\n * size, and reads run outside any transaction (no tx is pinned for the long upload).\n * Safe against late writers because a closed stream never accepts another chunk.\n */\nexport async function readChunksKeyset(params: {\n  streamId: string;\n  afterSeq: number;\n  limit: number;\n}): Promise<ChunkPageRow[]> {\n  const rows = await db()\n    .select({seq: logChunks.seq, data: logChunks.data})\n    .from(logChunks)\n    .where(and(eq(logChunks.streamId, params.streamId), gt(logChunks.seq, params.afterSeq)))\n    .orderBy(asc(logChunks.seq))\n    .limit(params.limit);\n  return rows;\n}\n\nexport interface ChunkPage {\n  /** Concatenated chunk bytes for the page, in `seq` order: ready-to-serve NDJSON. */\n  data: Buffer;\n  /** The last `seq` included; the next read passes this as `afterSeq`. */\n  nextSeq: number;\n  /** Whether at least one more chunk exists past `nextSeq`. */\n  hasMore: boolean;\n}\n\n// Caps the per-read metadata scan so a stream with pathologically many tiny chunks\n// can't make one read walk the whole stream; the client re-polls (hasMore) past it.\nconst CHUNK_PAGE_SCAN_CAP = 4096;\n\n/**\n * A byte-bounded page of a stream's chunk bytes in `seq` order, for the inline read path.\n * Walking by `seq` (not the runner byte offset) is what makes server-injected control tombstones\n * interleave with normalized runner records exactly as compaction concatenates them, so the inline\n * NDJSON is byte-identical to the compacted object.\n *\n * Returns at most ~`maxBytes`, but always at least one whole chunk so the cursor advances\n * even when a single chunk exceeds `maxBytes`. The cheap `(seq, byte_len)` scan picks the\n * prefix first, so the heavy `data` column is only materialized for the chunks actually\n * returned.\n */\nexport async function readChunkPageBySeq(params: {\n  streamId: string;\n  afterSeq: number;\n  maxBytes: number;\n}): Promise<ChunkPage> {\n  const meta = await db()\n    .select({seq: logChunks.seq, byteLen: logChunks.byteLen})\n    .from(logChunks)\n    .where(and(eq(logChunks.streamId, params.streamId), gt(logChunks.seq, params.afterSeq)))\n    .orderBy(asc(logChunks.seq))\n    .limit(CHUNK_PAGE_SCAN_CAP + 1);\n\n  if (meta.length === 0) {\n    return {data: Buffer.alloc(0), nextSeq: params.afterSeq, hasMore: false};\n  }\n\n  let accumulatedBytes = 0;\n  let includedCount = 0;\n  let nextSeq = params.afterSeq;\n  for (const row of meta) {\n    if (includedCount > 0 && accumulatedBytes + row.byteLen > params.maxBytes) break;\n    accumulatedBytes += row.byteLen;\n    nextSeq = row.seq;\n    includedCount += 1;\n    if (includedCount >= CHUNK_PAGE_SCAN_CAP) break;\n  }\n\n  const hasMore = includedCount < meta.length;\n\n  const rows = await db()\n    .select({data: logChunks.data})\n    .from(logChunks)\n    .where(\n      and(\n        eq(logChunks.streamId, params.streamId),\n        gt(logChunks.seq, params.afterSeq),\n        lte(logChunks.seq, nextSeq),\n      ),\n    )\n    .orderBy(asc(logChunks.seq));\n\n  return {data: Buffer.concat(rows.map((row) => row.data)), nextSeq, hasMore};\n}\n\nexport interface ChunkStats {\n  count: number;\n  maxSeq: number;\n  uncompressedBytes: number;\n}\n\n/**\n * Aggregate of a stream's chunks: row count, highest `seq`, and total stored bytes.\n * Compaction reads this once before uploading, both to stamp object metadata and as the\n * baseline its streamed totals are checked against before the chunk rows are deleted.\n */\nexport async function chunkStats(streamId: string): Promise<ChunkStats> {\n  const [row] = await db()\n    .select({\n      count: sql<number>`count(*)::int`,\n      maxSeq: sql<number>`coalesce(max(${logChunks.seq}), 0)::int`,\n      uncompressedBytes: sql<string>`coalesce(sum(${logChunks.byteLen}), 0)::text`,\n    })\n    .from(logChunks)\n    .where(eq(logChunks.streamId, streamId));\n\n  return {\n    count: row?.count ?? 0,\n    maxSeq: row?.maxSeq ?? 0,\n    uncompressedBytes: Number(row?.uncompressedBytes ?? '0'),\n  };\n}\n"],"names":["Buffer","and","asc","eq","gt","lte","sql","db","logChunks","insertChunk","tx","params","insert","values","streamId","streamOffset","byteLen","data","origin","readChunksKeyset","rows","select","seq","from","where","afterSeq","orderBy","limit","CHUNK_PAGE_SCAN_CAP","readChunkPageBySeq","meta","length","alloc","nextSeq","hasMore","accumulatedBytes","includedCount","row","maxBytes","concat","map","chunkStats","count","maxSeq","uncompressedBytes","Number"],"mappings":"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"}