@hops-ops/distributed 4.9.0 → 4.11.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,56 @@ 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
+surface needs its own authorization-specific copy, use a qualified route
+document such as `+layout.public.graphql`; it still belongs to that layout.
+
+Put stable values in GraphQL itself:
+
+```graphql
+query ChatMessages(
+  $limit: Int! = 25
+  $offset: Int! = 0
+) @load @live {
+  chat_messages(limit: $limit, offset: $offset) { message_id body }
+}
+```
+
+The generated variable properties are optional, while the compiler-owned codec
+canonicalizes the defaults before cache identity, SSR, live continuation, or
+transport. An explicit `ChatMessages.use({ limit: 50, offset: 0 })` overrides
+them; `ChatMessages.use()` uses the exact defaults.
+
+Same-name route parameters are inferred. For external values, add one bounded
+sidecar beside the document rather than putting screen behavior in
+`distributed.config.js`:
+
+```js
+// SearchResults.graphql.bindings.js
+import {
+  defineGraphqlIslandBindings,
+  forwardedProp,
+  searchParam,
+  sessionClaim
+} from '@hops-ops/distributed/sveltekit';
+
+export default defineGraphqlIslandBindings({
+  query: searchParam('q'),
+  viewerId: sessionClaim('user', 'id'),
+  filters: forwardedProp('filters')
+});
+```
+
+The helper rejects unsafe shapes, generation checks the keys against the
+operation, and the same binding is reused by SSR, hover prefetch, navigation,
+hydration, and live work. Resolution precedence is explicit call variables,
+then sidecar/route sources, then GraphQL defaults. A non-null variable without
+any of those sources fails generation before transport. Central `boundaries`
+registrations remain an explicit-placement escape hatch and cannot be combined
+with a sidecar for the same operation.
+
 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 +247,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 +265,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 +291,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 +374,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 +504,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/identity/codec.d.ts

@@ -3,6 +3,7 @@ import type { ReplicaOperationArtifact, ReplicaVariableCodecArtifact, ReplicaVar
 export type VariableCodecRegistry = {
     readonly limits: ReplicaVariableCodecLimits;
     readonly variables: ReadonlyMap<string, ReplicaVariableInputRef>;
+    readonly defaults: ReadonlyMap<string, ReplicaValue>;
     readonly inputs: ReadonlyMap<string, ReplicaVariableInputDefinition>;
 };
 /**

package/dist/replica/identity/codec.js

@@ -24,6 +24,10 @@ export function canonicalizeOperationVariables(artifact, variables) {
     for (const [name, input] of [...registry.variables].sort(([left], [right]) => compareCodeUnits(left, right))) {
         const present = supplied.has(name) && supplied.get(name) !== undefined;
         if (!present) {
+            if (registry.defaults.has(name)) {
+                canonical.push([name, registry.defaults.get(name)]);
+                continue;
+            }
             if (!input.nullable) {
                 variableValueInvalid(`variables.${name}`, 'required variable is missing');
             }
@@ -37,8 +41,8 @@ export function canonicalizeOperationVariables(artifact, variables) {
     return freezeRecord(canonical);
 }
 export function validateVariableCodec(codec) {
-    const root = artifactRecord(codec, 'artifact.variableCodec', ['version', 'limits', 'variables', 'inputs']);
-    if (root.version !== 1)
+    const root = artifactRecord(codec, 'artifact.variableCodec', ['version', 'limits', 'variables', 'defaults', 'inputs']);
+    if (root.version !== 2)
         variableCodecInvalid('artifact.variableCodec.version');
     const rawLimits = artifactRecord(root.limits, 'artifact.variableCodec.limits', ['maxDepth', 'maxBoolWidth', 'maxInList']);
     const limits = {
@@ -62,7 +66,16 @@ export function validateVariableCodec(codec) {
     for (const [name, definition] of inputs) {
         validateInputDefinition(definition, `artifact.variableCodec.inputs.${name}`, inputs, new Set(), 0);
     }
-    return { limits, variables, inputs };
+    const defaults = new Map();
+    const registry = { limits, variables, defaults, inputs };
+    for (const [name, value] of artifactRecordEntries(root.defaults, 'artifact.variableCodec.defaults')) {
+        const input = variables.get(name);
+        if (input === undefined) {
+            variableCodecInvalid(`artifact.variableCodec.defaults.${name}`);
+        }
+        defaults.set(name, canonicalizeInputRef(input, value, registry, `artifact.variableCodec.defaults.${name}`, new Set(), 0));
+    }
+    return registry;
 }
 export function validateInputRef(value, path, inputs, limits, active, depth) {
     checkCodecDepth(depth, path);

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

@@ -150,9 +150,11 @@ export type ReplicaVariableCodecLimits = {
 };
 /** Exact variable codec emitted beside a generated operation artifact. */
 export type ReplicaVariableCodecArtifact = {
-    readonly version: 1;
+    readonly version: 2;
     readonly limits: ReplicaVariableCodecLimits;
     readonly variables: Readonly<Record<string, ReplicaVariableInputRef>>;
+    /** Canonical GraphQL defaults, applied before cache identity or transport. */
+    readonly defaults: Readonly<Record<string, ReplicaValue>>;
     readonly inputs: Readonly<Record<string, ReplicaVariableInputDefinition>>;
 };
 export type ReplicaFilterOperator = '_eq' | '_neq' | '_gt' | '_gte' | '_lt' | '_lte' | '_in' | '_nin' | '_is_null' | '_like' | '_ilike' | '_contains' | '_contained_in' | '_has_key';
@@ -444,6 +446,40 @@ 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 defaultValue?: ReplicaValue;
+        }[];
+    };
+    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 +568,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;
+}