@astrale-os/kernel-protocol 0.5.0-beta.7 → 0.5.0-beta.9

package/dist/publication/requirements.js

@@ -1,7 +1,6 @@
-import { KernelSchema } from '@astrale-os/kernel-core/schema';
 import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema/authority/operation';
-import { Key, patterns, Ref } from '@astrale-os/kernel-dsl/v1/addressing';
-import { revisionOfDomainSchema } from '@astrale-os/kernel-dsl/v1/schema/revision';
+import { acceptDefinitionRef, callableAddress, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { revision } from '@astrale-os/kernel-dsl/v1/schema/revision';
 import { array, deepFreeze, exact, record, unique } from './content.js';
 import { fail } from './error.js';
 export const ClassOperationOrder = Object.freeze([
@@ -49,13 +48,12 @@ export function validateRequirements(root, closure, requirements) {
     const dependencies = exactDependencyClosure(root, closure);
     for (const callable of requirements.capabilities.functions ?? []) {
         const dependency = capabilityOwner(root, dependencies, callable, 'Function');
-        const reference = Key.ref(callable);
-        if (!hasCallable(dependency, reference)) {
+        if (!hasCallable(dependency, callable)) {
             fail('PUBLICATION_INVALID', 'Function capability requirement names an unknown dependency callable.');
         }
     }
     for (const requirement of requirements.capabilities.classes ?? []) {
-        const key = Key.fromSchema(requirement.class);
+        const key = Key.of(requirement.class);
         const dependency = capabilityOwner(root, dependencies, key, 'Class');
         if (dependency.classes[requirement.class.name] === undefined) {
             fail('PUBLICATION_INVALID', 'Class capability requirement names an unknown dependency Class.');
@@ -68,7 +66,7 @@ function exactDependencyClosure(root, closure) {
     const visit = (owner) => {
         for (const coordinate of owner.dependencies) {
             const dependency = supplied.get(coordinate.origin);
-            if (dependency === undefined || revisionOfDomainSchema(dependency) !== coordinate.revision) {
+            if (dependency === undefined || revision(dependency) !== coordinate.revision) {
                 fail('PUBLICATION_INVALID', 'Publication Bundle omits an exact dependency.');
             }
             if (reachable.has(dependency.origin))
@@ -84,8 +82,10 @@ function admitCallable(input) {
     if (typeof input !== 'string' || !Key.is(input)) {
         return fail('PUBLICATION_INVALID', 'Function capability reference is invalid.');
     }
-    const reference = Key.ref(input);
-    if (!reference.startsWith('function.') && !Ref.isMethod(reference)) {
+    try {
+        callableAddress(input);
+    }
+    catch {
         return fail('PUBLICATION_INVALID', 'Function capability reference must name a Function or Method.');
     }
     return input;
@@ -123,16 +123,16 @@ function admitAuthorityOperations(input, kind) {
     return Object.freeze(values);
 }
 function admitClassRef(input) {
-    const value = record(input, 'PUBLICATION_INVALID', 'Class capability reference is invalid.');
-    exact(value, ['kind', 'name', 'origin'], 'PUBLICATION_INVALID');
-    if (value.kind !== 'class' ||
-        typeof value.origin !== 'string' ||
-        !patterns.origin.test(value.origin) ||
-        typeof value.name !== 'string' ||
-        !patterns.memberName.test(value.name)) {
+    let value;
+    try {
+        value = acceptDefinitionRef(input);
+    }
+    catch {
         fail('PUBLICATION_INVALID', 'Class capability reference is invalid.');
     }
-    return Object.freeze({ origin: value.origin, kind: 'class', name: value.name });
+    if (value.kind !== 'class')
+        fail('PUBLICATION_INVALID', 'Class capability reference is invalid.');
+    return value;
 }
 function nonEmpty(input, label) {
     const values = [...array(input, 'PUBLICATION_INVALID')];
@@ -158,28 +158,23 @@ function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
 function classKey(input) {
-    return String(Key.fromSchema(input));
+    return String(Key.of(input));
 }
 function capabilityOwner(root, dependencies, key, label) {
     const origin = Key.origin(key);
     if (origin === root.origin)
         fail('PUBLICATION_INVALID', `${label} capability target cannot be local.`);
-    if (origin === KernelSchema.origin)
-        return KernelSchema;
     const dependency = dependencies.get(origin);
     if (dependency === undefined) {
         fail('PUBLICATION_INVALID', `${label} capability target must belong to the exact dependency closure.`);
     }
     return dependency;
 }
-function hasCallable(dependency, reference) {
-    if (reference.startsWith('function.')) {
-        return dependency.functions[Ref.member(reference)] !== undefined;
-    }
-    const ownerKind = Ref.namespace(reference);
-    const owner = Ref.member(reference);
-    const method = Ref.child(reference);
-    const declaration = ownerKind === 'class' ? dependency.classes[owner] : dependency.interfaces[owner];
-    return declaration?.family === 'node' && declaration.methods[method] !== undefined;
+function hasCallable(dependency, callable) {
+    const coordinate = callableAddress(callable);
+    if (coordinate.kind === 'function')
+        return dependency.functions[coordinate.name] !== undefined;
+    const declaration = dependency.classes[coordinate.owner.name];
+    const method = declaration?.kind === 'node' ? declaration.methods[coordinate.name] : undefined;
+    return method !== undefined && method.inheritance !== 'abstract';
 }
-//# sourceMappingURL=requirements.js.map

package/dist/publication/route.d.ts

@@ -35,4 +35,3 @@ export interface HttpRouteDeclaration extends Omit<HttpRoute, 'href'> {
 }
 export declare function admitRoute(input: unknown, origin: string): HttpRoute;
 export declare function admitRouteDeclaration(input: unknown, origin: string): HttpRouteDeclaration;
-//# sourceMappingURL=route.d.ts.map

package/dist/publication/route.js

@@ -152,4 +152,3 @@ function stringRecord(input) {
     }
     return Object.freeze(output);
 }
-//# sourceMappingURL=route.js.map

package/dist/publication/schema.d.ts

@@ -1,8 +1,7 @@
-import type { Revision } from '@astrale-os/kernel-dsl/v1/schema';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { BundleDescriptor } from './bundle-descriptor.js';
 export interface Schema {
     readonly revision: Revision;
     readonly bundle: BundleDescriptor;
 }
 export declare function admitSchema(input: unknown): Schema;
-//# sourceMappingURL=schema.d.ts.map

package/dist/publication/schema.js

@@ -13,4 +13,3 @@ export function admitSchema(input) {
         bundle: admitBundleDescriptor(value.bundle),
     });
 }
-//# sourceMappingURL=schema.js.map

package/dist/routes/admission.d.ts

@@ -1,4 +1,3 @@
 import type { Table } from './table.js';
 /** Admit one emitted portable Table before Server composition. */
 export declare function acceptTable(input: unknown): Table;
-//# sourceMappingURL=admission.d.ts.map

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