deepline 0.2.53 → 0.2.55

package/dist/cli/index.mjs

@@ -1030,7 +1030,7 @@ var 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.53",
+  version: "0.2.55",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -1965,7 +1965,7 @@ function createSecretRedactionContext(initialValues = []) {
     if (value.length >= 4) exactSecrets.add(value);
   }
   for (const value of initialValues) register(value);
-  function redactString(value) {
+  function redactString2(value) {
     let output2 = value;
     for (const secret of exactSecrets) {
       output2 = output2.replace(
@@ -1986,7 +1986,7 @@ function createSecretRedactionContext(initialValues = []) {
     return redactSecretLikeString(output2);
   }
   function redact(value) {
-    if (typeof value === "string") return redactString(value);
+    if (typeof value === "string") return redactString2(value);
     if (Array.isArray(value)) return value.map((entry) => redact(entry));
     if (value && typeof value === "object") {
       return Object.fromEntries(
@@ -1999,7 +1999,7 @@ function createSecretRedactionContext(initialValues = []) {
     return value;
   }
   function redactKnownSecrets(value) {
-    if (typeof value === "string") return redactString(value);
+    if (typeof value === "string") return redactString2(value);
     if (Array.isArray(value)) {
       return value.map((entry) => redactKnownSecrets(entry));
     }
@@ -2015,7 +2015,7 @@ function createSecretRedactionContext(initialValues = []) {
   }
   return {
     register,
-    redactString,
+    redactString: redactString2,
     redactKnownSecrets,
     redact
   };
@@ -2035,12 +2035,334 @@ var RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES = 64 * 1024;
 // ../shared_libs/play-runtime/ledger-safe-payload.ts
 var ledgerIngressRedactor = createSecretRedactionContext();
 
-// ../shared_libs/play-runtime/activity-observation.ts
+// ../shared_libs/play-runtime/docflow-node-io.ts
+var DOCFLOW_NODE_IO_LIMITS = {
+  maxPaths: 16,
+  maxDepth: 3,
+  maxObjectFields: 12,
+  maxArrayItems: 3,
+  maxStringBytes: 256,
+  maxPhaseBytes: 2e3,
+  maxErrorBytes: 512
+};
+var utf8Encoder = new TextEncoder();
+var PLAY_DATASET_BRAND = /* @__PURE__ */ Symbol.for("deepline.play.dataset");
+function ledgerSafeDocflowPreviewKey(key) {
+  if (!key.startsWith("$")) return key;
+  const stripped = key.replace(/^\$+/, "");
+  return stripped || "output";
+}
+function utf8Bytes(value) {
+  return utf8Encoder.encode(value).byteLength;
+}
+function truncateUtf8(value, maxBytes) {
+  if (utf8Bytes(value) <= maxBytes) return value;
+  let output2 = "";
+  for (const character of value) {
+    if (utf8Bytes(`${output2}${character}\u2026`) > maxBytes) break;
+    output2 += character;
+  }
+  return `${output2}\u2026`;
+}
+function redactString(redactor, value, key) {
+  if (!key) return redactor.redactString(value);
+  const wrapped = redactor.redact({ [key]: value });
+  return typeof wrapped[key] === "string" ? wrapped[key] : redactor.redactString(value);
+}
+function safeString(value, redactor, key) {
+  if (typeof value !== "string") return void 0;
+  return truncateUtf8(
+    redactString(redactor, value, key),
+    DOCFLOW_NODE_IO_LIMITS.maxStringBytes
+  );
+}
+function previewValue(value, input2) {
+  if (value === null) return { kind: "null" };
+  if (value === void 0) return { kind: "unavailable", reason: "undefined" };
+  if (typeof value === "string") {
+    return {
+      kind: "scalar",
+      value: safeString(value, input2.redactor, input2.key) ?? ""
+    };
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? { kind: "scalar", value } : { kind: "unavailable", reason: "unsupported" };
+  }
+  if (typeof value === "boolean") return { kind: "scalar", value };
+  if (typeof value === "bigint") {
+    return { kind: "unavailable", reason: "bigint" };
+  }
+  if (typeof value === "function") {
+    return { kind: "unavailable", reason: "function" };
+  }
+  if (typeof value === "symbol") {
+    return { kind: "unavailable", reason: "symbol" };
+  }
+  if (typeof value !== "object") {
+    return { kind: "unavailable", reason: "unsupported" };
+  }
+  try {
+    const brand = readDataProperty(value, PLAY_DATASET_BRAND);
+    const datasetKind = readDataProperty(value, "datasetKind");
+    const datasetId = readDataProperty(value, "datasetId");
+    const tableNamespace = readDataProperty(value, "tableNamespace");
+    if (brand.ok && brand.value === true && datasetKind.ok && (datasetKind.value === "csv" || datasetKind.value === "map") && datasetId.ok && typeof datasetId.value === "string") {
+      return {
+        kind: "dataset",
+        datasetId: safeString(datasetId.value, input2.redactor, "datasetId") ?? "dataset",
+        datasetKind: datasetKind.value,
+        tableNamespace: tableNamespace.ok && tableNamespace.value === null ? null : tableNamespace.ok ? safeString(
+          tableNamespace.value,
+          input2.redactor,
+          "tableNamespace"
+        ) : void 0
+      };
+    }
+    const kind = readDataProperty(value, "kind");
+    const count = readDataProperty(value, "count");
+    const preview = readDataProperty(value, "preview");
+    if (kind.ok && kind.value === "dataset" && datasetKind.ok && (datasetKind.value === "csv" || datasetKind.value === "map") && datasetId.ok && typeof datasetId.value === "string" && count.ok && typeof count.value === "number" && preview.ok && Array.isArray(preview.value)) {
+      return {
+        kind: "dataset",
+        datasetId: safeString(datasetId.value, input2.redactor, "datasetId") ?? "dataset",
+        datasetKind: datasetKind.value,
+        tableNamespace: tableNamespace.ok && tableNamespace.value === null ? null : tableNamespace.ok ? safeString(
+          tableNamespace.value,
+          input2.redactor,
+          "tableNamespace"
+        ) : void 0,
+        rowCount: Math.max(0, Math.floor(count.value))
+      };
+    }
+  } catch {
+    return { kind: "unavailable", reason: "access_error" };
+  }
+  if (input2.ancestors.has(value)) {
+    return { kind: "unavailable", reason: "cycle" };
+  }
+  if (input2.depth >= DOCFLOW_NODE_IO_LIMITS.maxDepth) {
+    return { kind: "unavailable", reason: "depth" };
+  }
+  input2.ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const items = [];
+      for (let index = 0; index < Math.min(value.length, DOCFLOW_NODE_IO_LIMITS.maxArrayItems); index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          String(index)
+        );
+        items.push(
+          descriptor && "value" in descriptor ? previewValue(descriptor.value, {
+            ...input2,
+            depth: input2.depth + 1
+          }) : { kind: "unavailable", reason: "access_error" }
+        );
+      }
+      return {
+        kind: "array",
+        items,
+        totalItems: value.length,
+        ...value.length > items.length ? { truncated: true } : {}
+      };
+    }
+    let descriptors;
+    try {
+      descriptors = Object.getOwnPropertyDescriptors(value);
+    } catch {
+      return { kind: "unavailable", reason: "access_error" };
+    }
+    const entries = Object.entries(descriptors).filter(
+      ([, descriptor]) => descriptor.enumerable
+    );
+    const selected = entries.slice(0, DOCFLOW_NODE_IO_LIMITS.maxObjectFields);
+    const fields = {};
+    for (const [key, descriptor] of selected) {
+      const safeKey = truncateUtf8(
+        ledgerSafeDocflowPreviewKey(input2.redactor.redactString(key)),
+        DOCFLOW_NODE_IO_LIMITS.maxStringBytes
+      );
+      fields[safeKey] = "value" in descriptor ? previewValue(descriptor.value, {
+        ...input2,
+        depth: input2.depth + 1,
+        key
+      }) : { kind: "unavailable", reason: "access_error" };
+    }
+    return {
+      kind: "object",
+      fields,
+      totalFields: entries.length,
+      ...entries.length > selected.length ? { truncated: true } : {}
+    };
+  } catch {
+    return { kind: "unavailable", reason: "access_error" };
+  } finally {
+    input2.ancestors.delete(value);
+  }
+}
+function readDataProperty(value, property) {
+  if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+    return { ok: false };
+  }
+  try {
+    let owner = value;
+    while (owner) {
+      const descriptor = Object.getOwnPropertyDescriptor(owner, property);
+      if (descriptor) {
+        return "value" in descriptor ? { ok: true, value: descriptor.value } : { ok: false };
+      }
+      owner = Object.getPrototypeOf(owner);
+    }
+  } catch {
+    return { ok: false };
+  }
+  return { ok: false };
+}
+function buildPlayDocflowNodeErrorPreview(error, redactor = createSecretRedactionContext()) {
+  try {
+    const message = error instanceof Error ? error.message : String(error);
+    return truncateUtf8(
+      redactor.redactString(message),
+      DOCFLOW_NODE_IO_LIMITS.maxErrorBytes
+    );
+  } catch {
+    return "Non-Error value thrown (message unavailable)";
+  }
+}
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function normalizePreview(value, depth) {
+  if (!isRecord3(value) || typeof value.kind !== "string") return null;
+  if (value.kind === "null") return { kind: "null" };
+  if (value.kind === "scalar") {
+    if (typeof value.value === "string" || typeof value.value === "boolean" || typeof value.value === "number" && Number.isFinite(value.value)) {
+      return previewValue(value.value, {
+        depth: 0,
+        ancestors: /* @__PURE__ */ new WeakSet(),
+        redactor: createSecretRedactionContext()
+      });
+    }
+    return null;
+  }
+  if (value.kind === "unavailable") {
+    const reason = value.reason;
+    return typeof reason === "string" && [
+      "undefined",
+      "function",
+      "symbol",
+      "bigint",
+      "cycle",
+      "depth",
+      "access_error",
+      "limit",
+      "unsupported"
+    ].includes(reason) ? {
+      kind: "unavailable",
+      reason
+    } : null;
+  }
+  if (value.kind === "dataset") {
+    const datasetId = safeString(
+      value.datasetId,
+      createSecretRedactionContext(),
+      "datasetId"
+    );
+    if (!datasetId || value.datasetKind !== "csv" && value.datasetKind !== "map") {
+      return null;
+    }
+    return {
+      kind: "dataset",
+      datasetId,
+      datasetKind: value.datasetKind,
+      ...value.tableNamespace === null ? { tableNamespace: null } : typeof value.tableNamespace === "string" ? {
+        tableNamespace: safeString(
+          value.tableNamespace,
+          createSecretRedactionContext(),
+          "tableNamespace"
+        )
+      } : {},
+      ...typeof value.rowCount === "number" && Number.isFinite(value.rowCount) ? { rowCount: Math.max(0, Math.floor(value.rowCount)) } : {}
+    };
+  }
+  if (depth >= DOCFLOW_NODE_IO_LIMITS.maxDepth) {
+    return { kind: "unavailable", reason: "depth" };
+  }
+  if (value.kind === "array" && Array.isArray(value.items)) {
+    const items = value.items.slice(0, DOCFLOW_NODE_IO_LIMITS.maxArrayItems).map((item) => normalizePreview(item, depth + 1)).filter((item) => item !== null);
+    const totalItems = typeof value.totalItems === "number" && Number.isFinite(value.totalItems) ? Math.max(items.length, Math.floor(value.totalItems)) : items.length;
+    return {
+      kind: "array",
+      items,
+      totalItems,
+      ...value.truncated === true || totalItems > items.length ? { truncated: true } : {}
+    };
+  }
+  if (value.kind === "object" && isRecord3(value.fields)) {
+    const fields = {};
+    for (const [key, field] of Object.entries(value.fields).slice(
+      0,
+      DOCFLOW_NODE_IO_LIMITS.maxObjectFields
+    )) {
+      const normalized = normalizePreview(field, depth + 1);
+      if (normalized) fields[ledgerSafeDocflowPreviewKey(key)] = normalized;
+    }
+    const totalFields = typeof value.totalFields === "number" && Number.isFinite(value.totalFields) ? Math.max(Object.keys(fields).length, Math.floor(value.totalFields)) : Object.keys(fields).length;
+    return {
+      kind: "object",
+      fields,
+      totalFields,
+      ...value.truncated === true || totalFields > Object.keys(fields).length ? { truncated: true } : {}
+    };
+  }
+  return null;
+}
+function normalizePlayDocflowNodeIoState(value) {
+  if (!isRecord3(value)) return void 0;
+  const attempt = typeof value.attempt === "number" && Number.isFinite(value.attempt) ? Math.max(0, Math.floor(value.attempt)) : 0;
+  const normalizeMap = (raw) => {
+    if (!isRecord3(raw)) return void 0;
+    const output2 = {};
+    for (const [path, preview] of Object.entries(raw).slice(
+      0,
+      DOCFLOW_NODE_IO_LIMITS.maxPaths
+    )) {
+      const normalized = normalizePreview(preview, 0);
+      if (!normalized) continue;
+      const safePath = ledgerSafeDocflowPreviewKey(path);
+      const candidate = { ...output2, [safePath]: normalized };
+      if (utf8Bytes(JSON.stringify(candidate)) > DOCFLOW_NODE_IO_LIMITS.maxPhaseBytes) {
+        break;
+      }
+      output2[safePath] = normalized;
+    }
+    return output2;
+  };
+  const inputs = normalizeMap(value.inputs);
+  const outputs = normalizeMap(value.outputs);
+  const error = typeof value.error === "string" ? buildPlayDocflowNodeErrorPreview(value.error) : value.error === null ? null : void 0;
+  return {
+    attempt,
+    ...typeof value.invocationId === "string" && value.invocationId.trim() ? {
+      invocationId: truncateUtf8(
+        value.invocationId.trim(),
+        DOCFLOW_NODE_IO_LIMITS.maxStringBytes
+      )
+    } : {},
+    ...inputs ? { inputs } : {},
+    ...outputs ? { outputs } : {},
+    ...value.inputsTruncated === true ? { inputsTruncated: true } : {},
+    ...value.outputsTruncated === true ? { outputsTruncated: true } : {},
+    ...error !== void 0 ? { error } : {}
+  };
+}
+
+// ../shared_libs/play-runtime/activity-observation.ts
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
 function isPlayActivityObservation(value) {
-  if (!isRecord3(value) || value.schemaVersion !== 1 || typeof value.activityId !== "string" || !value.activityId.trim() || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || !isRecord3(value.target) || !isRecord3(value.state)) {
+  if (!isRecord4(value) || value.schemaVersion !== 1 || typeof value.activityId !== "string" || !value.activityId.trim() || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || !isRecord4(value.target) || !isRecord4(value.state)) {
     return false;
   }
   const targetKinds = /* @__PURE__ */ new Set([
@@ -2310,9 +2632,30 @@ function projectPlayRunActivity(input2) {
   return projection(fallback, now, normalizedStatus !== "waiting");
 }
 
+// ../shared_libs/play-runtime/cell-provenance.ts
+function finiteNonNegativeInteger2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return null;
+  }
+  return Math.trunc(value);
+}
+function nonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function normalizeDatasetBornFrom(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  const table = nonEmptyString(record.table);
+  const rowCountIn = finiteNonNegativeInteger2(record.rowCountIn);
+  if (!table || rowCountIn === null) return null;
+  return { table, rowCountIn };
+}
+
 // ../shared_libs/play-runtime/run-ledger.ts
 var LOG_TAIL_LIMIT = 100;
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber(value) {
@@ -2408,21 +2751,21 @@ function createEmptyPlayRunLedgerSnapshot(input2) {
   };
 }
 function normalizePlayRunLedgerSnapshot(value, fallback) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return createEmptyPlayRunLedgerSnapshot(fallback);
   }
   const orderedStepIds = Array.isArray(value.orderedStepIds) ? value.orderedStepIds.filter(
     (entry) => typeof entry === "string" && Boolean(entry.trim())
   ) : [];
-  const rawSteps = isRecord4(value.stepsById) ? value.stepsById : {};
+  const rawSteps = isRecord5(value.stepsById) ? value.stepsById : {};
   const stepsById = {};
   for (const [stepId, rawStep] of Object.entries(rawSteps)) {
-    if (!stepId.trim() || !isRecord4(rawStep)) continue;
+    if (!stepId.trim() || !isRecord5(rawStep)) continue;
     const rawStatus = normalizeStepStatus(rawStep.status);
     if (!rawStatus) continue;
     const completedAt = finiteNumber(rawStep.completedAt);
     const status = rawStatus === "running" && completedAt !== null ? "completed" : rawStatus;
-    const rawProgress = isRecord4(rawStep.progress) ? rawStep.progress : null;
+    const rawProgress = isRecord5(rawStep.progress) ? rawStep.progress : null;
     stepsById[stepId] = {
       stepId,
       label: optionalString(rawStep.label),
@@ -2438,11 +2781,12 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       progress: rawProgress ? normalizeStepProgress(rawProgress) : null
     };
   }
-  const rawDatasets = isRecord4(value.datasetsById) ? value.datasetsById : {};
+  const rawDatasets = isRecord5(value.datasetsById) ? value.datasetsById : {};
   const datasetsById = {};
   for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
-    if (!datasetId.trim() || !isRecord4(rawDataset)) continue;
+    if (!datasetId.trim() || !isRecord5(rawDataset)) continue;
     const phase = rawDataset.phase === "available" || rawDataset.phase === "failed" ? rawDataset.phase : "registered";
+    const datasetBornFrom = normalizeDatasetBornFrom(rawDataset.bornFrom);
     datasetsById[datasetId] = {
       datasetId,
       path: optionalString(rawDataset.path) ?? `datasets.${datasetId}`,
@@ -2452,10 +2796,14 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       succeededRows: Math.max(0, finiteNumber(rawDataset.succeededRows) ?? 0),
       failedRows: Math.max(0, finiteNumber(rawDataset.failedRows) ?? 0),
       complete: rawDataset.complete === true,
+      // ADR 0019 birth survives the snapshot round trip. A partial record is
+      // dropped rather than half-admitted, so a dataset either states where its
+      // rows came from or says nothing.
+      ...datasetBornFrom ? { bornFrom: datasetBornFrom } : {},
       updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0
     };
   }
-  const rawActivities = isRecord4(value.activitiesById) ? value.activitiesById : {};
+  const rawActivities = isRecord5(value.activitiesById) ? value.activitiesById : {};
   const activitiesById = {};
   for (const [activityId, rawActivity] of Object.entries(rawActivities)) {
     if (activityId.trim() && isPlayActivityObservation(rawActivity) && rawActivity.activityId === activityId) {
@@ -2532,7 +2880,8 @@ function normalizeStepProgress(value) {
     } : {},
     ...finiteNumber(value.startedAt) !== null ? { startedAt: finiteNumber(value.startedAt) } : {},
     ...finiteNumber(value.completedAt) !== null ? { completedAt: finiteNumber(value.completedAt) } : {},
-    ...finiteNumber(value.updatedAt) !== null ? { updatedAt: finiteNumber(value.updatedAt) } : {}
+    ...finiteNumber(value.updatedAt) !== null ? { updatedAt: finiteNumber(value.updatedAt) } : {},
+    ...normalizePlayDocflowNodeIoState(value.nodeIo) ? { nodeIo: normalizePlayDocflowNodeIoState(value.nodeIo) } : {}
   };
 }
 
@@ -2604,18 +2953,18 @@ function normalizePlayRunLiveStatus(value) {
 function isTerminalPlayRunLiveStatus(status) {
   return isTerminalPlayRunLifecycleStatus(status);
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function extractTerminalRunLogTail(result) {
-  if (!isRecord5(result) || !isRecord5(result._metadata)) {
+  if (!isRecord6(result) || !isRecord6(result._metadata)) {
     return null;
   }
   const runLogTail = result._metadata.runLogTail;
-  if (!isRecord5(runLogTail) || !Array.isArray(runLogTail.tail)) {
+  if (!isRecord6(runLogTail) || !Array.isArray(runLogTail.tail)) {
     return null;
   }
   const logTail = runLogTail.tail.filter(
@@ -2651,11 +3000,13 @@ function buildSnapshotFromLedger(snapshot) {
       artifactTableNamespace: step.progress.artifactTableNamespace ?? step.artifactTableNamespace ?? null,
       startedAt: step.startedAt ?? null,
       completedAt: step.completedAt ?? null,
-      updatedAt: step.progress.updatedAt ?? step.updatedAt ?? null
+      updatedAt: step.progress.updatedAt ?? step.updatedAt ?? null,
+      nodeIo: step.progress.nodeIo
     } : null,
     startedAt: step.startedAt ?? null,
     completedAt: step.completedAt ?? null,
-    updatedAt: step.updatedAt ?? null
+    updatedAt: step.updatedAt ?? null,
+    ...step.progress?.nodeIo ? { nodeIo: step.progress.nodeIo } : {}
   }));
   const liveStatus = normalizePlayRunLiveStatus(snapshot.status);
   const rowOutcomes = isTerminalPlayRunLiveStatus(liveStatus) && Object.keys(snapshot.stepsById).length > 0 ? summarizeRunRowOutcomes(snapshot) : null;
@@ -3405,8 +3756,17 @@ function resolvePlayRunRuntimeSelection(request) {
   const configuredToken = process.env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
   if (!configured) {
     if (configuredNamespace || configuredToken) {
+      const present = [];
+      if (configuredNamespace) present.push("DEEPLINE_RUNTIME_NAMESPACE");
+      if (configuredToken) present.push("DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN");
+      const isPlural = present.length > 1;
       throw new DeeplineError(
-        "DEEPLINE_RUNTIME_ENVIRONMENT=preview and DEEPLINE_RUNTIME_NAMESPACE are required when runtime selection configuration is present.",
+        [
+          `Incomplete play runtime selection: ${present.join(" and ")} ${isPlural ? "are" : "is"} set but DEEPLINE_RUNTIME_ENVIRONMENT is not.`,
+          "Preview routing requires DEEPLINE_RUNTIME_ENVIRONMENT=preview together with DEEPLINE_RUNTIME_NAMESPACE; the token alone authorizes nothing.",
+          `If you did not export ${isPlural ? "these" : "this"} yourself, ${isPlural ? "they were" : "it was"} most likely auto-loaded from a .env or .env.local in the current directory (bun loads those automatically, and in a git worktree .env.local is usually a symlink to the main checkout).`,
+          `To run against the app-native runtime, clear ${isPlural ? "them" : "it"} for this command: ${present.map((name) => `${name}=`).join(" ")} <your deepline command>`
+        ].join("\n"),
         void 0,
         "INVALID_RUNTIME_ENVIRONMENT"
       );
@@ -3574,7 +3934,7 @@ function requireTargetBillingIdempotencyKey(value) {
   }
   return normalized;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPrebuiltPlayDescription(play) {
@@ -3746,7 +4106,7 @@ function updatePlayLiveStatusState(state, event) {
   }
   const runId = typeof payload.runId === "string" && payload.runId ? payload.runId : isPlayRunPackage(payload) ? payload.run.id : state.runId;
   const status = normalizeLiveStatus(payload.status) ?? (isPlayRunPackage(payload) ? normalizeLiveStatus(payload.run.status) : null) ?? state.status;
-  const progressPayload = isRecord6(payload.progress) ? payload.progress : {};
+  const progressPayload = isRecord7(payload.progress) ? payload.progress : {};
   if (event.type === "play.run.final_status" && state.logs.length === 0 && state.lastLogSeq === 0) {
     const payloadLogs = readStringArray(payload.logs);
     const progressLogs = readStringArray(progressPayload.logs);
@@ -3889,9 +4249,9 @@ var DeeplineClient = class {
     return fields.length > 0 ? { fields } : schema;
   }
   schemaMetadata(schema, key) {
-    if (!isRecord6(schema)) return null;
+    if (!isRecord7(schema)) return null;
     const value = schema[key];
-    return isRecord6(value) ? value : null;
+    return isRecord7(value) ? value : null;
   }
   playRunCommand(play, options) {
     const target = play.reference || play.name;
@@ -3940,7 +4300,7 @@ var DeeplineClient = class {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
-      staticPipeline: isRecord6(play.staticPipeline) ? play.staticPipeline : isRecord6(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord6(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
+      staticPipeline: isRecord7(play.staticPipeline) ? play.staticPipeline : isRecord7(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord7(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand: runCommand2,
@@ -9136,14 +9496,14 @@ function sanitizeCsvProjectionInfo(input2) {
   const rows = input2.rows.map(stripCsvProjectionFields);
   return { rows, columns };
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSerializedDataset(value) {
-  return isRecord7(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
+  return isRecord8(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
 }
 function isPackagedDatasetOutput(value) {
-  return isRecord7(value) && value.kind === "dataset" && isRecord7(value.preview) && Array.isArray(value.preview.rows);
+  return isRecord8(value) && value.kind === "dataset" && isRecord8(value.preview) && Array.isArray(value.preview.rows);
 }
 function pathParts(path) {
   return path.split(".").map((part) => part.trim()).filter(Boolean);
@@ -9151,7 +9511,7 @@ function pathParts(path) {
 function valueAtPath(root, path) {
   let cursor = root;
   for (const part of pathParts(path)) {
-    if (!isRecord7(cursor)) {
+    if (!isRecord8(cursor)) {
       return void 0;
     }
     cursor = cursor[part];
@@ -9159,17 +9519,17 @@ function valueAtPath(root, path) {
   return cursor;
 }
 function totalRowsForDataset(result, datasetPath) {
-  const metadata = isRecord7(result._metadata) ? result._metadata : null;
+  const metadata = isRecord8(result._metadata) ? result._metadata : null;
   const parentPath = datasetPath.split(".").slice(0, -1).join(".");
   const parent = parentPath ? valueAtPath({ result }, parentPath) : result;
-  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord7(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
+  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord8(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
 }
 function rowArray(value) {
   if (!Array.isArray(value)) {
     return null;
   }
   const rows = value.filter(
-    (row) => isRecord7(row)
+    (row) => isRecord8(row)
   );
   return rows.length === value.length ? rows : null;
 }
@@ -9193,7 +9553,7 @@ function inferColumns(rows) {
   return columns;
 }
 function columnsFromDatasetSummary(summary) {
-  if (!isRecord7(summary) || !isRecord7(summary.columnStats)) {
+  if (!isRecord8(summary) || !isRecord8(summary.columnStats)) {
     return [];
   }
   return Object.keys(summary.columnStats).filter((column) => column);
@@ -9241,7 +9601,7 @@ function canonicalRowsInfoFromCandidate(input2) {
       datasetId: typeof candidate.value.datasetId === "string" ? candidate.value.datasetId : null,
       tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null,
       ...candidate.value.recovered === true ? { recovered: true } : {},
-      ...isRecord7(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace") ? {
+      ...isRecord8(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace") ? {
         exportUnavailableReason: candidate.value.exportUnavailable.reason,
         ...typeof candidate.value.exportUnavailable.message === "string" ? {
           exportUnavailableMessage: candidate.value.exportUnavailable.message
@@ -9289,7 +9649,7 @@ function collectDatasetCandidates(input2) {
     });
     return;
   }
-  if (!isRecord7(input2.value)) {
+  if (!isRecord8(input2.value)) {
     return;
   }
   for (const [key, child] of Object.entries(input2.value)) {
@@ -9306,12 +9666,12 @@ function collectDatasetCandidates(input2) {
   }
 }
 function collectCanonicalRowsInfos(statusOrResult) {
-  const root = isRecord7(statusOrResult) ? statusOrResult : null;
-  const result = isRecord7(root?.result) ? root.result : root;
+  const root = isRecord8(statusOrResult) ? statusOrResult : null;
+  const result = isRecord8(root?.result) ? root.result : root;
   if (!result) {
     return [];
   }
-  const metadata = isRecord7(result._metadata) ? result._metadata : null;
+  const metadata = isRecord8(result._metadata) ? result._metadata : null;
   const totalFromMetadata = metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count;
   const candidates = [
     {
@@ -9335,8 +9695,8 @@ function collectCanonicalRowsInfos(statusOrResult) {
       total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count
     }
   ];
-  if (isRecord7(result.output)) {
-    const outputMetadata = isRecord7(result.output._metadata) ? result.output._metadata : null;
+  if (isRecord8(result.output)) {
+    const outputMetadata = isRecord8(result.output._metadata) ? result.output._metadata : null;
     const outputTotalFromMetadata = outputMetadata?.totalRows ?? outputMetadata?.rowCount ?? outputMetadata?.count;
     candidates.push(
       {
@@ -9363,14 +9723,14 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   if (Array.isArray(result.steps)) {
     result.steps.forEach((step, index) => {
-      if (!isRecord7(step) || !isRecord7(step.output)) {
+      if (!isRecord8(step) || !isRecord8(step.output)) {
         return;
       }
       const source = typeof step.output.path === "string" ? step.output.path : typeof step.id === "string" ? `steps.${step.id}.output` : `steps.${index}.output`;
       candidates.push({
         source,
         value: step.output,
-        total: step.output.rowCount ?? (isRecord7(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord7(step.progress) ? step.progress.total : void 0)
+        total: step.output.rowCount ?? (isRecord8(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord8(step.progress) ? step.progress.total : void 0)
       });
     });
   }
@@ -9398,15 +9758,15 @@ function collectCanonicalRowsInfos(statusOrResult) {
   return infos;
 }
 function collectPackagedDatasetCandidates(statusOrResult) {
-  const root = isRecord7(statusOrResult) ? statusOrResult : null;
+  const root = isRecord8(statusOrResult) ? statusOrResult : null;
   if (!root) {
     return [];
   }
-  const pkg = isRecord7(root.package) ? root.package : root;
+  const pkg = isRecord8(root.package) ? root.package : root;
   const datasets = Array.isArray(pkg.datasets) ? pkg.datasets : [];
   const candidates = [];
   for (const output2 of datasets) {
-    if (!isRecord7(output2) || !isPackagedDatasetOutput(output2)) {
+    if (!isRecord8(output2) || !isPackagedDatasetOutput(output2)) {
       continue;
     }
     const source = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
@@ -9416,18 +9776,18 @@ function collectPackagedDatasetCandidates(statusOrResult) {
     candidates.push({
       source,
       value: output2,
-      total: output2.rowCount ?? (isRecord7(output2.preview) ? output2.preview.totalRows : void 0)
+      total: output2.rowCount ?? (isRecord8(output2.preview) ? output2.preview.totalRows : void 0)
     });
   }
   return candidates;
 }
 function collectPackagedStepDatasetCandidates(statusOrResult) {
-  const root = isRecord7(statusOrResult) ? statusOrResult : null;
+  const root = isRecord8(statusOrResult) ? statusOrResult : null;
   if (!root) return [];
-  const pkg = isRecord7(root.package) ? root.package : root;
+  const pkg = isRecord8(root.package) ? root.package : root;
   const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
   return steps.flatMap((step) => {
-    if (!isRecord7(step) || !isPackagedDatasetOutput(step.output)) return [];
+    if (!isRecord8(step) || !isPackagedDatasetOutput(step.output)) return [];
     const source = typeof step.output.path === "string" && step.output.path.trim() ? step.output.path.trim() : null;
     return source ? [
       {
@@ -9439,8 +9799,8 @@ function collectPackagedStepDatasetCandidates(statusOrResult) {
   });
 }
 function collectSerializedDatasetRowsInfos(statusOrResult) {
-  const root = isRecord7(statusOrResult) ? statusOrResult : null;
-  const result = isRecord7(root?.result) ? root.result : root;
+  const root = isRecord8(statusOrResult) ? statusOrResult : null;
+  const result = isRecord8(root?.result) ? root.result : root;
   const candidates = [];
   if (result) {
     collectDatasetCandidates({
@@ -9448,7 +9808,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       path: "result",
       output: candidates
     });
-    if (isRecord7(result.output)) {
+    if (isRecord8(result.output)) {
       collectDatasetCandidates({
         value: result.output,
         path: "result",
@@ -9526,13 +9886,13 @@ function summarizeSampleValue(value, depth = 0) {
   if (typeof parsed === "number" || typeof parsed === "boolean") return parsed;
   if (depth >= 3) {
     if (Array.isArray(parsed)) return [];
-    if (isRecord7(parsed)) return {};
+    if (isRecord8(parsed)) return {};
     return compactScalar(parsed);
   }
   if (Array.isArray(parsed)) {
     return parsed.slice(0, 3).map((item) => summarizeSampleValue(item, depth + 1));
   }
-  if (isRecord7(parsed)) {
+  if (isRecord8(parsed)) {
     const out = {};
     for (const [key, nested] of Object.entries(parsed)) {
       if (["__dl", "meta", "metadata"].includes(key)) {
@@ -9563,7 +9923,7 @@ function compactCell(value) {
     }
     return `[${parsed.length} items]`;
   }
-  if (isRecord7(parsed)) {
+  if (isRecord8(parsed)) {
     for (const key of ["matched_result", "output"]) {
       if (parsed[key] !== null && parsed[key] !== void 0 && parsed[key] !== "") {
         return compactCell(parsed[key]);
@@ -10652,17 +11012,17 @@ function parsePositiveInteger2(value, flagName) {
   }
   return parsed;
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function extractionEntries(value) {
-  if (Array.isArray(value)) return value.filter(isRecord8);
-  if (!isRecord8(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord9);
+  if (!isRecord9(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord8(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord9(entry) ? { name, ...entry } : { name }
   );
 }
 var PlayBootstrapError = class extends Error {
@@ -11224,7 +11584,7 @@ function readCsvSampleRows(sample) {
     relax_column_count: true,
     trim: true
   });
-  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord8) : [];
+  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord9) : [];
 }
 function readSourceCsvColumnSpecs(csvPath) {
   const sample = readCsvSample(csvPath);
@@ -11257,16 +11617,16 @@ function packagedCsvPathForPlay(csvPath) {
   return portablePath.startsWith(".") ? portablePath : `./${portablePath}`;
 }
 function getterNamesFromTool(tool, kind) {
-  const usageGuidance = isRecord8(tool?.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord8(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord8(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const usageGuidance = isRecord9(tool?.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord9(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord9(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
   const key = kind === "list" ? "extractedLists" : "extractedValues";
   const snakeKey = kind === "list" ? "extracted_lists" : "extracted_values";
   return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
 }
 function targetGettersFromTool(tool) {
-  const record = isRecord8(tool) ? tool : {};
+  const record = isRecord9(tool) ? tool : {};
   const raw = record.targetGetters ?? record.target_getters;
-  if (!isRecord8(raw)) return {};
+  if (!isRecord9(raw)) return {};
   const entries = [];
   for (const [target, value] of Object.entries(raw)) {
     const paths = Array.isArray(value) ? value.map((path) => typeof path === "string" ? path.trim() : "").filter(Boolean) : [];
@@ -11287,10 +11647,10 @@ function listRowCandidateKeysFromTool(tool) {
   return [...keys].sort();
 }
 function inputPropertyNames(schema) {
-  if (!isRecord8(schema)) return [];
-  if (isRecord8(schema.properties)) return Object.keys(schema.properties);
+  if (!isRecord9(schema)) return [];
+  if (isRecord9(schema.properties)) return Object.keys(schema.properties);
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord8).map((field) => stringValue(field.name)).filter(Boolean);
+    return schema.fields.filter(isRecord9).map((field) => stringValue(field.name)).filter(Boolean);
   }
   return [];
 }
@@ -11304,7 +11664,7 @@ function schemaFieldDetails(schema) {
   return { required, optional };
 }
 function jsonSchemaTypeExpression(schema) {
-  if (!isRecord8(schema)) return "unknown";
+  if (!isRecord9(schema)) return "unknown";
   const type = schema.type;
   if (Array.isArray(type)) {
     return type.map((entry) => jsonSchemaTypeExpression({ ...schema, type: entry })).join(" | ");
@@ -11334,7 +11694,7 @@ function jsonSchemaTypeExpression(schema) {
   }
 }
 function objectPropertySchema(schema, property) {
-  return isRecord8(schema) && isRecord8(schema.properties) ? schema.properties[property] : null;
+  return isRecord9(schema) && isRecord9(schema.properties) ? schema.properties[property] : null;
 }
 function playOutputHasField(schema, field) {
   return objectPropertySchema(schema, field) != null;
@@ -11510,14 +11870,14 @@ ${indent2.slice(2)}}`;
 }
 function requiredPlayInputFields(play) {
   const schema = play?.inputSchema;
-  if (!isRecord8(schema)) return [];
+  if (!isRecord9(schema)) return [];
   if (Array.isArray(schema.required)) {
     return schema.required.filter(
       (value) => typeof value === "string"
     );
   }
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord8).filter(
+    return schema.fields.filter(isRecord9).filter(
       (field) => field.required === true && typeof field.name === "string"
     ).map((field) => String(field.name));
   }
@@ -11698,7 +12058,7 @@ function validateBootstrapRoutes(input2) {
   }
 }
 function staticPipelineSubsteps(pipeline) {
-  if (!isRecord8(pipeline)) return [];
+  if (!isRecord9(pipeline)) return [];
   return [
     ...extractionEntries(pipeline.stages),
     ...extractionEntries(pipeline.substeps)
@@ -11706,7 +12066,7 @@ function staticPipelineSubsteps(pipeline) {
 }
 function playUsesMapBackedRuntime(play) {
   const pipeline = play?.staticPipeline;
-  if (!isRecord8(pipeline)) return false;
+  if (!isRecord9(pipeline)) return false;
   if (stringValue(pipeline.tableNamespace)) return true;
   return staticPipelineSubsteps(pipeline).some((substep) => {
     if (stringValue(substep.type) === "map") return true;
@@ -11715,7 +12075,7 @@ function playUsesMapBackedRuntime(play) {
       aliases: [],
       runCommand: "",
       examples: [],
-      staticPipeline: isRecord8(substep.pipeline) ? substep.pipeline : null
+      staticPipeline: isRecord9(substep.pipeline) ? substep.pipeline : null
     });
   });
 }
@@ -12319,8 +12679,7 @@ import {
   sep
 } from "path";
 import { builtinModules } from "module";
-import { Parser } from "acorn";
-import { tsPlugin } from "acorn-typescript";
+import { Parser as Parser2 } from "acorn";
 import { build, transformSync } from "esbuild";
 
 // ../node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
@@ -15708,6 +16067,22 @@ var PLAY_AUTHORING_FIELD_REGISTRY = {
     description: "Whether the dataset returns all rows or only newly admitted rows.",
     errorMessage: 'ctx.dataset run mode must be "upsert" or "net_new".'
   },
+  "ctx.dataset.run.undrawnColumns": {
+    schema: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+    fixtures: {
+      valid: ["miss_reason"],
+      invalid: [],
+      absent: void 0,
+      unresolved: { expression: "undrawnColumns" },
+      edition1: ["miss_reason"]
+    },
+    referenceType: "readonly string[]",
+    required: false,
+    resolution: "static-when-present",
+    issueCode: "play_authoring_dataset_option_invalid",
+    description: "Computed columns deliberately left out of the authored @mermaid diagram.",
+    errorMessage: "ctx.dataset run undrawnColumns must be a non-empty array of static column-name strings."
+  },
   "ctx.step.id": {
     schema: Type.String({ minLength: 1 }),
     fixtures: {
@@ -16195,7 +16570,7 @@ var PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   "export type StepProgramOutput<TProgram> = TProgram extends StepProgram<unknown, infer Output, unknown> ? Output : never;",
   "export type DatasetRowKey<InputRow extends object> = (keyof InputRow & string) | readonly (keyof InputRow & string)[] | ((row: InputRow, index: number) => string | number | readonly unknown[]);",
   "export type DatasetDefinitionOptions<InputRow extends object> = { key?: DatasetRowKey<InputRow> };",
-  `export type DatasetRunOptions<InputRow extends object> = { description?: ${cloudReferenceType("ctx.dataset.run.description")}; key?: DatasetRowKey<InputRow>; onRowError?: ${cloudReferenceType("ctx.dataset.run.onRowError")}; mode?: ${cloudReferenceType("ctx.dataset.run.mode")} };`,
+  `export type DatasetRunOptions<InputRow extends object> = { description?: ${cloudReferenceType("ctx.dataset.run.description")}; key?: DatasetRowKey<InputRow>; onRowError?: ${cloudReferenceType("ctx.dataset.run.onRowError")}; mode?: ${cloudReferenceType("ctx.dataset.run.mode")}; undrawnColumns?: ${cloudReferenceType("ctx.dataset.run.undrawnColumns")} };`,
   "export type DatasetBuilder<InputRow extends object, OutputRow extends object> = {",
   "  withColumn<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;",
   "  withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value> & { readonly runIf: (row: OutputRow, index: number) => boolean | Promise<boolean> }): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;",
@@ -16226,6 +16601,125 @@ var PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   "export type DefinedPlay<TInput, TOutput extends PlayReturnObject> = ((ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>) & { readonly name: string; readonly __inputType?: TInput; readonly __outputType?: TOutput; readonly runtime?: PlayBindings['runtime']; readonly compatibility?: PlayBindings['compatibility'] };"
 ];
 
+// ../shared_libs/plays/ts-ast.ts
+import { Parser } from "acorn";
+import { tsPlugin } from "acorn-typescript";
+var TypeScriptParser = Parser.extend(
+  tsPlugin({
+    allowSatisfies: true,
+    jsx: {
+      allowNamespaces: true,
+      allowNamespacedObjects: true
+    }
+  })
+);
+function isAstNode(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+function astArray(value) {
+  return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function parsePlaySourceForAnalysis(sourceCode) {
+  try {
+    return TypeScriptParser.parse(sourceCode, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowHashBang: true
+    });
+  } catch {
+    return null;
+  }
+}
+
+// ../shared_libs/plays/play-exports.ts
+var PLAY_DEFAULT_EXPORT = "default";
+function getIdentifierName(node) {
+  return isAstNode(node) && node.type === "Identifier" ? typeof node.name === "string" ? node.name : null : null;
+}
+function unwrapStaticExpression(node) {
+  let current = node;
+  while (current && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression")) {
+    current = isAstNode(current.expression) ? current.expression : null;
+  }
+  return current;
+}
+function isDefinePlayCall(node) {
+  const expression = unwrapStaticExpression(node);
+  if (!expression || expression.type !== "CallExpression") return false;
+  const callee = isAstNode(expression.callee) ? expression.callee : null;
+  if (!callee) return false;
+  if (callee.type === "Identifier") {
+    return callee.name === "definePlay" || callee.name === "defineWorkflow";
+  }
+  if (callee.type === "MemberExpression" && !callee.computed && isAstNode(callee.property) && callee.property.type === "Identifier") {
+    return callee.property.name === "definePlay" || callee.property.name === "defineWorkflow";
+  }
+  return false;
+}
+function listPlayFileExports(sourceCode) {
+  const ast = parsePlaySourceForAnalysis(sourceCode);
+  if (!ast) return null;
+  const declarations = /* @__PURE__ */ new Map();
+  const namedExports = /* @__PURE__ */ new Map();
+  let defaultExpression = null;
+  const recordDeclarations = (declaration, exported) => {
+    for (const declarator of astArray(declaration.declarations)) {
+      const name = getIdentifierName(declarator.id);
+      if (!name) continue;
+      declarations.set(
+        name,
+        isAstNode(declarator.init) ? declarator.init : null
+      );
+      if (exported) namedExports.set(name, name);
+    }
+  };
+  for (const statement of astArray(ast.body)) {
+    if (statement.type === "VariableDeclaration") {
+      recordDeclarations(statement, false);
+      continue;
+    }
+    if (statement.type === "ExportDefaultDeclaration") {
+      defaultExpression = isAstNode(statement.declaration) ? statement.declaration : null;
+      continue;
+    }
+    if (statement.type === "TSExportAssignment") {
+      defaultExpression = isAstNode(statement.expression) ? statement.expression : null;
+      continue;
+    }
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    if (isAstNode(statement.declaration) && statement.declaration.type === "VariableDeclaration") {
+      recordDeclarations(statement.declaration, true);
+    }
+    for (const specifier of astArray(statement.specifiers)) {
+      const localName = getIdentifierName(specifier.local);
+      const exportedName = getIdentifierName(specifier.exported);
+      if (localName && exportedName) namedExports.set(exportedName, localName);
+    }
+  }
+  const defaultLocalName = getIdentifierName(
+    unwrapStaticExpression(defaultExpression)
+  );
+  const defaultIsPlay = defaultLocalName ? isDefinePlayCall(declarations.get(defaultLocalName) ?? null) : isDefinePlayCall(defaultExpression);
+  const exports = [];
+  const aliasedLocals = /* @__PURE__ */ new Set();
+  if (defaultIsPlay) {
+    const aliases = defaultLocalName ? [...namedExports.entries()].filter(([, local]) => local === defaultLocalName).map(([exported]) => exported) : [];
+    if (defaultLocalName) aliasedLocals.add(defaultLocalName);
+    exports.push({ name: PLAY_DEFAULT_EXPORT, aliases });
+  }
+  for (const [exportedName, localName] of namedExports) {
+    if (exportedName === PLAY_DEFAULT_EXPORT) continue;
+    if (aliasedLocals.has(localName)) continue;
+    if (!isDefinePlayCall(declarations.get(localName) ?? null)) continue;
+    exports.push({ name: exportedName, aliases: [] });
+  }
+  return exports;
+}
+
+// ../shared_libs/plays/docflow.ts
+var MERMAID_NODE_ATTRIBUTES = ["label", "type", "in", "out", "arm"];
+var LEGACY_DOCFLOW_ATTRIBUTES = ["id", ...MERMAID_NODE_ATTRIBUTES];
+
 // ../shared_libs/plays/secret-guardrails.ts
 var SECRET_ENV_PATTERN = /\bprocess(?:\.env|\[['"]env['"]\])(?:\.|\[['"])([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PRIVATE[_-]?KEY|ACCESS[_-]?KEY)[A-Z0-9_]*)(?:['"]\])?/g;
 var PRIVATE_KEY_PATTERN = /-----BEGIN (?:RSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/;
@@ -16249,7 +16743,7 @@ function collectInlineSecretFindings(sourceCode) {
 var MAX_PLAY_BUNDLE_BYTES = 30 * 1024 * 1024;
 
 // ../shared_libs/plays/bundling/index.ts
-var PLAY_BUNDLE_CACHE_VERSION = 28;
+var PLAY_BUNDLE_CACHE_VERSION = 33;
 var PLAY_ARTIFACT_CACHE_DIR = join7(
   tmpdir2(),
   `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`
@@ -16262,15 +16756,6 @@ var NODE_BUILTIN_SET = new Set(
 function extractDefinedPlayName(sourceCode) {
   return extractDefinedPlayMetadata(sourceCode, null)?.name ?? null;
 }
-var TypeScriptParser = Parser.extend(
-  tsPlugin({
-    allowSatisfies: true,
-    jsx: {
-      allowNamespaces: true,
-      allowNamespacedObjects: true
-    }
-  })
-);
 function parsePlaySourceAst(sourceCode) {
   try {
     return TypeScriptParser.parse(sourceCode, {
@@ -16287,7 +16772,7 @@ function parsePlaySourceAst(sourceCode) {
         legalComments: "none",
         sourcemap: false
       }).code;
-      return Parser.parse(transformed, {
+      return Parser2.parse(transformed, {
         ecmaVersion: "latest",
         sourceType: "module",
         allowHashBang: true
@@ -16297,17 +16782,11 @@ function parsePlaySourceAst(sourceCode) {
     }
   }
 }
-function getIdentifierName(node) {
+function getIdentifierName2(node) {
   return isAstNode(node) && node.type === "Identifier" ? typeof node.name === "string" ? node.name : null : null;
 }
-function isAstNode(value) {
-  return value !== null && typeof value === "object" && "type" in value;
-}
-function astArray(value) {
-  return Array.isArray(value) ? value.filter(isAstNode) : [];
-}
 function memberExpressionPath(node) {
-  const expression = unwrapStaticExpression(node);
+  const expression = unwrapStaticExpression2(node);
   if (!expression) return null;
   if (expression.type === "Identifier" && typeof expression.name === "string") {
     return [expression.name];
@@ -16365,7 +16844,7 @@ function buildPlayMetadataContext(ast) {
   for (const statement of astArray(ast.body)) {
     if (statement.type === "VariableDeclaration") {
       for (const declaration of astArray(statement.declarations)) {
-        const name = getIdentifierName(declaration.id);
+        const name = getIdentifierName2(declaration.id);
         if (!name) continue;
         const initializer = isAstNode(declaration.init) ? declaration.init : null;
         declarations.set(
@@ -16388,7 +16867,7 @@ function buildPlayMetadataContext(ast) {
         for (const declaration of astArray(
           statement.declaration.declarations
         )) {
-          const name = getIdentifierName(declaration.id);
+          const name = getIdentifierName2(declaration.id);
           if (!name) continue;
           const initializer = isAstNode(declaration.init) ? declaration.init : null;
           declarations.set(
@@ -16402,8 +16881,8 @@ function buildPlayMetadataContext(ast) {
         }
       }
       for (const specifier of astArray(statement.specifiers)) {
-        const localName = getIdentifierName(specifier.local);
-        const exportedName = getIdentifierName(specifier.exported) ?? (isAstNode(specifier.exported) && specifier.exported.type === "Literal" && typeof specifier.exported.value === "string" ? specifier.exported.value : null);
+        const localName = getIdentifierName2(specifier.local);
+        const exportedName = getIdentifierName2(specifier.exported) ?? (isAstNode(specifier.exported) && specifier.exported.type === "Literal" && typeof specifier.exported.value === "string" ? specifier.exported.value : null);
         if (localName && exportedName) {
           namedExports.set(exportedName, localName);
         }
@@ -16420,7 +16899,7 @@ function buildPlayMetadataContext(ast) {
   }
   return { declarations, namedExports, commonJsExports, defaultExport };
 }
-function unwrapStaticExpression(node) {
+function unwrapStaticExpression2(node) {
   let current = node ?? null;
   while (current && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression")) {
     current = isAstNode(current.expression) ? current.expression : null;
@@ -16428,7 +16907,7 @@ function unwrapStaticExpression(node) {
   return current;
 }
 function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Set(), trimResult = true) {
-  const expression = unwrapStaticExpression(node);
+  const expression = unwrapStaticExpression2(node);
   if (!expression) return null;
   if (expression.type === "Literal") {
     const value = expression.value;
@@ -16458,7 +16937,7 @@ function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Se
     if (!value?.trim()) return null;
     return trimResult ? value.trim() : value;
   }
-  const identifier = getIdentifierName(expression);
+  const identifier = getIdentifierName2(expression);
   if (!identifier || seen.has(identifier)) return null;
   seen.add(identifier);
   return staticStringFromExpression(
@@ -16483,10 +16962,10 @@ function propertyNameFromKey(property) {
   return null;
 }
 function objectExpressionFromNode(node, context, seen = /* @__PURE__ */ new Set()) {
-  const expression = unwrapStaticExpression(node);
+  const expression = unwrapStaticExpression2(node);
   if (!expression) return null;
   if (expression.type === "ObjectExpression") return expression;
-  const identifier = getIdentifierName(expression);
+  const identifier = getIdentifierName2(expression);
   if (!identifier || seen.has(identifier)) return null;
   seen.add(identifier);
   return objectExpressionFromNode(
@@ -16553,12 +17032,12 @@ function staticPropertyNames(node, context, ancestors = /* @__PURE__ */ new Set(
   return names;
 }
 function staticNumberFromExpression(node, context, seen = /* @__PURE__ */ new Set()) {
-  const expression = unwrapStaticExpression(node);
+  const expression = unwrapStaticExpression2(node);
   if (!expression) return null;
   if (expression.type === "Literal" && typeof expression.value === "number") {
     return expression.value;
   }
-  const identifier = getIdentifierName(expression);
+  const identifier = getIdentifierName2(expression);
   if (!identifier || seen.has(identifier)) return null;
   seen.add(identifier);
   return staticNumberFromExpression(
@@ -16647,7 +17126,7 @@ function stringPropertyFromObjectExpression(node, propertyName, context, seenObj
   return value;
 }
 function isDefinePlayCallee(node) {
-  const callee = unwrapStaticExpression(node);
+  const callee = unwrapStaticExpression2(node);
   if (!callee) return false;
   if (callee.type === "Identifier" && (callee.name === "definePlay" || callee.name === "defineWorkflow")) {
     return true;
@@ -16659,7 +17138,7 @@ function isDefinePlayCallee(node) {
   return false;
 }
 function playMetadataFromDefinePlayCall(node, context) {
-  const expression = unwrapStaticExpression(node);
+  const expression = unwrapStaticExpression2(node);
   if (!expression || expression.type !== "CallExpression" || !isDefinePlayCallee(isAstNode(expression.callee) ? expression.callee : null)) {
     return null;
   }
@@ -16705,13 +17184,13 @@ function resolveExportExpression(exportName, context) {
   if (exportName === "default") {
     const commonJsDefault = context.commonJsExports.get("default");
     if (commonJsDefault) {
-      const commonJsDefaultIdentifier = getIdentifierName(
-        unwrapStaticExpression(commonJsDefault)
+      const commonJsDefaultIdentifier = getIdentifierName2(
+        unwrapStaticExpression2(commonJsDefault)
       );
       return commonJsDefaultIdentifier ? context.declarations.get(commonJsDefaultIdentifier) ?? commonJsDefault : commonJsDefault;
     }
-    const defaultExpression = unwrapStaticExpression(context.defaultExport);
-    const defaultIdentifier = getIdentifierName(defaultExpression);
+    const defaultExpression = unwrapStaticExpression2(context.defaultExport);
+    const defaultIdentifier = getIdentifierName2(defaultExpression);
     if (!defaultIdentifier) {
       const defaultExportName = context.namedExports.get("default");
       return defaultExportName ? context.declarations.get(defaultExportName) ?? null : defaultExpression;
@@ -16721,8 +17200,8 @@ function resolveExportExpression(exportName, context) {
   if (exportName) {
     const commonJsExport = context.commonJsExports.get(exportName);
     if (commonJsExport) {
-      const commonJsExportIdentifier = getIdentifierName(
-        unwrapStaticExpression(commonJsExport)
+      const commonJsExportIdentifier = getIdentifierName2(
+        unwrapStaticExpression2(commonJsExport)
       );
       return commonJsExportIdentifier ? context.declarations.get(commonJsExportIdentifier) ?? commonJsExport : commonJsExport;
     }
@@ -16748,7 +17227,7 @@ function extractDefinedPlayMetadata(sourceCode, exportName) {
       context
     );
     if (directDefaultMetadata) return directDefaultMetadata;
-    const defaultIdentifier = getIdentifierName(context.defaultExport);
+    const defaultIdentifier = getIdentifierName2(context.defaultExport);
     if (defaultIdentifier) {
       const defaultMetadata = playMetadataFromDefinePlayCall(
         context.declarations.get(defaultIdentifier),
@@ -17292,6 +17771,79 @@ function isInternalGlueStepId(stepId) {
   return typeof stepId === "string" && stepId.startsWith(INTERNAL_GLUE_NODE_ID_PREFIX);
 }
 
+// ../shared_libs/play-runtime/log-provenance.ts
+var LOG_PROVENANCE_CLASSES = [
+  "user",
+  "lifecycle",
+  "replay",
+  "infra",
+  "diagnostic",
+  "receipt"
+];
+var LOG_PROVENANCE_POLICY = {
+  user: { watch: true, ui: true, debug: true },
+  lifecycle: { watch: true, ui: true, debug: true },
+  replay: { watch: false, ui: false, debug: true },
+  infra: { watch: false, ui: false, debug: true },
+  diagnostic: { watch: true, ui: true, debug: true },
+  receipt: { watch: false, ui: false, debug: true }
+};
+function logProvenanceReaches(provenance, surface) {
+  return LOG_PROVENANCE_POLICY[provenance][surface];
+}
+var PROVENANCE_SENTINEL = "
";
+var PROVENANCE_PREFIX = `${PROVENANCE_SENTINEL}prov:`;
+function readProvenanceTag(line) {
+  if (!line.startsWith(PROVENANCE_PREFIX)) {
+    return { provenance: null, line };
+  }
+  const end = line.indexOf(PROVENANCE_SENTINEL, PROVENANCE_PREFIX.length);
+  if (end === -1) {
+    return { provenance: null, line };
+  }
+  const candidate = line.slice(PROVENANCE_PREFIX.length, end);
+  const provenance = LOG_PROVENANCE_CLASSES.includes(
+    candidate
+  ) ? candidate : null;
+  return { provenance, line: line.slice(end + 1) };
+}
+function classifyLegacyLogLine(line) {
+  const message = stripLeadingTimestamp(line);
+  if (/recovered (?:from checkpoint|response from checkpoint)/i.test(message)) {
+    return "replay";
+  }
+  if (/^\[perf\] runtime receipt\b/i.test(message)) {
+    return "receipt";
+  }
+  if (/^\[perf\] runtime (?:map|state)\b/i.test(message) || /\[worker\] picked up run\b/.test(message) || /\[worker\] heartbeat\b/.test(message) || /\[worker\] progress completedRows=\d+ totalRows=\d+ rowUpdates=\d+/.test(
+    message
+  ) || /\[worker\] step started\b/.test(message) || /\[worker\] Preparing run files\b/.test(message) || /\[worker\] Run files ready\b/.test(message) || /\[worker\] Runtime ready\b/.test(message) || /\[worker\] Sandbox (?:starting|create start|create done|workspace ready|upload start|runner uploaded)\b/.test(
+    message
+  ) || /^\[event\] play\.step\.progress\b/.test(message) || /^\[event\] play\.run\.snapshot\b/.test(message) || /^\[event\] play\.sheet\.summary\b/.test(message)) {
+    return "infra";
+  }
+  if (/^\[warn\]/i.test(message) || /^\[error\]/i.test(message) || /^\[runtime\.[a-z_]*(?:failure|error)\]/i.test(message)) {
+    return "diagnostic";
+  }
+  return "user";
+}
+function classifyLogLine(line) {
+  const tagged = readProvenanceTag(line);
+  if (tagged.provenance !== null) {
+    return { provenance: tagged.provenance, line: tagged.line };
+  }
+  return { provenance: classifyLegacyLogLine(tagged.line), line: tagged.line };
+}
+function stripLeadingTimestamp(line) {
+  const match = line.match(/^\[([^\]]+)\]\s*([\s\S]*)$/);
+  if (!match) {
+    return line;
+  }
+  const inner = match[1] ?? "";
+  const isTimestamp = !Number.isNaN(new Date(inner).getTime());
+  return isTimestamp ? match[2] ?? line : line;
+}
+
 // ../shared_libs/play-runtime/fixture-behavior.ts
 var FIXTURE_BEHAVIOR_VERSION = 1;
 var FIXTURE_BEHAVIOR_RESPONSE_VERSION = 2;
@@ -18269,11 +18821,12 @@ function formatUnresolvedPackagedFiles(filePath, unresolvedFileReferences) {
   const details = unresolvedFileReferences.map((unresolved) => `${unresolved.sourceFragment}: ${unresolved.message}`).join("; ");
   return `Failed to package local ctx.csv(...) files in ${filePath}: ${details}`;
 }
-async function collectBundledPlayGraph(entryFile, profile = null) {
+async function collectBundledPlayGraph(entryFile, profile = null, entryExportName = PLAY_DEFAULT_EXPORT) {
   const playBundler = await loadPlayBundler();
   const nodes = /* @__PURE__ */ new Map();
   const visiting = /* @__PURE__ */ new Set();
   const artifactKind = resolveEnabledExecutionProfile(profile).artifactKind;
+  const rootPath = normalizePlayPath(entryFile);
   const visit = async (filePath) => {
     const absolutePath = normalizePlayPath(filePath);
     const cached = nodes.get(absolutePath);
@@ -18288,7 +18841,8 @@ async function collectBundledPlayGraph(entryFile, profile = null) {
     visiting.add(absolutePath);
     try {
       const bundleResult = await playBundler.bundlePlayFile(absolutePath, {
-        target: artifactKind
+        target: artifactKind,
+        ...absolutePath === rootPath && entryExportName !== PLAY_DEFAULT_EXPORT ? { exportName: entryExportName } : {}
       });
       if (bundleResult.success === false) {
         throw new Error(
@@ -18478,6 +19032,12 @@ var TERMINAL_PLAY_STATUSES2 = /* @__PURE__ */ new Set([
 var PLAY_START_TRANSIENT_RETRY_DELAYS_MS = [500, 1500];
 var PLAY_PROGRESS_HEARTBEAT_INTERVAL_MS = 15e3;
 var PLAY_STATUS_HEARTBEAT_INTERVAL_MS = 15e3;
+function watchSurfaceReaches(state, provenance) {
+  if (logProvenanceReaches(provenance, "watch")) {
+    return true;
+  }
+  return state.verbose === true && logProvenanceReaches(provenance, "debug");
+}
 function getEventPayload(event) {
   return event.payload && typeof event.payload === "object" ? event.payload : {};
 }
@@ -18514,6 +19074,13 @@ function getStatusFromLiveEvent(event) {
 }
 function readLiveRunField(event, field) {
   const payload = getEventPayload(event);
+  if (field === "waitKind") {
+    const wait = payload.wait ?? getRunRecordFromPackage(payload)?.wait;
+    if (wait && typeof wait === "object" && !Array.isArray(wait)) {
+      const kind = wait.kind;
+      if (typeof kind === "string" && kind.trim()) return kind.trim();
+    }
+  }
   const run = getRunRecordFromPackage(payload);
   const records = [payload, payload.progress, run, run?.progress].filter(
     (value) => Boolean(value && typeof value === "object" && !Array.isArray(value))
@@ -18660,6 +19227,9 @@ function emitLiveDebugTableHints(input2) {
       process.stdout
     );
   }
+  if (!watchSurfaceReaches(input2.state, "infra")) {
+    return;
+  }
   const tableNamespace = extractTableNamespaceFromLiveEvent(input2.event);
   if (!tableNamespace) {
     return;
@@ -18685,15 +19255,17 @@ function describeLiveEventPhase(event) {
     const runId = eventRunId ? ` ${eventRunId}` : "";
     return status ? `${status}${runId}` : null;
   }
-  if (event.type === "play.step.status" || event.type === "play.step.progress") {
+  if (event.type === "play.step.progress") {
     const label = typeof payload.label === "string" && payload.label.trim() ? payload.label.trim() : formatStepLabelFromNodeId(payload.stepId);
     if (!label) {
       return null;
     }
     const completed = typeof payload.completed === "number" ? payload.completed : null;
     const total = typeof payload.total === "number" ? payload.total : null;
-    const progress = completed !== null && total !== null ? ` ${completed}/${total}` : "";
-    return `step ${label}${progress}`;
+    if (completed === null || total === null) {
+      return null;
+    }
+    return `step ${label} ${completed}/${total}`;
   }
   if (event.type === "play.sheet.summary" || event.type === "play.sheet.delta") {
     const table = typeof payload.tableNamespace === "string" ? payload.tableNamespace : "";
@@ -18732,6 +19304,7 @@ function formatStepLabelFromNodeId(raw) {
       return value;
   }
 }
+var TERMINAL_STEP_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "skipped"]);
 function getStepTransitionLineFromLiveEvent(event, state) {
   if (event.type !== "play.step.status") {
     return null;
@@ -18750,7 +19323,16 @@ function getStepTransitionLineFromLiveEvent(event, state) {
   if (state.printedStepStatuses.get(stepId) === status) {
     return null;
   }
+  state.terminalStepIds ??= /* @__PURE__ */ new Set();
+  const isTerminal = TERMINAL_STEP_STATUSES.has(status);
+  const isReplayEcho = !isTerminal && state.terminalStepIds.has(stepId);
   state.printedStepStatuses.set(stepId, status);
+  if (isTerminal) {
+    state.terminalStepIds.add(stepId);
+  }
+  if (isReplayEcho && !watchSurfaceReaches(state, "replay")) {
+    return null;
+  }
   return `step ${label}: ${status}`;
 }
 function formatProgressCounts(input2) {
@@ -19141,6 +19723,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
   const state = {
     lastLogIndex: 0,
     emittedRunnerStarted: false,
+    verbose: input2.verboseLogs === true,
     lastProgressSignature: null,
     lastProgressHeartbeatAt: 0,
     lastStatusHeartbeatAt: 0
@@ -19505,7 +20088,9 @@ var BULKY_RETURN_KEYS = /* @__PURE__ */ new Set([
   "sequenceTrace",
   "logs"
 ]);
-function formatPlayLogLine(line, status, state) {
+function formatPlayLogLine(rawLine, status, state) {
+  const classified = classifyLogLine(rawLine);
+  const line = classified.line;
   const timestampMatch = line.match(/^\[([^\]]+)\]\s*(.*)$/);
   const parsedTimestamp = timestampMatch?.[1] ? new Date(timestampMatch[1]) : null;
   const timestamp = parsedTimestamp && !Number.isNaN(parsedTimestamp.getTime()) ? parsedTimestamp.toLocaleTimeString("en-US", {
@@ -19523,11 +20108,6 @@ function formatPlayLogLine(line, status, state) {
     state.emittedRunnerStarted = true;
     return `${prefix}runner started`;
   }
-  if (/\[worker\] step started\b/.test(message) || /\[worker\] Preparing run files\b/.test(message) || /\[worker\] Run files ready\b/.test(message) || /\[worker\] Runtime ready\b/.test(message) || /\[worker\] Sandbox (?:starting|create start|create done|workspace ready|upload start|runner uploaded)\b/.test(
-    message
-  )) {
-    return null;
-  }
   const stages = (status?.contract?.staticPipeline?.stages ?? []).filter((stage) => stage.tableNamespace);
   const sourceLabelForNamespace = (namespace) => {
     const stage = stages.find((entry) => entry.tableNamespace === namespace);
@@ -19548,6 +20128,9 @@ function formatPlayLogLine(line, status, state) {
     const [, results, executed, cached] = mapDone;
     return `${prefix}done: ${formatInteger(Number(results))} results, ${formatInteger(Number(executed))} executed, ${formatInteger(Number(cached))} cached`;
   }
+  if (!watchSurfaceReaches(state, classified.provenance)) {
+    return null;
+  }
   return `${prefix}${message}`;
 }
 function isDatasetResultEnvelope(value) {
@@ -21127,7 +21710,7 @@ function extractPlayValidationErrors(value) {
   if (value instanceof DeeplineError) {
     return extractPlayValidationErrors(value.details);
   }
-  if (!isRecord9(value)) {
+  if (!isRecord10(value)) {
     return [];
   }
   const directErrors = stringArrayField(value, "errors");
@@ -21364,6 +21947,7 @@ function parsePlayRunOptions(args) {
   const debugFixtureProviderPacing = args.includes(
     "--debug-fixture-provider-pacing"
   );
+  const verboseLogs = args.includes("--logs") || debugMapLatency;
   let waitTimeoutMs = null;
   let profile = null;
   let fixtureBehavior = null;
@@ -21500,6 +22084,7 @@ function parsePlayRunOptions(args) {
     revisionSelector,
     watch,
     emitLogs,
+    verboseLogs,
     jsonOutput,
     fullJson,
     waitTimeoutMs,
@@ -21586,7 +22171,7 @@ function printPlayCheckLimits(limits) {
     `  bundle: ${formatByteBudget(limits.bundle.usedBytes, limits.bundle.limitBytes)}`
   );
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue2(value) {
@@ -21596,14 +22181,14 @@ function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
 function extractionEntries2(value) {
-  if (Array.isArray(value)) return value.filter(isRecord9);
-  if (!isRecord9(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord10);
+  if (!isRecord10(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord9(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord10(entry) ? { name, ...entry } : { name }
   );
 }
 function firstRawPath(entry) {
-  const details = isRecord9(entry.details) ? entry.details : {};
+  const details = isRecord10(entry.details) ? entry.details : {};
   const paths = [
     ...asArray(details.rawToolOutputPaths),
     ...asArray(details.raw_tool_output_paths),
@@ -21621,12 +22206,12 @@ function checkHintRawPath(value) {
 function collectStaticPipelineToolIds(staticPipeline) {
   const seen = /* @__PURE__ */ new Set();
   const visitPipeline = (pipeline) => {
-    if (!isRecord9(pipeline)) return;
+    if (!isRecord10(pipeline)) return;
     for (const step of [
       ...asArray(pipeline.stages),
       ...asArray(pipeline.substeps)
     ]) {
-      if (!isRecord9(step)) continue;
+      if (!isRecord10(step)) continue;
       if (step.type === "tool") {
         const toolId = stringValue2(step.toolId) || stringValue2(step.tool);
         if (toolId) seen.add(toolId);
@@ -21640,9 +22225,9 @@ function collectStaticPipelineToolIds(staticPipeline) {
   return [...seen].sort();
 }
 function toolGetterHintFromMetadata(toolId, tool) {
-  const usageGuidance = isRecord9(tool.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord9(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord9(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
-  const toolResponse = isRecord9(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord9(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
+  const usageGuidance = isRecord10(tool.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord10(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord10(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const toolResponse = isRecord10(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord10(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
   const lists = extractionEntries2(
     resultGuidance.extractedLists ?? resultGuidance.extracted_lists
   ).map((entry) => ({
@@ -21738,6 +22323,11 @@ function printRecognizedSummary(recognized) {
   for (const dataset of recognized.datasets ?? []) {
     const columns = dataset.columns?.length ? ` (${dataset.columns.length} col${dataset.columns.length === 1 ? "" : "s"}: ${dataset.columns.join(", ")})` : "";
     console.log(`  dataset ${dataset.name}${columns}`);
+    if (dataset.undrawnColumns?.length) {
+      console.log(
+        `    undrawn (declared): ${dataset.undrawnColumns.join(", ")}`
+      );
+    }
   }
   if (recognized.inputs?.length) {
     console.log(`  inputs: ${recognized.inputs.join(", ")}`);
@@ -21823,16 +22413,16 @@ function partitionMirroredErrors(errors, issues) {
 async function handlePlayCheck(args) {
   const options = parsePlayCheckOptions(args);
   if (!isFileTarget(options.target)) {
-    const client3 = new DeeplineClient();
+    const client2 = new DeeplineClient();
     try {
-      await assertCanonicalNamedPlayReference(client3, options.target, {
+      await assertCanonicalNamedPlayReference(client2, options.target, {
         command: "check"
       });
-      const play = await client3.describePlay(
+      const play = await client2.describePlay(
         parseReferencedPlayTarget2(options.target).playName,
         { compact: true }
       );
-      const result2 = {
+      const result = {
         valid: true,
         target: options.target,
         name: play.name,
@@ -21845,10 +22435,10 @@ async function handlePlayCheck(args) {
         note: "Named/prebuilt play contract is available. No run was started."
       };
       if (options.jsonOutput) {
-        process.stdout.write(`${JSON.stringify(result2)}
+        process.stdout.write(`${JSON.stringify(result)}
 `);
       } else {
-        console.log(`\u2713 ${result2.reference} passed named play contract check`);
+        console.log(`\u2713 ${result.reference} passed named play contract check`);
         console.log("  no run started; no Deepline credits spent");
         if (play.runCommand) console.log(`  run: ${play.runCommand}`);
       }
@@ -21873,41 +22463,58 @@ async function handlePlayCheck(args) {
   }
   const absolutePlayPath = resolve11(options.target);
   const sourceCode = readFileSync8(absolutePlayPath, "utf-8");
+  const exportNames = resolvePlayCheckExportNames(sourceCode);
+  const outcomes = [];
+  for (const exportName of exportNames) {
+    outcomes.push(
+      await checkOneExportedPlay({
+        absolutePlayPath,
+        sourceCode,
+        exportName,
+        target: options.target
+      })
+    );
+  }
+  const merged = mergePlayCheckExportOutcomes(outcomes);
+  if (options.jsonOutput) {
+    process.stdout.write(`${JSON.stringify(merged.json)}
+`);
+  } else {
+    printPlayCheckOutcomes(outcomes, options.target);
+  }
+  return merged.valid ? 0 : 1;
+}
+function resolvePlayCheckExportNames(sourceCode) {
+  const exports = listPlayFileExports(sourceCode);
+  if (!exports || exports.length === 0) return [PLAY_DEFAULT_EXPORT];
+  return exports.map((entry) => entry.name);
+}
+async function checkOneExportedPlay(input2) {
+  const { absolutePlayPath, sourceCode, exportName } = input2;
+  const fallbackName = extractPlayName(sourceCode, absolutePlayPath);
   let graph;
   try {
-    graph = await collectBundledPlayGraph(absolutePlayPath);
+    graph = await collectBundledPlayGraph(absolutePlayPath, null, exportName);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (options.jsonOutput) {
-      process.stdout.write(
-        `${JSON.stringify({ valid: false, stage: "bundle", errors: [message] })}
-`
-      );
-    } else {
-      console.error(message);
-    }
-    return 1;
+    return {
+      exportName,
+      playName: fallbackName,
+      stage: "bundle",
+      result: {
+        valid: false,
+        errors: [error instanceof Error ? error.message : String(error)]
+      }
+    };
   }
-  const playName = graph.root.playName ?? extractPlayName(sourceCode, absolutePlayPath);
+  const playName = graph.root.playName ?? fallbackName;
   const descriptionErrors = collectMissingPlayDescriptionErrors(graph);
   if (descriptionErrors.length > 0) {
-    if (options.jsonOutput) {
-      process.stdout.write(
-        `${JSON.stringify({
-          name: playName,
-          valid: false,
-          stage: "authoring",
-          errors: descriptionErrors
-        })}
-`
-      );
-    } else {
-      console.error(`\u2717 ${playName} failed local play check`);
-      for (const error of descriptionErrors) {
-        console.error(`  ${error}`);
-      }
-    }
-    return 1;
+    return {
+      exportName,
+      playName,
+      stage: "authoring",
+      result: { valid: false, errors: descriptionErrors }
+    };
   }
   const client2 = new DeeplineClient();
   const integrationMode = resolveEvalIntegrationMode();
@@ -21922,64 +22529,136 @@ async function handlePlayCheck(args) {
     sourceFiles: graph.root.sourceFiles,
     description: graph.root.playDescription ?? void 0,
     artifact: graph.root.artifact,
+    ...exportName === PLAY_DEFAULT_EXPORT ? {} : { exportName },
     ...importedPlays.length > 0 ? { importedPlays } : {},
     ...integrationMode ? { integrationMode } : {}
   });
-  const enrichedResult = {
-    ...result,
-    errors: result.valid ? result.errors : addPlayCheckRepairHints({
-      errors: result.errors,
-      sourceCode: graph.root.sourceCode
-    }),
-    toolGetterHints: result.toolGetterHints ?? await buildToolGetterHints(client2, result.staticPipeline)
-  };
-  if (options.jsonOutput) {
-    process.stdout.write(
-      `${JSON.stringify({ name: playName, ...enrichedResult })}
-`
-    );
-  } else if (enrichedResult.valid) {
-    const summary = enrichedResult.summary?.trim();
-    console.log(
-      summary ? `\u2713 ${playName} valid \u2014 ${summary}` : `\u2713 ${playName} passed cloud play check`
-    );
-    if (enrichedResult.artifactHash) {
-      console.log(`  artifact: ${enrichedResult.artifactHash.slice(0, 12)}`);
+  return {
+    exportName,
+    playName,
+    result: {
+      ...result,
+      errors: result.valid ? result.errors : addPlayCheckRepairHints({
+        errors: result.errors,
+        sourceCode: graph.root.sourceCode
+      }),
+      toolGetterHints: result.toolGetterHints ?? await buildToolGetterHints(client2, result.staticPipeline)
     }
-    if (enrichedResult.sourceHash) {
-      console.log(`  source: ${enrichedResult.sourceHash.slice(0, 12)}`);
+  };
+}
+function mergePlayCheckExportOutcomes(outcomes) {
+  const primary = outcomes[0];
+  const valid = outcomes.every((outcome) => outcome.result.valid);
+  const base = {
+    name: primary.playName,
+    ...primary.stage ? { stage: primary.stage } : {},
+    ...primary.result,
+    valid
+  };
+  if (outcomes.length === 1) {
+    return { valid, json: base };
+  }
+  const errors = [...primary.result.errors];
+  const seenErrors = new Set(errors);
+  const warnings = [...primary.result.warnings ?? []];
+  const seenWarnings = new Set(warnings);
+  const issues = [...primary.result.issues ?? []];
+  const seenIssues = new Set(
+    issues.map((issue) => `${issue.code} ${issue.path ?? ""} ${issue.message}`)
+  );
+  for (const outcome of outcomes.slice(1)) {
+    for (const error of outcome.result.errors) {
+      if (seenErrors.has(error)) continue;
+      seenErrors.add(error);
+      errors.push(`[export ${outcome.exportName}] ${error}`);
+    }
+    for (const warning of outcome.result.warnings ?? []) {
+      if (seenWarnings.has(warning)) continue;
+      seenWarnings.add(warning);
+      warnings.push(`[export ${outcome.exportName}] ${warning}`);
+    }
+    for (const issue of outcome.result.issues ?? []) {
+      const key = `${issue.code} ${issue.path ?? ""} ${issue.message}`;
+      if (seenIssues.has(key)) continue;
+      seenIssues.add(key);
+      issues.push({ ...issue, exportName: outcome.exportName });
     }
-    printPlayCheckLimits(enrichedResult.limits);
-    if (enrichedResult.artifactHash) {
-      console.log(
-        `  publish: deepline plays publish ${shellQuote2(options.target)} --expected-artifact ${enrichedResult.artifactHash}`
-      );
+  }
+  return {
+    valid,
+    json: {
+      ...base,
+      errors,
+      ...warnings.length > 0 || primary.result.warnings ? { warnings } : {},
+      ...issues.length > 0 || primary.result.issues ? { issues } : {},
+      exports: outcomes.map((outcome) => ({
+        ...outcome.result,
+        exportName: outcome.exportName,
+        name: outcome.playName,
+        ...outcome.stage ? { stage: outcome.stage } : {}
+      }))
     }
-    printPlayTriggers(enrichedResult.triggers);
-    printRecognizedSummary(enrichedResult.recognized);
-    printPlayCheckIssues(
-      enrichedResult.issues,
-      (line) => console.log(line),
-      enrichedResult.warnings
+  };
+}
+function playCheckFailureStage(outcome) {
+  if (outcome.stage === "bundle") return "to bundle";
+  if (outcome.stage === "authoring") return "local play check";
+  return outcome.result.limits ? "cloud play check" : "local play check";
+}
+function printPlayCheckOutcome(outcome, target, prefix) {
+  const { result, playName } = outcome;
+  if (!result.valid) {
+    console.error(
+      `\u2717 ${prefix}${playName} failed ${playCheckFailureStage(outcome)}`
     );
-    printToolGetterHints(enrichedResult.toolGetterHints);
-  } else {
-    console.error(`\u2717 ${playName} failed cloud play check`);
     const { unstructuredErrors } = partitionMirroredErrors(
-      enrichedResult.errors,
-      enrichedResult.issues
+      result.errors,
+      result.issues
     );
     for (const error of unstructuredErrors) {
       console.error(`  ${error}`);
     }
     printPlayCheckIssues(
-      enrichedResult.issues,
+      result.issues,
       (line) => console.error(line),
-      enrichedResult.warnings
+      result.warnings
     );
-    printToolGetterHints(enrichedResult.toolGetterHints);
+    printToolGetterHints(result.toolGetterHints);
+    return;
+  }
+  const summary = result.summary?.trim();
+  console.log(
+    summary ? `\u2713 ${prefix}${playName} valid \u2014 ${summary}` : `\u2713 ${prefix}${playName} passed ${result.limits ? "cloud" : "local"} play check`
+  );
+  if (result.artifactHash) {
+    console.log(`  artifact: ${result.artifactHash.slice(0, 12)}`);
+  }
+  if (result.sourceHash) {
+    console.log(`  source: ${result.sourceHash.slice(0, 12)}`);
+  }
+  printPlayCheckLimits(result.limits);
+  if (result.artifactHash && outcome.exportName === PLAY_DEFAULT_EXPORT) {
+    console.log(
+      `  publish: deepline plays publish ${shellQuote2(target)} --expected-artifact ${result.artifactHash}`
+    );
+  }
+  printPlayTriggers(result.triggers);
+  printRecognizedSummary(result.recognized);
+  printPlayCheckIssues(
+    result.issues,
+    (line) => console.log(line),
+    result.warnings
+  );
+  printToolGetterHints(result.toolGetterHints);
+}
+function printPlayCheckOutcomes(outcomes, target) {
+  if (outcomes.length === 1) {
+    printPlayCheckOutcome(outcomes[0], target, "");
+    return;
+  }
+  for (const outcome of outcomes) {
+    printPlayCheckOutcome(outcome, target, `[${outcome.exportName}] `);
   }
-  return enrichedResult.valid ? 0 : 1;
 }
 async function handleFileBackedRun(options, hooks) {
   if (options.target.kind !== "file") {
@@ -22113,6 +22792,7 @@ async function handleFileBackedRun(options, hooks) {
         playName,
         jsonOutput: options.jsonOutput,
         emitLogs: options.emitLogs,
+        verboseLogs: options.verboseLogs,
         waitTimeoutMs: options.waitTimeoutMs,
         open: options.open,
         progress,
@@ -22292,6 +22972,7 @@ async function handleNamedRun(options, hooks) {
         playName,
         jsonOutput: options.jsonOutput,
         emitLogs: options.emitLogs,
+        verboseLogs: options.verboseLogs,
         waitTimeoutMs: options.waitTimeoutMs,
         open: options.open,
         progress,
@@ -26056,7 +26737,7 @@ function isMarkedTestAiInferenceCommand(command) {
   if (normalizeEnrichPlayRef(command.tool) !== "run_javascript") {
     return false;
   }
-  return isRecord10(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
+  return isRecord11(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
 }
 function enrichDebugEnabled(env = process.env) {
   const raw = String(env.DEEPLINE_DEBUG_ENRICH ?? "").trim().toLowerCase();
@@ -26320,7 +27001,7 @@ function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord10(value)) {
+    if (!isRecord11(value)) {
       return value;
     }
     const next = Object.fromEntries(
@@ -26329,7 +27010,7 @@ function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
         key === "rerunCommand" && typeof entry === "string" ? enrichCommand : rewrite(entry)
       ])
     );
-    if (isRecord10(next.next) && typeof next.next.run === "string") {
+    if (isRecord11(next.next) && typeof next.next.run === "string") {
       next.next = { ...next.next, run: enrichCommand };
     }
     return next;
@@ -26811,7 +27492,7 @@ async function resolveWatchedGeneratedPlayStatus(input2) {
   }
   return input2.client.runs.get(runId, { full: true });
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 async function captureStdout(run, options = {}) {
@@ -27063,15 +27744,15 @@ function readFirstEnrichDatasetActions(value) {
       return null;
     }
     const record = candidate;
-    const actions = isRecord10(record.actions) ? record.actions : null;
-    const currentQuery = isRecord10(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
-    const legacyQuery = isRecord10(actions?.query) ? actions.query : null;
+    const actions = isRecord11(record.actions) ? record.actions : null;
+    const currentQuery = isRecord11(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
+    const legacyQuery = isRecord11(actions?.query) ? actions.query : null;
     const query = currentQuery?.kind === "deepline_db_query" ? currentQuery : legacyQuery?.kind === "deepline_db_query" ? legacyQuery : null;
     if (query?.kind === "deepline_db_query") {
       return {
         dataset: record,
         query,
-        ...isRecord10(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
+        ...isRecord11(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
       };
     }
     if (options.allowLegacy && record.kind === "dataset" && typeof record.queryDatasetCommand === "string" && record.queryDatasetCommand.trim()) {
@@ -27124,7 +27805,7 @@ function enrichCustomerDbJson(input2) {
   const dataset = actions.dataset;
   const sql = actionStringField(query, "sql") ?? parseSqlFromDbQueryCommand(actions.queryDatasetCommand);
   const datasetPath = actionStringField(query, "datasetPath") ?? actionStringField(dataset, "path") ?? actionStringField(dataset, "tableNamespace");
-  const api = isRecord10(query.api) ? query.api : null;
+  const api = isRecord11(query.api) ? query.api : null;
   const apiPath = actionStringField(api ?? {}, "path") ?? "/api/v2/db/query";
   const apiMethod = actionStringField(api ?? {}, "method") ?? "POST";
   if (!datasetPath) {
@@ -27193,11 +27874,11 @@ function sqlStringLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function failureAliasFromCellMeta(cellMeta) {
-  if (!isRecord10(cellMeta)) {
+  if (!isRecord11(cellMeta)) {
     return null;
   }
   for (const [alias, meta] of Object.entries(cellMeta)) {
-    if (!isRecord10(meta)) {
+    if (!isRecord11(meta)) {
       continue;
     }
     const failure = failureCellFromMeta(meta, {});
@@ -27691,7 +28372,7 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   return fallback;
 }
 function failureCellFromMeta(meta, fallback) {
-  if (!isRecord10(meta)) {
+  if (!isRecord11(meta)) {
     return null;
   }
   const status = typeof meta.status === "string" ? meta.status.trim().toLowerCase() : "";
@@ -27711,7 +28392,7 @@ function failureCellFromMeta(meta, fallback) {
   };
 }
 function applyFailureCellMeta(row, cellMeta, fallback) {
-  if (!isRecord10(cellMeta)) {
+  if (!isRecord11(cellMeta)) {
     return;
   }
   for (const [field, meta] of Object.entries(cellMeta)) {
@@ -27939,7 +28620,7 @@ function stableRowSnapshot(value) {
 }
 function cellFailureError(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord10(parsed)) {
+  if (!isRecord11(parsed)) {
     const text = typeof parsed === "string" ? parsed.trim() : "";
     if (/^(?:[A-Za-z0-9_:-]+:\s*)?(?:Error|TypeError|ReferenceError|SyntaxError|RangeError):\s+/.test(
       text
@@ -27947,12 +28628,12 @@ function cellFailureError(value) {
       return { message: text };
     }
   }
-  if (!isRecord10(parsed)) {
+  if (!isRecord11(parsed)) {
     return null;
   }
   const status = typeof parsed.status === "string" ? parsed.status.trim().toLowerCase() : "";
   const directError = typeof parsed.error === "string" ? parsed.error.trim() : typeof parsed.last_error === "string" ? parsed.last_error.trim() : "";
-  const result = isRecord10(parsed.result) ? parsed.result : null;
+  const result = isRecord11(parsed.result) ? parsed.result : null;
   const resultError = typeof result?.error === "string" ? result.error.trim() : typeof result?.message === "string" ? result.message.trim() : "";
   if (!directError && !resultError && status !== "error" && status !== "failed") {
     return null;
@@ -28022,7 +28703,7 @@ function assignFlattenedFailurePath(target, field, value) {
   let cursor = target;
   for (const part of normalized.slice(0, -1)) {
     const existing = cursor[part];
-    if (!isRecord10(existing)) {
+    if (!isRecord11(existing)) {
       const next = {};
       cursor[part] = next;
       cursor = next;
@@ -28186,10 +28867,10 @@ function waterfallExecutionSignal(status, spec) {
   let everyChildStatOnlyConditionSkipped = true;
   const childAliasesWithStats = /* @__PURE__ */ new Set();
   for (const childAlias of childAliases) {
-    for (const stat4 of summaries.map((summary) => summary[childAlias]).filter(isRecord10)) {
+    for (const stat4 of summaries.map((summary) => summary[childAlias]).filter(isRecord11)) {
       sawChildStats = true;
       childAliasesWithStats.add(childAlias);
-      const execution = isRecord10(stat4.execution) ? stat4.execution : null;
+      const execution = isRecord11(stat4.execution) ? stat4.execution : null;
       const executedSummary = parseExecutionSummary(
         execution?.["completed:executed"]
       );
@@ -28219,7 +28900,7 @@ function waterfallExecutionSignal(status, spec) {
 }
 function emptyWaterfallStatsEvidence(status, spec) {
   const summaries = collectColumnStats(status);
-  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord10);
+  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord11);
   for (const stat4 of parentStats) {
     const nonEmpty = parseExecutionSummary(stat4.non_empty);
     if (nonEmpty?.total && nonEmpty.count === 0) {
@@ -28233,7 +28914,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
   let selectedRows = 0;
   let sawStatsForEveryChild = true;
   for (const childAlias of childAliases) {
-    const stat4 = summaries.map((summary) => summary[childAlias]).find(isRecord10);
+    const stat4 = summaries.map((summary) => summary[childAlias]).find(isRecord11);
     if (!stat4) {
       sawStatsForEveryChild = false;
       break;
@@ -28242,7 +28923,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
     if ((nonEmpty?.count ?? 0) > 0) {
       return null;
     }
-    const execution = isRecord10(stat4.execution) ? stat4.execution : null;
+    const execution = isRecord11(stat4.execution) ? stat4.execution : null;
     const executed = parseExecutionSummary(execution?.["completed:executed"]);
     const reused = parseExecutionSummary(execution?.["completed:reused"]);
     const skipped = parseExecutionSummary(execution?.["skipped:condition"]);
@@ -28284,11 +28965,11 @@ function collectStatusFailureJobs(input2) {
   const jobs = [];
   aliases.forEach((spec, aliasIndex) => {
     const { alias } = spec;
-    const stat4 = summaries.map((summary) => summary[alias]).find(isRecord10);
+    const stat4 = summaries.map((summary) => summary[alias]).find(isRecord11);
     if (!stat4) {
       return;
     }
-    const execution = isRecord10(stat4.execution) ? stat4.execution : null;
+    const execution = isRecord11(stat4.execution) ? stat4.execution : null;
     const failedCount = Math.min(
       selectedRows,
       Math.max(
@@ -28395,10 +29076,10 @@ function collectColumnStats(status) {
       value.forEach(visit);
       return;
     }
-    if (!isRecord10(value)) {
+    if (!isRecord11(value)) {
       return;
     }
-    if (isRecord10(value.columnStats)) {
+    if (isRecord11(value.columnStats)) {
       summaries.push(value.columnStats);
     }
     Object.values(value).forEach(visit);
@@ -28410,12 +29091,12 @@ function firstAliasExecutionCounts(input2) {
   const aliases = collectConfigScalarAliasOrder(input2.config);
   const summaries = collectColumnStats(input2.status);
   for (const alias of aliases) {
-    const stat4 = summaries.map((summary) => summary[alias]).find(isRecord10);
+    const stat4 = summaries.map((summary) => summary[alias]).find(isRecord11);
     if (!stat4) continue;
     if (input2.forceAliases.has(normalizeAlias2(alias))) {
       return { executed: input2.selectedRows, reused: 0 };
     }
-    const execution = isRecord10(stat4.execution) ? stat4.execution : null;
+    const execution = isRecord11(stat4.execution) ? stat4.execution : null;
     if (!execution) continue;
     return {
       executed: parseExecutionCount(execution["completed:executed"]),
@@ -28442,14 +29123,14 @@ function rewriteEnrichJsonStatus(input2) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord10(value)) {
+    if (!isRecord11(value)) {
       return value;
     }
     const next = {};
     for (const [key, entry] of Object.entries(value)) {
       next[key] = rewrite(entry);
     }
-    if (isRecord10(next.progress)) {
+    if (isRecord11(next.progress)) {
       next.progress = {
         ...next.progress,
         ...selectedRows > 0 ? { total: selectedRows } : {},
@@ -28458,8 +29139,8 @@ function rewriteEnrichJsonStatus(input2) {
         ...failedRows > 0 ? { failed: failedRows, pending: 0 } : {}
       };
     }
-    if (isRecord10(next.summary)) {
-      const rowCounts = isRecord10(next.summary.rowCounts) ? next.summary.rowCounts : null;
+    if (isRecord11(next.summary)) {
+      const rowCounts = isRecord11(next.summary.rowCounts) ? next.summary.rowCounts : null;
       if (failedRows > 0) {
         next.summary = {
           ...next.summary,
@@ -28472,11 +29153,11 @@ function rewriteEnrichJsonStatus(input2) {
         };
       }
     }
-    if (isRecord10(next.columnStats) && selectedRows > 0) {
+    if (isRecord11(next.columnStats) && selectedRows > 0) {
       const columnStats = { ...next.columnStats };
       for (const alias of forcedAliases) {
-        const stat4 = isRecord10(columnStats[alias]) ? columnStats[alias] : null;
-        const execution = isRecord10(stat4?.execution) ? stat4.execution : null;
+        const stat4 = isRecord11(columnStats[alias]) ? columnStats[alias] : null;
+        const execution = isRecord11(stat4?.execution) ? stat4.execution : null;
         if (!stat4 || !execution) continue;
         columnStats[alias] = {
           ...stat4,
@@ -28495,14 +29176,14 @@ function rewriteEnrichJsonStatus(input2) {
     return next;
   };
   const rewritten = rewrite(input2.status);
-  if (failedRows === 0 || !isRecord10(rewritten)) {
+  if (failedRows === 0 || !isRecord11(rewritten)) {
     return rewritten;
   }
   const partialStatus = selectedRows > 0 && failedRows < selectedRows ? "partial_success" : "failed";
   return {
     ...rewritten,
     ...rewritten.status === "completed" || rewritten.status === "failed" ? { status: partialStatus } : {},
-    ...isRecord10(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
+    ...isRecord11(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
   };
 }
 function summarizeFailedJobError(value) {
@@ -29126,7 +29807,7 @@ function materializeCsvCellValue(value) {
   return value;
 }
 function compactArrayEnvelopeCompleteValue(value) {
-  if (!isRecord10(value) || value.kind !== "array") {
+  if (!isRecord11(value) || value.kind !== "array") {
     return null;
   }
   if (!Array.isArray(value.preview)) {
@@ -29140,7 +29821,7 @@ function compactArrayEnvelopeCompleteValue(value) {
 }
 function disambiguateCompactAiInferencePayload(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord10(parsed) || !cellFailureError(parsed)) {
+  if (!isRecord11(parsed) || !cellFailureError(parsed)) {
     return value;
   }
   return {
@@ -29149,14 +29830,14 @@ function disambiguateCompactAiInferencePayload(value) {
   };
 }
 function compactAiInferenceCellForCsv(value) {
-  if (!isRecord10(value)) {
+  if (!isRecord11(value)) {
     return value;
   }
   const extractedJson = value.extracted_json;
   if (extractedJson !== null && extractedJson !== void 0) {
     return disambiguateCompactAiInferencePayload(extractedJson);
   }
-  const result = isRecord10(value.result) ? value.result : null;
+  const result = isRecord11(value.result) ? value.result : null;
   const object = result?.object;
   if (object !== null && object !== void 0) {
     return disambiguateCompactAiInferencePayload(object);
@@ -29173,12 +29854,12 @@ function compactAiInferenceCellForCsv(value) {
 }
 function materializeEnrichAliasCellForCsv(row, alias, options) {
   const direct = row[alias];
-  if (isRecord10(direct)) {
+  if (isRecord11(direct)) {
     const completeArray = compactArrayEnvelopeCompleteValue(direct);
     if (completeArray) {
       return materializeCsvCellValue(completeArray);
     }
-    if (options?.compactAiCell && direct.status === "completed" && (isRecord10(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
+    if (options?.compactAiCell && direct.status === "completed" && (isRecord11(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
       return materializeCsvCellValue(compactAiInferenceCellForCsv(direct));
     }
     if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
@@ -29319,11 +30000,11 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
 }
 function legacyMetadataFromRow(row) {
   const direct = parseLegacyMetadataCell(row._metadata);
-  if (direct && isRecord10(direct.columns)) {
+  if (direct && isRecord11(direct.columns)) {
     return direct;
   }
   const relocated = parseLegacyMetadataCell(row.metadata);
-  if (relocated && isRecord10(relocated.columns)) {
+  if (relocated && isRecord11(relocated.columns)) {
     return relocated;
   }
   const flattenedColumns = parseLegacyMetadataCell(row["metadata.columns"]);
@@ -29340,7 +30021,7 @@ function legacyMetadataFromRow(row) {
 }
 function parseLegacyMetadataCell(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (isRecord10(parsed)) {
+  if (isRecord11(parsed)) {
     return parsed;
   }
   if (typeof value !== "string") {
@@ -29357,12 +30038,12 @@ function parseLegacyMetadataCell(value) {
   for (const candidate of candidates) {
     try {
       const decoded = JSON.parse(candidate);
-      if (isRecord10(decoded)) {
+      if (isRecord11(decoded)) {
         return decoded;
       }
       if (typeof decoded === "string") {
         const nested = JSON.parse(decoded);
-        if (isRecord10(nested)) {
+        if (isRecord11(nested)) {
           return nested;
         }
       }
@@ -29372,8 +30053,8 @@ function parseLegacyMetadataCell(value) {
   return null;
 }
 function mergeLegacyMetadataRecords(base, enriched) {
-  const baseColumns = isRecord10(base.columns) ? base.columns : null;
-  const enrichedColumns = isRecord10(enriched.columns) ? enriched.columns : null;
+  const baseColumns = isRecord11(base.columns) ? base.columns : null;
+  const enrichedColumns = isRecord11(enriched.columns) ? enriched.columns : null;
   const merged = {
     ...base,
     ...enriched
@@ -34193,7 +34874,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
 }
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
-    if (!isRecord11(entry)) return [];
+    if (!isRecord12(entry)) return [];
     const name = stringField2(entry, "name");
     const expression = stringField2(entry, "expression");
     return name && expression ? [{ name, expression }] : [];
@@ -34214,7 +34895,7 @@ function printMonitorTypeFilters(tool) {
   }
   console.log("Deploy filters (set in the monitor payload):");
   for (const name of names) {
-    const field = isRecord11(properties[name]) ? properties[name] : {};
+    const field = isRecord12(properties[name]) ? properties[name] : {};
     const star = required.has(name) ? "*" : "";
     const enumVals = arrayField2(field, "enum").filter(
       (v) => typeof v === "string"
@@ -34226,14 +34907,14 @@ function printMonitorTypeFilters(tool) {
 }
 function printMonitorTypeStreams(tool) {
   const streams = arrayField2(tool, "streams", "output_streams").filter(
-    isRecord11
+    isRecord12
   );
   if (!streams.length) return;
   console.log("");
   console.log("Filter columns (a play's sqlListeners.where, per stream):");
   for (const stream of streams) {
     const name = stringField2(stream, "stream");
-    const cols = arrayField2(stream, "columns").filter(isRecord11).map((col) => stringField2(col, "name")).filter(Boolean);
+    const cols = arrayField2(stream, "columns").filter(isRecord12).map((col) => stringField2(col, "name")).filter(Boolean);
     console.log(`- ${name}: ${cols.join(", ")}`);
   }
 }
@@ -34251,7 +34932,7 @@ function printMonitorTypePricing(tool) {
   }
   console.log("Pricing (Deepline credits per accepted event):");
   for (const key of keys) {
-    const entry = isRecord11(byType[key]) ? byType[key] : {};
+    const entry = isRecord12(byType[key]) ? byType[key] : {};
     const credits = numberField2(entry, "deepline_credits", "deeplineCredits");
     const display = stringField2(entry, "display");
     const shown = display || (credits !== null ? `${formatDecimal(credits)} credits/event` : "see --json");
@@ -34296,8 +34977,8 @@ function printCompactToolContract(tool, requestedToolId) {
     return;
   }
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord11(contract.cost) ? contract.cost : {};
-  const getters = isRecord11(contract.getters) ? contract.getters : {};
+  const cost = isRecord12(contract.cost) ? contract.cost : {};
+  const getters = isRecord12(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const inputFields = recursiveToolInputFieldsForDisplay(
@@ -34312,7 +34993,7 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log(`Tags: ${contract.categories.join(", ")}`);
   }
   if (contract.deprecated === true) {
-    const deprecation = isRecord11(contract.deprecation) ? contract.deprecation : {};
+    const deprecation = isRecord12(contract.deprecation) ? contract.deprecation : {};
     const message = stringField2(deprecation, "message");
     const replacementToolId = stringField2(
       deprecation,
@@ -34339,7 +35020,7 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("");
     console.log("Inputs:");
     for (const field of inputFields) {
-      if (!isRecord11(field)) continue;
+      if (!isRecord12(field)) continue;
       const name = stringField2(field, "name");
       if (!name) continue;
       const required = field.required ? "*" : "";
@@ -34358,7 +35039,7 @@ function printCompactToolContract(tool, requestedToolId) {
   }
   console.log("");
   printToolExamplesOnly(tool, requestedToolId, { includeSamples: false });
-  const starterScript = isRecord11(contract.starterScript) ? contract.starterScript : {};
+  const starterScript = isRecord12(contract.starterScript) ? contract.starterScript : {};
   const starterPath = stringField2(starterScript, "path");
   if (starterPath) {
     console.log("");
@@ -34372,14 +35053,14 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("Getters:");
     if (listGetters.length) console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord11(entry))
+      if (isRecord12(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
     }
     if (valueGetters.length) console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord11(entry))
+      if (isRecord12(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -34396,7 +35077,7 @@ function printToolPricingOnly(tool, requestedToolId, options = {}) {
     return;
   }
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord11(contract.cost) ? contract.cost : {};
+  const cost = isRecord12(contract.cost) ? contract.cost : {};
   const pricingModel = stringField2(cost, "pricingModel") || "unknown";
   const billingMode = stringField2(cost, "billingMode") || "unknown";
   const unit = pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit";
@@ -34468,10 +35149,10 @@ function printToolExamplesOnly(tool, requestedToolId, options = {}) {
     `  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`
   );
   console.log("});");
-  const getters = isRecord11(contract.getters) ? contract.getters : {};
+  const getters = isRecord12(contract.getters) ? contract.getters : {};
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
-  const firstGetter = [...valueGetters, ...listGetters].find(isRecord11);
+  const firstGetter = [...valueGetters, ...listGetters].find(isRecord12);
   if (firstGetter) {
     const name = stringField2(firstGetter, "name") || "value";
     const expression = stringField2(firstGetter, "expression");
@@ -34507,7 +35188,7 @@ function printPlayLikeToolUsage(tool, requestedToolId) {
 }
 function printToolGettersOnly(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const getters = isRecord11(contract.getters) ? contract.getters : {};
+  const getters = isRecord12(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   console.log(`Getters: ${contract.toolId}`);
@@ -34520,7 +35201,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (listGetters.length) {
     console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord11(entry))
+      if (isRecord12(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -34529,7 +35210,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (valueGetters.length) {
     console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord11(entry))
+      if (isRecord12(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -34555,7 +35236,7 @@ function sampleValueForField(field) {
 function samplePayloadForInputFields(fields) {
   return Object.fromEntries(
     fields.slice(0, 4).flatMap((field) => {
-      if (!isRecord11(field)) return [];
+      if (!isRecord12(field)) return [];
       const name = stringField2(field, "name");
       if (!name) return [];
       return [[name, sampleValueForField(field)]];
@@ -34673,12 +35354,12 @@ function formatListedToolCost(tool) {
 }
 function toolInputFieldsForDisplay(inputSchema) {
   if (Array.isArray(inputSchema.fields))
-    return inputSchema.fields.filter(isRecord11);
-  const jsonSchema = isRecord11(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
-  const properties = isRecord11(jsonSchema.properties) ? jsonSchema.properties : {};
+    return inputSchema.fields.filter(isRecord12);
+  const jsonSchema = isRecord12(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord12(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = Array.isArray(jsonSchema.required) ? new Set(jsonSchema.required.map(String)) : /* @__PURE__ */ new Set();
   return Object.entries(properties).map(([name, value]) => {
-    const property = isRecord11(value) ? value : {};
+    const property = isRecord12(value) ? value : {};
     return {
       name,
       type: typeof property.type === "string" ? property.type : "unknown",
@@ -34689,10 +35370,10 @@ function toolInputFieldsForDisplay(inputSchema) {
   });
 }
 function canonicalToolJsonSchema(inputSchema) {
-  return isRecord11(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  return isRecord12(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
 }
 function declaredToolJsonSchema(inputSchema) {
-  if (isRecord11(inputSchema.jsonSchema)) {
+  if (isRecord12(inputSchema.jsonSchema)) {
     return inputSchema.jsonSchema;
   }
   return Array.isArray(inputSchema.fields) ? null : inputSchema;
@@ -34717,7 +35398,7 @@ function publicToolInputSchemaForDescribe(inputSchema) {
   };
   const stripDescriptions = (value) => {
     if (Array.isArray(value)) return value.map(stripDescriptions);
-    if (!isRecord11(value)) return value;
+    if (!isRecord12(value)) return value;
     return Object.fromEntries(
       Object.entries(value).flatMap(([key, nested]) => {
         if (key === "description" && typeof nested === "string" && exposesProviderSpend(nested)) {
@@ -34738,7 +35419,7 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
       for (const item of value) collectSchemaIds(item);
       return;
     }
-    if (!isRecord11(value)) return;
+    if (!isRecord12(value)) return;
     if (typeof value.$id === "string" && value.$id.trim()) {
       schemasById.set(value.$id.trim(), value);
     }
@@ -34751,10 +35432,10 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
     let current = root;
     for (const rawSegment of ref.slice(2).split("/")) {
       const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
-      if (!isRecord11(current)) return schema;
+      if (!isRecord12(current)) return schema;
       current = current[segment];
     }
-    return isRecord11(current) ? current : schema;
+    return isRecord12(current) ? current : schema;
   };
   const addField = (field) => {
     const name = typeof field.name === "string" ? field.name : "";
@@ -34769,7 +35450,7 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
     if (ref && activeRefs.has(ref)) return;
     const schema = resolveRef(unresolvedSchema);
     const nextActiveRefs = ref ? /* @__PURE__ */ new Set([...activeRefs, ref]) : activeRefs;
-    const type = Array.isArray(schema.type) ? schema.type.map(String).join("|") : typeof schema.type === "string" ? schema.type : isRecord11(schema.properties) ? "object" : schema.items ? "array" : "unknown";
+    const type = Array.isArray(schema.type) ? schema.type.map(String).join("|") : typeof schema.type === "string" ? schema.type : isRecord12(schema.properties) ? "object" : schema.items ? "array" : "unknown";
     if (path) {
       addField({
         name: path,
@@ -34780,12 +35461,12 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
         ...Object.prototype.hasOwnProperty.call(schema, "default") ? { default: schema.default } : {}
       });
     }
-    const properties = isRecord11(schema.properties) ? schema.properties : {};
+    const properties = isRecord12(schema.properties) ? schema.properties : {};
     const requiredNames = new Set(
       Array.isArray(schema.required) ? schema.required.map(String) : []
     );
     for (const [name, value] of Object.entries(properties)) {
-      if (!isRecord11(value)) continue;
+      if (!isRecord12(value)) continue;
       visit(
         value,
         path ? `${path}.${name}` : name,
@@ -34793,13 +35474,13 @@ function recursiveToolInputFieldsForDisplay(inputSchema) {
         nextActiveRefs
       );
     }
-    if (isRecord11(schema.items)) {
+    if (isRecord12(schema.items)) {
       visit(schema.items, `${path}[]`, false, nextActiveRefs);
     }
     for (const keyword of ["anyOf", "oneOf", "allOf"]) {
       const branches = Array.isArray(schema[keyword]) ? schema[keyword] : [];
       for (const branch of branches) {
-        if (isRecord11(branch)) {
+        if (isRecord12(branch)) {
           visit(branch, path, required, nextActiveRefs);
         }
       }
@@ -34827,14 +35508,14 @@ function printJsonPreview(label, payload) {
 }
 function samplePayload(samples, key) {
   const entry = samples[key];
-  if (!isRecord11(entry)) return void 0;
+  if (!isRecord12(entry)) return void 0;
   return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
 }
 function commandEnvelopeFromRawResponse(rawResponse) {
-  return isRecord11(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
+  return isRecord12(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
 function extractToolExecutionWarningMessages(rawResponse) {
-  if (!isRecord11(rawResponse)) return [];
+  if (!isRecord12(rawResponse)) return [];
   const candidates = [
     recordField2(recordField2(rawResponse, "toolResponse"), "meta"),
     recordField2(
@@ -34851,7 +35532,7 @@ function extractToolExecutionWarningMessages(rawResponse) {
     for (const warning of warnings) {
       if (typeof warning === "string" && warning.trim()) {
         messages.push(warning.trim());
-      } else if (isRecord11(warning)) {
+      } else if (isRecord12(warning)) {
         const message = stringField2(warning, "message");
         if (message) messages.push(message);
       }
@@ -34860,7 +35541,7 @@ function extractToolExecutionWarningMessages(rawResponse) {
   return [...new Set(messages)];
 }
 function apifySyncRecoveryNext(rawResponse) {
-  if (!isRecord11(rawResponse) || rawResponse.status !== "running") return null;
+  if (!isRecord12(rawResponse) || rawResponse.status !== "running") return null;
   const toolResponse = recordField2(rawResponse, "toolResponse");
   const raw = recordField2(toolResponse, "raw");
   if (raw.state !== "awaiting_apify") return null;
@@ -34883,7 +35564,7 @@ function apifySyncRecoveryNext(rawResponse) {
 }
 function listExtractorPathsFromUsageGuidance(tool) {
   const toolExecutionResult = tool.usageGuidance?.toolExecutionResult;
-  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord11(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
+  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord12(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
   return extractedLists.flatMap((entry) => {
     const paths = entry.details?.candidatePaths ?? entry.details?.rawToolOutputPaths;
     if (!Array.isArray(paths)) return [];
@@ -34899,7 +35580,7 @@ function formatDecimal(value) {
 function formatUsd(value) {
   return `$${formatDecimal(value)}`;
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringField2(source, ...keys) {
@@ -34926,7 +35607,7 @@ function arrayField2(source, ...keys) {
 function recordField2(source, ...keys) {
   for (const key of keys) {
     const value = source[key];
-    if (isRecord11(value)) return value;
+    if (isRecord12(value)) return value;
   }
   return {};
 }
@@ -34992,7 +35673,7 @@ function parseJsonObjectArgument(raw, flagName) {
     }
     throw invalidJsonError(flagName, message);
   }
-  if (!isRecord11(parsed)) {
+  if (!isRecord12(parsed)) {
     throw invalidJsonError(flagName, "expected an object.");
   }
   return parsed;
@@ -35142,7 +35823,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     kind: summaryEntries.length > 0 ? "object" : "raw",
     summary: input2.summary
   };
-  const envelopeHasCanonicalOutput = isRecord11(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
+  const envelopeHasCanonicalOutput = isRecord12(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
   const envelopeHasDeclaredOutput = Object.prototype.hasOwnProperty.call(
     envelope,
     "output"
@@ -35375,7 +36056,7 @@ async function executeTool(args) {
       {
         ...baseEnvelope,
         local: {
-          ...isRecord11(baseEnvelope.local) ? baseEnvelope.local : {},
+          ...isRecord12(baseEnvelope.local) ? baseEnvelope.local : {},
           payload_file: jsonPath
         }
       },
@@ -36094,6 +36775,7 @@ var DEFAULT_V1_SKILL_NAMES = [
   "build-tam",
   "clay-to-deepline",
   "deepline-analytics",
+  "deepline-engine",
   "deepline-feedback",
   "deepline-gtm",
   "deepline-plays",