@workflow/builders 5.0.0-beta.43 → 5.0.0-beta.46

package/dist/vercel-build-output-api.js

@@ -32,7 +32,7 @@ export class VercelBuildOutputAPIBuilder extends BaseBuilder {
         await this.createVcConfig(workflowsFuncDir, {
             handler: 'index.mjs',
             // Skip the source-map-support runtime shim when sourcemaps are
-            // disabled — it's a meaningful chunk of the function bundle and
+            // disabled: it's a meaningful chunk of the function bundle and
             // serves no purpose without maps.
             shouldAddSourcemapSupport: this.sourcemapsEnabled,
             maxDuration: 'max',
@@ -93,4 +93,4 @@ export class VercelBuildOutputAPIBuilder extends BaseBuilder {
         this.logBaseBuilderInfo('Webhook function available at /.well-known/workflow/v1/webhook/[token]');
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vercel-build-output-api.js","sourceRoot":"","sources":["../src/vercel-build-output-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { copyFile, mkdir, rm, writeFile } from 'node:fs/promises';\nimport { join, resolve } from 'node:path';\nimport { BaseBuilder } from './base-builder.js';\nimport { getWorkflowQueueTrigger } from './constants.js';\n\nexport class VercelBuildOutputAPIBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    const outputDir = resolve(this.config.workingDir, '.vercel/output');\n    const functionsDir = join(outputDir, 'functions');\n    const workflowGeneratedDir = join(functionsDir, '.well-known/workflow/v1');\n\n    // Ensure output directories exist\n    await mkdir(workflowGeneratedDir, { recursive: true });\n    // Build caches may still contain the retired standalone step function.\n    await rm(join(workflowGeneratedDir, 'step.func'), {\n      recursive: true,\n      force: true,\n    });\n\n    const inputFiles = await this.getInputFiles();\n    const tsconfigPath = await this.findTsConfigPath();\n    // Create combined bundle in flow.func/\n    this.logBaseBuilderInfo(\n      'Creating Vercel Build Output API combined function'\n    );\n    const workflowsFuncDir = join(workflowGeneratedDir, 'flow.func');\n    await mkdir(workflowsFuncDir, { recursive: true });\n\n    const { manifest } = await this.createCombinedBundle({\n      inputFiles,\n      stepsOutfile: join(workflowsFuncDir, '__step_registrations.mjs'),\n      flowOutfile: join(workflowsFuncDir, 'index.mjs'),\n      tsconfigPath,\n      bundleFinalOutput: true,\n    });\n\n    // Create package.json and .vc-config.json for combined function\n    await this.createPackageJson(workflowsFuncDir, 'module');\n    await this.createVcConfig(workflowsFuncDir, {\n      handler: 'index.mjs',\n      // Skip the source-map-support runtime shim when sourcemaps are\n      // disabled — it's a meaningful chunk of the function bundle and\n      // serves no purpose without maps.\n      shouldAddSourcemapSupport: this.sourcemapsEnabled,\n      maxDuration: 'max',\n      experimentalTriggers: [getWorkflowQueueTrigger()],\n      runtime: this.config.runtime,\n    });\n\n    await this.buildWebhookFunction({ workflowGeneratedDir });\n    await this.createBuildOutputConfig(outputDir);\n\n    // Generate unified manifest\n    const workflowBundlePath = join(\n      workflowGeneratedDir,\n      'flow.func/index.mjs'\n    );\n    const manifestJson = await this.createManifest({\n      workflowBundlePath,\n      manifestDir: workflowGeneratedDir,\n      manifest,\n    });\n\n    // Expose manifest as a static file when WORKFLOW_PUBLIC_MANIFEST=1.\n    // Vercel Build Output API serves static files from .vercel/output/static/\n    if (this.shouldExposePublicManifest && manifestJson) {\n      const staticManifestDir = join(\n        outputDir,\n        'static/.well-known/workflow/v1'\n      );\n      await mkdir(staticManifestDir, { recursive: true });\n      if (process.env.VERCEL_DEPLOYMENT_ID === undefined) {\n        await writeFile(join(staticManifestDir, '.gitignore'), '*');\n      }\n      await copyFile(\n        join(workflowGeneratedDir, 'manifest.json'),\n        join(staticManifestDir, 'manifest.json')\n      );\n    }\n\n    await this.createClientLibrary();\n  }\n\n  private async buildWebhookFunction({\n    workflowGeneratedDir,\n    bundle = true,\n  }: {\n    workflowGeneratedDir: string;\n    bundle?: boolean;\n  }): Promise<void> {\n    this.logBaseBuilderInfo(\n      'Creating Vercel Build Output API webhook function'\n    );\n    const webhookFuncDir = join(workflowGeneratedDir, 'webhook/[token].func');\n\n    // Bundle the webhook route with dependencies resolved\n    await this.createWebhookBundle({\n      outfile: join(webhookFuncDir, 'index.mjs'),\n      bundle, // Build Output API needs bundling (except in tests)\n    });\n\n    // Create package.json and .vc-config.json for webhook function\n    await this.createPackageJson(webhookFuncDir, 'module');\n    await this.createVcConfig(webhookFuncDir, {\n      handler: 'index.mjs',\n      shouldAddHelpers: false,\n      runtime: this.config.runtime,\n    });\n  }\n\n  private async createBuildOutputConfig(outputDir: string): Promise<void> {\n    // Create config.json for Build Output API\n    const buildOutputConfig = {\n      version: 3,\n      routes: [\n        {\n          src: '^\\\\/\\\\.well-known\\\\/workflow\\\\/v1\\\\/webhook\\\\/([^\\\\/]+)$',\n          dest: '/.well-known/workflow/v1/webhook/[token]',\n        },\n      ],\n    };\n\n    await writeFile(\n      join(outputDir, 'config.json'),\n      JSON.stringify(buildOutputConfig, null, 2)\n    );\n\n    this.logBaseBuilderInfo(`Build Output API created at ${outputDir}`);\n    this.logBaseBuilderInfo(\n      'Combined function available at /.well-known/workflow/v1/flow'\n    );\n    this.logBaseBuilderInfo(\n      'Webhook function available at /.well-known/workflow/v1/webhook/[token]'\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vercel-build-output-api.js","sourceRoot":"","sources":["../src/vercel-build-output-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { copyFile, mkdir, rm, writeFile } from 'node:fs/promises';\nimport { join, resolve } from 'node:path';\nimport { BaseBuilder } from './base-builder.js';\nimport { getWorkflowQueueTrigger } from './constants.js';\n\nexport class VercelBuildOutputAPIBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    const outputDir = resolve(this.config.workingDir, '.vercel/output');\n    const functionsDir = join(outputDir, 'functions');\n    const workflowGeneratedDir = join(functionsDir, '.well-known/workflow/v1');\n\n    // Ensure output directories exist\n    await mkdir(workflowGeneratedDir, { recursive: true });\n    // Build caches may still contain the retired standalone step function.\n    await rm(join(workflowGeneratedDir, 'step.func'), {\n      recursive: true,\n      force: true,\n    });\n\n    const inputFiles = await this.getInputFiles();\n    const tsconfigPath = await this.findTsConfigPath();\n    // Create combined bundle in flow.func/\n    this.logBaseBuilderInfo(\n      'Creating Vercel Build Output API combined function'\n    );\n    const workflowsFuncDir = join(workflowGeneratedDir, 'flow.func');\n    await mkdir(workflowsFuncDir, { recursive: true });\n\n    const { manifest } = await this.createCombinedBundle({\n      inputFiles,\n      stepsOutfile: join(workflowsFuncDir, '__step_registrations.mjs'),\n      flowOutfile: join(workflowsFuncDir, 'index.mjs'),\n      tsconfigPath,\n      bundleFinalOutput: true,\n    });\n\n    // Create package.json and .vc-config.json for combined function\n    await this.createPackageJson(workflowsFuncDir, 'module');\n    await this.createVcConfig(workflowsFuncDir, {\n      handler: 'index.mjs',\n      // Skip the source-map-support runtime shim when sourcemaps are\n      // disabled: it's a meaningful chunk of the function bundle and\n      // serves no purpose without maps.\n      shouldAddSourcemapSupport: this.sourcemapsEnabled,\n      maxDuration: 'max',\n      experimentalTriggers: [getWorkflowQueueTrigger()],\n      runtime: this.config.runtime,\n    });\n\n    await this.buildWebhookFunction({ workflowGeneratedDir });\n    await this.createBuildOutputConfig(outputDir);\n\n    // Generate unified manifest\n    const workflowBundlePath = join(\n      workflowGeneratedDir,\n      'flow.func/index.mjs'\n    );\n    const manifestJson = await this.createManifest({\n      workflowBundlePath,\n      manifestDir: workflowGeneratedDir,\n      manifest,\n    });\n\n    // Expose manifest as a static file when WORKFLOW_PUBLIC_MANIFEST=1.\n    // Vercel Build Output API serves static files from .vercel/output/static/\n    if (this.shouldExposePublicManifest && manifestJson) {\n      const staticManifestDir = join(\n        outputDir,\n        'static/.well-known/workflow/v1'\n      );\n      await mkdir(staticManifestDir, { recursive: true });\n      if (process.env.VERCEL_DEPLOYMENT_ID === undefined) {\n        await writeFile(join(staticManifestDir, '.gitignore'), '*');\n      }\n      await copyFile(\n        join(workflowGeneratedDir, 'manifest.json'),\n        join(staticManifestDir, 'manifest.json')\n      );\n    }\n\n    await this.createClientLibrary();\n  }\n\n  private async buildWebhookFunction({\n    workflowGeneratedDir,\n    bundle = true,\n  }: {\n    workflowGeneratedDir: string;\n    bundle?: boolean;\n  }): Promise<void> {\n    this.logBaseBuilderInfo(\n      'Creating Vercel Build Output API webhook function'\n    );\n    const webhookFuncDir = join(workflowGeneratedDir, 'webhook/[token].func');\n\n    // Bundle the webhook route with dependencies resolved\n    await this.createWebhookBundle({\n      outfile: join(webhookFuncDir, 'index.mjs'),\n      bundle, // Build Output API needs bundling (except in tests)\n    });\n\n    // Create package.json and .vc-config.json for webhook function\n    await this.createPackageJson(webhookFuncDir, 'module');\n    await this.createVcConfig(webhookFuncDir, {\n      handler: 'index.mjs',\n      shouldAddHelpers: false,\n      runtime: this.config.runtime,\n    });\n  }\n\n  private async createBuildOutputConfig(outputDir: string): Promise<void> {\n    // Create config.json for Build Output API\n    const buildOutputConfig = {\n      version: 3,\n      routes: [\n        {\n          src: '^\\\\/\\\\.well-known\\\\/workflow\\\\/v1\\\\/webhook\\\\/([^\\\\/]+)$',\n          dest: '/.well-known/workflow/v1/webhook/[token]',\n        },\n      ],\n    };\n\n    await writeFile(\n      join(outputDir, 'config.json'),\n      JSON.stringify(buildOutputConfig, null, 2)\n    );\n\n    this.logBaseBuilderInfo(`Build Output API created at ${outputDir}`);\n    this.logBaseBuilderInfo(\n      'Combined function available at /.well-known/workflow/v1/flow'\n    );\n    this.logBaseBuilderInfo(\n      'Webhook function available at /.well-known/workflow/v1/webhook/[token]'\n    );\n  }\n}\n"]}

package/dist/workflow-bundle-boundary.test.d.ts

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

package/dist/workflow-bundle-boundary.test.d.ts.map

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

package/dist/workflow-bundle-boundary.test.js

@@ -0,0 +1,78 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { BaseBuilder } from './base-builder.js';
+class TestBuilder extends BaseBuilder {
+    async build() { }
+    createWorkflowBundle(inputFile, outfile, discoveredEntries) {
+        return this.createWorkflowsBundle({
+            inputFiles: [inputFile],
+            outfile,
+            bundleFinalOutput: false,
+            includeMetafile: true,
+            discoveredEntries,
+        });
+    }
+}
+describe('workflow bundle boundary', () => {
+    const repoRoot = resolve(import.meta.dirname, '../../..');
+    const outputDirs = [];
+    afterEach(() => {
+        for (const outputDir of outputDirs) {
+            rmSync(outputDir, { recursive: true, force: true });
+        }
+    });
+    async function getWorkflowBundleInputs(source) {
+        // Keep the fixture beneath this package so its workspace dependencies are
+        // resolved exactly as they are for a real consumer workflow.
+        const outputDir = mkdtempSync(join(import.meta.dirname, '.workflow-pruning-'));
+        outputDirs.push(outputDir);
+        const inputFile = join(outputDir, 'workflow.ts');
+        writeFileSync(inputFile, source);
+        const config = {
+            buildTarget: 'standalone',
+            workingDir: outputDir,
+            projectRoot: repoRoot,
+            moduleSpecifierRoot: repoRoot,
+            dirs: ['.'],
+            stepsBundlePath: join(outputDir, 'steps.js'),
+            workflowsBundlePath: join(outputDir, 'workflow.js'),
+            webhookBundlePath: join(outputDir, 'webhook.js'),
+            sourcemap: false,
+        };
+        const discoveredEntries = {
+            discoveredSteps: new Set(),
+            discoveredWorkflows: new Set([inputFile]),
+            discoveredSerdeFiles: new Set(),
+        };
+        const { interimBundleMetafile } = await new TestBuilder(config).createWorkflowBundle(inputFile, config.workflowsBundlePath, discoveredEntries);
+        expect(interimBundleMetafile).toBeDefined();
+        return Object.keys(interimBundleMetafile?.inputs ?? {}).map((input) => input.replaceAll('\\', '/'));
+    }
+    function expectNoZodInputs(inputs) {
+        expect(inputs.filter((input) => input.includes('/node_modules/zod/'))).toEqual([]);
+    }
+    it('does not bundle world schemas into a minimal workflow', async () => {
+        const inputs = await getWorkflowBundleInputs(`export async function minimal() { "use workflow"; return 1; }`);
+        expectNoZodInputs(inputs);
+    });
+    it('does not bundle world schemas for core workflow APIs', async () => {
+        const inputs = await getWorkflowBundleInputs(`
+      import { createHook, setAttributes } from '@workflow/core';
+
+      async function basicStep(value: number) {
+        "use step";
+        return value + 1;
+      }
+
+      export async function realisticWorkflow() {
+        "use workflow";
+        await setAttributes({ phase: 'started' });
+        const hook = createHook<number>();
+        return basicStep(await hook);
+      }
+    `);
+        expectNoZodInputs(inputs);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/write-if-changed.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Reports whether `targetPath` already holds exactly `content`.
+ *
+ * Generated files are rewritten on every rebuild, and in dev most rebuilds
+ * produce byte-identical output. Rewriting anyway bumps the mtime (and, for
+ * the rename-based atomic write, the inode) of a file that lives inside the
+ * app directory the dev server watches, so the bundler sees a change and
+ * recompiles. Comparing first lets the caller skip the write entirely.
+ *
+ * Any read failure (missing file, permissions) reports `false`, so the caller
+ * falls back to writing.
+ */
+export declare function hasSameContent(targetPath: string, content: string): Promise<boolean>;
+/**
+ * `writeFile`, skipped when the file already holds `content`.
+ *
+ * Returns whether the file was actually written.
+ */
+export declare function writeFileIfChanged(targetPath: string, content: string): Promise<boolean>;
+//# sourceMappingURL=write-if-changed.d.ts.map

package/dist/write-if-changed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-if-changed.d.ts","sourceRoot":"","sources":["../src/write-if-changed.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CAgBlB;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CAMlB"}

package/dist/write-if-changed.js

@@ -0,0 +1,44 @@
+import { readFile, stat, writeFile } from 'node:fs/promises';
+/**
+ * Reports whether `targetPath` already holds exactly `content`.
+ *
+ * Generated files are rewritten on every rebuild, and in dev most rebuilds
+ * produce byte-identical output. Rewriting anyway bumps the mtime (and, for
+ * the rename-based atomic write, the inode) of a file that lives inside the
+ * app directory the dev server watches, so the bundler sees a change and
+ * recompiles. Comparing first lets the caller skip the write entirely.
+ *
+ * Any read failure (missing file, permissions) reports `false`, so the caller
+ * falls back to writing.
+ */
+export async function hasSameContent(targetPath, content) {
+    try {
+        // Compare bytes rather than decoded strings: utf-8 decoding is lossy, so
+        // two different byte sequences can decode to the same string and a real
+        // change would be skipped.
+        const expected = Buffer.from(content, 'utf8');
+        // Reject on size before reading the file, which for the generated bundle
+        // is the expensive half.
+        const { size } = await stat(targetPath);
+        if (size !== expected.byteLength) {
+            return false;
+        }
+        return Buffer.compare(await readFile(targetPath), expected) === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `writeFile`, skipped when the file already holds `content`.
+ *
+ * Returns whether the file was actually written.
+ */
+export async function writeFileIfChanged(targetPath, content) {
+    if (await hasSameContent(targetPath, content)) {
+        return false;
+    }
+    await writeFile(targetPath, content);
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/write-if-changed.test.d.ts

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

package/dist/write-if-changed.test.d.ts.map

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

package/dist/write-if-changed.test.js

@@ -0,0 +1,186 @@
+import { chmodSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { BaseBuilder } from './base-builder.js';
+import { hasSameContent, writeFileIfChanged } from './write-if-changed.js';
+// Resolve symlinks in tmpdir to avoid macOS /var -> /private/var issues
+const realTmpdir = realpathSync(tmpdir());
+/** Minimal subclass exposing the protected `writeGeneratedFile()`. */
+class TestBuilder extends BaseBuilder {
+    async build() {
+        // no-op
+    }
+    writeGeneratedFile(targetPath, content) {
+        return super.writeGeneratedFile(targetPath, content);
+    }
+}
+/**
+ * Stands in for a target whose consumers use the mtime of a generated file as
+ * a change signal, such as the Nitro dev handler.
+ */
+class OptedOutBuilder extends TestBuilder {
+    get skipsUnchangedGeneratedWrites() {
+        return false;
+    }
+}
+function makeConfig(workingDir) {
+    return {
+        buildTarget: 'standalone',
+        workingDir,
+        dirs: [workingDir],
+        stepsBundlePath: join(workingDir, 'steps.js'),
+        workflowsBundlePath: join(workingDir, 'workflows.js'),
+        webhookBundlePath: join(workingDir, 'webhook.js'),
+    };
+}
+function createBuilder(workingDir) {
+    return new TestBuilder(makeConfig(workingDir));
+}
+function createOptedOutBuilder(workingDir) {
+    return new OptedOutBuilder(makeConfig(workingDir));
+}
+/**
+ * mtime resolution varies by filesystem, so compare the full stat identity
+ * (mtime in ns plus inode) rather than trusting a millisecond timestamp.
+ * `writeGeneratedFile` renames over the target, which changes the inode even
+ * when the mtime happens to land in the same tick.
+ */
+function fileIdentity(path) {
+    const s = statSync(path, { bigint: true });
+    return `${s.mtimeNs}:${s.ino}`;
+}
+let testRoot;
+beforeEach(() => {
+    testRoot = mkdtempSync(join(realTmpdir, 'write-if-changed-'));
+});
+afterEach(() => {
+    rmSync(testRoot, { recursive: true, force: true });
+});
+describe('hasSameContent', () => {
+    it('is false when the file does not exist', async () => {
+        await expect(hasSameContent(join(testRoot, 'missing.js'), 'hello')).resolves.toBe(false);
+    });
+    it('is true for byte-identical content', async () => {
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, 'export const a = 1;\n');
+        await expect(hasSameContent(target, 'export const a = 1;\n')).resolves.toBe(true);
+    });
+    it('is false when content differs at the same byte length', async () => {
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, 'aaaa');
+        await expect(hasSameContent(target, 'aaab')).resolves.toBe(false);
+    });
+    it('is false when only the length differs', async () => {
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, 'aaaa');
+        await expect(hasSameContent(target, 'aaaaa')).resolves.toBe(false);
+    });
+    it('compares utf-8 byte length, not code units', async () => {
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, '// é\u{1f600}\n', 'utf-8');
+        await expect(hasSameContent(target, '// é\u{1f600}\n')).resolves.toBe(true);
+    });
+    it('is false for byte-different content that decodes to the same string', async () => {
+        // An unpaired surrogate and U+FFFD both decode to the replacement
+        // character, so a utf-8 string comparison would call these equal.
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, Buffer.from([0x61, 0xf0, 0x90, 0x80]));
+        await expect(hasSameContent(target, Buffer.from([0x61, 0xef, 0xbf, 0xbd]).toString())).resolves.toBe(false);
+    });
+    it('is false when the path is a directory', async () => {
+        // Match the directory's own reported size so the check cannot pass by
+        // short-circuiting on length before it ever tries to read.
+        const sameSizeAsDir = 'x'.repeat(statSync(testRoot).size);
+        await expect(hasSameContent(testRoot, sameSizeAsDir)).resolves.toBe(false);
+    });
+    it('is false when the file cannot be read', async () => {
+        const target = join(testRoot, 'locked.js');
+        writeFileSync(target, 'secret');
+        chmodSync(target, 0o000);
+        try {
+            // Root ignores the mode bits, so only assert when the read really fails.
+            let readable = true;
+            try {
+                readFileSync(target, 'utf8');
+            }
+            catch {
+                readable = false;
+            }
+            if (readable) {
+                return;
+            }
+            await expect(hasSameContent(target, 'secret')).resolves.toBe(false);
+        }
+        finally {
+            chmodSync(target, 0o600);
+        }
+    });
+});
+describe('writeFileIfChanged', () => {
+    it('creates the file when it does not exist', async () => {
+        const target = join(testRoot, 'a.js');
+        await expect(writeFileIfChanged(target, 'hello')).resolves.toBe(true);
+        expect(readFileSync(target, 'utf8')).toBe('hello');
+    });
+    it('does not touch the file when content is unchanged', async () => {
+        const target = join(testRoot, 'a.js');
+        await writeFileIfChanged(target, 'hello');
+        const before = fileIdentity(target);
+        await expect(writeFileIfChanged(target, 'hello')).resolves.toBe(false);
+        expect(fileIdentity(target)).toBe(before);
+    });
+    it('rewrites the file when content changes', async () => {
+        const target = join(testRoot, 'a.js');
+        await writeFileIfChanged(target, 'hello');
+        await expect(writeFileIfChanged(target, 'goodbye')).resolves.toBe(true);
+        expect(readFileSync(target, 'utf8')).toBe('goodbye');
+    });
+});
+describe('writeGeneratedFile', () => {
+    // Regression test for the dev watcher thrash: the generated routes live
+    // inside the app directory the dev server watches, so a rewrite with
+    // identical bytes still invalidates the bundler and forces a recompile.
+    it('leaves the file untouched when the generated output is unchanged', async () => {
+        const builder = createBuilder(testRoot);
+        const target = join(testRoot, 'route.js');
+        await builder.writeGeneratedFile(target, 'export const GET = () => {};');
+        const before = fileIdentity(target);
+        await builder.writeGeneratedFile(target, 'export const GET = () => {};');
+        expect(fileIdentity(target)).toBe(before);
+    });
+    it('leaves no temp files behind when the write is skipped', async () => {
+        const builder = createBuilder(testRoot);
+        const target = join(testRoot, 'route.js');
+        await builder.writeGeneratedFile(target, 'same');
+        await builder.writeGeneratedFile(target, 'same');
+        expect(readdirSync(testRoot).filter((f) => f.endsWith('.tmp'))).toEqual([]);
+    });
+    it('still writes when the generated output changes', async () => {
+        const builder = createBuilder(testRoot);
+        const target = join(testRoot, 'route.js');
+        await builder.writeGeneratedFile(target, 'v1');
+        await builder.writeGeneratedFile(target, 'v2');
+        expect(readFileSync(target, 'utf8')).toBe('v2');
+    });
+    it('creates the file on first write', async () => {
+        const builder = createBuilder(testRoot);
+        const target = join(testRoot, 'route.js');
+        await builder.writeGeneratedFile(target, 'first');
+        expect(readFileSync(target, 'utf8')).toBe('first');
+    });
+    // The Nitro dev handler cache-busts its import of `steps.mjs` off the mtime
+    // of `workflows.mjs`, so that target opts out: skipping the redundant write
+    // would freeze the version key and serve stale step code. See
+    // `packages/nitro/src/builders.ts`.
+    it('still rewrites unchanged output when the target opts out', async () => {
+        const builder = createOptedOutBuilder(testRoot);
+        const target = join(testRoot, 'workflows.mjs');
+        await builder.writeGeneratedFile(target, 'export const a = 1;');
+        const before = fileIdentity(target);
+        await builder.writeGeneratedFile(target, 'export const a = 1;');
+        expect(fileIdentity(target)).not.toBe(before);
+        expect(readFileSync(target, 'utf8')).toBe('export const a = 1;');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"write-if-changed.test.js","sourceRoot":"","sources":["../src/write-if-changed.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  chmodSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  realpathSync,\n  rmSync,\n  statSync,\n  writeFileSync,\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { afterEach, beforeEach, describe, expect, it } from 'vitest';\nimport { BaseBuilder } from './base-builder.js';\nimport type { StandaloneConfig } from './types.js';\nimport { hasSameContent, writeFileIfChanged } from './write-if-changed.js';\n\n// Resolve symlinks in tmpdir to avoid macOS /var -> /private/var issues\nconst realTmpdir = realpathSync(tmpdir());\n\n/** Minimal subclass exposing the protected `writeGeneratedFile()`. */\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    // no-op\n  }\n\n  public writeGeneratedFile(\n    targetPath: string,\n    content: string\n  ): Promise<void> {\n    return super.writeGeneratedFile(targetPath, content);\n  }\n}\n\n/**\n * Stands in for a target whose consumers use the mtime of a generated file as\n * a change signal, such as the Nitro dev handler.\n */\nclass OptedOutBuilder extends TestBuilder {\n  protected override get skipsUnchangedGeneratedWrites(): boolean {\n    return false;\n  }\n}\n\nfunction makeConfig(workingDir: string): StandaloneConfig {\n  return {\n    buildTarget: 'standalone',\n    workingDir,\n    dirs: [workingDir],\n    stepsBundlePath: join(workingDir, 'steps.js'),\n    workflowsBundlePath: join(workingDir, 'workflows.js'),\n    webhookBundlePath: join(workingDir, 'webhook.js'),\n  };\n}\n\nfunction createBuilder(workingDir: string): TestBuilder {\n  return new TestBuilder(makeConfig(workingDir));\n}\n\nfunction createOptedOutBuilder(workingDir: string): OptedOutBuilder {\n  return new OptedOutBuilder(makeConfig(workingDir));\n}\n\n/**\n * mtime resolution varies by filesystem, so compare the full stat identity\n * (mtime in ns plus inode) rather than trusting a millisecond timestamp.\n * `writeGeneratedFile` renames over the target, which changes the inode even\n * when the mtime happens to land in the same tick.\n */\nfunction fileIdentity(path: string): string {\n  const s = statSync(path, { bigint: true });\n  return `${s.mtimeNs}:${s.ino}`;\n}\n\nlet testRoot: string;\n\nbeforeEach(() => {\n  testRoot = mkdtempSync(join(realTmpdir, 'write-if-changed-'));\n});\n\nafterEach(() => {\n  rmSync(testRoot, { recursive: true, force: true });\n});\n\ndescribe('hasSameContent', () => {\n  it('is false when the file does not exist', async () => {\n    await expect(\n      hasSameContent(join(testRoot, 'missing.js'), 'hello')\n    ).resolves.toBe(false);\n  });\n\n  it('is true for byte-identical content', async () => {\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, 'export const a = 1;\\n');\n\n    await expect(hasSameContent(target, 'export const a = 1;\\n')).resolves.toBe(\n      true\n    );\n  });\n\n  it('is false when content differs at the same byte length', async () => {\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, 'aaaa');\n\n    await expect(hasSameContent(target, 'aaab')).resolves.toBe(false);\n  });\n\n  it('is false when only the length differs', async () => {\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, 'aaaa');\n\n    await expect(hasSameContent(target, 'aaaaa')).resolves.toBe(false);\n  });\n\n  it('compares utf-8 byte length, not code units', async () => {\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, '// é\\u{1f600}\\n', 'utf-8');\n\n    await expect(hasSameContent(target, '// é\\u{1f600}\\n')).resolves.toBe(true);\n  });\n\n  it('is false for byte-different content that decodes to the same string', async () => {\n    // An unpaired surrogate and U+FFFD both decode to the replacement\n    // character, so a utf-8 string comparison would call these equal.\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, Buffer.from([0x61, 0xf0, 0x90, 0x80]));\n\n    await expect(\n      hasSameContent(target, Buffer.from([0x61, 0xef, 0xbf, 0xbd]).toString())\n    ).resolves.toBe(false);\n  });\n\n  it('is false when the path is a directory', async () => {\n    // Match the directory's own reported size so the check cannot pass by\n    // short-circuiting on length before it ever tries to read.\n    const sameSizeAsDir = 'x'.repeat(statSync(testRoot).size);\n\n    await expect(hasSameContent(testRoot, sameSizeAsDir)).resolves.toBe(false);\n  });\n\n  it('is false when the file cannot be read', async () => {\n    const target = join(testRoot, 'locked.js');\n    writeFileSync(target, 'secret');\n    chmodSync(target, 0o000);\n\n    try {\n      // Root ignores the mode bits, so only assert when the read really fails.\n      let readable = true;\n      try {\n        readFileSync(target, 'utf8');\n      } catch {\n        readable = false;\n      }\n      if (readable) {\n        return;\n      }\n      await expect(hasSameContent(target, 'secret')).resolves.toBe(false);\n    } finally {\n      chmodSync(target, 0o600);\n    }\n  });\n});\n\ndescribe('writeFileIfChanged', () => {\n  it('creates the file when it does not exist', async () => {\n    const target = join(testRoot, 'a.js');\n\n    await expect(writeFileIfChanged(target, 'hello')).resolves.toBe(true);\n    expect(readFileSync(target, 'utf8')).toBe('hello');\n  });\n\n  it('does not touch the file when content is unchanged', async () => {\n    const target = join(testRoot, 'a.js');\n    await writeFileIfChanged(target, 'hello');\n    const before = fileIdentity(target);\n\n    await expect(writeFileIfChanged(target, 'hello')).resolves.toBe(false);\n\n    expect(fileIdentity(target)).toBe(before);\n  });\n\n  it('rewrites the file when content changes', async () => {\n    const target = join(testRoot, 'a.js');\n    await writeFileIfChanged(target, 'hello');\n\n    await expect(writeFileIfChanged(target, 'goodbye')).resolves.toBe(true);\n    expect(readFileSync(target, 'utf8')).toBe('goodbye');\n  });\n});\n\ndescribe('writeGeneratedFile', () => {\n  // Regression test for the dev watcher thrash: the generated routes live\n  // inside the app directory the dev server watches, so a rewrite with\n  // identical bytes still invalidates the bundler and forces a recompile.\n  it('leaves the file untouched when the generated output is unchanged', async () => {\n    const builder = createBuilder(testRoot);\n    const target = join(testRoot, 'route.js');\n\n    await builder.writeGeneratedFile(target, 'export const GET = () => {};');\n    const before = fileIdentity(target);\n\n    await builder.writeGeneratedFile(target, 'export const GET = () => {};');\n\n    expect(fileIdentity(target)).toBe(before);\n  });\n\n  it('leaves no temp files behind when the write is skipped', async () => {\n    const builder = createBuilder(testRoot);\n    const target = join(testRoot, 'route.js');\n\n    await builder.writeGeneratedFile(target, 'same');\n    await builder.writeGeneratedFile(target, 'same');\n\n    expect(readdirSync(testRoot).filter((f) => f.endsWith('.tmp'))).toEqual([]);\n  });\n\n  it('still writes when the generated output changes', async () => {\n    const builder = createBuilder(testRoot);\n    const target = join(testRoot, 'route.js');\n\n    await builder.writeGeneratedFile(target, 'v1');\n    await builder.writeGeneratedFile(target, 'v2');\n\n    expect(readFileSync(target, 'utf8')).toBe('v2');\n  });\n\n  it('creates the file on first write', async () => {\n    const builder = createBuilder(testRoot);\n    const target = join(testRoot, 'route.js');\n\n    await builder.writeGeneratedFile(target, 'first');\n\n    expect(readFileSync(target, 'utf8')).toBe('first');\n  });\n\n  // The Nitro dev handler cache-busts its import of `steps.mjs` off the mtime\n  // of `workflows.mjs`, so that target opts out: skipping the redundant write\n  // would freeze the version key and serve stale step code. See\n  // `packages/nitro/src/builders.ts`.\n  it('still rewrites unchanged output when the target opts out', async () => {\n    const builder = createOptedOutBuilder(testRoot);\n    const target = join(testRoot, 'workflows.mjs');\n\n    await builder.writeGeneratedFile(target, 'export const a = 1;');\n    const before = fileIdentity(target);\n\n    await builder.writeGeneratedFile(target, 'export const a = 1;');\n\n    expect(fileIdentity(target)).not.toBe(before);\n    expect(readFileSync(target, 'utf8')).toBe('export const a = 1;');\n  });\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/builders",
-  "version": "5.0.0-beta.43",
+  "version": "5.0.0-beta.46",
   "description": "Shared builder infrastructure for Workflow SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,9 +41,9 @@
     "find-up": "7.0.0",
     "json5": "2.2.3",
     "tinyglobby": "0.2.17",
-    "@workflow/core": "5.0.0-beta.43",
-    "@workflow/errors": "5.0.0-beta.17",
-    "@workflow/utils": "5.0.0-beta.8",
+    "@workflow/core": "5.0.0-beta.46",
+    "@workflow/errors": "5.0.0-beta.18",
+    "@workflow/utils": "5.0.0-beta.9",
     "@workflow/swc-plugin": "5.0.0-beta.5"
   },
   "scripts": {