@workflow/builders 5.0.0-beta.3 → 5.0.0-beta.31

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/fast-discovery.d.ts

@@ -0,0 +1,20 @@
+export interface DiscoveredEntries {
+    discoveredSteps: Set<string>;
+    discoveredWorkflows: Set<string>;
+    discoveredSerdeFiles: Set<string>;
+    /**
+     * All JS/TS files visited while walking the workflow import graph.
+     * Watch-mode integrations use this to distinguish relevant HMR changes from
+     * unrelated application file edits.
+     */
+    discoveredFiles?: Set<string>;
+}
+interface FastDiscoverEntriesOptions {
+    entryPoints: string[];
+    state: DiscoveredEntries;
+    defaultTsconfigPath: string | undefined;
+    workingDir: string;
+}
+export declare function fastDiscoverEntries({ entryPoints, state, defaultTsconfigPath, workingDir, }: FastDiscoverEntriesOptions): Promise<void>;
+export {};
+//# sourceMappingURL=fast-discovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fast-discovery.d.ts","sourceRoot":"","sources":["../src/fast-discovery.ts"],"names":[],"mappings":"AA+CA,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjC,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAClC;;;;OAIG;IACH,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED,UAAU,0BAA0B;IAClC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,KAAK,EAAE,iBAAiB,CAAC;IACzB,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;CACpB;AA+kBD,wBAAsB,mBAAmB,CAAC,EACxC,WAAW,EACX,KAAK,EACL,mBAAmB,EACnB,UAAU,GACX,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CA6X5C"}