@webstir-io/webstir-frontend 0.1.40 → 0.1.41

package/dist/builders/jsBuilder.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import { build as esbuild } from 'esbuild';
-import { glob } from 'glob';
 import { FOLDERS, FILES, EXTENSIONS } from '../core/constants.js';
 import { getPages } from '../core/pages.js';
 import { ensureDir, pathExists, copy, remove, stat } from '../utils/fs.js';
-import { updatePageManifest, updateSharedAssets, readSharedAssets } from '../assets/assetManifest.js';
+import { scanGlob } from '../utils/glob.js';
+import { updatePageManifest, updateSharedAssets, readSharedAssets, } from '../assets/assetManifest.js';
 import { createCompressedVariants } from '../assets/precompression.js';
 import { shouldProcess } from '../utils/changedFile.js';
 import { findPageFromChangedFile } from '../utils/pathMatch.js';
@@ -18,24 +18,24 @@ export function createJavaScriptBuilder(context) {
         },
         async publish() {
             await bundleJavaScript(context, true);
-        }
+        },
     };
 }
 async function bundleJavaScript(context, isProduction) {
     const { config } = context;
+    const bundler = resolveJavaScriptBundler(context.env);
     if (!shouldProcess(context, [
         {
             directory: config.paths.src.frontend,
-            extensions: [EXTENSIONS.ts, EXTENSIONS.js, '.tsx', '.jsx']
-        }
+            extensions: [EXTENSIONS.ts, EXTENSIONS.js, '.tsx', '.jsx'],
+        },
     ])) {
         return;
     }
     const targetPage = findPageFromChangedFile(context.changedFile, config.paths.src.pages);
     const pages = await getPages(config.paths.src.pages);
-    let builtAny = false;
     await assertFeatureModulesPresent(config, context.enable);
-    await compileAppTypeScript(config, isProduction);
+    await compileAppTypeScript(context, isProduction, bundler);
     for (const page of pages) {
         if (targetPage && page.name !== targetPage) {
             continue;
@@ -44,12 +44,11 @@ async function bundleJavaScript(context, isProduction) {
         if (!entryPoint) {
             continue;
         }
-        builtAny = true;
         if (isProduction) {
-            await buildForProduction(config, page.name, entryPoint);
+            await buildForProduction(config, page.name, entryPoint, bundler);
         }
         else {
-            await buildForDevelopment(config, page.name, entryPoint);
+            await buildForDevelopment(config, page.name, entryPoint, bundler);
         }
     }
     // Always copy dev runtime scripts in dev builds to support HMR/refresh even when no page JS exists.
@@ -57,7 +56,8 @@ async function bundleJavaScript(context, isProduction) {
         await copyRuntimeScripts(config, context.enable, isProduction);
     }
 }
-async function compileAppTypeScript(config, isProduction) {
+async function compileAppTypeScript(context, isProduction, bundler) {
+    const { config } = context;
     const appRoot = config.paths.src.app;
     if (!(await pathExists(appRoot))) {
         return;
@@ -69,24 +69,9 @@ async function compileAppTypeScript(config, isProduction) {
         }
         const outputDir = path.join(config.paths.dist.frontend, FOLDERS.app);
         await ensureDir(outputDir);
-        const result = await esbuild({
-            entryPoints: [entryPoint],
-            outdir: outputDir,
-            format: 'esm',
-            target: 'es2020',
-            platform: 'browser',
-            minify: true,
-            sourcemap: false,
-            bundle: true,
-            entryNames: 'app-[hash]',
-            assetNames: 'assets/[name]-[hash]',
-            metafile: true,
-            logLevel: 'silent'
-        });
-        const fileName = await resolveAppBundleName(outputDir, entryPoint, result.metafile);
-        if (!fileName) {
-            throw new Error(`esbuild did not produce an app bundle for ${entryPoint}.`);
-        }
+        const fileName = bundler === 'bun'
+            ? await buildAppForProductionWithBun(outputDir, entryPoint)
+            : await buildAppForProductionWithEsbuild(outputDir, entryPoint);
         const absolutePath = path.join(outputDir, fileName);
         if (config.features.precompression) {
             await createCompressedVariants(absolutePath);
@@ -94,7 +79,7 @@ async function compileAppTypeScript(config, isProduction) {
         else {
             await Promise.all([
                 remove(`${absolutePath}${EXTENSIONS.br}`).catch(() => undefined),
-                remove(`${absolutePath}${EXTENSIONS.gz}`).catch(() => undefined)
+                remove(`${absolutePath}${EXTENSIONS.gz}`).catch(() => undefined),
             ]);
         }
         const existing = await readSharedAssets(config.paths.dist.frontend);
@@ -105,37 +90,30 @@ async function compileAppTypeScript(config, isProduction) {
             await remove(`${previousPath}${EXTENSIONS.br}`).catch(() => undefined);
             await remove(`${previousPath}${EXTENSIONS.gz}`).catch(() => undefined);
         }
-        await updateSharedAssets(config.paths.dist.frontend, shared => {
+        await updateSharedAssets(config.paths.dist.frontend, (shared) => {
             shared.js = fileName;
         });
         return;
     }
-    const entryPoints = (await glob('**/*.{ts,tsx}', { cwd: appRoot, nodir: true }))
-        .filter((relativePath) => !relativePath.endsWith('.d.ts'))
-        .map((relativePath) => path.join(appRoot, relativePath));
-    if (entryPoints.length === 0) {
+    const entryPoint = await resolveAppEntry(appRoot);
+    if (!entryPoint) {
         return;
     }
-    const outdir = isProduction
-        ? path.join(config.paths.dist.frontend, FOLDERS.app)
-        : path.join(config.paths.build.frontend, FOLDERS.app);
+    const outdir = path.join(config.paths.build.frontend, FOLDERS.app);
     await ensureDir(outdir);
-    await esbuild({
-        entryPoints,
-        outdir,
-        format: 'esm',
-        target: 'es2020',
-        platform: 'browser',
-        sourcemap: !isProduction,
-        minify: isProduction,
-        bundle: false,
-        outbase: appRoot,
-        logLevel: 'silent'
-    });
+    if (bundler === 'bun') {
+        await buildForDevelopmentWithBun(outdir, entryPoint);
+        return;
+    }
+    await buildAppForDevelopmentWithEsbuild(outdir, entryPoint);
 }
-async function buildForDevelopment(config, pageName, entryPoint) {
+async function buildForDevelopment(config, pageName, entryPoint, bundler) {
     const outputDir = path.join(config.paths.build.pages, pageName);
     await ensureDir(outputDir);
+    if (bundler === 'bun') {
+        await buildForDevelopmentWithBun(outputDir, entryPoint);
+        return;
+    }
     const outfile = path.join(outputDir, `${FILES.index}${EXTENSIONS.js}`);
     await esbuild({
         entryPoints: [entryPoint],
@@ -145,12 +123,94 @@ async function buildForDevelopment(config, pageName, entryPoint) {
         platform: 'browser',
         sourcemap: true,
         outfile,
-        logLevel: 'silent'
+        logLevel: 'silent',
     });
 }
-async function buildForProduction(config, pageName, entryPoint) {
+async function buildForProduction(config, pageName, entryPoint, bundler) {
     const outputDir = path.join(config.paths.dist.pages, pageName);
     await ensureDir(outputDir);
+    const fileName = bundler === 'bun'
+        ? await buildPageForProductionWithBun(outputDir, pageName, entryPoint)
+        : await buildPageForProductionWithEsbuild(outputDir, pageName, entryPoint);
+    const absolutePath = path.join(outputDir, fileName);
+    if (config.features.precompression) {
+        await createCompressedVariants(absolutePath);
+    }
+    else {
+        await Promise.all([
+            remove(`${absolutePath}${EXTENSIONS.br}`).catch(() => undefined),
+            remove(`${absolutePath}${EXTENSIONS.gz}`).catch(() => undefined),
+        ]);
+    }
+    await updatePageManifest(outputDir, pageName, (manifest) => {
+        manifest.js = fileName;
+    });
+}
+async function buildAppForProductionWithEsbuild(outputDir, entryPoint) {
+    const result = await esbuild({
+        entryPoints: [entryPoint],
+        outdir: outputDir,
+        format: 'esm',
+        target: 'es2020',
+        platform: 'browser',
+        minify: true,
+        sourcemap: false,
+        bundle: true,
+        entryNames: 'app-[hash]',
+        assetNames: 'assets/[name]-[hash]',
+        metafile: true,
+        logLevel: 'silent',
+    });
+    const fileName = await resolveAppBundleName(outputDir, entryPoint, result.metafile);
+    if (!fileName) {
+        throw new Error(`esbuild did not produce an app bundle for ${entryPoint}.`);
+    }
+    return fileName;
+}
+async function buildAppForProductionWithBun(outputDir, entryPoint) {
+    const result = await runBunBrowserBuild({
+        entryPoint,
+        root: path.dirname(entryPoint),
+        outputDir,
+        minify: true,
+        sourcemap: 'none',
+        naming: {
+            entry: 'app-[hash].js',
+            asset: 'assets/[name]-[hash].[ext]',
+        },
+    });
+    ensureBunBuildSucceeded(result, `app bundle ${entryPoint}`);
+    const fileName = resolveBunEntryOutputName(result.outputs, outputDir, (name) => {
+        return name.startsWith('app-') && name.endsWith(EXTENSIONS.js);
+    });
+    if (!fileName) {
+        throw new Error(`Bun.build() did not produce an app bundle for ${entryPoint}.`);
+    }
+    return fileName;
+}
+async function buildForDevelopmentWithBun(outputDir, entryPoint) {
+    const result = await runBunBrowserBuild({
+        entryPoint,
+        root: path.dirname(entryPoint),
+        outputDir,
+        minify: false,
+        sourcemap: 'linked',
+    });
+    ensureBunBuildSucceeded(result, `development bundle ${entryPoint}`);
+}
+async function buildAppForDevelopmentWithEsbuild(outputDir, entryPoint) {
+    await esbuild({
+        entryPoints: [entryPoint],
+        outdir: outputDir,
+        format: 'esm',
+        target: 'es2020',
+        platform: 'browser',
+        sourcemap: 'linked',
+        bundle: true,
+        logLevel: 'silent',
+    });
+}
+async function buildPageForProductionWithEsbuild(outputDir, pageName, entryPoint) {
     const result = await esbuild({
         entryPoints: [entryPoint],
         bundle: true,
@@ -163,33 +223,41 @@ async function buildForProduction(config, pageName, entryPoint) {
         entryNames: `${FILES.index}-[hash]`,
         assetNames: 'assets/[name]-[hash]',
         metafile: true,
-        logLevel: 'silent'
+        logLevel: 'silent',
     });
     const outputs = result.metafile?.outputs ?? {};
     const scriptPath = Object.keys(outputs).find((file) => file.endsWith('.js'));
     if (!scriptPath) {
         throw new Error(`esbuild did not produce a JavaScript bundle for page '${pageName}'.`);
     }
-    const fileName = path.basename(scriptPath);
-    const absolutePath = path.join(outputDir, fileName);
-    if (config.features.precompression) {
-        await createCompressedVariants(absolutePath);
-    }
-    else {
-        await Promise.all([
-            remove(`${absolutePath}${EXTENSIONS.br}`).catch(() => undefined),
-            remove(`${absolutePath}${EXTENSIONS.gz}`).catch(() => undefined)
-        ]);
-    }
-    await updatePageManifest(outputDir, pageName, (manifest) => {
-        manifest.js = fileName;
+    return path.basename(scriptPath);
+}
+async function buildPageForProductionWithBun(outputDir, pageName, entryPoint) {
+    const result = await runBunBrowserBuild({
+        entryPoint,
+        root: path.dirname(entryPoint),
+        outputDir,
+        minify: true,
+        sourcemap: 'none',
+        naming: {
+            entry: `${FILES.index}-[hash].js`,
+            asset: 'assets/[name]-[hash].[ext]',
+        },
+    });
+    ensureBunBuildSucceeded(result, `page bundle '${pageName}'`);
+    const fileName = resolveBunEntryOutputName(result.outputs, outputDir, (name) => {
+        return name.startsWith(`${FILES.index}-`) && name.endsWith(EXTENSIONS.js);
     });
+    if (!fileName) {
+        throw new Error(`Bun.build() did not produce a JavaScript bundle for page '${pageName}'.`);
+    }
+    return fileName;
 }
-async function copyRuntimeScripts(config, enable, isProduction) {
+async function copyRuntimeScripts(config, _enable, isProduction) {
     const scripts = [
         // Always copy dev runtime in dev builds to support live reload, even if no page JS exists.
         { name: FILES.refreshJs, copyToDist: false, required: !isProduction },
-        { name: FILES.hmrJs, copyToDist: false, required: !isProduction }
+        { name: FILES.hmrJs, copyToDist: false, required: !isProduction },
     ];
     for (const script of scripts) {
         if (!script.required) {
@@ -244,15 +312,13 @@ async function assertFeatureModulesPresent(config, enable) {
     if (missing.length === 0) {
         return;
     }
-    const expected = missing
-        .map((name) => `src/frontend/app/scripts/features/${name}.ts`)
-        .join(', ');
+    const expected = missing.map((name) => `src/frontend/app/scripts/features/${name}.ts`).join(', ');
     throw new Error(`Enabled feature module(s) missing: ${missing.join(', ')}. Run 'webstir enable <feature>' to scaffold them (expected: ${expected}).`);
 }
 async function hasFeatureModule(config, name) {
     const root = path.join(config.paths.src.app, 'scripts', 'features');
-    return await pathExists(path.join(root, `${name}${EXTENSIONS.ts}`))
-        || await pathExists(path.join(root, `${name}${EXTENSIONS.js}`));
+    return ((await pathExists(path.join(root, `${name}${EXTENSIONS.ts}`))) ||
+        (await pathExists(path.join(root, `${name}${EXTENSIONS.js}`))));
 }
 async function resolveAppBundleName(outputDir, entryPoint, metafile) {
     const outputs = metafile?.outputs ?? {};
@@ -266,7 +332,7 @@ async function resolveAppBundleName(outputDir, entryPoint, metafile) {
     if (entryOutput) {
         return path.basename(entryOutput[0]);
     }
-    const matches = await glob('app-*.js', { cwd: outputDir, nodir: true });
+    const matches = await scanGlob('app-*.js', { cwd: outputDir });
     if (matches.length === 0) {
         return null;
     }
@@ -283,12 +349,89 @@ async function resolveAppBundleName(outputDir, entryPoint, metafile) {
     }
     return latest?.name ?? matches[0] ?? null;
 }
+async function runBunBrowserBuild(options) {
+    const build = getBunBuild();
+    if (!build) {
+        throw new Error('Bun.build() is not available in the current runtime.');
+    }
+    return await build({
+        entrypoints: [options.entryPoint],
+        root: options.root,
+        outdir: options.outputDir,
+        target: 'browser',
+        format: 'esm',
+        minify: options.minify,
+        sourcemap: options.sourcemap,
+        splitting: false,
+        naming: options.naming,
+        throw: false,
+    });
+}
+function resolveJavaScriptBundler(env) {
+    const requestedBundler = normalizeJavaScriptBundler(env?.WEBSTIR_FRONTEND_BUNDLER);
+    if (requestedBundler !== 'bun') {
+        return 'esbuild';
+    }
+    if (!getBunBuild()) {
+        console.warn('[webstir-frontend] WEBSTIR_FRONTEND_BUNDLER=bun requested outside a Bun runtime; falling back to esbuild.');
+        return 'esbuild';
+    }
+    return 'bun';
+}
+function normalizeJavaScriptBundler(rawBundler) {
+    return typeof rawBundler === 'string' && rawBundler.trim().toLowerCase() === 'bun'
+        ? 'bun'
+        : 'esbuild';
+}
+function resolveBunEntryOutputName(outputs, outputDir, matcher) {
+    const normalizedOutputDir = path.resolve(outputDir);
+    for (const output of outputs ?? []) {
+        if (output.kind !== 'entry-point') {
+            continue;
+        }
+        if (path.resolve(path.dirname(output.path)) !== normalizedOutputDir) {
+            continue;
+        }
+        const fileName = path.basename(output.path);
+        if (matcher(fileName)) {
+            return fileName;
+        }
+    }
+    return null;
+}
+function ensureBunBuildSucceeded(result, label) {
+    const errors = (result.logs ?? [])
+        .filter((entry) => entry.level === 'error')
+        .map((entry) => formatBunBuildMessage(entry));
+    if (!result.success || errors.length > 0) {
+        throw new Error(errors[0] ?? `Bun.build() failed for ${label}.`);
+    }
+}
+function formatBunBuildMessage(entry) {
+    const text = typeof entry.message === 'string'
+        ? entry.message
+        : typeof entry.text === 'string'
+            ? entry.text
+            : 'Bun.build() failed.';
+    const position = entry.position;
+    if (position?.file) {
+        const line = typeof position.line === 'number' ? position.line : 1;
+        const column = typeof position.column === 'number' ? position.column : 1;
+        return `${position.file}:${line}:${column} ${text}`;
+    }
+    return text;
+}
+function getBunBuild() {
+    const runtime = globalThis;
+    const build = runtime.Bun?.build;
+    return typeof build === 'function' ? build.bind(runtime.Bun) : undefined;
+}
 async function resolveAppEntry(appRoot) {
     const candidates = [
         `${APP_ENTRY_BASENAME}${EXTENSIONS.ts}`,
         `${APP_ENTRY_BASENAME}.tsx`,
         `${APP_ENTRY_BASENAME}${EXTENSIONS.js}`,
-        `${APP_ENTRY_BASENAME}.jsx`
+        `${APP_ENTRY_BASENAME}.jsx`,
     ];
     for (const candidate of candidates) {
         const fullPath = path.join(appRoot, candidate);

package/dist/builders/staticAssetsBuilder.js

@@ -11,14 +11,14 @@ const IMAGE_EXTENSIONS = [
     EXTENSIONS.gif,
     EXTENSIONS.svg,
     EXTENSIONS.webp,
-    EXTENSIONS.ico
+    EXTENSIONS.ico,
 ];
 const FONT_EXTENSIONS = [
     EXTENSIONS.woff,
     EXTENSIONS.woff2,
     EXTENSIONS.ttf,
     EXTENSIONS.otf,
-    EXTENSIONS.eot
+    EXTENSIONS.eot,
 ];
 const MEDIA_EXTENSIONS = [
     EXTENSIONS.mp3,
@@ -27,7 +27,7 @@ const MEDIA_EXTENSIONS = [
     EXTENSIONS.ogg,
     EXTENSIONS.mp4,
     EXTENSIONS.webm,
-    EXTENSIONS.mov
+    EXTENSIONS.mov,
 ];
 const ALLOW_ALL_ROBOTS = 'User-agent: *\nAllow: /\n';
 export function createStaticAssetsBuilder(context) {
@@ -38,7 +38,7 @@ export function createStaticAssetsBuilder(context) {
         },
         async publish() {
             await copyStaticAssets(context, true);
-        }
+        },
     };
 }
 async function copyStaticAssets(context, isProduction) {
@@ -46,14 +46,32 @@ async function copyStaticAssets(context, isProduction) {
     if (!shouldProcess(context, [
         { directory: config.paths.src.images, extensions: IMAGE_EXTENSIONS },
         { directory: config.paths.src.fonts, extensions: FONT_EXTENSIONS },
-        { directory: config.paths.src.media, extensions: MEDIA_EXTENSIONS }
+        { directory: config.paths.src.media, extensions: MEDIA_EXTENSIONS },
     ])) {
         return;
     }
     const targets = [
-        { source: config.paths.src.images, build: config.paths.build.frontend, dist: config.paths.dist.frontend, folder: FOLDERS.images, extensions: IMAGE_EXTENSIONS },
-        { source: config.paths.src.fonts, build: config.paths.build.frontend, dist: config.paths.dist.frontend, folder: FOLDERS.fonts, extensions: FONT_EXTENSIONS },
-        { source: config.paths.src.media, build: config.paths.build.frontend, dist: config.paths.dist.frontend, folder: FOLDERS.media, extensions: MEDIA_EXTENSIONS }
+        {
+            source: config.paths.src.images,
+            build: config.paths.build.frontend,
+            dist: config.paths.dist.frontend,
+            folder: FOLDERS.images,
+            extensions: IMAGE_EXTENSIONS,
+        },
+        {
+            source: config.paths.src.fonts,
+            build: config.paths.build.frontend,
+            dist: config.paths.dist.frontend,
+            folder: FOLDERS.fonts,
+            extensions: FONT_EXTENSIONS,
+        },
+        {
+            source: config.paths.src.media,
+            build: config.paths.build.frontend,
+            dist: config.paths.dist.frontend,
+            folder: FOLDERS.media,
+            extensions: MEDIA_EXTENSIONS,
+        },
     ];
     for (const target of targets) {
         if (!(await pathExists(target.source))) {
@@ -131,7 +149,7 @@ async function syncImageWithoutOptimization(buildRoot, distRoot, relativePath) {
     }
     await Promise.all([
         remove(`${destinationPath}${EXTENSIONS.webp}`).catch(() => undefined),
-        remove(`${destinationPath}${EXTENSIONS.avif}`).catch(() => undefined)
+        remove(`${destinationPath}${EXTENSIONS.avif}`).catch(() => undefined),
     ]);
 }
 async function syncRobotsTxt(config, isProduction) {

package/dist/builders/types.d.ts

@@ -3,6 +3,7 @@ export interface BuilderContext {
     readonly config: FrontendConfig;
     readonly changedFile?: string;
     readonly enable?: EnableFlags;
+    readonly env?: Record<string, string | undefined>;
 }
 export interface Builder {
     readonly name: string;

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 export {};

package/dist/cli.js

@@ -1,11 +1,8 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import { Command } from 'commander';
 import { runAddPage, runBuild, runPublish, runRebuild } from './operations.js';
-import { WatchDaemon } from './watch/watchDaemon.js';
 const program = new Command();
-program
-    .name('webstir-frontend')
-    .description('Webstir frontend build orchestrator');
+program.name('webstir-frontend').description('Webstir frontend build orchestrator');
 program
     .command('build')
     .description('Build frontend assets for development workflows')
@@ -15,7 +12,7 @@ program
     try {
         await runBuild({
             workspaceRoot: cmd.workspace,
-            changedFile: cmd.changedFile ?? undefined
+            changedFile: cmd.changedFile ?? undefined,
         });
     }
     catch (error) {
@@ -31,7 +28,7 @@ program
     try {
         await runPublish({
             workspaceRoot: cmd.workspace,
-            publishMode: cmd.mode === 'ssg' ? 'ssg' : 'bundle'
+            publishMode: cmd.mode === 'ssg' ? 'ssg' : 'bundle',
         });
     }
     catch (error) {
@@ -47,7 +44,7 @@ program
     try {
         await runRebuild({
             workspaceRoot: cmd.workspace,
-            changedFile: cmd.changedFile ?? undefined
+            changedFile: cmd.changedFile ?? undefined,
         });
     }
     catch (error) {
@@ -65,29 +62,8 @@ program
         await runAddPage({
             workspaceRoot: cmd.workspace,
             pageName: name,
-            ssg: rawMode === 'ssg' ? true : rawMode === 'standard' ? false : undefined
-        });
-    }
-    catch (error) {
-        handleError(error);
-    }
-});
-program
-    .command('watch-daemon')
-    .description('Run the persistent frontend watch daemon')
-    .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
-    .option('--no-auto-start', 'Defer startup until a start command is received')
-    .option('-v, --verbose', 'Enable verbose watch diagnostics')
-    .option('--hmr-verbose', 'Log detailed hot-update diagnostics')
-    .action(async (cmd) => {
-    try {
-        const daemon = new WatchDaemon({
-            workspaceRoot: cmd.workspace,
-            autoStart: cmd.autoStart,
-            verbose: cmd.verbose === true,
-            hmrVerbose: cmd.hmrVerbose === true
+            ssg: rawMode === 'ssg' ? true : rawMode === 'standard' ? false : undefined,
         });
-        await daemon.run();
     }
     catch (error) {
         handleError(error);

package/dist/config/manifest.js

@@ -1,17 +1,18 @@
-import { promises as fs } from 'fs';
-import path from 'path';
+import { rename } from 'node:fs/promises';
+import path from 'node:path';
 import { frontendConfigSchema } from './schema.js';
+import { ensureDir, readFile, writeFile } from '../utils/fs.js';
 export async function writeConfigManifest(options) {
     const parsed = frontendConfigSchema.parse(options.data);
     const directory = path.dirname(options.outputPath);
-    await fs.mkdir(directory, { recursive: true });
+    await ensureDir(directory);
     const serialized = JSON.stringify(parsed, undefined, 2);
     const tempPath = path.join(directory, `.webstir-frontend-${process.pid}-${Date.now()}.tmp`);
-    await fs.writeFile(tempPath, serialized, 'utf8');
-    await fs.rename(tempPath, options.outputPath);
+    await writeFile(tempPath, serialized);
+    await rename(tempPath, options.outputPath);
 }
 export async function readConfigManifest(manifestPath) {
-    const json = await fs.readFile(manifestPath, 'utf8');
+    const json = await readFile(manifestPath);
     const parsed = JSON.parse(json);
     return frontendConfigSchema.parse(parsed);
 }

package/dist/config/paths.js

@@ -1,5 +1,5 @@
-import path from 'path';
-import { promises as fs } from 'fs';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
 import { FOLDERS } from '../core/constants.js';
 export const FRONTEND_MANIFEST_FILENAME = 'frontend-manifest.json';
 export function resolveManifestPath(workspaceRoot) {

package/dist/config/schema.d.ts

@@ -152,14 +152,17 @@ export declare const frontendPathSchema: z.ZodObject<{
 }>;
 export declare const frontendFeatureFlagsSchema: z.ZodObject<{
     htmlSecurity: z.ZodDefault<z.ZodBoolean>;
+    externalResourceIntegrity: z.ZodDefault<z.ZodBoolean>;
     imageOptimization: z.ZodDefault<z.ZodBoolean>;
     precompression: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     htmlSecurity: boolean;
+    externalResourceIntegrity: boolean;
     imageOptimization: boolean;
     precompression: boolean;
 }, {
     htmlSecurity?: boolean | undefined;
+    externalResourceIntegrity?: boolean | undefined;
     imageOptimization?: boolean | undefined;
     precompression?: boolean | undefined;
 }>;
@@ -318,20 +321,24 @@ export declare const frontendConfigSchema: z.ZodObject<{
     }>;
     features: z.ZodObject<{
         htmlSecurity: z.ZodDefault<z.ZodBoolean>;
+        externalResourceIntegrity: z.ZodDefault<z.ZodBoolean>;
         imageOptimization: z.ZodDefault<z.ZodBoolean>;
         precompression: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         htmlSecurity: boolean;
+        externalResourceIntegrity: boolean;
         imageOptimization: boolean;
         precompression: boolean;
     }, {
         htmlSecurity?: boolean | undefined;
+        externalResourceIntegrity?: boolean | undefined;
         imageOptimization?: boolean | undefined;
         precompression?: boolean | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     features: {
         htmlSecurity: boolean;
+        externalResourceIntegrity: boolean;
         imageOptimization: boolean;
         precompression: boolean;
     };
@@ -372,6 +379,7 @@ export declare const frontendConfigSchema: z.ZodObject<{
 }, {
     features: {
         htmlSecurity?: boolean | undefined;
+        externalResourceIntegrity?: boolean | undefined;
         imageOptimization?: boolean | undefined;
         precompression?: boolean | undefined;
     };