deepline 0.1.10 → 0.1.12

package/dist/repo/shared_libs/plays/bundling/index.ts

@@ -99,6 +99,15 @@ export type PlayBundlingAdapter = {
   warnAboutNonDevelopmentBundling?(filePath: string): void;
 };
 
+function assertValidExportName(exportName: string): void {
+  if (exportName === 'default') return;
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
+    throw new Error(
+      `Invalid play export name "${exportName}". Named prebuilt exports must be valid JavaScript identifiers.`,
+    );
+  }
+}
+
 export type BundledPlayFileSuccess = {
   success: true;
   artifact: PlayBundleArtifact;
@@ -409,6 +418,32 @@ function workersPlayEntryAliasPlugin(playFilePath: string): Plugin {
   };
 }
 
+function workersNamedPlayEntryAliasPlugin(
+  playFilePath: string,
+  exportName: string,
+): Plugin {
+  return {
+    name: 'deepline-workers-named-play-entry-alias',
+    setup(buildContext) {
+      buildContext.onResolve(
+        { filter: new RegExp(`^${WORKERS_PLAY_ENTRY_VIRTUAL}$`) },
+        () => ({
+          path: `${playFilePath}.${exportName}.entry.ts`,
+          namespace: 'deepline-named-play-entry',
+        }),
+      );
+      buildContext.onLoad(
+        { filter: /.*/, namespace: 'deepline-named-play-entry' },
+        () => ({
+          contents: `export { ${exportName} as default } from ${JSON.stringify(playFilePath)};\n`,
+          loader: 'ts',
+          resolveDir: dirname(playFilePath),
+        }),
+      );
+    },
+  };
+}
+
 /**
  * Cloudflare Workers' `nodejs_compat` flag covers most node builtins (path,
  * crypto, buffer, async_hooks, ...) but NOT `node:fs` / `node:fs/promises` /
@@ -1068,6 +1103,7 @@ export type BundlePlayFileOptions = {
    * kind is cached independently on disk.
    */
   target?: PlayArtifactKind;
+  exportName?: string;
 };
 
 export type BundlePlayFileCoreOptions = BundlePlayFileOptions & {
@@ -1084,11 +1120,25 @@ async function runEsbuildForCjsNode(
   entryFile: string,
   importedPlayDependencies: ImportedPlayDependency[],
   adapter: PlayBundlingAdapter,
+  exportName: string,
 ): Promise<EsbuildBundleOutput | string[]> {
   const sdkAliasPlugin = localSdkAliasPlugin(adapter);
   const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
+  const namedExportShim =
+    exportName === 'default'
+      ? null
+      : `export { ${exportName} as default } from ${JSON.stringify(entryFile)};\n`;
   const result = await build({
-    entryPoints: [entryFile],
+    ...(namedExportShim
+      ? {
+          stdin: {
+            contents: namedExportShim,
+            resolveDir: dirname(entryFile),
+            sourcefile: `${basename(entryFile)}.${exportName}.entry.ts`,
+            loader: 'ts' as const,
+          },
+        }
+      : { entryPoints: [entryFile] }),
     absWorkingDir: adapter.projectRoot,
     bundle: true,
     format: 'cjs',
@@ -1121,10 +1171,14 @@ async function runEsbuildForEsmWorkers(
   playEntryFile: string,
   importedPlayDependencies: ImportedPlayDependency[],
   adapter: PlayBundlingAdapter,
+  exportName: string,
 ): Promise<EsbuildBundleOutput | string[]> {
   const sdkAliasPlugin = localSdkAliasPlugin(adapter, { workersRuntime: true });
   const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
-  const playEntryAlias = workersPlayEntryAliasPlugin(playEntryFile);
+  const playEntryAlias =
+    exportName === 'default'
+      ? workersPlayEntryAliasPlugin(playEntryFile)
+      : workersNamedPlayEntryAliasPlugin(playEntryFile, exportName);
   const result = await build({
     // Entry is the Workers harness; it imports the play via the virtual
     // `deepline-play-entry` alias resolved by workersPlayEntryAliasPlugin.
@@ -1199,11 +1253,16 @@ export async function bundlePlayFile(
 ): Promise<BundledPlayFileResult> {
   const adapter = options.adapter;
   const target: PlayArtifactKind = options.target ?? PLAY_ARTIFACT_KINDS.cjsNode20;
+  const exportName = options.exportName?.trim() || 'default';
+  assertValidExportName(exportName);
   const absolutePath = await normalizeLocalPath(filePath);
   adapter.warnAboutNonDevelopmentBundling?.(absolutePath);
 
   try {
     const analysis = await analyzeSourceGraph(absolutePath, adapter);
+    analysis.graphHash = sha256(
+      `${analysis.graphHash}\nentry-export:${exportName}`,
+    );
     // For esm_workers builds, the harness source files (entry.ts +
     // peer DO/coordinator types it imports) are bundled INTO every play
     // artifact. So any harness edit must produce a different graphHash so
@@ -1275,8 +1334,8 @@ export async function bundlePlayFile(
     }
     const buildOutcome =
       target === PLAY_ARTIFACT_KINDS.esmWorkers
-        ? await runEsbuildForEsmWorkers(absolutePath, analysis.importedPlayDependencies, adapter)
-        : await runEsbuildForCjsNode(absolutePath, analysis.importedPlayDependencies, adapter);
+        ? await runEsbuildForEsmWorkers(absolutePath, analysis.importedPlayDependencies, adapter, exportName)
+        : await runEsbuildForCjsNode(absolutePath, analysis.importedPlayDependencies, adapter, exportName);
     if (Array.isArray(buildOutcome)) {
       return {
         success: false,
@@ -1287,7 +1346,11 @@ export async function bundlePlayFile(
     const { bundledCode, sourceMapText, outputExtension } = buildOutcome;
 
     const normalizedSourceMap = normalizeSourceMapForRuntime(sourceMapText);
-    const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${basename(absolutePath).replace(/\.[^.]+$/, '')}.${outputExtension}`;
+    const virtualBaseName =
+      exportName === 'default'
+        ? basename(absolutePath).replace(/\.[^.]+$/, '')
+        : `${basename(absolutePath).replace(/\.[^.]+$/, '')}.${exportName}`;
+    const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
     const executableCode = `${bundledCode}\n//# sourceMappingURL=${basename(virtualFilename)}.map\n`;
     const bundleSizeError = getBundleSizeError(
       absolutePath,

package/dist/repo/shared_libs/plays/compiler-manifest.ts

@@ -179,7 +179,7 @@ export type PlayRuntimeManifest = {
   compiledAt: number;
   compilerVersion: string;
   sourceCode?: string | null;
-  dynamicWorkerCode?: string | null;
+  bundledCode?: string | null;
   maxCreditsPerRun?: number | null;
 };
 

package/dist/repo/shared_libs/plays/dataset.ts

@@ -255,7 +255,7 @@ export function createPlayDataset<T>(
       metadata?.datasetId ??
       `${metadata?.kind ?? 'map'}:${metadata?.tableNamespace ?? metadata?.sourceLabel ?? 'inline'}`,
     count: materializedRows.length,
-    previewRows: materializedRows.slice(0, 10),
+    previewRows: materializedRows.slice(0, 5),
     sourceLabel: metadata?.sourceLabel ?? null,
     tableNamespace: metadata?.tableNamespace ?? null,
     resolvers: {

package/dist/repo/shared_libs/plays/runtime-validation.ts

@@ -233,14 +233,14 @@ function extractValidatedMapTableNamespace(
   const rowsArgument = node.arguments[1];
   if (!keyArgument) {
     errors.push(
-      'ctx.map() requires a string literal map key as the first argument, e.g. ctx.map("leads", rows, { key: "lead_id" }).step("company", row => row.domain).run(...).',
+      'ctx.map() requires a string literal map key as the first argument, e.g. ctx.map("leads", rows).step("company", row => row.domain).run({ key: "lead_id" }).',
     );
     return null;
   }
 
   if (!rowsArgument) {
     errors.push(
-      'ctx.map() requires rows as the second argument, e.g. ctx.map("leads", rows, { key: "lead_id" }).step("company", row => row.domain).run(...).',
+      'ctx.map() requires rows as the second argument, e.g. ctx.map("leads", rows).step("company", row => row.domain).run({ key: "lead_id" }).',
     );
     return null;
   }
@@ -264,7 +264,7 @@ function extractValidatedMapTableNamespace(
   } catch (error) {
     errors.push(
       error instanceof Error
-        ? `${error.message} Example: ctx.map("leads", rows, { key: "lead_id" }).step("company", row => row.domain).run({ description: "..." }).`
+        ? `${error.message} Example: ctx.map("leads", rows).step("company", row => row.domain).run({ key: "lead_id", description: "..." }).`
         : `ctx.map() key must normalize to <= ${MAP_KEY_NAMESPACE_MAX_LENGTH} characters.`,
     );
     return null;
@@ -272,7 +272,7 @@ function extractValidatedMapTableNamespace(
 
   if (rowsArgument.type === 'ObjectExpression') {
     errors.push(
-      'ctx.map() key must not be an object. Use ctx.map("leads", rows, { key: "lead_id" }).step(...).run(...).',
+      'ctx.map() key must not be an object. Use ctx.map("leads", rows).step(...).run({ key: "lead_id" }).',
     );
     return null;
   }
@@ -285,36 +285,16 @@ function extractValidatedMapTableNamespace(
   }
 
   const optionsArgument = node.arguments[2];
-  if (optionsArgument && !isMapDefinitionOptionsNode(optionsArgument)) {
-    errors.push('ctx.map() accepts key, rows, and map options only.');
+  if (optionsArgument) {
+    errors.push(
+      'ctx.map() accepts only a map key and rows. Add steps with .step(...) and pass row identity options to .run({ key: "lead_id" }).',
+    );
     return null;
   }
 
   return keyArgument.value.trim();
 }
 
-function isMapDefinitionOptionsNode(node: acorn.Node): boolean {
-  if (node.type !== 'ObjectExpression') return false;
-  const properties = (
-    node as acorn.Node & {
-      properties: acorn.Node[];
-    }
-  ).properties;
-  return properties.every((property) => {
-    if (property.type !== 'Property') return false;
-    const key = (property as acorn.Node & { key: acorn.Node }).key as
-      | (acorn.Node & { type: 'Identifier'; name: string })
-      | (acorn.Node & { type: 'Literal'; value: unknown });
-    const name =
-      key.type === 'Identifier'
-        ? key.name
-        : key.type === 'Literal' && typeof key.value === 'string'
-          ? key.value
-          : null;
-    return name === 'key' || name === 'staleAfterSeconds';
-  });
-}
-
 function isCtxMapCall(node: acorn.Node): node is acorn.CallExpression {
   if (node.type !== 'CallExpression') {
     return false;

package/package.json

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

package/dist/repo/apps/play-runner-workers/src/runtime/tool-result.ts

@@ -1,184 +0,0 @@
-/**
- * Per-play Worker tool result wrapper.
- *
- * User play code expects ergonomic getters like `result.getEmail()`. Keep this
- * local and dependency-free so those getters do not pull the shared runtime
- * module graph into every dynamic Worker.
- */
-
-export type ToolResultMetadataInput = {
-  toolId: string;
-  resultIdentityGetters?: Record<string, readonly string[]>;
-  listExtractorPaths?: readonly string[];
-  listIdentityGetters?: Record<string, readonly string[]>;
-};
-
-type ToolResultExecutionMetadata = {
-  idempotent: true;
-  cached: boolean;
-  source: 'live' | 'checkpoint' | 'cache';
-  cacheKey?: string;
-};
-
-export type ToolExecuteResult<TResult = unknown> = {
-  status: string;
-  result: TResult;
-  _metadata: {
-    toolId: string;
-    execution: ToolResultExecutionMetadata;
-    targets: Record<string, { value: unknown; path: string }>;
-    lists: Record<string, { path: string; count: number | null; keys: Record<string, string> }>;
-  };
-  get<T = unknown>(target: string): T | null;
-  getEmail(): string | null;
-  getPhone(): string | null;
-  getLinkedin(): string | null;
-  list<T = Record<string, unknown>>(name?: string): T[] | null;
-  listPick<const TKeys extends readonly string[]>(
-    keys: TKeys,
-    name?: string,
-  ): Array<Record<TKeys[number], unknown>> | null;
-  listKeys(name?: string): Record<string, string>;
-};
-
-type PathSegment = string | number;
-
-export function createToolExecuteResult<TResult = unknown>(input: {
-  status: string;
-  result: TResult;
-  metadata: ToolResultMetadataInput;
-  execution: ToolResultExecutionMetadata;
-}): ToolExecuteResult<TResult> {
-  const targets: ToolExecuteResult<TResult>['_metadata']['targets'] = {};
-  for (const [target, paths] of Object.entries(
-    input.metadata.resultIdentityGetters ?? {},
-  )) {
-    const path = paths
-      .map((rawPath) => String(rawPath || '').trim().replace(/^result\./, ''))
-      .find((candidate) => candidate && getAtPath(input.result, candidate) != null);
-    if (path) {
-      targets[target] = { value: getAtPath(input.result, path), path };
-    }
-  }
-  if (Object.keys(targets).length === 0 && isRecordLike(input.result)) {
-    for (const target of ['email', 'phone', 'linkedin', 'domain', 'status']) {
-      if (target in input.result && input.result[target] != null) {
-        targets[target] = { value: input.result[target], path: target };
-      }
-    }
-  }
-
-  const lists: ToolExecuteResult<TResult>['_metadata']['lists'] = {};
-  for (const rawPath of input.metadata.listExtractorPaths ?? []) {
-    const path = String(rawPath || '').trim().replace(/^result\./, '');
-    const rows = normalizeRows(getAtPath(input.result, path));
-    if (!path || !rows) continue;
-    const name = path.split('.').filter(Boolean).at(-1)?.replace(/\[\d+\]$/, '') || path;
-    const keys = Object.fromEntries(
-      Object.keys(rows[0] ?? {}).map((key) => [key, key]),
-    );
-    lists[name] = { path, count: rows.length, keys };
-  }
-
-  return {
-    status: input.status,
-    result: input.result,
-    _metadata: {
-      toolId: input.metadata.toolId,
-      execution: input.execution,
-      targets,
-      lists,
-    },
-    get<T = unknown>(target: string): T | null {
-      return (this._metadata.targets[target]?.value as T | undefined) ?? null;
-    },
-    getEmail(): string | null {
-      const value = this.get('email');
-      return typeof value === 'string' && value.trim() ? value : null;
-    },
-    getPhone(): string | null {
-      const value = this.get('phone');
-      return typeof value === 'string' && value.trim() ? value : null;
-    },
-    getLinkedin(): string | null {
-      const value = this.get('linkedin');
-      return typeof value === 'string' && value.trim() ? value : null;
-    },
-    list<T = Record<string, unknown>>(name?: string): T[] | null {
-      const entryName = name ?? Object.keys(this._metadata.lists)[0];
-      if (!entryName) return null;
-      const list = this._metadata.lists[entryName];
-      return list ? (normalizeRows(getAtPath(this.result, list.path)) as T[] | null) : null;
-    },
-    listPick<const TKeys extends readonly string[]>(
-      keys: TKeys,
-      name?: string,
-    ): Array<Record<TKeys[number], unknown>> | null {
-      const entryName = name ?? Object.keys(this._metadata.lists)[0];
-      if (!entryName) return null;
-      const listMetadata = this._metadata.lists[entryName];
-      if (!listMetadata) return null;
-      const rows = normalizeRows(getAtPath(this.result, listMetadata.path));
-      if (!rows) return null;
-      return rows.map((row) => {
-        const picked: Record<string, unknown> = {};
-        for (const key of keys) {
-          const path = listMetadata.keys[key];
-          picked[key] = path ? getAtPath(row, path) ?? null : null;
-        }
-        return picked as Record<TKeys[number], unknown>;
-      });
-    },
-    listKeys(name?: string): Record<string, string> {
-      const entryName = name ?? Object.keys(this._metadata.lists)[0];
-      return entryName ? (this._metadata.lists[entryName]?.keys ?? {}) : {};
-    },
-  };
-}
-
-export function isToolExecuteResult(value: unknown): value is ToolExecuteResult {
-  return (
-    isRecordLike(value) &&
-    typeof value.status === 'string' &&
-    isRecordLike(value._metadata) &&
-    'result' in value
-  );
-}
-
-function parseToolPath(path: string): PathSegment[] {
-  const segments: PathSegment[] = [];
-  for (const rawPart of path.split('.').filter(Boolean)) {
-    const bracketPattern = /([^\[\]]+)|\[(\d+)\]/g;
-    let matched = false;
-    for (const match of rawPart.matchAll(bracketPattern)) {
-      matched = true;
-      if (match[1]) segments.push(match[1]);
-      else if (match[2]) segments.push(Number(match[2]));
-    }
-    if (!matched) segments.push(rawPart);
-  }
-  return segments;
-}
-
-function getAtPath(root: unknown, path: string): unknown {
-  let current = root;
-  for (const segment of parseToolPath(path)) {
-    if (typeof segment === 'number') {
-      if (!Array.isArray(current)) return undefined;
-      current = current[segment];
-    } else {
-      if (!isRecordLike(current)) return undefined;
-      current = current[segment];
-    }
-  }
-  return current;
-}
-
-function normalizeRows(value: unknown): Record<string, unknown>[] | null {
-  if (!Array.isArray(value)) return null;
-  return value.map((entry) => (isRecordLike(entry) ? entry : { value: entry }));
-}
-
-function isRecordLike(value: unknown): value is Record<string, unknown> {
-  return value != null && typeof value === 'object' && !Array.isArray(value);
-}