@abide/abide 0.117.2 → 0.119.0

package/src/shared/reactive/watch.ts

@@ -22,15 +22,15 @@ import {
     detach,
     newSubscriber,
     type Subscriber,
-    TRACKING,
     type Tracked,
+    TRACKING,
     truncate,
     truncateProbes,
     untracked,
 } from './tracking.ts'
 
 export type Disposer = () => void
-// biome-ignore lint/suspicious/noConfusingVoidType: `void` is an EFFECT'S RETURN POSITION and is load-bearing. `undefined` there refuses the ordinary effect — a block body that returns nothing infers `void`, which is not assignable to `undefined` — so the rule's own fix would reject every caller that does not return a disposer.
+// `void` is an EFFECT'S RETURN POSITION and is load-bearing. `undefined` there refuses the ordinary effect — a block body that returns nothing infers `void`, which is not assignable to `undefined` — so every caller that does not return a disposer would be rejected.
 export type Effect = () => void | Disposer
 
 const WATCH_LOG = namedLogger('abide:watch')
@@ -186,7 +186,7 @@ export function watchOver(
     adopter: Tracked | null,
     effect: Effect,
 ): Disposer {
-    // biome-ignore lint/suspicious/noConfusingVoidType: `void` is an EFFECT'S RETURN POSITION and is load-bearing. `undefined` there refuses the ordinary effect — a block body that returns nothing infers `void`, which is not assignable to `undefined` — so the rule's own fix would reject every caller that does not return a disposer.
+    // `void`, not `undefined`: see `Effect`.
     let dispose: Disposer | void
     // The sources are declared rather than tracked. `detach` still tears this down: it truncates
     // from the cursor, and the cursor of a body that never tracked is zero.
@@ -259,7 +259,7 @@ export function watchOver(
  * adoption mirror's too. Two literals keep that call site to the effects a template makes.
  */
 export function watchTracked(effect: Effect): Disposer {
-    // biome-ignore lint/suspicious/noConfusingVoidType: `void` is an EFFECT'S RETURN POSITION and is load-bearing. `undefined` there refuses the ordinary effect — a block body that returns nothing infers `void`, which is not assignable to `undefined` — so the rule's own fix would reject every caller that does not return a disposer.
+    // `void`, not `undefined`: see `Effect`.
     let dispose: Disposer | void
     const reader: Subscriber = newSubscriber([], null)
     // 11.32 — A RERUN READS THROUGH THE SCOPE THE WATCH WAS OPENED IN, not the ambient one. The

package/src/shared/refuse.ts

@@ -8,8 +8,8 @@
 // cannot narrow against a name it never wrote. `Aborted` is the one the app asks for itself: it
 // comes back only from a call the app handed a signal and then aborted (16.49).
 
-import { FAILURE_STATUS_TEXT } from './FAILURE_STATUS_TEXT.ts'
 import { type Failed, failed, isFailed } from './Failed.ts'
+import { FAILURE_STATUS_TEXT } from './FAILURE_STATUS_TEXT.ts'
 import type { Issues } from './Issues.ts'
 import type { JsonValue } from './JsonValue.ts'
 import { namedLogger } from './log.ts'

package/src/shared/routePattern.ts

@@ -17,29 +17,78 @@ export type Segment = {
     kind: SegmentKind
     /** The literal text for a static segment, the param name for the other three. */
     name: string
+    /** 23.26 — the matcher a dynamic segment names after `=`, or `undefined` where it names none. */
+    matcher: string | undefined
+    /** 30.34, 30.35 — what a part must match to be taken: the matcher's, or the period default. */
+    accepts: RegExp
 }
 
+/** 30.34, 30.36 — what a segment naming no matcher takes: a part carrying no period. */
+const PERIODLESS = /^[^.]+$/
+
+// A segment naming a matcher, parsed with no table to resolve it in, takes nothing: only a route
+// table's own rows say which regex a name stands for (23.26), and a reader that only builds an
+// address or compares shapes never walks one.
+const UNRESOLVED = /(?!)/
+
 /**
  * A route literal split into its segments, each classified by kind.
  *
- * `[...rest]`, `[[optional]]`, `[required]`, or a literal. Ordered longest-first: `[[a]]` is a
- * `[a]` with another bracket round it, so testing the short form first matches both.
+ * `[...rest]`, `[[optional]]`, `[required]`, or a literal, each dynamic one optionally naming a
+ * matcher after `=`, compiled from `matchers` — each name's anchored source, as the build wrote it
+ * into the row (23.26) — where a route table hands its row's. Ordered
+ * longest-first: `[[a]]` is a `[a]` with another bracket round it, so testing the short form first
+ * matches both.
  */
-export function parseRoutePattern(pattern: string): Segment[] {
+export function parseRoutePattern(
+    pattern: string,
+    matchers?: Record<string, string>,
+): Segment[] {
     const out: Segment[] = []
     for (const raw of pattern.split('/')) {
         if (raw === '') continue
-        if (raw.startsWith('[[') && raw.endsWith(']]'))
-            out.push({ kind: 'optional', name: raw.slice(2, -2) })
-        else if (raw.startsWith('[...') && raw.endsWith(']'))
-            out.push({ kind: 'rest', name: raw.slice(4, -1) })
-        else if (raw.startsWith('[') && raw.endsWith(']'))
-            out.push({ kind: 'required', name: raw.slice(1, -1) })
-        else out.push({ kind: 'static', name: raw })
+        let kind: SegmentKind = 'static'
+        let body = raw
+        if (raw.startsWith('[[') && raw.endsWith(']]')) {
+            kind = 'optional'
+            body = raw.slice(2, -2)
+        } else if (raw.startsWith('[...') && raw.endsWith(']')) {
+            kind = 'rest'
+            body = raw.slice(4, -1)
+        } else if (raw.startsWith('[') && raw.endsWith(']')) {
+            kind = 'required'
+            body = raw.slice(1, -1)
+        }
+        const split = kind === 'static' ? -1 : body.indexOf('=')
+        const matcher = split === -1 ? undefined : body.slice(split + 1)
+        out.push({
+            kind,
+            name: split === -1 ? body : body.slice(0, split),
+            matcher,
+            accepts:
+                matcher === undefined
+                    ? PERIODLESS
+                    : matchers === undefined
+                      ? UNRESOLVED
+                      : resolvedIn(matchers, matcher, pattern),
+        })
     }
     return out
 }
 
+function resolvedIn(
+    matchers: Record<string, string>,
+    matcher: string,
+    pattern: string,
+): RegExp {
+    const source = matchers[matcher]
+    if (source === undefined)
+        throw new Error(
+            `abide: the route table's row for ${pattern} carries no matcher ${matcher}, which the build writes beside every segment naming one. RULEBOOK 23.26.`,
+        )
+    return new RegExp(source)
+}
+
 /**
  * A `sort` comparator over two parsed patterns: negative where `a` is the more specific.
  *
@@ -99,12 +148,15 @@ export function coversRoute(outer: Segment[], route: Segment[]): boolean {
  * which page an address resolves to, so it is here with `compareRoutes` rather than written out
  * beside each table: the server's boot and the client router's start compile through one call.
  */
-export function rankRoutes<T extends { pattern: string }>(
-    rows: T[],
-): (T & { segments: Segment[] })[] {
+export function rankRoutes<
+    T extends { pattern: string; matchers?: Record<string, string> },
+>(rows: T[]): (T & { segments: Segment[] })[] {
     const ranked: (T & { segments: Segment[] })[] = []
     for (const row of rows)
-        ranked.push({ ...row, segments: parseRoutePattern(row.pattern) })
+        ranked.push({
+            ...row,
+            segments: parseRoutePattern(row.pattern, row.matchers ?? {}),
+        })
     ranked.sort((a, b) => compareRoutes(a.segments, b.segments))
     return ranked
 }

package/src/shared/rpc.ts

@@ -17,12 +17,11 @@ import { DERIVED_ARGS } from './DERIVED_ARGS.ts'
 import { type Failed, isFailedNamed } from './Failed.ts'
 import { GLOBAL_GETS } from './GLOBAL_GETS.ts'
 import { HandlerRoute } from './HandlerRoute.ts'
-import type { Issues } from './Issues.ts'
 import { IN_PROCESS_ORIGIN } from './IN_PROCESS_ORIGIN.ts'
+import type { Issues } from './Issues.ts'
 import { compose, type Middleware } from './Middleware.ts'
 import { outbox, type QueuedCall, sendingFor } from './outbox.ts'
 import { principalRotated } from './principalRotated.ts'
-import { RPC_SERVER } from './RPC_SERVER.ts'
 import {
     contractOf,
     type Gated,
@@ -42,18 +41,19 @@ import {
     type Keyed,
     type OptionalParameter,
     type Reactive,
-    type Refusals,
     reactive,
+    type Refusals,
     type Shaping,
     STREAMING,
-    type Streams,
     streamingOrSettled,
+    type Streams,
 } from './reactive/index.ts'
 import { MUTATION } from './reactive/MUTATION.ts'
 import { dropAnswered } from './reactive/Reactive.ts'
-import { SELECTION_MEMBERS } from './reactive/SELECTION_MEMBERS.ts'
 import { builtHere, isForwarder } from './reactive/scoped.ts'
+import { SELECTION_MEMBERS } from './reactive/SELECTION_MEMBERS.ts'
 import { checkArgs, validationError } from './refuse.ts'
+import { RPC_SERVER } from './RPC_SERVER.ts'
 import { rpcRequest } from './rpcRequest.ts'
 import type { Schema } from './Schema.ts'
 
@@ -150,8 +150,7 @@ type Annotated<Args> = 0 extends 1 & Args
       : Derived<Exclude<Args, undefined>>
 // `Member` is distributed over and `Whole` is not: a member that is not the whole is one arm of a union.
 type Derived<Member, Whole = Member> = Member extends
-    | readonly unknown[]
-    | ((...given: never[]) => unknown)
+    readonly unknown[] | ((...given: never[]) => unknown)
     ? never
     : Member extends object
       ? [Whole] extends [Member]
@@ -215,8 +214,7 @@ export type Plain = { invalidate?: never }
 // every function arm, whose `& Plain` only passes assignability. The guard is the whole parameter
 // because `& Plain` kept `GET(0)` the literal `0`, and a bound of `Plain` refuses every primitive.
 type Held<Accepted> = Accepted extends
-    | ((...given: never[]) => unknown)
-    | { invalidate: unknown }
+    ((...given: never[]) => unknown) | { invalidate: unknown }
     ? never
     : Accepted | PromiseLike<Accepted>
 
@@ -262,8 +260,7 @@ type Declare = {
     >
     <Chunk, Shaped = Chunk[], Gate = Schema<Chunk[]>>(
         handler: (() =>
-            | AsyncGenerator<Chunk>
-            | Promise<AsyncGenerator<Chunk>>) &
+            AsyncGenerator<Chunk> | Promise<AsyncGenerator<Chunk>>) &
             Plain,
         options?: Shaping<Chunk[], Shaped, never, Gate> & RpcOptions<undefined>,
     ): Rpc<Kept<Shaped>, undefined, Refusals<Shaped, Gate, Chunk[]>, Chunk>

package/src/shared/url.ts

@@ -12,26 +12,31 @@ type Parts<P extends string> = P extends `${infer Head}/${infer Tail}`
     ? Head | Parts<Tail>
     : P
 
+// 23.26 — a segment's param is named before any `=`: `[symbol=TICKER]` is `symbol`.
+type ParamName<Body extends string> = Body extends `${infer Name}=${string}`
+    ? Name
+    : Body
+
 export type RequiredNames<P extends string> =
     Parts<P> extends infer Part
         ? Part extends `[${infer Name}]`
             ? Name extends `[${string}` | `...${string}`
                 ? never
-                : Name
+                : ParamName<Name>
             : never
         : never
 
 export type OptionalNames<P extends string> =
     Parts<P> extends infer Part
         ? Part extends `[[${infer Name}]]`
-            ? Name
+            ? ParamName<Name>
             : never
         : never
 
 export type RestNames<P extends string> =
     Parts<P> extends infer Part
         ? Part extends `[...${infer Name}]`
-            ? Name
+            ? ParamName<Name>
             : never
         : never
 
@@ -51,18 +56,28 @@ export type HasSegments<P extends string> = [
 
 export type Query = Record<string, unknown> | URLSearchParams
 
-/** The params a route literal takes, by segment kind. */
+/** The params a route literal takes, by segment kind, and 30.3 — narrowed where `abide check` says. */
 export type ParamsOf<P extends string> = {
     [K in RequiredNames<P>]: string | number
 } & { [K in OptionalNames<P>]?: string | number } & {
     [K in RestNames<P>]?: string | number | (string | number)[]
-}
+} & Narrowed<P>
+
+/**
+ * 23.9, 30.3 — the params `abide check` declared for `P` beside its key: each whose matcher is an
+ * alternation of literals, as their union. Nothing where it declared none, or nothing at all.
+ */
+type Narrowed<P extends string> = P extends keyof Routes
+    ? Routes[P] extends true
+        ? unknown
+        : Routes[P]
+    : unknown
 
 /**
  * 30.26 — the route literals an app files its pages under, which `abide check` declares for the app
  * it checks. Where nothing declared them any literal is taken, so a plain `tsc` still compiles.
  */
-// biome-ignore lint/suspicious/noEmptyInterface: filled by declaration merging, per app
+// Filled by declaration merging, per app — each literal to `true`, or to the params it narrows (23.9)
 export interface Routes {}
 
 /** 30.26 — what `url` takes: one of the app's route literals, or any where none were declared. */
@@ -76,7 +91,9 @@ export type RouteLiteral = [keyof Routes] extends [never]
  */
 export type RouteParams<P extends string> = {
     [K in RequiredNames<P>]: string
-} & { [K in OptionalNames<P>]?: string } & { [K in RestNames<P>]: string[] }
+} & { [K in OptionalNames<P>]?: string } & {
+    [K in RestNames<P>]: string[]
+} & Narrowed<P>
 
 /**
  * An address from a route literal and its params, resolved against the mount, with an optional

package/src/shared/validateJson.ts

@@ -13,8 +13,8 @@
 // `description`, `default` and the rest say nothing about whether a value is valid, and a
 // generated document carries them.
 
-import type { Issues } from './Issues.ts'
 import { isRecord } from './isRecord.ts'
+import type { Issues } from './Issues.ts'
 import { issuesOf } from './issuesOf.ts'
 import type { JsonValue } from './JsonValue.ts'
 import { note } from './note.ts'

package/src/ui/ArmRegion.ts

@@ -11,6 +11,7 @@ import {
     type ShareScope,
 } from '#shared/reactive/share.ts'
 import { untracked } from '#shared/reactive/tracking.ts'
+
 import { HYDRATE_LOG } from './Mismatch.ts'
 import { fillRegion, isEmptyRegion, type Region } from './regions.ts'
 import { Scope, type Stoppable } from './Scope.ts'

package/src/ui/Level.ts

@@ -6,6 +6,7 @@ import {
 } from '#shared/reactive/share.ts'
 import { untracked } from '#shared/reactive/tracking.ts'
 import { type Disposer, watchTracked } from '#shared/reactive/watch.ts'
+
 import { reconciled, reconcileHead } from './reconcileHead.ts'
 import { isEmptyRegion, type Region } from './regions.ts'
 import type { Scope } from './Scope.ts'

package/src/ui/List.ts

@@ -1,5 +1,6 @@
 import { listOf } from '#shared/listOf.ts'
 import { untracked } from '#shared/reactive/tracking.ts'
+
 import { HYDRATE_LOG, Mismatch, warnMismatch } from './Mismatch.ts'
 import { reconcile } from './reconcile.ts'
 import { isEmptyRegion, type Region, removeUntil } from './regions.ts'

package/src/ui/RawRun.ts

@@ -1,4 +1,5 @@
 import { RAW_CLOSE, RAW_OPEN } from '#shared/ANCHORS.ts'
+
 import { Mismatch } from './Mismatch.ts'
 import { parseMarkup } from './parseMarkup.ts'
 import { removeUntil } from './regions.ts'

package/src/ui/Router.ts

@@ -11,6 +11,7 @@ import { arrive, route } from '#shared/route.ts'
 import { rankRoutes, type Segment } from '#shared/routePattern.ts'
 import { setUpLevels } from '#shared/setUpLevels.ts'
 import { paintedCallsLanded } from '#shared/takeEarlyCall.ts'
+
 import { LAYER_MOUNT, LAYER_NAVIGATE } from './LAYER_NAMES.ts'
 import { Level } from './Level.ts'
 import { beginLayer, endLayer } from './measureLayer.ts'

package/src/ui/TryRegion.ts

@@ -16,6 +16,7 @@ import { type Reactive, reactive } from '#shared/reactive/index.ts'
 import { NotLanded } from '#shared/reactive/NotLanded.ts'
 import { untracked } from '#shared/reactive/tracking.ts'
 import { type Disposer, watchTracked } from '#shared/reactive/watch.ts'
+
 import { type Arm, type ArmMakers, ArmRegion } from './ArmRegion.ts'
 import { Mismatch } from './Mismatch.ts'
 import {

package/src/ui/adoptWalk.ts

@@ -1,6 +1,7 @@
 import { RAW_CLOSE, RAW_OPEN } from '#shared/ANCHORS.ts'
+
 import { Mismatch } from './Mismatch.ts'
-import { type RawRun, rawCloseOf, rawRunEndingAt } from './RawRun.ts'
+import { rawCloseOf, type RawRun, rawRunEndingAt } from './RawRun.ts'
 import { closeOf, opensRegion, type Region } from './regions.ts'
 
 // WHERE A NODE IS WHEN THE SERVER ALREADY WROTE IT — the adopt half of every region's mount: the

package/src/ui/bindElement.ts

@@ -1,6 +1,7 @@
 import { isReactive } from '#shared/reactive/isReactive.ts'
 import { isThenable } from '#shared/reactive/isThenable.ts'
 import type { Disposer } from '#shared/reactive/watch.ts'
+
 import { holdWhileLeaving } from './leave.ts'
 
 /**

package/src/ui/bindFiles.ts

@@ -1,4 +1,5 @@
 import { boundValue, writeBound } from '#shared/boundValue.ts'
+
 import type { Scope } from './Scope.ts'
 
 /**

package/src/ui/bindGroup.ts

@@ -4,6 +4,7 @@ import {
     heldValue,
     writeBound,
 } from '#shared/boundValue.ts'
+
 import type { Scope } from './Scope.ts'
 
 /**

package/src/ui/bindProperty.ts

@@ -13,6 +13,7 @@ import {
     writeBound,
 } from '#shared/boundValue.ts'
 import { numberFromText } from '#shared/numberFromText.ts'
+
 import type { Scope } from './Scope.ts'
 
 type Bound = HTMLInputElement & HTMLDetailsElement

package/src/ui/bindSpread.ts

@@ -3,6 +3,7 @@
 // function becomes the element's listener, replaced when the value hands over another.
 
 import { spreadEntries } from '#shared/spread.ts'
+
 import type { Scope } from './Scope.ts'
 import { addAttribute } from './setAttribute.ts'
 

package/src/ui/index.ts

@@ -50,12 +50,7 @@ export { contributeHead } from './Level.ts'
 export { listAt, updateList } from './List.ts'
 export { warnMismatch } from './Mismatch.ts'
 export { markupNodes, namespaceUnder } from './parseMarkup.ts'
-export {
-    fillEmpty,
-    fillRegion,
-    isEmptyRegion,
-    type Region,
-} from './regions.ts'
+export { fillEmpty, fillRegion, isEmptyRegion, type Region } from './regions.ts'
 export { rowKeyOf } from './rowKeyOf.ts'
 export { itemOf, noUpdate, replaceRow, rowCell } from './rows.ts'
 export { EMPTY_SCOPE, Scope } from './Scope.ts'

package/src/ui/outboxQueue.ts

@@ -17,7 +17,7 @@ import {
 } from '#shared/answerOf.ts'
 import { failedFrom, isFailed, problemOf } from '#shared/Failed.ts'
 import type { Problem } from '#shared/Failed.ts'
-import { type ShownCall, showLine, showSending } from '#shared/outbox.ts'
+import { showLine, type ShownCall, showSending } from '#shared/outbox.ts'
 import { onPrincipalRotated } from '#shared/principalRotated.ts'
 import {
     isReactive,

package/src/ui/parseMarkup.ts

@@ -50,7 +50,8 @@ export function parseMarkup(parent: Node, markup: string): DocumentFragment {
         TEMPLATES.set(document, template)
     }
     const space = namespaceUnder(parent)
-    const wrapper = space === HTML_NAMESPACE ? undefined : space === SVG ? 'svg' : 'math'
+    const wrapper =
+        space === HTML_NAMESPACE ? undefined : space === SVG ? 'svg' : 'math'
     if (wrapper === undefined) {
         template.innerHTML = markup
         return template.content

package/src/ui/reconcile.ts

@@ -1,8 +1,9 @@
 import { PATCHES } from '#shared/reactive/PATCHES.ts'
+
 import { LAYER_RECONCILE } from './LAYER_NAMES.ts'
 import type { List } from './List.ts'
-import { HYDRATE_LOG } from './Mismatch.ts'
 import { beginLayer, endLayer } from './measureLayer.ts'
+import { HYDRATE_LOG } from './Mismatch.ts'
 import { emptyRegion } from './regions.ts'
 import { dropRow, makeRow, moveRow, type Row, updateRow } from './rows.ts'
 

package/src/ui/reconcileHead.ts

@@ -13,6 +13,7 @@
 // server painted is ADOPTED the first time its contributor is reconciled, matched in chain order.
 
 import { headKeyOf } from '#shared/headKeyOf.ts'
+
 import { markupNodes } from './parseMarkup.ts'
 
 /** One contributor's head, parsed once per text it reads. */

package/src/ui/regions.ts

@@ -1,8 +1,9 @@
 import { REGION_CLOSE, REGION_OPEN } from '#shared/ANCHORS.ts'
+
 import { LAYER_FILL } from './LAYER_NAMES.ts'
 import { anyLeaving, leave } from './leave.ts'
-import { Mismatch } from './Mismatch.ts'
 import { beginLayer, endLayer } from './measureLayer.ts'
+import { Mismatch } from './Mismatch.ts'
 
 export type Region = { open: Comment; close: Comment }
 

package/src/ui/registerWorker.ts

@@ -5,6 +5,7 @@ import { WORKER_ADDRESS } from '#shared/ADDRESSES.ts'
 import { MOUNT, mounted } from '#shared/mount.ts'
 import { OFFLINE_META } from '#shared/OFFLINE_META.ts'
 import { onPrincipalRotated } from '#shared/principalRotated.ts'
+
 import { HYDRATE_LOG } from './Mismatch.ts'
 
 /** Registers the app's service worker once the page has loaded, over the mount's whole scope. */

package/src/ui/rows.ts

@@ -1,6 +1,7 @@
 import { REGION_CLOSE, ROW_OPEN } from '#shared/ANCHORS.ts'
 import { moveItem, rowItem } from '#shared/reactive/index.ts'
 import { PATCHES } from '#shared/reactive/PATCHES.ts'
+
 import { leave } from './leave.ts'
 import { moveNode } from './moveNode.ts'
 import { closeOf, opensRegion, type Region, removeUntil } from './regions.ts'

package/src/ui/setMarkup.ts

@@ -1,4 +1,5 @@
 import { WORK } from '#shared/WORK.ts'
+
 import { RawRun, refillRun, textToMarkup } from './RawRun.ts'
 
 /**

package/src/ui/setText.ts

@@ -1,4 +1,5 @@
 import { WORK } from '#shared/WORK.ts'
+
 import { markupToText, RawRun } from './RawRun.ts'
 
 /**

package/src/ui/socketWire.ts

@@ -3,7 +3,10 @@
 // where the version it holds is not the server's, and the writes of each patch over it (18.6, 18.11).
 
 import { SOCKET_ADDRESS } from '#shared/ADDRESSES.ts'
+import { applyPatch } from '#shared/applyPatch.ts'
 import { mounted } from '#shared/mount.ts'
+import type { BrowserFrame, ServerFrame } from '#shared/muxFrames.ts'
+import { onPrincipalRotated } from '#shared/principalRotated.ts'
 import { canonicalKey } from '#shared/reactive/canonicalKey.ts'
 import {
     heldGenerationOf,
@@ -14,9 +17,7 @@ import {
     writtenLocally,
 } from '#shared/reactive/index.ts'
 import { PATCHES } from '#shared/reactive/PATCHES.ts'
-import type { BrowserFrame, ServerFrame } from '#shared/muxFrames.ts'
-import { applyPatch } from '#shared/applyPatch.ts'
-import { onPrincipalRotated } from '#shared/principalRotated.ts'
+
 import { HYDRATE_LOG } from './Mismatch.ts'
 import { undelivered, whenDelivered } from './outboxQueue.ts'
 

package/src/ui/wire.ts

@@ -33,11 +33,12 @@ import { LOAD_OFFLINE } from '#shared/LOAD_OFFLINE.ts'
 import { LOAD_SIGNAL } from '#shared/LOAD_SIGNAL.ts'
 import { reactive, standIn, structural } from '#shared/reactive/index.ts'
 import {
-    type Defaults,
     declareDefaults,
+    type Defaults,
 } from '#shared/reactive/parameterDefaults.ts'
 import { declare, type Method } from '#shared/rpc.ts'
 import { type RpcRequest, rpcRequest } from '#shared/rpcRequest.ts'
+
 import { enqueue, undelivered } from './outboxQueue.ts'
 import { followRpc } from './socketWire.ts'