@astrale-os/kernel-protocol 0.5.0-beta.6 → 0.5.0-beta.61

package/dist/routes/compiler.js

@@ -1,3 +1,4 @@
+import { isBinaryInput } from '@astrale-os/kernel-dsl/v1';
 import { admitRouteDeclaration } from '../publication/route.js';
 import { rejectCollisions } from './collision.js';
 import { fail } from './error.js';
@@ -8,41 +9,46 @@ export function compile(input) {
     if (input === null || typeof input !== 'object' || !Array.isArray(input.routes)) {
         throw new TypeError('Route compilation input is invalid.');
     }
-    const authored = input.routes.map((entry) => admitRouteDeclaration(entry, input.validator.origin));
+    const authored = input.routes.map((entry) => admitRouteDeclaration(entry, input.domain.origin));
     const entries = authored.map((declaration) => {
-        const meaning = input.validator.callable(declaration.callable);
-        if (meaning === undefined) {
-            fail('NATIVE_ROUTE_BINDING_INVALID', `Unknown callable ${declaration.callable}.`);
+        const meaning = input.domain.callable(declaration.callable);
+        if (meaning === undefined || (isMethod(meaning) && !meaning.executable)) {
+            fail('NATIVE_ROUTE_BINDING_INVALID', `Unavailable callable ${declaration.callable}.`);
+        }
+        if (isBinaryInput(meaning.definition.input)) {
+            fail('NATIVE_ROUTE_BINDING_INVALID', `Native route ${declaration.name} cannot bind a binary-input Function.`);
         }
         const href = placePath(declaration.path, 'https://routes.invalid');
         const route = { ...declaration, href };
         validateTemplate(href);
-        validateMapping(route, meaning.fields, meaning.target.kind === 'method' && meaning.target.dispatch === 'instance');
+        validateMapping(route, meaning.inputFields, isMethod(meaning) && !meaning.static);
         validateWireMapping(route);
         validateCredentialMapping(route);
         if (route.method === 'GET' && route.body !== undefined) {
             fail('NATIVE_ROUTE_DECLARATION_INVALID', `GET route ${route.name} cannot declare a body.`);
         }
-        const target = meaning.target.kind === 'function'
+        const target = !isMethod(meaning)
             ? { kind: 'function' }
-            : meaning.target.dispatch === 'static'
+            : meaning.static
                 ? { kind: 'method', dispatch: 'static' }
                 : { kind: 'method', dispatch: 'instance', receiver: route.receiver };
         const { href: _href, receiver: _receiver, ...portable } = route;
         return Object.freeze({
             ...portable,
             target,
-            authentication: meaning.authentication,
-            output: meaning.output,
+            auth: meaning.auth,
+            output: meaning.output.mode,
             path: declaration.path,
             default: declaration.default === true,
         });
     });
     rejectCollisions(entries.map((entry) => ({ ...entry, href: placePath(entry.path, 'https://routes.invalid') })));
     return Object.freeze({
-        origin: input.validator.origin,
-        revision: input.validator.revision,
+        origin: input.domain.origin,
+        revision: input.domain.revision,
         entries: Object.freeze(entries),
     });
 }
-//# sourceMappingURL=compiler.js.map
+function isMethod(meaning) {
+    return 'owner' in meaning;
+}

package/dist/routes/credential.d.ts

@@ -6,4 +6,3 @@ export declare function specificHeaderWires(entry: Route): ReadonlySet<string>;
 export declare function putCredential(entry: Route, url: URL, headers: Record<string, string>, credential: string): void;
 export declare function withoutCredentialHeaders(entry: Route, input: Readonly<Record<string, string>>): Record<string, string>;
 export declare function readCredential(entry: Route, url: URL, headers: Record<string, string>): string | undefined;
-//# sourceMappingURL=credential.d.ts.map

package/dist/routes/credential.js

@@ -116,4 +116,3 @@ function withoutCookie(header, name) {
         .join('; ');
     return value.length === 0 ? undefined : value;
 }
-//# sourceMappingURL=credential.js.map

package/dist/routes/decode.d.ts

@@ -1,6 +1,5 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
 import type { PublicationRef } from '../publication/index.js';
 import type { HttpRequest, Invocation } from './request.js';
 import type { Route } from './table.js';
-export declare function decode(entry: Route, request: HttpRequest, validator: schema.Validator, served: PublicationRef): Invocation;
-//# sourceMappingURL=decode.d.ts.map
+export declare function decode(entry: Route, request: HttpRequest, domain: Domain, served: PublicationRef): Invocation;

package/dist/routes/decode.js

@@ -1,5 +1,4 @@
-import { NodePath, Path } from '@astrale-os/kernel-core/path';
-import { Key, Ref } from '@astrale-os/kernel-dsl/v1/addressing';
+import { NodePath } from '@astrale-os/kernel-core/path';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { readCredential, specificHeaderWires, withoutCredentialHeaders } from './credential.js';
 import { fail, invalidRequest } from './error.js';
@@ -10,7 +9,7 @@ import { decodeRouting } from './routing.js';
 import { decodeScalar } from './scalar.js';
 import { requiresReceiver } from './target.js';
 import { matchTemplate, PLACEHOLDER } from './template.js';
-export function decode(entry, request, validator, served) {
+export function decode(entry, request, domain, served) {
     if (!methodMatches(entry, request.method))
         invalidRequest('HTTP method does not match the route.');
     const matched = matchTemplate(entry.href, request.url);
@@ -18,10 +17,10 @@ export function decode(entry, request, validator, served) {
         invalidRequest('URL does not match the route template.');
     const values = {};
     for (const [name, value] of Object.entries(matched)) {
-        values[name] = decodeScalar(entry, name, value, validator);
+        values[name] = decodeScalar(entry, name, value, domain);
     }
     if (entry.requestMethod !== undefined) {
-        values[entry.requestMethod] = decodeScalar(entry, entry.requestMethod, request.method.toUpperCase(), validator);
+        values[entry.requestMethod] = decodeScalar(entry, entry.requestMethod, request.method.toUpperCase(), domain);
     }
     let url;
     try {
@@ -41,7 +40,7 @@ export function decode(entry, request, validator, served) {
         const found = url.searchParams.getAll(wire);
         if (found.length !== 1)
             invalidRequest(`Query parameter ${wire} must occur exactly once.`);
-        values[name] = decodeScalar(entry, name, found[0], validator);
+        values[name] = decodeScalar(entry, name, found[0], domain);
     }
     for (const [name, pick] of Object.entries(entry.headers ?? {})) {
         if (pick === '*') {
@@ -55,12 +54,12 @@ export function decode(entry, request, validator, served) {
             const value = headers[pick.toLowerCase()];
             if (value === undefined)
                 invalidRequest(`Missing header ${pick}.`);
-            values[name] = decodeScalar(entry, name, value, validator);
+            values[name] = decodeScalar(entry, name, value, domain);
         }
     }
     if (entry.body === '*') {
         const body = parseJsonObject(request.body);
-        const allowed = remainderFields(entry, validator);
+        const allowed = remainderFields(entry, domain);
         for (const name of Object.keys(body)) {
             if (!allowed.has(name)) {
                 invalidRequest(`JSON body field ${name} is not owned by the route remainder mapping.`);
@@ -112,34 +111,25 @@ export function decode(entry, request, validator, served) {
         }
         throw cause;
     }
-    const ref = Key.ref(entry.callable);
-    const target = Ref.isMethod(ref)
-        ? receiver === undefined
-            ? Path.staticMethod(Path.project({
-                origin: Key.origin(entry.callable),
-                kind: Ref.namespace(ref),
-                name: Ref.member(ref),
-            }), Ref.child(ref)).raw
-            : Path.instanceMethod(Path.from(receiver), Ref.child(ref)).raw
-        : Path.project({
-            origin: Key.origin(entry.callable),
-            kind: 'function',
-            name: Ref.member(ref),
-        }).raw;
+    const target = Object.freeze({
+        callable: entry.callable,
+        revision: domain.revision,
+        ...(receiver === undefined ? {} : { instance: receiver }),
+    });
     return Object.freeze({
         call: Object.freeze({ target, input }),
         ...(credential === undefined ? {} : { credential }),
         ...(routing === undefined ? {} : { routing }),
     });
 }
-function remainderFields(entry, validator) {
+function remainderFields(entry, domain) {
     const claimed = new Set([
         ...[...entry.href.matchAll(PLACEHOLDER)].map((item) => item[1]),
         ...(entry.requestMethod === undefined ? [] : [entry.requestMethod]),
         ...Object.keys(entry.query ?? {}),
         ...Object.keys(entry.headers ?? {}),
     ]);
-    const fields = validator.callable(entry.callable)?.fields ?? [];
+    const fields = domain.callable(entry.callable)?.inputFields ?? [];
     const allowed = new Set(fields.filter((name) => !claimed.has(name)));
     const receiver = entry.target.kind === 'method' && entry.target.dispatch === 'instance'
         ? entry.target.receiver
@@ -149,4 +139,3 @@ function remainderFields(entry, validator) {
     }
     return allowed;
 }
-//# sourceMappingURL=decode.js.map

package/dist/routes/encode.d.ts

@@ -1,5 +1,4 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
 import type { Invocation, Request } from './request.js';
 import type { Route } from './table.js';
-export declare function encode(entry: Route, invocation: Invocation, validator: schema.Validator): Request;
-//# sourceMappingURL=encode.d.ts.map
+export declare function encode(entry: Route, invocation: Invocation, domain: Domain): Request;

package/dist/routes/encode.js

@@ -1,5 +1,6 @@
+import { targetPath } from '@astrale-os/kernel-core/callable';
 import { Path } from '@astrale-os/kernel-core/path';
-import { Key, Ref } from '@astrale-os/kernel-dsl/v1/addressing';
+import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { firstCredentialIsAmbient, putCredential, specificHeaderWires, withoutCredentialHeaders, } from './credential.js';
 import { fail, invalidRequest } from './error.js';
@@ -8,26 +9,27 @@ import { encodeStrongEtag, HTTP_ROUTE_ISSUER, HTTP_ROUTE_PUBLICATION } from './r
 import { asObject, encodeScalar, scalar } from './scalar.js';
 import { requiresReceiver } from './target.js';
 import { authorityEnd, encodeTemplate, PLACEHOLDER } from './template.js';
-export function encode(entry, invocation, validator) {
+export function encode(entry, invocation, domain) {
+    if (typeof invocation.call.target !== 'string' &&
+        invocation.call.target.revision !== undefined &&
+        invocation.call.target.revision !== domain.revision) {
+        invalidRequest('Invocation Target revision does not match the selected route Domain.');
+    }
     const input = asObject(invocation.call.input);
-    const target = Path.from(invocation.call.target);
+    const target = Path.from(targetPath(invocation.call.target));
     const needsReceiver = requiresReceiver(entry);
-    const ref = Key.ref(entry.callable);
-    const methodName = Ref.isMethod(ref) ? Ref.child(ref) : undefined;
+    const coordinate = callableAddress(entry.callable);
+    const methodName = coordinate.kind === 'method' ? coordinate.name : undefined;
     const receiver = needsReceiver ? instanceSource(target, methodName) : undefined;
     const source = receiver?.raw;
     const expected = needsReceiver
-        ? Path.instanceMethod(receiver, methodName).raw
-        : Ref.isMethod(ref)
-            ? Path.staticMethod(Path.project({
-                origin: Key.origin(entry.callable),
-                kind: Ref.namespace(ref),
-                name: Ref.member(ref),
-            }), methodName).raw
+        ? Path.instanceMethod(receiver, entry.callable).raw
+        : coordinate.kind === 'method'
+            ? Path.staticMethod(Path.project(coordinate.owner), methodName).raw
             : Path.project({
-                origin: Key.origin(entry.callable),
+                origin: coordinate.origin,
                 kind: 'function',
-                name: Ref.member(ref),
+                name: coordinate.name,
             }).raw;
     if (target.raw !== expected)
         invalidRequest('Invocation Path does not match the selected route.');
@@ -35,7 +37,7 @@ export function encode(entry, invocation, validator) {
         ? entry.target.receiver
         : undefined;
     const field = (name) => (name === receiverName ? source : input[name]);
-    const wireField = (name) => encodeScalar(entry, name, field(name), validator);
+    const wireField = (name) => encodeScalar(entry, name, field(name), domain);
     const hostEnd = authorityEnd(entry.href);
     let url = entry.href.replaceAll(PLACEHOLDER, (_whole, name, catchall, offset) => encodeTemplate(wireField(name), catchall, offset < hostEnd));
     const parsed = new URL(url);
@@ -113,7 +115,7 @@ export function encode(entry, invocation, validator) {
     url = parsed.toString();
     const mappedMethod = entry.requestMethod === undefined
         ? undefined
-        : encodeScalar(entry, entry.requestMethod, input[entry.requestMethod], validator).toUpperCase();
+        : encodeScalar(entry, entry.requestMethod, input[entry.requestMethod], domain).toUpperCase();
     const requestedMethod = invocation.method?.toUpperCase();
     if (mappedMethod !== undefined &&
         requestedMethod !== undefined &&
@@ -147,4 +149,3 @@ function instanceSource(target, name) {
     }
     return Path.fromAST({ anchor: target.ast.anchor, steps: steps.slice(0, -1) });
 }
-//# sourceMappingURL=encode.js.map

package/dist/routes/error-response.d.ts

@@ -3,4 +3,3 @@ export interface ErrorResponse {
     readonly error: ErrorPayload;
 }
 export declare function decodeErrorResponse(input: unknown): ErrorResponse;
-//# sourceMappingURL=error-response.d.ts.map

package/dist/routes/error-response.js

@@ -29,4 +29,3 @@ function isValueObject(value) {
 function invalid(cause) {
     return fail('NATIVE_ROUTE_RESPONSE_INVALID', 'Native route error response is invalid.', cause);
 }
-//# sourceMappingURL=error-response.js.map

package/dist/routes/error.d.ts

@@ -6,4 +6,3 @@ export declare class RouteError extends Error {
 }
 export declare function fail(code: ErrorCode, message: string, cause?: unknown): never;
 export declare function invalidRequest(message: string): never;
-//# sourceMappingURL=error.d.ts.map

package/dist/routes/error.js

@@ -12,4 +12,3 @@ export function fail(code, message, cause) {
 export function invalidRequest(message) {
     return fail('NATIVE_ROUTE_REQUEST_INVALID', message);
 }
-//# sourceMappingURL=error.js.map

package/dist/routes/evidence.d.ts

@@ -1,6 +1,5 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
 import type { Publication } from '../publication/publication.js';
 import type { Table } from './table.js';
-/** Verify that an admitted Table carries the exact published wire and Validator meaning. */
-export declare function verifyTable(table: Table, deployed: Publication, validator: schema.Validator): Table;
-//# sourceMappingURL=evidence.d.ts.map
+/** Verify that an admitted Table carries the exact published wire and Domain meaning. */
+export declare function verifyTable(table: Table, deployed: Publication, domain: Pick<Domain, 'origin' | 'revision' | 'callable'>): Table;

package/dist/routes/evidence.js

@@ -1,32 +1,34 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { compareReferences, reference } from '../publication/reference.js';
 import { fail } from './error.js';
-/** Verify that an admitted Table carries the exact published wire and Validator meaning. */
-export function verifyTable(table, deployed, validator) {
+/** Verify that an admitted Table carries the exact published wire and Domain meaning. */
+export function verifyTable(table, deployed, domain) {
     if (compareReferences(table.publication, reference(deployed)) !== 'exact' ||
-        validator.origin !== deployed.origin ||
-        validator.revision !== deployed.schema.revision ||
+        domain.origin !== deployed.origin ||
+        domain.revision !== deployed.schema.revision ||
         json.serialize(table.entries.map(wireRoute)) !==
             json.serialize(deployed.routes)) {
         fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Table evidence differs from its Publication.');
     }
     for (const entry of table.entries) {
-        const meaning = validator.callable(entry.callable);
+        const meaning = domain.callable(entry.callable);
         const targetMatches = meaning !== undefined &&
-            ((entry.target.kind === 'function' && meaning.target.kind === 'function') ||
+            ((entry.target.kind === 'function' && !isMethod(meaning)) ||
                 (entry.target.kind === 'method' &&
-                    meaning.target.kind === 'method' &&
-                    entry.target.dispatch === meaning.target.dispatch));
-        if (!targetMatches ||
-            meaning.authentication !== entry.authentication ||
-            meaning.output !== entry.output) {
-            fail('NATIVE_ROUTE_BINDING_INVALID', `Route ${entry.name} differs from Validator meaning.`);
+                    isMethod(meaning) &&
+                    meaning.executable &&
+                    entry.target.dispatch === (meaning.static ? 'static' : 'instance')));
+        if (!targetMatches || meaning.auth !== entry.auth || meaning.output.mode !== entry.output) {
+            fail('NATIVE_ROUTE_BINDING_INVALID', `Route ${entry.name} differs from Domain meaning.`);
         }
     }
     return table;
 }
+function isMethod(meaning) {
+    return 'owner' in meaning;
+}
 function wireRoute(entry) {
-    const { target, authentication: _authentication, output: _output, default: isDefault, ...wire } = entry;
+    const { target, auth: _auth, output: _output, default: isDefault, ...wire } = entry;
     return {
         ...wire,
         ...(isDefault ? { default: true } : {}),
@@ -35,4 +37,3 @@ function wireRoute(entry) {
             : {}),
     };
 }
-//# sourceMappingURL=evidence.js.map

package/dist/routes/index.d.ts

@@ -17,4 +17,3 @@ export { decodeRouting, decodeMiss, decodeStale, HTTP_ROUTE_PUBLICATION, HTTP_RO
 export { select } from './select.js';
 export { decodeStreamFrame, encodeStreamFrame, STREAM_MEDIA_TYPE, type StreamFrame, } from './stream.js';
 export { templatesOverlap } from './template.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/routes/index.js

@@ -14,4 +14,3 @@ export { decodeRouting, decodeMiss, decodeStale, HTTP_ROUTE_PUBLICATION, HTTP_RO
 export { select } from './select.js';
 export { decodeStreamFrame, encodeStreamFrame, STREAM_MEDIA_TYPE, } from './stream.js';
 export { templatesOverlap } from './template.js';
-//# sourceMappingURL=index.js.map

package/dist/routes/mapping.d.ts

@@ -3,4 +3,3 @@ export declare function validateMapping(route: HttpRoute, fields: readonly strin
 export declare function validateWireMapping(route: HttpRoute): void;
 export declare function validateCredentialMapping(route: HttpRoute): void;
 export declare function isReservedHeader(input: string): boolean;
-//# sourceMappingURL=mapping.d.ts.map

package/dist/routes/mapping.js

@@ -124,4 +124,3 @@ function uniqueWires(route, kind, wires) {
         fail('NATIVE_ROUTE_MAPPING_AMBIGUOUS', `Route ${route.name} maps one ${kind} wire source more than once.`);
     }
 }
-//# sourceMappingURL=mapping.js.map

package/dist/routes/match.d.ts

@@ -2,4 +2,3 @@ import type { HttpRequest } from './request.js';
 import type { Route, Table } from './table.js';
 export declare function match(table: Table, request: Pick<HttpRequest, 'url' | 'method'>): Route | undefined;
 export declare function methodMatches(entry: Route, method: string): boolean;
-//# sourceMappingURL=match.d.ts.map

package/dist/routes/match.js

@@ -5,4 +5,3 @@ export function match(table, request) {
 export function methodMatches(entry, method) {
     return entry.method === '*' || entry.method === method.toUpperCase();
 }
-//# sourceMappingURL=match.js.map

package/dist/routes/placement.d.ts

@@ -3,4 +3,3 @@ import type { Plan } from './plan.js';
 /** Resolve a provider-neutral Plan beneath one exact serving issuer. */
 export declare function place(plan: Plan, issuer: string): readonly publication.HttpRoute[];
 export declare function placePath(path: string, issuer: string): string;
-//# sourceMappingURL=placement.d.ts.map

package/dist/routes/placement.js

@@ -1,7 +1,7 @@
 /** Resolve a provider-neutral Plan beneath one exact serving issuer. */
 export function place(plan, issuer) {
     return Object.freeze(plan.entries.map((entry) => {
-        const { path, target, authentication: _authentication, output: _output, default: isDefault, ...wire } = entry;
+        const { path, target, auth: _auth, output: _output, default: isDefault, ...wire } = entry;
         return Object.freeze({
             ...wire,
             href: placePath(path, issuer),
@@ -16,4 +16,3 @@ export function placePath(path, issuer) {
     const base = new URL(issuer);
     return `${base.origin}${path}`;
 }
-//# sourceMappingURL=placement.js.map

package/dist/routes/plan.d.ts

@@ -1,12 +1,13 @@
-import type { Key, schema } from '@astrale-os/kernel-dsl/v1';
+import type { FunctionAuth, Key, Revision } from '@astrale-os/kernel-dsl/v1';
+import type { OutputMode } from '@astrale-os/kernel-dsl/v1/language';
 import type { CredentialSource, HttpMethod, RouteBody, RouteHeaders } from '../publication/index.js';
 import type { RouteTarget } from './target.js';
 export interface PlanEntry {
     readonly name: string;
     readonly callable: Key.Callable;
     readonly target: RouteTarget;
-    readonly authentication: schema.FunctionAuth;
-    readonly output: schema.OutputMode;
+    readonly auth: FunctionAuth;
+    readonly output: OutputMode;
     readonly path: string;
     readonly method: HttpMethod;
     readonly requestMethod?: string;
@@ -18,7 +19,6 @@ export interface PlanEntry {
 }
 export interface Plan {
     readonly origin: Key.Origin;
-    readonly revision: schema.Revision;
+    readonly revision: Revision;
     readonly entries: readonly PlanEntry[];
 }
-//# sourceMappingURL=plan.d.ts.map

package/dist/routes/plan.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=plan.js.map

package/dist/routes/release-unavailable.d.ts

@@ -6,4 +6,3 @@ export declare const HTTP_ROUTE_RELEASE_UNAVAILABLE: 'x-astrale-release-unavaila
 export declare const HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS: 410;
 export declare function releaseUnavailableHeaders(): Readonly<Record<string, string>>;
 export declare function decodeReleaseUnavailable(status: number, headers: HttpRequest['headers']): ReleaseUnavailable | undefined;
-//# sourceMappingURL=release-unavailable.d.ts.map

package/dist/routes/release-unavailable.js

@@ -30,4 +30,3 @@ function header(input, name) {
     }
     return found;
 }
-//# sourceMappingURL=release-unavailable.js.map

package/dist/routes/request.d.ts

@@ -24,4 +24,3 @@ export interface HttpRequest {
 export declare function bodyText(body: HttpRequest['body']): string;
 export declare function parseJsonObject(body: HttpRequest['body']): Record<string, Value>;
 export declare function normalizeHeaders(input: HttpRequest['headers']): Record<string, string>;
-//# sourceMappingURL=request.d.ts.map

package/dist/routes/request.js

@@ -4,7 +4,9 @@ export function bodyText(body) {
     if (body === undefined)
         return '';
     try {
-        return typeof body === 'string' ? body : new TextDecoder('utf-8', { fatal: true }).decode(body);
+        return typeof body === 'string'
+            ? body
+            : new TextDecoder('utf-8', { fatal: true, ignoreBOM: false }).decode(body);
     }
     catch (cause) {
         if (cause instanceof TypeError) {
@@ -49,4 +51,3 @@ export function normalizeHeaders(input) {
     }
     return output;
 }
-//# sourceMappingURL=request.js.map

package/dist/routes/reservation.d.ts

@@ -1,4 +1,3 @@
 import type { Publication } from '../publication/publication.js';
 import type { Route } from './table.js';
 export declare function rejectReserved(publication: Publication, entries: readonly Route[]): void;
-//# sourceMappingURL=reservation.d.ts.map

package/dist/routes/reservation.js

@@ -1,4 +1,5 @@
 import * as issuer from '../issuer/index.js';
+import { bundleUrl } from '../publication/bundle.js';
 import { PATH as PUBLICATION_PATH } from '../publication/publication.js';
 import { fail } from './error.js';
 import { templateUrl, templatesOverlap } from './template.js';
@@ -14,8 +15,13 @@ export function rejectReserved(publication, entries) {
             ...(endpoint.websocket === undefined ? [] : [httpUrlForWebSocket(endpoint.websocket)]),
         ]),
     ];
+    const addressed = bundleUrl(publication.identity.issuer, publication.schema.bundle.ref);
+    const bundlePattern = publication.schema.bundle.href === addressed
+        ? `${addressed.slice(0, addressed.lastIndexOf('/') + 1)}{artifact}`
+        : undefined;
     for (const entry of entries) {
-        const claimed = [...reservedPaths].some((path) => templateClaimsPath(entry.href, path)) ||
+        const claimed = (bundlePattern !== undefined && templatesOverlap(entry.href, bundlePattern)) ||
+            [...reservedPaths].some((path) => templateClaimsPath(entry.href, path)) ||
             reservedUrls.some((reserved) => templatesOverlap(entry.href, routeLocation(reserved)));
         if (claimed) {
             fail('NATIVE_ROUTE_RESERVED', `Route ${entry.name} claims reserved URL ${templateUrl(entry.href).href}.`);
@@ -35,4 +41,3 @@ function templateClaimsPath(template, path) {
     const url = templateUrl(template);
     return templatesOverlap(template, `${url.origin}${path}`);
 }
-//# sourceMappingURL=reservation.js.map

package/dist/routes/routing.d.ts

@@ -20,4 +20,3 @@ export declare function decodeStale(status: number, headers: HttpRequest['header
 export declare function missHeaders(): Readonly<Record<string, string>>;
 export declare function decodeMiss(status: number, headers: HttpRequest['headers']): MissControl | undefined;
 export declare function encodeStrongEtag(input: Etag): string;
-//# sourceMappingURL=routing.d.ts.map

package/dist/routes/routing.js

@@ -85,4 +85,3 @@ function routingHeader(input, name) {
     }
     return found;
 }
-//# sourceMappingURL=routing.js.map

package/dist/routes/scalar.d.ts

@@ -1,8 +1,7 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
 import type * as portable from '@astrale-os/kernel-dsl/value';
 import type { Route } from './table.js';
-export declare function encodeScalar(entry: Route, name: string, value: unknown, validator: schema.Validator): string;
-export declare function decodeScalar(entry: Route, name: string, encoded: string, validator: schema.Validator): portable.Value;
+export declare function encodeScalar(entry: Route, name: string, value: unknown, domain: Domain): string;
+export declare function decodeScalar(entry: Route, name: string, encoded: string, domain: Domain): portable.Value;
 export declare function scalar(value: unknown): string;
 export declare function asObject(value: unknown): Record<string, portable.Value>;
-//# sourceMappingURL=scalar.d.ts.map

package/dist/routes/scalar.js

@@ -1,20 +1,20 @@
 import { invalidRequest } from './error.js';
 const JSON_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
-export function encodeScalar(entry, name, value, validator) {
+export function encodeScalar(entry, name, value, domain) {
     const encoded = scalar(value);
     if (name === receiver(entry))
         return encoded;
-    const decoded = decodeScalar(entry, name, encoded, validator);
+    const decoded = decodeScalar(entry, name, encoded, domain);
     if (!sameScalar(decoded, value)) {
         invalidRequest(`Native route field ${name} does not round-trip through its declared value schema.`);
     }
     return encoded;
 }
-export function decodeScalar(entry, name, encoded, validator) {
+export function decodeScalar(entry, name, encoded, domain) {
     if (name === receiver(entry))
         return encoded;
-    const meaning = validator.callable(entry.callable);
-    if (meaning?.fields?.includes(name) !== true) {
+    const meaning = domain.callable(entry.callable);
+    if (meaning?.inputFields?.includes(name) !== true) {
         invalidRequest(`Native route maps unknown input field ${name}.`);
     }
     const candidates = [encoded];
@@ -59,4 +59,3 @@ function sameScalar(left, right) {
     return (Object.is(left, right) ||
         (typeof left === 'number' && typeof right === 'number' && left === 0 && right === 0));
 }
-//# sourceMappingURL=scalar.js.map

package/dist/routes/select.d.ts

@@ -1,4 +1,3 @@
 import type { Key } from '@astrale-os/kernel-dsl/v1';
 import type { Route, Table } from './table.js';
 export declare function select(table: Table, callable: Key.Callable, route?: string): Route | undefined;
-//# sourceMappingURL=select.d.ts.map

package/dist/routes/select.js

@@ -14,4 +14,3 @@ export function select(table, callable, route) {
         return candidates[0];
     return candidates.find((entry) => entry.default);
 }
-//# sourceMappingURL=select.js.map

package/dist/routes/stream.d.ts

@@ -12,4 +12,3 @@ export type StreamFrame = {
 };
 export declare function encodeStreamFrame(input: StreamFrame): string;
 export declare function decodeStreamFrame(event: string, data: string): StreamFrame;
-//# sourceMappingURL=stream.d.ts.map

package/dist/routes/stream.js

@@ -48,4 +48,3 @@ export function decodeStreamFrame(event, data) {
     }
     return fail('NATIVE_ROUTE_RESPONSE_INVALID', `Unknown native stream event ${JSON.stringify(event)}.`);
 }
-//# sourceMappingURL=stream.js.map

package/dist/routes/table.d.ts

@@ -7,4 +7,3 @@ export interface Table {
     readonly publication: PublicationRef;
     readonly entries: readonly Route[];
 }
-//# sourceMappingURL=table.d.ts.map

package/dist/routes/table.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=table.js.map

package/dist/routes/target.d.ts

@@ -11,4 +11,3 @@ export type RouteTarget = {
 export declare function requiresReceiver(entry: {
     readonly target: RouteTarget;
 }): boolean;
-//# sourceMappingURL=target.d.ts.map

package/dist/routes/target.js

@@ -1,4 +1,3 @@
 export function requiresReceiver(entry) {
     return entry.target.kind === 'method' && entry.target.dispatch === 'instance';
 }
-//# sourceMappingURL=target.js.map

package/dist/routes/template.d.ts

@@ -6,4 +6,3 @@ export declare function templatesOverlap(left: string, right: string): boolean;
 export declare function matchTemplate(template: string, input: string): Record<string, string> | undefined;
 export declare function encodeTemplate(value: unknown, catchall: string | undefined, host: boolean): string;
 export declare function authorityEnd(input: string): number;
-//# sourceMappingURL=template.d.ts.map