deepline 0.3.386 → 0.3.388

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.386',
+  version: '0.3.388',
   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/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-XS6JCYYQ.mjs → auth-2DIKNI7P.mjs}

@@ -13,12 +13,12 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-4PW2BDZK.mjs";
-import "./chunk-FDWCSBSN.mjs";
-import "./chunk-XOQBP42J.mjs";
+} from "./chunk-OHJRJM7E.mjs";
+import "./chunk-BECUIDJV.mjs";
+import "./chunk-QPGEZ4PU.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-NXGCO4JB.mjs";
-import "./chunk-H7EGS5CE.mjs";
+import "./chunk-NRJPUSLB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-Z4NL25WP.js

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