deepline 0.3.187 → 0.3.188

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.187',
+  version: '0.3.188',
   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/runtime-api.ts

@@ -88,6 +88,7 @@ import {
   activeRuntimeSheetAttemptFenceSql,
   newerTerminalRuntimeSheetRowSql,
   releasableRuntimeSheetAttemptFenceSql,
+  sameOwnerTerminalAttemptEpochSql,
 } from './sheet-attempt-sql';
 import type { MapRowOutcome } from './durability-store';
 import { RUNTIME_CAPACITY_POLICY } from './runtime-capacity-policy';
@@ -7119,6 +7120,7 @@ export type RuntimeMapRowsWriteResult = {
 type RuntimeMapRowsMutationResult = {
   updated: number;
   fencedRows: RuntimeMapRowsStaleRow[];
+  conflictKeys: string[];
 };
 
 const RUNTIME_MAP_ROWS_STALE_REASONS: ReadonlySet<RuntimeMapRowsStaleReason> =
@@ -7308,6 +7310,7 @@ async function completeRuntimeMapRowChunks(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
+  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -7335,6 +7338,7 @@ async function completeRuntimeMapRowChunks(
       updated: number;
       matched_keys: string[];
       fenced_rows: unknown;
+      conflict_keys: string[];
     }>(
       `WITH updates AS (
          SELECT key_values._key,
@@ -7351,7 +7355,6 @@ async function completeRuntimeMapRowChunks(
        ),
        matched_updates AS (
          SELECT target._key AS matched_key,
-                updates._key AS submitted_key,
                 target._status AS prev_status,
                 target._cell_meta AS prev_cell_meta,
                 updates.input_index,
@@ -7361,6 +7364,40 @@ async function completeRuntimeMapRowChunks(
            JOIN ${sheetTable(session)} AS target
              ON target._key = updates._key
        ),
+       same_version_conflicts AS (
+         SELECT updates.matched_key AS _key
+           FROM matched_updates AS updates
+           JOIN ${sheetTable(session)} AS target
+             ON target._key = updates.matched_key
+          WHERE $13::bigint IS NOT NULL
+            AND target._write_version = $13::bigint
+            AND target._run_id = $5::text
+            AND target._status IN ('enriched', 'failed')
+            AND (
+              EXISTS (
+                SELECT 1
+                  FROM unnest($8::text[]) AS field_values(field)
+                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
+              )
+              OR (
+                coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
+                AND COALESCE(target._attempt_seq, 0) = $12::integer
+              )
+            )
+            AND (
+              target._status <> 'enriched'
+              OR (${targetChangedPatchedCellSql})
+            )
+            -- First terminal wins: suppress conflict for same owner+epoch already-terminal row.
+            -- Durable replay (omitted_terminal_replay) from same attempt epoch is idempotent.
+            AND NOT (
+              $10::text IS NOT NULL
+              AND $12::integer IS NOT NULL
+              AND target._status = 'enriched'
+              AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
+              AND COALESCE(target._attempt_seq, 0) = $12::integer
+            )
+       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'enriched',
@@ -7377,6 +7414,7 @@ async function completeRuntimeMapRowChunks(
              _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
          FROM matched_updates AS updates
          WHERE target._key = updates.matched_key
+                   AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
 		           AND ($13::bigint IS NULL OR target._write_version = $13::bigint)
                    AND ($13::bigint IS NOT NULL OR target._status <> 'enriched')
 		           AND NOT (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
@@ -7386,27 +7424,14 @@ async function completeRuntimeMapRowChunks(
              OR ($9::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$9::text', '$10::text', '$11::timestamptz', '$12::integer')})
 		             OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
            )
-           -- A same-version enriched row is already the durable result for this
-           -- logical run. Provider retries may produce a different payload or
-           -- timestamp; preserve the first terminal value. Input-index repair
-           -- remains writable when the submitted key itself changed.
+           -- First terminal wins: skip UPDATE for already-terminal same-owner+epoch row.
+           -- Even though we excluded from conflicts, we still no-op here for idempotency.
            AND NOT (
-             $13::bigint IS NOT NULL
-             AND target._write_version = $13::bigint
-             AND target._run_id = $5::text
+             $10::text IS NOT NULL
+             AND $12::integer IS NOT NULL
              AND target._status = 'enriched'
-             AND updates.submitted_key = target._key
-             AND (
-               EXISTS (
-                 SELECT 1
-                   FROM unnest($8::text[]) AS field_values(field)
-                  WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
-               )
-               OR (
-                 $10::text IS NOT NULL
-                 AND target._attempt_owner_run_id IS NOT DISTINCT FROM $10::text
-               )
-             )
+             AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
+             AND COALESCE(target._attempt_seq, 0) = $12::integer
            )
            AND (
              target._status <> 'enriched'
@@ -7539,6 +7564,7 @@ async function completeRuntimeMapRowChunks(
          (SELECT count(*)::int FROM applied_rows) AS updated,
          coalesce((SELECT array_agg(matched_key) FROM matched_updates), '{}'::text[]) AS matched_keys,
          coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
+         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys,
          (SELECT count(*)::int FROM summary_delta) AS summary_delta_count,
          (SELECT count(*)::int FROM column_delta) AS column_delta_count`,
       [
@@ -7559,12 +7585,19 @@ async function completeRuntimeMapRowChunks(
     );
     const matchedKeys = new Set(rows[0]?.matched_keys ?? []);
     const chunkFencedRows = parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows);
+    const chunkConflictKeys = rows[0]?.conflict_keys ?? [];
     // An exact-version replay that already produced the same terminal value is
     // accepted idempotently even when SQL has no physical mutation to apply.
     // Stale versions remain excluded through fenced_rows.
     const appliedCount = Number(rows[0]?.updated ?? 0);
     updated += appliedCount;
     fencedRows.push(...chunkFencedRows);
+    conflictKeys.push(...chunkConflictKeys);
+
+    if (chunkConflictKeys.length > 0) {
+      continue;
+    }
+
     if (matchedKeys.size === chunk.length) {
       continue;
     }
@@ -7582,8 +7615,9 @@ async function completeRuntimeMapRowChunks(
     );
     updated += repaired.updated;
     fencedRows.push(...repaired.fencedRows);
+    conflictKeys.push(...repaired.conflictKeys);
   }
-  return { updated, fencedRows };
+  return { updated, fencedRows, conflictKeys };
 }
 
 async function completeRuntimeMapRowChunksWithInputIndexRepair(
@@ -7593,6 +7627,7 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
+  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -7612,6 +7647,7 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
     const { rows } = await client.query<{
       _key?: string;
       fenced_rows?: unknown;
+      conflict_keys?: string[];
       updated?: number;
     }>(
       `WITH updates AS (
@@ -7643,6 +7679,40 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
              )
           ORDER BY target._key, (target._key = updates._key) DESC
        ),
+       same_version_conflicts AS (
+         SELECT updates.submitted_key AS _key
+           FROM matched_updates AS updates
+           JOIN ${sheetTable(session)} AS target
+             ON target._key = updates.matched_key
+          WHERE $13::bigint IS NOT NULL
+            AND target._write_version = $13::bigint
+            AND target._run_id = $5::text
+            AND target._status IN ('enriched', 'failed')
+            AND (
+              EXISTS (
+                SELECT 1
+                  FROM unnest($8::text[]) AS field_values(field)
+                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
+              )
+              OR (
+                coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
+                AND COALESCE(target._attempt_seq, 0) = $12::integer
+              )
+            )
+            AND (
+              target._status <> 'enriched'
+              OR (${targetChangedPatchedCellSql})
+            )
+            -- First terminal wins: suppress conflict for same owner+epoch already-terminal row.
+            -- Durable replay (omitted_terminal_replay) from same attempt epoch is idempotent.
+            AND NOT (
+              $10::text IS NOT NULL
+              AND $12::integer IS NOT NULL
+              AND target._status = 'enriched'
+              AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
+              AND COALESCE(target._attempt_seq, 0) = $12::integer
+            )
+       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'enriched',
@@ -7660,31 +7730,14 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
          FROM matched_updates AS updates, ${sheetTable(session)} AS prev
          WHERE target._key = updates.matched_key
            AND prev._key = target._key
+           AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
            AND ($13::bigint IS NULL OR target._write_version = $13::bigint)
            AND ($13::bigint IS NOT NULL OR target._status <> 'enriched')
 		           AND NOT (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
            AND (
              ($9::text IS NULL AND target._run_id = $5::text)
              OR ($9::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$9::text', '$10::text', '$11::timestamptz', '$12::integer')})
-           OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
-           )
-           AND NOT (
-             $13::bigint IS NOT NULL
-             AND target._write_version = $13::bigint
-             AND target._run_id = $5::text
-             AND target._status = 'enriched'
-             AND updates.submitted_key = target._key
-             AND (
-               EXISTS (
-                 SELECT 1
-                   FROM unnest($8::text[]) AS field_values(field)
-                  WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
-               )
-               OR (
-                 $10::text IS NOT NULL
-                 AND target._attempt_owner_run_id IS NOT DISTINCT FROM $10::text
-               )
-             )
+		             OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
            )
            AND (
              target._status <> 'enriched'
@@ -7813,7 +7866,8 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
        )
        SELECT
          (SELECT count(*)::int FROM applied_rows) AS updated,
-         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows`,
+         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
+         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys`,
       [
         chunkKeys,
         chunkInputIndexes,
@@ -7832,8 +7886,9 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
     );
     updated += Number(rows[0]?.updated ?? 0);
     fencedRows.push(...parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows));
+    conflictKeys.push(...(rows[0]?.conflict_keys ?? []));
   }
-  return { updated, fencedRows };
+  return { updated, fencedRows, conflictKeys };
 }
 
 async function insertMissingCompletedMapRowChunks(
@@ -8029,6 +8084,7 @@ async function failRuntimeMapRowChunks(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
+  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -8061,6 +8117,7 @@ async function failRuntimeMapRowChunks(
     const { rows } = await client.query<{
       updated?: number;
       fenced_rows?: unknown;
+      conflict_keys?: string[];
     }>(
       `WITH updates AS (
          SELECT key_values._key,
@@ -8081,7 +8138,6 @@ async function failRuntimeMapRowChunks(
        matched_updates AS (
          SELECT DISTINCT ON (target._key)
                 target._key AS matched_key,
-                updates._key AS submitted_key,
                 updates.data_patch,
                 updates.cell_meta_patch,
                 updates.error
@@ -8095,6 +8151,42 @@ async function failRuntimeMapRowChunks(
              )
           ORDER BY target._key, (target._key = updates._key) DESC
        ),
+       same_version_conflicts AS (
+         SELECT updates.matched_key AS _key
+           FROM matched_updates AS updates
+           JOIN ${sheetTable(session)} AS target
+             ON target._key = updates.matched_key
+          WHERE $16::bigint IS NOT NULL
+            AND target._write_version = $16::bigint
+            AND target._run_id = $6::text
+            AND target._status IN ('enriched', 'failed')
+            AND (
+              EXISTS (
+                SELECT 1
+                  FROM unnest($9::text[]) AS field_values(field)
+                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $6::text
+              )
+              OR (
+                coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
+                AND COALESCE(target._attempt_seq, 0) = $14::integer
+              )
+            )
+            AND (
+              target._status <> 'failed'
+              OR target._error IS DISTINCT FROM updates.error
+              OR (${targetChangedPatchedCellSql})
+            )
+            -- Same-owner terminal replay is not a conflict. Normal replay
+            -- preserves the first value below; explicit force-failure may update it.
+            -- Different owners and attempt epochs still conflict.
+            AND NOT (
+              $12::text IS NOT NULL
+              AND $14::integer IS NOT NULL
+              AND target._status IN ('failed', 'enriched')
+              AND coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
+              AND COALESCE(target._attempt_seq, 0) = $14::integer
+            )
+       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'failed',
@@ -8111,6 +8203,7 @@ async function failRuntimeMapRowChunks(
              _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
          FROM matched_updates AS updates, ${sheetTable(session)} AS prev
          WHERE target._key = updates.matched_key
+           AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
            AND ($16::bigint IS NULL OR target._write_version = $16::bigint)
            AND prev._key = target._key
            AND ($15::boolean OR target._status <> 'enriched')
@@ -8119,16 +8212,15 @@ async function failRuntimeMapRowChunks(
              ($11::text IS NULL AND target._run_id = $6::text)
              OR ($11::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$11::text', '$12::text', '$13::timestamptz', '$14::integer')})
 	           )
-           -- Normal replay preserves the first terminal value for an exact
-           -- same-version key. Force-failure is the explicit teardown escape
-           -- hatch and may still overwrite it.
+           -- First terminal wins for failed rows too, BUT only when NOT force-failing.
+           -- Normal replay: no-op when already-failed OR already-enriched from same owner+epoch.
            AND NOT (
              $15::boolean = FALSE
-             AND $16::bigint IS NOT NULL
-             AND target._write_version = $16::bigint
-             AND target._run_id = $6::text
+             AND $12::text IS NOT NULL
+             AND $14::integer IS NOT NULL
              AND target._status IN ('failed', 'enriched')
-             AND updates.submitted_key = target._key
+             AND coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
+             AND COALESCE(target._attempt_seq, 0) = $14::integer
            )
          RETURNING target._key, prev._status AS prev_status
        ),
@@ -8225,7 +8317,8 @@ async function failRuntimeMapRowChunks(
        )
        SELECT
          (SELECT count(*)::int FROM applied_rows) AS updated,
-         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows`,
+         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
+         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys`,
       [
         chunkKeys,
         chunkInputIndexes,
@@ -8247,10 +8340,12 @@ async function failRuntimeMapRowChunks(
     );
     const appliedCount = Number(rows[0]?.updated ?? 0);
     const chunkFencedRows = parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows);
+    const chunkConflictKeys = rows[0]?.conflict_keys ?? [];
     updated += appliedCount;
     fencedRows.push(...chunkFencedRows);
+    conflictKeys.push(...chunkConflictKeys);
   }
-  return { updated, fencedRows };
+  return { updated, fencedRows, conflictKeys };
 }
 
 /**
@@ -8461,9 +8556,10 @@ export async function completeRuntimeMapRows(
               return {
                 updated: updated.updated + inserted.inserted,
                 fencedRows: updated.fencedRows,
+                conflictKeys: updated.conflictKeys,
               };
             })()
-          : { updated: 0, fencedRows: [] };
+          : { updated: 0, fencedRows: [], conflictKeys: [] };
       const failed =
         failedRows.length > 0
           ? await failRuntimeMapRowChunks(client, session, {
@@ -8482,7 +8578,17 @@ export async function completeRuntimeMapRows(
                 input.tableNamespace,
               ),
             })
-          : { updated: 0, fencedRows: [] };
+          : { updated: 0, fencedRows: [], conflictKeys: [] };
+      const conflictKeys = [...completed.conflictKeys, ...failed.conflictKeys];
+      if (conflictKeys.length > 0) {
+        throw new Error(
+          `Runtime Sheet received the same write version with a different terminal payload for row(s): ${[
+            ...new Set(conflictKeys),
+          ]
+            .slice(0, 10)
+            .join(', ')}.`,
+        );
+      }
       return classifyRuntimeMapRowsWrite({
         submittedKeys: uniqueRows.keys(),
         updated: completed.updated + failed.updated,

package/dist/bundling-sources/shared_libs/play-runtime/sheet-attempt-sql.ts

@@ -41,11 +41,11 @@ export function releasableRuntimeSheetAttemptFenceSql(
 }
 
 /**
- * Predicate for callers that need to identify a terminal row from the same
- * attempt owner + epoch. Runtime map persistence now enforces first-terminal
- * idempotency inline because its write-version and row-key context are also
- * required; keep this helper exported for compatibility with external
- * conformance checks and integrations.
+ * Predicate for durable replay idempotency: matches rows that are already
+ * terminal (enriched or failed) from the same attempt owner + epoch. Used to
+ * suppress same-version conflicts when a worker restarts and re-runs map rows
+ * that it already completed. First terminal state wins; payload/error drift on
+ * replay is accepted as a no-op rather than rejected as a conflict.
  */
 export function sameOwnerTerminalAttemptEpochSql(
   tableAlias: string,

package/dist/cli/index.js

@@ -3051,7 +3051,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.187",
+  version: "0.3.188",
   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

@@ -3046,7 +3046,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.187",
+  version: "0.3.188",
   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

@@ -864,7 +864,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.187",
+  version: "0.3.188",
   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

@@ -768,7 +768,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.187",
+  version: "0.3.188",
   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.187";
+    readonly version: "0.3.188";
     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.187";
+    readonly version: "0.3.188";
     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.187",
+  version: "0.3.188",
   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.187",
+  version: "0.3.188",
   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.187",
+  "version": "0.3.188",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",