@bleedingdev/modern-js-renderer-solid 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/dist/esm-node/router-binding/publicMatchData.js

@@ -0,0 +1,447 @@
+import { DataProtocolError, assertPublicData, parsePublicData, serializePublicData } from "@modern-js/renderer-core/data";
+import { RouteDataError } from "@modern-js/renderer-core/router";
+import { getRequestEvent } from "@solidjs/web";
+import { projectRouteDataError } from "../route-data-error.js";
+const observed = new WeakMap();
+const snapshots = new WeakMap();
+const projectedPromises = new WeakSet();
+function requestFailureOwner(explicit) {
+    return explicit ?? getRequestEvent()?.locals.session;
+}
+function privateReferences(owner, contexts) {
+    const references = new WeakSet();
+    const event = getRequestEvent();
+    const identity = owner && "identity" in owner ? owner.identity : void 0;
+    let count = 0;
+    const visit = (value, depth)=>{
+        if (!value || "object" != typeof value && "function" != typeof value || value === identity) return;
+        if (++count > 2e4 || depth > 100) throw new DataProtocolError("Private request context exceeds its size or depth limit");
+        if (references.has(value)) return;
+        references.add(value);
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype === Map.prototype) for (const [key, entry] of Map.prototype.entries.call(value)){
+            visit(key, depth + 1);
+            visit(entry, depth + 1);
+        }
+        else if (prototype === Set.prototype) for (const entry of Set.prototype.values.call(value))visit(entry, depth + 1);
+        else if (prototype === Object.prototype || null === prototype || prototype === Array.prototype) for (const key of Reflect.ownKeys(value)){
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor.get && !descriptor.set) visit(descriptor.value, depth + 1);
+        }
+    };
+    if (owner) {
+        references.add(owner);
+        if ("request" in owner) visit(owner.request, 0);
+        if ("platform" in owner) visit(owner.platform, 0);
+    }
+    if (event) {
+        visit(event, 0);
+        visit(event.locals, 0);
+    }
+    for (const context of contexts)visit(context, 0);
+    return references;
+}
+function rejectPrivateReferences(value, references) {
+    const seen = new WeakSet();
+    let count = 0;
+    const visit = (current, depth)=>{
+        if (++count > 2e4 || depth > 100) throw new DataProtocolError("Public data exceeds its size or depth limit");
+        if (!current || "object" != typeof current) return;
+        if (references.has(current)) throw new DataProtocolError("Public data must not contain private request references");
+        if (seen.has(current)) return;
+        seen.add(current);
+        const prototype = Object.getPrototypeOf(current);
+        if (prototype === Promise.prototype) return;
+        for (const key of Reflect.ownKeys(current)){
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (!descriptor.get && !descriptor.set) visit(descriptor.value, depth + 1);
+        }
+        if (prototype === Map.prototype) for (const [key, entry] of Map.prototype.entries.call(current)){
+            visit(key, depth + 1);
+            visit(entry, depth + 1);
+        }
+        else if (prototype === Set.prototype) for (const entry of Set.prototype.values.call(current))visit(entry, depth + 1);
+    };
+    visit(value, 0);
+}
+function projectDeferred(promise, session, references) {
+    let promises = observed.get(session);
+    if (!promises) {
+        promises = new WeakMap();
+        observed.set(session, promises);
+    }
+    const previous = promises.get(promise);
+    if (previous) {
+        previous.scopes.push(references);
+        return previous.projection;
+    }
+    const scopes = [
+        references
+    ];
+    const owner = new WeakRef(session);
+    const project = (value)=>{
+        try {
+            for (const scope of scopes)rejectPrivateReferences(value, scope);
+            return immutableSnapshot(value, owner.deref());
+        } catch (error) {
+            owner.deref()?.fail(error);
+            throw Object.freeze({
+                name: "DataProtocolError",
+                message: "Invalid public deferred data"
+            });
+        }
+    };
+    const reject = (reason)=>{
+        let projected;
+        try {
+            for (const scope of scopes)rejectPrivateReferences(reason, scope);
+            projected = reason instanceof Error ? preparePublicMatchError(reason, owner.deref()) : immutableSnapshot(reason, owner.deref());
+        } catch (error) {
+            owner.deref()?.fail(error);
+            throw Object.freeze({
+                name: "DataProtocolError",
+                message: "Invalid public deferred error"
+            });
+        }
+        throw projected;
+    };
+    const projection = Promise.prototype.then.call(promise, project, reject);
+    const observation = {
+        scopes,
+        projection
+    };
+    promises.set(promise, observation);
+    promises.set(projection, observation);
+    projectedPromises.add(projection);
+    let status;
+    let settledValue;
+    Object.defineProperties(projection, {
+        s: {
+            get: ()=>status,
+            set: (next)=>{
+                if (void 0 === next || 0 === next || 1 === next || 2 === next) {
+                    status = next;
+                    return;
+                }
+                const error = new DataProtocolError("Unsupported native immutable route-data Promise state. AsyncIterable values are not supported.");
+                owner.deref()?.fail(error);
+                throw error;
+            }
+        },
+        v: {
+            get: ()=>settledValue,
+            set: (next)=>{
+                try {
+                    for (const scope of scopes)rejectPrivateReferences(next, scope);
+                    settledValue = 2 === status && next instanceof Error ? preparePublicMatchError(next, owner.deref()) : immutableSnapshot(next, owner.deref());
+                } catch (error) {
+                    owner.deref()?.fail(error);
+                    throw error;
+                }
+            }
+        }
+    });
+    Object.seal(projection);
+    projection.catch(()=>{});
+    return projection;
+}
+function criticalProjection(value, validateNativePromise) {
+    const seen = new WeakMap();
+    const slots = [];
+    let count = 0;
+    const copy = (current, depth)=>{
+        if (++count > 2e4 || depth > 100) throw new DataProtocolError("Public data exceeds its size or depth limit");
+        if (!current || "object" != typeof current) return current;
+        const previous = seen.get(current);
+        if (previous) return previous;
+        const prototype = Object.getPrototypeOf(current);
+        for (const key of Reflect.ownKeys(current)){
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if ("symbol" == typeof key || descriptor.get || descriptor.set) throw new DataProtocolError("Public data must not contain symbols or accessors");
+        }
+        let result;
+        if (prototype === Object.prototype || null === prototype) result = Object.create(prototype);
+        else if (prototype === Array.prototype && Array.isArray(current)) result = [];
+        else {
+            rejectMutableNativeContainer(prototype);
+            assertPublicData(current);
+            throw new DataProtocolError("Unsupported public data container");
+        }
+        seen.set(current, result);
+        for (const key of Reflect.ownKeys(current)){
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if ("symbol" == typeof key || descriptor.get || descriptor.set) throw new DataProtocolError("Public data must not contain symbols or accessors");
+            if (0 === depth && (prototype === Object.prototype || null === prototype) && descriptor.enumerable && descriptor.value instanceof Promise) {
+                const promise = descriptor.value;
+                if (Object.getPrototypeOf(promise) !== Promise.prototype) throw new DataProtocolError("Public data must not contain custom Promise properties or prototypes");
+                if (!projectedPromises.has(promise) && 0 !== Reflect.ownKeys(promise).length) {
+                    if (!validateNativePromise) throw new DataProtocolError("Public data must not contain custom Promise properties or prototypes");
+                    validateNativePromise(promise);
+                }
+                slots.push([
+                    key,
+                    descriptor
+                ]);
+                Object.defineProperty(result, key, {
+                    ...descriptor,
+                    value: void 0
+                });
+            } else Object.defineProperty(result, key, {
+                ...descriptor,
+                value: copy(descriptor.value, depth + 1)
+            });
+        }
+        return result;
+    };
+    return {
+        critical: copy(value, 0),
+        slots
+    };
+}
+function preparePublicLoaderData(value, owner, privateContexts = []) {
+    return prepareLoaderData(value, owner, privateContexts);
+}
+function prepareHydratedLoaderData(value, owner, privateContexts = []) {
+    return prepareLoaderData(value, owner, privateContexts, true);
+}
+function prepareLoaderData(value, owner, privateContexts = [], hydration = false) {
+    const session = requestFailureOwner(owner);
+    const references = privateReferences(session, privateContexts);
+    rejectPrivateReferences(value, references);
+    if (value && "object" == typeof value && session) {
+        const cached = snapshots.get(session)?.get(value);
+        if (cached) {
+            for (const promise of cached.deferred)projectDeferred(promise, session, references);
+            return cached.snapshot;
+        }
+    }
+    const nativeSettlements = new Map();
+    const validateNativePromise = hydration ? (promise)=>{
+        const descriptors = Object.getOwnPropertyDescriptors(promise);
+        for (const key of Reflect.ownKeys(promise)){
+            const descriptor = Object.getOwnPropertyDescriptor(promise, key);
+            if ("s" !== key && "v" !== key || descriptor.get || descriptor.set) throw new DataProtocolError("Native hydrated Promise metadata must contain only s/v data fields");
+        }
+        const status = descriptors.s?.value;
+        if (0 !== status && 1 !== status && 2 !== status) throw new DataProtocolError("Unsupported native hydrated Promise state; AsyncIterable values are not supported");
+        if ((1 === status || 2 === status) && !descriptors.v) throw new DataProtocolError("Native settled hydrated Promises require a value data field");
+        let projected;
+        if (descriptors.v) {
+            const settled = descriptors.v.value;
+            rejectPrivateReferences(settled, references);
+            projected = 2 === status && settled instanceof Error ? preparePublicMatchError(settled, session, privateContexts) : immutableSnapshot(settled, session);
+        }
+        nativeSettlements.set(promise, {
+            status,
+            hasValue: Boolean(descriptors.v),
+            value: projected
+        });
+    } : void 0;
+    const { critical, slots } = criticalProjection(value, validateNativePromise);
+    let snapshot = parsePublicData(serializePublicData(critical));
+    if (slots.length) {
+        if (!session || "function" != typeof session.fail || !(session.signal instanceof AbortSignal)) throw new DataProtocolError("Native deferred public data requires its owning request session");
+        for (const [key, descriptor] of slots){
+            const projection = projectDeferred(descriptor.value, session, references);
+            const settlement = nativeSettlements.get(descriptor.value);
+            if (settlement) {
+                Object.getOwnPropertyDescriptor(projection, "s").set.call(projection, settlement.status);
+                if (settlement.hasValue) Object.getOwnPropertyDescriptor(projection, "v").set.call(projection, settlement.value);
+            }
+            Object.defineProperty(snapshot, key, {
+                ...descriptor,
+                value: projection
+            });
+        }
+    }
+    snapshot = rememberSnapshot(value, snapshot, session, slots.map(([, descriptor])=>descriptor.value));
+    return snapshot;
+}
+function preparePublicContextData(value, owner, privateContexts = []) {
+    assertPublicData(value);
+    return preparePublicLoaderData(value, owner, privateContexts);
+}
+function preparePublishedRouteContext(context, owner, privateContexts = []) {
+    const snapshot = preparePublicContextData(context, owner, privateContexts);
+    if (!snapshot || "object" != typeof snapshot) throw new DataProtocolError("Native public route context must be a plain record");
+    const prototype = Object.getPrototypeOf(context);
+    if (prototype !== Object.prototype && null !== prototype) throw new DataProtocolError("Native public route context must be a plain record");
+    if (snapshot !== context) for (const key of Reflect.ownKeys(context)){
+        const descriptor = Object.getOwnPropertyDescriptor(context, key);
+        const checked = Object.getOwnPropertyDescriptor(snapshot, key);
+        if (checked && checked.value !== descriptor.value) Object.defineProperty(context, key, {
+            ...descriptor,
+            value: checked.value
+        });
+    }
+    freezeSnapshot(context);
+    const record = {
+        snapshot: context,
+        deferred: []
+    };
+    snapshots.get(owner)?.set(context, record);
+    snapshots.get(owner)?.set(snapshot, record);
+}
+const errorNames = new Map([
+    [
+        DataProtocolError.prototype,
+        "DataProtocolError"
+    ],
+    [
+        Error.prototype,
+        "Error"
+    ],
+    [
+        EvalError.prototype,
+        "EvalError"
+    ],
+    [
+        RangeError.prototype,
+        "RangeError"
+    ],
+    [
+        ReferenceError.prototype,
+        "ReferenceError"
+    ],
+    [
+        SyntaxError.prototype,
+        "SyntaxError"
+    ],
+    [
+        TypeError.prototype,
+        "TypeError"
+    ],
+    [
+        URIError.prototype,
+        "URIError"
+    ]
+]);
+function preparePublicMatchError(error, owner, privateContexts = []) {
+    const references = privateReferences(requestFailureOwner(owner), privateContexts);
+    if (error && "object" == typeof error && Object.getPrototypeOf(error) === RouteDataError.prototype) {
+        const result = projectRouteDataError(error, "development" !== process.env.NODE_ENV);
+        rejectPrivateReferences(result, references);
+        return immutableSnapshot(result, requestFailureOwner(owner));
+    }
+    const fallback = Object.freeze({
+        name: "Error",
+        message: "Unexpected Server Error"
+    });
+    if (!error || "object" != typeof error) return fallback;
+    const prototype = Object.getPrototypeOf(error);
+    if ((prototype === Object.prototype || null === prototype) && Object.getOwnPropertyDescriptor(error, "isNotFound")?.value === true) return preparePublicContextData(error, owner, privateContexts);
+    const name = errorNames.get(prototype);
+    if (!name) throw new DataProtocolError("Public match errors require an exact supported error prototype");
+    const descriptors = Object.getOwnPropertyDescriptors(error);
+    for (const key of Reflect.ownKeys(descriptors)){
+        const descriptor = Object.getOwnPropertyDescriptor(error, key);
+        if ("string" != typeof key || ![
+            "name",
+            "message",
+            "stack",
+            "cause"
+        ].includes(key)) throw new DataProtocolError("Public errors must not contain undeclared fields");
+        if ("stack" !== key || !descriptor.get && !descriptor.set) {
+            if ("symbol" == typeof key || descriptor.get || descriptor.set) throw new DataProtocolError("Public errors must not contain symbols or accessors");
+            rejectPrivateReferences(descriptor.value, references);
+            assertPublicData(descriptor.value);
+        }
+    }
+    if ("development" !== process.env.NODE_ENV && prototype !== DataProtocolError.prototype) return fallback;
+    const result = {
+        name: "string" == typeof descriptors.name?.value ? descriptors.name.value : name,
+        message: "string" == typeof descriptors.message?.value ? descriptors.message.value : fallback.message
+    };
+    if ("development" === process.env.NODE_ENV && "string" == typeof descriptors.stack?.value) result.stack = descriptors.stack.value;
+    if (descriptors.cause) result.cause = descriptors.cause.value;
+    return immutableSnapshot(result, requestFailureOwner(owner));
+}
+function rejectMutableNativeContainer(prototype) {
+    const names = new Map([
+        [
+            Date.prototype,
+            "Date"
+        ],
+        [
+            RegExp.prototype,
+            "RegExp"
+        ],
+        [
+            Map.prototype,
+            "Map"
+        ],
+        [
+            Set.prototype,
+            "Set"
+        ]
+    ]);
+    const name = prototype && names.get(prototype);
+    if (name) throw new DataProtocolError(`Unsupported native immutable route-data: ${name}. Use scalar values, plain records or arrays.`);
+}
+function freezeSnapshot(value) {
+    const seen = new WeakSet();
+    const visit = (current)=>{
+        if (!current || "object" != typeof current || current instanceof Promise || seen.has(current)) return;
+        seen.add(current);
+        rejectMutableNativeContainer(Object.getPrototypeOf(current));
+        for (const key of Reflect.ownKeys(current))visit(Object.getOwnPropertyDescriptor(current, key).value);
+        Object.freeze(current);
+    };
+    visit(value);
+}
+function immutableSnapshot(value, owner) {
+    assertPublicData(value);
+    const { critical } = criticalProjection(value);
+    const snapshot = parsePublicData(serializePublicData(critical));
+    return rememberSnapshot(value, snapshot, owner);
+}
+function rememberSnapshot(original, snapshot, owner, deferred = []) {
+    if (!owner || !original || "object" != typeof original) {
+        freezeSnapshot(snapshot);
+        return snapshot;
+    }
+    let values = snapshots.get(owner);
+    if (!values) {
+        values = new WeakMap();
+        snapshots.set(owner, values);
+    }
+    const aliases = new WeakMap();
+    const records = [];
+    const reuse = (source, projected)=>{
+        if (!source || "object" != typeof source || source instanceof Promise || !projected || "object" != typeof projected) return projected;
+        const cached = values.get(source);
+        if (cached) return cached.snapshot;
+        const previous = aliases.get(source);
+        if (previous) return previous;
+        aliases.set(source, projected);
+        records.push([
+            source,
+            projected
+        ]);
+        for (const key of Reflect.ownKeys(projected)){
+            const sourceDescriptor = Object.getOwnPropertyDescriptor(source, key);
+            const descriptor = Object.getOwnPropertyDescriptor(projected, key);
+            if (!sourceDescriptor || sourceDescriptor.get || sourceDescriptor.set) continue;
+            const value = reuse(sourceDescriptor.value, descriptor.value);
+            if (value !== descriptor.value) Object.defineProperty(projected, key, {
+                ...descriptor,
+                value
+            });
+        }
+        return projected;
+    };
+    const result = reuse(original, snapshot);
+    const { critical } = criticalProjection(result);
+    serializePublicData(critical);
+    freezeSnapshot(result);
+    for (const [source, projected] of records){
+        const record = {
+            snapshot: projected,
+            deferred: source === original ? deferred : []
+        };
+        values.set(source, record);
+        values.set(projected, record);
+    }
+    return result;
+}
+export { prepareHydratedLoaderData, preparePublicContextData, preparePublicLoaderData, preparePublicMatchError, preparePublishedRouteContext };

package/dist/esm-node/router-binding/registryTransfer.js

@@ -0,0 +1,210 @@
+import { DataProtocolError } from "@modern-js/renderer-core/data";
+import { getHydrationWriter, getRequestEvent, takeHydrationValue } from "@solidjs/web";
+import { restoreRouteDataError } from "../route-data-error.js";
+import { prepareHydratedLoaderData, preparePublicContextData, preparePublicLoaderData, preparePublicMatchError, preparePublishedRouteContext } from "./publicMatchData.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const MATCH_KEY_PREFIX = "tsr:";
+const preparedTransfers = new WeakMap();
+const publicRouteDataOwners = new WeakMap();
+function registerPublicRouteDataOwner(routeTree, owner, privateContexts = []) {
+    publicRouteDataOwners.set(routeTree, {
+        owner: new WeakRef(owner),
+        privateContexts: privateContexts.map((value)=>new WeakRef(value))
+    });
+}
+function requireManagedPublicRouter(router) {
+    const owner = getRequestEvent()?.locals.session;
+    if (!owner || publicRouteDataOwners.get(router.options.routeTree)?.owner.deref()) return;
+    const error = new DataProtocolError("Custom native Solid routers are unsupported by UltraModern SSR. Use the managed filesystem route tree and application router public-data boundary.");
+    owner.fail(error);
+    throw error;
+}
+function installPublicContextPublication(router) {
+    const scope = publicRouteDataOwners.get(router.options.routeTree);
+    const owner = scope?.owner.deref();
+    if (!scope || !owner) return;
+    const publish = router.stores.setMatches;
+    router.stores.setMatches = (matches)=>{
+        try {
+            const privateContexts = scope.privateContexts.flatMap((reference)=>{
+                const value = reference.deref();
+                return value ? [
+                    value
+                ] : [];
+            });
+            preparePublishedMatches(matches, owner, privateContexts);
+        } catch (error) {
+            owner.fail(error);
+            throw error;
+        }
+        publish(matches);
+    };
+}
+function preparePublishedMatches(matches, owner, privateContexts) {
+    for (const match of matches)preparePublicContextData(match.context, owner, privateContexts);
+    for (const match of matches)preparePublishedRouteContext(match.context, owner, privateContexts);
+}
+function prepareEntries(router, owner, privateContexts = []) {
+    const entries = new Map();
+    const matches = router.stores.matches.get();
+    const contexts = privateContexts;
+    for (const match of matches){
+        if ("pending" === match.status) continue;
+        const entry = {
+            status: match.status,
+            updatedAt: match.updatedAt
+        };
+        if (void 0 !== match.loaderData) entry.loaderData = preparePublicLoaderData(match.loaderData, owner, contexts);
+        if (void 0 !== match.error) entry.error = preparePublicMatchError(match.error, owner, contexts);
+        const beforeLoadContext = nativeContextField(match, "__beforeLoadContext");
+        if (void 0 !== beforeLoadContext) entry.beforeLoadContext = preparePublicContextData(beforeLoadContext, owner, contexts);
+        if (match._notFound) entry.notFound = true;
+        if (void 0 !== match.ssr) entry.ssr = match.ssr;
+        entries.set(match.id, entry);
+    }
+    return entries;
+}
+function prepareRouterMatchTransfer(router, owner, privateContexts = []) {
+    try {
+        const entries = prepareEntries(router, owner, privateContexts);
+        let routers = preparedTransfers.get(owner);
+        if (!routers) {
+            routers = new WeakMap();
+            preparedTransfers.set(owner, routers);
+        }
+        routers.set(router, entries);
+    } catch (error) {
+        owner.fail(error);
+        throw error;
+    }
+}
+function serializeMatchTransfer(router) {
+    requireManagedPublicRouter(router);
+    if (router.serverSsr) return;
+    const writer = getHydrationWriter();
+    if (!writer || !__rspack_external_solid_js_0ac0db99.isHydratable()) return;
+    const owner = getRequestEvent()?.locals.session;
+    const entries = (owner && preparedTransfers.get(owner)?.get(router)) ?? prepareEntries(router, owner);
+    for (const [id, entry] of entries)writer.write(MATCH_KEY_PREFIX + id, entry);
+}
+function primeRouterFromRegistry(router) {
+    if (router.stores.matches.get().length > 0) return false;
+    const registry = globalThis._$HY?.r;
+    if (!registry) return false;
+    let hasMatchEntries = false;
+    for(const key in registry)if (key.startsWith(MATCH_KEY_PREFIX)) {
+        hasMatchEntries = true;
+        break;
+    }
+    if (!hasMatchEntries) return false;
+    const matches = router.matchRoutes(router.latestLocation);
+    if (0 === matches.length) return false;
+    const entries = [];
+    let complete = true;
+    for (const match of matches){
+        const key = MATCH_KEY_PREFIX + match.id;
+        const transferred = takeHydrationValue(key);
+        if (transferred?.status !== "resolved") {
+            complete = false;
+            if (transferred?.status === "pending") Promise.prototype.then.call(transferred.promise, void 0, ()=>{});
+            continue;
+        }
+        const entry = transferred.value;
+        if (!entry || "string" != typeof entry.status) {
+            complete = false;
+            continue;
+        }
+        entries.push(entry);
+    }
+    if (!complete) return false;
+    const primed = [];
+    const scope = publicRouteDataOwners.get(router.options.routeTree);
+    const owner = scope?.owner.deref();
+    const privateContexts = scope?.privateContexts.flatMap((reference)=>{
+        const value = reference.deref();
+        return value ? [
+            value
+        ] : [];
+    }) ?? [];
+    try {
+        for (const [index, match] of matches.entries()){
+            const entry = entries[index];
+            const checked = {
+                ...entry,
+                loaderData: prepareHydratedLoaderData(entry.loaderData, owner, privateContexts),
+                beforeLoadContext: preparePublicContextData(entry.beforeLoadContext, owner, privateContexts),
+                error: preparePublicContextData(entry.error, owner, privateContexts)
+            };
+            entries[index] = checked;
+            primed.push(applyTransferredMatch(match, checked));
+        }
+        for (const [index, next] of primed.entries()){
+            const match = matches[index];
+            const route = router.routesById[match.routeId];
+            const parentContext = primed[index - 1]?.context ?? router.options.context ?? {};
+            const routeContext = route.options.context?.({
+                deps: match.loaderDeps,
+                params: match.params,
+                context: parentContext,
+                location: router.latestLocation,
+                navigate: (options)=>router.navigate({
+                        ...options,
+                        _fromLocation: router.latestLocation
+                    }),
+                buildLocation: router.buildLocation,
+                cause: match.cause,
+                abortController: match.abortController,
+                preload: false,
+                matches: primed,
+                routeId: route.id
+            }) || void 0;
+            Object.defineProperty(next, "_ctx", {
+                value: routeContext,
+                configurable: true,
+                writable: true,
+                enumerable: true
+            });
+            next.context = {
+                ...parentContext,
+                ...routeContext,
+                ...entries[index].beforeLoadContext
+            };
+        }
+        if (owner) preparePublishedMatches(primed, owner, privateContexts);
+    } catch (error) {
+        owner?.fail(error);
+        return false;
+    }
+    router._committed = primed;
+    router.batch(()=>{
+        router.stores.setMatches(primed);
+        router.stores.status.set("idle");
+        router.stores.resolvedLocation.set(router.stores.location.get());
+    });
+    return true;
+}
+function applyTransferredMatch(match, entry) {
+    const next = {
+        ...match,
+        status: entry.status,
+        updatedAt: entry.updatedAt,
+        error: isRouteDataErrorSnapshot(entry.error) ? Object.freeze(restoreRouteDataError(entry.error)) : entry.error,
+        invalid: false,
+        isFetching: false,
+        preload: false,
+        _notFound: entry.notFound,
+        __beforeLoadContext: entry.beforeLoadContext
+    };
+    if ("loaderData" in entry) next.loaderData = entry.loaderData;
+    if ("ssr" in entry) next.ssr = entry.ssr;
+    return next;
+}
+function isRouteDataErrorSnapshot(value) {
+    return !!value && "object" == typeof value && Object.getOwnPropertyDescriptor(value, "kind")?.value === "ultramodern-route-data-error";
+}
+function nativeContextField(match, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(match, key);
+    if (descriptor?.get || descriptor?.set) throw new DataProtocolError("Native route context must not contain accessor fields");
+    return descriptor?.value;
+}
+export { MATCH_KEY_PREFIX, installPublicContextPublication, prepareRouterMatchTransfer, primeRouterFromRegistry, registerPublicRouteDataOwner, requireManagedPublicRouter, serializeMatchTransfer };

package/dist/esm-node/router-binding/renderRouteNotFound.js

@@ -0,0 +1,22 @@
+import { renderInNonRouteComponentContext } from "./nonRouteComponentContext.js";
+import { DefaultGlobalNotFound } from "./not-found.js";
+function renderRouteNotFound(router, route, data) {
+    if ("production" !== process.env.NODE_ENV) {
+        if (!route.options.notFoundComponent) {
+            if (router.options.defaultNotFoundComponent) {
+                const DefaultNotFoundComponent = router.options.defaultNotFoundComponent;
+                return renderInNonRouteComponentContext(()=>DefaultNotFoundComponent(data), "notFoundComponent");
+            }
+            console.warn(`Warning: A notFoundError was encountered on the route with ID "${route.id}", but a notFoundComponent option was not configured, nor was a router level defaultNotFoundComponent configured. Consider configuring at least one of these to avoid TanStack Router's overly generic defaultNotFoundComponent (<p>Not Found</p>)`);
+            return DefaultGlobalNotFound({});
+        }
+        const NotFoundComponent = route.options.notFoundComponent;
+        return renderInNonRouteComponentContext(()=>NotFoundComponent(data), "notFoundComponent");
+    }
+    if (!route.options.notFoundComponent) {
+        if (router.options.defaultNotFoundComponent) return router.options.defaultNotFoundComponent(data);
+        return DefaultGlobalNotFound({});
+    }
+    return route.options.notFoundComponent(data);
+}
+export { renderRouteNotFound };