@hops-ops/distributed 4.9.0 → 4.11.0

package/dist/sveltekit/operation-identity.d.ts

@@ -0,0 +1,4 @@
+import type { ReplicaOperationArtifact } from '../replica/index.js';
+import type { GraphqlVariables } from '../types.js';
+/** Build the canonical identity shared by SSR scheduling and browser retention. */
+export declare function boundaryOperationIdentity(artifact: ReplicaOperationArtifact<unknown, GraphqlVariables>, variables: GraphqlVariables): string;

package/dist/sveltekit/operation-identity.js

@@ -0,0 +1,10 @@
+/** Build the canonical identity shared by SSR scheduling and browser retention. */
+export function boundaryOperationIdentity(artifact, variables) {
+    return JSON.stringify([
+        artifact.protocol.version,
+        artifact.protocol.schemaHash,
+        artifact.protocol.surface,
+        artifact.id,
+        variables
+    ]);
+}

package/dist/sveltekit/replica.d.ts

@@ -3,6 +3,8 @@ import type { GqlAuth, GqlError, GraphqlVariables } from '../types.js';
 import type { WebSocketConstructor } from '../websocket.js';
 import type { FetchLike } from '../request.js';
 import { type PageGraphqlData } from './auth.js';
+import { type DistributedBoundaryPlan, type DistributedBoundaryOperation, type DistributedBoundaryVariableSources, type DistributedBoundaryVariableContext } from './boundary-variables.js';
+import { type DistributedSvelteKitBoundaryInstance, type DistributedSvelteKitBoundaryLocation, type DistributedSvelteKitLocationContext, type SveltekitBoundaryLifecycleDiagnostic, type SveltekitBoundaryRetention } from './boundary-lifecycle.js';
 import { type DistributedReloadOptions } from './lifecycle.js';
 type UnknownCommandEntries = Readonly<Record<string, never>>;
 export type SveltekitSessionSource = Readonly<{
@@ -28,6 +30,8 @@ export type SveltekitReplicaHydration = Readonly<{
     version: 1;
     state: import('../replica/index.js').ReplicaDehydratedState;
     readonly operations?: readonly string[];
+    /** Exact variable-binding fingerprints used to create this SSR seed. */
+    readonly bindings?: readonly string[];
 }>;
 /**
  * Independently trusted SSR/session authority for one hydration transfer.
@@ -64,6 +68,10 @@ export type CreateDistributedSvelteKitOptions<TCommands = Readonly<Record<never,
     authority?: SveltekitReplicaAuthority;
     createCommands?: SveltekitCommandRuntimeFactory<TCommands>;
     replica?: Omit<DistributedReplicaOptions, 'transport'>;
+    /** Generated boundary operations accepted by this component-tree client. */
+    boundaries: readonly DistributedBoundaryOperation[];
+    /** Redacted structural lifecycle events for boundary ownership diagnostics. */
+    onBoundaryDiagnostic?: (event: SveltekitBoundaryLifecycleDiagnostic) => void;
     onAuthError?: (error: unknown) => void;
     /** Generated clients supply the surface key; apps may declare safe state partitions. */
     reload?: DistributedReloadOptions;
@@ -110,12 +118,21 @@ export type SveltekitBoundOperation<TData, TVariables extends GraphqlVariables>
     read(variables: TVariables): ReplicaSnapshot<TData>;
     /** Client-side hover/nav warmup; no-ops when the replica already has a complete snapshot. */
     prefetch(variables: TVariables): Promise<void>;
+    /** One typed binding shared by SSR, navigation, prefetch, hydration, and live use. */
+    boundary<TSession = unknown, TProps = Readonly<Record<string, unknown>>>(plan: DistributedBoundaryPlan, sources: DistributedBoundaryVariableSources<TVariables>): DistributedBoundaryOperation<TData, TVariables, TSession, TProps>;
 }>;
 export type DistributedSvelteKitClient<TCommands> = Readonly<{
     replica: DistributedReplica;
     transport: ReplicaGraphqlTransport;
     commands: TCommands;
     operation<TData, TVariables extends GraphqlVariables>(artifact: ReplicaOperationArtifact<TData, TVariables>): SveltekitBoundOperation<TData, TVariables>;
+    boundary<TData, TVariables extends GraphqlVariables, TSession, TProps>(operation: DistributedBoundaryOperation<TData, TVariables, TSession, TProps>): SveltekitBoundBoundaryOperation<TData, TVariables, TSession, TProps>;
+    /** Retain every generated selection owned by one mounted page/layout instance. */
+    retainBoundary<TSession, TProps>(instance: DistributedSvelteKitBoundaryInstance, context: DistributedBoundaryVariableContext<TSession, TProps>): SveltekitBoundaryRetention;
+    /** Retain the nearest generated page/layout boundary at this location. */
+    retainLocation<TSession, TProps>(location: DistributedSvelteKitBoundaryLocation, context: DistributedSvelteKitLocationContext<TSession, TProps>): SveltekitBoundaryRetention;
+    /** Prefetch the generated page and owning layout selections for a target URL. */
+    prefetchLocation<TSession, TProps>(pathname: string, context: DistributedSvelteKitLocationContext<TSession, TProps>): Promise<void>;
     /**
      * Apply a server seed. A malformed or mismatched seed closes the old
      * generation and returns false so the bound operation refetches.
@@ -125,6 +142,13 @@ export type DistributedSvelteKitClient<TCommands> = Readonly<{
     invalidateAuthorization(): void;
     destroy(): void;
 }>;
+export type SveltekitBoundBoundaryOperation<TData, TVariables extends GraphqlVariables, TSession, TProps> = Readonly<{
+    operation: DistributedBoundaryOperation<TData, TVariables, TSession, TProps>;
+    variables(context: DistributedBoundaryVariableContext<TSession, TProps>): TVariables;
+    use(context: DistributedBoundaryVariableContext<TSession, TProps>, options?: UseSveltekitOperationOptions): SveltekitQueryStore<TData>;
+    read(context: DistributedBoundaryVariableContext<TSession, TProps>): ReplicaSnapshot<TData>;
+    prefetch(context: DistributedBoundaryVariableContext<TSession, TProps>): Promise<void>;
+}>;
 /**
  * Bind the framework-neutral replica to Svelte's readable-store lifecycle.
  *

package/dist/sveltekit/replica.js

@@ -2,6 +2,8 @@ import { sameAuthCredential, snapshotAuthCredential } from '../identity.js';
 import { createDistributedReplica, createReplicaGraphqlTransport } from '../replica/index.js';
 import { replicaCommandProjectedLifecycleOf } from '../replica/command-runtime.js';
 import { authFromPageData } from './auth.js';
+import { defineDistributedBoundaryBinding, defineDistributedBoundaryOperation } from './boundary-variables.js';
+import { DistributedSvelteKitBoundaryController } from './boundary-lifecycle.js';
 import { distributedReloadLifecycle, registerDistributedReloadClient } from './lifecycle.js';
 /**
  * Bind the framework-neutral replica to Svelte's readable-store lifecycle.
@@ -15,12 +17,20 @@ export function createDistributedSvelteKit(options) {
         typeof options.session.getAuth !== 'function') {
         throw new TypeError('Distributed SvelteKit requires one session source');
     }
+    if (!Array.isArray(options.boundaries)) {
+        throw new TypeError('Distributed SvelteKit requires generated boundary operations');
+    }
     if ((options.hydration === undefined) !==
         (options.authority === undefined)) {
         throw new TypeError('Distributed SvelteKit hydration requires separate trusted SSR authority');
     }
     let replica;
-    const auth = createAuthorizationFence(options.session, () => replica?.invalidateAuthorization(), options.onAuthError);
+    let boundaryController;
+    const boundaryIds = Object.freeze([...new Set(options.boundaries.map(({ binding }) => binding.id))].sort());
+    const auth = createAuthorizationFence(options.session, () => {
+        boundaryController?.disposeScope();
+        replica?.invalidateAuthorization();
+    }, options.onAuthError);
     const configuredUrl = options.url;
     const transport = createReplicaGraphqlTransport({
         getUrl: typeof configuredUrl === 'function'
@@ -34,8 +44,13 @@ export function createDistributedSvelteKit(options) {
     });
     replica = createDistributedReplica({
         transport,
-        ...(options.replica ?? {})
+        ...(options.replica ?? {}),
+        onAuthorizationGenerationDispose: () => {
+            boundaryController?.disposeScope();
+            options.replica?.onAuthorizationGenerationDispose?.();
+        }
     });
+    boundaryController = new DistributedSvelteKitBoundaryController(replica, options.boundaries, options.onBoundaryDiagnostic);
     const stores = new Set();
     const pending = new PendingReceiptStore();
     let destroyed = false;
@@ -43,6 +58,10 @@ export function createDistributedSvelteKit(options) {
         let accepted = false;
         try {
             const expected = validatedHydrationAuthority(authority);
+            const hydrationBindings = [...(hydration.bindings ?? [])].sort();
+            if (hydrationBindings.some((value) => !boundaryIds.includes(value))) {
+                throw new TypeError('Distributed SvelteKit hydration boundary binding fingerprint changed');
+            }
             const active = replica.scope;
             if (active !== undefined && !sameReplicaScope(active, expected)) {
                 throw new TypeError('Distributed SvelteKit hydration authority changed before session invalidation');
@@ -54,8 +73,10 @@ export function createDistributedSvelteKit(options) {
         catch {
             accepted = false;
         }
-        if (!accepted)
+        if (!accepted) {
+            boundaryController.disposeScope();
             replica.invalidateAuthorization();
+        }
         return accepted;
     };
     if (options.hydration !== undefined && options.authority !== undefined) {
@@ -108,24 +129,67 @@ export function createDistributedSvelteKit(options) {
             stores.delete(store);
         }
     });
+    const boundary = (binding) => {
+        if (!boundaryIds.includes(binding.binding.id)) {
+            throw new TypeError('Distributed boundary operation was not registered with this SvelteKit client');
+        }
+        const bound = operation(binding.artifact);
+        const variables = (context) => binding.binding.resolve(context);
+        return Object.freeze({
+            operation: binding,
+            variables,
+            use(context, useOptions) {
+                const invoke = bound.use;
+                return invoke(variables(context), useOptions);
+            },
+            read(context) {
+                return bound.read(variables(context));
+            },
+            prefetch(context) {
+                return bound.prefetch(variables(context));
+            }
+        });
+    };
     return Object.freeze({
         replica,
         transport,
         commands,
         operation,
+        boundary,
+        retainBoundary(instance, context) {
+            if (destroyed) {
+                throw new Error('Distributed SvelteKit client is destroyed');
+            }
+            return boundaryController.retain(instance, context);
+        },
+        retainLocation(location, context) {
+            if (destroyed) {
+                throw new Error('Distributed SvelteKit client is destroyed');
+            }
+            return boundaryController.retainLocation(location, context);
+        },
+        prefetchLocation(pathname, context) {
+            if (destroyed) {
+                return Promise.reject(new Error('Distributed SvelteKit client is destroyed'));
+            }
+            return boundaryController.prefetchLocation(pathname, context);
+        },
         hydrate,
         prefetch(artifact, variables) {
             return prefetchReplicaOperation(replica, artifact, variables);
         },
         invalidateAuthorization() {
-            if (!destroyed)
+            if (!destroyed) {
+                boundaryController.disposeScope();
                 replica.invalidateAuthorization();
+            }
         },
         destroy() {
             if (destroyed)
                 return;
             destroyed = true;
             auth.dispose();
+            boundaryController.destroy();
             for (const store of [...stores])
                 store.destroy();
             stores.clear();
@@ -204,7 +268,10 @@ function bindOperation(replica, artifact, pending, lifecycle) {
         artifact,
         use,
         read: (variables) => replica.read(artifact, variables),
-        prefetch: (variables) => prefetchReplicaOperation(replica, artifact, variables)
+        prefetch: (variables) => prefetchReplicaOperation(replica, artifact, variables),
+        boundary(plan, sources) {
+            return defineDistributedBoundaryOperation(plan, artifact, defineDistributedBoundaryBinding(artifact, sources));
+        }
     });
 }
 function prefetchReplicaOperation(replica, artifact, variables) {

package/dist/sveltekit/server-replica.d.ts

@@ -1,24 +1,19 @@
-import { type ReplicaOperationArtifact } from '../replica/index.js';
 import type { FetchLike } from '../request.js';
 import type { GqlAuth, GraphqlVariables } from '../types.js';
 import { type PageGraphqlData } from './auth.js';
+import { type DistributedBoundaryOperation } from './boundary-variables.js';
 import type { SveltekitDistributedPageData } from './replica.js';
-export type DistributedRoutePlan = Readonly<{
-    operation: string;
-    route: string;
-    source_path?: string;
-    discovery: 'convention' | 'explicit';
-}>;
-export type DistributedRouteOperation = Readonly<{
-    plan: DistributedRoutePlan;
-    artifact: ReplicaOperationArtifact<unknown, GraphqlVariables>;
-}>;
 export type SveltekitServerLoadEventLike<TLocals = unknown> = Readonly<{
     locals: TLocals;
     route?: Readonly<{
         id?: string | null;
     }>;
     url?: URL;
+    params?: Readonly<Record<string, string | undefined>>;
+    parent?(): Promise<Readonly<Record<string, unknown>>>;
+    request?: Readonly<{
+        signal: AbortSignal;
+    }>;
     fetch?: FetchLike;
     /**
      * SvelteKit client-side navigation and hover preload (`__data.json`).
@@ -27,16 +22,16 @@ export type SveltekitServerLoadEventLike<TLocals = unknown> = Readonly<{
      */
     isDataRequest?: boolean;
 }>;
-export type DistributedRouteVariables<TEvent extends SveltekitServerLoadEventLike> = Readonly<Record<string, (event: TEvent) => GraphqlVariables | Promise<GraphqlVariables>>>;
 export type CreateDistributedSvelteKitServerOptions<TSession extends NonNullable<PageGraphqlData['session']>, TEvent extends SveltekitServerLoadEventLike = SveltekitServerLoadEventLike> = Readonly<{
-    routes: readonly DistributedRouteOperation[];
+    /** One executable binding per promoted page/layout island. */
+    boundaries: readonly DistributedBoundaryOperation<unknown, GraphqlVariables, TSession, Readonly<Record<string, unknown>>>[];
     getSession(event: TEvent): Promise<TSession | null>;
     getRole(session: TSession | null, event: TEvent): string | null | undefined;
     getAuth?(pageData: PageGraphqlData, event: TEvent): GqlAuth;
     /** Private API origin or same-origin `/graphql`; defaults to `/graphql`. */
     getUrl?(event: TEvent): string;
-    /** Variables for routed operations that do not accept `{}`. */
-    variables?: DistributedRouteVariables<TEvent>;
+    /** Maximum simultaneous SSR island refreshes. Defaults to 8, maximum 32. */
+    maxConcurrency?: number;
 }>;
 export type DistributedSvelteKitServer<TEvent> = Readonly<{
     load(event: TEvent): Promise<SveltekitDistributedPageData & {
@@ -49,14 +44,3 @@ export type DistributedSvelteKitServer<TEvent> = Readonly<{
  * across requests.
  */
 export declare function createDistributedSvelteKitServer<TSession extends NonNullable<PageGraphqlData['session']>, TEvent extends SveltekitServerLoadEventLike = SveltekitServerLoadEventLike>(options: CreateDistributedSvelteKitServerOptions<TSession, TEvent>): DistributedSvelteKitServer<TEvent>;
-/**
- * Explicit one-line fallback when the compiler cannot discover route ownership.
- *
- * Prefer co-locating `+page.graphql`; the compiler diagnostic includes the
- * equivalent `--route Operation=/route-id` registration.
- */
-export declare function registerDistributedRoute<TData, TVariables extends GraphqlVariables>(route: string, operation: string, artifact: ReplicaOperationArtifact<TData, TVariables>): DistributedRouteOperation;
-/**
- * Match a SvelteKit route id (`/blob/[[gameId]]`) to a browser pathname.
- */
-export declare function matchDistributedRoute(routeId: string, pathname: string): boolean;

package/dist/sveltekit/server-replica.js

@@ -1,12 +1,15 @@
 import { createDistributedReplica, createReplicaGraphqlTransport } from '../replica/index.js';
 import { authFromPageData } from './auth.js';
+import { resolveDistributedBoundaryVariables } from './boundary-variables.js';
+import { boundaryOperationIdentity } from './operation-identity.js';
 /**
  * One app-level root layout loader for every compiler-discovered `@load`
  * operation. Each invocation creates a fresh replica and never shares SSR data
  * across requests.
  */
 export function createDistributedSvelteKitServer(options) {
-    const routes = validateRoutes(options.routes);
+    const boundaries = validateBoundaryOperations(options.boundaries);
+    const maxConcurrency = validateConcurrency(options.maxConcurrency ?? 8);
     return Object.freeze({
         async load(event) {
             const session = await options.getSession(event);
@@ -25,54 +28,102 @@ export function createDistributedSvelteKitServer(options) {
             }
             const auth = options.getAuth?.(pageData, event) ?? authFromPageData(pageData);
             const routeId = routeIdentity(event);
-            const selected = routes.filter(({ plan }) => plan.route === routeId);
-            if (selected.length === 0) {
+            const selectedBoundaries = boundaries
+                .filter(({ plan }) => plan.kind === 'page'
+                ? plan.route === routeId
+                : layoutOwnsRoute(plan.route, routeId))
+                .sort(compareBoundaryOperations);
+            if (selectedBoundaries.length === 0) {
                 return {
                     ...pageData,
                     gqlError: null
                 };
             }
+            const requestSignal = event.request?.signal;
             const fetchImpl = event.fetch;
+            const requestFetch = fetchImpl === undefined || requestSignal === undefined
+                ? fetchImpl
+                : ((input, init) => {
+                    const transportSignal = init?.signal;
+                    const signal = transportSignal === undefined || transportSignal === null
+                        ? requestSignal
+                        : AbortSignal.any([requestSignal, transportSignal]);
+                    return fetchImpl(input, { ...init, signal });
+                });
             const transport = createReplicaGraphqlTransport({
                 getUrl: () => options.getUrl?.(event) ?? '/graphql',
                 getAuth: () => auth,
-                ...(fetchImpl === undefined ? {} : { fetch: fetchImpl })
+                ...(requestFetch === undefined ? {} : { fetch: requestFetch })
             });
             const replica = createDistributedReplica({ transport });
-            const watches = [];
+            const activeWatches = new Set();
+            const executions = [];
+            let aborted = requestSignal?.aborted ?? false;
+            const abort = () => {
+                aborted = true;
+                for (const watch of activeWatches)
+                    watch.destroy();
+            };
+            requestSignal?.addEventListener('abort', abort, { once: true });
             try {
-                for (const binding of selected) {
-                    let variables;
+                const needsParent = selectedBoundaries.some(({ binding }) => Object.values(binding.sources).some((source) => source?.kind === 'forwarded_prop'));
+                const props = needsParent && event.parent !== undefined
+                    ? await settleWithRequestAbort(() => event.parent(), requestSignal)
+                    : Object.freeze({});
+                if (aborted)
+                    throw requestAborted();
+                const boundaryContext = Object.freeze({
+                    params: event.params ?? Object.freeze({}),
+                    search: event.url?.searchParams ?? new URLSearchParams(),
+                    session,
+                    props
+                });
+                const scheduled = new Map();
+                for (const binding of selectedBoundaries) {
+                    if (aborted)
+                        throw requestAborted();
+                    const variables = resolveDistributedBoundaryVariables(binding.artifact, binding.binding.sources, boundaryContext);
+                    const identity = boundaryOperationIdentity(binding.artifact, variables);
+                    if (scheduled.has(identity))
+                        continue;
+                    scheduled.set(identity, {
+                        identity,
+                        operation: binding.plan.operation,
+                        artifact: binding.artifact,
+                        variables
+                    });
+                }
+                const completed = await mapBounded([...scheduled.values()], maxConcurrency, async (item) => {
+                    if (aborted)
+                        throw requestAborted();
+                    const watch = replica.watch(item.artifact, item.variables, { live: false });
+                    activeWatches.add(watch);
+                    let failure = null;
                     try {
-                        variables =
-                            (await options.variables?.[binding.plan.operation]?.(event)) ??
-                                {};
-                        const watch = replica.watch(binding.artifact, variables, { live: false });
-                        watches.push({
-                            operation: binding.plan.operation,
-                            artifact: binding.artifact,
-                            variables,
-                            watch
-                        });
+                        await watch.refresh();
                     }
-                    catch (error) {
-                        if (options.variables?.[binding.plan.operation] === undefined) {
-                            throw new Error(`Distributed @load operation \`${binding.plan.operation}\` needs route variables; configure variables.${binding.plan.operation}(event) in createDistributedSvelteKitServer`, { cause: error });
-                        }
-                        throw error;
+                    catch {
+                        failure = 'Distributed GraphQL island refresh failed';
                     }
-                }
-                await Promise.all(watches.map(({ watch }) => watch.refresh()));
-                const errors = watches.flatMap(({ watch }) => watch.get().errors);
-                for (const { artifact, variables, watch } of watches) {
+                    if (watch.get().errors.length > 0) {
+                        failure = 'Distributed GraphQL island refresh failed';
+                    }
+                    return Object.freeze({ ...item, watch, failure });
+                });
+                executions.push(...completed);
+                if (aborted)
+                    throw requestAborted();
+                const errors = executions.flatMap(({ failure }) => failure === null ? [] : [failure]);
+                for (const { artifact, variables, watch } of executions) {
                     // Preserve exact rendered-operation reachability after the
                     // temporary watch is released.
                     replica.read(artifact, variables);
                     watch.destroy();
+                    activeWatches.delete(watch);
                 }
                 const transfer = replica.scope === undefined
                     ? undefined
-                    : hydrationTransfer(replica.dehydrate(), selected.map(({ plan }) => plan.operation));
+                    : hydrationTransfer(replica.dehydrate(), selectedBoundaries.map(({ plan }) => plan.operation), selectedBoundaries.map(({ binding }) => binding.id));
                 return {
                     ...pageData,
                     ...(transfer === undefined
@@ -81,41 +132,30 @@ export function createDistributedSvelteKitServer(options) {
                             distributed: transfer.hydration,
                             distributedAuthority: transfer.authority
                         }),
-                    gqlError: errors[0]?.message ??
+                    gqlError: errors[0] ??
                         (transfer === undefined
                             ? 'Distributed GraphQL response did not establish an authoritative cache scope'
                             : null)
                 };
             }
             finally {
-                for (const { watch } of watches)
+                requestSignal?.removeEventListener('abort', abort);
+                for (const watch of activeWatches)
                     watch.destroy();
+                activeWatches.clear();
             }
         }
     });
 }
-/**
- * Explicit one-line fallback when the compiler cannot discover route ownership.
- *
- * Prefer co-locating `+page.graphql`; the compiler diagnostic includes the
- * equivalent `--route Operation=/route-id` registration.
- */
-export function registerDistributedRoute(route, operation, artifact) {
-    return Object.freeze({
-        plan: Object.freeze({
-            operation: nonEmpty(operation, 'operation'),
-            route: normalizeRoute(route),
-            discovery: 'explicit'
-        }),
-        artifact: artifact
-    });
-}
-function hydrationTransfer(state, operations) {
+function hydrationTransfer(state, operations, bindings = []) {
     return Object.freeze({
         hydration: Object.freeze({
             version: 1,
             state,
-            operations: Object.freeze([...operations])
+            operations: Object.freeze([...operations]),
+            ...(bindings.length === 0
+                ? {}
+                : { bindings: Object.freeze([...new Set(bindings)].sort()) })
         }),
         authority: Object.freeze({
             version: 1,
@@ -123,102 +163,89 @@ function hydrationTransfer(state, operations) {
         })
     });
 }
-/**
- * Match a SvelteKit route id (`/blob/[[gameId]]`) to a browser pathname.
- */
-export function matchDistributedRoute(routeId, pathname) {
-    const route = normalizeRoute(routeId);
-    const path = normalizePathname(pathname);
-    if (route === path)
-        return true;
-    const routeParts = route
-        .split('/')
-        .filter(Boolean)
-        .filter((part) => !(part.startsWith('(') && part.endsWith(')')));
-    const pathParts = path.split('/').filter(Boolean);
-    const failed = new Set();
-    const matches = (routeIndex, pathIndex) => {
-        const state = routeIndex + ':' + pathIndex;
-        if (failed.has(state))
-            return false;
-        if (routeIndex === routeParts.length) {
-            return pathIndex === pathParts.length;
-        }
-        const part = routeParts[routeIndex];
-        const optionalRest = part.startsWith('[[...') && part.endsWith(']]');
-        const rest = part.startsWith('[...') && part.endsWith(']');
-        if (optionalRest || rest) {
-            for (let next = pathIndex; next <= pathParts.length; next += 1) {
-                if (matches(routeIndex + 1, next))
-                    return true;
-            }
-            failed.add(state);
-            return false;
-        }
-        const optional = part.startsWith('[[') && part.endsWith(']]');
-        if (optional) {
-            if (matches(routeIndex + 1, pathIndex))
-                return true;
-            if (pathIndex < pathParts.length &&
-                matches(routeIndex + 1, pathIndex + 1)) {
-                return true;
-            }
-            failed.add(state);
-            return false;
-        }
-        const parameter = part.startsWith('[') && part.endsWith(']');
-        if ((parameter && pathIndex < pathParts.length) ||
-            (!parameter &&
-                pathIndex < pathParts.length &&
-                pathParts[pathIndex] === part)) {
-            if (matches(routeIndex + 1, pathIndex + 1))
-                return true;
-        }
-        failed.add(state);
-        return false;
-    };
-    return matches(0, 0);
-}
-function normalizePathname(pathname) {
-    if (typeof pathname !== 'string' || pathname.length === 0)
-        return '/';
-    const trimmed = pathname.replace(/\/+$/, '');
-    return trimmed.length === 0 ? '/' : trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
-}
-function validateRoutes(value) {
+function validateBoundaryOperations(value) {
     if (!Array.isArray(value)) {
-        throw new TypeError('createDistributedSvelteKitServer requires generated DISTRIBUTED_ROUTE_OPERATIONS');
+        throw new TypeError('createDistributedSvelteKitServer boundaries must be an array');
     }
     const identities = new Set();
-    return Object.freeze(value.map((binding, index) => {
-        if (binding === null ||
-            typeof binding !== 'object' ||
-            binding.plan === null ||
-            typeof binding.plan !== 'object' ||
-            binding.artifact === null ||
-            typeof binding.artifact !== 'object') {
-            throw new TypeError(`invalid Distributed route binding at index ${index}`);
-        }
-        const operation = nonEmpty(binding.plan.operation, 'route operation');
-        const route = normalizeRoute(binding.plan.route);
-        if (binding.artifact.id.length === 0) {
-            throw new TypeError(`invalid Distributed route artifact for ${operation}`);
+    return Object.freeze(value.map((operation, index) => {
+        if (operation === null ||
+            typeof operation !== 'object' ||
+            operation.binding?.version !== 1 ||
+            operation.binding.artifactId !== operation.artifact?.id) {
+            throw new TypeError(`invalid Distributed boundary operation at index ${index}`);
         }
-        const identity = `${route}\u0000${operation}`;
+        const route = normalizeRoute(operation.plan.route);
+        const identity = `${operation.plan.kind}\u0000${route}\u0000${operation.plan.operation}`;
         if (identities.has(identity)) {
-            throw new TypeError(`duplicate Distributed route operation ${operation} at ${route}`);
+            throw new TypeError(`duplicate Distributed boundary operation ${operation.plan.operation} at ${route}`);
         }
         identities.add(identity);
         return Object.freeze({
-            plan: Object.freeze({
-                ...binding.plan,
-                operation,
-                route
-            }),
-            artifact: binding.artifact
+            ...operation,
+            plan: Object.freeze({ ...operation.plan, route })
         });
     }));
 }
+function compareBoundaryOperations(left, right) {
+    const leftDepth = left.plan.route.split('/').filter(Boolean).length;
+    const rightDepth = right.plan.route.split('/').filter(Boolean).length;
+    return (leftDepth - rightDepth ||
+        left.plan.kind.localeCompare(right.plan.kind) ||
+        left.plan.route.localeCompare(right.plan.route) ||
+        left.plan.operation.localeCompare(right.plan.operation) ||
+        left.binding.id.localeCompare(right.binding.id));
+}
+function layoutOwnsRoute(layout, route) {
+    const owner = normalizeRoute(layout);
+    const selected = normalizeRoute(route);
+    return owner === '/' || selected === owner || selected.startsWith(`${owner}/`);
+}
+function validateConcurrency(value) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > 32) {
+        throw new TypeError('Distributed SvelteKit maxConcurrency must be an integer from 1 through 32');
+    }
+    return value;
+}
+async function mapBounded(values, concurrency, map) {
+    const results = new Array(values.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < values.length) {
+            const index = next;
+            next += 1;
+            results[index] = await map(values[index], index);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));
+    return results;
+}
+function requestAborted() {
+    const error = new Error('Distributed SvelteKit request was aborted');
+    error.name = 'AbortError';
+    return error;
+}
+async function settleWithRequestAbort(start, signal) {
+    if (signal === undefined)
+        return await start();
+    if (signal.aborted)
+        throw requestAborted();
+    let rejectAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        rejectAbort = reject;
+    });
+    const abort = () => rejectAbort?.(requestAborted());
+    signal.addEventListener('abort', abort, { once: true });
+    try {
+        if (signal.aborted)
+            throw requestAborted();
+        return await Promise.race([start(), aborted]);
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+        rejectAbort = undefined;
+    }
+}
 function routeIdentity(event) {
     const route = event.route?.id;
     if (typeof route === 'string' && route.length > 0)