@workflow/builders 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/build-queue.js

@@ -23,4 +23,4 @@ export function createBuildQueue() {
         return queue;
     };
 }
-//# sourceMappingURL=build-queue.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtcXVldWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvYnVpbGQtcXVldWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBQ0gsTUFBTSxVQUFVLGdCQUFnQjtJQUM5QixJQUFJLEtBQUssR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7SUFFOUIsT0FBTyxDQUFDLElBQXlCLEVBQWlCLEVBQUU7UUFDbEQsS0FBSyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUU7WUFDckMsT0FBTyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNyQixDQUFDLENBQUMsQ0FBQztRQUNILE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ3JlYXRlcyBhIGJ1aWxkIHF1ZXVlIHRoYXQgc2VyaWFsaXplcyBhc3luYyB0YXNrcyB0byBwcmV2ZW50IHJhY2UgY29uZGl0aW9ucy5cbiAqXG4gKiBXaGVuIHJhcGlkIGZpbGUgY2hhbmdlcyB0cmlnZ2VyIG11bHRpcGxlIGJ1aWxkcywgdGhpcyBlbnN1cmVzIHRoZXkgcnVuXG4gKiBzZXF1ZW50aWFsbHkgcmF0aGVyIHRoYW4gY29uY3VycmVudGx5LCBhdm9pZGluZyBpc3N1ZXMgbGlrZTpcbiAqIC0gUGFydGlhbCBmaWxlIHJlYWRzIGR1cmluZyB3cml0ZXNcbiAqIC0gQ29ycnVwdGVkIG1lcmdlIG9wZXJhdGlvbnNcbiAqIC0gRHVwbGljYXRlL2NvbmZsaWN0aW5nIGJ1aWxkc1xuICpcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBlbnF1ZXVlID0gY3JlYXRlQnVpbGRRdWV1ZSgpO1xuICpcbiAqIC8vIFRoZXNlIHdpbGwgcnVuIHNlcXVlbnRpYWxseSwgbm90IGNvbmN1cnJlbnRseVxuICogZW5xdWV1ZSgoKSA9PiBidWlsZGVyLmJ1aWxkKCkpO1xuICogZW5xdWV1ZSgoKSA9PiBidWlsZGVyLmJ1aWxkKCkpO1xuICovXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlQnVpbGRRdWV1ZSgpIHtcbiAgbGV0IHF1ZXVlID0gUHJvbWlzZS5yZXNvbHZlKCk7XG5cbiAgcmV0dXJuICh0YXNrOiAoKSA9PiBQcm9taXNlPHZvaWQ+KTogUHJvbWlzZTx2b2lkPiA9PiB7XG4gICAgcXVldWUgPSBxdWV1ZS50aGVuKHRhc2spLmNhdGNoKChlcnIpID0+IHtcbiAgICAgIGNvbnNvbGUuZXJyb3IoZXJyKTtcbiAgICB9KTtcbiAgICByZXR1cm4gcXVldWU7XG4gIH07XG59XG4iXX0=

package/dist/config-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowConfig } from './types.js';
+import type { SourcemapMode, WorkflowConfig } from './types.js';
 export interface DecoratorOptions {
     decorators: boolean;
     legacyDecorator: boolean;
@@ -40,5 +40,8 @@ export declare function createBaseBuilderConfig(options: {
     watch?: boolean;
     externalPackages?: string[];
     runtime?: string;
+    sourcemap?: SourcemapMode;
 }): Omit<WorkflowConfig, 'buildTarget'>;
+export declare function resolveConfiguredProjectRoot(workingDir: string, configuredRoot: string): string;
+export declare function resolveProjectRoot(workingDir: string): string;
 //# sourceMappingURL=config-helpers.d.ts.map

package/dist/config-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-helpers.d.ts","sourceRoot":"","sources":["../src/config-helpers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,gBAAgB,CAAC;IAC1B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED;;;;;;GAMG;AACH,wBAAsB,+BAA+B,CACnD,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,OAAO,CAAC,gBAAgB,CAAC,CAgC3B;AAED;;;;;;GAMG;AACH,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,CAAC,CAG3B;AAED;;;GAGG;AACH,wBAAsB,6CAA6C,CACjE,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,8BAA8B,CAAC,CAMzC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,CAYtC"}
+{"version":3,"file":"config-helpers.d.ts","sourceRoot":"","sources":["../src/config-helpers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,gBAAgB,CAAC;IAC1B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED;;;;;;GAMG;AACH,wBAAsB,+BAA+B,CACnD,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,OAAO,CAAC,gBAAgB,CAAC,CAgC3B;AAED;;;;;;GAMG;AACH,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,CAAC,CAG3B;AAED;;;GAGG;AACH,wBAAsB,6CAA6C,CACjE,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,8BAA8B,CAAC,CAMzC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B,GAAG,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,CAatC;AA6CD,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,MAAM,CAIR;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAmB7D"}

package/dist/config-helpers.js

@@ -1,4 +1,6 @@
+import { statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { findUp } from 'find-up';
 import JSON5 from 'json5';
 /**
@@ -72,6 +74,66 @@ export function createBaseBuilderConfig(options) {
         webhookBundlePath: '', // Not used by base builder methods
         externalPackages: options.externalPackages,
         runtime: options.runtime,
+        sourcemap: options.sourcemap,
     };
 }
-//# sourceMappingURL=config-helpers.js.map
+const WORKSPACE_ROOT_FILES = ['pnpm-workspace.yaml'];
+const PROJECT_ROOT_FILES = [
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lock',
+    'bun.lockb',
+];
+function fileExists(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function findRootFile(names, workingDir) {
+    let current = resolve(workingDir);
+    while (true) {
+        for (const name of names) {
+            const file = join(current, name);
+            if (fileExists(file)) {
+                return file;
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+function findProjectRootFile(workingDir) {
+    return (findRootFile(WORKSPACE_ROOT_FILES, workingDir) ??
+        findRootFile(PROJECT_ROOT_FILES, workingDir));
+}
+export function resolveConfiguredProjectRoot(workingDir, configuredRoot) {
+    return isAbsolute(configuredRoot)
+        ? configuredRoot
+        : resolve(workingDir, configuredRoot);
+}
+export function resolveProjectRoot(workingDir) {
+    let rootFile = findProjectRootFile(workingDir);
+    if (!rootFile) {
+        return resolve(workingDir);
+    }
+    while (true) {
+        const currentDir = dirname(rootFile);
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            return currentDir;
+        }
+        const parentRootFile = findProjectRootFile(parentDir);
+        if (!parentRootFile) {
+            return currentDir;
+        }
+        rootFile = parentRootFile;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-helpers.js","sourceRoot":"","sources":["../src/config-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,OAAO,CAAC;AAc1B;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B,CACnD,YAAgC;IAEhC,MAAM,cAAc,GAAqB;QACvC,UAAU,EAAE,KAAK;QACjB,eAAe,EAAE,KAAK;QACtB,iBAAiB,EAAE,KAAK;KACzB,CAAC;IAEF,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QACtD,MAAM,QAAQ,GACZ,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvB,MAAM,eAAe,GAAG,QAAQ,CAAC,eAAe,IAAI,EAAE,CAAC;QAEvD,qFAAqF;QACrF,MAAM,sBAAsB,GAC1B,eAAe,CAAC,sBAAsB,KAAK,IAAI,CAAC;QAClD,MAAM,qBAAqB,GACzB,eAAe,CAAC,qBAAqB,KAAK,IAAI,CAAC;QAEjD,OAAO;YACL,UAAU,EAAE,sBAAsB;YAClC,eAAe,EAAE,sBAAsB;YACvC,iBAAiB,EAAE,sBAAsB,IAAI,qBAAqB;SACnE,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,0DAA0D;QAC1D,OAAO,cAAc,CAAC;IACxB,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B,CACnD,GAAW;IAEX,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,6CAA6C,CAAC,GAAG,CAAC,CAAC;IAC7E,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,6CAA6C,CACjE,GAAW;IAEX,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,CAAC,eAAe,EAAE,eAAe,CAAC,EAAE;QAClE,GAAG;KACJ,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,MAAM,+BAA+B,CAAC,UAAU,CAAC,CAAC;IAClE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;AACjC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAQvC;IACC,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC;QACnC,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,UAAU,EAAE,OAAO,CAAC,UAAU;QAC9B,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,eAAe,EAAE,EAAE,EAAE,mCAAmC;QACxD,mBAAmB,EAAE,EAAE,EAAE,mCAAmC;QAC5D,iBAAiB,EAAE,EAAE,EAAE,mCAAmC;QAC1D,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;QAC1C,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,SAAS,EAAE,OAAO,CAAC,SAAS;KAC7B,CAAC;AACJ,CAAC;AAED,MAAM,oBAAoB,GAAG,CAAC,qBAAqB,CAAC,CAAC;AACrD,MAAM,kBAAkB,GAAG;IACzB,gBAAgB;IAChB,mBAAmB;IACnB,WAAW;IACX,UAAU;IACV,WAAW;CACZ,CAAC;AAEF,SAAS,UAAU,CAAC,IAAY;IAC9B,IAAI,CAAC;QACH,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CAAC,KAAe,EAAE,UAAkB;IACvD,IAAI,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAElC,OAAO,IAAI,EAAE,CAAC;QACZ,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACjC,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;gBACrB,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;YACvB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,GAAG,MAAM,CAAC;IACnB,CAAC;AACH,CAAC;AAED,SAAS,mBAAmB,CAAC,UAAkB;IAC7C,OAAO,CACL,YAAY,CAAC,oBAAoB,EAAE,UAAU,CAAC;QAC9C,YAAY,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAC7C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,4BAA4B,CAC1C,UAAkB,EAClB,cAAsB;IAEtB,OAAO,UAAU,CAAC,cAAc,CAAC;QAC/B,CAAC,CAAC,cAAc;QAChB,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,UAAkB;IACnD,IAAI,QAAQ,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC;IAC/C,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO,IAAI,EAAE,CAAC;QACZ,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QACrC,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;QACtC,IAAI,SAAS,KAAK,UAAU,EAAE,CAAC;YAC7B,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,MAAM,cAAc,GAAG,mBAAmB,CAAC,SAAS,CAAC,CAAC;QACtD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,QAAQ,GAAG,cAAc,CAAC;IAC5B,CAAC;AACH,CAAC","sourcesContent":["import { statSync } from 'node:fs';\nimport { readFile } from 'node:fs/promises';\nimport { dirname, isAbsolute, join, resolve } from 'node:path';\nimport { findUp } from 'find-up';\nimport JSON5 from 'json5';\nimport type { SourcemapMode, WorkflowConfig } from './types.js';\n\nexport interface DecoratorOptions {\n  decorators: boolean;\n  legacyDecorator: boolean;\n  decoratorMetadata: boolean;\n}\n\nexport interface DecoratorOptionsWithConfigPath {\n  options: DecoratorOptions;\n  configPath: string | undefined;\n}\n\n/**\n * Reads tsconfig.json and extracts decorator-related compiler options.\n * Returns decorator options based on experimentalDecorators and emitDecoratorMetadata settings.\n *\n * @param tsconfigPath - Path to tsconfig.json or jsconfig.json\n * @returns DecoratorOptions with settings based on tsconfig compilerOptions\n */\nexport async function getDecoratorOptionsFromTsConfig(\n  tsconfigPath: string | undefined\n): Promise<DecoratorOptions> {\n  const defaultOptions: DecoratorOptions = {\n    decorators: false,\n    legacyDecorator: false,\n    decoratorMetadata: false,\n  };\n\n  if (!tsconfigPath) {\n    return defaultOptions;\n  }\n\n  try {\n    const content = await readFile(tsconfigPath, 'utf-8');\n    const tsconfig: { compilerOptions?: Record<string, unknown> } =\n      JSON5.parse(content);\n    const compilerOptions = tsconfig.compilerOptions || {};\n\n    // Match Next.js behavior: enable decorators only when experimentalDecorators is true\n    const experimentalDecorators =\n      compilerOptions.experimentalDecorators === true;\n    const emitDecoratorMetadata =\n      compilerOptions.emitDecoratorMetadata === true;\n\n    return {\n      decorators: experimentalDecorators,\n      legacyDecorator: experimentalDecorators,\n      decoratorMetadata: experimentalDecorators && emitDecoratorMetadata,\n    };\n  } catch {\n    // If we can't read or parse the tsconfig, return defaults\n    return defaultOptions;\n  }\n}\n\n/**\n * Finds tsconfig.json in the given directory (or ancestors) and extracts decorator options.\n * Combines tsconfig discovery with decorator option extraction for convenience.\n *\n * @param cwd - Directory to start searching for tsconfig.json\n * @returns DecoratorOptions with settings based on tsconfig compilerOptions\n */\nexport async function getDecoratorOptionsForDirectory(\n  cwd: string\n): Promise<DecoratorOptions> {\n  const { options } = await getDecoratorOptionsForDirectoryWithConfigPath(cwd);\n  return options;\n}\n\n/**\n * Finds tsconfig.json/jsconfig.json in the given directory tree and returns\n * both decorator options and the config path used to derive them.\n */\nexport async function getDecoratorOptionsForDirectoryWithConfigPath(\n  cwd: string\n): Promise<DecoratorOptionsWithConfigPath> {\n  const configPath = await findUp(['tsconfig.json', 'jsconfig.json'], {\n    cwd,\n  });\n  const options = await getDecoratorOptionsFromTsConfig(configPath);\n  return { options, configPath };\n}\n\n/**\n * Creates a partial configuration for builders that don't use bundle paths directly.\n * Used by framework integrations like Nitro where the builder computes paths internally.\n */\nexport function createBaseBuilderConfig(options: {\n  workingDir: string;\n  projectRoot?: string;\n  dirs?: string[];\n  watch?: boolean;\n  externalPackages?: string[];\n  runtime?: string;\n  sourcemap?: SourcemapMode;\n}): Omit<WorkflowConfig, 'buildTarget'> {\n  return {\n    dirs: options.dirs ?? ['workflows'],\n    projectRoot: options.projectRoot,\n    workingDir: options.workingDir,\n    watch: options.watch,\n    stepsBundlePath: '', // Not used by base builder methods\n    workflowsBundlePath: '', // Not used by base builder methods\n    webhookBundlePath: '', // Not used by base builder methods\n    externalPackages: options.externalPackages,\n    runtime: options.runtime,\n    sourcemap: options.sourcemap,\n  };\n}\n\nconst WORKSPACE_ROOT_FILES = ['pnpm-workspace.yaml'];\nconst PROJECT_ROOT_FILES = [\n  'pnpm-lock.yaml',\n  'package-lock.json',\n  'yarn.lock',\n  'bun.lock',\n  'bun.lockb',\n];\n\nfunction fileExists(path: string): boolean {\n  try {\n    return statSync(path).isFile();\n  } catch {\n    return false;\n  }\n}\n\nfunction findRootFile(names: string[], workingDir: string): string | undefined {\n  let current = resolve(workingDir);\n\n  while (true) {\n    for (const name of names) {\n      const file = join(current, name);\n      if (fileExists(file)) {\n        return file;\n      }\n    }\n\n    const parent = dirname(current);\n    if (parent === current) {\n      return undefined;\n    }\n    current = parent;\n  }\n}\n\nfunction findProjectRootFile(workingDir: string): string | undefined {\n  return (\n    findRootFile(WORKSPACE_ROOT_FILES, workingDir) ??\n    findRootFile(PROJECT_ROOT_FILES, workingDir)\n  );\n}\n\nexport function resolveConfiguredProjectRoot(\n  workingDir: string,\n  configuredRoot: string\n): string {\n  return isAbsolute(configuredRoot)\n    ? configuredRoot\n    : resolve(workingDir, configuredRoot);\n}\n\nexport function resolveProjectRoot(workingDir: string): string {\n  let rootFile = findProjectRootFile(workingDir);\n  if (!rootFile) {\n    return resolve(workingDir);\n  }\n\n  while (true) {\n    const currentDir = dirname(rootFile);\n    const parentDir = dirname(currentDir);\n    if (parentDir === currentDir) {\n      return currentDir;\n    }\n\n    const parentRootFile = findProjectRootFile(parentDir);\n    if (!parentRootFile) {\n      return currentDir;\n    }\n    rootFile = parentRootFile;\n  }\n}\n"]}

package/dist/config-helpers.test.d.ts

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

package/dist/config-helpers.test.d.ts.map

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

package/dist/config-helpers.test.js

@@ -0,0 +1,17 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it, onTestFinished } from 'vitest';
+import { resolveProjectRoot } from './config-helpers.js';
+describe('resolveProjectRoot', () => {
+    it('prefers the workspace root over app lockfiles', () => {
+        const repoRoot = mkdtempSync(join(tmpdir(), 'workflow-project-root-'));
+        onTestFinished(() => rmSync(repoRoot, { recursive: true, force: true }));
+        const appRoot = join(repoRoot, 'apps/web');
+        mkdirSync(appRoot, { recursive: true });
+        writeFileSync(join(repoRoot, 'pnpm-workspace.yaml'), 'packages: []\n');
+        writeFileSync(join(appRoot, 'package-lock.json'), '{}\n');
+        expect(resolveProjectRoot(appRoot)).toBe(repoRoot);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/constants.d.ts

@@ -1,8 +1,23 @@
 /**
- * Queue trigger configuration for workflow step execution.
- * Steps are queued to the __wkf_step_* topic.
+ * Creates a queue trigger configuration for the workflow handler.
+ * Handles both workflow orchestration and step execution on the same route.
+ * Background steps are queued back to the workflow topic with a stepId.
+ *
+ * When `namespace` is provided, the trigger topic is scoped to avoid
+ * collisions with other frameworks or direct Workflow SDK usage in the
+ * same deployment.
+ *
+ * @example
+ * // default: topic = '__wkf_workflow_*'
+ * createWorkflowQueueTrigger()
+ *
+ * @example
+ * // namespaced: topic = '__custom_wkf_workflow_*'
+ * createWorkflowQueueTrigger({ namespace: 'custom' })
  */
-export declare const STEP_QUEUE_TRIGGER: {
+export declare function createWorkflowQueueTrigger(options?: {
+    namespace?: string;
+}): {
     type: "queue/v2beta";
     topic: string;
     consumer: string;
@@ -10,8 +25,19 @@ export declare const STEP_QUEUE_TRIGGER: {
     initialDelaySeconds: number;
 };
 /**
- * Queue trigger configuration for workflow orchestration.
- * Workflows are queued to the __wkf_workflow_* topic.
+ * Creates the optional second argument for generated `workflowEntrypoint()`
+ * calls. The namespace is resolved while building so generated route files do
+ * not need `WORKFLOW_QUEUE_NAMESPACE` at runtime.
+ */
+export declare function createWorkflowEntrypointOptionsCode(options?: {
+    namespace?: string;
+    basePath?: string;
+    /** Raw code identifier/expression emitted into generated route files, not data. */
+    routeModuleBodyStartedAt?: string;
+}): string;
+export declare function createWorkflowRouteHandlersCode(workflowEntrypointCall: string): string;
+/**
+ * Default queue trigger (no namespace). Backward compatible.
  */
 export declare const WORKFLOW_QUEUE_TRIGGER: {
     type: "queue/v2beta";
@@ -20,4 +46,39 @@ export declare const WORKFLOW_QUEUE_TRIGGER: {
     retryAfterSeconds: number;
     initialDelaySeconds: number;
 };
+/**
+ * Returns the queue trigger configuration for workflow (flow) routes.
+ *
+ * Builds on `createWorkflowQueueTrigger()` — the namespace comes from
+ * `options` or `WORKFLOW_QUEUE_NAMESPACE`, resolved at call time. When
+ * `WORKFLOW_SEQUENTIAL_REPLAYS` is enabled, sets `maxConcurrency: 1` so the
+ * queue processes at most one flow invocation per concrete topic at a time.
+ * Paired with the per-run physical topic naming in `@workflow/world-vercel`
+ * (which appends the run id to the flow topic), this enforces at most one
+ * orchestrator invocation per run. Queued step invocations share this flow
+ * trigger rather than using a separate route.
+ *
+ * Integrations that write their own flow trigger config instead of calling
+ * this must mirror the conditional `maxConcurrency: 1` themselves — the
+ * runtime half (per-run topics) activates from the env var alone, and without
+ * the trigger half those topics are not serialized.
+ *
+ * Must be read at build time, where the env var gates what is written into
+ * the route's `experimentalTriggers` config.
+ */
+/**
+ * Whether sequential replays are enabled (`WORKFLOW_SEQUENTIAL_REPLAYS=1`). Read
+ * at call time.
+ */
+export declare function isSequentialReplaysEnabled(): boolean;
+export declare function getWorkflowQueueTrigger(options?: {
+    namespace?: string;
+}): {
+    maxConcurrency?: number | undefined;
+    type: "queue/v2beta";
+    topic: string;
+    consumer: string;
+    retryAfterSeconds: number;
+    initialDelaySeconds: number;
+};
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;CAM9B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;CAMlC,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;EAU1E;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,CAAC,EAAE;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC,UAyBA;AAED,wBAAgB,+BAA+B,CAC7C,sBAAsB,EAAE,MAAM,UAM/B;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;CAA+B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,wBAAgB,uBAAuB,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;EAOvE"}

package/dist/constants.js

@@ -1,23 +1,110 @@
+const QUEUE_NAMESPACE_PATTERN = /^[a-z][a-z0-9]*$/;
+function resolveQueueNamespace(namespace) {
+    return namespace ?? process.env.WORKFLOW_QUEUE_NAMESPACE ?? undefined;
+}
+function getQueueTopicPrefix(namespace) {
+    if (namespace !== undefined) {
+        if (!QUEUE_NAMESPACE_PATTERN.test(namespace)) {
+            throw new Error(`Invalid queue namespace "${namespace}": must be lowercase alphanumeric, starting with a letter`);
+        }
+        return `__${namespace}_wkf_workflow_`;
+    }
+    return '__wkf_workflow_';
+}
 /**
- * Queue trigger configuration for workflow step execution.
- * Steps are queued to the __wkf_step_* topic.
+ * Creates a queue trigger configuration for the workflow handler.
+ * Handles both workflow orchestration and step execution on the same route.
+ * Background steps are queued back to the workflow topic with a stepId.
+ *
+ * When `namespace` is provided, the trigger topic is scoped to avoid
+ * collisions with other frameworks or direct Workflow SDK usage in the
+ * same deployment.
+ *
+ * @example
+ * // default: topic = '__wkf_workflow_*'
+ * createWorkflowQueueTrigger()
+ *
+ * @example
+ * // namespaced: topic = '__custom_wkf_workflow_*'
+ * createWorkflowQueueTrigger({ namespace: 'custom' })
  */
-export const STEP_QUEUE_TRIGGER = {
-    type: 'queue/v2beta',
-    topic: '__wkf_step_*',
-    consumer: 'default',
-    retryAfterSeconds: 5, // Delay between retries (default: 60)
-    initialDelaySeconds: 0, // Initial delay before first delivery (default: 0)
-};
+export function createWorkflowQueueTrigger(options) {
+    const namespace = resolveQueueNamespace(options?.namespace);
+    return {
+        type: 'queue/v2beta',
+        topic: `${getQueueTopicPrefix(namespace)}*`,
+        consumer: 'default',
+        retryAfterSeconds: 5, // Delay between retries (default: 60)
+        initialDelaySeconds: 0, // Initial delay before first delivery (default: 0)
+    };
+}
 /**
- * Queue trigger configuration for workflow orchestration.
- * Workflows are queued to the __wkf_workflow_* topic.
+ * Creates the optional second argument for generated `workflowEntrypoint()`
+ * calls. The namespace is resolved while building so generated route files do
+ * not need `WORKFLOW_QUEUE_NAMESPACE` at runtime.
  */
-export const WORKFLOW_QUEUE_TRIGGER = {
-    type: 'queue/v2beta',
-    topic: '__wkf_workflow_*',
-    consumer: 'default',
-    retryAfterSeconds: 5, // Delay between retries (default: 60)
-    initialDelaySeconds: 0, // Initial delay before first delivery (default: 0)
-};
-//# sourceMappingURL=constants.js.map
+export function createWorkflowEntrypointOptionsCode(options) {
+    const namespace = resolveQueueNamespace(options?.namespace);
+    const fields = [];
+    if (namespace) {
+        // Reuse prefix construction for namespace validation.
+        getQueueTopicPrefix(namespace);
+        fields.push(`namespace: ${JSON.stringify(namespace)}`);
+    }
+    if (options?.basePath !== undefined) {
+        fields.push(`basePath: ${JSON.stringify(options.basePath)}`);
+    }
+    if (options?.routeModuleBodyStartedAt) {
+        fields.push(`routeModuleBodyStartedAt: ${options.routeModuleBodyStartedAt}`);
+    }
+    if (fields.length === 0) {
+        return '';
+    }
+    return `, { ${fields.join(', ')} }`;
+}
+export function createWorkflowRouteHandlersCode(workflowEntrypointCall) {
+    return `export const POST = ${workflowEntrypointCall};
+export const GET = POST;
+export const HEAD = POST;
+export const OPTIONS = POST;`;
+}
+/**
+ * Default queue trigger (no namespace). Backward compatible.
+ */
+export const WORKFLOW_QUEUE_TRIGGER = createWorkflowQueueTrigger();
+/**
+ * Returns the queue trigger configuration for workflow (flow) routes.
+ *
+ * Builds on `createWorkflowQueueTrigger()` — the namespace comes from
+ * `options` or `WORKFLOW_QUEUE_NAMESPACE`, resolved at call time. When
+ * `WORKFLOW_SEQUENTIAL_REPLAYS` is enabled, sets `maxConcurrency: 1` so the
+ * queue processes at most one flow invocation per concrete topic at a time.
+ * Paired with the per-run physical topic naming in `@workflow/world-vercel`
+ * (which appends the run id to the flow topic), this enforces at most one
+ * orchestrator invocation per run. Queued step invocations share this flow
+ * trigger rather than using a separate route.
+ *
+ * Integrations that write their own flow trigger config instead of calling
+ * this must mirror the conditional `maxConcurrency: 1` themselves — the
+ * runtime half (per-run topics) activates from the env var alone, and without
+ * the trigger half those topics are not serialized.
+ *
+ * Must be read at build time, where the env var gates what is written into
+ * the route's `experimentalTriggers` config.
+ */
+/**
+ * Whether sequential replays are enabled (`WORKFLOW_SEQUENTIAL_REPLAYS=1`). Read
+ * at call time.
+ */
+export function isSequentialReplaysEnabled() {
+    return process.env.WORKFLOW_SEQUENTIAL_REPLAYS === '1';
+}
+export function getWorkflowQueueTrigger(options) {
+    return {
+        ...createWorkflowQueueTrigger(options),
+        ...(isSequentialReplaysEnabled() && {
+            maxConcurrency: 1,
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,uBAAuB,GAAG,kBAAkB,CAAC;AAEnD,SAAS,qBAAqB,CAAC,SAAkB;IAC/C,OAAO,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,wBAAwB,IAAI,SAAS,CAAC;AACxE,CAAC;AAED,SAAS,mBAAmB,CAAC,SAAkB;IAC7C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CACb,4BAA4B,SAAS,2DAA2D,CACjG,CAAC;QACJ,CAAC;QAED,OAAO,KAAK,SAAS,gBAAgB,CAAC;IACxC,CAAC;IAED,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,0BAA0B,CAAC,OAAgC;IACzE,MAAM,SAAS,GAAG,qBAAqB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAE5D,OAAO;QACL,IAAI,EAAE,cAAuB;QAC7B,KAAK,EAAE,GAAG,mBAAmB,CAAC,SAAS,CAAC,GAAG;QAC3C,QAAQ,EAAE,SAAS;QACnB,iBAAiB,EAAE,CAAC,EAAE,sCAAsC;QAC5D,mBAAmB,EAAE,CAAC,EAAE,mDAAmD;KAC5E,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mCAAmC,CAAC,OAKnD;IACC,MAAM,SAAS,GAAG,qBAAqB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC5D,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,IAAI,SAAS,EAAE,CAAC;QACd,sDAAsD;QACtD,mBAAmB,CAAC,SAAS,CAAC,CAAC;QAC/B,MAAM,CAAC,IAAI,CAAC,cAAc,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IACzD,CAAC;IAED,IAAI,OAAO,EAAE,QAAQ,KAAK,SAAS,EAAE,CAAC;QACpC,MAAM,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED,IAAI,OAAO,EAAE,wBAAwB,EAAE,CAAC;QACtC,MAAM,CAAC,IAAI,CACT,6BAA6B,OAAO,CAAC,wBAAwB,EAAE,CAChE,CAAC;IACJ,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,+BAA+B,CAC7C,sBAA8B;IAE9B,OAAO,uBAAuB,sBAAsB;;;6BAGzB,CAAC;AAC9B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,0BAA0B,EAAE,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;GAGG;AACH,MAAM,UAAU,0BAA0B;IACxC,OAAO,OAAO,CAAC,GAAG,CAAC,2BAA2B,KAAK,GAAG,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,OAAgC;IACtE,OAAO;QACL,GAAG,0BAA0B,CAAC,OAAO,CAAC;QACtC,GAAG,CAAC,0BAA0B,EAAE,IAAI;YAClC,cAAc,EAAE,CAAC;SAClB,CAAC;KACH,CAAC;AACJ,CAAC","sourcesContent":["const QUEUE_NAMESPACE_PATTERN = /^[a-z][a-z0-9]*$/;\n\nfunction resolveQueueNamespace(namespace?: string): string | undefined {\n  return namespace ?? process.env.WORKFLOW_QUEUE_NAMESPACE ?? undefined;\n}\n\nfunction getQueueTopicPrefix(namespace?: string) {\n  if (namespace !== undefined) {\n    if (!QUEUE_NAMESPACE_PATTERN.test(namespace)) {\n      throw new Error(\n        `Invalid queue namespace \"${namespace}\": must be lowercase alphanumeric, starting with a letter`\n      );\n    }\n\n    return `__${namespace}_wkf_workflow_`;\n  }\n\n  return '__wkf_workflow_';\n}\n\n/**\n * Creates a queue trigger configuration for the workflow handler.\n * Handles both workflow orchestration and step execution on the same route.\n * Background steps are queued back to the workflow topic with a stepId.\n *\n * When `namespace` is provided, the trigger topic is scoped to avoid\n * collisions with other frameworks or direct Workflow SDK usage in the\n * same deployment.\n *\n * @example\n * // default: topic = '__wkf_workflow_*'\n * createWorkflowQueueTrigger()\n *\n * @example\n * // namespaced: topic = '__custom_wkf_workflow_*'\n * createWorkflowQueueTrigger({ namespace: 'custom' })\n */\nexport function createWorkflowQueueTrigger(options?: { namespace?: string }) {\n  const namespace = resolveQueueNamespace(options?.namespace);\n\n  return {\n    type: 'queue/v2beta' as const,\n    topic: `${getQueueTopicPrefix(namespace)}*`,\n    consumer: 'default',\n    retryAfterSeconds: 5, // Delay between retries (default: 60)\n    initialDelaySeconds: 0, // Initial delay before first delivery (default: 0)\n  };\n}\n\n/**\n * Creates the optional second argument for generated `workflowEntrypoint()`\n * calls. The namespace is resolved while building so generated route files do\n * not need `WORKFLOW_QUEUE_NAMESPACE` at runtime.\n */\nexport function createWorkflowEntrypointOptionsCode(options?: {\n  namespace?: string;\n  basePath?: string;\n  /** Raw code identifier/expression emitted into generated route files, not data. */\n  routeModuleBodyStartedAt?: string;\n}) {\n  const namespace = resolveQueueNamespace(options?.namespace);\n  const fields: string[] = [];\n\n  if (namespace) {\n    // Reuse prefix construction for namespace validation.\n    getQueueTopicPrefix(namespace);\n    fields.push(`namespace: ${JSON.stringify(namespace)}`);\n  }\n\n  if (options?.basePath !== undefined) {\n    fields.push(`basePath: ${JSON.stringify(options.basePath)}`);\n  }\n\n  if (options?.routeModuleBodyStartedAt) {\n    fields.push(\n      `routeModuleBodyStartedAt: ${options.routeModuleBodyStartedAt}`\n    );\n  }\n\n  if (fields.length === 0) {\n    return '';\n  }\n\n  return `, { ${fields.join(', ')} }`;\n}\n\nexport function createWorkflowRouteHandlersCode(\n  workflowEntrypointCall: string\n) {\n  return `export const POST = ${workflowEntrypointCall};\nexport const GET = POST;\nexport const HEAD = POST;\nexport const OPTIONS = POST;`;\n}\n\n/**\n * Default queue trigger (no namespace). Backward compatible.\n */\nexport const WORKFLOW_QUEUE_TRIGGER = createWorkflowQueueTrigger();\n\n/**\n * Returns the queue trigger configuration for workflow (flow) routes.\n *\n * Builds on `createWorkflowQueueTrigger()` — the namespace comes from\n * `options` or `WORKFLOW_QUEUE_NAMESPACE`, resolved at call time. When\n * `WORKFLOW_SEQUENTIAL_REPLAYS` is enabled, sets `maxConcurrency: 1` so the\n * queue processes at most one flow invocation per concrete topic at a time.\n * Paired with the per-run physical topic naming in `@workflow/world-vercel`\n * (which appends the run id to the flow topic), this enforces at most one\n * orchestrator invocation per run. Queued step invocations share this flow\n * trigger rather than using a separate route.\n *\n * Integrations that write their own flow trigger config instead of calling\n * this must mirror the conditional `maxConcurrency: 1` themselves — the\n * runtime half (per-run topics) activates from the env var alone, and without\n * the trigger half those topics are not serialized.\n *\n * Must be read at build time, where the env var gates what is written into\n * the route's `experimentalTriggers` config.\n */\n/**\n * Whether sequential replays are enabled (`WORKFLOW_SEQUENTIAL_REPLAYS=1`). Read\n * at call time.\n */\nexport function isSequentialReplaysEnabled(): boolean {\n  return process.env.WORKFLOW_SEQUENTIAL_REPLAYS === '1';\n}\n\nexport function getWorkflowQueueTrigger(options?: { namespace?: string }) {\n  return {\n    ...createWorkflowQueueTrigger(options),\n    ...(isSequentialReplaysEnabled() && {\n      maxConcurrency: 1,\n    }),\n  };\n}\n"]}

package/dist/constants.test.d.ts

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

package/dist/constants.test.d.ts.map

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

package/dist/constants.test.js

@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createWorkflowEntrypointOptionsCode, createWorkflowQueueTrigger, getWorkflowQueueTrigger, } from './constants.js';
+describe('getWorkflowQueueTrigger', () => {
+    let originalStrict;
+    beforeEach(() => {
+        originalStrict = process.env.WORKFLOW_SEQUENTIAL_REPLAYS;
+    });
+    afterEach(() => {
+        if (originalStrict !== undefined) {
+            process.env.WORKFLOW_SEQUENTIAL_REPLAYS = originalStrict;
+        }
+        else {
+            delete process.env.WORKFLOW_SEQUENTIAL_REPLAYS;
+        }
+    });
+    it('omits maxConcurrency by default', () => {
+        delete process.env.WORKFLOW_SEQUENTIAL_REPLAYS;
+        const trigger = getWorkflowQueueTrigger();
+        expect(trigger.topic).toBe('__wkf_workflow_*');
+        expect('maxConcurrency' in trigger).toBe(false);
+    });
+    it('sets maxConcurrency: 1 when WORKFLOW_SEQUENTIAL_REPLAYS=1', () => {
+        process.env.WORKFLOW_SEQUENTIAL_REPLAYS = '1';
+        const trigger = getWorkflowQueueTrigger();
+        expect(trigger).toMatchObject({
+            topic: '__wkf_workflow_*',
+            maxConcurrency: 1,
+        });
+    });
+    it('does not set maxConcurrency for non-"1" values', () => {
+        process.env.WORKFLOW_SEQUENTIAL_REPLAYS = 'true';
+        const trigger = getWorkflowQueueTrigger();
+        expect('maxConcurrency' in trigger).toBe(false);
+    });
+    it('composes with an explicit namespace option', () => {
+        process.env.WORKFLOW_SEQUENTIAL_REPLAYS = '1';
+        expect(getWorkflowQueueTrigger({ namespace: 'custom' })).toMatchObject({
+            topic: '__custom_wkf_workflow_*',
+            maxConcurrency: 1,
+        });
+    });
+    it('resolves WORKFLOW_QUEUE_NAMESPACE at call time', () => {
+        delete process.env.WORKFLOW_SEQUENTIAL_REPLAYS;
+        process.env.WORKFLOW_QUEUE_NAMESPACE = 'callns';
+        try {
+            expect(getWorkflowQueueTrigger().topic).toBe('__callns_wkf_workflow_*');
+        }
+        finally {
+            delete process.env.WORKFLOW_QUEUE_NAMESPACE;
+        }
+    });
+});
+describe('createWorkflowQueueTrigger', () => {
+    afterEach(() => {
+        delete process.env.WORKFLOW_QUEUE_NAMESPACE;
+    });
+    it('uses the default workflow topic without a namespace', () => {
+        expect(createWorkflowQueueTrigger().topic).toBe('__wkf_workflow_*');
+    });
+    it('uses an explicit namespace when provided', () => {
+        expect(createWorkflowQueueTrigger({ namespace: 'custom' }).topic).toBe('__custom_wkf_workflow_*');
+    });
+    it('uses WORKFLOW_QUEUE_NAMESPACE when no explicit namespace is provided', () => {
+        process.env.WORKFLOW_QUEUE_NAMESPACE = 'custom';
+        expect(createWorkflowQueueTrigger().topic).toBe('__custom_wkf_workflow_*');
+    });
+});
+describe('createWorkflowEntrypointOptionsCode', () => {
+    afterEach(() => {
+        delete process.env.WORKFLOW_QUEUE_NAMESPACE;
+    });
+    it('omits runtime options without a namespace', () => {
+        expect(createWorkflowEntrypointOptionsCode()).toBe('');
+    });
+    it('inlines an explicit namespace', () => {
+        expect(createWorkflowEntrypointOptionsCode({ namespace: 'custom' })).toBe(', { namespace: "custom" }');
+    });
+    it('inlines WORKFLOW_QUEUE_NAMESPACE at build time', () => {
+        process.env.WORKFLOW_QUEUE_NAMESPACE = 'custom';
+        expect(createWorkflowEntrypointOptionsCode()).toBe(', { namespace: "custom" }');
+    });
+    it('inlines route module timing with namespace options', () => {
+        expect(createWorkflowEntrypointOptionsCode({
+            namespace: 'custom',
+            basePath: '/v2',
+            routeModuleBodyStartedAt: 'workflowRouteModuleBodyStartedAt',
+        })).toBe(', { namespace: "custom", basePath: "/v2", routeModuleBodyStartedAt: workflowRouteModuleBodyStartedAt }');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.test.js","sourceRoot":"","sources":["../src/constants.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { afterEach, beforeEach, describe, expect, it } from 'vitest';\n\nimport {\n  createWorkflowEntrypointOptionsCode,\n  createWorkflowQueueTrigger,\n  getWorkflowQueueTrigger,\n} from './constants.js';\n\ndescribe('getWorkflowQueueTrigger', () => {\n  let originalStrict: string | undefined;\n\n  beforeEach(() => {\n    originalStrict = process.env.WORKFLOW_SEQUENTIAL_REPLAYS;\n  });\n\n  afterEach(() => {\n    if (originalStrict !== undefined) {\n      process.env.WORKFLOW_SEQUENTIAL_REPLAYS = originalStrict;\n    } else {\n      delete process.env.WORKFLOW_SEQUENTIAL_REPLAYS;\n    }\n  });\n\n  it('omits maxConcurrency by default', () => {\n    delete process.env.WORKFLOW_SEQUENTIAL_REPLAYS;\n    const trigger = getWorkflowQueueTrigger();\n    expect(trigger.topic).toBe('__wkf_workflow_*');\n    expect('maxConcurrency' in trigger).toBe(false);\n  });\n\n  it('sets maxConcurrency: 1 when WORKFLOW_SEQUENTIAL_REPLAYS=1', () => {\n    process.env.WORKFLOW_SEQUENTIAL_REPLAYS = '1';\n    const trigger = getWorkflowQueueTrigger();\n    expect(trigger).toMatchObject({\n      topic: '__wkf_workflow_*',\n      maxConcurrency: 1,\n    });\n  });\n\n  it('does not set maxConcurrency for non-\"1\" values', () => {\n    process.env.WORKFLOW_SEQUENTIAL_REPLAYS = 'true';\n    const trigger = getWorkflowQueueTrigger();\n    expect('maxConcurrency' in trigger).toBe(false);\n  });\n\n  it('composes with an explicit namespace option', () => {\n    process.env.WORKFLOW_SEQUENTIAL_REPLAYS = '1';\n    expect(getWorkflowQueueTrigger({ namespace: 'custom' })).toMatchObject({\n      topic: '__custom_wkf_workflow_*',\n      maxConcurrency: 1,\n    });\n  });\n\n  it('resolves WORKFLOW_QUEUE_NAMESPACE at call time', () => {\n    delete process.env.WORKFLOW_SEQUENTIAL_REPLAYS;\n    process.env.WORKFLOW_QUEUE_NAMESPACE = 'callns';\n    try {\n      expect(getWorkflowQueueTrigger().topic).toBe('__callns_wkf_workflow_*');\n    } finally {\n      delete process.env.WORKFLOW_QUEUE_NAMESPACE;\n    }\n  });\n});\n\ndescribe('createWorkflowQueueTrigger', () => {\n  afterEach(() => {\n    delete process.env.WORKFLOW_QUEUE_NAMESPACE;\n  });\n\n  it('uses the default workflow topic without a namespace', () => {\n    expect(createWorkflowQueueTrigger().topic).toBe('__wkf_workflow_*');\n  });\n\n  it('uses an explicit namespace when provided', () => {\n    expect(createWorkflowQueueTrigger({ namespace: 'custom' }).topic).toBe(\n      '__custom_wkf_workflow_*'\n    );\n  });\n\n  it('uses WORKFLOW_QUEUE_NAMESPACE when no explicit namespace is provided', () => {\n    process.env.WORKFLOW_QUEUE_NAMESPACE = 'custom';\n\n    expect(createWorkflowQueueTrigger().topic).toBe('__custom_wkf_workflow_*');\n  });\n});\n\ndescribe('createWorkflowEntrypointOptionsCode', () => {\n  afterEach(() => {\n    delete process.env.WORKFLOW_QUEUE_NAMESPACE;\n  });\n\n  it('omits runtime options without a namespace', () => {\n    expect(createWorkflowEntrypointOptionsCode()).toBe('');\n  });\n\n  it('inlines an explicit namespace', () => {\n    expect(createWorkflowEntrypointOptionsCode({ namespace: 'custom' })).toBe(\n      ', { namespace: \"custom\" }'\n    );\n  });\n\n  it('inlines WORKFLOW_QUEUE_NAMESPACE at build time', () => {\n    process.env.WORKFLOW_QUEUE_NAMESPACE = 'custom';\n\n    expect(createWorkflowEntrypointOptionsCode()).toBe(\n      ', { namespace: \"custom\" }'\n    );\n  });\n\n  it('inlines route module timing with namespace options', () => {\n    expect(\n      createWorkflowEntrypointOptionsCode({\n        namespace: 'custom',\n        basePath: '/v2',\n        routeModuleBodyStartedAt: 'workflowRouteModuleBodyStartedAt',\n      })\n    ).toBe(\n      ', { namespace: \"custom\", basePath: \"/v2\", routeModuleBodyStartedAt: workflowRouteModuleBodyStartedAt }'\n    );\n  });\n});\n"]}

package/dist/discover-entries-esbuild-plugin.d.ts

@@ -1,7 +1,9 @@
 import type { Plugin } from 'esbuild';
 export declare const jsTsRegex: RegExp;
 export declare const importParents: Map<string, Set<string>>;
-export declare function parentHasChild(parent: string, childToFind: string): boolean;
+export declare function parentHasChild(parent: string, childToFind: string, { excludedRoots, }?: {
+    excludedRoots?: Iterable<string>;
+}): boolean;
 export declare function createDiscoverEntriesPlugin(state: {
     discoveredSteps: Set<string>;
     discoveredWorkflows: Set<string>;

package/dist/discover-entries-esbuild-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discover-entries-esbuild-plugin.d.ts","sourceRoot":"","sources":["../src/discover-entries-esbuild-plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAUtC,eAAO,MAAM,SAAS,QAAuC,CAAC;AAwB9D,eAAO,MAAM,aAAa,0BAAiC,CAAC;AAK5D,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CA0B3E;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE;IACL,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjC,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnC,EACD,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAiIR"}
+{"version":3,"file":"discover-entries-esbuild-plugin.d.ts","sourceRoot":"","sources":["../src/discover-entries-esbuild-plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AA2BtC,eAAO,MAAM,SAAS,QAAuC,CAAC;AAyB9D,eAAO,MAAM,aAAa,0BAAiC,CAAC;AAK5D,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,EACE,aAAa,GACd,GAAE;IACD,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC7B,GACL,OAAO,CA8BT;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE;IACL,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjC,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnC,EACD,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAiIR"}