@workflow/builders 5.0.0-beta.2 → 5.0.0-beta.20

package/dist/external-package-warning.test.js

@@ -0,0 +1,219 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { BaseBuilder } from './base-builder.js';
+/**
+ * Minimal subclass to expose the protected `discoverEntries()` for testing.
+ */
+class TestBuilder extends BaseBuilder {
+    async build() {
+        // no-op
+    }
+    // Expose for tests
+    discoverEntriesPublic(inputs, outdir) {
+        return this.discoverEntries(inputs, outdir);
+    }
+}
+// Resolve symlinks in tmpdir to avoid macOS /var -> /private/var issues
+const realTmpdir = realpathSync(tmpdir());
+function writeFile(path, contents) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, contents, 'utf-8');
+}
+function createBuilder(workingDir, externalPackages) {
+    const config = {
+        buildTarget: 'standalone',
+        workingDir,
+        dirs: ['.'],
+        externalPackages,
+        stepsBundlePath: join(workingDir, 'steps.js'),
+        workflowsBundlePath: join(workingDir, 'workflows.js'),
+        webhookBundlePath: join(workingDir, 'webhook.js'),
+    };
+    return new TestBuilder(config);
+}
+describe('warnAboutExternalWorkflowPackages', () => {
+    let testRoot;
+    let warnSpy;
+    beforeEach(() => {
+        testRoot = mkdtempSync(join(realTmpdir, 'workflow-external-pkg-warning-'));
+        warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        warnSpy.mockRestore();
+        rmSync(testRoot, { recursive: true, force: true });
+    });
+    it('warns when an external package depends on @workflow/serde', async () => {
+        // Create a mock project with a node_modules package
+        const projectDir = join(testRoot, 'project');
+        // Create a minimal entry file for the project
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        // Create the external package with @workflow/serde dependency
+        writeFile(join(projectDir, 'node_modules', 'my-serde-pkg', 'package.json'), JSON.stringify({
+            name: 'my-serde-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+            dependencies: {
+                '@workflow/serde': '^1.0.0',
+            },
+        }));
+        writeFile(join(projectDir, 'node_modules', 'my-serde-pkg', 'index.js'), 'export class Foo {}');
+        const builder = createBuilder(projectDir, ['my-serde-pkg']);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).toHaveBeenCalled();
+        const warnMessage = warnSpy.mock.calls[0]?.[0];
+        expect(warnMessage).toContain('my-serde-pkg');
+        expect(warnMessage).toContain('serverExternalPackages');
+        expect(warnMessage).toContain('serialization classes');
+    });
+    it('warns when an external package source contains serde symbols', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        // Package without @workflow/serde dep but with Symbol.for patterns in source
+        writeFile(join(projectDir, 'node_modules', 'my-symbol-pkg', 'package.json'), JSON.stringify({
+            name: 'my-symbol-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+        }));
+        writeFile(join(projectDir, 'node_modules', 'my-symbol-pkg', 'index.js'), `export class Bar {
+  static [Symbol.for('workflow-serialize')](instance) { return {}; }
+  static [Symbol.for('workflow-deserialize')](data) { return new Bar(); }
+}`);
+        const builder = createBuilder(projectDir, ['my-symbol-pkg']);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).toHaveBeenCalled();
+        const warnMessage = warnSpy.mock.calls[0]?.[0];
+        expect(warnMessage).toContain('my-symbol-pkg');
+        expect(warnMessage).toContain('serialization classes');
+    });
+    it('warns when an external package contains "use step" directives', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        writeFile(join(projectDir, 'node_modules', 'my-step-pkg', 'package.json'), JSON.stringify({
+            name: 'my-step-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+        }));
+        writeFile(join(projectDir, 'node_modules', 'my-step-pkg', 'index.js'), `export async function doWork() {
+  "use step";
+  return 42;
+}`);
+        const builder = createBuilder(projectDir, ['my-step-pkg']);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).toHaveBeenCalled();
+        const warnMessage = warnSpy.mock.calls[0]?.[0];
+        expect(warnMessage).toContain('my-step-pkg');
+        expect(warnMessage).toContain('"use step" functions');
+    });
+    it('warns when an external package contains "use workflow" directives', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        writeFile(join(projectDir, 'node_modules', 'my-workflow-pkg', 'package.json'), JSON.stringify({
+            name: 'my-workflow-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+        }));
+        writeFile(join(projectDir, 'node_modules', 'my-workflow-pkg', 'index.js'), `export async function runJob() {
+  "use workflow";
+  return "done";
+}`);
+        const builder = createBuilder(projectDir, ['my-workflow-pkg']);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).toHaveBeenCalled();
+        const warnMessage = warnSpy.mock.calls[0]?.[0];
+        expect(warnMessage).toContain('my-workflow-pkg');
+        expect(warnMessage).toContain('"use workflow" functions');
+    });
+    it('does not warn for packages without workflow patterns', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        writeFile(join(projectDir, 'node_modules', 'plain-pkg', 'package.json'), JSON.stringify({
+            name: 'plain-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+        }));
+        writeFile(join(projectDir, 'node_modules', 'plain-pkg', 'index.js'), 'export const hello = "world";');
+        const builder = createBuilder(projectDir, ['plain-pkg']);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).not.toHaveBeenCalled();
+    });
+    it('does not warn for pseudo-packages (server-only, client-only)', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        const builder = createBuilder(projectDir, ['server-only', 'client-only']);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).not.toHaveBeenCalled();
+    });
+    it('does not warn when externalPackages is empty', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        const builder = createBuilder(projectDir, []);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).not.toHaveBeenCalled();
+    });
+    it('warns only once per package across multiple discoverEntries calls', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        writeFile(join(projectDir, 'other.ts'), 'export const y = 2;');
+        writeFile(join(projectDir, 'node_modules', 'my-serde-pkg', 'package.json'), JSON.stringify({
+            name: 'my-serde-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+            dependencies: { '@workflow/serde': '^1.0.0' },
+        }));
+        writeFile(join(projectDir, 'node_modules', 'my-serde-pkg', 'index.js'), 'export class Foo {}');
+        const builder = createBuilder(projectDir, ['my-serde-pkg']);
+        // Call discoverEntries twice with different inputs
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        await builder.discoverEntriesPublic([join(projectDir, 'other.ts')], join(projectDir, 'out2'));
+        // Should only warn once
+        const warnCalls = warnSpy.mock.calls.filter((call) => call[0].includes('my-serde-pkg'));
+        expect(warnCalls).toHaveLength(1);
+    });
+    it('lists multiple detected issues in the warning message', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        writeFile(join(projectDir, 'node_modules', 'multi-pkg', 'package.json'), JSON.stringify({
+            name: 'multi-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+            dependencies: { '@workflow/serde': '^1.0.0' },
+        }));
+        writeFile(join(projectDir, 'node_modules', 'multi-pkg', 'index.js'), `export async function doWork() {
+  "use step";
+  return 42;
+}
+export class Foo {
+  static [Symbol.for('workflow-serialize')](instance) { return {}; }
+  static [Symbol.for('workflow-deserialize')](data) { return new Foo(); }
+}`);
+        const builder = createBuilder(projectDir, ['multi-pkg']);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).toHaveBeenCalled();
+        const warnMessage = warnSpy.mock.calls[0]?.[0];
+        expect(warnMessage).toContain('"use step" functions');
+        expect(warnMessage).toContain('serialization classes');
+    });
+    it('warns via entry-file detection when package.json has no serde dep', async () => {
+        const projectDir = join(testRoot, 'project');
+        writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');
+        // Package without @workflow/serde in deps, but entry has "use step"
+        writeFile(join(projectDir, 'node_modules', 'no-serde-dep-pkg', 'package.json'), JSON.stringify({
+            name: 'no-serde-dep-pkg',
+            version: '1.0.0',
+            main: 'index.js',
+        }));
+        writeFile(join(projectDir, 'node_modules', 'no-serde-dep-pkg', 'index.js'), `export async function doWork() {
+  "use step";
+  return 42;
+}`);
+        const builder = createBuilder(projectDir, ['no-serde-dep-pkg']);
+        await builder.discoverEntriesPublic([join(projectDir, 'index.ts')], join(projectDir, 'out'));
+        expect(warnSpy).toHaveBeenCalled();
+        const warnMessage = warnSpy.mock.calls[0]?.[0];
+        expect(warnMessage).toContain('no-serde-dep-pkg');
+        expect(warnMessage).toContain('"use step" functions');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"external-package-warning.test.js","sourceRoot":"","sources":["../src/external-package-warning.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  mkdirSync,\n  mkdtempSync,\n  realpathSync,\n  rmSync,\n  writeFileSync,\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { dirname, join } from 'node:path';\nimport { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';\nimport { BaseBuilder, type DiscoveredEntries } from './base-builder.js';\nimport type { StandaloneConfig } from './types.js';\n\n/**\n * Minimal subclass to expose the protected `discoverEntries()` for testing.\n */\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    // no-op\n  }\n\n  // Expose for tests\n  public discoverEntriesPublic(\n    inputs: string[],\n    outdir: string\n  ): Promise<DiscoveredEntries> {\n    return this.discoverEntries(inputs, outdir);\n  }\n}\n\n// Resolve symlinks in tmpdir to avoid macOS /var -> /private/var issues\nconst realTmpdir = realpathSync(tmpdir());\n\nfunction writeFile(path: string, contents: string): void {\n  mkdirSync(dirname(path), { recursive: true });\n  writeFileSync(path, contents, 'utf-8');\n}\n\nfunction createBuilder(\n  workingDir: string,\n  externalPackages: string[]\n): TestBuilder {\n  const config: StandaloneConfig = {\n    buildTarget: 'standalone',\n    workingDir,\n    dirs: ['.'],\n    externalPackages,\n    stepsBundlePath: join(workingDir, 'steps.js'),\n    workflowsBundlePath: join(workingDir, 'workflows.js'),\n    webhookBundlePath: join(workingDir, 'webhook.js'),\n  };\n  return new TestBuilder(config);\n}\n\ndescribe('warnAboutExternalWorkflowPackages', () => {\n  let testRoot: string;\n  let warnSpy: ReturnType<typeof vi.spyOn>;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'workflow-external-pkg-warning-'));\n    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});\n  });\n\n  afterEach(() => {\n    warnSpy.mockRestore();\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('warns when an external package depends on @workflow/serde', async () => {\n    // Create a mock project with a node_modules package\n    const projectDir = join(testRoot, 'project');\n\n    // Create a minimal entry file for the project\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    // Create the external package with @workflow/serde dependency\n    writeFile(\n      join(projectDir, 'node_modules', 'my-serde-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'my-serde-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n        dependencies: {\n          '@workflow/serde': '^1.0.0',\n        },\n      })\n    );\n    writeFile(\n      join(projectDir, 'node_modules', 'my-serde-pkg', 'index.js'),\n      'export class Foo {}'\n    );\n\n    const builder = createBuilder(projectDir, ['my-serde-pkg']);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).toHaveBeenCalled();\n    const warnMessage = warnSpy.mock.calls[0]?.[0] as string;\n    expect(warnMessage).toContain('my-serde-pkg');\n    expect(warnMessage).toContain('serverExternalPackages');\n    expect(warnMessage).toContain('serialization classes');\n  });\n\n  it('warns when an external package source contains serde symbols', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    // Package without @workflow/serde dep but with Symbol.for patterns in source\n    writeFile(\n      join(projectDir, 'node_modules', 'my-symbol-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'my-symbol-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n      })\n    );\n    writeFile(\n      join(projectDir, 'node_modules', 'my-symbol-pkg', 'index.js'),\n      `export class Bar {\n  static [Symbol.for('workflow-serialize')](instance) { return {}; }\n  static [Symbol.for('workflow-deserialize')](data) { return new Bar(); }\n}`\n    );\n\n    const builder = createBuilder(projectDir, ['my-symbol-pkg']);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).toHaveBeenCalled();\n    const warnMessage = warnSpy.mock.calls[0]?.[0] as string;\n    expect(warnMessage).toContain('my-symbol-pkg');\n    expect(warnMessage).toContain('serialization classes');\n  });\n\n  it('warns when an external package contains \"use step\" directives', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    writeFile(\n      join(projectDir, 'node_modules', 'my-step-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'my-step-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n      })\n    );\n    writeFile(\n      join(projectDir, 'node_modules', 'my-step-pkg', 'index.js'),\n      `export async function doWork() {\n  \"use step\";\n  return 42;\n}`\n    );\n\n    const builder = createBuilder(projectDir, ['my-step-pkg']);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).toHaveBeenCalled();\n    const warnMessage = warnSpy.mock.calls[0]?.[0] as string;\n    expect(warnMessage).toContain('my-step-pkg');\n    expect(warnMessage).toContain('\"use step\" functions');\n  });\n\n  it('warns when an external package contains \"use workflow\" directives', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    writeFile(\n      join(projectDir, 'node_modules', 'my-workflow-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'my-workflow-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n      })\n    );\n    writeFile(\n      join(projectDir, 'node_modules', 'my-workflow-pkg', 'index.js'),\n      `export async function runJob() {\n  \"use workflow\";\n  return \"done\";\n}`\n    );\n\n    const builder = createBuilder(projectDir, ['my-workflow-pkg']);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).toHaveBeenCalled();\n    const warnMessage = warnSpy.mock.calls[0]?.[0] as string;\n    expect(warnMessage).toContain('my-workflow-pkg');\n    expect(warnMessage).toContain('\"use workflow\" functions');\n  });\n\n  it('does not warn for packages without workflow patterns', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    writeFile(\n      join(projectDir, 'node_modules', 'plain-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'plain-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n      })\n    );\n    writeFile(\n      join(projectDir, 'node_modules', 'plain-pkg', 'index.js'),\n      'export const hello = \"world\";'\n    );\n\n    const builder = createBuilder(projectDir, ['plain-pkg']);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).not.toHaveBeenCalled();\n  });\n\n  it('does not warn for pseudo-packages (server-only, client-only)', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    const builder = createBuilder(projectDir, ['server-only', 'client-only']);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).not.toHaveBeenCalled();\n  });\n\n  it('does not warn when externalPackages is empty', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    const builder = createBuilder(projectDir, []);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).not.toHaveBeenCalled();\n  });\n\n  it('warns only once per package across multiple discoverEntries calls', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n    writeFile(join(projectDir, 'other.ts'), 'export const y = 2;');\n\n    writeFile(\n      join(projectDir, 'node_modules', 'my-serde-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'my-serde-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n        dependencies: { '@workflow/serde': '^1.0.0' },\n      })\n    );\n    writeFile(\n      join(projectDir, 'node_modules', 'my-serde-pkg', 'index.js'),\n      'export class Foo {}'\n    );\n\n    const builder = createBuilder(projectDir, ['my-serde-pkg']);\n\n    // Call discoverEntries twice with different inputs\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'other.ts')],\n      join(projectDir, 'out2')\n    );\n\n    // Should only warn once\n    const warnCalls = warnSpy.mock.calls.filter((call: unknown[]) =>\n      (call[0] as string).includes('my-serde-pkg')\n    );\n    expect(warnCalls).toHaveLength(1);\n  });\n\n  it('lists multiple detected issues in the warning message', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    writeFile(\n      join(projectDir, 'node_modules', 'multi-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'multi-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n        dependencies: { '@workflow/serde': '^1.0.0' },\n      })\n    );\n    writeFile(\n      join(projectDir, 'node_modules', 'multi-pkg', 'index.js'),\n      `export async function doWork() {\n  \"use step\";\n  return 42;\n}\nexport class Foo {\n  static [Symbol.for('workflow-serialize')](instance) { return {}; }\n  static [Symbol.for('workflow-deserialize')](data) { return new Foo(); }\n}`\n    );\n\n    const builder = createBuilder(projectDir, ['multi-pkg']);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).toHaveBeenCalled();\n    const warnMessage = warnSpy.mock.calls[0]?.[0] as string;\n    expect(warnMessage).toContain('\"use step\" functions');\n    expect(warnMessage).toContain('serialization classes');\n  });\n\n  it('warns via entry-file detection when package.json has no serde dep', async () => {\n    const projectDir = join(testRoot, 'project');\n\n    writeFile(join(projectDir, 'index.ts'), 'export const x = 1;');\n\n    // Package without @workflow/serde in deps, but entry has \"use step\"\n    writeFile(\n      join(projectDir, 'node_modules', 'no-serde-dep-pkg', 'package.json'),\n      JSON.stringify({\n        name: 'no-serde-dep-pkg',\n        version: '1.0.0',\n        main: 'index.js',\n      })\n    );\n    writeFile(\n      join(projectDir, 'node_modules', 'no-serde-dep-pkg', 'index.js'),\n      `export async function doWork() {\n  \"use step\";\n  return 42;\n}`\n    );\n\n    const builder = createBuilder(projectDir, ['no-serde-dep-pkg']);\n    await builder.discoverEntriesPublic(\n      [join(projectDir, 'index.ts')],\n      join(projectDir, 'out')\n    );\n\n    expect(warnSpy).toHaveBeenCalled();\n    const warnMessage = warnSpy.mock.calls[0]?.[0] as string;\n    expect(warnMessage).toContain('no-serde-dep-pkg');\n    expect(warnMessage).toContain('\"use step\" functions');\n  });\n});\n"]}

package/dist/get-input-files.test.js

@@ -1,4 +1,4 @@
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
@@ -14,6 +14,12 @@ class TestBuilder extends BaseBuilder {
     getInputFiles() {
         return super.getInputFiles();
     }
+    getDiagnosticsManifestPath() {
+        return super.getDiagnosticsManifestPath();
+    }
+    ensureSwcIgnored() {
+        return super.ensureSwcIgnored();
+    }
 }
 // Resolve symlinks in tmpdir to avoid macOS /var -> /private/var issues
 const realTmpdir = realpathSync(tmpdir());
@@ -31,7 +37,7 @@ function writeFile(dir, relativePath, content = '') {
     writeFileSync(fullPath, content, 'utf-8');
     return fullPath;
 }
-function createBuilder(workingDir, dirs) {
+function createBuilder(workingDir, dirs, configOverrides = {}) {
     const config = {
         buildTarget: 'standalone',
         workingDir,
@@ -39,6 +45,7 @@ function createBuilder(workingDir, dirs) {
         stepsBundlePath: join(workingDir, 'steps.js'),
         workflowsBundlePath: join(workingDir, 'workflows.js'),
         webhookBundlePath: join(workingDir, 'webhook.js'),
+        ...configOverrides,
     };
     return new TestBuilder(config);
 }
@@ -80,6 +87,7 @@ describe('getInputFiles', () => {
         writeFile(srcDir, '.workflow-data/state.ts');
         writeFile(srcDir, '.workflow-vitest/workflows.mjs');
         writeFile(srcDir, '.well-known/workflow/route.ts');
+        writeFile(srcDir, '.swc/cache/plugin-output.ts');
         writeFile(srcDir, '.turbo/cache/build.ts');
         writeFile(srcDir, '.cache/babel/plugin.js');
         writeFile(srcDir, '.yarn/releases/yarn.cjs');
@@ -97,6 +105,7 @@ describe('getInputFiles', () => {
         expect(files).not.toContain(normalize(join(srcDir, '.workflow-data/state.ts')));
         expect(files).not.toContain(normalize(join(srcDir, '.workflow-vitest/workflows.mjs')));
         expect(files).not.toContain(normalize(join(srcDir, '.well-known/workflow/route.ts')));
+        expect(files).not.toContain(normalize(join(srcDir, '.swc/cache/plugin-output.ts')));
         expect(files).not.toContain(normalize(join(srcDir, '.turbo/cache/build.ts')));
         expect(files).not.toContain(normalize(join(srcDir, '.cache/babel/plugin.js')));
         expect(files).not.toContain(normalize(join(srcDir, '.yarn/releases/yarn.cjs')));
@@ -118,4 +127,74 @@ describe('getInputFiles', () => {
         expect(files).toContain(normalize(join(srcDir, '.api/config.cjs')));
     });
 });
-//# sourceMappingURL=get-input-files.test.js.map
+describe('ensureSwcIgnored', () => {
+    let testRoot;
+    beforeEach(() => {
+        testRoot = mkdtempSync(join(realTmpdir, 'swc-gitignore-'));
+    });
+    afterEach(() => {
+        rmSync(testRoot, { recursive: true, force: true });
+    });
+    it('adds .swc to the project .gitignore once', async () => {
+        writeFile(testRoot, '.gitignore', 'node_modules\n');
+        const builder = createBuilder(testRoot, ['src']);
+        await builder.ensureSwcIgnored();
+        await builder.ensureSwcIgnored();
+        const gitignore = readFileSync(join(testRoot, '.gitignore'), 'utf-8');
+        const swcEntries = gitignore
+            .split(/\r?\n/)
+            .filter((line) => line.trim() === '/.swc');
+        expect(gitignore).toBe('node_modules\n/.swc\n');
+        expect(swcEntries).toHaveLength(1);
+    });
+    it('preserves existing .swc gitignore variants', async () => {
+        writeFile(testRoot, '.gitignore', 'node_modules\n.swc/\n');
+        const builder = createBuilder(testRoot, ['src']);
+        await builder.ensureSwcIgnored();
+        expect(readFileSync(join(testRoot, '.gitignore'), 'utf-8')).toBe('node_modules\n.swc/\n');
+    });
+});
+describe('getDiagnosticsManifestPath', () => {
+    let testRoot;
+    beforeEach(() => {
+        testRoot = mkdtempSync(join(realTmpdir, 'diagnostics-path-'));
+    });
+    afterEach(() => {
+        rmSync(testRoot, { recursive: true, force: true });
+    });
+    it('uses an explicit diagnosticsDir when configured', () => {
+        const builder = createBuilder(testRoot, ['src'], {
+            diagnosticsDir: '.next/diagnostics',
+        });
+        expect(builder.getDiagnosticsManifestPath()).toBe(join(testRoot, '.next/diagnostics/workflows-manifest.json'));
+    });
+    it('does not emit Vercel diagnostics for non-Vercel builder targets', () => {
+        const previousTargetWorld = process.env.WORKFLOW_TARGET_WORLD;
+        process.env.WORKFLOW_TARGET_WORLD = 'vercel';
+        try {
+            const builder = createBuilder(testRoot, ['src']);
+            expect(builder.getDiagnosticsManifestPath()).toBeUndefined();
+        }
+        finally {
+            if (previousTargetWorld === undefined) {
+                delete process.env.WORKFLOW_TARGET_WORLD;
+            }
+            else {
+                process.env.WORKFLOW_TARGET_WORLD = previousTargetWorld;
+            }
+        }
+    });
+    it('falls back to Vercel output diagnostics for the Vercel builder', () => {
+        const config = {
+            buildTarget: 'vercel-build-output-api',
+            workingDir: testRoot,
+            dirs: ['src'],
+            stepsBundlePath: join(testRoot, 'steps.js'),
+            workflowsBundlePath: join(testRoot, 'workflows.js'),
+            webhookBundlePath: join(testRoot, 'webhook.js'),
+        };
+        const builder = new TestBuilder(config);
+        expect(builder.getDiagnosticsManifestPath()).toBe(join(testRoot, '.vercel/output/diagnostics/workflows-manifest.json'));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-input-files.test.js","sourceRoot":"","sources":["../src/get-input-files.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  mkdirSync,\n  mkdtempSync,\n  readFileSync,\n  realpathSync,\n  rmSync,\n  writeFileSync,\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { dirname, join } from 'node:path';\nimport { afterEach, beforeEach, describe, expect, it } from 'vitest';\nimport { BaseBuilder } from './base-builder.js';\nimport type { StandaloneConfig, VercelBuildOutputConfig } from './types.js';\n\n/**\n * Minimal subclass to expose the protected `getInputFiles()` for testing.\n */\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    // no-op\n  }\n\n  // Expose for tests\n  public getInputFiles(): Promise<string[]> {\n    return super.getInputFiles();\n  }\n\n  public getDiagnosticsManifestPath(): string | undefined {\n    return super.getDiagnosticsManifestPath();\n  }\n\n  public ensureSwcIgnored(): Promise<void> {\n    return super.ensureSwcIgnored();\n  }\n}\n\n// Resolve symlinks in tmpdir to avoid macOS /var -> /private/var issues\nconst realTmpdir = realpathSync(tmpdir());\n\n/**\n * Normalize a path to forward slashes for cross-platform comparison.\n * tinyglobby always returns forward-slash paths, even on Windows,\n * while Node's `path.join()` uses backslashes on Windows.\n */\nfunction normalize(p: string): string {\n  return p.replace(/\\\\/g, '/');\n}\n\nfunction writeFile(dir: string, relativePath: string, content = ''): string {\n  const fullPath = join(dir, relativePath);\n  mkdirSync(dirname(fullPath), { recursive: true });\n  writeFileSync(fullPath, content, 'utf-8');\n  return fullPath;\n}\n\nfunction createBuilder(\n  workingDir: string,\n  dirs: string[],\n  configOverrides: Partial<StandaloneConfig> = {}\n): TestBuilder {\n  const config: StandaloneConfig = {\n    buildTarget: 'standalone',\n    workingDir,\n    dirs,\n    stepsBundlePath: join(workingDir, 'steps.js'),\n    workflowsBundlePath: join(workingDir, 'workflows.js'),\n    webhookBundlePath: join(workingDir, 'webhook.js'),\n    ...configOverrides,\n  };\n  return new TestBuilder(config);\n}\n\ndescribe('getInputFiles', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'get-input-files-'));\n  });\n\n  afterEach(() => {\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('discovers files inside dot-prefixed directories', async () => {\n    const srcDir = join(testRoot, 'src');\n    writeFile(srcDir, '.hidden/step.ts', \"'use step';\");\n    writeFile(srcDir, '.config/workflow.ts', \"'use workflow';\");\n    writeFile(srcDir, 'regular/step.ts', \"'use step';\");\n\n    const builder = createBuilder(testRoot, ['src']);\n    const files = (await builder.getInputFiles()).map(normalize);\n\n    expect(files).toContain(normalize(join(srcDir, '.hidden/step.ts')));\n    expect(files).toContain(normalize(join(srcDir, '.config/workflow.ts')));\n    expect(files).toContain(normalize(join(srcDir, 'regular/step.ts')));\n  });\n\n  it('discovers dot-prefixed files', async () => {\n    const srcDir = join(testRoot, 'src');\n    writeFile(srcDir, '.hidden-step.ts', \"'use step';\");\n    writeFile(srcDir, 'visible-step.ts', \"'use step';\");\n\n    const builder = createBuilder(testRoot, ['src']);\n    const files = (await builder.getInputFiles()).map(normalize);\n\n    expect(files).toContain(normalize(join(srcDir, '.hidden-step.ts')));\n    expect(files).toContain(normalize(join(srcDir, 'visible-step.ts')));\n  });\n\n  it('still excludes explicitly ignored dot-directories', async () => {\n    const srcDir = join(testRoot, 'src');\n    writeFile(srcDir, '.git/hooks/pre-commit.ts');\n    writeFile(srcDir, '.next/server/page.ts');\n    writeFile(srcDir, '.nuxt/workflow/steps.mjs');\n    writeFile(srcDir, '.vercel/output/step.ts');\n    writeFile(srcDir, '.svelte-kit/output/step.ts');\n    writeFile(srcDir, '.workflow-data/state.ts');\n    writeFile(srcDir, '.workflow-vitest/workflows.mjs');\n    writeFile(srcDir, '.well-known/workflow/route.ts');\n    writeFile(srcDir, '.swc/cache/plugin-output.ts');\n    writeFile(srcDir, '.turbo/cache/build.ts');\n    writeFile(srcDir, '.cache/babel/plugin.js');\n    writeFile(srcDir, '.yarn/releases/yarn.cjs');\n    writeFile(srcDir, '.pnpm-store/v3/files.ts');\n    writeFile(srcDir, 'node_modules/pkg/index.ts');\n    // This one should still be found\n    writeFile(srcDir, '.custom/step.ts', \"'use step';\");\n\n    const builder = createBuilder(testRoot, ['src']);\n    const files = (await builder.getInputFiles()).map(normalize);\n\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.git/hooks/pre-commit.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.next/server/page.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.nuxt/workflow/steps.mjs'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.vercel/output/step.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.svelte-kit/output/step.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.workflow-data/state.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.workflow-vitest/workflows.mjs'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.well-known/workflow/route.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.swc/cache/plugin-output.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.turbo/cache/build.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.cache/babel/plugin.js'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.yarn/releases/yarn.cjs'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, '.pnpm-store/v3/files.ts'))\n    );\n    expect(files).not.toContain(\n      normalize(join(srcDir, 'node_modules/pkg/index.ts'))\n    );\n    expect(files).toContain(normalize(join(srcDir, '.custom/step.ts')));\n  });\n\n  it('discovers files with various supported extensions in dot-directories', async () => {\n    const srcDir = join(testRoot, 'src');\n    writeFile(srcDir, '.api/route.tsx');\n    writeFile(srcDir, '.api/handler.mts');\n    writeFile(srcDir, '.api/utils.js');\n    writeFile(srcDir, '.api/config.cjs');\n\n    const builder = createBuilder(testRoot, ['src']);\n    const files = (await builder.getInputFiles()).map(normalize);\n\n    expect(files).toContain(normalize(join(srcDir, '.api/route.tsx')));\n    expect(files).toContain(normalize(join(srcDir, '.api/handler.mts')));\n    expect(files).toContain(normalize(join(srcDir, '.api/utils.js')));\n    expect(files).toContain(normalize(join(srcDir, '.api/config.cjs')));\n  });\n});\n\ndescribe('ensureSwcIgnored', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'swc-gitignore-'));\n  });\n\n  afterEach(() => {\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('adds .swc to the project .gitignore once', async () => {\n    writeFile(testRoot, '.gitignore', 'node_modules\\n');\n\n    const builder = createBuilder(testRoot, ['src']);\n\n    await builder.ensureSwcIgnored();\n    await builder.ensureSwcIgnored();\n\n    const gitignore = readFileSync(join(testRoot, '.gitignore'), 'utf-8');\n    const swcEntries = gitignore\n      .split(/\\r?\\n/)\n      .filter((line) => line.trim() === '/.swc');\n\n    expect(gitignore).toBe('node_modules\\n/.swc\\n');\n    expect(swcEntries).toHaveLength(1);\n  });\n\n  it('preserves existing .swc gitignore variants', async () => {\n    writeFile(testRoot, '.gitignore', 'node_modules\\n.swc/\\n');\n\n    const builder = createBuilder(testRoot, ['src']);\n\n    await builder.ensureSwcIgnored();\n\n    expect(readFileSync(join(testRoot, '.gitignore'), 'utf-8')).toBe(\n      'node_modules\\n.swc/\\n'\n    );\n  });\n});\n\ndescribe('getDiagnosticsManifestPath', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'diagnostics-path-'));\n  });\n\n  afterEach(() => {\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('uses an explicit diagnosticsDir when configured', () => {\n    const builder = createBuilder(testRoot, ['src'], {\n      diagnosticsDir: '.next/diagnostics',\n    });\n\n    expect(builder.getDiagnosticsManifestPath()).toBe(\n      join(testRoot, '.next/diagnostics/workflows-manifest.json')\n    );\n  });\n\n  it('does not emit Vercel diagnostics for non-Vercel builder targets', () => {\n    const previousTargetWorld = process.env.WORKFLOW_TARGET_WORLD;\n    process.env.WORKFLOW_TARGET_WORLD = 'vercel';\n    try {\n      const builder = createBuilder(testRoot, ['src']);\n\n      expect(builder.getDiagnosticsManifestPath()).toBeUndefined();\n    } finally {\n      if (previousTargetWorld === undefined) {\n        delete process.env.WORKFLOW_TARGET_WORLD;\n      } else {\n        process.env.WORKFLOW_TARGET_WORLD = previousTargetWorld;\n      }\n    }\n  });\n\n  it('falls back to Vercel output diagnostics for the Vercel builder', () => {\n    const config: VercelBuildOutputConfig = {\n      buildTarget: 'vercel-build-output-api',\n      workingDir: testRoot,\n      dirs: ['src'],\n      stepsBundlePath: join(testRoot, 'steps.js'),\n      workflowsBundlePath: join(testRoot, 'workflows.js'),\n      webhookBundlePath: join(testRoot, 'webhook.js'),\n    };\n    const builder = new TestBuilder(config);\n\n    expect(builder.getDiagnosticsManifestPath()).toBe(\n      join(testRoot, '.vercel/output/diagnostics/workflows-manifest.json')\n    );\n  });\n});\n"]}

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { applySwcTransform } from './apply-swc-transform.js';
 export { BaseBuilder } from './base-builder.js';
 export { createBuildQueue } from './build-queue.js';
 export { createBaseBuilderConfig, type DecoratorOptions, type DecoratorOptionsWithConfigPath, getDecoratorOptionsForDirectory, getDecoratorOptionsForDirectoryWithConfigPath, } from './config-helpers.js';
-export { STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER } from './constants.js';
+export { createWorkflowEntrypointOptionsCode, createWorkflowQueueTrigger, WORKFLOW_QUEUE_TRIGGER, } from './constants.js';
 export { createDiscoverEntriesPlugin } from './discover-entries-esbuild-plugin.js';
 export { clearModuleSpecifierCache, getImportPath, type ImportPathResult, type ModuleSpecifierResult, resolveModuleSpecifier, } from './module-specifier.js';
 export { createNodeModuleErrorPlugin } from './node-module-esbuild-plugin.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EACL,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,8BAA8B,EACnC,+BAA+B,EAC/B,6CAA6C,GAC9C,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EACL,yBAAyB,EACzB,aAAa,EACb,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EACL,yBAAyB,EACzB,eAAe,GAChB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EACvB,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EACL,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,8BAA8B,EACnC,+BAA+B,EAC/B,6CAA6C,GAC9C,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,mCAAmC,EACnC,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EACL,yBAAyB,EACzB,aAAa,EACb,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EACL,yBAAyB,EACzB,eAAe,GAChB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EACvB,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -2,7 +2,7 @@ export { applySwcTransform } from './apply-swc-transform.js';
 export { BaseBuilder } from './base-builder.js';
 export { createBuildQueue } from './build-queue.js';
 export { createBaseBuilderConfig, getDecoratorOptionsForDirectory, getDecoratorOptionsForDirectoryWithConfigPath, } from './config-helpers.js';
-export { STEP_QUEUE_TRIGGER, WORKFLOW_QUEUE_TRIGGER } from './constants.js';
+export { createWorkflowEntrypointOptionsCode, createWorkflowQueueTrigger, WORKFLOW_QUEUE_TRIGGER, } from './constants.js';
 export { createDiscoverEntriesPlugin } from './discover-entries-esbuild-plugin.js';
 export { clearModuleSpecifierCache, getImportPath, resolveModuleSpecifier, } from './module-specifier.js';
 export { createNodeModuleErrorPlugin } from './node-module-esbuild-plugin.js';
@@ -15,4 +15,4 @@ export { detectWorkflowPatterns, generatedWorkflowPathPattern, isGeneratedWorkfl
 export { isValidBuildTarget, validBuildTargets } from './types.js';
 export { VercelBuildOutputAPIBuilder } from './vercel-build-output-api.js';
 export { resolveWorkflowAliasRelativePath } from './workflow-alias.js';
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/module-specifier.d.ts

@@ -28,16 +28,34 @@ export interface ModuleSpecifierResult {
  * // => { moduleSpecifier: 'workflow/internal/builtins@4.0.0' }
  *
  * @example
- * // File in workspace package
- * resolveModuleSpecifier('/project/packages/shared/src/utils.ts', '/project')
+ * // Exported root file in workspace package
+ * resolveModuleSpecifier('/project/packages/shared/src/index.ts', '/project')
  * // => { moduleSpecifier: '@myorg/shared@0.0.0' }
  *
  * @example
+ * // Non-exported / deep package file
+ * resolveModuleSpecifier('/project/packages/shared/src/internal/foo.ts', '/project')
+ * // => { moduleSpecifier: undefined }
+ *
+ * @example
  * // Local app file
  * resolveModuleSpecifier('/project/src/workflows/order.ts', '/project')
  * // => { moduleSpecifier: undefined }
  */
 export declare function resolveModuleSpecifier(filePath: string, projectRoot: string): ModuleSpecifierResult;
+/**
+ * Strip the trailing "@<version>" suffix from a module specifier produced by
+ * `resolveModuleSpecifier`, leaving the bare `name` or `name/subpath` form.
+ *
+ * Use this when you want to compare or dedupe specifiers across versions
+ * (e.g. treating `@workflow/ai/agent@5.0.0-beta.4` and
+ * `@workflow/ai/agent@5.0.0-beta.5` as the same logical module).
+ *
+ * Colocated with `resolveModuleSpecifier` so the construction and parsing
+ * stay in sync — see the `${pkg.name}${subpath}@${pkg.version}` and
+ * `${pkg.name}@${pkg.version}` paths above.
+ */
+export declare function stripPackageVersion(specifier: string): string;
 /**
  * Clear the package.json cache. Useful for testing or when package.json files may have changed.
  */

package/dist/module-specifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-specifier.d.ts","sourceRoot":"","sources":["../src/module-specifier.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAgQD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,qBAAqB,CA6BvB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD;AA0HD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,gBAAgB,CA6DlB"}
+{"version":3,"file":"module-specifier.d.ts","sourceRoot":"","sources":["../src/module-specifier.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAoTD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,qBAAqB,CA6CvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD;AA0HD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,gBAAgB,CA6DlB"}