@sjcx/vorma 0.0.0-pre.2 → 0.0.0-pre.3

package/dist/metadata-BoPKo-G2.js

@@ -1,32 +0,0 @@
-import { Effect } from "effect";
-import { readFile } from "node:fs/promises";
-//#region src/server/development/metadata.ts
-/** Reads each atomic development publication; unchanged bytes retain the same snapshot. */
-function createDevelopmentMetadataReader(input) {
-	let previousText;
-	let previous = input.initial;
-	return Effect.tryPromise({
-		try: async (signal) => {
-			const text = await readFile(input.url, {
-				encoding: "utf8",
-				signal
-			});
-			if (text !== previousText) {
-				previous = {
-					...JSON.parse(text),
-					publicAssetDirectoryUrl: input.initial.publicAssetDirectoryUrl
-				};
-				previousText = text;
-			}
-			return previous;
-		},
-		catch: (cause) => {
-			return {
-				_tag: "DevelopmentMetadataIssue",
-				cause
-			};
-		}
-	});
-}
-//#endregion
-export { createDevelopmentMetadataReader };

package/dist/primitives/tasks/index.d.ts

@@ -1 +0,0 @@
-export * from "@vorma/primitives/tasks";

package/dist/primitives/tasks/index.js

@@ -1 +0,0 @@
-export * from "@vorma/primitives/tasks";

package/dist/route-context-CtY_9U_W.js

@@ -1,559 +0,0 @@
-import { o as canonicalizeRequestPathForMatcher } from "./value-transport-Bst4Hk-n.js";
-import { t as buildHref } from "./href-Cqyax8Y0.js";
-import { Cause, Context, Data, Effect, Layer, Option, Result, Scope, Stream } from "effect";
-import { AsyncResult, Atom } from "effect/unstable/reactivity";
-import { transportTypeEntries } from "virtual:vorma/client-transport-types";
-//#region src/client/errors.ts
-var InputError = class extends Data.TaggedError("InputError") {};
-var BuildMismatchError = class extends Data.TaggedError("BuildMismatchError") {};
-var TransportError = class extends Data.TaggedError("TransportError") {};
-var HandlerError = class extends Data.TaggedError("HandlerError") {};
-/** A later endpoint call with the same dedupe key cancelled this call's request. */
-var CancelledByDedupeKeyError = class extends Data.TaggedError("CancelledByDedupeKeyError") {};
-var NavigationError = class extends Data.TaggedError("NavigationError") {};
-var RevalidationError = class extends Data.TaggedError("RevalidationError") {};
-var PrefetchError = class extends Data.TaggedError("PrefetchError") {};
-var QueryRedirected = class extends Data.TaggedError("QueryRedirected") {};
-function unwrapSingleFailure(error) {
-	if (!Cause.isCause(error)) return error;
-	const reason = error.reasons.length === 1 ? error.reasons[0] : void 0;
-	return reason?._tag === "Fail" ? reason.error : void 0;
-}
-/** The sanitized presentation of any failure: explicit public fields, or a generic 500. */
-function sanitizeRouteError(error) {
-	const value = unwrapSingleFailure(error);
-	if (typeof value === "object" && value !== null && "status" in value && "clientMessage" in value && typeof value.status === "number" && typeof value.clientMessage === "string") return {
-		status: value.status,
-		clientMessage: value.clientMessage
-	};
-	return {
-		status: 500,
-		clientMessage: "An unexpected error occurred."
-	};
-}
-/** Recognizes typed navigation control without consuming defects or composite failures. */
-function getQueryRedirect(error) {
-	const value = unwrapSingleFailure(error);
-	return value instanceof QueryRedirected ? value : void 0;
-}
-//#endregion
-//#region src/client/state.ts
-const INITIAL_CLIENT_STATE = {
-	lifecycle: { _tag: "PreBoot" },
-	frame: null,
-	navigation: {
-		pending: null,
-		latest: AsyncResult.initial()
-	},
-	freshness: {
-		demand: null,
-		epoch: 0,
-		attempt: {
-			coveredSequence: null,
-			phase: "idle",
-			skipWorkIndicator: false,
-			waiters: [],
-			latest: AsyncResult.initial()
-		}
-	},
-	operations: /* @__PURE__ */ new Map(),
-	prefetch: /* @__PURE__ */ new Map(),
-	buildMismatch: Option.none(),
-	generation: 0,
-	sequence: 0
-};
-/** Registry-local state; private to the package. Public atoms are projections. */
-const clientStateAtom = Atom.make(INITIAL_CLIENT_STATE).pipe(Atom.keepAlive);
-//#endregion
-//#region src/client/projections.ts
-const frameAtom = Atom.readable((get) => get(clientStateAtom).frame);
-const navigationAtom = Atom.readable((get) => get(clientStateAtom).navigation);
-const freshnessAtom = Atom.readable((get) => get(clientStateAtom).freshness);
-const operationsAtom = Atom.readable((get) => get(clientStateAtom).operations);
-const prefetchAtom = Atom.readable((get) => get(clientStateAtom).prefetch);
-Atom.readable((get) => get(clientStateAtom).lifecycle);
-const committedFrameAtom = frameAtom;
-/** Projects server-public fields or preserves a browser-local cause according to its source. */
-function projectRouteError(error) {
-	const presentation = sanitizeRouteError(error.error);
-	if (error.source === "serverLoader") return {
-		...presentation,
-		pattern: error.pattern,
-		source: error.source
-	};
-	return {
-		...presentation,
-		pattern: error.pattern,
-		source: error.source,
-		cause: Cause.isCause(error.error) ? error.error : Cause.die(error.error)
-	};
-}
-/** The public route state of a frame. */
-function projectRouteState(frame) {
-	return {
-		href: frame.href,
-		historyState: Option.fromUndefinedOr(frame.historyState),
-		matches: frame.entries.map((entry) => {
-			return {
-				pattern: entry.pattern,
-				params: entry.params,
-				splatValues: entry.splatValues
-			};
-		}),
-		error: Option.map(Option.fromNullOr(frame.error), projectRouteError)
-	};
-}
-const routeStateAtom = Atom.map(frameAtom, (frame) => {
-	return frame === null ? Option.none() : Option.some(projectRouteState(frame));
-});
-const navigationStateAtom = Atom.map(navigationAtom, (navigation) => {
-	return {
-		pending: Option.fromNullOr(navigation.pending),
-		latestAttempt: navigation.latest
-	};
-});
-const revalidationStateAtom = Atom.map(freshnessAtom, (freshness) => {
-	return {
-		requiresRevalidation: freshness.demand !== null,
-		pending: freshness.attempt.phase === "running" ? Option.some({
-			phase: "running",
-			skipWorkIndicator: freshness.attempt.skipWorkIndicator && (freshness.demand === null || freshness.demand.skipWorkIndicator)
-		}) : freshness.attempt.phase === "retrying" ? Option.some({
-			phase: "scheduled",
-			skipWorkIndicator: freshness.attempt.skipWorkIndicator
-		}) : freshness.demand !== null && freshness.attempt.phase === "idle" ? Option.some({
-			phase: "scheduled",
-			skipWorkIndicator: freshness.demand.skipWorkIndicator
-		}) : Option.none(),
-		latestAttempt: freshness.attempt.latest
-	};
-});
-/**
-* Active queries depend on this; it changes only when a demand registers. It
-* is eager because its dependents are lazy runtime computations behind
-* wrappers, and the registry recomputes a lazy atom's lazy dependents only
-* when the atom itself is recomputed.
-*/
-const refreshEpochAtom = Atom.readable((get) => get(clientStateAtom).freshness.epoch).pipe(Atom.setLazy(false), Atom.keepAlive);
-const buildMismatchAtom = Atom.readable((get) => get(clientStateAtom).buildMismatch);
-const workStateAtom = Atom.readable((get) => {
-	const navigation = get(navigationStateAtom);
-	const revalidation = get(revalidationStateAtom);
-	const prefetch = get(prefetchAtom);
-	const operations = get(operationsAtom);
-	return {
-		navigation: navigation.pending,
-		revalidation: revalidation.pending,
-		prefetches: [...prefetch.values()].map((pending) => {
-			return {
-				href: pending.href,
-				phase: "preparing",
-				skipWorkIndicator: pending.skipWorkIndicator
-			};
-		}),
-		operations: [...operations.values()]
-	};
-});
-/** One operation's state while it is tracked; the observer retains the settled value afterward. */
-const getOperationStateAtom = Atom.family((id) => {
-	return Atom.readable((get) => {
-		const tracked = get(operationsAtom).get(id);
-		if (tracked !== void 0) return Option.some(tracked);
-		const previous = Option.flatten(get.self());
-		return Option.filter(previous, (value) => value.phase === "settled");
-	});
-});
-//#endregion
-//#region src/client/links.ts
-const NO_MATCH = {
-	active: {
-		exact: false,
-		ancestor: false
-	},
-	pending: {
-		exact: false,
-		ancestor: false
-	}
-};
-const NO_LINK_STATE_ATOM = Atom.make(NO_MATCH);
-function parseCandidate(href) {
-	const url = new URL(href, window.location.href);
-	return {
-		url,
-		path: Result.getOrNull(canonicalizeRequestPathForMatcher(url.pathname))
-	};
-}
-function matchesExactly(input) {
-	const { target, candidate, rules } = input;
-	return target.path !== null && target.path === candidate.path && (rules.includeSearch !== true || target.url.search === candidate.url.search) && (rules.includeHash !== true || target.url.hash === candidate.url.hash);
-}
-function matchesAncestor(input) {
-	const { target, candidate, targetPattern, candidatePatterns } = input;
-	if (target.path === null || candidate.path === null) return false;
-	const prefix = target.path === "/" ? "/" : `${target.path}/`;
-	return target.path !== candidate.path && (prefix === "/" || candidate.path.startsWith(prefix)) && (targetPattern === void 0 || candidatePatterns === void 0 || candidatePatterns.includes(targetPattern));
-}
-function equalsLinkState(current, next) {
-	return current.active.exact === next.active.exact && current.active.ancestor === next.active.ancestor && current.pending.exact === next.pending.exact && current.pending.ancestor === next.pending.ancestor;
-}
-const getLinkStateAtomByKey = Atom.family((key) => {
-	const { href, pattern } = key;
-	const rules = key;
-	return Atom.readable((get) => {
-		const route = get(routeStateAtom);
-		if (Option.isNone(route)) return NO_MATCH;
-		const target = parseCandidate(href);
-		if (target.url.origin !== window.location.origin) return NO_MATCH;
-		const committed = parseCandidate(route.value.href);
-		const patterns = route.value.matches.map((match) => match.pattern);
-		const pendingHref = Option.map(get(navigationStateAtom).pending, (pending) => pending.href);
-		const pending = Option.map(pendingHref, parseCandidate);
-		return {
-			active: {
-				exact: matchesExactly({
-					target,
-					candidate: committed,
-					rules
-				}),
-				ancestor: matchesAncestor({
-					target,
-					candidate: committed,
-					targetPattern: pattern,
-					candidatePatterns: patterns
-				})
-			},
-			pending: {
-				exact: Option.isSome(pending) ? matchesExactly({
-					target,
-					candidate: pending.value,
-					rules
-				}) : false,
-				ancestor: Option.isSome(pending) ? matchesAncestor({
-					target,
-					candidate: pending.value,
-					targetPattern: pattern,
-					candidatePatterns: void 0
-				}) : false
-			}
-		};
-	}).pipe(Atom.withEquality(equalsLinkState));
-});
-/** The active and pending facts of a resolved link target under its match rules. */
-function getLinkStateAtomFor(input) {
-	if (input.rules?.skip === true) return NO_LINK_STATE_ATOM;
-	return getLinkStateAtomByKey({
-		href: input.href,
-		pattern: input.pattern,
-		includeSearch: input.rules?.includeSearch === true,
-		includeHash: input.rules?.includeHash === true
-	});
-}
-/** Whether a click may be intercepted: unmodified, primary, and targeting this browsing context. */
-function allowsInterception(event, targetAttribute) {
-	return !(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) && (event.button === void 0 || event.button === 0) && (targetAttribute === void 0 || targetAttribute === "" || targetAttribute === "_self");
-}
-/** Whether the device's last pointer input was touch. */
-let touchActive = false;
-/** Tracks whether the last pointer input was touch; the returned function detaches. */
-function attachPointerModalityTracking() {
-	function handleTouchStart() {
-		touchActive = true;
-	}
-	function handlePointerInput(event) {
-		if (event.pointerType === "touch") touchActive = true;
-		else if (event.pointerType === "mouse" || event.pointerType === "pen") touchActive = false;
-	}
-	window.addEventListener("touchstart", handleTouchStart);
-	window.addEventListener("pointerdown", handlePointerInput);
-	window.addEventListener("pointermove", handlePointerInput);
-	return () => {
-		window.removeEventListener("touchstart", handleTouchStart);
-		window.removeEventListener("pointerdown", handlePointerInput);
-		window.removeEventListener("pointermove", handlePointerInput);
-	};
-}
-/** One link's prefetch intent: an observer handle held from a pointer's or focus's arrival until either leaves. */
-function createLinkIntent(input) {
-	let timer;
-	let release;
-	function acquirePrefetchHold() {
-		const url = Result.try(() => new URL(input.getHrefFn(), window.location.href));
-		if (Result.isFailure(url) || url.success.origin !== window.location.origin) return;
-		const fiber = input.coordinator.fork(input.coordinator.prefetch.holdUntilInterrupted(url.success, { skipWorkIndicator: input.skipWorkIndicator }));
-		release = () => fiber.interruptUnsafe();
-	}
-	function releasePrefetchHold() {
-		if (timer !== void 0) {
-			window.clearTimeout(timer);
-			timer = void 0;
-		}
-		release?.();
-		release = void 0;
-	}
-	return {
-		begin: (_source, delayMs) => {
-			if (release !== void 0 || timer !== void 0) return;
-			timer = window.setTimeout(() => {
-				timer = void 0;
-				acquirePrefetchHold();
-			}, delayMs ?? 100);
-		},
-		end: (source) => {
-			if (source === "pointer" && touchActive) return;
-			releasePrefetchHold();
-		},
-		reset: releasePrefetchHold
-	};
-}
-//#endregion
-//#region src/client/transport-type-entries.ts
-/** The Effect data types that occur in this application's contracts. */
-const CLIENT_TRANSPORT_TYPE_ENTRIES = transportTypeEntries;
-//#endregion
-//#region src/client/route-url.ts
-/** Returns a raw href unchanged or encodes a typed destination as an origin-relative URL. */
-function toHref(input) {
-	if (input.href !== void 0) return Result.succeed(input.href);
-	const href = buildHref({
-		kind: "ui",
-		pattern: input.pattern,
-		transportTypeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES,
-		...input.params === void 0 ? {} : { params: input.params },
-		...input.splatValues === void 0 ? {} : { splatValues: input.splatValues },
-		...input.input === void 0 ? {} : { search: input.input },
-		...input.hash === void 0 ? {} : { hash: input.hash }
-	});
-	return Result.isFailure(href) ? Result.fail(new InputError({
-		pattern: input.pattern,
-		message: href.failure.reason,
-		cause: href.failure
-	})) : Result.succeed(href.success);
-}
-//#endregion
-//#region src/client/runtime.ts
-const CLIENT_UNAVAILABLE_ERROR = { _tag: "ClientUnavailableError" };
-const ClientCoordinator = Context.Service("vorma/client/ClientCoordinator");
-const applicationContextsAtom = Atom.make(Option.none());
-function publishApplicationContexts(input) {
-	input.registry.set(applicationContextsAtom, Option.some(input.contexts));
-}
-/** Browser operations and both service groups. Asynchronous computations stay Initial before boot. */
-const clientRuntime = Atom.runtime((get) => {
-	return Option.match(get(applicationContextsAtom), {
-		onNone: () => Layer.effectContext(Effect.fail(CLIENT_UNAVAILABLE_ERROR)),
-		onSome: (contexts) => Layer.succeedContext(contexts.client)
-	});
-});
-/** Provides only the application's universal service group. */
-const universalRuntime = Atom.runtime((get) => {
-	return Option.match(get(applicationContextsAtom), {
-		onNone: () => Layer.effectContext(Effect.fail(CLIENT_UNAVAILABLE_ERROR)),
-		onSome: (contexts) => Layer.succeedContext(contexts.universal)
-	});
-});
-/** Runs an Effect with the mounted application's client context. */
-function provideClientContext(contexts, effect) {
-	return Effect.provide(effect, contexts.client);
-}
-//#endregion
-//#region src/client/work-indicator.ts
-const optionsAtom = Atom.make(void 0).pipe(Atom.keepAlive);
-const applicationWorkCountAtom = Atom.make(0);
-/** Whether included framework work or explicitly tracked application work is unfinished. */
-const workIndicatorActiveAtom = Atom.readable((get) => {
-	if (get(applicationWorkCountAtom) > 0) return true;
-	const options = get(optionsAtom);
-	if (options === void 0) return false;
-	const work = get(workStateAtom);
-	return options.skipNavigations !== true && Option.isSome(work.navigation) && !work.navigation.value.skipWorkIndicator || options.skipRevalidations !== true && Option.isSome(work.revalidation) && !work.revalidation.value.skipWorkIndicator || options.skipApiRequests !== true && work.operations.some((operation) => {
-		return operation.phase !== "settled" && !operation.skipWorkIndicator;
-	});
-});
-function createWorkIndicator(core, options) {
-	core.registry.set(optionsAtom, options);
-	function track(effect) {
-		return Effect.acquireUseRelease(Effect.sync(() => {
-			core.registry.update(applicationWorkCountAtom, (count) => count + 1);
-		}), () => effect, () => {
-			return Effect.sync(() => {
-				core.registry.update(applicationWorkCountAtom, (count) => count - 1);
-			});
-		});
-	}
-	function start() {
-		if (options === void 0) return Effect.void;
-		const configured = options;
-		return Effect.gen(function* () {
-			let visible = false;
-			let pending;
-			const unsubscribe = core.registry.subscribe(workIndicatorActiveAtom, (active) => {
-				pending?.interruptUnsafe();
-				pending = void 0;
-				if (visible === active) return;
-				pending = core.forkFiber(Effect.sleep(active ? configured.startDelayMs : configured.stopDelayMs).pipe(Effect.andThen(Effect.sync(() => {
-					visible = active;
-					if (active) configured.startFn();
-					else configured.stopFn();
-				}))));
-			}, { immediate: true });
-			yield* Scope.addFinalizer(core.scope, Effect.sync(() => {
-				unsubscribe();
-				pending?.interruptUnsafe();
-				if (visible) configured.stopFn();
-			}));
-		});
-	}
-	return {
-		start,
-		track
-	};
-}
-//#endregion
-//#region src/client/route-synchronization.ts
-function makeTargetError(cause) {
-	return new NavigationError({
-		stage: "target",
-		cause: Cause.isCause(cause) ? cause : Cause.fail(cause)
-	});
-}
-function resolveSynchronizationTarget(input) {
-	const href = input.href;
-	if (Result.isFailure(href)) return Result.fail(makeTargetError(href.failure));
-	const url = Result.try(() => new URL(href.success, window.location.href));
-	return Result.isFailure(url) ? Result.fail(makeTargetError(url.failure)) : Result.succeed({
-		href: url.success.href,
-		navigationOptions: input.navigationOptions
-	});
-}
-function matchesEquivalentRoute(coordinator, href) {
-	const route = coordinator.registry.get(routeStateAtom);
-	if (Option.isSome(route) && route.value.href === href) return true;
-	const navigation = coordinator.registry.get(navigationStateAtom);
-	return Option.isSome(navigation.pending) && navigation.pending.value.href === href;
-}
-function runSynchronizationTarget(input) {
-	if (matchesEquivalentRoute(input.coordinator, input.target.href)) return Effect.void;
-	const delay = input.debounceDelay === void 0 ? Effect.void : Effect.sleep(input.debounceDelay);
-	return Effect.andThen(delay, Effect.suspend(() => {
-		return matchesEquivalentRoute(input.coordinator, input.target.href) ? Effect.void : Effect.asVoid(input.coordinator.navigation.navigate(input.target.href, input.target.navigationOptions));
-	}));
-}
-function readSynchronizationTarget(input) {
-	return Effect.suspend(() => {
-		const resolved = resolveSynchronizationTarget({
-			href: input.href,
-			navigationOptions: {
-				replace: input.options.replace ?? true,
-				scrollToTop: input.options.scrollToTop ?? false,
-				scrollToFragment: input.options.scrollToFragment ?? false,
-				...input.options.skipWorkIndicator === void 0 ? {} : { skipWorkIndicator: input.options.skipWorkIndicator }
-			}
-		});
-		if (Result.isFailure(resolved)) input.coordinator.navigation.recordTargetFailure(resolved.failure);
-		return Effect.fromResult(resolved);
-	});
-}
-/** Keeps a route synchronized with the latest target from a native Stream. */
-function synchronizeRoute(input) {
-	return Effect.flatMap(ClientCoordinator, (coordinator) => {
-		return input.targets.pipe(Stream.mapEffect((target) => {
-			return readSynchronizationTarget({
-				coordinator,
-				href: toHref(target),
-				options: input
-			});
-		}), Stream.switchMap((target) => {
-			return Stream.fromEffect(runSynchronizationTarget({
-				coordinator,
-				target,
-				debounceDelay: input.debounceDelay
-			}));
-		}), Stream.runDrain);
-	});
-}
-//#endregion
-//#region src/client/route-context.ts
-const ROUTE_CONTEXT = Symbol("vorma/client/RouteContext");
-function selectMatch(entry) {
-	return {
-		pattern: entry.pattern,
-		params: entry.params,
-		splatValues: entry.splatValues,
-		input: entry.input
-	};
-}
-/**
-* The value for the entry the context currently sees, or for the entry it
-* last saw: a context outlives its entry by one render when a commit replaces
-* the position, and before any computation it saw the entry it was created
-* from.
-*/
-function selectRetainedValue(get, own, creation, selectFn) {
-	const entry = get(own);
-	if (entry !== void 0) return selectFn(entry);
-	const previous = get.self();
-	return Option.isSome(previous) ? previous.value : selectFn(creation);
-}
-/** The route context of a view mounted at `index` for `entry`; its atoms follow that position while it holds the entry's pattern. */
-function createRouteContext(index, entry) {
-	const own = Atom.readable((get) => {
-		const committed = get(committedFrameAtom);
-		if (committed !== null && committed.error !== null && committed.error.index <= index) return;
-		const current = committed === null ? void 0 : committed.entries[index];
-		return current?.pattern === entry.pattern ? current : void 0;
-	});
-	return { [ROUTE_CONTEXT]: {
-		pattern: entry.pattern,
-		index,
-		loaderDataAtom: Atom.readable((get) => {
-			return selectRetainedValue(get, own, entry, (current) => {
-				return current.loaderData;
-			});
-		}),
-		clientLoaderDataAtom: Atom.readable((get) => {
-			return selectRetainedValue(get, own, entry, (current) => {
-				return AsyncResult.isSuccess(current.clientLoaderData) ? current.clientLoaderData.value : void 0;
-			});
-		}),
-		matchAtom: Atom.readable((get) => {
-			return selectRetainedValue(get, own, entry, selectMatch);
-		})
-	} };
-}
-/** The committed entry with `pattern`, wherever it sits in the chain. */
-const getPatternEntryAtom = Atom.family((pattern) => {
-	return Atom.readable((get) => {
-		const committed = get(committedFrameAtom);
-		return Option.fromNullishOr(committed === null ? void 0 : committed.entries.find((entry) => entry.pattern === pattern));
-	});
-});
-const getLoaderDataAtomByPattern = Atom.family((pattern) => {
-	return Atom.readable((get) => {
-		return Option.map(get(getPatternEntryAtom(pattern)), (entry) => {
-			return entry.loaderData;
-		});
-	});
-});
-const getClientLoaderDataAtomByPattern = Atom.family((pattern) => {
-	return Atom.readable((get) => {
-		return Option.map(get(getPatternEntryAtom(pattern)), (entry) => {
-			return entry.clientLoaderData;
-		});
-	});
-});
-const getMatchAtomByPattern = Atom.family((pattern) => {
-	return Atom.readable((get) => {
-		return Option.map(get(getPatternEntryAtom(pattern)), selectMatch);
-	});
-});
-function getLoaderDataAtom(input) {
-	return typeof input === "string" ? getLoaderDataAtomByPattern(input) : input[ROUTE_CONTEXT].loaderDataAtom;
-}
-function getClientLoaderDataAtom(input) {
-	return typeof input === "string" ? getClientLoaderDataAtomByPattern(input) : input[ROUTE_CONTEXT].clientLoaderDataAtom;
-}
-function getRouteMatchAtom(input) {
-	return typeof input === "string" ? getMatchAtomByPattern(input) : input[ROUTE_CONTEXT].matchAtom;
-}
-//#endregion
-export { routeStateAtom as A, RevalidationError as B, committedFrameAtom as C, projectRouteState as D, projectRouteError as E, HandlerError as F, getQueryRedirect as H, InputError as I, NavigationError as L, clientStateAtom as M, BuildMismatchError as N, refreshEpochAtom as O, CancelledByDedupeKeyError as P, PrefetchError as R, buildMismatchAtom as S, navigationStateAtom as T, TransportError as V, CLIENT_TRANSPORT_TYPE_ENTRIES as _, readSynchronizationTarget as a, createLinkIntent as b, createWorkIndicator as c, ClientCoordinator as d, clientRuntime as f, toHref as g, universalRuntime as h, getRouteMatchAtom as i, workStateAtom as j, revalidationStateAtom as k, workIndicatorActiveAtom as l, publishApplicationContexts as m, getClientLoaderDataAtom as n, runSynchronizationTarget as o, provideClientContext as p, getLoaderDataAtom as r, synchronizeRoute as s, createRouteContext as t, CLIENT_UNAVAILABLE_ERROR as u, allowsInterception as v, getOperationStateAtom as w, getLinkStateAtomFor as x, attachPointerModalityTracking as y, QueryRedirected as z };

package/dist/route-matching-D_uSG2P9.js

@@ -1,33 +0,0 @@
-import { l as decodeMatchCaptures } from "./value-transport-Bst4Hk-n.js";
-import { _ as CLIENT_TRANSPORT_TYPE_ENTRIES } from "./route-context-CtY_9U_W.js";
-import { t as parseSearchParams } from "./search-parse-0f7oqVsG.js";
-import { Option, Result } from "effect";
-import { createNestedValueMatcher, findNestedValueMatches } from "@vorma/primitives/matcher";
-//#region src/client/route-matching.ts
-function createLearnedMatcher(registrations) {
-	const matcher = createNestedValueMatcher(registrations);
-	return { matchPath: (path) => {
-		const matches = findNestedValueMatches(matcher, path);
-		if (Option.isNone(matches)) return null;
-		const chain = [];
-		for (const match of matches.value) {
-			const captures = decodeMatchCaptures(match);
-			if (Result.isFailure(captures)) return null;
-			chain.push({
-				value: match.value,
-				...captures.success
-			});
-		}
-		return chain;
-	} };
-}
-/** Parses a destination's search through the decoded contract structure, without validating its checks. */
-function parseSearch(input) {
-	return parseSearchParams({
-		document: input.document,
-		params: input.searchParams,
-		typeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES
-	});
-}
-//#endregion
-export { createLearnedMatcher, parseSearch };