@orkestrel/router 0.0.1 → 0.0.3

package/README.md

@@ -17,11 +17,40 @@ npm install @orkestrel/router
 - ESM-only (no CommonJS build)
 - Server and browser environments both supported
 
-## Status
+## Usage
+
+```ts
+import { createDispatcher, createRouter } from '@orkestrel/router'
+
+const router = createRouter<{ readonly page: string }>()
+router.add({ path: '/users/:id', meta: { page: 'profile' } })
+router.match('/users/7') // { path: '/users/:id', params: { id: '7' }, meta: { page: 'profile' } }
+
+const dispatcher = createDispatcher<{ readonly userId: string }>({
+	routes: [
+		{
+			method: 'GET',
+			path: '/users/:id',
+			handler: (_request, context) => Response.json(context.params),
+		},
+	],
+})
+const response = await dispatcher.handle(new Request('http://x/users/7'), { userId: 'me' })
+```
+
+`Router` is the shared registry-and-match engine — literal-over-param-over-wildcard
+precedence, trailing-slash folding, and tolerant percent-decoding — that both `Dispatcher`
+(fetch-standard, method-dimensioned) and the browser `Navigator` compose. Path params are
+inferred at the type level from the literal pattern via `PathParams`, and `route()` pins a
+`RouteInput`'s path so literal inference survives across call sites. The `./browser` entry
+adds `createNavigator` for headless History/hash navigation; the `./server` entry adds
+`buildRequest` / `sendResponse` / `createListener` for `node:http`.
+
+## Guide
 
-The public API is under design and not yet implemented — this package
-currently ships no runtime code. This README will gain an install snippet,
-usage examples, and a guide link once the design lands.
+For the full surface — the core `Router`, the `Dispatcher`, the browser `Navigator`, and the
+`node:http` server adapter — see
+[`guides/src/router.md`](guides/src/router.md).
 
 ## Package
 

package/dist/src/browser/index.d.ts

@@ -1,4 +1,283 @@
-export type * from './types.js';
-export * from './helpers.js';
-export * from './Navigator.js';
-export * from './factories.js';
+import { EmitterErrorHandler } from '@orkestrel/emitter';
+import { EmitterHooks } from '@orkestrel/emitter';
+import { EmitterInterface } from '@orkestrel/emitter';
+import { RouteEntry } from '../core/index.ts';
+import { RouterInterface } from '../core/index.ts';
+import { RouterMatch } from '../core/index.ts';
+
+/**
+ * Create a {@link NavigatorInterface} — the headless History/hash navigation
+ * entity composing one core `Router<RouteEntry<Meta>>`.
+ *
+ * @remarks
+ * Prefer this over `new Navigator(...)` at call sites that only need the
+ * interface.
+ *
+ * @typeParam Meta - The opaque per-route payload a match carries back
+ * @param options - The `routes` to register, the `history` toggle (default
+ *   `false`, hash mode), an optional `base` (history mode), an optional
+ *   `fallback` path, an optional `guard` hook, opt-in link `intercept`
+ *   (history mode), the `sensitive` case toggle, and the AGENTS §13 emitter
+ *   `on`/`error` wiring
+ * @returns A live {@link NavigatorInterface} handle — call `start()` to begin
+ *   dispatching
+ *
+ * @example
+ * ```ts
+ * import { createNavigator } from '@src/browser'
+ *
+ * const navigator = createNavigator({
+ * 	routes: [
+ * 		{ path: '/users/:id', meta: { title: 'User' } },
+ * 		{ path: '/tokens', meta: { title: 'Tokens' } },
+ * 	],
+ * 	on: { navigate: (match) => (document.title = match.meta.title) },
+ * })
+ * navigator.start()
+ * ```
+ */
+export declare function createNavigator<Meta>(options: NavigatorOptions<Meta>): NavigatorInterface<Meta>;
+
+/**
+ * Extract the `/`-prefixed pathname from a `location.hash` value — strip the
+ * leading `#` (keeping the route's own leading `/`) and any `?query` suffix.
+ *
+ * @remarks
+ * The grammar this package matches everywhere is `/`-prefixed (§4 path
+ * grammar), so a hash-mode location's `'#/users/7?x'` becomes `'/users/7'`
+ * — a hash pattern is expected to start `'#/'`; anything else (an empty hash,
+ * or one that does not begin `'#/'`) yields `''` (the `Navigator` then falls
+ * back). Total — never throws.
+ *
+ * @param hash - The raw `window.location.hash` value (e.g. `'#/users/7?x'`)
+ * @returns The `/`-prefixed pathname to match, or `''` for an empty / non-`#/` hash
+ *
+ * @example
+ * ```ts
+ * extractHashPath('#/users/7?x') // '/users/7'
+ * extractHashPath('#/tokens') // '/tokens'
+ * extractHashPath('') // '' — the Navigator falls back
+ * extractHashPath('#other') // '' — not a `#/` route hash
+ * ```
+ */
+export declare function extractHashPath(hash: string): string;
+
+/**
+ * Find the nearest enclosing `<a>` element a DOM event originated from, by
+ * walking its composed path — the pure lookup behind history-mode link
+ * interception.
+ *
+ * @remarks
+ * Uses `event.composedPath()` (not `event.target`) so a click on a styled
+ * child INSIDE an anchor (an icon, a span) still resolves to the anchor.
+ * Total — never throws; returns `undefined` when no anchor is found on the
+ * path.
+ *
+ * @param event - The DOM event to search (typically a `click`)
+ * @returns The nearest enclosing `HTMLAnchorElement`, or `undefined`
+ *
+ * @example
+ * ```ts
+ * document.addEventListener('click', (event) => {
+ * 	const anchor = findAnchor(event)
+ * 	if (anchor !== undefined) console.log(anchor.href)
+ * })
+ * ```
+ */
+export declare function findAnchor(event: Event): HTMLAnchorElement | undefined;
+
+/**
+ * The headless History/hash navigation entity — composes one core
+ * `Router<RouteEntry<Meta>>`, resolving the current location on `start()` and
+ * every subsequent navigation event, tracking `active`, and emitting
+ * `navigate` through the core {@link Emitter} (AGENTS §13). No `render` /
+ * `outlet` — the consumer owns rendering.
+ *
+ * @typeParam Meta - The opaque per-route payload a match carries back
+ *
+ * @remarks
+ * - **One shared engine.** Each `route.path` is registered on the SAME
+ *   `Router` machine the core `Dispatcher` composes, keyed for dedup by its
+ *   {@link canonicalizePath} (last write wins, replace-in-place) — literal-
+ *   over-param precedence, trailing-slash insensitivity, and
+ *   `:param`/`*wildcard` extraction all come from that one engine (AGENTS
+ *   §21).
+ * - **Resolve pipeline.** Compute the `/`-prefixed pathname to match
+ *   ({@link resolveLocationPath}) → {@link match} it → on a miss, match the
+ *   `fallback` through the SAME engine → a fallback that ALSO matches nothing
+ *   aborts any pending guarded navigation (a miss SUPERSEDES it, same as a
+ *   newer navigation) and leaves `active` `undefined`, emitting nothing
+ *   (§21-honest: no phantom match is fabricated) → the optional `guard` may
+ *   veto → on a verdict, `active` is set and `navigate` emitted.
+ * - **Supersede-safe guard.** Every navigation mints an `@orkestrel/abort`
+ *   handle, aborting the PREVIOUS navigation's handle first; a guard verdict
+ *   that resolves after its navigation was superseded (`signal.aborted`) is
+ *   discarded, same as a `false`/rejected verdict. A guard throw routes to
+ *   the `error` handler and vetoes. `stop()`/`destroy()` also abort the
+ *   pending handle.
+ * - **Hash vs history mode.** Hash mode (`history: false`, the default) binds
+ *   `hashchange`; history mode (`history: true`) binds `popstate` and, when
+ *   `intercept` is set, same-origin `<a>` click interception (a plain
+ *   left-click with no modifier keys, `target`, or `download` attribute).
+ *
+ * @example
+ * ```ts
+ * const navigator = new Navigator<{ readonly title: string }>({
+ * 	routes: [
+ * 		{ path: '/users/:id', meta: { title: 'User' } },
+ * 		{ path: '/tokens', meta: { title: 'Tokens' } },
+ * 	],
+ * })
+ * navigator.emitter.on('navigate', (match) => (document.title = match.meta.title))
+ * navigator.start() // resolves the current hash now, and on every hashchange
+ * navigator.navigate('/tokens')
+ * ```
+ */
+declare class Navigator_2<Meta> implements NavigatorInterface<Meta> {
+    #private;
+    constructor(options: NavigatorOptions<Meta>);
+    get router(): RouterInterface<RouteEntry<Meta>>;
+    get emitter(): EmitterInterface<NavigatorEventMap<Meta>>;
+    get active(): RouterMatch<Meta> | undefined;
+    start(): void;
+    stop(): void;
+    navigate(path: string): void;
+    match(path: string): RouterMatch<Meta> | undefined;
+    destroy(): void;
+}
+export { Navigator_2 as Navigator }
+
+/**
+ * The `Navigator`'s event map (AGENTS §13) — the single `navigate` signal a
+ * consumer observes.
+ *
+ * @typeParam Meta - The opaque per-route payload the resolved match carries
+ *
+ * @remarks
+ * `navigate` fires once per successful resolution (start, hashchange/popstate,
+ * `navigate()`, link interception) — never for a vetoed or superseded navigation
+ * ({@link NavigatorOptions.guard}), and never when a miss's fallback also
+ * misses (§21-honest: `active` is left `undefined`, nothing emitted).
+ */
+export declare type NavigatorEventMap<Meta> = {
+    readonly navigate: readonly [match: RouterMatch<Meta>];
+};
+
+/**
+ * The headless History/hash navigation entity contract (the §4.5 behavioral-
+ * interface role for the one-class-per-file `Navigator`). Composes a core
+ * `Router<RouteEntry<Meta>>`, resolves the current location on `start()` and
+ * on every subsequent navigation event, tracks `active`, and emits
+ * `navigate` through the AGENTS §13 {@link EmitterInterface}.
+ *
+ * @typeParam Meta - The opaque per-route payload a match carries back
+ *
+ * @remarks
+ * - `router` — the underlying registry, exposed READONLY for introspection
+ *   (the same object routes were registered on).
+ * - `emitter` — the AGENTS §13 observable surface for {@link NavigatorEventMap}.
+ * - `active` — the currently-resolved {@link RouterMatch}, or `undefined`
+ *   before the first resolve (or when a miss's fallback also misses).
+ * - `start()` — begin listening (`hashchange` in hash mode; `popstate` +
+ *   optional link interception in history mode) and resolve the current
+ *   location now. Idempotent — a second call is a no-op.
+ * - `stop()` — stop listening. Idempotent.
+ * - `navigate(path)` — navigate programmatically: sets `location.hash` (hash
+ *   mode) or calls `history.pushState` (history mode), then resolves. A
+ *   no-op hash navigation (already the active hash) resolves directly, since
+ *   no `hashchange` would otherwise fire.
+ * - `match(path)` — a PURE lookup through the underlying `Router`: no
+ *   location read, no fallback, no guard, no emit.
+ * - `destroy()` — `stop()` plus tear down the `#emitter` (AGENTS §13).
+ */
+export declare interface NavigatorInterface<Meta> {
+    readonly router: RouterInterface<RouteEntry<Meta>>;
+    readonly emitter: EmitterInterface<NavigatorEventMap<Meta>>;
+    readonly active: RouterMatch<Meta> | undefined;
+    start(): void;
+    stop(): void;
+    navigate(path: string): void;
+    match(path: string): RouterMatch<Meta> | undefined;
+    destroy(): void;
+}
+
+/**
+ * Options for `createNavigator` — the `routes` to dispatch between, the
+ * navigation substrate, the optional guard hook, and the AGENTS §13 emitter
+ * wiring.
+ *
+ * @typeParam Meta - The opaque payload each route may carry
+ *
+ * @remarks
+ * - `routes` — the route entries to register once with the shared core
+ *   `Router` (each `path` compiled once); registration order does NOT decide
+ *   precedence — specificity does (literal-over-param-over-wildcard).
+ * - `history` — `false` (default, hash mode: `#/…` + `hashchange`, zero
+ *   server configuration) or `true` (history mode: `pushState`/`popstate`).
+ * - `base` — a history-mode path prefix stripped from `location.pathname`
+ *   before matching, and prepended when navigating (`navigate`, link
+ *   interception). Ignored unless `history` is set.
+ * - `fallback` — the route PATTERN to resolve when the current location
+ *   matches NOTHING. Omitted ⇒ the first route's path. A `fallback` that
+ *   itself matches no registered route leaves `active` `undefined` and emits
+ *   nothing (§21-honest: no phantom match is fabricated).
+ * - `guard` — `(to, from, signal) => boolean | Promise<boolean>`, called
+ *   before a navigation commits; a `false`/rejected verdict, or one arriving
+ *   after the navigation was SUPERSEDED (`signal.aborted`), is discarded —
+ *   `active` stays unchanged and nothing is emitted. `signal` fires when a
+ *   NEWER navigation starts (or on `stop`/`destroy`), so a slow async guard
+ *   can cancel its own work off it. A throw routes to the `error` handler
+ *   below and vetoes the navigation.
+ * - `intercept` — opt-in same-origin `<a>` click interception (history mode
+ *   only): a plain left-click on a same-origin link with no modifier keys,
+ *   no `target`, and no `download` attribute is intercepted into `navigate`.
+ * - `sensitive` — forwarded to the underlying `Router` (default `true`).
+ * - `on` — initial `NavigatorEventMap` listeners (AGENTS §8/§13).
+ * - `error` — the emitter's listener-error handler (AGENTS §13); ALSO the
+ *   handler a thrown {@link guard} routes to (the Navigator's own pipeline,
+ *   not a listener throw, so it is surfaced through the same channel).
+ */
+export declare interface NavigatorOptions<Meta> {
+    readonly routes: readonly RouteEntry<Meta>[];
+    readonly history?: boolean;
+    readonly base?: string;
+    readonly fallback?: string;
+    readonly guard?: (to: RouterMatch<Meta>, from: RouterMatch<Meta> | undefined, signal: AbortSignal) => boolean | Promise<boolean>;
+    readonly intercept?: boolean;
+    readonly sensitive?: boolean;
+    readonly on?: EmitterHooks<NavigatorEventMap<Meta>>;
+    readonly error?: EmitterErrorHandler;
+}
+
+/**
+ * Resolve the `/`-prefixed pathname to match for the CURRENT location, in
+ * either navigation mode — the one seam `extractHashPath` (hash mode) and
+ * history-mode base-stripping share.
+ *
+ * @remarks
+ * Hash mode (`history: false`) reads `location.hash` through
+ * {@link extractHashPath}. History mode (`history: true`) reads
+ * `location.pathname` and strips a leading `base` prefix when one is
+ * configured: `base` itself maps to the root `'/'`; a pathname that is not
+ * under `base` is returned unchanged (a base mismatch is not this helper's
+ * concern — the `Navigator`'s match then simply misses). Total — never throws.
+ *
+ * @param location - The `hash` + `pathname` pair to resolve from (accepts a
+ *   real `Location` or any object shaped the same, for pure unit testing)
+ * @param history - The navigation substrate: `false` for hash mode, `true`
+ *   for history mode
+ * @param base - The history-mode path prefix to strip (ignored in hash mode;
+ *   omit for no prefix)
+ * @returns The `/`-prefixed pathname to match
+ *
+ * @example
+ * ```ts
+ * resolveLocationPath({ hash: '#/users/7', pathname: '/' }, false) // '/users/7'
+ * resolveLocationPath({ hash: '', pathname: '/app/users/7' }, true, '/app') // '/users/7'
+ * resolveLocationPath({ hash: '', pathname: '/app' }, true, '/app') // '/'
+ * resolveLocationPath({ hash: '', pathname: '/other/users' }, true, '/app') // '/other/users'
+ * ```
+ */
+export declare function resolveLocationPath(location: Pick<Location, 'hash' | 'pathname'>, history: boolean, base?: string): string;
+
+export { }

package/dist/src/browser/index.js

@@ -1,4 +1,7 @@
-import { canonicalizePath, createRouter, joinPaths } from "../core/index.cjs";
+import { createAbort } from "@orkestrel/abort";
+import { Emitter } from "@orkestrel/emitter";
+import { isFunction, isString } from "@orkestrel/contract";
+import { canonicalizePath, createRouter, joinPaths } from "../core/index.js";
 //#region src/browser/helpers.ts
 /**
 * Extract the `/`-prefixed pathname from a `location.hash` value — strip the
@@ -92,305 +95,6 @@ function findAnchor(event) {
 	for (const node of event.composedPath()) if (node instanceof HTMLAnchorElement) return node;
 }
 //#endregion
-//#region node_modules/@orkestrel/abort/dist/src/core/index.js
-/**
-* Link an own `AbortSignal` to an optional parent signal.
-*
-* @remarks
-* When `parent` is `undefined`, the own signal is returned unchanged. When a
-* parent is given, the result is `AbortSignal.any([own, parent])`, which fires
-* on EITHER the own signal aborting or the parent aborting — without
-* re-implementing listener wiring. A parent that has ALREADY aborted makes the
-* combined signal born aborted (carrying the parent's reason).
-*
-* @param own - The instance's own signal.
-* @param parent - An optional parent signal to link against.
-* @returns `own` unchanged when `parent` is `undefined`, otherwise
-*   `AbortSignal.any([own, parent])`.
-*
-* @example
-* ```ts
-* import { linkSignal } from '@src/core'
-*
-* const controller = new AbortController()
-* const linked = linkSignal(controller.signal, undefined) // controller.signal
-* ```
-*/
-function linkSignal(own, parent) {
-	return parent === void 0 ? own : AbortSignal.any([own, parent]);
-}
-Object.freeze([
-	"null",
-	"boolean",
-	"object",
-	"array",
-	"number",
-	"integer",
-	"string"
-]);
-/** Determine whether a value is a string. */
-function isString$1(value) {
-	return typeof value === "string";
-}
-/**
-* A cancellation handle — a thin, traceable wrapper over a native
-* `AbortController` whose exposed `signal` can be linked to a parent signal.
-*
-* @remarks
-* - **Own controller.** The instance owns a private `AbortController`; `abort`
-*   aborts it, and `aborted` reads the exposed signal. `abort(reason)` keeps any
-*   DEFINED reason verbatim (including a falsy `null` / `0` / `''` / `false`);
-*   `abort()` / `abort(undefined)` defaults `signal.reason` to an `AbortError`
-*   `DOMException`. Aborting is idempotent — the first reason sticks.
-* - **Parent linking.** When `options.signal` is given, the exposed `signal` is
-*   `AbortSignal.any([own, parent])`, so it fires on EITHER the own `abort()` or
-*   the parent aborting — without re-implementing listener wiring. A parent that
-*   has ALREADY aborted makes the handle born aborted (carrying the parent's reason).
-* - **Traceable.** Each handle carries an `id` (caller-supplied or a random UUID)
-*   for correlating cancellations across the system.
-* - **Event-free.** A pure functional primitive — no Emitter, no events.
-*
-* @example
-* ```ts
-* const abort = new Abort()
-* abort.signal.addEventListener('abort', () => stop(), { once: true })
-* abort.abort('cancelled') // flips `aborted`, fires `signal` with the reason
-* ```
-*/
-var Abort = class {
-	#controller = new AbortController();
-	id;
-	signal;
-	constructor(options) {
-		this.id = isString$1(options?.id) ? options.id : crypto.randomUUID();
-		this.signal = linkSignal(this.#controller.signal, options?.signal);
-	}
-	get aborted() {
-		return this.signal.aborted;
-	}
-	abort(reason) {
-		this.#controller.abort(reason);
-	}
-};
-/**
-* Create a cancellation handle — a thin, traceable wrapper over a native
-* `AbortController` whose `signal` can be linked to a parent signal.
-*
-* @remarks
-* The created handle's `signal` fires when its own `abort()` is called; when
-* `options.signal` is given, it ALSO fires when that parent signal aborts (linked
-* via `AbortSignal.any`). Pass `options.id` to label the handle for tracing, or
-* let it default to a random UUID.
-*
-* @param options - Optional `id` (a trace label; defaults to a random UUID) and
-*   `signal` (a parent signal whose abort also fires the created handle's signal)
-* @returns A working {@link AbortInterface}
-*
-* @example
-* ```ts
-* import { createAbort } from '@src/core'
-*
-* const abort = createAbort()
-* const work = fetch(url, { signal: abort.signal })
-* abort.abort() // cancels the fetch via the linked native signal
-* ```
-*
-* @example
-* ```ts
-* // Link to a parent so a parent cancellation also aborts the child.
-* const parent = createAbort()
-* const child = createAbort({ signal: parent.signal })
-* parent.abort() // child.aborted is now true
-* ```
-*/
-function createAbort(options) {
-	return new Abort(options);
-}
-//#endregion
-//#region node_modules/@orkestrel/emitter/dist/src/core/index.js
-/**
-* Extract the own enumerable keys of a mapped object, typed as its key union.
-*
-* @remarks
-* `Object.keys` widens its result to `string[]`, which breaks the key↔value
-* correlation a mapped type (like `EmitterHooks<TMap>`) otherwise guarantees.
-* A `for…in` push into a `keyof`-typed array narrows the result back,
-* type-safely and with no assertion.
-*
-* @typeParam T - The object shape whose keys are extracted.
-* @param object - The object to read keys from.
-* @returns The object's own enumerable keys, typed as `(keyof T)[]`.
-*
-* @example
-* ```ts
-* import { extractKeys } from '@src/core'
-*
-* const hooks = { tick: () => {}, done: () => {} }
-* extractKeys(hooks) // ['tick', 'done']
-* extractKeys({}) // []
-* ```
-*/
-function extractKeys(object) {
-	const collected = [];
-	for (const key in object) collected.push(key);
-	return collected;
-}
-Object.freeze([
-	"null",
-	"boolean",
-	"object",
-	"array",
-	"number",
-	"integer",
-	"string"
-]);
-/** Determine whether a value is callable. */
-function isFunction$1(value) {
-	return typeof value === "function";
-}
-/**
-* A typed synchronous event emitter — the foundational observable primitive of
-* the codebase (AGENTS §13). Stateful entities OWN one as a `#emitter` field and
-* expose it through `readonly emitter`; they never inherit from it.
-*
-* @typeParam TMap - The event map: each event name to the argument tuple its
-*   listeners receive.
-*
-* @remarks
-* - **Synchronous.** `emit` invokes listeners in registration order, in the
-*   current tick.
-* - **Listener isolation.** A throwing listener never stops its siblings: every
-*   listener runs, and a throw is routed to the `error` handler
-*   ({@link EmitterOptions.error}) — never rethrown. Every throwing listener
-*   surfaces (not just the first), and with no `error` handler a throw is swallowed
-*   silently. The `error` handler runs inside its own try/catch, so a throwing
-*   error-handler is swallowed too (anti-recursion — it cannot escape or re-enter).
-* - **Per-event storage.** Listeners live in a per-event `Set`, so every public
-*   method is precisely typed with no assertions.
-* - **Destroyed → no-op.** After `destroy()`, `on` / `once` / `emit` do nothing
-*   and `destroyed` is `true`.
-*
-* @example
-* ```ts
-* type CounterEventMap = {
-* 	tick: readonly [count: number]
-* 	done: readonly []
-* }
-*
-* const emitter = new Emitter<CounterEventMap>({
-* 	on: { done: () => stop() },
-* 	error: (error, event) => log(`listener for ${event} threw`, error),
-* })
-* emitter.on('tick', (count) => render(count))
-* emitter.emit('tick', 1)
-* ```
-*/
-var Emitter = class {
-	#destroyed = false;
-	#listeners = {};
-	#wrappers = {};
-	#error;
-	constructor(options) {
-		const error = options?.error;
-		this.#error = isFunction$1(error) ? error : void 0;
-		const hooks = options?.on;
-		if (hooks !== void 0) this.#wire(hooks);
-	}
-	get destroyed() {
-		return this.#destroyed;
-	}
-	on(event, handler) {
-		if (this.#destroyed) return;
-		(this.#listeners[event] ??= /* @__PURE__ */ new Set()).add(handler);
-	}
-	once(event, handler) {
-		if (this.#destroyed) return;
-		const pending = this.#wrappers[event] ??= /* @__PURE__ */ new Map();
-		const wrapper = (...args) => {
-			this.#listeners[event]?.delete(wrapper);
-			const wrappers = pending.get(handler);
-			wrappers?.delete(wrapper);
-			if (wrappers !== void 0 && wrappers.size === 0) pending.delete(handler);
-			handler(...args);
-		};
-		const wrappers = pending.get(handler) ?? /* @__PURE__ */ new Set();
-		wrappers.add(wrapper);
-		pending.set(handler, wrappers);
-		this.on(event, wrapper);
-	}
-	off(event, handler) {
-		const listeners = this.#listeners[event];
-		const wrappers = this.#wrappers[event];
-		const pending = wrappers?.get(handler);
-		if (pending !== void 0) {
-			for (const wrapper of pending) listeners?.delete(wrapper);
-			wrappers?.delete(handler);
-		}
-		listeners?.delete(handler);
-	}
-	emit(event, ...args) {
-		if (this.#destroyed) return;
-		const listeners = this.#listeners[event];
-		if (listeners === void 0) return;
-		for (const handler of [...listeners]) try {
-			handler(...args);
-		} catch (error) {
-			this.#surface(error, event);
-		}
-	}
-	count(event) {
-		if (event !== void 0) return this.#listeners[event]?.size ?? 0;
-		let total = 0;
-		for (const set of Object.values(this.#listeners)) total += set?.size ?? 0;
-		return total;
-	}
-	clear(event) {
-		if (event !== void 0) {
-			delete this.#listeners[event];
-			delete this.#wrappers[event];
-			return;
-		}
-		this.#listeners = {};
-		this.#wrappers = {};
-	}
-	destroy() {
-		this.#listeners = {};
-		this.#wrappers = {};
-		this.#error = void 0;
-		this.#destroyed = true;
-	}
-	#surface(error, event) {
-		const handler = this.#error;
-		if (handler === void 0) return;
-		try {
-			handler(error, String(event));
-		} catch {}
-	}
-	#wire(hooks) {
-		for (const event of extractKeys(hooks)) {
-			const handler = hooks[event];
-			if (isFunction$1(handler)) this.on(event, handler);
-		}
-	}
-};
-Object.freeze([
-	"null",
-	"boolean",
-	"object",
-	"array",
-	"number",
-	"integer",
-	"string"
-]);
-/** Determine whether a value is a string. */
-function isString(value) {
-	return typeof value === "string";
-}
-/** Determine whether a value is callable. */
-function isFunction(value) {
-	return typeof value === "function";
-}
-//#endregion
 //#region src/browser/Navigator.ts
 /**
 * The headless History/hash navigation entity — composes one core