deepline 0.3.288 → 0.3.290

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.288',
+  version: '0.3.290',
   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/shared_libs/play-runtime/app-runtime-api.ts

@@ -111,12 +111,16 @@ export type RuntimeStatusUpdate = {
   liveLogs?: string[];
   /** Search-only context aligned to `liveLogs`; stripped before Convex. */
   liveLogContexts?: Array<PlayLogContext | null>;
+  liveLogIds?: Array<string | null>;
   /**
    * Monotonic count of log lines the producer ever emitted on this run's
    * channel. `liveLogs` is a rotating tail of those lines; the total lets the
    * positional cursor stay correct once the buffer has rotated.
    */
   liveLogTotalCount?: number;
+  /** Absolute start of a stateless gateway batch. Its durable positions must
+   * reach ingestion even if another request already forwarded a newer batch. */
+  liveLogBatchOffset?: number;
   /**
    * Monotonic scheduler attempt that owns the positional log channel. A new
    * attempt starts at offset zero without colliding with earlier attempts.
@@ -156,6 +160,7 @@ export type RuntimeStatusUpdate = {
   terminalLogReplay?: {
     lines: string[];
     lineContexts?: Array<PlayLogContext | null>;
+    lineIds?: Array<string | null>;
     totalCount?: number;
     dedupeMode?: 'semantic' | 'exact';
     producerAttempt?: number;
@@ -355,6 +360,8 @@ type RuntimeApiRequest =
 export type WorkerRuntimeApiContext = {
   baseUrl: string;
   executorToken: string;
+  /** Exact ingress-prefix verifier advertised by the immutable launch receiver. */
+  runLedgerIngressPrefixBatching?: true;
   boundary?: 'app_runtime' | 'receipt_gateway';
   integrationMode?: 'live' | 'eval_stub' | 'fixture' | null;
   vercelProtectionBypassToken?: string | null;
@@ -2197,18 +2204,22 @@ async function updateRunStatusViaAppRuntimeUnlocked(
       runId: update.playId,
       status: 'queued',
     });
-  // Positional cursor over this producer's log buffer. Running updates forward
-  // only the unsent suffix; terminal updates resend the retained buffer so the
-  // durable stream can recover any progress flush that was lost in transit.
-  const sentCount = isTerminalRuntimeStatus(update.status)
-    ? 0
-    : (runLogChannelSentCounts.get(
-        runLogChannelKey(update.playId, update.liveLogProducerAttempt),
-      ) ?? 0);
+  // Stateful producers forward their unsent suffix. A stateless gateway batch
+  // owns an absolute start: a newer request's process-local cursor is no proof
+  // that this batch reached ingestion. Durable positional identities reconcile
+  // overlap and terminal recovery.
+  const sentCount =
+    update.liveLogBatchOffset ??
+    (isTerminalRuntimeStatus(update.status)
+      ? 0
+      : (runLogChannelSentCounts.get(
+          runLogChannelKey(update.playId, update.liveLogProducerAttempt),
+        ) ?? 0));
   const logSlice = Array.isArray(update.liveLogs)
     ? slicePositionalLogLines({
         bufferLines: update.liveLogs,
         bufferContexts: update.liveLogContexts,
+        bufferIds: update.liveLogIds,
         bufferTotalCount: update.liveLogTotalCount ?? update.liveLogs.length,
         sentCount,
       })
@@ -2220,6 +2231,7 @@ async function updateRunStatusViaAppRuntimeUnlocked(
         ? {
             lines: update.liveLogs,
             lineContexts: update.liveLogContexts,
+            lineIds: update.liveLogIds,
             totalCount: update.liveLogTotalCount,
             producerAttempt: update.liveLogProducerAttempt,
           }
@@ -2239,7 +2251,13 @@ async function updateRunStatusViaAppRuntimeUnlocked(
       0,
       Math.max(0, replayOffset - logSlice.channelOffset),
     );
-    if (prefix.length) statusPatchLogSlice = { ...logSlice, lines: prefix };
+    if (prefix.length)
+      statusPatchLogSlice = {
+        ...logSlice,
+        lines: prefix,
+        lineContexts: logSlice.lineContexts?.slice(0, prefix.length),
+        lineIds: logSlice.lineIds?.slice(0, prefix.length),
+      };
   }
   const events = buildPlayRunLedgerEventsFromStatusPatch({
     patch: {
@@ -2250,6 +2268,7 @@ async function updateRunStatusViaAppRuntimeUnlocked(
       lastCheckpointAt: update.lastCheckpointAt ?? null,
       liveLogs: statusPatchLogSlice?.lines ?? null,
       liveLogContexts: statusPatchLogSlice?.lineContexts ?? null,
+      liveLogIds: statusPatchLogSlice?.lineIds ?? null,
       liveLogsChannelOffset: statusPatchLogSlice?.channelOffset ?? null,
       liveLogsProducerAttempt: update.liveLogProducerAttempt ?? null,
       liveNodeProgress: update.liveNodeProgress ?? null,
@@ -2335,6 +2354,7 @@ async function updateRunStatusViaAppRuntimeUnlocked(
           occurredAt: update.lastCheckpointAt ?? Date.now(),
           lines: terminalLogReplay.lines,
           lineContexts: terminalLogReplay.lineContexts,
+          lineIds: terminalLogReplay.lineIds,
           liveLogTotalCount: terminalLogReplay.totalCount,
           dedupeMode: terminalLogReplay.dedupeMode,
           producerAttempt: terminalLogReplay.producerAttempt,
@@ -2364,7 +2384,7 @@ async function updateRunStatusViaAppRuntimeUnlocked(
       events: terminalLogEvents,
     });
   }
-  if (statusPatchLogSlice) {
+  if (statusPatchLogSlice && update.liveLogBatchOffset === undefined) {
     runLogChannelSentCounts.set(
       runLogChannelKey(update.playId, update.liveLogProducerAttempt),
       statusPatchLogSlice.channelOffset + statusPatchLogSlice.lines.length,

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -1806,7 +1806,27 @@ type NativeBatchBodyAttribution = {
   release(): void;
 };
 
+type ToolBatchAdmissionObserver = {
+  pending(requests: readonly ToolCallRequest[]): void;
+  dispatched(requests: readonly ToolCallRequest[]): void;
+};
+
+function settleToolBatchGroups(
+  groups: ToolCallRequest[][],
+  execute: (requests: ToolCallRequest[]) => Promise<void>,
+  observer?: ToolBatchAdmissionObserver,
+): Promise<PromiseSettledResult<void>[]> {
+  return Promise.allSettled(
+    groups.map((requests) =>
+      execute(requests).finally(() => observer?.dispatched(requests)),
+    ),
+  );
+}
+
 type ToolExecutionApiOptions = {
+  /** Runner-local scheduling signals; never part of a provider/wire payload. */
+  onProviderAdmissionPending?: () => void;
+  onProviderDispatched?: () => void;
   timeoutMs?: number;
   abortSignal?: AbortSignal;
   durableCallReceiptKey?: string | null;
@@ -11829,8 +11849,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           request.executionAuthScopeDigest ?? '',
           String(strategy.toBucketKey(request.input)),
         ].join('\u0000'),
-        readyCount: strategy.maxBatchSize,
-        maxGroupSize: this.governor.policy.concurrency.toolCalls,
+        readyCount: Math.min(
+          strategy.maxBatchSize,
+          this.governor.policy.concurrency.toolCalls,
+        ),
+        maxGroupSize: Math.min(
+          strategy.maxBatchSize,
+          this.governor.policy.concurrency.toolCalls,
+        ),
         coalesceWindowMs: this.toolCoalesceWindowMs(
           this.#options.toolBatchCoalesceWindowMs,
           TOOL_BATCH_COALESCE_WINDOW_MS,
@@ -12030,6 +12056,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
 
     const requests: ToolCallRequest[] = [];
     const remaining: ToolCallRequest[] = [];
+    const remainingLaneKeys = new Set<string>();
     const selectedByLane = new Map<string, number>();
     for (const request of this.toolCallQueue) {
       const lane = this.toolDispatchLane(request);
@@ -12043,12 +12070,15 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         selectedByLane.set(lane.key, selectedCount + 1);
       } else {
         remaining.push(request);
+        remainingLaneKeys.add(lane.key);
       }
     }
     this.toolCallQueue = remaining;
     const selectedLaneKeys = new Set(selectedByLane.keys());
     for (const laneKey of selectedLaneKeys) {
-      this.toolDispatchQueuedAtByLane.delete(laneKey);
+      if (!remainingLaneKeys.has(laneKey)) {
+        this.toolDispatchQueuedAtByLane.delete(laneKey);
+      }
     }
     return { requests, laneKeys: selectedLaneKeys, nextDeadlineMs };
   }
@@ -12258,6 +12288,33 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     // it never waits for unrelated sibling calls from the previous column.
     const inFlightToolExecutions = new Map<Promise<void>, ToolCallRequest[]>();
     const activeGroupsByLane = new Map<string, number>();
+    // Keep a native batch lane together while its physical request is
+    // preparing or waiting for provider admission. Release it at dispatch, so
+    // provider residence does not serialize the next batch.
+    const pendingAdmissionByLane = new Map<string, Set<string>>();
+    const admissionObserver: ToolBatchAdmissionObserver = {
+      pending: (requests) => {
+        for (const request of requests) {
+          if (!this.#options.getBatchOperationStrategy?.(request.toolId))
+            continue;
+          const key = this.toolDispatchLane(request).key;
+          const pending = pendingAdmissionByLane.get(key) ?? new Set<string>();
+          pending.add(request.callId);
+          pendingAdmissionByLane.set(key, pending);
+        }
+      },
+      dispatched: (requests) => {
+        let changed = false;
+        for (const request of requests) {
+          const key = this.toolDispatchLane(request).key;
+          const pending = pendingAdmissionByLane.get(key);
+          if (!pending?.delete(request.callId)) continue;
+          changed = true;
+          if (pending.size === 0) pendingAdmissionByLane.delete(key);
+        }
+        if (changed) this.wakeToolDispatcher();
+      },
+    };
     const maxInFlightGroups = Math.max(
       1,
       Math.floor(
@@ -12319,6 +12376,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             .filter(([, count]) => count >= maxInFlightGroupsPerLane)
             .map(([laneKey]) => laneKey),
         );
+        for (const key of pendingAdmissionByLane.keys()) {
+          blockedLaneKeys.add(key);
+        }
         const dispatchable =
           inFlightToolExecutions.size >= maxInFlightGroups
             ? {
@@ -12361,7 +12421,11 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               (activeGroupsByLane.get(laneKey) ?? 0) + 1,
             );
           }
-          const tracked = this.executeBatchedToolCalls(dispatchable.requests)
+          admissionObserver.pending(dispatchable.requests);
+          const tracked = this.executeBatchedToolCalls(
+            dispatchable.requests,
+            admissionObserver,
+          )
             .catch(async (error) => {
               this.toolDispatcherFailure ??= error;
               this.rejectQueuedToolCalls(error);
@@ -12371,6 +12435,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               );
             })
             .finally(() => {
+              admissionObserver.dispatched(dispatchable.requests);
               this.observeToolDispatchGroupRoundTrip(
                 this.toolBatchDispatcherNowMs() - launchedAtMs,
               );
@@ -14231,6 +14296,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         originalLineWasRetained
           ? (this.logBuffer.contexts.at(-1) ?? undefined)
           : undefined,
+        this.logBuffer.ids.at(-1),
       );
       if (this.#options.verbose) console.log(retained);
     }
@@ -14930,6 +14996,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     return this.logBuffer.lines;
   }
 
+  getLogIds(): string[] {
+    return this.logBuffer.ids.slice();
+  }
+
   getLogContexts(): Array<PlayLogContext | null> {
     return this.logBuffer.contexts.slice();
   }
@@ -15676,6 +15746,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     toolId: string;
     requests: ToolCallRequest[];
     strategy: AnyBatchOperationStrategy;
+    admissionObserver?: ToolBatchAdmissionObserver;
   }): Promise<ToolCallRequest[]> {
     const { toolId, requests, strategy } = input;
     if (requests.length === 0) return [];
@@ -15952,6 +16023,12 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       ),
                       executionAuthScopeDigest:
                         detail.members[0]?.executionAuthScopeDigest ?? null,
+                      onProviderAdmissionPending: () =>
+                        input.admissionObserver?.pending(batch.memberRequests),
+                      onProviderDispatched: () =>
+                        input.admissionObserver?.dispatched(
+                          batch.memberRequests,
+                        ),
                       providerIdempotencyKey: detail.providerOperationKey,
                       providerIdempotencyReceiptKey:
                         compatibility.resultReceiptKey,
@@ -16199,6 +16276,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           });
           return { batch, result };
         } finally {
+          input.admissionObserver?.dispatched(batch.memberRequests);
           // A dispatch that never reached its split — a provider failure, a
           // cohort throw — must not leave the body registered against
           // nobody for the rest of the run.
@@ -16290,16 +16368,23 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
 
   private async executeBatchedToolCalls(
     queuedToolCalls: ToolCallRequest[],
+    admissionObserver?: ToolBatchAdmissionObserver,
   ): Promise<void> {
-    // Group by toolId
+    // Preserve authentication partitions through physical batch compilation.
     const byTool = new Map<string, ToolCallRequest[]>();
     for (const req of queuedToolCalls) {
-      if (!byTool.has(req.toolId)) byTool.set(req.toolId, []);
-      byTool.get(req.toolId)!.push(req);
-    }
-
-    const toolSettlements = await Promise.allSettled(
-      [...byTool.entries()].map(async ([toolId, requests]) => {
+      const key = JSON.stringify([
+        req.toolId,
+        req.executionAuthScopeDigest ?? '',
+      ]);
+      if (!byTool.has(key)) byTool.set(key, []);
+      byTool.get(key)!.push(req);
+    }
+    const toolGroups = [...byTool.values()];
+    const toolSettlements = await settleToolBatchGroups(
+      toolGroups,
+      async (requests) => {
+        const toolId = requests[0]!.toolId;
         this.runtimeLog(
           `Executing tool batch ${toolId}: ${requests.length} calls`,
         );
@@ -16430,6 +16515,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   toolId,
                   requests: cohortRequests,
                   strategy: operationStrategy,
+                  admissionObserver,
                 })
               : await this.executeCacheableNonNativeMapToolCallCohort({
                   toolId,
@@ -16524,6 +16610,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       providerOperationKey: aggregateProviderOperationKey,
                       apiOptions: {
                         durableCallReceiptKey: aggregateReceiptKey,
+                        onProviderAdmissionPending: () =>
+                          admissionObserver?.pending(batch.memberRequests),
+                        onProviderDispatched: () =>
+                          admissionObserver?.dispatched(batch.memberRequests),
                         legacyProviderRetryIdentities: [
                           {
                             transportReceiptKey:
@@ -16785,7 +16875,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             this.#options.onBatchComplete?.(this.checkpoint);
           }
         }
-      }),
+      },
+      admissionObserver,
     );
     const rejected = toolSettlements.find(
       (settlement): settlement is PromiseRejectedResult =>
@@ -17944,6 +18035,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           let providerTelemetryKey: string | null = null;
           let providerRunInFlightAtDispatch: number | null = null;
           const acquireProviderPermit = async (signal?: AbortSignal) => {
+            options?.onProviderAdmissionPending?.();
             logProvider429RetryPhase('provider_permit_wait_started');
             const permit = await this.resourceGovernor.acquireProviderPermit({
               toolId,
@@ -18094,6 +18186,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   acquireProviderPermit: async ({ signal }) =>
                     await acquireProviderPermit(signal),
                   tryAcquireProviderPermit: () => {
+                    options?.onProviderAdmissionPending?.();
                     logProvider429RetryPhase(
                       'provider_permit_acquire_attempted',
                     );
@@ -18146,6 +18239,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       > | null;
                     } = { current: null };
                     const beginProviderExecution = () => {
+                      if (providerExecution.current === null) {
+                        options?.onProviderDispatched?.();
+                      }
                       const execution =
                         providerExecution.current ??
                         this.resourceGovernor.beginProviderExecution({

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -851,7 +851,7 @@ export interface ContextOptions {
   /** Called after each durable batch completes for scheduler checkpointing. */
   onBatchComplete?: (checkpoint: PlayCheckpoint) => void;
   /** Called when the runtime emits a new execution log line. */
-  onLog?: (line: string, context?: PlayLogContext) => void;
+  onLog?: (line: string, context?: PlayLogContext, entryId?: string) => void;
   /**
    * Runtime-provided HTTP transport for ctx.fetch. Node runtimes should provide
    * a transport that validates resolved IP addresses at connect time.

package/dist/bundling-sources/shared_libs/play-runtime/fixture-behavior.ts

@@ -84,6 +84,7 @@ const FIXTURE_MODE_BYPASS_PROVIDERS = new Set([
   'test',
   'test_high',
   'test_low',
+  'test_batching',
   // Dedicated stateful failure fixtures must reach their local custom handlers
   // even when the surrounding Play runs in fixture mode.
   'test_receipt',

package/dist/bundling-sources/shared_libs/play-runtime/governor/rate-state-backend.ts

@@ -17,6 +17,9 @@ export const DEFAULT_ADVISORY_PROVIDER_MAX_RPS = 100;
 /** Cold-start rate for an unknown provider bucket shared across a fleet key. */
 export const DEFAULT_UNKNOWN_PROVIDER_COLD_START_RPS = 10;
 
+/** Learned-rate floor, independent of the unknown provider's starting guess. */
+export const DEFAULT_UNKNOWN_PROVIDER_MIN_RPS = 2;
+
 /** AIMD state cooldown cap; provider Retry-After holds remain uncapped. */
 export const PROVIDER_AIMD_COOLDOWN_CAP_MS = 45 * 60 * 1_000;
 

package/dist/bundling-sources/shared_libs/play-runtime/launch-identity.ts

@@ -52,6 +52,7 @@ export const PLAY_LAUNCH_ENVELOPE_FIELD_ROLES: {
   playId: 'detail',
   schedulerSchema: 'detail',
   requiresRunCreatedProjection: 'detail',
+  runtimeLogIdentity: 'detail',
   runtimeArtifact: 'detail',
   runtimeProtocolVersion: 'detail',
   staticPipeline: 'detail',

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

@@ -117,6 +117,23 @@ export const LOG_PROVENANCE_POLICY: Record<
   receipt: { watch: false, ui: false, debug: true },
 };
 
+/**
+ * Shared retention rule for the detached runner's positional log channel.
+ * Sender offsets and gateway persistence must count the same events. Host
+ * lifecycle output stays in worker logs; bounded performance markers also
+ * reach the durable stream for dispatcher throughput diagnostics.
+ */
+export function isDurableDirectRunnerLog(event: {
+  source?: unknown;
+  line?: unknown;
+}): boolean {
+  return (
+    typeof event.line === 'string' &&
+    event.line.length > 0 &&
+    (event.source !== 'worker' || event.line.startsWith('[perf-trace] '))
+  );
+}
+
 /** True when a line of the given provenance should render on the surface. */
 export function logProvenanceReaches(
   provenance: LogProvenance,

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/attempts/worker-terminal-projection.ts

@@ -39,10 +39,11 @@ export type PlayRunAttemptWorkerTerminalProjectionPorts = {
 };
 
 /**
- * Builds the worker projection Module. The ordering is its Interface:
- * reconcile durable truth, release failed-attempt leases, then enqueue
- * best-effort progress/outbox projection. A stale terminal fence observes the
- * winner only; it never emits a second projection sequence.
+ * Request delivery of the already committed terminal before awaited
+ * reconciliation or cleanup can delay it. Progress finalization still follows
+ * durable-truth reconciliation and failed-attempt lease release. A stale
+ * terminal fence observes the winner only; it never emits a second projection
+ * sequence.
  */
 export function createPlayRunAttemptWorkerTerminalProjection(
   ports: PlayRunAttemptWorkerTerminalProjectionPorts,
@@ -50,6 +51,7 @@ export function createPlayRunAttemptWorkerTerminalProjection(
   return {
     observeFenceLost: ports.observeFenceLost,
     async projectCommitted(input) {
+      ports.requestTerminalProjection({ terminal: input.terminal });
       await ports.reconcileTerminalTruth(input);
       if (input.terminal.status === 'failed') {
         await ports.releaseFailedAttempt({
@@ -58,7 +60,6 @@ export function createPlayRunAttemptWorkerTerminalProjection(
         });
       }
       ports.queueProgressFinalization(input);
-      ports.requestTerminalProjection({ terminal: input.terminal });
     },
   };
 }

package/dist/bundling-sources/shared_libs/play-runtime/play-runtime-batching-registry.ts

@@ -6,6 +6,7 @@ import { fullenrichBatchStrategies } from './fullenrich-batching';
 import { opensosdataBatchStrategies } from './opensosdata-batching';
 import { zerobounceBatchStrategies } from './zerobounce-batching';
 import { testAsyncBatchStrategies } from './test-async-batching';
+import { testAdmissionBatchStrategies } from './test-admission-batching';
 
 export const PLAY_RUNTIME_BATCH_OPERATION_REGISTRY: Record<
   string,
@@ -17,6 +18,7 @@ export const PLAY_RUNTIME_BATCH_OPERATION_REGISTRY: Record<
   ...fullenrichBatchStrategies,
   ...opensosdataBatchStrategies,
   ...testAsyncBatchStrategies,
+  ...testAdmissionBatchStrategies,
   ...zerobounceBatchStrategies,
 };
 

package/dist/bundling-sources/shared_libs/play-runtime/protocol.ts

@@ -185,6 +185,8 @@ export type PlayRunnerBudgetChargeResult = {
 };
 
 export interface PlayRunnerContextConfig extends RetainedPipelineCarrier {
+  /** Reader-first logging cutover, frozen at admission; absent stays legacy. */
+  runtimeLogIdentity?: 'origin';
   executorToken?: string;
   baseUrl?: string;
   /**
@@ -320,6 +322,8 @@ export type PlayRunnerLogEvent = {
   at: string;
   source: PlayLiveEventSource;
   line: string;
+  /** Origin identity, preserved across live and terminal transports. */
+  entryId?: string;
   /** Search-only context; omitted before the compatible Convex projection. */
   context?: PlayLogContext;
 };
@@ -411,6 +415,7 @@ export type PlayRunnerResult =
       outputRowCount?: number;
       rowOutcomes?: PlayRunnerRowOutcomeSummary;
       logs: string[];
+      logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
       stats: Record<string, unknown>;
@@ -426,6 +431,7 @@ export type PlayRunnerResult =
       status: 'suspended';
       suspension: PlayExecutionSuspension;
       logs: string[];
+      logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
       stats: Record<string, unknown>;
@@ -442,6 +448,7 @@ export type PlayRunnerResult =
       error: string;
       errors?: PlayRunFailureDetails[];
       logs: string[];
+      logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
       stats: Record<string, unknown>;

package/dist/bundling-sources/shared_libs/play-runtime/run-event-catalog.ts

@@ -387,6 +387,7 @@ export const RUN_SCHEDULER_OUTBOX_EVENT_TYPE = {
   runCancelled: RUN_EVENT_KIND.runCancelled,
   runEvents: 'run.events',
   runnerLogs: 'runner.logs',
+  receiptEvent: 'receipt.event',
   runWaitTimeout: 'run.wait_timeout',
 } as const;
 
@@ -549,6 +550,7 @@ export const RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL = {
   runCancelled: sqlStringLiteral(RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCancelled),
   runEvents: sqlStringLiteral(RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents),
   runnerLogs: sqlStringLiteral(RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runnerLogs),
+  receiptEvent: sqlStringLiteral(RUN_SCHEDULER_OUTBOX_EVENT_TYPE.receiptEvent),
   runWaitTimeout: sqlStringLiteral(
     RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaitTimeout,
   ),

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger-event-transport.ts

@@ -1,3 +1,4 @@
+import { normalizeRunLogIds } from './run-log-buffer';
 import { RUN_EVENT_KIND } from './run-event-catalog';
 import type { PlayRunLedgerIngressEvent } from './run-ledger';
 import type { PlayLogContext } from './log-context';
@@ -48,6 +49,14 @@ function splitRunEventForAppRuntime(
   const lineContexts = hasLineContexts
     ? (rawLineContexts as Array<PlayLogContext | null>)
     : null;
+  const payloadOwnsLineIds =
+    payload !== null && Object.hasOwn(payload, 'lineIds');
+  if (payloadOwnsLineIds && Object.hasOwn(event, 'lineIds'))
+    throw new TypeError('Run log identities must have one event owner.');
+  const lineIds = normalizeRunLogIds(
+    payloadOwnsLineIds ? payload?.lineIds : event.lineIds,
+    lines,
+  );
   const payloadChannelOffset =
     typeof payload?.channelOffset === 'number'
       ? payload.channelOffset
@@ -58,6 +67,7 @@ function splitRunEventForAppRuntime(
   const {
     lines: _outerLines,
     lineContexts: _outerLineContexts,
+    lineIds: _outerLineIds,
     ...eventWithoutOuterLines
   } = event;
   let index = 0;
@@ -68,17 +78,28 @@ function splitRunEventForAppRuntime(
       const lineBytes = appRuntimeTextEncoder.encode(
         JSON.stringify(lines[index]!),
       ).length;
+      const metadataBytes =
+        (lineContexts
+          ? appRuntimeTextEncoder.encode(JSON.stringify(lineContexts[index]))
+              .length + 1
+          : 0) +
+        (lineIds
+          ? appRuntimeTextEncoder.encode(JSON.stringify(lineIds[index]))
+              .length + 1
+          : 0);
       if (
         index > start &&
-        bytes + lineBytes + 1 > APP_RUNTIME_LOG_EVENT_MAX_JSON_BYTES
+        bytes + lineBytes + metadataBytes + 1 >
+          APP_RUNTIME_LOG_EVENT_MAX_JSON_BYTES
       ) {
         break;
       }
-      bytes += lineBytes + 1;
+      bytes += lineBytes + metadataBytes + 1;
       index += 1;
     }
     const batchLines = lines.slice(start, index);
     const batchLineContexts = lineContexts?.slice(start, index);
+    const batchLineIds = lineIds?.slice(start, index);
     split.push(
       payload
         ? {
@@ -87,13 +108,19 @@ function splitRunEventForAppRuntime(
               ? { lineContexts: batchLineContexts }
               : {}),
             ...(payloadOwnsLines ? {} : { lines: batchLines }),
+            ...(!payloadOwnsLineIds && batchLineIds
+              ? { lineIds: batchLineIds }
+              : {}),
             payload: {
               ...Object.fromEntries(
                 Object.entries(payload).filter(
-                  ([key]) => key !== 'lineContexts',
+                  ([key]) => key !== 'lineContexts' && key !== 'lineIds',
                 ),
               ),
               ...(payloadOwnsLines ? { lines: batchLines } : {}),
+              ...(payloadOwnsLineIds && batchLineIds
+                ? { lineIds: batchLineIds }
+                : {}),
               ...(payloadOwnsLineContexts && batchLineContexts
                 ? { lineContexts: batchLineContexts }
                 : {}),
@@ -109,6 +136,7 @@ function splitRunEventForAppRuntime(
             ...eventWithoutOuterLines,
             lines: batchLines,
             ...(batchLineContexts ? { lineContexts: batchLineContexts } : {}),
+            ...(batchLineIds ? { lineIds: batchLineIds } : {}),
             ...(eventChannelOffset === undefined
               ? {}
               : { channelOffset: eventChannelOffset + start }),