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

package/dist/swc-esbuild-plugin.test.js

@@ -9,6 +9,7 @@ const { applySwcTransformMock } = vi.hoisted(() => ({
 vi.mock('./apply-swc-transform.js', () => ({
     applySwcTransform: applySwcTransformMock,
 }));
+import { createDiscoverEntriesPlugin, importParents, } from './discover-entries-esbuild-plugin.js';
 import { createSwcPlugin } from './swc-esbuild-plugin.js';
 const realTmpdir = realpathSync(tmpdir());
 function writeFile(path, contents = '') {
@@ -19,6 +20,7 @@ describe('createSwcPlugin externalizeNonSteps', () => {
     let testRoot;
     beforeEach(() => {
         testRoot = mkdtempSync(join(realTmpdir, 'workflow-swc-plugin-'));
+        importParents.clear();
         applySwcTransformMock.mockReset();
         applySwcTransformMock.mockImplementation(async (_filename, source) => ({
             code: source,
@@ -26,8 +28,180 @@ describe('createSwcPlugin externalizeNonSteps', () => {
         }));
     });
     afterEach(() => {
+        importParents.clear();
         rmSync(testRoot, { recursive: true, force: true });
     });
+    it('reports authoritative transform results to an optional observer', async () => {
+        const srcDir = join(testRoot, 'src');
+        const stepFile = join(srcDir, 'step.ts');
+        const source = 'export const value = 42;';
+        const workflowManifest = {
+            steps: {
+                'src/step.ts': {
+                    value: {
+                        stepId: 'step//src/step//value',
+                    },
+                },
+            },
+        };
+        const onAfterTransform = vi.fn();
+        writeFile(stepFile, source);
+        applySwcTransformMock.mockResolvedValue({
+            code: `${source}\n/* transformed */`,
+            workflowManifest,
+        });
+        await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir: join(testRoot, 'out'),
+            bundle: true,
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile],
+                    onAfterTransform,
+                }),
+            ],
+        });
+        expect(onAfterTransform).toHaveBeenCalledOnce();
+        expect(onAfterTransform).toHaveBeenCalledWith({
+            mode: 'step',
+            filename: 'src/step.ts',
+            absolutePath: stepFile,
+            source,
+            code: `${source}\n/* transformed */`,
+            workflowManifest,
+        });
+    });
+    it('awaits asynchronous transform observers', async () => {
+        const stepFile = join(testRoot, 'src', 'step.ts');
+        let markObserverStarted = () => { };
+        let releaseObserver = () => { };
+        const observerStarted = new Promise((resolve) => {
+            markObserverStarted = resolve;
+        });
+        const observerBlocked = new Promise((resolve) => {
+            releaseObserver = resolve;
+        });
+        let buildCompleted = false;
+        writeFile(stepFile, 'export const value = 42;');
+        const build = esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir: join(testRoot, 'out'),
+            bundle: true,
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile],
+                    onAfterTransform: async () => {
+                        markObserverStarted();
+                        await observerBlocked;
+                    },
+                }),
+            ],
+        });
+        void build.then(() => {
+            buildCompleted = true;
+        });
+        await observerStarted;
+        await Promise.resolve();
+        expect(buildCompleted).toBe(false);
+        releaseObserver();
+        await build;
+        expect(buildCompleted).toBe(true);
+    });
+    it('fails the build when a transform observer throws', async () => {
+        const stepFile = join(testRoot, 'src', 'step.ts');
+        writeFile(stepFile, 'export const value = 42;');
+        await expect(esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir: join(testRoot, 'out'),
+            bundle: true,
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile],
+                    onAfterTransform: () => {
+                        throw new Error('transform observer failed');
+                    },
+                }),
+            ],
+        })).rejects.toThrow(/transform observer failed/);
+    });
+    it('fails the build when two files emit the same step id', async () => {
+        const srcDir = join(testRoot, 'src');
+        const firstStepFile = join(srcDir, 'confirmation.ts');
+        const secondStepFile = join(srcDir, 'reschedule.ts');
+        const onAfterTransform = vi.fn();
+        writeFile(firstStepFile, `export const first = true;`);
+        writeFile(secondStepFile, `export const second = true;`);
+        applySwcTransformMock.mockImplementation(async (filename, source) => ({
+            code: source,
+            workflowManifest: {
+                steps: {
+                    [filename]: {
+                        sendMessage: {
+                            stepId: 'step//shared-package@1.0.0//sendMessage',
+                        },
+                    },
+                },
+            },
+        }));
+        await expect(esbuild.build({
+            entryPoints: [firstStepFile, secondStepFile],
+            absWorkingDir: testRoot,
+            outdir: join(testRoot, 'out'),
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    onAfterTransform,
+                }),
+            ],
+        })).rejects.toThrow(/Duplicate workflow step ID/);
+        expect(onAfterTransform).toHaveBeenCalledOnce();
+    });
+    it('fails the build when two files emit the same workflow id', async () => {
+        const srcDir = join(testRoot, 'src');
+        const firstWorkflowFile = join(srcDir, 'confirmation.ts');
+        const secondWorkflowFile = join(srcDir, 'reschedule.ts');
+        writeFile(firstWorkflowFile, `export const first = true;`);
+        writeFile(secondWorkflowFile, `export const second = true;`);
+        applySwcTransformMock.mockImplementation(async (filename, source) => ({
+            code: source,
+            workflowManifest: {
+                workflows: {
+                    [filename]: {
+                        sendMessage: {
+                            workflowId: 'workflow//shared-package@1.0.0//sendMessage',
+                        },
+                    },
+                },
+            },
+        }));
+        await expect(esbuild.build({
+            entryPoints: [firstWorkflowFile, secondWorkflowFile],
+            absWorkingDir: testRoot,
+            outdir: join(testRoot, 'out'),
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'workflow',
+                }),
+            ],
+        })).rejects.toThrow(/Duplicate workflow ID/);
+    });
     it.each([
         { inputExt: '.ts', outputExt: '.js' },
         { inputExt: '.tsx', outputExt: '.js' },
@@ -61,12 +235,16 @@ describe('createSwcPlugin externalizeNonSteps', () => {
         expect(output).toContain(`/dep${outputExt}`);
         expect(output).not.toContain(`/dep${inputExt}`);
     });
-    it('rewrites path-aliased imports to relative paths', async () => {
+    it('bundles path-aliased project-local imports inline', async () => {
+        // Aliased project-local files must be bundled inline (not externalized
+        // as relative paths) because their source on disk may contain further
+        // alias imports that Node's ESM loader cannot resolve at runtime.
+        // See packages/builders/src/swc-esbuild-plugin.ts for full reasoning.
         const outdir = join(testRoot, 'out');
         const srcDir = join(testRoot, 'src');
         const libDir = join(srcDir, 'lib');
         const stepFile = join(srcDir, 'step.ts');
-        writeFile(join(libDir, 'config.ts'), 'export const config = {};');
+        writeFile(join(libDir, 'config.ts'), 'export const config = { value: "hello-from-config" };');
         writeFile(stepFile, `import { config } from '@/lib/config';\nconsole.log(config);`);
         const result = await esbuild.build({
             entryPoints: [stepFile],
@@ -88,8 +266,63 @@ describe('createSwcPlugin externalizeNonSteps', () => {
         });
         expect(result.errors).toHaveLength(0);
         const output = result.outputFiles[0].text;
-        expect(output).toContain('/lib/config.js');
+        // The aliased helper should be bundled inline (its content is in the
+        // output), not externalized as a relative path or left as a bare alias.
+        expect(output).toContain('hello-from-config');
         expect(output).not.toContain('@/lib/config');
+        expect(output).not.toMatch(/from\s+["'][^"']*\/lib\/config\.(js|ts)["']/);
+    });
+    it('bundles transitive aliased imports inside aliased helpers (Mux self-referencing package regression)', async () => {
+        // Regression test for https://github.com/muxinc/ai/pull/193.
+        //
+        // A package self-references its own subpath via tsconfig `paths` (e.g.
+        // `@my-pkg/lib/foo` → `src/lib/foo.ts`). A step file imports a helper
+        // via the alias, and that helper imports another helper via the alias.
+        //
+        // Previously the helpers were externalized as relative paths, but their
+        // source on disk still contained `import "@my-pkg/lib/..."`. At runtime,
+        // Node's ESM loader didn't know about tsconfig paths, fell through to
+        // the package's `exports` map, and threw `Package subpath ... is not
+        // defined by "exports"`.
+        //
+        // With the fix, aliased project-local files are bundled inline, so
+        // their alias imports are resolved at build time.
+        const outdir = join(testRoot, 'out');
+        const srcDir = join(testRoot, 'src');
+        const libDir = join(srcDir, 'lib');
+        const stepFile = join(srcDir, 'step.ts');
+        writeFile(join(libDir, 'providers.ts'), 'export const providerName = "anthropic";');
+        writeFile(join(libDir, 'client-factory.ts'), 
+        // Helper uses the same alias to reach a sibling — this is the case
+        // that broke the Mux build with workflow >= 4.2.0-beta.78.
+        `import { providerName } from '@my-pkg/lib/providers';
+export const client = { provider: providerName };`);
+        writeFile(stepFile, `import { client } from '@my-pkg/lib/client-factory';\nconsole.log(client);`);
+        const result = await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            alias: { '@my-pkg': srcDir },
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile],
+                    outdir,
+                    rewriteTsExtensions: true,
+                }),
+            ],
+        });
+        expect(result.errors).toHaveLength(0);
+        const output = result.outputFiles[0].text;
+        // Both helpers should be bundled inline — no aliased specifiers should
+        // leak into the output, where Node's ESM loader would choke on them.
+        expect(output).toContain('anthropic');
+        expect(output).not.toContain('@my-pkg/lib/providers');
+        expect(output).not.toContain('@my-pkg/lib/client-factory');
     });
     it('does not relativize Node.js builtin imports', async () => {
         const outdir = join(testRoot, 'out');
@@ -150,6 +383,39 @@ describe('createSwcPlugin externalizeNonSteps', () => {
         expect(output).toContain('hello');
         expect(output).not.toMatch(/from\s+["'].*node_modules/);
     });
+    it('externalizes nested bare package imports that only resolve from a bundled package', async () => {
+        const outdir = join(testRoot, 'out');
+        const srcDir = join(testRoot, 'src');
+        const stepFile = join(srcDir, 'step.ts');
+        const parentPkgDir = join(testRoot, 'node_modules', 'parent-pkg');
+        const parentPkgIndex = join(parentPkgDir, 'index.js');
+        const nativePkgDir = join(parentPkgDir, 'node_modules', 'optional-native');
+        writeFile(join(parentPkgDir, 'package.json'), JSON.stringify({ name: 'parent-pkg', main: 'index.js' }));
+        writeFile(parentPkgIndex, `const native = require('optional-native');\nexports.value = native.value;`);
+        writeFile(join(nativePkgDir, 'package.json'), JSON.stringify({ name: 'optional-native', main: 'binding.node' }));
+        writeFile(join(nativePkgDir, 'binding.node'), '');
+        writeFile(stepFile, `import { value } from 'parent-pkg';\nconsole.log(value);`);
+        const result = await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile, parentPkgIndex],
+                    outdir,
+                }),
+            ],
+        });
+        expect(result.errors).toHaveLength(0);
+        const output = result.outputFiles[0].text;
+        expect(output).toContain('optional-native');
+        expect(output).not.toContain('binding.node');
+    });
     it.each([
         '.ts',
         '.tsx',
@@ -181,6 +447,187 @@ describe('createSwcPlugin externalizeNonSteps', () => {
         const output = result.outputFiles[0].text;
         expect(output).toContain(`/dep${inputExt}`);
     });
+    it('bundles transitive local TypeScript dependencies with extensionless imports', async () => {
+        const outdir = join(testRoot, 'out');
+        const stepFile = join(testRoot, 'server', 'workflows', 'my-workflow.ts');
+        const constantsFile = join(testRoot, 'shared', 'constants.ts');
+        const helpersFile = join(testRoot, 'shared', 'helpers.ts');
+        writeFile(helpersFile, `export const HELPER_VALUE = "from-helper";`);
+        writeFile(constantsFile, `import { HELPER_VALUE } from './helpers';\nexport const CATEGORIES = [HELPER_VALUE];`);
+        writeFile(stepFile, `import { CATEGORIES } from '../../shared/constants';\nexport async function myStep() {\n  'use step';\n  return CATEGORIES[0];\n}`);
+        const state = {
+            discoveredSteps: new Set(),
+            discoveredWorkflows: new Set(),
+            discoveredSerdeFiles: new Set(),
+        };
+        await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            resolveExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+            plugins: [createDiscoverEntriesPlugin(state, testRoot)],
+        });
+        const result = await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            resolveExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile],
+                    outdir,
+                    bundleTransitiveLocalStepDependencies: true,
+                }),
+            ],
+        });
+        expect(result.errors).toHaveLength(0);
+        const output = result.outputFiles[0].text;
+        expect(output).toContain('from-helper');
+        expect(output).not.toMatch(/from\s+["'][^"']*shared\/constants/);
+        expect(output).not.toMatch(/from\s+["'][^"']*shared\/helpers/);
+    });
+    it('externalizes transitive local TypeScript dependencies by default', async () => {
+        const outdir = join(testRoot, 'out');
+        const stepFile = join(testRoot, 'server', 'workflows', 'my-workflow.ts');
+        const constantsFile = join(testRoot, 'shared', 'constants.ts');
+        const helpersFile = join(testRoot, 'shared', 'helpers.ts');
+        writeFile(helpersFile, `export const HELPER_VALUE = "from-helper";`);
+        writeFile(constantsFile, `import { HELPER_VALUE } from './helpers';\nexport const CATEGORIES = [HELPER_VALUE];`);
+        writeFile(stepFile, `import { CATEGORIES } from '../../shared/constants';\nexport async function myStep() {\n  'use step';\n  return CATEGORIES[0];\n}`);
+        const state = {
+            discoveredSteps: new Set(),
+            discoveredWorkflows: new Set(),
+            discoveredSerdeFiles: new Set(),
+        };
+        await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            resolveExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+            plugins: [createDiscoverEntriesPlugin(state, testRoot)],
+        });
+        const result = await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            resolveExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile],
+                    outdir,
+                }),
+            ],
+        });
+        expect(result.errors).toHaveLength(0);
+        const output = result.outputFiles[0].text;
+        expect(output).not.toContain('from-helper');
+        expect(output).toMatch(/from\s+["'][^"']*shared\/constants\.ts["']/);
+    });
+    it('keeps ordinary package dependencies external when reachable from a bundled step', async () => {
+        const outdir = join(testRoot, 'out');
+        const stepFile = join(testRoot, 'server', 'workflows', 'my-workflow.ts');
+        const pkgDir = join(testRoot, 'node_modules', 'plain-pkg');
+        const pkgIndex = join(pkgDir, 'index.js');
+        writeFile(join(pkgDir, 'package.json'), JSON.stringify({ name: 'plain-pkg', main: 'index.js' }));
+        writeFile(pkgIndex, `export const value = "from-package";`);
+        writeFile(stepFile, `import { value } from 'plain-pkg';\nexport async function myStep() {\n  'use step';\n  return value;\n}`);
+        const state = {
+            discoveredSteps: new Set(),
+            discoveredWorkflows: new Set(),
+            discoveredSerdeFiles: new Set(),
+        };
+        await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            plugins: [createDiscoverEntriesPlugin(state, testRoot)],
+        });
+        const result = await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile],
+                    outdir,
+                    bundleTransitiveLocalStepDependencies: true,
+                }),
+            ],
+        });
+        expect(result.errors).toHaveLength(0);
+        const output = result.outputFiles[0].text;
+        expect(output).toMatch(/from\s+["']plain-pkg["']/);
+        expect(output).not.toContain('from-package');
+    });
+    it('bundles package parents when they lead to discovered workflow-related entries', async () => {
+        const outdir = join(testRoot, 'out');
+        const stepFile = join(testRoot, 'server', 'workflows', 'my-workflow.ts');
+        const pkgDir = join(testRoot, 'node_modules', 'workflow-pkg');
+        const pkgIndex = join(pkgDir, 'index.js');
+        const pkgSerde = join(pkgDir, 'serde.js');
+        writeFile(join(pkgDir, 'package.json'), JSON.stringify({ name: 'workflow-pkg', main: 'index.js' }));
+        writeFile(pkgSerde, `export const value = "from-serde";`);
+        writeFile(pkgIndex, `export { value } from './serde.js';`);
+        writeFile(stepFile, `import { value } from 'workflow-pkg';\nexport async function myStep() {\n  'use step';\n  return value;\n}`);
+        const state = {
+            discoveredSteps: new Set(),
+            discoveredWorkflows: new Set(),
+            discoveredSerdeFiles: new Set(),
+        };
+        await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            plugins: [createDiscoverEntriesPlugin(state, testRoot)],
+        });
+        const result = await esbuild.build({
+            entryPoints: [stepFile],
+            absWorkingDir: testRoot,
+            outdir,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'step',
+                    entriesToBundle: [stepFile, pkgSerde],
+                    outdir,
+                }),
+            ],
+        });
+        expect(result.errors).toHaveLength(0);
+        const output = result.outputFiles[0].text;
+        expect(output).toContain('from-serde');
+        expect(output).not.toMatch(/from\s+["']workflow-pkg["']/);
+    });
 });
 describe('createSwcPlugin sideEffectEntries', () => {
     let testRoot;
@@ -468,7 +915,29 @@ describe('createSwcPlugin projectRoot', () => {
             ],
         });
         expect(result.errors).toHaveLength(0);
-        expect(applySwcTransformMock).toHaveBeenCalledWith('src/internal/message/workflow/handle-message.ts', expect.stringContaining('"use workflow"'), 'workflow', fixture.workflowFile, fixture.appRoot);
+        expect(applySwcTransformMock).toHaveBeenCalledWith('src/internal/message/workflow/handle-message.ts', expect.stringContaining('"use workflow"'), 'workflow', fixture.workflowFile, fixture.appRoot, fixture.appRoot);
+    });
+    it('passes an explicit moduleSpecifierRoot separately from projectRoot', async () => {
+        const fixture = setupFixture();
+        const tracingRoot = testRoot;
+        const result = await esbuild.build({
+            entryPoints: [fixture.workflowFile],
+            absWorkingDir: fixture.packageRoot,
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            plugins: [
+                createSwcPlugin({
+                    mode: 'workflow',
+                    projectRoot: tracingRoot,
+                    moduleSpecifierRoot: fixture.appRoot,
+                    workflowManifest: {},
+                }),
+            ],
+        });
+        expect(result.errors).toHaveLength(0);
+        expect(applySwcTransformMock).toHaveBeenCalledWith('src/internal/message/workflow/handle-message.ts', expect.stringContaining('"use workflow"'), 'workflow', fixture.workflowFile, tracingRoot, fixture.appRoot);
     });
     it('defaults the transform projectRoot to absWorkingDir', async () => {
         const fixture = setupFixture();
@@ -487,7 +956,7 @@ describe('createSwcPlugin projectRoot', () => {
             ],
         });
         expect(result.errors).toHaveLength(0);
-        expect(applySwcTransformMock).toHaveBeenCalledWith('src/internal/message/workflow/handle-message.ts', expect.stringContaining('"use workflow"'), 'workflow', fixture.workflowFile, fixture.packageRoot);
+        expect(applySwcTransformMock).toHaveBeenCalledWith('src/internal/message/workflow/handle-message.ts', expect.stringContaining('"use workflow"'), 'workflow', fixture.workflowFile, fixture.packageRoot, fixture.packageRoot);
     });
 });
-//# sourceMappingURL=swc-esbuild-plugin.test.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"swc-esbuild-plugin.test.js","sourceRoot":"","sources":["../src/swc-esbuild-plugin.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 * as esbuild from 'esbuild';\nimport { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';\n\nconst { applySwcTransformMock } = vi.hoisted(() => ({\n  applySwcTransformMock: vi.fn(),\n}));\n\nvi.mock('./apply-swc-transform.js', () => ({\n  applySwcTransform: applySwcTransformMock,\n}));\n\nimport {\n  createDiscoverEntriesPlugin,\n  importParents,\n} from './discover-entries-esbuild-plugin.js';\nimport { createSwcPlugin } from './swc-esbuild-plugin.js';\n\nconst realTmpdir = realpathSync(tmpdir());\n\nfunction writeFile(path: string, contents = ''): void {\n  mkdirSync(dirname(path), { recursive: true });\n  writeFileSync(path, contents, 'utf-8');\n}\n\ndescribe('createSwcPlugin externalizeNonSteps', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'workflow-swc-plugin-'));\n    importParents.clear();\n    applySwcTransformMock.mockReset();\n    applySwcTransformMock.mockImplementation(\n      async (_filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {},\n      })\n    );\n  });\n\n  afterEach(() => {\n    importParents.clear();\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('reports authoritative transform results to an optional observer', async () => {\n    const srcDir = join(testRoot, 'src');\n    const stepFile = join(srcDir, 'step.ts');\n    const source = 'export const value = 42;';\n    const workflowManifest = {\n      steps: {\n        'src/step.ts': {\n          value: {\n            stepId: 'step//src/step//value',\n          },\n        },\n      },\n    };\n    const onAfterTransform = vi.fn();\n\n    writeFile(stepFile, source);\n    applySwcTransformMock.mockResolvedValue({\n      code: `${source}\\n/* transformed */`,\n      workflowManifest,\n    });\n\n    await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir: join(testRoot, 'out'),\n      bundle: true,\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          onAfterTransform,\n        }),\n      ],\n    });\n\n    expect(onAfterTransform).toHaveBeenCalledOnce();\n    expect(onAfterTransform).toHaveBeenCalledWith({\n      mode: 'step',\n      filename: 'src/step.ts',\n      absolutePath: stepFile,\n      source,\n      code: `${source}\\n/* transformed */`,\n      workflowManifest,\n    });\n  });\n\n  it('awaits asynchronous transform observers', async () => {\n    const stepFile = join(testRoot, 'src', 'step.ts');\n    let markObserverStarted: () => void = () => {};\n    let releaseObserver: () => void = () => {};\n    const observerStarted = new Promise<void>((resolve) => {\n      markObserverStarted = resolve;\n    });\n    const observerBlocked = new Promise<void>((resolve) => {\n      releaseObserver = resolve;\n    });\n    let buildCompleted = false;\n\n    writeFile(stepFile, 'export const value = 42;');\n\n    const build = esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir: join(testRoot, 'out'),\n      bundle: true,\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          onAfterTransform: async () => {\n            markObserverStarted();\n            await observerBlocked;\n          },\n        }),\n      ],\n    });\n    void build.then(() => {\n      buildCompleted = true;\n    });\n\n    await observerStarted;\n    await Promise.resolve();\n    expect(buildCompleted).toBe(false);\n\n    releaseObserver();\n    await build;\n    expect(buildCompleted).toBe(true);\n  });\n\n  it('fails the build when a transform observer throws', async () => {\n    const stepFile = join(testRoot, 'src', 'step.ts');\n\n    writeFile(stepFile, 'export const value = 42;');\n\n    await expect(\n      esbuild.build({\n        entryPoints: [stepFile],\n        absWorkingDir: testRoot,\n        outdir: join(testRoot, 'out'),\n        bundle: true,\n        write: false,\n        plugins: [\n          createSwcPlugin({\n            mode: 'step',\n            entriesToBundle: [stepFile],\n            onAfterTransform: () => {\n              throw new Error('transform observer failed');\n            },\n          }),\n        ],\n      })\n    ).rejects.toThrow(/transform observer failed/);\n  });\n\n  it('fails the build when two files emit the same step id', async () => {\n    const srcDir = join(testRoot, 'src');\n    const firstStepFile = join(srcDir, 'confirmation.ts');\n    const secondStepFile = join(srcDir, 'reschedule.ts');\n    const onAfterTransform = vi.fn();\n\n    writeFile(firstStepFile, `export const first = true;`);\n    writeFile(secondStepFile, `export const second = true;`);\n\n    applySwcTransformMock.mockImplementation(\n      async (filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {\n          steps: {\n            [filename]: {\n              sendMessage: {\n                stepId: 'step//shared-package@1.0.0//sendMessage',\n              },\n            },\n          },\n        },\n      })\n    );\n\n    await expect(\n      esbuild.build({\n        entryPoints: [firstStepFile, secondStepFile],\n        absWorkingDir: testRoot,\n        outdir: join(testRoot, 'out'),\n        bundle: true,\n        format: 'esm',\n        platform: 'node',\n        write: false,\n        plugins: [\n          createSwcPlugin({\n            mode: 'step',\n            onAfterTransform,\n          }),\n        ],\n      })\n    ).rejects.toThrow(/Duplicate workflow step ID/);\n    expect(onAfterTransform).toHaveBeenCalledOnce();\n  });\n\n  it('fails the build when two files emit the same workflow id', async () => {\n    const srcDir = join(testRoot, 'src');\n    const firstWorkflowFile = join(srcDir, 'confirmation.ts');\n    const secondWorkflowFile = join(srcDir, 'reschedule.ts');\n\n    writeFile(firstWorkflowFile, `export const first = true;`);\n    writeFile(secondWorkflowFile, `export const second = true;`);\n\n    applySwcTransformMock.mockImplementation(\n      async (filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {\n          workflows: {\n            [filename]: {\n              sendMessage: {\n                workflowId: 'workflow//shared-package@1.0.0//sendMessage',\n              },\n            },\n          },\n        },\n      })\n    );\n\n    await expect(\n      esbuild.build({\n        entryPoints: [firstWorkflowFile, secondWorkflowFile],\n        absWorkingDir: testRoot,\n        outdir: join(testRoot, 'out'),\n        bundle: true,\n        format: 'esm',\n        platform: 'node',\n        write: false,\n        plugins: [\n          createSwcPlugin({\n            mode: 'workflow',\n          }),\n        ],\n      })\n    ).rejects.toThrow(/Duplicate workflow ID/);\n  });\n\n  it.each([\n    { inputExt: '.ts', outputExt: '.js' },\n    { inputExt: '.tsx', outputExt: '.js' },\n    { inputExt: '.mts', outputExt: '.mjs' },\n    { inputExt: '.cts', outputExt: '.cjs' },\n  ])('rewrites externalized $inputExt imports to $outputExt when rewriteTsExtensions is enabled', async ({\n    inputExt,\n    outputExt,\n  }) => {\n    const outdir = join(testRoot, 'out');\n    const srcDir = join(testRoot, 'src');\n    const stepFile = join(srcDir, 'step.ts');\n\n    writeFile(join(srcDir, `dep${inputExt}`), 'export const dep = {};');\n    writeFile(stepFile, `import { dep } from './dep';\\nconsole.log(dep);`);\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n          rewriteTsExtensions: true,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    expect(output).toContain(`/dep${outputExt}`);\n    expect(output).not.toContain(`/dep${inputExt}`);\n  });\n\n  it('bundles path-aliased project-local imports inline', async () => {\n    // Aliased project-local files must be bundled inline (not externalized\n    // as relative paths) because their source on disk may contain further\n    // alias imports that Node's ESM loader cannot resolve at runtime.\n    // See packages/builders/src/swc-esbuild-plugin.ts for full reasoning.\n    const outdir = join(testRoot, 'out');\n    const srcDir = join(testRoot, 'src');\n    const libDir = join(srcDir, 'lib');\n    const stepFile = join(srcDir, 'step.ts');\n\n    writeFile(\n      join(libDir, 'config.ts'),\n      'export const config = { value: \"hello-from-config\" };'\n    );\n    writeFile(\n      stepFile,\n      `import { config } from '@/lib/config';\\nconsole.log(config);`\n    );\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      alias: { '@': srcDir },\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n          rewriteTsExtensions: true,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    // The aliased helper should be bundled inline (its content is in the\n    // output), not externalized as a relative path or left as a bare alias.\n    expect(output).toContain('hello-from-config');\n    expect(output).not.toContain('@/lib/config');\n    expect(output).not.toMatch(/from\\s+[\"'][^\"']*\\/lib\\/config\\.(js|ts)[\"']/);\n  });\n\n  it('bundles transitive aliased imports inside aliased helpers (Mux self-referencing package regression)', async () => {\n    // Regression test for https://github.com/muxinc/ai/pull/193.\n    //\n    // A package self-references its own subpath via tsconfig `paths` (e.g.\n    // `@my-pkg/lib/foo` → `src/lib/foo.ts`). A step file imports a helper\n    // via the alias, and that helper imports another helper via the alias.\n    //\n    // Previously the helpers were externalized as relative paths, but their\n    // source on disk still contained `import \"@my-pkg/lib/...\"`. At runtime,\n    // Node's ESM loader didn't know about tsconfig paths, fell through to\n    // the package's `exports` map, and threw `Package subpath ... is not\n    // defined by \"exports\"`.\n    //\n    // With the fix, aliased project-local files are bundled inline, so\n    // their alias imports are resolved at build time.\n    const outdir = join(testRoot, 'out');\n    const srcDir = join(testRoot, 'src');\n    const libDir = join(srcDir, 'lib');\n    const stepFile = join(srcDir, 'step.ts');\n\n    writeFile(\n      join(libDir, 'providers.ts'),\n      'export const providerName = \"anthropic\";'\n    );\n    writeFile(\n      join(libDir, 'client-factory.ts'),\n      // Helper uses the same alias to reach a sibling — this is the case\n      // that broke the Mux build with workflow >= 4.2.0-beta.78.\n      `import { providerName } from '@my-pkg/lib/providers';\nexport const client = { provider: providerName };`\n    );\n    writeFile(\n      stepFile,\n      `import { client } from '@my-pkg/lib/client-factory';\\nconsole.log(client);`\n    );\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      alias: { '@my-pkg': srcDir },\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n          rewriteTsExtensions: true,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    // Both helpers should be bundled inline — no aliased specifiers should\n    // leak into the output, where Node's ESM loader would choke on them.\n    expect(output).toContain('anthropic');\n    expect(output).not.toContain('@my-pkg/lib/providers');\n    expect(output).not.toContain('@my-pkg/lib/client-factory');\n  });\n\n  it('does not relativize Node.js builtin imports', async () => {\n    const outdir = join(testRoot, 'out');\n    const srcDir = join(testRoot, 'src');\n    const stepFile = join(srcDir, 'step.ts');\n\n    writeFile(\n      stepFile,\n      `import { createHash } from 'crypto';\\nimport { join } from 'node:path';\\nconsole.log(createHash, join);`\n    );\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    // Builtins should remain as bare specifiers, not relativized paths\n    expect(output).toMatch(/from\\s+[\"']crypto[\"']/);\n    expect(output).toMatch(/from\\s+[\"']node:path[\"']/);\n    expect(output).not.toMatch(/from\\s+[\"']\\..*crypto[\"']/);\n    expect(output).not.toMatch(/from\\s+[\"']\\..*node:path[\"']/);\n  });\n\n  it('does not externalize aliased imports that resolve into node_modules', async () => {\n    const outdir = join(testRoot, 'out');\n    const srcDir = join(testRoot, 'src');\n    const stepFile = join(srcDir, 'step.ts');\n    const nodeModulesDir = join(testRoot, 'node_modules', 'some-pkg');\n\n    writeFile(join(nodeModulesDir, 'index.js'), 'export const pkg = \"hello\";');\n    writeFile(stepFile, `import { pkg } from '@pkg';\\nconsole.log(pkg);`);\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      alias: { '@pkg': join(nodeModulesDir, 'index.js') },\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    // Should be bundled (inlined), not externalized as a relative node_modules path\n    expect(output).toContain('hello');\n    expect(output).not.toMatch(/from\\s+[\"'].*node_modules/);\n  });\n\n  it('externalizes nested bare package imports that only resolve from a bundled package', async () => {\n    const outdir = join(testRoot, 'out');\n    const srcDir = join(testRoot, 'src');\n    const stepFile = join(srcDir, 'step.ts');\n    const parentPkgDir = join(testRoot, 'node_modules', 'parent-pkg');\n    const parentPkgIndex = join(parentPkgDir, 'index.js');\n    const nativePkgDir = join(parentPkgDir, 'node_modules', 'optional-native');\n\n    writeFile(\n      join(parentPkgDir, 'package.json'),\n      JSON.stringify({ name: 'parent-pkg', main: 'index.js' })\n    );\n    writeFile(\n      parentPkgIndex,\n      `const native = require('optional-native');\\nexports.value = native.value;`\n    );\n    writeFile(\n      join(nativePkgDir, 'package.json'),\n      JSON.stringify({ name: 'optional-native', main: 'binding.node' })\n    );\n    writeFile(join(nativePkgDir, 'binding.node'), '');\n    writeFile(\n      stepFile,\n      `import { value } from 'parent-pkg';\\nconsole.log(value);`\n    );\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile, parentPkgIndex],\n          outdir,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    expect(output).toContain('optional-native');\n    expect(output).not.toContain('binding.node');\n  });\n\n  it.each([\n    '.ts',\n    '.tsx',\n    '.mts',\n    '.cts',\n  ])('preserves externalized %s extensions by default', async (inputExt) => {\n    const outdir = join(testRoot, 'out');\n    const srcDir = join(testRoot, 'src');\n    const stepFile = join(srcDir, 'step.ts');\n\n    writeFile(join(srcDir, `dep${inputExt}`), 'export const dep = {};');\n    writeFile(stepFile, `import { dep } from './dep';\\nconsole.log(dep);`);\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    expect(output).toContain(`/dep${inputExt}`);\n  });\n\n  it('bundles transitive local TypeScript dependencies with extensionless imports', async () => {\n    const outdir = join(testRoot, 'out');\n    const stepFile = join(testRoot, 'server', 'workflows', 'my-workflow.ts');\n    const constantsFile = join(testRoot, 'shared', 'constants.ts');\n    const helpersFile = join(testRoot, 'shared', 'helpers.ts');\n\n    writeFile(helpersFile, `export const HELPER_VALUE = \"from-helper\";`);\n    writeFile(\n      constantsFile,\n      `import { HELPER_VALUE } from './helpers';\\nexport const CATEGORIES = [HELPER_VALUE];`\n    );\n    writeFile(\n      stepFile,\n      `import { CATEGORIES } from '../../shared/constants';\\nexport async function myStep() {\\n  'use step';\\n  return CATEGORIES[0];\\n}`\n    );\n\n    const state = {\n      discoveredSteps: new Set<string>(),\n      discoveredWorkflows: new Set<string>(),\n      discoveredSerdeFiles: new Set<string>(),\n    };\n    await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      resolveExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],\n      plugins: [createDiscoverEntriesPlugin(state, testRoot)],\n    });\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      resolveExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n          bundleTransitiveLocalStepDependencies: true,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    expect(output).toContain('from-helper');\n    expect(output).not.toMatch(/from\\s+[\"'][^\"']*shared\\/constants/);\n    expect(output).not.toMatch(/from\\s+[\"'][^\"']*shared\\/helpers/);\n  });\n\n  it('externalizes transitive local TypeScript dependencies by default', async () => {\n    const outdir = join(testRoot, 'out');\n    const stepFile = join(testRoot, 'server', 'workflows', 'my-workflow.ts');\n    const constantsFile = join(testRoot, 'shared', 'constants.ts');\n    const helpersFile = join(testRoot, 'shared', 'helpers.ts');\n\n    writeFile(helpersFile, `export const HELPER_VALUE = \"from-helper\";`);\n    writeFile(\n      constantsFile,\n      `import { HELPER_VALUE } from './helpers';\\nexport const CATEGORIES = [HELPER_VALUE];`\n    );\n    writeFile(\n      stepFile,\n      `import { CATEGORIES } from '../../shared/constants';\\nexport async function myStep() {\\n  'use step';\\n  return CATEGORIES[0];\\n}`\n    );\n\n    const state = {\n      discoveredSteps: new Set<string>(),\n      discoveredWorkflows: new Set<string>(),\n      discoveredSerdeFiles: new Set<string>(),\n    };\n    await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      resolveExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],\n      plugins: [createDiscoverEntriesPlugin(state, testRoot)],\n    });\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      resolveExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    expect(output).not.toContain('from-helper');\n    expect(output).toMatch(/from\\s+[\"'][^\"']*shared\\/constants\\.ts[\"']/);\n  });\n\n  it('keeps ordinary package dependencies external when reachable from a bundled step', async () => {\n    const outdir = join(testRoot, 'out');\n    const stepFile = join(testRoot, 'server', 'workflows', 'my-workflow.ts');\n    const pkgDir = join(testRoot, 'node_modules', 'plain-pkg');\n    const pkgIndex = join(pkgDir, 'index.js');\n\n    writeFile(\n      join(pkgDir, 'package.json'),\n      JSON.stringify({ name: 'plain-pkg', main: 'index.js' })\n    );\n    writeFile(pkgIndex, `export const value = \"from-package\";`);\n    writeFile(\n      stepFile,\n      `import { value } from 'plain-pkg';\\nexport async function myStep() {\\n  'use step';\\n  return value;\\n}`\n    );\n\n    const state = {\n      discoveredSteps: new Set<string>(),\n      discoveredWorkflows: new Set<string>(),\n      discoveredSerdeFiles: new Set<string>(),\n    };\n    await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [createDiscoverEntriesPlugin(state, testRoot)],\n    });\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile],\n          outdir,\n          bundleTransitiveLocalStepDependencies: true,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    expect(output).toMatch(/from\\s+[\"']plain-pkg[\"']/);\n    expect(output).not.toContain('from-package');\n  });\n\n  it('bundles package parents when they lead to discovered workflow-related entries', async () => {\n    const outdir = join(testRoot, 'out');\n    const stepFile = join(testRoot, 'server', 'workflows', 'my-workflow.ts');\n    const pkgDir = join(testRoot, 'node_modules', 'workflow-pkg');\n    const pkgIndex = join(pkgDir, 'index.js');\n    const pkgSerde = join(pkgDir, 'serde.js');\n\n    writeFile(\n      join(pkgDir, 'package.json'),\n      JSON.stringify({ name: 'workflow-pkg', main: 'index.js' })\n    );\n    writeFile(pkgSerde, `export const value = \"from-serde\";`);\n    writeFile(pkgIndex, `export { value } from './serde.js';`);\n    writeFile(\n      stepFile,\n      `import { value } from 'workflow-pkg';\\nexport async function myStep() {\\n  'use step';\\n  return value;\\n}`\n    );\n\n    const state = {\n      discoveredSteps: new Set<string>(),\n      discoveredWorkflows: new Set<string>(),\n      discoveredSerdeFiles: new Set<string>(),\n    };\n    await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [createDiscoverEntriesPlugin(state, testRoot)],\n    });\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile, pkgSerde],\n          outdir,\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    expect(output).toContain('from-serde');\n    expect(output).not.toMatch(/from\\s+[\"']workflow-pkg[\"']/);\n  });\n});\n\ndescribe('createSwcPlugin sideEffectEntries', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'workflow-swc-plugin-'));\n    applySwcTransformMock.mockReset();\n  });\n\n  afterEach(() => {\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  /**\n   * Helper: creates a fake node_modules package with `\"sideEffects\": false`\n   * in its package.json and a single entry file that exports a side-effectful\n   * registration call (simulating what the SWC transform produces).\n   */\n  function createSideEffectsFalsePackage(\n    packageName: string,\n    entryCode: string\n  ): string {\n    const pkgDir = join(testRoot, 'node_modules', packageName);\n    writeFile(\n      join(pkgDir, 'package.json'),\n      JSON.stringify({\n        name: packageName,\n        version: '1.0.0',\n        sideEffects: false,\n        main: 'index.js',\n      })\n    );\n    const entryPath = join(pkgDir, 'index.js');\n    writeFile(entryPath, entryCode);\n    return entryPath;\n  }\n\n  it('preserves bare imports of sideEffectEntries packages when bundling without entriesToBundle', async () => {\n    const sideEffectCode =\n      'globalThis.__registered = globalThis.__registered || [];\\nglobalThis.__registered.push(\"my-pkg\");';\n    const entryPath = createSideEffectsFalsePackage(\n      'my-side-effect-pkg',\n      sideEffectCode\n    );\n\n    // SWC mock: return the code unchanged (the side effects are already there)\n    applySwcTransformMock.mockImplementation(\n      async (_filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {},\n      })\n    );\n\n    const result = await esbuild.build({\n      stdin: {\n        contents: `import 'my-side-effect-pkg';`,\n        resolveDir: testRoot,\n        sourcefile: 'virtual-entry.js',\n        loader: 'js',\n      },\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'cjs',\n      platform: 'node',\n      write: false,\n      treeShaking: true,\n      logLevel: 'silent',\n      plugins: [\n        createSwcPlugin({\n          mode: 'workflow',\n          sideEffectEntries: [entryPath],\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    // The registration code should be present in the bundle\n    expect(output).toContain('__registered');\n  });\n\n  it('drops bare imports when sideEffectEntries is NOT provided for sideEffects:false packages', async () => {\n    const sideEffectCode =\n      'globalThis.__registered = globalThis.__registered || [];\\nglobalThis.__registered.push(\"my-pkg\");';\n    createSideEffectsFalsePackage('my-dropped-pkg', sideEffectCode);\n\n    applySwcTransformMock.mockImplementation(\n      async (_filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {},\n      })\n    );\n\n    const result = await esbuild.build({\n      stdin: {\n        contents: `import 'my-dropped-pkg';`,\n        resolveDir: testRoot,\n        sourcefile: 'virtual-entry.js',\n        loader: 'js',\n      },\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'cjs',\n      platform: 'node',\n      write: false,\n      treeShaking: true,\n      logLevel: 'silent',\n      plugins: [\n        createSwcPlugin({\n          mode: 'workflow',\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    // Without sideEffectEntries, esbuild drops the bare import\n    expect(output).not.toContain('__registered');\n  });\n\n  it('produces no warnings for sideEffectEntries packages', async () => {\n    const sideEffectCode =\n      'globalThis.__registered = globalThis.__registered || [];\\nglobalThis.__registered.push(\"warned-pkg\");';\n    const entryPath = createSideEffectsFalsePackage(\n      'my-warned-pkg',\n      sideEffectCode\n    );\n\n    applySwcTransformMock.mockImplementation(\n      async (_filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {},\n      })\n    );\n\n    const result = await esbuild.build({\n      stdin: {\n        contents: `import 'my-warned-pkg';`,\n        resolveDir: testRoot,\n        sourcefile: 'virtual-entry.js',\n        loader: 'js',\n      },\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'cjs',\n      platform: 'node',\n      write: false,\n      treeShaking: true,\n      plugins: [\n        createSwcPlugin({\n          mode: 'workflow',\n          sideEffectEntries: [entryPath],\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    // No \"ignored-bare-import\" warnings should be produced\n    const sideEffectWarnings = result.warnings.filter(\n      (w) => w.id === 'ignored-bare-import'\n    );\n    expect(sideEffectWarnings).toHaveLength(0);\n  });\n\n  it('preserves bare imports with entriesToBundle and sideEffectEntries together', async () => {\n    const sideEffectCode =\n      'globalThis.__registered = globalThis.__registered || [];\\nglobalThis.__registered.push(\"bundled-pkg\");';\n    const entryPath = createSideEffectsFalsePackage(\n      'my-bundled-pkg',\n      sideEffectCode\n    );\n\n    applySwcTransformMock.mockImplementation(\n      async (_filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {},\n      })\n    );\n\n    const outdir = join(testRoot, 'out');\n    const stepFile = join(testRoot, 'src', 'step.ts');\n    writeFile(\n      stepFile,\n      `import 'my-bundled-pkg';\\nexport const POST = () => {};`\n    );\n\n    const result = await esbuild.build({\n      entryPoints: [stepFile],\n      absWorkingDir: testRoot,\n      outdir,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      treeShaking: true,\n      logLevel: 'silent',\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: [stepFile, entryPath],\n          outdir,\n          sideEffectEntries: [entryPath],\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    // The registration code should be bundled in\n    expect(output).toContain('__registered');\n  });\n\n  it('preserves bare imports for local files with sideEffects:false in their parent package.json', async () => {\n    // Simulate a workspace package with sideEffects: false\n    const pkgDir = join(testRoot, 'packages', 'shared');\n    writeFile(\n      join(pkgDir, 'package.json'),\n      JSON.stringify({\n        name: '@myorg/shared',\n        version: '1.0.0',\n        sideEffects: false,\n        main: 'index.js',\n      })\n    );\n    const sharedEntry = join(pkgDir, 'index.js');\n    writeFile(sharedEntry, 'globalThis.__sharedRegistered = true;');\n\n    applySwcTransformMock.mockImplementation(\n      async (_filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {},\n      })\n    );\n\n    // Use a relative import to the local file (like the virtual entry does for local files)\n    const result = await esbuild.build({\n      stdin: {\n        contents: `import './packages/shared/index.js';`,\n        resolveDir: testRoot,\n        sourcefile: 'virtual-entry.js',\n        loader: 'js',\n      },\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'cjs',\n      platform: 'node',\n      write: false,\n      treeShaking: true,\n      logLevel: 'silent',\n      plugins: [\n        createSwcPlugin({\n          mode: 'workflow',\n          sideEffectEntries: [sharedEntry],\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    expect(output).toContain('__sharedRegistered');\n  });\n\n  it('does not override sideEffects for non-entry modules', async () => {\n    // Create two packages - one is a side-effect entry, one is not\n    const sideEffectCode = 'globalThis.__entryRegistered = true;';\n    const entryPath = createSideEffectsFalsePackage(\n      'entry-pkg',\n      sideEffectCode\n    );\n\n    const nonEntryCode = 'globalThis.__nonEntryRegistered = true;';\n    createSideEffectsFalsePackage('non-entry-pkg', nonEntryCode);\n\n    applySwcTransformMock.mockImplementation(\n      async (_filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {},\n      })\n    );\n\n    const result = await esbuild.build({\n      stdin: {\n        contents: `import 'entry-pkg';\\nimport 'non-entry-pkg';`,\n        resolveDir: testRoot,\n        sourcefile: 'virtual-entry.js',\n        loader: 'js',\n      },\n      absWorkingDir: testRoot,\n      bundle: true,\n      format: 'cjs',\n      platform: 'node',\n      write: false,\n      treeShaking: true,\n      logLevel: 'silent',\n      plugins: [\n        createSwcPlugin({\n          mode: 'workflow',\n          // Only entry-pkg is listed, non-entry-pkg is not\n          sideEffectEntries: [entryPath],\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    const output = result.outputFiles[0].text;\n    // entry-pkg should be preserved\n    expect(output).toContain('__entryRegistered');\n    // non-entry-pkg should be dropped (sideEffects: false is respected)\n    expect(output).not.toContain('__nonEntryRegistered');\n  });\n});\n\ndescribe('createSwcPlugin projectRoot', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'workflow-swc-plugin-'));\n    applySwcTransformMock.mockReset();\n    applySwcTransformMock.mockImplementation(\n      async (_filename: string, source: string) => ({\n        code: source,\n        workflowManifest: {},\n      })\n    );\n  });\n\n  afterEach(() => {\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  function setupFixture() {\n    const appRoot = join(testRoot, 'apps', 'chat');\n    const packageRoot = join(testRoot, 'packages', 'vade');\n    const workflowFile = join(\n      packageRoot,\n      'src',\n      'internal',\n      'message',\n      'workflow',\n      'handle-message.ts'\n    );\n\n    writeFile(\n      workflowFile,\n      `export async function handleMessageWorkflow(message) {\n  \"use workflow\";\n\n  return message;\n}\n`\n    );\n\n    return {\n      appRoot,\n      packageRoot,\n      workflowFile,\n    };\n  }\n\n  it('passes the explicit projectRoot through to applySwcTransform', async () => {\n    const fixture = setupFixture();\n\n    const result = await esbuild.build({\n      entryPoints: [fixture.workflowFile],\n      absWorkingDir: fixture.packageRoot,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'workflow',\n          projectRoot: fixture.appRoot,\n          workflowManifest: {},\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    expect(applySwcTransformMock).toHaveBeenCalledWith(\n      'src/internal/message/workflow/handle-message.ts',\n      expect.stringContaining('\"use workflow\"'),\n      'workflow',\n      fixture.workflowFile,\n      fixture.appRoot,\n      fixture.appRoot\n    );\n  });\n\n  it('passes an explicit moduleSpecifierRoot separately from projectRoot', async () => {\n    const fixture = setupFixture();\n    const tracingRoot = testRoot;\n\n    const result = await esbuild.build({\n      entryPoints: [fixture.workflowFile],\n      absWorkingDir: fixture.packageRoot,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'workflow',\n          projectRoot: tracingRoot,\n          moduleSpecifierRoot: fixture.appRoot,\n          workflowManifest: {},\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    expect(applySwcTransformMock).toHaveBeenCalledWith(\n      'src/internal/message/workflow/handle-message.ts',\n      expect.stringContaining('\"use workflow\"'),\n      'workflow',\n      fixture.workflowFile,\n      tracingRoot,\n      fixture.appRoot\n    );\n  });\n\n  it('defaults the transform projectRoot to absWorkingDir', async () => {\n    const fixture = setupFixture();\n\n    const result = await esbuild.build({\n      entryPoints: [fixture.workflowFile],\n      absWorkingDir: fixture.packageRoot,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      write: false,\n      plugins: [\n        createSwcPlugin({\n          mode: 'workflow',\n          workflowManifest: {},\n        }),\n      ],\n    });\n\n    expect(result.errors).toHaveLength(0);\n    expect(applySwcTransformMock).toHaveBeenCalledWith(\n      'src/internal/message/workflow/handle-message.ts',\n      expect.stringContaining('\"use workflow\"'),\n      'workflow',\n      fixture.workflowFile,\n      fixture.packageRoot,\n      fixture.packageRoot\n    );\n  });\n});\n"]}