@workflow/builders 5.0.0-beta.44 → 5.0.0-beta.47

package/dist/manifest-ids.d.ts

@@ -0,0 +1,35 @@
+import type { WorkflowManifest } from './apply-swc-transform.js';
+/**
+ * Location (and identity fingerprint) of a manifest entry that produced a
+ * workflow/step ID during a build. Shared by the duplicate-ID checks in
+ * `swc-esbuild-plugin.ts` (esbuild bundling path) and `base-builder.ts`
+ * (source registration path).
+ */
+export type ManifestEntryLocation = {
+    filePath: string;
+    name: string;
+    /**
+     * Fingerprint (SHA-256) of the source file contents that produced this
+     * entry. Used to recognize equivalent duplicate copies of the same module
+     * (see `assertUniqueManifestIds`). `undefined` when the caller cannot
+     * provide the source contents, which disables deduplication and preserves
+     * the collision error.
+     */
+    contentHash?: string;
+};
+/**
+ * Hash source file contents for manifest-entry equivalence comparison.
+ */
+export declare function hashManifestSource(source: string): string;
+/**
+ * Merge one file's transform manifest into the build-wide manifest, failing
+ * the build on genuine duplicate step/workflow IDs while deduplicating
+ * equivalent copies of the same module (e.g. pnpm peer-dependency variants
+ * of one package version).
+ *
+ * @param contentHash - Fingerprint of the source file that produced
+ * `incoming` (see {@link hashManifestSource}). Callers merge one file's
+ * manifest at a time, so a single hash covers every incoming entry.
+ */
+export declare function mergeWorkflowManifest(target: WorkflowManifest, incoming: WorkflowManifest, stepIds: Map<string, ManifestEntryLocation>, workflowIds: Map<string, ManifestEntryLocation>, contentHash?: string): void;
+//# sourceMappingURL=manifest-ids.d.ts.map

package/dist/manifest-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-ids.d.ts","sourceRoot":"","sources":["../src/manifest-ids.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEzD;AA6DD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,EAC3C,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,EAC/C,WAAW,CAAC,EAAE,MAAM,GACnB,IAAI,CAmBN"}

package/dist/manifest-ids.js

@@ -0,0 +1,69 @@
+import { createHash } from 'node:crypto';
+import { WorkflowBuildError } from '@workflow/errors';
+/**
+ * Hash source file contents for manifest-entry equivalence comparison.
+ */
+export function hashManifestSource(source) {
+    return createHash('sha256').update(source).digest('hex');
+}
+function formatIdLocation(location) {
+    return `${location.filePath}#${location.name}`;
+}
+function assertUniqueManifestIds(entriesByFile, ids, getId, label, contentHash) {
+    for (const [filePath, entries] of Object.entries(entriesByFile || {})) {
+        for (const [name, data] of Object.entries(entries)) {
+            const id = getId(data);
+            const existing = ids.get(id);
+            const current = { filePath, name, contentHash };
+            if (existing &&
+                (existing.filePath !== current.filePath ||
+                    existing.name !== current.name)) {
+                // Two *different* files generated the same ID. If both files have
+                // identical contents and the ID belongs to the same symbol, they are
+                // duplicate copies of the same logical module rather than a genuine
+                // collision. The main producer of such copies is pnpm, which
+                // materializes one package version once per peer-dependency
+                // resolution (node_modules/.pnpm/pkg@1.0.0_peer-a@.../ and
+                // .../pkg@1.0.0_peer-b@.../ hard-link the same store files), while
+                // the canonical ID intentionally describes the logical module
+                // (`name/subpath@version`) and ignores installation topology.
+                // Registering equivalent definitions is harmless — they run the same
+                // code under the same ID — so keep the first one and continue.
+                if (existing.name === current.name &&
+                    existing.contentHash !== undefined &&
+                    existing.contentHash === current.contentHash) {
+                    continue;
+                }
+                const idName = label === 'step' ? 'workflow step ID' : 'workflow ID';
+                const functionName = `${label} function`;
+                const capitalizedLabel = label === 'step' ? 'Step' : 'Workflow';
+                throw new WorkflowBuildError(`Duplicate ${idName} "${id}" generated for ${formatIdLocation(existing)} and ${formatIdLocation(current)}.`, {
+                    hint: `${capitalizedLabel} IDs must be unique across a build. ` +
+                        `If you own one of the colliding files, rename the ${functionName} or export ` +
+                        `the package file through a unique package subpath. If the collision is in a ` +
+                        `transitive dependency you don't control, file an issue with the upstream ` +
+                        `package or pin to a non-colliding version.`,
+                });
+            }
+            ids.set(id, current);
+        }
+    }
+}
+/**
+ * Merge one file's transform manifest into the build-wide manifest, failing
+ * the build on genuine duplicate step/workflow IDs while deduplicating
+ * equivalent copies of the same module (e.g. pnpm peer-dependency variants
+ * of one package version).
+ *
+ * @param contentHash - Fingerprint of the source file that produced
+ * `incoming` (see {@link hashManifestSource}). Callers merge one file's
+ * manifest at a time, so a single hash covers every incoming entry.
+ */
+export function mergeWorkflowManifest(target, incoming, stepIds, workflowIds, contentHash) {
+    assertUniqueManifestIds(incoming.steps, stepIds, (data) => data.stepId, 'step', contentHash);
+    assertUniqueManifestIds(incoming.workflows, workflowIds, (data) => data.workflowId, 'workflow', contentHash);
+    target.workflows = Object.assign(target.workflows || {}, incoming.workflows);
+    target.steps = Object.assign(target.steps || {}, incoming.steps);
+    target.classes = Object.assign(target.classes || {}, incoming.classes);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest-ids.js","sourceRoot":"","sources":["../src/manifest-ids.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport { WorkflowBuildError } from '@workflow/errors';\nimport type { WorkflowManifest } from './apply-swc-transform.js';\n\n/**\n * Location (and identity fingerprint) of a manifest entry that produced a\n * workflow/step ID during a build. Shared by the duplicate-ID checks in\n * `swc-esbuild-plugin.ts` (esbuild bundling path) and `base-builder.ts`\n * (source registration path).\n */\nexport type ManifestEntryLocation = {\n  filePath: string;\n  name: string;\n  /**\n   * Fingerprint (SHA-256) of the source file contents that produced this\n   * entry. Used to recognize equivalent duplicate copies of the same module\n   * (see `assertUniqueManifestIds`). `undefined` when the caller cannot\n   * provide the source contents, which disables deduplication and preserves\n   * the collision error.\n   */\n  contentHash?: string;\n};\n\n/**\n * Hash source file contents for manifest-entry equivalence comparison.\n */\nexport function hashManifestSource(source: string): string {\n  return createHash('sha256').update(source).digest('hex');\n}\n\nfunction formatIdLocation(location: ManifestEntryLocation): string {\n  return `${location.filePath}#${location.name}`;\n}\n\nfunction assertUniqueManifestIds<TEntry>(\n  entriesByFile: Record<string, Record<string, TEntry>> | undefined,\n  ids: Map<string, ManifestEntryLocation>,\n  getId: (entry: TEntry) => string,\n  label: 'step' | 'workflow',\n  contentHash: string | undefined\n): void {\n  for (const [filePath, entries] of Object.entries(entriesByFile || {})) {\n    for (const [name, data] of Object.entries(entries)) {\n      const id = getId(data);\n      const existing = ids.get(id);\n      const current = { filePath, name, contentHash };\n      if (\n        existing &&\n        (existing.filePath !== current.filePath ||\n          existing.name !== current.name)\n      ) {\n        // Two *different* files generated the same ID. If both files have\n        // identical contents and the ID belongs to the same symbol, they are\n        // duplicate copies of the same logical module rather than a genuine\n        // collision. The main producer of such copies is pnpm, which\n        // materializes one package version once per peer-dependency\n        // resolution (node_modules/.pnpm/pkg@1.0.0_peer-a@.../ and\n        // .../pkg@1.0.0_peer-b@.../ hard-link the same store files), while\n        // the canonical ID intentionally describes the logical module\n        // (`name/subpath@version`) and ignores installation topology.\n        // Registering equivalent definitions is harmless — they run the same\n        // code under the same ID — so keep the first one and continue.\n        if (\n          existing.name === current.name &&\n          existing.contentHash !== undefined &&\n          existing.contentHash === current.contentHash\n        ) {\n          continue;\n        }\n        const idName = label === 'step' ? 'workflow step ID' : 'workflow ID';\n        const functionName = `${label} function`;\n        const capitalizedLabel = label === 'step' ? 'Step' : 'Workflow';\n        throw new WorkflowBuildError(\n          `Duplicate ${idName} \"${id}\" generated for ${formatIdLocation(existing)} and ${formatIdLocation(current)}.`,\n          {\n            hint:\n              `${capitalizedLabel} IDs must be unique across a build. ` +\n              `If you own one of the colliding files, rename the ${functionName} or export ` +\n              `the package file through a unique package subpath. If the collision is in a ` +\n              `transitive dependency you don't control, file an issue with the upstream ` +\n              `package or pin to a non-colliding version.`,\n          }\n        );\n      }\n      ids.set(id, current);\n    }\n  }\n}\n\n/**\n * Merge one file's transform manifest into the build-wide manifest, failing\n * the build on genuine duplicate step/workflow IDs while deduplicating\n * equivalent copies of the same module (e.g. pnpm peer-dependency variants\n * of one package version).\n *\n * @param contentHash - Fingerprint of the source file that produced\n * `incoming` (see {@link hashManifestSource}). Callers merge one file's\n * manifest at a time, so a single hash covers every incoming entry.\n */\nexport function mergeWorkflowManifest(\n  target: WorkflowManifest,\n  incoming: WorkflowManifest,\n  stepIds: Map<string, ManifestEntryLocation>,\n  workflowIds: Map<string, ManifestEntryLocation>,\n  contentHash?: string\n): void {\n  assertUniqueManifestIds(\n    incoming.steps,\n    stepIds,\n    (data) => data.stepId,\n    'step',\n    contentHash\n  );\n  assertUniqueManifestIds(\n    incoming.workflows,\n    workflowIds,\n    (data) => data.workflowId,\n    'workflow',\n    contentHash\n  );\n\n  target.workflows = Object.assign(target.workflows || {}, incoming.workflows);\n  target.steps = Object.assign(target.steps || {}, incoming.steps);\n  target.classes = Object.assign(target.classes || {}, incoming.classes);\n}\n"]}

package/dist/manifest-ids.test.d.ts

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

package/dist/manifest-ids.test.d.ts.map

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

package/dist/manifest-ids.test.js

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+import { hashManifestSource, mergeWorkflowManifest, } from './manifest-ids.js';
+function createMaps() {
+    return {
+        stepIds: new Map(),
+        workflowIds: new Map(),
+    };
+}
+function stepManifest(filePath, name, stepId) {
+    return {
+        steps: {
+            [filePath]: {
+                [name]: { stepId },
+            },
+        },
+    };
+}
+function workflowManifest(filePath, name, workflowId) {
+    return {
+        workflows: {
+            [filePath]: {
+                [name]: { workflowId },
+            },
+        },
+    };
+}
+const PEER_A_FILE = 'node_modules/.pnpm/pkg@1.0.0_peer-a@1.0.0/node_modules/pkg/dist/steps.js';
+const PEER_B_FILE = 'node_modules/.pnpm/pkg@1.0.0_peer-b@2.0.0/node_modules/pkg/dist/steps.js';
+const STEP_ID = 'step//pkg/steps@1.0.0//doWork';
+const WORKFLOW_ID = 'workflow//pkg/steps@1.0.0//orchestrate';
+describe('mergeWorkflowManifest duplicate ID handling', () => {
+    it('throws when two different files emit the same step ID with different contents', () => {
+        const { stepIds, workflowIds } = createMaps();
+        const target = {};
+        mergeWorkflowManifest(target, stepManifest(PEER_A_FILE, 'doWork', STEP_ID), stepIds, workflowIds, hashManifestSource('export const doWork = 1;'));
+        expect(() => mergeWorkflowManifest(target, stepManifest(PEER_B_FILE, 'doWork', STEP_ID), stepIds, workflowIds, hashManifestSource('export const doWork = 2;'))).toThrow(/Duplicate workflow step ID/);
+    });
+    it('deduplicates identical copies of the same module emitting the same step ID', () => {
+        const { stepIds, workflowIds } = createMaps();
+        const target = {};
+        const contentHash = hashManifestSource('export const doWork = 1;');
+        mergeWorkflowManifest(target, stepManifest(PEER_A_FILE, 'doWork', STEP_ID), stepIds, workflowIds, contentHash);
+        mergeWorkflowManifest(target, stepManifest(PEER_B_FILE, 'doWork', STEP_ID), stepIds, workflowIds, contentHash);
+        // The first registration wins in the ID map...
+        expect(stepIds.get(STEP_ID)?.filePath).toBe(PEER_A_FILE);
+        // ...but both file entries stay in the manifest (both copies register
+        // the same ID at runtime, which is harmless for identical code).
+        expect(Object.keys(target.steps ?? {})).toEqual([PEER_A_FILE, PEER_B_FILE]);
+    });
+    it('deduplicates identical copies emitting the same workflow ID', () => {
+        const { stepIds, workflowIds } = createMaps();
+        const target = {};
+        const contentHash = hashManifestSource('export const orchestrate = 1;');
+        mergeWorkflowManifest(target, workflowManifest(PEER_A_FILE, 'orchestrate', WORKFLOW_ID), stepIds, workflowIds, contentHash);
+        expect(() => mergeWorkflowManifest(target, workflowManifest(PEER_B_FILE, 'orchestrate', WORKFLOW_ID), stepIds, workflowIds, contentHash)).not.toThrow();
+        expect(workflowIds.get(WORKFLOW_ID)?.filePath).toBe(PEER_A_FILE);
+    });
+    it('throws when the same workflow ID comes from different contents', () => {
+        const { stepIds, workflowIds } = createMaps();
+        const target = {};
+        mergeWorkflowManifest(target, workflowManifest(PEER_A_FILE, 'orchestrate', WORKFLOW_ID), stepIds, workflowIds, hashManifestSource('a'));
+        expect(() => mergeWorkflowManifest(target, workflowManifest(PEER_B_FILE, 'orchestrate', WORKFLOW_ID), stepIds, workflowIds, hashManifestSource('b'))).toThrow(/Duplicate workflow ID/);
+    });
+    it('throws when content hashes are unavailable, even for equal names', () => {
+        const { stepIds, workflowIds } = createMaps();
+        const target = {};
+        mergeWorkflowManifest(target, stepManifest(PEER_A_FILE, 'doWork', STEP_ID), stepIds, workflowIds);
+        expect(() => mergeWorkflowManifest(target, stepManifest(PEER_B_FILE, 'doWork', STEP_ID), stepIds, workflowIds)).toThrow(/Duplicate workflow step ID/);
+    });
+    it('throws when identical contents map the same ID to different symbol names', () => {
+        const { stepIds, workflowIds } = createMaps();
+        const target = {};
+        const contentHash = hashManifestSource('shared');
+        mergeWorkflowManifest(target, stepManifest(PEER_A_FILE, 'doWork', STEP_ID), stepIds, workflowIds, contentHash);
+        expect(() => mergeWorkflowManifest(target, stepManifest(PEER_B_FILE, 'doOtherWork', STEP_ID), stepIds, workflowIds, contentHash)).toThrow(/Duplicate workflow step ID/);
+    });
+    it('allows re-merging the same file without error', () => {
+        const { stepIds, workflowIds } = createMaps();
+        const target = {};
+        const manifest = stepManifest(PEER_A_FILE, 'doWork', STEP_ID);
+        const contentHash = hashManifestSource('export const doWork = 1;');
+        mergeWorkflowManifest(target, manifest, stepIds, workflowIds, contentHash);
+        expect(() => mergeWorkflowManifest(target, manifest, stepIds, workflowIds, contentHash)).not.toThrow();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest-ids.test.js","sourceRoot":"","sources":["../src/manifest-ids.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from 'vitest';\nimport type { WorkflowManifest } from './apply-swc-transform.js';\nimport {\n  hashManifestSource,\n  type ManifestEntryLocation,\n  mergeWorkflowManifest,\n} from './manifest-ids.js';\n\nfunction createMaps() {\n  return {\n    stepIds: new Map<string, ManifestEntryLocation>(),\n    workflowIds: new Map<string, ManifestEntryLocation>(),\n  };\n}\n\nfunction stepManifest(filePath: string, name: string, stepId: string) {\n  return {\n    steps: {\n      [filePath]: {\n        [name]: { stepId },\n      },\n    },\n  } satisfies WorkflowManifest;\n}\n\nfunction workflowManifest(filePath: string, name: string, workflowId: string) {\n  return {\n    workflows: {\n      [filePath]: {\n        [name]: { workflowId },\n      },\n    },\n  } satisfies WorkflowManifest;\n}\n\nconst PEER_A_FILE =\n  'node_modules/.pnpm/pkg@1.0.0_peer-a@1.0.0/node_modules/pkg/dist/steps.js';\nconst PEER_B_FILE =\n  'node_modules/.pnpm/pkg@1.0.0_peer-b@2.0.0/node_modules/pkg/dist/steps.js';\nconst STEP_ID = 'step//pkg/steps@1.0.0//doWork';\nconst WORKFLOW_ID = 'workflow//pkg/steps@1.0.0//orchestrate';\n\ndescribe('mergeWorkflowManifest duplicate ID handling', () => {\n  it('throws when two different files emit the same step ID with different contents', () => {\n    const { stepIds, workflowIds } = createMaps();\n    const target: WorkflowManifest = {};\n\n    mergeWorkflowManifest(\n      target,\n      stepManifest(PEER_A_FILE, 'doWork', STEP_ID),\n      stepIds,\n      workflowIds,\n      hashManifestSource('export const doWork = 1;')\n    );\n\n    expect(() =>\n      mergeWorkflowManifest(\n        target,\n        stepManifest(PEER_B_FILE, 'doWork', STEP_ID),\n        stepIds,\n        workflowIds,\n        hashManifestSource('export const doWork = 2;')\n      )\n    ).toThrow(/Duplicate workflow step ID/);\n  });\n\n  it('deduplicates identical copies of the same module emitting the same step ID', () => {\n    const { stepIds, workflowIds } = createMaps();\n    const target: WorkflowManifest = {};\n    const contentHash = hashManifestSource('export const doWork = 1;');\n\n    mergeWorkflowManifest(\n      target,\n      stepManifest(PEER_A_FILE, 'doWork', STEP_ID),\n      stepIds,\n      workflowIds,\n      contentHash\n    );\n    mergeWorkflowManifest(\n      target,\n      stepManifest(PEER_B_FILE, 'doWork', STEP_ID),\n      stepIds,\n      workflowIds,\n      contentHash\n    );\n\n    // The first registration wins in the ID map...\n    expect(stepIds.get(STEP_ID)?.filePath).toBe(PEER_A_FILE);\n    // ...but both file entries stay in the manifest (both copies register\n    // the same ID at runtime, which is harmless for identical code).\n    expect(Object.keys(target.steps ?? {})).toEqual([PEER_A_FILE, PEER_B_FILE]);\n  });\n\n  it('deduplicates identical copies emitting the same workflow ID', () => {\n    const { stepIds, workflowIds } = createMaps();\n    const target: WorkflowManifest = {};\n    const contentHash = hashManifestSource('export const orchestrate = 1;');\n\n    mergeWorkflowManifest(\n      target,\n      workflowManifest(PEER_A_FILE, 'orchestrate', WORKFLOW_ID),\n      stepIds,\n      workflowIds,\n      contentHash\n    );\n    expect(() =>\n      mergeWorkflowManifest(\n        target,\n        workflowManifest(PEER_B_FILE, 'orchestrate', WORKFLOW_ID),\n        stepIds,\n        workflowIds,\n        contentHash\n      )\n    ).not.toThrow();\n    expect(workflowIds.get(WORKFLOW_ID)?.filePath).toBe(PEER_A_FILE);\n  });\n\n  it('throws when the same workflow ID comes from different contents', () => {\n    const { stepIds, workflowIds } = createMaps();\n    const target: WorkflowManifest = {};\n\n    mergeWorkflowManifest(\n      target,\n      workflowManifest(PEER_A_FILE, 'orchestrate', WORKFLOW_ID),\n      stepIds,\n      workflowIds,\n      hashManifestSource('a')\n    );\n    expect(() =>\n      mergeWorkflowManifest(\n        target,\n        workflowManifest(PEER_B_FILE, 'orchestrate', WORKFLOW_ID),\n        stepIds,\n        workflowIds,\n        hashManifestSource('b')\n      )\n    ).toThrow(/Duplicate workflow ID/);\n  });\n\n  it('throws when content hashes are unavailable, even for equal names', () => {\n    const { stepIds, workflowIds } = createMaps();\n    const target: WorkflowManifest = {};\n\n    mergeWorkflowManifest(\n      target,\n      stepManifest(PEER_A_FILE, 'doWork', STEP_ID),\n      stepIds,\n      workflowIds\n    );\n    expect(() =>\n      mergeWorkflowManifest(\n        target,\n        stepManifest(PEER_B_FILE, 'doWork', STEP_ID),\n        stepIds,\n        workflowIds\n      )\n    ).toThrow(/Duplicate workflow step ID/);\n  });\n\n  it('throws when identical contents map the same ID to different symbol names', () => {\n    const { stepIds, workflowIds } = createMaps();\n    const target: WorkflowManifest = {};\n    const contentHash = hashManifestSource('shared');\n\n    mergeWorkflowManifest(\n      target,\n      stepManifest(PEER_A_FILE, 'doWork', STEP_ID),\n      stepIds,\n      workflowIds,\n      contentHash\n    );\n    expect(() =>\n      mergeWorkflowManifest(\n        target,\n        stepManifest(PEER_B_FILE, 'doOtherWork', STEP_ID),\n        stepIds,\n        workflowIds,\n        contentHash\n      )\n    ).toThrow(/Duplicate workflow step ID/);\n  });\n\n  it('allows re-merging the same file without error', () => {\n    const { stepIds, workflowIds } = createMaps();\n    const target: WorkflowManifest = {};\n    const manifest = stepManifest(PEER_A_FILE, 'doWork', STEP_ID);\n    const contentHash = hashManifestSource('export const doWork = 1;');\n\n    mergeWorkflowManifest(target, manifest, stepIds, workflowIds, contentHash);\n    expect(() =>\n      mergeWorkflowManifest(target, manifest, stepIds, workflowIds, contentHash)\n    ).not.toThrow();\n  });\n});\n"]}

package/dist/step-source-registration.test.js

@@ -78,5 +78,65 @@ describe('step source registration', () => {
         expect(generated).toContain('import "../src/serde.ts";');
         expect(Object.keys(manifest.classes ?? {})).toContain('src/serde.ts');
     });
+    /**
+     * pnpm materializes the same package version once per peer-dependency
+     * resolution (e.g. `.pnpm/step-pkg@1.0.0_peer-a@1.0.0/...` and
+     * `.pnpm/step-pkg@1.0.0_peer-b@2.0.0/...`), with byte-identical files.
+     * Both copies generate the same canonical step ID.
+     */
+    function writePnpmVirtualInstance(peerSuffix, stepSource) {
+        const pkgDir = join(testRoot, 'node_modules', '.pnpm', `step-pkg@1.0.0_${peerSuffix}`, 'node_modules', 'step-pkg');
+        writeFile(join(pkgDir, 'package.json'), JSON.stringify({
+            name: 'step-pkg',
+            version: '1.0.0',
+            exports: { '.': './index.js' },
+        }));
+        const stepFile = join(pkgDir, 'index.js');
+        writeFile(stepFile, stepSource);
+        return stepFile;
+    }
+    it('deduplicates identical pnpm peer-variant package copies', async () => {
+        const stepSource = `export async function runPackagedStep() {
+  'use step';
+  return 1;
+}
+`;
+        const copyA = writePnpmVirtualInstance('peer-a@1.0.0', stepSource);
+        const copyB = writePnpmVirtualInstance('peer-b@2.0.0', stepSource);
+        const outfile = join(testRoot, '.workflow', 'steps.js');
+        mkdirSync(dirname(outfile), { recursive: true });
+        const discoveredEntries = {
+            discoveredSteps: new Set([copyA, copyB]),
+            discoveredWorkflows: new Set(),
+            discoveredSerdeFiles: new Set(),
+        };
+        const { manifest } = await createBuilder(testRoot).createSourceStepRegistrations([copyA, copyB], outfile, discoveredEntries);
+        // Both copies land in the manifest under the same canonical step ID.
+        const stepEntries = Object.values(manifest.steps ?? {});
+        expect(stepEntries).toHaveLength(2);
+        for (const entries of stepEntries) {
+            expect(entries.runPackagedStep.stepId).toBe('step//step-pkg@1.0.0//runPackagedStep');
+        }
+    });
+    it('still rejects pnpm-style package copies whose implementations differ', async () => {
+        const copyA = writePnpmVirtualInstance('peer-a@1.0.0', `export async function runPackagedStep() {
+  'use step';
+  return 1;
+}
+`);
+        const copyB = writePnpmVirtualInstance('peer-b@2.0.0', `export async function runPackagedStep() {
+  'use step';
+  return 2;
+}
+`);
+        const outfile = join(testRoot, '.workflow', 'steps.js');
+        mkdirSync(dirname(outfile), { recursive: true });
+        const discoveredEntries = {
+            discoveredSteps: new Set([copyA, copyB]),
+            discoveredWorkflows: new Set(),
+            discoveredSerdeFiles: new Set(),
+        };
+        await expect(createBuilder(testRoot).createSourceStepRegistrations([copyA, copyB], outfile, discoveredEntries)).rejects.toThrow(/Duplicate workflow step ID/);
+    });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-source-registration.test.js","sourceRoot":"","sources":["../src/step-source-registration.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, type DiscoveredEntries } from './base-builder.js';\nimport type { StandaloneConfig } from './types.js';\n\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    // no-op\n  }\n\n  public createSourceStepRegistrations(\n    inputFiles: string[],\n    outfile: string,\n    discoveredEntries: DiscoveredEntries\n  ) {\n    return this.createStepsBundle({\n      inputFiles,\n      outfile,\n      externalizeNonSteps: true,\n      bundleTransitiveLocalStepDependencies: false,\n      sourceStepRegistrationImports: true,\n      discoveredEntries,\n    });\n  }\n}\n\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(workingDir: string): TestBuilder {\n  const config: StandaloneConfig = {\n    buildTarget: 'standalone',\n    workingDir,\n    dirs: ['.'],\n    stepsBundlePath: join(workingDir, '.workflow', 'steps.js'),\n    workflowsBundlePath: join(workingDir, '.workflow', 'workflows.js'),\n    webhookBundlePath: join(workingDir, '.workflow', 'webhook.js'),\n  };\n  return new TestBuilder(config);\n}\n\ndescribe('step source registration', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'workflow-step-registration-'));\n    writeFile(\n      join(testRoot, 'node_modules', 'workflow', 'package.json'),\n      JSON.stringify({ name: 'workflow', version: '1.0.0' })\n    );\n    writeFile(\n      join(testRoot, 'node_modules', 'workflow', 'internal', 'builtins.js'),\n      'export const __builtins = true;\\n'\n    );\n  });\n\n  afterEach(() => {\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('imports serde-only files for step context class registration', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const stepFile = join(testRoot, 'src', 'step.ts');\n    const serdeFile = join(testRoot, 'src', 'serde.ts');\n    const outfile = join(testRoot, '.workflow', 'steps.js');\n\n    mkdirSync(dirname(outfile), { recursive: true });\n    writeFile(entryFile, `export { runStep } from './step';\\n`);\n    writeFile(\n      stepFile,\n      `export async function runStep() {\n  'use step';\n  return 1;\n}\n`\n    );\n    writeFile(\n      serdeFile,\n      `export class Value {\n  static classId = 'Value';\n  static [Symbol.for('workflow-serialize')](value: Value) {\n    return value;\n  }\n  static [Symbol.for('workflow-deserialize')](value: Value) {\n    return value;\n  }\n}\n`\n    );\n\n    const discoveredEntries: DiscoveredEntries = {\n      discoveredSteps: new Set([stepFile]),\n      discoveredWorkflows: new Set(),\n      discoveredSerdeFiles: new Set([serdeFile]),\n    };\n\n    const { manifest } = await createBuilder(\n      testRoot\n    ).createSourceStepRegistrations([entryFile], outfile, discoveredEntries);\n    const generated = readFileSync(outfile, 'utf-8');\n\n    expect(generated).toContain('import \"workflow/internal/builtins\";');\n    expect(generated).toContain('import \"../src/step.ts\";');\n    expect(generated).toContain('import \"../src/serde.ts\";');\n    expect(Object.keys(manifest.classes ?? {})).toContain('src/serde.ts');\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-source-registration.test.js","sourceRoot":"","sources":["../src/step-source-registration.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, type DiscoveredEntries } from './base-builder.js';\nimport type { StandaloneConfig } from './types.js';\n\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    // no-op\n  }\n\n  public createSourceStepRegistrations(\n    inputFiles: string[],\n    outfile: string,\n    discoveredEntries: DiscoveredEntries\n  ) {\n    return this.createStepsBundle({\n      inputFiles,\n      outfile,\n      externalizeNonSteps: true,\n      bundleTransitiveLocalStepDependencies: false,\n      sourceStepRegistrationImports: true,\n      discoveredEntries,\n    });\n  }\n}\n\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(workingDir: string): TestBuilder {\n  const config: StandaloneConfig = {\n    buildTarget: 'standalone',\n    workingDir,\n    dirs: ['.'],\n    stepsBundlePath: join(workingDir, '.workflow', 'steps.js'),\n    workflowsBundlePath: join(workingDir, '.workflow', 'workflows.js'),\n    webhookBundlePath: join(workingDir, '.workflow', 'webhook.js'),\n  };\n  return new TestBuilder(config);\n}\n\ndescribe('step source registration', () => {\n  let testRoot: string;\n\n  beforeEach(() => {\n    testRoot = mkdtempSync(join(realTmpdir, 'workflow-step-registration-'));\n    writeFile(\n      join(testRoot, 'node_modules', 'workflow', 'package.json'),\n      JSON.stringify({ name: 'workflow', version: '1.0.0' })\n    );\n    writeFile(\n      join(testRoot, 'node_modules', 'workflow', 'internal', 'builtins.js'),\n      'export const __builtins = true;\\n'\n    );\n  });\n\n  afterEach(() => {\n    rmSync(testRoot, { recursive: true, force: true });\n  });\n\n  it('imports serde-only files for step context class registration', async () => {\n    const entryFile = join(testRoot, 'src', 'entry.ts');\n    const stepFile = join(testRoot, 'src', 'step.ts');\n    const serdeFile = join(testRoot, 'src', 'serde.ts');\n    const outfile = join(testRoot, '.workflow', 'steps.js');\n\n    mkdirSync(dirname(outfile), { recursive: true });\n    writeFile(entryFile, `export { runStep } from './step';\\n`);\n    writeFile(\n      stepFile,\n      `export async function runStep() {\n  'use step';\n  return 1;\n}\n`\n    );\n    writeFile(\n      serdeFile,\n      `export class Value {\n  static classId = 'Value';\n  static [Symbol.for('workflow-serialize')](value: Value) {\n    return value;\n  }\n  static [Symbol.for('workflow-deserialize')](value: Value) {\n    return value;\n  }\n}\n`\n    );\n\n    const discoveredEntries: DiscoveredEntries = {\n      discoveredSteps: new Set([stepFile]),\n      discoveredWorkflows: new Set(),\n      discoveredSerdeFiles: new Set([serdeFile]),\n    };\n\n    const { manifest } = await createBuilder(\n      testRoot\n    ).createSourceStepRegistrations([entryFile], outfile, discoveredEntries);\n    const generated = readFileSync(outfile, 'utf-8');\n\n    expect(generated).toContain('import \"workflow/internal/builtins\";');\n    expect(generated).toContain('import \"../src/step.ts\";');\n    expect(generated).toContain('import \"../src/serde.ts\";');\n    expect(Object.keys(manifest.classes ?? {})).toContain('src/serde.ts');\n  });\n\n  /**\n   * pnpm materializes the same package version once per peer-dependency\n   * resolution (e.g. `.pnpm/step-pkg@1.0.0_peer-a@1.0.0/...` and\n   * `.pnpm/step-pkg@1.0.0_peer-b@2.0.0/...`), with byte-identical files.\n   * Both copies generate the same canonical step ID.\n   */\n  function writePnpmVirtualInstance(\n    peerSuffix: string,\n    stepSource: string\n  ): string {\n    const pkgDir = join(\n      testRoot,\n      'node_modules',\n      '.pnpm',\n      `step-pkg@1.0.0_${peerSuffix}`,\n      'node_modules',\n      'step-pkg'\n    );\n    writeFile(\n      join(pkgDir, 'package.json'),\n      JSON.stringify({\n        name: 'step-pkg',\n        version: '1.0.0',\n        exports: { '.': './index.js' },\n      })\n    );\n    const stepFile = join(pkgDir, 'index.js');\n    writeFile(stepFile, stepSource);\n    return stepFile;\n  }\n\n  it('deduplicates identical pnpm peer-variant package copies', async () => {\n    const stepSource = `export async function runPackagedStep() {\n  'use step';\n  return 1;\n}\n`;\n    const copyA = writePnpmVirtualInstance('peer-a@1.0.0', stepSource);\n    const copyB = writePnpmVirtualInstance('peer-b@2.0.0', stepSource);\n    const outfile = join(testRoot, '.workflow', 'steps.js');\n    mkdirSync(dirname(outfile), { recursive: true });\n\n    const discoveredEntries: DiscoveredEntries = {\n      discoveredSteps: new Set([copyA, copyB]),\n      discoveredWorkflows: new Set(),\n      discoveredSerdeFiles: new Set(),\n    };\n\n    const { manifest } = await createBuilder(\n      testRoot\n    ).createSourceStepRegistrations([copyA, copyB], outfile, discoveredEntries);\n\n    // Both copies land in the manifest under the same canonical step ID.\n    const stepEntries = Object.values(manifest.steps ?? {});\n    expect(stepEntries).toHaveLength(2);\n    for (const entries of stepEntries) {\n      expect(entries.runPackagedStep.stepId).toBe(\n        'step//step-pkg@1.0.0//runPackagedStep'\n      );\n    }\n  });\n\n  it('still rejects pnpm-style package copies whose implementations differ', async () => {\n    const copyA = writePnpmVirtualInstance(\n      'peer-a@1.0.0',\n      `export async function runPackagedStep() {\n  'use step';\n  return 1;\n}\n`\n    );\n    const copyB = writePnpmVirtualInstance(\n      'peer-b@2.0.0',\n      `export async function runPackagedStep() {\n  'use step';\n  return 2;\n}\n`\n    );\n    const outfile = join(testRoot, '.workflow', 'steps.js');\n    mkdirSync(dirname(outfile), { recursive: true });\n\n    const discoveredEntries: DiscoveredEntries = {\n      discoveredSteps: new Set([copyA, copyB]),\n      discoveredWorkflows: new Set(),\n      discoveredSerdeFiles: new Set(),\n    };\n\n    await expect(\n      createBuilder(testRoot).createSourceStepRegistrations(\n        [copyA, copyB],\n        outfile,\n        discoveredEntries\n      )\n    ).rejects.toThrow(/Duplicate workflow step ID/);\n  });\n});\n"]}

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":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,0BAA0B,CAAC;AAQlC,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;CAC7C;AAED,MAAM,MAAM,0BAA0B,GAAG,CACvC,MAAM,EAAE,uBAAuB,KAC5B,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,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,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,0BAA0B,CAAC;IAC9C;;;;;;;;;;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;AAkHD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CA6XjE"}
+{"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;AAalC,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;CAC7C;AAED,MAAM,MAAM,0BAA0B,GAAG,CACvC,MAAM,EAAE,uBAAuB,KAC5B,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,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,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,0BAA0B,CAAC;IAC9C;;;;;;;;;;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,CAuYjE"}