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

package/dist/esm/router-server-snapshot.mjs

@@ -0,0 +1,367 @@
+import { createRequestDataPolicy, publicDataError } from "@modern-js/renderer-core/data";
+import { untilAborted } from "@modern-js/renderer-core/session";
+import { createSerializationAdapter } from "@octanejs/tanstack-router";
+import { cleanupOctaneRouterSSR } from "./router-server-cleanup.mjs";
+import { ADAPTER_KEY, MATCH_FIELDS, NATIVE_ERROR_KIND, NATIVE_ROOT_FIELDS, ROUTE_ERROR_KIND, descriptors, invalid, nativePromise, octaneRouterSnapshotAdapter, record, stringField } from "./router-snapshot.mjs";
+import { RouteDataError } from "./routes.mjs";
+const ERROR_FIELDS = new Set([
+    'name',
+    'message',
+    'stack',
+    'cause'
+]);
+const ROUTE_ERROR_FIELDS = new Set([
+    ...ERROR_FIELDS,
+    'routeId',
+    'status',
+    'data'
+]);
+const errorConstructors = new Map([
+    [
+        Error.prototype,
+        Error
+    ],
+    [
+        TypeError.prototype,
+        TypeError
+    ],
+    [
+        RangeError.prototype,
+        RangeError
+    ],
+    [
+        SyntaxError.prototype,
+        SyntaxError
+    ],
+    [
+        ReferenceError.prototype,
+        ReferenceError
+    ],
+    [
+        URIError.prototype,
+        URIError
+    ],
+    [
+        EvalError.prototype,
+        EvalError
+    ]
+]);
+const owners = new WeakMap();
+function prepareOctaneRouterSerialization(router, session, options = {}) {
+    session.signal.throwIfAborted();
+    if (owners.has(router)) throw invalid('a router already has a request serialization owner');
+    const adapterProperty = Object.getOwnPropertyDescriptor(router.options, 'serializationAdapters');
+    const dehydrateProperty = Object.getOwnPropertyDescriptor(router.options, 'dehydrate');
+    if (adapterProperty?.get || adapterProperty?.set || dehydrateProperty?.get || dehydrateProperty?.set) throw invalid('native serializer options must be owned data properties');
+    const consumerAdapters = adapterProperty?.value ?? [];
+    if (!Array.isArray(consumerAdapters) || Object.getPrototypeOf(consumerAdapters) !== Array.prototype) throw invalid('native serializationAdapters must be an owned array');
+    const adapterFields = descriptors(consumerAdapters);
+    if (consumerAdapters.length > 1 || 1 === consumerAdapters.length && adapterFields['0']?.value !== octaneRouterSnapshotAdapter || Object.keys(adapterFields).length !== consumerAdapters.length + 1) throw invalid('custom serializationAdapters are not admitted in framework SSR; return supported public data');
+    const consumerDehydrate = dehydrateProperty?.value;
+    if (void 0 !== consumerDehydrate && 'function' != typeof consumerDehydrate) throw invalid('native dehydrate must be an owned function');
+    owners.set(router, session);
+    const production = options.production ?? 'production' === process.env['NODE_ENV'];
+    const policy = createRequestDataPolicy([
+        session,
+        session.request,
+        session.platform,
+        session.platform.bindings,
+        ...options.forbiddenValues ?? []
+    ]);
+    const copies = new WeakMap();
+    const projectedRoots = new WeakSet();
+    let nativeRoot;
+    let released = false;
+    let failure;
+    const fail = (error)=>{
+        failure ??= error;
+        session.fail(failure);
+        cleanupOctaneRouterSSR(router);
+        throw failure;
+    };
+    const assertActive = ()=>{
+        if (void 0 !== failure) throw failure;
+        session.signal.throwIfAborted();
+    };
+    function copyPublic(value) {
+        policy.assertValue(value);
+        return copyValue(value);
+    }
+    function copyValue(value) {
+        if (null === value || 'object' != typeof value) return value;
+        const fields = descriptors(value);
+        const previous = copies.get(value);
+        if (previous) return previous;
+        const prototype = Object.getPrototypeOf(value);
+        let result;
+        if (prototype === Date.prototype) result = new Date(Date.prototype.valueOf.call(value));
+        else if (prototype === RegExp.prototype) {
+            const source = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source').get.call(value);
+            const flags = [
+                'hasIndices',
+                'global',
+                'ignoreCase',
+                'multiline',
+                'dotAll',
+                'unicode',
+                'unicodeSets',
+                'sticky'
+            ];
+            const letters = [
+                'd',
+                'g',
+                'i',
+                'm',
+                's',
+                'u',
+                'v',
+                'y'
+            ];
+            const enabled = flags.map((flag, index)=>Object.getOwnPropertyDescriptor(RegExp.prototype, flag)?.get?.call(value) ? letters[index] : '').join('');
+            result = new RegExp(source, enabled);
+        } else result = prototype === Map.prototype ? new Map() : prototype === Set.prototype ? new Set() : Array.isArray(value) ? [] : Object.create(prototype);
+        copies.set(value, result);
+        if (prototype === Map.prototype) for (const [key, item] of Map.prototype.entries.call(value))Map.prototype.set.call(result, copyValue(key), copyValue(item));
+        else if (prototype === Set.prototype) for (const item of Set.prototype.values.call(value))Set.prototype.add.call(result, copyValue(item));
+        for (const [key, field] of Object.entries(fields))if (!Array.isArray(value) || 'length' !== key) Object.defineProperty(result, key, {
+            ...field,
+            value: copyValue(field.value)
+        });
+        if (Array.isArray(value)) Object.defineProperty(result, 'length', fields['length']);
+        if (!Object.isExtensible(value)) Object.preventExtensions(result);
+        return result;
+    }
+    function copyError(value) {
+        if (null === value || 'object' != typeof value) return copyPublic(value);
+        policy.assertRoot(value);
+        const prototype = Object.getPrototypeOf(value);
+        const routeError = prototype === RouteDataError.prototype;
+        const Constructor = errorConstructors.get(prototype);
+        if (!routeError && !Constructor) return copyPublic(value);
+        const fields = descriptors(value, routeError ? ROUTE_ERROR_FIELDS : ERROR_FIELDS, true);
+        if ('[object Error]' !== Object.prototype.toString.call(value)) throw invalid('an error requires genuine native Error slots');
+        const name = fields['name'] ? stringField(fields, 'name') : routeError ? 'Error' : Constructor.name;
+        const message = fields['message'] ? stringField(fields, 'message') : '';
+        const stack = production ? void 0 : fields['stack']?.value;
+        if (void 0 !== stack && 'string' != typeof stack) throw invalid('stack must be a data string');
+        const cause = fields['cause'] ? copyPublic(fields['cause'].value) : void 0;
+        const projectedData = routeError ? copyPublic(fields['data']?.value) : void 0;
+        const previous = copies.get(value);
+        if (previous) return previous;
+        if (routeError) {
+            const routeId = stringField(fields, 'routeId');
+            const status = fields['status']?.value;
+            if (!routeId || !Number.isInteger(status) || status < 400 || status > 599) throw invalid('a route error has invalid identity or status');
+            const result = {
+                kind: ROUTE_ERROR_KIND,
+                routeId,
+                status,
+                name,
+                message,
+                data: projectedData,
+                ...void 0 === stack ? {} : {
+                    stack
+                },
+                ...fields['cause'] ? {
+                    cause
+                } : {}
+            };
+            copies.set(value, result);
+            return result;
+        }
+        const publicError = production ? publicDataError(value, true) : {
+            name,
+            message
+        };
+        const result = {
+            kind: NATIVE_ERROR_KIND,
+            type: production ? 'Error' : Constructor.name,
+            name: publicError.name,
+            message: publicError.message,
+            ...void 0 === stack ? {} : {
+                stack
+            },
+            ...!production && fields['cause'] ? {
+                cause
+            } : {}
+        };
+        copies.set(value, result);
+        return result;
+    }
+    function copyPromise(value) {
+        policy.assertRoot(value);
+        if (Reflect.ownKeys(value).length > 0) throw invalid('deferred values require native Promises without own fields');
+        const previous = copies.get(value);
+        if (previous) return previous;
+        const checked = Promise.prototype.then.call(value, (settled)=>{
+            try {
+                if (released || session.signal.aborted) throw invalid('the request serialization owner was released');
+                policy.assertRoot(value);
+                return copyPublic(settled);
+            } catch (error) {
+                return fail(error);
+            }
+        }, (reason)=>{
+            if (released || session.signal.aborted) throw invalid('the request serialization owner was released');
+            let projected;
+            try {
+                policy.assertRoot(value);
+                projected = copyError(reason);
+            } catch (error) {
+                return fail(error);
+            }
+            throw projected;
+        });
+        copies.set(value, checked);
+        Promise.prototype.then.call(checked, void 0, ()=>{});
+        return checked;
+    }
+    function copyLoader(value) {
+        if (nativePromise(value)) return copyPromise(value);
+        if (!record(value)) return copyPublic(value);
+        policy.assertRoot(value);
+        const fields = descriptors(value);
+        if (!Object.values(fields).some((field)=>nativePromise(field.value))) return copyPublic(value);
+        const previous = copies.get(value);
+        if (previous) return previous;
+        const result = Object.create(Object.getPrototypeOf(value));
+        copies.set(value, result);
+        for (const [key, field] of Object.entries(fields))Object.defineProperty(result, key, {
+            ...field,
+            value: nativePromise(field.value) ? copyPromise(field.value) : copyPublic(field.value)
+        });
+        if (!Object.isExtensible(value)) Object.preventExtensions(result);
+        return result;
+    }
+    function projectRoot(value) {
+        assertActive();
+        assertMatches();
+        if (!record(value) || Object.getPrototypeOf(value) !== Object.prototype) throw invalid('the first native serializer value must be its fresh outer record');
+        const fields = descriptors(value, NATIVE_ROOT_FIELDS);
+        const matches = fields['matches']?.value;
+        if (!fields['manifest'] || !Array.isArray(matches)) throw invalid('the native outer record shape changed');
+        const arrayFields = descriptors(matches);
+        const projectedMatches = [];
+        for(let index = 0; index < matches.length; index++){
+            const match = arrayFields[String(index)]?.value;
+            if (!record(match)) throw invalid('native matches must be dense records');
+            const matchFields = descriptors(match, MATCH_FIELDS);
+            const projected = {};
+            const id = stringField(matchFields, 'i');
+            const status = stringField(matchFields, 's');
+            const updatedAt = matchFields['u']?.value;
+            if (!id || 'number' != typeof updatedAt || !Number.isFinite(updatedAt)) throw invalid('native match metadata changed');
+            if (![
+                'pending',
+                'success',
+                'error',
+                'notFound',
+                'redirected'
+            ].includes(status)) throw invalid('native match status changed');
+            projected['i'] = id;
+            projected['u'] = updatedAt;
+            projected['s'] = status;
+            for (const [key, field] of Object.entries(matchFields))if ('i' !== key && 'u' !== key && 's' !== key) projected[key] = 'l' === key ? copyLoader(field.value) : 'e' === key ? copyError(field.value) : copyPublic(field.value);
+            projectedMatches.push(projected);
+        }
+        const result = {
+            manifest: copyPublic(fields['manifest'].value),
+            matches: projectedMatches
+        };
+        if (fields['lastMatchId']) result['lastMatchId'] = stringField(fields, 'lastMatchId');
+        if (fields['dehydratedData']) result['dehydratedData'] = copyPublic(fields['dehydratedData'].value);
+        projectedRoots.add(result);
+        return result;
+    }
+    const adapter = Object.freeze(createSerializationAdapter({
+        key: ADAPTER_KEY,
+        test (value) {
+            if (null === value || 'object' != typeof value || projectedRoots.has(value)) return false;
+            if (nativeRoot) return false;
+            nativeRoot = value;
+            return true;
+        },
+        toSerializable (value) {
+            try {
+                return projectRoot(value);
+            } catch (error) {
+                return fail(error);
+            }
+        },
+        fromSerializable: octaneRouterSnapshotAdapter.fromSerializable
+    }));
+    const adapters = Object.freeze([
+        adapter
+    ]);
+    const wrappedDehydrate = async ()=>{
+        try {
+            assertMatches();
+            const result = 'function' == typeof consumerDehydrate ? await untilAborted(Reflect.apply(consumerDehydrate, router.options, []), session.signal) : void 0;
+            assertMatches();
+            return result;
+        } catch (error) {
+            return fail(error);
+        }
+    };
+    const nativeOptions = {
+        ...router.options,
+        serializationAdapters: adapters,
+        dehydrate: wrappedDehydrate
+    };
+    router.update(nativeOptions);
+    session.registerCleanup(()=>{
+        released = true;
+        cleanupOctaneRouterSSR(router);
+    });
+    function assertMatches() {
+        try {
+            assertActive();
+            const currentAdapters = Object.getOwnPropertyDescriptor(router.options, 'serializationAdapters');
+            const currentDehydrate = Object.getOwnPropertyDescriptor(router.options, 'dehydrate');
+            if (currentAdapters?.get || currentAdapters?.set || currentAdapters?.value !== adapters || currentDehydrate?.get || currentDehydrate?.set || currentDehydrate?.value !== wrappedDehydrate) throw invalid('the request serializer owner was replaced');
+            for (const match of router.stores.matches.get()){
+                const prototype = Object.getPrototypeOf(match);
+                if (prototype !== Object.prototype && null !== prototype) throw invalid('native matches require owned plain records');
+                for (const key of [
+                    'id',
+                    'routeId',
+                    'updatedAt',
+                    'status',
+                    '__beforeLoadContext',
+                    'loaderData',
+                    'error',
+                    'ssr',
+                    'globalNotFound',
+                    'styles',
+                    'headScripts'
+                ]){
+                    const field = Object.getOwnPropertyDescriptor(match, key);
+                    if (field?.get || field?.set) throw invalid('native match fields must be owned values before dehydrate');
+                    if (!field && prototype && Object.getOwnPropertyDescriptor(prototype, key)) throw invalid('native match fields cannot be inherited');
+                    if (('id' === key || 'routeId' === key) && ('string' != typeof field?.value || !field.value)) throw invalid('native match identity must be an owned nonempty string');
+                    if ('updatedAt' === key && ('number' != typeof field?.value || !Number.isFinite(field.value))) throw invalid('native updatedAt must be an owned finite number');
+                    if ('status' === key && ('string' != typeof field?.value || ![
+                        'pending',
+                        'success',
+                        'error',
+                        'notFound',
+                        'redirected'
+                    ].includes(field.value))) throw invalid('native status must be an owned supported string');
+                    if (('styles' === key || 'headScripts' === key) && field?.value !== void 0) {
+                        const value = field.value;
+                        if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) throw invalid('native styles/headScripts are not admitted by the fragment host');
+                        const fields = descriptors(value);
+                        if (fields['length']?.value !== 0 || 1 !== Reflect.ownKeys(value).length) throw invalid('native styles/headScripts are not admitted by the fragment host');
+                    }
+                }
+            }
+        } catch (error) {
+            fail(error);
+        }
+    }
+    return {
+        assertActive,
+        assertMatches
+    };
+}
+export { prepareOctaneRouterSerialization };

package/dist/esm/router-server.mjs

@@ -0,0 +1,11 @@
+import { RouterProvider } from "@octanejs/tanstack-router";
+import { createElement } from "octane/server";
+export * from "@octanejs/tanstack-router/ssr/server";
+function OctaneRouterServer({ router }) {
+    return createElement(RouterProvider, {
+        router
+    });
+}
+export { createOctaneRequestHandler } from "./router-handler.mjs";
+export { prepareOctaneRouterSerialization } from "./router-server-snapshot.mjs";
+export { OctaneRouterServer };

package/dist/esm/router-snapshot.mjs

@@ -0,0 +1,199 @@
+import { DataProtocolError, assertPublicData } from "@modern-js/renderer-core/data";
+import { createSerializationAdapter } from "@octanejs/tanstack-router";
+import { RouteDataError } from "./routes.mjs";
+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 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'
+        ]));
+        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');
+    assertPublicData(error);
+    const restored = new 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 = createSerializationAdapter({
+    key: ADAPTER_KEY,
+    test: (_value)=>false,
+    toSerializable () {
+        throw invalid('the client decoder cannot serialize a server snapshot');
+    },
+    fromSerializable: decodeNativeSnapshot
+});
+export { ADAPTER_KEY, MATCH_FIELDS, NATIVE_ERROR_KIND, NATIVE_ROOT_FIELDS, ROUTE_ERROR_KIND, clearStack, descriptors, invalid, nativePromise, octaneRouterSnapshotAdapter, record, stringField };

package/dist/esm/router.mjs

@@ -0,0 +1,94 @@
+import { createDataClient } from "@modern-js/renderer-core/data";
+import { RouterProvider, createRouter, redirect, useMatch, useRouter } from "@octanejs/tanstack-router";
+import { createSubSlot, useCallback, useLayoutEffect, useRef } from "octane";
+import { assertOctaneIdentity } from "./bootstrap.mjs";
+import { RouteDataError, createFileSystemRouteTree, matchApplicationRouteIds, matchApplicationRoutes, resolveRouteData, selectApplicationDataRoute } from "./routes.mjs";
+export * from "@octanejs/tanstack-router";
+function useApplicationIdentity() {
+    const identity = 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');
+    assertOctaneIdentity(identity);
+    return Object.freeze({
+        ...identity
+    });
+}
+function useApplicationRouteId() {
+    const router = useRouter();
+    const routeId = 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 = 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(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) resolveRouteData(input.routeId, outcome);
+        else if ('success' === outcome.kind) await input.router.invalidate();
+        return outcome;
+    };
+}
+const actionSlot = 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 = useRouter();
+    const identity = useApplicationIdentity();
+    const routeId = useApplicationRouteId();
+    const owner = useRef(null, actionSlot(slot, 'owner'));
+    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 useCallback((previous, formData)=>createOctaneRouteAction({
+            router,
+            routeId,
+            identity,
+            url,
+            method,
+            fetch,
+            signal: owner.current?.signal
+        })(previous, formData), [
+        router,
+        routeId,
+        url,
+        method,
+        fetch
+    ], actionSlot(slot, 'action'));
+}
+export { RouteDataError, RouterProvider as ApplicationRouter, createFileSystemRouteTree, createOctaneRouteAction, createRouter as createApplicationRouter, matchApplicationRouteIds, matchApplicationRoutes, resolveRouteData, selectApplicationDataRoute, useApplicationIdentity, useApplicationRouteId, useOctaneRouteAction };