@bleedingdev/modern-js-runtime 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/esm/core/context/extensions.mjs

@@ -1,33 +0,0 @@
-const EXTENSIONS_SLOT = Symbol.for('@modern-js/runtime:context-extensions');
-function getStore(context) {
-    return context[EXTENSIONS_SLOT];
-}
-function ensureStore(context) {
-    const target = context;
-    const store = target[EXTENSIONS_SLOT] ?? new Map();
-    Object.defineProperty(target, EXTENSIONS_SLOT, {
-        configurable: true,
-        enumerable: true,
-        value: store
-    });
-    return store;
-}
-function stripRuntimeContextExtensions(context) {
-    delete context[EXTENSIONS_SLOT];
-}
-function createRuntimeContextExtension(id) {
-    const key = Symbol.for(`@modern-js/runtime:context-extension:${id}`);
-    return {
-        key,
-        get (context) {
-            return getStore(context)?.get(key);
-        },
-        set (context, value) {
-            ensureStore(context).set(key, value);
-        },
-        remove (context) {
-            getStore(context)?.delete(key);
-        }
-    };
-}
-export { createRuntimeContextExtension, stripRuntimeContextExtensions };

package/dist/esm/core/context/helmetContext.mjs

@@ -1,13 +0,0 @@
-import { createRuntimeContextExtension } from "./extensions.mjs";
-const helmetContextExtension = createRuntimeContextExtension('@modern-js/runtime:helmet-context');
-function getHelmetContext(context) {
-    return helmetContextExtension.get(context);
-}
-function ensureHelmetContext(context) {
-    const existing = helmetContextExtension.get(context);
-    if (void 0 !== existing) return existing;
-    const created = {};
-    helmetContextExtension.set(context, created);
-    return created;
-}
-export { ensureHelmetContext, getHelmetContext };

package/dist/esm/core/server/federatedCss.mjs

@@ -1,20 +0,0 @@
-import { escapeHtmlAttribute } from "@modern-js/runtime-extensions";
-import { attributesToString, hasStylesheetLink } from "./utils.mjs";
-const createFederatedCssLinks = (assets, options)=>{
-    if (void 0 === assets || 0 === assets.length) return '';
-    const seen = new Set(options.existingAssets || []);
-    const attributes = attributesToString(Object.fromEntries(Object.entries(options.attributes || {}).filter(([name])=>![
-            'href',
-            'rel'
-        ].includes(name.toLowerCase()))));
-    const links = [];
-    for (const asset of assets){
-        const href = escapeHtmlAttribute(asset);
-        if (!('' === asset || seen.has(asset) || hasStylesheetLink(options.template, asset) || hasStylesheetLink(options.template, href))) {
-            seen.add(asset);
-            links.push(`<link${attributes} href="${href}" rel="stylesheet" />`);
-        }
-    }
-    return links.join('');
-};
-export { createFederatedCssLinks };

package/dist/esm/core/server/scriptOrder.mjs

@@ -1,90 +0,0 @@
-import { getRouterMatchedRouteIds } from "../../router/runtime/lifecycle.mjs";
-import { CHUNK_JS_PLACEHOLDER } from "./constants.mjs";
-import { attributesToString, safeReplace } from "./utils.mjs";
-function getScriptTags(template) {
-    const scriptRegExp = /<script\b[^>]*\bsrc=(["'])(.*?)\1[^>]*><\/script>/g;
-    return Array.from(template.matchAll(scriptRegExp)).map((match)=>({
-            index: match.index ?? 0,
-            tag: match[0],
-            src: match[2]
-        }));
-}
-function getAssetBasename(src) {
-    const withoutQuery = src.split(/[?#]/)[0];
-    return withoutQuery.split('/').pop() || withoutQuery;
-}
-function isEntryScript(src, entryName, asyncEntry) {
-    const basename = getAssetBasename(src);
-    const prefix = asyncEntry ? `async-${entryName}` : entryName;
-    return basename === `${prefix}.js` || basename.startsWith(`${prefix}.`) || basename.startsWith(`${prefix}-`);
-}
-const dedupeByUrl = (chunks)=>{
-    const seen = new Set();
-    return chunks.filter((chunk)=>{
-        if (void 0 === chunk.url || '' === chunk.url || seen.has(chunk.url)) return false;
-        seen.add(chunk.url);
-        return true;
-    });
-};
-const isAsyncEntryScriptChunk = (chunk, entryName)=>{
-    if (void 0 === chunk.url || !chunk.url.endsWith('.js')) return false;
-    const asyncEntryName = `async-${entryName}`;
-    const filename = chunk.filename ?? chunk.url;
-    const basename = filename.split('/').pop() ?? filename;
-    return basename === `${asyncEntryName}.js` || basename.startsWith(`${asyncEntryName}.`) || basename.startsWith(`${asyncEntryName}-`);
-};
-function getRouteAssets(runtimeContext, routeManifest = runtimeContext.routeManifest) {
-    return routeManifest?.routeAssets;
-}
-function getMatchedRouteAssets(runtimeContext, routeManifest) {
-    const routeAssets = getRouteAssets(runtimeContext, routeManifest);
-    if (void 0 === routeAssets) return [];
-    const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
-    return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []);
-}
-function getMatchedRouteChunks(runtimeContext, routeManifest, routeAssetToChunk) {
-    if (void 0 === routeManifest) return [];
-    return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
-}
-const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
-    const asyncEntryScriptChunks = [];
-    const asyncEntryDependencyChunks = [];
-    for (const chunk of asyncEntryChunks)if (isAsyncEntryScriptChunk(chunk, entryName)) asyncEntryScriptChunks.push(chunk);
-    else asyncEntryDependencyChunks.push(chunk);
-    return dedupeByUrl([
-        ...asyncEntryDependencyChunks,
-        ...collectedChunks,
-        ...matchedRouteChunks,
-        ...asyncEntryScriptChunks
-    ]);
-};
-function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index') {
-    if ('' === scripts) return template;
-    const scriptTags = getScriptTags(template);
-    const target = scriptTags.find((match)=>isEntryScript(match.src, entryName, false)) ?? scriptTags.find((match)=>isEntryScript(match.src, entryName, true));
-    if (void 0 === target) return template;
-    return `${template.slice(0, target.index)}${scripts}${template.slice(target.index)}`;
-}
-function replaceChunkJsPlaceholder(template, scripts, entryName, placeholder = CHUNK_JS_PLACEHOLDER) {
-    if (!template.includes(placeholder)) return template;
-    if ('' === scripts) return safeReplace(template, placeholder, '');
-    const withoutPlaceholder = safeReplace(template, placeholder, '');
-    const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, scripts, entryName);
-    if (withEarlyScripts !== withoutPlaceholder) return withEarlyScripts;
-    return safeReplace(template, placeholder, scripts);
-}
-function createRouteHydrationScriptTags(runtimeContext, entryName, options = {}) {
-    const { nonce, template } = options;
-    const routeAssets = getRouteAssets(runtimeContext);
-    if (void 0 === routeAssets) return '';
-    const existingScriptSrcs = void 0 === template ? new Set() : new Set(getScriptTags(template).map(({ src })=>src));
-    const jsAssets = Array.from(new Set([
-        ...getMatchedRouteAssets(runtimeContext),
-        ...routeAssets[`async-${entryName}`]?.assets ?? []
-    ].filter((asset)=>asset.endsWith('.js'))));
-    return jsAssets.filter((asset)=>!existingScriptSrcs.has(asset)).map((asset)=>`<script${attributesToString({
-            src: asset,
-            nonce: nonce || void 0
-        })}></script>`).join(' ');
-}
-export { createRouteHydrationScriptTags, getMatchedRouteChunks, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };

package/dist/esm/module-federation/consume-surface.mjs

@@ -1,158 +0,0 @@
-import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry } from "./index.mjs";
-import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "./surface-resolution-types.mjs";
-function classifyDiscoveryError(code) {
-    switch(code){
-        case 'major-not-published':
-        case 'stale-record':
-            return 'version-skew';
-        case 'identity-mismatch':
-            return 'contract';
-        case 'unknown-unit':
-        case 'unknown-surface':
-        case 'provider-unavailable':
-            return 'remote-unavailable';
-        default:
-            return 'remote-unavailable';
-    }
-}
-function toRemoteString(ref) {
-    return void 0 === validateSurfaceRef(ref) ? formatSurfaceRef(ref) : `${ref.unitId}#${ref.surfaceId}`;
-}
-async function reportFailure(options, ref, base) {
-    const remote = toRemoteString(ref);
-    const telemetry = createModuleFederationFallbackTelemetry({
-        appName: options.appName,
-        classification: base.classification,
-        error: base.error ?? base.discoveryError,
-        metadata: {
-            env: options.env,
-            surfaceRef: remote,
-            ...base.discoveryError ? {
-                discoveryErrorCode: base.discoveryError.code
-            } : {},
-            ...base.resolved ? {
-                buildMarker: base.resolved.buildMarker
-            } : {}
-        },
-        phase: base.phase,
-        remote,
-        status: 'degraded'
-    });
-    try {
-        await emitModuleFederationFallbackTelemetry({
-            appName: options.appName,
-            classification: base.classification,
-            error: base.error ?? base.discoveryError,
-            metadata: telemetry.metadata,
-            phase: base.phase,
-            remote,
-            status: 'degraded'
-        }, options.telemetry ?? {});
-    } catch  {}
-    const failure = {
-        ref,
-        env: options.env,
-        phase: base.phase,
-        classification: base.classification,
-        telemetry
-    };
-    if (base.discoveryError) failure.discoveryError = base.discoveryError;
-    if (void 0 !== base.error) failure.error = base.error;
-    if (base.resolved) failure.resolved = base.resolved;
-    const critical = (options.classification ?? 'critical') === 'critical';
-    const reason = base.discoveryError ?? (void 0 !== base.error ? base.error : createDiscoveryError('identity-mismatch', remote, `resolved record for "${remote}" is incompatible`, {
-        env: options.env
-    }));
-    let degradedValue;
-    try {
-        degradedValue = await options.degraded(failure);
-    } catch (handlerError) {
-        try {
-            await emitModuleFederationFallbackTelemetry({
-                appName: options.appName,
-                classification: base.classification,
-                error: handlerError,
-                metadata: {
-                    ...telemetry.metadata,
-                    degradedHandlerFailed: true
-                },
-                phase: base.phase,
-                remote,
-                status: 'failed'
-            }, options.telemetry ?? {});
-        } catch  {}
-        if (critical) throw reason;
-        return;
-    }
-    if (critical) throw reason;
-    return degradedValue;
-}
-async function consumeSurface(options) {
-    let ref;
-    if ('string' == typeof options.ref) {
-        const parsed = parseSurfaceRef(options.ref);
-        if (!parsed.ok) {
-            const hashIndex = options.ref.indexOf('#');
-            const echoed = -1 === hashIndex ? {
-                unitId: options.ref,
-                surfaceId: ''
-            } : {
-                unitId: options.ref.slice(0, hashIndex),
-                surfaceId: options.ref.slice(hashIndex + 1)
-            };
-            return reportFailure(options, echoed, {
-                phase: 'discovery',
-                classification: 'remote-unavailable',
-                discoveryError: createDiscoveryError('unknown-surface', options.ref, `SurfaceRef "${options.ref}" is not a valid canonical reference (${parsed.error.code}).`, {
-                    parseError: parsed.error,
-                    env: options.env
-                })
-            });
-        }
-        ref = parsed.ref;
-    } else ref = options.ref;
-    let resolution;
-    try {
-        resolution = await options.provider.resolve(ref, options.env);
-    } catch (error) {
-        return reportFailure(options, ref, {
-            phase: 'discovery',
-            classification: classifyModuleFederationFallback(error),
-            error
-        });
-    }
-    if (!resolution.ok) return reportFailure(options, ref, {
-        phase: 'discovery',
-        classification: classifyDiscoveryError(resolution.error.code),
-        discoveryError: resolution.error
-    });
-    const resolved = resolution.unit;
-    if ('incompatible' === resolved.compatibility.status) return reportFailure(options, ref, {
-        phase: 'discovery',
-        classification: 'contract',
-        resolved
-    });
-    try {
-        return await options.load({
-            resolved,
-            ref,
-            env: options.env
-        });
-    } catch (error) {
-        return reportFailure(options, ref, {
-            phase: 'load',
-            classification: classifyModuleFederationFallback(error),
-            error,
-            resolved
-        });
-    }
-}
-function createSurfaceConsumer(base) {
-    return function(options) {
-        return consumeSurface({
-            ...base,
-            ...options
-        });
-    };
-}
-export { consumeSurface, createSurfaceConsumer };

package/dist/esm/module-federation/distributed-ssr.mjs

@@ -1,82 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { useRuntimeContext } from "../core/context/runtime.mjs";
-const DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY = '__modernDistributedSsrFragments';
-const DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY = '__modernDistributedSsrFragmentRequest';
-function distributedSsrFragmentKey(remote, expose) {
-    return `${remote}::${expose}`;
-}
-function getDistributedSsrFragmentContext(response) {
-    const locals = response?.locals;
-    if ('object' != typeof locals || null === locals) return;
-    const context = DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY in locals ? locals[DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY] : void 0;
-    if ('object' != typeof context || null === context) return;
-    return context;
-}
-function useDistributedSsrFragmentProps({ boundaryId, expose }) {
-    const runtimeContext = useRuntimeContext();
-    const locals = runtimeContext.requestContext?.response?.locals;
-    const request = 'object' == typeof locals && null !== locals && DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY in locals ? locals[DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY] : void 0;
-    if ('object' != typeof request || null === request || !('boundaryId' in request) || request.boundaryId !== boundaryId || !('expose' in request) || request.expose !== expose) throw new Error(`Distributed SSR fragment request contract mismatch for ${boundaryId} ${expose}.`);
-    const props = 'props' in request ? request.props : void 0;
-    if ('object' != typeof props || null === props || Array.isArray(props)) throw new Error(`Distributed SSR fragment request props must be an object for ${boundaryId} ${expose}.`);
-    return props;
-}
-function isThenable(value) {
-    return void 0 !== value && 'then' in value && 'function' == typeof value.then;
-}
-function DistributedSsrBoundary({ children, expose, fallback, fragmentProps, remote }) {
-    const runtimeContext = useRuntimeContext();
-    const key = distributedSsrFragmentKey(remote, expose);
-    const attributes = {
-        'data-modern-distributed-ssr-boundary': key
-    };
-    if (runtimeContext.isBrowser) return /*#__PURE__*/ jsx("div", {
-        ...attributes,
-        children: children
-    });
-    const fragmentContext = getDistributedSsrFragmentContext(runtimeContext.requestContext?.response);
-    if (void 0 === fragmentContext) return /*#__PURE__*/ jsx("div", {
-        ...attributes,
-        children: children
-    });
-    const resolverFragmentProps = void 0 === fragmentProps ? {} : Object.fromEntries(Object.entries(fragmentProps));
-    const fragmentOrPromise = fragmentContext.resolve?.(remote, expose, resolverFragmentProps) ?? fragmentContext.fragments?.[key];
-    if (isThenable(fragmentOrPromise)) throw fragmentOrPromise;
-    const fragment = fragmentOrPromise;
-    if (fragment?.status === 'ready') return /*#__PURE__*/ jsx("div", {
-        ...attributes,
-        "data-modern-distributed-ssr-build": fragment.buildMarker,
-        "data-modern-distributed-ssr-digest": fragment.digest,
-        "data-modern-distributed-ssr-status": "ready",
-        dangerouslySetInnerHTML: {
-            __html: fragment.html
-        }
-    });
-    return /*#__PURE__*/ jsx("div", {
-        ...attributes,
-        "data-modern-distributed-ssr-reason": fragment?.reason ?? 'missing',
-        "data-modern-distributed-ssr-status": "degraded",
-        children: fallback
-    });
-}
-function createDistributedSsrComponent({ createComponent, expose, fallback, remote }) {
-    let RemoteComponent;
-    function DeferredRemoteComponent(props) {
-        RemoteComponent ??= createComponent();
-        return /*#__PURE__*/ jsx(RemoteComponent, {
-            ...props
-        });
-    }
-    return function(props) {
-        return /*#__PURE__*/ jsx(DistributedSsrBoundary, {
-            expose: expose,
-            fallback: fallback,
-            fragmentProps: props,
-            remote: remote,
-            children: /*#__PURE__*/ jsx(DeferredRemoteComponent, {
-                ...props
-            })
-        });
-    };
-}
-export { DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY, DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, DistributedSsrBoundary, createDistributedSsrComponent, distributedSsrFragmentKey, useDistributedSsrFragmentProps };

package/dist/esm/module-federation/index.mjs

@@ -1,115 +0,0 @@
-export * from "./consume-surface.mjs";
-export * from "./distributed-ssr.mjs";
-export * from "./last-known-good.mjs";
-export * from "./manifest-recovery-runtime-plugin.mjs";
-export * from "./surface-resolution-types.mjs";
-const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
-const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
-class ModuleFederationRemoteLoadTimeoutError extends Error {
-    constructor(remote, timeoutMs){
-        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
-        this.name = 'ModuleFederationRemoteLoadTimeoutError';
-    }
-}
-class ModuleFederationRemoteLoadError extends Error {
-    constructor(remote, attempts, causeError){
-        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
-        this.name = 'ModuleFederationRemoteLoadError';
-        this.remote = remote;
-        this.attempts = attempts;
-        this.causeError = causeError;
-    }
-}
-class ModuleFederationRemoteComponentContractError extends Error {
-    constructor(remote, exportName){
-        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
-        this.name = 'ModuleFederationRemoteComponentContractError';
-    }
-}
-function toError(error) {
-    if (error instanceof Error) return error;
-    return new Error('string' == typeof error ? error : 'Unknown remote load error');
-}
-function classifyModuleFederationFallback(error) {
-    const normalizedError = toError(error);
-    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
-    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
-    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
-    const message = normalizedError.message;
-    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
-    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
-    return 'remote-unavailable';
-}
-function createModuleFederationFallbackTelemetry(input) {
-    const error = void 0 !== input.error ? toError(input.error) : void 0;
-    const status = input.status ?? 'degraded';
-    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
-    const metadata = {
-        ...input.metadata ?? {},
-        classification: input.classification,
-        remote: input.remote,
-        status
-    };
-    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
-    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
-    if (void 0 !== error) {
-        metadata.errorName = error.name;
-        metadata.errorMessage = error.message;
-    }
-    const payload = {
-        appName: input.appName,
-        eventName,
-        metadata,
-        phase: input.phase,
-        reason: input.classification,
-        schemaVersion: 1
-    };
-    if (void 0 !== input.entry) payload.entry = input.entry;
-    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
-    return payload;
-}
-function toModuleFederationFallbackAttributes(payload) {
-    return {
-        'data-mf-fallback-app': payload.appName,
-        'data-mf-fallback-classification': payload.reason,
-        'data-mf-fallback-phase': payload.phase,
-        'data-mf-fallback-remote': String(payload.metadata.remote),
-        'data-mf-fallback-status': String(payload.metadata.status),
-        'data-mf-telemetry-event': payload.eventName
-    };
-}
-async function emitModuleFederationFallbackTelemetry(input, options = {}) {
-    const payload = createModuleFederationFallbackTelemetry(input);
-    if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) window.dispatchEvent(new CustomEvent(payload.eventName, {
-        detail: payload
-    }));
-    const shouldPost = true === options.postSignal || Boolean(options.endpoint);
-    if (!shouldPost) return {
-        dispatched: true,
-        posted: false
-    };
-    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-    if ('function' != typeof fetchImpl) return {
-        dispatched: true,
-        posted: false
-    };
-    const headers = new Headers({
-        'content-type': 'application/json'
-    });
-    if (void 0 !== options.authToken && options.authToken.length > 0) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
-    const response = await fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
-        body: JSON.stringify(payload),
-        headers,
-        method: 'POST',
-        keepalive: true
-    });
-    return {
-        dispatched: true,
-        posted: true,
-        postStatus: response.status
-    };
-}
-export { DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, useDistributedSsrFragmentProps } from "./distributed-ssr.mjs";
-export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };

package/dist/esm/module-federation/last-known-good.mjs

@@ -1,113 +0,0 @@
-import { selectResolvedSurface } from "@modern-js/utils/universal";
-import { createDiscoveryError, deliveryUnitResolutionKey } from "./surface-resolution-types.mjs";
-const LAST_KNOWN_GOOD_PROVIDER_NAME = 'last-known-good';
-function createInMemoryLkgStorage() {
-    const map = new Map();
-    return {
-        read (key) {
-            return map.get(key);
-        },
-        write (key, record) {
-            map.set(key, record);
-        }
-    };
-}
-function markDegraded(resolved, reason) {
-    return {
-        ...resolved,
-        compatibility: {
-            ...resolved.compatibility,
-            status: 'degraded',
-            reason
-        }
-    };
-}
-function staleRecordResult(ref, env, ageMs, maxStaleMs) {
-    return {
-        ok: false,
-        error: createDiscoveryError('stale-record', ref, `Last-known-good record for surface is stale: age ${ageMs}ms exceeds maxStaleMs ${maxStaleMs}ms`, {
-            env,
-            ageMs,
-            maxStaleMs
-        })
-    };
-}
-function resolutionAnswersRef(resolved, ref) {
-    const selected = selectResolvedSurface(resolved, ref);
-    return selected.ok && selected.surface.servedMajor === ref.major;
-}
-function createLastKnownGoodProvider(options) {
-    const storage = options.storage ?? createInMemoryLkgStorage();
-    const now = options.now ?? (()=>Math.floor(performance.timeOrigin + performance.now()));
-    const maxStaleMs = options.freshness?.maxStaleMs;
-    let nextResolutionGeneration = 0;
-    const latestCacheableGenerationByKey = new Map();
-    const writeTailByKey = new Map();
-    async function cacheCompatibleResolution(key, generation, record) {
-        latestCacheableGenerationByKey.set(key, Math.max(latestCacheableGenerationByKey.get(key) ?? 0, generation));
-        const previous = writeTailByKey.get(key) ?? Promise.resolve();
-        const write = previous.catch(()=>void 0).then(async ()=>{
-            if (latestCacheableGenerationByKey.get(key) !== generation) return;
-            await storage.write(key, record);
-        });
-        writeTailByKey.set(key, write);
-        try {
-            await write;
-        } finally{
-            if (writeTailByKey.get(key) === write) writeTailByKey.delete(key);
-        }
-    }
-    async function serveFromCache(ref, env, fallback) {
-        const key = deliveryUnitResolutionKey(ref.unitId, env);
-        const cached = await storage.read(key);
-        if (!cached) return fallback();
-        if (cached.major !== ref.major) return fallback();
-        if (!resolutionAnswersRef(cached.resolved, ref)) return fallback();
-        if ('compatible' !== cached.resolved.compatibility.status) return fallback();
-        const ageMs = now() - cached.storedAt;
-        if (void 0 !== maxStaleMs && ageMs > maxStaleMs) return staleRecordResult(ref, env, ageMs, maxStaleMs);
-        return {
-            ok: true,
-            unit: markDegraded(cached.resolved, `served last-known-good record (age ${ageMs}ms) after provider failure`)
-        };
-    }
-    return {
-        name: LAST_KNOWN_GOOD_PROVIDER_NAME,
-        async resolve (ref, env) {
-            const key = deliveryUnitResolutionKey(ref.unitId, env);
-            const generation = ++nextResolutionGeneration;
-            let resolution;
-            try {
-                resolution = await options.provider.resolve(ref, env);
-            } catch (error) {
-                return serveFromCache(ref, env, ()=>({
-                        ok: false,
-                        error: createDiscoveryError('provider-unavailable', ref, error instanceof Error ? error.message : 'provider threw a non-error value', {
-                            env,
-                            provider: options.provider.name
-                        })
-                    }));
-            }
-            if (!resolution.ok) {
-                const failure = resolution;
-                return serveFromCache(ref, env, ()=>failure);
-            }
-            if (!resolutionAnswersRef(resolution.unit, ref)) return serveFromCache(ref, env, ()=>({
-                    ok: false,
-                    error: createDiscoveryError('identity-mismatch', ref, `Provider ${options.provider.name} returned a delivery unit that does not answer the requested surface.`, {
-                        env,
-                        provider: options.provider.name,
-                        recordUnitId: resolution.unit.unitId,
-                        availableSurfaces: resolution.unit.surfaces.map((surface)=>surface.surfaceId)
-                    })
-                }));
-            if ('compatible' === resolution.unit.compatibility.status) await cacheCompatibleResolution(key, generation, {
-                resolved: resolution.unit,
-                storedAt: now(),
-                major: ref.major
-            });
-            return resolution;
-        }
-    };
-}
-export { LAST_KNOWN_GOOD_PROVIDER_NAME, createInMemoryLkgStorage, createLastKnownGoodProvider };