deepline 0.3.324 → 0.3.326

package/dist/bundling-sources/sdk/src/plays/local-play-execution.ts

@@ -0,0 +1,189 @@
+import type { DeeplineClient } from '../client.js';
+import type { BundledPlayFileSuccess } from './bundle-play-file.js';
+
+export type LocalPlayGraph = {
+  root: BundledPlayFileSuccess;
+  nodes: Map<string, BundledPlayFileSuccess>;
+};
+
+function importedNodes(graph: LocalPlayGraph): BundledPlayFileSuccess[] {
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const ordered: BundledPlayFileSuccess[] = [];
+  const names = new Map<string, string>();
+  const visit = (node: BundledPlayFileSuccess) => {
+    if (visiting.has(node.filePath))
+      throw new Error(`Recursive imported Play graph at ${node.filePath}.`);
+    if (visited.has(node.filePath)) return;
+    visiting.add(node.filePath);
+    for (const dependency of node.importedPlayDependencies) {
+      const child = graph.nodes.get(dependency.filePath);
+      if (!child)
+        throw new Error(
+          `Missing bundled Play dependency ${dependency.filePath}.`,
+        );
+      visit(child);
+    }
+    visiting.delete(node.filePath);
+    visited.add(node.filePath);
+    if (node === graph.root) return;
+    if (!node.playName)
+      throw new Error(
+        `Imported Play ${node.filePath} must export definePlay(...).`,
+      );
+    const existing = names.get(node.playName);
+    if (existing !== undefined && existing !== node.filePath)
+      throw new Error(
+        `Imported Play name ${node.playName} belongs to more than one source file.`,
+      );
+    names.set(node.playName, node.filePath);
+    ordered.push(node);
+  };
+  visit(graph.root);
+  return ordered;
+}
+
+/** Describe local execution without storing artifacts or starting cloud work. */
+export function planLocalPlayExecution(
+  graph: LocalPlayGraph,
+  input: { runIdFile?: string | null } = {},
+) {
+  const imports = importedNodes(graph).map((node) => ({
+    name: node.playName!,
+    artifactHash: node.artifact.artifactHash,
+    graphHash: node.artifact.graphHash,
+  }));
+  return {
+    command: 'plays run',
+    root: {
+      name: graph.root.playName,
+      artifactHash: graph.root.artifact.artifactHash,
+      publication: 'unpublished' as const,
+    },
+    importedPlays: imports.map((node) => ({
+      ...node,
+      publication: 'pinned' as const,
+    })),
+    effects: {
+      cloudMutations: imports.length
+        ? [
+            'store_imported_execution_artifacts',
+            'stage_files_if_present',
+            'register_unpublished_root_revision',
+            'start_run',
+          ]
+        : [
+            'stage_files_if_present',
+            'register_unpublished_root_revision',
+            'start_run',
+          ],
+      localWrites: input.runIdFile
+        ? ['bundle_cache', 'run_identity_file']
+        : ['bundle_cache'],
+      creditSpending: 'tool_calls_may_spend' as const,
+      recovery: 'inspect_or_resume_original_run_id' as const,
+    },
+  };
+}
+
+/** Store immutable imported execution content without changing draft or live revisions. */
+export async function pinLocalPlayImports(
+  client: Pick<DeeplineClient, 'registerPlayArtifact'>,
+  graph: LocalPlayGraph,
+): Promise<LocalPlayGraph> {
+  const imports = importedNodes(graph);
+  if (imports.length === 0) return graph;
+  // Validate the entire graph before the first storage request.
+  for (const node of [...imports, graph.root]) {
+    if (!node.compilerManifest)
+      throw new Error(`Missing compiler manifest for ${node.filePath}.`);
+  }
+  const nodes = new Map(graph.nodes);
+  const stored = new Map<
+    string,
+    NonNullable<
+      BundledPlayFileSuccess['artifact']['importedPlayArtifacts']
+    >[string]
+  >();
+  const withPins = (node: BundledPlayFileSuccess): BundledPlayFileSuccess => {
+    const closure = new Map<
+      string,
+      NonNullable<
+        BundledPlayFileSuccess['artifact']['importedPlayArtifacts']
+      >[string]
+    >();
+    for (const dependency of node.importedPlayDependencies) {
+      const child = nodes.get(dependency.filePath)!;
+      const pointer = stored.get(dependency.filePath);
+      if (!pointer)
+        throw new Error(`Imported Play ${dependency.filePath} was not stored.`);
+      for (const [name, pin] of Object.entries(
+        child.artifact.importedPlayArtifacts ?? {},
+      ))
+        closure.set(name, pin);
+      closure.set(child.playName!, pointer);
+    }
+    return {
+      ...node,
+      artifact: {
+        ...node.artifact,
+        ...(closure.size
+          ? { importedPlayArtifacts: Object.fromEntries(closure) }
+          : {}),
+      },
+    };
+  };
+  // Children are stored before parents so every pointer refers to immutable content.
+  for (const original of imports) {
+    const node = withPins(original);
+    const result = await client.registerPlayArtifact({
+      name: node.playName!,
+      sourceCode: node.sourceCode,
+      sourceFiles: node.sourceFiles,
+      description: node.playDescription ?? undefined,
+      artifact: node.artifact,
+      compilerManifest: node.compilerManifest!,
+      publish: false,
+      artifactOnly: true,
+    });
+    if (
+      typeof result.artifactStorageKey !== 'string' ||
+      !result.artifactStorageKey.trim()
+    )
+      throw new Error(
+        `No immutable artifact identity was returned for ${node.playName}.`,
+      );
+    stored.set(node.filePath, {
+      artifactStorageKey: result.artifactStorageKey,
+      artifactHash: node.artifact.artifactHash,
+      graphHash: node.artifact.graphHash,
+    });
+    nodes.set(node.filePath, node);
+  }
+  const root = withPins(graph.root);
+  nodes.set(root.filePath, root);
+  return { root, nodes };
+}
+
+/** Publish exactly the reviewed import graph; the root is submitted as an unpublished run. */
+export async function publishLocalPlayImports(
+  client: Pick<DeeplineClient, 'registerPlayArtifact'>,
+  graph: LocalPlayGraph,
+): Promise<void> {
+  const nodes = importedNodes(graph);
+  for (const node of nodes) {
+    if (!node.compilerManifest)
+      throw new Error(`Missing compiler manifest for ${node.filePath}.`);
+  }
+  for (const node of nodes) {
+    await client.registerPlayArtifact({
+      name: node.playName!,
+      sourceCode: node.sourceCode,
+      sourceFiles: node.sourceFiles,
+      description: node.playDescription ?? undefined,
+      artifact: node.artifact,
+      compilerManifest: node.compilerManifest!,
+      publish: true,
+    });
+  }
+}

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

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.324',
+  version: '0.3.326',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/sdk/src/tool-calls.ts

@@ -26,7 +26,7 @@ const EXECUTE_RESPONSE_INTENT_HEADER = 'x-deepline-execute-response-intent';
 const RAW_V2_EXECUTE_RESPONSE_CONTRACT = RAW_V2_TOOL_RESPONSE_CONTRACT;
 const DEFAULT_EXECUTION_RECOVERY_TIMEOUT_MS = 15 * 60 * 1_000;
 
-function validateExecutionIdempotencyKey(key: string): void {
+export function validateExecutionIdempotencyKey(key: string): void {
   if (
     typeof key !== 'string' ||
     key.length < 1 ||

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

@@ -124,6 +124,12 @@ export interface CustomerDbColumn {
  * query and selected customer tables.
  */
 export interface CustomerDbQueryResult {
+  /** Present for explicitly keyed SQL; recovery keeps the original completion time. */
+  operation?: {
+    operation_key: string;
+    completed_at_ms: number;
+    source: 'executed' | 'operation_recovery';
+  };
   /** This query reads the current mutable customer database, not one run snapshot. */
   scope?: { kind: 'database'; mutability: 'current' };
   /** Database command executed by the query endpoint. */

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

@@ -241,6 +241,7 @@ type RuntimeApiRequest =
     }
   | {
       action: 'launch_play_async';
+      resolveImportedArtifact?: boolean;
       key: string;
       invocationKey: string;
       playRef: string;
@@ -2725,6 +2726,7 @@ export async function recordFirstClaimLatencyViaAppRuntime(
 export async function launchPlayAsyncViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: {
+    resolveImportedArtifact?: boolean;
     key: string;
     invocationKey: string;
     playRef: string;

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

@@ -2139,6 +2139,11 @@ async function run(
   const runtimeInput = config.input ?? {};
   const runtimeInputObject: Record<string, unknown> =
     playRunInputObjectView(runtimeInput);
+  const importedArtifactOptions = (playRef: string) =>
+    config.artifact.importedPlayArtifacts &&
+    Object.hasOwn(config.artifact.importedPlayArtifacts, playRef)
+      ? { resolveImportedArtifact: true as const }
+      : {};
   const resolveChildPlay =
     createRunScopedChildPlayResolver<ResolvedPlayExecution>({
       resolvePlay: async (playRef) => {
@@ -2157,6 +2162,7 @@ async function run(
               userEmail: config.context.userEmail,
             },
             playRef,
+            importedArtifactOptions(playRef),
           );
           if (resolved?.resolutionDiagnostics) {
             emitWorkerLog(
@@ -2284,7 +2290,7 @@ async function run(
           ...appRuntimeApiContext,
           requestTimeoutMs: RUNNER_RUNTIME_CONTROL_REQUEST_TIMEOUT_MS,
         },
-        request,
+        { ...request, ...importedArtifactOptions(request.playRef) },
       ),
     onBatchComplete: (checkpoint) => {
       emitRunnerEvent(

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

@@ -275,6 +275,7 @@ export type RuntimeReceiptFailure = RuntimeReceiptLease & {
 export type RuntimePlayResolutionAction = {
   action: 'resolve_play';
   playRef: string;
+  resolveImportedArtifact?: boolean;
 };
 
 export type RuntimeResultsAction = {

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

@@ -540,6 +540,7 @@ type RuntimeApiActionRequest =
   | {
       action: 'resolve_play';
       playRef: string;
+      resolveImportedArtifact?: boolean;
       acceptRetainedPipelineGraph?: boolean;
     }
   | {
@@ -3675,6 +3676,7 @@ async function writeRuntimeRowsWithProvisioningRetry(
 export async function resolveRuntimeReferencedPlay(
   context: RuntimeApiContext,
   playRef: string,
+  options?: { resolveImportedArtifact?: boolean },
 ): Promise<ResolvedRuntimePlay | null> {
   const wire = await postRuntimeApi<{
     play: ResolvedRuntimePlay | null;
@@ -3682,6 +3684,9 @@ export async function resolveRuntimeReferencedPlay(
   }>(context, {
     action: 'resolve_play',
     playRef,
+    ...(options?.resolveImportedArtifact === true
+      ? { resolveImportedArtifact: true }
+      : {}),
     acceptRetainedPipelineGraph: true,
   });
   const response = {

package/dist/bundling-sources/shared_libs/play-runtime/tool-result.ts

@@ -614,13 +614,79 @@ function normalizeRelativePath(path: string): string {
     .replace(/^\./, '');
 }
 
+/**
+ * Keys that carry the dialable number inside a provider's phone object, in
+ * preference order (Apollo `sanitized_number`, Wiza/Lusha/Forager `number`,
+ * Enformion `phoneNumber`, Datagma `display_international`, ...).
+ */
+const PHONE_OBJECT_VALUE_KEYS = [
+  'sanitized_number',
+  'number',
+  'phone',
+  'phone_number',
+  'phoneNumber',
+  'display_international',
+  'displayInternational',
+  'international',
+  'value',
+  'raw_number',
+  'raw',
+  'sanitized',
+] as const;
+
+/** Shortest real national number; anything shorter is a flag or a mask. */
+const PHONE_TARGET_MIN_DIGITS = 7;
+
+/**
+ * The `phone` getter is typed as one string. Providers put the number inside
+ * objects (`{ number, type }`) and arrays, and put availability flags under
+ * the same keys (`mobile_phone: true`, `has_direct_phone: "Yes"`, masked
+ * `"120******"`). Resolve to the first dialable string, or null when the
+ * value carries no phone number at all.
+ */
+function phoneTargetValue(value: unknown): string | null {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return phoneTargetValue(String(value));
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    const digits = trimmed.replace(/\D/g, '').length;
+    return digits >= PHONE_TARGET_MIN_DIGITS ? trimmed : null;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const phone = phoneTargetValue(entry);
+      if (phone) return phone;
+    }
+    return null;
+  }
+  if (isRecord(value)) {
+    for (const key of PHONE_OBJECT_VALUE_KEYS) {
+      const phone = phoneTargetValue(value[key]);
+      if (phone) return phone;
+    }
+  }
+  return null;
+}
+
+/** The value a target accepts from a candidate, or undefined to keep looking. */
+function acceptedTargetValue(
+  target: string | undefined,
+  value: unknown,
+): unknown {
+  if (target === 'phone') return phoneTargetValue(value) ?? undefined;
+  return isMeaningfulValue(value) ? value : undefined;
+}
+
 function getFirstMeaningfulValueAtPath(
   root: unknown,
   path: string,
+  target?: string,
 ): ToolResultTargetMetadata | null {
   for (const entry of valuesAtSegments(root, parsePath(path))) {
-    if (isMeaningfulValue(entry.value)) {
-      return { value: entry.value, path: entry.path };
+    const value = acceptedTargetValue(target, entry.value);
+    if (value !== undefined) {
+      return { value, path: entry.path };
     }
   }
   return null;
@@ -663,10 +729,11 @@ function normalizeRows(value: unknown): Record<string, unknown>[] | null {
 function findFirstTargetByPath(
   result: unknown,
   paths: readonly string[] | undefined,
+  target?: string,
 ): ToolResultTargetMetadata | null {
   for (const path of paths ?? []) {
     for (const candidate of candidateResultPaths(path)) {
-      const match = getFirstMeaningfulValueAtPath(result, candidate);
+      const match = getFirstMeaningfulValueAtPath(result, candidate, target);
       if (match) return match;
     }
   }
@@ -756,11 +823,10 @@ function findFirstTargetByKey(
   };
   for (const [key, value] of Object.entries(result)) {
     if (rule.reject?.some((pattern) => pattern.test(key))) continue;
-    if (
-      rule.match.some((pattern) => pattern.test(key)) &&
-      isMeaningfulValue(value)
-    ) {
-      return { value, path: pathToString([...path, key]) };
+    if (!rule.match.some((pattern) => pattern.test(key))) continue;
+    const accepted = acceptedTargetValue(target, value);
+    if (accepted !== undefined) {
+      return { value: accepted, path: pathToString([...path, key]) };
     }
   }
   for (const [key, value] of Object.entries(result)) {
@@ -1038,7 +1104,11 @@ function buildTargets(
       targets[target] = emailStatusTarget;
       continue;
     }
-    const fromExtractor = findFirstTargetByPath(result, descriptor.paths);
+    const fromExtractor = findFirstTargetByPath(
+      result,
+      descriptor.paths,
+      target,
+    );
     if (!fromExtractor) {
       // A declared null is an explicit provider answer, not permission to
       // guess from a similarly named sibling such as `emailDomain`.
@@ -1065,7 +1135,11 @@ function buildTargets(
       target,
       targetGetters?.[target] ?? declaredTargetPaths.get(target) ?? [],
     );
-    const fromMetadata = findFirstTargetByPath(result, targetGetters?.[target]);
+    const fromMetadata = findFirstTargetByPath(
+      result,
+      targetGetters?.[target],
+      target,
+    );
     if (fromMetadata) {
       targets[target] = fromMetadata;
       continue;

package/dist/bundling-sources/shared_libs/plays/artifact-types.ts

@@ -62,6 +62,15 @@ export type PlayBundleArtifact = {
   sourceMap: string;
   importPolicy: PlayImportPolicy;
   compatibility: PlayArtifactCompatibility;
+  /** Immutable imported execution closure; absent artifacts retain named live resolution. */
+  importedPlayArtifacts?: Record<
+    string,
+    {
+      artifactStorageKey: string;
+      artifactHash: string;
+      graphHash: string;
+    }
+  >;
   generatedAt: number;
   cacheHit: boolean;
 };

package/dist/cli/auth-6STWK6UK.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkMKHSZA2Xjs = require('./chunk-MKHSZA2X.js');
+require('./chunk-CUUHQ3AO.js');
+require('./chunk-TXVOB5J2.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-BUYZEUY4.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkMKHSZA2Xjs.EXIT_WORKSPACE_MISMATCH; exports.clearPendingClaim = _chunkMKHSZA2Xjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkMKHSZA2Xjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkMKHSZA2Xjs.handleRegister; exports.handleStatus = _chunkMKHSZA2Xjs.handleStatus; exports.handleWait = _chunkMKHSZA2Xjs.handleWait; exports.readPendingAuthClaim = _chunkMKHSZA2Xjs.readPendingAuthClaim; exports.registerAuthCommands = _chunkMKHSZA2Xjs.registerAuthCommands; exports.reportSetupCompleted = _chunkMKHSZA2Xjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkMKHSZA2Xjs.resolvePendingAuthClaimForResume;

package/dist/cli/{auth-6KWNR6AI.mjs → auth-VON5FFUK.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-5QZFWY7C.mjs";
-import "./chunk-I7RLL7LN.mjs";
-import "./chunk-TJGJTB5T.mjs";
+} from "./chunk-ZRN6YOF2.mjs";
+import "./chunk-M7CPVMDB.mjs";
+import "./chunk-BR7GGTAE.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-HHZDWBSQ.mjs";
+import "./chunk-BQJVMKWL.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/{billing-VQ2NUJLB.mjs → billing-X6JUEFRE.mjs}

@@ -1,7 +1,7 @@
 import {
   DeeplineClient,
   iterateCursorPages
-} from "./chunk-3ZKAKQYC.mjs";
+} from "./chunk-KLWBAQ5A.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
   createTimestampedName,
@@ -9,13 +9,13 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-I7RLL7LN.mjs";
+} from "./chunk-M7CPVMDB.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-TJGJTB5T.mjs";
+} from "./chunk-BR7GGTAE.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-HHZDWBSQ.mjs";
+import "./chunk-BQJVMKWL.mjs";
 import "./chunk-6IKARAYD.mjs";
 import {
   DeeplineError