@astrale-os/kernel-protocol 0.5.0-beta.4 → 0.5.0-beta.41

package/dist/routes/admission.js

@@ -2,7 +2,7 @@ import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
 import { acceptReference } from '../publication/reference.js';
 import { admitRoute } from '../publication/route.js';
 import { fail } from './error.js';
-const AUTHENTICATION = new Set(['anonymous', 'authenticated', 'authorized']);
+const AUTH = new Set(['anonymous', 'authenticated', 'authorized']);
 const OUTPUT = new Set(['value', 'stream', 'binary']);
 /** Admit one emitted portable Table before Server composition. */
 export function acceptTable(input) {
@@ -19,11 +19,11 @@ export function acceptTable(input) {
 }
 function acceptRoute(input, origin) {
     const value = object(input, 'Route Table entry');
-    exact(value, ['name', 'callable', 'target', 'authentication', 'output', 'href', 'method', 'default'], 'Route Table entry', ['requestMethod', 'query', 'headers', 'body', 'credential']);
+    exact(value, ['name', 'callable', 'target', 'auth', 'output', 'href', 'method', 'default'], 'Route Table entry', ['requestMethod', 'query', 'headers', 'body', 'credential']);
     if (typeof value.default !== 'boolean')
         invalid('Route Table default');
-    if (typeof value.authentication !== 'string' || !AUTHENTICATION.has(value.authentication)) {
-        invalid('Route Table authentication');
+    if (typeof value.auth !== 'string' || !AUTH.has(value.auth)) {
+        invalid('Route Table auth');
     }
     if (typeof value.output !== 'string' || !OUTPUT.has(value.output))
         invalid('Route Table output');
@@ -44,7 +44,7 @@ function acceptRoute(input, origin) {
     return Object.freeze({
         ...common,
         target: target(value.target),
-        authentication: value.authentication,
+        auth: value.auth,
         output: value.output,
         default: value.default,
     });
@@ -87,4 +87,3 @@ function exact(value, required, label, optional = []) {
 function invalid(label) {
     return fail('NATIVE_ROUTE_BINDING_INVALID', `${label} is invalid.`);
 }
-//# sourceMappingURL=admission.js.map

package/dist/routes/binding.d.ts

@@ -1,7 +1,6 @@
-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 { Plan } from './plan.js';
 import type { Table } from './table.js';
-/** Bind one Plan to an exact placed Publication and matching Validator. */
-export declare function bind(plan: Plan, deployed: Publication, validator: schema.Validator): Table;
-//# sourceMappingURL=binding.d.ts.map
+/** Bind one Plan to an exact placed Publication and matching resolved Domain. */
+export declare function bind(plan: Plan, deployed: Publication, domain: Domain): Table;

package/dist/routes/binding.js

@@ -3,13 +3,13 @@ import { reference } from '../publication/reference.js';
 import { fail } from './error.js';
 import { place } from './placement.js';
 import { rejectReserved } from './reservation.js';
-/** Bind one Plan to an exact placed Publication and matching Validator. */
-export function bind(plan, deployed, validator) {
+/** Bind one Plan to an exact placed Publication and matching resolved Domain. */
+export function bind(plan, deployed, domain) {
     if (plan.origin !== deployed.origin ||
-        plan.origin !== validator.origin ||
+        plan.origin !== domain.origin ||
         plan.revision !== deployed.schema.revision ||
-        plan.revision !== validator.revision) {
-        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Plan, Publication, and Validator identity differ.');
+        plan.revision !== domain.revision) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Plan, Publication, and Domain identity differ.');
     }
     if (json.serialize(place(plan, deployed.identity.issuer)) !==
         json.serialize(deployed.routes)) {
@@ -25,4 +25,3 @@ export function bind(plan, deployed, validator) {
         entries: Object.freeze(entries),
     });
 }
-//# sourceMappingURL=binding.js.map

package/dist/routes/collision.d.ts

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

package/dist/routes/collision.js

@@ -14,4 +14,3 @@ export function rejectCollisions(entries) {
 function overlap(left, right) {
     return left === '*' || right === '*' || left === right;
 }
-//# sourceMappingURL=collision.js.map

package/dist/routes/compiler.d.ts

@@ -1,9 +1,8 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
 import type * as publication from '../publication/index.js';
 import type { Plan } from './plan.js';
 export interface CompileInput {
     readonly routes: readonly publication.HttpRouteDeclaration[];
-    readonly validator: schema.Validator;
+    readonly domain: Domain;
 }
 export declare function compile(input: CompileInput): Plan;
-//# sourceMappingURL=compiler.d.ts.map

package/dist/routes/compiler.js

@@ -8,41 +8,43 @@ 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);
+        const meaning = input.domain.callable(declaration.callable);
         if (meaning === undefined) {
             fail('NATIVE_ROUTE_BINDING_INVALID', `Unknown callable ${declaration.callable}.`);
         }
         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,5 @@
 import { NodePath, 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 { readCredential, specificHeaderWires, withoutCredentialHeaders } from './credential.js';
 import { fail, invalidRequest } from './error.js';
@@ -10,7 +10,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 +18,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 +41,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 +55,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,19 +112,15 @@ export function decode(entry, request, validator, served) {
         }
         throw cause;
     }
-    const ref = Key.ref(entry.callable);
-    const target = Ref.isMethod(ref)
+    const coordinate = callableAddress(entry.callable);
+    const target = coordinate.kind === 'method'
         ? 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.staticMethod(Path.project(coordinate.owner), coordinate.name).raw
+            : Path.instanceMethod(Path.from(receiver), coordinate.name).raw
         : Path.project({
-            origin: Key.origin(entry.callable),
+            origin: coordinate.origin,
             kind: 'function',
-            name: Ref.member(ref),
+            name: coordinate.name,
         }).raw;
     return Object.freeze({
         call: Object.freeze({ target, input }),
@@ -132,14 +128,14 @@ export function decode(entry, request, validator, served) {
         ...(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 +145,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,5 @@
 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 +8,22 @@ 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) {
     const input = asObject(invocation.call.input);
     const target = Path.from(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
+        : 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 +31,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 +109,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 +143,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,33 @@
 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) &&
+                    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 +36,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

@@ -16,7 +16,7 @@ export function rejectReserved(publication, entries) {
     ];
     for (const entry of entries) {
         const claimed = [...reservedPaths].some((path) => templateClaimsPath(entry.href, path)) ||
-            reservedUrls.some((reserved) => templatesOverlap(entry.href, reserved));
+            reservedUrls.some((reserved) => templatesOverlap(entry.href, routeLocation(reserved)));
         if (claimed) {
             fail('NATIVE_ROUTE_RESERVED', `Route ${entry.name} claims reserved URL ${templateUrl(entry.href).href}.`);
         }
@@ -27,8 +27,11 @@ function httpUrlForWebSocket(input) {
     url.protocol = url.protocol === 'wss:' ? 'https:' : 'http:';
     return url.toString();
 }
+function routeLocation(input) {
+    const url = new URL(input);
+    return `${url.origin}${url.pathname}`;
+}
 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