deepline 0.3.385 → 0.3.387

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.385',
+  version: '0.3.387',
   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/run-event-catalog.ts

@@ -485,6 +485,15 @@ export const RUN_LOG_RETENTION_MAX_LINES = 25_000;
 export const RUN_LOG_RETENTION_MAX_BYTES = 5 * 1024 * 1024;
 export const RUN_LOG_PAGE_MAX_LIMIT = 1_000;
 export const RUN_LOG_PAGE_DEFAULT_LIMIT = RUN_LOG_PAGE_MAX_LIMIT;
+/**
+ * Per-fact bound for a retained terminal log tail. Deferred projection splits
+ * a larger tail into consecutive facts at write time, so one materialization
+ * prefix projects at most eight such facts whatever the tail length. The byte
+ * bound counts each line with its context, metadata and identity; a single
+ * entry larger than it travels alone rather than being truncated.
+ */
+export const RUN_LOG_TERMINAL_FACT_MAX_LINES = RUN_LOG_PAGE_MAX_LIMIT;
+export const RUN_LOG_TERMINAL_FACT_MAX_BYTES = 256 * 1024;
 export const RUN_LOG_TAIL_DEFAULT_LIMIT = 200;
 export const RUN_LOG_FAILED_VIEW_MAX_LINES = 20;
 export const RUN_LOG_RATE_LIMIT_POLICY = {

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

@@ -18021,6 +18021,18 @@ function outboxByEventIdSql(
     )`;
 }
 
+/**
+ * `failed_at IS NULL` in a form the planner cannot use to choose a partial
+ * index. Every outbox partial index that run_id does not lead requires
+ * `failed_at IS NULL`, and statistics taken between bursts record those
+ * indexes as empty. A run-scoped probe that proves their predicate therefore
+ * scans every run's pending facts instead of its own. The check still applies
+ * to each row, including a concurrently updated row under FOR UPDATE.
+ */
+function outboxNotFailedSql(alias: string): string {
+  return `coalesce(${alias}.failed_at IS NULL, false)`;
+}
+
 // A projection receipt has always admitted at most eight ordered outbox facts.
 // Share that existing boundary between its SQL snapshot and prefix validation.
 const RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS = 8;
@@ -18290,7 +18302,7 @@ function runLedgerTerminalPendingSql(
       AND terminal_event.run_id = ${alias}.run_id
       AND terminal_event.event_type IN (${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled})
       AND terminal_event.delivered_at IS NULL
-      AND terminal_event.failed_at IS NULL
+      AND ${outboxNotFailedSql('terminal_event')}
       AND coalesce(terminal_event.next_attempt_at, terminal_event.created_at) <= now()
   )`;
 }
@@ -18307,7 +18319,7 @@ function runLedgerWaitingPendingSql(
       -- Detached runner parks are transport-only and project no public wait.
       AND waiting_event.payload_json->>'kind' IS DISTINCT FROM 'detached_runner'
       AND waiting_event.delivered_at IS NULL
-      AND waiting_event.failed_at IS NULL
+      AND ${outboxNotFailedSql('waiting_event')}
       AND coalesce(waiting_event.next_attempt_at, waiting_event.created_at) <= now())`;
 }
 
@@ -18481,7 +18493,7 @@ async function claimPostgresSchedulerOutboxPrefix(
           AND EXISTS (
             SELECT 1 FROM ${tableName('outbox', options)} AS target
             WHERE target.run_id = $2 AND target.event_id = $6
-              AND ${pending('target')} AND target.failed_at IS NULL
+              AND ${pending('target')} AND ${outboxNotFailedSql('target')}
           )`
               : ''
           }
@@ -18491,9 +18503,10 @@ async function claimPostgresSchedulerOutboxPrefix(
           AND candidate.lease_owner = $3 AND candidate.lease_expires_at > clock_timestamp()`
               : ''
           }
-          AND candidate.failed_at IS NULL
+          AND ${outboxNotFailedSql('candidate')}
           AND coalesce(candidate.next_attempt_at, candidate.created_at) <= now()
           AND ($2::text IS NULL OR candidate.run_id = $2)
+          ${runId !== null ? 'AND candidate.run_id = $2::text' : ''}
           AND (
             $3::text IS NULL
             OR candidate.lease_owner = $3::text
@@ -18621,7 +18634,7 @@ async function claimPostgresSchedulerOutboxPrefix(
           ${runId !== null ? 'AND outbox.run_id = $2::text' : ''}
           ${findSearchBlockersOnce ? 'AND outbox.event_id = ANY(ARRAY(SELECT event_id FROM search_facts))' : ''}
           AND ${searchLaneSql('outbox')} = ${input.searchOnly === true ? 'true' : 'false'}
-          AND outbox.failed_at IS NULL
+          AND ${outboxNotFailedSql('outbox')}
           -- Admission is causally first and must be projected alone. A later
           -- start/terminal append may not leapfrog a delayed queued row.
           AND (

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

@@ -35,7 +35,12 @@ import {
   type RunEventQueryRetention,
   type RunEventSummaryResult,
 } from '../run-event-query';
-import { RUN_LOG_LEVELS, type RunLogLevel } from '../run-event-catalog';
+import {
+  RUN_LOG_LEVELS,
+  RUN_LOG_TERMINAL_FACT_MAX_BYTES,
+  RUN_LOG_TERMINAL_FACT_MAX_LINES,
+  type RunLogLevel,
+} from '../run-event-catalog';
 import type { PostgresSchedulerQueryClient } from './postgres';
 import {
   RUN_EVENT_CONVEX_INTERNAL_KIND_SQL_LITERAL,
@@ -86,7 +91,7 @@ const RUNTIME_EVENT_LOG_POSITION_EXPRESSION = `jsonb_set(
 // Migration readiness tracks this projection body independently of scheduler
 // wire and schema versions. Bump when a changed trigger must be reinstalled.
 export const RUNTIME_EVENT_SEARCH_OUTBOX_PROJECTION_MARKER =
-  'runtime-event-search-primary-key-fence-direct-independent-receipts';
+  'runtime-event-search-direct-receipts-bounded-terminal-log-facts';
 /** Trusted trigger-authored state; absent on already-projected legacy rows. */
 export const RUNTIME_EVENT_DEFERRED_PROJECTION_FIELD =
   '_runtimeSearchProjectionPending';
@@ -2965,6 +2970,112 @@ export async function attachRuntimeEventSearchTriggers(
     END
     $function$
   `);
+  // A retained terminal tail can hold the whole runner log. Split it here, at
+  // the write every producer build shares, so no deferred fact grows with it.
+  // Each chunk is the log.appended item the projector already builds from
+  // terminalLogLines, with its own channelOffset: positions, origin IDs,
+  // contexts and metadata are unchanged, and older projectors read it as is.
+  // Earlier chunks become preceding runner.logs facts; the carrier keeps the
+  // last chunk after its own progress events, so lines stay in causal order.
+  await client.query(`
+    CREATE OR REPLACE FUNCTION ${schema}.split_terminal_log_envelope(observation ${schema}.outbox)
+    RETURNS ${schema}.outbox
+    LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog AS $function$
+    DECLARE payload jsonb := observation.payload_json; attempt jsonb; line_count integer;
+            has_contexts boolean; has_metadata boolean; has_ids boolean;
+            sizes integer[]; starts integer[] := ARRAY[0]; items jsonb[];
+            chunk_lines integer := 0; chunk_bytes bigint := 0; line_position integer; chunk_number integer;
+    BEGIN
+      attempt := coalesce(NULLIF(payload->'producerAttempt', 'null'::jsonb),
+        payload->'terminalWorkCounterSegment'->'attempt');
+      has_contexts := jsonb_typeof(payload->'terminalLogContexts') = 'array';
+      has_metadata := payload ? 'terminalLogMetadata';
+      has_ids := jsonb_typeof(payload->'terminalLogIds') = 'array';
+      line_count := jsonb_array_length(payload->'terminalLogLines');
+      -- Malformed or unpositioned envelopes stay whole so the projector
+      -- reports them exactly as before. Legacy runs deliver these lines to
+      -- the Convex ledger and keep their single carrier.
+      IF line_count = 0
+        OR NOT coalesce((attempt #>> '{}') ~ '^[1-9][0-9]{0,5}$', false)
+        OR (payload ? 'terminalLogContexts' AND jsonb_typeof(payload->'terminalLogContexts') <> 'null'
+          AND NOT (has_contexts AND jsonb_array_length(payload->'terminalLogContexts') = line_count))
+        OR (has_metadata AND NOT (jsonb_typeof(payload->'terminalLogMetadata') = 'array'
+          AND jsonb_array_length(payload->'terminalLogMetadata') = line_count))
+        OR (payload ? 'terminalLogIds' AND jsonb_typeof(payload->'terminalLogIds') <> 'null'
+          AND NOT (has_ids AND jsonb_array_length(payload->'terminalLogIds') = line_count))
+        OR (payload ? 'terminalProgressEvents'
+          AND jsonb_typeof(payload->'terminalProgressEvents') IS DISTINCT FROM 'array')
+        OR NOT EXISTS (SELECT 1 FROM ${schema}.runs WHERE run_id = observation.run_id
+          AND (run_log_store = 'planet_scale' OR run_event_store = 'planet_scale'))
+        -- A retried producer write conflicts and inserts nothing.
+        OR EXISTS (SELECT 1 FROM ${schema}.outbox WHERE event_id = observation.event_id) THEN
+        RETURN observation;
+      END IF;
+      SELECT array_agg(octet_length(entry.line::text)
+          + coalesce(octet_length(entry.context::text), 0)
+          + coalesce(octet_length(entry.metadata::text), 0)
+          + coalesce(octet_length(entry.id::text), 0) + 8 ORDER BY entry.position)
+        INTO sizes
+        FROM ROWS FROM (
+          jsonb_array_elements(payload->'terminalLogLines'),
+          jsonb_array_elements(CASE WHEN has_contexts THEN payload->'terminalLogContexts' ELSE '[]'::jsonb END),
+          jsonb_array_elements(CASE WHEN has_metadata THEN payload->'terminalLogMetadata' ELSE '[]'::jsonb END),
+          jsonb_array_elements(CASE WHEN has_ids THEN payload->'terminalLogIds' ELSE '[]'::jsonb END)
+        ) WITH ORDINALITY AS entry(line, context, metadata, id, position);
+      FOR line_position IN 1..line_count LOOP
+        IF chunk_lines > 0 AND (chunk_lines >= ${RUN_LOG_TERMINAL_FACT_MAX_LINES}
+          OR chunk_bytes + sizes[line_position] > ${RUN_LOG_TERMINAL_FACT_MAX_BYTES}) THEN
+          starts := starts || (line_position - 1);
+          chunk_lines := 0;
+          chunk_bytes := 0;
+        END IF;
+        chunk_lines := chunk_lines + 1;
+        chunk_bytes := chunk_bytes + sizes[line_position];
+      END LOOP;
+      IF cardinality(starts) = 1 THEN
+        RETURN observation;
+      END IF;
+      -- Same item, with the same null stripping, as the projector's envelope.
+      SELECT array_agg(chunked.item ORDER BY chunked.number) INTO items
+        FROM (
+          SELECT width_bucket((entry.position - 1)::integer, starts) AS number,
+            jsonb_strip_nulls(jsonb_build_object(
+              'type', ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}, 'runId', observation.run_id,
+              'source', 'terminal', 'producerAttempt', attempt,
+              'channelOffset', min(entry.position) - 1,
+              'lines', jsonb_agg(entry.line ORDER BY entry.position),
+              'lineContexts', CASE WHEN has_contexts THEN jsonb_agg(entry.context ORDER BY entry.position) END,
+              'lineMetadata', CASE WHEN has_metadata THEN jsonb_agg(entry.metadata ORDER BY entry.position) END,
+              'lineIds', CASE WHEN has_ids THEN jsonb_agg(entry.id ORDER BY entry.position) END
+            )) AS item
+            FROM ROWS FROM (
+              jsonb_array_elements(payload->'terminalLogLines'),
+              jsonb_array_elements(CASE WHEN has_contexts THEN payload->'terminalLogContexts' ELSE '[]'::jsonb END),
+              jsonb_array_elements(CASE WHEN has_metadata THEN payload->'terminalLogMetadata' ELSE '[]'::jsonb END),
+              jsonb_array_elements(CASE WHEN has_ids THEN payload->'terminalLogIds' ELSE '[]'::jsonb END)
+            ) WITH ORDINALITY AS entry(line, context, metadata, id, position)
+           GROUP BY 1
+        ) AS chunked;
+      FOR chunk_number IN 1..cardinality(items) - 1 LOOP
+        INSERT INTO ${schema}.outbox (event_id, run_id, event_type, payload_json, created_at)
+        VALUES ('terminal-log-chunk:' || observation.event_id || ':' || chunk_number, observation.run_id,
+          ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runnerLogs},
+          jsonb_build_object('producerAttempt', attempt,
+            'terminalProgressEvents', jsonb_build_array(items[chunk_number])),
+          observation.created_at + (chunk_number - 1) * interval '1 microsecond')
+        ON CONFLICT (event_id) DO NOTHING;
+      END LOOP;
+      observation.created_at := observation.created_at
+        + (cardinality(items) - 1) * interval '1 microsecond';
+      observation.payload_json := (payload - 'terminalLogLines' - 'terminalLogContexts'
+          - 'terminalLogMetadata' - 'terminalLogIds')
+        || jsonb_build_object('terminalProgressEvents',
+          coalesce(payload->'terminalProgressEvents', '[]'::jsonb)
+            || jsonb_build_array(items[cardinality(items)]));
+      RETURN observation;
+    END
+    $function$
+  `);
   await client.query(`
     CREATE OR REPLACE FUNCTION ${schema}.search_outbox_event() RETURNS trigger
     LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog AS $function$
@@ -2973,6 +3084,10 @@ export async function attachRuntimeEventSearchTriggers(
       IF NEW.payload_json->'${RUNTIME_EVENT_SEARCH_ONLY_FIELD}' = 'true'::jsonb THEN RETURN NEW; END IF;
       IF ${schema}.defer_runtime_event_projection_for_run(NEW.run_id)
         AND NEW.event_type <> ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runCreated} THEN
+        IF NEW.event_type IN (${RUN_EVENT_TERMINAL_LOG_CARRIER_SQL_LIST})
+          AND jsonb_typeof(NEW.payload_json->'terminalLogLines') = 'array' THEN
+          NEW := ${schema}.split_terminal_log_envelope(NEW);
+        END IF;
         IF NEW.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents} THEN
           -- One cheap Run fence captures whether ingress preceded terminal
           -- closure. No indexed log lookup or search mutex runs under it.
@@ -3204,6 +3319,7 @@ export async function attachRuntimeEventSearchTriggers(
     ${schema}.guard_runtime_outbox_ack(),
     ${schema}.compact_runtime_outbox_payload(${schema}.outbox),
     ${schema}.accept_runner_log_payload(), ${schema}.search_outbox_event(),
+    ${schema}.split_terminal_log_envelope(${schema}.outbox),
     ${schema}.compact_run_log_result(), ${schema}.without_log_events(jsonb),
     ${schema}.convex_projection_event(jsonb), ${schema}.convex_projection_events(jsonb),
     ${schema}.run_log_metadata(text, jsonb, timestamptz), ${schema}.compact_runner_log_envelope(jsonb), ${schema}.without_runtime_log_tail(jsonb)

package/dist/cli/{auth-4D4IBZZN.mjs → auth-CKRRMJQU.mjs}

@@ -13,12 +13,12 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-SC2MM6IY.mjs";
-import "./chunk-TIBMH2VI.mjs";
-import "./chunk-NV5VCWNJ.mjs";
+} from "./chunk-4KTBZLGR.mjs";
+import "./chunk-BXRWG6ZG.mjs";
+import "./chunk-7F5HBT3S.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-NXGCO4JB.mjs";
-import "./chunk-TTIISDJB.mjs";
+import "./chunk-CWZRBSMO.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-M65RW5ZI.js

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkDVVYOV2Ojs = require('./chunk-DVVYOV2O.js');
+require('./chunk-FUTYFVJR.js');
+require('./chunk-A5L54JX6.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-7JETEXCL.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkDVVYOV2Ojs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkDVVYOV2Ojs.authStatusLine; exports.clearPendingClaim = _chunkDVVYOV2Ojs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkDVVYOV2Ojs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkDVVYOV2Ojs.handleRegister; exports.handleStatus = _chunkDVVYOV2Ojs.handleStatus; exports.handleWait = _chunkDVVYOV2Ojs.handleWait; exports.httpJson = _chunkDVVYOV2Ojs.httpJson; exports.readPendingAuthClaim = _chunkDVVYOV2Ojs.readPendingAuthClaim; exports.readStatusBanner = _chunkDVVYOV2Ojs.readStatusBanner; exports.registerAuthCommands = _chunkDVVYOV2Ojs.registerAuthCommands; exports.reportSetupCompleted = _chunkDVVYOV2Ojs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkDVVYOV2Ojs.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkDVVYOV2Ojs.statusBannerLine;