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

package/dist/base-builder.js

@@ -1,7 +1,10 @@
 import { randomUUID } from 'node:crypto';
-import { mkdir, readFile, realpath, rename, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, realpath, rename, rm, stat, writeFile, } from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { promisify } from 'node:util';
+import { buildLogger } from '@workflow/core/logger';
+import { WorkflowBuildError } from '@workflow/errors';
 import { pluralize } from '@workflow/utils';
 import chalk from 'chalk';
 import enhancedResolveOriginal from 'enhanced-resolve';
@@ -9,15 +12,70 @@ import * as esbuild from 'esbuild';
 import { findUp } from 'find-up';
 import { glob } from 'tinyglobby';
 import { applySwcTransform, } from './apply-swc-transform.js';
-import { createDiscoverEntriesPlugin } from './discover-entries-esbuild-plugin.js';
+import { createWorkflowEntrypointOptionsCode, createWorkflowRouteHandlersCode, } from './constants.js';
 import { getEsbuildTsconfigOptions } from './esbuild-tsconfig.js';
-import { getImportPath } from './module-specifier.js';
+import { fastDiscoverEntries, } from './fast-discovery.js';
+import { getImportPath, resolveModuleSpecifier, stripPackageVersion, } from './module-specifier.js';
 import { createNodeModuleErrorPlugin } from './node-module-esbuild-plugin.js';
 import { createPseudoPackagePlugin } from './pseudo-package-esbuild-plugin.js';
 import { createSwcPlugin } from './swc-esbuild-plugin.js';
+import { detectWorkflowPatterns } from './transform-utils.js';
 import { extractWorkflowGraphs } from './workflows-extractor.js';
 const enhancedResolve = promisify(enhancedResolveOriginal);
+const require = createRequire(import.meta.url);
+/**
+ * Legacy opt-in for source maps on the final workflow wrapper + webhook
+ * bundles (which default to off, unlike the step/interim workflow bundles
+ * that default to inline). Superseded by the `sourcemap` config option and
+ * the `WORKFLOW_SOURCEMAP` environment variable; kept for back-compat.
+ */
 const EMIT_SOURCEMAPS_FOR_DEBUGGING = process.env.WORKFLOW_EMIT_SOURCEMAPS_FOR_DEBUGGING === '1';
+const VALID_SOURCEMAP_STRINGS = new Set([
+    'inline',
+    'linked',
+    'external',
+    'both',
+]);
+/**
+ * Parse the value of the `WORKFLOW_SOURCEMAP` environment variable into a
+ * `SourcemapMode`. Returns `undefined` if the env var is unset, empty, or
+ * unrecognized (a warning is emitted for unrecognized values).
+ */
+function parseSourcemapEnv(value) {
+    if (value === undefined || value === '')
+        return undefined;
+    switch (value) {
+        case '0':
+        case 'false':
+            return false;
+        case '1':
+        case 'true':
+            return true;
+        default:
+            if (VALID_SOURCEMAP_STRINGS.has(value)) {
+                return value;
+            }
+            console.warn(`Ignoring unrecognized WORKFLOW_SOURCEMAP=${value}. ` +
+                `Expected one of: true, false, 0, 1, inline, linked, external, both.`);
+            return undefined;
+    }
+}
+/**
+ * Parse the value of the `WORKFLOW_DISCOVER_NODE_MODULES` environment variable
+ * into a boolean. Returns `undefined` if the env var is unset or empty so
+ * callers can fall back to config/default.
+ */
+function parseDiscoverNodeModulesEnv(value) {
+    if (value === undefined || value === '')
+        return undefined;
+    return value !== '0' && value !== 'false';
+}
+function formatBuildDuration(durationMs) {
+    if (durationMs < 1000) {
+        return `${durationMs}ms`;
+    }
+    return `${(durationMs / 1000).toFixed(1)}s`;
+}
 /**
  * Normalize an array of file paths by appending the `realpath()` of each entry
  * (to handle symlinks, e.g. pnpm/workspace layouts) and deduplicating.
@@ -28,6 +86,64 @@ async function withRealpaths(entries) {
         return resolved ? [entry, resolved] : [entry];
     }))).flat()));
 }
+/**
+ * Canonical "what module does this file represent?" key used to dedupe
+ * virtual-entry imports.
+ *
+ * If the file resolves to a real package specifier (`workflow/internal/builtins`,
+ * `@internal/agent/server`, etc.), we return the bare specifier — version
+ * stripped — because esbuild's package resolution will collapse all
+ * importers of that specifier to the same physical module regardless of
+ * which on-disk copy (src vs dist) any one importer wrote.
+ *
+ * Otherwise we fall back to the absolute file path. Distinct local-app
+ * files have distinct paths, so this still dedupes a file against itself
+ * (e.g. if it shows up in both `stepFiles` and `serdeOnlyFiles`) without
+ * conflating unrelated files.
+ */
+function moduleIdentityKey(file, moduleSpecifierRoot) {
+    const { moduleSpecifier } = resolveModuleSpecifier(file, moduleSpecifierRoot);
+    if (moduleSpecifier) {
+        // Strip the "@<version>" suffix so source and dist copies of the same
+        // export collapse to the same key.
+        return stripPackageVersion(moduleSpecifier);
+    }
+    return file.replace(/\\/g, '/');
+}
+function formatIdLocation(location) {
+    return `${location.filePath}#${location.name}`;
+}
+function assertUniqueManifestIds(entriesByFile, ids, getId, label) {
+    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 };
+            if (existing &&
+                (existing.filePath !== current.filePath ||
+                    existing.name !== current.name)) {
+                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);
+        }
+    }
+}
+function mergeWorkflowManifest(target, incoming, stepIds, workflowIds) {
+    assertUniqueManifestIds(incoming.steps, stepIds, (data) => data.stepId, 'step');
+    assertUniqueManifestIds(incoming.workflows, workflowIds, (data) => data.workflowId, 'workflow');
+    target.workflows = Object.assign(target.workflows || {}, incoming.workflows);
+    target.steps = Object.assign(target.steps || {}, incoming.steps);
+    target.classes = Object.assign(target.classes || {}, incoming.classes);
+}
 /**
  * Base class for workflow builders. Provides common build logic for transforming
  * workflow source files into deployable bundles using esbuild and SWC.
@@ -36,23 +152,37 @@ async function withRealpaths(entries) {
  */
 export class BaseBuilder {
     config;
+    /**
+     * Tracks which external packages have already been warned about
+     * to avoid duplicate warnings across multiple discoverEntries() calls.
+     */
+    warnedExternalPackages = new Set();
+    workflowBuildStartTime;
+    manifestTransformCache = new Map();
     constructor(config) {
         this.config = config;
     }
     get transformProjectRoot() {
         return this.config.projectRoot || this.config.workingDir;
     }
-    /**
-     * Whether informational BaseBuilder logs should be printed.
-     * Subclasses can override this to silence progress logs while keeping warnings/errors.
-     */
-    get shouldLogBaseBuilderInfo() {
-        return true;
+    get moduleSpecifierRoot() {
+        return this.config.moduleSpecifierRoot || this.transformProjectRoot;
     }
     logBaseBuilderInfo(...args) {
-        if (this.shouldLogBaseBuilderInfo) {
-            console.log(...args);
-        }
+        buildLogger.debug(args.map(String).join(' '));
+    }
+    startWorkflowBuildTimer() {
+        this.workflowBuildStartTime = Date.now();
+    }
+    getWorkflowBuildDuration() {
+        return Date.now() - (this.workflowBuildStartTime ?? Date.now());
+    }
+    resetWorkflowBuildTimer() {
+        this.workflowBuildStartTime = undefined;
+    }
+    getWorkflowBuildSummary({ stepCount, workflowCount, }) {
+        const counts = `${stepCount} ${pluralize('step', 'steps', stepCount)}, ${workflowCount} ${pluralize('workflow', 'workflows', workflowCount)}`;
+        return `✓ Compiled workflows in ${formatBuildDuration(this.getWorkflowBuildDuration())} (${counts})`;
     }
     logCreateWorkflowsBundleInfo(...args) {
         if (!this.config.suppressCreateWorkflowsBundleLogs) {
@@ -118,12 +248,14 @@ export class BaseBuilder {
             '**/node_modules/**',
             '**/.git/**',
             '**/.next/**',
+            '**/.nitro/**',
             '**/.nuxt/**',
             '**/.output/**',
             '**/.vercel/**',
             '**/.workflow-data/**',
             '**/.workflow-vitest/**',
             '**/.well-known/workflow/**',
+            '**/.swc/**',
             '**/.svelte-kit/**',
             '**/.turbo/**',
             '**/.cache/**',
@@ -152,6 +284,111 @@ export class BaseBuilder {
      * (e.g., when files are added/removed during watch mode).
      */
     discoveredEntries = new WeakMap();
+    clearDiscoveredEntriesCache() {
+        this.discoveredEntries = new WeakMap();
+    }
+    clearManifestTransformCache() {
+        this.manifestTransformCache.clear();
+    }
+    /**
+     * Pseudo-packages that should not be checked for workflow patterns.
+     */
+    static PSEUDO_PACKAGES = new Set([
+        'server-only',
+        'client-only',
+    ]);
+    /**
+     * Checks each package in externalPackages for workflow patterns and emits
+     * warnings if any contain "use step", "use workflow" directives, or
+     * serialization classes. These patterns will not be transformed by the
+     * workflow compiler when the package is externalized.
+     */
+    async warnAboutExternalWorkflowPackages() {
+        const externalPackages = this.config.externalPackages;
+        if (!externalPackages?.length)
+            return;
+        for (const pkg of externalPackages) {
+            if (BaseBuilder.PSEUDO_PACKAGES.has(pkg))
+                continue;
+            if (this.warnedExternalPackages.has(pkg))
+                continue;
+            if (pkg.startsWith('.') ||
+                pkg.startsWith('/') ||
+                pkg.startsWith('$') ||
+                pkg.includes('*') ||
+                pkg.includes(':')) {
+                continue;
+            }
+            try {
+                // Check package.json dependencies for @workflow/serde (fast path)
+                let hasWorkflowSerdeDep = false;
+                try {
+                    const pkgJsonPath = require.resolve(`${pkg}/package.json`, {
+                        paths: [this.config.workingDir],
+                    });
+                    const pkgJsonSource = await readFile(pkgJsonPath, 'utf-8');
+                    const pkgJson = JSON.parse(pkgJsonSource);
+                    const dependencies = typeof pkgJson.dependencies === 'object' &&
+                        pkgJson.dependencies !== null &&
+                        !Array.isArray(pkgJson.dependencies)
+                        ? pkgJson.dependencies
+                        : {};
+                    const peerDependencies = typeof pkgJson.peerDependencies === 'object' &&
+                        pkgJson.peerDependencies !== null &&
+                        !Array.isArray(pkgJson.peerDependencies)
+                        ? pkgJson.peerDependencies
+                        : {};
+                    hasWorkflowSerdeDep =
+                        Object.hasOwn(dependencies, '@workflow/serde') ||
+                            Object.hasOwn(peerDependencies, '@workflow/serde');
+                }
+                catch {
+                    // package.json not resolvable - continue to source check
+                }
+                // Check source patterns (thorough path).
+                // Note: require.resolve only inspects the package's main entry point.
+                // If workflow constructs live in sub-paths (e.g. `my-pkg/workflows`),
+                // they won't be detected here. The @workflow/serde dep check above
+                // partially covers serde cases. This is acceptable as a best-effort
+                // heuristic — the primary fix is auto-removal in withWorkflow().
+                let hasUseStep = false;
+                let hasUseWorkflow = false;
+                let hasSerde = hasWorkflowSerdeDep;
+                try {
+                    const entryPath = require.resolve(pkg, {
+                        paths: [this.config.workingDir],
+                    });
+                    const source = await readFile(entryPath, 'utf-8');
+                    const patterns = detectWorkflowPatterns(source);
+                    hasUseStep = patterns.hasUseStep;
+                    hasUseWorkflow = patterns.hasUseWorkflow;
+                    if (!hasSerde) {
+                        hasSerde = patterns.hasSerde;
+                    }
+                }
+                catch {
+                    // Entry file not resolvable or not readable - use what we have
+                }
+                if (!hasUseStep && !hasUseWorkflow && !hasSerde)
+                    continue;
+                // Build a specific description of what was found
+                const issues = [];
+                if (hasUseWorkflow)
+                    issues.push('"use workflow" functions');
+                if (hasUseStep)
+                    issues.push('"use step" functions');
+                if (hasSerde)
+                    issues.push('serialization classes');
+                this.warnedExternalPackages.add(pkg);
+                console.warn(`\n${chalk.yellow('⚠')} Warning: ${chalk.bold(`"${pkg}"`)} is listed in ${chalk.bold('externalPackages')} (${chalk.bold('serverExternalPackages')} in Next.js) but contains workflow code (${issues.join(', ')}).` +
+                    `\n  This code will ${chalk.bold('not')} be transformed by the workflow compiler, which can cause runtime failures.` +
+                    `\n  Remove ${chalk.bold(`"${pkg}"`)} from ${chalk.bold('externalPackages')} (${chalk.bold('serverExternalPackages')} in Next.js) to fix this.\n`);
+            }
+            catch {
+                // Best-effort: if anything goes wrong, skip this package silently
+            }
+        }
+    }
     async discoverEntries(inputs, outdir, tsconfigPath) {
         const previousResult = this.discoveredEntries.get(inputs);
         if (previousResult) {
@@ -161,46 +398,59 @@ export class BaseBuilder {
             discoveredSteps: new Set(),
             discoveredWorkflows: new Set(),
             discoveredSerdeFiles: new Set(),
+            discoveredFiles: new Set(),
         };
         const discoverStart = Date.now();
-        // Resolve the SDK runtime entry point so that the discovery pass
-        // traces through it and discovers serde classes (like `Run`) that
-        // live inside SDK packages. Without this, files like `run.js` are
-        // only discovered when user code happens to import them.
+        // Resolve the SDK runtime serde entry point so that the discovery pass
+        // discovers classes like `Run` that live inside SDK packages. Without this,
+        // files like `run.js` are only discovered when user code imports them.
         // This is resolved here (rather than in callers) so that the original
         // `inputs` array reference is preserved for WeakMap caching — callers
         // like createWorkflowsBundle and createStepsBundle can share the same
         // cache entry when they pass the same inputFiles array.
-        const resolvedWorkflowRuntime = await enhancedResolve(outdir, 'workflow/runtime').catch(() => undefined);
+        const resolvedWorkflowRuntime = await enhancedResolve(outdir, '@workflow/core/runtime/run').catch(() => undefined);
         const entryPoints = resolvedWorkflowRuntime
             ? [...inputs, resolvedWorkflowRuntime]
             : inputs;
         const effectiveTsconfigPath = tsconfigPath ?? (await this.findTsConfigPath());
-        const esbuildTsconfigOptions = await getEsbuildTsconfigOptions(effectiveTsconfigPath);
-        try {
-            await esbuild.build({
-                treeShaking: true,
-                entryPoints,
-                plugins: [
-                    createDiscoverEntriesPlugin(state, this.transformProjectRoot),
-                ],
-                platform: 'node',
-                write: false,
-                outdir,
-                bundle: true,
-                sourcemap: false,
-                absWorkingDir: this.config.workingDir,
-                logLevel: 'silent',
-                ...esbuildTsconfigOptions,
-                // External packages that should not be bundled during discovery
-                external: this.config.externalPackages || [],
-            });
-        }
-        catch (_) { }
+        await fastDiscoverEntries({
+            entryPoints,
+            state,
+            defaultTsconfigPath: effectiveTsconfigPath,
+            workingDir: this.config.workingDir,
+            discoverWorkflowsInNodeModules: this.resolveDiscoverWorkflowsInNodeModules(),
+        });
         this.logBaseBuilderInfo(`Discovering workflow directives`, `${Date.now() - discoverStart}ms`);
+        // Warn about external packages that contain workflow code
+        await this.warnAboutExternalWorkflowPackages();
         this.discoveredEntries.set(inputs, state);
         return state;
     }
+    /**
+     * Writes generated files atomically where possible. On Windows, Next.js can
+     * briefly hold generated route files open while compiling them, which makes
+     * rename-over-existing fail with EPERM/EACCES. In that case, fall back to a
+     * direct overwrite so watch rebuilds can still make progress.
+     */
+    async writeGeneratedFile(targetPath, content) {
+        const tempPath = `${targetPath}.${randomUUID()}.tmp`;
+        await writeFile(tempPath, content);
+        try {
+            await rename(tempPath, targetPath);
+        }
+        catch (error) {
+            const errorCode = error && typeof error === 'object' && 'code' in error
+                ? error.code
+                : undefined;
+            if (process.platform === 'win32' &&
+                (errorCode === 'EPERM' || errorCode === 'EACCES')) {
+                await writeFile(targetPath, content);
+                await rm(tempPath, { force: true });
+                return;
+            }
+            throw error;
+        }
+    }
     /**
      * Writes debug information to a JSON file for troubleshooting build issues.
      * Uses atomic write (temp file + rename) to prevent race conditions when
@@ -228,12 +478,7 @@ export class BaseBuilder {
                 ...existing,
                 ...debugData,
             }, null, 2);
-            // Write atomically: write to temp file, then rename.
-            // rename() is atomic on POSIX systems and provides best-effort atomicity on Windows.
-            // Prevents race conditions where concurrent builds read partially-written files.
-            const tempPath = `${targetPath}.${randomUUID()}.tmp`;
-            await writeFile(tempPath, mergedData);
-            await rename(tempPath, targetPath);
+            await this.writeGeneratedFile(targetPath, mergedData);
         }
         catch (error) {
             console.warn('Failed to write debug file:', error);
@@ -257,7 +502,9 @@ export class BaseBuilder {
                 }
             }
             if (throwOnError) {
-                throw new Error(`Build failed during ${phase}:\n${errorMessages.join('\n')}`);
+                throw new WorkflowBuildError(`Build failed during ${phase}:\n${errorMessages.join('\n')}`, {
+                    hint: `Review the esbuild errors above — they come from the ${phase} bundle. Fix the offending source files and re-run the build.`,
+                });
             }
         }
         if (!options?.suppressWarnings &&
@@ -288,24 +535,117 @@ export class BaseBuilder {
         }
         return relativePath;
     }
+    async getCachedManifestTransform(file, mode) {
+        const stats = await stat(file);
+        const cacheKey = `${mode}:${file}`;
+        const cached = this.manifestTransformCache.get(cacheKey);
+        if (cached &&
+            cached.size === stats.size &&
+            cached.mtimeMs === stats.mtimeMs) {
+            return cached.manifest;
+        }
+        const source = await readFile(file, 'utf8');
+        const relativeFilepath = this.getRelativeFilepath(file);
+        const { workflowManifest } = await applySwcTransform(relativeFilepath, source, mode, file, this.transformProjectRoot, this.moduleSpecifierRoot);
+        this.manifestTransformCache.set(cacheKey, {
+            size: stats.size,
+            mtimeMs: stats.mtimeMs,
+            manifest: workflowManifest,
+        });
+        return workflowManifest;
+    }
+    createRouteImportSpecifier(file, routeDir) {
+        const { importPath, isPackage } = getImportPath(file, this.config.workingDir);
+        if (isPackage) {
+            return importPath;
+        }
+        let relativePath = relative(routeDir, file).replace(/\\/g, '/');
+        if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {
+            relativePath = `./${relativePath}`;
+        }
+        return relativePath;
+    }
+    async createStepSourceRegistrationFile({ inputFiles, outfile, tsconfigPath, discoveredEntries, }) {
+        const stepsBundleStart = Date.now();
+        const workflowManifest = {};
+        const builtInSteps = 'workflow/internal/builtins';
+        const resolvedBuiltInSteps = (await enhancedResolve(dirname(outfile), builtInSteps).catch((err) => {
+            throw new WorkflowBuildError(`Failed to resolve built-in steps sources.\n\nCaused by: ${String(err)}`, {
+                hint: 'run `pnpm install workflow` to resolve this issue.',
+                cause: err,
+            });
+        }));
+        const discovered = discoveredEntries ??
+            (await this.discoverEntries(inputFiles, dirname(outfile), tsconfigPath));
+        const stepFiles = [...discovered.discoveredSteps].sort();
+        const workflowFiles = [...discovered.discoveredWorkflows].sort();
+        const serdeFiles = [...discovered.discoveredSerdeFiles].sort();
+        const stepFilesSet = new Set(stepFiles);
+        const serdeOnlyFiles = serdeFiles.filter((f) => !stepFilesSet.has(f));
+        await this.writeDebugFile(outfile, {
+            stepFiles,
+            workflowFiles,
+            serdeOnlyFiles,
+            sourceImports: true,
+        });
+        const emittedImportIdentities = new Set([builtInSteps]);
+        const importStatements = [];
+        const routeDir = dirname(outfile);
+        const addRegistrationImport = (specifier) => {
+            importStatements.push(`import ${JSON.stringify(specifier)};`);
+        };
+        const addRegistrationFileImport = (file) => {
+            const identity = moduleIdentityKey(file, this.moduleSpecifierRoot);
+            if (emittedImportIdentities.has(identity)) {
+                return;
+            }
+            emittedImportIdentities.add(identity);
+            addRegistrationImport(this.createRouteImportSpecifier(file, routeDir));
+        };
+        addRegistrationImport(builtInSteps);
+        for (const file of stepFiles) {
+            addRegistrationFileImport(file);
+        }
+        for (const file of serdeOnlyFiles) {
+            addRegistrationFileImport(file);
+        }
+        const output = `// biome-ignore-all lint: generated file
+/* eslint-disable */
+${importStatements.join('\n')}
+
+export const __steps_registered = true;
+`;
+        await mkdir(dirname(outfile), { recursive: true });
+        await this.writeGeneratedFile(outfile, output);
+        const manifestFiles = Array.from(new Set([...stepFiles, ...serdeOnlyFiles, resolvedBuiltInSteps])).sort();
+        const stepIds = new Map();
+        const workflowIds = new Map();
+        await Promise.all(manifestFiles.map(async (file) => {
+            const fileManifest = await this.getCachedManifestTransform(file, 'step');
+            mergeWorkflowManifest(workflowManifest, fileManifest, stepIds, workflowIds);
+        }));
+        await this.ensureSwcIgnored();
+        this.logBaseBuilderInfo('Created step registrations', `${Date.now() - stepsBundleStart}ms`);
+        return workflowManifest;
+    }
     /**
      * Creates a bundle for workflow step functions.
      * Steps have full Node.js runtime access and handle side effects, API calls, etc.
      *
      * @param externalizeNonSteps - If true, only bundles step entry points and externalizes other code
+     * @param sourceStepRegistrationImports - If true, emits a source import registration file instead of bundling step registrations
+     * @param bundleTransitiveLocalStepDependencies - If true, also bundles project-local files imported by step entries for direct runtime loading
      * @returns Build context (for watch mode) and the collected workflow manifest
      */
-    async createStepsBundle({ inputFiles, format = 'esm', outfile, externalizeNonSteps, rewriteTsExtensions, tsconfigPath, discoveredEntries, }) {
+    async createStepsBundle({ inputFiles, format = 'esm', outfile, externalizeNonSteps, bundleTransitiveLocalStepDependencies, sourceStepRegistrationImports, rewriteTsExtensions, tsconfigPath, discoveredEntries, skipEsmRequireBanner = false, }) {
         const stepsBundleStart = Date.now();
         const workflowManifest = {};
         const builtInSteps = 'workflow/internal/builtins';
         const resolvedBuiltInSteps = await enhancedResolve(dirname(outfile), 'workflow/internal/builtins').catch((err) => {
-            throw new Error([
-                chalk.red('Failed to resolve built-in steps sources.'),
-                `${chalk.yellow.bold('hint:')} run \`${chalk.cyan.italic('npm install workflow')}\` to resolve this issue.`,
-                '',
-                `Caused by: ${chalk.red(String(err))}`,
-            ].join('\n'));
+            throw new WorkflowBuildError(`Failed to resolve built-in steps sources.\n\nCaused by: ${String(err)}`, {
+                hint: 'run `pnpm install workflow` to resolve this issue.',
+                cause: err,
+            });
         });
         // Discovery of workflow/step/serde entries. The SDK runtime entry point
         // (workflow/runtime) is resolved inside discoverEntries() itself so that
@@ -321,6 +661,19 @@ export class BaseBuilder {
         // when receiving data from workflows and serialized when returning data to workflows.
         const stepFilesSet = new Set(stepFiles);
         const serdeOnlyFiles = serdeFiles.filter((f) => !stepFilesSet.has(f));
+        if (sourceStepRegistrationImports &&
+            externalizeNonSteps &&
+            !bundleTransitiveLocalStepDependencies) {
+            return {
+                context: undefined,
+                manifest: await this.createStepSourceRegistrationFile({
+                    inputFiles,
+                    outfile,
+                    tsconfigPath,
+                    discoveredEntries: discovered,
+                }),
+            };
+        }
         // log the step files for debugging
         await this.writeDebugFile(outfile, {
             stepFiles,
@@ -331,6 +684,28 @@ export class BaseBuilder {
         // For workspace/node_modules packages, uses the package name so esbuild
         // will resolve through package.json exports with the appropriate conditions
         const createImport = (file) => {
+            const normalizedWorkspaceRoot = this.config.workingDir
+                .replace(/\\/g, '/')
+                .replace(/\/$/, '');
+            const normalizedWorkspaceFile = file.replace(/\\/g, '/');
+            // Only use relative source paths for workspace symlinks (files
+            // outside node_modules in a packages/*/src/ directory). For tarball-
+            // installed packages (files inside node_modules/), fall through to
+            // getImportPath which returns package specifiers — this allows the
+            // SWC plugin's externalizeNonSteps to work correctly.
+            const isWorkspaceSourceBackedPackageFile = normalizedWorkspaceFile.includes('/packages/') &&
+                normalizedWorkspaceFile.includes('/src/') &&
+                !normalizedWorkspaceFile.includes('/node_modules/') &&
+                !(normalizedWorkspaceFile === normalizedWorkspaceRoot ||
+                    normalizedWorkspaceFile.startsWith(`${normalizedWorkspaceRoot}/`));
+            const isSourceBackedPackageFile = isWorkspaceSourceBackedPackageFile;
+            if (isSourceBackedPackageFile) {
+                let relativePath = relative(normalizedWorkspaceRoot, normalizedWorkspaceFile).replace(/\\/g, '/');
+                if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {
+                    relativePath = `./${relativePath}`;
+                }
+                return `import '${relativePath}';`;
+            }
             const { importPath, isPackage } = getImportPath(file, this.config.workingDir);
             if (isPackage) {
                 // Use package name - esbuild will resolve via package.json exports
@@ -353,9 +728,27 @@ export class BaseBuilder {
         };
         // Create a virtual entry that imports all files. All step definitions
         // will get registered thanks to the swc transform.
-        const stepImports = stepFiles.map(createImport).join('\n');
+        //
+        // Dedupe imports by canonical module identity so we never emit two
+        // import lines that resolve to the same physical module. Pre-seed the
+        // set with the built-in steps import so a workspace step file at
+        // `packages/workflow/src/internal/builtins.ts` doesn't emit a second,
+        // relative-path competing import — esbuild would otherwise transform
+        // both copies and the swc plugin would generate duplicate step IDs.
+        const emittedImportIdentities = new Set([builtInSteps]);
+        const buildImports = (files) => files
+            .filter((file) => {
+            const identity = moduleIdentityKey(file, this.moduleSpecifierRoot);
+            if (emittedImportIdentities.has(identity))
+                return false;
+            emittedImportIdentities.add(identity);
+            return true;
+        })
+            .map(createImport)
+            .join('\n');
+        const stepImports = buildImports(stepFiles);
         // Include serde-only files for class registration side effects
-        const serdeImports = serdeOnlyFiles.map(createImport).join('\n');
+        const serdeImports = buildImports(serdeOnlyFiles);
         const entryContent = `
     // Built in steps
     import '${builtInSteps}';
@@ -363,8 +756,9 @@ export class BaseBuilder {
     ${stepImports}
     // Serde files for cross-context class registration
     ${serdeImports}
-    // API entrypoint
-    export { stepEntrypoint as POST } from 'workflow/runtime';`;
+    // Sentinel export so bundlers (rollup) don't tree-shake this module
+    // when it's imported as a side-effect-only dependency.
+    export const __steps_registered = true;`;
         // Bundle with esbuild and our custom SWC plugin
         const entriesToBundle = externalizeNonSteps
             ? [
@@ -383,7 +777,9 @@ export class BaseBuilder {
         ]);
         const esbuildTsconfigOptions = await getEsbuildTsconfigOptions(tsconfigPath);
         const { banner: importMetaBanner, define: importMetaDefine } = this.getCjsImportMetaPolyfill(format);
-        const esmRequireBanner = this.getEsmRequireBanner(format);
+        const esmRequireBanner = skipEsmRequireBanner
+            ? ''
+            : this.getEsmRequireBanner(format);
         const esbuildCtx = await esbuild.context({
             banner: {
                 js: `// biome-ignore-all lint: generated file\n/* eslint-disable */\n${importMetaBanner}${esmRequireBanner}`,
@@ -421,11 +817,14 @@ export class BaseBuilder {
                 '.mjs',
                 '.cjs',
             ],
-            // Inline source maps for better stack traces in step execution.
-            // Steps execute in Node.js context and inline sourcemaps ensure we get
-            // meaningful stack traces with proper file names and line numbers when errors
-            // occur in deeply nested function calls across multiple files.
-            sourcemap: 'inline',
+            // Source maps for better stack traces in step execution. Steps execute
+            // in Node.js context and inline sourcemaps give meaningful stack traces
+            // with proper file names and line numbers when errors occur in deeply
+            // nested function calls across multiple files. Defaults to inline in
+            // development and off in production (see `defaultSourcemapMode`) to keep
+            // production function bundles small; override with the `sourcemap`
+            // config option or the `WORKFLOW_SOURCEMAP` env var.
+            sourcemap: this.resolveSourcemap(this.defaultSourcemapMode),
             plugins: [
                 // Handle pseudo-packages like 'server-only' and 'client-only' by providing
                 // empty modules. Must run first to intercept these before other resolution.
@@ -435,7 +834,10 @@ export class BaseBuilder {
                     entriesToBundle: normalizedEntriesToBundle,
                     outdir: outfile ? dirname(outfile) : undefined,
                     projectRoot: this.transformProjectRoot,
+                    moduleSpecifierRoot: this.moduleSpecifierRoot,
                     workflowManifest,
+                    onAfterTransform: this.config.onAfterTransform,
+                    bundleTransitiveLocalStepDependencies,
                     rewriteTsExtensions,
                     sideEffectEntries: normalizedSideEffectEntries,
                 }),
@@ -453,9 +855,7 @@ export class BaseBuilder {
         const workflowOnlyFiles = workflowFiles.filter((f) => !stepFiles.includes(f));
         await Promise.all(workflowOnlyFiles.map(async (workflowFile) => {
             try {
-                const source = await readFile(workflowFile, 'utf8');
-                const relativeFilepath = this.getRelativeFilepath(workflowFile);
-                const { workflowManifest: fileManifest } = await applySwcTransform(relativeFilepath, source, 'workflow', workflowFile, this.transformProjectRoot);
+                const fileManifest = await this.getCachedManifestTransform(workflowFile, 'workflow');
                 if (fileManifest.workflows) {
                     workflowManifest.workflows = Object.assign(workflowManifest.workflows || {}, fileManifest.workflows);
                 }
@@ -468,8 +868,7 @@ export class BaseBuilder {
                 console.warn(`Warning: Failed to extract workflow metadata from ${workflowFile}:`, error instanceof Error ? error.message : String(error));
             }
         }));
-        // Create .gitignore in .swc directory
-        await this.createSwcGitignore();
+        await this.ensureSwcIgnored();
         if (this.config.watch) {
             return { context: esbuildCtx, manifest: workflowManifest };
         }
@@ -519,12 +918,26 @@ export class BaseBuilder {
             }
             return `import '${relativePath}';`;
         };
-        // Create a virtual entry that imports all workflow files
+        // Create a virtual entry that imports all workflow files. Dedupe by
+        // canonical module identity so source/dist copies of the same workspace
+        // package export don't both get imported (which would make the swc
+        // plugin generate duplicate workflow IDs).
+        const emittedImportIdentities = new Set();
+        const buildImports = (files) => files
+            .filter((file) => {
+            const identity = moduleIdentityKey(file, this.moduleSpecifierRoot);
+            if (emittedImportIdentities.has(identity))
+                return false;
+            emittedImportIdentities.add(identity);
+            return true;
+        })
+            .map(createImport)
+            .join('\n');
         // The SWC plugin in workflow mode emits `globalThis.__private_workflows.set(workflowId, fn)`
         // calls directly, so we just need to import the files (Map is initialized via banner)
-        const workflowImports = workflowFiles.map(createImport).join('\n');
+        const workflowImports = buildImports(workflowFiles);
         // Include serde-only files for class registration side effects
-        const serdeImports = serdeOnlyFiles.map(createImport).join('\n');
+        const serdeImports = buildImports(serdeOnlyFiles);
         const imports = serdeImports
             ? `${workflowImports}\n// Serde files for cross-context class registration\n${serdeImports}`
             : workflowImports;
@@ -561,10 +974,15 @@ export class BaseBuilder {
             banner: {
                 js: 'globalThis.__private_workflows = new Map();',
             },
-            // Inline source maps for better stack traces in workflow VM execution.
-            // This intermediate bundle is executed via runInContext() in a VM, so we need
-            // inline source maps to get meaningful stack traces instead of "evalmachine.<anonymous>".
-            sourcemap: 'inline',
+            // Source maps for better stack traces in workflow VM execution. This
+            // intermediate bundle is executed via runInContext() in a VM, so inline
+            // source maps give meaningful stack traces instead of
+            // "evalmachine.<anonymous>". Defaults to inline in development and off in
+            // production (see `defaultSourcemapMode`) to keep production function
+            // bundles small; override with the `sourcemap` config option or the
+            // `WORKFLOW_SOURCEMAP` env var. The runtime remaps stacks only when a
+            // map is present, so disabling maps degrades gracefully.
+            sourcemap: this.resolveSourcemap(this.defaultSourcemapMode),
             // Use tsconfig for path alias resolution.
             // For symlinked configs this uses tsconfigRaw to preserve cwd-relative aliases.
             ...esbuildTsconfigOptions,
@@ -585,7 +1003,9 @@ export class BaseBuilder {
                 createSwcPlugin({
                     mode: 'workflow',
                     projectRoot: this.transformProjectRoot,
+                    moduleSpecifierRoot: this.moduleSpecifierRoot,
                     workflowManifest,
+                    onAfterTransform: this.config.onAfterTransform,
                     sideEffectEntries: normalizedWorkflowSideEffectEntries,
                 }),
                 // This plugin must run after the swc plugin to ensure dead code elimination
@@ -621,11 +1041,12 @@ export class BaseBuilder {
                 await mkdir(dirname(resolvedPath), { recursive: true });
                 await writeFile(resolvedPath, prefix + JSON.stringify(workflowManifest, null, 2));
             }
-            // Create .gitignore in .swc directory
-            await this.createSwcGitignore();
+            await this.ensureSwcIgnored();
             if (!interimBundle.outputFiles ||
                 interimBundle.outputFiles.length === 0) {
-                throw new Error('No output files generated from esbuild');
+                throw new WorkflowBuildError('No output files generated from esbuild', {
+                    hint: 'This usually indicates a misconfigured entry point or an empty workflow directory. Check that your workflow files contain a `"use workflow"` or `"use step"` directive.',
+                });
             }
             // Serde compliance warnings: check if workflow bundle has Node.js imports
             // alongside serde-registered classes (these will fail at runtime in the sandbox)
@@ -660,15 +1081,20 @@ export class BaseBuilder {
                     console.warn(chalk.yellow(`⚠ Serde warning for ${classLabel}: `) + issue);
                 }
             }
+            const workflowEntrypointOptionsCode = createWorkflowEntrypointOptionsCode({
+                basePath: this.config.basePath,
+                routeModuleBodyStartedAt: 'workflowRouteModuleBodyStartedAt',
+            });
             const bundleFinal = async (interimBundle) => {
                 const workflowBundleCode = interimBundle;
                 const workflowFunctionCode = `// biome-ignore-all lint: generated file
 /* eslint-disable */
 import { workflowEntrypoint } from 'workflow/runtime';
 
+const workflowRouteModuleBodyStartedAt = Date.now();
 const workflowCode = \`${workflowBundleCode.replace(/[\\`$]/g, '\\$&')}\`;
 
-export const POST = workflowEntrypoint(workflowCode);`;
+${createWorkflowRouteHandlersCode(`workflowEntrypoint(workflowCode${workflowEntrypointOptionsCode})`)}`;
                 // we skip the final bundling step for Next.js so it can bundle itself
                 if (!bundleFinalOutput) {
                     if (!outfile) {
@@ -677,11 +1103,7 @@ export const POST = workflowEntrypoint(workflowCode);`;
                     // Ensure the output directory exists
                     const outputDir = dirname(outfile);
                     await mkdir(outputDir, { recursive: true });
-                    // Atomic write: write to temp file then rename to prevent
-                    // file watchers from reading partial file during write
-                    const tempPath = `${outfile}.${randomUUID()}.tmp`;
-                    await writeFile(tempPath, workflowFunctionCode);
-                    await rename(tempPath, outfile);
+                    await this.writeGeneratedFile(outfile, workflowFunctionCode);
                     return;
                 }
                 const bundleStartTime = Date.now();
@@ -701,7 +1123,7 @@ export const POST = workflowEntrypoint(workflowCode);`;
                     outfile,
                     // Source maps for the final workflow bundle wrapper (not important since this code
                     // doesn't run in the VM - only the intermediate bundle sourcemap is relevant)
-                    sourcemap: EMIT_SOURCEMAPS_FOR_DEBUGGING,
+                    sourcemap: this.resolveSourcemap(EMIT_SOURCEMAPS_FOR_DEBUGGING),
                     absWorkingDir: this.config.workingDir,
                     bundle: true,
                     format,
@@ -717,16 +1139,18 @@ export const POST = workflowEntrypoint(workflowCode);`;
                 });
                 this.logCreateWorkflowsBundleInfo('Created final workflow bundle', `${Date.now() - bundleStartTime}ms`);
             };
-            await bundleFinal(interimBundle.outputFiles[0].text);
+            const interimBundleText = interimBundle.outputFiles[0].text;
+            await bundleFinal(interimBundleText);
             if (keepInterimBundleContext) {
                 shouldDisposeInterimBundleCtx = false;
                 return {
                     manifest: workflowManifest,
                     interimBundleCtx,
                     bundleFinal,
+                    interimBundleText,
                 };
             }
-            return { manifest: workflowManifest };
+            return { manifest: workflowManifest, interimBundleText };
         }
         catch (error) {
             shouldDisposeInterimBundleCtx = true;
@@ -743,6 +1167,172 @@ export const POST = workflowEntrypoint(workflowCode);`;
             }
         }
     }
+    /**
+     * V2: Creates a combined bundle that includes both step registrations and
+     * workflow orchestration in a single route. The combined entrypoint executes
+     * steps inline when possible, reducing function invocations and queue overhead.
+     *
+     * This method reuses createStepsBundle (for step registrations) and
+     * createWorkflowsBundle (for workflow VM code), then combines them into
+     * a single route file using workflowEntrypoint().
+     */
+    async createCombinedBundle({ inputFiles, stepsOutfile, flowOutfile, format = 'esm', bundleFinalOutput = true, tsconfigPath, externalizeNonSteps, bundleTransitiveLocalStepDependencies, sourceStepRegistrationImports, discoveredEntries, }) {
+        this.startWorkflowBuildTimer();
+        const effectiveDiscoveredEntries = discoveredEntries ??
+            (await this.discoverEntries(inputFiles, dirname(flowOutfile), tsconfigPath));
+        // 1. Build step registrations bundle (used as separate file for
+        // bundleFinalOutput: false, or read back for inline content when true)
+        const { context: stepsContext, manifest: stepsManifest } = await this.createStepsBundle({
+            inputFiles,
+            outfile: stepsOutfile,
+            // When bundleFinalOutput is true, use ESM for the steps bundle
+            // regardless of the final output format. The final esbuild pass
+            // converts everything to the target format. Using CJS here causes
+            // a module.exports collision: the steps bundle's top-level
+            // module.exports overwrites the combined route's module.exports
+            // when esbuild inlines the steps without a __commonJS wrapper.
+            format: bundleFinalOutput ? 'esm' : format,
+            externalizeNonSteps,
+            bundleTransitiveLocalStepDependencies,
+            sourceStepRegistrationImports,
+            tsconfigPath,
+            discoveredEntries: effectiveDiscoveredEntries,
+            // Skip the createRequire banner here — when bundleFinalOutput is true
+            // the outer esbuild pass will inline this bundle and add its own
+            // banner. Emitting it twice declares __createRequire twice.
+            skipEsmRequireBanner: bundleFinalOutput,
+        });
+        // 2. Build workflow VM code
+        const tempWorkflowOutfile = `${flowOutfile}.__wf_tmp.js`;
+        const workflowsResult = await this.createWorkflowsBundle({
+            inputFiles,
+            outfile: tempWorkflowOutfile,
+            format,
+            bundleFinalOutput: false,
+            tsconfigPath,
+            discoveredEntries: effectiveDiscoveredEntries,
+        });
+        const workflowVMCode = workflowsResult.interimBundleText;
+        if (!workflowVMCode) {
+            throw new Error('createWorkflowsBundle did not return interimBundleText');
+        }
+        // Clean up the wrapper file
+        try {
+            const { unlink } = await import('node:fs/promises');
+            await unlink(tempWorkflowOutfile);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        // 3. Generate combined route file
+        const stepsRelativePath = `./${basename(stepsOutfile).replace(/\\/g, '/')}`;
+        const escapedVMCode = workflowVMCode.replace(/[\\`$]/g, '\\$&');
+        const workflowEntrypointOptionsCode = createWorkflowEntrypointOptionsCode({
+            basePath: this.config.basePath,
+            routeModuleBodyStartedAt: 'workflowRouteModuleBodyStartedAt',
+        });
+        const combinedFunctionCode = `// biome-ignore-all lint: generated file
+/* eslint-disable */
+import { __steps_registered } from '${stepsRelativePath}';
+import { workflowEntrypoint } from 'workflow/runtime';
+
+const workflowRouteModuleBodyStartedAt = Date.now();
+
+// Prevent rollup from tree-shaking the steps side-effect import
+void __steps_registered;
+
+const workflowCode = \`${escapedVMCode}\`;
+
+${createWorkflowRouteHandlersCode(`workflowEntrypoint(workflowCode${workflowEntrypointOptionsCode})`)}`;
+        if (!bundleFinalOutput) {
+            await this.writeGeneratedFile(flowOutfile, combinedFunctionCode);
+        }
+        else {
+            // Bundle the combined code for standalone use
+            const bundleStartTime = Date.now();
+            const { banner: importMetaBanner, define: importMetaDefine } = this.getCjsImportMetaPolyfill(format);
+            // ESM banner provides `require` via createRequire(import.meta.url) so
+            // CJS dependencies that call require() for Node.js builtins keep working
+            // in the ESM output produced by bundleFinalOutput: true.
+            const finalEsmRequireBanner = this.getEsmRequireBanner(format);
+            const finalResult = await esbuild.build({
+                banner: {
+                    js: `// biome-ignore-all lint: generated file\n/* eslint-disable */\n${importMetaBanner}${finalEsmRequireBanner}`,
+                },
+                stdin: {
+                    contents: combinedFunctionCode,
+                    resolveDir: dirname(flowOutfile),
+                    sourcefile: 'virtual-entry.js',
+                    loader: 'js',
+                },
+                outfile: flowOutfile,
+                absWorkingDir: this.config.workingDir,
+                bundle: true,
+                format,
+                platform: 'node',
+                target: 'es2022',
+                write: true,
+                keepNames: true,
+                minify: false,
+                define: importMetaDefine,
+                external: ['@aws-sdk/credential-provider-web-identity'],
+            });
+            this.logEsbuildMessages(finalResult, 'combined bundle', true);
+            this.logBaseBuilderInfo('Created combined bundle', `${Date.now() - bundleStartTime}ms`);
+        }
+        // Merge manifests
+        const manifest = {
+            ...stepsManifest,
+            workflows: {
+                ...stepsManifest.workflows,
+                ...workflowsResult.manifest.workflows,
+            },
+            classes: {
+                ...stepsManifest.classes,
+                ...workflowsResult.manifest.classes,
+            },
+        };
+        // Create a custom bundleFinal for watch mode that uses workflowEntrypoint
+        const combinedBundleFinal = async (interimBundleText) => {
+            const escaped = interimBundleText.replace(/[\\`$]/g, '\\$&');
+            const workflowEntrypointOptionsCode = createWorkflowEntrypointOptionsCode({
+                basePath: this.config.basePath,
+                routeModuleBodyStartedAt: 'workflowRouteModuleBodyStartedAt',
+            });
+            const code = `// biome-ignore-all lint: generated file
+/* eslint-disable */
+import { __steps_registered } from '${stepsRelativePath}';
+import { workflowEntrypoint } from 'workflow/runtime';
+
+const workflowRouteModuleBodyStartedAt = Date.now();
+
+void __steps_registered;
+
+const workflowCode = \`${escaped}\`;
+
+${createWorkflowRouteHandlersCode(`workflowEntrypoint(workflowCode${workflowEntrypointOptionsCode})`)}`;
+            const outputDir = dirname(flowOutfile);
+            await mkdir(outputDir, { recursive: true });
+            await this.writeGeneratedFile(flowOutfile, code);
+        };
+        if (this.config.watch) {
+            return {
+                manifest,
+                stepsContext,
+                interimBundleCtx: workflowsResult.interimBundleCtx,
+                bundleFinal: combinedBundleFinal,
+                discoveredEntries: effectiveDiscoveredEntries,
+                stepsManifest,
+                workflowsManifest: workflowsResult.manifest,
+            };
+        }
+        return {
+            manifest,
+            discoveredEntries: effectiveDiscoveredEntries,
+            stepsManifest,
+            workflowsManifest: workflowsResult.manifest,
+        };
+    }
     /**
      * Creates a client library bundle for workflow execution.
      * The client library allows importing and calling workflows from application code.
@@ -832,13 +1422,14 @@ export const POST = workflowEntrypoint(workflowCode);`;
                 createSwcPlugin({
                     mode: 'step',
                     projectRoot: this.transformProjectRoot,
+                    moduleSpecifierRoot: this.moduleSpecifierRoot,
+                    onAfterTransform: this.config.onAfterTransform,
                     sideEffectEntries: normalizedClientSideEffectEntries,
                 }),
             ],
         });
         this.logEsbuildMessages(clientResult, 'client library bundle');
-        // Create .gitignore in .swc directory
-        await this.createSwcGitignore();
+        await this.ensureSwcIgnored();
     }
     /**
      * Creates a webhook handler bundle for resuming workflows via HTTP callbacks.
@@ -850,7 +1441,10 @@ export const POST = workflowEntrypoint(workflowCode);`;
         await mkdir(dirname(outfile), { recursive: true });
         // Create a static route that calls resumeWebhook
         // This route works for both Next.js and Vercel Build Output API
-        const routeContent = `import { resumeWebhook } from 'workflow/api';
+        // Bundled Build Output API webhook functions need world.ts statically
+        // present so getWorldLazy() can use the global getWorld registration
+        // instead of falling back to a missing sibling import("./world.js").
+        const routeContent = `${bundle ? "import 'workflow/runtime';\n" : ''}import { resumeWebhook } from 'workflow/api';
 
 async function handler(request) {
   const url = new URL(request.url);
@@ -919,7 +1513,7 @@ export const OPTIONS = handler;`;
                 '.mjs',
                 '.cjs',
             ],
-            sourcemap: EMIT_SOURCEMAPS_FOR_DEBUGGING,
+            sourcemap: this.resolveSourcemap(EMIT_SOURCEMAPS_FOR_DEBUGGING),
             mainFields: ['module', 'main'],
             // Don't externalize anything - bundle everything including workflow packages
             external: [],
@@ -968,7 +1562,40 @@ export const OPTIONS = handler;`;
     async ensureDirectory(filePath) {
         await mkdir(dirname(filePath), { recursive: true });
     }
-    async createSwcGitignore() {
+    async ensureSwcIgnored() {
+        await this.ensureProjectSwcGitignoreEntry();
+        await this.createSwcDirectoryGitignore();
+    }
+    async ensureProjectSwcGitignoreEntry() {
+        const gitignorePath = join(this.config.workingDir, '.gitignore');
+        try {
+            let content = '';
+            try {
+                content = await readFile(gitignorePath, 'utf-8');
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    return;
+                }
+            }
+            const hasSwcEntry = content.split(/\r?\n/).some((line) => {
+                const trimmed = line.trim();
+                return (trimmed === '.swc' ||
+                    trimmed === '.swc/' ||
+                    trimmed === '/.swc' ||
+                    trimmed === '/.swc/');
+            });
+            if (hasSwcEntry) {
+                return;
+            }
+            const separator = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+            await writeFile(gitignorePath, `${content}${separator}/.swc\n`);
+        }
+        catch {
+            // We're intentionally silently ignoring this error - updating .gitignore isn't critical
+        }
+    }
+    async createSwcDirectoryGitignore() {
         try {
             await writeFile(join(this.config.workingDir, '.swc', '.gitignore'), '*\n');
         }
@@ -995,6 +1622,67 @@ export const OPTIONS = handler;`;
             return this.resolvePath('.vercel/output/diagnostics/workflows-manifest.json');
         }
     }
+    /**
+     * Whether this is a development/watch build (e.g. `next dev`, `nitro dev`,
+     * or a Vite-based dev server for astro/sveltekit/vite). `config.watch` is
+     * plumbed by the builders that own a dev server (next, nitro, nest); the
+     * Vite-based integrations don't set it but run with
+     * `NODE_ENV === 'development'`. When neither signal is present we treat the
+     * build as production, so CLI/Vercel production builds default to off.
+     */
+    get isDevelopmentBuild() {
+        return this.config.watch === true || process.env.NODE_ENV === 'development';
+    }
+    /**
+     * Default source map mode for the stack-relevant bundles (steps + the
+     * intermediate workflow VM bundle): inline source maps in development so
+     * stack traces point at source files, and off in production so function
+     * bundles stay small (helps stay under the Vercel 250MB function limit) and
+     * skip the source-map-support runtime shim. The `sourcemap` config option
+     * and `WORKFLOW_SOURCEMAP` env var override this in either environment.
+     */
+    get defaultSourcemapMode() {
+        return this.isDevelopmentBuild ? 'inline' : false;
+    }
+    /**
+     * Resolve the effective source map mode for a given call site. Precedence:
+     * explicit `sourcemap` config > `WORKFLOW_SOURCEMAP` env var > the call
+     * site's default. Returned value is passed directly to esbuild's
+     * `sourcemap` option.
+     */
+    resolveSourcemap(defaultMode) {
+        if (this.config.sourcemap !== undefined)
+            return this.config.sourcemap;
+        const envMode = parseSourcemapEnv(process.env.WORKFLOW_SOURCEMAP);
+        if (envMode !== undefined)
+            return envMode;
+        return defaultMode;
+    }
+    /**
+     * Resolve whether workflow/step files under `node_modules` are discovered.
+     * Precedence: explicit `discoverWorkflowsInNodeModules` config > the
+     * `WORKFLOW_DISCOVER_NODE_MODULES` env var (`0`/`false` disables) > the
+     * default (`true`, discover them).
+     */
+    resolveDiscoverWorkflowsInNodeModules() {
+        if (this.config.discoverWorkflowsInNodeModules !== undefined) {
+            return this.config.discoverWorkflowsInNodeModules;
+        }
+        const envValue = parseDiscoverNodeModulesEnv(process.env.WORKFLOW_DISCOVER_NODE_MODULES);
+        if (envValue !== undefined)
+            return envValue;
+        return true;
+    }
+    /**
+     * Whether the resolved source map mode emits any source maps at all.
+     * Used by consumers like the Vercel builder to decide whether to include
+     * the source-map-support runtime shim in generated functions. Uses the same
+     * environment-aware default (`defaultSourcemapMode`) as the step/workflow
+     * bundles, so a production build with no override omits the shim.
+     */
+    get sourcemapsEnabled() {
+        return this.resolveSourcemap(this.defaultSourcemapMode) !== false;
+    }
     /**
      * Creates a manifest JSON file containing step/workflow/class metadata
      * and graph data for visualization.
@@ -1022,10 +1710,18 @@ export const OPTIONS = handler;`;
             const workflowCount = Object.values(workflows).reduce((acc, w) => acc + Object.keys(w).length, 0);
             const classCount = Object.values(classes).reduce((acc, c) => acc + Object.keys(c).length, 0);
             this.logCreateManifestInfo(`Created manifest with ${stepCount} ${pluralize('step', 'steps', stepCount)}, ${workflowCount} ${pluralize('workflow', 'workflows', workflowCount)}, and ${classCount} ${pluralize('class', 'classes', classCount)}`, `${Date.now() - buildStart}ms`);
+            if (!this.config.suppressCreateManifestLogs) {
+                console.log(this.getWorkflowBuildSummary({
+                    stepCount,
+                    workflowCount,
+                }));
+            }
+            this.resetWorkflowBuildTimer();
             return manifestJson;
         }
         catch (error) {
             console.warn('Failed to create manifest:', error instanceof Error ? error.message : String(error));
+            this.resetWorkflowBuildTimer();
             return undefined;
         }
     }
@@ -1085,4 +1781,4 @@ export const OPTIONS = handler;`;
         return result;
     }
 }
-//# sourceMappingURL=base-builder.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-builder.js","sourceRoot":"","sources":["../src/base-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EACL,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,EAAE,EACF,IAAI,EACJ,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,uBAAuB,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EACL,iBAAiB,GAElB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,mCAAmC,EACnC,+BAA+B,GAChC,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAEL,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,MAAM,eAAe,GAAG,SAAS,CAAC,uBAAuB,CAAC,CAAC;AAC3D,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAI/C;;;;;GAKG;AACH,MAAM,6BAA6B,GACjC,OAAO,CAAC,GAAG,CAAC,sCAAsC,KAAK,GAAG,CAAC;AAE7D,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAC;IACtC,QAAQ;IACR,QAAQ;IACR,UAAU;IACV,MAAM;CACP,CAAC,CAAC;AAEH;;;;GAIG;AACH,SAAS,iBAAiB,CACxB,KAAyB;IAEzB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IAC1D,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,GAAG,CAAC;QACT,KAAK,OAAO;YACV,OAAO,KAAK,CAAC;QACf,KAAK,GAAG,CAAC;QACT,KAAK,MAAM;YACT,OAAO,IAAI,CAAC;QACd;YACE,IAAI,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBACvC,OAAO,KAAsB,CAAC;YAChC,CAAC;YACD,OAAO,CAAC,IAAI,CACV,4CAA4C,KAAK,IAAI;gBACnD,qEAAqE,CACxE,CAAC;YACF,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,2BAA2B,CAClC,KAAyB;IAEzB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IAC1D,OAAO,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,OAAO,CAAC;AAC5C,CAAC;AAED,SAAS,mBAAmB,CAAC,UAAkB;IAC7C,IAAI,UAAU,GAAG,IAAI,EAAE,CAAC;QACtB,OAAO,GAAG,UAAU,IAAI,CAAC;IAC3B,CAAC;IAED,OAAO,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC;AAC9C,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,aAAa,CAAC,OAAiB;IAC5C,OAAO,KAAK,CAAC,IAAI,CACf,IAAI,GAAG,CACL,CACE,MAAM,OAAO,CAAC,GAAG,CACf,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QAC1B,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC9D,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC,CAAC,CACH,CACF,CAAC,IAAI,EAAE,CACT,CACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,iBAAiB,CAAC,IAAY,EAAE,mBAA2B;IAClE,MAAM,EAAE,eAAe,EAAE,GAAG,sBAAsB,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;IAC9E,IAAI,eAAe,EAAE,CAAC;QACpB,sEAAsE;QACtE,mCAAmC;QACnC,OAAO,mBAAmB,CAAC,eAAe,CAAC,CAAC;IAC9C,CAAC;IACD,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AAClC,CAAC;AAaD,SAAS,gBAAgB,CAAC,QAA+B;IACvD,OAAO,GAAG,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;AACjD,CAAC;AAED,SAAS,uBAAuB,CAC9B,aAAiE,EACjE,GAAuC,EACvC,KAAgC,EAChC,KAA0B;IAE1B,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,IAAI,EAAE,CAAC,EAAE,CAAC;QACtE,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACnD,MAAM,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YACvB,MAAM,QAAQ,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC7B,MAAM,OAAO,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;YACnC,IACE,QAAQ;gBACR,CAAC,QAAQ,CAAC,QAAQ,KAAK,OAAO,CAAC,QAAQ;oBACrC,QAAQ,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,EACjC,CAAC;gBACD,MAAM,MAAM,GAAG,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,aAAa,CAAC;gBACrE,MAAM,YAAY,GAAG,GAAG,KAAK,WAAW,CAAC;gBACzC,MAAM,gBAAgB,GAAG,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC;gBAChE,MAAM,IAAI,kBAAkB,CAC1B,aAAa,MAAM,KAAK,EAAE,mBAAmB,gBAAgB,CAAC,QAAQ,CAAC,QAAQ,gBAAgB,CAAC,OAAO,CAAC,GAAG,EAC3G;oBACE,IAAI,EACF,GAAG,gBAAgB,sCAAsC;wBACzD,qDAAqD,YAAY,aAAa;wBAC9E,8EAA8E;wBAC9E,2EAA2E;wBAC3E,4CAA4C;iBAC/C,CACF,CAAC;YACJ,CAAC;YACD,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,qBAAqB,CAC5B,MAAwB,EACxB,QAA0B,EAC1B,OAA2C,EAC3C,WAA+C;IAE/C,uBAAuB,CACrB,QAAQ,CAAC,KAAK,EACd,OAAO,EACP,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,EACrB,MAAM,CACP,CAAC;IACF,uBAAuB,CACrB,QAAQ,CAAC,SAAS,EAClB,WAAW,EACX,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,EACzB,UAAU,CACX,CAAC;IAEF,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,IAAI,EAAE,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC7E,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IACjE,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;AACzE,CAAC;AAED;;;;;GAKG;AACH,MAAM,OAAgB,WAAW;IACrB,MAAM,CAAiB;IAEjC;;;OAGG;IACK,sBAAsB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC3C,sBAAsB,CAAqB;IAC3C,sBAAsB,GAAG,IAAI,GAAG,EAAmC,CAAC;IAE5E,YAAY,MAAsB;QAChC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,IAAc,oBAAoB;QAChC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;IAC3D,CAAC;IAED,IAAc,mBAAmB;QAC/B,OAAO,IAAI,CAAC,MAAM,CAAC,mBAAmB,IAAI,IAAI,CAAC,oBAAoB,CAAC;IACtE,CAAC;IAES,kBAAkB,CAAC,GAAG,IAAe;QAC7C,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAChD,CAAC;IAEO,uBAAuB;QAC7B,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC3C,CAAC;IAEO,wBAAwB;QAC9B,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,sBAAsB,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAClE,CAAC;IAEO,uBAAuB;QAC7B,IAAI,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAC1C,CAAC;IAEO,uBAAuB,CAAC,EAC9B,SAAS,EACT,aAAa,GAId;QACC,MAAM,MAAM,GAAG,GAAG,SAAS,IAAI,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,KAAK,aAAa,IAAI,SAAS,CAAC,UAAU,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,CAAC;QAC9I,OAAO,2BAA2B,mBAAmB,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC;IACvG,CAAC;IAEO,4BAA4B,CAAC,GAAG,IAAe;QACrD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,iCAAiC,EAAE,CAAC;YACnD,IAAI,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAEO,0BAA0B,CAAC,GAAG,IAAe;QACnD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,+BAA+B,EAAE,CAAC;YACjD,IAAI,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAEO,qBAAqB,CAAC,GAAG,IAAe;QAC9C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,0BAA0B,EAAE,CAAC;YAC5C,IAAI,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,wBAAwB,CAAC,MAAc;QAI7C,IAAI,MAAM,KAAK,KAAK;YAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QACxD,OAAO;YACL,MAAM,EACJ,0HAA0H;gBAC1H,kGAAkG;gBAClG,+EAA+E;YACjF,MAAM,EAAE;gBACN,iBAAiB,EAAE,mBAAmB;gBACtC,qBAAqB,EAAE,uBAAuB;aAC/C;SACF,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACK,mBAAmB,CAAC,MAAc;QACxC,IAAI,MAAM,KAAK,KAAK;YAAE,OAAO,EAAE,CAAC;QAChC,OAAO,oHAAoH,CAAC;IAC9H,CAAC;IAQD;;;OAGG;IACO,KAAK,CAAC,gBAAgB;QAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QACpD,OAAO,MAAM,CAAC,CAAC,eAAe,EAAE,eAAe,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,aAAa;QAC3B,MAAM,MAAM,GAAG;YACb,oBAAoB;YACpB,YAAY;YACZ,aAAa;YACb,cAAc;YACd,aAAa;YACb,eAAe;YACf,eAAe;YACf,sBAAsB;YACtB,wBAAwB;YACxB,4BAA4B;YAC5B,YAAY;YACZ,mBAAmB;YACnB,cAAc;YACd,cAAc;YACd,aAAa;YACb,mBAAmB;SACpB,CAAC;QAEF,qEAAqE;QACrE,mEAAmE;QACnE,sEAAsE;QACtE,gEAAgE;QAChE,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC3B,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;YACjD,OAAO,IAAI,CAAC,CAAC,sCAAsC,CAAC,EAAE;gBACpD,GAAG;gBACH,MAAM;gBACN,QAAQ,EAAE,IAAI;gBACd,GAAG,EAAE,IAAI;aACV,CAAC,CAAC;QACL,CAAC,CAAC,CACH,CAAC;QAEF,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC;IACxB,CAAC;IAED;;;;;OAKG;IACK,iBAAiB,GACvB,IAAI,OAAO,EAAE,CAAC;IAET,2BAA2B;QAChC,IAAI,CAAC,iBAAiB,GAAG,IAAI,OAAO,EAAE,CAAC;IACzC,CAAC;IAEM,2BAA2B;QAChC,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC;IACtC,CAAC;IAED;;OAEG;IACK,MAAM,CAAU,eAAe,GAAG,IAAI,GAAG,CAAC;QAChD,aAAa;QACb,aAAa;KACd,CAAC,CAAC;IAEH;;;;;OAKG;IACK,KAAK,CAAC,iCAAiC;QAC7C,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;QACtD,IAAI,CAAC,gBAAgB,EAAE,MAAM;YAAE,OAAO;QAEtC,KAAK,MAAM,GAAG,IAAI,gBAAgB,EAAE,CAAC;YACnC,IAAI,WAAW,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAS;YACnD,IAAI,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAS;YAEnD,IACE,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC;gBACnB,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC;gBACnB,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC;gBACnB,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC;gBACjB,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EACjB,CAAC;gBACD,SAAS;YACX,CAAC;YAED,IAAI,CAAC;gBACH,kEAAkE;gBAClE,IAAI,mBAAmB,GAAG,KAAK,CAAC;gBAChC,IAAI,CAAC;oBACH,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,GAAG,eAAe,EAAE;wBACzD,KAAK,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;qBAChC,CAAC,CAAC;oBACH,MAAM,aAAa,GAAG,MAAM,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;oBAC3D,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAGvC,CAAC;oBACF,MAAM,YAAY,GAChB,OAAO,OAAO,CAAC,YAAY,KAAK,QAAQ;wBACxC,OAAO,CAAC,YAAY,KAAK,IAAI;wBAC7B,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC;wBAClC,CAAC,CAAE,OAAO,CAAC,YAAwC;wBACnD,CAAC,CAAC,EAAE,CAAC;oBACT,MAAM,gBAAgB,GACpB,OAAO,OAAO,CAAC,gBAAgB,KAAK,QAAQ;wBAC5C,OAAO,CAAC,gBAAgB,KAAK,IAAI;wBACjC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC;wBACtC,CAAC,CAAE,OAAO,CAAC,gBAA4C;wBACvD,CAAC,CAAC,EAAE,CAAC;oBACT,mBAAmB;wBACjB,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,iBAAiB,CAAC;4BAC9C,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;gBACvD,CAAC;gBAAC,MAAM,CAAC;oBACP,yDAAyD;gBAC3D,CAAC;gBAED,yCAAyC;gBACzC,sEAAsE;gBACtE,sEAAsE;gBACtE,mEAAmE;gBACnE,oEAAoE;gBACpE,iEAAiE;gBACjE,IAAI,UAAU,GAAG,KAAK,CAAC;gBACvB,IAAI,cAAc,GAAG,KAAK,CAAC;gBAC3B,IAAI,QAAQ,GAAG,mBAAmB,CAAC;gBACnC,IAAI,CAAC;oBACH,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE;wBACrC,KAAK,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;qBAChC,CAAC,CAAC;oBACH,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;oBAClD,MAAM,QAAQ,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;oBAChD,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;oBACjC,cAAc,GAAG,QAAQ,CAAC,cAAc,CAAC;oBACzC,IAAI,CAAC,QAAQ,EAAE,CAAC;wBACd,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;oBAC/B,CAAC;gBACH,CAAC;gBAAC,MAAM,CAAC;oBACP,+DAA+D;gBACjE,CAAC;gBAED,IAAI,CAAC,UAAU,IAAI,CAAC,cAAc,IAAI,CAAC,QAAQ;oBAAE,SAAS;gBAE1D,iDAAiD;gBACjD,MAAM,MAAM,GAAa,EAAE,CAAC;gBAC5B,IAAI,cAAc;oBAAE,MAAM,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;gBAC5D,IAAI,UAAU;oBAAE,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;gBACpD,IAAI,QAAQ;oBAAE,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;gBAEnD,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAErC,OAAO,CAAC,IAAI,CACV,KAAK,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,iBAAiB,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,KAAK,KAAK,CAAC,IAAI,CAAC,wBAAwB,CAAC,4CAA4C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;oBAChN,sBAAsB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,6EAA6E;oBACpH,cAAc,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,SAAS,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,KAAK,KAAK,CAAC,IAAI,CAAC,wBAAwB,CAAC,6BAA6B,CACpJ,CAAC;YACJ,CAAC;YAAC,MAAM,CAAC;gBACP,kEAAkE;YACpE,CAAC;QACH,CAAC;IACH,CAAC;IAES,KAAK,CAAC,eAAe,CAC7B,MAAgB,EAChB,MAAc,EACd,YAAqB;QAErB,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAE1D,IAAI,cAAc,EAAE,CAAC;YACnB,OAAO,cAAc,CAAC;QACxB,CAAC;QACD,MAAM,KAAK,GAAsB;YAC/B,eAAe,EAAE,IAAI,GAAG,EAAE;YAC1B,mBAAmB,EAAE,IAAI,GAAG,EAAE;YAC9B,oBAAoB,EAAE,IAAI,GAAG,EAAE;YAC/B,eAAe,EAAE,IAAI,GAAG,EAAE;SAC3B,CAAC;QAEF,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEjC,uEAAuE;QACvE,4EAA4E;QAC5E,uEAAuE;QACvE,sEAAsE;QACtE,sEAAsE;QACtE,sEAAsE;QACtE,wDAAwD;QACxD,MAAM,uBAAuB,GAAG,MAAM,eAAe,CACnD,MAAM,EACN,4BAA4B,CAC7B,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QACzB,MAAM,WAAW,GAAG,uBAAuB;YACzC,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,uBAAuB,CAAC;YACtC,CAAC,CAAC,MAAM,CAAC;QAEX,MAAM,qBAAqB,GACzB,YAAY,IAAI,CAAC,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;QAElD,MAAM,mBAAmB,CAAC;YACxB,WAAW;YACX,KAAK;YACL,mBAAmB,EAAE,qBAAqB;YAC1C,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;YAClC,8BAA8B,EAC5B,IAAI,CAAC,qCAAqC,EAAE;SAC/C,CAAC,CAAC;QAEH,IAAI,CAAC,kBAAkB,CACrB,iCAAiC,EACjC,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,aAAa,IAAI,CAClC,CAAC;QAEF,0DAA0D;QAC1D,MAAM,IAAI,CAAC,iCAAiC,EAAE,CAAC;QAE/C,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC1C,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,kBAAkB,CAC9B,UAAkB,EAClB,OAAe;QAEf,MAAM,QAAQ,GAAG,GAAG,UAAU,IAAI,UAAU,EAAE,MAAM,CAAC;QACrD,MAAM,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACnC,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,SAAS,GACb,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,IAAI,KAAK;gBACnD,CAAC,CAAE,KAA+B,CAAC,IAAI;gBACvC,CAAC,CAAC,SAAS,CAAC;YAChB,IACE,OAAO,CAAC,QAAQ,KAAK,OAAO;gBAC5B,CAAC,SAAS,KAAK,OAAO,IAAI,SAAS,KAAK,QAAQ,CAAC,EACjD,CAAC;gBACD,MAAM,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACrC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;gBACpC,OAAO;YACT,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,cAAc,CAC1B,OAAe,EACf,SAAiB,EACjB,KAAe;QAEf,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC;QACjD,MAAM,UAAU,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,aAAa,CAAC;QAClF,IAAI,QAAQ,GAAG,EAAE,CAAC;QAElB,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,CAAC;gBACV,IAAI,CAAC;oBACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;oBACnD,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACjC,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,wDAAwD;oBACxD,+EAA+E;oBAC/E,IAAK,CAA2B,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;wBACnD,OAAO,CAAC,IAAI,CAAC,2CAA2C,EAAE,CAAC,CAAC,CAAC;oBAC/D,CAAC;gBACH,CAAC;YACH,CAAC;YAED,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAC/B;gBACE,GAAG,QAAQ;gBACX,GAAG,SAAS;aACb,EACD,IAAI,EACJ,CAAC,CACF,CAAC;YAEF,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACxD,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,OAAO,CAAC,IAAI,CAAC,6BAA6B,EAAE,KAAK,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,kBAAkB,CACxB,MAA4C,EAC5C,KAAa,EACb,YAAY,GAAG,IAAI,EACnB,OAEC;QAED,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9C,OAAO,CAAC,KAAK,CAAC,uBAAuB,KAAK,GAAG,CAAC,CAAC;YAC/C,MAAM,aAAa,GAAa,EAAE,CAAC;YACnC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBAClC,OAAO,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;gBACjC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC/B,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;oBACnB,MAAM,QAAQ,GAAG,UAAU,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;oBACjG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;oBACxB,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAC/B,CAAC;YACH,CAAC;YAED,IAAI,YAAY,EAAE,CAAC;gBACjB,MAAM,IAAI,kBAAkB,CAC1B,uBAAuB,KAAK,MAAM,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAC5D;oBACE,IAAI,EAAE,wDAAwD,KAAK,+DAA+D;iBACnI,CACF,CAAC;YACJ,CAAC;QACH,CAAC;QAED,IACE,CAAC,OAAO,EAAE,gBAAgB;YAC1B,MAAM,CAAC,QAAQ;YACf,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAC1B,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,0BAA0B,KAAK,GAAG,CAAC,CAAC;YACjD,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACtC,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;gBAClC,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACrB,OAAO,CAAC,IAAI,CACV,UAAU,OAAO,CAAC,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,CACtF,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,YAAoB;QAC9C,MAAM,cAAc,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACxD,MAAM,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACxE,IAAI,YAAY,GAAG,QAAQ,CAAC,oBAAoB,EAAE,cAAc,CAAC,CAAC,OAAO,CACvE,KAAK,EACL,GAAG,CACJ,CAAC;QACF,wDAAwD;QACxD,IAAI,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,YAAY,GAAG,YAAY;iBACxB,KAAK,CAAC,GAAG,CAAC;iBACV,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC;iBAC/B,IAAI,CAAC,GAAG,CAAC,CAAC;QACf,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,KAAK,CAAC,0BAA0B,CACtC,IAAY,EACZ,IAAyB;QAEzB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACzD,IACE,MAAM;YACN,MAAM,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI;YAC1B,MAAM,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO,EAChC,CAAC;YACD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC5C,MAAM,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACxD,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,iBAAiB,CAClD,gBAAgB,EAChB,MAAM,EACN,IAAI,EACJ,IAAI,EACJ,IAAI,CAAC,oBAAoB,EACzB,IAAI,CAAC,mBAAmB,CACzB,CAAC;QACF,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,QAAQ,EAAE;YACxC,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,QAAQ,EAAE,gBAAgB;SAC3B,CAAC,CAAC;QACH,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAES,0BAA0B,CAAC,IAAY,EAAE,QAAgB;QACjE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,aAAa,CAC7C,IAAI,EACJ,IAAI,CAAC,MAAM,CAAC,UAAU,CACvB,CAAC;QACF,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,IAAI,YAAY,GAAG,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAChE,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YACtE,YAAY,GAAG,KAAK,YAAY,EAAE,CAAC;QACrC,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAES,KAAK,CAAC,gCAAgC,CAAC,EAC/C,UAAU,EACV,OAAO,EACP,YAAY,EACZ,iBAAiB,GAMlB;QACC,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,gBAAgB,GAAqB,EAAE,CAAC;QAC9C,MAAM,YAAY,GAAG,4BAA4B,CAAC;QAClD,MAAM,oBAAoB,GAAG,CAAC,MAAM,eAAe,CACjD,OAAO,CAAC,OAAO,CAAC,EAChB,YAAY,CACb,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACd,MAAM,IAAI,kBAAkB,CAC1B,2DAA2D,MAAM,CAAC,GAAG,CAAC,EAAE,EACxE;gBACE,IAAI,EAAE,oDAAoD;gBAC1D,KAAK,EAAE,GAAG;aACX,CACF,CAAC;QACJ,CAAC,CAAC,CAAW,CAAC;QAEd,MAAM,UAAU,GACd,iBAAiB;YACjB,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;QAC3E,MAAM,SAAS,GAAG,CAAC,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC,IAAI,EAAE,CAAC;QACzD,MAAM,aAAa,GAAG,CAAC,GAAG,UAAU,CAAC,mBAAmB,CAAC,CAAC,IAAI,EAAE,CAAC;QACjE,MAAM,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE,CAAC;QAC/D,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;QACxC,MAAM,cAAc,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAEtE,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE;YACjC,SAAS;YACT,aAAa;YACb,cAAc;YACd,aAAa,EAAE,IAAI;SACpB,CAAC,CAAC;QAEH,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAS,CAAC,YAAY,CAAC,CAAC,CAAC;QAChE,MAAM,gBAAgB,GAAa,EAAE,CAAC;QACtC,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAClC,MAAM,qBAAqB,GAAG,CAAC,SAAiB,EAAQ,EAAE;YACxD,gBAAgB,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAChE,CAAC,CAAC;QACF,MAAM,yBAAyB,GAAG,CAAC,IAAY,EAAQ,EAAE;YACvD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACnE,IAAI,uBAAuB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC1C,OAAO;YACT,CAAC;YACD,uBAAuB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACtC,qBAAqB,CAAC,IAAI,CAAC,0BAA0B,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;QACzE,CAAC,CAAC;QAEF,qBAAqB,CAAC,YAAY,CAAC,CAAC;QACpC,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE,CAAC;YAC7B,yBAAyB,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,cAAc,EAAE,CAAC;YAClC,yBAAyB,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;QAED,MAAM,MAAM,GAAG;;EAEjB,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC;;;CAG5B,CAAC;QACE,MAAM,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACnD,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAE/C,MAAM,aAAa,GAAG,KAAK,CAAC,IAAI,CAC9B,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,cAAc,EAAE,oBAAoB,CAAC,CAAC,CACjE,CAAC,IAAI,EAAE,CAAC;QACT,MAAM,OAAO,GAAG,IAAI,GAAG,EAAiC,CAAC;QACzD,MAAM,WAAW,GAAG,IAAI,GAAG,EAAiC,CAAC;QAC7D,MAAM,OAAO,CAAC,GAAG,CACf,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;YAC/B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,0BAA0B,CACxD,IAAI,EACJ,MAAM,CACP,CAAC;YACF,qBAAqB,CACnB,gBAAgB,EAChB,YAAY,EACZ,OAAO,EACP,WAAW,CACZ,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;QAEF,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC9B,IAAI,CAAC,kBAAkB,CACrB,4BAA4B,EAC5B,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,gBAAgB,IAAI,CACrC,CAAC;QACF,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED;;;;;;;;OAQG;IACO,KAAK,CAAC,iBAAiB,CAAC,EAChC,UAAU,EACV,MAAM,GAAG,KAAK,EACd,OAAO,EACP,mBAAmB,EACnB,qCAAqC,EACrC,6BAA6B,EAC7B,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EACjB,oBAAoB,GAAG,KAAK,GAkB7B;QAIC,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,gBAAgB,GAAqB,EAAE,CAAC;QAC9C,MAAM,YAAY,GAAG,4BAA4B,CAAC;QAElD,MAAM,oBAAoB,GAAG,MAAM,eAAe,CAChD,OAAO,CAAC,OAAO,CAAC,EAChB,4BAA4B,CAC7B,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACd,MAAM,IAAI,kBAAkB,CAC1B,2DAA2D,MAAM,CAAC,GAAG,CAAC,EAAE,EACxE;gBACE,IAAI,EAAE,oDAAoD;gBAC1D,KAAK,EAAE,GAAG;aACX,CACF,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,wEAAwE;QACxE,yEAAyE;QACzE,sEAAsE;QACtE,0EAA0E;QAC1E,MAAM,UAAU,GACd,iBAAiB;YACjB,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;QAC3E,MAAM,SAAS,GAAG,CAAC,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC,IAAI,EAAE,CAAC;QACzD,MAAM,aAAa,GAAG,CAAC,GAAG,UAAU,CAAC,mBAAmB,CAAC,CAAC,IAAI,EAAE,CAAC;QACjE,MAAM,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE,CAAC;QAE/D,2FAA2F;QAC3F,+EAA+E;QAC/E,sFAAsF;QACtF,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;QACxC,MAAM,cAAc,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAEtE,IACE,6BAA6B;YAC7B,mBAAmB;YACnB,CAAC,qCAAqC,EACtC,CAAC;YACD,OAAO;gBACL,OAAO,EAAE,SAAS;gBAClB,QAAQ,EAAE,MAAM,IAAI,CAAC,gCAAgC,CAAC;oBACpD,UAAU;oBACV,OAAO;oBACP,YAAY;oBACZ,iBAAiB,EAAE,UAAU;iBAC9B,CAAC;aACH,CAAC;QACJ,CAAC;QAED,mCAAmC;QACnC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE;YACjC,SAAS;YACT,aAAa;YACb,cAAc;SACf,CAAC,CAAC;QAEH,mDAAmD;QACnD,wEAAwE;QACxE,4EAA4E;QAC5E,MAAM,YAAY,GAAG,CAAC,IAAY,EAAE,EAAE;YACpC,MAAM,uBAAuB,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU;iBACnD,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;iBACnB,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACtB,MAAM,uBAAuB,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACzD,+DAA+D;YAC/D,qEAAqE;YACrE,mEAAmE;YACnE,mEAAmE;YACnE,sDAAsD;YACtD,MAAM,kCAAkC,GACtC,uBAAuB,CAAC,QAAQ,CAAC,YAAY,CAAC;gBAC9C,uBAAuB,CAAC,QAAQ,CAAC,OAAO,CAAC;gBACzC,CAAC,uBAAuB,CAAC,QAAQ,CAAC,gBAAgB,CAAC;gBACnD,CAAC,CACC,uBAAuB,KAAK,uBAAuB;oBACnD,uBAAuB,CAAC,UAAU,CAAC,GAAG,uBAAuB,GAAG,CAAC,CAClE,CAAC;YACJ,MAAM,yBAAyB,GAAG,kCAAkC,CAAC;YAErE,IAAI,yBAAyB,EAAE,CAAC;gBAC9B,IAAI,YAAY,GAAG,QAAQ,CACzB,uBAAuB,EACvB,uBAAuB,CACxB,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBACtB,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;oBACtE,YAAY,GAAG,KAAK,YAAY,EAAE,CAAC;gBACrC,CAAC;gBACD,OAAO,WAAW,YAAY,IAAI,CAAC;YACrC,CAAC;YAED,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,aAAa,CAC7C,IAAI,EACJ,IAAI,CAAC,MAAM,CAAC,UAAU,CACvB,CAAC;YAEF,IAAI,SAAS,EAAE,CAAC;gBACd,mEAAmE;gBACnE,OAAO,WAAW,UAAU,IAAI,CAAC;YACnC,CAAC;YAED,qCAAqC;YACrC,oEAAoE;YACpE,sGAAsG;YACtG,MAAM,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACxE,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAChD,6DAA6D;YAC7D,IAAI,YAAY,GAAG,QAAQ,CAAC,oBAAoB,EAAE,cAAc,CAAC,CAAC,OAAO,CACvE,KAAK,EACL,GAAG,CACJ,CAAC;YACF,0EAA0E;YAC1E,sEAAsE;YACtE,0BAA0B;YAC1B,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtE,YAAY,GAAG,KAAK,YAAY,EAAE,CAAC;YACrC,CAAC;YACD,OAAO,WAAW,YAAY,IAAI,CAAC;QACrC,CAAC,CAAC;QAEF,sEAAsE;QACtE,mDAAmD;QACnD,EAAE;QACF,mEAAmE;QACnE,sEAAsE;QACtE,iEAAiE;QACjE,sEAAsE;QACtE,qEAAqE;QACrE,oEAAoE;QACpE,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAS,CAAC,YAAY,CAAC,CAAC,CAAC;QAChE,MAAM,YAAY,GAAG,CAAC,KAAe,EAAU,EAAE,CAC/C,KAAK;aACF,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YACf,MAAM,QAAQ,GAAG,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACnE,IAAI,uBAAuB,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,OAAO,KAAK,CAAC;YACxD,uBAAuB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACtC,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;aACD,GAAG,CAAC,YAAY,CAAC;aACjB,IAAI,CAAC,IAAI,CAAC,CAAC;QAEhB,MAAM,WAAW,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;QAE5C,+DAA+D;QAC/D,MAAM,YAAY,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;QAElD,MAAM,YAAY,GAAG;;cAEX,YAAY;;MAEpB,WAAW;;MAEX,YAAY;;;4CAG0B,CAAC;QAEzC,gDAAgD;QAChD,MAAM,eAAe,GAAG,mBAAmB;YACzC,CAAC,CAAC;gBACE,GAAG,SAAS;gBACZ,GAAG,UAAU;gBACb,GAAG,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;aACxD;YACH,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,yBAAyB,GAAG,eAAe;YAC/C,CAAC,CAAC,MAAM,aAAa,CAAC,eAAe,CAAC;YACtC,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,2BAA2B,GAAG,MAAM,aAAa,CAAC;YACtD,GAAG,SAAS;YACZ,GAAG,cAAc;YACjB,GAAG,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;SACxD,CAAC,CAAC;QACH,MAAM,sBAAsB,GAC1B,MAAM,yBAAyB,CAAC,YAAY,CAAC,CAAC;QAChD,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAC1D,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;QACxC,MAAM,gBAAgB,GAAG,oBAAoB;YAC3C,CAAC,CAAC,EAAE;YACJ,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;QAErC,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC;YACvC,MAAM,EAAE;gBACN,EAAE,EAAE,mEAAmE,gBAAgB,GAAG,gBAAgB,EAAE;aAC7G;YACD,KAAK,EAAE;gBACL,QAAQ,EAAE,YAAY;gBACtB,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;gBAClC,UAAU,EAAE,kBAAkB;gBAC9B,MAAM,EAAE,IAAI;aACb;YACD,OAAO;YACP,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;YACrC,MAAM,EAAE,IAAI;YACZ,MAAM;YACN,QAAQ,EAAE,MAAM;YAChB,UAAU,EAAE,CAAC,MAAM,CAAC;YACpB,MAAM,EAAE,QAAQ;YAChB,KAAK,EAAE,IAAI;YACX,WAAW,EAAE,IAAI;YACjB,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,KAAK;YACb,GAAG,EAAE,UAAU;YACf,QAAQ,EAAE,OAAO;YACjB,0CAA0C;YAC1C,gFAAgF;YAChF,GAAG,sBAAsB;YACzB,MAAM,EAAE,gBAAgB;YACxB,iBAAiB,EAAE;gBACjB,KAAK;gBACL,MAAM;gBACN,MAAM;gBACN,MAAM;gBACN,KAAK;gBACL,MAAM;gBACN,MAAM;gBACN,MAAM;aACP;YACD,uEAAuE;YACvE,wEAAwE;YACxE,sEAAsE;YACtE,qEAAqE;YACrE,yEAAyE;YACzE,mEAAmE;YACnE,qDAAqD;YACrD,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,oBAAoB,CAAC;YAC3D,OAAO,EAAE;gBACP,2EAA2E;gBAC3E,4EAA4E;gBAC5E,yBAAyB,EAAE;gBAC3B,eAAe,CAAC;oBACd,IAAI,EAAE,MAAM;oBACZ,eAAe,EAAE,yBAAyB;oBAC1C,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;oBAC9C,WAAW,EAAE,IAAI,CAAC,oBAAoB;oBACtC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;oBAC7C,gBAAgB;oBAChB,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAC,gBAAgB;oBAC9C,qCAAqC;oBACrC,mBAAmB;oBACnB,iBAAiB,EAAE,2BAA2B;iBAC/C,CAAC;aACH;YACD,qEAAqE;YACrE,4DAA4D;YAC5D,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC;SACpE,CAAC,CAAC;QAEH,MAAM,WAAW,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;QAE/C,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,uBAAuB,CAAC,CAAC;QAC9D,IAAI,CAAC,kBAAkB,CACrB,sBAAsB,EACtB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,gBAAgB,IAAI,CACrC,CAAC;QAEF,6EAA6E;QAC7E,8EAA8E;QAC9E,iEAAiE;QACjE,MAAM,iBAAiB,GAAG,aAAa,CAAC,MAAM,CAC5C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAC9B,CAAC;QACF,MAAM,OAAO,CAAC,GAAG,CACf,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE;YAC3C,IAAI,CAAC;gBACH,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,0BAA0B,CACxD,YAAY,EACZ,UAAU,CACX,CAAC;gBACF,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;oBAC3B,gBAAgB,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,CACxC,gBAAgB,CAAC,SAAS,IAAI,EAAE,EAChC,YAAY,CAAC,SAAS,CACvB,CAAC;gBACJ,CAAC;gBACD,IAAI,YAAY,CAAC,OAAO,EAAE,CAAC;oBACzB,gBAAgB,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CACtC,gBAAgB,CAAC,OAAO,IAAI,EAAE,EAC9B,YAAY,CAAC,OAAO,CACrB,CAAC;gBACJ,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,4EAA4E;gBAC5E,OAAO,CAAC,IAAI,CACV,qDAAqD,YAAY,GAAG,EACpE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CACvD,CAAC;YACJ,CAAC;QACH,CAAC,CAAC,CACH,CAAC;QAEF,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAE9B,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACtB,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;QAC7D,CAAC;QACD,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;QAC3B,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC5D,CAAC;IAED;;;;;OAKG;IACO,KAAK,CAAC,qBAAqB,CAAC,EACpC,UAAU,EACV,MAAM,GAAG,KAAK,EACd,OAAO,EACP,iBAAiB,GAAG,IAAI,EACxB,wBAAwB,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAC5C,YAAY,EACZ,iBAAiB,GASlB;QAOC,MAAM,UAAU,GACd,iBAAiB;YACjB,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;QAC3E,MAAM,aAAa,GAAG,CAAC,GAAG,UAAU,CAAC,mBAAmB,CAAC,CAAC,IAAI,EAAE,CAAC;QACjE,MAAM,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE,CAAC;QAE/D,+FAA+F;QAC/F,mFAAmF;QACnF,4EAA4E;QAC5E,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,CAAC;QAChD,MAAM,cAAc,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1E,uCAAuC;QACvC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC,CAAC;QAEtE,mDAAmD;QACnD,sEAAsE;QACtE,qDAAqD;QACrD,MAAM,YAAY,GAAG,CAAC,IAAY,EAAE,EAAE;YACpC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,aAAa,CAC7C,IAAI,EACJ,IAAI,CAAC,MAAM,CAAC,UAAU,CACvB,CAAC;YAEF,IAAI,SAAS,EAAE,CAAC;gBACd,mEAAmE;gBACnE,qCAAqC;gBACrC,OAAO,WAAW,UAAU,IAAI,CAAC;YACnC,CAAC;YAED,qCAAqC;YACrC,oEAAoE;YACpE,sGAAsG;YACtG,MAAM,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACxE,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAChD,6DAA6D;YAC7D,IAAI,YAAY,GAAG,QAAQ,CAAC,oBAAoB,EAAE,cAAc,CAAC,CAAC,OAAO,CACvE,KAAK,EACL,GAAG,CACJ,CAAC;YACF,0EAA0E;YAC1E,sEAAsE;YACtE,0BAA0B;YAC1B,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtE,YAAY,GAAG,KAAK,YAAY,EAAE,CAAC;YACrC,CAAC;YACD,OAAO,WAAW,YAAY,IAAI,CAAC;QACrC,CAAC,CAAC;QAEF,oEAAoE;QACpE,wEAAwE;QACxE,mEAAmE;QACnE,2CAA2C;QAC3C,MAAM,uBAAuB,GAAG,IAAI,GAAG,EAAU,CAAC;QAClD,MAAM,YAAY,GAAG,CAAC,KAAe,EAAU,EAAE,CAC/C,KAAK;aACF,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YACf,MAAM,QAAQ,GAAG,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACnE,IAAI,uBAAuB,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,OAAO,KAAK,CAAC;YACxD,uBAAuB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACtC,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;aACD,GAAG,CAAC,YAAY,CAAC;aACjB,IAAI,CAAC,IAAI,CAAC,CAAC;QAEhB,6FAA6F;QAC7F,sFAAsF;QACtF,MAAM,eAAe,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;QAEpD,+DAA+D;QAC/D,MAAM,YAAY,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;QAElD,MAAM,OAAO,GAAG,YAAY;YAC1B,CAAC,CAAC,GAAG,eAAe,0DAA0D,YAAY,EAAE;YAC5F,CAAC,CAAC,eAAe,CAAC;QAEpB,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACnC,MAAM,gBAAgB,GAAqB,EAAE,CAAC;QAC9C,MAAM,sBAAsB,GAC1B,MAAM,yBAAyB,CAAC,YAAY,CAAC,CAAC;QAChD,MAAM,mCAAmC,GAAG,MAAM,aAAa,CAAC;YAC9D,GAAG,aAAa;YAChB,GAAG,cAAc;SAClB,CAAC,CAAC;QAEH,kEAAkE;QAClE,8CAA8C;QAC9C,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC;YAC7C,KAAK,EAAE;gBACL,QAAQ,EAAE,OAAO;gBACjB,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;gBAClC,UAAU,EAAE,kBAAkB;gBAC9B,MAAM,EAAE,IAAI;aACb;YACD,MAAM,EAAE,IAAI;YACZ,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;YACrC,MAAM,EAAE,KAAK,EAAE,uCAAuC;YACtD,QAAQ,EAAE,SAAS,EAAE,2CAA2C;YAChE,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,+BAA+B;YAC/D,UAAU,EAAE,CAAC,UAAU,CAAC,EAAE,yDAAyD;YACnF,MAAM,EAAE,QAAQ;YAChB,KAAK,EAAE,KAAK;YACZ,WAAW,EAAE,IAAI;YACjB,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,KAAK;YACb,iEAAiE;YACjE,4EAA4E;YAC5E,qEAAqE;YACrE,MAAM,EAAE;gBACN,EAAE,EAAE,6CAA6C;aAClD;YACD,qEAAqE;YACrE,wEAAwE;YACxE,sDAAsD;YACtD,0EAA0E;YAC1E,sEAAsE;YACtE,oEAAoE;YACpE,sEAAsE;YACtE,yDAAyD;YACzD,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,oBAAoB,CAAC;YAC3D,0CAA0C;YAC1C,gFAAgF;YAChF,GAAG,sBAAsB;YACzB,iBAAiB,EAAE;gBACjB,KAAK;gBACL,MAAM;gBACN,MAAM;gBACN,MAAM;gBACN,KAAK;gBACL,MAAM;gBACN,MAAM;gBACN,MAAM;aACP;YACD,OAAO,EAAE;gBACP,2EAA2E;gBAC3E,4EAA4E;gBAC5E,yBAAyB,EAAE;gBAC3B,eAAe,CAAC;oBACd,IAAI,EAAE,UAAU;oBAChB,WAAW,EAAE,IAAI,CAAC,oBAAoB;oBACtC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;oBAC7C,gBAAgB;oBAChB,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAC,gBAAgB;oBAC9C,iBAAiB,EAAE,mCAAmC;iBACvD,CAAC;gBACF,4EAA4E;gBAC5E,oFAAoF;gBACpF,2BAA2B,EAAE;aAC9B;YACD,mFAAmF;YACnF,2FAA2F;YAC3F,uFAAuF;YACvF,qFAAqF;YACrF,2CAA2C;YAC3C,6CAA6C;YAC7C,qFAAqF;YACrF,iFAAiF;SAClF,CAAC,CAAC;QACH,IAAI,6BAA6B,GAAG,CAAC,wBAAwB,CAAC;QAC9D,IAAI,CAAC;YACH,MAAM,aAAa,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,CAAC;YAEvD,IAAI,CAAC,kBAAkB,CACrB,aAAa,EACb,8BAA8B,EAC9B,IAAI,EACJ;gBACE,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAC,qCAAqC;aACpE,CACF,CAAC;YACF,IAAI,CAAC,4BAA4B,CAC/B,sCAAsC,EACtC,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,IAAI,CACpC,CAAC;YAEF,IAAI,IAAI,CAAC,MAAM,CAAC,oBAAoB,EAAE,CAAC;gBACrC,MAAM,YAAY,GAAG,OAAO,CAC1B,OAAO,CAAC,GAAG,EAAE,EACb,IAAI,CAAC,MAAM,CAAC,oBAAoB,CACjC,CAAC;gBACF,IAAI,MAAM,GAAG,EAAE,CAAC;gBAEhB,IAAI,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;oBAClC,MAAM,GAAG,mBAAmB,CAAC;gBAC/B,CAAC;qBAAM,IACL,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC;oBAC5B,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,EAC7B,CAAC;oBACD,MAAM,GAAG,iBAAiB,CAAC;gBAC7B,CAAC;gBAED,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;gBACxD,MAAM,SAAS,CACb,YAAY,EACZ,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC,CACnD,CAAC;YACJ,CAAC;YAED,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAE9B,IACE,CAAC,aAAa,CAAC,WAAW;gBAC1B,aAAa,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,EACtC,CAAC;gBACD,MAAM,IAAI,kBAAkB,CAAC,wCAAwC,EAAE;oBACrE,IAAI,EAAE,yKAAyK;iBAChL,CAAC,CAAC;YACL,CAAC;YAED,0EAA0E;YAC1E,iFAAiF;YACjF,IACE,gBAAgB,CAAC,OAAO;gBACxB,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EAChD,CAAC;gBACD,MAAM,EAAE,sBAAsB,EAAE,GAAG,MAAM,MAAM,CAAC,oBAAoB,CAAC,CAAC;gBACtE,MAAM,UAAU,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBACrD,MAAM,WAAW,GAAG,sBAAsB,CAAC;oBACzC,UAAU,EAAE,EAAE;oBACd,YAAY,EAAE,UAAU;oBACxB,QAAQ,EAAE,gBAAgB;iBAC3B,CAAC,CAAC;gBACH,0DAA0D;gBAC1D,MAAM,eAAe,GAAG,IAAI,GAAG,EAAuB,CAAC;gBACvD,KAAK,MAAM,GAAG,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;oBACtC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;wBACnB,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;4BAC/B,IAAI,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;4BACjD,IAAI,CAAC,eAAe,EAAE,CAAC;gCACrB,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;gCACpC,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;4BAC9C,CAAC;4BACD,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;wBACrC,CAAC;oBACH,CAAC;gBACH,CAAC;gBACD,KAAK,MAAM,CAAC,KAAK,EAAE,eAAe,CAAC,IAAI,eAAe,EAAE,CAAC;oBACvD,MAAM,UAAU,GAAG,CAAC,GAAG,eAAe,CAAC,CAAC;oBACxC,MAAM,UAAU,GACd,UAAU,CAAC,MAAM,KAAK,CAAC;wBACrB,CAAC,CAAC,UAAU,UAAU,CAAC,CAAC,CAAC,GAAG;wBAC5B,CAAC,CAAC,WAAW,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;oBACpE,OAAO,CAAC,IAAI,CACV,KAAK,CAAC,MAAM,CAAC,uBAAuB,UAAU,IAAI,CAAC,GAAG,KAAK,CAC5D,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,MAAM,6BAA6B,GAAG,mCAAmC,CACvE;gBACE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;gBAC9B,wBAAwB,EAAE,kCAAkC;aAC7D,CACF,CAAC;YAEF,MAAM,WAAW,GAAG,KAAK,EAAE,aAAqB,EAAE,EAAE;gBAClD,MAAM,kBAAkB,GAAG,aAAa,CAAC;gBAEzC,MAAM,oBAAoB,GAAG;;;;;yBAKZ,kBAAkB,CAAC,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC;;EAEpE,+BAA+B,CAAC,kCAAkC,6BAA6B,GAAG,CAAC,EAAE,CAAC;gBAEhG,sEAAsE;gBACtE,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBACvB,IAAI,CAAC,OAAO,EAAE,CAAC;wBACb,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;oBACpE,CAAC;oBACD,qCAAqC;oBACrC,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;oBACnC,MAAM,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;oBAE5C,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC;oBAC7D,OAAO;gBACT,CAAC;gBAED,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBAEnC,kEAAkE;gBAClE,+DAA+D;gBAC/D,MAAM,qBAAqB,GAAG,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;gBAC/D,MAAM,mBAAmB,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC;oBAC9C,MAAM,EAAE;wBACN,EAAE,EAAE,mEAAmE,qBAAqB,EAAE;qBAC/F;oBACD,KAAK,EAAE;wBACL,QAAQ,EAAE,oBAAoB;wBAC9B,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;wBAClC,UAAU,EAAE,kBAAkB;wBAC9B,MAAM,EAAE,IAAI;qBACb;oBACD,OAAO;oBACP,mFAAmF;oBACnF,8EAA8E;oBAC9E,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,6BAA6B,CAAC;oBAC/D,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;oBACrC,MAAM,EAAE,IAAI;oBACZ,MAAM;oBACN,QAAQ,EAAE,MAAM;oBAChB,MAAM,EAAE,QAAQ;oBAChB,KAAK,EAAE,IAAI;oBACX,SAAS,EAAE,IAAI;oBACf,MAAM,EAAE,KAAK;oBACb,QAAQ,EAAE,CAAC,2CAA2C,CAAC;iBACxD,CAAC,CAAC;gBAEH,IAAI,CAAC,kBAAkB,CACrB,mBAAmB,EACnB,uBAAuB,EACvB,IAAI,EACJ;oBACE,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAC,qCAAqC;iBACpE,CACF,CAAC;gBACF,IAAI,CAAC,4BAA4B,CAC/B,+BAA+B,EAC/B,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,IAAI,CACpC,CAAC;YACJ,CAAC,CAAC;YACF,MAAM,iBAAiB,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAC5D,MAAM,WAAW,CAAC,iBAAiB,CAAC,CAAC;YAErC,IAAI,wBAAwB,EAAE,CAAC;gBAC7B,6BAA6B,GAAG,KAAK,CAAC;gBACtC,OAAO;oBACL,QAAQ,EAAE,gBAAgB;oBAC1B,gBAAgB;oBAChB,WAAW;oBACX,iBAAiB;iBAClB,CAAC;YACJ,CAAC;YACD,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,CAAC;QAC3D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,6BAA6B,GAAG,IAAI,CAAC;YACrC,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,IAAI,6BAA6B,EAAE,CAAC;gBAClC,IAAI,CAAC;oBACH,MAAM,gBAAgB,CAAC,OAAO,EAAE,CAAC;gBACnC,CAAC;gBAAC,OAAO,YAAY,EAAE,CAAC;oBACtB,OAAO,CAAC,IAAI,CACV,oDAAoD,EACpD,YAAY,CACb,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACO,KAAK,CAAC,oBAAoB,CAAC,EACnC,UAAU,EACV,YAAY,EACZ,WAAW,EACX,MAAM,GAAG,KAAK,EACd,iBAAiB,GAAG,IAAI,EACxB,YAAY,EACZ,mBAAmB,EACnB,qCAAqC,EACrC,6BAA6B,EAC7B,iBAAiB,GAclB;QASC,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,MAAM,0BAA0B,GAC9B,iBAAiB;YACjB,CAAC,MAAM,IAAI,CAAC,eAAe,CACzB,UAAU,EACV,OAAO,CAAC,WAAW,CAAC,EACpB,YAAY,CACb,CAAC,CAAC;QAEL,gEAAgE;QAChE,uEAAuE;QACvE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,GACtD,MAAM,IAAI,CAAC,iBAAiB,CAAC;YAC3B,UAAU;YACV,OAAO,EAAE,YAAY;YACrB,+DAA+D;YAC/D,gEAAgE;YAChE,kEAAkE;YAClE,2DAA2D;YAC3D,gEAAgE;YAChE,+DAA+D;YAC/D,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM;YAC1C,mBAAmB;YACnB,qCAAqC;YACrC,6BAA6B;YAC7B,YAAY;YACZ,iBAAiB,EAAE,0BAA0B;YAC7C,sEAAsE;YACtE,iEAAiE;YACjE,4DAA4D;YAC5D,oBAAoB,EAAE,iBAAiB;SACxC,CAAC,CAAC;QAEL,4BAA4B;QAC5B,MAAM,mBAAmB,GAAG,GAAG,WAAW,cAAc,CAAC;QACzD,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC;YACvD,UAAU;YACV,OAAO,EAAE,mBAAmB;YAC5B,MAAM;YACN,iBAAiB,EAAE,KAAK;YACxB,YAAY;YACZ,iBAAiB,EAAE,0BAA0B;SAC9C,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,eAAe,CAAC,iBAAiB,CAAC;QACzD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;QAED,4BAA4B;QAC5B,IAAI,CAAC;YACH,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAC;YACpD,MAAM,MAAM,CAAC,mBAAmB,CAAC,CAAC;QACpC,CAAC;QAAC,MAAM,CAAC;YACP,wBAAwB;QAC1B,CAAC;QAED,kCAAkC;QAClC,MAAM,iBAAiB,GAAG,KAAK,QAAQ,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;QAC5E,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAChE,MAAM,6BAA6B,GAAG,mCAAmC,CAAC;YACxE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC9B,wBAAwB,EAAE,kCAAkC;SAC7D,CAAC,CAAC;QAEH,MAAM,oBAAoB,GAAG;;sCAEK,iBAAiB;;;;;;;;yBAQ9B,aAAa;;EAEpC,+BAA+B,CAAC,kCAAkC,6BAA6B,GAAG,CAAC,EAAE,CAAC;QAEpG,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;QACnE,CAAC;aAAM,CAAC;YACN,8CAA8C;YAC9C,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACnC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAC1D,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;YACxC,sEAAsE;YACtE,yEAAyE;YACzE,yDAAyD;YACzD,MAAM,qBAAqB,GAAG,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;YAC/D,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC;gBACtC,MAAM,EAAE;oBACN,EAAE,EAAE,mEAAmE,gBAAgB,GAAG,qBAAqB,EAAE;iBAClH;gBACD,KAAK,EAAE;oBACL,QAAQ,EAAE,oBAAoB;oBAC9B,UAAU,EAAE,OAAO,CAAC,WAAW,CAAC;oBAChC,UAAU,EAAE,kBAAkB;oBAC9B,MAAM,EAAE,IAAI;iBACb;gBACD,OAAO,EAAE,WAAW;gBACpB,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;gBACrC,MAAM,EAAE,IAAI;gBACZ,MAAM;gBACN,QAAQ,EAAE,MAAM;gBAChB,MAAM,EAAE,QAAQ;gBAChB,KAAK,EAAE,IAAI;gBACX,SAAS,EAAE,IAAI;gBACf,MAAM,EAAE,KAAK;gBACb,MAAM,EAAE,gBAAgB;gBACxB,QAAQ,EAAE,CAAC,2CAA2C,CAAC;aACxD,CAAC,CAAC;YACH,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,iBAAiB,EAAE,IAAI,CAAC,CAAC;YAC9D,IAAI,CAAC,kBAAkB,CACrB,yBAAyB,EACzB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,IAAI,CACpC,CAAC;QACJ,CAAC;QAED,kBAAkB;QAClB,MAAM,QAAQ,GAAqB;YACjC,GAAG,aAAa;YAChB,SAAS,EAAE;gBACT,GAAG,aAAa,CAAC,SAAS;gBAC1B,GAAG,eAAe,CAAC,QAAQ,CAAC,SAAS;aACtC;YACD,OAAO,EAAE;gBACP,GAAG,aAAa,CAAC,OAAO;gBACxB,GAAG,eAAe,CAAC,QAAQ,CAAC,OAAO;aACpC;SACF,CAAC;QAEF,0EAA0E;QAC1E,MAAM,mBAAmB,GAAG,KAAK,EAAE,iBAAyB,EAAE,EAAE;YAC9D,MAAM,OAAO,GAAG,iBAAiB,CAAC,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YAC7D,MAAM,6BAA6B,GAAG,mCAAmC,CACvE;gBACE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;gBAC9B,wBAAwB,EAAE,kCAAkC;aAC7D,CACF,CAAC;YACF,MAAM,IAAI,GAAG;;sCAEmB,iBAAiB;;;;;;;yBAO9B,OAAO;;EAE9B,+BAA+B,CAAC,kCAAkC,6BAA6B,GAAG,CAAC,EAAE,CAAC;YAElG,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;YACvC,MAAM,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAC5C,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACnD,CAAC,CAAC;QAEF,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACtB,OAAO;gBACL,QAAQ;gBACR,YAAY;gBACZ,gBAAgB,EAAE,eAAe,CAAC,gBAAgB;gBAClD,WAAW,EAAE,mBAAmB;gBAChC,iBAAiB,EAAE,0BAA0B;gBAC7C,aAAa;gBACb,iBAAiB,EAAE,eAAe,CAAC,QAAQ;aAC5C,CAAC;QACJ,CAAC;QAED,OAAO;YACL,QAAQ;YACR,iBAAiB,EAAE,0BAA0B;YAC7C,aAAa;YACb,iBAAiB,EAAE,eAAe,CAAC,QAAQ;SAC5C,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,mBAAmB;QACjC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;YAClC,qDAAqD;YACrD,OAAO;QACT,CAAC;QAED,IAAI,CAAC,kBAAkB,CACrB,gCAAgC,EAChC,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAC7B,CAAC;QACF,IAAI,CAAC,kBAAkB,CACrB,kIAAkI,CACnI,CAAC;QAEF,qDAAqD;QACrD,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACxD,MAAM,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAE5C,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;QAE9C,mGAAmG;QACnG,+EAA+E;QAC/E,+FAA+F;QAC/F,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,IAAI,CAAC,eAAe,CACzD,UAAU,EACV,SAAS,CACV,CAAC;QAEF,oEAAoE;QACpE,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAClC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAC7C,CAAC;QACF,MAAM,cAAc,GAAG,CAAC,GAAG,oBAAoB,CAAC,CAAC,MAAM,CACrD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,CAAC,CACpC,CAAC;QAEF,iEAAiE;QACjE,wEAAwE;QACxE,kEAAkE;QAClE,MAAM,SAAS,GAAG,UAAU;aACzB,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACZ,MAAM,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACxE,IAAI,YAAY,GAAG,QAAQ,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC,OAAO,CAC7D,KAAK,EACL,GAAG,CACJ,CAAC;YACF,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtE,YAAY,GAAG,KAAK,YAAY,EAAE,CAAC;YACrC,CAAC;YACD,OAAO,kBAAkB,YAAY,IAAI,CAAC;QAC5C,CAAC,CAAC;aACD,IAAI,CAAC,IAAI,CAAC,CAAC;QAEd,iFAAiF;QACjF,MAAM,YAAY,GAAG,cAAc;aAChC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACZ,MAAM,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACxE,IAAI,YAAY,GAAG,QAAQ,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC,OAAO,CAC7D,KAAK,EACL,GAAG,CACJ,CAAC;YACF,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtE,YAAY,GAAG,KAAK,YAAY,EAAE,CAAC;YACrC,CAAC;YACD,OAAO,WAAW,YAAY,IAAI,CAAC;QACrC,CAAC,CAAC;aACD,IAAI,CAAC,IAAI,CAAC,CAAC;QAEd,sEAAsE;QACtE,MAAM,YAAY,GAAG,YAAY;YAC/B,CAAC,CAAC,wDAAwD,YAAY,KAAK,SAAS,EAAE;YACtF,CAAC,CAAC,SAAS,CAAC;QAEd,gDAAgD;QAChD,MAAM,iCAAiC,GAAG,MAAM,aAAa,CAAC;YAC5D,GAAG,UAAU;YACb,GAAG,cAAc;SAClB,CAAC,CAAC;QACH,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC;YACvC,MAAM,EAAE;gBACN,EAAE,EAAE,kEAAkE;aACvE;YACD,KAAK,EAAE;gBACL,QAAQ,EAAE,YAAY;gBACtB,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;gBAClC,UAAU,EAAE,kBAAkB;gBAC9B,MAAM,EAAE,IAAI;aACb;YACD,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,gBAAgB;YACrC,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,MAAM;YAChB,GAAG,EAAE,UAAU;YACf,MAAM,EAAE,QAAQ;YAChB,KAAK,EAAE,IAAI;YACX,WAAW,EAAE,IAAI;YACjB,QAAQ,EAAE,CAAC,gBAAgB,CAAC;YAC5B,iBAAiB,EAAE;gBACjB,KAAK;gBACL,MAAM;gBACN,MAAM;gBACN,MAAM;gBACN,KAAK;gBACL,MAAM;gBACN,MAAM;gBACN,MAAM;aACP;YACD,OAAO,EAAE;gBACP,eAAe,CAAC;oBACd,IAAI,EAAE,MAAM;oBACZ,WAAW,EAAE,IAAI,CAAC,oBAAoB;oBACtC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;oBAC7C,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAC,gBAAgB;oBAC9C,iBAAiB,EAAE,iCAAiC;iBACrD,CAAC;aACH;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAC;QAE/D,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,mBAAmB,CAAC,EAClC,OAAO,EACP,MAAM,GAAG,KAAK,GAIf;QACC,IAAI,CAAC,0BAA0B,CAAC,wBAAwB,CAAC,CAAC;QAC1D,MAAM,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAEnD,iDAAiD;QACjD,gEAAgE;QAChE,sEAAsE;QACtE,qEAAqE;QACrE,qEAAqE;QACrE,MAAM,YAAY,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4BxC,CAAC;QAE7B,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,6CAA6C;YAC7C,MAAM,SAAS,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;YACvC,OAAO;QACT,CAAC;QAED,+DAA+D;QAE/D,MAAM,uBAAuB,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAChE,MAAM,kBAAkB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACtC,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC;YACjC,MAAM,EAAE;gBACN,EAAE,EAAE,mEAAmE,uBAAuB,EAAE;aACjG;YACD,KAAK,EAAE;gBACL,QAAQ,EAAE,YAAY;gBACtB,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;gBAClC,UAAU,EAAE,kBAAkB;gBAC9B,MAAM,EAAE,IAAI;aACb;YACD,OAAO;YACP,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;YACrC,MAAM,EAAE,IAAI;YACZ,GAAG,EAAE,UAAU;YACf,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,MAAM;YAChB,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC;YACnD,MAAM,EAAE,QAAQ;YAChB,KAAK,EAAE,IAAI;YACX,WAAW,EAAE,IAAI;YACjB,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,KAAK;YACb,iBAAiB,EAAE;gBACjB,KAAK;gBACL,MAAM;gBACN,MAAM;gBACN,MAAM;gBACN,KAAK;gBACL,MAAM;gBACN,MAAM;gBACN,MAAM;aACP;YACD,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,6BAA6B,CAAC;YAC/D,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;YAC9B,6EAA6E;YAC7E,QAAQ,EAAE,EAAE;SACb,CAAC,CAAC;QAEH,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;QAC3D,IAAI,CAAC,0BAA0B,CAC7B,wBAAwB,EACxB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,kBAAkB,IAAI,CACvC,CAAC;IACJ,CAAC;IAED;;OAEG;IACO,KAAK,CAAC,iBAAiB,CAC/B,GAAW,EACX,IAA2B;QAE3B,MAAM,WAAW,GAAG,EAAE,IAAI,EAAE,CAAC;QAC7B,MAAM,SAAS,CACb,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,EACzB,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,CACrC,CAAC;IACJ,CAAC;IAED;;OAEG;IACO,KAAK,CAAC,cAAc,CAC5B,GAAW,EACX,MAiBC;QAED,MAAM,QAAQ,GAAG;YACf,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,YAAY;YACvC,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,WAAW;YACtC,YAAY,EAAE,MAAM,CAAC,YAAY,IAAI,QAAQ;YAC7C,YAAY,EAAE,MAAM,CAAC,YAAY,IAAI,OAAO;YAC5C,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,IAAI,IAAI;YACjD,GAAG,CAAC,MAAM,CAAC,WAAW,KAAK,SAAS,IAAI;gBACtC,WAAW,EAAE,MAAM,CAAC,WAAW;aAChC,CAAC;YACF,GAAG,CAAC,MAAM,CAAC,yBAAyB,KAAK,SAAS,IAAI;gBACpD,yBAAyB,EAAE,MAAM,CAAC,yBAAyB;aAC5D,CAAC;YACF,GAAG,CAAC,MAAM,CAAC,oBAAoB,IAAI;gBACjC,oBAAoB,EAAE,MAAM,CAAC,oBAAoB;aAClD,CAAC;SACH,CAAC;QAEF,MAAM,SAAS,CACb,IAAI,CAAC,GAAG,EAAE,iBAAiB,CAAC,EAC5B,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAClC,CAAC;IACJ,CAAC;IAED;;OAEG;IACO,WAAW,CAAC,IAAY;QAChC,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACO,KAAK,CAAC,eAAe,CAAC,QAAgB;QAC9C,MAAM,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACtD,CAAC;IAES,KAAK,CAAC,gBAAgB;QAC9B,MAAM,IAAI,CAAC,8BAA8B,EAAE,CAAC;QAC5C,MAAM,IAAI,CAAC,2BAA2B,EAAE,CAAC;IAC3C,CAAC;IAEO,KAAK,CAAC,8BAA8B;QAC1C,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAEjE,IAAI,CAAC;YACH,IAAI,OAAO,GAAG,EAAE,CAAC;YACjB,IAAI,CAAC;gBACH,OAAO,GAAG,MAAM,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;YACnD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBACvD,OAAO;gBACT,CAAC;YACH,CAAC;YAED,MAAM,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;gBACvD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;gBAC5B,OAAO,CACL,OAAO,KAAK,MAAM;oBAClB,OAAO,KAAK,OAAO;oBACnB,OAAO,KAAK,OAAO;oBACnB,OAAO,KAAK,QAAQ,CACrB,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,IAAI,WAAW,EAAE,CAAC;gBAChB,OAAO;YACT,CAAC;YAED,MAAM,SAAS,GACb,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5D,MAAM,SAAS,CAAC,aAAa,EAAE,GAAG,OAAO,GAAG,SAAS,SAAS,CAAC,CAAC;QAClE,CAAC;QAAC,MAAM,CAAC;YACP,wFAAwF;QAC1F,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,2BAA2B;QACvC,IAAI,CAAC;YACH,MAAM,SAAS,CACb,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,CAAC,EAClD,KAAK,CACN,CAAC;QACJ,CAAC;QAAC,MAAM,CAAC;YACP,wFAAwF;QAC1F,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,IAAc,0BAA0B;QACtC,OAAO,OAAO,CAAC,GAAG,CAAC,wBAAwB,KAAK,GAAG,CAAC;IACtD,CAAC;IAED;;;OAGG;IACO,0BAA0B;QAClC,IAAI,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YAC/B,OAAO,OAAO,CACZ,IAAI,CAAC,MAAM,CAAC,UAAU,EACtB,IAAI,CAAC,MAAM,CAAC,cAAc,EAC1B,yBAAyB,CAC1B,CAAC;QACJ,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,KAAK,yBAAyB,EAAE,CAAC;YAC1D,OAAO,IAAI,CAAC,WAAW,CACrB,oDAAoD,CACrD,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,IAAc,kBAAkB;QAC9B,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa,CAAC;IAC9E,CAAC;IAED;;;;;;;OAOG;IACH,IAAc,oBAAoB;QAChC,OAAO,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;IACpD,CAAC;IAED;;;;;OAKG;IACO,gBAAgB,CAAC,WAA0B;QACnD,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;QACtE,MAAM,OAAO,GAAG,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAClE,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,OAAO,CAAC;QAC1C,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;;OAKG;IACO,qCAAqC;QAC7C,IAAI,IAAI,CAAC,MAAM,CAAC,8BAA8B,KAAK,SAAS,EAAE,CAAC;YAC7D,OAAO,IAAI,CAAC,MAAM,CAAC,8BAA8B,CAAC;QACpD,CAAC;QACD,MAAM,QAAQ,GAAG,2BAA2B,CAC1C,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAC3C,CAAC;QACF,IAAI,QAAQ,KAAK,SAAS;YAAE,OAAO,QAAQ,CAAC;QAC5C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,IAAc,iBAAiB;QAC7B,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,KAAK,CAAC;IACpE,CAAC;IAED;;;;;OAKG;IACO,KAAK,CAAC,cAAc,CAAC,EAC7B,kBAAkB,EAClB,WAAW,EACX,QAAQ,GAKT;QACC,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC9B,IAAI,CAAC,qBAAqB,CAAC,sBAAsB,CAAC,CAAC;QAEnD,IAAI,CAAC;YACH,MAAM,cAAc,GAAG,MAAM,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;YAEvE,MAAM,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACxD,MAAM,SAAS,GAAG,IAAI,CAAC,wBAAwB,CAC7C,QAAQ,CAAC,SAAS,EAClB,cAAc,CACf,CAAC;YACF,MAAM,OAAO,GAAG,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAE9D,MAAM,MAAM,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;YAC/D,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAErD,MAAM,KAAK,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAC9C,MAAM,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,CAAC,EAAE,YAAY,CAAC,CAAC;YAElE,MAAM,uBAAuB,GAAG,IAAI,CAAC,0BAA0B,EAAE,CAAC;YAClE,IAAI,uBAAuB,EAAE,CAAC;gBAC5B,MAAM,IAAI,CAAC,eAAe,CAAC,uBAAuB,CAAC,CAAC;gBACpD,MAAM,SAAS,CAAC,uBAAuB,EAAE,YAAY,CAAC,CAAC;YACzD,CAAC;YAED,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAC3C,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,EACvC,CAAC,CACF,CAAC;YACF,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CACnD,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,EACvC,CAAC,CACF,CAAC;YACF,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAC9C,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,EACvC,CAAC,CACF,CAAC;YAEF,IAAI,CAAC,qBAAqB,CACxB,yBAAyB,SAAS,IAAI,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,KAAK,aAAa,IAAI,SAAS,CAAC,UAAU,EAAE,WAAW,EAAE,aAAa,CAAC,SAAS,UAAU,IAAI,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,EACpN,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,UAAU,IAAI,CAC/B,CAAC;YAEF,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,0BAA0B,EAAE,CAAC;gBAC5C,OAAO,CAAC,GAAG,CACT,IAAI,CAAC,uBAAuB,CAAC;oBAC3B,SAAS;oBACT,aAAa;iBACd,CAAC,CACH,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAE/B,OAAO,YAAY,CAAC;QACtB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,IAAI,CACV,4BAA4B,EAC5B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CACvD,CAAC;YACF,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAC/B,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAEO,oBAAoB,CAC1B,KAAgC;QAEhC,MAAM,MAAM,GAAuD,EAAE,CAAC;QACtE,IAAI,CAAC,KAAK;YAAE,OAAO,MAAM,CAAC;QAE1B,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACxD,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YACtB,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACnD,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;YACnD,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,wBAAwB,CAC9B,SAAwC,EACxC,MAGC;QAQD,MAAM,MAAM,GAMR,EAAE,CAAC;QACP,IAAI,CAAC,SAAS;YAAE,OAAO,MAAM,CAAC;QAE9B,sEAAsE;QACtE,mEAAmE;QACnE,qEAAqE;QACrE,2DAA2D;QAC3D,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAG7B,CAAC;QACJ,KAAK,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/D,MAAM,UAAU,GAAG,SAAS;iBACzB,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;iBACpB,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;YAC5B,gBAAgB,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QACjD,CAAC;QAED,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC5D,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YACtB,8CAA8C;YAC9C,MAAM,kBAAkB,GAAG,QAAQ;iBAChC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;iBACpB,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;YAE5B,MAAM,YAAY,GAChB,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;YAE/D,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACnD,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG;oBACvB,UAAU,EAAE,IAAI,CAAC,UAAU;oBAC3B,KAAK,EAAE,YAAY,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;iBAC/D,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,sBAAsB,CAC5B,OAAoC;QAEpC,MAAM,MAAM,GAAwD,EAAE,CAAC;QACvE,IAAI,CAAC,OAAO;YAAE,OAAO,MAAM,CAAC;QAE5B,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1D,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YACtB,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACnD,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC;YACrD,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC","sourcesContent":["import { randomUUID } from 'node:crypto';\nimport {\n  mkdir,\n  readFile,\n  realpath,\n  rename,\n  rm,\n  stat,\n  writeFile,\n} from 'node:fs/promises';\nimport { createRequire } from 'node:module';\nimport { basename, dirname, join, relative, resolve } from 'node:path';\nimport { promisify } from 'node:util';\nimport { buildLogger } from '@workflow/core/logger';\nimport { WorkflowBuildError } from '@workflow/errors';\nimport { pluralize } from '@workflow/utils';\nimport chalk from 'chalk';\nimport enhancedResolveOriginal from 'enhanced-resolve';\nimport * as esbuild from 'esbuild';\nimport { findUp } from 'find-up';\nimport { glob } from 'tinyglobby';\nimport {\n  applySwcTransform,\n  type WorkflowManifest,\n} from './apply-swc-transform.js';\nimport {\n  createWorkflowEntrypointOptionsCode,\n  createWorkflowRouteHandlersCode,\n} from './constants.js';\nimport { getEsbuildTsconfigOptions } from './esbuild-tsconfig.js';\nimport {\n  type DiscoveredEntries,\n  fastDiscoverEntries,\n} from './fast-discovery.js';\nimport {\n  getImportPath,\n  resolveModuleSpecifier,\n  stripPackageVersion,\n} from './module-specifier.js';\nimport { createNodeModuleErrorPlugin } from './node-module-esbuild-plugin.js';\nimport { createPseudoPackagePlugin } from './pseudo-package-esbuild-plugin.js';\nimport { createSwcPlugin } from './swc-esbuild-plugin.js';\nimport { detectWorkflowPatterns } from './transform-utils.js';\nimport type { SourcemapMode, WorkflowConfig } from './types.js';\nimport { extractWorkflowGraphs } from './workflows-extractor.js';\n\nconst enhancedResolve = promisify(enhancedResolveOriginal);\nconst require = createRequire(import.meta.url);\n\nexport type { DiscoveredEntries } from './fast-discovery.js';\n\n/**\n * Legacy opt-in for source maps on the final workflow wrapper + webhook\n * bundles (which default to off, unlike the step/interim workflow bundles\n * that default to inline). Superseded by the `sourcemap` config option and\n * the `WORKFLOW_SOURCEMAP` environment variable; kept for back-compat.\n */\nconst EMIT_SOURCEMAPS_FOR_DEBUGGING =\n  process.env.WORKFLOW_EMIT_SOURCEMAPS_FOR_DEBUGGING === '1';\n\nconst VALID_SOURCEMAP_STRINGS = new Set([\n  'inline',\n  'linked',\n  'external',\n  'both',\n]);\n\n/**\n * Parse the value of the `WORKFLOW_SOURCEMAP` environment variable into a\n * `SourcemapMode`. Returns `undefined` if the env var is unset, empty, or\n * unrecognized (a warning is emitted for unrecognized values).\n */\nfunction parseSourcemapEnv(\n  value: string | undefined\n): SourcemapMode | undefined {\n  if (value === undefined || value === '') return undefined;\n  switch (value) {\n    case '0':\n    case 'false':\n      return false;\n    case '1':\n    case 'true':\n      return true;\n    default:\n      if (VALID_SOURCEMAP_STRINGS.has(value)) {\n        return value as SourcemapMode;\n      }\n      console.warn(\n        `Ignoring unrecognized WORKFLOW_SOURCEMAP=${value}. ` +\n          `Expected one of: true, false, 0, 1, inline, linked, external, both.`\n      );\n      return undefined;\n  }\n}\n\n/**\n * Parse the value of the `WORKFLOW_DISCOVER_NODE_MODULES` environment variable\n * into a boolean. Returns `undefined` if the env var is unset or empty so\n * callers can fall back to config/default.\n */\nfunction parseDiscoverNodeModulesEnv(\n  value: string | undefined\n): boolean | undefined {\n  if (value === undefined || value === '') return undefined;\n  return value !== '0' && value !== 'false';\n}\n\nfunction formatBuildDuration(durationMs: number): string {\n  if (durationMs < 1000) {\n    return `${durationMs}ms`;\n  }\n\n  return `${(durationMs / 1000).toFixed(1)}s`;\n}\n\n/**\n * Normalize an array of file paths by appending the `realpath()` of each entry\n * (to handle symlinks, e.g. pnpm/workspace layouts) and deduplicating.\n */\nasync function withRealpaths(entries: string[]): Promise<string[]> {\n  return Array.from(\n    new Set(\n      (\n        await Promise.all(\n          entries.map(async (entry) => {\n            const resolved = await realpath(entry).catch(() => undefined);\n            return resolved ? [entry, resolved] : [entry];\n          })\n        )\n      ).flat()\n    )\n  );\n}\n\n/**\n * Canonical \"what module does this file represent?\" key used to dedupe\n * virtual-entry imports.\n *\n * If the file resolves to a real package specifier (`workflow/internal/builtins`,\n * `@internal/agent/server`, etc.), we return the bare specifier — version\n * stripped — because esbuild's package resolution will collapse all\n * importers of that specifier to the same physical module regardless of\n * which on-disk copy (src vs dist) any one importer wrote.\n *\n * Otherwise we fall back to the absolute file path. Distinct local-app\n * files have distinct paths, so this still dedupes a file against itself\n * (e.g. if it shows up in both `stepFiles` and `serdeOnlyFiles`) without\n * conflating unrelated files.\n */\nfunction moduleIdentityKey(file: string, moduleSpecifierRoot: string): string {\n  const { moduleSpecifier } = resolveModuleSpecifier(file, moduleSpecifierRoot);\n  if (moduleSpecifier) {\n    // Strip the \"@<version>\" suffix so source and dist copies of the same\n    // export collapse to the same key.\n    return stripPackageVersion(moduleSpecifier);\n  }\n  return file.replace(/\\\\/g, '/');\n}\n\ntype ManifestEntryLocation = {\n  filePath: string;\n  name: string;\n};\n\ntype CachedManifestTransform = {\n  size: number;\n  mtimeMs: number;\n  manifest: WorkflowManifest;\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): 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 };\n      if (\n        existing &&\n        (existing.filePath !== current.filePath ||\n          existing.name !== current.name)\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\nfunction mergeWorkflowManifest(\n  target: WorkflowManifest,\n  incoming: WorkflowManifest,\n  stepIds: Map<string, ManifestEntryLocation>,\n  workflowIds: Map<string, ManifestEntryLocation>\n): void {\n  assertUniqueManifestIds(\n    incoming.steps,\n    stepIds,\n    (data) => data.stepId,\n    'step'\n  );\n  assertUniqueManifestIds(\n    incoming.workflows,\n    workflowIds,\n    (data) => data.workflowId,\n    'workflow'\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\n/**\n * Base class for workflow builders. Provides common build logic for transforming\n * workflow source files into deployable bundles using esbuild and SWC.\n *\n * Subclasses must implement the build() method to define builder-specific logic.\n */\nexport abstract class BaseBuilder {\n  protected config: WorkflowConfig;\n\n  /**\n   * Tracks which external packages have already been warned about\n   * to avoid duplicate warnings across multiple discoverEntries() calls.\n   */\n  private warnedExternalPackages = new Set<string>();\n  private workflowBuildStartTime: number | undefined;\n  private manifestTransformCache = new Map<string, CachedManifestTransform>();\n\n  constructor(config: WorkflowConfig) {\n    this.config = config;\n  }\n\n  protected get transformProjectRoot(): string {\n    return this.config.projectRoot || this.config.workingDir;\n  }\n\n  protected get moduleSpecifierRoot(): string {\n    return this.config.moduleSpecifierRoot || this.transformProjectRoot;\n  }\n\n  protected logBaseBuilderInfo(...args: unknown[]): void {\n    buildLogger.debug(args.map(String).join(' '));\n  }\n\n  private startWorkflowBuildTimer(): void {\n    this.workflowBuildStartTime = Date.now();\n  }\n\n  private getWorkflowBuildDuration(): number {\n    return Date.now() - (this.workflowBuildStartTime ?? Date.now());\n  }\n\n  private resetWorkflowBuildTimer(): void {\n    this.workflowBuildStartTime = undefined;\n  }\n\n  private getWorkflowBuildSummary({\n    stepCount,\n    workflowCount,\n  }: {\n    stepCount: number;\n    workflowCount: number;\n  }): string {\n    const counts = `${stepCount} ${pluralize('step', 'steps', stepCount)}, ${workflowCount} ${pluralize('workflow', 'workflows', workflowCount)}`;\n    return `✓ Compiled workflows in ${formatBuildDuration(this.getWorkflowBuildDuration())} (${counts})`;\n  }\n\n  private logCreateWorkflowsBundleInfo(...args: unknown[]): void {\n    if (!this.config.suppressCreateWorkflowsBundleLogs) {\n      this.logBaseBuilderInfo(...args);\n    }\n  }\n\n  private logCreateWebhookBundleInfo(...args: unknown[]): void {\n    if (!this.config.suppressCreateWebhookBundleLogs) {\n      this.logBaseBuilderInfo(...args);\n    }\n  }\n\n  private logCreateManifestInfo(...args: unknown[]): void {\n    if (!this.config.suppressCreateManifestLogs) {\n      this.logBaseBuilderInfo(...args);\n    }\n  }\n\n  /**\n   * When outputting CJS, esbuild replaces `import.meta` with an empty object,\n   * making `import.meta.url` (and `import.meta.resolve`) undefined. This method\n   * returns banner code and `define` entries that polyfill them using CJS\n   * equivalents (`__filename`, `require.resolve`) so user code (e.g. Prisma)\n   * that relies on `import.meta.url` works correctly in bundled CJS output.\n   */\n  private getCjsImportMetaPolyfill(format: string): {\n    banner: string;\n    define: Record<string, string>;\n  } {\n    if (format !== 'cjs') return { banner: '', define: {} };\n    return {\n      banner:\n        'var __import_meta_url = typeof __filename !== \"undefined\" ? require(\"url\").pathToFileURL(__filename).href : undefined;\\n' +\n        'var __import_meta_resolve = typeof require !== \"undefined\" && typeof __filename !== \"undefined\" ' +\n        '? (s) => require(\"url\").pathToFileURL(require.resolve(s)).href : undefined;\\n',\n      define: {\n        'import.meta.url': '__import_meta_url',\n        'import.meta.resolve': '__import_meta_resolve',\n      },\n    };\n  }\n\n  /**\n   * When outputting fully-bundled ESM, CJS dependencies that call require()\n   * for Node.js builtins (e.g. debug → require('tty')) break because esbuild's\n   * CJS-to-ESM __require shim doesn't have access to a real require function.\n   * This banner provides one via createRequire so bundled CJS code works in ESM.\n   */\n  private getEsmRequireBanner(format: string): string {\n    if (format !== 'esm') return '';\n    return 'import { createRequire as __createRequire } from \"node:module\";\\nvar require = __createRequire(import.meta.url);\\n';\n  }\n\n  /**\n   * Performs the complete build process for workflows.\n   * Subclasses must implement this to define their specific build steps.\n   */\n  abstract build(): Promise<void>;\n\n  /**\n   * Finds tsconfig.json/jsconfig.json for the project.\n   * Used by esbuild to properly resolve module imports during bundling.\n   */\n  protected async findTsConfigPath(): Promise<string | undefined> {\n    const cwd = this.config.workingDir || process.cwd();\n    return findUp(['tsconfig.json', 'jsconfig.json'], { cwd });\n  }\n\n  /**\n   * Discovers all source files in the configured directories.\n   * Searches for TypeScript and JavaScript files while excluding common build\n   * and dependency directories.\n   */\n  protected async getInputFiles(): Promise<string[]> {\n    const ignore = [\n      '**/node_modules/**',\n      '**/.git/**',\n      '**/.next/**',\n      '**/.nitro/**',\n      '**/.nuxt/**',\n      '**/.output/**',\n      '**/.vercel/**',\n      '**/.workflow-data/**',\n      '**/.workflow-vitest/**',\n      '**/.well-known/workflow/**',\n      '**/.swc/**',\n      '**/.svelte-kit/**',\n      '**/.turbo/**',\n      '**/.cache/**',\n      '**/.yarn/**',\n      '**/.pnpm-store/**',\n    ];\n\n    // Use relative patterns with `cwd` per directory so that `dot: true`\n    // applies consistently to both the search pattern *and* the ignore\n    // patterns. When absolute patterns are used with tinyglobby, the `**`\n    // in ignore patterns does not match dot-prefixed path segments.\n    const results = await Promise.all(\n      this.config.dirs.map((dir) => {\n        const cwd = resolve(this.config.workingDir, dir);\n        return glob(['**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}'], {\n          cwd,\n          ignore,\n          absolute: true,\n          dot: true,\n        });\n      })\n    );\n\n    return results.flat();\n  }\n\n  /**\n   * Caches discovered workflow entries by input array reference.\n   * Uses WeakMap to allow garbage collection when input arrays are no longer referenced.\n   * This cache is invalidated automatically when the inputs array reference changes\n   * (e.g., when files are added/removed during watch mode).\n   */\n  private discoveredEntries: WeakMap<string[], DiscoveredEntries> =\n    new WeakMap();\n\n  public clearDiscoveredEntriesCache(): void {\n    this.discoveredEntries = new WeakMap();\n  }\n\n  public clearManifestTransformCache(): void {\n    this.manifestTransformCache.clear();\n  }\n\n  /**\n   * Pseudo-packages that should not be checked for workflow patterns.\n   */\n  private static readonly PSEUDO_PACKAGES = new Set([\n    'server-only',\n    'client-only',\n  ]);\n\n  /**\n   * Checks each package in externalPackages for workflow patterns and emits\n   * warnings if any contain \"use step\", \"use workflow\" directives, or\n   * serialization classes. These patterns will not be transformed by the\n   * workflow compiler when the package is externalized.\n   */\n  private async warnAboutExternalWorkflowPackages(): Promise<void> {\n    const externalPackages = this.config.externalPackages;\n    if (!externalPackages?.length) return;\n\n    for (const pkg of externalPackages) {\n      if (BaseBuilder.PSEUDO_PACKAGES.has(pkg)) continue;\n      if (this.warnedExternalPackages.has(pkg)) continue;\n\n      if (\n        pkg.startsWith('.') ||\n        pkg.startsWith('/') ||\n        pkg.startsWith('$') ||\n        pkg.includes('*') ||\n        pkg.includes(':')\n      ) {\n        continue;\n      }\n\n      try {\n        // Check package.json dependencies for @workflow/serde (fast path)\n        let hasWorkflowSerdeDep = false;\n        try {\n          const pkgJsonPath = require.resolve(`${pkg}/package.json`, {\n            paths: [this.config.workingDir],\n          });\n          const pkgJsonSource = await readFile(pkgJsonPath, 'utf-8');\n          const pkgJson = JSON.parse(pkgJsonSource) as {\n            dependencies?: unknown;\n            peerDependencies?: unknown;\n          };\n          const dependencies =\n            typeof pkgJson.dependencies === 'object' &&\n            pkgJson.dependencies !== null &&\n            !Array.isArray(pkgJson.dependencies)\n              ? (pkgJson.dependencies as Record<string, unknown>)\n              : {};\n          const peerDependencies =\n            typeof pkgJson.peerDependencies === 'object' &&\n            pkgJson.peerDependencies !== null &&\n            !Array.isArray(pkgJson.peerDependencies)\n              ? (pkgJson.peerDependencies as Record<string, unknown>)\n              : {};\n          hasWorkflowSerdeDep =\n            Object.hasOwn(dependencies, '@workflow/serde') ||\n            Object.hasOwn(peerDependencies, '@workflow/serde');\n        } catch {\n          // package.json not resolvable - continue to source check\n        }\n\n        // Check source patterns (thorough path).\n        // Note: require.resolve only inspects the package's main entry point.\n        // If workflow constructs live in sub-paths (e.g. `my-pkg/workflows`),\n        // they won't be detected here. The @workflow/serde dep check above\n        // partially covers serde cases. This is acceptable as a best-effort\n        // heuristic — the primary fix is auto-removal in withWorkflow().\n        let hasUseStep = false;\n        let hasUseWorkflow = false;\n        let hasSerde = hasWorkflowSerdeDep;\n        try {\n          const entryPath = require.resolve(pkg, {\n            paths: [this.config.workingDir],\n          });\n          const source = await readFile(entryPath, 'utf-8');\n          const patterns = detectWorkflowPatterns(source);\n          hasUseStep = patterns.hasUseStep;\n          hasUseWorkflow = patterns.hasUseWorkflow;\n          if (!hasSerde) {\n            hasSerde = patterns.hasSerde;\n          }\n        } catch {\n          // Entry file not resolvable or not readable - use what we have\n        }\n\n        if (!hasUseStep && !hasUseWorkflow && !hasSerde) continue;\n\n        // Build a specific description of what was found\n        const issues: string[] = [];\n        if (hasUseWorkflow) issues.push('\"use workflow\" functions');\n        if (hasUseStep) issues.push('\"use step\" functions');\n        if (hasSerde) issues.push('serialization classes');\n\n        this.warnedExternalPackages.add(pkg);\n\n        console.warn(\n          `\\n${chalk.yellow('⚠')} Warning: ${chalk.bold(`\"${pkg}\"`)} is listed in ${chalk.bold('externalPackages')} (${chalk.bold('serverExternalPackages')} in Next.js) but contains workflow code (${issues.join(', ')}).` +\n            `\\n  This code will ${chalk.bold('not')} be transformed by the workflow compiler, which can cause runtime failures.` +\n            `\\n  Remove ${chalk.bold(`\"${pkg}\"`)} from ${chalk.bold('externalPackages')} (${chalk.bold('serverExternalPackages')} in Next.js) to fix this.\\n`\n        );\n      } catch {\n        // Best-effort: if anything goes wrong, skip this package silently\n      }\n    }\n  }\n\n  protected async discoverEntries(\n    inputs: string[],\n    outdir: string,\n    tsconfigPath?: string\n  ): Promise<DiscoveredEntries> {\n    const previousResult = this.discoveredEntries.get(inputs);\n\n    if (previousResult) {\n      return previousResult;\n    }\n    const state: DiscoveredEntries = {\n      discoveredSteps: new Set(),\n      discoveredWorkflows: new Set(),\n      discoveredSerdeFiles: new Set(),\n      discoveredFiles: new Set(),\n    };\n\n    const discoverStart = Date.now();\n\n    // Resolve the SDK runtime serde entry point so that the discovery pass\n    // discovers classes like `Run` that live inside SDK packages. Without this,\n    // files like `run.js` are only discovered when user code imports them.\n    // This is resolved here (rather than in callers) so that the original\n    // `inputs` array reference is preserved for WeakMap caching — callers\n    // like createWorkflowsBundle and createStepsBundle can share the same\n    // cache entry when they pass the same inputFiles array.\n    const resolvedWorkflowRuntime = await enhancedResolve(\n      outdir,\n      '@workflow/core/runtime/run'\n    ).catch(() => undefined);\n    const entryPoints = resolvedWorkflowRuntime\n      ? [...inputs, resolvedWorkflowRuntime]\n      : inputs;\n\n    const effectiveTsconfigPath =\n      tsconfigPath ?? (await this.findTsConfigPath());\n\n    await fastDiscoverEntries({\n      entryPoints,\n      state,\n      defaultTsconfigPath: effectiveTsconfigPath,\n      workingDir: this.config.workingDir,\n      discoverWorkflowsInNodeModules:\n        this.resolveDiscoverWorkflowsInNodeModules(),\n    });\n\n    this.logBaseBuilderInfo(\n      `Discovering workflow directives`,\n      `${Date.now() - discoverStart}ms`\n    );\n\n    // Warn about external packages that contain workflow code\n    await this.warnAboutExternalWorkflowPackages();\n\n    this.discoveredEntries.set(inputs, state);\n    return state;\n  }\n\n  /**\n   * Writes generated files atomically where possible. On Windows, Next.js can\n   * briefly hold generated route files open while compiling them, which makes\n   * rename-over-existing fail with EPERM/EACCES. In that case, fall back to a\n   * direct overwrite so watch rebuilds can still make progress.\n   */\n  private async writeGeneratedFile(\n    targetPath: string,\n    content: string\n  ): Promise<void> {\n    const tempPath = `${targetPath}.${randomUUID()}.tmp`;\n    await writeFile(tempPath, content);\n    try {\n      await rename(tempPath, targetPath);\n    } catch (error) {\n      const errorCode =\n        error && typeof error === 'object' && 'code' in error\n          ? (error as NodeJS.ErrnoException).code\n          : undefined;\n      if (\n        process.platform === 'win32' &&\n        (errorCode === 'EPERM' || errorCode === 'EACCES')\n      ) {\n        await writeFile(targetPath, content);\n        await rm(tempPath, { force: true });\n        return;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Writes debug information to a JSON file for troubleshooting build issues.\n   * Uses atomic write (temp file + rename) to prevent race conditions when\n   * multiple builds run concurrently.\n   */\n  private async writeDebugFile(\n    outfile: string,\n    debugData: object,\n    merge?: boolean\n  ): Promise<void> {\n    const prefix = this.config.debugFilePrefix || '';\n    const targetPath = `${dirname(outfile)}/${prefix}${basename(outfile)}.debug.json`;\n    let existing = {};\n\n    try {\n      if (merge) {\n        try {\n          const content = await readFile(targetPath, 'utf8');\n          existing = JSON.parse(content);\n        } catch (e) {\n          // File doesn't exist yet or is corrupted - start fresh.\n          // Don't log error for ENOENT (file not found) as that's expected on first run.\n          if ((e as NodeJS.ErrnoException).code !== 'ENOENT') {\n            console.warn('Error reading debug file, starting fresh:', e);\n          }\n        }\n      }\n\n      const mergedData = JSON.stringify(\n        {\n          ...existing,\n          ...debugData,\n        },\n        null,\n        2\n      );\n\n      await this.writeGeneratedFile(targetPath, mergedData);\n    } catch (error: unknown) {\n      console.warn('Failed to write debug file:', error);\n    }\n  }\n\n  /**\n   * Logs and optionally throws on esbuild errors and warnings.\n   * @param throwOnError - If true, throws an error when esbuild errors are present\n   */\n  private logEsbuildMessages(\n    result: { errors?: any[]; warnings?: any[] },\n    phase: string,\n    throwOnError = true,\n    options?: {\n      suppressWarnings?: boolean;\n    }\n  ): void {\n    if (result.errors && result.errors.length > 0) {\n      console.error(`❌ esbuild errors in ${phase}:`);\n      const errorMessages: string[] = [];\n      for (const error of result.errors) {\n        console.error(`  ${error.text}`);\n        errorMessages.push(error.text);\n        if (error.location) {\n          const location = `    at ${error.location.file}:${error.location.line}:${error.location.column}`;\n          console.error(location);\n          errorMessages.push(location);\n        }\n      }\n\n      if (throwOnError) {\n        throw new WorkflowBuildError(\n          `Build failed during ${phase}:\\n${errorMessages.join('\\n')}`,\n          {\n            hint: `Review the esbuild errors above — they come from the ${phase} bundle. Fix the offending source files and re-run the build.`,\n          }\n        );\n      }\n    }\n\n    if (\n      !options?.suppressWarnings &&\n      result.warnings &&\n      result.warnings.length > 0\n    ) {\n      console.warn(`!  esbuild warnings in ${phase}:`);\n      for (const warning of result.warnings) {\n        console.warn(`  ${warning.text}`);\n        if (warning.location) {\n          console.warn(\n            `    at ${warning.location.file}:${warning.location.line}:${warning.location.column}`\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Converts an absolute file path to a normalized relative path for the manifest.\n   */\n  private getRelativeFilepath(absolutePath: string): string {\n    const normalizedFile = absolutePath.replace(/\\\\/g, '/');\n    const normalizedWorkingDir = this.config.workingDir.replace(/\\\\/g, '/');\n    let relativePath = relative(normalizedWorkingDir, normalizedFile).replace(\n      /\\\\/g,\n      '/'\n    );\n    // Handle files discovered outside the working directory\n    if (relativePath.startsWith('../')) {\n      relativePath = relativePath\n        .split('/')\n        .filter((part) => part !== '..')\n        .join('/');\n    }\n    return relativePath;\n  }\n\n  private async getCachedManifestTransform(\n    file: string,\n    mode: 'workflow' | 'step'\n  ): Promise<WorkflowManifest> {\n    const stats = await stat(file);\n    const cacheKey = `${mode}:${file}`;\n    const cached = this.manifestTransformCache.get(cacheKey);\n    if (\n      cached &&\n      cached.size === stats.size &&\n      cached.mtimeMs === stats.mtimeMs\n    ) {\n      return cached.manifest;\n    }\n\n    const source = await readFile(file, 'utf8');\n    const relativeFilepath = this.getRelativeFilepath(file);\n    const { workflowManifest } = await applySwcTransform(\n      relativeFilepath,\n      source,\n      mode,\n      file,\n      this.transformProjectRoot,\n      this.moduleSpecifierRoot\n    );\n    this.manifestTransformCache.set(cacheKey, {\n      size: stats.size,\n      mtimeMs: stats.mtimeMs,\n      manifest: workflowManifest,\n    });\n    return workflowManifest;\n  }\n\n  protected createRouteImportSpecifier(file: string, routeDir: string): string {\n    const { importPath, isPackage } = getImportPath(\n      file,\n      this.config.workingDir\n    );\n    if (isPackage) {\n      return importPath;\n    }\n\n    let relativePath = relative(routeDir, file).replace(/\\\\/g, '/');\n    if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {\n      relativePath = `./${relativePath}`;\n    }\n    return relativePath;\n  }\n\n  protected async createStepSourceRegistrationFile({\n    inputFiles,\n    outfile,\n    tsconfigPath,\n    discoveredEntries,\n  }: {\n    inputFiles: string[];\n    outfile: string;\n    tsconfigPath?: string;\n    discoveredEntries?: DiscoveredEntries;\n  }): Promise<WorkflowManifest> {\n    const stepsBundleStart = Date.now();\n    const workflowManifest: WorkflowManifest = {};\n    const builtInSteps = 'workflow/internal/builtins';\n    const resolvedBuiltInSteps = (await enhancedResolve(\n      dirname(outfile),\n      builtInSteps\n    ).catch((err) => {\n      throw new WorkflowBuildError(\n        `Failed to resolve built-in steps sources.\\n\\nCaused by: ${String(err)}`,\n        {\n          hint: 'run `pnpm install workflow` to resolve this issue.',\n          cause: err,\n        }\n      );\n    })) as string;\n\n    const discovered =\n      discoveredEntries ??\n      (await this.discoverEntries(inputFiles, dirname(outfile), tsconfigPath));\n    const stepFiles = [...discovered.discoveredSteps].sort();\n    const workflowFiles = [...discovered.discoveredWorkflows].sort();\n    const serdeFiles = [...discovered.discoveredSerdeFiles].sort();\n    const stepFilesSet = new Set(stepFiles);\n    const serdeOnlyFiles = serdeFiles.filter((f) => !stepFilesSet.has(f));\n\n    await this.writeDebugFile(outfile, {\n      stepFiles,\n      workflowFiles,\n      serdeOnlyFiles,\n      sourceImports: true,\n    });\n\n    const emittedImportIdentities = new Set<string>([builtInSteps]);\n    const importStatements: string[] = [];\n    const routeDir = dirname(outfile);\n    const addRegistrationImport = (specifier: string): void => {\n      importStatements.push(`import ${JSON.stringify(specifier)};`);\n    };\n    const addRegistrationFileImport = (file: string): void => {\n      const identity = moduleIdentityKey(file, this.moduleSpecifierRoot);\n      if (emittedImportIdentities.has(identity)) {\n        return;\n      }\n      emittedImportIdentities.add(identity);\n      addRegistrationImport(this.createRouteImportSpecifier(file, routeDir));\n    };\n\n    addRegistrationImport(builtInSteps);\n    for (const file of stepFiles) {\n      addRegistrationFileImport(file);\n    }\n    for (const file of serdeOnlyFiles) {\n      addRegistrationFileImport(file);\n    }\n\n    const output = `// biome-ignore-all lint: generated file\n/* eslint-disable */\n${importStatements.join('\\n')}\n\nexport const __steps_registered = true;\n`;\n    await mkdir(dirname(outfile), { recursive: true });\n    await this.writeGeneratedFile(outfile, output);\n\n    const manifestFiles = Array.from(\n      new Set([...stepFiles, ...serdeOnlyFiles, resolvedBuiltInSteps])\n    ).sort();\n    const stepIds = new Map<string, ManifestEntryLocation>();\n    const workflowIds = new Map<string, ManifestEntryLocation>();\n    await Promise.all(\n      manifestFiles.map(async (file) => {\n        const fileManifest = await this.getCachedManifestTransform(\n          file,\n          'step'\n        );\n        mergeWorkflowManifest(\n          workflowManifest,\n          fileManifest,\n          stepIds,\n          workflowIds\n        );\n      })\n    );\n\n    await this.ensureSwcIgnored();\n    this.logBaseBuilderInfo(\n      'Created step registrations',\n      `${Date.now() - stepsBundleStart}ms`\n    );\n    return workflowManifest;\n  }\n\n  /**\n   * Creates a bundle for workflow step functions.\n   * Steps have full Node.js runtime access and handle side effects, API calls, etc.\n   *\n   * @param externalizeNonSteps - If true, only bundles step entry points and externalizes other code\n   * @param sourceStepRegistrationImports - If true, emits a source import registration file instead of bundling step registrations\n   * @param bundleTransitiveLocalStepDependencies - If true, also bundles project-local files imported by step entries for direct runtime loading\n   * @returns Build context (for watch mode) and the collected workflow manifest\n   */\n  protected async createStepsBundle({\n    inputFiles,\n    format = 'esm',\n    outfile,\n    externalizeNonSteps,\n    bundleTransitiveLocalStepDependencies,\n    sourceStepRegistrationImports,\n    rewriteTsExtensions,\n    tsconfigPath,\n    discoveredEntries,\n    skipEsmRequireBanner = false,\n  }: {\n    tsconfigPath?: string;\n    inputFiles: string[];\n    outfile: string;\n    format?: 'cjs' | 'esm';\n    externalizeNonSteps?: boolean;\n    bundleTransitiveLocalStepDependencies?: boolean;\n    sourceStepRegistrationImports?: boolean;\n    rewriteTsExtensions?: boolean;\n    discoveredEntries?: DiscoveredEntries;\n    /**\n     * When true, skip the `createRequire` banner on the steps bundle.\n     * Used by `createCombinedBundle` with `bundleFinalOutput: true` where\n     * the outer esbuild pass provides its own banner, preventing the\n     * `__createRequire` identifier from being declared twice after inlining.\n     */\n    skipEsmRequireBanner?: boolean;\n  }): Promise<{\n    context: esbuild.BuildContext | undefined;\n    manifest: WorkflowManifest;\n  }> {\n    const stepsBundleStart = Date.now();\n    const workflowManifest: WorkflowManifest = {};\n    const builtInSteps = 'workflow/internal/builtins';\n\n    const resolvedBuiltInSteps = await enhancedResolve(\n      dirname(outfile),\n      'workflow/internal/builtins'\n    ).catch((err) => {\n      throw new WorkflowBuildError(\n        `Failed to resolve built-in steps sources.\\n\\nCaused by: ${String(err)}`,\n        {\n          hint: 'run `pnpm install workflow` to resolve this issue.',\n          cause: err,\n        }\n      );\n    });\n\n    // Discovery of workflow/step/serde entries. The SDK runtime entry point\n    // (workflow/runtime) is resolved inside discoverEntries() itself so that\n    // callers can pass the original inputFiles reference and benefit from\n    // WeakMap caching across createWorkflowsBundle / createStepsBundle calls.\n    const discovered =\n      discoveredEntries ??\n      (await this.discoverEntries(inputFiles, dirname(outfile), tsconfigPath));\n    const stepFiles = [...discovered.discoveredSteps].sort();\n    const workflowFiles = [...discovered.discoveredWorkflows].sort();\n    const serdeFiles = [...discovered.discoveredSerdeFiles].sort();\n\n    // Include serde files that aren't already step files for cross-context class registration.\n    // Classes need to be registered in the step bundle so they can be deserialized\n    // when receiving data from workflows and serialized when returning data to workflows.\n    const stepFilesSet = new Set(stepFiles);\n    const serdeOnlyFiles = serdeFiles.filter((f) => !stepFilesSet.has(f));\n\n    if (\n      sourceStepRegistrationImports &&\n      externalizeNonSteps &&\n      !bundleTransitiveLocalStepDependencies\n    ) {\n      return {\n        context: undefined,\n        manifest: await this.createStepSourceRegistrationFile({\n          inputFiles,\n          outfile,\n          tsconfigPath,\n          discoveredEntries: discovered,\n        }),\n      };\n    }\n\n    // log the step files for debugging\n    await this.writeDebugFile(outfile, {\n      stepFiles,\n      workflowFiles,\n      serdeOnlyFiles,\n    });\n\n    // Helper to create import statement from file path\n    // For workspace/node_modules packages, uses the package name so esbuild\n    // will resolve through package.json exports with the appropriate conditions\n    const createImport = (file: string) => {\n      const normalizedWorkspaceRoot = this.config.workingDir\n        .replace(/\\\\/g, '/')\n        .replace(/\\/$/, '');\n      const normalizedWorkspaceFile = file.replace(/\\\\/g, '/');\n      // Only use relative source paths for workspace symlinks (files\n      // outside node_modules in a packages/*/src/ directory). For tarball-\n      // installed packages (files inside node_modules/), fall through to\n      // getImportPath which returns package specifiers — this allows the\n      // SWC plugin's externalizeNonSteps to work correctly.\n      const isWorkspaceSourceBackedPackageFile =\n        normalizedWorkspaceFile.includes('/packages/') &&\n        normalizedWorkspaceFile.includes('/src/') &&\n        !normalizedWorkspaceFile.includes('/node_modules/') &&\n        !(\n          normalizedWorkspaceFile === normalizedWorkspaceRoot ||\n          normalizedWorkspaceFile.startsWith(`${normalizedWorkspaceRoot}/`)\n        );\n      const isSourceBackedPackageFile = isWorkspaceSourceBackedPackageFile;\n\n      if (isSourceBackedPackageFile) {\n        let relativePath = relative(\n          normalizedWorkspaceRoot,\n          normalizedWorkspaceFile\n        ).replace(/\\\\/g, '/');\n        if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {\n          relativePath = `./${relativePath}`;\n        }\n        return `import '${relativePath}';`;\n      }\n\n      const { importPath, isPackage } = getImportPath(\n        file,\n        this.config.workingDir\n      );\n\n      if (isPackage) {\n        // Use package name - esbuild will resolve via package.json exports\n        return `import '${importPath}';`;\n      }\n\n      // Local app file - use relative path\n      // Normalize both paths to forward slashes before calling relative()\n      // This is critical on Windows where relative() can produce unexpected results with mixed path formats\n      const normalizedWorkingDir = this.config.workingDir.replace(/\\\\/g, '/');\n      const normalizedFile = file.replace(/\\\\/g, '/');\n      // Calculate relative path from working directory to the file\n      let relativePath = relative(normalizedWorkingDir, normalizedFile).replace(\n        /\\\\/g,\n        '/'\n      );\n      // Ensure relative paths start with ./ so esbuild resolves them correctly.\n      // Paths like \".output/...\" are not valid relative specifiers and must\n      // become \"./.output/...\".\n      if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {\n        relativePath = `./${relativePath}`;\n      }\n      return `import '${relativePath}';`;\n    };\n\n    // Create a virtual entry that imports all files. All step definitions\n    // will get registered thanks to the swc transform.\n    //\n    // Dedupe imports by canonical module identity so we never emit two\n    // import lines that resolve to the same physical module. Pre-seed the\n    // set with the built-in steps import so a workspace step file at\n    // `packages/workflow/src/internal/builtins.ts` doesn't emit a second,\n    // relative-path competing import — esbuild would otherwise transform\n    // both copies and the swc plugin would generate duplicate step IDs.\n    const emittedImportIdentities = new Set<string>([builtInSteps]);\n    const buildImports = (files: string[]): string =>\n      files\n        .filter((file) => {\n          const identity = moduleIdentityKey(file, this.moduleSpecifierRoot);\n          if (emittedImportIdentities.has(identity)) return false;\n          emittedImportIdentities.add(identity);\n          return true;\n        })\n        .map(createImport)\n        .join('\\n');\n\n    const stepImports = buildImports(stepFiles);\n\n    // Include serde-only files for class registration side effects\n    const serdeImports = buildImports(serdeOnlyFiles);\n\n    const entryContent = `\n    // Built in steps\n    import '${builtInSteps}';\n    // User steps\n    ${stepImports}\n    // Serde files for cross-context class registration\n    ${serdeImports}\n    // Sentinel export so bundlers (rollup) don't tree-shake this module\n    // when it's imported as a side-effect-only dependency.\n    export const __steps_registered = true;`;\n\n    // Bundle with esbuild and our custom SWC plugin\n    const entriesToBundle = externalizeNonSteps\n      ? [\n          ...stepFiles,\n          ...serdeFiles,\n          ...(resolvedBuiltInSteps ? [resolvedBuiltInSteps] : []),\n        ]\n      : undefined;\n    const normalizedEntriesToBundle = entriesToBundle\n      ? await withRealpaths(entriesToBundle)\n      : undefined;\n    const normalizedSideEffectEntries = await withRealpaths([\n      ...stepFiles,\n      ...serdeOnlyFiles,\n      ...(resolvedBuiltInSteps ? [resolvedBuiltInSteps] : []),\n    ]);\n    const esbuildTsconfigOptions =\n      await getEsbuildTsconfigOptions(tsconfigPath);\n    const { banner: importMetaBanner, define: importMetaDefine } =\n      this.getCjsImportMetaPolyfill(format);\n    const esmRequireBanner = skipEsmRequireBanner\n      ? ''\n      : this.getEsmRequireBanner(format);\n\n    const esbuildCtx = await esbuild.context({\n      banner: {\n        js: `// biome-ignore-all lint: generated file\\n/* eslint-disable */\\n${importMetaBanner}${esmRequireBanner}`,\n      },\n      stdin: {\n        contents: entryContent,\n        resolveDir: this.config.workingDir,\n        sourcefile: 'virtual-entry.js',\n        loader: 'js',\n      },\n      outfile,\n      absWorkingDir: this.config.workingDir,\n      bundle: true,\n      format,\n      platform: 'node',\n      conditions: ['node'],\n      target: 'es2022',\n      write: true,\n      treeShaking: true,\n      keepNames: true,\n      minify: false,\n      jsx: 'preserve',\n      logLevel: 'error',\n      // Use tsconfig for path alias resolution.\n      // For symlinked configs this uses tsconfigRaw to preserve cwd-relative aliases.\n      ...esbuildTsconfigOptions,\n      define: importMetaDefine,\n      resolveExtensions: [\n        '.ts',\n        '.tsx',\n        '.mts',\n        '.cts',\n        '.js',\n        '.jsx',\n        '.mjs',\n        '.cjs',\n      ],\n      // Source maps for better stack traces in step execution. Steps execute\n      // in Node.js context and inline sourcemaps give meaningful stack traces\n      // with proper file names and line numbers when errors occur in deeply\n      // nested function calls across multiple files. Defaults to inline in\n      // development and off in production (see `defaultSourcemapMode`) to keep\n      // production function bundles small; override with the `sourcemap`\n      // config option or the `WORKFLOW_SOURCEMAP` env var.\n      sourcemap: this.resolveSourcemap(this.defaultSourcemapMode),\n      plugins: [\n        // Handle pseudo-packages like 'server-only' and 'client-only' by providing\n        // empty modules. Must run first to intercept these before other resolution.\n        createPseudoPackagePlugin(),\n        createSwcPlugin({\n          mode: 'step',\n          entriesToBundle: normalizedEntriesToBundle,\n          outdir: outfile ? dirname(outfile) : undefined,\n          projectRoot: this.transformProjectRoot,\n          moduleSpecifierRoot: this.moduleSpecifierRoot,\n          workflowManifest,\n          onAfterTransform: this.config.onAfterTransform,\n          bundleTransitiveLocalStepDependencies,\n          rewriteTsExtensions,\n          sideEffectEntries: normalizedSideEffectEntries,\n        }),\n      ],\n      // Plugin should catch most things, but this lets users hard override\n      // if the plugin misses anything that should be externalized\n      external: ['bun', 'bun:*', ...(this.config.externalPackages || [])],\n    });\n\n    const stepsResult = await esbuildCtx.rebuild();\n\n    this.logEsbuildMessages(stepsResult, 'steps bundle creation');\n    this.logBaseBuilderInfo(\n      'Created steps bundle',\n      `${Date.now() - stepsBundleStart}ms`\n    );\n\n    // Handle workflow-only files that may have been tree-shaken from the bundle.\n    // These files have no steps, so esbuild removes them, but we still need their\n    // workflow metadata for the manifest. Transform them separately.\n    const workflowOnlyFiles = workflowFiles.filter(\n      (f) => !stepFiles.includes(f)\n    );\n    await Promise.all(\n      workflowOnlyFiles.map(async (workflowFile) => {\n        try {\n          const fileManifest = await this.getCachedManifestTransform(\n            workflowFile,\n            'workflow'\n          );\n          if (fileManifest.workflows) {\n            workflowManifest.workflows = Object.assign(\n              workflowManifest.workflows || {},\n              fileManifest.workflows\n            );\n          }\n          if (fileManifest.classes) {\n            workflowManifest.classes = Object.assign(\n              workflowManifest.classes || {},\n              fileManifest.classes\n            );\n          }\n        } catch (error) {\n          // Log warning but continue - don't fail build for workflow-only file issues\n          console.warn(\n            `Warning: Failed to extract workflow metadata from ${workflowFile}:`,\n            error instanceof Error ? error.message : String(error)\n          );\n        }\n      })\n    );\n\n    await this.ensureSwcIgnored();\n\n    if (this.config.watch) {\n      return { context: esbuildCtx, manifest: workflowManifest };\n    }\n    await esbuildCtx.dispose();\n    return { context: undefined, manifest: workflowManifest };\n  }\n\n  /**\n   * Creates a bundle for workflow orchestration functions.\n   * Workflows run in a sandboxed VM and coordinate step execution.\n   *\n   * @param bundleFinalOutput - If false, skips the final bundling step (used by Next.js)\n   */\n  protected async createWorkflowsBundle({\n    inputFiles,\n    format = 'esm',\n    outfile,\n    bundleFinalOutput = true,\n    keepInterimBundleContext = this.config.watch,\n    tsconfigPath,\n    discoveredEntries,\n  }: {\n    tsconfigPath?: string;\n    inputFiles: string[];\n    outfile: string;\n    format?: 'cjs' | 'esm';\n    bundleFinalOutput?: boolean;\n    keepInterimBundleContext?: boolean;\n    discoveredEntries?: DiscoveredEntries;\n  }): Promise<{\n    manifest: WorkflowManifest;\n    interimBundleCtx?: esbuild.BuildContext;\n    bundleFinal?: (interimBundleResult: string) => Promise<void>;\n    /** The raw workflow VM code (before wrapping with entrypoint) */\n    interimBundleText?: string;\n  }> {\n    const discovered =\n      discoveredEntries ??\n      (await this.discoverEntries(inputFiles, dirname(outfile), tsconfigPath));\n    const workflowFiles = [...discovered.discoveredWorkflows].sort();\n    const serdeFiles = [...discovered.discoveredSerdeFiles].sort();\n\n    // Include serde files that aren't already workflow files for cross-context class registration.\n    // Classes need to be registered in the workflow bundle so they can be deserialized\n    // when receiving data from steps or when serializing data to send to steps.\n    const workflowFilesSet = new Set(workflowFiles);\n    const serdeOnlyFiles = serdeFiles.filter((f) => !workflowFilesSet.has(f));\n\n    // log the workflow files for debugging\n    await this.writeDebugFile(outfile, { workflowFiles, serdeOnlyFiles });\n\n    // Helper to create import statement from file path\n    // For packages, uses the package name so esbuild will resolve through\n    // package.json exports with conditions: ['workflow']\n    const createImport = (file: string) => {\n      const { importPath, isPackage } = getImportPath(\n        file,\n        this.config.workingDir\n      );\n\n      if (isPackage) {\n        // Use package name - esbuild will resolve via package.json exports\n        // and apply the 'workflow' condition\n        return `import '${importPath}';`;\n      }\n\n      // Local app file - use relative path\n      // Normalize both paths to forward slashes before calling relative()\n      // This is critical on Windows where relative() can produce unexpected results with mixed path formats\n      const normalizedWorkingDir = this.config.workingDir.replace(/\\\\/g, '/');\n      const normalizedFile = file.replace(/\\\\/g, '/');\n      // Calculate relative path from working directory to the file\n      let relativePath = relative(normalizedWorkingDir, normalizedFile).replace(\n        /\\\\/g,\n        '/'\n      );\n      // Ensure relative paths start with ./ so esbuild resolves them correctly.\n      // Paths like \".output/...\" are not valid relative specifiers and must\n      // become \"./.output/...\".\n      if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {\n        relativePath = `./${relativePath}`;\n      }\n      return `import '${relativePath}';`;\n    };\n\n    // Create a virtual entry that imports all workflow files. Dedupe by\n    // canonical module identity so source/dist copies of the same workspace\n    // package export don't both get imported (which would make the swc\n    // plugin generate duplicate workflow IDs).\n    const emittedImportIdentities = new Set<string>();\n    const buildImports = (files: string[]): string =>\n      files\n        .filter((file) => {\n          const identity = moduleIdentityKey(file, this.moduleSpecifierRoot);\n          if (emittedImportIdentities.has(identity)) return false;\n          emittedImportIdentities.add(identity);\n          return true;\n        })\n        .map(createImport)\n        .join('\\n');\n\n    // The SWC plugin in workflow mode emits `globalThis.__private_workflows.set(workflowId, fn)`\n    // calls directly, so we just need to import the files (Map is initialized via banner)\n    const workflowImports = buildImports(workflowFiles);\n\n    // Include serde-only files for class registration side effects\n    const serdeImports = buildImports(serdeOnlyFiles);\n\n    const imports = serdeImports\n      ? `${workflowImports}\\n// Serde files for cross-context class registration\\n${serdeImports}`\n      : workflowImports;\n\n    const bundleStartTime = Date.now();\n    const workflowManifest: WorkflowManifest = {};\n    const esbuildTsconfigOptions =\n      await getEsbuildTsconfigOptions(tsconfigPath);\n    const normalizedWorkflowSideEffectEntries = await withRealpaths([\n      ...workflowFiles,\n      ...serdeOnlyFiles,\n    ]);\n\n    // Bundle with esbuild and our custom SWC plugin in workflow mode.\n    // this bundle will be run inside a vm isolate\n    const interimBundleCtx = await esbuild.context({\n      stdin: {\n        contents: imports,\n        resolveDir: this.config.workingDir,\n        sourcefile: 'virtual-entry.js',\n        loader: 'js',\n      },\n      bundle: true,\n      absWorkingDir: this.config.workingDir,\n      format: 'cjs', // Runs inside the VM which expects cjs\n      platform: 'neutral', // The platform is neither node nor browser\n      mainFields: ['module', 'main'], // To support npm style imports\n      conditions: ['workflow'], // Allow packages to export 'workflow' compliant versions\n      target: 'es2022',\n      write: false,\n      treeShaking: true,\n      keepNames: true,\n      minify: false,\n      // Initialize the workflow registry at the very top of the bundle\n      // This must be in banner (not the virtual entry) because esbuild's bundling\n      // can reorder code, and the .set() calls need the Map to exist first\n      banner: {\n        js: 'globalThis.__private_workflows = new Map();',\n      },\n      // Source maps for better stack traces in workflow VM execution. This\n      // intermediate bundle is executed via runInContext() in a VM, so inline\n      // source maps give meaningful stack traces instead of\n      // \"evalmachine.<anonymous>\". Defaults to inline in development and off in\n      // production (see `defaultSourcemapMode`) to keep production function\n      // bundles small; override with the `sourcemap` config option or the\n      // `WORKFLOW_SOURCEMAP` env var. The runtime remaps stacks only when a\n      // map is present, so disabling maps degrades gracefully.\n      sourcemap: this.resolveSourcemap(this.defaultSourcemapMode),\n      // Use tsconfig for path alias resolution.\n      // For symlinked configs this uses tsconfigRaw to preserve cwd-relative aliases.\n      ...esbuildTsconfigOptions,\n      resolveExtensions: [\n        '.ts',\n        '.tsx',\n        '.mts',\n        '.cts',\n        '.js',\n        '.jsx',\n        '.mjs',\n        '.cjs',\n      ],\n      plugins: [\n        // Handle pseudo-packages like 'server-only' and 'client-only' by providing\n        // empty modules. Must run first to intercept these before other resolution.\n        createPseudoPackagePlugin(),\n        createSwcPlugin({\n          mode: 'workflow',\n          projectRoot: this.transformProjectRoot,\n          moduleSpecifierRoot: this.moduleSpecifierRoot,\n          workflowManifest,\n          onAfterTransform: this.config.onAfterTransform,\n          sideEffectEntries: normalizedWorkflowSideEffectEntries,\n        }),\n        // This plugin must run after the swc plugin to ensure dead code elimination\n        // happens first, preventing false positives on Node.js imports in unused code paths\n        createNodeModuleErrorPlugin(),\n      ],\n      // NOTE: We intentionally do NOT use the external option here for workflow bundles.\n      // When packages are marked external with format: 'cjs', esbuild generates require() calls.\n      // However, the workflow VM (vm.runInContext) does not have require() defined - it only\n      // provides module.exports and exports. External packages would fail at runtime with:\n      //   ReferenceError: require is not defined\n      // Instead, we bundle everything and rely on:\n      // - createPseudoPackagePlugin() to handle server-only/client-only with empty modules\n      // - createNodeModuleErrorPlugin() to catch Node.js builtin imports at build time\n    });\n    let shouldDisposeInterimBundleCtx = !keepInterimBundleContext;\n    try {\n      const interimBundle = await interimBundleCtx.rebuild();\n\n      this.logEsbuildMessages(\n        interimBundle,\n        'intermediate workflow bundle',\n        true,\n        {\n          suppressWarnings: this.config.suppressCreateWorkflowsBundleWarnings,\n        }\n      );\n      this.logCreateWorkflowsBundleInfo(\n        'Created intermediate workflow bundle',\n        `${Date.now() - bundleStartTime}ms`\n      );\n\n      if (this.config.workflowManifestPath) {\n        const resolvedPath = resolve(\n          process.cwd(),\n          this.config.workflowManifestPath\n        );\n        let prefix = '';\n\n        if (resolvedPath.endsWith('.cjs')) {\n          prefix = 'module.exports = ';\n        } else if (\n          resolvedPath.endsWith('.js') ||\n          resolvedPath.endsWith('.mjs')\n        ) {\n          prefix = 'export default ';\n        }\n\n        await mkdir(dirname(resolvedPath), { recursive: true });\n        await writeFile(\n          resolvedPath,\n          prefix + JSON.stringify(workflowManifest, null, 2)\n        );\n      }\n\n      await this.ensureSwcIgnored();\n\n      if (\n        !interimBundle.outputFiles ||\n        interimBundle.outputFiles.length === 0\n      ) {\n        throw new WorkflowBuildError('No output files generated from esbuild', {\n          hint: 'This usually indicates a misconfigured entry point or an empty workflow directory. Check that your workflow files contain a `\"use workflow\"` or `\"use step\"` directive.',\n        });\n      }\n\n      // Serde compliance warnings: check if workflow bundle has Node.js imports\n      // alongside serde-registered classes (these will fail at runtime in the sandbox)\n      if (\n        workflowManifest.classes &&\n        Object.keys(workflowManifest.classes).length > 0\n      ) {\n        const { analyzeSerdeCompliance } = await import('./serde-checker.js');\n        const bundleText = interimBundle.outputFiles[0].text;\n        const serdeResult = analyzeSerdeCompliance({\n          sourceCode: '',\n          workflowCode: bundleText,\n          manifest: workflowManifest,\n        });\n        // De-dupe warnings: group identical issues across classes\n        const issuesToClasses = new Map<string, Set<string>>();\n        for (const cls of serdeResult.classes) {\n          if (!cls.compliant) {\n            for (const issue of cls.issues) {\n              let affectedClasses = issuesToClasses.get(issue);\n              if (!affectedClasses) {\n                affectedClasses = new Set<string>();\n                issuesToClasses.set(issue, affectedClasses);\n              }\n              affectedClasses.add(cls.className);\n            }\n          }\n        }\n        for (const [issue, affectedClasses] of issuesToClasses) {\n          const classNames = [...affectedClasses];\n          const classLabel =\n            classNames.length === 1\n              ? `class \"${classNames[0]}\"`\n              : `classes ${classNames.map((name) => `\"${name}\"`).join(', ')}`;\n          console.warn(\n            chalk.yellow(`⚠ Serde warning for ${classLabel}: `) + issue\n          );\n        }\n      }\n\n      const workflowEntrypointOptionsCode = createWorkflowEntrypointOptionsCode(\n        {\n          basePath: this.config.basePath,\n          routeModuleBodyStartedAt: 'workflowRouteModuleBodyStartedAt',\n        }\n      );\n\n      const bundleFinal = async (interimBundle: string) => {\n        const workflowBundleCode = interimBundle;\n\n        const workflowFunctionCode = `// biome-ignore-all lint: generated file\n/* eslint-disable */\nimport { workflowEntrypoint } from 'workflow/runtime';\n\nconst workflowRouteModuleBodyStartedAt = Date.now();\nconst workflowCode = \\`${workflowBundleCode.replace(/[\\\\`$]/g, '\\\\$&')}\\`;\n\n${createWorkflowRouteHandlersCode(`workflowEntrypoint(workflowCode${workflowEntrypointOptionsCode})`)}`;\n\n        // we skip the final bundling step for Next.js so it can bundle itself\n        if (!bundleFinalOutput) {\n          if (!outfile) {\n            throw new Error(`Invariant: missing outfile for workflow bundle`);\n          }\n          // Ensure the output directory exists\n          const outputDir = dirname(outfile);\n          await mkdir(outputDir, { recursive: true });\n\n          await this.writeGeneratedFile(outfile, workflowFunctionCode);\n          return;\n        }\n\n        const bundleStartTime = Date.now();\n\n        // Now bundle this so we can resolve the @workflow/core dependency\n        // we could remove this if we do nft tracing or similar instead\n        const finalEsmRequireBanner = this.getEsmRequireBanner(format);\n        const finalWorkflowResult = await esbuild.build({\n          banner: {\n            js: `// biome-ignore-all lint: generated file\\n/* eslint-disable */\\n${finalEsmRequireBanner}`,\n          },\n          stdin: {\n            contents: workflowFunctionCode,\n            resolveDir: this.config.workingDir,\n            sourcefile: 'virtual-entry.js',\n            loader: 'js',\n          },\n          outfile,\n          // Source maps for the final workflow bundle wrapper (not important since this code\n          // doesn't run in the VM - only the intermediate bundle sourcemap is relevant)\n          sourcemap: this.resolveSourcemap(EMIT_SOURCEMAPS_FOR_DEBUGGING),\n          absWorkingDir: this.config.workingDir,\n          bundle: true,\n          format,\n          platform: 'node',\n          target: 'es2022',\n          write: true,\n          keepNames: true,\n          minify: false,\n          external: ['@aws-sdk/credential-provider-web-identity'],\n        });\n\n        this.logEsbuildMessages(\n          finalWorkflowResult,\n          'final workflow bundle',\n          true,\n          {\n            suppressWarnings: this.config.suppressCreateWorkflowsBundleWarnings,\n          }\n        );\n        this.logCreateWorkflowsBundleInfo(\n          'Created final workflow bundle',\n          `${Date.now() - bundleStartTime}ms`\n        );\n      };\n      const interimBundleText = interimBundle.outputFiles[0].text;\n      await bundleFinal(interimBundleText);\n\n      if (keepInterimBundleContext) {\n        shouldDisposeInterimBundleCtx = false;\n        return {\n          manifest: workflowManifest,\n          interimBundleCtx,\n          bundleFinal,\n          interimBundleText,\n        };\n      }\n      return { manifest: workflowManifest, interimBundleText };\n    } catch (error) {\n      shouldDisposeInterimBundleCtx = true;\n      throw error;\n    } finally {\n      if (shouldDisposeInterimBundleCtx) {\n        try {\n          await interimBundleCtx.dispose();\n        } catch (disposeError) {\n          console.warn(\n            'Warning: Failed to dispose workflow bundle context',\n            disposeError\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * V2: Creates a combined bundle that includes both step registrations and\n   * workflow orchestration in a single route. The combined entrypoint executes\n   * steps inline when possible, reducing function invocations and queue overhead.\n   *\n   * This method reuses createStepsBundle (for step registrations) and\n   * createWorkflowsBundle (for workflow VM code), then combines them into\n   * a single route file using workflowEntrypoint().\n   */\n  protected async createCombinedBundle({\n    inputFiles,\n    stepsOutfile,\n    flowOutfile,\n    format = 'esm',\n    bundleFinalOutput = true,\n    tsconfigPath,\n    externalizeNonSteps,\n    bundleTransitiveLocalStepDependencies,\n    sourceStepRegistrationImports,\n    discoveredEntries,\n  }: {\n    inputFiles: string[];\n    /** Output path for the step registrations bundle (side effects only) */\n    stepsOutfile: string;\n    /** Output path for the combined route file */\n    flowOutfile: string;\n    format?: 'cjs' | 'esm';\n    bundleFinalOutput?: boolean;\n    tsconfigPath?: string;\n    externalizeNonSteps?: boolean;\n    bundleTransitiveLocalStepDependencies?: boolean;\n    sourceStepRegistrationImports?: boolean;\n    discoveredEntries?: DiscoveredEntries;\n  }): Promise<{\n    manifest: WorkflowManifest;\n    stepsContext?: esbuild.BuildContext;\n    interimBundleCtx?: esbuild.BuildContext;\n    bundleFinal?: (interimBundleResult: string) => Promise<void>;\n    discoveredEntries: DiscoveredEntries;\n    stepsManifest: WorkflowManifest;\n    workflowsManifest: WorkflowManifest;\n  }> {\n    this.startWorkflowBuildTimer();\n    const effectiveDiscoveredEntries =\n      discoveredEntries ??\n      (await this.discoverEntries(\n        inputFiles,\n        dirname(flowOutfile),\n        tsconfigPath\n      ));\n\n    // 1. Build step registrations bundle (used as separate file for\n    // bundleFinalOutput: false, or read back for inline content when true)\n    const { context: stepsContext, manifest: stepsManifest } =\n      await this.createStepsBundle({\n        inputFiles,\n        outfile: stepsOutfile,\n        // When bundleFinalOutput is true, use ESM for the steps bundle\n        // regardless of the final output format. The final esbuild pass\n        // converts everything to the target format. Using CJS here causes\n        // a module.exports collision: the steps bundle's top-level\n        // module.exports overwrites the combined route's module.exports\n        // when esbuild inlines the steps without a __commonJS wrapper.\n        format: bundleFinalOutput ? 'esm' : format,\n        externalizeNonSteps,\n        bundleTransitiveLocalStepDependencies,\n        sourceStepRegistrationImports,\n        tsconfigPath,\n        discoveredEntries: effectiveDiscoveredEntries,\n        // Skip the createRequire banner here — when bundleFinalOutput is true\n        // the outer esbuild pass will inline this bundle and add its own\n        // banner. Emitting it twice declares __createRequire twice.\n        skipEsmRequireBanner: bundleFinalOutput,\n      });\n\n    // 2. Build workflow VM code\n    const tempWorkflowOutfile = `${flowOutfile}.__wf_tmp.js`;\n    const workflowsResult = await this.createWorkflowsBundle({\n      inputFiles,\n      outfile: tempWorkflowOutfile,\n      format,\n      bundleFinalOutput: false,\n      tsconfigPath,\n      discoveredEntries: effectiveDiscoveredEntries,\n    });\n\n    const workflowVMCode = workflowsResult.interimBundleText;\n    if (!workflowVMCode) {\n      throw new Error('createWorkflowsBundle did not return interimBundleText');\n    }\n\n    // Clean up the wrapper file\n    try {\n      const { unlink } = await import('node:fs/promises');\n      await unlink(tempWorkflowOutfile);\n    } catch {\n      // Ignore cleanup errors\n    }\n\n    // 3. Generate combined route file\n    const stepsRelativePath = `./${basename(stepsOutfile).replace(/\\\\/g, '/')}`;\n    const escapedVMCode = workflowVMCode.replace(/[\\\\`$]/g, '\\\\$&');\n    const workflowEntrypointOptionsCode = createWorkflowEntrypointOptionsCode({\n      basePath: this.config.basePath,\n      routeModuleBodyStartedAt: 'workflowRouteModuleBodyStartedAt',\n    });\n\n    const combinedFunctionCode = `// biome-ignore-all lint: generated file\n/* eslint-disable */\nimport { __steps_registered } from '${stepsRelativePath}';\nimport { workflowEntrypoint } from 'workflow/runtime';\n\nconst workflowRouteModuleBodyStartedAt = Date.now();\n\n// Prevent rollup from tree-shaking the steps side-effect import\nvoid __steps_registered;\n\nconst workflowCode = \\`${escapedVMCode}\\`;\n\n${createWorkflowRouteHandlersCode(`workflowEntrypoint(workflowCode${workflowEntrypointOptionsCode})`)}`;\n\n    if (!bundleFinalOutput) {\n      await this.writeGeneratedFile(flowOutfile, combinedFunctionCode);\n    } else {\n      // Bundle the combined code for standalone use\n      const bundleStartTime = Date.now();\n      const { banner: importMetaBanner, define: importMetaDefine } =\n        this.getCjsImportMetaPolyfill(format);\n      // ESM banner provides `require` via createRequire(import.meta.url) so\n      // CJS dependencies that call require() for Node.js builtins keep working\n      // in the ESM output produced by bundleFinalOutput: true.\n      const finalEsmRequireBanner = this.getEsmRequireBanner(format);\n      const finalResult = await esbuild.build({\n        banner: {\n          js: `// biome-ignore-all lint: generated file\\n/* eslint-disable */\\n${importMetaBanner}${finalEsmRequireBanner}`,\n        },\n        stdin: {\n          contents: combinedFunctionCode,\n          resolveDir: dirname(flowOutfile),\n          sourcefile: 'virtual-entry.js',\n          loader: 'js',\n        },\n        outfile: flowOutfile,\n        absWorkingDir: this.config.workingDir,\n        bundle: true,\n        format,\n        platform: 'node',\n        target: 'es2022',\n        write: true,\n        keepNames: true,\n        minify: false,\n        define: importMetaDefine,\n        external: ['@aws-sdk/credential-provider-web-identity'],\n      });\n      this.logEsbuildMessages(finalResult, 'combined bundle', true);\n      this.logBaseBuilderInfo(\n        'Created combined bundle',\n        `${Date.now() - bundleStartTime}ms`\n      );\n    }\n\n    // Merge manifests\n    const manifest: WorkflowManifest = {\n      ...stepsManifest,\n      workflows: {\n        ...stepsManifest.workflows,\n        ...workflowsResult.manifest.workflows,\n      },\n      classes: {\n        ...stepsManifest.classes,\n        ...workflowsResult.manifest.classes,\n      },\n    };\n\n    // Create a custom bundleFinal for watch mode that uses workflowEntrypoint\n    const combinedBundleFinal = async (interimBundleText: string) => {\n      const escaped = interimBundleText.replace(/[\\\\`$]/g, '\\\\$&');\n      const workflowEntrypointOptionsCode = createWorkflowEntrypointOptionsCode(\n        {\n          basePath: this.config.basePath,\n          routeModuleBodyStartedAt: 'workflowRouteModuleBodyStartedAt',\n        }\n      );\n      const code = `// biome-ignore-all lint: generated file\n/* eslint-disable */\nimport { __steps_registered } from '${stepsRelativePath}';\nimport { workflowEntrypoint } from 'workflow/runtime';\n\nconst workflowRouteModuleBodyStartedAt = Date.now();\n\nvoid __steps_registered;\n\nconst workflowCode = \\`${escaped}\\`;\n\n${createWorkflowRouteHandlersCode(`workflowEntrypoint(workflowCode${workflowEntrypointOptionsCode})`)}`;\n\n      const outputDir = dirname(flowOutfile);\n      await mkdir(outputDir, { recursive: true });\n      await this.writeGeneratedFile(flowOutfile, code);\n    };\n\n    if (this.config.watch) {\n      return {\n        manifest,\n        stepsContext,\n        interimBundleCtx: workflowsResult.interimBundleCtx,\n        bundleFinal: combinedBundleFinal,\n        discoveredEntries: effectiveDiscoveredEntries,\n        stepsManifest,\n        workflowsManifest: workflowsResult.manifest,\n      };\n    }\n\n    return {\n      manifest,\n      discoveredEntries: effectiveDiscoveredEntries,\n      stepsManifest,\n      workflowsManifest: workflowsResult.manifest,\n    };\n  }\n\n  /**\n   * Creates a client library bundle for workflow execution.\n   * The client library allows importing and calling workflows from application code.\n   * Only generated if clientBundlePath is specified in config.\n   */\n  protected async createClientLibrary(): Promise<void> {\n    if (!this.config.clientBundlePath) {\n      // Silently exit since no client bundle was requested\n      return;\n    }\n\n    this.logBaseBuilderInfo(\n      'Generating a client library at',\n      this.config.clientBundlePath\n    );\n    this.logBaseBuilderInfo(\n      'NOTE: The recommended way to use workflow with a framework like NextJS is using the loader/plugin with webpack/turbobpack/rollup'\n    );\n\n    // Ensure we have the directory for the client bundle\n    const outputDir = dirname(this.config.clientBundlePath);\n    await mkdir(outputDir, { recursive: true });\n\n    const inputFiles = await this.getInputFiles();\n\n    // Discover serde files from the input files' dependency tree for cross-context class registration.\n    // Classes need to be registered in the client bundle so they can be serialized\n    // when passing data to workflows via start() and deserialized when receiving workflow results.\n    const { discoveredSerdeFiles } = await this.discoverEntries(\n      inputFiles,\n      outputDir\n    );\n\n    // Identify serde files that aren't in the inputFiles (deduplicated)\n    const inputFilesNormalized = new Set(\n      inputFiles.map((f) => f.replace(/\\\\/g, '/'))\n    );\n    const serdeOnlyFiles = [...discoveredSerdeFiles].filter(\n      (f) => !inputFilesNormalized.has(f)\n    );\n\n    // Re-exports for input files (user's workflow/step definitions).\n    // These must use valid relative specifiers because some frameworks pass\n    // generated files like \".output/server/index.mjs\" as input files.\n    const reexports = inputFiles\n      .map((file) => {\n        const normalizedWorkingDir = this.config.workingDir.replace(/\\\\/g, '/');\n        let relativePath = relative(normalizedWorkingDir, file).replace(\n          /\\\\/g,\n          '/'\n        );\n        if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {\n          relativePath = `./${relativePath}`;\n        }\n        return `export * from '${relativePath}';`;\n      })\n      .join('\\n');\n\n    // Side-effect imports for serde files not in inputFiles (for class registration)\n    const serdeImports = serdeOnlyFiles\n      .map((file) => {\n        const normalizedWorkingDir = this.config.workingDir.replace(/\\\\/g, '/');\n        let relativePath = relative(normalizedWorkingDir, file).replace(\n          /\\\\/g,\n          '/'\n        );\n        if (!relativePath.startsWith('./') && !relativePath.startsWith('../')) {\n          relativePath = `./${relativePath}`;\n        }\n        return `import '${relativePath}';`;\n      })\n      .join('\\n');\n\n    // Combine: serde imports (for registration side effects) + re-exports\n    const entryContent = serdeImports\n      ? `// Serde files for cross-context class registration\\n${serdeImports}\\n${reexports}`\n      : reexports;\n\n    // Bundle with esbuild and our custom SWC plugin\n    const normalizedClientSideEffectEntries = await withRealpaths([\n      ...inputFiles,\n      ...serdeOnlyFiles,\n    ]);\n    const clientResult = await esbuild.build({\n      banner: {\n        js: '// biome-ignore-all lint: generated file\\n/* eslint-disable */\\n',\n      },\n      stdin: {\n        contents: entryContent,\n        resolveDir: this.config.workingDir,\n        sourcefile: 'virtual-entry.js',\n        loader: 'js',\n      },\n      outfile: this.config.clientBundlePath,\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      jsx: 'preserve',\n      target: 'es2022',\n      write: true,\n      treeShaking: true,\n      external: ['@workflow/core'],\n      resolveExtensions: [\n        '.ts',\n        '.tsx',\n        '.mts',\n        '.cts',\n        '.js',\n        '.jsx',\n        '.mjs',\n        '.cjs',\n      ],\n      plugins: [\n        createSwcPlugin({\n          mode: 'step',\n          projectRoot: this.transformProjectRoot,\n          moduleSpecifierRoot: this.moduleSpecifierRoot,\n          onAfterTransform: this.config.onAfterTransform,\n          sideEffectEntries: normalizedClientSideEffectEntries,\n        }),\n      ],\n    });\n\n    this.logEsbuildMessages(clientResult, 'client library bundle');\n\n    await this.ensureSwcIgnored();\n  }\n\n  /**\n   * Creates a webhook handler bundle for resuming workflows via HTTP callbacks.\n   *\n   * @param bundle - If true, bundles dependencies (needed for Build Output API)\n   */\n  protected async createWebhookBundle({\n    outfile,\n    bundle = false,\n  }: {\n    outfile: string;\n    bundle?: boolean;\n  }): Promise<void> {\n    this.logCreateWebhookBundleInfo('Creating webhook route');\n    await mkdir(dirname(outfile), { recursive: true });\n\n    // Create a static route that calls resumeWebhook\n    // This route works for both Next.js and Vercel Build Output API\n    // Bundled Build Output API webhook functions need world.ts statically\n    // present so getWorldLazy() can use the global getWorld registration\n    // instead of falling back to a missing sibling import(\"./world.js\").\n    const routeContent = `${bundle ? \"import 'workflow/runtime';\\n\" : ''}import { resumeWebhook } from 'workflow/api';\n\nasync function handler(request) {\n  const url = new URL(request.url);\n  // Extract token from pathname: /.well-known/workflow/v1/webhook/{token}\n  const pathParts = url.pathname.split('/');\n  const token = decodeURIComponent(pathParts[pathParts.length - 1]);\n\n  if (!token) {\n    return new Response('Missing token', { status: 400 });\n  }\n\n  try {\n    const response = await resumeWebhook(token, request);\n    return response;\n  } catch (error) {\n    // TODO: differentiate between invalid token and other errors\n    console.error('Error during resumeWebhook', error);\n    return new Response(null, { status: 404 });\n  }\n}\n\nexport const GET = handler;\nexport const POST = handler;\nexport const PUT = handler;\nexport const PATCH = handler;\nexport const DELETE = handler;\nexport const HEAD = handler;\nexport const OPTIONS = handler;`;\n\n    if (!bundle) {\n      // For Next.js, just write the unbundled file\n      await writeFile(outfile, routeContent);\n      return;\n    }\n\n    // For Build Output API, bundle with esbuild to resolve imports\n\n    const webhookEsmRequireBanner = this.getEsmRequireBanner('esm');\n    const webhookBundleStart = Date.now();\n    const result = await esbuild.build({\n      banner: {\n        js: `// biome-ignore-all lint: generated file\\n/* eslint-disable */\\n${webhookEsmRequireBanner}`,\n      },\n      stdin: {\n        contents: routeContent,\n        resolveDir: this.config.workingDir,\n        sourcefile: 'webhook-route.js',\n        loader: 'js',\n      },\n      outfile,\n      absWorkingDir: this.config.workingDir,\n      bundle: true,\n      jsx: 'preserve',\n      format: 'esm',\n      platform: 'node',\n      conditions: ['import', 'module', 'node', 'default'],\n      target: 'es2022',\n      write: true,\n      treeShaking: true,\n      keepNames: true,\n      minify: false,\n      resolveExtensions: [\n        '.ts',\n        '.tsx',\n        '.mts',\n        '.cts',\n        '.js',\n        '.jsx',\n        '.mjs',\n        '.cjs',\n      ],\n      sourcemap: this.resolveSourcemap(EMIT_SOURCEMAPS_FOR_DEBUGGING),\n      mainFields: ['module', 'main'],\n      // Don't externalize anything - bundle everything including workflow packages\n      external: [],\n    });\n\n    this.logEsbuildMessages(result, 'webhook bundle creation');\n    this.logCreateWebhookBundleInfo(\n      'Created webhook bundle',\n      `${Date.now() - webhookBundleStart}ms`\n    );\n  }\n\n  /**\n   * Creates a package.json file with the specified module type.\n   */\n  protected async createPackageJson(\n    dir: string,\n    type: 'commonjs' | 'module'\n  ): Promise<void> {\n    const packageJson = { type };\n    await writeFile(\n      join(dir, 'package.json'),\n      JSON.stringify(packageJson, null, 2)\n    );\n  }\n\n  /**\n   * Creates a .vc-config.json file for Vercel Build Output API functions.\n   */\n  protected async createVcConfig(\n    dir: string,\n    config: {\n      runtime?: string;\n      handler?: string;\n      launcherType?: string;\n      architecture?: string;\n      shouldAddHelpers?: boolean;\n      shouldAddSourcemapSupport?: boolean;\n      maxDuration?: number | 'max';\n      experimentalTriggers?: Array<{\n        type: 'queue/v2beta';\n        topic: string;\n        consumer: string;\n        maxDeliveries?: number;\n        maxConcurrency?: number;\n        retryAfterSeconds?: number;\n        initialDelaySeconds?: number;\n      }>;\n    }\n  ): Promise<void> {\n    const vcConfig = {\n      runtime: config.runtime ?? 'nodejs22.x',\n      handler: config.handler ?? 'index.mjs',\n      launcherType: config.launcherType ?? 'Nodejs',\n      architecture: config.architecture ?? 'arm64',\n      shouldAddHelpers: config.shouldAddHelpers ?? true,\n      ...(config.maxDuration !== undefined && {\n        maxDuration: config.maxDuration,\n      }),\n      ...(config.shouldAddSourcemapSupport !== undefined && {\n        shouldAddSourcemapSupport: config.shouldAddSourcemapSupport,\n      }),\n      ...(config.experimentalTriggers && {\n        experimentalTriggers: config.experimentalTriggers,\n      }),\n    };\n\n    await writeFile(\n      join(dir, '.vc-config.json'),\n      JSON.stringify(vcConfig, null, 2)\n    );\n  }\n\n  /**\n   * Resolves a path relative to the working directory.\n   */\n  protected resolvePath(path: string): string {\n    return resolve(this.config.workingDir, path);\n  }\n\n  /**\n   * Ensures the directory for a file path exists, creating it if necessary.\n   */\n  protected async ensureDirectory(filePath: string): Promise<void> {\n    await mkdir(dirname(filePath), { recursive: true });\n  }\n\n  protected async ensureSwcIgnored(): Promise<void> {\n    await this.ensureProjectSwcGitignoreEntry();\n    await this.createSwcDirectoryGitignore();\n  }\n\n  private async ensureProjectSwcGitignoreEntry(): Promise<void> {\n    const gitignorePath = join(this.config.workingDir, '.gitignore');\n\n    try {\n      let content = '';\n      try {\n        content = await readFile(gitignorePath, 'utf-8');\n      } catch (error) {\n        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {\n          return;\n        }\n      }\n\n      const hasSwcEntry = content.split(/\\r?\\n/).some((line) => {\n        const trimmed = line.trim();\n        return (\n          trimmed === '.swc' ||\n          trimmed === '.swc/' ||\n          trimmed === '/.swc' ||\n          trimmed === '/.swc/'\n        );\n      });\n\n      if (hasSwcEntry) {\n        return;\n      }\n\n      const separator =\n        content.length > 0 && !content.endsWith('\\n') ? '\\n' : '';\n      await writeFile(gitignorePath, `${content}${separator}/.swc\\n`);\n    } catch {\n      // We're intentionally silently ignoring this error - updating .gitignore isn't critical\n    }\n  }\n\n  private async createSwcDirectoryGitignore(): Promise<void> {\n    try {\n      await writeFile(\n        join(this.config.workingDir, '.swc', '.gitignore'),\n        '*\\n'\n      );\n    } catch {\n      // We're intentionally silently ignoring this error - creating .gitignore isn't critical\n    }\n  }\n\n  /**\n   * Whether the manifest should be exposed as a public HTTP route.\n   * Controlled by the `WORKFLOW_PUBLIC_MANIFEST` environment variable.\n   */\n  protected get shouldExposePublicManifest(): boolean {\n    return process.env.WORKFLOW_PUBLIC_MANIFEST === '1';\n  }\n\n  /**\n   * Resolves the workflow manifest diagnostics path, when this builder should\n   * emit one.\n   */\n  protected getDiagnosticsManifestPath(): string | undefined {\n    if (this.config.diagnosticsDir) {\n      return resolve(\n        this.config.workingDir,\n        this.config.diagnosticsDir,\n        'workflows-manifest.json'\n      );\n    }\n\n    if (this.config.buildTarget === 'vercel-build-output-api') {\n      return this.resolvePath(\n        '.vercel/output/diagnostics/workflows-manifest.json'\n      );\n    }\n  }\n\n  /**\n   * Whether this is a development/watch build (e.g. `next dev`, `nitro dev`,\n   * or a Vite-based dev server for astro/sveltekit/vite). `config.watch` is\n   * plumbed by the builders that own a dev server (next, nitro, nest); the\n   * Vite-based integrations don't set it but run with\n   * `NODE_ENV === 'development'`. When neither signal is present we treat the\n   * build as production, so CLI/Vercel production builds default to off.\n   */\n  protected get isDevelopmentBuild(): boolean {\n    return this.config.watch === true || process.env.NODE_ENV === 'development';\n  }\n\n  /**\n   * Default source map mode for the stack-relevant bundles (steps + the\n   * intermediate workflow VM bundle): inline source maps in development so\n   * stack traces point at source files, and off in production so function\n   * bundles stay small (helps stay under the Vercel 250MB function limit) and\n   * skip the source-map-support runtime shim. The `sourcemap` config option\n   * and `WORKFLOW_SOURCEMAP` env var override this in either environment.\n   */\n  protected get defaultSourcemapMode(): SourcemapMode {\n    return this.isDevelopmentBuild ? 'inline' : false;\n  }\n\n  /**\n   * Resolve the effective source map mode for a given call site. Precedence:\n   * explicit `sourcemap` config > `WORKFLOW_SOURCEMAP` env var > the call\n   * site's default. Returned value is passed directly to esbuild's\n   * `sourcemap` option.\n   */\n  protected resolveSourcemap(defaultMode: SourcemapMode): SourcemapMode {\n    if (this.config.sourcemap !== undefined) return this.config.sourcemap;\n    const envMode = parseSourcemapEnv(process.env.WORKFLOW_SOURCEMAP);\n    if (envMode !== undefined) return envMode;\n    return defaultMode;\n  }\n\n  /**\n   * Resolve whether workflow/step files under `node_modules` are discovered.\n   * Precedence: explicit `discoverWorkflowsInNodeModules` config > the\n   * `WORKFLOW_DISCOVER_NODE_MODULES` env var (`0`/`false` disables) > the\n   * default (`true`, discover them).\n   */\n  protected resolveDiscoverWorkflowsInNodeModules(): boolean {\n    if (this.config.discoverWorkflowsInNodeModules !== undefined) {\n      return this.config.discoverWorkflowsInNodeModules;\n    }\n    const envValue = parseDiscoverNodeModulesEnv(\n      process.env.WORKFLOW_DISCOVER_NODE_MODULES\n    );\n    if (envValue !== undefined) return envValue;\n    return true;\n  }\n\n  /**\n   * Whether the resolved source map mode emits any source maps at all.\n   * Used by consumers like the Vercel builder to decide whether to include\n   * the source-map-support runtime shim in generated functions. Uses the same\n   * environment-aware default (`defaultSourcemapMode`) as the step/workflow\n   * bundles, so a production build with no override omits the shim.\n   */\n  protected get sourcemapsEnabled(): boolean {\n    return this.resolveSourcemap(this.defaultSourcemapMode) !== false;\n  }\n\n  /**\n   * Creates a manifest JSON file containing step/workflow/class metadata\n   * and graph data for visualization.\n   *\n   * @returns The manifest JSON string, or undefined if manifest creation failed.\n   */\n  protected async createManifest({\n    workflowBundlePath,\n    manifestDir,\n    manifest,\n  }: {\n    workflowBundlePath: string;\n    manifestDir: string;\n    manifest: WorkflowManifest;\n  }): Promise<string | undefined> {\n    const buildStart = Date.now();\n    this.logCreateManifestInfo('Creating manifest...');\n\n    try {\n      const workflowGraphs = await extractWorkflowGraphs(workflowBundlePath);\n\n      const steps = this.convertStepsManifest(manifest.steps);\n      const workflows = this.convertWorkflowsManifest(\n        manifest.workflows,\n        workflowGraphs\n      );\n      const classes = this.convertClassesManifest(manifest.classes);\n\n      const output = { version: '1.0.0', steps, workflows, classes };\n      const manifestJson = JSON.stringify(output, null, 2);\n\n      await mkdir(manifestDir, { recursive: true });\n      await writeFile(join(manifestDir, 'manifest.json'), manifestJson);\n\n      const diagnosticsManifestPath = this.getDiagnosticsManifestPath();\n      if (diagnosticsManifestPath) {\n        await this.ensureDirectory(diagnosticsManifestPath);\n        await writeFile(diagnosticsManifestPath, manifestJson);\n      }\n\n      const stepCount = Object.values(steps).reduce(\n        (acc, s) => acc + Object.keys(s).length,\n        0\n      );\n      const workflowCount = Object.values(workflows).reduce(\n        (acc, w) => acc + Object.keys(w).length,\n        0\n      );\n      const classCount = Object.values(classes).reduce(\n        (acc, c) => acc + Object.keys(c).length,\n        0\n      );\n\n      this.logCreateManifestInfo(\n        `Created manifest with ${stepCount} ${pluralize('step', 'steps', stepCount)}, ${workflowCount} ${pluralize('workflow', 'workflows', workflowCount)}, and ${classCount} ${pluralize('class', 'classes', classCount)}`,\n        `${Date.now() - buildStart}ms`\n      );\n\n      if (!this.config.suppressCreateManifestLogs) {\n        console.log(\n          this.getWorkflowBuildSummary({\n            stepCount,\n            workflowCount,\n          })\n        );\n      }\n      this.resetWorkflowBuildTimer();\n\n      return manifestJson;\n    } catch (error) {\n      console.warn(\n        'Failed to create manifest:',\n        error instanceof Error ? error.message : String(error)\n      );\n      this.resetWorkflowBuildTimer();\n      return undefined;\n    }\n  }\n\n  private convertStepsManifest(\n    steps: WorkflowManifest['steps']\n  ): Record<string, Record<string, { stepId: string }>> {\n    const result: Record<string, Record<string, { stepId: string }>> = {};\n    if (!steps) return result;\n\n    for (const [filePath, entries] of Object.entries(steps)) {\n      result[filePath] = {};\n      for (const [name, data] of Object.entries(entries)) {\n        result[filePath][name] = { stepId: data.stepId };\n      }\n    }\n    return result;\n  }\n\n  private convertWorkflowsManifest(\n    workflows: WorkflowManifest['workflows'],\n    graphs: Record<\n      string,\n      Record<string, { graph: { nodes: any[]; edges: any[] } }>\n    >\n  ): Record<\n    string,\n    Record<\n      string,\n      { workflowId: string; graph: { nodes: any[]; edges: any[] } }\n    >\n  > {\n    const result: Record<\n      string,\n      Record<\n        string,\n        { workflowId: string; graph: { nodes: any[]; edges: any[] } }\n      >\n    > = {};\n    if (!workflows) return result;\n\n    // Build a normalized lookup for graphs since the graph extractor uses\n    // paths from workflowId (e.g. \"./workflows/hello-agent\") while the\n    // manifest uses source file paths (e.g. \"workflows/hello-agent.ts\").\n    // Normalize by stripping leading \"./\" and file extensions.\n    const normalizedGraphs = new Map<\n      string,\n      Record<string, { graph: { nodes: any[]; edges: any[] } }>\n    >();\n    for (const [graphPath, graphEntries] of Object.entries(graphs)) {\n      const normalized = graphPath\n        .replace(/^\\.\\//, '')\n        .replace(/\\.[^/.]+$/, '');\n      normalizedGraphs.set(normalized, graphEntries);\n    }\n\n    for (const [filePath, entries] of Object.entries(workflows)) {\n      result[filePath] = {};\n      // Normalize the manifest file path for lookup\n      const normalizedFilePath = filePath\n        .replace(/^\\.\\//, '')\n        .replace(/\\.[^/.]+$/, '');\n\n      const graphEntries =\n        graphs[filePath] || normalizedGraphs.get(normalizedFilePath);\n\n      for (const [name, data] of Object.entries(entries)) {\n        result[filePath][name] = {\n          workflowId: data.workflowId,\n          graph: graphEntries?.[name]?.graph || { nodes: [], edges: [] },\n        };\n      }\n    }\n    return result;\n  }\n\n  private convertClassesManifest(\n    classes: WorkflowManifest['classes']\n  ): Record<string, Record<string, { classId: string }>> {\n    const result: Record<string, Record<string, { classId: string }>> = {};\n    if (!classes) return result;\n\n    for (const [filePath, entries] of Object.entries(classes)) {\n      result[filePath] = {};\n      for (const [name, data] of Object.entries(entries)) {\n        result[filePath][name] = { classId: data.classId };\n      }\n    }\n    return result;\n  }\n}\n"]}