@webstir-io/webstir-frontend 0.1.40

package/dist/utils/changedFile.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+export function shouldProcess(context, rules) {
+    const changed = context.changedFile;
+    if (!changed) {
+        return true;
+    }
+    const normalizedChanged = path.resolve(changed);
+    for (const rule of rules) {
+        const normalizedDir = path.resolve(rule.directory);
+        if (!isPathInside(normalizedChanged, normalizedDir)) {
+            continue;
+        }
+        if (!rule.extensions || rule.extensions.length === 0) {
+            return true;
+        }
+        const extension = path.extname(normalizedChanged).toLowerCase();
+        if (rule.extensions.includes(extension)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isPathInside(target, directory) {
+    const relative = path.relative(directory, target);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,11 @@
+import fs from 'fs-extra';
+export declare function ensureDir(path: string): Promise<void>;
+export declare function emptyDir(path: string): Promise<void>;
+export declare function remove(path: string): Promise<void>;
+export declare function copy(source: string, destination: string): Promise<void>;
+export declare function pathExists(path: string): Promise<boolean>;
+export declare function stat(path: string): Promise<fs.Stats>;
+export declare function readJson<T>(path: string): Promise<T | null>;
+export declare function writeJson(path: string, data: unknown): Promise<void>;
+export declare function readFile(path: string): Promise<string>;
+export declare function writeFile(path: string, contents: string): Promise<void>;

package/dist/utils/fs.js

@@ -0,0 +1,39 @@
+import fs from 'fs-extra';
+export async function ensureDir(path) {
+    await fs.ensureDir(path);
+}
+export async function emptyDir(path) {
+    await fs.emptyDir(path);
+}
+export async function remove(path) {
+    await fs.remove(path);
+}
+export async function copy(source, destination) {
+    await fs.copy(source, destination, { overwrite: true, errorOnExist: false });
+}
+export async function pathExists(path) {
+    return fs.pathExists(path);
+}
+export async function stat(path) {
+    return fs.stat(path);
+}
+export async function readJson(path) {
+    try {
+        return await fs.readJson(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeJson(path, data) {
+    await fs.writeJson(path, data, { spaces: 2 });
+}
+export async function readFile(path) {
+    return fs.readFile(path, 'utf8');
+}
+export async function writeFile(path, contents) {
+    await fs.outputFile(path, contents, 'utf8');
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashContent(content: string, length?: number): string;

package/dist/utils/hash.js

@@ -0,0 +1,5 @@
+import { createHash } from 'node:crypto';
+export function hashContent(content, length = 8) {
+    const hash = createHash('sha256').update(content).digest('hex');
+    return hash.slice(0, length);
+}

package/dist/utils/pagePaths.d.ts

@@ -0,0 +1,5 @@
+export declare function resolvePagesUrlPrefix(frontendRoot: string, pagesRoot: string): string;
+export declare function isRootPagesLayout(frontendRoot: string, pagesRoot: string): boolean;
+export declare function resolvePageAssetUrl(pagesUrlPrefix: string, pageName: string, fileName: string): string;
+export declare function resolvePageHtmlUrl(pagesUrlPrefix: string, pageName: string, useRootIndex: boolean): string;
+export declare function resolvePageHtmlDir(pagesRoot: string, pageName: string, useRootIndex: boolean): string;

package/dist/utils/pagePaths.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { FOLDERS, FILES } from '../core/constants.js';
+export function resolvePagesUrlPrefix(frontendRoot, pagesRoot) {
+    const relative = path.relative(frontendRoot, pagesRoot).replace(/\\/g, '/');
+    if (!relative || relative === '.' || relative.startsWith('..')) {
+        return '';
+    }
+    return `/${trimSlashes(relative)}`;
+}
+export function isRootPagesLayout(frontendRoot, pagesRoot) {
+    return resolvePagesUrlPrefix(frontendRoot, pagesRoot) === '';
+}
+export function resolvePageAssetUrl(pagesUrlPrefix, pageName, fileName) {
+    return joinUrl(pagesUrlPrefix, pageName, fileName);
+}
+export function resolvePageHtmlUrl(pagesUrlPrefix, pageName, useRootIndex) {
+    if (useRootIndex && pageName === FOLDERS.home) {
+        return `/${FILES.indexHtml}`;
+    }
+    return joinUrl(pagesUrlPrefix, pageName, FILES.indexHtml);
+}
+export function resolvePageHtmlDir(pagesRoot, pageName, useRootIndex) {
+    if (useRootIndex && pageName === FOLDERS.home) {
+        return pagesRoot;
+    }
+    return path.join(pagesRoot, pageName);
+}
+function joinUrl(...segments) {
+    const cleaned = segments
+        .map(segment => trimSlashes(segment))
+        .filter(segment => segment.length > 0);
+    return `/${cleaned.join('/')}`;
+}
+function trimSlashes(value) {
+    return value.replace(/^\/+|\/+$/g, '');
+}

package/dist/utils/pathMatch.d.ts

@@ -0,0 +1,3 @@
+export declare function isInsideDirectory(filePath: string, directory: string): boolean;
+export declare function findPageFromChangedFile(changedFile: string | undefined, pagesRoot: string): string | null;
+export declare function relativePathWithin(filePath: string | undefined, directory: string): string | null;

package/dist/utils/pathMatch.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+export function isInsideDirectory(filePath, directory) {
+    const resolvedFile = path.resolve(filePath);
+    const resolvedDirectory = path.resolve(directory);
+    const relative = path.relative(resolvedDirectory, resolvedFile);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+export function findPageFromChangedFile(changedFile, pagesRoot) {
+    if (!changedFile) {
+        return null;
+    }
+    const resolvedChanged = path.resolve(changedFile);
+    const resolvedPagesRoot = path.resolve(pagesRoot);
+    if (!isInsideDirectory(resolvedChanged, resolvedPagesRoot)) {
+        return null;
+    }
+    const relative = path.relative(resolvedPagesRoot, resolvedChanged);
+    const segments = relative.split(path.sep);
+    return segments.length > 0 && segments[0] ? segments[0] : null;
+}
+export function relativePathWithin(filePath, directory) {
+    if (!filePath) {
+        return null;
+    }
+    if (!isInsideDirectory(filePath, directory)) {
+        return null;
+    }
+    return path.relative(path.resolve(directory), path.resolve(filePath));
+}

package/dist/watch/frontendFiles.d.ts

@@ -0,0 +1,3 @@
+import type { EnableFlags, FrontendConfig } from '../types.js';
+export declare function resolveEntryPoint(pageDirectory: string): Promise<string | null>;
+export declare function copyRefreshScript(config: FrontendConfig, enable?: EnableFlags): Promise<void>;

package/dist/watch/frontendFiles.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { ensureDir, pathExists, copy } from '../utils/fs.js';
+import { FILES, EXTENSIONS } from '../core/constants.js';
+export async function resolveEntryPoint(pageDirectory) {
+    const candidates = [`${FILES.index}${EXTENSIONS.ts}`, `${FILES.index}.tsx`, `${FILES.index}${EXTENSIONS.js}`, `${FILES.index}.jsx`];
+    for (const candidate of candidates) {
+        const file = path.join(pageDirectory, candidate);
+        if (await pathExists(file)) {
+            return file;
+        }
+    }
+    return null;
+}
+export async function copyRefreshScript(config, enable) {
+    const runtimeScripts = [FILES.refreshJs, FILES.hmrJs];
+    for (const scriptName of runtimeScripts) {
+        const source = path.join(config.paths.src.app, scriptName);
+        if (!(await pathExists(source))) {
+            continue;
+        }
+        const destination = path.join(config.paths.build.frontend, scriptName);
+        await ensureDir(path.dirname(destination));
+        await copy(source, destination);
+    }
+}

package/dist/watch/hotUpdateTracker.d.ts

@@ -0,0 +1,51 @@
+import type { BuildResult } from 'esbuild';
+import type { FrontendConfig } from '../types.js';
+import type { BuilderContext } from '../builders/types.js';
+export interface HotAsset {
+    readonly type: 'js' | 'css';
+    readonly path: string;
+    readonly relativePath: string;
+    readonly url: string;
+}
+export interface HotUpdateDetails {
+    readonly modules: readonly HotAsset[];
+    readonly styles: readonly HotAsset[];
+    readonly requiresReload: boolean;
+    readonly fallbackReasons: readonly string[];
+    readonly changedFile?: string;
+    readonly stats?: HotUpdateStats;
+}
+export interface HotUpdateStats {
+    readonly hotUpdates: number;
+    readonly reloadFallbacks: number;
+}
+interface ProcessJavaScriptResult {
+    readonly modules: readonly HotAsset[];
+    readonly requiresReload: boolean;
+    readonly fallbackReasons: readonly string[];
+}
+interface CollectCssResult {
+    readonly styles: readonly HotAsset[];
+    readonly requiresReload: boolean;
+    readonly fallbackReasons: readonly string[];
+}
+interface HotUpdateTrackerOptions {
+    readonly workspaceRoot: string;
+}
+export declare class HotUpdateTracker {
+    private readonly workspaceRoot;
+    private readonly pageOutputHashes;
+    private readonly assetFingerprints;
+    constructor(options: HotUpdateTrackerOptions);
+    reset(): void;
+    removePage(pageName: string): void;
+    processJavaScriptResult(pageName: string, result: BuildResult, config: FrontendConfig): Promise<ProcessJavaScriptResult>;
+    collectCssChanges(context: BuilderContext, pageNames: readonly string[]): Promise<CollectCssResult>;
+    private computeAssetFingerprint;
+    private getPageCssOutputPath;
+    private getAppCssOutputPath;
+    private createHotAsset;
+    private resolveOutputPath;
+    private toWebPath;
+}
+export {};

package/dist/watch/hotUpdateTracker.js

@@ -0,0 +1,205 @@
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { FOLDERS, FILES, EXTENSIONS } from '../core/constants.js';
+import { emitDiagnostic } from '../core/diagnostics.js';
+import { pathExists } from '../utils/fs.js';
+import { isPathInside } from '../utils/changedFile.js';
+import { findPageFromChangedFile } from '../utils/pathMatch.js';
+export class HotUpdateTracker {
+    workspaceRoot;
+    pageOutputHashes = new Map();
+    assetFingerprints = new Map();
+    constructor(options) {
+        this.workspaceRoot = options.workspaceRoot;
+    }
+    reset() {
+        this.pageOutputHashes.clear();
+        this.assetFingerprints.clear();
+    }
+    removePage(pageName) {
+        this.pageOutputHashes.delete(pageName);
+    }
+    async processJavaScriptResult(pageName, result, config) {
+        const modules = [];
+        let requiresReload = false;
+        const fallbackReasons = [];
+        const metafile = result.metafile;
+        if (!metafile) {
+            fallbackReasons.push('javascript.metafile.missing');
+            return { modules, requiresReload: true, fallbackReasons };
+        }
+        const buildRoot = config.paths.build.frontend;
+        const currentOutputs = new Set();
+        const previousOutputs = this.pageOutputHashes.get(pageName) ?? new Map();
+        for (const outputPath of Object.keys(metafile.outputs)) {
+            const extension = path.extname(outputPath).toLowerCase();
+            if (extension !== EXTENSIONS.js && extension !== '.mjs') {
+                continue;
+            }
+            const absoluteOutput = this.resolveOutputPath(outputPath);
+            currentOutputs.add(absoluteOutput);
+            const fingerprint = await this.computeAssetFingerprint(absoluteOutput, buildRoot, 'js');
+            if (!fingerprint) {
+                if (this.assetFingerprints.has(absoluteOutput)) {
+                    this.assetFingerprints.delete(absoluteOutput);
+                }
+                if (previousOutputs.has(absoluteOutput)) {
+                    previousOutputs.delete(absoluteOutput);
+                    requiresReload = true;
+                    fallbackReasons.push('javascript.output.missing');
+                }
+                continue;
+            }
+            if (fingerprint.requiresReload) {
+                requiresReload = true;
+                fallbackReasons.push('javascript.fingerprint.error');
+            }
+            if (fingerprint.changed) {
+                modules.push(fingerprint.asset);
+            }
+            if (fingerprint.hash) {
+                previousOutputs.set(absoluteOutput, { hash: fingerprint.hash });
+            }
+            else if (previousOutputs.has(absoluteOutput)) {
+                previousOutputs.delete(absoluteOutput);
+            }
+        }
+        for (const known of Array.from(previousOutputs.keys())) {
+            if (!currentOutputs.has(known)) {
+                previousOutputs.delete(known);
+                requiresReload = true;
+                fallbackReasons.push('javascript.output.removed');
+            }
+        }
+        this.pageOutputHashes.set(pageName, previousOutputs);
+        return { modules, requiresReload, fallbackReasons: uniqueReasons(fallbackReasons) };
+    }
+    async collectCssChanges(context, pageNames) {
+        const { config, changedFile } = context;
+        const buildRoot = config.paths.build.frontend;
+        const candidates = new Set();
+        if (!changedFile) {
+            for (const page of pageNames) {
+                candidates.add(this.getPageCssOutputPath(config, page));
+            }
+            candidates.add(this.getAppCssOutputPath(config));
+        }
+        else {
+            const normalized = path.resolve(changedFile);
+            const extension = path.extname(normalized).toLowerCase();
+            if (extension === EXTENSIONS.css) {
+                if (isPathInside(normalized, config.paths.src.app)) {
+                    for (const page of pageNames) {
+                        candidates.add(this.getPageCssOutputPath(config, page));
+                    }
+                    candidates.add(this.getAppCssOutputPath(config));
+                }
+                else if (isPathInside(normalized, config.paths.src.pages)) {
+                    const page = findPageFromChangedFile(normalized, config.paths.src.pages);
+                    if (page) {
+                        candidates.add(this.getPageCssOutputPath(config, page));
+                    }
+                }
+                else if (isPathInside(normalized, config.paths.src.frontend)) {
+                    for (const page of pageNames) {
+                        candidates.add(this.getPageCssOutputPath(config, page));
+                    }
+                    candidates.add(this.getAppCssOutputPath(config));
+                }
+            }
+        }
+        if (candidates.size === 0 && !changedFile) {
+            candidates.add(this.getAppCssOutputPath(config));
+            for (const page of pageNames) {
+                candidates.add(this.getPageCssOutputPath(config, page));
+            }
+        }
+        const styles = [];
+        let requiresReload = !changedFile;
+        const fallbackReasons = [];
+        if (!changedFile) {
+            fallbackReasons.push('css.full-rebuild');
+        }
+        for (const candidate of candidates) {
+            const fingerprint = await this.computeAssetFingerprint(candidate, buildRoot, 'css');
+            if (!fingerprint) {
+                if (this.assetFingerprints.has(path.resolve(candidate))) {
+                    this.assetFingerprints.delete(path.resolve(candidate));
+                    requiresReload = true;
+                    fallbackReasons.push('css.asset.missing');
+                }
+                continue;
+            }
+            if (fingerprint.requiresReload) {
+                requiresReload = true;
+                fallbackReasons.push('css.fingerprint.error');
+            }
+            if (fingerprint.changed) {
+                styles.push(fingerprint.asset);
+            }
+        }
+        return { styles, requiresReload, fallbackReasons: uniqueReasons(fallbackReasons) };
+    }
+    async computeAssetFingerprint(filePath, buildRoot, type) {
+        const absolutePath = path.resolve(filePath);
+        if (!(await pathExists(absolutePath))) {
+            return null;
+        }
+        try {
+            const contents = await readFile(absolutePath);
+            const hash = createHash('sha1').update(contents).digest('hex');
+            const previous = this.assetFingerprints.get(absolutePath);
+            const changed = previous !== hash;
+            this.assetFingerprints.set(absolutePath, hash);
+            return {
+                asset: this.createHotAsset(absolutePath, buildRoot, type),
+                changed,
+                requiresReload: false,
+                hash
+            };
+        }
+        catch (error) {
+            emitDiagnostic({
+                code: 'frontend.watch.unexpected',
+                kind: 'watch-daemon',
+                stage: 'css-fingerprint',
+                severity: 'error',
+                message: `Failed to fingerprint asset '${absolutePath}': ${error instanceof Error ? error.message : String(error)}`
+            });
+            return {
+                asset: this.createHotAsset(absolutePath, buildRoot, type),
+                changed: false,
+                requiresReload: true
+            };
+        }
+    }
+    getPageCssOutputPath(config, pageName) {
+        return path.join(config.paths.build.frontend, FOLDERS.pages, pageName, `${FILES.index}${EXTENSIONS.css}`);
+    }
+    getAppCssOutputPath(config) {
+        return path.join(config.paths.build.frontend, FOLDERS.app, 'app.css');
+    }
+    createHotAsset(filePath, buildRoot, type) {
+        const relativePath = path.relative(buildRoot, filePath);
+        const webPath = this.toWebPath(relativePath);
+        return {
+            type,
+            path: filePath,
+            relativePath,
+            url: webPath.startsWith('/') ? webPath : `/${webPath}`
+        };
+    }
+    resolveOutputPath(outputPath) {
+        if (path.isAbsolute(outputPath)) {
+            return outputPath;
+        }
+        return path.resolve(this.workspaceRoot, outputPath);
+    }
+    toWebPath(relativePath) {
+        return relativePath.split(path.sep).join('/') || '';
+    }
+}
+function uniqueReasons(reasons) {
+    return Array.from(new Set(reasons.filter(Boolean)));
+}

package/dist/watch/pipelineHelpers.d.ts

@@ -0,0 +1,26 @@
+import type { Builder, BuilderContext } from '../builders/types.js';
+import { WatchReporter, type SerializedMessage } from './watchReporter.js';
+import type { HotAsset, HotUpdateDetails } from './hotUpdateTracker.js';
+export interface JavaScriptBuildSummary {
+    readonly pagesBuilt: readonly string[];
+    readonly warnings: readonly SerializedMessage[];
+    readonly modules: readonly HotAsset[];
+    readonly requiresReload: boolean;
+    readonly fallbackReasons: readonly string[];
+}
+export interface AdditionalBuildResult {
+    readonly succeeded: boolean;
+    readonly assets: readonly string[];
+    readonly styles: readonly HotAsset[];
+    readonly requiresReload: boolean;
+    readonly fallbackReasons: readonly string[];
+}
+export declare function runBuilderWithDiagnostics(builder: Builder, reporter: WatchReporter, context: BuilderContext, changedFile: string | undefined, relativeChange: string | undefined): Promise<boolean>;
+export declare function emitPipelineSuccess(summary: JavaScriptBuildSummary, assetsResult: AdditionalBuildResult, changedFile: string | undefined, relativeChange: string | undefined, hotUpdate: HotUpdateDetails): void;
+export declare function serializeSummary(summary: JavaScriptBuildSummary, changedFile: string | undefined, skipped: boolean): Record<string, unknown>;
+export declare function emitJavaScriptFailure(error: unknown, changedFile?: string): void;
+export declare class JavaScriptBuildError extends Error {
+    readonly pageName: string;
+    readonly details: readonly SerializedMessage[];
+    constructor(pageName: string, cause: unknown);
+}

package/dist/watch/pipelineHelpers.js

@@ -0,0 +1,177 @@
+import { emitDiagnostic } from '../core/diagnostics.js';
+import { serializeMessages } from './watchReporter.js';
+const BUILDER_DISPLAY_NAMES = {
+    css: 'CSS',
+    html: 'HTML',
+    'static-assets': 'Static assets'
+};
+export async function runBuilderWithDiagnostics(builder, reporter, context, changedFile, relativeChange) {
+    const displayName = BUILDER_DISPLAY_NAMES[builder.name] ?? builder.name;
+    const messageContext = relativeChange ? ` (${relativeChange})` : '';
+    reporter.emitVerbose({
+        code: `frontend.watch.${builder.name}.build.start`,
+        kind: 'watch-daemon',
+        stage: builder.name,
+        severity: 'info',
+        message: `Starting ${displayName} rebuild${messageContext}.`,
+        data: changedFile ? { changedFile, builder: builder.name } : { builder: builder.name }
+    });
+    try {
+        await builder.build(context);
+        reporter.emitVerbose({
+            code: `frontend.watch.${builder.name}.build.success`,
+            kind: 'watch-daemon',
+            stage: builder.name,
+            severity: 'info',
+            message: `${displayName} rebuild completed${messageContext}.`,
+            data: changedFile ? { changedFile, builder: builder.name } : { builder: builder.name }
+        });
+        return true;
+    }
+    catch (error) {
+        const details = { builder: builder.name };
+        if (changedFile) {
+            details.changedFile = changedFile;
+        }
+        if (error instanceof Error) {
+            details.error = error.message;
+        }
+        else {
+            details.error = String(error);
+        }
+        emitDiagnostic({
+            code: `frontend.watch.${builder.name}.build.failure`,
+            kind: 'watch-daemon',
+            stage: builder.name,
+            severity: 'error',
+            message: `${displayName} rebuild failed${messageContext}.`,
+            data: details
+        });
+        return false;
+    }
+}
+export function emitPipelineSuccess(summary, assetsResult, changedFile, relativeChange, hotUpdate) {
+    const message = `Frontend rebuild pipeline completed${relativeChange ? ` (${relativeChange})` : ''}.`;
+    const data = {
+        pages: summary.pagesBuilt,
+        assets: assetsResult.assets,
+        hotUpdate: serializeHotUpdate(hotUpdate, relativeChange)
+    };
+    if (relativeChange) {
+        data.changedFile = relativeChange;
+    }
+    else if (changedFile) {
+        data.changedFile = changedFile;
+    }
+    if (summary.warnings.length > 0) {
+        data.javascriptWarnings = summary.warnings;
+    }
+    emitDiagnostic({
+        code: 'frontend.watch.pipeline.success',
+        kind: 'watch-daemon',
+        stage: 'pipeline',
+        severity: 'info',
+        message,
+        data
+    });
+}
+export function serializeSummary(summary, changedFile, skipped) {
+    const data = {
+        pages: summary.pagesBuilt
+    };
+    if (changedFile) {
+        data.changedFile = changedFile;
+    }
+    if (summary.warnings.length > 0) {
+        data.warnings = summary.warnings;
+    }
+    if (skipped) {
+        data.skipped = true;
+    }
+    if (summary.modules.length > 0) {
+        data.modules = summary.modules.map(asset => asset.url);
+    }
+    if (summary.requiresReload) {
+        data.requiresReload = true;
+    }
+    if (summary.fallbackReasons.length > 0) {
+        data.fallbackReasons = summary.fallbackReasons;
+    }
+    return data;
+}
+export function emitJavaScriptFailure(error, changedFile) {
+    let message = 'JavaScript rebuild failed.';
+    let severity = 'error';
+    const data = changedFile ? { changedFile } : {};
+    if (error instanceof JavaScriptBuildError) {
+        message = `JavaScript rebuild failed for page '${error.pageName}'.`;
+        if (error.details.length > 0) {
+            data.errors = error.details;
+        }
+    }
+    else if (error instanceof Error) {
+        message = `JavaScript rebuild failed: ${error.message}`;
+    }
+    emitDiagnostic({
+        code: 'frontend.watch.javascript.build.failure',
+        kind: 'watch-daemon',
+        stage: 'javascript',
+        severity,
+        message,
+        data: Object.keys(data).length > 0 ? data : undefined
+    });
+}
+export class JavaScriptBuildError extends Error {
+    pageName;
+    details;
+    constructor(pageName, cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        super(message);
+        this.pageName = pageName;
+        this.details = isBuildFailure(cause) ? serializeMessages(cause.errors ?? []) : [];
+    }
+}
+function serializeHotUpdate(hotUpdate, relativeChange) {
+    const data = {
+        requiresReload: hotUpdate.requiresReload,
+        modules: hotUpdate.modules.map(asset => serializeHotAsset(asset)),
+        styles: hotUpdate.styles.map(asset => serializeHotAsset(asset))
+    };
+    if (relativeChange) {
+        data.changedFile = relativeChange;
+    }
+    else if (hotUpdate.changedFile) {
+        data.changedFile = hotUpdate.changedFile;
+    }
+    if (hotUpdate.fallbackReasons.length > 0) {
+        data.fallbackReasons = hotUpdate.fallbackReasons;
+    }
+    if (hotUpdate.stats) {
+        data.stats = {
+            hotUpdates: hotUpdate.stats.hotUpdates,
+            reloadFallbacks: hotUpdate.stats.reloadFallbacks
+        };
+    }
+    return data;
+}
+function serializeHotAsset(asset) {
+    return {
+        type: asset.type,
+        path: asset.path,
+        relativePath: asset.relativePath,
+        url: asset.url
+    };
+}
+function isBuildFailure(error) {
+    if (typeof error !== 'object' || error === null) {
+        return false;
+    }
+    const candidate = error;
+    return Array.isArray(candidate.errors) && candidate.errors.every(isEsbuildMessage);
+}
+function isEsbuildMessage(candidate) {
+    if (typeof candidate !== 'object' || candidate === null) {
+        return false;
+    }
+    return typeof candidate.text === 'string';
+}