deepline 0.3.406 → 0.3.407

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

@@ -3232,8 +3232,8 @@ export class DeeplineClient {
   /**
    * Search available tools using Deepline's ranked backend search.
    *
-   * This is the same discovery surface used by the CLI: it ranks across
-   * tool metadata, categories, agent guidance, and input schema fields.
+   * The CLI uses the same search.
+   * The search ranks tool metadata, categories, agent guidance, and input schema fields.
    */
   async searchTools(
     options: ToolSearchOptions = {},
@@ -3308,13 +3308,12 @@ export class DeeplineClient {
   /**
    * Describe a Deepline Agent model and its provider-specific option surface.
    *
-   * Combines live AI Gateway model metadata with Deepline's generated AI SDK
-   * provider option registry so agents can construct `providerOptions`
-   * payloads before executing `deeplineagent`.
+   * The method combines live AI Gateway model metadata with Deepline's generated registry of AI SDK provider options.
+   * Agents can use this information to construct `providerOptions` payloads before they execute `deeplineagent`.
    *
-   * The returned option schemas describe accepted provider option shapes, not
-   * guaranteed support for every model. Runtime AI SDK/Gateway errors remain
-   * authoritative for model-gated values.
+   * The returned schemas describe accepted shapes for provider options.
+   * These schemas do not guarantee that every model supports each option.
+   * Runtime AI SDK and Gateway errors determine support for model-specific values.
    *
    * @param model - Exact-case Gateway model id such as `"openai/gpt-5.6-luna"`
    * @returns Model metadata, provider option shapes, and runnable examples
@@ -3331,8 +3330,8 @@ export class DeeplineClient {
   /**
    * Quote dynamic AI inference pricing for a concrete payload.
    *
-   * The result separates a planning estimate from a proven authorization
-   * maximum and contains Deepline credits only.
+   * The result contains a planning estimate and a separate, proven authorization maximum.
+   * Both values use Deepline credits.
    */
   async quoteInferenceTool(
     toolId: 'ai_evaluate' | 'ai_inference' | 'deeplineagent',
@@ -3437,13 +3436,16 @@ export class DeeplineClient {
    * entrypoints: the CLI, {@link Deepline.connect}, {@link submitPlay},
    * or {@link runPlay}.
    *
-   * Supported invocation surfaces intentionally share this same run contract:
-   * `deepline plays run`, repo scripts such as `bun run deepline -- plays run`,
-   * SDK context calls like `Deepline.connect().play(name).run()`, and direct
-   * `POST /api/v2/plays/run` calls all return a workflow/run id. The completed
-   * output is always retrievable from `getPlayStatus(runId).result` (or from
-   * `PlayJob.get()` for SDK context calls). Execution logs live under
-   * `progress.logs`; they are not part of the user output object.
+   * These interfaces share the run contract and return a workflow or run ID:
+   *
+   * - `deepline plays run`.
+   * - Repository scripts such as `bun run deepline -- plays run`.
+   * - SDK context calls such as `Deepline.connect().play(name).run()`.
+   * - Direct `POST /api/v2/plays/run` calls.
+   *
+   * Read completed output from `getPlayStatus(runId).result`.
+   * For SDK context calls, read output from `PlayJob.get()`.
+   * Execution logs appear under `progress.logs`. The user output object does not contain these logs.
    *
    * @param request - Play run configuration (name, code, input, etc.)
    * @returns Run metadata including the public `workflowId`
@@ -3718,9 +3720,8 @@ export class DeeplineClient {
   /**
    * Compile a bundled play artifact into the server-side compiler manifest.
    *
-   * The manifest records imports, trigger bindings, static pipeline shape, and
-   * runtime metadata needed before a play artifact can be checked, registered,
-   * or run.
+   * The manifest records imports, trigger bindings, static pipeline shape, and runtime metadata.
+   * The compiler needs these records before it checks, registers, or runs a Play artifact.
    */
   async compilePlayManifest(input: {
     name: string;
@@ -3802,8 +3803,8 @@ export class DeeplineClient {
   /**
    * Register an already-bundled play artifact and start a run from it.
    *
-   * This is the low-level file-backed run path used by SDK/CLI packaging
-   * wrappers after local bundling has produced the runtime artifact.
+   * SDK and CLI packaging wrappers use this low-level run method for file-based Plays.
+   * Local bundling must produce the runtime artifact first.
    */
   async startPlayRunFromBundle(input: {
     name: string;
@@ -3859,15 +3860,15 @@ export class DeeplineClient {
   /**
    * Register a bundled play artifact and start a run from the live revision.
    *
-   * Convenience wrapper around {@link registerPlayArtifact} plus
-   * {@link startPlayRun}. This is the canonical file-backed path used by wrappers.
-   * The returned id can be passed to {@link getPlayStatus} to retrieve the same
-   * durable `{ result }` object that the CLI prints after `plays run` completes.
+   * This method wraps {@link registerPlayArtifact} and {@link startPlayRun}.
+   * Packaging wrappers use this method for file-based Plays.
+   * Pass the returned ID to {@link getPlayStatus}.
+   * The method returns the same durable `{ result }` object that the CLI prints after `plays run` completes.
    *
-   * @param code - Source string fallback; the bundled artifact should be passed in `options.artifact`
-   * @param csvPath - Path to input CSV file, or `null`
-   * @param name - Play name (extracted from source if omitted)
-   * @param options - Additional submission options
+   * @param code - Fallback source string. Pass the bundled artifact in `options.artifact`.
+   * @param csvPath - Path to the input CSV file, or `null`.
+   * @param name - Play name. The SDK derives it from the source when omitted.
+   * @param options - Additional submission options.
    * @returns Workflow metadata with `workflowId`
    *
    * @example
@@ -3998,9 +3999,8 @@ export class DeeplineClient {
   /**
    * Mint short-lived presigned upload targets for staged play files.
    *
-   * Internal primitive used by {@link stagePlayFiles}. The server returns an
-   * already-staged ref (no upload needed) for content-addressed files it
-   * already holds, or a presigned PUT URL the caller uploads the body to.
+   * Internal primitive used by {@link stagePlayFiles}. For a content-addressed file already in storage, the server returns a staged reference. That file needs no upload.
+   * For other files, the server returns a presigned PUT URL. Upload the file body to that URL.
    */
   async mintStagedPlayFileUploads(
     files: Array<{
@@ -4016,8 +4016,7 @@ export class DeeplineClient {
   /**
    * Resolve staged play files by content hash without uploading bytes.
    *
-   * Missing files are returned so callers can upload only the files the server
-   * does not already have.
+   * The response identifies missing files. Callers need to upload only these files.
    */
   async resolveStagedPlayFiles(
     files: Array<{
@@ -4658,11 +4657,11 @@ export class DeeplineClient {
   /**
    * Start a fresh run from a prior run's retained input and pinned revision.
    *
-   * Every invocation sends an `Idempotency-Key`. When the caller does not
-   * supply one, a fresh key is generated once per call so the transport's own
-   * network retries converge on a single rerun. Pass the same explicit key
-   * across separate invocations to repeat an ambiguous result safely; a
-   * different key intentionally starts another rerun.
+   * Every invocation sends an `Idempotency-Key`.
+   * When the caller supplies no key, the SDK creates a fresh key once per call.
+   * The transport reuses that key for network retries, so those retries produce one rerun.
+   * Reuse an explicit key across separate invocations when the previous result is uncertain.
+   * A different key starts another rerun.
    */
   async rerun(
     runId: string,
@@ -5113,8 +5112,8 @@ export class DeeplineClient {
     options?: StopAllRunsOptions,
   ): Promise<StopAllPlayRunsResult>;
   /**
-   * Stop every active run visible to the current workspace, or with
-   * `dryRun: true` enumerate the exact candidates without cancelling anything.
+   * Stop every active run visible to the current workspace.
+   * With `dryRun: true`, list the exact candidates without cancelling any run.
    *
    * This is the SDK equivalent of:
    *
@@ -5123,8 +5122,8 @@ export class DeeplineClient {
    * deepline runs stop-all --reason "stale lock"
    * ```
    *
-   * Use this when a failed parent run left child or waiting runs active and you
-   * need to clear the workspace run-slot state without knowing each run id.
+   * Use this method when a failed parent leaves active child or waiting runs.
+   * The method clears workspace run-slot state without requiring each run ID.
    */
   async stopAllRuns(
     options?: StopAllRunsOptions,
@@ -5150,8 +5149,8 @@ export class DeeplineClient {
   }
 
   /**
-   * List one page of callable plays; grep retains exhaustive matching results.
-   * Use listPlaysPage to retain pagination metadata.
+   * List one page of callable Plays. With grep, the method retains all matching results.
+   * Use listPlaysPage for pagination metadata.
    *
    * Pass `origin: "prebuilt"` for Deepline-managed prebuilts or
    * `origin: "owned"` for org-owned plays.
@@ -5736,8 +5735,7 @@ export class DeeplineClient {
   /**
    * Get the full definition and state of a named play.
    *
-   * Returns the play's revision state (draft, live), recent runs,
-   * sheet processing summary, and database URL.
+   * The response includes revision state (draft or live), recent runs, a summary of sheet processing, and the database URL.
    *
    * @param name - Play name
    * @returns Complete play detail
@@ -5813,10 +5811,10 @@ export class DeeplineClient {
   /**
    * Get a normalized play description suitable for agents and CLIs.
    *
-   * The description includes runnable examples, input/output summaries, clone
-   * guidance, revision state, and latest run metadata when available. Pass
-   * `{ pipeline: true }` to include the compiled pipeline, which can be
-   * hundreds of kilobytes and is otherwise left out.
+   * The description includes runnable examples, input and output summaries, clone guidance, and revision state.
+   * It also includes metadata for the latest run when available.
+   * Set `{ pipeline: true }` to include the compiled pipeline.
+   * The pipeline can be hundreds of kilobytes. The response omits it by default.
    */
   async describePlay(
     name: string,
@@ -5884,8 +5882,7 @@ export class DeeplineClient {
    * Make a play revision live.
    *
    * When `revisionId` is omitted, the current working revision becomes live.
-   * The live version is what executes when the play is run by name without
-   * specifying an explicit revision.
+   * A call by Play name executes the live revision unless the caller specifies another revision.
    *
    * @param name - Play name
    * @param request - Optional explicit revision to make live
@@ -6211,9 +6208,9 @@ export class DeeplineClient {
   }
 
   /**
-   * What Deepline has billed each run so far (customer-visible credits, never
-   * provider spend) and whether any of its charges is still settling — the
-   * same read the dashboard's runs grid shows. `GET /api/v2/runs/billing`.
+   * Read Deepline credits billed to each run and whether charges are still settling.
+   * The response never shows provider spend. The dashboard runs grid uses the same read.
+   * HTTP endpoint: `GET /api/v2/runs/billing`.
    */
   async getRunBilling(runIds: readonly string[]): Promise<RunBillingResult> {
     const params = new URLSearchParams();

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

@@ -192,8 +192,8 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  * A play can be triggered three ways, declared as the third argument to
  * {@link definePlay}:
  * - `webhook` — an inbound HTTP call (with optional legacy HMAC or Standard
- *   Webhooks signature verification);
- * - `cron` — a schedule; or
+ *   Webhooks signature verification).
+ * - `cron` — a schedule.
  * - `sqlListeners` — a **monitor**: the play runs whenever a monitor writes a new
  *   row to its output stream. This is how you build a play "on top of" a monitor
  *   (e.g. run enrichment every time a watched company posts a new job). Each
@@ -1232,8 +1232,8 @@ export class DeeplineContext {
    * Run a named or prebuilt play and wait for its output.
    *
    * This is the high-level SDK equivalent of `ctx.play(name).runSync(input)`.
-   * Inside a play runtime, prefer the in-play `ctx.runPlay(key, playRef, input,
-   * options)` form so the child run is checkpointed under a stable key.
+   * Inside a Play, prefer `ctx.runPlay(key, playRef, input, options)`.
+   * The runtime checkpoints the child run under a stable key.
    *
    * @param playOrRef - Play name or prebuilt/reference object.
    * @param input - JSON input passed to the play.
@@ -1630,7 +1630,10 @@ export function defineInput<TInput>(
 /**
  * Define a play — a composable TypeScript workflow for the Deepline platform.
  *
- * The returned value is both a callable function, invoked by the Deepline runtime with a runtime context, and a named play handle carrying `.run()`, `.versions()`, `.get()` and `.publish()` for remote lifecycle management. Plays are the primary abstraction for repeatable data pipelines and execute durably, with automatic retries and timeouts.
+ * The returned value is both a callable function and a named Play handle.
+ * The Deepline runtime calls the function with a runtime context.
+ * The handle provides `.run()`, `.versions()`, `.get()`, and `.publish()` for remote lifecycle operations.
+ * Plays define repeatable data pipelines. The runtime executes them durably with automatic retries and timeouts.
  *
  * @typeParam TInput - The input type accepted by the play
  * @typeParam TOutput - The return type of the play

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

@@ -202,7 +202,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.406',
+  version: '0.3.407',
   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/types.ts

@@ -1181,9 +1181,10 @@ export interface StopPlayRunResult {
   /** True if HITL state or its same-message Slack card still needs retrying. */
   hitlCancellationPending?: boolean;
   /**
-   * True only when the scheduler and the canonical run ledger disagree (for
-   * example a terminal scheduler run whose ledger projection is pending), so
-   * the stop could not be confirmed. Never set for a queued cancellation.
+   * True only when the scheduler and the canonical run ledger disagree and
+   * the server could not confirm the stop.
+   * For example, the scheduler can report a terminal run while the ledger
+   * projection is pending. This field is never true for a queued cancellation.
    */
   staleSchedulerState?: boolean;
   /** Server-side error detail when the stop failed (`state: 'failed'`). */

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

@@ -5,6 +5,7 @@ import {
   dispatchRunLedgerOutboxToLedgerThroughEventWithClientScope,
   type PostgresSchedulerOptions,
   type PostgresSchedulerOutboxDrainResult,
+  type RunLedgerDispatchLaunch,
   type RunLedgerOutboxWithClient,
 } from '../../scheduler-backends/postgres';
 
@@ -17,6 +18,8 @@ export type GatewayRunLedgerProjectionAdapterInput = {
    * against the active outbox lease while retaining supported transport hooks.
    */
   runtimeApi: WorkerRuntimeApiContext;
+  /** Immutable launch already read by the worker that committed the terminal. */
+  launch?: RunLedgerDispatchLaunch;
   withClient: RunLedgerOutboxWithClient;
   schedulerOptions?: Pick<PostgresSchedulerOptions, 'schema'>;
 };
@@ -35,6 +38,7 @@ export function createGatewayRunLedgerProjectionAdapter(
     runId: input.runId,
     runtimeApi: input.runtimeApi,
     tokenAuthority: 'gateway' as const,
+    ...(input.launch ? { dispatchLaunch: input.launch } : {}),
     ...(input.runtimeApi.signal ? { signal: input.runtimeApi.signal } : {}),
   };
   return {

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

@@ -872,6 +872,7 @@ function buildDefaultDeps(absurd: Absurd): AbsurdRuntimeWorkerDeps {
       await createRunLedgerProjectionJob({
         outbox: createGatewayRunLedgerProjectionAdapter({
           runId,
+          launch,
           runtimeApi: {
             ...absurdRuntimeApiFromLaunch(launch),
             ...(signal ? { signal } : {}),

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

@@ -19053,6 +19053,8 @@ async function claimRunLedgerOutboxPrefixInBatch(
     expectedHeadEventId?: string;
     lockStrength?: 'no_key_update';
     transportCandidate?: RunLedgerTransportCandidate;
+    /** Discover the zero-effect transport head under this transaction's run lock. */
+    discoverTransportHead?: boolean;
     recoverTransportDelivery?: boolean;
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
@@ -19093,8 +19095,22 @@ async function claimRunLedgerOutboxPrefixInBatch(
   // run/head locks a never-leased, never-frozen carrier may be acknowledged
   // locally before the next READ COMMITTED statement claims its successor.
   // Keep the successor's existing run.events-first receipt shape unchanged.
+  const recoverTransportDelivery = input.recoverTransportDelivery === true;
+  // An ACK and successor claim commit in the same transaction. For a discovered
+  // carrier whose response was lost, xmin plus the still-live successor owner
+  // proves exactly which delivery consumed this drain's allowance.
+  const ownedTransportSql = (alias: string) => `
+    to_jsonb(${alias})->>'delivery_batch_started_at' IS NULL AND EXISTS (
+      SELECT 1 FROM ${tableName('outbox', options)} AS successor
+      WHERE successor.run_id = ${alias}.run_id AND successor.delivered_at IS NULL
+        AND successor.lease_owner = ${escapeLiteral(leaseOwner!)}
+        AND successor.lease_expires_at > clock_timestamp()
+        AND successor.xmin = ${alias}.xmin
+        AND NOT ${searchLaneSql('successor')}
+    )`;
   const transportHeadSql =
-    input.transportCandidate !== undefined &&
+    (input.transportCandidate !== undefined ||
+      input.discoverTransportHead === true) &&
     input.allowIngressPrefix === true &&
     !input.searchOnly &&
     !input.extendOwnedHead &&
@@ -19112,8 +19128,12 @@ async function claimRunLedgerOutboxPrefixInBatch(
         ), eligible_transport_head AS MATERIALIZED (
           SELECT head.* FROM transport_head AS head
           WHERE current_setting('deepline.run_ledger_outbox_lock', true) = ${escapeLiteral(input.runId)}
-            AND head.event_id = ${escapeLiteral(input.transportCandidate!.eventId)}
-            AND head.delivery_key = ${escapeLiteral(input.transportCandidate!.deliveryKey)}
+            ${
+              input.transportCandidate
+                ? `AND head.event_id = ${escapeLiteral(input.transportCandidate.eventId)}
+            AND head.delivery_key = ${escapeLiteral(input.transportCandidate.deliveryKey)}`
+                : ''
+            }
             AND ${runLedgerZeroEffectTransportSql('head')}
             AND ${runLedgerTerminalPendingSql('head', options)}
             AND EXISTS (
@@ -19142,24 +19162,22 @@ async function claimRunLedgerOutboxPrefixInBatch(
             escapeLiteral(input.runId),
           )}
         )${
-          input.recoverTransportDelivery === true
+          recoverTransportDelivery
             ? `, prior_transport AS MATERIALIZED (
           SELECT prior.event_id, prior.run_id, prior.event_type, prior.delivery_key,
                  (extract(epoch FROM (prior.delivered_at-prior.created_at))*1000)::float8 AS lag_ms,
-                 to_jsonb(prior)->>'delivery_batch_started_at' IS NULL AND EXISTS (
-                   SELECT 1 FROM ${tableName('outbox', options)} AS successor
-                   WHERE successor.run_id = prior.run_id AND successor.delivered_at IS NULL
-                     AND successor.lease_owner = ${escapeLiteral(leaseOwner!)}
-                     AND successor.lease_expires_at > clock_timestamp()
-                     AND successor.xmin = prior.xmin
-                     AND NOT ${searchLaneSql('successor')}
-                 ) AS owned
+                 ${ownedTransportSql('prior')} AS owned
           FROM ${tableName('outbox', options)} AS prior
           WHERE current_setting('deepline.run_ledger_outbox_lock', true) = ${escapeLiteral(input.runId)}
             AND prior.run_id = ${escapeLiteral(input.runId)}
-            AND prior.event_id = ${escapeLiteral(input.transportCandidate!.eventId)}
-            AND prior.delivery_key = ${escapeLiteral(input.transportCandidate!.deliveryKey)}
-            AND prior.event_type = ${escapeLiteral(input.transportCandidate!.eventType)}
+            ${
+              input.transportCandidate
+                ? `AND prior.event_id = ${escapeLiteral(input.transportCandidate.eventId)}
+            AND prior.delivery_key = ${escapeLiteral(input.transportCandidate.deliveryKey)}
+            AND prior.event_type = ${escapeLiteral(input.transportCandidate.eventType)}`
+                : `AND ${runLedgerZeroEffectTransportSql('prior')}
+            AND ${ownedTransportSql('prior')}`
+            }
             AND prior.delivered_at IS NOT NULL
             AND NOT EXISTS (SELECT 1 FROM delivered)
         )`
@@ -19168,7 +19186,7 @@ async function claimRunLedgerOutboxPrefixInBatch(
           SELECT delivered.event_id, head.run_id, delivered.event_type, head.delivery_key, delivered.lag_ms
           FROM delivered JOIN eligible_transport_head AS head ON head.event_id = delivered.event_id
           ${
-            input.recoverTransportDelivery === true
+            recoverTransportDelivery
               ? `UNION ALL
           SELECT event_id,run_id,event_type,delivery_key,lag_ms FROM prior_transport WHERE owned`
               : ''
@@ -19185,13 +19203,28 @@ async function claimRunLedgerOutboxPrefixInBatch(
                          json_build_object('eventId', delivered.event_id, 'kind', 'outbox_delivered')::text)::text
         FROM transport_deliveries AS delivered
         ${
-          input.recoverTransportDelivery === true
+          recoverTransportDelivery
             ? `UNION ALL
         SELECT 'transport_unconfirmed'::text,event_id,run_id,event_type,NULL::jsonb,NULL::timestamptz,
                NULL::text,delivery_key,lag_ms,false,NULL::float8,NULL::text,NULL::text
         FROM prior_transport WHERE NOT owned`
             : ''
-        }`
+        }` +
+        (recoverTransportDelivery && !input.transportCandidate
+          ? `
+        UNION ALL
+        SELECT 'transport_unconfirmed'::text,pending.event_id,pending.run_id,pending.event_type,NULL::jsonb,NULL::timestamptz,
+               NULL::text,pending.delivery_key,0::float8,false,NULL::float8,NULL::text,NULL::text
+        FROM ${tableName('outbox', options)} AS pending
+        WHERE current_setting('deepline.run_ledger_outbox_lock', true) = ${escapeLiteral(input.runId)}
+          AND pending.run_id = ${escapeLiteral(input.runId)} AND pending.delivered_at IS NULL
+          AND pending.lease_owner = ${escapeLiteral(leaseOwner!)}
+          AND NOT ${searchLaneSql('pending')}
+          AND NOT EXISTS (SELECT 1 FROM transport_deliveries)
+        -- A renewal may have replaced the transaction proof. Hand back the
+        -- prefix instead of guessing whether a carrier spent its allowance.
+        `
+          : '')
       : undefined;
   let result: QueryResult<RunLedgerOutboxPrefixClaimRow>;
   try {
@@ -20587,6 +20620,12 @@ export type RunLedgerOutboxDispatchInput = {
    * explicit context as before.
    */
   runtimeApi?: WorkerRuntimeApiContext | null;
+  /**
+   * Immutable launch already held by a terminal producer. Reuse requires the
+   * same run and the existing qualified projection token; claims and receiver
+   * ownership proofs still read durable state. Other dispatches read SQL.
+   */
+  dispatchLaunch?: RunLedgerDispatchLaunch;
   limit?: number;
   runId?: string | null;
   leaseOwner?: string | null;
@@ -21160,19 +21199,38 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     )
       return null;
     const targetRunId = input.runId?.trim() || null;
+    const producerLaunch =
+      terminalRunId === targetRunId &&
+      !input.headEventId &&
+      tokenAuthority === 'gateway' &&
+      input.dispatchLaunch?.runId === targetRunId &&
+      usableRunLedgerExecutorToken(input.dispatchLaunch, reuseMarginMs, options)
+        ?.runLedgerIngressPrefixBatching === true
+        ? input.dispatchLaunch
+        : null;
     const selected =
       selectedFastRun ??
-      (input.waitForRunLock && targetRunId
-        ? await client.query<{
-            run_id: string;
-            dispatch_launch_json: unknown;
-            transport_head?: RunLedgerTransportCandidate | null;
-          }>(
-            `SELECT runs.run_id, ${needsLaunch ? runLedgerDispatchLaunchSql('runs') : 'NULL::jsonb'} AS dispatch_launch_json, ${transportHeadSelection} AS transport_head
+      (producerLaunch
+        ? {
+            rows: [
+              {
+                run_id: producerLaunch.runId,
+                dispatch_launch_json: producerLaunch,
+                transport_head: undefined,
+              },
+            ],
+          }
+        : input.waitForRunLock && targetRunId
+          ? await client.query<{
+              run_id: string;
+              dispatch_launch_json: unknown;
+              transport_head?: RunLedgerTransportCandidate | null;
+            }>(
+              `SELECT runs.run_id, ${needsLaunch ? runLedgerDispatchLaunchSql('runs') : 'NULL::jsonb'} AS dispatch_launch_json, ${transportHeadSelection} AS transport_head
              FROM ${tableName('runs', options)} AS runs WHERE runs.run_id = $1`,
-            [targetRunId],
-          )
-        : await selectRunForClaim(client, targetRunId));
+              [targetRunId],
+            )
+          : await selectRunForClaim(client, targetRunId));
     const runId = selected.rows[0]?.run_id;
     if (!runId)
       return {
@@ -21201,6 +21259,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
           !input.headEventId && ingressPrefixClaimed
             ? (selected.rows[0]?.transport_head ?? undefined)
             : undefined,
+        discoverTransportHead: producerLaunch !== null && ingressPrefixClaimed,
         recoverTransportDelivery: claimInvocations > 1,
       },
       options,

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -1403,7 +1403,12 @@ export type PlayAuthoringFetchResponse = {
   /** Full response body as text, with any known secret values redacted. */
   bodyText: string;
   /**
-   * The parsed body, eagerly decoded at request time. Read it as a property — `const body = res.json`, never `await res.json()`. Null when the body is empty AND when it is not valid JSON: a malformed payload is reported as null rather than thrown, so check `res.ok` and fall back to `res.bodyText` before treating null as an empty result.
+   * The runtime parses the body at request time.
+   * Read the property with `const body = res.json`. Do not call `await res.json()`.
+   * The value is null when the body is empty or is not valid JSON.
+   * Malformed JSON produces null instead of an error.
+   *
+   * Check `res.ok`. Check `res.bodyText` before you interpret null as an empty response.
    */
   json: unknown | null;
 };

package/dist/cli/auth-4JTX6AGM.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkIY6GKJ4Ojs = require('./chunk-IY6GKJ4O.js');
+require('./chunk-D2ZRMZKF.js');
+require('./chunk-THHM4DPE.js');
+require('./chunk-Q2E4E4FJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-7LKYHZVB.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkIY6GKJ4Ojs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkIY6GKJ4Ojs.authStatusLine; exports.clearPendingClaim = _chunkIY6GKJ4Ojs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkIY6GKJ4Ojs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkIY6GKJ4Ojs.handleRegister; exports.handleStatus = _chunkIY6GKJ4Ojs.handleStatus; exports.handleWait = _chunkIY6GKJ4Ojs.handleWait; exports.httpJson = _chunkIY6GKJ4Ojs.httpJson; exports.readPendingAuthClaim = _chunkIY6GKJ4Ojs.readPendingAuthClaim; exports.readStatusBanner = _chunkIY6GKJ4Ojs.readStatusBanner; exports.registerAuthCommands = _chunkIY6GKJ4Ojs.registerAuthCommands; exports.reportSetupCompleted = _chunkIY6GKJ4Ojs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkIY6GKJ4Ojs.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkIY6GKJ4Ojs.statusBannerLine;

package/dist/cli/{auth-U7LIMXIS.mjs → auth-WURWNNLE.mjs}

@@ -13,13 +13,13 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-2MLY2ZBT.mjs";
-import "./chunk-5IGBBYXH.mjs";
-import "./chunk-CGX4NSS3.mjs";
+} from "./chunk-UFFSOV6I.mjs";
+import "./chunk-BKC6VMYZ.mjs";
+import "./chunk-ZBCTXQ3P.mjs";
 import "./chunk-YHPYUZZX.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-NXGCO4JB.mjs";
-import "./chunk-42RUJLQI.mjs";
+import "./chunk-UPEOEYZ3.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {