@shipfox/api-logs 2.0.0

package/dist/presentation/routes/read-logs.d.ts

@@ -0,0 +1,2 @@
+export declare const readLogsRoute: import("@shipfox/node-fastify").RouteDefinition;
+//# sourceMappingURL=read-logs.d.ts.map

package/dist/presentation/routes/read-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-logs.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/read-logs.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,aAAa,iDA6BxB,CAAC"}

package/dist/presentation/routes/read-logs.js

@@ -0,0 +1,41 @@
+import { requireUserContext } from '@shipfox/api-auth-context';
+import { readLogsQuerySchema, readLogsResponseSchema } from '@shipfox/api-logs-dto';
+import { ClientError, defineRoute } from '@shipfox/node-fastify';
+import { z } from 'zod';
+import { buildLogReadResult } from '#core/read-logs.js';
+import { getStreamByStepAttempt } from '#db/streams.js';
+import { toReadLogsDto } from '#presentation/dto/read-logs.js';
+export const readLogsRoute = defineRoute({
+    method: 'GET',
+    path: '/:stepId/attempts/:attempt/logs',
+    description: 'Read a page of logs for a step attempt: inline NDJSON while the stream is hot, a presigned object URL once it is compacted.',
+    schema: {
+        params: z.object({
+            stepId: z.string().uuid(),
+            attempt: z.coerce.number().int().min(1)
+        }),
+        querystring: readLogsQuerySchema,
+        response: {
+            200: readLogsResponseSchema
+        }
+    },
+    handler: async (request)=>{
+        const user = requireUserContext(request);
+        const { stepId, attempt } = request.params;
+        const { cursor } = request.query;
+        const stream = await getStreamByStepAttempt({
+            stepId,
+            attempt
+        });
+        // 404 covers both "no such stream" and "not your workspace" so the endpoint never
+        // leaks the existence of another workspace's step.
+        if (!stream || !user.canAccess(stream.workspaceId)) {
+            throw new ClientError('Logs not found', 'not-found', {
+                status: 404
+            });
+        }
+        return toReadLogsDto(await buildLogReadResult(stream, cursor));
+    }
+});
+
+//# sourceMappingURL=read-logs.js.map

package/dist/presentation/routes/read-logs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/routes/read-logs.ts"],"sourcesContent":["import {requireUserContext} from '@shipfox/api-auth-context';\nimport {readLogsQuerySchema, readLogsResponseSchema} from '@shipfox/api-logs-dto';\nimport {ClientError, defineRoute} from '@shipfox/node-fastify';\nimport {z} from 'zod';\nimport {buildLogReadResult} from '#core/read-logs.js';\nimport {getStreamByStepAttempt} from '#db/streams.js';\nimport {toReadLogsDto} from '#presentation/dto/read-logs.js';\n\nexport const readLogsRoute = defineRoute({\n  method: 'GET',\n  path: '/:stepId/attempts/:attempt/logs',\n  description:\n    'Read a page of logs for a step attempt: inline NDJSON while the stream is hot, a presigned object URL once it is compacted.',\n  schema: {\n    params: z.object({\n      stepId: z.string().uuid(),\n      attempt: z.coerce.number().int().min(1),\n    }),\n    querystring: readLogsQuerySchema,\n    response: {\n      200: readLogsResponseSchema,\n    },\n  },\n  handler: async (request) => {\n    const user = requireUserContext(request);\n    const {stepId, attempt} = request.params;\n    const {cursor} = request.query;\n\n    const stream = await getStreamByStepAttempt({stepId, attempt});\n    // 404 covers both \"no such stream\" and \"not your workspace\" so the endpoint never\n    // leaks the existence of another workspace's step.\n    if (!stream || !user.canAccess(stream.workspaceId)) {\n      throw new ClientError('Logs not found', 'not-found', {status: 404});\n    }\n\n    return toReadLogsDto(await buildLogReadResult(stream, cursor));\n  },\n});\n"],"names":["requireUserContext","readLogsQuerySchema","readLogsResponseSchema","ClientError","defineRoute","z","buildLogReadResult","getStreamByStepAttempt","toReadLogsDto","readLogsRoute","method","path","description","schema","params","object","stepId","string","uuid","attempt","coerce","number","int","min","querystring","response","handler","request","user","cursor","query","stream","canAccess","workspaceId","status"],"mappings":"AAAA,SAAQA,kBAAkB,QAAO,4BAA4B;AAC7D,SAAQC,mBAAmB,EAAEC,sBAAsB,QAAO,wBAAwB;AAClF,SAAQC,WAAW,EAAEC,WAAW,QAAO,wBAAwB;AAC/D,SAAQC,CAAC,QAAO,MAAM;AACtB,SAAQC,kBAAkB,QAAO,qBAAqB;AACtD,SAAQC,sBAAsB,QAAO,iBAAiB;AACtD,SAAQC,aAAa,QAAO,iCAAiC;AAE7D,OAAO,MAAMC,gBAAgBL,YAAY;IACvCM,QAAQ;IACRC,MAAM;IACNC,aACE;IACFC,QAAQ;QACNC,QAAQT,EAAEU,MAAM,CAAC;YACfC,QAAQX,EAAEY,MAAM,GAAGC,IAAI;YACvBC,SAASd,EAAEe,MAAM,CAACC,MAAM,GAAGC,GAAG,GAAGC,GAAG,CAAC;QACvC;QACAC,aAAavB;QACbwB,UAAU;YACR,KAAKvB;QACP;IACF;IACAwB,SAAS,OAAOC;QACd,MAAMC,OAAO5B,mBAAmB2B;QAChC,MAAM,EAACX,MAAM,EAAEG,OAAO,EAAC,GAAGQ,QAAQb,MAAM;QACxC,MAAM,EAACe,MAAM,EAAC,GAAGF,QAAQG,KAAK;QAE9B,MAAMC,SAAS,MAAMxB,uBAAuB;YAACS;YAAQG;QAAO;QAC5D,kFAAkF;QAClF,mDAAmD;QACnD,IAAI,CAACY,UAAU,CAACH,KAAKI,SAAS,CAACD,OAAOE,WAAW,GAAG;YAClD,MAAM,IAAI9B,YAAY,kBAAkB,aAAa;gBAAC+B,QAAQ;YAAG;QACnE;QAEA,OAAO1B,cAAc,MAAMF,mBAAmByB,QAAQF;IACxD;AACF,GAAG"}

package/dist/presentation/subscribers/on-job-terminated.d.ts

@@ -0,0 +1,8 @@
+import type { WorkflowsJobTerminatedEventDto } from '@shipfox/api-workflows-dto';
+/**
+ * A job reached a terminal state (any path: completion, cancellation, lease-expiry,
+ * timeout). Arm the grace-then-close workflow for any of its streams the runner never
+ * ended itself. Deduped by workflow id, so a redelivered event is a no-op.
+ */
+export declare function onJobTerminated(payload: WorkflowsJobTerminatedEventDto): Promise<void>;
+//# sourceMappingURL=on-job-terminated.d.ts.map

package/dist/presentation/subscribers/on-job-terminated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-job-terminated.d.ts","sourceRoot":"","sources":["../../../src/presentation/subscribers/on-job-terminated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,8BAA8B,EAAC,MAAM,4BAA4B,CAAC;AAM/E;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,IAAI,CAAC,CAc5F"}

package/dist/presentation/subscribers/on-job-terminated.js

@@ -0,0 +1,32 @@
+import { logger } from '@shipfox/node-opentelemetry';
+import { temporalClient } from '@shipfox/node-temporal';
+import { config } from '#config.js';
+import { LOGS_LIFECYCLE_TASK_QUEUE } from '#temporal/constants.js';
+/**
+ * A job reached a terminal state (any path: completion, cancellation, lease-expiry,
+ * timeout). Arm the grace-then-close workflow for any of its streams the runner never
+ * ended itself. Deduped by workflow id, so a redelivered event is a no-op.
+ */ export async function onJobTerminated(payload) {
+    try {
+        await temporalClient().workflow.start('closeAbandonedStreams', {
+            taskQueue: LOGS_LIFECYCLE_TASK_QUEUE,
+            workflowId: `logs-close:${payload.jobId}`,
+            args: [
+                {
+                    jobId: payload.jobId,
+                    graceSeconds: config.LOG_STREAM_CLOSE_GRACE_SECONDS
+                }
+            ]
+        });
+    } catch (error) {
+        if (error instanceof Error && error.name === 'WorkflowExecutionAlreadyStartedError') {
+            logger().debug({
+                jobId: payload.jobId
+            }, 'Close-abandoned-streams workflow already started');
+            return;
+        }
+        throw error;
+    }
+}
+
+//# sourceMappingURL=on-job-terminated.js.map

package/dist/presentation/subscribers/on-job-terminated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/subscribers/on-job-terminated.ts"],"sourcesContent":["import type {WorkflowsJobTerminatedEventDto} from '@shipfox/api-workflows-dto';\nimport {logger} from '@shipfox/node-opentelemetry';\nimport {temporalClient} from '@shipfox/node-temporal';\nimport {config} from '#config.js';\nimport {LOGS_LIFECYCLE_TASK_QUEUE} from '#temporal/constants.js';\n\n/**\n * A job reached a terminal state (any path: completion, cancellation, lease-expiry,\n * timeout). Arm the grace-then-close workflow for any of its streams the runner never\n * ended itself. Deduped by workflow id, so a redelivered event is a no-op.\n */\nexport async function onJobTerminated(payload: WorkflowsJobTerminatedEventDto): Promise<void> {\n  try {\n    await temporalClient().workflow.start('closeAbandonedStreams', {\n      taskQueue: LOGS_LIFECYCLE_TASK_QUEUE,\n      workflowId: `logs-close:${payload.jobId}`,\n      args: [{jobId: payload.jobId, graceSeconds: config.LOG_STREAM_CLOSE_GRACE_SECONDS}],\n    });\n  } catch (error) {\n    if (error instanceof Error && error.name === 'WorkflowExecutionAlreadyStartedError') {\n      logger().debug({jobId: payload.jobId}, 'Close-abandoned-streams workflow already started');\n      return;\n    }\n    throw error;\n  }\n}\n"],"names":["logger","temporalClient","config","LOGS_LIFECYCLE_TASK_QUEUE","onJobTerminated","payload","workflow","start","taskQueue","workflowId","jobId","args","graceSeconds","LOG_STREAM_CLOSE_GRACE_SECONDS","error","Error","name","debug"],"mappings":"AACA,SAAQA,MAAM,QAAO,8BAA8B;AACnD,SAAQC,cAAc,QAAO,yBAAyB;AACtD,SAAQC,MAAM,QAAO,aAAa;AAClC,SAAQC,yBAAyB,QAAO,yBAAyB;AAEjE;;;;CAIC,GACD,OAAO,eAAeC,gBAAgBC,OAAuC;IAC3E,IAAI;QACF,MAAMJ,iBAAiBK,QAAQ,CAACC,KAAK,CAAC,yBAAyB;YAC7DC,WAAWL;YACXM,YAAY,CAAC,WAAW,EAAEJ,QAAQK,KAAK,EAAE;YACzCC,MAAM;gBAAC;oBAACD,OAAOL,QAAQK,KAAK;oBAAEE,cAAcV,OAAOW,8BAA8B;gBAAA;aAAE;QACrF;IACF,EAAE,OAAOC,OAAO;QACd,IAAIA,iBAAiBC,SAASD,MAAME,IAAI,KAAK,wCAAwC;YACnFhB,SAASiB,KAAK,CAAC;gBAACP,OAAOL,QAAQK,KAAK;YAAA,GAAG;YACvC;QACF;QACA,MAAMI;IACR;AACF"}

package/dist/presentation/subscribers/on-log-stream-closed.d.ts

@@ -0,0 +1,9 @@
+import type { LogStreamClosedEvent } from '@shipfox/api-logs-dto';
+/**
+ * A stream reached `closed` (declared end or timeout sweep). Start its compaction workflow
+ * and return; no S3 work runs in the dispatcher. Deduped by `logs-compact:{streamId}`, so a
+ * redelivered event is a no-op. A start that fails for any other reason is left to the
+ * reconcile cron, which re-drives any closed-but-uncompacted stream.
+ */
+export declare function onLogStreamClosed(payload: LogStreamClosedEvent): Promise<void>;
+//# sourceMappingURL=on-log-stream-closed.d.ts.map

package/dist/presentation/subscribers/on-log-stream-closed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-log-stream-closed.d.ts","sourceRoot":"","sources":["../../../src/presentation/subscribers/on-log-stream-closed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAKhE;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAcpF"}

package/dist/presentation/subscribers/on-log-stream-closed.js

@@ -0,0 +1,31 @@
+import { logger } from '@shipfox/node-opentelemetry';
+import { temporalClient } from '@shipfox/node-temporal';
+import { LOGS_COMPACTION_TASK_QUEUE } from '#temporal/constants.js';
+/**
+ * A stream reached `closed` (declared end or timeout sweep). Start its compaction workflow
+ * and return; no S3 work runs in the dispatcher. Deduped by `logs-compact:{streamId}`, so a
+ * redelivered event is a no-op. A start that fails for any other reason is left to the
+ * reconcile cron, which re-drives any closed-but-uncompacted stream.
+ */ export async function onLogStreamClosed(payload) {
+    try {
+        await temporalClient().workflow.start('compactStream', {
+            taskQueue: LOGS_COMPACTION_TASK_QUEUE,
+            workflowId: `logs-compact:${payload.streamId}`,
+            args: [
+                {
+                    streamId: payload.streamId
+                }
+            ]
+        });
+    } catch (error) {
+        if (error instanceof Error && error.name === 'WorkflowExecutionAlreadyStartedError') {
+            logger().debug({
+                streamId: payload.streamId
+            }, 'Compaction workflow already started');
+            return;
+        }
+        throw error;
+    }
+}
+
+//# sourceMappingURL=on-log-stream-closed.js.map

package/dist/presentation/subscribers/on-log-stream-closed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/subscribers/on-log-stream-closed.ts"],"sourcesContent":["import type {LogStreamClosedEvent} from '@shipfox/api-logs-dto';\nimport {logger} from '@shipfox/node-opentelemetry';\nimport {temporalClient} from '@shipfox/node-temporal';\nimport {LOGS_COMPACTION_TASK_QUEUE} from '#temporal/constants.js';\n\n/**\n * A stream reached `closed` (declared end or timeout sweep). Start its compaction workflow\n * and return; no S3 work runs in the dispatcher. Deduped by `logs-compact:{streamId}`, so a\n * redelivered event is a no-op. A start that fails for any other reason is left to the\n * reconcile cron, which re-drives any closed-but-uncompacted stream.\n */\nexport async function onLogStreamClosed(payload: LogStreamClosedEvent): Promise<void> {\n  try {\n    await temporalClient().workflow.start('compactStream', {\n      taskQueue: LOGS_COMPACTION_TASK_QUEUE,\n      workflowId: `logs-compact:${payload.streamId}`,\n      args: [{streamId: payload.streamId}],\n    });\n  } catch (error) {\n    if (error instanceof Error && error.name === 'WorkflowExecutionAlreadyStartedError') {\n      logger().debug({streamId: payload.streamId}, 'Compaction workflow already started');\n      return;\n    }\n    throw error;\n  }\n}\n"],"names":["logger","temporalClient","LOGS_COMPACTION_TASK_QUEUE","onLogStreamClosed","payload","workflow","start","taskQueue","workflowId","streamId","args","error","Error","name","debug"],"mappings":"AACA,SAAQA,MAAM,QAAO,8BAA8B;AACnD,SAAQC,cAAc,QAAO,yBAAyB;AACtD,SAAQC,0BAA0B,QAAO,yBAAyB;AAElE;;;;;CAKC,GACD,OAAO,eAAeC,kBAAkBC,OAA6B;IACnE,IAAI;QACF,MAAMH,iBAAiBI,QAAQ,CAACC,KAAK,CAAC,iBAAiB;YACrDC,WAAWL;YACXM,YAAY,CAAC,aAAa,EAAEJ,QAAQK,QAAQ,EAAE;YAC9CC,MAAM;gBAAC;oBAACD,UAAUL,QAAQK,QAAQ;gBAAA;aAAE;QACtC;IACF,EAAE,OAAOE,OAAO;QACd,IAAIA,iBAAiBC,SAASD,MAAME,IAAI,KAAK,wCAAwC;YACnFb,SAASc,KAAK,CAAC;gBAACL,UAAUL,QAAQK,QAAQ;YAAA,GAAG;YAC7C;QACF;QACA,MAAME;IACR;AACF"}

package/dist/presentation/subscribers/on-step-attempt-terminated.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowsStepAttemptTerminatedEventDto } from '@shipfox/api-workflows-dto';
+export declare function onStepAttemptTerminated(payload: WorkflowsStepAttemptTerminatedEventDto): Promise<void>;
+//# sourceMappingURL=on-step-attempt-terminated.d.ts.map

package/dist/presentation/subscribers/on-step-attempt-terminated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-step-attempt-terminated.d.ts","sourceRoot":"","sources":["../../../src/presentation/subscribers/on-step-attempt-terminated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,sCAAsC,EAAC,MAAM,4BAA4B,CAAC;AAGvF,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,sCAAsC,GAC9C,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/presentation/subscribers/on-step-attempt-terminated.js

@@ -0,0 +1,14 @@
+import { finalizeAttemptLogStream } from '#core/finalize-attempt-stream.js';
+export async function onStepAttemptTerminated(payload) {
+    await finalizeAttemptLogStream({
+        jobId: payload.jobId,
+        workflowRunAttemptId: payload.workflowRunAttemptId,
+        workspaceId: payload.workspaceId,
+        projectId: payload.projectId,
+        stepId: payload.stepId,
+        attempt: payload.attempt,
+        logOutcome: payload.logOutcome
+    });
+}
+
+//# sourceMappingURL=on-step-attempt-terminated.js.map

package/dist/presentation/subscribers/on-step-attempt-terminated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/subscribers/on-step-attempt-terminated.ts"],"sourcesContent":["import type {WorkflowsStepAttemptTerminatedEventDto} from '@shipfox/api-workflows-dto';\nimport {finalizeAttemptLogStream} from '#core/finalize-attempt-stream.js';\n\nexport async function onStepAttemptTerminated(\n  payload: WorkflowsStepAttemptTerminatedEventDto,\n): Promise<void> {\n  await finalizeAttemptLogStream({\n    jobId: payload.jobId,\n    workflowRunAttemptId: payload.workflowRunAttemptId,\n    workspaceId: payload.workspaceId,\n    projectId: payload.projectId,\n    stepId: payload.stepId,\n    attempt: payload.attempt,\n    logOutcome: payload.logOutcome,\n  });\n}\n"],"names":["finalizeAttemptLogStream","onStepAttemptTerminated","payload","jobId","workflowRunAttemptId","workspaceId","projectId","stepId","attempt","logOutcome"],"mappings":"AACA,SAAQA,wBAAwB,QAAO,mCAAmC;AAE1E,OAAO,eAAeC,wBACpBC,OAA+C;IAE/C,MAAMF,yBAAyB;QAC7BG,OAAOD,QAAQC,KAAK;QACpBC,sBAAsBF,QAAQE,oBAAoB;QAClDC,aAAaH,QAAQG,WAAW;QAChCC,WAAWJ,QAAQI,SAAS;QAC5BC,QAAQL,QAAQK,MAAM;QACtBC,SAASN,QAAQM,OAAO;QACxBC,YAAYP,QAAQO,UAAU;IAChC;AACF"}

package/dist/temporal/activities/close-abandoned-streams.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Job termination does not guarantee the runner flushed an end record: it may have
+ * died, been capped, or lost its spool. Each stream closes in its own transaction
+ * through the guarded `closeStream`, so a declared-close race is skipped instead of
+ * writing a duplicate event or tombstone.
+ */
+export declare function closeAbandonedStreamsActivity(params: {
+    jobId: string;
+}): Promise<{
+    closed: number;
+}>;
+//# sourceMappingURL=close-abandoned-streams.d.ts.map

package/dist/temporal/activities/close-abandoned-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-abandoned-streams.d.ts","sourceRoot":"","sources":["../../../src/temporal/activities/close-abandoned-streams.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAsB,6BAA6B,CAAC,MAAM,EAAE;IAC1D,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC,CAgB5B"}

package/dist/temporal/activities/close-abandoned-streams.js

@@ -0,0 +1,33 @@
+import { closeStream } from '#core/close-stream.js';
+import { db } from '#db/db.js';
+import { listOpenStreamsByJob } from '#db/streams.js';
+import { recordAppendedCount, streamClosedCount } from '#metrics/instance.js';
+/**
+ * Job termination does not guarantee the runner flushed an end record: it may have
+ * died, been capped, or lost its spool. Each stream closes in its own transaction
+ * through the guarded `closeStream`, so a declared-close race is skipped instead of
+ * writing a duplicate event or tombstone.
+ */ export async function closeAbandonedStreamsActivity(params) {
+    const open = await listOpenStreamsByJob(params.jobId);
+    let closed = 0;
+    for (const stream of open){
+        const result = await db().transaction((tx)=>closeStream(tx, {
+                streamId: stream.id,
+                reason: 'timeout'
+            }));
+        if (result) {
+            closed += 1;
+            recordAppendedCount.add(1, {
+                kind: 'runner_lost'
+            });
+            streamClosedCount.add(1, {
+                reason: 'timeout'
+            });
+        }
+    }
+    return {
+        closed
+    };
+}
+
+//# sourceMappingURL=close-abandoned-streams.js.map

package/dist/temporal/activities/close-abandoned-streams.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/activities/close-abandoned-streams.ts"],"sourcesContent":["import {closeStream} from '#core/close-stream.js';\nimport {db} from '#db/db.js';\nimport {listOpenStreamsByJob} from '#db/streams.js';\nimport {recordAppendedCount, streamClosedCount} from '#metrics/instance.js';\n\n/**\n * Job termination does not guarantee the runner flushed an end record: it may have\n * died, been capped, or lost its spool. Each stream closes in its own transaction\n * through the guarded `closeStream`, so a declared-close race is skipped instead of\n * writing a duplicate event or tombstone.\n */\nexport async function closeAbandonedStreamsActivity(params: {\n  jobId: string;\n}): Promise<{closed: number}> {\n  const open = await listOpenStreamsByJob(params.jobId);\n\n  let closed = 0;\n  for (const stream of open) {\n    const result = await db().transaction((tx) =>\n      closeStream(tx, {streamId: stream.id, reason: 'timeout'}),\n    );\n    if (result) {\n      closed += 1;\n      recordAppendedCount.add(1, {kind: 'runner_lost'});\n      streamClosedCount.add(1, {reason: 'timeout'});\n    }\n  }\n\n  return {closed};\n}\n"],"names":["closeStream","db","listOpenStreamsByJob","recordAppendedCount","streamClosedCount","closeAbandonedStreamsActivity","params","open","jobId","closed","stream","result","transaction","tx","streamId","id","reason","add","kind"],"mappings":"AAAA,SAAQA,WAAW,QAAO,wBAAwB;AAClD,SAAQC,EAAE,QAAO,YAAY;AAC7B,SAAQC,oBAAoB,QAAO,iBAAiB;AACpD,SAAQC,mBAAmB,EAAEC,iBAAiB,QAAO,uBAAuB;AAE5E;;;;;CAKC,GACD,OAAO,eAAeC,8BAA8BC,MAEnD;IACC,MAAMC,OAAO,MAAML,qBAAqBI,OAAOE,KAAK;IAEpD,IAAIC,SAAS;IACb,KAAK,MAAMC,UAAUH,KAAM;QACzB,MAAMI,SAAS,MAAMV,KAAKW,WAAW,CAAC,CAACC,KACrCb,YAAYa,IAAI;gBAACC,UAAUJ,OAAOK,EAAE;gBAAEC,QAAQ;YAAS;QAEzD,IAAIL,QAAQ;YACVF,UAAU;YACVN,oBAAoBc,GAAG,CAAC,GAAG;gBAACC,MAAM;YAAa;YAC/Cd,kBAAkBa,GAAG,CAAC,GAAG;gBAACD,QAAQ;YAAS;QAC7C;IACF;IAEA,OAAO;QAACP;IAAM;AAChB"}

package/dist/temporal/activities/compact-stream.d.ts

@@ -0,0 +1,33 @@
+import { compactedGzipStream } from '#core/compaction.js';
+import { type Transaction } from '#db/db.js';
+export type CompactStreamResult = {
+    outcome: 'gone';
+} | {
+    outcome: 'already-compacted';
+} | {
+    outcome: 'superseded';
+} | {
+    outcome: 'retention-raced';
+} | {
+    outcome: 'compacted';
+    objectKey: string;
+    chunkCount: number;
+    uncompressedBytes: number;
+};
+interface CompactStreamDependencies {
+    compactedGzipStream: typeof compactedGzipStream;
+    setObjectKeyAndDeleteChunks: (tx: Transaction, params: {
+        streamId: string;
+        objectKey: string;
+    }) => Promise<{
+        updated: boolean;
+    }>;
+}
+export declare function createCompactStreamActivity(dependencies?: CompactStreamDependencies): (params: {
+    streamId: string;
+}) => Promise<CompactStreamResult>;
+export declare const compactStreamActivity: (params: {
+    streamId: string;
+}) => Promise<CompactStreamResult>;
+export {};
+//# sourceMappingURL=compact-stream.d.ts.map

package/dist/temporal/activities/compact-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact-stream.d.ts","sourceRoot":"","sources":["../../../src/temporal/activities/compact-stream.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAK,KAAK,WAAW,EAAC,MAAM,WAAW,CAAC;AAI/C,MAAM,MAAM,mBAAmB,GAC3B;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACjB;IAAC,OAAO,EAAE,mBAAmB,CAAA;CAAC,GAC9B;IAAC,OAAO,EAAE,YAAY,CAAA;CAAC,GACvB;IAAC,OAAO,EAAE,iBAAiB,CAAA;CAAC,GAC5B;IAAC,OAAO,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAC,CAAC;AAE7F,UAAU,yBAAyB;IACjC,mBAAmB,EAAE,OAAO,mBAAmB,CAAC;IAChD,2BAA2B,EAAE,CAC3B,EAAE,EAAE,WAAW,EACf,MAAM,EAAE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,KAC1C,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAC,CAAC,CAAC;CAClC;AAsFD,wBAAgB,2BAA2B,CACzC,YAAY,GAAE,yBAA+C,GAC5D,CAAC,MAAM,EAAE;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAW9D;AAED,eAAO,MAAM,qBAAqB,WAbtB;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,KAAK,OAAO,CAAC,mBAAmB,CAaI,CAAC"}

package/dist/temporal/activities/compact-stream.js

@@ -0,0 +1,95 @@
+import { Context } from '@temporalio/activity';
+import { compactedObjectKey, deleteObject, putCompactedObject } from '#api/object-storage.js';
+import { compactedGzipStream } from '#core/compaction.js';
+import { chunkStats } from '#db/chunks.js';
+import { db } from '#db/db.js';
+import { getAttemptStreamById, setObjectKeyAndDeleteChunks } from '#db/streams.js';
+import { compactionCount } from '#metrics/instance.js';
+const defaultDependencies = {
+    compactedGzipStream,
+    setObjectKeyAndDeleteChunks
+};
+/**
+ * Compacts one closed stream into a single gzip NDJSON object, then deletes its chunk rows.
+ *
+ *   load stream ──┬─ gone ─────────────► no-op (retention raced)
+ *                 ├─ object_key set ───► no-op (idempotent re-run)
+ *                 └─ else: upload to a per-attempt key ─► gzip ─► multipart (abort-aware, heartbeat)
+ *                          │
+ *                 verify streamed count/maxSeq/bytes == table  (mismatch ─► delete upload, throw, retry)
+ *                          │
+ *                 tx: set object_key (state='closed' AND object_key IS NULL) + delete chunks
+ *                          └─ 0 rows ─► delete this attempt's upload, then re-read the row:
+ *                                         gone ─► retention raced · keyed ─► superseded by another attempt
+ *
+ * Each attempt uploads to its own `compactedObjectKey(stream, uuid)`, so a slow or zombie
+ * attempt can never overwrite a published object. The single-winner publish (object_key set
+ * + chunk delete, atomic) drops chunks only once a complete object is durable; the integrity
+ * check (count, maxSeq, and byte total) guards a read bug from publishing a truncated object
+ * before the only copy of the source is gone (S3 part checksums cover byte transfer).
+ */ async function compactStream(params, dependencies) {
+    const stream = await getAttemptStreamById(params.streamId);
+    if (!stream) return {
+        outcome: 'gone'
+    };
+    if (stream.objectKey) return {
+        outcome: 'already-compacted'
+    };
+    const ctx = Context.current();
+    const uploadKey = compactedObjectKey(stream, crypto.randomUUID());
+    const expected = await chunkStats(stream.id);
+    const { body, stats } = dependencies.compactedGzipStream({
+        streamId: stream.id,
+        onPage: ()=>ctx.heartbeat()
+    });
+    await putCompactedObject({
+        key: uploadKey,
+        body,
+        signal: ctx.cancellationSignal,
+        onProgress: ()=>ctx.heartbeat(),
+        metadata: {
+            stream_id: stream.id,
+            chunk_count: String(expected.count),
+            uncompressed_bytes: String(expected.uncompressedBytes),
+            last_seq: String(expected.maxSeq)
+        }
+    });
+    if (stats.chunkCount !== expected.count || stats.lastSeq !== expected.maxSeq || stats.uncompressedBytes !== expected.uncompressedBytes) {
+        await deleteObject(uploadKey).catch(()=>undefined);
+        throw new Error(`Compaction integrity check failed for stream ${stream.id}: streamed ${stats.chunkCount} chunks / ${stats.uncompressedBytes} bytes up to seq ${stats.lastSeq}, table holds ${expected.count} / ${expected.uncompressedBytes} bytes up to seq ${expected.maxSeq}`);
+    }
+    const { updated } = await db().transaction((tx)=>dependencies.setObjectKeyAndDeleteChunks(tx, {
+            streamId: stream.id,
+            objectKey: uploadKey
+        }));
+    if (!updated) {
+        await deleteObject(uploadKey);
+        const current = await getAttemptStreamById(stream.id);
+        return {
+            outcome: current ? 'superseded' : 'retention-raced'
+        };
+    }
+    return {
+        outcome: 'compacted',
+        objectKey: uploadKey,
+        chunkCount: stats.chunkCount,
+        uncompressedBytes: stats.uncompressedBytes
+    };
+}
+export function createCompactStreamActivity(dependencies = defaultDependencies) {
+    return async (params)=>{
+        let outcome = 'failed';
+        try {
+            const result = await compactStream(params, dependencies);
+            outcome = result.outcome;
+            return result;
+        } finally{
+            compactionCount.add(1, {
+                outcome
+            });
+        }
+    };
+}
+export const compactStreamActivity = createCompactStreamActivity();
+
+//# sourceMappingURL=compact-stream.js.map

package/dist/temporal/activities/compact-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/activities/compact-stream.ts"],"sourcesContent":["import {Context} from '@temporalio/activity';\nimport {compactedObjectKey, deleteObject, putCompactedObject} from '#api/object-storage.js';\nimport {compactedGzipStream} from '#core/compaction.js';\nimport {chunkStats} from '#db/chunks.js';\nimport {db, type Transaction} from '#db/db.js';\nimport {getAttemptStreamById, setObjectKeyAndDeleteChunks} from '#db/streams.js';\nimport {type CompactionMetricOutcome, compactionCount} from '#metrics/instance.js';\n\nexport type CompactStreamResult =\n  | {outcome: 'gone'}\n  | {outcome: 'already-compacted'}\n  | {outcome: 'superseded'}\n  | {outcome: 'retention-raced'}\n  | {outcome: 'compacted'; objectKey: string; chunkCount: number; uncompressedBytes: number};\n\ninterface CompactStreamDependencies {\n  compactedGzipStream: typeof compactedGzipStream;\n  setObjectKeyAndDeleteChunks: (\n    tx: Transaction,\n    params: {streamId: string; objectKey: string},\n  ) => Promise<{updated: boolean}>;\n}\n\nconst defaultDependencies: CompactStreamDependencies = {\n  compactedGzipStream,\n  setObjectKeyAndDeleteChunks,\n};\n\n/**\n * Compacts one closed stream into a single gzip NDJSON object, then deletes its chunk rows.\n *\n *   load stream ──┬─ gone ─────────────► no-op (retention raced)\n *                 ├─ object_key set ───► no-op (idempotent re-run)\n *                 └─ else: upload to a per-attempt key ─► gzip ─► multipart (abort-aware, heartbeat)\n *                          │\n *                 verify streamed count/maxSeq/bytes == table  (mismatch ─► delete upload, throw, retry)\n *                          │\n *                 tx: set object_key (state='closed' AND object_key IS NULL) + delete chunks\n *                          └─ 0 rows ─► delete this attempt's upload, then re-read the row:\n *                                         gone ─► retention raced · keyed ─► superseded by another attempt\n *\n * Each attempt uploads to its own `compactedObjectKey(stream, uuid)`, so a slow or zombie\n * attempt can never overwrite a published object. The single-winner publish (object_key set\n * + chunk delete, atomic) drops chunks only once a complete object is durable; the integrity\n * check (count, maxSeq, and byte total) guards a read bug from publishing a truncated object\n * before the only copy of the source is gone (S3 part checksums cover byte transfer).\n */\nasync function compactStream(\n  params: {streamId: string},\n  dependencies: CompactStreamDependencies,\n): Promise<CompactStreamResult> {\n  const stream = await getAttemptStreamById(params.streamId);\n  if (!stream) return {outcome: 'gone'};\n  if (stream.objectKey) return {outcome: 'already-compacted'};\n\n  const ctx = Context.current();\n  const uploadKey = compactedObjectKey(stream, crypto.randomUUID());\n  const expected = await chunkStats(stream.id);\n  const {body, stats} = dependencies.compactedGzipStream({\n    streamId: stream.id,\n    onPage: () => ctx.heartbeat(),\n  });\n\n  await putCompactedObject({\n    key: uploadKey,\n    body,\n    signal: ctx.cancellationSignal,\n    onProgress: () => ctx.heartbeat(),\n    metadata: {\n      stream_id: stream.id,\n      chunk_count: String(expected.count),\n      uncompressed_bytes: String(expected.uncompressedBytes),\n      last_seq: String(expected.maxSeq),\n    },\n  });\n\n  if (\n    stats.chunkCount !== expected.count ||\n    stats.lastSeq !== expected.maxSeq ||\n    stats.uncompressedBytes !== expected.uncompressedBytes\n  ) {\n    await deleteObject(uploadKey).catch(() => undefined);\n    throw new Error(\n      `Compaction integrity check failed for stream ${stream.id}: streamed ${stats.chunkCount} chunks / ${stats.uncompressedBytes} bytes up to seq ${stats.lastSeq}, table holds ${expected.count} / ${expected.uncompressedBytes} bytes up to seq ${expected.maxSeq}`,\n    );\n  }\n\n  const {updated} = await db().transaction((tx) =>\n    dependencies.setObjectKeyAndDeleteChunks(tx, {\n      streamId: stream.id,\n      objectKey: uploadKey,\n    }),\n  );\n  if (!updated) {\n    await deleteObject(uploadKey);\n    const current = await getAttemptStreamById(stream.id);\n    return {outcome: current ? 'superseded' : 'retention-raced'};\n  }\n\n  return {\n    outcome: 'compacted',\n    objectKey: uploadKey,\n    chunkCount: stats.chunkCount,\n    uncompressedBytes: stats.uncompressedBytes,\n  };\n}\n\nexport function createCompactStreamActivity(\n  dependencies: CompactStreamDependencies = defaultDependencies,\n): (params: {streamId: string}) => Promise<CompactStreamResult> {\n  return async (params) => {\n    let outcome: CompactionMetricOutcome = 'failed';\n    try {\n      const result = await compactStream(params, dependencies);\n      outcome = result.outcome;\n      return result;\n    } finally {\n      compactionCount.add(1, {outcome});\n    }\n  };\n}\n\nexport const compactStreamActivity = createCompactStreamActivity();\n"],"names":["Context","compactedObjectKey","deleteObject","putCompactedObject","compactedGzipStream","chunkStats","db","getAttemptStreamById","setObjectKeyAndDeleteChunks","compactionCount","defaultDependencies","compactStream","params","dependencies","stream","streamId","outcome","objectKey","ctx","current","uploadKey","crypto","randomUUID","expected","id","body","stats","onPage","heartbeat","key","signal","cancellationSignal","onProgress","metadata","stream_id","chunk_count","String","count","uncompressed_bytes","uncompressedBytes","last_seq","maxSeq","chunkCount","lastSeq","catch","undefined","Error","updated","transaction","tx","createCompactStreamActivity","result","add","compactStreamActivity"],"mappings":"AAAA,SAAQA,OAAO,QAAO,uBAAuB;AAC7C,SAAQC,kBAAkB,EAAEC,YAAY,EAAEC,kBAAkB,QAAO,yBAAyB;AAC5F,SAAQC,mBAAmB,QAAO,sBAAsB;AACxD,SAAQC,UAAU,QAAO,gBAAgB;AACzC,SAAQC,EAAE,QAAyB,YAAY;AAC/C,SAAQC,oBAAoB,EAAEC,2BAA2B,QAAO,iBAAiB;AACjF,SAAsCC,eAAe,QAAO,uBAAuB;AAiBnF,MAAMC,sBAAiD;IACrDN;IACAI;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,eAAeG,cACbC,MAA0B,EAC1BC,YAAuC;IAEvC,MAAMC,SAAS,MAAMP,qBAAqBK,OAAOG,QAAQ;IACzD,IAAI,CAACD,QAAQ,OAAO;QAACE,SAAS;IAAM;IACpC,IAAIF,OAAOG,SAAS,EAAE,OAAO;QAACD,SAAS;IAAmB;IAE1D,MAAME,MAAMlB,QAAQmB,OAAO;IAC3B,MAAMC,YAAYnB,mBAAmBa,QAAQO,OAAOC,UAAU;IAC9D,MAAMC,WAAW,MAAMlB,WAAWS,OAAOU,EAAE;IAC3C,MAAM,EAACC,IAAI,EAAEC,KAAK,EAAC,GAAGb,aAAaT,mBAAmB,CAAC;QACrDW,UAAUD,OAAOU,EAAE;QACnBG,QAAQ,IAAMT,IAAIU,SAAS;IAC7B;IAEA,MAAMzB,mBAAmB;QACvB0B,KAAKT;QACLK;QACAK,QAAQZ,IAAIa,kBAAkB;QAC9BC,YAAY,IAAMd,IAAIU,SAAS;QAC/BK,UAAU;YACRC,WAAWpB,OAAOU,EAAE;YACpBW,aAAaC,OAAOb,SAASc,KAAK;YAClCC,oBAAoBF,OAAOb,SAASgB,iBAAiB;YACrDC,UAAUJ,OAAOb,SAASkB,MAAM;QAClC;IACF;IAEA,IACEf,MAAMgB,UAAU,KAAKnB,SAASc,KAAK,IACnCX,MAAMiB,OAAO,KAAKpB,SAASkB,MAAM,IACjCf,MAAMa,iBAAiB,KAAKhB,SAASgB,iBAAiB,EACtD;QACA,MAAMrC,aAAakB,WAAWwB,KAAK,CAAC,IAAMC;QAC1C,MAAM,IAAIC,MACR,CAAC,6CAA6C,EAAEhC,OAAOU,EAAE,CAAC,WAAW,EAAEE,MAAMgB,UAAU,CAAC,UAAU,EAAEhB,MAAMa,iBAAiB,CAAC,iBAAiB,EAAEb,MAAMiB,OAAO,CAAC,cAAc,EAAEpB,SAASc,KAAK,CAAC,GAAG,EAAEd,SAASgB,iBAAiB,CAAC,iBAAiB,EAAEhB,SAASkB,MAAM,EAAE;IAEpQ;IAEA,MAAM,EAACM,OAAO,EAAC,GAAG,MAAMzC,KAAK0C,WAAW,CAAC,CAACC,KACxCpC,aAAaL,2BAA2B,CAACyC,IAAI;YAC3ClC,UAAUD,OAAOU,EAAE;YACnBP,WAAWG;QACb;IAEF,IAAI,CAAC2B,SAAS;QACZ,MAAM7C,aAAakB;QACnB,MAAMD,UAAU,MAAMZ,qBAAqBO,OAAOU,EAAE;QACpD,OAAO;YAACR,SAASG,UAAU,eAAe;QAAiB;IAC7D;IAEA,OAAO;QACLH,SAAS;QACTC,WAAWG;QACXsB,YAAYhB,MAAMgB,UAAU;QAC5BH,mBAAmBb,MAAMa,iBAAiB;IAC5C;AACF;AAEA,OAAO,SAASW,4BACdrC,eAA0CH,mBAAmB;IAE7D,OAAO,OAAOE;QACZ,IAAII,UAAmC;QACvC,IAAI;YACF,MAAMmC,SAAS,MAAMxC,cAAcC,QAAQC;YAC3CG,UAAUmC,OAAOnC,OAAO;YACxB,OAAOmC;QACT,SAAU;YACR1C,gBAAgB2C,GAAG,CAAC,GAAG;gBAACpC;YAAO;QACjC;IACF;AACF;AAEA,OAAO,MAAMqC,wBAAwBH,8BAA8B"}

package/dist/temporal/activities/compaction-reconcile.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Backstop for the event-triggered path: finds closed streams that never got an object
+ * key past the stale window and re-starts compaction for each. Starting by the same
+ * `logs-compact:{streamId}` workflow id re-drives a stream whose bounded-retry run already
+ * failed and closed, while skipping one whose run is still RUNNING (AlreadyStarted). Starts
+ * independent workflows, not children, so a re-driven run is not tied to this cron tick.
+ *
+ * One stream's unexpected start failure is logged and skipped, never thrown: a single poison
+ * stream must not abort the batch and leave the rest of the backlog un-re-driven (the next
+ * tick retries it). The activity only fails on the initial DB query.
+ */
+export declare function compactionReconcileActivity(): Promise<{
+    restarted: number;
+    failed: number;
+}>;
+//# sourceMappingURL=compaction-reconcile.d.ts.map

package/dist/temporal/activities/compaction-reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-reconcile.d.ts","sourceRoot":"","sources":["../../../src/temporal/activities/compaction-reconcile.ts"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,wBAAsB,2BAA2B,IAAI,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC,CA2BhG"}

package/dist/temporal/activities/compaction-reconcile.js

@@ -0,0 +1,52 @@
+import { logger } from '@shipfox/node-opentelemetry';
+import { temporalClient } from '@shipfox/node-temporal';
+import { config } from '#config.js';
+import { listStaleUncompactedStreams } from '#db/streams.js';
+import { LOGS_COMPACTION_TASK_QUEUE } from '#temporal/constants.js';
+// Bounded per tick; remaining stale streams are picked up on the next cron run.
+const RECONCILE_BATCH_LIMIT = 100;
+/**
+ * Backstop for the event-triggered path: finds closed streams that never got an object
+ * key past the stale window and re-starts compaction for each. Starting by the same
+ * `logs-compact:{streamId}` workflow id re-drives a stream whose bounded-retry run already
+ * failed and closed, while skipping one whose run is still RUNNING (AlreadyStarted). Starts
+ * independent workflows, not children, so a re-driven run is not tied to this cron tick.
+ *
+ * One stream's unexpected start failure is logged and skipped, never thrown: a single poison
+ * stream must not abort the batch and leave the rest of the backlog un-re-driven (the next
+ * tick retries it). The activity only fails on the initial DB query.
+ */ export async function compactionReconcileActivity() {
+    const stale = await listStaleUncompactedStreams({
+        olderThanSeconds: config.LOG_COMPACTION_RECONCILE_STALE_SECONDS,
+        limit: RECONCILE_BATCH_LIMIT
+    });
+    let restarted = 0;
+    let failed = 0;
+    for (const stream of stale){
+        try {
+            await temporalClient().workflow.start('compactStream', {
+                taskQueue: LOGS_COMPACTION_TASK_QUEUE,
+                workflowId: `logs-compact:${stream.id}`,
+                args: [
+                    {
+                        streamId: stream.id
+                    }
+                ]
+            });
+            restarted += 1;
+        } catch (error) {
+            if (error instanceof Error && error.name === 'WorkflowExecutionAlreadyStartedError') continue;
+            failed += 1;
+            logger().error({
+                err: error,
+                streamId: stream.id
+            }, 'Failed to re-drive stale stream compaction');
+        }
+    }
+    return {
+        restarted,
+        failed
+    };
+}
+
+//# sourceMappingURL=compaction-reconcile.js.map

package/dist/temporal/activities/compaction-reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/activities/compaction-reconcile.ts"],"sourcesContent":["import {logger} from '@shipfox/node-opentelemetry';\nimport {temporalClient} from '@shipfox/node-temporal';\nimport {config} from '#config.js';\nimport {listStaleUncompactedStreams} from '#db/streams.js';\nimport {LOGS_COMPACTION_TASK_QUEUE} from '#temporal/constants.js';\n\n// Bounded per tick; remaining stale streams are picked up on the next cron run.\nconst RECONCILE_BATCH_LIMIT = 100;\n\n/**\n * Backstop for the event-triggered path: finds closed streams that never got an object\n * key past the stale window and re-starts compaction for each. Starting by the same\n * `logs-compact:{streamId}` workflow id re-drives a stream whose bounded-retry run already\n * failed and closed, while skipping one whose run is still RUNNING (AlreadyStarted). Starts\n * independent workflows, not children, so a re-driven run is not tied to this cron tick.\n *\n * One stream's unexpected start failure is logged and skipped, never thrown: a single poison\n * stream must not abort the batch and leave the rest of the backlog un-re-driven (the next\n * tick retries it). The activity only fails on the initial DB query.\n */\nexport async function compactionReconcileActivity(): Promise<{restarted: number; failed: number}> {\n  const stale = await listStaleUncompactedStreams({\n    olderThanSeconds: config.LOG_COMPACTION_RECONCILE_STALE_SECONDS,\n    limit: RECONCILE_BATCH_LIMIT,\n  });\n\n  let restarted = 0;\n  let failed = 0;\n  for (const stream of stale) {\n    try {\n      await temporalClient().workflow.start('compactStream', {\n        taskQueue: LOGS_COMPACTION_TASK_QUEUE,\n        workflowId: `logs-compact:${stream.id}`,\n        args: [{streamId: stream.id}],\n      });\n      restarted += 1;\n    } catch (error) {\n      if (error instanceof Error && error.name === 'WorkflowExecutionAlreadyStartedError') continue;\n      failed += 1;\n      logger().error(\n        {err: error, streamId: stream.id},\n        'Failed to re-drive stale stream compaction',\n      );\n    }\n  }\n\n  return {restarted, failed};\n}\n"],"names":["logger","temporalClient","config","listStaleUncompactedStreams","LOGS_COMPACTION_TASK_QUEUE","RECONCILE_BATCH_LIMIT","compactionReconcileActivity","stale","olderThanSeconds","LOG_COMPACTION_RECONCILE_STALE_SECONDS","limit","restarted","failed","stream","workflow","start","taskQueue","workflowId","id","args","streamId","error","Error","name","err"],"mappings":"AAAA,SAAQA,MAAM,QAAO,8BAA8B;AACnD,SAAQC,cAAc,QAAO,yBAAyB;AACtD,SAAQC,MAAM,QAAO,aAAa;AAClC,SAAQC,2BAA2B,QAAO,iBAAiB;AAC3D,SAAQC,0BAA0B,QAAO,yBAAyB;AAElE,gFAAgF;AAChF,MAAMC,wBAAwB;AAE9B;;;;;;;;;;CAUC,GACD,OAAO,eAAeC;IACpB,MAAMC,QAAQ,MAAMJ,4BAA4B;QAC9CK,kBAAkBN,OAAOO,sCAAsC;QAC/DC,OAAOL;IACT;IAEA,IAAIM,YAAY;IAChB,IAAIC,SAAS;IACb,KAAK,MAAMC,UAAUN,MAAO;QAC1B,IAAI;YACF,MAAMN,iBAAiBa,QAAQ,CAACC,KAAK,CAAC,iBAAiB;gBACrDC,WAAWZ;gBACXa,YAAY,CAAC,aAAa,EAAEJ,OAAOK,EAAE,EAAE;gBACvCC,MAAM;oBAAC;wBAACC,UAAUP,OAAOK,EAAE;oBAAA;iBAAE;YAC/B;YACAP,aAAa;QACf,EAAE,OAAOU,OAAO;YACd,IAAIA,iBAAiBC,SAASD,MAAME,IAAI,KAAK,wCAAwC;YACrFX,UAAU;YACVZ,SAASqB,KAAK,CACZ;gBAACG,KAAKH;gBAAOD,UAAUP,OAAOK,EAAE;YAAA,GAChC;QAEJ;IACF;IAEA,OAAO;QAACP;QAAWC;IAAM;AAC3B"}

package/dist/temporal/activities/index.d.ts

@@ -0,0 +1,14 @@
+import { closeAbandonedStreamsActivity } from './close-abandoned-streams.js';
+import { compactionReconcileActivity } from './compaction-reconcile.js';
+import { reapStaleOpenStreamsActivity } from './reap-stale-open-streams.js';
+import { retentionSweepActivity } from './retention-sweep.js';
+export declare function createLogsActivities(): {
+    closeAbandonedStreamsActivity: typeof closeAbandonedStreamsActivity;
+    compactStreamActivity: (params: {
+        streamId: string;
+    }) => Promise<import("./compact-stream.js").CompactStreamResult>;
+    compactionReconcileActivity: typeof compactionReconcileActivity;
+    reapStaleOpenStreamsActivity: typeof reapStaleOpenStreamsActivity;
+    retentionSweepActivity: typeof retentionSweepActivity;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/temporal/activities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/temporal/activities/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,6BAA6B,EAAC,MAAM,8BAA8B,CAAC;AAE3E,OAAO,EAAC,2BAA2B,EAAC,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAC,4BAA4B,EAAC,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAC,sBAAsB,EAAC,MAAM,sBAAsB,CAAC;AAE5D,wBAAgB,oBAAoB;;;;;;;;EAQnC"}

package/dist/temporal/activities/index.js

@@ -0,0 +1,16 @@
+import { closeAbandonedStreamsActivity } from './close-abandoned-streams.js';
+import { compactStreamActivity } from './compact-stream.js';
+import { compactionReconcileActivity } from './compaction-reconcile.js';
+import { reapStaleOpenStreamsActivity } from './reap-stale-open-streams.js';
+import { retentionSweepActivity } from './retention-sweep.js';
+export function createLogsActivities() {
+    return {
+        closeAbandonedStreamsActivity,
+        compactStreamActivity,
+        compactionReconcileActivity,
+        reapStaleOpenStreamsActivity,
+        retentionSweepActivity
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/dist/temporal/activities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/activities/index.ts"],"sourcesContent":["import {closeAbandonedStreamsActivity} from './close-abandoned-streams.js';\nimport {compactStreamActivity} from './compact-stream.js';\nimport {compactionReconcileActivity} from './compaction-reconcile.js';\nimport {reapStaleOpenStreamsActivity} from './reap-stale-open-streams.js';\nimport {retentionSweepActivity} from './retention-sweep.js';\n\nexport function createLogsActivities() {\n  return {\n    closeAbandonedStreamsActivity,\n    compactStreamActivity,\n    compactionReconcileActivity,\n    reapStaleOpenStreamsActivity,\n    retentionSweepActivity,\n  };\n}\n"],"names":["closeAbandonedStreamsActivity","compactStreamActivity","compactionReconcileActivity","reapStaleOpenStreamsActivity","retentionSweepActivity","createLogsActivities"],"mappings":"AAAA,SAAQA,6BAA6B,QAAO,+BAA+B;AAC3E,SAAQC,qBAAqB,QAAO,sBAAsB;AAC1D,SAAQC,2BAA2B,QAAO,4BAA4B;AACtE,SAAQC,4BAA4B,QAAO,+BAA+B;AAC1E,SAAQC,sBAAsB,QAAO,uBAAuB;AAE5D,OAAO,SAASC;IACd,OAAO;QACLL;QACAC;QACAC;QACAC;QACAC;IACF;AACF"}

package/dist/temporal/activities/reap-stale-open-streams.d.ts

@@ -0,0 +1,4 @@
+import { type ReapStaleOpenStreamsResult } from '#core/reap-stale-open-streams.js';
+/** Cron-driven backstop that force-closes open streams the one-shot job-terminal close missed. */
+export declare function reapStaleOpenStreamsActivity(): Promise<ReapStaleOpenStreamsResult>;
+//# sourceMappingURL=reap-stale-open-streams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reap-stale-open-streams.d.ts","sourceRoot":"","sources":["../../../src/temporal/activities/reap-stale-open-streams.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,kCAAkC,CAAC;AAG1C,kGAAkG;AAClG,wBAAgB,4BAA4B,IAAI,OAAO,CAAC,0BAA0B,CAAC,CAKlF"}

package/dist/temporal/activities/reap-stale-open-streams.js

@@ -0,0 +1,11 @@
+import { config } from '#config.js';
+import { reapStaleOpenStreams } from '#core/reap-stale-open-streams.js';
+import { REAP_BATCH_LIMIT } from '#temporal/constants.js';
+/** Cron-driven backstop that force-closes open streams the one-shot job-terminal close missed. */ export function reapStaleOpenStreamsActivity() {
+    return reapStaleOpenStreams({
+        olderThanSeconds: config.LOG_STREAM_REAP_AFTER_SECONDS,
+        batchLimit: REAP_BATCH_LIMIT
+    });
+}
+
+//# sourceMappingURL=reap-stale-open-streams.js.map

package/dist/temporal/activities/reap-stale-open-streams.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/activities/reap-stale-open-streams.ts"],"sourcesContent":["import {config} from '#config.js';\nimport {\n  type ReapStaleOpenStreamsResult,\n  reapStaleOpenStreams,\n} from '#core/reap-stale-open-streams.js';\nimport {REAP_BATCH_LIMIT} from '#temporal/constants.js';\n\n/** Cron-driven backstop that force-closes open streams the one-shot job-terminal close missed. */\nexport function reapStaleOpenStreamsActivity(): Promise<ReapStaleOpenStreamsResult> {\n  return reapStaleOpenStreams({\n    olderThanSeconds: config.LOG_STREAM_REAP_AFTER_SECONDS,\n    batchLimit: REAP_BATCH_LIMIT,\n  });\n}\n"],"names":["config","reapStaleOpenStreams","REAP_BATCH_LIMIT","reapStaleOpenStreamsActivity","olderThanSeconds","LOG_STREAM_REAP_AFTER_SECONDS","batchLimit"],"mappings":"AAAA,SAAQA,MAAM,QAAO,aAAa;AAClC,SAEEC,oBAAoB,QACf,mCAAmC;AAC1C,SAAQC,gBAAgB,QAAO,yBAAyB;AAExD,gGAAgG,GAChG,OAAO,SAASC;IACd,OAAOF,qBAAqB;QAC1BG,kBAAkBJ,OAAOK,6BAA6B;QACtDC,YAAYJ;IACd;AACF"}

package/dist/temporal/activities/retention-sweep.d.ts

@@ -0,0 +1,7 @@
+import { type RetentionSweepResult } from '#core/retention.js';
+/**
+ * Cron-driven sweep for expired closed log streams. Heartbeats per stream; the core loop owns
+ * the wall-clock budget because Temporal timeouts do not stop already-running JS.
+ */
+export declare function retentionSweepActivity(): Promise<RetentionSweepResult>;
+//# sourceMappingURL=retention-sweep.d.ts.map

package/dist/temporal/activities/retention-sweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention-sweep.d.ts","sourceRoot":"","sources":["../../../src/temporal/activities/retention-sweep.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,KAAK,oBAAoB,EAAoB,MAAM,oBAAoB,CAAC;AAOhF;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAStE"}

package/dist/temporal/activities/retention-sweep.js

@@ -0,0 +1,19 @@
+import { Context } from '@temporalio/activity';
+import { config } from '#config.js';
+import { runRetentionSweep } from '#core/retention.js';
+import { RETENTION_BATCH_LIMIT, RETENTION_MAX_ITERATIONS, RETENTION_TIME_BUDGET_MS } from '#temporal/constants.js';
+/**
+ * Cron-driven sweep for expired closed log streams. Heartbeats per stream; the core loop owns
+ * the wall-clock budget because Temporal timeouts do not stop already-running JS.
+ */ export function retentionSweepActivity() {
+    const ctx = Context.current();
+    return runRetentionSweep({
+        retentionDays: config.LOG_RETENTION_DAYS,
+        batchLimit: RETENTION_BATCH_LIMIT,
+        timeBudgetMs: RETENTION_TIME_BUDGET_MS,
+        maxIterations: RETENTION_MAX_ITERATIONS,
+        onProgress: ()=>ctx.heartbeat()
+    });
+}
+
+//# sourceMappingURL=retention-sweep.js.map

package/dist/temporal/activities/retention-sweep.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/activities/retention-sweep.ts"],"sourcesContent":["import {Context} from '@temporalio/activity';\nimport {config} from '#config.js';\nimport {type RetentionSweepResult, runRetentionSweep} from '#core/retention.js';\nimport {\n  RETENTION_BATCH_LIMIT,\n  RETENTION_MAX_ITERATIONS,\n  RETENTION_TIME_BUDGET_MS,\n} from '#temporal/constants.js';\n\n/**\n * Cron-driven sweep for expired closed log streams. Heartbeats per stream; the core loop owns\n * the wall-clock budget because Temporal timeouts do not stop already-running JS.\n */\nexport function retentionSweepActivity(): Promise<RetentionSweepResult> {\n  const ctx = Context.current();\n  return runRetentionSweep({\n    retentionDays: config.LOG_RETENTION_DAYS,\n    batchLimit: RETENTION_BATCH_LIMIT,\n    timeBudgetMs: RETENTION_TIME_BUDGET_MS,\n    maxIterations: RETENTION_MAX_ITERATIONS,\n    onProgress: () => ctx.heartbeat(),\n  });\n}\n"],"names":["Context","config","runRetentionSweep","RETENTION_BATCH_LIMIT","RETENTION_MAX_ITERATIONS","RETENTION_TIME_BUDGET_MS","retentionSweepActivity","ctx","current","retentionDays","LOG_RETENTION_DAYS","batchLimit","timeBudgetMs","maxIterations","onProgress","heartbeat"],"mappings":"AAAA,SAAQA,OAAO,QAAO,uBAAuB;AAC7C,SAAQC,MAAM,QAAO,aAAa;AAClC,SAAmCC,iBAAiB,QAAO,qBAAqB;AAChF,SACEC,qBAAqB,EACrBC,wBAAwB,EACxBC,wBAAwB,QACnB,yBAAyB;AAEhC;;;CAGC,GACD,OAAO,SAASC;IACd,MAAMC,MAAMP,QAAQQ,OAAO;IAC3B,OAAON,kBAAkB;QACvBO,eAAeR,OAAOS,kBAAkB;QACxCC,YAAYR;QACZS,cAAcP;QACdQ,eAAeT;QACfU,YAAY,IAAMP,IAAIQ,SAAS;IACjC;AACF"}

package/dist/temporal/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const LOGS_LIFECYCLE_TASK_QUEUE = "logs-lifecycle";
+export declare const LOGS_COMPACTION_TASK_QUEUE = "logs-compaction";
+export declare const RETENTION_BATCH_LIMIT = 200;
+export declare const RETENTION_TIME_BUDGET_MS: number;
+export declare const RETENTION_MAX_ITERATIONS = 1000;
+export declare const REAP_BATCH_LIMIT = 100;
+//# sourceMappingURL=constants.d.ts.map

package/dist/temporal/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/temporal/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAI1D,eAAO,MAAM,0BAA0B,oBAAoB,CAAC;AAI5D,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,wBAAwB,QAAa,CAAC;AACnD,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAG9C,eAAO,MAAM,gBAAgB,MAAM,CAAC"}