deepline 0.3.261 → 0.3.262

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.261',
+  version: '0.3.262',
   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

@@ -314,7 +314,9 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // deploy readiness require it; v50 only built it on the concurrent path.
 // v52 indexes only delivered outbox rows that still contain raw log bodies.
 // The concurrent build lets retention skip already-scrubbed history.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 52;
+// v53 refreshes the indexed runtime log reconciliation projection. Its query
+// indexes remain operator-prepared concurrently, outside shared bootstrap.
+export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 53;
 const POSTGRES_SCHEDULER_SCHEMA_MIGRATIONS_TABLE =
   'scheduler_schema_migrations';
 export const POSTGRES_SCHEDULER_OPEN_RECOVERY_INDEX =

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

@@ -9,10 +9,39 @@ import { normalizeRuntimeSchedulerSchema } from '../runtime-scheduler-topology';
 import type { PostgresSchedulerQueryClient } from './postgres';
 
 const EVENTS_TABLE = 'runtime_observability.events';
+const RUNTIME_EVENT_LOG_DEDUPE_INDEX = 'runtime_events_log_attempt_digest_idx';
+const RUNTIME_EVENT_LOG_POSITION_INDEX =
+  'runtime_events_log_attempt_position_idx';
+const RUNTIME_EVENT_LOG_LEGACY_INDEX =
+  'runtime_events_legacy_log_normalize_idx';
+const RUNTIME_EVENT_LOG_BODY_PAGE_INDEX = 'runtime_events_run_log_body_seq_idx';
+const RUNTIME_EVENT_LOG_LEGACY_PREDICATE = `kind = 'log.appended'
+  AND source_digest IS NOT NULL
+  AND NOT (search_doc ? 'logContentDigest')
+  AND (search_doc->>'producerAttempt') ~ '^[1-9][0-9]{0,5}$'`;
+const RUNTIME_EVENT_LOG_BODY_PAGE_PREDICATE = `kind = 'log.appended'
+  AND log_seq IS NOT NULL
+  AND (log_body IS NOT NULL OR message IS NOT NULL)`;
+const RUNTIME_EVENT_LOG_DEDUPE_PREDICATE = `kind = 'log.appended'
+  AND source_digest IS NOT NULL
+  AND search_doc ? 'producerAttempt'
+  AND search_doc ? 'logContentDigest'`;
+const RUNTIME_EVENT_LOG_POSITION_PREDICATE = `kind = 'log.appended'
+  AND search_doc ? 'producerAttempt'
+  AND search_doc ? 'logPositions'`;
+const RUNTIME_EVENT_LOG_POSITION_EXPRESSION = `jsonb_set(
+  jsonb_set(
+    jsonb_set(
+      jsonb_set(coalesce(search_doc->'logPositions', '{}'::jsonb),
+        ARRAY['producerAttempt'], search_doc->'producerAttempt', true),
+      ARRAY['_runtimeScope:' || runtime_scope], 'true'::jsonb, true),
+    ARRAY['_orgId:' || org_id], 'true'::jsonb, true),
+  ARRAY['_runId:' || run_id], 'true'::jsonb, true
+)`;
 // 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-log-context-v8-terminal-progress-counts-compact-first-progress-channel-aliases';
+  'runtime-event-search-log-context-v9-indexed-channel-reconciliation';
 export const RUNTIME_EVENTS_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 const MAX_SEARCH_WINDOW_MS = RUNTIME_EVENTS_RETENTION_MS;
 const MAX_SEARCH_RESULTS = 200;
@@ -455,12 +484,21 @@ export async function getRuntimeRunLogPage(
     // Match the event-then-cursor relation lock order used by migrations and
     // log projection. Cursor-first reads can deadlock a schema expansion.
     `WITH retained AS (
-       SELECT min(log_seq) AS first_seq, max(log_seq) AS last_seq
-         FROM runtime_observability.events
-        WHERE runtime_scope = $1 AND org_id = $2 AND run_id = $3
-          AND kind = 'log.appended' AND log_seq IS NOT NULL
-          AND (log_body IS NOT NULL OR message IS NOT NULL)
-          AND ingested_at >= clock_timestamp() - interval '7 days'
+       SELECT
+         (SELECT log_seq
+            FROM runtime_observability.events
+           WHERE runtime_scope = $1 AND org_id = $2 AND run_id = $3
+             AND kind = 'log.appended' AND log_seq IS NOT NULL
+             AND (log_body IS NOT NULL OR message IS NOT NULL)
+             AND ingested_at >= clock_timestamp() - interval '7 days'
+           ORDER BY log_seq ASC LIMIT 1) AS first_seq,
+         (SELECT log_seq
+            FROM runtime_observability.events
+           WHERE runtime_scope = $1 AND org_id = $2 AND run_id = $3
+             AND kind = 'log.appended' AND log_seq IS NOT NULL
+             AND (log_body IS NOT NULL OR message IS NOT NULL)
+             AND ingested_at >= clock_timestamp() - interval '7 days'
+           ORDER BY log_seq DESC LIMIT 1) AS last_seq
      ), run_cursor AS (
        SELECT last_seq
          FROM runtime_observability.run_log_cursors
@@ -807,7 +845,8 @@ export async function attachRuntimeEventSearchTriggers(
             doc jsonb; line_doc jsonb; line_context jsonb;
             eid text; existing_digest text; digest text; assigned_seq bigint; terminal_progress_identity boolean;
             log_channel text; log_position bigint; matched_event_id text; matched_doc jsonb;
-            legacy_position_prefix text; log_alias jsonb; envelope_attempt 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[];
             recent_log_keys jsonb := '{}'::jsonb; dedupe_key text;
             terminal_overlap_counts jsonb := '{}'::jsonb;
@@ -1013,15 +1052,53 @@ export async function attachRuntimeEventSearchTriggers(
                 END IF;
                 log_alias := jsonb_build_object('producerAttempt', (item->>'producerAttempt')::integer,
                   'logPositions', jsonb_build_object(log_channel, log_position));
+                position_alias := jsonb_build_object(
+                  'producerAttempt', (item->>'producerAttempt')::integer,
+                  '_runtimeScope:' || ${quoteLiteral(scope)}, true,
+                  '_orgId:' || run_org, true,
+                  '_runId:' || observation.run_id, true)
+                  || jsonb_build_object(log_channel, log_position);
                 matched_event_id := NULL;
-                -- A channel position names one canonical occurrence. Sorting
-                -- here makes cached plans scan the primary key on a miss.
+                position_event_ids := ARRAY[
+                  legacy_position_prefix || log_position::text,
+                  'log-worker:' || observation.run_id || ':' || (item->>'producerAttempt') || ':' || log_position::text,
+                  'log-replay:' || observation.run_id || ':' || (item->>'producerAttempt') || ':' || log_position::text,
+                  'log-envelope:' || observation.run_id || ':' || (item->>'producerAttempt') || ':' || log_position::text
+                ];
+                -- Positional identities have a bounded set of historical IDs.
+                -- Probe those primary keys directly; scanning every event in
+                -- the run for JSON containment made one lookup grow with run age.
                 SELECT event.event_id, event.source_digest, event.search_doc
                   INTO matched_event_id, existing_digest, matched_doc
                   FROM runtime_observability.events AS event
                  WHERE event.runtime_scope = ${quoteLiteral(scope)} AND event.org_id = run_org
                    AND event.run_id = observation.run_id AND event.kind = 'log.appended'
-                   AND event.search_doc @> log_alias;
+                   AND event.event_id = ANY(position_event_ids)
+                   AND (
+                     event.search_doc->'logPositions'->>log_channel = log_position::text
+                     OR (NOT (event.search_doc ? 'logPositions')
+                       AND event.event_id = legacy_position_prefix || log_position::text
+                       AND (CASE WHEN event.search_doc->>'source' = 'coordinator'
+                            THEN 'replay' ELSE 'worker' END) = log_channel)
+                   )
+                 ORDER BY event.event_id
+                 LIMIT 1;
+                IF matched_event_id IS NULL THEN
+                  -- A transport may already be aliased onto an event whose
+                  -- primary key belongs to another channel. Find that alias
+                  -- independently of content so changed bytes still fail the
+                  -- immutable-position check below.
+                  SELECT event.event_id, event.source_digest, event.search_doc
+                    INTO matched_event_id, existing_digest, matched_doc
+                    FROM runtime_observability.events AS event
+                   WHERE event.runtime_scope = ${quoteLiteral(scope)} AND event.org_id = run_org
+                     AND event.run_id = observation.run_id AND event.kind = 'log.appended'
+                     AND event.search_doc ? 'producerAttempt'
+                     AND event.search_doc ? 'logPositions'
+                     AND (${RUNTIME_EVENT_LOG_POSITION_EXPRESSION.replaceAll('search_doc', 'event.search_doc')}) @> position_alias
+                   ORDER BY event.log_seq NULLS LAST, event.event_id
+                   LIMIT 1;
+                END IF;
                 IF matched_event_id IS NOT NULL THEN
                   IF existing_digest IS DISTINCT FROM digest THEN
                     RAISE EXCEPTION 'Positional log event identity changed its content';
@@ -1036,9 +1113,12 @@ export async function attachRuntimeEventSearchTriggers(
                   FROM runtime_observability.events AS event
                  WHERE event.runtime_scope = ${quoteLiteral(scope)} AND event.org_id = run_org
                    AND event.run_id = observation.run_id AND event.kind = 'log.appended'
-                   AND event.search_doc @> jsonb_build_object(
-                     'producerAttempt', (item->>'producerAttempt')::integer, 'logContentDigest', digest)
+                   AND event.source_digest IS NOT NULL
+                   AND event.search_doc ? 'producerAttempt'
+                   AND event.search_doc ? 'logContentDigest'
+                   AND event.search_doc->>'producerAttempt' = ((item->>'producerAttempt')::integer)::text
                    AND event.source_digest = digest
+                   AND event.search_doc @> jsonb_build_object('logContentDigest', digest)
                    AND NOT (coalesce(event.search_doc->'logPositions', '{}'::jsonb) ? log_channel)
                    AND (event.search_doc ? 'logPositions' OR log_channel <>
                      CASE WHEN event.search_doc->>'source' = 'coordinator' THEN 'replay' ELSE 'worker' END)
@@ -1408,10 +1488,40 @@ export async function attachRuntimeEventSearchTriggers(
   `);
   // Replacing AFTER with BEFORE is one DDL transaction, so live inserts cannot
   // observe an interval with no projector. All older unmarked runs stay full.
+  // Once installed, leave the matching trigger attached: dropping it takes an
+  // ACCESS EXCLUSIVE lock on the busy outbox table even when only its function
+  // body or projection marker changed.
+  const outboxTrigger = await client.query<{ matches: boolean }>(
+    `SELECT EXISTS (
+      SELECT 1
+      FROM pg_trigger AS trg
+      JOIN pg_class AS rel ON rel.oid = trg.tgrelid
+      JOIN pg_namespace AS rel_ns ON rel_ns.oid = rel.relnamespace
+      JOIN pg_proc AS fn ON fn.oid = trg.tgfoid
+      JOIN pg_namespace AS fn_ns ON fn_ns.oid = fn.pronamespace
+      WHERE rel_ns.nspname = $1 AND rel.relname = 'outbox'
+        AND trg.tgname = 'runtime_outbox_event_v1'
+        AND NOT trg.tgisinternal
+        AND trg.tgenabled IN ('O', 'A')
+        AND trg.tgtype = 7
+        AND trg.tgqual IS NULL
+        AND trg.tgargs = ''::bytea
+        AND fn_ns.nspname = $1 AND fn.proname = 'search_outbox_event'
+        AND fn.pronargs = 0
+    ) AS matches`,
+    [scope],
+  );
+  if (outboxTrigger.rows[0]?.matches !== true) {
+    await client.query(`DO $replace$ BEGIN
+      IF EXISTS (SELECT 1 FROM pg_trigger WHERE tgrelid = '${schema}.outbox'::regclass
+        AND tgname = 'runtime_outbox_event_v1' AND NOT tgisinternal) THEN
+        DROP TRIGGER runtime_outbox_event_v1 ON ${schema}.outbox;
+      END IF;
+      CREATE TRIGGER runtime_outbox_event_v1 BEFORE INSERT ON ${schema}.outbox
+        FOR EACH ROW EXECUTE FUNCTION ${schema}.search_outbox_event();
+    END $replace$`);
+  }
   await client.query(`DO $create$ BEGIN
-    DROP TRIGGER IF EXISTS runtime_outbox_event_v1 ON ${schema}.outbox;
-    CREATE TRIGGER runtime_outbox_event_v1 BEFORE INSERT ON ${schema}.outbox
-      FOR EACH ROW EXECUTE FUNCTION ${schema}.search_outbox_event();
     IF NOT EXISTS (SELECT 1 FROM pg_trigger WHERE tgrelid = '${schema}.attempts'::regclass
       AND tgname = 'runtime_attempt_log_acceptance') THEN
       CREATE TRIGGER runtime_attempt_log_acceptance BEFORE UPDATE OF runner_result_json ON ${schema}.attempts
@@ -1486,6 +1596,204 @@ function normalizedRetentionPredicate(value: string): string {
     .join('');
 }
 
+// Query indexes include mixed AND/OR predicates. Remove catalog-added wrappers
+// around atomic terms, but keep boolean grouping so a changed predicate cannot
+// silently widen an index to unrelated tenant/event rows.
+function normalizedQueryIndexPredicate(value: string): string {
+  let normalized = (
+    value.match(/'(?:''|[^'])*'|::text\b|\b(?:AND|OR)\b|[()\s]+|./gi) ?? []
+  )
+    .filter((token) => token !== '::text')
+    .map((token) => {
+      if (/^(AND|OR)$/i.test(token))
+        return `\u0001${token.toUpperCase()}\u0001`;
+      return token.startsWith("'") ? token : token.replace(/\s/g, '');
+    })
+    .join('');
+  let previous: string;
+  do {
+    previous = normalized;
+    normalized = normalized
+      .replace(/\(([^()]*)\)/g, (group, expression: string) =>
+        /\u0001(?:AND|OR)\u0001/.test(expression) ? group : expression,
+      )
+      .replace(
+        /\(\(([^()]*(?:\u0001AND\u0001|\u0001OR\u0001)[^()]*)\)\)/g,
+        '($1)',
+      );
+    while (isWholeExpressionWrapped(normalized)) {
+      normalized = normalized.slice(1, -1);
+    }
+  } while (normalized !== previous);
+  return normalized;
+}
+
+function isWholeExpressionWrapped(value: string): boolean {
+  if (!value.startsWith('(') || !value.endsWith(')')) return false;
+  let depth = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] === "'") {
+      if (value[index + 1] === "'") index += 1;
+      else {
+        const closingQuote = value.indexOf("'", index + 1);
+        if (closingQuote === -1) return false;
+        index = closingQuote;
+      }
+    } else if (value[index] === '(') depth += 1;
+    else if (value[index] === ')') {
+      depth -= 1;
+      if (depth === 0 && index !== value.length - 1) return false;
+      if (depth < 0) return false;
+    }
+  }
+  return depth === 0;
+}
+
+type RuntimeEventIndexExpectation = {
+  name: string;
+  keys: string[];
+  predicate: string;
+  createSql: string;
+  method?: 'btree' | 'gin';
+  opclasses?: string[];
+};
+
+const RUNTIME_EVENT_QUERY_INDEXES: RuntimeEventIndexExpectation[] = [
+  {
+    name: RUNTIME_EVENT_LOG_POSITION_INDEX,
+    method: 'gin',
+    opclasses: ['jsonb_path_ops'],
+    keys: [
+      "jsonb_set(jsonb_set(jsonb_set(jsonb_set(COALESCE(search_doc -> 'logPositions'::text, '{}'::jsonb), ARRAY['producerAttempt'::text], search_doc -> 'producerAttempt'::text, true), ARRAY['_runtimeScope:'::text || runtime_scope], 'true'::jsonb, true), ARRAY['_orgId:'::text || org_id], 'true'::jsonb, true), ARRAY['_runId:'::text || run_id], 'true'::jsonb, true)",
+    ],
+    predicate: RUNTIME_EVENT_LOG_POSITION_PREDICATE,
+    createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS ${RUNTIME_EVENT_LOG_POSITION_INDEX}
+      ON runtime_observability.events USING gin
+        ((${RUNTIME_EVENT_LOG_POSITION_EXPRESSION}) jsonb_path_ops)
+      WHERE ${RUNTIME_EVENT_LOG_POSITION_PREDICATE}`,
+  },
+  {
+    name: RUNTIME_EVENT_LOG_DEDUPE_INDEX,
+    keys: [
+      'runtime_scope',
+      'org_id',
+      'run_id',
+      "(search_doc ->> 'producerAttempt'::text)",
+      'source_digest',
+    ],
+    predicate: RUNTIME_EVENT_LOG_DEDUPE_PREDICATE,
+    createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS ${RUNTIME_EVENT_LOG_DEDUPE_INDEX}
+      ON runtime_observability.events
+        (runtime_scope, org_id, run_id, (search_doc->>'producerAttempt'), source_digest)
+      WHERE ${RUNTIME_EVENT_LOG_DEDUPE_PREDICATE}`,
+  },
+  {
+    name: RUNTIME_EVENT_LOG_LEGACY_INDEX,
+    keys: ['runtime_scope', 'org_id', 'run_id'],
+    predicate: RUNTIME_EVENT_LOG_LEGACY_PREDICATE,
+    createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS ${RUNTIME_EVENT_LOG_LEGACY_INDEX}
+      ON runtime_observability.events (runtime_scope, org_id, run_id)
+      WHERE ${RUNTIME_EVENT_LOG_LEGACY_PREDICATE}`,
+  },
+  {
+    name: RUNTIME_EVENT_LOG_BODY_PAGE_INDEX,
+    keys: ['runtime_scope', 'org_id', 'run_id', 'log_seq'],
+    predicate: RUNTIME_EVENT_LOG_BODY_PAGE_PREDICATE,
+    createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS ${RUNTIME_EVENT_LOG_BODY_PAGE_INDEX}
+      ON runtime_observability.events (runtime_scope, org_id, run_id, log_seq)
+      WHERE ${RUNTIME_EVENT_LOG_BODY_PAGE_PREDICATE}`,
+  },
+];
+
+/** Build only operator-owned indexes, concurrently and outside a transaction. */
+export async function prepareRuntimeEventQueryIndexes(
+  client: PostgresSchedulerQueryClient,
+): Promise<void> {
+  for (const expected of RUNTIME_EVENT_QUERY_INDEXES) {
+    type IndexShape = {
+      valid: boolean;
+      ready: boolean;
+      is_unique: boolean;
+      table_matches: boolean;
+      key_count: number;
+      attribute_count: number;
+      method: string;
+      keys: string[];
+      opclasses: string[];
+      predicate: string | null;
+    };
+    const inspect = () =>
+      client.query<IndexShape>(
+        `SELECT index_row.indisvalid AS valid,
+                index_row.indisready AS ready,
+                index_row.indisunique AS is_unique,
+                index_row.indrelid = to_regclass('runtime_observability.events') AS table_matches,
+                index_row.indnkeyatts AS key_count,
+                index_row.indnatts AS attribute_count,
+                method.amname AS method,
+                ARRAY(
+                  SELECT pg_get_indexdef(index_row.indexrelid, key_number.position, true)
+                    FROM generate_series(1, index_row.indnkeyatts) AS key_number(position)
+                   ORDER BY key_number.position
+                ) AS keys,
+                (
+                  SELECT coalesce(json_agg(operator_class.opcname ORDER BY classes.position), '[]'::json)
+                    FROM unnest(index_row.indclass) WITH ORDINALITY AS classes(opclass_oid, position)
+                    JOIN pg_opclass AS operator_class ON operator_class.oid = classes.opclass_oid
+                ) AS opclasses,
+                pg_get_expr(index_row.indpred, index_row.indrelid) AS predicate
+           FROM pg_index AS index_row
+           JOIN pg_class AS index_class ON index_class.oid = index_row.indexrelid
+           JOIN pg_am AS method ON method.oid = index_class.relam
+          WHERE index_class.oid = to_regclass($1)`,
+        [`runtime_observability.${expected.name}`],
+      );
+    const assertShape = (shape: IndexShape): void => {
+      if (!shape.valid || !shape.ready) {
+        throw new Error(
+          `Runtime event index ${expected.name} is invalid or incomplete; inspect and repair the failed build explicitly.`,
+        );
+      }
+      if (
+        !shape.table_matches ||
+        shape.is_unique ||
+        shape.method !== (expected.method ?? 'btree') ||
+        (expected.opclasses !== undefined &&
+          (shape.opclasses.length !== expected.opclasses.length ||
+            shape.opclasses.some(
+              (name, index) => name !== expected.opclasses![index],
+            ))) ||
+        shape.key_count !== expected.keys.length ||
+        shape.attribute_count !== expected.keys.length ||
+        shape.keys.length !== expected.keys.length ||
+        shape.keys.some(
+          (key, index) =>
+            normalizedRetentionPredicate(key) !==
+            normalizedRetentionPredicate(expected.keys[index]!),
+        ) ||
+        shape.predicate === null ||
+        normalizedQueryIndexPredicate(shape.predicate) !==
+          normalizedQueryIndexPredicate(expected.predicate)
+      ) {
+        throw new Error(
+          `Runtime event index ${expected.name} differs from its expected table, keys, method, uniqueness or predicate. Actual catalog shape: ${JSON.stringify(shape)}. Inspect and repair it explicitly.`,
+        );
+      }
+    };
+
+    const existing = (await inspect()).rows[0];
+    if (existing) assertShape(existing);
+    await client.query(expected.createSql);
+    const built = (await inspect()).rows[0];
+    if (!built) {
+      throw new Error(
+        `Runtime event index ${expected.name} was not found after preparation.`,
+      );
+    }
+    assertShape(built);
+  }
+}
+
 /** Operator-only concurrent index build; never part of runtime bootstrap. */
 export async function prepareRuntimeEventRetentionIndex(
   client: PostgresSchedulerQueryClient,

package/dist/cli/index.js

@@ -3512,7 +3512,7 @@ var 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.261",
+  version: "0.3.262",
   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: {
     updatePreferences: 1

package/dist/cli/index.mjs

@@ -3507,7 +3507,7 @@ var 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.261",
+  version: "0.3.262",
   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: {
     updatePreferences: 1

package/dist/index.js

@@ -1325,7 +1325,7 @@ var 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.261",
+  version: "0.3.262",
   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: {
     updatePreferences: 1

package/dist/index.mjs

@@ -1229,7 +1229,7 @@ var 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.261",
+  version: "0.3.262",
   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: {
     updatePreferences: 1

package/dist/release.d.mts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.261";
+    readonly version: "0.3.262";
     readonly 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.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.d.ts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.261";
+    readonly version: "0.3.262";
     readonly 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.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.js

@@ -74,7 +74,7 @@ var 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.261",
+  version: "0.3.262",
   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: {
     updatePreferences: 1

package/dist/release.mjs

@@ -48,7 +48,7 @@ var 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.261",
+  version: "0.3.262",
   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: {
     updatePreferences: 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.3.261",
+  "version": "0.3.262",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",