@workflow/builders 5.0.0-beta.26 → 5.0.0-beta.28

package/dist/workflows-extractor.test.js

@@ -36,5 +36,35 @@ describe('extractWorkflowGraphs', () => {
         });
         expect(consoleError).not.toHaveBeenCalled();
     });
+    it('extracts step nodes when step proxies include pure annotations', async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'workflow-builders-'));
+        const bundlePath = join(tempDir, 'workflow-bundle.js');
+        await writeFile(bundlePath, [
+            'var stepOne = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./input.ts//stepOne");',
+            'async function testWorkflow(input) {',
+            '  const output = await stepOne(input);',
+            '  return output;',
+            '}',
+            'testWorkflow.workflowId = "workflow//./input.ts//testWorkflow";',
+        ].join('\n'));
+        await expect(extractWorkflowGraphs(bundlePath)).resolves.toEqual({
+            './input.ts': {
+                testWorkflow: expect.objectContaining({
+                    workflowId: 'workflow//./input.ts//testWorkflow',
+                    graph: expect.objectContaining({
+                        nodes: expect.arrayContaining([
+                            expect.objectContaining({
+                                type: 'step',
+                                data: expect.objectContaining({
+                                    label: 'stepOne',
+                                    stepId: 'step//./input.ts//stepOne',
+                                }),
+                            }),
+                        ]),
+                    }),
+                }),
+            },
+        });
+    });
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2Zsb3dzLWV4dHJhY3Rvci50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3dvcmtmbG93cy1leHRyYWN0b3IudGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLEVBQUUsRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUMxRCxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ2pDLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDakMsT0FBTyxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDN0QsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFakUsUUFBUSxDQUFDLHVCQUF1QixFQUFFLEdBQUcsRUFBRTtJQUNyQyxJQUFJLE9BQTJCLENBQUM7SUFFaEMsU0FBUyxDQUFDLEtBQUssSUFBSSxFQUFFO1FBQ25CLEVBQUUsQ0FBQyxlQUFlLEVBQUUsQ0FBQztRQUVyQixJQUFJLE9BQU8sRUFBRSxDQUFDO1lBQ1osTUFBTSxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUNwRCxPQUFPLEdBQUcsU0FBUyxDQUFDO1FBQ3RCLENBQUM7SUFDSCxDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyx1RUFBdUUsRUFBRSxLQUFLLElBQUksRUFBRTtRQUNyRixPQUFPLEdBQUcsTUFBTSxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxFQUFFLG9CQUFvQixDQUFDLENBQUMsQ0FBQztRQUM5RCxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsT0FBTyxFQUFFLG9CQUFvQixDQUFDLENBQUM7UUFDdkQsTUFBTSxZQUFZLEdBQUcsRUFBRTthQUNwQixLQUFLLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQzthQUN2QixrQkFBa0IsQ0FBQyxHQUFHLEVBQUUsR0FBRSxDQUFDLENBQUMsQ0FBQztRQUVoQyxNQUFNLFNBQVMsQ0FDYixVQUFVLEVBQ1Y7WUFDRSx3QkFBd0I7WUFDeEIsdUJBQXVCO1lBQ3ZCLGdFQUFnRTtZQUNoRSxzQkFBc0I7WUFDdEIsR0FBRztZQUNILHlEQUF5RDtZQUN6RCxJQUFJO1NBQ0wsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQ2IsQ0FBQztRQUVGLE1BQU0sTUFBTSxDQUFDLHFCQUFxQixDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQztZQUMvRCxZQUFZLEVBQUU7Z0JBQ1osUUFBUSxFQUFFLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQztvQkFDaEMsVUFBVSxFQUFFLGdDQUFnQztpQkFDN0MsQ0FBQzthQUNIO1NBQ0YsQ0FBQyxDQUFDO1FBQ0gsTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0lBQzlDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBta2R0ZW1wLCBybSwgd3JpdGVGaWxlIH0gZnJvbSAnbm9kZTpmcy9wcm9taXNlcyc7XG5pbXBvcnQgeyB0bXBkaXIgfSBmcm9tICdub2RlOm9zJztcbmltcG9ydCB7IGpvaW4gfSBmcm9tICdub2RlOnBhdGgnO1xuaW1wb3J0IHsgYWZ0ZXJFYWNoLCBkZXNjcmliZSwgZXhwZWN0LCBpdCwgdmkgfSBmcm9tICd2aXRlc3QnO1xuaW1wb3J0IHsgZXh0cmFjdFdvcmtmbG93R3JhcGhzIH0gZnJvbSAnLi93b3JrZmxvd3MtZXh0cmFjdG9yLmpzJztcblxuZGVzY3JpYmUoJ2V4dHJhY3RXb3JrZmxvd0dyYXBocycsICgpID0+IHtcbiAgbGV0IHRlbXBEaXI6IHN0cmluZyB8IHVuZGVmaW5lZDtcblxuICBhZnRlckVhY2goYXN5bmMgKCkgPT4ge1xuICAgIHZpLnJlc3RvcmVBbGxNb2NrcygpO1xuXG4gICAgaWYgKHRlbXBEaXIpIHtcbiAgICAgIGF3YWl0IHJtKHRlbXBEaXIsIHsgcmVjdXJzaXZlOiB0cnVlLCBmb3JjZTogdHJ1ZSB9KTtcbiAgICAgIHRlbXBEaXIgPSB1bmRlZmluZWQ7XG4gICAgfVxuICB9KTtcblxuICBpdCgncGFyc2VzIHdvcmtmbG93Q29kZSB0ZW1wbGF0ZSBsaXRlcmFscyB3aXRoIHVuaWNvZGUtZXNjYXBlIGlkZW50aWZpZXJzJywgYXN5bmMgKCkgPT4ge1xuICAgIHRlbXBEaXIgPSBhd2FpdCBta2R0ZW1wKGpvaW4odG1wZGlyKCksICd3b3JrZmxvdy1idWlsZGVycy0nKSk7XG4gICAgY29uc3QgYnVuZGxlUGF0aCA9IGpvaW4odGVtcERpciwgJ3dvcmtmbG93LWJ1bmRsZS5qcycpO1xuICAgIGNvbnN0IGNvbnNvbGVFcnJvciA9IHZpXG4gICAgICAuc3B5T24oY29uc29sZSwgJ2Vycm9yJylcbiAgICAgIC5tb2NrSW1wbGVtZW50YXRpb24oKCkgPT4ge30pO1xuXG4gICAgYXdhaXQgd3JpdGVGaWxlKFxuICAgICAgYnVuZGxlUGF0aCxcbiAgICAgIFtcbiAgICAgICAgJ2NvbnN0IHdvcmtmbG93Q29kZSA9IGAnLFxuICAgICAgICAnZnVuY3Rpb24gd29ya2Zsb3coKSB7JyxcbiAgICAgICAgJyAgdmFyIERFQlVSUl9NQVAgPSBuZXcgTWFwKE9iamVjdC5lbnRyaWVzKHtcXFxcXFxcXHUwMEM2OiBcIkFlXCJ9KSk7JyxcbiAgICAgICAgJyAgcmV0dXJuIERFQlVSUl9NQVA7JyxcbiAgICAgICAgJ30nLFxuICAgICAgICAnd29ya2Zsb3cud29ya2Zsb3dJZCA9IFwid29ya2Zsb3cvLy4vaW5wdXQuanMvL3dvcmtmbG93XCI7JyxcbiAgICAgICAgJ2A7JyxcbiAgICAgIF0uam9pbignXFxuJylcbiAgICApO1xuXG4gICAgYXdhaXQgZXhwZWN0KGV4dHJhY3RXb3JrZmxvd0dyYXBocyhidW5kbGVQYXRoKSkucmVzb2x2ZXMudG9FcXVhbCh7XG4gICAgICAnLi9pbnB1dC5qcyc6IHtcbiAgICAgICAgd29ya2Zsb3c6IGV4cGVjdC5vYmplY3RDb250YWluaW5nKHtcbiAgICAgICAgICB3b3JrZmxvd0lkOiAnd29ya2Zsb3cvLy4vaW5wdXQuanMvL3dvcmtmbG93JyxcbiAgICAgICAgfSksXG4gICAgICB9LFxuICAgIH0pO1xuICAgIGV4cGVjdChjb25zb2xlRXJyb3IpLm5vdC50b0hhdmVCZWVuQ2FsbGVkKCk7XG4gIH0pO1xufSk7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/world-target.d.ts

@@ -0,0 +1,20 @@
+import type * as esbuild from 'esbuild';
+export declare const WORKFLOW_WORLD_TARGET_MODULE = "@workflow/core/runtime/world-target";
+export declare const WORKFLOW_CORE_RUNTIME_MODULE = "@workflow/core/runtime";
+export { getWorldImport, normalizeWorkflowTargetWorldImport, } from '@workflow/utils';
+export type WorkflowWorldTargetEnvironment = Record<string, string | undefined>;
+export declare function isWorkflowTargetWorldPath(targetWorld: string): boolean;
+export declare function ensureWorkflowTargetWorldEnv(env?: WorkflowWorldTargetEnvironment): string;
+export declare function resolveWorkflowTargetWorldAlias({ workingDir, targetWorld, }: {
+    workingDir: string;
+    targetWorld?: string;
+}): string;
+export declare function resolveWorkflowCoreRuntimeAlias({ workingDir, }: {
+    workingDir: string;
+}): string;
+export declare function createWorkflowWorldTargetEsbuildPlugin({ workingDir, externalPackages, targetWorld, }: {
+    workingDir: string;
+    externalPackages?: string[];
+    targetWorld?: string;
+}): esbuild.Plugin;
+//# sourceMappingURL=world-target.d.ts.map

package/dist/world-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-target.d.ts","sourceRoot":"","sources":["../src/world-target.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,OAAO,MAAM,SAAS,CAAC;AAExC,eAAO,MAAM,4BAA4B,wCACF,CAAC;AACxC,eAAO,MAAM,4BAA4B,2BAA2B,CAAC;AAErE,OAAO,EACL,cAAc,EACd,kCAAkC,GACnC,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,8BAA8B,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAEhF,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAOtE;AAED,wBAAgB,4BAA4B,CAC1C,GAAG,GAAE,8BAA4C,GAChD,MAAM,CAIR;AA6BD,wBAAgB,+BAA+B,CAAC,EAC9C,UAAU,EACV,WAA4C,GAC7C,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,MAAM,CAIT;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,UAAU,GACX,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,MAAM,CAET;AAED,wBAAgB,sCAAsC,CAAC,EACrD,UAAU,EACV,gBAAqB,EACrB,WAA4C,GAC7C,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,MAAM,CA0BjB"}

package/dist/world-target.js

@@ -0,0 +1,74 @@
+import { createRequire } from 'node:module';
+import { isAbsolute, join, win32 } from 'node:path';
+import { getWorldImport, normalizeWorkflowTargetWorldImport, } from '@workflow/utils';
+export const WORKFLOW_WORLD_TARGET_MODULE = '@workflow/core/runtime/world-target';
+export const WORKFLOW_CORE_RUNTIME_MODULE = '@workflow/core/runtime';
+export { getWorldImport, normalizeWorkflowTargetWorldImport, } from '@workflow/utils';
+export function isWorkflowTargetWorldPath(targetWorld) {
+    return (targetWorld.startsWith('./') ||
+        targetWorld.startsWith('../') ||
+        isAbsolute(targetWorld) ||
+        win32.isAbsolute(targetWorld));
+}
+export function ensureWorkflowTargetWorldEnv(env = process.env) {
+    const targetWorld = getWorldImport(env);
+    env.WORKFLOW_TARGET_WORLD = targetWorld;
+    return targetWorld;
+}
+/**
+ * Resolve a module specifier from the app's working directory, falling back
+ * to this package's own dependencies (for built-in worlds the app doesn't
+ * depend on directly), and finally to the bare specifier so callers can
+ * externalize modules that aren't installed.
+ */
+function resolveFromWorkingDir(specifier, workingDir) {
+    let require;
+    try {
+        require = createRequire(join(workingDir, 'package.json'));
+    }
+    catch {
+        require = createRequire(import.meta.url);
+    }
+    try {
+        return require.resolve(specifier, {
+            paths: [workingDir],
+        });
+    }
+    catch {
+        try {
+            return createRequire(import.meta.url).resolve(specifier);
+        }
+        catch {
+            return specifier;
+        }
+    }
+}
+export function resolveWorkflowTargetWorldAlias({ workingDir, targetWorld = ensureWorkflowTargetWorldEnv(), }) {
+    const normalizedTargetWorld = normalizeWorkflowTargetWorldImport(targetWorld) ?? targetWorld;
+    return resolveFromWorkingDir(normalizedTargetWorld, workingDir);
+}
+export function resolveWorkflowCoreRuntimeAlias({ workingDir, }) {
+    return resolveFromWorkingDir(WORKFLOW_CORE_RUNTIME_MODULE, workingDir);
+}
+export function createWorkflowWorldTargetEsbuildPlugin({ workingDir, externalPackages = [], targetWorld = ensureWorkflowTargetWorldEnv(), }) {
+    const normalizedTargetWorld = normalizeWorkflowTargetWorldImport(targetWorld) ?? targetWorld;
+    return {
+        name: 'workflow:world-target',
+        setup(build) {
+            build.onResolve({ filter: /^@workflow\/core\/runtime\/world-target$/ }, () => {
+                if (externalPackages.includes(normalizedTargetWorld)) {
+                    return { path: normalizedTargetWorld, external: true };
+                }
+                const alias = resolveWorkflowTargetWorldAlias({
+                    workingDir,
+                    targetWorld: normalizedTargetWorld,
+                });
+                if (alias === normalizedTargetWorld) {
+                    return { path: normalizedTargetWorld, external: true };
+                }
+                return { path: alias };
+            });
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/world-target.test.d.ts

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

package/dist/world-target.test.d.ts.map

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

package/dist/world-target.test.js

@@ -0,0 +1,106 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { ensureWorkflowTargetWorldEnv, getWorldImport, isWorkflowTargetWorldPath, normalizeWorkflowTargetWorldImport, resolveWorkflowCoreRuntimeAlias, resolveWorkflowTargetWorldAlias, WORKFLOW_CORE_RUNTIME_MODULE, WORKFLOW_WORLD_TARGET_MODULE, } from './world-target.js';
+describe('workflow world target', () => {
+    it('normalizes built-in aliases to package specifiers', () => {
+        expect(normalizeWorkflowTargetWorldImport('local')).toBe('@workflow/world-local');
+        expect(normalizeWorkflowTargetWorldImport('vercel')).toBe('@workflow/world-vercel');
+        expect(normalizeWorkflowTargetWorldImport('@workflow/world-postgres')).toBe('@workflow/world-postgres');
+    });
+    it('defaults to local outside Vercel', () => {
+        expect(getWorldImport({})).toBe('@workflow/world-local');
+    });
+    it('defaults to Vercel when deployed on Vercel', () => {
+        expect(getWorldImport({
+            VERCEL_DEPLOYMENT_ID: 'dpl_123',
+        })).toBe('@workflow/world-vercel');
+    });
+    it('writes the normalized target back to the env object', () => {
+        const env = { WORKFLOW_TARGET_WORLD: 'local' };
+        expect(ensureWorkflowTargetWorldEnv(env)).toBe('@workflow/world-local');
+        expect(env.WORKFLOW_TARGET_WORLD).toBe('@workflow/world-local');
+    });
+    it('resolves package aliases to concrete module paths', () => {
+        const testDir = mkdtempSync(join(tmpdir(), 'workflow-world-target-'));
+        const packageDir = join(testDir, 'node_modules/@workflow/world-custom');
+        mkdirSync(packageDir, { recursive: true });
+        writeFileSync(join(packageDir, 'package.json'), JSON.stringify({
+            name: '@workflow/world-custom',
+            type: 'module',
+            exports: './index.js',
+        }));
+        writeFileSync(join(packageDir, 'index.js'), 'export function createWorld() {}');
+        const alias = resolveWorkflowTargetWorldAlias({
+            workingDir: testDir,
+            targetWorld: '@workflow/world-custom',
+        });
+        try {
+            expect(alias.replace(/\\/g, '/')).toMatch(/node_modules\/@workflow\/world-custom\/index\.js$/);
+        }
+        finally {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('resolves relative module files from the working directory', () => {
+        const testDir = mkdtempSync(join(tmpdir(), 'workflow-world-target-'));
+        const worldFile = join(testDir, 'my-world.ts');
+        writeFileSync(worldFile, 'export function createWorld() {}');
+        const alias = resolveWorkflowTargetWorldAlias({
+            workingDir: testDir,
+            targetWorld: './my-world.ts',
+        });
+        try {
+            expect(alias).toBe(realpathSync(worldFile));
+        }
+        finally {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('detects path-like target worlds', () => {
+        expect(isWorkflowTargetWorldPath('./my-world.ts')).toBe(true);
+        expect(isWorkflowTargetWorldPath('../my-world.ts')).toBe(true);
+        expect(isWorkflowTargetWorldPath('/tmp/my-world.ts')).toBe(true);
+        expect(isWorkflowTargetWorldPath('C:\\repo\\my-world.ts')).toBe(true);
+        expect(isWorkflowTargetWorldPath('@workflow/world-postgres')).toBe(false);
+    });
+    it('keeps unresolved custom aliases externalizable', () => {
+        expect(resolveWorkflowTargetWorldAlias({
+            workingDir: process.cwd(),
+            targetWorld: '@workflow/world-custom',
+        })).toBe('@workflow/world-custom');
+    });
+    it('resolves built-in worlds from the builder package when the app omits them', () => {
+        const testDir = mkdtempSync(join(tmpdir(), 'workflow-world-target-'));
+        try {
+            const alias = resolveWorkflowTargetWorldAlias({
+                workingDir: testDir,
+                targetWorld: '@workflow/world-local',
+            });
+            expect(alias.replace(/\\/g, '/')).toMatch(/packages\/world-local\/dist\/index\.js$/);
+        }
+        finally {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('uses the core target module as the alias key', () => {
+        expect(WORKFLOW_WORLD_TARGET_MODULE).toBe('@workflow/core/runtime/world-target');
+    });
+    it('resolves the core runtime module from the builder package when the app omits it', () => {
+        const testDir = mkdtempSync(join(tmpdir(), 'workflow-world-target-'));
+        try {
+            const alias = resolveWorkflowCoreRuntimeAlias({
+                workingDir: testDir,
+            });
+            expect(alias.replace(/\\/g, '/')).toMatch(/packages\/core\/dist\/runtime\.js$/);
+        }
+        finally {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('uses the core runtime module as the runtime alias key', () => {
+        expect(WORKFLOW_CORE_RUNTIME_MODULE).toBe('@workflow/core/runtime');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"world-target.test.js","sourceRoot":"","sources":["../src/world-target.test.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,WAAW,EACX,YAAY,EACZ,MAAM,EACN,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EACL,4BAA4B,EAC5B,cAAc,EACd,yBAAyB,EACzB,kCAAkC,EAClC,+BAA+B,EAC/B,+BAA+B,EAC/B,4BAA4B,EAC5B,4BAA4B,GAC7B,MAAM,mBAAmB,CAAC;AAE3B,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;IACrC,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,MAAM,CAAC,kCAAkC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CACtD,uBAAuB,CACxB,CAAC;QACF,MAAM,CAAC,kCAAkC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CACvD,wBAAwB,CACzB,CAAC;QACF,MAAM,CAAC,kCAAkC,CAAC,0BAA0B,CAAC,CAAC,CAAC,IAAI,CACzE,0BAA0B,CAC3B,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC1C,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;QACpD,MAAM,CACJ,cAAc,CAAC;YACb,oBAAoB,EAAE,SAAS;SAChC,CAAC,CACH,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;QAC7D,MAAM,GAAG,GAAG,EAAE,qBAAqB,EAAE,OAAO,EAAE,CAAC;QAE/C,MAAM,CAAC,4BAA4B,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;QACxE,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,wBAAwB,CAAC,CAAC,CAAC;QACtE,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,EAAE,qCAAqC,CAAC,CAAC;QACxE,SAAS,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3C,aAAa,CACX,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,EAChC,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,wBAAwB;YAC9B,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,YAAY;SACtB,CAAC,CACH,CAAC;QACF,aAAa,CACX,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,EAC5B,kCAAkC,CACnC,CAAC;QAEF,MAAM,KAAK,GAAG,+BAA+B,CAAC;YAC5C,UAAU,EAAE,OAAO;YACnB,WAAW,EAAE,wBAAwB;SACtC,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,CACvC,mDAAmD,CACpD,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACpD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACnE,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,wBAAwB,CAAC,CAAC,CAAC;QACtE,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QAC/C,aAAa,CAAC,SAAS,EAAE,kCAAkC,CAAC,CAAC;QAE7D,MAAM,KAAK,GAAG,+BAA+B,CAAC;YAC5C,UAAU,EAAE,OAAO;YACnB,WAAW,EAAE,eAAe;SAC7B,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;QAC9C,CAAC;gBAAS,CAAC;YACT,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACpD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;QACzC,MAAM,CAAC,yBAAyB,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9D,MAAM,CAAC,yBAAyB,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/D,MAAM,CAAC,yBAAyB,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjE,MAAM,CAAC,yBAAyB,CAAC,uBAAuB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtE,MAAM,CAAC,yBAAyB,CAAC,0BAA0B,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gDAAgD,EAAE,GAAG,EAAE;QACxD,MAAM,CACJ,+BAA+B,CAAC;YAC9B,UAAU,EAAE,OAAO,CAAC,GAAG,EAAE;YACzB,WAAW,EAAE,wBAAwB;SACtC,CAAC,CACH,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2EAA2E,EAAE,GAAG,EAAE;QACnF,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,wBAAwB,CAAC,CAAC,CAAC;QAEtE,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,+BAA+B,CAAC;gBAC5C,UAAU,EAAE,OAAO;gBACnB,WAAW,EAAE,uBAAuB;aACrC,CAAC,CAAC;YAEH,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,CACvC,yCAAyC,CAC1C,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACpD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;QACtD,MAAM,CAAC,4BAA4B,CAAC,CAAC,IAAI,CACvC,qCAAqC,CACtC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iFAAiF,EAAE,GAAG,EAAE;QACzF,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,wBAAwB,CAAC,CAAC,CAAC;QAEtE,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,+BAA+B,CAAC;gBAC5C,UAAU,EAAE,OAAO;aACpB,CAAC,CAAC;YAEH,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,CACvC,oCAAoC,CACrC,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACpD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAC/D,MAAM,CAAC,4BAA4B,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import {\n  mkdirSync,\n  mkdtempSync,\n  realpathSync,\n  rmSync,\n  writeFileSync,\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { describe, expect, it } from 'vitest';\nimport {\n  ensureWorkflowTargetWorldEnv,\n  getWorldImport,\n  isWorkflowTargetWorldPath,\n  normalizeWorkflowTargetWorldImport,\n  resolveWorkflowCoreRuntimeAlias,\n  resolveWorkflowTargetWorldAlias,\n  WORKFLOW_CORE_RUNTIME_MODULE,\n  WORKFLOW_WORLD_TARGET_MODULE,\n} from './world-target.js';\n\ndescribe('workflow world target', () => {\n  it('normalizes built-in aliases to package specifiers', () => {\n    expect(normalizeWorkflowTargetWorldImport('local')).toBe(\n      '@workflow/world-local'\n    );\n    expect(normalizeWorkflowTargetWorldImport('vercel')).toBe(\n      '@workflow/world-vercel'\n    );\n    expect(normalizeWorkflowTargetWorldImport('@workflow/world-postgres')).toBe(\n      '@workflow/world-postgres'\n    );\n  });\n\n  it('defaults to local outside Vercel', () => {\n    expect(getWorldImport({})).toBe('@workflow/world-local');\n  });\n\n  it('defaults to Vercel when deployed on Vercel', () => {\n    expect(\n      getWorldImport({\n        VERCEL_DEPLOYMENT_ID: 'dpl_123',\n      })\n    ).toBe('@workflow/world-vercel');\n  });\n\n  it('writes the normalized target back to the env object', () => {\n    const env = { WORKFLOW_TARGET_WORLD: 'local' };\n\n    expect(ensureWorkflowTargetWorldEnv(env)).toBe('@workflow/world-local');\n    expect(env.WORKFLOW_TARGET_WORLD).toBe('@workflow/world-local');\n  });\n\n  it('resolves package aliases to concrete module paths', () => {\n    const testDir = mkdtempSync(join(tmpdir(), 'workflow-world-target-'));\n    const packageDir = join(testDir, 'node_modules/@workflow/world-custom');\n    mkdirSync(packageDir, { recursive: true });\n    writeFileSync(\n      join(packageDir, 'package.json'),\n      JSON.stringify({\n        name: '@workflow/world-custom',\n        type: 'module',\n        exports: './index.js',\n      })\n    );\n    writeFileSync(\n      join(packageDir, 'index.js'),\n      'export function createWorld() {}'\n    );\n\n    const alias = resolveWorkflowTargetWorldAlias({\n      workingDir: testDir,\n      targetWorld: '@workflow/world-custom',\n    });\n\n    try {\n      expect(alias.replace(/\\\\/g, '/')).toMatch(\n        /node_modules\\/@workflow\\/world-custom\\/index\\.js$/\n      );\n    } finally {\n      rmSync(testDir, { recursive: true, force: true });\n    }\n  });\n\n  it('resolves relative module files from the working directory', () => {\n    const testDir = mkdtempSync(join(tmpdir(), 'workflow-world-target-'));\n    const worldFile = join(testDir, 'my-world.ts');\n    writeFileSync(worldFile, 'export function createWorld() {}');\n\n    const alias = resolveWorkflowTargetWorldAlias({\n      workingDir: testDir,\n      targetWorld: './my-world.ts',\n    });\n\n    try {\n      expect(alias).toBe(realpathSync(worldFile));\n    } finally {\n      rmSync(testDir, { recursive: true, force: true });\n    }\n  });\n\n  it('detects path-like target worlds', () => {\n    expect(isWorkflowTargetWorldPath('./my-world.ts')).toBe(true);\n    expect(isWorkflowTargetWorldPath('../my-world.ts')).toBe(true);\n    expect(isWorkflowTargetWorldPath('/tmp/my-world.ts')).toBe(true);\n    expect(isWorkflowTargetWorldPath('C:\\\\repo\\\\my-world.ts')).toBe(true);\n    expect(isWorkflowTargetWorldPath('@workflow/world-postgres')).toBe(false);\n  });\n\n  it('keeps unresolved custom aliases externalizable', () => {\n    expect(\n      resolveWorkflowTargetWorldAlias({\n        workingDir: process.cwd(),\n        targetWorld: '@workflow/world-custom',\n      })\n    ).toBe('@workflow/world-custom');\n  });\n\n  it('resolves built-in worlds from the builder package when the app omits them', () => {\n    const testDir = mkdtempSync(join(tmpdir(), 'workflow-world-target-'));\n\n    try {\n      const alias = resolveWorkflowTargetWorldAlias({\n        workingDir: testDir,\n        targetWorld: '@workflow/world-local',\n      });\n\n      expect(alias.replace(/\\\\/g, '/')).toMatch(\n        /packages\\/world-local\\/dist\\/index\\.js$/\n      );\n    } finally {\n      rmSync(testDir, { recursive: true, force: true });\n    }\n  });\n\n  it('uses the core target module as the alias key', () => {\n    expect(WORKFLOW_WORLD_TARGET_MODULE).toBe(\n      '@workflow/core/runtime/world-target'\n    );\n  });\n\n  it('resolves the core runtime module from the builder package when the app omits it', () => {\n    const testDir = mkdtempSync(join(tmpdir(), 'workflow-world-target-'));\n\n    try {\n      const alias = resolveWorkflowCoreRuntimeAlias({\n        workingDir: testDir,\n      });\n\n      expect(alias.replace(/\\\\/g, '/')).toMatch(\n        /packages\\/core\\/dist\\/runtime\\.js$/\n      );\n    } finally {\n      rmSync(testDir, { recursive: true, force: true });\n    }\n  });\n\n  it('uses the core runtime module as the runtime alias key', () => {\n    expect(WORKFLOW_CORE_RUNTIME_MODULE).toBe('@workflow/core/runtime');\n  });\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/builders",
-  "version": "5.0.0-beta.26",
+  "version": "5.0.0-beta.28",
   "description": "Shared builder infrastructure for Workflow SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,9 +40,11 @@
     "find-up": "7.0.0",
     "json5": "2.2.3",
     "tinyglobby": "0.2.17",
-    "@workflow/core": "5.0.0-beta.26",
-    "@workflow/errors": "5.0.0-beta.8",
-    "@workflow/utils": "5.0.0-beta.4",
+    "@workflow/core": "5.0.0-beta.28",
+    "@workflow/errors": "5.0.0-beta.10",
+    "@workflow/utils": "5.0.0-beta.6",
+    "@workflow/world-local": "5.0.0-beta.24",
+    "@workflow/world-vercel": "5.0.0-beta.24",
     "@workflow/swc-plugin": "5.0.0-beta.5"
   },
   "scripts": {