deepline 0.3.300 → 0.3.302

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.300',
+  version: '0.3.302',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/sdk/src/runs/watch-polling.ts

@@ -95,7 +95,7 @@ async function backfillRotatedLogTail(input: {
 }): Promise<PlayRunLiveSnapshot> {
   // A late first attach intentionally shows the retained tail and its gap
   // marker. Backfill only lines that rotated out after this watcher attached.
-  if (!input.previous.runSignature) {
+  if (!input.previous.runSignature || input.snapshot.logsUnavailable) {
     return input.snapshot;
   }
   const gap = resolvePlayRunLogGap(input.snapshot, input.previous.lastLogSeq);

package/dist/bundling-sources/shared_libs/play-runtime/live-state-contract.ts

@@ -84,6 +84,8 @@ export type PlayRunLiveSnapshot = {
   status: PlayRunLiveStatus;
   updatedAt: number | null;
   logs: string[];
+  /** Present when an optional canonical log read failed for this snapshot. */
+  logsUnavailable?: true;
   activeArtifactTableNamespace: string | null;
   resultTableNamespace: string | null;
   nodeStates: PlayVisualNodeStateSnapshot[];

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/projection/gateway-adapter.ts

@@ -5,7 +5,7 @@ import {
   dispatchRunLedgerOutboxToLedgerThroughEventWithClientScope,
   type PostgresSchedulerOptions,
   type PostgresSchedulerOutboxDrainResult,
-  type PostgresSchedulerQueryClient,
+  type RunLedgerOutboxWithClient,
 } from '../../scheduler-backends/postgres';
 
 import type { RunLedgerProjectionPorts } from '../../play-runs/projection/ports';
@@ -17,9 +17,7 @@ export type GatewayRunLedgerProjectionAdapterInput = {
    * against the active outbox lease while retaining supported transport hooks.
    */
   runtimeApi: WorkerRuntimeApiContext;
-  withClient: <T>(
-    operation: (client: PostgresSchedulerQueryClient) => Promise<T>,
-  ) => Promise<T>;
+  withClient: RunLedgerOutboxWithClient;
   schedulerOptions?: Pick<PostgresSchedulerOptions, 'schema'>;
 };
 

package/dist/bundling-sources/shared_libs/play-runtime/run-log-buffer.ts

@@ -117,3 +117,63 @@ export function normalizeRunLogIds(
     );
   return value;
 }
+
+/** One owner for every per-line annotation crossing a runtime boundary. */
+export const RUN_LOG_ANNOTATION_FIELDS = [
+  'lineContexts',
+  'lineMetadata',
+  'lineIds',
+] as const;
+
+export function hasRunLogAnnotations(value: object): boolean {
+  return RUN_LOG_ANNOTATION_FIELDS.some((field) =>
+    Object.prototype.hasOwnProperty.call(value, field),
+  );
+}
+
+/** Old producers may omit annotations; present arrays must stay aligned. */
+export function normalizeRunLogAnnotations(
+  value: {
+    lineContexts?: unknown;
+    lineMetadata?: unknown;
+    lineIds?: unknown;
+  },
+  lines: readonly unknown[],
+): {
+  lineContexts?: Array<PlayLogContext | null>;
+  lineMetadata?: Array<PlayLogMetadata | null>;
+  lineIds?: Array<string | null>;
+} {
+  for (const field of ['lineContexts', 'lineMetadata'] as const) {
+    const entries = value[field];
+    if (
+      entries !== undefined &&
+      (!Array.isArray(entries) || entries.length !== lines.length)
+    ) {
+      throw new TypeError(`Run log ${field} must align with their lines.`);
+    }
+  }
+  const lineContexts = Array.isArray(value.lineContexts)
+    ? value.lineContexts.map(normalizePlayLogContext)
+    : undefined;
+  const lineMetadata = Array.isArray(value.lineMetadata)
+    ? value.lineMetadata.map(normalizePlayLogMetadata)
+    : undefined;
+  const lineIds = normalizeRunLogIds(value.lineIds, lines);
+  return {
+    ...(lineContexts ? { lineContexts } : {}),
+    ...(lineMetadata ? { lineMetadata } : {}),
+    ...(lineIds ? { lineIds } : {}),
+  };
+}
+
+/** Search owns these annotations; compatibility projections omit them together. */
+export function stripRunLogAnnotations<T extends object>(
+  value: T,
+): Omit<T, (typeof RUN_LOG_ANNOTATION_FIELDS)[number]> {
+  const copy = { ...value };
+  for (const field of RUN_LOG_ANNOTATION_FIELDS) {
+    delete (copy as Record<string, unknown>)[field];
+  }
+  return copy;
+}

package/dist/bundling-sources/shared_libs/play-runtime/run-snapshot-stream.ts

@@ -99,6 +99,12 @@ export type PlayRunLiveSnapshot = {
    * crossed the retention cap (ADR-0009). Additive/optional on the wire.
    */
   logsTruncated?: boolean;
+  /**
+   * The canonical log store could not be read for this snapshot. The run
+   * status remains authoritative; callers should retry logs on the next poll
+   * or use the paginated logs endpoint. The log cursor does not advance.
+   */
+  logsUnavailable?: true;
   activeArtifactTableNamespace: string | null;
   resultTableNamespace: string | null;
   datasets?: PlayRunLedgerDatasetSnapshot[];
@@ -573,6 +579,13 @@ function diffLogLines(input: {
   lastLogSeq: number;
 }): { lines: string[]; lastLogSeq: number; firstSeq: number | null } {
   const { logs, totalLogCount } = input.snapshot;
+  if (input.snapshot.logsUnavailable) {
+    return {
+      lines: [],
+      lastLogSeq: input.lastLogSeq,
+      firstSeq: null,
+    };
+  }
   if (totalLogCount <= input.lastLogSeq) {
     return { lines: [], lastLogSeq: input.lastLogSeq, firstSeq: null };
   }

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-lifecycle.ts

@@ -694,12 +694,22 @@ async function acquireOneShotDaytonaSandbox(input: {
     },
   );
   input.emitStage('create:start');
+  const admissionRequestedAt = Date.now();
+  let admissionWaitMs = 0;
+  let admissionQueued = false;
+  const create = () => {
+    admissionWaitMs = Date.now() - admissionRequestedAt;
+    if (admissionQueued) {
+      input.emitStage('create:admission_ready', { admissionWaitMs });
+    }
+    return createRetriedOneShotDaytonaSandbox(input);
+  };
   const result = input.startAdmission
-    ? await input.startAdmission.run(
-        () => createRetriedOneShotDaytonaSandbox(input),
-        input.cancellationSignal,
-      )
-    : await createRetriedOneShotDaytonaSandbox(input);
+    ? await input.startAdmission.run(create, input.cancellationSignal, () => {
+        admissionQueued = true;
+        input.emitStage('create:admission_wait');
+      })
+    : await create();
   // The runner's egress probe measures the sandbox-to-estate round trip; the
   // sandbox's target names the region that round trip crosses.
   console.info('[play-runner.daytona.sandbox_acquired]', {
@@ -779,6 +789,7 @@ async function acquireOneShotDaytonaSandbox(input: {
     sandboxId: sandbox.id,
     attempt: result.attempt,
     elapsedMs: billingStartedAt - input.startedAt,
+    admissionWaitMs,
     attemptElapsedMs: result.attemptElapsedMs,
     // Daytona's default snapshot is intentionally provider-managed. Record the
     // resolved immutable snapshot identifier so a slow acquisition can be

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-start-admission.ts

@@ -1,7 +1,11 @@
 import { RUNTIME_CAPACITY_POLICY } from '../../runtime-capacity-policy';
 
 export type DaytonaSandboxStartAdmission = {
-  run<T>(operation: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+  run<T>(
+    operation: () => Promise<T>,
+    signal?: AbortSignal,
+    onQueued?: () => void,
+  ): Promise<T>;
 };
 
 /**
@@ -45,6 +49,7 @@ export function createDaytonaSandboxStartAdmission(
     async run<T>(
       operation: () => Promise<T>,
       signal?: AbortSignal,
+      onQueued?: () => void,
     ): Promise<T> {
       signal?.throwIfAborted();
       // Preserve eager prepare semantics when capacity is free: the provider
@@ -57,6 +62,7 @@ export function createDaytonaSandboxStartAdmission(
               return createRelease();
             })()
           : await new Promise<() => void>((resolve, reject) => {
+              onQueued?.();
               const accept = (release: () => void) => {
                 signal?.removeEventListener('abort', abort);
                 resolve(release);

package/dist/bundling-sources/shared_libs/play-runtime/runtime-capacity-policy.ts

@@ -66,11 +66,13 @@ export const RUNTIME_CAPACITY_POLICY = {
   sandboxAcquisition: {
     /**
      * Starting a Daytona sandbox is a provider control-plane transition, not
-     * an Absurd execution slot. Serialize starts within each worker process;
-     * once started, all eight execution slots may run concurrently.
+     * an Absurd execution slot. Allow up to five concurrent starts within one
+     * worker process; the fleet-wide limiter paces lifecycle admissions, and
+     * this semaphore bounds concurrent create/retry ladders. A worker has
+     * eight execution slots.
      */
-    daytonaConcurrentStartsPerProcess: 1,
-    /** Fleet-wide AIMD start pacing, separate from execution-slot scaling. */
+    daytonaConcurrentStartsPerProcess: 5,
+    /** Fleet-wide AIMD lifecycle-admission pacing. */
     daytonaInitialStartsPerMinute: 120,
     daytonaMaximumStartsPerMinute: 600,
   },

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-runtime-worker.ts

@@ -870,8 +870,8 @@ function buildDefaultDeps(absurd: Absurd): AbsurdRuntimeWorkerDeps {
             ...absurdRuntimeApiFromLaunch(launch),
             ...(signal ? { signal } : {}),
           },
-          withClient: (operation) =>
-            withRuntimeSchedulerClient(getPool(), operation),
+          withClient: (operation, trace) =>
+            withRuntimeSchedulerClient(getPool(), operation, trace),
           schedulerOptions: options,
         }),
       }).deliver(targetEventId ? { targetEventId } : {}),