@bleedingdev/modern-js-server-core 3.2.0-ultramodern.0

package/dist/esm/adapters/node/plugins/static.mjs

@@ -0,0 +1,329 @@
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { fs } from "@modern-js/utils";
+import { getMimeType } from "hono/utils/mime";
+import path from "path";
+import { sortRoutes } from "../../../utils/index.mjs";
+import { getPublicDirPatterns } from "../../../utils/publicDir.mjs";
+const serverStaticPlugin = ()=>({
+        name: '@modern-js/plugin-server-static',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, distDirectory: pwd, routes } = api.getServerContext();
+                const config = api.getServerConfig();
+                const serverStaticMiddleware = createStaticMiddleware({
+                    pwd: pwd,
+                    routes,
+                    output: config.output || {},
+                    html: config.html || {},
+                    server: config.server || {}
+                });
+                middlewares.push({
+                    name: 'server-static',
+                    handler: serverStaticMiddleware
+                });
+            });
+        }
+    });
+const PRE_COMPRESSED_ASSET_EXTENSIONS = {
+    br: '.br',
+    gzip: '.gz'
+};
+const PRE_COMPRESSED_SUPPORTED_ENCODINGS = [
+    'br',
+    'gzip'
+];
+const parseAcceptEncoding = (value)=>value.split(',').map((item)=>item.trim()).filter(Boolean).map((item)=>{
+        const [rawName, ...params] = item.split(';');
+        const name = rawName.trim().toLowerCase();
+        let q = 1;
+        for (const param of params){
+            const [key, rawValue] = param.split('=').map((v)=>v.trim());
+            if ('q' !== key.toLowerCase() || null == rawValue) continue;
+            const parsedQ = Number(rawValue);
+            if (!Number.isNaN(parsedQ)) q = Math.max(0, Math.min(parsedQ, 1));
+        }
+        return {
+            name,
+            q
+        };
+    });
+const getAcceptedEncodings = (value)=>{
+    if (!value) return [];
+    const parsed = parseAcceptEncoding(value);
+    const qualityByEncoding = new Map();
+    let wildcardQuality;
+    for (const { name, q } of parsed){
+        if ('*' === name) {
+            wildcardQuality = q;
+            continue;
+        }
+        qualityByEncoding.set(name, q);
+    }
+    const getQuality = (encoding)=>{
+        const explicit = qualityByEncoding.get(encoding);
+        if (void 0 !== explicit) return explicit;
+        return wildcardQuality ?? 0;
+    };
+    return PRE_COMPRESSED_SUPPORTED_ENCODINGS.map((encoding)=>({
+            encoding,
+            quality: getQuality(encoding)
+        })).filter((item)=>item.quality > 0).sort((a, b)=>b.quality - a.quality).map((item)=>item.encoding);
+};
+const appendVaryHeader = (c, value)=>{
+    const current = c.res.headers.get('Vary');
+    if (!current) return void c.header('Vary', value);
+    const values = current.split(',').map((item)=>item.trim().toLowerCase()).filter(Boolean);
+    if (!values.includes(value.toLowerCase())) c.header('Vary', `${current}, ${value}`);
+};
+const resolvePreCompressedAsset = async (c, filepath)=>{
+    const brPath = `${filepath}${PRE_COMPRESSED_ASSET_EXTENSIONS.br}`;
+    const gzipPath = `${filepath}${PRE_COMPRESSED_ASSET_EXTENSIONS.gzip}`;
+    const [hasBr, hasGzip] = await Promise.all([
+        fs.pathExists(brPath),
+        fs.pathExists(gzipPath)
+    ]);
+    const hasVariant = hasBr || hasGzip;
+    if (!hasVariant) return {
+        selected: null,
+        hasVariant: false
+    };
+    const acceptedEncodings = getAcceptedEncodings(c.req.header('accept-encoding'));
+    for (const encoding of acceptedEncodings){
+        if ('br' === encoding && hasBr) return {
+            selected: {
+                filepath: brPath,
+                encoding
+            },
+            hasVariant: true
+        };
+        if ('gzip' === encoding && hasGzip) return {
+            selected: {
+                filepath: gzipPath,
+                encoding
+            },
+            hasVariant: true
+        };
+    }
+    return {
+        selected: null,
+        hasVariant: true
+    };
+};
+function createPublicMiddleware({ pwd, routes }) {
+    return async (c, next)=>{
+        const route = matchPublicRoute(c.req, routes);
+        if (route) {
+            const { entryPath } = route;
+            const originFilename = path.join(pwd, entryPath);
+            const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
+            const filename = preCompressedAsset.selected?.filepath ?? originFilename;
+            const data = await fileReader.readFile(filename, 'buffer');
+            const mimeType = getMimeType(originFilename);
+            if (null !== data) {
+                const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+                if (mimeType) c.header('Content-Type', mimeType);
+                Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+                    c.header(k, v);
+                });
+                if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
+                if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
+                c.header('Content-Length', String(data.byteLength));
+                return c.body(body, 200);
+            }
+        }
+        return await next();
+    };
+}
+function matchPublicRoute(req, routes) {
+    for (const route of routes.sort(sortRoutes))if (!route.isSSR && route.entryPath.startsWith('public') && req.path.startsWith(route.urlPath)) return route;
+}
+const extractPathname = (url)=>{
+    try {
+        if (url.includes('://')) return new URL(url).pathname || '/';
+        if (url.startsWith('//')) return new URL(`http:${url}`).pathname || '/';
+        return url;
+    } catch (e) {
+        return url;
+    }
+};
+const MODULE_FEDERATION_MANIFEST_FILE = 'mf-manifest.json';
+const MODULE_FEDERATION_OPTIONAL_FILES = [
+    'mf-stats.json'
+];
+const trimLeadingSlash = (value)=>value.replace(/^\/+/, '');
+const joinModuleFederationAssetPath = (assetPath, assetName)=>{
+    if (!assetName) return '';
+    return trimLeadingSlash(path.posix.join(assetPath || '', assetName));
+};
+const appendModuleFederationAsset = (set, assetPath)=>{
+    if (!assetPath) return;
+    set.add(trimLeadingSlash(assetPath));
+};
+const appendModuleFederationAssets = (set, assets)=>{
+    assets?.js?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
+    assets?.js?.async?.forEach((asset)=>appendModuleFederationAsset(set, asset));
+    assets?.css?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
+    assets?.css?.async?.forEach((asset)=>appendModuleFederationAsset(set, asset));
+};
+const hasAbsoluteProtocol = (value)=>/^https?:\/\//i.test(value) || value.startsWith('//');
+const ensureLeadingSlash = (value)=>{
+    if ('' === value) return '/';
+    return value.startsWith('/') ? value : `/${value}`;
+};
+const ensureTrailingSlash = (value)=>value.endsWith('/') ? value : `${value}/`;
+const patchModuleFederationManifestPublicPath = (c, manifestBuffer, pathPrefix)=>{
+    try {
+        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
+        const publicPath = manifest.metaData?.publicPath;
+        if (!publicPath || hasAbsoluteProtocol(publicPath)) return manifestBuffer;
+        const requestURL = new URL(c.req.url);
+        const prefixPath = ensureTrailingSlash(ensureLeadingSlash(pathPrefix || '/'));
+        manifest.metaData = {
+            ...manifest.metaData,
+            publicPath: `${requestURL.origin}${prefixPath}`
+        };
+        return Buffer.from(JSON.stringify(manifest), 'utf-8');
+    } catch  {
+        return manifestBuffer;
+    }
+};
+const patchModuleFederationRemoteEntryPublicPath = (c, remoteEntryBuffer, pathPrefix)=>{
+    const requestURL = new URL(c.req.url);
+    const prefixPath = ensureTrailingSlash(ensureLeadingSlash(pathPrefix || '/'));
+    const publicPath = `${requestURL.origin}${prefixPath}`;
+    const source = remoteEntryBuffer.toString('utf-8');
+    const patched = source.replace(/__webpack_require__\.p\s*=\s*(['"`])[^'"`]*\1;/, `__webpack_require__.p = ${JSON.stringify(publicPath)};`).replace(/__rspack_require__\.p\s*=\s*(['"`])[^'"`]*\1;/, `__rspack_require__.p = ${JSON.stringify(publicPath)};`);
+    if (patched === source) return remoteEntryBuffer;
+    return Buffer.from(patched, 'utf-8');
+};
+const getModuleFederationAssetList = async (pwd)=>{
+    const assets = new Set();
+    const manifestPath = path.join(pwd, MODULE_FEDERATION_MANIFEST_FILE);
+    if (!await fs.pathExists(manifestPath)) return {
+        assets,
+        remoteEntry: null
+    };
+    assets.add(MODULE_FEDERATION_MANIFEST_FILE);
+    const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
+    if (null === manifestBuffer) return {
+        assets,
+        remoteEntry: null
+    };
+    for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await fs.pathExists(path.join(pwd, filename))) assets.add(filename);
+    let remoteEntryFile = null;
+    try {
+        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
+        const remoteEntry = joinModuleFederationAssetPath(manifest.metaData?.remoteEntry?.path, manifest.metaData?.remoteEntry?.name);
+        const dtsZip = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.zip);
+        const dtsApi = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.api);
+        if (remoteEntry) {
+            assets.add(remoteEntry);
+            remoteEntryFile = remoteEntry;
+        }
+        if (dtsZip) assets.add(dtsZip);
+        if (dtsApi) assets.add(dtsApi);
+        manifest.shared?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+        manifest.remotes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+        manifest.exposes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+    } catch  {}
+    return {
+        assets,
+        remoteEntry: remoteEntryFile
+    };
+};
+function createStaticMiddleware(options) {
+    const { pwd, routes } = options;
+    const prefix = options.output.assetPrefix || '/';
+    const pathPrefix = extractPathname(prefix);
+    const { distPath: { css: cssPath, js: jsPath, media: mediaPath } = {} } = options.output;
+    const { favicon } = options.html;
+    const { publicDir } = options.server;
+    const favicons = prepareFavicons(favicon);
+    const staticFiles = [
+        cssPath,
+        jsPath,
+        mediaPath
+    ].filter((v)=>Boolean(v));
+    const publicDirPatterns = getPublicDirPatterns(publicDir);
+    const staticReg = [
+        'static/',
+        'upload/',
+        ...staticFiles,
+        ...publicDirPatterns
+    ];
+    const iconReg = [
+        'favicon.ico',
+        'icon.png',
+        ...favicons
+    ];
+    const regPrefix = pathPrefix.endsWith('/') ? pathPrefix : `${pathPrefix}/`;
+    const staticPathRegExp = new RegExp(`^${regPrefix}(${[
+        ...staticReg,
+        ...iconReg
+    ].join('|')})`);
+    const publicMiddleware = createPublicMiddleware({
+        pwd,
+        routes: routes || []
+    });
+    let moduleFederationAssetsPromise = null;
+    const getModuleFederationAssets = async ()=>{
+        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = getModuleFederationAssetList(pwd);
+        return moduleFederationAssetsPromise;
+    };
+    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
+        if (moduleFederationAsset) {
+            c.header('Access-Control-Allow-Origin', '*');
+            c.header('Access-Control-Allow-Headers', '*');
+            c.header('Access-Control-Allow-Methods', 'GET,HEAD,OPTIONS');
+        }
+        const mimeType = getMimeType(filepath);
+        if (mimeType) c.header('Content-Type', mimeType);
+        const shouldPatchManifest = moduleFederationAsset && requestPath === MODULE_FEDERATION_MANIFEST_FILE;
+        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
+        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
+        const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
+            selected: null,
+            hasVariant: false
+        };
+        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
+        const chunk = await fileReader.readFileFromSystem(targetFilepath, 'buffer');
+        if (null === chunk) return null;
+        const responseChunk = shouldPatchManifest ? patchModuleFederationManifestPublicPath(c, chunk, pathPrefix) : shouldPatchRemoteEntry ? patchModuleFederationRemoteEntryPublicPath(c, chunk, pathPrefix) : chunk;
+        if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
+        if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
+        c.header('Content-Length', String(responseChunk.byteLength));
+        const body = new Uint8Array(responseChunk.buffer, responseChunk.byteOffset, responseChunk.byteLength);
+        return c.body(body, 200);
+    };
+    return async (c, next)=>{
+        const pageRoute = c.get('route');
+        const pathname = c.req.path;
+        if (pageRoute && '' === path.extname(pathname)) return next();
+        const hit = staticPathRegExp.test(pathname);
+        const requestPath = trimLeadingSlash(pathname.replace(pathPrefix, ()=>''));
+        if (requestPath.includes('..')) return next();
+        const moduleFederationAssetMeta = await getModuleFederationAssets();
+        const isModuleFederationAsset = moduleFederationAssetMeta.assets.has(requestPath);
+        const isModuleFederationRemoteEntry = moduleFederationAssetMeta.remoteEntry === requestPath;
+        const serveByPath = async (filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
+            if (!await fs.pathExists(filepath)) return null;
+            return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, requestPath);
+        };
+        if (hit) {
+            const response = await serveByPath(path.join(pwd, requestPath), isModuleFederationAsset, isModuleFederationRemoteEntry);
+            if (null !== response) return response;
+            return next();
+        }
+        if (isModuleFederationAsset) {
+            const response = await serveByPath(path.join(pwd, requestPath), true, isModuleFederationRemoteEntry);
+            if (null !== response) return response;
+        }
+        return publicMiddleware(c, next);
+    };
+}
+const prepareFavicons = (favicon)=>{
+    const faviconNames = [];
+    if (favicon && 'string' == typeof favicon) faviconNames.push(favicon.substring(favicon.lastIndexOf('/') + 1));
+    return faviconNames;
+};
+export { createPublicMiddleware, createStaticMiddleware, serverStaticPlugin };

package/dist/esm/constants.mjs

@@ -0,0 +1,28 @@
+const AGGRED_DIR = {
+    mock: 'config/mock',
+    server: 'server',
+    api: 'api',
+    shared: 'shared',
+    lambda: 'lambda'
+};
+const REPLACE_REG = {
+    before: {
+        head: '<head\\b[^>]*>',
+        body: '<body\\b[^>]*>'
+    },
+    after: {
+        head: '</head>',
+        body: '</body>'
+    }
+};
+var constants_ServerTimings = /*#__PURE__*/ function(ServerTimings) {
+    ServerTimings["SERVER_HANDLE_REQUEST"] = "server-handle-request";
+    ServerTimings["SERVER_MIDDLEWARE"] = "server-middleware";
+    ServerTimings["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
+    ServerTimings["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
+    return ServerTimings;
+}({});
+const SERVER_TIMING = 'Server-Timing';
+const X_RENDER_CACHE = 'x-render-cache';
+const X_MODERNJS_RENDER = 'x-modernjs-render';
+export { AGGRED_DIR, REPLACE_REG, SERVER_TIMING, X_MODERNJS_RENDER, X_RENDER_CACHE, constants_ServerTimings as ServerTimings };

package/dist/esm/context.mjs

@@ -0,0 +1,4 @@
+import { createStorage } from "./utils/storage.mjs";
+const kHonoContextStorage = Symbol.for('modernjs.server-core.honoContextStorage');
+const { run: run, useContext: useHonoContext } = createStorage(kHonoContextStorage);
+export { run, useHonoContext };

package/dist/esm/helper.mjs

@@ -0,0 +1,11 @@
+const LOADER_CONTEXT = 'loaderContext';
+function getLoaderCtx(c) {
+    const loaderContext = c.get(LOADER_CONTEXT);
+    if (loaderContext) return loaderContext;
+    {
+        const loaderContext = new Map();
+        c.set(LOADER_CONTEXT, loaderContext);
+        return loaderContext;
+    }
+}
+export { getLoaderCtx };

package/dist/esm/hono.mjs

@@ -0,0 +1,2 @@
+export { deleteCookie, getCookie, setCookie } from "hono/cookie";
+export { languageDetector } from "hono/language";

package/dist/esm/index.mjs

@@ -0,0 +1,12 @@
+export * from "./plugins/index.mjs";
+export * from "./types/config/index.mjs";
+export * from "./types/plugins/index.mjs";
+export * from "./types/render.mjs";
+export * from "./types/requestHandler.mjs";
+export { Hono } from "hono";
+export { AGGRED_DIR } from "./constants.mjs";
+export { run, useHonoContext } from "./context.mjs";
+export { getLoaderCtx } from "./helper.mjs";
+export { createServerBase } from "./serverBase.mjs";
+export { ErrorDigest, createErrorHtml, onError } from "./utils/index.mjs";
+export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths } from "./utils/publicDir.mjs";

package/dist/esm/plugins/compat/hooks.mjs

@@ -0,0 +1,40 @@
+function getHookRunners(context) {
+    const { hooks } = context;
+    return {
+        config: (params)=>hooks.modifyConfig.call(params),
+        prepare: ()=>hooks.onPrepare.call(),
+        reset: (params)=>hooks.onReset.call(params),
+        fallback: (input)=>hooks.fallback.call(input),
+        prepareWebServer: (input)=>hooks.prepareWebServer.call(input),
+        prepareApiServer: (input)=>hooks.prepareApiServer.call(input),
+        afterMatch: (ctx)=>hooks.afterMatch.call(ctx),
+        afterRender: (ctx)=>hooks.afterRender.call(ctx),
+        afterStreamingRender: (ctx)=>hooks.afterStreamingRender.call(ctx)
+    };
+}
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'config':
+            return 'modifyConfig';
+        case 'prepare':
+            return 'onPrepare';
+        case 'reset':
+            return 'onReset';
+        default:
+            return hookRunnerName;
+    }
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = transformHookRunner(key);
+            if (api[newAPI]) api[newAPI]((...params)=>{
+                const res = fn(...params);
+                return res;
+            });
+        }
+    });
+}
+export { getHookRunners, handleSetupResult, transformHookRunner };

package/dist/esm/plugins/compat/index.mjs

@@ -0,0 +1,27 @@
+import { createAsyncHook, createAsyncPipelineHook } from "@modern-js/plugin";
+import { getHookRunners, handleSetupResult } from "./hooks.mjs";
+const compatPlugin = ()=>({
+        name: '@modern-js/server-compat',
+        registryHooks: {
+            fallback: createAsyncHook(),
+            prepareWebServer: createAsyncPipelineHook(),
+            prepareApiServer: createAsyncPipelineHook(),
+            afterMatch: createAsyncPipelineHook(),
+            afterRender: createAsyncPipelineHook(),
+            afterStreamingRender: createAsyncPipelineHook()
+        },
+        _registryApi: (getServerContext, updateServerContext)=>{
+            const getInternalContext = ()=>getServerContext()._internalContext;
+            return {
+                useConfigContext: ()=>getInternalContext().config,
+                useAppContext: ()=>{
+                    const { _internalContext, ...serverContext } = getServerContext();
+                    return serverContext;
+                },
+                setAppContext: (context)=>updateServerContext(context),
+                useHookRunners: ()=>getHookRunners(getInternalContext())
+            };
+        },
+        setup: ()=>{}
+    });
+export { compatPlugin, handleSetupResult };

package/dist/esm/plugins/contractGateAutopilot.mjs

@@ -0,0 +1,124 @@
+import { createFileContractGateSnapshotStore } from "./contractGateSnapshotStore.mjs";
+const DEFAULT_POLL_INTERVAL_MS = 15000;
+const DEFAULT_GATE_STALE_AFTER_MS = 600000;
+class ContractGateAutopilot {
+    async start() {
+        await this.syncOnce();
+        if (this.poller) return;
+        this.poller = setInterval(()=>{
+            this.syncOnce();
+        }, this.pollIntervalMs);
+        if ('function' == typeof this.poller.unref) this.poller.unref();
+    }
+    stop() {
+        if (this.poller) {
+            clearInterval(this.poller);
+            this.poller = void 0;
+        }
+    }
+    async syncOnce() {
+        const snapshot = await this.loadSnapshot();
+        if (!snapshot) return 0;
+        const gates = this.normalizeSnapshot(snapshot);
+        let updatedCount = 0;
+        for (const gate of gates){
+            this.orchestrator.addRequiredContractGate(gate.name);
+            const fingerprint = `${gate.passed ? '1' : '0'}:${gate.reason || ''}`;
+            if (this.appliedGateFingerprints.get(gate.name) !== fingerprint) {
+                this.orchestrator.setContractGate(gate.name, gate.passed, gate.reason);
+                this.appliedGateFingerprints.set(gate.name, fingerprint);
+                updatedCount += 1;
+                this.logger?.info?.(`[telemetry.canary.autopilot] gate=${gate.name} passed=${String(gate.passed)} reason=${gate.reason || 'none'}`);
+            }
+        }
+        return updatedCount;
+    }
+    async loadSnapshot() {
+        try {
+            const snapshot = await this.gateSnapshotStore.readSnapshot();
+            if (!snapshot) return;
+            const fingerprint = JSON.stringify(snapshot);
+            if (fingerprint === this.lastSnapshotFingerprint) return;
+            this.lastSnapshotFingerprint = fingerprint;
+            return snapshot;
+        } catch (error) {
+            const source = this.gateSnapshotPath || this.gateSnapshotStore.name || 'stateStore';
+            this.logger?.warn?.(`[telemetry.canary.autopilot] failed to load gate snapshot ${source}: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+    }
+    normalizeSnapshot(snapshot) {
+        const now = Date.now();
+        const output = [];
+        const gates = snapshot.gates;
+        if (!gates || 'object' != typeof gates) return output;
+        for (const [name, value] of Object.entries(gates)){
+            const normalizedName = name.trim();
+            if (!normalizedName) continue;
+            const gate = this.normalizeGateValue(value, snapshot.updatedAt, now);
+            if (!gate) continue;
+            if ('number' == typeof gate.expiresAt && Number.isFinite(gate.expiresAt) && gate.expiresAt > 0 && now >= gate.expiresAt) {
+                output.push({
+                    name: normalizedName,
+                    passed: true,
+                    reason: void 0,
+                    updatedAt: gate.updatedAt,
+                    expiresAt: gate.expiresAt
+                });
+                continue;
+            }
+            const isStale = this.gateStaleAfterMs > 0 && now - gate.updatedAt > this.gateStaleAfterMs;
+            if (isStale) {
+                output.push({
+                    name: normalizedName,
+                    passed: false,
+                    reason: gate.reason || 'Gate snapshot is stale',
+                    updatedAt: gate.updatedAt
+                });
+                continue;
+            }
+            output.push({
+                name: normalizedName,
+                passed: gate.passed,
+                reason: gate.reason,
+                updatedAt: gate.updatedAt
+            });
+        }
+        return output;
+    }
+    normalizeGateValue(value, snapshotUpdatedAt, now) {
+        if ('boolean' == typeof value) return {
+            passed: value,
+            updatedAt: this.normalizeUpdatedAt(snapshotUpdatedAt, now)
+        };
+        if (!value || 'object' != typeof value) return;
+        const hasPassed = 'boolean' == typeof value.passed;
+        const passed = true === value.passed;
+        let reason = 'string' == typeof value.reason && value.reason.trim().length > 0 ? value.reason : void 0;
+        if (!hasPassed) reason = reason || 'Gate snapshot record is missing "passed" boolean';
+        return {
+            passed,
+            reason,
+            updatedAt: this.normalizeUpdatedAt(value.updatedAt ?? snapshotUpdatedAt, now),
+            expiresAt: this.normalizeExpiresAt(value.expiresAt)
+        };
+    }
+    normalizeUpdatedAt(value, fallback) {
+        if ('number' == typeof value && Number.isFinite(value) && value > 0) return value;
+        return fallback;
+    }
+    normalizeExpiresAt(value) {
+        if ('number' == typeof value && Number.isFinite(value) && value > 0) return value;
+    }
+    constructor(options){
+        this.appliedGateFingerprints = new Map();
+        this.orchestrator = options.orchestrator;
+        if (!options.gateSnapshotStore && !options.gateSnapshotPath) throw new Error('ContractGateAutopilot requires gateSnapshotPath or gateSnapshotStore');
+        this.gateSnapshotPath = options.gateSnapshotPath;
+        this.gateSnapshotStore = options.gateSnapshotStore || createFileContractGateSnapshotStore(options.gateSnapshotPath);
+        this.pollIntervalMs = Math.max(250, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+        this.gateStaleAfterMs = Math.max(0, options.gateStaleAfterMs ?? DEFAULT_GATE_STALE_AFTER_MS);
+        this.logger = options.logger;
+    }
+}
+export { ContractGateAutopilot };