deepline 0.3.353 → 0.3.354

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.353',
+  version: '0.3.354',
   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/scheduler-backends/postgres.ts

@@ -20633,7 +20633,9 @@ async function dispatchRunLedgerOutboxBatchWithScope(
             for (const row of result.rows)
               prefix[row.ordinal - 1]!.payload = row.payload;
           } catch (error) {
-            await client.query('ROLLBACK');
+            // A query timeout may already have closed this connection. Keep
+            // the delivery failure for retry classification and diagnostics.
+            await client.query('ROLLBACK').catch(() => undefined);
             throw error;
           }
         });

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

@@ -86,7 +86,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-origin-batches-new-run-cutover-fresh-origin';
+  'runtime-event-search-origin-batch-fields-once';
 /** Trusted trigger-authored state; absent on already-projected legacy rows. */
 export const RUNTIME_EVENT_DEFERRED_PROJECTION_FIELD =
   '_runtimeSearchProjectionPending';
@@ -2027,23 +2027,28 @@ export async function attachRuntimeEventSearchTriggers(
   await client.query(`
     CREATE OR REPLACE FUNCTION ${schema}.project_origin_log_batch(observation ${schema}.outbox, item jsonb, run_org text, play text, compact_logs boolean, canonical_events boolean, at_time timestamptz, doc jsonb, closed boolean)
     RETURNS text[] LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog AS $function$
-    DECLARE fresh text[]; mismatches bigint;
+    DECLARE fresh text[]; mismatches bigint; expected_ids text[]; existing_identities jsonb;
+      batch_lines jsonb := item->'lines';
+      batch_ids jsonb := item->'lineIds';
+      batch_contexts jsonb := item->'lineContexts';
+      batch_metadata jsonb := item->'lineMetadata';
+      batch_event jsonb := item - 'lines' - 'lineContexts' - 'lineIds' - 'lineMetadata';
     BEGIN
-      IF jsonb_typeof(item->'lineIds') IS DISTINCT FROM 'array'
-        OR jsonb_array_length(item->'lineIds') <> jsonb_array_length(item->'lines')
-        OR EXISTS (SELECT 1 FROM jsonb_array_elements(item->'lineIds') id WHERE jsonb_typeof(id) <> 'string' OR (id #>> '{}') !~ '^[A-Za-z0-9:_-]{1,128}$')
-        OR (SELECT count(DISTINCT id) FROM jsonb_array_elements(item->'lineIds') id) <> jsonb_array_length(item->'lineIds') THEN
+      IF jsonb_typeof(batch_ids) IS DISTINCT FROM 'array'
+        OR jsonb_array_length(batch_ids) <> jsonb_array_length(batch_lines)
+        OR EXISTS (SELECT 1 FROM jsonb_array_elements(batch_ids) id WHERE jsonb_typeof(id) <> 'string' OR (id #>> '{}') !~ '^[A-Za-z0-9:_-]{1,128}$')
+        OR (SELECT count(DISTINCT id) FROM jsonb_array_elements(batch_ids) id) <> jsonb_array_length(batch_ids) THEN
         RAISE EXCEPTION 'Origin log identities must be distinct bounded strings aligned with lines';
       END IF;
-      IF EXISTS (SELECT 1 FROM jsonb_array_elements(item->'lines') line WHERE jsonb_typeof(line) <> 'string') THEN
+      IF EXISTS (SELECT 1 FROM jsonb_array_elements(batch_lines) line WHERE jsonb_typeof(line) <> 'string') THEN
         RAISE EXCEPTION 'Search projection requires log line strings';
       END IF;
       IF item ? 'lineContexts' AND EXISTS (
-        SELECT 1 FROM jsonb_array_elements(item->'lineContexts') ctx
+        SELECT 1 FROM jsonb_array_elements(batch_contexts) ctx
         WHERE jsonb_typeof(ctx) NOT IN ('object', 'null')
       ) THEN RAISE EXCEPTION 'Search projection log context must be an object'; END IF;
       IF item ? 'lineContexts' AND EXISTS (
-        SELECT 1 FROM jsonb_array_elements(item->'lineContexts') ctx
+        SELECT 1 FROM jsonb_array_elements(batch_contexts) ctx
         WHERE jsonb_typeof(ctx) = 'object' AND (
           (SELECT count(*) FROM jsonb_object_keys(ctx)) > 8 OR octet_length(ctx::text) > 2064
           OR EXISTS (SELECT 1 FROM jsonb_each(ctx) field WHERE
@@ -2053,28 +2058,31 @@ export async function attachRuntimeEventSearchTriggers(
             OR (jsonb_typeof(field.value) = 'number' AND octet_length(field.value #>> '{}') > 32))
         )
       ) THEN RAISE EXCEPTION 'Search projection log context has an unsupported key or value'; END IF;
+      -- Generic plans cannot fold item field extraction or removal. Cache the
+      -- aligned arrays and event header once: rebuilding a multi-megabyte item
+      -- per line makes retained terminal envelopes quadratic even on replay.
       WITH entries AS MATERIALIZED (
         SELECT value #>> '{}' AS body, ordinality AS ordinal,
-          'log-origin:' || observation.run_id || ':' || (item->'lineIds'->>(ordinality-1)::int) AS eid,
-          NULLIF(item->'lineContexts'->(ordinality-1)::int, 'null'::jsonb) AS ctx,
-          ${schema}.run_log_metadata(value #>> '{}', item->'lineMetadata'->(ordinality-1)::int, at_time) AS metadata
-        FROM jsonb_array_elements(item->'lines') WITH ORDINALITY
+          'log-origin:' || observation.run_id || ':' || (batch_ids->>(ordinality-1)::int) AS eid,
+          NULLIF(batch_contexts->(ordinality-1)::int, 'null'::jsonb) AS ctx,
+          ${schema}.run_log_metadata(value #>> '{}', batch_metadata->(ordinality-1)::int, at_time) AS metadata
+        FROM jsonb_array_elements(batch_lines) WITH ORDINALITY
       ), inserted AS (
         INSERT INTO runtime_observability.events (
           runtime_scope, org_id, event_id, event_seq, event_payload, occurred_at,
           run_id, play_name, kind, level, message, log_body, source_digest, log_text_digest, search_doc
         ) SELECT ${quoteLiteral(scope)}, run_org, eid,
           CASE WHEN canonical_events THEN nextval('runtime_observability.runtime_event_order_seq') END,
-          CASE WHEN canonical_events THEN jsonb_strip_nulls((item - 'lines' - 'lineContexts' - 'lineIds' - 'lineMetadata') || jsonb_build_object(
+          CASE WHEN canonical_events THEN jsonb_strip_nulls(batch_event || jsonb_build_object(
             'type', ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}, 'runId', observation.run_id,
             'occurredAt', metadata->'occurredAt', 'level', metadata->'level', 'stepId', metadata->'stepId', 'lineOrdinal', ordinal,
-            'entryId', item->'lineIds'->(ordinal-1)::int, 'context', ctx)) END,
+            'entryId', batch_ids->(ordinal-1)::int, 'context', ctx)) END,
           to_timestamp((metadata->>'occurredAt')::double precision / 1000), observation.run_id, play, ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}, metadata->>'level',
           CASE WHEN compact_logs THEN NULL ELSE left(body, 2048) END, body,
           CASE WHEN ctx IS NULL THEN encode(sha256(convert_to(body,'UTF8')),'hex')
             ELSE encode(sha256(convert_to(jsonb_build_array(body,ctx)::text,'UTF8')),'hex') END,
           encode(sha256(convert_to(btrim(body),'UTF8')),'hex'),
-          doc || (metadata - 'occurredAt') || jsonb_strip_nulls(jsonb_build_object('entryId', item->'lineIds'->(ordinal-1)::int, 'context', ctx))
+          doc || (metadata - 'occurredAt') || jsonb_strip_nulls(jsonb_build_object('entryId', batch_ids->(ordinal-1)::int, 'context', ctx))
         FROM entries WHERE NOT closed ORDER BY ordinal
         ON CONFLICT (runtime_scope, org_id, event_id) DO NOTHING RETURNING event_id
       ) SELECT coalesce(array_agg(inserted.event_id ORDER BY entries.ordinal), ARRAY[]::text[])
@@ -2082,27 +2090,31 @@ export async function attachRuntimeEventSearchTriggers(
       -- The INSERT already proves the content of every fresh identity. Only
       -- retries or a concurrent uniqueness winner need a journal read-back.
       -- This fast path serves both inline and background origin projection.
-      IF cardinality(fresh) = jsonb_array_length(item->'lines') THEN
+      IF cardinality(fresh) = jsonb_array_length(batch_lines) THEN
         RETURN fresh;
       END IF;
       -- A new READ COMMITTED statement sees a concurrent uniqueness winner.
-      -- Tombstones retain digest/identity: retry never restores an expired body.
-      SELECT count(*) INTO mismatches
-      FROM jsonb_array_elements(item->'lines') WITH ORDINALITY AS entries(body, ordinal)
-      -- Keep each replay proof on the journal primary key. An unrestricted
-      -- join can hash the whole shared org history for a small JSON batch.
-      LEFT JOIN LATERAL (
-        SELECT event.run_id, event.kind, event.source_digest
+      -- Resolve the whole key set once. A per-line LATERAL lookup can choose
+      -- a non-leading event_id index scan when scope/org statistics are skewed,
+      -- re-reading the same history for every ID even though the PK is unique.
+      SELECT array_agg('log-origin:' || observation.run_id || ':' || (id #>> '{}') ORDER BY ordinal)
+        INTO expected_ids FROM jsonb_array_elements(batch_ids) WITH ORDINALITY AS ids(id, ordinal);
+      SELECT jsonb_object_agg(event.event_id, jsonb_build_object(
+        'runId', event.run_id, 'kind', event.kind, 'digest', event.source_digest))
+        INTO existing_identities
         FROM runtime_observability.events event
-        WHERE event.runtime_scope = ${quoteLiteral(scope)} AND event.org_id = run_org
-          AND event.event_id = 'log-origin:' || observation.run_id || ':' || (item->'lineIds'->>(ordinal-1)::int)
-        -- The primary key admits one row; retain a parameterized point lookup.
-        LIMIT 1
-      ) event ON true
-      WHERE event.run_id IS DISTINCT FROM observation.run_id OR event.kind IS DISTINCT FROM ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}
-        OR event.source_digest IS DISTINCT FROM CASE WHEN NULLIF(item->'lineContexts'->(ordinal-1)::int, 'null'::jsonb) IS NULL
+       WHERE event.runtime_scope = ${quoteLiteral(scope)} AND event.org_id = run_org
+         AND event.event_id = ANY(expected_ids);
+      -- JSON key lookups preserve one proof per identity without a join whose
+      -- generic plan can multiply the two variable-size sets. Tombstones keep
+      -- their digest/identity: retry never restores an expired body.
+      SELECT count(*) INTO mismatches
+      FROM jsonb_array_elements(batch_lines) WITH ORDINALITY AS entries(body, ordinal)
+      WHERE existing_identities->expected_ids[ordinal]->>'runId' IS DISTINCT FROM observation.run_id
+        OR existing_identities->expected_ids[ordinal]->>'kind' IS DISTINCT FROM ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}
+        OR existing_identities->expected_ids[ordinal]->>'digest' IS DISTINCT FROM CASE WHEN NULLIF(batch_contexts->(ordinal-1)::int, 'null'::jsonb) IS NULL
           THEN encode(sha256(convert_to(body #>> '{}','UTF8')),'hex')
-          ELSE encode(sha256(convert_to(jsonb_build_array(body #>> '{}',item->'lineContexts'->(ordinal-1)::int)::text,'UTF8')),'hex') END;
+          ELSE encode(sha256(convert_to(jsonb_build_array(body #>> '{}',batch_contexts->(ordinal-1)::int)::text,'UTF8')),'hex') END;
       IF mismatches > 0 THEN
         RAISE EXCEPTION 'Origin log identity changed its content or ingress is closed after terminal acceptance';
       END IF;
@@ -2119,7 +2131,7 @@ export async function attachRuntimeEventSearchTriggers(
             log_channel text; log_position bigint; matched_event_id text; matched_doc jsonb;
             legacy_position_prefix text; position_event_ids text[];
             log_alias jsonb; position_alias jsonb; envelope_attempt jsonb;
-            line_count bigint; fresh_event_ids text[] := ARRAY[]::text[];
+            line_count bigint; fresh_event_ids text[] := ARRAY[]::text[]; fresh_positions jsonb;
             recent_log_keys jsonb := '{}'::jsonb; dedupe_key text;
             terminal_overlap_counts jsonb := '{}'::jsonb;
             recent_log_keys_loaded boolean := false; recent_log_attempt text;
@@ -2769,16 +2781,18 @@ export async function attachRuntimeEventSearchTriggers(
         DO UPDATE SET last_seq = runtime_observability.run_log_cursors.last_seq + EXCLUDED.last_seq,
                       updated_at = clock_timestamp()
         RETURNING last_seq INTO assigned_seq;
-        -- Bound sequence assignment before joining the variable-size ID list.
-        -- Shared-journal history from other runs is never a candidate.
+        -- Build ordinal lookup once. Generic plans estimate a run and unnest
+        -- as tiny, then compare every inserted line against the entire ID list
+        -- in a nested loop. Fresh IDs came only from this transaction's inserts
+        -- for this scope/org/run, so the primary-key set is the complete target.
+        SELECT jsonb_object_agg(fresh.event_id, fresh.ordinality)
+          INTO fresh_positions
+          FROM unnest(fresh_event_ids) WITH ORDINALITY AS fresh(event_id, ordinality);
         UPDATE runtime_observability.events AS event
-           SET log_seq = assigned_seq - line_count + fresh.ordinality
-          FROM unnest(fresh_event_ids) WITH ORDINALITY AS fresh(event_id, ordinality)
+           SET log_seq = assigned_seq - line_count + (fresh_positions->>event.event_id)::bigint
          WHERE event.runtime_scope = ${quoteLiteral(scope)}
            AND event.org_id = run_org
-           AND event.run_id = observation.run_id
-           AND event.event_id = ANY(fresh_event_ids)
-           AND event.event_id = fresh.event_id;
+           AND event.event_id = ANY(fresh_event_ids);
       END IF;
       RETURN;
     END

package/dist/cli/auth-6UTAYZYH.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkC4YFKD7Bjs = require('./chunk-C4YFKD7B.js');
+require('./chunk-RQJORG4F.js');
+require('./chunk-QFD3VXQS.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-B6SRSDBH.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkC4YFKD7Bjs.EXIT_WORKSPACE_MISMATCH; exports.clearPendingClaim = _chunkC4YFKD7Bjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkC4YFKD7Bjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkC4YFKD7Bjs.handleRegister; exports.handleStatus = _chunkC4YFKD7Bjs.handleStatus; exports.handleWait = _chunkC4YFKD7Bjs.handleWait; exports.readPendingAuthClaim = _chunkC4YFKD7Bjs.readPendingAuthClaim; exports.registerAuthCommands = _chunkC4YFKD7Bjs.registerAuthCommands; exports.reportSetupCompleted = _chunkC4YFKD7Bjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkC4YFKD7Bjs.resolvePendingAuthClaimForResume;

package/dist/cli/{auth-FVIZVTCB.mjs → auth-WLFZLPVL.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-CQQ5N4YO.mjs";
-import "./chunk-ZDEO3EGW.mjs";
-import "./chunk-U3FUXTIB.mjs";
+} from "./chunk-GVXFIFI3.mjs";
+import "./chunk-XAXLATYC.mjs";
+import "./chunk-YK2XGEY3.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-RRDCBCRI.mjs";
+import "./chunk-HEN4YY2R.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";