deepline 0.1.0 → 0.1.2

package/dist/repo/sdk/src/plays/bundle-play-file.ts

@@ -0,0 +1,133 @@
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+import {
+  bundlePlayFile as bundlePlayFileCore,
+  type BundlePlayFileOptions,
+  type BundledPlayFileSuccess,
+  type BundledPlayFileResult,
+  type ImportedPlayDependency,
+  type PlayBundlingAdapter,
+  type PlayLocalFileDiscoveryError,
+  type PlayLocalFileReference,
+} from '../../../shared_libs/plays/bundling/index.js';
+import {
+  PLAY_ARTIFACT_KINDS,
+  PLAY_BACKEND_DESCRIPTORS,
+  type PlayArtifactKind,
+} from '../../../shared_libs/play-runtime/backend.js';
+import { resolveExecutionProfile } from '../../../shared_libs/play-runtime/profiles.js';
+import {
+  discoverPackagedLocalFiles,
+} from './local-file-discovery.js';
+
+export type {
+  BundlePlayFileOptions,
+  BundledPlayFileSuccess,
+  BundledPlayFileResult,
+  ImportedPlayDependency,
+  PlayLocalFileDiscoveryError,
+  PlayLocalFileReference,
+};
+
+export type {
+  PlayArtifactCompatibility,
+  PlayBundleArtifact,
+  PlayImportPolicy,
+  PlayPackageImport,
+  PlayRuntimeFeature,
+} from '../../../shared_libs/plays/bundling/index.js';
+
+export {
+  extractDefinedPlayName,
+} from '../../../shared_libs/plays/bundling/index.js';
+
+const PLAY_BUNDLE_CACHE_VERSION = 24;
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const SDK_PACKAGE_ROOT = resolve(MODULE_DIR, '..', '..');
+const SOURCE_REPO_ROOT = resolve(SDK_PACKAGE_ROOT, '..');
+const HAS_SOURCE_BUNDLING_SOURCES = existsSync(
+  resolve(SOURCE_REPO_ROOT, 'apps', 'play-runner-workers', 'src', 'entry.ts'),
+);
+const PACKAGED_REPO_ROOT = resolve(SDK_PACKAGE_ROOT, 'dist', 'repo');
+const HAS_PACKAGED_BUNDLING_SOURCES = existsSync(
+  resolve(PACKAGED_REPO_ROOT, 'apps', 'play-runner-workers', 'src', 'entry.ts'),
+);
+const PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES
+  ? SOURCE_REPO_ROOT
+  : HAS_PACKAGED_BUNDLING_SOURCES
+  ? PACKAGED_REPO_ROOT
+  : resolve(SDK_PACKAGE_ROOT, '..');
+const SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES
+  ? resolve(SOURCE_REPO_ROOT, 'sdk', 'src')
+  : HAS_PACKAGED_BUNDLING_SOURCES
+  ? resolve(PACKAGED_REPO_ROOT, 'sdk', 'src')
+  : resolve(SDK_PACKAGE_ROOT, 'src');
+const SDK_PACKAGE_JSON = resolve(SDK_PACKAGE_ROOT, 'package.json');
+const SDK_ENTRY_FILE = resolve(SDK_SOURCE_ROOT, 'index.ts');
+const SDK_TYPES_ENTRY_FILE = resolve(SDK_PACKAGE_ROOT, 'dist', 'index.d.ts');
+const SDK_WORKERS_ENTRY_FILE = resolve(SDK_SOURCE_ROOT, 'worker-play-entry.ts');
+const WORKERS_HARNESS_ENTRY_FILE = resolve(PROJECT_ROOT, 'apps', 'play-runner-workers', 'src', 'entry.ts');
+const WORKERS_HARNESS_FILES_DIR = resolve(PROJECT_ROOT, 'apps', 'play-runner-workers', 'src');
+
+let hasWarnedAboutNonDevelopmentBundling = false;
+
+function warnAboutNonDevelopmentBundling(filePath: string): void {
+  if (hasWarnedAboutNonDevelopmentBundling) {
+    return;
+  }
+
+  const nodeEnv = String(process.env.NODE_ENV ?? '').trim().toLowerCase();
+  if (!nodeEnv || nodeEnv === 'development' || nodeEnv === 'test') {
+    return;
+  }
+
+  hasWarnedAboutNonDevelopmentBundling = true;
+  console.warn(
+    `[deepline] Warning: live play bundling was invoked while NODE_ENV=${nodeEnv} for ${filePath}. ` +
+      'This source-first SDK path is intended for local development. ' +
+      'For preview/production, run a published or prebuilt play reference instead of bundling source at runtime.',
+  );
+  console.warn(
+    '[deepline] Preferred production call pattern: client.play("person-to-email").run(...) ' +
+      'or run a previously registered/published org play.',
+  );
+}
+
+function defaultPlayBundleTarget(): PlayArtifactKind {
+  return PLAY_BACKEND_DESCRIPTORS[
+    resolveExecutionProfile(null).runner
+  ].artifactKind;
+}
+
+export function createSdkPlayBundlingAdapter(): PlayBundlingAdapter {
+  return {
+    projectRoot: PROJECT_ROOT,
+    nodeModulesDir: resolve(PROJECT_ROOT, 'node_modules'),
+    cacheDir: join(tmpdir(), `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`),
+    sdkSourceRoot: SDK_SOURCE_ROOT,
+    sdkPackageJson: SDK_PACKAGE_JSON,
+    sdkEntryFile: SDK_ENTRY_FILE,
+    sdkTypesEntryFile: existsSync(SDK_TYPES_ENTRY_FILE)
+      ? SDK_TYPES_ENTRY_FILE
+      : SDK_ENTRY_FILE,
+    sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
+    workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
+    workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
+    discoverPackagedLocalFiles,
+    warnAboutNonDevelopmentBundling,
+  };
+}
+
+export async function bundlePlayFile(
+  filePath: string,
+  options: BundlePlayFileOptions = {},
+): Promise<BundledPlayFileResult> {
+  return bundlePlayFileCore(filePath, {
+    target: options.target ?? defaultPlayBundleTarget(),
+    adapter: createSdkPlayBundlingAdapter(),
+  });
+}
+
+export { PLAY_ARTIFACT_KINDS };

package/dist/repo/sdk/src/plays/harness-stub.ts

@@ -0,0 +1,210 @@
+/**
+ * Per-play stub that calls into the long-lived Play Harness Worker via
+ * `env.HARNESS`.
+ *
+ * This file is what ends up bundled into every per-play Worker. It MUST
+ * stay tiny — every byte here is paid by every fresh-graphHash V8
+ * compile in CF's WorkerLoader. Target: <2 KB minified.
+ *
+ * What it does:
+ *   - Exposes thin functions that look like the in-bundle implementations
+ *     they're replacing (validate, runtime-api call, …).
+ *   - Each function calls `env.HARNESS.<method>(...)` — the typed RPC
+ *     stub provided by the Cloudflare service binding.
+ *
+ * What it does NOT do:
+ *   - Does NOT import zod (that's the whole point — zod stays in the
+ *     harness Worker).
+ *   - Does NOT import the harness Worker's `PlayHarness` class (that
+ *     would re-bundle the whole harness; only TYPES are imported).
+ *   - Does NOT cache RPC results across plays — caching belongs to
+ *     callers if they want it. This file stays stateless so it composes
+ *     cleanly under the per-play orchestrator's expectations.
+ *
+ * How the env binding reaches per-play code:
+ *   The coordinator's `WorkerLoader` factory passes `HARNESS` in the
+ *   per-play Worker's `env` map (see
+ *   `apps/play-runner-workers/src/coordinator-entry.ts` near
+ *   `loadDynamicPlayWorkerSync`). The per-play harness then reads it
+ *   off `WorkerEnv` and stashes it via `setHarnessBinding`.
+ *
+ * @see {@link ../../../apps/play-harness-worker/README.md}
+ */
+
+import type {
+  PlayHarnessRpc,
+  RuntimeApiCallInput,
+  RuntimeApiCallResult,
+  RuntimePayloadSchemaId,
+  ValidatePayloadResult,
+} from '../../../apps/play-harness-worker/src/rpc-types';
+
+/**
+ * Service-binding RPC stub shape — what `env.HARNESS` looks like inside
+ * a per-play Worker. Cloudflare exposes WorkerEntrypoint methods as
+ * promise-returning RPC stubs; the type matches `PlayHarnessRpc`.
+ */
+export type HarnessBinding = PlayHarnessRpc;
+type HarnessFetchBinding = HarnessBinding & {
+  fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+};
+
+/**
+ * Module-level holder for the binding. Set by the per-play harness on
+ * worker init (see `apps/play-runner-workers/src/entry.ts → setHarnessBinding`).
+ *
+ * Why a module-level holder instead of threading the binding through
+ * every call site: most leaf-call sites are deep inside SDK utilities
+ * (`ctx.tool`, `ctx.csv`, etc.) and threading a binding everywhere would
+ * be a structural mess. A single set-once holder, set very early in the
+ * worker's lifecycle, gives us clean call sites without sacrificing
+ * isolation — each per-play Worker is its own isolate, so the holder is
+ * never shared across plays.
+ */
+let cachedBinding: HarnessBinding | null = null;
+
+/**
+ * Install the harness binding for this worker. Called once on init from
+ * the per-play harness. Subsequent calls overwrite — the last writer
+ * wins. In practice the per-play harness sets this exactly once before
+ * any user code runs, so overwrites should never happen in production.
+ */
+export function setHarnessBinding(binding: HarnessBinding | null): void {
+  cachedBinding = binding;
+}
+
+/**
+ * Read the installed binding or throw a loud error. We deliberately
+ * throw rather than fall back to a HTTP-fetch path: fall-backs hide
+ * misconfiguration and let perf regressions creep in silently. If
+ * HARNESS is missing, the coordinator forgot to wire it in the
+ * WorkerLoader factory — that's a deploy bug, not a runtime contingency.
+ */
+function requireBinding(): HarnessBinding {
+  if (!cachedBinding) {
+    throw new Error(
+      '[harness-stub] env.HARNESS is not wired. The coordinator must pass HARNESS in the WorkerLoader factory env. ' +
+        'See apps/play-runner-workers/src/coordinator-entry.ts → loadDynamicPlayWorkerSync.',
+    );
+  }
+  return cachedBinding;
+}
+
+// ---------------------------------------------------------------------------
+// Public stub functions — these are what call sites use instead of the
+// in-bundle implementations they replace.
+//
+// Each function MUST stay a one-line forwarder to keep the per-play
+// bundle minimal. If a stub starts growing logic, that logic belongs in
+// the harness Worker, not here.
+// ---------------------------------------------------------------------------
+
+/**
+ * Liveness ping. Mostly used by tests + diagnostics that run inside a
+ * play context; production code rarely calls this.
+ */
+export async function harnessPing(): Promise<{ ok: true; ts: number }> {
+  return requireBinding().ping();
+}
+
+/**
+ * Forward a runtime-API call through the harness.
+ *
+ * Replaces what was previously a direct `fetch(env.RUNTIME_API, ...)`
+ * call in the per-play harness. The transport is identical (HTTPS to
+ * the upstream), but the HTTP client lives in the harness Worker so
+ * its retry/timeout/error code doesn't ride in every per-play bundle.
+ */
+export async function harnessRuntimeApiCall(
+  input: RuntimeApiCallInput,
+): Promise<RuntimeApiCallResult> {
+  return requireBinding().runtimeApiCall(input);
+}
+
+/**
+ * Start or continue a map dataset write inside the harness, so this call
+ * skips per-play callback overhead for heavy Postgres writes.
+ */
+export async function harnessStartSheetDataset(input: {
+  baseUrl: string;
+  executorToken: string;
+  playName: string;
+  tableNamespace: string;
+  sheetContract: unknown;
+  rows: Array<Record<string, unknown>>;
+  runId: string;
+  userEmail?: string | null;
+}): Promise<{
+  inserted: number;
+  skipped: number;
+  pendingRows: Array<Record<string, unknown>>;
+  completedRows: Array<Record<string, unknown>>;
+  tableNamespace: string;
+}> {
+  return requireBinding().startSheetDataset(input);
+}
+
+/**
+ * Persist completed map rows inside the harness, directly through the
+ * scoped Neon callback surface.
+ */
+export async function harnessPersistCompletedSheetRows(input: {
+  baseUrl: string;
+  executorToken: string;
+  playName: string;
+  tableNamespace: string;
+  sheetContract: unknown;
+  rows: Array<Record<string, unknown>>;
+  outputFields: string[];
+  runId: string;
+  userEmail?: string | null;
+}): Promise<{ ok: true; rowsWritten: number; tableNamespace: string }> {
+  return requireBinding().persistCompletedMapRows(input);
+}
+
+/**
+ * Stream a staged R2 object through the harness Worker. Unlike the legacy
+ * signed-URL helper this never touches the Vercel runtime route, and it keeps
+ * large CSV bodies as streams instead of serializing them through RPC.
+ */
+export async function harnessFetchStagedFile(input: {
+  executorToken: string;
+  storageKey: string;
+  method?: 'GET' | 'HEAD';
+  range?: { offset: number; length: number };
+}): Promise<Response> {
+  const binding = requireBinding() as HarnessFetchBinding;
+  if (typeof binding.fetch !== 'function') {
+    throw new Error(
+      '[harness-stub] env.HARNESS does not expose fetch(); cannot stream staged R2 files through the harness.',
+    );
+  }
+  const url = new URL('https://play-harness.internal/r2/staged-file');
+  url.searchParams.set('storageKey', input.storageKey);
+  const headers: Record<string, string> = {
+    authorization: `Bearer ${input.executorToken}`,
+  };
+  if (input.range) {
+    const end = input.range.offset + input.range.length - 1;
+    headers.range = `bytes=${input.range.offset}-${end}`;
+  }
+  return binding.fetch(url.toString(), {
+    method: input.method ?? 'GET',
+    headers,
+  });
+}
+
+/**
+ * Validate a payload against a named schema. The schema definitions
+ * (and zod itself) live in the harness Worker — see
+ * `apps/play-harness-worker/src/leaves/validate.ts → KNOWN_SCHEMAS`.
+ *
+ * Use a schema id of the form `tool:<provider>:<operation>` for tool
+ * inputs, or `runtime-api:<action>` for runtime-api request bodies.
+ */
+export async function harnessValidatePayload(
+  schemaId: RuntimePayloadSchemaId,
+  payload: unknown,
+): Promise<ValidatePayloadResult> {
+  return requireBinding().validatePayload({ schemaId, payload });
+}

package/dist/repo/sdk/src/plays/local-file-discovery.ts

@@ -0,0 +1,326 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import ts from 'typescript';
+
+export interface PlayLocalFileReference {
+  sourceFragment: string;
+  logicalPath: string;
+  absolutePath: string;
+  bytes: number;
+  contentHash: string;
+  contentType: string;
+}
+
+export interface PlayLocalFileDiscoveryError {
+  sourceFragment: string;
+  message: string;
+}
+
+export interface PlayLocalFileDiscoveryResult {
+  files: PlayLocalFileReference[];
+  unresolved: PlayLocalFileDiscoveryError[];
+}
+
+export interface PlayStagedFileRef {
+  storageKind: 'r2';
+  storageKey: string;
+  logicalPath: string;
+  fileName: string;
+  contentHash: string;
+  contentType: string;
+  bytes: number;
+}
+
+type ConstMap = Map<string, string>;
+
+const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+
+function sha256(buffer: Buffer): string {
+  return createHash('sha256').update(buffer).digest('hex');
+}
+
+function contentTypeForFile(filePath: string): string {
+  const extension = extname(filePath).toLowerCase();
+  if (extension === '.csv') return 'text/csv';
+  if (extension === '.json') return 'application/json';
+  if (extension === '.txt') return 'text/plain';
+  return 'application/octet-stream';
+}
+
+function isCtxCsvCall(node: ts.CallExpression): boolean {
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false;
+  }
+  const target = node.expression.expression;
+  return (
+    ts.isIdentifier(target) &&
+    (target.text === 'ctx' || target.text.endsWith('Ctx')) &&
+    node.expression.name.text === 'csv'
+  );
+}
+
+function extractSourceFragment(source: string, node: ts.Node): string {
+  return source.slice(node.getStart(), node.getEnd()).trim();
+}
+
+function referencesInputIdentifier(node: ts.Node): boolean {
+  if (ts.isIdentifier(node) && node.text === 'input') {
+    return true;
+  }
+
+  return node.getChildren().some((child) => referencesInputIdentifier(child));
+}
+
+function isRuntimeInputExpression(node: ts.Expression): boolean {
+  if (ts.isPropertyAccessExpression(node)) {
+    return ts.isIdentifier(node.expression) && node.expression.text === 'input';
+  }
+  if (ts.isElementAccessExpression(node)) {
+    return ts.isIdentifier(node.expression) && node.expression.text === 'input';
+  }
+  if (ts.isIdentifier(node)) {
+    return node.text === 'input';
+  }
+
+  if (ts.isParenthesizedExpression(node)) {
+    return isRuntimeInputExpression(node.expression);
+  }
+
+  if (
+    ts.isBinaryExpression(node) &&
+    (node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
+      node.operatorToken.kind === ts.SyntaxKind.BarBarToken)
+  ) {
+    return isRuntimeInputExpression(node.left) || isRuntimeInputExpression(node.right);
+  }
+
+  if (ts.isConditionalExpression(node)) {
+    return (
+      isRuntimeInputExpression(node.condition) ||
+      isRuntimeInputExpression(node.whenTrue) ||
+      isRuntimeInputExpression(node.whenFalse)
+    );
+  }
+
+  return referencesInputIdentifier(node);
+}
+
+function resolveStringExpression(node: ts.Expression, constants: ConstMap): string | null {
+  if (ts.isStringLiteralLike(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+
+  if (ts.isParenthesizedExpression(node)) {
+    return resolveStringExpression(node.expression, constants);
+  }
+
+  if (ts.isIdentifier(node)) {
+    return constants.get(node.text) ?? null;
+  }
+
+  if (ts.isTemplateExpression(node)) {
+    let value = node.head.text;
+    for (const span of node.templateSpans) {
+      const resolved = resolveStringExpression(span.expression, constants);
+      if (resolved == null) {
+        return null;
+      }
+      value += resolved + span.literal.text;
+    }
+    return value;
+  }
+
+  if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+    const left = resolveStringExpression(node.left, constants);
+    const right = resolveStringExpression(node.right, constants);
+    if (left == null || right == null) {
+      return null;
+    }
+    return left + right;
+  }
+
+  return null;
+}
+
+function collectTopLevelStringConstants(sourceFile: ts.SourceFile): ConstMap {
+  const constants: ConstMap = new Map();
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) {
+      continue;
+    }
+
+    if (!(statement.declarationList.flags & ts.NodeFlags.Const)) {
+      continue;
+    }
+
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+        continue;
+      }
+
+      const resolved = resolveStringExpression(declaration.initializer, constants);
+      if (resolved != null) {
+        constants.set(declaration.name.text, resolved);
+      }
+    }
+  }
+
+  return constants;
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isPathInsideDirectory(filePath: string, directory: string): boolean {
+  const relativePath = relative(directory, filePath);
+  return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
+}
+
+async function resolveLocalImport(fromFile: string, specifier: string): Promise<string> {
+  const base = isAbsolute(specifier) ? resolve(specifier) : resolve(dirname(fromFile), specifier);
+  const candidates: string[] = [base];
+  const explicitExtension = extname(base).toLowerCase();
+
+  if (!explicitExtension) {
+    candidates.push(...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`));
+    candidates.push(...SOURCE_EXTENSIONS.map((extension) => join(base, `index${extension}`)));
+  } else if (['.js', '.jsx', '.mjs', '.cjs'].includes(explicitExtension)) {
+    const stem = base.slice(0, -explicitExtension.length);
+    candidates.push(...SOURCE_EXTENSIONS.map((extension) => `${stem}${extension}`));
+  }
+
+  for (const candidate of candidates) {
+    if (await fileExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  throw new Error(`Could not resolve local import "${specifier}" from ${fromFile}`);
+}
+
+export async function discoverPackagedLocalFiles(
+  entryFile: string,
+): Promise<PlayLocalFileDiscoveryResult> {
+  const absoluteEntryFile = resolve(entryFile);
+  const packagingRoot = dirname(absoluteEntryFile);
+  const files = new Map<string, PlayLocalFileReference>();
+  const unresolved: PlayLocalFileDiscoveryError[] = [];
+  const visitedFiles = new Set<string>();
+
+  const visitSourceFile = async (filePath: string): Promise<void> => {
+    const absolutePath = resolve(filePath);
+    if (visitedFiles.has(absolutePath)) {
+      return;
+    }
+    visitedFiles.add(absolutePath);
+
+    const sourceCode = await readFile(absolutePath, 'utf-8');
+    const sourceFile = ts.createSourceFile(
+      absolutePath,
+      sourceCode,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TS,
+    );
+    const constants = collectTopLevelStringConstants(sourceFile);
+    const childVisits: Promise<void>[] = [];
+
+    const visitNode = async (node: ts.Node): Promise<void> => {
+      if (ts.isCallExpression(node) && isCtxCsvCall(node)) {
+        const argument = node.arguments[0];
+        if (!argument) {
+          unresolved.push({
+            sourceFragment: 'ctx.csv()',
+            message: 'ctx.csv() requires a file path string or input reference.',
+          });
+        } else if (!isRuntimeInputExpression(argument)) {
+          const resolvedPath = resolveStringExpression(argument, constants);
+          if (resolvedPath == null) {
+            unresolved.push({
+              sourceFragment: extractSourceFragment(sourceCode, argument),
+              message:
+                'Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file.',
+            });
+          } else {
+            const absoluteCsvPath = resolve(dirname(absolutePath), resolvedPath);
+            if (isAbsolute(resolvedPath) || !isPathInsideDirectory(absoluteCsvPath, packagingRoot)) {
+              unresolved.push({
+                sourceFragment: extractSourceFragment(sourceCode, argument),
+                message:
+                  'ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead.',
+              });
+              return;
+            }
+            const buffer = await readFile(absoluteCsvPath);
+            const stats = await stat(absoluteCsvPath);
+            files.set(absoluteCsvPath, {
+              sourceFragment: extractSourceFragment(sourceCode, argument),
+              logicalPath: resolvedPath,
+              absolutePath: absoluteCsvPath,
+              bytes: stats.size,
+              contentHash: sha256(buffer),
+              contentType: contentTypeForFile(absoluteCsvPath),
+            });
+          }
+        }
+      }
+
+      if (
+        ts.isImportDeclaration(node) &&
+        !node.importClause?.isTypeOnly &&
+        ts.isStringLiteral(node.moduleSpecifier) &&
+        node.moduleSpecifier.text.startsWith('.')
+      ) {
+        childVisits.push(
+          resolveLocalImport(absolutePath, node.moduleSpecifier.text).then((resolvedImport) =>
+            visitSourceFile(resolvedImport),
+          ),
+        );
+      }
+
+      if (
+        ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'require' &&
+        node.arguments.length === 1 &&
+        ts.isStringLiteral(node.arguments[0]) &&
+        node.arguments[0].text.startsWith('.')
+      ) {
+        childVisits.push(
+          resolveLocalImport(absolutePath, node.arguments[0].text).then((resolvedImport) =>
+            visitSourceFile(resolvedImport),
+          ),
+        );
+      }
+
+      await Promise.all(node.getChildren(sourceFile).map((child) => visitNode(child)));
+    };
+
+    await visitNode(sourceFile);
+    await Promise.all(childVisits);
+  };
+
+  await visitSourceFile(absoluteEntryFile);
+
+  return {
+    files: [...files.values()],
+    unresolved,
+  };
+}
+
+export function buildPlayStorageKey(input: {
+  orgId: string;
+  contentHash: string;
+  logicalPath: string;
+}): string {
+  const fileName = basename(input.logicalPath);
+  return `plays/v2/orgs/${input.orgId}/files/${input.contentHash}/${fileName}`;
+}