deepline 0.1.200 → 0.1.201

package/dist/bundling-sources/apps/play-runner-workers/src/entry.ts

@@ -6173,7 +6173,20 @@ function createMinimalWorkerCtx(
           ? ` cells=${totalStepCells}/${totalStepCellsCompleted}/${totalStepCellsSkipped}`
           : '';
       await flushQueuedMapProgressUpdates();
-      callbacks?.onMapCompleted?.(mapNodeId, completedAt);
+      // Ordering invariant (progress-before-terminal): the authoritative final
+      // progress bump MUST land in the live progress map and reach the ledger
+      // BEFORE `onMapCompleted` emits the map node's `step.completed`
+      // transition. The reducer's `step.completed` event carries no progress of
+      // its own — it inherits `current.progress` (run-ledger.ts step.completed
+      // case). If we emitted `step.completed` first (as this used to), the step
+      // could settle on the last mid-flight throttled bump (e.g. completed=2 of
+      // a 10-row hint) while the reconciled terminal bump was still pending on
+      // the throttled ledger channel, persisting the run forever as completed
+      // with a stale "2/10" fraction. Draining the final bump first makes that
+      // lost-update race structurally impossible: by the time `step.completed`
+      // is enqueued, `stepProgressByNodeId[mapNodeId]` already holds
+      // `completed=finalizedRowsWritten`, `total=completed+failed`, so the
+      // settled step inherits truthful counts (`completed + failed === total`).
       await updateMapProgress({
         completed: finalizedRowsWritten,
         total: finalizedRowsWritten + totalRowsFailed,
@@ -6188,6 +6201,7 @@ function createMinimalWorkerCtx(
                 finalizedRowsWritten,
               ),
       });
+      callbacks?.onMapCompleted?.(mapNodeId, completedAt);
       emitEvent({
         type: 'log',
         level: totalRowsFailed > 0 ? 'warn' : 'info',
@@ -7011,9 +7025,10 @@ function createMinimalWorkerCtx(
                   options?.timeoutMs == null && !childNeedsWorkflowScheduler,
                 body: {
                   name: resolvedName,
-                  childIdempotencyKey: wasFailed && receiptContext.leaseId
-                    ? `${receiptKey}:claim:${receiptContext.leaseId}`
-                    : receiptKey,
+                  childIdempotencyKey:
+                    wasFailed && receiptContext.leaseId
+                      ? `${receiptKey}:claim:${receiptContext.leaseId}`
+                      : receiptKey,
                   input: isRecord(input) ? input : {},
                   orgId: req.orgId,
                   callbackUrl: req.callbackUrl,

package/dist/bundling-sources/sdk/src/release.ts

@@ -106,10 +106,10 @@ export const SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: '0.1.200',
+  version: '0.1.201',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.200',
+    latest: '0.1.201',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -31,6 +31,32 @@ export type PlayRunLedgerEventSource =
   | 'coordinator'
   | 'system';
 
+/**
+ * Live progress for a single step/node.
+ *
+ * Verified producer semantics (workers_edge map executor —
+ * `apps/play-runner-workers/src/entry.ts`):
+ *
+ * - `completed` counts SUCCESSFULLY written rows ONLY, never failures/skips.
+ *   In-flight it is `min(total, totalRowsWritten + completedExecutedRows)`
+ *   where `completedExecutedRows` increments on success only (entry.ts:5635);
+ *   failures increment the separate `failedExecutedRows` (entry.ts:5684).
+ *   At map finalize it is set to `finalizedRowsWritten` (successes).
+ * - `failed` counts settled-but-failed rows (row-failure isolation persists
+ *   these; they re-execute on the next run).
+ * - `total` is the settled-row denominator. In-flight it is the row-count
+ *   estimate (`rowCountHint`); at map finalize it is reconciled to
+ *   `completed + failed` and CAN SHRINK from the initial estimate when rows are
+ *   filtered/skipped. So `total` is monotonic-up during flight but is corrected
+ *   down to the settled count at terminal.
+ *
+ * Terminal invariant: once the step is settled, `completed + failed === total`.
+ * Because `completed` is successes-only (NOT all-settled), readers must NOT
+ * assume `completed === total` at terminal — a truthful terminal render is
+ * `{total} rows` when `failed === 0`, else a `completed`/`failed`/`total`
+ * breakdown. See `settleRunningStepsOnTerminal` for why the reducer does not
+ * force `completed = total`.
+ */
 export type PlayRunLedgerStepProgress = {
   completed?: number;
   total?: number;
@@ -775,6 +801,23 @@ function retryablePlatformDeployFailureSnapshot(
   );
 }
 
+// Force-settles steps still marked `running` when the RUN reaches a terminal
+// status (the fallback for steps that never emitted their own step.completed,
+// e.g. a crash between the last progress bump and the terminal event). This
+// only flips status and stamps `completedAt`; it deliberately does NOT
+// reconcile `progress.completed` to `progress.total`.
+//
+// Why not reconcile: per PlayRunLedgerStepProgress semantics, `completed`
+// counts SUCCESSES ONLY, so `completed === total` is NOT a valid invariant at
+// terminal — a run can legitimately settle with failed/skipped rows (row-
+// failure isolation). Forcing `completed = total` here would fabricate
+// successes that never happened and falsify the persisted counts. The truthful
+// terminal counts are carried by the producer's final reconciled bump, which
+// the workers_edge finalize path now drains BEFORE emitting step.completed
+// (entry.ts finalize ordering invariant). This settle path is the last-resort
+// heal for the missing-final-bump case, where the honest thing is "we know it
+// stopped, we do not know it fully succeeded" — leave the last observed
+// counts, just mark it settled so the UI stops rendering a live ticker.
 function settleRunningStepsOnTerminal(
   snapshot: PlayRunLedgerSnapshot,
   status: Extract<PlayRunLedgerStepStatus, 'completed' | 'failed'>,

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -726,6 +726,75 @@ async function isRuntimeSheetSchemaReady(
   }
 }
 
+/**
+ * Report exactly what the scoped runtime role can see for the sheet table, from
+ * the same connection the readiness probe uses. When ensure_sheet reports the
+ * table as provisioned but the runner probe still returns not-ready, the cause
+ * is almost always that the runtime role lacks a privilege on the freshly
+ * created table (so information_schema.columns hides the attempt columns) or a
+ * schema/table-name mismatch. This turns the previously blind "still not ready"
+ * error into an actionable one that names the concrete missing piece.
+ */
+async function readRuntimeSheetSchemaDiagnostic(
+  session: RuntimePostgresSession,
+): Promise<Record<string, unknown>> {
+  const query = async (
+    client: RuntimeQueryClient,
+  ): Promise<Record<string, unknown>> => {
+    const visibleColumns = await client.query<{ column_name: string }>(
+      `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = $1
+          AND table_name = $2
+        ORDER BY ordinal_position
+      `,
+      [session.postgres.schema, session.postgres.sheetTable],
+    );
+    const privileges = await client.query<Record<string, unknown>>(
+      `
+        SELECT
+          current_user AS probe_role,
+          to_regclass($3) IS NOT NULL AS regclass_visible,
+          has_table_privilege(current_user, $3, 'SELECT') AS can_select,
+          has_table_privilege(current_user, $3, 'INSERT') AS can_insert,
+          has_table_privilege(current_user, $3, 'UPDATE') AS can_update
+      `,
+      [
+        session.postgres.schema,
+        session.postgres.sheetTable,
+        `${quoteIdentifier(session.postgres.schema)}.${quoteIdentifier(session.postgres.sheetTable)}`,
+      ],
+    );
+    const visible = new Set(visibleColumns.rows.map((row) => row.column_name));
+    return {
+      schema: session.postgres.schema,
+      table: session.postgres.sheetTable,
+      probeRole: privileges.rows[0]?.probe_role ?? null,
+      regclassVisible: privileges.rows[0]?.regclass_visible ?? null,
+      canSelect: privileges.rows[0]?.can_select ?? null,
+      canInsert: privileges.rows[0]?.can_insert ?? null,
+      canUpdate: privileges.rows[0]?.can_update ?? null,
+      visibleColumnCount: visible.size,
+      missingAttemptColumns: RUNTIME_SHEET_ATTEMPT_COLUMNS.filter(
+        (column) => !visible.has(column),
+      ),
+    };
+  };
+  try {
+    if (isRuntimeOneShotQueryFactoryRegistered()) {
+      return await withRuntimeOneShotPostgres(session, query);
+    }
+    return await withRuntimePostgres(session, query);
+  } catch (error) {
+    return {
+      schema: session.postgres.schema,
+      table: session.postgres.sheetTable,
+      diagnosticError: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 async function waitForRuntimeSheetSchemaReadyAfterEnsure(
   session: RuntimePostgresSession,
   input: {
@@ -839,7 +908,7 @@ async function ensureRuntimeSheetForPreloadedSession(
       phase: 'ensure_sheet_for_preloaded_session',
       ms: Date.now() - ensureStartedAt,
     });
-    const readyAfterEnsure = await waitForRuntimeSheetSchemaReadyAfterEnsure(
+    let readyAfterEnsure = await waitForRuntimeSheetSchemaReadyAfterEnsure(
       input.session,
       {
         sheetContract: input.sheetContract,
@@ -847,8 +916,39 @@ async function ensureRuntimeSheetForPreloadedSession(
       },
     );
     if (!readyAfterEnsure) {
+      // ensure_sheet provisions the sheet as the tenant admin role, but the
+      // preloaded session probes as the scoped runtime role. When the tenant
+      // role contract was only partially applied (e.g. role-membership grants
+      // skipped on a data plane where the owner cannot administer roles), the
+      // runtime role never inherits access to the freshly created table, so its
+      // information_schema view hides the attempt columns and the probe stays
+      // not-ready even though the table exists. Re-apply the storage grants
+      // through the same self-heal the pre-ensure probe uses, then re-check
+      // once. This is a grant repair, not a blind retry: if the runtime role
+      // still cannot see the sheet, we fail loudly below with the concrete
+      // runtime-role view.
+      const repairStartedAt = Date.now();
+      await repairRuntimeStorageGrants(context, {
+        playName: context.playName,
+      });
+      input.timings?.push({
+        phase: 'repair_storage_grants_after_preloaded_session_ensure',
+        ms: Date.now() - repairStartedAt,
+        retried: true,
+      });
+      readyAfterEnsure = await waitForRuntimeSheetSchemaReadyAfterEnsure(
+        input.session,
+        {
+          sheetContract: input.sheetContract,
+          timings: input.timings,
+        },
+      );
+    }
+    if (!readyAfterEnsure) {
+      const diagnostic = await readRuntimeSheetSchemaDiagnostic(input.session);
       throw new Error(
-        `Runtime sheet schema for ctx.dataset("${input.tableNamespace}") is still not ready after ensure_sheet.`,
+        `Runtime sheet schema for ctx.dataset("${input.tableNamespace}") is still not ready after ensure_sheet. ` +
+          `Runtime-role view: ${JSON.stringify(diagnostic)}`,
       );
     }
   })();

package/dist/cli/index.js

@@ -623,10 +623,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.200",
+  version: "0.1.201",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.200",
+    latest: "0.1.201",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/cli/index.mjs

@@ -608,10 +608,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.200",
+  version: "0.1.201",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.200",
+    latest: "0.1.201",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/index.js

@@ -422,10 +422,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.200",
+  version: "0.1.201",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.200",
+    latest: "0.1.201",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/index.mjs

@@ -352,10 +352,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.200",
+  version: "0.1.201",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.200",
+    latest: "0.1.201",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.200",
+  "version": "0.1.201",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {