@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.10

package/dist/cjs/router-snapshot.js

@@ -0,0 +1,270 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ADAPTER_KEY: ()=>ADAPTER_KEY,
+    MATCH_FIELDS: ()=>MATCH_FIELDS,
+    NATIVE_ERROR_KIND: ()=>NATIVE_ERROR_KIND,
+    NATIVE_ROOT_FIELDS: ()=>NATIVE_ROOT_FIELDS,
+    ROUTE_ERROR_KIND: ()=>ROUTE_ERROR_KIND,
+    clearStack: ()=>clearStack,
+    descriptors: ()=>descriptors,
+    invalid: ()=>invalid,
+    nativePromise: ()=>nativePromise,
+    octaneRouterSnapshotAdapter: ()=>octaneRouterSnapshotAdapter,
+    record: ()=>record,
+    stringField: ()=>stringField
+});
+const data_namespaceObject = require("@modern-js/renderer-core/data");
+const tanstack_router_namespaceObject = require("@octanejs/tanstack-router");
+const external_routes_js_namespaceObject = require("./routes.js");
+const ADAPTER_KEY = 'ultramodern.octane-public-snapshot.v1';
+const ROUTE_ERROR_KIND = 'ultramodern-route-error';
+const NATIVE_ERROR_KIND = 'ultramodern-native-error';
+const nativeErrorTypes = Object.freeze({
+    Error,
+    TypeError,
+    RangeError,
+    SyntaxError,
+    ReferenceError,
+    URIError,
+    EvalError
+});
+const NATIVE_ROOT_FIELDS = new Set([
+    'manifest',
+    'matches',
+    'lastMatchId',
+    'dehydratedData'
+]);
+const MATCH_FIELDS = new Set([
+    'i',
+    'u',
+    's',
+    'b',
+    'l',
+    'e',
+    'ssr',
+    'g'
+]);
+function invalid(message) {
+    const error = new data_namespaceObject.DataProtocolError(`Octane router snapshot: ${message}`);
+    delete error.stack;
+    return error;
+}
+function descriptors(value, allowed, allowLazyStack = false) {
+    const result = Object.create(null);
+    for (const key of Reflect.ownKeys(value)){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ('string' != typeof key || allowed && !allowed.has(key)) throw invalid('an unsupported own field cannot be transferred');
+        if (descriptor.get || descriptor.set) {
+            if ('stack' === key && allowLazyStack) continue;
+            throw invalid('accessors cannot be transferred');
+        }
+        result[key] = descriptor;
+    }
+    return result;
+}
+function record(value) {
+    return null !== value && 'object' == typeof value && (Object.getPrototypeOf(value) === Object.prototype || null === Object.getPrototypeOf(value));
+}
+function stringField(fields, key) {
+    const value = fields[key]?.value;
+    if ('string' != typeof value) throw invalid(`${key} must be a string`);
+    return value;
+}
+function nativePromise(value) {
+    return null !== value && 'object' == typeof value && Object.getPrototypeOf(value) === Promise.prototype;
+}
+function clearStack(error, stack) {
+    delete error.stack;
+    if ('string' == typeof stack) Object.defineProperty(error, 'stack', {
+        value: stack,
+        writable: true,
+        configurable: true
+    });
+}
+function decodeRouteError(error) {
+    if (!record(error)) return error;
+    const errorFields = descriptors(error);
+    const kind = errorFields['kind']?.value;
+    if (kind !== ROUTE_ERROR_KIND && kind !== NATIVE_ERROR_KIND) return error;
+    if (kind === NATIVE_ERROR_KIND) {
+        descriptors(error, new Set([
+            'kind',
+            'type',
+            'name',
+            'message',
+            'stack',
+            'cause'
+        ]));
+        (0, data_namespaceObject.assertPublicData)(error);
+        const type = stringField(errorFields, 'type');
+        const Constructor = Object.getOwnPropertyDescriptor(nativeErrorTypes, type)?.value;
+        if (!Constructor) throw invalid('the native Error type is unsupported');
+        const restored = new Constructor(stringField(errorFields, 'message'));
+        clearStack(restored, errorFields['stack']?.value);
+        Object.defineProperty(restored, 'name', {
+            value: stringField(errorFields, 'name'),
+            writable: true,
+            configurable: true
+        });
+        if (errorFields['cause']) Object.defineProperty(restored, 'cause', {
+            value: errorFields['cause'].value,
+            writable: true,
+            configurable: true
+        });
+        return restored;
+    }
+    const expected = new Set([
+        'kind',
+        'routeId',
+        'status',
+        'data',
+        'name',
+        'message',
+        'stack',
+        'cause'
+    ]);
+    descriptors(error, expected);
+    const routeId = stringField(errorFields, 'routeId');
+    const name = stringField(errorFields, 'name');
+    const message = stringField(errorFields, 'message');
+    const status = errorFields['status']?.value;
+    if (!routeId || !Number.isInteger(status) || status < 400 || status > 599) throw invalid('a route error has invalid identity or status');
+    (0, data_namespaceObject.assertPublicData)(error);
+    const restored = new external_routes_js_namespaceObject.RouteDataError(routeId, {
+        kind: 'error',
+        status: status,
+        error: {
+            name,
+            message
+        },
+        data: errorFields['data']?.value,
+        thrown: true
+    });
+    clearStack(restored, errorFields['stack']?.value);
+    if (errorFields['cause']) Object.defineProperty(restored, 'cause', {
+        value: errorFields['cause'].value,
+        writable: true,
+        configurable: true
+    });
+    return restored;
+}
+function decodeNativeSnapshot(value) {
+    if (!record(value)) throw invalid('the native root must be a record');
+    const fields = descriptors(value, NATIVE_ROOT_FIELDS);
+    const matches = fields['matches']?.value;
+    if (!Array.isArray(matches)) throw invalid('native matches must be an array');
+    const matchFields = descriptors(matches);
+    const promises = new WeakMap();
+    const loaders = new WeakMap();
+    const errors = new WeakMap();
+    const decodeError = (error)=>{
+        if (null === error || 'object' != typeof error) return error;
+        if (errors.has(error)) return errors.get(error);
+        const restored = decodeRouteError(error);
+        errors.set(error, restored);
+        return restored;
+    };
+    const decodePromise = (promise)=>{
+        const previous = promises.get(promise);
+        if (previous) return previous;
+        const restored = Promise.prototype.then.call(promise, void 0, (error)=>{
+            throw decodeError(error);
+        });
+        promises.set(promise, restored);
+        Promise.prototype.then.call(restored, void 0, ()=>{});
+        return restored;
+    };
+    const decodeLoader = (loader)=>{
+        if (nativePromise(loader)) return decodePromise(loader);
+        if (!record(loader)) return loader;
+        const properties = descriptors(loader);
+        if (!Object.values(properties).some((field)=>nativePromise(field.value))) return loader;
+        const previous = loaders.get(loader);
+        if (previous) return previous;
+        const restored = Object.create(Object.getPrototypeOf(loader));
+        loaders.set(loader, restored);
+        for (const [key, field] of Object.entries(properties))Object.defineProperty(restored, key, {
+            ...field,
+            value: nativePromise(field.value) ? decodePromise(field.value) : field.value
+        });
+        if (!Object.isExtensible(loader)) Object.preventExtensions(restored);
+        return restored;
+    };
+    const restoredMatches = [];
+    for(let index = 0; index < matches.length; index++){
+        const match = matchFields[String(index)]?.value;
+        if (!record(match)) throw invalid('a native match must be a record');
+        const properties = descriptors(match, MATCH_FIELDS);
+        const restored = {};
+        for (const [key, field] of Object.entries(properties))restored[key] = 'e' === key ? decodeError(field.value) : 'l' === key ? decodeLoader(field.value) : field.value;
+        restoredMatches.push(restored);
+    }
+    const restored = {};
+    for (const [key, field] of Object.entries(fields))restored[key] = 'matches' === key ? restoredMatches : field.value;
+    return restored;
+}
+const octaneRouterSnapshotAdapter = (0, tanstack_router_namespaceObject.createSerializationAdapter)({
+    key: ADAPTER_KEY,
+    test: (_value)=>false,
+    toSerializable () {
+        throw invalid('the client decoder cannot serialize a server snapshot');
+    },
+    fromSerializable: decodeNativeSnapshot
+});
+exports.ADAPTER_KEY = __webpack_exports__.ADAPTER_KEY;
+exports.MATCH_FIELDS = __webpack_exports__.MATCH_FIELDS;
+exports.NATIVE_ERROR_KIND = __webpack_exports__.NATIVE_ERROR_KIND;
+exports.NATIVE_ROOT_FIELDS = __webpack_exports__.NATIVE_ROOT_FIELDS;
+exports.ROUTE_ERROR_KIND = __webpack_exports__.ROUTE_ERROR_KIND;
+exports.clearStack = __webpack_exports__.clearStack;
+exports.descriptors = __webpack_exports__.descriptors;
+exports.invalid = __webpack_exports__.invalid;
+exports.nativePromise = __webpack_exports__.nativePromise;
+exports.octaneRouterSnapshotAdapter = __webpack_exports__.octaneRouterSnapshotAdapter;
+exports.record = __webpack_exports__.record;
+exports.stringField = __webpack_exports__.stringField;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ADAPTER_KEY",
+    "MATCH_FIELDS",
+    "NATIVE_ERROR_KIND",
+    "NATIVE_ROOT_FIELDS",
+    "ROUTE_ERROR_KIND",
+    "clearStack",
+    "descriptors",
+    "invalid",
+    "nativePromise",
+    "octaneRouterSnapshotAdapter",
+    "record",
+    "stringField"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router.js

@@ -0,0 +1,218 @@
+"use strict";
+var __webpack_modules__ = {
+    "./bootstrap" (module) {
+        module.exports = require("./bootstrap.js");
+    },
+    "./routes" (module) {
+        module.exports = require("./routes.js");
+    },
+    "@modern-js/renderer-core/data" (module) {
+        module.exports = require("@modern-js/renderer-core/data");
+    },
+    "@octanejs/tanstack-router" (module) {
+        module.exports = require("@octanejs/tanstack-router");
+    },
+    octane (module) {
+        module.exports = require("octane");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _modern_js_renderer_core_data__rspack_import_0 = __webpack_require__("@modern-js/renderer-core/data");
+    var _octanejs_tanstack_router__rspack_import_1 = __webpack_require__("@octanejs/tanstack-router");
+    var octane__rspack_import_2 = __webpack_require__("octane");
+    var _bootstrap__rspack_import_3 = __webpack_require__("./bootstrap");
+    var _routes__rspack_import_4 = __webpack_require__("./routes");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _octanejs_tanstack_router__rspack_import_1)if ([
+        "createFileSystemRouteTree",
+        "createApplicationRouter",
+        "useApplicationIdentity",
+        "createOctaneRouteAction",
+        "useApplicationRouteId",
+        "default",
+        "useOctaneRouteAction",
+        "matchApplicationRouteIds",
+        "ApplicationRouter",
+        "matchApplicationRoutes",
+        "resolveRouteData",
+        "selectApplicationDataRoute",
+        "RouteDataError"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_octanejs_tanstack_router__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    function useApplicationIdentity() {
+        const identity = (0, _octanejs_tanstack_router__rspack_import_1.useRouter)().options.context?.ultramodern?.rendererIdentity;
+        if (!identity || 'object' != typeof identity || Array.isArray(identity)) throw new Error('The Octane application router is missing its renderer identity');
+        (0, _bootstrap__rspack_import_3.assertOctaneIdentity)(identity);
+        return Object.freeze({
+            ...identity
+        });
+    }
+    function useApplicationRouteId() {
+        const router = (0, _octanejs_tanstack_router__rspack_import_1.useRouter)();
+        const routeId = (0, _octanejs_tanstack_router__rspack_import_1.useMatch)({
+            strict: false,
+            select: (match)=>match.routeId
+        });
+        if ('string' != typeof routeId) throw new Error('The Octane application requires an active native route match');
+        const id = router.routesById[routeId]?.options.staticData?.ultramodernRouteId;
+        if ('string' != typeof id || 0 === id.length) throw new Error('The Octane application route is missing its filesystem identity');
+        return id;
+    }
+    function assertNavigableActionRedirect(status, method) {
+        if (307 === status || 308 === status || (301 === status || 302 === status) && 'POST' !== method) throw new Error(`A native action redirect must not preserve the method (HTTP ${status} after ${method}); redirect with 303 to navigate after the mutation`);
+    }
+    function createOctaneRouteAction(input) {
+        const data = (0, _modern_js_renderer_core_data__rspack_import_0.createDataClient)(input.routeId, input.identity, {
+            fetch: input.fetch
+        });
+        return async (_previous, formData)=>{
+            input.signal?.throwIfAborted();
+            const target = 'function' == typeof input.url ? input.url() : input.url ?? input.router.latestLocation.publicHref;
+            const origin = input.router.options.origin ?? globalThis.location?.origin;
+            const request = new Request(new URL(target, origin), {
+                method: input.method ?? 'POST',
+                body: formData,
+                signal: input.signal
+            });
+            const outcome = await data.action({
+                request
+            });
+            await outcome.completion;
+            input.signal?.throwIfAborted();
+            if ('redirect' === outcome.kind) {
+                assertNavigableActionRedirect(outcome.status, request.method);
+                const resolved = input.router.resolveRedirect((0, _octanejs_tanstack_router__rspack_import_1.redirect)({
+                    href: new URL(outcome.location, request.url).href,
+                    statusCode: outcome.status
+                }));
+                await input.router.navigate({
+                    href: resolved.options.href
+                });
+            } else if (('error' === outcome.kind || 'not-found' === outcome.kind) && outcome.thrown) (0, _routes__rspack_import_4.resolveRouteData)(input.routeId, outcome);
+            else if ('success' === outcome.kind) await input.router.invalidate();
+            return outcome;
+        };
+    }
+    const actionSlot = (0, octane__rspack_import_2.createSubSlot)({
+        slotlessPrefix: 'ultramodern-action:'
+    });
+    function useOctaneRouteAction(...args) {
+        const tail = args.at(-1);
+        const slot = 'symbol' == typeof tail ? tail : void 0;
+        const binding = 'object' == typeof args[0] && null !== args[0] ? args[0] : {};
+        const router = (0, _octanejs_tanstack_router__rspack_import_1.useRouter)();
+        const identity = useApplicationIdentity();
+        const routeId = useApplicationRouteId();
+        const owner = (0, octane__rspack_import_2.useRef)(null, actionSlot(slot, 'owner'));
+        (0, octane__rspack_import_2.useLayoutEffect)(()=>{
+            const controller = new AbortController();
+            owner.current = controller;
+            return ()=>controller.abort(new DOMException('The route action owner unmounted', 'AbortError'));
+        }, [], actionSlot(slot, 'lifetime'));
+        const { url, method, fetch } = binding;
+        return (0, octane__rspack_import_2.useCallback)((previous, formData)=>createOctaneRouteAction({
+                router,
+                routeId,
+                identity,
+                url,
+                method,
+                fetch,
+                signal: owner.current?.signal
+            })(previous, formData), [
+            router,
+            routeId,
+            url,
+            method,
+            fetch
+        ], actionSlot(slot, 'action'));
+    }
+    __webpack_require__.d(__webpack_exports__, {
+        ApplicationRouter: ()=>_octanejs_tanstack_router__rspack_import_1.RouterProvider,
+        RouteDataError: ()=>_routes__rspack_import_4.RouteDataError,
+        createApplicationRouter: ()=>_octanejs_tanstack_router__rspack_import_1.createRouter,
+        createFileSystemRouteTree: ()=>_routes__rspack_import_4.createFileSystemRouteTree,
+        createOctaneRouteAction: ()=>createOctaneRouteAction,
+        matchApplicationRouteIds: ()=>_routes__rspack_import_4.matchApplicationRouteIds,
+        matchApplicationRoutes: ()=>_routes__rspack_import_4.matchApplicationRoutes,
+        resolveRouteData: ()=>_routes__rspack_import_4.resolveRouteData,
+        selectApplicationDataRoute: ()=>_routes__rspack_import_4.selectApplicationDataRoute,
+        useApplicationIdentity: ()=>useApplicationIdentity,
+        useApplicationRouteId: ()=>useApplicationRouteId,
+        useOctaneRouteAction: ()=>useOctaneRouteAction
+    });
+})();
+exports.ApplicationRouter = __webpack_exports__.ApplicationRouter;
+exports.RouteDataError = __webpack_exports__.RouteDataError;
+exports.createApplicationRouter = __webpack_exports__.createApplicationRouter;
+exports.createFileSystemRouteTree = __webpack_exports__.createFileSystemRouteTree;
+exports.createOctaneRouteAction = __webpack_exports__.createOctaneRouteAction;
+exports.matchApplicationRouteIds = __webpack_exports__.matchApplicationRouteIds;
+exports.matchApplicationRoutes = __webpack_exports__.matchApplicationRoutes;
+exports.resolveRouteData = __webpack_exports__.resolveRouteData;
+exports.selectApplicationDataRoute = __webpack_exports__.selectApplicationDataRoute;
+exports.useApplicationIdentity = __webpack_exports__.useApplicationIdentity;
+exports.useApplicationRouteId = __webpack_exports__.useApplicationRouteId;
+exports.useOctaneRouteAction = __webpack_exports__.useOctaneRouteAction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ApplicationRouter",
+    "RouteDataError",
+    "createApplicationRouter",
+    "createFileSystemRouteTree",
+    "createOctaneRouteAction",
+    "matchApplicationRouteIds",
+    "matchApplicationRoutes",
+    "resolveRouteData",
+    "selectApplicationDataRoute",
+    "useApplicationIdentity",
+    "useApplicationRouteId",
+    "useOctaneRouteAction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/routes.js

@@ -0,0 +1,190 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    RouteDataError: ()=>router_namespaceObject.RouteDataError,
+    createFileSystemRouteTree: ()=>createFileSystemRouteTree,
+    hasUnchangedOctaneFileRouteHead: ()=>hasUnchangedOctaneFileRouteHead,
+    matchApplicationRouteIds: ()=>router_namespaceObject.matchApplicationRouteIds,
+    matchApplicationRoutes: ()=>router_namespaceObject.matchApplicationRoutes,
+    resolveRouteData: ()=>resolveRouteData,
+    selectApplicationDataRoute: ()=>router_namespaceObject.selectApplicationDataRoute
+});
+const router_namespaceObject = require("@modern-js/renderer-core/router");
+const tanstack_router_namespaceObject = require("@octanejs/tanstack-router");
+const external_octane_namespaceObject = require("octane");
+const fileRouteHeads = new WeakMap();
+function hasUnchangedOctaneFileRouteHead(route) {
+    return fileRouteHeads.get(route) === route.options.head;
+}
+function resolveRouteData(routeId, outcome) {
+    return (0, router_namespaceObject.resolveRouteData)({
+        redirect: tanstack_router_namespaceObject.redirect,
+        notFound: tanstack_router_namespaceObject.notFound
+    }, routeId, outcome);
+}
+function isReactiveNativeMatch(value) {
+    return 'object' == typeof value && null !== value && 'function' == typeof Reflect.get(value, 'get') && 'function' == typeof Reflect.get(value, 'subscribe');
+}
+function observeRouteCompletion(router, routeId, controller, signal, completion) {
+    completion.catch((error)=>{
+        if (signal.aborted) return;
+        const route = Object.values(router.routesById).find((candidate)=>candidate.options.staticData?.ultramodernRouteId === routeId);
+        if (!route) return;
+        const store = router.stores.getMatchStore(route.id);
+        let subscription;
+        let settled = false;
+        const cleanup = ()=>{
+            subscription?.unsubscribe();
+            signal.removeEventListener('abort', onAbort);
+        };
+        const onAbort = ()=>{
+            settled = true;
+            cleanup();
+        };
+        const publish = async ()=>{
+            if (settled) return;
+            const current = store.get();
+            if (!current) return;
+            if (current.abortController !== controller || signal.aborted || 'pending' !== current.status && 'success' !== current.status) return void onAbort();
+            if ('success' !== current.status || current.isFetching) return;
+            settled = true;
+            cleanup();
+            const route = router.routesById[current.routeId];
+            let failure = error;
+            try {
+                await route?.options.errorComponent?.preload?.();
+                if (signal.aborted || store.get()?.abortController !== controller) return;
+                route?.options.onError?.(failure);
+            } catch (onErrorFailure) {
+                failure = onErrorFailure;
+            }
+            if (signal.aborted) return;
+            router.stores.setMatches(router.stores.matches.get().map((previous)=>previous.routeId !== route.id || previous.abortController !== controller || 'success' !== previous.status || previous.isFetching ? previous : {
+                    ...previous,
+                    error: failure,
+                    status: 'error',
+                    isFetching: false
+                }));
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (isReactiveNativeMatch(store)) subscription = store.subscribe(publish);
+        if (settled) subscription?.unsubscribe();
+        else publish();
+    });
+}
+function createFileSystemRouteTree(routes, modules, options = {}) {
+    const { root: rootDescriptor, children } = (0, router_namespaceObject.splitFileSystemRoutes)(routes);
+    function bindings(route, errorComponent) {
+        const needsData = Boolean(route.modules?.data || route.modules?.clientData);
+        if (needsData && !options.loadRoute) throw new Error(`An Octane data route requires its loader: ${route.id}`);
+        const loadRoute = options.loadRoute;
+        const { head, ...module } = modules[route.id] ?? {};
+        return {
+            ...module,
+            ...void 0 !== head ? {
+                head
+            } : {},
+            ...errorComponent ? {
+                errorComponent
+            } : {},
+            component: module.component ?? tanstack_router_namespaceObject.Outlet,
+            staticData: {
+                ultramodernRouteId: route.id
+            },
+            ...needsData && loadRoute ? {
+                loader: async (match)=>{
+                    const { outcome, signal } = await (0, router_namespaceObject.loadFileSystemRoute)(route, loadRoute, options, match);
+                    if ('completion' in outcome && outcome.completion) {
+                        const router = options.getRouter?.();
+                        if (!router) throw new Error('An Octane streamed data route requires its native router');
+                        let failed = false;
+                        let failure;
+                        outcome.completion.catch((error)=>{
+                            failed = true;
+                            failure = error;
+                        });
+                        await Promise.resolve();
+                        signal.throwIfAborted();
+                        if (failed) throw failure;
+                        observeRouteCompletion(router, route.id, match.abortController, signal, outcome.completion);
+                    }
+                    options.onOutcome?.(route.id, outcome);
+                    return resolveRouteData(route.id, outcome);
+                }
+            } : {}
+        };
+    }
+    const rootBindings = rootDescriptor ? bindings(rootDescriptor) : {
+        component: tanstack_router_namespaceObject.Outlet
+    };
+    const authoredRoot = rootBindings.component;
+    function OctaneDocumentRoot(props) {
+        return (0, external_octane_namespaceObject.createElement)(external_octane_namespaceObject.Fragment, null, (0, external_octane_namespaceObject.createElement)(tanstack_router_namespaceObject.HeadContent), (0, external_octane_namespaceObject.createElement)(authoredRoot, props), (0, external_octane_namespaceObject.createElement)(tanstack_router_namespaceObject.Scripts));
+    }
+    if (void 0 !== authoredRoot.preload) OctaneDocumentRoot.preload = authoredRoot.preload;
+    const rootErrorComponent = rootDescriptor && modules[rootDescriptor.id]?.errorComponent || tanstack_router_namespaceObject.ErrorComponent;
+    const root = (0, tanstack_router_namespaceObject.createRootRoute)({
+        ...rootBindings,
+        component: OctaneDocumentRoot
+    });
+    fileRouteHeads.set(root, root.options.head);
+    function bind(route, parent, inheritedErrorComponent) {
+        const errorComponent = modules[route.id]?.errorComponent ?? inheritedErrorComponent;
+        const native = (0, tanstack_router_namespaceObject.createRoute)({
+            getParentRoute: ()=>parent,
+            ...(0, router_namespaceObject.nativeRoutePath)(route),
+            ...bindings(route, errorComponent)
+        });
+        fileRouteHeads.set(native, native.options.head);
+        return native.addChildren(route.children.map((child)=>bind(child, native, errorComponent)));
+    }
+    return root.addChildren(children.map((route)=>bind(route, root, rootErrorComponent)));
+}
+exports.RouteDataError = __webpack_exports__.RouteDataError;
+exports.createFileSystemRouteTree = __webpack_exports__.createFileSystemRouteTree;
+exports.hasUnchangedOctaneFileRouteHead = __webpack_exports__.hasUnchangedOctaneFileRouteHead;
+exports.matchApplicationRouteIds = __webpack_exports__.matchApplicationRouteIds;
+exports.matchApplicationRoutes = __webpack_exports__.matchApplicationRoutes;
+exports.resolveRouteData = __webpack_exports__.resolveRouteData;
+exports.selectApplicationDataRoute = __webpack_exports__.selectApplicationDataRoute;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RouteDataError",
+    "createFileSystemRouteTree",
+    "hasUnchangedOctaneFileRouteHead",
+    "matchApplicationRouteIds",
+    "matchApplicationRoutes",
+    "resolveRouteData",
+    "selectApplicationDataRoute"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});