deepline 0.2.8 → 0.2.10

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

@@ -160,7 +160,7 @@ export const SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: '0.2.8',
+  version: '0.2.10',
   contracts: {
     api: {
       name: 'sdk-http-api',

package/dist/bundling-sources/shared_libs/play-runtime/activity-observation.ts

@@ -328,6 +328,7 @@ type ProjectionStep = {
   nodeId: string;
   status?: string;
   label?: string;
+  artifactTableNamespace?: string | null;
   updatedAt?: number | null;
   progress?: PlayActivityProgress | null;
 };
@@ -490,6 +491,19 @@ export function projectPlayRunActivity(input: {
     )
     .sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
   if (pendingDataset) {
+    const activeDatasetStep = input.nodeStates?.find(
+      (candidate) =>
+        candidate.nodeId === input.activeNodeId &&
+        candidate.status === 'running' &&
+        candidate.artifactTableNamespace === pendingDataset.tableNamespace,
+    );
+    const datasetStep =
+      activeDatasetStep ??
+      input.nodeStates?.find(
+        (candidate) =>
+          candidate.artifactTableNamespace === pendingDataset.tableNamespace,
+      );
+    const datasetProgress = datasetStep?.progress ?? null;
     return projection(
       {
         schemaVersion: 1,
@@ -502,17 +516,20 @@ export function projectPlayRunActivity(input: {
         state: {
           kind: 'active',
           progress: {
-            completed: pendingDataset.persistedRows,
+            completed:
+              datasetProgress?.completed ?? pendingDataset.persistedRows,
             total:
-              typeof pendingDataset.succeededRows === 'number' ||
+              datasetProgress?.total ??
+              (typeof pendingDataset.succeededRows === 'number' ||
               typeof pendingDataset.failedRows === 'number'
                 ? (pendingDataset.succeededRows ?? 0) +
                   (pendingDataset.failedRows ?? 0)
-                : undefined,
-            failed: pendingDataset.failedRows,
+                : undefined),
+            failed: datasetProgress?.failed ?? pendingDataset.failedRows,
           },
         },
-        observedAt: pendingDataset.updatedAt ?? observedAt,
+        observedAt:
+          datasetStep?.updatedAt ?? pendingDataset.updatedAt ?? observedAt,
       },
       now,
     );

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

@@ -367,17 +367,8 @@ function isRetryableAppRuntimeResponse(input: {
   // The app runtime may explicitly classify an otherwise-client-error status
   // as transient. Keep the structured delivery contract authoritative rather
   // than reducing every 4xx to permanent at the worker boundary.
-  try {
-    const parsed = JSON.parse(input.body) as unknown;
-    if (
-      parsed &&
-      typeof parsed === 'object' &&
-      !Array.isArray(parsed) &&
-      (parsed as { retryable?: unknown }).retryable === true
-    ) {
-      return true;
-    }
-  } catch {}
+  const explicitRetryable = appRuntimeExplicitRetryable(input.body);
+  if (explicitRetryable !== null) return explicitRetryable;
   if (
     input.action === 'append_run_events' &&
     input.status === 500 &&
@@ -391,6 +382,19 @@ function isRetryableAppRuntimeResponse(input: {
   return isRetryableAppRuntimeResponseStatus(input.status);
 }
 
+function appRuntimeExplicitRetryable(body: string): boolean | null {
+  try {
+    const parsed = JSON.parse(body) as unknown;
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return null;
+    }
+    const retryable = (parsed as { retryable?: unknown }).retryable;
+    return typeof retryable === 'boolean' ? retryable : null;
+  } catch {
+    return null;
+  }
+}
+
 function isRetryableAppRuntimeResponseStatus(status: number): boolean {
   return (
     status === 429 ||
@@ -1158,15 +1162,14 @@ async function postAppRuntimeApi<TResponse>(
       status: response.status,
       code,
       requestId,
-      // Immediate request retries are intentionally selective, but durable
-      // delivery must never classify an unrecognized upstream 5xx as poison.
-      retryable:
-        response.status >= 500 ||
-        isRetryableAppRuntimeResponse({
-          action: body.action,
-          status: response.status,
-          body: responseText,
-        }),
+      // The structured response is authoritative even for a 5xx. Retrying an
+      // explicitly deterministic database failure here turns one rejected SQL
+      // statement into an unbounded outer-writer loop.
+      retryable: isRetryableAppRuntimeResponse({
+        action: body.action,
+        status: response.status,
+        body: responseText,
+      }),
       detail: summarizeAppRuntimeErrorBody(responseText),
       boundaryLabel,
     });