deepline 0.1.11 → 0.1.19

package/dist/repo/shared_libs/play-runtime/worker-api-types.ts

@@ -1,140 +0,0 @@
-export type PlayStagedFileRef = {
-  storageKind: 'r2';
-  storageKey: string;
-  logicalPath: string;
-  fileName: string;
-  contentHash: string;
-  contentType: string;
-  bytes: number;
-};
-
-export type PlayVisualNodeProgress = {
-  completed?: number;
-  total?: number;
-  failed?: number;
-  message?: string;
-  updatedAt?: number;
-  startedAt?: number;
-  completedAt?: number;
-  artifactTableNamespace?: string | null;
-};
-
-export type PlayVisualNodeProgressMap = Record<string, PlayVisualNodeProgress>;
-
-export type ComputeBillingItem = {
-  itemId: string;
-  source: string;
-  unit: string;
-  units: number;
-  providerCostUsd: number;
-  metadata?: unknown;
-};
-
-const DAYTONA_COMPUTE_PRICING_USD = {
-  vcpuSecond: 0.000014,
-  memoryGiBSecond: 0.0000045,
-  storageGiBSecond: 0.00000003,
-  includedStorageGiB: 5,
-} as const;
-
-const TEMPORAL_COMPUTE_PRICING_USD = {
-  action: 50 / 1_000_000,
-} as const;
-
-const NEON_COMPUTE_PRICING_USD = {
-  cuHour: 0.106,
-  defaultCu: 1,
-} as const;
-
-function roundUsd(amount: number): number {
-  return Number(Math.max(0, amount).toFixed(12));
-}
-
-export function resolveDaytonaSandboxComputeItem(input: {
-  itemId: string;
-  source?: string;
-  wallTimeSeconds: number;
-  cpu: number;
-  memoryGiB: number;
-  diskGiB: number;
-  sandboxId?: string | null;
-  startedAt?: number;
-  endedAt?: number;
-}): ComputeBillingItem {
-  const billableSeconds = Math.max(1, Math.ceil(input.wallTimeSeconds));
-  const cpu = Math.max(0, input.cpu);
-  const memoryGiB = Math.max(0, input.memoryGiB);
-  const billableDiskGiB = Math.max(
-    0,
-    input.diskGiB - DAYTONA_COMPUTE_PRICING_USD.includedStorageGiB,
-  );
-  const providerCostUsd = roundUsd(
-    billableSeconds *
-      (cpu * DAYTONA_COMPUTE_PRICING_USD.vcpuSecond +
-        memoryGiB * DAYTONA_COMPUTE_PRICING_USD.memoryGiBSecond +
-        billableDiskGiB *
-          DAYTONA_COMPUTE_PRICING_USD.storageGiBSecond),
-  );
-
-  return {
-    itemId: input.itemId,
-    source: input.source ?? 'daytona',
-    unit: 'sandbox_second',
-    units: billableSeconds,
-    providerCostUsd,
-    metadata: {
-      sandboxId: input.sandboxId ?? null,
-      cpu,
-      memoryGiB,
-      diskGiB: Math.max(0, input.diskGiB),
-      billableDiskGiB,
-      startedAt: input.startedAt,
-      endedAt: input.endedAt,
-    },
-  };
-}
-
-export function resolveTemporalComputeItem(input: {
-  itemId: string;
-  actions: number;
-  metadata?: unknown;
-}): ComputeBillingItem {
-  const actions = Math.max(0, Math.ceil(input.actions));
-  return {
-    itemId: input.itemId,
-    source: 'temporal',
-    unit: 'action',
-    units: actions,
-    providerCostUsd: roundUsd(actions * TEMPORAL_COMPUTE_PRICING_USD.action),
-    metadata: input.metadata,
-  };
-}
-
-export function resolveNeonComputeItem(input: {
-  itemId: string;
-  activeSeconds: number;
-  cu?: number;
-  metadata?: unknown;
-}): ComputeBillingItem {
-  const billableSeconds = Math.max(0, Math.ceil(input.activeSeconds));
-  const cu = Math.max(0, input.cu ?? NEON_COMPUTE_PRICING_USD.defaultCu);
-  return {
-    itemId: input.itemId,
-    source: 'neon',
-    unit: 'cu_second',
-    units: billableSeconds * cu,
-    providerCostUsd: roundUsd(
-      billableSeconds * cu * (NEON_COMPUTE_PRICING_USD.cuHour / 3600),
-    ),
-    metadata: {
-      activeSeconds: billableSeconds,
-      cu,
-      cuHourUsd: NEON_COMPUTE_PRICING_USD.cuHour,
-      ...(input.metadata && typeof input.metadata === 'object'
-        ? (input.metadata as Record<string, unknown>)
-        : input.metadata !== undefined
-          ? { inputMetadata: input.metadata }
-          : {}),
-    },
-  };
-}

package/dist/repo/shared_libs/plays/artifact-transport.ts

@@ -1,14 +0,0 @@
-import type { PlayBundleArtifact } from './artifact-types';
-
-const INLINE_SOURCE_MAP_PATTERN =
-  /\r?\n?\/\/# sourceMappingURL=data:application\/json;base64,[A-Za-z0-9+/=]+\s*$/;
-
-export function compactPlayArtifactForRuntimeTransport(
-  artifact: PlayBundleArtifact,
-): PlayBundleArtifact {
-  return {
-    ...artifact,
-    bundledCode: artifact.bundledCode.replace(INLINE_SOURCE_MAP_PATTERN, ''),
-    sourceMap: '',
-  };
-}

package/dist/repo/shared_libs/plays/artifact-types.ts

@@ -1,49 +0,0 @@
-export type PlayPackageImport = {
-  name: string;
-  version: string | null;
-};
-
-export type PlayImportPolicy = {
-  localFiles: string[];
-  nodeBuiltins: string[];
-  packages: PlayPackageImport[];
-};
-
-export type PlayRuntimeFeature =
-  | 'artifact_storage'
-  | 'checkpoint_resume'
-  | 'durable_sleep'
-  | 'packaged_files';
-
-export type PlayArtifactCompatibility = {
-  apiVersion: number;
-  artifactVersion: number;
-  minRunnerVersion: number;
-  runtimeFeatures: PlayRuntimeFeature[];
-  runtimeBackend?: string | null;
-};
-
-/**
- * Identifies which runtime can consume this artifact:
- *   - cjs_node20: Daytona / local-process (Node.js)
- *   - esm_workers: Cloudflare Workers (V8 isolate)
- */
-export type PlayArtifactKind = 'cjs_node20' | 'esm_workers';
-
-export type PlayBundleArtifact = {
-  codeFormat: 'cjs_module' | 'esm_module';
-  /** Defaults to cjs_node20 when not present (legacy artifacts). */
-  artifactKind?: PlayArtifactKind;
-  entryFile: string;
-  virtualFilename: string;
-  sourceHash: string;
-  graphHash: string;
-  artifactHash: string;
-  sourceMapHash: string;
-  bundledCode: string;
-  sourceMap: string;
-  importPolicy: PlayImportPolicy;
-  compatibility: PlayArtifactCompatibility;
-  generatedAt: number;
-  cacheHit: boolean;
-};

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

@@ -1,186 +0,0 @@
-import type { PlayArtifactKind } from '../play-runtime/backend';
-
-export interface PlayStaticPipelineSnapshot {
-  tableNamespace?: string;
-  inputFields?: string[];
-  csvArg?: string;
-  hasInlineData?: boolean;
-  csvDescription?: string;
-  mapDescription?: string;
-  fields: string[];
-  stages?: PlayStaticSubstepSnapshot[];
-  substeps: PlayStaticSubstepSnapshot[];
-  sheetContract?: PlaySheetContractSnapshot | null;
-  sheetContractErrors?: string[];
-}
-
-export type PlaySheetColumnSourceSnapshot =
-  | 'input'
-  | 'mapField'
-  | 'waterfallStep'
-  | 'childPlayColumn';
-
-export interface PlaySheetColumnContractSnapshot {
-  id: string;
-  sqlName: string;
-  source: PlaySheetColumnSourceSnapshot;
-  field?: string;
-  parentField?: string;
-  playId?: string;
-  waterfallId?: string;
-  outputField?: string;
-  outputSqlName?: string;
-  stepId?: string;
-  toolId?: string;
-}
-
-export interface PlaySheetContractSnapshot {
-  tableNamespace: string;
-  columns: PlaySheetColumnContractSnapshot[];
-}
-
-export interface PlayStaticSourceRangeSnapshot {
-  sourcePath?: string;
-  startLine: number;
-  endLine: number;
-  startColumn: number;
-  endColumn: number;
-}
-
-type PlayStaticSubstepMetadataSnapshot = {
-  conditional?: boolean;
-};
-
-export type PlayStaticSubstepSnapshot = PlayStaticSubstepMetadataSnapshot &
-  (
-    | {
-        type: 'csv';
-        field: string;
-        path?: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRangeSnapshot;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'map';
-        field: string;
-        name?: string;
-        tableNamespace?: string;
-        inputFields?: string[];
-        outputFields?: string[];
-        waterfallIds?: string[];
-        sheetContract?: PlaySheetContractSnapshot | null;
-        description?: string;
-        sourceRange?: PlayStaticSourceRangeSnapshot;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'tool';
-        toolId: string;
-        field: string;
-        description?: string;
-        inLoop?: boolean;
-        isEventWait?: boolean;
-        sourceRange?: PlayStaticSourceRangeSnapshot;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'waterfall';
-        tool?: string;
-        field: string;
-        inLoop?: boolean;
-        id?: string;
-        output?: string;
-        minResults?: number;
-        sourceText?: string;
-        steps?: Array<{
-          id: string;
-          kind?: 'tool' | 'code';
-          toolId?: string;
-          paramsSource?: string;
-        }>;
-        description?: string;
-        sourceRange?: PlayStaticSourceRangeSnapshot;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'step_suite';
-        field: string;
-        steps: PlayStaticSubstepSnapshot[];
-        returnSource?: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRangeSnapshot;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'play_call';
-        playId: string;
-        field: string;
-        inLoop?: boolean;
-        pipeline?: PlayStaticPipelineSnapshot | null;
-        cycleDetected?: boolean;
-        resolutionError?: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRangeSnapshot;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'run_javascript';
-        alias: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRangeSnapshot;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'code';
-        field: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRangeSnapshot;
-        callDepth?: number;
-        callPath?: string[];
-      }
-  );
-
-export const PLAY_COMPILER_MANIFEST_VERSION = 1;
-
-export type PlayCompilerDependencyManifest = {
-  playName: string;
-  sourceHash: string;
-  graphHash: string;
-  artifactHash: string;
-  staticPipeline: PlayStaticPipelineSnapshot;
-};
-
-export type PlayCompilerManifest = {
-  compilerVersion: number;
-  playName: string;
-  sourceHash: string;
-  graphHash: string;
-  artifactHash: string;
-  artifactKind?: PlayArtifactKind;
-  staticPipeline: PlayStaticPipelineSnapshot;
-  importedPlayDependencies: PlayCompilerDependencyManifest[];
-};
-
-export type PlayRuntimeManifest = {
-  playName?: string;
-  graphHash: string;
-  artifactHash: string;
-  artifactStorageKey: string;
-  staticPipelineHash: string;
-  staticPipeline: PlayStaticPipelineSnapshot;
-  compiledAt: number;
-  compilerVersion: string;
-  sourceCode?: string | null;
-  dynamicWorkerCode?: string | null;
-  maxCreditsPerRun?: number | null;
-};
-
-export type PlayRuntimeManifestMap = Record<string, PlayRuntimeManifest>;

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

@@ -1,264 +0,0 @@
-export type PlayPrimitive = string | number | boolean | null;
-
-export type PlayValueTemplate =
-  | PlayPrimitive
-  | { $ref: string }
-  | { [key: string]: PlayValueTemplate }
-  | PlayValueTemplate[];
-
-export type SerializedPlayJavascript = {
-  kind: 'serialized_javascript';
-  source: string;
-  displayName?: string;
-};
-
-export type PlayJavascriptExecutorContext = {
-  row: Record<string, unknown>;
-  steps: Record<string, unknown>;
-  input: Record<string, unknown>;
-  index: number;
-};
-
-export type PlayJavascriptExecutor<TResult = unknown> = (
-  context: PlayJavascriptExecutorContext,
-) => TResult | Promise<TResult>;
-
-export type PlayStructuredStep =
-  | {
-      type: 'tool';
-      alias: string;
-      toolId: string;
-      input: Record<string, PlayValueTemplate>;
-      description?: string;
-    }
-  | {
-      type: 'waterfall';
-      alias: string;
-      tool: string;
-      input: Record<string, PlayValueTemplate>;
-      providers?: string[];
-      description?: string;
-    }
-  | {
-      type: 'run_javascript';
-      alias: string;
-      execute: SerializedPlayJavascript;
-      input?: Record<string, PlayValueTemplate>;
-      description?: string;
-      displayAs?: 'run_javascript';
-    };
-
-export type PlayStructuredDefinition = {
-  version: 1;
-  map: {
-    key: string;
-    steps: PlayStructuredStep[];
-  };
-  result?: {
-    mode?: 'rows';
-  };
-};
-
-export function serializeExecutableJs<TResult = unknown>(
-  execute: PlayJavascriptExecutor<TResult>,
-  displayName?: string,
-): SerializedPlayJavascript {
-  const source = execute.toString().trim();
-  if (!source) {
-    throw new Error('Executable JavaScript function source must be non-empty.');
-  }
-  return {
-    kind: 'serialized_javascript',
-    source,
-    displayName,
-  };
-}
-
-export function runJavascriptStep<TResult = unknown>(input: {
-  alias: string;
-  execute: PlayJavascriptExecutor<TResult>;
-  description?: string;
-  input?: Record<string, PlayValueTemplate>;
-}): Extract<PlayStructuredStep, { type: 'run_javascript' }> {
-  return {
-    type: 'run_javascript',
-    alias: input.alias,
-    execute: serializeExecutableJs(input.execute, input.alias),
-    ...(input.description ? { description: input.description } : {}),
-    ...(input.input ? { input: input.input } : {}),
-    displayAs: 'run_javascript',
-  };
-}
-
-export function definePlayDefinition(
-  definition: PlayStructuredDefinition,
-): PlayStructuredDefinition {
-  return definition;
-}
-
-function formatTemplate(template: PlayValueTemplate): string {
-  if (
-    template === null ||
-    typeof template === 'string' ||
-    typeof template === 'number' ||
-    typeof template === 'boolean'
-  ) {
-    return JSON.stringify(template);
-  }
-  if (Array.isArray(template)) {
-    return `[${template.map((value) => formatTemplate(value)).join(', ')}]`;
-  }
-  if ('$ref' in template && typeof template.$ref === 'string') {
-    return `ref(${JSON.stringify(template.$ref)})`;
-  }
-  return `{ ${Object.entries(template)
-    .map(([key, value]) => `${JSON.stringify(key)}: ${formatTemplate(value)}`)
-    .join(', ')} }`;
-}
-
-export function renderPlayDefinitionSource(
-  definition: PlayStructuredDefinition,
-): string {
-  const lines: string[] = [];
-  lines.push('definePlayDefinition({');
-  lines.push('  version: 1,');
-  lines.push('  map: {');
-  lines.push(`    key: ${JSON.stringify(definition.map.key)},`);
-  lines.push('    steps: [');
-  for (const step of definition.map.steps) {
-    if (step.type === 'tool') {
-      lines.push('      {');
-      lines.push('        type: "tool",');
-      lines.push(`        alias: ${JSON.stringify(step.alias)},`);
-      lines.push(`        toolId: ${JSON.stringify(step.toolId)},`);
-      lines.push(`        input: ${formatTemplate(step.input)},`);
-      if (step.description) {
-        lines.push(`        description: ${JSON.stringify(step.description)},`);
-      }
-      lines.push('      },');
-      continue;
-    }
-    if (step.type === 'waterfall') {
-      lines.push('      {');
-      lines.push('        type: "waterfall",');
-      lines.push(`        alias: ${JSON.stringify(step.alias)},`);
-      lines.push(`        tool: ${JSON.stringify(step.tool)},`);
-      lines.push(`        input: ${formatTemplate(step.input)},`);
-      if (step.providers?.length) {
-        lines.push(`        providers: ${JSON.stringify(step.providers)},`);
-      }
-      if (step.description) {
-        lines.push(`        description: ${JSON.stringify(step.description)},`);
-      }
-      lines.push('      },');
-      continue;
-    }
-    lines.push(`      runJavascriptStep({
-        alias: ${JSON.stringify(step.alias)},
-        execute: ${step.execute.source},
-        ${step.input ? `input: ${formatTemplate(step.input)},` : ''}
-      }),`);
-  }
-  lines.push('    ],');
-  lines.push('  },');
-  lines.push('});');
-  return lines.join('\n');
-}
-
-export function validatePlayStructuredDefinition(
-  definition: unknown,
-): { valid: boolean; errors: string[] } {
-  const errors: string[] = [];
-  if (!definition || typeof definition !== 'object') {
-    return { valid: false, errors: ['Definition must be an object.'] };
-  }
-  const candidate = definition as Partial<PlayStructuredDefinition>;
-  if (candidate.version !== 1) {
-    errors.push('Definition version must be 1.');
-  }
-  if (typeof candidate.map?.key !== 'string' || !candidate.map.key.trim()) {
-    errors.push('Definition map.key must be a non-empty string.');
-  }
-  if (!Array.isArray(candidate.map?.steps) || candidate.map.steps.length === 0) {
-    errors.push('Definition must contain at least one step.');
-  }
-  for (const [index, step] of (candidate.map?.steps ?? []).entries()) {
-    if (!step || typeof step !== 'object') {
-      errors.push(`Step ${index} must be an object.`);
-      continue;
-    }
-    const typedStep = step as PlayStructuredStep;
-    if (!typedStep.alias?.trim()) {
-      errors.push(`Step ${index} requires a non-empty alias.`);
-    }
-    if (typedStep.type === 'tool' && !typedStep.toolId?.trim()) {
-      errors.push(`Tool step ${typedStep.alias || index} requires toolId.`);
-    }
-    if (typedStep.type === 'waterfall' && !typedStep.tool?.trim()) {
-      errors.push(`Waterfall step ${typedStep.alias || index} requires tool.`);
-    }
-    if (typedStep.type === 'run_javascript') {
-      if (!typedStep.execute?.source?.trim()) {
-        errors.push(`run_javascript step ${typedStep.alias || index} requires executable source.`);
-        continue;
-      }
-      try {
-        new Function(`return (${typedStep.execute.source});`);
-      } catch (error) {
-        errors.push(
-          `run_javascript step ${typedStep.alias || index} parse error: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-
-function getPathValue(
-  value: unknown,
-  path: string,
-): unknown {
-  if (!path) return value;
-  const normalized = path.replace(/^\$?/, '');
-  const parts = normalized.split('.').filter(Boolean);
-  let current = value;
-  for (const part of parts) {
-    if (current == null || typeof current !== 'object') return undefined;
-    current = (current as Record<string, unknown>)[part];
-  }
-  return current;
-}
-
-export function resolvePlayValueTemplate(
-  template: PlayValueTemplate,
-  context: PlayJavascriptExecutorContext,
-): unknown {
-  if (
-    template === null ||
-    typeof template === 'string' ||
-    typeof template === 'number' ||
-    typeof template === 'boolean'
-  ) {
-    return template;
-  }
-  if (Array.isArray(template)) {
-    return template.map((item) => resolvePlayValueTemplate(item, context));
-  }
-  if ('$ref' in template && typeof template.$ref === 'string') {
-    const [root, ...rest] = template.$ref.split('.');
-    const path = rest.join('.');
-    if (root === 'row') return getPathValue(context.row, path);
-    if (root === 'steps') return getPathValue(context.steps, path);
-    if (root === 'input') return getPathValue(context.input, path);
-    if (root === 'index') return context.index;
-    return undefined;
-  }
-  return Object.fromEntries(
-    Object.entries(template).map(([key, value]) => [
-      key,
-      resolvePlayValueTemplate(value, context),
-    ]),
-  );
-}

package/dist/repo/shared_libs/plays/file-refs.ts

@@ -1,11 +0,0 @@
-export interface PlayR2FileRef {
-  storageKind: 'r2';
-  storageKey: string;
-  logicalPath: string;
-  fileName: string;
-  contentHash: string;
-  contentType: string;
-  bytes: number;
-}
-
-export type PlayExecutionFileRef = PlayR2FileRef;