@hops-ops/distributed 4.9.0 → 4.10.0

package/README.md

@@ -5,7 +5,7 @@ The generated, end-to-end typed client for
 
 Rust table, relationship, role, and command definitions produce one authorized
 client surface. `distributed client` combines that surface with application GraphQL
-documents and emits typed operations, live companions, route-load plans, and
+documents and emits typed operations, live companions, island metadata, and
 commands. This package executes those artifacts through one normalized,
 causally consistent browser replica.
 
@@ -67,7 +67,7 @@ injects wire-only identity and revision fields, and emits:
 - an exact typed operation and optional live companion;
 - normalization, identity, relationship, filter, order, and pagination plans;
 - the closed variable codec used before cache lookup or transport;
-- a static `@load` route registry;
+- framework-neutral island metadata plus an inspectable SvelteKit boundary plan;
 - an SSR-safe SvelteKit wrapper with static operation bindings and tree-local
   client/command access;
 - a nested command tree with input defaults, optimistic effects, and causal
@@ -100,7 +100,10 @@ export const distributedClients = [
     module: '$distributed',
     manifest: { args: serviceManifestArgs },
     surface: 'e2e-ui',
-    documents: ['src/routes/(app)/**/*.graphql'],
+    documents: [
+      'src/routes/(app)/**/*.graphql',
+      'src/lib/components/**/*.graphql'
+    ],
     out: 'src/lib/generated/distributed'
   },
   {
@@ -128,6 +131,13 @@ keeps ordinary application documents out of the admin tree; each trust boundary
 has its own Rust manifest entrypoint, generated directory, virtual module, and
 request-local replica. A single-surface application can omit the second entry.
 
+A component can own a sibling `Component.graphql` island. The adapter walks
+static Svelte imports and promotes `@load` work to the nearest page/layout.
+Route-local `+page.graphql` and `+layout.graphql` remain first-class. When a
+required variable cannot be proved from route/search/session/forwarded-prop
+sources, add one typed `boundaries` registration here; that generated binding
+is reused by SSR, hover prefetch, navigation, hydration, and live work.
+
 The Vite integration runs `distributed client` at startup/build, watches GraphQL
 documents, stages all surfaces, commits a rollback-capable multi-output
 transaction, then triggers one reload. It exposes the generated Svelte wrapper
@@ -194,11 +204,11 @@ import {
   createDistributedSvelteKitServer
 } from '@hops-ops/distributed/sveltekit';
 import {
-  DISTRIBUTED_ROUTE_OPERATIONS
+  DISTRIBUTED_BOUNDARY_OPERATIONS
 } from '$distributed';
 
 const distributed = createDistributedSvelteKitServer({
-  routes: DISTRIBUTED_ROUTE_OPERATIONS,
+  boundaries: DISTRIBUTED_BOUNDARY_OPERATIONS,
   getSession: ({ locals }) => locals.auth(),
   getRole: (session) => roleFromSession(session)
 });
@@ -212,15 +222,20 @@ authorization lifecycle. The generated module retains no client singleton:
 ```ts
 // src/routes/+layout.svelte
 import { browser } from '$app/environment';
+import { page } from '$app/state';
 import {
   createPageDataSessionSource
 } from '@hops-ops/distributed/sveltekit';
-import { provideDistributed } from '$distributed';
+import {
+  DISTRIBUTED_BOUNDARY_OPERATIONS,
+  provideDistributed
+} from '$distributed';
 
 let { data, children } = $props();
 const pageData = createPageDataSessionSource(data);
 
 const client = provideDistributed({
+  boundaries: DISTRIBUTED_BOUNDARY_OPERATIONS,
   browser,
   session: pageData.session,
   ...(data.distributed !== undefined &&
@@ -233,6 +248,26 @@ const client = provideDistributed({
 });
 
 $effect(() => pageData.set(data));
+
+$effect(() => {
+  const retained = client.retainLocation(
+    { id: 'active-page', pathname: page.url.pathname, kind: 'page' },
+    {
+      search: page.url.searchParams,
+      session: data.session,
+      props: data
+    }
+  );
+  return () => retained.release();
+});
+
+// A delegated link-hover handler can warm any generated target without an
+// operation-name switch or a second variable map.
+await client.prefetchLocation(target.pathname, {
+  search: target.searchParams,
+  session: data.session,
+  props: data
+});
 ```
 
 Route components import only their generated surface. Static operation wrappers
@@ -296,7 +331,10 @@ deduplicates work, and optionally maintains the generated live operation.
 `read()` is side-effect-free. `dehydrate()` and `hydrate()` transfer confirmed
 state without exposing a public storage schema. Cold `hydrate` seeds an empty
 client; warm same-scope `hydrate` merges so soft navigation cannot discard
-confirmed session data the next route did not re-dehydrate.
+confirmed session data the next boundary did not re-dehydrate. Layout
+retention survives child navigation, page retention is replaced on page exit,
+and exact layout/page duplicates share one replica watch until the final owner
+releases it.
 
 The replica stores normalized records and exact argument-sensitive indexes,
 not GraphQL response blobs. Generated selection metadata reconstructs each
@@ -423,7 +461,7 @@ duplicated as decision documents in this package.
   command runtime, query-plan helpers, and optional persistence.
 - `@hops-ops/distributed/diagnostics` — redacted support snapshots and artifact
   inspection.
-- `@hops-ops/distributed/sveltekit` — Svelte stores, SSR route loading,
+- `@hops-ops/distributed/sveltekit` — Svelte stores, island SSR composition,
   hydration, auth lifecycle, and tree-local generated bindings.
 - `@hops-ops/distributed/sveltekit/vite` — Node-only one-shot/check/watch
   generation, virtual module aliases, and GraphQL HTTP/WebSocket proxy helpers.

package/dist/replica/distributed-replica/impl-protocol.d.ts

@@ -34,6 +34,7 @@ export type ProtocolHost = {
     setProtocolGeneration(value: ProtocolGeneration | undefined): void;
     getProtocolGenerationSequence(): number;
     bumpProtocolGenerationSequence(): void;
+    disposeAuthorizationGeneration(): void;
     getTrustedPresets(): readonly DistributedTrustedPreset[];
     setTrustedPresets(value: readonly DistributedTrustedPreset[]): void;
     getCommandAuthorityContract(): RegisteredCommandAuthorityContract | undefined;

package/dist/replica/distributed-replica/impl-protocol.js

@@ -107,6 +107,7 @@ export function purgeProtocolGeneration(host) {
 }
 export function closeAuthorizationGeneration(host) {
     host.bumpProtocolGenerationSequence();
+    host.disposeAuthorizationGeneration();
     host.abortAuthorization();
     host.closeActiveTransports();
 }

package/dist/replica/distributed-replica/impl.js

@@ -22,6 +22,7 @@ export class DistributedReplicaImpl {
     #engine;
     #transport;
     #reportObserverError;
+    #onAuthorizationGenerationDispose;
     #diagnostics;
     #diagnosticLayers;
     #inFlight = new Map();
@@ -68,6 +69,8 @@ export class DistributedReplicaImpl {
     constructor(options = {}) {
         this.#transport = options.transport;
         this.#reportObserverError = options.onObserverError ?? reportUnhandledObserverError;
+        this.#onAuthorizationGenerationDispose =
+            options.onAuthorizationGenerationDispose;
         this.#diagnostics = options.diagnostics;
         this.#diagnosticLayers =
             options.diagnostics === undefined ? undefined : new Map();
@@ -209,6 +212,14 @@ export class DistributedReplicaImpl {
             bumpProtocolGenerationSequence: () => {
                 self.#protocolGenerationSequence += 1;
             },
+            disposeAuthorizationGeneration: () => {
+                try {
+                    self.#onAuthorizationGenerationDispose?.();
+                }
+                catch (error) {
+                    self._reportObserverErrors([error]);
+                }
+            },
             getTrustedPresets: () => self.#trustedPresets,
             setTrustedPresets: (value) => {
                 self.#trustedPresets = value;

package/dist/replica/distributed-replica/watch.js

@@ -11,6 +11,7 @@ export class ReplicaWatchState {
     #snapshot;
     #identitySignature;
     #destroyed = false;
+    #autoFetchScheduled = false;
     #unregister;
     constructor(owner, artifact, variables, options) {
         this.#owner = owner;
@@ -57,7 +58,8 @@ export class ReplicaWatchState {
         if (this.#destroyed)
             return;
         this.materialized = materialized;
-        this.#sync(true);
+        this.#sync(false);
+        this.#scheduleAutoFetch();
     }
     _stateChanged(allowFetch) {
         if (this.#destroyed)
@@ -92,4 +94,14 @@ export class ReplicaWatchState {
         if (allowFetch)
             void this.#owner._fetch(this, false);
     }
+    #scheduleAutoFetch() {
+        if (this.#autoFetchScheduled || this.#destroyed)
+            return;
+        this.#autoFetchScheduled = true;
+        queueMicrotask(() => {
+            this.#autoFetchScheduled = false;
+            if (!this.#destroyed)
+                void this.#owner._fetch(this, false);
+        });
+    }
 }

package/dist/replica/index.d.ts

@@ -17,6 +17,6 @@ export { compareReplicaOrder, decideReplicaPaginationMaintenance, evaluateReplic
 export { createReplicaIndexMaintenanceRegistry, formatReplicaIndexStaleReason } from './index-maintenance.js';
 export type { ReplicaIndexDependencyChange, ReplicaIndexMaintenanceDecision, ReplicaIndexMaintenanceIndex, ReplicaIndexMaintenanceReason, ReplicaIndexMaintenanceReasonCode, ReplicaIndexMaintenanceRecord, ReplicaIndexMaintenanceRegistry, ReplicaIndexMaintenanceSnapshot, ReplicaIndexPlanRegistration, ReplicaIndexRecordChange, ReplicaIndexRelationshipChange, ReplicaIndexSemanticChange, ReplicaIndexSemanticLayer } from './index-maintenance.js';
 export type { ReplicaFilterEvaluation, ReplicaFilterEvaluationOptions, ReplicaOrderComparison, ReplicaPaginationChange, ReplicaPaginationMaintenanceDecision, ReplicaQueryPlanPath, ReplicaQueryPlanReason, ReplicaQueryPlanReasonCode, ReplicaRelationshipFilterRequest } from './query-plan.js';
-export type { DistributedReplicaOptions, DistributedReplica, ReplicaArgumentsArtifact, ReplicaArgumentValue, ReplicaAuthoritativeScope, ReplicaBaseWriter, ReplicaBranchSemantic, ReplicaClientSurface, ReplicaCoverageArtifact, ReplicaDehydratedState, ReplicaFilterArtifact, ReplicaFilterExpression, ReplicaFilterFieldArtifact, ReplicaFilterLiteral, ReplicaFilterOperand, ReplicaFilterOperator, ReplicaIdentity, ReplicaIndexCoverage, ReplicaIndexInspection, ReplicaIndexTarget, ReplicaListValue, ReplicaLiveObserver, ReplicaLiveState, ReplicaLiteralValue, ReplicaModelArtifact, ReplicaObjectBranch, ReplicaObjectMember, ReplicaObjectSelection, ReplicaObjectValue, ReplicaOperationArtifact, ReplicaOperationSourceLocation, ReplicaOperationProtocol, ReplicaOrderArtifact, ReplicaOrderFieldArtifact, ReplicaOrderTieBreakerArtifact, ReplicaOptimisticWriter, ReplicaPaginationArtifact, ReplicaPaginationDisposition, ReplicaProtocolOperationArtifact, ReplicaRecordInspection, ReplicaRecordPatch, ReplicaRevalidationPlan, ReplicaRevalidationRelationship, ReplicaRevision, ReplicaRelationshipArtifact, ReplicaRelationshipKeyMapping, ReplicaRelationshipKind, ReplicaResultEnvelope, ReplicaRowPolicyArtifact, ReplicaRootSelection, ReplicaScalarSelection, ReplicaSelectionStorage, ReplicaSparse, ReplicaSnapshot, ReplicaStatus, ReplicaTransport, ReplicaTransportRequest, ReplicaVariableValue, ReplicaVariableCodecArtifact, ReplicaVariableEnumInputRef, ReplicaVariableFilterInputDefinition, ReplicaVariableFilterInputField, ReplicaVariableFilterInputRelationship, ReplicaVariableFilterInputTarget, ReplicaVariableInputDefinition, ReplicaVariableInputRef, ReplicaVariableListInputRef, ReplicaVariableNamedInputRef, ReplicaVariableOrderInputDefinition, ReplicaVariableOrderInputField, ReplicaVariableScalarInputRef, ReplicaValue, ReplicaWatch, ReplicaWriteSource, WatchReplicaOptions } from './types.js';
+export type { DistributedReplicaOptions, DistributedReplica, ReplicaArgumentsArtifact, ReplicaArgumentValue, ReplicaAuthoritativeScope, ReplicaBaseWriter, ReplicaBranchSemantic, ReplicaClientSurface, ReplicaCoverageArtifact, ReplicaDehydratedState, ReplicaFilterArtifact, ReplicaFilterExpression, ReplicaFilterFieldArtifact, ReplicaFilterLiteral, ReplicaFilterOperand, ReplicaFilterOperator, ReplicaIdentity, ReplicaIndexCoverage, ReplicaIndexInspection, ReplicaIndexTarget, ReplicaIslandMetadata, ReplicaIslandOperation, ReplicaListValue, ReplicaLiveObserver, ReplicaLiveState, ReplicaLiteralValue, ReplicaModelArtifact, ReplicaObjectBranch, ReplicaObjectMember, ReplicaObjectSelection, ReplicaObjectValue, ReplicaOperationArtifact, ReplicaOperationSourceLocation, ReplicaOperationProtocol, ReplicaOrderArtifact, ReplicaOrderFieldArtifact, ReplicaOrderTieBreakerArtifact, ReplicaOptimisticWriter, ReplicaPaginationArtifact, ReplicaPaginationDisposition, ReplicaProtocolOperationArtifact, ReplicaRecordInspection, ReplicaRecordPatch, ReplicaRevalidationPlan, ReplicaRevalidationRelationship, ReplicaRevision, ReplicaRelationshipArtifact, ReplicaRelationshipKeyMapping, ReplicaRelationshipKind, ReplicaResultEnvelope, ReplicaRowPolicyArtifact, ReplicaRootSelection, ReplicaScalarSelection, ReplicaSelectionStorage, ReplicaSparse, ReplicaSnapshot, ReplicaStatus, ReplicaTransport, ReplicaTransportRequest, ReplicaVariableValue, ReplicaVariableCodecArtifact, ReplicaVariableEnumInputRef, ReplicaVariableFilterInputDefinition, ReplicaVariableFilterInputField, ReplicaVariableFilterInputRelationship, ReplicaVariableFilterInputTarget, ReplicaVariableInputDefinition, ReplicaVariableInputRef, ReplicaVariableListInputRef, ReplicaVariableNamedInputRef, ReplicaVariableOrderInputDefinition, ReplicaVariableOrderInputField, ReplicaVariableScalarInputRef, ReplicaValue, ReplicaWatch, ReplicaWriteSource, WatchReplicaOptions } from './types.js';
 export { lowerMutationCache, MUTATION_CACHE_VISIBILITY_FULL, MUTATION_CACHE_VISIBILITY_UNAUTHORIZED, } from './mutation-cache.js';
 export type { MutationCacheEffect, MutationCacheProgram, MutationCacheVisibility, MutationField, MutationOperation, MutationProgram, MutationTarget, } from './mutation-cache.js';

package/dist/replica/types.d.ts

@@ -444,6 +444,39 @@ export type ReplicaProtocolOperationArtifact<TData = Record<string, unknown>, TV
     readonly variableCodec: ReplicaVariableCodecArtifact;
 };
 export type ReplicaOperationArtifact<TData = Record<string, unknown>, TVariables extends GraphqlVariables = GraphqlVariables> = ReplicaProtocolOperationArtifact<TData, TVariables>;
+/** Framework-neutral compiler metadata consumed by placement adapters. */
+export type ReplicaIslandMetadata = {
+    readonly version: 1;
+    readonly id: string;
+    readonly operation: string;
+    readonly operationHash: string;
+    readonly modulePath: string;
+    readonly exportName: string;
+    readonly source: ReplicaOperationSourceLocation;
+    readonly directives: {
+        readonly load: boolean;
+        readonly live: boolean;
+    };
+    readonly variableSchema: {
+        readonly reference: string;
+        readonly codecVersion: number;
+        readonly variables: readonly {
+            readonly name: string;
+            readonly graphqlType: string;
+        }[];
+    };
+    readonly liveCoverage: {
+        readonly requested: boolean;
+        readonly finite: boolean;
+        readonly kind: string;
+        readonly maxItems?: number;
+    };
+};
+/** One adapter-consumable island plan bound to its executable operation. */
+export type ReplicaIslandOperation<TData = Record<string, unknown>, TVariables extends GraphqlVariables = GraphqlVariables> = {
+    readonly plan: ReplicaIslandMetadata;
+    readonly artifact: ReplicaOperationArtifact<TData, TVariables>;
+};
 export type ReplicaWriteSource = 'network' | 'live' | 'ssr' | 'restore' | 'atomic';
 export type ReplicaResultEnvelope<TData = unknown> = {
     readonly data?: TData | null;
@@ -532,6 +565,11 @@ export type WatchReplicaOptions = {
 export type DistributedReplicaOptions = {
     readonly transport?: ReplicaTransport;
     readonly onObserverError?: (error: AggregateError) => void;
+    /**
+     * Runs after the old generation is fenced and before its transports/state
+     * are purged. Framework adapters use this to release generation-owned views.
+     */
+    readonly onAuthorizationGenerationDispose?: () => void;
     /** Opt-in framework-neutral diagnostics; absent in production by default. */
     readonly diagnostics?: ReplicaDiagnosticsSink;
 };

package/dist/sveltekit/boundary-lifecycle.d.ts

@@ -0,0 +1,37 @@
+import type { DistributedReplica } from '../replica/index.js';
+import type { DistributedBoundaryOperation, DistributedBoundaryVariableContext } from './boundary-variables.js';
+export type DistributedSvelteKitBoundaryInstance = Readonly<{
+    /** Opaque identity for one mounted SvelteKit page or layout instance. */
+    id: string;
+    route: string;
+    kind: 'layout' | 'page';
+}>;
+export type DistributedSvelteKitBoundaryLocation = Readonly<{
+    /** Opaque identity for one mounted page or layout instance. */
+    id: string;
+    pathname: string;
+    kind: 'layout' | 'page';
+}>;
+export type DistributedSvelteKitLocationContext<TSession = unknown, TProps = Readonly<Record<string, unknown>>> = Omit<DistributedBoundaryVariableContext<TSession, TProps>, 'params'>;
+export type SveltekitBoundaryLifecycleDiagnostic = Readonly<{
+    action: 'acquire' | 'retain' | 'release' | 'scope-dispose' | 'final-unsubscribe';
+    boundary: string;
+    operation?: string;
+    live?: boolean;
+    owners: number;
+}>;
+export type SveltekitBoundaryRetention = Readonly<{
+    release(): void;
+}>;
+export declare class DistributedSvelteKitBoundaryController {
+    #private;
+    constructor(replica: DistributedReplica, operations: readonly DistributedBoundaryOperation[], diagnostic?: (event: SveltekitBoundaryLifecycleDiagnostic) => void);
+    retain<TSession, TProps>(instance: DistributedSvelteKitBoundaryInstance, context: DistributedBoundaryVariableContext<TSession, TProps>): SveltekitBoundaryRetention;
+    /** Retain the nearest generated page/layout boundary at a browser location. */
+    retainLocation<TSession, TProps>(location: DistributedSvelteKitBoundaryLocation, context: DistributedSvelteKitLocationContext<TSession, TProps>): SveltekitBoundaryRetention;
+    /** Warm every generated page and owning layout selection for one target URL. */
+    prefetchLocation<TSession, TProps>(pathname: string, context: DistributedSvelteKitLocationContext<TSession, TProps>): Promise<void>;
+    /** Close every old-scope owner while keeping the controller reusable. */
+    disposeScope(): void;
+    destroy(): void;
+}

package/dist/sveltekit/boundary-lifecycle.js

@@ -0,0 +1,355 @@
+import { boundaryOperationIdentity } from './operation-identity.js';
+const MAX_BOUNDARY_INSTANCES = 4_096;
+const MAX_INSTANCE_ID_BYTES = 512;
+const MAX_LOCATION_PATHNAME_BYTES = 8_192;
+const MAX_LOCATION_SEGMENTS = 256;
+export class DistributedSvelteKitBoundaryController {
+    #replica;
+    #operations;
+    #diagnostic;
+    #instances = new Map();
+    #identityOwners = new Map();
+    #destroyed = false;
+    constructor(replica, operations, diagnostic) {
+        this.#replica = replica;
+        this.#operations = operations;
+        this.#diagnostic = diagnostic;
+    }
+    retain(instance, context) {
+        if (this.#destroyed) {
+            throw new Error('Distributed SvelteKit boundary controller is destroyed');
+        }
+        const validated = validateInstance(instance);
+        const resolved = this.#resolve(validated, context);
+        const signature = JSON.stringify(resolved.map(({ identity }) => identity));
+        const existing = this.#instances.get(validated.id);
+        if (existing !== undefined) {
+            if (existing.signature !== signature ||
+                existing.boundary !== validated.boundary) {
+                throw new Error('Distributed SvelteKit boundary instance changed ownership while retained');
+            }
+            existing.owners += 1;
+            this.#emit({
+                action: 'retain',
+                boundary: existing.boundary,
+                owners: existing.owners
+            });
+            return this.#lease(validated.id, existing);
+        }
+        if (this.#instances.size >= MAX_BOUNDARY_INSTANCES) {
+            throw new Error(`Distributed SvelteKit cannot retain more than ${MAX_BOUNDARY_INSTANCES} boundary instances`);
+        }
+        const watches = [];
+        try {
+            for (const item of resolved) {
+                const watch = this.#replica.watch(item.operation.artifact, item.variables, { live: item.live });
+                watches.push(Object.freeze({
+                    watch,
+                    identity: item.identity,
+                    operation: item.operation.plan.operation,
+                    live: item.live
+                }));
+            }
+        }
+        catch (error) {
+            for (const { watch } of watches)
+                watch.destroy();
+            throw error;
+        }
+        const retained = {
+            signature,
+            boundary: validated.boundary,
+            owners: 1,
+            watches: Object.freeze(watches)
+        };
+        this.#instances.set(validated.id, retained);
+        for (const item of watches) {
+            const owners = (this.#identityOwners.get(item.identity) ?? 0) + 1;
+            this.#identityOwners.set(item.identity, owners);
+            this.#emit({
+                action: 'acquire',
+                boundary: retained.boundary,
+                operation: item.operation,
+                live: item.live,
+                owners
+            });
+        }
+        return this.#lease(validated.id, retained);
+    }
+    /** Retain the nearest generated page/layout boundary at a browser location. */
+    retainLocation(location, context) {
+        const matched = matchNearestBoundary(this.#operations, location.pathname, location.kind);
+        if (matched === undefined) {
+            return Object.freeze({ release: () => undefined });
+        }
+        return this.retain({
+            id: location.id,
+            route: matched.route,
+            kind: location.kind
+        }, Object.freeze({ ...context, params: matched.params }));
+    }
+    /** Warm every generated page and owning layout selection for one target URL. */
+    async prefetchLocation(pathname, context) {
+        if (this.#destroyed) {
+            throw new Error('Distributed SvelteKit boundary controller is destroyed');
+        }
+        const matches = matchLocationBoundaries(this.#operations, pathname);
+        const scheduled = new Map();
+        for (const matched of matches) {
+            for (const item of this.#resolve({
+                id: 'prefetch',
+                route: matched.route,
+                kind: matched.kind,
+                boundary: `${matched.kind}:${matched.route}`
+            }, Object.freeze({ ...context, params: matched.params }))) {
+                scheduled.set(item.identity, item);
+            }
+        }
+        await Promise.all([...scheduled.values()].map(async (item) => {
+            const snapshot = this.#replica.read(item.operation.artifact, item.variables);
+            if (snapshot.complete && !snapshot.stale)
+                return;
+            const watch = this.#replica.watch(item.operation.artifact, item.variables, { live: false });
+            try {
+                await watch.refresh();
+            }
+            finally {
+                watch.destroy();
+            }
+        }));
+    }
+    /** Close every old-scope owner while keeping the controller reusable. */
+    disposeScope() {
+        if (this.#destroyed)
+            return;
+        this.#disposeInstances(true);
+    }
+    destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        this.#disposeInstances(false);
+    }
+    #resolve(instance, context) {
+        const selected = this.#operations.filter(({ plan }) => plan.kind === instance.kind && normalizeRoute(plan.route) === instance.route);
+        if (selected.length === 0) {
+            throw new Error(`Distributed SvelteKit boundary plan has no ${instance.boundary} selection`);
+        }
+        return Object.freeze(selected.map((operation) => {
+            const variables = operation.binding.resolve(context);
+            return Object.freeze({
+                operation,
+                variables,
+                identity: boundaryOperationIdentity(operation.artifact, variables),
+                live: operation.artifact.live !== undefined
+            });
+        }));
+    }
+    #lease(instanceId, retained) {
+        let released = false;
+        return Object.freeze({
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                if (this.#instances.get(instanceId) !== retained)
+                    return;
+                retained.owners -= 1;
+                this.#emit({
+                    action: 'release',
+                    boundary: retained.boundary,
+                    owners: retained.owners
+                });
+                if (retained.owners > 0)
+                    return;
+                this.#instances.delete(instanceId);
+                this.#releaseWatches(retained);
+            }
+        });
+    }
+    #disposeInstances(scope) {
+        for (const [instanceId, retained] of [...this.#instances]) {
+            this.#instances.delete(instanceId);
+            if (scope) {
+                this.#emit({
+                    action: 'scope-dispose',
+                    boundary: retained.boundary,
+                    owners: 0
+                });
+            }
+            this.#releaseWatches(retained);
+        }
+    }
+    #releaseWatches(retained) {
+        for (const item of retained.watches) {
+            item.watch.destroy();
+            const owners = (this.#identityOwners.get(item.identity) ?? 1) - 1;
+            if (owners > 0) {
+                this.#identityOwners.set(item.identity, owners);
+                continue;
+            }
+            this.#identityOwners.delete(item.identity);
+            if (item.live) {
+                this.#emit({
+                    action: 'final-unsubscribe',
+                    boundary: retained.boundary,
+                    operation: item.operation,
+                    live: true,
+                    owners: 0
+                });
+            }
+        }
+    }
+    #emit(event) {
+        try {
+            this.#diagnostic?.(Object.freeze(event));
+        }
+        catch {
+            // Diagnostics are observational and cannot alter lifecycle ownership.
+        }
+    }
+}
+function validateInstance(instance) {
+    if (instance === null || typeof instance !== 'object') {
+        throw new TypeError('Distributed SvelteKit boundary instance is required');
+    }
+    const id = typeof instance.id === 'string' ? instance.id.trim() : undefined;
+    if (typeof id !== 'string' ||
+        id.length === 0 ||
+        new TextEncoder().encode(id).byteLength > MAX_INSTANCE_ID_BYTES) {
+        throw new TypeError('Distributed SvelteKit boundary instance id is invalid');
+    }
+    if (instance.kind !== 'layout' && instance.kind !== 'page') {
+        throw new TypeError('Distributed SvelteKit boundary instance kind is invalid');
+    }
+    const route = normalizeRoute(instance.route);
+    return Object.freeze({
+        id,
+        route,
+        kind: instance.kind,
+        boundary: `${instance.kind}:${route}`
+    });
+}
+function normalizeRoute(value) {
+    if (typeof value !== 'string' || !value.startsWith('/')) {
+        throw new TypeError('Distributed SvelteKit boundary route must start with /');
+    }
+    const normalized = value.length === 1 ? value : value.replace(/\/+$/, '');
+    return normalized.length === 0 ? '/' : normalized;
+}
+function matchNearestBoundary(operations, pathname, kind) {
+    const matches = matchLocationBoundaries(operations, pathname).filter((candidate) => candidate.kind === kind);
+    if (matches.length === 0)
+        return undefined;
+    const mostSpecific = matches[0];
+    if (matches[1] !== undefined &&
+        matches[1].specificity === mostSpecific.specificity) {
+        throw new Error(`Distributed SvelteKit boundary plan is ambiguous for this ${kind} location`);
+    }
+    return mostSpecific;
+}
+function matchLocationBoundaries(operations, pathname) {
+    const routes = new Map();
+    for (const { plan } of operations) {
+        routes.set(`${plan.kind}\u0000${plan.route}`, {
+            route: plan.route,
+            kind: plan.kind
+        });
+    }
+    const matches = [];
+    for (const candidate of routes.values()) {
+        const matched = matchRoutePattern(candidate.route, pathname, candidate.kind === 'layout');
+        if (matched !== undefined) {
+            matches.push(Object.freeze({ ...candidate, ...matched }));
+        }
+    }
+    return Object.freeze(matches.sort((left, right) => right.specificity - left.specificity ||
+        left.kind.localeCompare(right.kind) ||
+        left.route.localeCompare(right.route)));
+}
+function matchRoutePattern(pattern, pathname, prefix) {
+    const route = normalizeRoute(pattern);
+    const path = normalizePathname(pathname);
+    const routeSegments = route
+        .split('/')
+        .filter((segment) => segment.length > 0 && !/^\(.+\)$/.test(segment));
+    const pathSegments = path.split('/').filter((segment) => segment.length > 0);
+    const params = Object.create(null);
+    let pathIndex = 0;
+    let specificity = 0;
+    for (let routeIndex = 0; routeIndex < routeSegments.length; routeIndex += 1) {
+        const segment = routeSegments[routeIndex];
+        // SvelteKit matcher functions are application code. The browser adapter
+        // cannot execute or guess them from a generated route pattern.
+        if (segment.startsWith('[') && segment.includes('='))
+            return undefined;
+        const rest = /^\[\[?\.\.\.([^\]=]+)(?:=[^\]]+)?\]?\]$/.exec(segment);
+        if (rest !== null) {
+            const values = pathSegments.slice(pathIndex).map(decodePathSegment);
+            if (values.some((value) => value === undefined))
+                return undefined;
+            params[rest[1]] =
+                values.length === 0 ? undefined : values.join('/');
+            pathIndex = pathSegments.length;
+            break;
+        }
+        const optional = /^\[\[([^\]=]+)(?:=[^\]]+)?\]\]$/.exec(segment);
+        if (optional !== null) {
+            const remainingRequired = routeSegments
+                .slice(routeIndex + 1)
+                .filter((part) => !/^\[\[/.test(part)).length;
+            if (pathSegments.length - pathIndex > remainingRequired) {
+                const value = decodePathSegment(pathSegments[pathIndex++]);
+                if (value === undefined)
+                    return undefined;
+                params[optional[1]] = value;
+            }
+            else {
+                params[optional[1]] = undefined;
+            }
+            continue;
+        }
+        const dynamic = /^\[([^\]=]+)(?:=[^\]]+)?\]$/.exec(segment);
+        if (dynamic !== null) {
+            if (pathSegments[pathIndex] === undefined)
+                return undefined;
+            const value = decodePathSegment(pathSegments[pathIndex++]);
+            if (value === undefined)
+                return undefined;
+            params[dynamic[1]] = value;
+            continue;
+        }
+        if (pathSegments[pathIndex] === undefined)
+            return undefined;
+        const actual = decodePathSegment(pathSegments[pathIndex++]);
+        if (actual === undefined || actual !== segment)
+            return undefined;
+        specificity += 1;
+    }
+    if (!prefix && pathIndex !== pathSegments.length)
+        return undefined;
+    return Object.freeze({
+        params: Object.freeze(params),
+        specificity: specificity * 1_000 + routeSegments.length
+    });
+}
+function normalizePathname(value) {
+    if (typeof value !== 'string' ||
+        !value.startsWith('/') ||
+        new TextEncoder().encode(value).byteLength > MAX_LOCATION_PATHNAME_BYTES ||
+        value.split('/').length - 1 > MAX_LOCATION_SEGMENTS) {
+        throw new TypeError('Distributed SvelteKit location pathname is invalid or exceeds adapter limits');
+    }
+    const withoutQuery = value.split(/[?#]/u, 1)[0];
+    return withoutQuery.length === 1
+        ? withoutQuery
+        : withoutQuery.replace(/\/+$/, '');
+}
+function decodePathSegment(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return undefined;
+    }
+}