@workflow/builders 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/fast-discovery.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fast-discovery.test.d.ts.map

package/dist/fast-discovery.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fast-discovery.test.d.ts","sourceRoot":"","sources":["../src/fast-discovery.test.ts"],"names":[],"mappings":""}

package/dist/fast-discovery.test.js

@@ -0,0 +1,453 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { BaseBuilder } from './base-builder.js';
+import { importParents, parentHasChild, } from './discover-entries-esbuild-plugin.js';
+class TestBuilder extends BaseBuilder {
+    async build() {
+        // no-op
+    }
+    discoverEntriesPublic(inputs, outdir, tsconfigPath) {
+        return this.discoverEntries(inputs, outdir, tsconfigPath);
+    }
+    createRouteImportSpecifierPublic(file, routeDir) {
+        return this.createRouteImportSpecifier(file, routeDir);
+    }
+}
+const realTmpdir = realpathSync(tmpdir());
+function normalize(path) {
+    return path.replace(/\\/g, '/');
+}
+function writeFile(path, contents) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, contents, 'utf-8');
+}
+function createBuilder(workingDir, overrides) {
+    const config = {
+        buildTarget: 'standalone',
+        workingDir,
+        dirs: ['.'],
+        stepsBundlePath: join(workingDir, 'steps.js'),
+        workflowsBundlePath: join(workingDir, 'workflows.js'),
+        webhookBundlePath: join(workingDir, 'webhook.js'),
+        ...overrides,
+    };
+    return new TestBuilder(config);
+}
+describe('fast workflow discovery', () => {
+    let testRoot;
+    beforeEach(() => {
+        testRoot = mkdtempSync(join(realTmpdir, 'workflow-fast-discovery-'));
+        importParents.clear();
+    });
+    afterEach(() => {
+        importParents.clear();
+        rmSync(testRoot, { recursive: true, force: true });
+    });
+    it('discovers transitive relative step imports and tracks the parent chain', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const workflowFile = join(testRoot, 'src', 'workflow.ts');
+        const stepFile = join(testRoot, 'src', 'step.ts');
+        writeFile(entryFile, `import './workflow';\n`);
+        writeFile(workflowFile, `import { doStep } from './step';\nvoid doStep;\n`);
+        writeFile(stepFile, `export async function doStep() {
+  'use step';
+  return 1;
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredSteps).toEqual(new Set([normalize(stepFile)]));
+        expect(parentHasChild(normalize(entryFile), normalize(stepFile))).toBe(true);
+    });
+    it('discovers relative JS imports whose basename includes .step', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const workflowFile = join(testRoot, 'src', 'hello.step.js');
+        writeFile(entryFile, `import './hello.step';\n`);
+        writeFile(workflowFile, `export async function run() {
+  'use workflow';
+  return 'ok';
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(workflowFile)]));
+        expect(parentHasChild(normalize(entryFile), normalize(workflowFile))).toBe(true);
+    });
+    it('discovers workflow files reached through an imported package re-export', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const packageRoot = join(testRoot, 'node_modules', 'workflow-pkg');
+        const packageIndex = join(packageRoot, 'index.js');
+        const packageWorkflow = join(packageRoot, 'workflow.js');
+        writeFile(entryFile, `import { run } from 'workflow-pkg';\nvoid run;\n`);
+        writeFile(join(packageRoot, 'package.json'), JSON.stringify({
+            name: 'workflow-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+            dependencies: {
+                workflow: '^1.0.0',
+            },
+        }));
+        writeFile(packageIndex, `export { run } from './workflow.js';\n`);
+        writeFile(packageWorkflow, `export async function run() {
+  "use workflow";
+  return "ok";
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(packageWorkflow)]));
+        expect(parentHasChild(normalize(packageIndex), normalize(packageWorkflow))).toBe(true);
+    });
+    it('does not descend into node_modules when discoverWorkflowsInNodeModules is false', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const localWorkflow = join(testRoot, 'src', 'local-workflow.ts');
+        const packageRoot = join(testRoot, 'node_modules', 'workflow-pkg');
+        const packageIndex = join(packageRoot, 'index.js');
+        const packageWorkflow = join(packageRoot, 'workflow.js');
+        const packageStep = join(packageRoot, 'step.js');
+        writeFile(entryFile, `import './local-workflow';\nimport { run } from 'workflow-pkg';\nvoid run;\n`);
+        writeFile(localWorkflow, `export async function localRun() {
+  'use workflow';
+  return 'ok';
+}
+`);
+        writeFile(join(packageRoot, 'package.json'), JSON.stringify({
+            name: 'workflow-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+            dependencies: {
+                workflow: '^1.0.0',
+            },
+        }));
+        writeFile(packageIndex, `export { run } from './workflow.js';\nexport { doWork } from './step.js';\n`);
+        writeFile(packageWorkflow, `export async function run() {
+  "use workflow";
+  return "ok";
+}
+`);
+        writeFile(packageStep, `export async function doWork() {
+  "use step";
+  return "done";
+}
+`);
+        const discovered = await createBuilder(testRoot, {
+            discoverWorkflowsInNodeModules: false,
+        }).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        // Local (non-node_modules) workflow is still discovered.
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(localWorkflow)]));
+        // The node_modules workflow and step are not registered.
+        expect(discovered.discoveredWorkflows.has(normalize(packageWorkflow))).toBe(false);
+        expect(discovered.discoveredSteps.has(normalize(packageStep))).toBe(false);
+        // The dependency's files are never read/scanned: the import graph is not
+        // descended into at all, so none of them show up as discovered files and
+        // the parent edge into the package is not recorded.
+        for (const file of [packageIndex, packageWorkflow, packageStep]) {
+            expect(discovered.discoveredFiles?.has(normalize(file))).toBe(false);
+        }
+        expect(parentHasChild(normalize(entryFile), normalize(packageIndex))).toBe(false);
+    });
+    it('still follows imports within node_modules so seeded package entries resolve their subtree', async () => {
+        // Mirrors how the SDK seeds `@workflow/core/runtime/run` (a node_modules
+        // file) as an entry point: descent is blocked from application code, but a
+        // node_modules file may still reach its own transitive files.
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const packageRoot = join(testRoot, 'node_modules', 'seeded-pkg');
+        const packageIndex = join(packageRoot, 'index.js');
+        const packageWorkflow = join(packageRoot, 'workflow.js');
+        writeFile(entryFile, `export const noop = 1;\n`);
+        writeFile(join(packageRoot, 'package.json'), JSON.stringify({
+            name: 'seeded-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+            dependencies: { workflow: '^1.0.0' },
+        }));
+        writeFile(packageIndex, `export { run } from './workflow.js';\n`);
+        writeFile(packageWorkflow, `export async function run() {
+  "use workflow";
+  return "ok";
+}
+`);
+        // Seed the node_modules index directly as an entry point (as the builder
+        // does for the SDK runtime serde entry).
+        const discovered = await createBuilder(testRoot, {
+            discoverWorkflowsInNodeModules: false,
+        }).discoverEntriesPublic([entryFile, packageIndex], join(testRoot, 'out'));
+        expect(discovered.discoveredWorkflows.has(normalize(packageWorkflow))).toBe(true);
+        expect(parentHasChild(normalize(packageIndex), normalize(packageWorkflow))).toBe(true);
+    });
+    it('discovers files reached through tsconfig path aliases', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const registryFile = join(testRoot, 'src', '_workflows.ts');
+        const workflowFile = join(testRoot, 'src', 'workflows', 'workflow.ts');
+        const tsconfigFile = join(testRoot, 'tsconfig.json');
+        writeFile(tsconfigFile, JSON.stringify({
+            compilerOptions: {
+                paths: {
+                    '@/*': ['./src/*'],
+                },
+            },
+        }));
+        writeFile(entryFile, `import { allWorkflows } from '@/_workflows';\n`);
+        writeFile(registryFile, `import * as workflow from './workflows/workflow';
+export const allWorkflows = { workflow };
+`);
+        writeFile(workflowFile, `export async function run() {
+  'use workflow';
+  return 'ok';
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'), tsconfigFile);
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(workflowFile)]));
+        expect(parentHasChild(normalize(entryFile), normalize(workflowFile))).toBe(true);
+    });
+    it('discovers dotted files reached through tsconfig path aliases', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const registryFile = join(testRoot, 'src', 'workflows', 'hello.index.ts');
+        const workflowFile = join(testRoot, 'src', 'workflows', 'hello.ts');
+        const tsconfigFile = join(testRoot, 'tsconfig.json');
+        writeFile(tsconfigFile, JSON.stringify({
+            compilerOptions: {
+                paths: {
+                    '@/*': ['./src/*'],
+                },
+            },
+        }));
+        writeFile(entryFile, `import { helloWorkflow } from '@/workflows/hello.index';\n`);
+        writeFile(registryFile, `export { helloWorkflow } from './hello';\n`);
+        writeFile(workflowFile, `export async function helloWorkflow() {
+  'use workflow';
+  return 'ok';
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'), tsconfigFile);
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(workflowFile)]));
+    });
+    it('ignores non-source files reached through tsconfig path aliases', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const assetFile = join(testRoot, 'src', 'styles', 'app.css');
+        const tsconfigFile = join(testRoot, 'tsconfig.json');
+        writeFile(tsconfigFile, JSON.stringify({
+            compilerOptions: {
+                paths: {
+                    '@/*': ['./src/*'],
+                },
+            },
+        }));
+        writeFile(entryFile, `import '@/styles/app.css';\n`);
+        writeFile(assetFile, `'use workflow';\n`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'), tsconfigFile);
+        expect(discovered.discoveredWorkflows).toEqual(new Set());
+        expect(discovered.discoveredFiles).toEqual(new Set([normalize(entryFile)]));
+    });
+    it('discovers path aliases inherited through tsconfig extends', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const workflowFile = join(testRoot, 'src', 'workflows', 'workflow.ts');
+        const baseTsconfigFile = join(testRoot, 'tsconfig.base.json');
+        const tsconfigFile = join(testRoot, 'tsconfig.json');
+        writeFile(baseTsconfigFile, JSON.stringify({
+            compilerOptions: {
+                baseUrl: '.',
+                paths: {
+                    '@base/*': ['./src/*'],
+                },
+            },
+        }));
+        writeFile(tsconfigFile, JSON.stringify({
+            extends: './tsconfig.base.json',
+        }));
+        writeFile(entryFile, `import { run } from '@base/workflows/workflow';\n`);
+        writeFile(workflowFile, `export async function run() {
+  'use workflow';
+  return 'ok';
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'), tsconfigFile);
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(workflowFile)]));
+    });
+    it('discovers path aliases with multiple wildcards', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const workflowFile = join(testRoot, 'src', 'features', 'billing', 'flows', 'charge.ts');
+        const tsconfigFile = join(testRoot, 'tsconfig.json');
+        writeFile(tsconfigFile, JSON.stringify({
+            compilerOptions: {
+                paths: {
+                    '@feature/*/workflow/*': ['./src/features/*/flows/*'],
+                },
+            },
+        }));
+        writeFile(entryFile, `import { charge } from '@feature/billing/workflow/charge';\n`);
+        writeFile(workflowFile, `export async function charge() {
+  'use workflow';
+  return 'ok';
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'), tsconfigFile);
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(workflowFile)]));
+    });
+    it('ignores imports that only appear inside comments', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const registryFile = join(testRoot, 'src', '_workflows.ts');
+        const workflowFile = join(testRoot, 'src', 'workflows', 'simple.ts');
+        writeFile(entryFile, `import './_workflows';\n`);
+        writeFile(registryFile, `// import * as simple from './workflows/simple';
+
+export const allWorkflows = {
+  'workflows/simple.ts': simple,
+} as const;
+`);
+        writeFile(workflowFile, `export async function simple() {
+  'use workflow';
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredWorkflows).toEqual(new Set());
+        expect(discovered.discoveredFiles).toEqual(new Set([normalize(entryFile), normalize(registryFile)]));
+    });
+    it('does not treat regex literals as comments', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const registryFile = join(testRoot, 'src', '_workflows.ts');
+        const workflowFile = join(testRoot, 'src', 'workflows', 'simple.ts');
+        writeFile(entryFile, `import './_workflows';\n`);
+        writeFile(registryFile, `const commentStartChars = /[/*]/;
+const protocol = /https?:\\/\\//;
+import './workflows/simple';
+`);
+        writeFile(workflowFile, `export async function simple() {
+  'use workflow';
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(workflowFile)]));
+    });
+    it('uses nearest nested jsconfig aliases in monorepo packages', async () => {
+        const rootTsconfigFile = join(testRoot, 'tsconfig.json');
+        const packageRoot = join(testRoot, 'packages', 'app');
+        const entryFile = join(packageRoot, 'src', 'entry.js');
+        const workflowFile = join(packageRoot, 'src', 'workflow.js');
+        writeFile(rootTsconfigFile, JSON.stringify({
+            compilerOptions: {
+                paths: {
+                    '@root/*': ['./root/*'],
+                },
+            },
+        }));
+        writeFile(join(packageRoot, 'jsconfig.json'), JSON.stringify({
+            compilerOptions: {
+                paths: {
+                    '#/*': ['./src/*'],
+                },
+            },
+        }));
+        writeFile(entryFile, `import { run } from '#/workflow';\n`);
+        writeFile(workflowFile, `export async function run() {
+  "use workflow";
+  return "ok";
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(workflowFile)]));
+    });
+    it('only treats serde files as registration candidates when they define static serde methods', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const reducerFile = join(testRoot, 'src', 'reducer.ts');
+        const serdeFile = join(testRoot, 'src', 'serde.ts');
+        writeFile(entryFile, `import './reducer';
+import './serde';
+`);
+        writeFile(reducerFile, `import { WORKFLOW_SERIALIZE } from '@workflow/serde';
+
+export function reducer(value: unknown) {
+  return value?.constructor?.[WORKFLOW_SERIALIZE];
+}
+`);
+        writeFile(serdeFile, `import { WORKFLOW_SERIALIZE as WS } from '@workflow/serde';
+
+export class Value {
+  static classId = 'Value';
+  static [WS](value: Value) {
+    return value;
+  }
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredSerdeFiles).toEqual(new Set([normalize(serdeFile)]));
+    });
+    it('categorizes step, workflow, and serde usage independently', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const stepFile = join(testRoot, 'src', 'step.ts');
+        const workflowFile = join(testRoot, 'src', 'workflow.ts');
+        const serdeFile = join(testRoot, 'src', 'serde.ts');
+        writeFile(entryFile, `import './step';
+import './workflow';
+import './serde';
+`);
+        writeFile(stepFile, `export async function runStep() {
+  'use step';
+  return 'ok';
+}
+`);
+        writeFile(workflowFile, `export async function runWorkflow() {
+  'use workflow';
+  return 'ok';
+}
+`);
+        writeFile(serdeFile, `export class Value {
+  static classId = 'Value';
+  static [Symbol.for('workflow-serialize')](value: Value) {
+    return value;
+  }
+}
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredSteps).toEqual(new Set([normalize(stepFile)]));
+        expect(discovered.discoveredWorkflows).toEqual(new Set([normalize(workflowFile)]));
+        expect(discovered.discoveredSerdeFiles).toEqual(new Set([normalize(serdeFile)]));
+    });
+    it('ignores serde examples that only appear inside comments', async () => {
+        const entryFile = join(testRoot, 'src', 'entry.ts');
+        const docsFile = join(testRoot, 'src', 'docs.ts');
+        writeFile(entryFile, `import './docs';\n`);
+        writeFile(docsFile, `/**
+ * import { WORKFLOW_SERIALIZE } from '@workflow/serde';
+ *
+ * class Example {
+ *   static [WORKFLOW_SERIALIZE](value) {
+ *     return value;
+ *   }
+ * }
+ */
+export const WORKFLOW_SERIALIZE = Symbol.for('workflow-serialize');
+`);
+        const discovered = await createBuilder(testRoot).discoverEntriesPublic([entryFile], join(testRoot, 'out'));
+        expect(discovered.discoveredSerdeFiles).toEqual(new Set());
+    });
+    it('relativizes nested package step registration imports', () => {
+        const routeDir = join(testRoot, 'app', '.well-known', 'workflow', 'v1');
+        const directPackageFile = join(testRoot, 'node_modules', 'direct-pkg', 'step.js');
+        const nestedPackageFile = join(testRoot, 'node_modules', 'parent-pkg', 'node_modules', 'nested-pkg', 'step.js');
+        writeFile(join(testRoot, 'package.json'), JSON.stringify({
+            dependencies: {
+                'direct-pkg': '1.0.0',
+            },
+        }));
+        writeFile(join(testRoot, 'node_modules', 'direct-pkg', 'package.json'), JSON.stringify({
+            name: 'direct-pkg',
+            version: '1.0.0',
+            exports: {
+                './step': './step.js',
+            },
+        }));
+        writeFile(directPackageFile, `export const step = true;\n`);
+        writeFile(join(testRoot, 'node_modules', 'parent-pkg', 'node_modules', 'nested-pkg', 'package.json'), JSON.stringify({
+            name: 'nested-pkg',
+            version: '1.0.0',
+            exports: {
+                './step': './step.js',
+            },
+        }));
+        writeFile(nestedPackageFile, `export const step = true;\n`);
+        const builder = createBuilder(testRoot);
+        expect(builder.createRouteImportSpecifierPublic(directPackageFile, routeDir)).toBe('direct-pkg/step');
+        expect(builder.createRouteImportSpecifierPublic(nestedPackageFile, routeDir)).toBe('../../../../node_modules/parent-pkg/node_modules/nested-pkg/step.js');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fast-discovery.test.js","sourceRoot":"","sources":["../src/fast-discovery.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  mkdirSync,\n  mkdtempSync,\n  realpathSync,\n  rmSync,\n  writeFileSync,\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { dirname, join } from 'node:path';\nimport { afterEach, beforeEach, describe, expect, it } from 'vitest';\nimport { BaseBuilder, type DiscoveredEntries } from './base-builder.js';\nimport {\n  importParents,\n  parentHasChild,\n} from './discover-entries-esbuild-plugin.js';\nimport type { StandaloneConfig } from './types.js';\n\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    // no-op\n  }\n\n  public discoverEntriesPublic(\n    inputs: string[],\n    outdir: string,\n    tsconfigPath?: string\n  ): Promise<DiscoveredEntries> {\n    return this.discoverEntries(inputs, outdir, tsconfigPath);\n  }\n\n  public createRouteImportSpecifierPublic(\n    file: string,\n    routeDir: string\n  ): string {\n    return this.createRouteImportSpecifier(file, routeDir);\n  }\n}\n\nconst realTmpdir = realpathSync(tmpdir());\n\nfunction normalize(path: string): string {\n  return path.replace(/\\\\/g, '/');\n}\n\nfunction writeFile(path: string, contents: string): void {\n  mkdirSync(dirname(path), { recursive: true });\n  writeFileSync(path, contents, 'utf-8');\n}\n\nfunction createBuilder(\n  workingDir: string,\n  overrides?: Partial<StandaloneConfig>\n): TestBuilder {\n  const config: StandaloneConfig = {\n    buildTarget: 'standalone',\n    workingDir,\n    dirs: ['.'],\n    stepsBundlePath: join(workingDir, 'steps.js'),\n    workflowsBundlePath: join(workingDir, 'workflows.js'),\n    webhookBundlePath: join(workingDir, 'webhook.js'),\n    ...overrides,\n  };\n  return new TestBuilder(config);\n}\n\ndescribe('fast workflow discovery', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'workflow-fast-discovery-'));\n    importParents.clear();\n  });\n\n  afterEach(() => {\n    importParents.clear();\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('discovers transitive relative step imports and tracks the parent chain', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const workflowFile = join(testRoot, 'src', 'workflow.ts');\n    const stepFile = join(testRoot, 'src', 'step.ts');\n\n    writeFile(entryFile, `import './workflow';\\n`);\n    writeFile(workflowFile, `import { doStep } from './step';\\nvoid doStep;\\n`);\n    writeFile(\n      stepFile,\n      `export async function doStep() {\n  'use step';\n  return 1;\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredSteps).toEqual(new Set([normalize(stepFile)]));\n    expect(parentHasChild(normalize(entryFile), normalize(stepFile))).toBe(\n      true\n    );\n  });\n\n  it('discovers relative JS imports whose basename includes .step', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const workflowFile = join(testRoot, 'src', 'hello.step.js');\n\n    writeFile(entryFile, `import './hello.step';\\n`);\n    writeFile(\n      workflowFile,\n      `export async function run() {\n  'use workflow';\n  return 'ok';\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(workflowFile)])\n    );\n    expect(parentHasChild(normalize(entryFile), normalize(workflowFile))).toBe(\n      true\n    );\n  });\n\n  it('discovers workflow files reached through an imported package re-export', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const packageRoot = join(testRoot, 'node_modules', 'workflow-pkg');\n    const packageIndex = join(packageRoot, 'index.js');\n    const packageWorkflow = join(packageRoot, 'workflow.js');\n\n    writeFile(entryFile, `import { run } from 'workflow-pkg';\\nvoid run;\\n`);\n    writeFile(\n      join(packageRoot, 'package.json'),\n      JSON.stringify({\n        name: 'workflow-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n        dependencies: {\n          workflow: '^1.0.0',\n        },\n      })\n    );\n    writeFile(packageIndex, `export { run } from './workflow.js';\\n`);\n    writeFile(\n      packageWorkflow,\n      `export async function run() {\n  \"use workflow\";\n  return \"ok\";\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(packageWorkflow)])\n    );\n    expect(\n      parentHasChild(normalize(packageIndex), normalize(packageWorkflow))\n    ).toBe(true);\n  });\n\n  it('does not descend into node_modules when discoverWorkflowsInNodeModules is false', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const localWorkflow = join(testRoot, 'src', 'local-workflow.ts');\n    const packageRoot = join(testRoot, 'node_modules', 'workflow-pkg');\n    const packageIndex = join(packageRoot, 'index.js');\n    const packageWorkflow = join(packageRoot, 'workflow.js');\n    const packageStep = join(packageRoot, 'step.js');\n\n    writeFile(\n      entryFile,\n      `import './local-workflow';\\nimport { run } from 'workflow-pkg';\\nvoid run;\\n`\n    );\n    writeFile(\n      localWorkflow,\n      `export async function localRun() {\n  'use workflow';\n  return 'ok';\n}\n`\n    );\n    writeFile(\n      join(packageRoot, 'package.json'),\n      JSON.stringify({\n        name: 'workflow-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n        dependencies: {\n          workflow: '^1.0.0',\n        },\n      })\n    );\n    writeFile(\n      packageIndex,\n      `export { run } from './workflow.js';\\nexport { doWork } from './step.js';\\n`\n    );\n    writeFile(\n      packageWorkflow,\n      `export async function run() {\n  \"use workflow\";\n  return \"ok\";\n}\n`\n    );\n    writeFile(\n      packageStep,\n      `export async function doWork() {\n  \"use step\";\n  return \"done\";\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot, {\n      discoverWorkflowsInNodeModules: false,\n    }).discoverEntriesPublic([entryFile], join(testRoot, 'out'));\n\n    // Local (non-node_modules) workflow is still discovered.\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(localWorkflow)])\n    );\n    // The node_modules workflow and step are not registered.\n    expect(discovered.discoveredWorkflows.has(normalize(packageWorkflow))).toBe(\n      false\n    );\n    expect(discovered.discoveredSteps.has(normalize(packageStep))).toBe(false);\n    // The dependency's files are never read/scanned: the import graph is not\n    // descended into at all, so none of them show up as discovered files and\n    // the parent edge into the package is not recorded.\n    for (const file of [packageIndex, packageWorkflow, packageStep]) {\n      expect(discovered.discoveredFiles?.has(normalize(file))).toBe(false);\n    }\n    expect(parentHasChild(normalize(entryFile), normalize(packageIndex))).toBe(\n      false\n    );\n  });\n\n  it('still follows imports within node_modules so seeded package entries resolve their subtree', async () => {\n    // Mirrors how the SDK seeds `@workflow/core/runtime/run` (a node_modules\n    // file) as an entry point: descent is blocked from application code, but a\n    // node_modules file may still reach its own transitive files.\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const packageRoot = join(testRoot, 'node_modules', 'seeded-pkg');\n    const packageIndex = join(packageRoot, 'index.js');\n    const packageWorkflow = join(packageRoot, 'workflow.js');\n\n    writeFile(entryFile, `export const noop = 1;\\n`);\n    writeFile(\n      join(packageRoot, 'package.json'),\n      JSON.stringify({\n        name: 'seeded-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n        dependencies: { workflow: '^1.0.0' },\n      })\n    );\n    writeFile(packageIndex, `export { run } from './workflow.js';\\n`);\n    writeFile(\n      packageWorkflow,\n      `export async function run() {\n  \"use workflow\";\n  return \"ok\";\n}\n`\n    );\n\n    // Seed the node_modules index directly as an entry point (as the builder\n    // does for the SDK runtime serde entry).\n    const discovered = await createBuilder(testRoot, {\n      discoverWorkflowsInNodeModules: false,\n    }).discoverEntriesPublic([entryFile, packageIndex], join(testRoot, 'out'));\n\n    expect(discovered.discoveredWorkflows.has(normalize(packageWorkflow))).toBe(\n      true\n    );\n    expect(\n      parentHasChild(normalize(packageIndex), normalize(packageWorkflow))\n    ).toBe(true);\n  });\n\n  it('discovers files reached through tsconfig path aliases', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const registryFile = join(testRoot, 'src', '_workflows.ts');\n    const workflowFile = join(testRoot, 'src', 'workflows', 'workflow.ts');\n    const tsconfigFile = join(testRoot, 'tsconfig.json');\n\n    writeFile(\n      tsconfigFile,\n      JSON.stringify({\n        compilerOptions: {\n          paths: {\n            '@/*': ['./src/*'],\n          },\n        },\n      })\n    );\n    writeFile(entryFile, `import { allWorkflows } from '@/_workflows';\\n`);\n    writeFile(\n      registryFile,\n      `import * as workflow from './workflows/workflow';\nexport const allWorkflows = { workflow };\n`\n    );\n    writeFile(\n      workflowFile,\n      `export async function run() {\n  'use workflow';\n  return 'ok';\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out'),\n      tsconfigFile\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(workflowFile)])\n    );\n    expect(parentHasChild(normalize(entryFile), normalize(workflowFile))).toBe(\n      true\n    );\n  });\n\n  it('discovers dotted files reached through tsconfig path aliases', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const registryFile = join(testRoot, 'src', 'workflows', 'hello.index.ts');\n    const workflowFile = join(testRoot, 'src', 'workflows', 'hello.ts');\n    const tsconfigFile = join(testRoot, 'tsconfig.json');\n\n    writeFile(\n      tsconfigFile,\n      JSON.stringify({\n        compilerOptions: {\n          paths: {\n            '@/*': ['./src/*'],\n          },\n        },\n      })\n    );\n    writeFile(\n      entryFile,\n      `import { helloWorkflow } from '@/workflows/hello.index';\\n`\n    );\n    writeFile(registryFile, `export { helloWorkflow } from './hello';\\n`);\n    writeFile(\n      workflowFile,\n      `export async function helloWorkflow() {\n  'use workflow';\n  return 'ok';\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out'),\n      tsconfigFile\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(workflowFile)])\n    );\n  });\n\n  it('ignores non-source files reached through tsconfig path aliases', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const assetFile = join(testRoot, 'src', 'styles', 'app.css');\n    const tsconfigFile = join(testRoot, 'tsconfig.json');\n\n    writeFile(\n      tsconfigFile,\n      JSON.stringify({\n        compilerOptions: {\n          paths: {\n            '@/*': ['./src/*'],\n          },\n        },\n      })\n    );\n    writeFile(entryFile, `import '@/styles/app.css';\\n`);\n    writeFile(assetFile, `'use workflow';\\n`);\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out'),\n      tsconfigFile\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(new Set());\n    expect(discovered.discoveredFiles).toEqual(new Set([normalize(entryFile)]));\n  });\n\n  it('discovers path aliases inherited through tsconfig extends', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const workflowFile = join(testRoot, 'src', 'workflows', 'workflow.ts');\n    const baseTsconfigFile = join(testRoot, 'tsconfig.base.json');\n    const tsconfigFile = join(testRoot, 'tsconfig.json');\n\n    writeFile(\n      baseTsconfigFile,\n      JSON.stringify({\n        compilerOptions: {\n          baseUrl: '.',\n          paths: {\n            '@base/*': ['./src/*'],\n          },\n        },\n      })\n    );\n    writeFile(\n      tsconfigFile,\n      JSON.stringify({\n        extends: './tsconfig.base.json',\n      })\n    );\n    writeFile(entryFile, `import { run } from '@base/workflows/workflow';\\n`);\n    writeFile(\n      workflowFile,\n      `export async function run() {\n  'use workflow';\n  return 'ok';\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out'),\n      tsconfigFile\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(workflowFile)])\n    );\n  });\n\n  it('discovers path aliases with multiple wildcards', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const workflowFile = join(\n      testRoot,\n      'src',\n      'features',\n      'billing',\n      'flows',\n      'charge.ts'\n    );\n    const tsconfigFile = join(testRoot, 'tsconfig.json');\n\n    writeFile(\n      tsconfigFile,\n      JSON.stringify({\n        compilerOptions: {\n          paths: {\n            '@feature/*/workflow/*': ['./src/features/*/flows/*'],\n          },\n        },\n      })\n    );\n    writeFile(\n      entryFile,\n      `import { charge } from '@feature/billing/workflow/charge';\\n`\n    );\n    writeFile(\n      workflowFile,\n      `export async function charge() {\n  'use workflow';\n  return 'ok';\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out'),\n      tsconfigFile\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(workflowFile)])\n    );\n  });\n\n  it('ignores imports that only appear inside comments', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const registryFile = join(testRoot, 'src', '_workflows.ts');\n    const workflowFile = join(testRoot, 'src', 'workflows', 'simple.ts');\n\n    writeFile(entryFile, `import './_workflows';\\n`);\n    writeFile(\n      registryFile,\n      `// import * as simple from './workflows/simple';\n\nexport const allWorkflows = {\n  'workflows/simple.ts': simple,\n} as const;\n`\n    );\n    writeFile(\n      workflowFile,\n      `export async function simple() {\n  'use workflow';\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(new Set());\n    expect(discovered.discoveredFiles).toEqual(\n      new Set([normalize(entryFile), normalize(registryFile)])\n    );\n  });\n\n  it('does not treat regex literals as comments', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const registryFile = join(testRoot, 'src', '_workflows.ts');\n    const workflowFile = join(testRoot, 'src', 'workflows', 'simple.ts');\n\n    writeFile(entryFile, `import './_workflows';\\n`);\n    writeFile(\n      registryFile,\n      `const commentStartChars = /[/*]/;\nconst protocol = /https?:\\\\/\\\\//;\nimport './workflows/simple';\n`\n    );\n    writeFile(\n      workflowFile,\n      `export async function simple() {\n  'use workflow';\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(workflowFile)])\n    );\n  });\n\n  it('uses nearest nested jsconfig aliases in monorepo packages', async () => {\n    const rootTsconfigFile = join(testRoot, 'tsconfig.json');\n    const packageRoot = join(testRoot, 'packages', 'app');\n    const entryFile = join(packageRoot, 'src', 'entry.js');\n    const workflowFile = join(packageRoot, 'src', 'workflow.js');\n\n    writeFile(\n      rootTsconfigFile,\n      JSON.stringify({\n        compilerOptions: {\n          paths: {\n            '@root/*': ['./root/*'],\n          },\n        },\n      })\n    );\n    writeFile(\n      join(packageRoot, 'jsconfig.json'),\n      JSON.stringify({\n        compilerOptions: {\n          paths: {\n            '#/*': ['./src/*'],\n          },\n        },\n      })\n    );\n    writeFile(entryFile, `import { run } from '#/workflow';\\n`);\n    writeFile(\n      workflowFile,\n      `export async function run() {\n  \"use workflow\";\n  return \"ok\";\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(workflowFile)])\n    );\n  });\n\n  it('only treats serde files as registration candidates when they define static serde methods', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const reducerFile = join(testRoot, 'src', 'reducer.ts');\n    const serdeFile = join(testRoot, 'src', 'serde.ts');\n\n    writeFile(\n      entryFile,\n      `import './reducer';\nimport './serde';\n`\n    );\n    writeFile(\n      reducerFile,\n      `import { WORKFLOW_SERIALIZE } from '@workflow/serde';\n\nexport function reducer(value: unknown) {\n  return value?.constructor?.[WORKFLOW_SERIALIZE];\n}\n`\n    );\n    writeFile(\n      serdeFile,\n      `import { WORKFLOW_SERIALIZE as WS } from '@workflow/serde';\n\nexport class Value {\n  static classId = 'Value';\n  static [WS](value: Value) {\n    return value;\n  }\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredSerdeFiles).toEqual(\n      new Set([normalize(serdeFile)])\n    );\n  });\n\n  it('categorizes step, workflow, and serde usage independently', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const stepFile = join(testRoot, 'src', 'step.ts');\n    const workflowFile = join(testRoot, 'src', 'workflow.ts');\n    const serdeFile = join(testRoot, 'src', 'serde.ts');\n\n    writeFile(\n      entryFile,\n      `import './step';\nimport './workflow';\nimport './serde';\n`\n    );\n    writeFile(\n      stepFile,\n      `export async function runStep() {\n  'use step';\n  return 'ok';\n}\n`\n    );\n    writeFile(\n      workflowFile,\n      `export async function runWorkflow() {\n  'use workflow';\n  return 'ok';\n}\n`\n    );\n    writeFile(\n      serdeFile,\n      `export class Value {\n  static classId = 'Value';\n  static [Symbol.for('workflow-serialize')](value: Value) {\n    return value;\n  }\n}\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredSteps).toEqual(new Set([normalize(stepFile)]));\n    expect(discovered.discoveredWorkflows).toEqual(\n      new Set([normalize(workflowFile)])\n    );\n    expect(discovered.discoveredSerdeFiles).toEqual(\n      new Set([normalize(serdeFile)])\n    );\n  });\n\n  it('ignores serde examples that only appear inside comments', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const docsFile = join(testRoot, 'src', 'docs.ts');\n\n    writeFile(entryFile, `import './docs';\\n`);\n    writeFile(\n      docsFile,\n      `/**\n * import { WORKFLOW_SERIALIZE } from '@workflow/serde';\n *\n * class Example {\n *   static [WORKFLOW_SERIALIZE](value) {\n *     return value;\n *   }\n * }\n */\nexport const WORKFLOW_SERIALIZE = Symbol.for('workflow-serialize');\n`\n    );\n\n    const discovered = await createBuilder(testRoot).discoverEntriesPublic(\n      [entryFile],\n      join(testRoot, 'out')\n    );\n\n    expect(discovered.discoveredSerdeFiles).toEqual(new Set());\n  });\n\n  it('relativizes nested package step registration imports', () => {\n    const routeDir = join(testRoot, 'app', '.well-known', 'workflow', 'v1');\n    const directPackageFile = join(\n      testRoot,\n      'node_modules',\n      'direct-pkg',\n      'step.js'\n    );\n    const nestedPackageFile = join(\n      testRoot,\n      'node_modules',\n      'parent-pkg',\n      'node_modules',\n      'nested-pkg',\n      'step.js'\n    );\n\n    writeFile(\n      join(testRoot, 'package.json'),\n      JSON.stringify({\n        dependencies: {\n          'direct-pkg': '1.0.0',\n        },\n      })\n    );\n    writeFile(\n      join(testRoot, 'node_modules', 'direct-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'direct-pkg',\n        version: '1.0.0',\n        exports: {\n          './step': './step.js',\n        },\n      })\n    );\n    writeFile(directPackageFile, `export const step = true;\\n`);\n    writeFile(\n      join(\n        testRoot,\n        'node_modules',\n        'parent-pkg',\n        'node_modules',\n        'nested-pkg',\n        'package.json'\n      ),\n      JSON.stringify({\n        name: 'nested-pkg',\n        version: '1.0.0',\n        exports: {\n          './step': './step.js',\n        },\n      })\n    );\n    writeFile(nestedPackageFile, `export const step = true;\\n`);\n\n    const builder = createBuilder(testRoot);\n    expect(\n      builder.createRouteImportSpecifierPublic(directPackageFile, routeDir)\n    ).toBe('direct-pkg/step');\n    expect(\n      builder.createRouteImportSpecifierPublic(nestedPackageFile, routeDir)\n    ).toBe(\n      '../../../../node_modules/parent-pkg/node_modules/nested-pkg/step.js'\n    );\n  });\n});\n"]}