@workflow/builders 5.0.0-beta.1 → 5.0.0-beta.10

package/dist/resolve-sourcemap.test.js

@@ -0,0 +1,126 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { BaseBuilder } from './base-builder.js';
+/**
+ * Minimal subclass that exposes the protected `resolveSourcemap()` and
+ * `sourcemapsEnabled` members for testing.
+ */
+class TestBuilder extends BaseBuilder {
+    async build() {
+        // no-op
+    }
+    callResolveSourcemap(defaultMode) {
+        return this.resolveSourcemap(defaultMode);
+    }
+    get publicSourcemapsEnabled() {
+        return this.sourcemapsEnabled;
+    }
+}
+function createBuilder(sourcemap) {
+    const config = {
+        buildTarget: 'standalone',
+        workingDir: '/tmp/workflow-test',
+        dirs: ['.'],
+        stepsBundlePath: '',
+        workflowsBundlePath: '',
+        webhookBundlePath: '',
+        sourcemap,
+    };
+    return new TestBuilder(config);
+}
+describe('resolveSourcemap', () => {
+    const originalEnv = process.env.WORKFLOW_SOURCEMAP;
+    beforeEach(() => {
+        delete process.env.WORKFLOW_SOURCEMAP;
+    });
+    afterEach(() => {
+        if (originalEnv === undefined) {
+            delete process.env.WORKFLOW_SOURCEMAP;
+        }
+        else {
+            process.env.WORKFLOW_SOURCEMAP = originalEnv;
+        }
+    });
+    it('returns the default when no config or env var is set', () => {
+        const builder = createBuilder();
+        expect(builder.callResolveSourcemap('inline')).toBe('inline');
+        expect(builder.callResolveSourcemap(false)).toBe(false);
+        expect(builder.callResolveSourcemap(true)).toBe(true);
+    });
+    it('prefers explicit config over the default', () => {
+        expect(createBuilder(false).callResolveSourcemap('inline')).toBe(false);
+        expect(createBuilder('external').callResolveSourcemap('inline')).toBe('external');
+        expect(createBuilder('linked').callResolveSourcemap(false)).toBe('linked');
+        expect(createBuilder(true).callResolveSourcemap('inline')).toBe(true);
+    });
+    it('prefers explicit config over environment variable', () => {
+        process.env.WORKFLOW_SOURCEMAP = 'inline';
+        expect(createBuilder(false).callResolveSourcemap('inline')).toBe(false);
+        expect(createBuilder('external').callResolveSourcemap('inline')).toBe('external');
+    });
+    it('uses environment variable when config is not set', () => {
+        process.env.WORKFLOW_SOURCEMAP = 'false';
+        expect(createBuilder().callResolveSourcemap('inline')).toBe(false);
+        process.env.WORKFLOW_SOURCEMAP = 'true';
+        expect(createBuilder().callResolveSourcemap(false)).toBe(true);
+        for (const mode of ['inline', 'linked', 'external', 'both']) {
+            process.env.WORKFLOW_SOURCEMAP = mode;
+            expect(createBuilder().callResolveSourcemap('inline')).toBe(mode);
+        }
+    });
+    it('accepts "0" / "1" as environment variable aliases for false / true', () => {
+        process.env.WORKFLOW_SOURCEMAP = '0';
+        expect(createBuilder().callResolveSourcemap('inline')).toBe(false);
+        process.env.WORKFLOW_SOURCEMAP = '1';
+        expect(createBuilder().callResolveSourcemap(false)).toBe(true);
+    });
+    it('falls back to default when env var is empty or unrecognized', () => {
+        process.env.WORKFLOW_SOURCEMAP = '';
+        expect(createBuilder().callResolveSourcemap('inline')).toBe('inline');
+        // Suppress the expected warning
+        const originalWarn = console.warn;
+        console.warn = () => { };
+        try {
+            process.env.WORKFLOW_SOURCEMAP = 'nonsense';
+            expect(createBuilder().callResolveSourcemap('inline')).toBe('inline');
+        }
+        finally {
+            console.warn = originalWarn;
+        }
+    });
+});
+describe('sourcemapsEnabled', () => {
+    const originalEnv = process.env.WORKFLOW_SOURCEMAP;
+    beforeEach(() => {
+        delete process.env.WORKFLOW_SOURCEMAP;
+    });
+    afterEach(() => {
+        if (originalEnv === undefined) {
+            delete process.env.WORKFLOW_SOURCEMAP;
+        }
+        else {
+            process.env.WORKFLOW_SOURCEMAP = originalEnv;
+        }
+    });
+    it('is true by default', () => {
+        expect(createBuilder().publicSourcemapsEnabled).toBe(true);
+    });
+    it('is false when config sourcemap is false', () => {
+        expect(createBuilder(false).publicSourcemapsEnabled).toBe(false);
+    });
+    it('is true for any non-false config value', () => {
+        for (const mode of [
+            true,
+            'inline',
+            'linked',
+            'external',
+            'both',
+        ]) {
+            expect(createBuilder(mode).publicSourcemapsEnabled).toBe(true);
+        }
+    });
+    it('is false when WORKFLOW_SOURCEMAP env is false', () => {
+        process.env.WORKFLOW_SOURCEMAP = 'false';
+        expect(createBuilder().publicSourcemapsEnabled).toBe(false);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve-sourcemap.test.js","sourceRoot":"","sources":["../src/resolve-sourcemap.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { afterEach, beforeEach, describe, expect, it } from 'vitest';\nimport { BaseBuilder } from './base-builder.js';\nimport type { SourcemapMode, StandaloneConfig } from './types.js';\n\n/**\n * Minimal subclass that exposes the protected `resolveSourcemap()` and\n * `sourcemapsEnabled` members for testing.\n */\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    // no-op\n  }\n\n  public callResolveSourcemap(defaultMode: SourcemapMode): SourcemapMode {\n    return this.resolveSourcemap(defaultMode);\n  }\n\n  public get publicSourcemapsEnabled(): boolean {\n    return this.sourcemapsEnabled;\n  }\n}\n\nfunction createBuilder(sourcemap?: SourcemapMode): TestBuilder {\n  const config: StandaloneConfig = {\n    buildTarget: 'standalone',\n    workingDir: '/tmp/workflow-test',\n    dirs: ['.'],\n    stepsBundlePath: '',\n    workflowsBundlePath: '',\n    webhookBundlePath: '',\n    sourcemap,\n  };\n  return new TestBuilder(config);\n}\n\ndescribe('resolveSourcemap', () => {\n  const originalEnv = process.env.WORKFLOW_SOURCEMAP;\n\n  beforeEach(() => {\n    delete process.env.WORKFLOW_SOURCEMAP;\n  });\n\n  afterEach(() => {\n    if (originalEnv === undefined) {\n      delete process.env.WORKFLOW_SOURCEMAP;\n    } else {\n      process.env.WORKFLOW_SOURCEMAP = originalEnv;\n    }\n  });\n\n  it('returns the default when no config or env var is set', () => {\n    const builder = createBuilder();\n    expect(builder.callResolveSourcemap('inline')).toBe('inline');\n    expect(builder.callResolveSourcemap(false)).toBe(false);\n    expect(builder.callResolveSourcemap(true)).toBe(true);\n  });\n\n  it('prefers explicit config over the default', () => {\n    expect(createBuilder(false).callResolveSourcemap('inline')).toBe(false);\n    expect(createBuilder('external').callResolveSourcemap('inline')).toBe(\n      'external'\n    );\n    expect(createBuilder('linked').callResolveSourcemap(false)).toBe('linked');\n    expect(createBuilder(true).callResolveSourcemap('inline')).toBe(true);\n  });\n\n  it('prefers explicit config over environment variable', () => {\n    process.env.WORKFLOW_SOURCEMAP = 'inline';\n    expect(createBuilder(false).callResolveSourcemap('inline')).toBe(false);\n    expect(createBuilder('external').callResolveSourcemap('inline')).toBe(\n      'external'\n    );\n  });\n\n  it('uses environment variable when config is not set', () => {\n    process.env.WORKFLOW_SOURCEMAP = 'false';\n    expect(createBuilder().callResolveSourcemap('inline')).toBe(false);\n\n    process.env.WORKFLOW_SOURCEMAP = 'true';\n    expect(createBuilder().callResolveSourcemap(false)).toBe(true);\n\n    for (const mode of ['inline', 'linked', 'external', 'both'] as const) {\n      process.env.WORKFLOW_SOURCEMAP = mode;\n      expect(createBuilder().callResolveSourcemap('inline')).toBe(mode);\n    }\n  });\n\n  it('accepts \"0\" / \"1\" as environment variable aliases for false / true', () => {\n    process.env.WORKFLOW_SOURCEMAP = '0';\n    expect(createBuilder().callResolveSourcemap('inline')).toBe(false);\n\n    process.env.WORKFLOW_SOURCEMAP = '1';\n    expect(createBuilder().callResolveSourcemap(false)).toBe(true);\n  });\n\n  it('falls back to default when env var is empty or unrecognized', () => {\n    process.env.WORKFLOW_SOURCEMAP = '';\n    expect(createBuilder().callResolveSourcemap('inline')).toBe('inline');\n\n    // Suppress the expected warning\n    const originalWarn = console.warn;\n    console.warn = () => {};\n    try {\n      process.env.WORKFLOW_SOURCEMAP = 'nonsense';\n      expect(createBuilder().callResolveSourcemap('inline')).toBe('inline');\n    } finally {\n      console.warn = originalWarn;\n    }\n  });\n});\n\ndescribe('sourcemapsEnabled', () => {\n  const originalEnv = process.env.WORKFLOW_SOURCEMAP;\n\n  beforeEach(() => {\n    delete process.env.WORKFLOW_SOURCEMAP;\n  });\n\n  afterEach(() => {\n    if (originalEnv === undefined) {\n      delete process.env.WORKFLOW_SOURCEMAP;\n    } else {\n      process.env.WORKFLOW_SOURCEMAP = originalEnv;\n    }\n  });\n\n  it('is true by default', () => {\n    expect(createBuilder().publicSourcemapsEnabled).toBe(true);\n  });\n\n  it('is false when config sourcemap is false', () => {\n    expect(createBuilder(false).publicSourcemapsEnabled).toBe(false);\n  });\n\n  it('is true for any non-false config value', () => {\n    for (const mode of [\n      true,\n      'inline',\n      'linked',\n      'external',\n      'both',\n    ] as const) {\n      expect(createBuilder(mode).publicSourcemapsEnabled).toBe(true);\n    }\n  });\n\n  it('is false when WORKFLOW_SOURCEMAP env is false', () => {\n    process.env.WORKFLOW_SOURCEMAP = 'false';\n    expect(createBuilder().publicSourcemapsEnabled).toBe(false);\n  });\n});\n"]}

package/dist/serde-checker.js

@@ -115,4 +115,4 @@ export function extractClassEntries(manifest) {
     }
     return entries;
 }
-//# sourceMappingURL=serde-checker.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serde-checker.js","sourceRoot":"","sources":["../src/serde-checker.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Serde compliance checker for workflow custom class serialization.\n *\n * Analyzes source code to determine if classes with WORKFLOW_SERIALIZE /\n * WORKFLOW_DESERIALIZE are correctly set up for the workflow sandbox.\n *\n * Used by:\n * - CLI `validate` command\n * - CLI `transform` command (--check-serde)\n * - SWC playground serde analysis panel\n * - Build-time warnings in BaseBuilder\n */\n\nimport builtinModules from 'builtin-modules';\nimport type { WorkflowManifest } from './apply-swc-transform.js';\n\n// Build a regex that matches Node.js built-in module imports in transformed code.\n// Handles both ESM (`from 'fs'`, `from 'node:fs'`) and CJS (`require('fs')`)\nconst nodeBuiltins = builtinModules.join('|');\n\n// Regex to extract specific module names from import/require statements\nconst nodeImportExtractRegex = new RegExp(\n  `(?:from\\\\s+['\"](?:node:)?((?:${nodeBuiltins})(?:/[^'\"]*)?)['\"]` +\n    `|require\\\\s*\\\\(\\\\s*['\"](?:node:)?((?:${nodeBuiltins})(?:/[^'\"]*)?)['\"]\\\\s*\\\\))`,\n  'g'\n);\n\n// Regex to detect class registration IIFEs generated by the SWC plugin\nconst registrationIifeRegex =\n  /Symbol\\.for\\s*\\(\\s*[\"']workflow-class-registry[\"']\\s*\\)/;\n\n/**\n * Result of checking a single class for serde compliance.\n */\nexport interface SerdeClassCheckResult {\n  /** The class name as detected in the source */\n  className: string;\n  /** The classId assigned by the SWC plugin (from the manifest) */\n  classId: string;\n  /** Whether the SWC plugin detected serde symbols on this class */\n  detected: boolean;\n  /** Whether a registration IIFE was generated in the output */\n  registered: boolean;\n  /**\n   * Node.js built-in module imports remaining in the workflow-mode output.\n   * If non-empty, the class is NOT workflow-sandbox compliant.\n   */\n  nodeImports: string[];\n  /** Whether the class passes all compliance checks */\n  compliant: boolean;\n  /** Human-readable descriptions of any issues found */\n  issues: string[];\n}\n\n/**\n * Full result of serde compliance analysis for a source file.\n */\nexport interface SerdeCheckResult {\n  /** Per-class analysis results */\n  classes: SerdeClassCheckResult[];\n  /** All Node.js built-in imports found in the workflow-mode output */\n  globalNodeImports: string[];\n  /** Whether the workflow-mode output contains any serde-related classes */\n  hasSerdeClasses: boolean;\n  /** The raw workflow manifest extracted from the SWC transform */\n  manifest: WorkflowManifest;\n}\n\n/**\n * Lightweight serde compliance checker that works with pre-computed\n * SWC transform results. This avoids re-running the SWC transform\n * when the caller already has the outputs (e.g., the playground or builder).\n */\nexport function analyzeSerdeCompliance(options: {\n  /** Source code (used for pattern detection) */\n  sourceCode: string;\n  /** Workflow-mode transformed output */\n  workflowCode: string;\n  /** Manifest extracted from the SWC transform */\n  manifest: WorkflowManifest;\n}): SerdeCheckResult {\n  const { sourceCode, workflowCode, manifest } = options;\n\n  // 1. Extract all Node.js built-in imports from the workflow output\n  const globalNodeImports = extractNodeImports(workflowCode);\n\n  // 2. Check if the manifest contains any serde-registered classes\n  const classEntries = extractClassEntries(manifest);\n  const hasSerdeClasses = classEntries.length > 0;\n\n  // 3. Check if the workflow output contains registration IIFEs\n  const hasRegistration = registrationIifeRegex.test(workflowCode);\n\n  // 4. Analyze each class\n  const classes: SerdeClassCheckResult[] = classEntries.map((entry) => {\n    const issues: string[] = [];\n\n    // Check for Node.js imports (these will fail in the workflow sandbox)\n    if (globalNodeImports.length > 0) {\n      issues.push(\n        `Workflow bundle contains Node.js built-in imports: ${globalNodeImports.join(', ')}. ` +\n          `These will fail at runtime in the workflow sandbox. ` +\n          `Add \"use step\" to methods that depend on Node.js APIs so they are stripped from the workflow bundle.`\n      );\n    }\n\n    // Check for registration\n    if (!hasRegistration) {\n      issues.push(\n        `No class registration IIFE was generated. ` +\n          `Ensure WORKFLOW_SERIALIZE and WORKFLOW_DESERIALIZE are defined as static methods ` +\n          `inside the class body using computed property syntax: static [WORKFLOW_SERIALIZE](...) { ... }`\n      );\n    }\n\n    return {\n      className: entry.className,\n      classId: entry.classId,\n      detected: true,\n      registered: hasRegistration,\n      nodeImports: globalNodeImports,\n      compliant: globalNodeImports.length === 0 && hasRegistration,\n      issues,\n    };\n  });\n\n  // 5. Check for classes that have serde patterns in source but weren't detected by SWC\n  const sourceHasSerdePatterns =\n    /\\[\\s*WORKFLOW_(?:SERIALIZE|DESERIALIZE)\\s*\\]/.test(sourceCode) ||\n    /Symbol\\.for\\s*\\(\\s*['\"]workflow-(?:serialize|deserialize)['\"]\\s*\\)/.test(\n      sourceCode\n    );\n\n  if (sourceHasSerdePatterns && classEntries.length === 0) {\n    classes.push({\n      className: '<unknown>',\n      classId: '',\n      detected: false,\n      registered: false,\n      nodeImports: globalNodeImports,\n      compliant: false,\n      issues: [\n        `Source code contains WORKFLOW_SERIALIZE/WORKFLOW_DESERIALIZE patterns but ` +\n          `the SWC plugin did not detect any serde-enabled classes. ` +\n          `Ensure the symbols are defined as static methods INSIDE the class body, ` +\n          `not assigned externally (e.g., (MyClass as any)[WORKFLOW_SERIALIZE] = ...).`,\n      ],\n    });\n  }\n\n  return {\n    classes,\n    globalNodeImports,\n    hasSerdeClasses,\n    manifest,\n  };\n}\n\n/**\n * Extract Node.js built-in module names from transformed code.\n */\nfunction extractNodeImports(code: string): string[] {\n  const imports = new Set<string>();\n  // Reset regex state\n  nodeImportExtractRegex.lastIndex = 0;\n  for (\n    let match = nodeImportExtractRegex.exec(code);\n    match !== null;\n    match = nodeImportExtractRegex.exec(code)\n  ) {\n    // match[1] is from the ESM pattern, match[2] is from the CJS pattern\n    const moduleName = match[1] || match[2];\n    if (moduleName) {\n      // Normalize to base module name (e.g., 'fs/promises' -> 'fs')\n      imports.add(moduleName.split('/')[0]);\n    }\n  }\n  return [...imports].sort();\n}\n\n/**\n * Extract class entries from a WorkflowManifest.\n */\nexport function extractClassEntries(\n  manifest: WorkflowManifest\n): Array<{ className: string; classId: string; fileName: string }> {\n  const entries: Array<{\n    className: string;\n    classId: string;\n    fileName: string;\n  }> = [];\n  if (!manifest.classes) return entries;\n\n  for (const [fileName, classes] of Object.entries(manifest.classes)) {\n    for (const [className, { classId }] of Object.entries(classes)) {\n      entries.push({ className, classId, fileName });\n    }\n  }\n  return entries;\n}\n"]}

package/dist/standalone.d.ts

@@ -3,9 +3,6 @@ import type { WorkflowConfig } from './types.js';
 export declare class StandaloneBuilder extends BaseBuilder {
     constructor(config: WorkflowConfig);
     build(): Promise<void>;
-    private mergeManifests;
-    private buildStepsBundle;
-    private buildWorkflowsBundle;
     private buildWebhookFunction;
 }
 //# sourceMappingURL=standalone.d.ts.map

package/dist/standalone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../src/standalone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,iBAAkB,SAAQ,WAAW;gBACpC,MAAM,EAAE,cAAc;IAO5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA+B5B,OAAO,CAAC,cAAc;YAuBR,gBAAgB;YAqBhB,oBAAoB;YA0BpB,oBAAoB;CAUnC"}
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../src/standalone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,iBAAkB,SAAQ,WAAW;gBACpC,MAAM,EAAE,cAAc;IAO5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAiCd,oBAAoB;CAUnC"}

package/dist/standalone.js

@@ -9,19 +9,19 @@ export class StandaloneBuilder extends BaseBuilder {
     async build() {
         const inputFiles = await this.getInputFiles();
         const tsconfigPath = await this.findTsConfigPath();
-        const options = {
+        const stepsBundlePath = this.resolvePath(this.config.stepsBundlePath);
+        const workflowBundlePath = this.resolvePath(this.config.workflowsBundlePath);
+        await this.ensureDirectory(stepsBundlePath);
+        await this.ensureDirectory(workflowBundlePath);
+        console.log('Creating combined bundle');
+        const { manifest } = await this.createCombinedBundle({
             inputFiles,
+            stepsOutfile: stepsBundlePath,
+            flowOutfile: workflowBundlePath,
             tsconfigPath,
-        };
-        const stepsManifest = await this.buildStepsBundle(options);
-        const workflowsManifest = await this.buildWorkflowsBundle(options);
+            bundleFinalOutput: true,
+        });
         await this.buildWebhookFunction();
-        // Merge manifests from both bundles
-        // Steps bundle discovers classes from default export conditions
-        // Workflow bundle discovers classes from 'workflow' export conditions
-        const manifest = this.mergeManifests(stepsManifest, workflowsManifest);
-        // Build unified manifest from workflow bundle
-        const workflowBundlePath = this.resolvePath(this.config.workflowsBundlePath);
         const manifestDir = this.resolvePath('.well-known/workflow/v1');
         await this.createManifest({
             workflowBundlePath,
@@ -30,35 +30,6 @@ export class StandaloneBuilder extends BaseBuilder {
         });
         await this.createClientLibrary();
     }
-    mergeManifests(stepsManifest, workflowsManifest) {
-        return {
-            steps: { ...stepsManifest.steps, ...workflowsManifest.steps },
-            workflows: { ...stepsManifest.workflows, ...workflowsManifest.workflows },
-            classes: { ...stepsManifest.classes, ...workflowsManifest.classes },
-        };
-    }
-    async buildStepsBundle({ inputFiles, tsconfigPath, }) {
-        console.log('Creating steps bundle at', this.config.stepsBundlePath);
-        const stepsBundlePath = this.resolvePath(this.config.stepsBundlePath);
-        await this.ensureDirectory(stepsBundlePath);
-        const { manifest } = await this.createStepsBundle({
-            outfile: stepsBundlePath,
-            inputFiles,
-            tsconfigPath,
-        });
-        return manifest;
-    }
-    async buildWorkflowsBundle({ inputFiles, tsconfigPath, }) {
-        console.log('Creating workflows bundle at', this.config.workflowsBundlePath);
-        const workflowBundlePath = this.resolvePath(this.config.workflowsBundlePath);
-        await this.ensureDirectory(workflowBundlePath);
-        const { manifest } = await this.createWorkflowsBundle({
-            outfile: workflowBundlePath,
-            inputFiles,
-            tsconfigPath,
-        });
-        return manifest;
-    }
     async buildWebhookFunction() {
         console.log('Creating webhook bundle at', this.config.webhookBundlePath);
         const webhookBundlePath = this.resolvePath(this.config.webhookBundlePath);
@@ -68,4 +39,4 @@ export class StandaloneBuilder extends BaseBuilder {
         });
     }
 }
-//# sourceMappingURL=standalone.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/swc-esbuild-plugin.d.ts

@@ -1,7 +1,7 @@
 import type { Plugin } from 'esbuild';
 import { type WorkflowManifest } from './apply-swc-transform.js';
 export interface SwcPluginOptions {
-    mode: 'step' | 'workflow' | 'client';
+    mode: 'step' | 'workflow';
     entriesToBundle?: string[];
     outdir?: string;
     projectRoot?: string;
@@ -18,6 +18,15 @@ export interface SwcPluginOptions {
      * breaks them because the .js file doesn't exist on disk.
      */
     rewriteTsExtensions?: boolean;
+    /**
+     * Bundle project-local files that are transitively imported by step entries.
+     *
+     * Keep this disabled when a downstream bundler consumes the generated step
+     * bundle because that bundler can resolve the externalized local imports.
+     * Enable it for direct runtime loading, where Node imports the generated step
+     * bundle from disk without a later bundling pass.
+     */
+    bundleTransitiveLocalStepDependencies?: boolean;
     /**
      * Absolute file paths of discovered workflow/step/serde entries whose
      * imports must be treated as side-effectful.

package/dist/swc-esbuild-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swc-esbuild-plugin.d.ts","sourceRoot":"","sources":["../src/swc-esbuild-plugin.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,0BAA0B,CAAC;AAOlC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAsCD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAgTjE"}
+{"version":3,"file":"swc-esbuild-plugin.d.ts","sourceRoot":"","sources":["../src/swc-esbuild-plugin.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,0BAA0B,CAAC;AAQlC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;OAOG;IACH,qCAAqC,CAAC,EAAE,OAAO,CAAC;IAChD;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AA0CD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAqWjE"}

package/dist/swc-esbuild-plugin.js

@@ -4,6 +4,7 @@ import { promisify } from 'node:util';
 import enhancedResolveOrig from 'enhanced-resolve';
 import { applySwcTransform, } from './apply-swc-transform.js';
 import { jsTsRegex, parentHasChild, } from './discover-entries-esbuild-plugin.js';
+import { resolveModuleSpecifier } from './module-specifier.js';
 import { resolveWorkflowAliasRelativePath } from './workflow-alias.js';
 const NODE_RESOLVE_OPTIONS = {
     dependencyType: 'commonjs',
@@ -39,6 +40,9 @@ const NODE_ESM_RESOLVE_OPTIONS = {
     dependencyType: 'esm',
     conditionNames: ['node', 'import'],
 };
+function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
 export function createSwcPlugin(options) {
     return {
         name: 'swc-workflow-plugin',
@@ -75,17 +79,33 @@ export function createSwcPlugin(options) {
                     const specifier = args.path;
                     const specifierIsPath = specifier.startsWith('.') || specifier.startsWith('/');
                     let resolvedPath;
-                    // Determines whether the external path should be relativized
-                    // (project-local file) or kept as a bare specifier (npm package).
-                    let shouldMakeRelative = specifierIsPath;
+                    // Path-style specifiers (./foo, ../foo, /abs/path) externalize as
+                    // relative paths from `outdir`. Bare specifiers (npm packages)
+                    // externalize as-is so Node can resolve them at runtime.
+                    const shouldMakeRelative = specifierIsPath;
                     if (specifierIsPath) {
                         resolvedPath = await enhancedResolve(args.resolveDir, specifier);
                     }
                     else {
                         // Resolve from project root so nested deps aren't externalized
                         resolvedPath = await enhancedResolve(build.initialOptions.absWorkingDir || process.cwd(), specifier).catch(() => undefined); // swallow so esbuild fallback below can try
-                        // Fall back to esbuild for aliases/tsconfig paths,
-                        // but only accept project-local results
+                        // Fall back to esbuild for aliases/tsconfig paths.
+                        //
+                        // If the specifier resolves to a project-local file via an
+                        // alias/path mapping (e.g. tsconfig `paths`, esbuild `alias`,
+                        // self-referencing package names like `@my-pkg/lib/foo`), we
+                        // bundle it inline rather than externalizing.
+                        //
+                        // Externalizing such files is unsafe: we'd emit a relative
+                        // import to the original source on disk, but that source can
+                        // contain further alias imports. At runtime, Node's ESM loader
+                        // doesn't know about tsconfig paths or build-time aliases, so
+                        // those transitive imports throw `ERR_MODULE_NOT_FOUND` /
+                        // `Package subpath ... is not defined by "exports"`.
+                        //
+                        // Bundling inline ensures alias-based imports are resolved at
+                        // build time (where the alias map is known) and the runtime
+                        // never sees an unresolvable specifier.
                         if (!resolvedPath) {
                             const esbuildResult = await build.resolve(specifier, {
                                 resolveDir: args.resolveDir,
@@ -99,15 +119,33 @@ export function createSwcPlugin(options) {
                                     .replace(/\\/g, '/')
                                     .includes('/node_modules/');
                             if (isProjectLocalFile) {
-                                resolvedPath = esbuildResult.path;
-                                shouldMakeRelative = true;
+                                // Let esbuild bundle this aliased project-local file inline
+                                // (return null to defer to esbuild's normal pipeline). The
+                                // SWC `onLoad` handler will still process it.
+                                return null;
+                            }
+                            else if (options.entriesToBundle &&
+                                esbuildResult.path?.endsWith('.node')) {
+                                return {
+                                    external: true,
+                                    path: specifier,
+                                };
                             }
                         }
                     }
                     if (!resolvedPath)
                         return null;
                     // Normalize to forward slashes for cross-platform comparison
-                    const normalizedResolvedPath = resolvedPath.replace(/\\/g, '/');
+                    const normalizedResolvedPath = normalizePath(resolvedPath);
+                    const workingDir = build.initialOptions.absWorkingDir || process.cwd();
+                    const projectRoot = options.projectRoot || workingDir;
+                    if (options.entriesToBundle &&
+                        normalizedResolvedPath.endsWith('.node')) {
+                        return {
+                            external: true,
+                            path: specifier,
+                        };
+                    }
                     // Check if this module is a discovered entry whose SWC-transformed
                     // code contains side effects (workflow/step/class registration).
                     // Override the package.json "sideEffects": false so esbuild does not
@@ -128,6 +166,17 @@ export function createSwcPlugin(options) {
                                 shouldBundle = true;
                                 break;
                             }
+                            // Bundle project-local source files that are imported by a
+                            // step/serde entry so direct runtime loaders do not see raw TS
+                            // extensionless imports. Keep package dependencies external
+                            // unless they are themselves in entriesToBundle or are parents
+                            // of a discovered workflow/step/serde file via the check above.
+                            if (options.bundleTransitiveLocalStepDependencies &&
+                                isProjectLocalFile(normalizedResolvedPath, projectRoot) &&
+                                parentHasChild(normalizedEntry, normalizedResolvedPath)) {
+                                shouldBundle = true;
+                                break;
+                            }
                         }
                         if (shouldBundle) {
                             // Let esbuild bundle this entry, but override sideEffects if needed.
@@ -275,4 +324,10 @@ export function createSwcPlugin(options) {
         },
     };
 }
-//# sourceMappingURL=swc-esbuild-plugin.js.map
+function isProjectLocalFile(filePath, projectRoot) {
+    if (normalizePath(filePath).includes('/node_modules/')) {
+        return false;
+    }
+    return (resolveModuleSpecifier(filePath, projectRoot).moduleSpecifier === undefined);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"swc-esbuild-plugin.js","sourceRoot":"","sources":["../src/swc-esbuild-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { relative } from 'node:path';\nimport { promisify } from 'node:util';\nimport enhancedResolveOrig from 'enhanced-resolve';\nimport type { Plugin } from 'esbuild';\nimport {\n  applySwcTransform,\n  type WorkflowManifest,\n} from './apply-swc-transform.js';\nimport {\n  jsTsRegex,\n  parentHasChild,\n} from './discover-entries-esbuild-plugin.js';\nimport { resolveModuleSpecifier } from './module-specifier.js';\nimport { resolveWorkflowAliasRelativePath } from './workflow-alias.js';\n\nexport interface SwcPluginOptions {\n  mode: 'step' | 'workflow';\n  entriesToBundle?: string[];\n  outdir?: string;\n  projectRoot?: string;\n  workflowManifest?: WorkflowManifest;\n  /**\n   * Rewrite TypeScript extensions (.ts, .tsx, .mts, .cts) to their JS\n   * equivalents (.js, .mjs, .cjs) in externalized import paths.\n   *\n   * Enable this when the output bundle is consumed directly by Node's native\n   * ESM loader (e.g. vitest), which cannot resolve .ts extensions.\n   *\n   * Leave disabled (default) when a downstream bundler (webpack, Vite, etc.)\n   * handles resolution — those tools resolve .ts natively and rewriting\n   * breaks them because the .js file doesn't exist on disk.\n   */\n  rewriteTsExtensions?: boolean;\n  /**\n   * Bundle project-local files that are transitively imported by step entries.\n   *\n   * Keep this disabled when a downstream bundler consumes the generated step\n   * bundle because that bundler can resolve the externalized local imports.\n   * Enable it for direct runtime loading, where Node imports the generated step\n   * bundle from disk without a later bundling pass.\n   */\n  bundleTransitiveLocalStepDependencies?: boolean;\n  /**\n   * Absolute file paths of discovered workflow/step/serde entries whose\n   * imports must be treated as side-effectful.\n   *\n   * The SWC compiler transform injects registration calls (workflow IDs,\n   * step IDs, class serialization, etc.) into these files. Without this\n   * override, esbuild honours `\"sideEffects\": false` from the package's\n   * `package.json` and silently drops bare imports of these modules.\n   */\n  sideEffectEntries?: string[];\n}\n\nconst NODE_RESOLVE_OPTIONS = {\n  dependencyType: 'commonjs',\n  modules: ['node_modules'],\n  exportsFields: ['exports'],\n  importsFields: ['imports'],\n  conditionNames: ['node', 'require'],\n  descriptionFiles: ['package.json'],\n  extensions: [\n    '.ts',\n    '.tsx',\n    '.mts',\n    '.cts',\n    '.cjs',\n    '.mjs',\n    '.js',\n    '.jsx',\n    '.json',\n    '.node',\n  ],\n  enforceExtensions: false,\n  symlinks: true,\n  mainFields: ['main'],\n  mainFiles: ['index'],\n  roots: [],\n  fullySpecified: false,\n  preferRelative: false,\n  preferAbsolute: false,\n  restrictions: [],\n};\n\nconst NODE_ESM_RESOLVE_OPTIONS = {\n  ...NODE_RESOLVE_OPTIONS,\n  dependencyType: 'esm',\n  conditionNames: ['node', 'import'],\n};\n\nfunction normalizePath(path: string): string {\n  return path.replace(/\\\\/g, '/');\n}\n\nexport function createSwcPlugin(options: SwcPluginOptions): Plugin {\n  return {\n    name: 'swc-workflow-plugin',\n    setup(build) {\n      // everything is external unless explicitly configured\n      // to be bundled\n      const cjsResolver = promisify(\n        enhancedResolveOrig.create(NODE_RESOLVE_OPTIONS)\n      );\n      const esmResolver = promisify(\n        enhancedResolveOrig.create(NODE_ESM_RESOLVE_OPTIONS)\n      );\n\n      const enhancedResolve = async (context: string, path: string) => {\n        try {\n          return await esmResolver(context, path);\n        } catch (_) {\n          return cjsResolver(context, path);\n        }\n      };\n\n      // Pre-compute the normalized side-effect entries set for O(1) lookups.\n      const normalizedSideEffectEntries = new Set(\n        options.sideEffectEntries?.map((e) => e.replace(/\\\\/g, '/'))\n      );\n\n      build.onResolve({ filter: /.*/ }, async (args) => {\n        if (args.pluginData?.skipSwcPlugin) return null;\n\n        if (\n          !options.entriesToBundle &&\n          normalizedSideEffectEntries.size === 0\n        ) {\n          return null;\n        }\n\n        // When only sideEffectEntries is set (no entriesToBundle), we only\n        // need to override sideEffects for top-level bare imports — typically\n        // from the virtual entry. Skip resolution for transitive imports\n        // (dynamic imports, requires, etc.) to avoid unnecessary overhead.\n        if (!options.entriesToBundle && args.kind !== 'import-statement') {\n          return null;\n        }\n\n        try {\n          const specifier = args.path;\n          const specifierIsPath =\n            specifier.startsWith('.') || specifier.startsWith('/');\n\n          let resolvedPath: string | false | undefined;\n          // Path-style specifiers (./foo, ../foo, /abs/path) externalize as\n          // relative paths from `outdir`. Bare specifiers (npm packages)\n          // externalize as-is so Node can resolve them at runtime.\n          const shouldMakeRelative = specifierIsPath;\n\n          if (specifierIsPath) {\n            resolvedPath = await enhancedResolve(args.resolveDir, specifier);\n          } else {\n            // Resolve from project root so nested deps aren't externalized\n            resolvedPath = await enhancedResolve(\n              build.initialOptions.absWorkingDir || process.cwd(),\n              specifier\n            ).catch(() => undefined); // swallow so esbuild fallback below can try\n\n            // Fall back to esbuild for aliases/tsconfig paths.\n            //\n            // If the specifier resolves to a project-local file via an\n            // alias/path mapping (e.g. tsconfig `paths`, esbuild `alias`,\n            // self-referencing package names like `@my-pkg/lib/foo`), we\n            // bundle it inline rather than externalizing.\n            //\n            // Externalizing such files is unsafe: we'd emit a relative\n            // import to the original source on disk, but that source can\n            // contain further alias imports. At runtime, Node's ESM loader\n            // doesn't know about tsconfig paths or build-time aliases, so\n            // those transitive imports throw `ERR_MODULE_NOT_FOUND` /\n            // `Package subpath ... is not defined by \"exports\"`.\n            //\n            // Bundling inline ensures alias-based imports are resolved at\n            // build time (where the alias map is known) and the runtime\n            // never sees an unresolvable specifier.\n            if (!resolvedPath) {\n              const esbuildResult = await build.resolve(specifier, {\n                resolveDir: args.resolveDir,\n                kind: args.kind,\n                pluginData: { skipSwcPlugin: true },\n              });\n              const didResolve =\n                !!esbuildResult.path && !esbuildResult.errors.length;\n              const isProjectLocalFile =\n                didResolve &&\n                !esbuildResult.external &&\n                !esbuildResult.path\n                  .replace(/\\\\/g, '/')\n                  .includes('/node_modules/');\n              if (isProjectLocalFile) {\n                // Let esbuild bundle this aliased project-local file inline\n                // (return null to defer to esbuild's normal pipeline). The\n                // SWC `onLoad` handler will still process it.\n                return null;\n              } else if (\n                options.entriesToBundle &&\n                esbuildResult.path?.endsWith('.node')\n              ) {\n                return {\n                  external: true,\n                  path: specifier,\n                };\n              }\n            }\n          }\n\n          if (!resolvedPath) return null;\n\n          // Normalize to forward slashes for cross-platform comparison\n          const normalizedResolvedPath = normalizePath(resolvedPath);\n          const workingDir =\n            build.initialOptions.absWorkingDir || process.cwd();\n          const projectRoot = options.projectRoot || workingDir;\n\n          if (\n            options.entriesToBundle &&\n            normalizedResolvedPath.endsWith('.node')\n          ) {\n            return {\n              external: true,\n              path: specifier,\n            };\n          }\n\n          // Check if this module is a discovered entry whose SWC-transformed\n          // code contains side effects (workflow/step/class registration).\n          // Override the package.json \"sideEffects\": false so esbuild does not\n          // drop bare imports of these modules.\n          const hasSideEffects = normalizedSideEffectEntries.has(\n            normalizedResolvedPath\n          );\n\n          if (options.entriesToBundle) {\n            let shouldBundle = false;\n            for (const entryToBundle of options.entriesToBundle) {\n              const normalizedEntry = entryToBundle.replace(/\\\\/g, '/');\n\n              if (normalizedResolvedPath === normalizedEntry) {\n                shouldBundle = true;\n                break;\n              }\n\n              // if the current entry imports a child that needs\n              // to be bundled then it needs to also be bundled so\n              // that the child can have our transform applied\n              if (parentHasChild(normalizedResolvedPath, normalizedEntry)) {\n                shouldBundle = true;\n                break;\n              }\n\n              // Bundle project-local source files that are imported by a\n              // step/serde entry so direct runtime loaders do not see raw TS\n              // extensionless imports. Keep package dependencies external\n              // unless they are themselves in entriesToBundle or are parents\n              // of a discovered workflow/step/serde file via the check above.\n              if (\n                options.bundleTransitiveLocalStepDependencies &&\n                isProjectLocalFile(normalizedResolvedPath, projectRoot) &&\n                parentHasChild(normalizedEntry, normalizedResolvedPath)\n              ) {\n                shouldBundle = true;\n                break;\n              }\n            }\n\n            if (shouldBundle) {\n              // Let esbuild bundle this entry, but override sideEffects if needed.\n              // We must return the resolved `path` alongside `sideEffects` because\n              // returning only `{ sideEffects: true }` without a path causes esbuild\n              // to fall through to its own resolver, which re-reads the package.json\n              // and applies `\"sideEffects\": false` from there.\n              return hasSideEffects\n                ? { path: resolvedPath, sideEffects: true }\n                : null;\n            }\n\n            let externalPath: string;\n            if (shouldMakeRelative) {\n              // When the resolved file lives inside node_modules, let\n              // esbuild bundle it rather than externalizing with a deeply\n              // nested relative path. Downstream bundlers (Rollup/Vite)\n              // can't rewrite opaque `__require()` calls in CJS shims, so\n              // relative paths computed for `outdir` break once the output\n              // is rebundled to a different directory.\n              if (normalizedResolvedPath.includes('/node_modules/')) {\n                return null; // let esbuild bundle it\n              }\n\n              externalPath = relative(\n                options.outdir || process.cwd(),\n                resolvedPath\n              ).replace(/\\\\/g, '/');\n\n              if (options.rewriteTsExtensions) {\n                // Rewrite TypeScript extensions to their JS equivalents so the\n                // externalized import is loadable by Node's native ESM loader.\n                externalPath = externalPath\n                  .replace(/\\.tsx?$/, '.js')\n                  .replace(/\\.mts$/, '.mjs')\n                  .replace(/\\.cts$/, '.cjs');\n              }\n            } else {\n              externalPath = specifier;\n            }\n\n            return {\n              external: true,\n              path: externalPath,\n              sideEffects: hasSideEffects || undefined,\n            };\n          }\n\n          // No entriesToBundle — only override sideEffects when needed.\n          // We must return the resolved `path` alongside `sideEffects` because\n          // returning only `{ sideEffects: true }` without a path causes esbuild\n          // to fall through to its own resolver, which re-reads the package.json\n          // and applies `\"sideEffects\": false` from there.\n          return hasSideEffects\n            ? { path: resolvedPath, sideEffects: true }\n            : null;\n        } catch (_) {}\n        return null;\n      });\n\n      // Handle TypeScript and JavaScript files\n      build.onLoad({ filter: jsTsRegex }, async (args) => {\n        // Determine if this is a TypeScript file\n        try {\n          // Determine the loader based on the output\n          let loader: 'js' | 'jsx' | 'tsx' = 'js';\n          if (args.path.endsWith('.jsx')) {\n            loader = 'jsx';\n          } else if (args.path.endsWith('.tsx')) {\n            loader = 'tsx';\n          }\n          const source = await readFile(args.path, 'utf8');\n          const normalizedSource = source\n            .replace(/require\\(\\s*(['\"])server-only\\1\\s*\\)/g, 'void 0')\n            .replace(/require\\(\\s*(['\"])client-only\\1\\s*\\)/g, 'void 0');\n\n          // Calculate relative path for SWC plugin\n          // The filename parameter is used to generate workflowId/stepId, so it must be relative\n          const workingDir =\n            build.initialOptions.absWorkingDir || process.cwd();\n          const projectRoot = options.projectRoot || workingDir;\n          // Normalize paths: convert backslashes to forward slashes and remove trailing slashes\n          const normalizedWorkingDir = workingDir\n            .replace(/\\\\/g, '/')\n            .replace(/\\/$/, '');\n          const normalizedPath = args.path.replace(/\\\\/g, '/');\n\n          // Windows fix: Always do case-insensitive path comparison as the PRIMARY logic\n          // to work around node:path.relative() not recognizing paths with different drive\n          // letter casing (e.g., D: vs d:) as being in the same tree\n          const lowerWd = normalizedWorkingDir.toLowerCase();\n          const lowerPath = normalizedPath.toLowerCase();\n\n          let relativeFilepath: string;\n          if (lowerPath.startsWith(lowerWd + '/')) {\n            // File is under working directory - manually calculate relative path\n            // This ensures we get a relative path even with drive letter casing issues\n            relativeFilepath = normalizedPath.substring(\n              normalizedWorkingDir.length + 1\n            );\n          } else if (lowerPath === lowerWd) {\n            // File IS the working directory\n            relativeFilepath = '.';\n          } else {\n            // File is outside working directory - use relative() and strip ../ prefixes if needed\n            relativeFilepath = relative(\n              normalizedWorkingDir,\n              normalizedPath\n            ).replace(/\\\\/g, '/');\n\n            // Handle files discovered outside the working directory\n            // These come back as ../path/to/file, but we want just path/to/file\n            if (relativeFilepath.startsWith('../')) {\n              const aliasedRelativePath =\n                await resolveWorkflowAliasRelativePath(args.path, workingDir);\n              if (aliasedRelativePath) {\n                relativeFilepath = aliasedRelativePath;\n              } else {\n                relativeFilepath = relativeFilepath\n                  .split('/')\n                  .filter((part) => part !== '..')\n                  .join('/');\n              }\n            }\n          }\n\n          // Final safety check - ensure we never pass an absolute path to SWC\n          if (\n            relativeFilepath.includes(':') ||\n            relativeFilepath.startsWith('/')\n          ) {\n            // This should never happen, but if it does, use just the filename as last resort\n            console.error(\n              `[ERROR] relativeFilepath is still absolute: ${relativeFilepath}`\n            );\n            relativeFilepath = normalizedPath.split('/').pop() || 'unknown.ts';\n          }\n\n          const { code: transformedCode, workflowManifest } =\n            await applySwcTransform(\n              relativeFilepath,\n              normalizedSource,\n              options.mode,\n              args.path, // Pass absolute path for module specifier resolution\n              projectRoot\n            );\n\n          if (!options.workflowManifest) {\n            options.workflowManifest = {};\n          }\n\n          options.workflowManifest.workflows = Object.assign(\n            options.workflowManifest.workflows || {},\n            workflowManifest.workflows\n          );\n          options.workflowManifest.steps = Object.assign(\n            options.workflowManifest.steps || {},\n            workflowManifest.steps\n          );\n          options.workflowManifest.classes = Object.assign(\n            options.workflowManifest.classes || {},\n            workflowManifest.classes\n          );\n\n          return {\n            contents: transformedCode,\n            loader,\n          };\n        } catch (error) {\n          const errorMessage =\n            error instanceof Error ? error.message : String(error);\n          console.error(\n            `❌ SWC transform error in ${args.path}:`,\n            errorMessage\n          );\n          return {\n            errors: [\n              {\n                text: `SWC transform failed: ${errorMessage}`,\n                location: { file: args.path, line: 0, column: 0 },\n              },\n            ],\n          };\n        }\n      });\n    },\n  };\n}\n\nfunction isProjectLocalFile(filePath: string, projectRoot: string): boolean {\n  if (normalizePath(filePath).includes('/node_modules/')) {\n    return false;\n  }\n\n  return (\n    resolveModuleSpecifier(filePath, projectRoot).moduleSpecifier === undefined\n  );\n}\n"]}