deepline 0.3.392 → 0.3.394

package/dist/bundling-sources/shared_libs/plays/dataset.ts

@@ -4,6 +4,118 @@ import type { PlayDatasetColumnTypes } from '../play-data-plane/contracts';
 const PLAY_DATASET_BRAND = Symbol.for('deepline.play.dataset');
 const NODE_INSPECT_CUSTOM = Symbol.for('nodejs.util.inspect.custom');
 const residentRowsByDataset = new WeakMap<object, readonly unknown[]>();
+// Source ordinals are execution provenance, never customer columns. Weak
+// references keep streaming sources bounded and transforms preserve ordinals.
+type PlayDatasetSourceRowIdentity = Readonly<{
+  datasetId: string;
+  rowIndex: number;
+}>;
+const sourceRowIdentityByRow = new WeakMap<
+  object,
+  PlayDatasetSourceRowIdentity
+>();
+const sourceRowIdentitiesByRows = new WeakMap<
+  readonly unknown[],
+  readonly (PlayDatasetSourceRowIdentity | undefined)[]
+>();
+type PlayDatasetSourceOccurrence<T> = {
+  row: T;
+  sourceIdentity?: PlayDatasetSourceRowIdentity;
+};
+const sourceOccurrencesByDataset = new WeakMap<
+  object,
+  () => AsyncIterable<PlayDatasetSourceOccurrence<unknown>>
+>();
+
+export function setPlayDatasetSourceRowIdentity<T>(
+  row: T,
+  identity: Readonly<{ datasetId: string; rowIndex: number }>,
+): T {
+  if (row && typeof row === 'object') sourceRowIdentityByRow.set(row, identity);
+  return row;
+}
+
+export function getPlayDatasetSourceRowIdentity(
+  row: unknown,
+): Readonly<{ datasetId: string; rowIndex: number }> | undefined {
+  return row && typeof row === 'object'
+    ? sourceRowIdentityByRow.get(row)
+    : undefined;
+}
+
+/** Container provenance distinguishes occurrences even when a mapper returns a shared typed value. */
+export function getPlayDatasetSourceRowIdentityAt(
+  rows: readonly unknown[],
+  index: number,
+): PlayDatasetSourceRowIdentity | undefined {
+  const identities = sourceRowIdentitiesByRows.get(rows);
+  return identities
+    ? identities[index]
+    : getPlayDatasetSourceRowIdentity(rows[index]);
+}
+
+export function copyPlayDatasetSourceRowIdentity<T>(
+  source: unknown,
+  target: T,
+): T {
+  const identity = getPlayDatasetSourceRowIdentity(source);
+  return identity ? setPlayDatasetSourceRowIdentity(target, identity) : target;
+}
+
+/** A mapper may return the same object for several physical source records. */
+function copySourceOccurrenceToMappedValue<T>(
+  identity: PlayDatasetSourceRowIdentity | undefined,
+  mapped: T,
+): T {
+  if (!identity || !mapped || typeof mapped !== 'object') return mapped;
+  const prototype = Object.getPrototypeOf(mapped);
+  // Plain row values can carry provenance on a distinct execution object.
+  // Typed values retain their mapper result and internal slots; their distinct
+  // occurrences travel in the iterator/container sidecar instead.
+  const occurrence = (
+    Array.isArray(mapped)
+      ? Object.defineProperties([], Object.getOwnPropertyDescriptors(mapped))
+      : prototype === Object.prototype || prototype === null
+        ? Object.create(prototype, Object.getOwnPropertyDescriptors(mapped))
+        : mapped
+  ) as T;
+  return setPlayDatasetSourceRowIdentity(occurrence, identity);
+}
+
+async function* iterateSourceOccurrences<T>(
+  input: PlayDatasetInput<T>,
+): AsyncIterable<PlayDatasetSourceOccurrence<T>> {
+  if (isPlayDataset(input)) {
+    const occurrences = sourceOccurrencesByDataset.get(input);
+    if (occurrences) {
+      yield* occurrences() as AsyncIterable<PlayDatasetSourceOccurrence<T>>;
+      return;
+    }
+    for await (const row of input)
+      yield { row, sourceIdentity: getPlayDatasetSourceRowIdentity(row) };
+    return;
+  }
+  if (Array.isArray(input)) {
+    for (let index = 0; index < input.length; index += 1) {
+      yield {
+        row: input[index]!,
+        sourceIdentity: getPlayDatasetSourceRowIdentityAt(input, index),
+      };
+    }
+    return;
+  }
+  if (
+    input != null &&
+    typeof input === 'object' &&
+    Symbol.asyncIterator in input
+  ) {
+    for await (const row of input as AsyncIterable<T>)
+      yield { row, sourceIdentity: getPlayDatasetSourceRowIdentity(row) };
+    return;
+  }
+  for (const row of input as Iterable<T>)
+    yield { row, sourceIdentity: getPlayDatasetSourceRowIdentity(row) };
+}
 const DEFAULT_MATERIALIZE_LIMIT = 10_000;
 export const PLAY_DATASET_EXECUTION_PAGE_ROWS = 1_000;
 export const PLAY_DATASET_EXECUTION_PAGE_BYTES = 64 * 1024 * 1024;
@@ -32,6 +144,14 @@ export type PlayDatasetWorkProgressSummary = {
   pending: number;
   failed: number;
   degraded?: boolean;
+  /** Fixed-shape source/output accounting; does not redefine legacy totals. */
+  cardinality?: {
+    sourceRows: number;
+    uniqueInputRows: number;
+    duplicateOccurrences: number;
+    outputRows: number;
+    rowIdentity: 'source_row' | 'key';
+  };
   duplicates?: {
     exact?: number;
     semantic?: number;
@@ -658,7 +778,9 @@ function createTransformedPlayDataset<T, U>(
     options?.sourceLabel ??
     `${source.sourceLabel ?? source.tableNamespace ?? source.datasetId}.${transform.kind}`;
 
-  const iterate = async function* (): AsyncIterable<U> {
+  const iterateOccurrences = async function* (): AsyncIterable<
+    PlayDatasetSourceOccurrence<U>
+  > {
     if (transform.kind === 'slice') {
       const bounds = normalizeSliceBounds({
         start: transform.start,
@@ -666,10 +788,10 @@ function createTransformedPlayDataset<T, U>(
         count: await source.count(),
       });
       let index = 0;
-      for await (const row of source) {
+      for await (const occurrence of iterateSourceOccurrences(source)) {
         if (index >= bounds.end) break;
         if (index >= bounds.start) {
-          yield row as unknown as U;
+          yield occurrence as unknown as PlayDatasetSourceOccurrence<U>;
         }
         index += 1;
       }
@@ -678,27 +800,42 @@ function createTransformedPlayDataset<T, U>(
 
     let inputIndex = 0;
     let outputIndex = 0;
-    for await (const row of source) {
+    for await (const { row, sourceIdentity } of iterateSourceOccurrences(
+      source,
+    )) {
       if (transform.kind === 'filter') {
         if (await transform.predicate(row, inputIndex)) {
-          yield row as unknown as U;
+          yield { row: row as unknown as U, sourceIdentity };
           outputIndex += 1;
         }
       } else {
-        yield await transform.mapper(row, outputIndex);
+        yield {
+          row: copySourceOccurrenceToMappedValue(
+            sourceIdentity,
+            await transform.mapper(row, outputIndex),
+          ),
+          sourceIdentity,
+        };
         outputIndex += 1;
       }
       inputIndex += 1;
     }
   };
 
+  const iterate = async function* (): AsyncIterable<U> {
+    for await (const { row } of iterateOccurrences()) yield row;
+  };
+
   const collect = async (limit?: number): Promise<U[]> => {
     const rows: U[] = [];
+    const identities: (PlayDatasetSourceRowIdentity | undefined)[] = [];
+    sourceRowIdentitiesByRows.set(rows, identities);
     const boundedLimit =
       limit === undefined ? undefined : Math.max(0, Math.floor(limit));
     if (boundedLimit === 0) return rows;
-    for await (const row of iterate()) {
+    for await (const { row, sourceIdentity } of iterateOccurrences()) {
       rows.push(row);
+      identities.push(sourceIdentity);
       if (boundedLimit !== undefined && rows.length >= boundedLimit) break;
     }
     return rows;
@@ -722,7 +859,7 @@ function createTransformedPlayDataset<T, U>(
     return total;
   };
 
-  return createDeferredPlayDataset({
+  const dataset = createDeferredPlayDataset({
     datasetKind: source.datasetKind,
     datasetId: transformDatasetId({
       source: source as PlayDataset<unknown>,
@@ -747,6 +884,13 @@ function createTransformedPlayDataset<T, U>(
         }) as AsyncIterable<U>,
     },
   });
+  sourceOccurrencesByDataset.set(
+    dataset,
+    iterateOccurrences as () => AsyncIterable<
+      PlayDatasetSourceOccurrence<unknown>
+    >,
+  );
+  return dataset;
 }
 
 export function createDeferredPlayDataset<T>(input: {
@@ -922,10 +1066,15 @@ export async function* iteratePlayDatasetInputPages<T>(
         : DATASET_UTF8_ENCODER.encode(serialized).byteLength;
     });
   let page: T[] = [];
+  let pageIdentities: (PlayDatasetSourceRowIdentity | undefined)[] = [];
+  sourceRowIdentitiesByRows.set(page, pageIdentities);
   let pageBytes = 0;
   let offset = 0;
   let index = 0;
-  const pushRow = (row: T): Array<{ rows: T[]; offset: number }> => {
+  const pushRow = (
+    row: T,
+    sourceIdentity: PlayDatasetSourceRowIdentity | undefined,
+  ): Array<{ rows: T[]; offset: number }> => {
     options?.onRow?.(row, index);
     index += 1;
     const rowBytes = Math.max(0, Math.ceil(estimateRowBytes(row)));
@@ -934,14 +1083,19 @@ export async function* iteratePlayDatasetInputPages<T>(
       ready.push({ rows: page, offset });
       offset += page.length;
       page = [];
+      pageIdentities = [];
+      sourceRowIdentitiesByRows.set(page, pageIdentities);
       pageBytes = 0;
     }
     page.push(row);
+    pageIdentities.push(sourceIdentity);
     pageBytes += rowBytes;
     if (page.length >= pageSize || pageBytes >= maxPageBytes) {
       ready.push({ rows: page, offset });
       offset += page.length;
       page = [];
+      pageIdentities = [];
+      sourceRowIdentitiesByRows.set(page, pageIdentities);
       pageBytes = 0;
     }
     return ready;
@@ -952,48 +1106,15 @@ export async function* iteratePlayDatasetInputPages<T>(
     const finalPage = page;
     const finalOffset = offset;
     page = [];
+    pageIdentities = [];
+    sourceRowIdentitiesByRows.set(page, pageIdentities);
     pageBytes = 0;
     offset += finalPage.length;
     return { rows: finalPage, offset: finalOffset };
   };
 
-  const emitRow = async function* (row: T) {
-    for (const ready of pushRow(row)) yield ready;
-  };
-
-  if (isPlayDataset(input)) {
-    for await (const row of input) {
-      yield* emitRow(row);
-    }
-    const finalPage = flush();
-    if (finalPage) yield finalPage;
-    return;
-  }
-
-  if (Array.isArray(input)) {
-    for (const row of input) {
-      yield* emitRow(row);
-    }
-    const finalPage = flush();
-    if (finalPage) yield finalPage;
-    return;
-  }
-
-  if (
-    input != null &&
-    typeof input === 'object' &&
-    Symbol.asyncIterator in input
-  ) {
-    for await (const row of input as AsyncIterable<T>) {
-      yield* emitRow(row);
-    }
-    const finalPage = flush();
-    if (finalPage) yield finalPage;
-    return;
-  }
-
-  for (const row of input as Iterable<T>) {
-    yield* emitRow(row);
+  for await (const { row, sourceIdentity } of iterateSourceOccurrences(input)) {
+    for (const ready of pushRow(row, sourceIdentity)) yield ready;
   }
   const finalPage = flush();
   if (finalPage) yield finalPage;
@@ -1003,41 +1124,13 @@ export async function materializePlayDatasetInput<T>(
   input: PlayDatasetInput<T>,
   options?: MaterializePlayDatasetInputOptions<T>,
 ): Promise<T[]> {
-  const pushRow = (rows: T[], row: T): void => {
+  const rows: T[] = [];
+  const identities: (PlayDatasetSourceRowIdentity | undefined)[] = [];
+  sourceRowIdentitiesByRows.set(rows, identities);
+  for await (const { row, sourceIdentity } of iterateSourceOccurrences(input)) {
     options?.onRow?.(row, rows.length);
     rows.push(row);
-  };
-
-  if (isPlayDataset(input)) {
-    const rows: T[] = [];
-    for await (const row of input) {
-      pushRow(rows, row);
-    }
-    return rows;
-  }
-
-  if (Array.isArray(input)) {
-    const rows: T[] = [];
-    for (const row of input) {
-      pushRow(rows, row);
-    }
-    return rows;
-  }
-
-  const rows: T[] = [];
-  if (
-    input != null &&
-    typeof input === 'object' &&
-    Symbol.asyncIterator in input
-  ) {
-    for await (const row of input as AsyncIterable<T>) {
-      pushRow(rows, row);
-    }
-    return rows;
-  }
-
-  for (const row of input as Iterable<T>) {
-    pushRow(rows, row);
+    identities.push(sourceIdentity);
   }
   return rows;
 }

package/dist/bundling-sources/shared_libs/plays/static-pipeline.ts

@@ -98,6 +98,7 @@ export interface StoredStaticPipelineV2Branch {
   index: number;
   label: string;
   condition?: string;
+  inputRequirement?: PlayStaticInputCondition;
 }
 
 function dedupeStaticFieldNames(
@@ -336,7 +337,11 @@ function truncateStaticControlFlowBranchesForStorage(
     omitUndefinedProperties({
       ...(input.preserveAdditiveMetadata
         ? branch
-        : { label: branch.label, condition: branch.condition }),
+        : {
+            label: branch.label,
+            condition: branch.condition,
+            inputRequirement: branch.inputRequirement,
+          }),
       steps: truncateStaticSubstepsForStorage(
         branch.steps,
         nextStoredSubstepInput(input),
@@ -882,6 +887,9 @@ export function createStoredStaticPipelineV2(
                   typeof branchRecord.condition === 'string'
                     ? branchRecord.condition
                     : undefined,
+                inputRequirement: parsePlayStaticInputCondition(
+                  branchRecord.inputRequirement,
+                ),
               }),
             );
             if (Array.isArray(branchRecord.steps)) {
@@ -1043,6 +1051,9 @@ export function hydrateStoredStaticPipelineV2(
         label: branch.label,
         condition:
           typeof branch.condition === 'string' ? branch.condition : undefined,
+        inputRequirement: parsePlayStaticInputCondition(
+          branch.inputRequirement,
+        ),
         steps: [] as PlayStaticSubstep[],
       }),
     );
@@ -1233,10 +1244,14 @@ export interface PlayStaticSourceRange {
 }
 
 type PlayStaticSubstepMetadata = {
+  /** A source helper received execution context but its work could not be resolved. */
+  unresolvedProviderWork?: boolean;
   /** This call is syntactically inside Promise.all/allSettled/race/any. */
   concurrent?: boolean;
   conditional?: boolean;
   disabled?: boolean;
+  /** Source-bound input-only gate; absent means reachability is unknown. */
+  inputRequirement?: PlayStaticInputCondition;
   /**
    * Where this substep was REACHED FROM, when the extractor resolved it by
    * following a call into another function — the range of the call expression
@@ -1267,10 +1282,167 @@ export type PlayStaticControlFlowBranch = {
   label: string;
   /** The arm's condition source text, when it has one (omitted for `else`). */
   condition?: string;
+  inputRequirement?: PlayStaticInputCondition;
   /** Static work in this arm. Empty for log/throw/return-only arms. */
   steps: PlayStaticSubstep[];
 };
 
+/** Declarative subset of input conditions; never evaluates authored JavaScript. */
+export type PlayStaticInputValue =
+  | { kind: 'input'; path: string[] }
+  | { kind: 'literal'; value: string | number | boolean | null };
+export type PlayStaticInputCondition =
+  | { kind: 'truthy'; value: PlayStaticInputValue }
+  | { kind: 'not'; condition: PlayStaticInputCondition }
+  | {
+      kind: 'and' | 'or';
+      left: PlayStaticInputCondition;
+      right: PlayStaticInputCondition;
+    }
+  | { kind: 'equals'; left: PlayStaticInputValue; right: PlayStaticInputValue }
+  | {
+      kind: 'includes';
+      value: PlayStaticInputValue;
+      item: PlayStaticInputValue;
+    };
+
+function parsePlayStaticInputCondition(
+  value: unknown,
+): PlayStaticInputCondition | undefined {
+  if (value === undefined) return undefined;
+  const active = new WeakSet<object>();
+  const operand = (value: unknown): PlayStaticInputValue => {
+    const record = asStaticRecord(value);
+    if (
+      record?.kind === 'input' &&
+      Array.isArray(record.path) &&
+      record.path.every((key) => typeof key === 'string')
+    )
+      return { ...record, kind: 'input', path: record.path };
+    if (record?.kind === 'literal') {
+      const literal = record.value;
+      if (literal === null) return { ...record, kind: 'literal', value: null };
+      if (
+        typeof literal === 'string' ||
+        typeof literal === 'boolean' ||
+        (typeof literal === 'number' && Number.isFinite(literal))
+      )
+        return { ...record, kind: 'literal', value: literal };
+    }
+    return invalidStoredStaticPipelineV2('invalid input requirement value');
+  };
+  const condition = (value: unknown): PlayStaticInputCondition => {
+    const record = asStaticRecord(value);
+    if (!record || active.has(record))
+      return invalidStoredStaticPipelineV2(
+        'invalid input requirement condition',
+      );
+    active.add(record);
+    try {
+      switch (record.kind) {
+        case 'truthy':
+          return { ...record, kind: 'truthy', value: operand(record.value) };
+        case 'not':
+          return {
+            ...record,
+            kind: 'not',
+            condition: condition(record.condition),
+          };
+        case 'and':
+        case 'or':
+          return {
+            ...record,
+            kind: record.kind,
+            left: condition(record.left),
+            right: condition(record.right),
+          };
+        case 'equals':
+          return {
+            ...record,
+            kind: 'equals',
+            left: operand(record.left),
+            right: operand(record.right),
+          };
+        case 'includes':
+          return {
+            ...record,
+            kind: 'includes',
+            value: operand(record.value),
+            item: operand(record.item),
+          };
+        default:
+          return invalidStoredStaticPipelineV2(
+            'invalid input requirement condition',
+          );
+      }
+    } finally {
+      active.delete(record);
+    }
+  };
+  return condition(value);
+}
+
+export function evaluatePlayStaticInputCondition(
+  condition: PlayStaticInputCondition,
+  input: Record<string, unknown>,
+): boolean | null {
+  const read = (value: PlayStaticInputValue): unknown => {
+    if (value.kind === 'literal') return value.value;
+    let current: unknown = input;
+    for (const key of value.path) {
+      if (
+        !current ||
+        typeof current !== 'object' ||
+        !Object.hasOwn(current, key)
+      )
+        return undefined;
+      current = (current as Record<string, unknown>)[key];
+    }
+    return current;
+  };
+  const evaluate = (value: PlayStaticInputCondition): boolean | null => {
+    switch (value.kind) {
+      case 'truthy':
+        return Boolean(read(value.value));
+      case 'not': {
+        const result = evaluate(value.condition);
+        return result === null ? null : !result;
+      }
+      case 'equals':
+        return read(value.left) === read(value.right);
+      case 'includes': {
+        const collection = read(value.value);
+        const item = read(value.item);
+        if (Array.isArray(collection)) return collection.includes(item);
+        if (typeof collection === 'string' && typeof item === 'string')
+          return collection.includes(item);
+        return null;
+      }
+      case 'and': {
+        const left = evaluate(value.left);
+        const right = evaluate(value.right);
+        return left === false || right === false
+          ? false
+          : left === true && right === true
+            ? true
+            : null;
+      }
+      case 'or': {
+        const left = evaluate(value.left);
+        const right = evaluate(value.right);
+        return left === true || right === true
+          ? true
+          : left === false && right === false
+            ? false
+            : null;
+      }
+      default:
+        return null;
+    }
+  };
+  return evaluate(condition);
+}
+
 export type PlayStaticSubstep = PlayStaticSubstepMetadata &
   (
     | {

package/dist/bundling-sources/shared_libs/plays/tool-result-types.ts

@@ -40,6 +40,24 @@ export type ToolResultExecutionMetadata = {
   /** Canonical saved result identity; receiptKey may name a transport alias. */
   resultReceiptKey?: string;
   attachedToReceiptKey?: string;
+  /** Freshness and operation recovery are independent of provider idempotency. */
+  freshness?: CallFreshnessMetadata;
+  /** Time the live result completed, retained unchanged through recovery. */
+  completedAt?: number;
+};
+
+export type CallFreshnessMetadata = {
+  requestedStaleAfterSeconds: number | null;
+  effectiveStaleAfterSeconds: number | null;
+  source:
+    | 'executed'
+    | 'operation_recovery'
+    | 'reusable_result'
+    | 'live_observation';
+  resultAgeMs: number;
+  completedAt: number;
+  operationReceiptKey?: string;
+  unavailableReason?: string;
 };
 
 export type ToolResultTargetMetadata = {

package/dist/cli/auth-IHKISLJQ.js

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk354JCXA2js = require('./chunk-354JCXA2.js');
+require('./chunk-KGNTKMRG.js');
+require('./chunk-CS6RAIVY.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-6YAUMG27.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunk354JCXA2js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunk354JCXA2js.authStatusLine; exports.clearPendingClaim = _chunk354JCXA2js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunk354JCXA2js.clearSatisfiedPendingClaim; exports.handleRegister = _chunk354JCXA2js.handleRegister; exports.handleStatus = _chunk354JCXA2js.handleStatus; exports.handleWait = _chunk354JCXA2js.handleWait; exports.httpJson = _chunk354JCXA2js.httpJson; exports.readPendingAuthClaim = _chunk354JCXA2js.readPendingAuthClaim; exports.readStatusBanner = _chunk354JCXA2js.readStatusBanner; exports.registerAuthCommands = _chunk354JCXA2js.registerAuthCommands; exports.reportSetupCompleted = _chunk354JCXA2js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunk354JCXA2js.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunk354JCXA2js.statusBannerLine;

package/dist/cli/{auth-6JSA2ZCW.mjs → auth-OSXDAVCF.mjs}

@@ -13,12 +13,12 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-R3O2CZ4H.mjs";
-import "./chunk-2G7DXFHI.mjs";
-import "./chunk-2GAHHSLB.mjs";
+} from "./chunk-MFB2VKBO.mjs";
+import "./chunk-NR3DFKNF.mjs";
+import "./chunk-FJGW5GXU.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-NXGCO4JB.mjs";
-import "./chunk-YAZCDBXX.mjs";
+import "./chunk-TJI2EN6K.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {