@astrale-os/kernel-protocol 0.5.0-beta.3 → 0.5.0-beta.31

package/dist/routes/credential.js

@@ -4,19 +4,19 @@ export function credentialSources(route) {
     return Array.isArray(source) ? source : [source];
 }
 export function firstCredentialIsAmbient(entry) {
-    return credentialSources(entry.route)[0].in === 'cookie';
+    return credentialSources(entry)[0].in === 'cookie';
 }
 export function specificHeaderWires(entry) {
-    return new Set(Object.values(entry.route.headers ?? {})
+    return new Set(Object.values(entry.headers ?? {})
         .filter((wire) => wire !== '*')
         .map((wire) => wire.toLowerCase()));
 }
 export function putCredential(entry, url, headers, credential) {
-    if (entry.route.credential === undefined) {
+    if (entry.credential === undefined) {
         headers.authorization = `Bearer ${credential}`;
         return;
     }
-    const source = credentialSources(entry.route)[0];
+    const source = credentialSources(entry)[0];
     if (source.in === 'header') {
         headers[(source.name ?? 'authorization').toLowerCase()] = credential;
     }
@@ -36,7 +36,7 @@ export function withoutCredentialHeaders(entry, input) {
         }
         output[canonical] = value;
     }
-    for (const source of credentialSources(entry.route)) {
+    for (const source of credentialSources(entry)) {
         if (source.in === 'header') {
             delete output[(source.name ?? 'authorization').toLowerCase()];
             continue;
@@ -53,7 +53,7 @@ export function withoutCredentialHeaders(entry, input) {
 }
 export function readCredential(entry, url, headers) {
     const found = [];
-    if (entry.route.credential === undefined) {
+    if (entry.credential === undefined) {
         const authorization = headers.authorization;
         if (authorization === undefined)
             return undefined;
@@ -62,7 +62,7 @@ export function readCredential(entry, url, headers) {
             invalidRequest('Authorization must contain one Bearer credential.');
         return matched[1];
     }
-    for (const source of credentialSources(entry.route)) {
+    for (const source of credentialSources(entry)) {
         let value;
         if (source.in === 'header') {
             value = headers[(source.name ?? 'authorization').toLowerCase()];
@@ -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,4 +1,5 @@
+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 { CompiledRoute } from './route.js';
-export declare function decode(entry: CompiledRoute, request: HttpRequest): Invocation;
-//# sourceMappingURL=decode.d.ts.map
+import type { Route } from './table.js';
+export declare function decode(entry: Route, request: HttpRequest, domain: Domain, served: PublicationRef): Invocation;

package/dist/routes/decode.js

@@ -1,27 +1,27 @@
 import { NodePath, Path } from '@astrale-os/kernel-core/path';
-import { Key, Ref } from '@astrale-os/kernel-dsl/v1';
+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';
 import { isReservedHeader } from './mapping.js';
 import { methodMatches } from './match.js';
 import { bodyText, normalizeHeaders, parseJsonObject } from './request.js';
-import { requiresReceiver } from './route.js';
 import { decodeRouting } from './routing.js';
-import { asObject, decodeScalar } from './scalar.js';
+import { decodeScalar } from './scalar.js';
+import { requiresReceiver } from './target.js';
 import { matchTemplate, PLACEHOLDER } from './template.js';
-export function decode(entry, request) {
+export function decode(entry, request, domain, served) {
     if (!methodMatches(entry, request.method))
         invalidRequest('HTTP method does not match the route.');
-    const matched = matchTemplate(entry.route.href, request.url);
+    const matched = matchTemplate(entry.href, request.url);
     if (matched === undefined)
         invalidRequest('URL does not match the route template.');
     const values = {};
     for (const [name, value] of Object.entries(matched)) {
-        values[name] = decodeScalar(entry, name, value);
+        values[name] = decodeScalar(entry, name, value, domain);
     }
-    if (entry.route.requestMethod !== undefined) {
-        values[entry.route.requestMethod] = decodeScalar(entry, entry.route.requestMethod, request.method.toUpperCase());
+    if (entry.requestMethod !== undefined) {
+        values[entry.requestMethod] = decodeScalar(entry, entry.requestMethod, request.method.toUpperCase(), domain);
     }
     let url;
     try {
@@ -35,32 +35,32 @@ export function decode(entry, request) {
     }
     const headers = normalizeHeaders(request.headers);
     const credential = readCredential(entry, url, headers);
-    const routing = decodeRouting(request, entry.publication);
+    const routing = decodeRouting(request, served);
     const applicationHeaders = withoutCredentialHeaders(entry, headers);
-    for (const [name, wire] of Object.entries(entry.route.query ?? {})) {
+    for (const [name, wire] of Object.entries(entry.query ?? {})) {
         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]);
+        values[name] = decodeScalar(entry, name, found[0], domain);
     }
-    for (const [name, pick] of Object.entries(entry.route.headers ?? {})) {
+    for (const [name, pick] of Object.entries(entry.headers ?? {})) {
         if (pick === '*') {
             const explicit = specificHeaderWires(entry);
             values[name] = Object.fromEntries(Object.entries(applicationHeaders).filter(([header]) => !explicit.has(header) &&
                 header !== 'accept' &&
                 !isReservedHeader(header) &&
-                (entry.route.body === undefined || header !== 'content-type')));
+                (entry.body === undefined || header !== 'content-type')));
         }
         else {
             const value = headers[pick.toLowerCase()];
             if (value === undefined)
                 invalidRequest(`Missing header ${pick}.`);
-            values[name] = decodeScalar(entry, name, value);
+            values[name] = decodeScalar(entry, name, value, domain);
         }
     }
-    if (entry.route.body === '*') {
+    if (entry.body === '*') {
         const body = parseJsonObject(request.body);
-        const allowed = remainderFields(entry);
+        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.`);
@@ -68,10 +68,10 @@ export function decode(entry, request) {
         }
         Object.assign(values, body);
     }
-    else if (entry.route.body !== undefined) {
-        const needsText = Object.values(entry.route.body).some((pick) => typeof pick !== 'string');
+    else if (entry.body !== undefined) {
+        const needsText = Object.values(entry.body).some((pick) => typeof pick !== 'string');
         const body = needsText ? bodyText(request.body) : parseJsonObject(request.body);
-        for (const [name, pick] of Object.entries(entry.route.body)) {
+        for (const [name, pick] of Object.entries(entry.body)) {
             if (typeof pick !== 'string') {
                 values[name] = body;
             }
@@ -85,7 +85,10 @@ export function decode(entry, request) {
     }
     let receiver;
     if (requiresReceiver(entry)) {
-        const encodedReceiver = entry.route.receiver === undefined ? undefined : values[entry.route.receiver];
+        const receiverName = entry.target.kind === 'method' && entry.target.dispatch === 'instance'
+            ? entry.target.receiver
+            : undefined;
+        const encodedReceiver = receiverName === undefined ? undefined : values[receiverName];
         if (typeof encodedReceiver !== 'string')
             invalidRequest('Instance route receiver is missing.');
         try {
@@ -97,7 +100,7 @@ export function decode(entry, request) {
             }
             throw cause;
         }
-        delete values[entry.route.receiver];
+        delete values[receiverName];
     }
     let input;
     try {
@@ -109,19 +112,15 @@ export function decode(entry, request) {
         }
         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 }),
@@ -129,19 +128,20 @@ export function decode(entry, request) {
         ...(routing === undefined ? {} : { routing }),
     });
 }
-function remainderFields(entry) {
+function remainderFields(entry, domain) {
     const claimed = new Set([
-        ...[...entry.route.href.matchAll(PLACEHOLDER)].map((item) => item[1]),
-        ...(entry.route.requestMethod === undefined ? [] : [entry.route.requestMethod]),
-        ...Object.keys(entry.route.query ?? {}),
-        ...Object.keys(entry.route.headers ?? {}),
+        ...[...entry.href.matchAll(PLACEHOLDER)].map((item) => item[1]),
+        ...(entry.requestMethod === undefined ? [] : [entry.requestMethod]),
+        ...Object.keys(entry.query ?? {}),
+        ...Object.keys(entry.headers ?? {}),
     ]);
-    const input = asObject(entry.declaration.input);
-    const properties = asObject(input.properties);
-    const allowed = new Set(Object.keys(properties).filter((name) => !claimed.has(name)));
-    if (entry.route.receiver !== undefined && !claimed.has(entry.route.receiver)) {
-        allowed.add(entry.route.receiver);
+    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
+        : undefined;
+    if (receiver !== undefined && !claimed.has(receiver)) {
+        allowed.add(receiver);
     }
     return allowed;
 }
-//# sourceMappingURL=decode.js.map

package/dist/routes/encode.d.ts

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

package/dist/routes/encode.js

@@ -1,50 +1,49 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { Key, Ref } from '@astrale-os/kernel-dsl/v1';
+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';
 import { isReservedHeader } from './mapping.js';
-import { requiresReceiver } from './route.js';
 import { encodeStrongEtag, HTTP_ROUTE_ISSUER, HTTP_ROUTE_PUBLICATION } from './routing.js';
 import { asObject, encodeScalar, scalar } from './scalar.js';
+import { requiresReceiver } from './target.js';
 import { authorityEnd, encodeTemplate, PLACEHOLDER } from './template.js';
-export function encode(entry, invocation) {
+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.');
-    const field = (name) => (name === entry.route.receiver ? source : input[name]);
-    const wireField = (name) => encodeScalar(entry, name, field(name));
-    const hostEnd = authorityEnd(entry.route.href);
-    let url = entry.route.href.replaceAll(PLACEHOLDER, (_whole, name, catchall, offset) => encodeTemplate(wireField(name), catchall, offset < hostEnd));
+    const receiverName = entry.target.kind === 'method' && entry.target.dispatch === 'instance'
+        ? entry.target.receiver
+        : undefined;
+    const field = (name) => (name === receiverName ? source : input[name]);
+    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);
-    for (const [name, wire] of Object.entries(entry.route.query ?? {})) {
+    for (const [name, wire] of Object.entries(entry.query ?? {})) {
         parsed.searchParams.append(wire, wireField(name));
     }
     let headers = {};
-    for (const [name, pick] of Object.entries(entry.route.headers ?? {})) {
+    for (const [name, pick] of Object.entries(entry.headers ?? {})) {
         if (pick !== '*')
             headers[pick] = wireField(name);
     }
-    const headerRemainder = Object.entries(entry.route.headers ?? {}).find(([, pick]) => pick === '*');
+    const headerRemainder = Object.entries(entry.headers ?? {}).find(([, pick]) => pick === '*');
     if (headerRemainder !== undefined) {
         const explicit = specificHeaderWires(entry);
         for (const [header, headerValue] of Object.entries(asObject(field(headerRemainder[0])))) {
@@ -56,27 +55,27 @@ export function encode(entry, invocation) {
         }
     }
     let body;
-    if (entry.route.body === '*') {
+    if (entry.body === '*') {
         const claimed = new Set([
-            ...[...entry.route.href.matchAll(PLACEHOLDER)].map((item) => item[1]),
-            ...(entry.route.requestMethod === undefined ? [] : [entry.route.requestMethod]),
-            ...Object.keys(entry.route.query ?? {}),
-            ...Object.keys(entry.route.headers ?? {}),
+            ...[...entry.href.matchAll(PLACEHOLDER)].map((item) => item[1]),
+            ...(entry.requestMethod === undefined ? [] : [entry.requestMethod]),
+            ...Object.keys(entry.query ?? {}),
+            ...Object.keys(entry.headers ?? {}),
         ]);
         const output = {};
         for (const [name, value] of Object.entries(input)) {
             if (!claimed.has(name))
                 output[name] = value;
         }
-        if (entry.route.receiver !== undefined && !claimed.has(entry.route.receiver)) {
-            output[entry.route.receiver] = source;
+        if (receiverName !== undefined && !claimed.has(receiverName)) {
+            output[receiverName] = source;
         }
         body = portable.json.serialize(output);
         headers['content-type'] = 'application/json';
     }
-    else if (entry.route.body !== undefined) {
+    else if (entry.body !== undefined) {
         const output = {};
-        for (const [name, pick] of Object.entries(entry.route.body)) {
+        for (const [name, pick] of Object.entries(entry.body)) {
             if (typeof pick !== 'string')
                 body = scalar(field(name));
             else
@@ -108,16 +107,16 @@ export function encode(entry, invocation) {
         headers[HTTP_ROUTE_ISSUER] = invocation.routing.issuer;
     }
     url = parsed.toString();
-    const mappedMethod = entry.route.requestMethod === undefined
+    const mappedMethod = entry.requestMethod === undefined
         ? undefined
-        : encodeScalar(entry, entry.route.requestMethod, input[entry.route.requestMethod]).toUpperCase();
+        : encodeScalar(entry, entry.requestMethod, input[entry.requestMethod], domain).toUpperCase();
     const requestedMethod = invocation.method?.toUpperCase();
     if (mappedMethod !== undefined &&
         requestedMethod !== undefined &&
         mappedMethod !== requestedMethod) {
         invalidRequest('Native route request method differs from its mapped input field.');
     }
-    const methodCandidate = entry.route.method === '*' ? (requestedMethod ?? mappedMethod) : entry.route.method;
+    const methodCandidate = entry.method === '*' ? (requestedMethod ?? mappedMethod) : entry.method;
     if (methodCandidate === undefined) {
         fail('NATIVE_ROUTE_REQUEST_INVALID', 'Wildcard route invocation requires an HTTP method.');
     }
@@ -144,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

@@ -0,0 +1,5 @@
+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 Domain meaning. */
+export declare function verifyTable(table: Table, deployed: Publication, domain: Pick<Domain, 'origin' | 'revision' | 'callable'>): Table;

package/dist/routes/evidence.js

@@ -0,0 +1,38 @@
+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 Domain meaning. */
+export function verifyTable(table, deployed, domain) {
+    if (compareReferences(table.publication, reference(deployed)) !== 'exact' ||
+        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 = domain.callable(entry.callable);
+        const targetMatches = meaning !== undefined &&
+            ((entry.target.kind === 'function' && !isMethod(meaning)) ||
+                (entry.target.kind === 'method' &&
+                    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, auth: _auth, output: _output, default: isDefault, ...wire } = entry;
+    return {
+        ...wire,
+        ...(isDefault ? { default: true } : {}),
+        ...(target.kind === 'method' && target.dispatch === 'instance'
+            ? { receiver: target.receiver }
+            : {}),
+    };
+}

package/dist/routes/index.d.ts

@@ -1,13 +1,19 @@
-export { compile } from './compile.js';
+export { bind } from './binding.js';
+export { acceptTable } from './admission.js';
+export { compile, type CompileInput } from './compiler.js';
 export { decode } from './decode.js';
 export { decodeErrorResponse, type ErrorResponse } from './error-response.js';
 export { encode } from './encode.js';
+export { verifyTable } from './evidence.js';
 export { type ErrorCode, RouteError } from './error.js';
 export { match } from './match.js';
 export { type HttpRequest, type Invocation, type Request } from './request.js';
-export { type CompiledRoute } from './route.js';
+export type { Plan, PlanEntry } from './plan.js';
+export type { Route, Table } from './table.js';
+export type { RouteTarget } from './target.js';
+export { place } from './placement.js';
+export { decodeReleaseUnavailable, HTTP_ROUTE_RELEASE_UNAVAILABLE, HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS, releaseUnavailableHeaders, type ReleaseUnavailable, } from './release-unavailable.js';
 export { decodeRouting, decodeMiss, decodeStale, HTTP_ROUTE_PUBLICATION, HTTP_ROUTE_ISSUER, HTTP_ROUTE_MISS, HTTP_ROUTE_MISS_STATUS, HTTP_ROUTE_STALE, HTTP_ROUTE_STALE_STATUS, missHeaders, staleHeaders, type MissControl, type StaleControl, } from './routing.js';
 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

@@ -1,13 +1,16 @@
-export { compile } from './compile.js';
+export { bind } from './binding.js';
+export { acceptTable } from './admission.js';
+export { compile } from './compiler.js';
 export { decode } from './decode.js';
 export { decodeErrorResponse } from './error-response.js';
 export { encode } from './encode.js';
+export { verifyTable } from './evidence.js';
 export { RouteError } from './error.js';
 export { match } from './match.js';
 export {} from './request.js';
-export {} from './route.js';
+export { place } from './placement.js';
+export { decodeReleaseUnavailable, HTTP_ROUTE_RELEASE_UNAVAILABLE, HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS, releaseUnavailableHeaders, } from './release-unavailable.js';
 export { decodeRouting, decodeMiss, decodeStale, HTTP_ROUTE_PUBLICATION, HTTP_ROUTE_ISSUER, HTTP_ROUTE_MISS, HTTP_ROUTE_MISS_STATUS, HTTP_ROUTE_STALE, HTTP_ROUTE_STALE_STATUS, missHeaders, staleHeaders, } from './routing.js';
 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

@@ -1,6 +1,5 @@
 import type { HttpRoute } from '../publication/index.js';
-export declare function validateMapping(route: HttpRoute, input: unknown, instanceMethod: boolean): void;
+export declare function validateMapping(route: HttpRoute, fields: readonly string[] | undefined, instanceMethod: boolean): void;
 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

@@ -1,17 +1,13 @@
 import { HTTP_IDEMPOTENCY_KEY } from '../invocation/index.js';
 import { credentialSources } from './credential.js';
 import { fail } from './error.js';
+import { HTTP_ROUTE_RELEASE_UNAVAILABLE } from './release-unavailable.js';
 import { HTTP_ROUTE_ISSUER, HTTP_ROUTE_MISS, HTTP_ROUTE_PUBLICATION, HTTP_ROUTE_STALE, } from './routing.js';
 import { PLACEHOLDER } from './template.js';
-export function validateMapping(route, input, instanceMethod) {
-    const contract = asRecord(input);
-    const properties = asRecord(contract?.properties);
-    if (contract?.type !== 'object' ||
-        properties === undefined ||
-        contract.additionalProperties !== false) {
+export function validateMapping(route, fields, instanceMethod) {
+    if (fields === undefined) {
         fail('NATIVE_ROUTE_DECLARATION_INVALID', `Route ${route.name} requires a closed object input schema.`);
     }
-    const fields = Object.keys(properties);
     if (route.receiver !== undefined && fields.includes(route.receiver)) {
         fail('NATIVE_ROUTE_MAPPING_AMBIGUOUS', `Route ${route.name} receiver cannot also be a callable input field.`);
     }
@@ -117,6 +113,7 @@ const RESERVED_HEADERS = new Set([
     HTTP_ROUTE_ISSUER,
     HTTP_ROUTE_MISS,
     HTTP_ROUTE_PUBLICATION,
+    HTTP_ROUTE_RELEASE_UNAVAILABLE,
     HTTP_ROUTE_STALE,
 ]);
 export function isReservedHeader(input) {
@@ -127,9 +124,3 @@ function uniqueWires(route, kind, wires) {
         fail('NATIVE_ROUTE_MAPPING_AMBIGUOUS', `Route ${route.name} maps one ${kind} wire source more than once.`);
     }
 }
-function asRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-//# sourceMappingURL=mapping.js.map

package/dist/routes/match.d.ts

@@ -1,5 +1,4 @@
 import type { HttpRequest } from './request.js';
-import type { CompiledRoute } from './route.js';
-export declare function match(entries: readonly CompiledRoute[], request: Pick<HttpRequest, 'url' | 'method'>): CompiledRoute | undefined;
-export declare function methodMatches(entry: CompiledRoute, method: string): boolean;
-//# sourceMappingURL=match.d.ts.map
+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;

package/dist/routes/match.js

@@ -1,9 +1,7 @@
 import { matchTemplate } from './template.js';
-export function match(entries, request) {
-    return entries.find((entry) => methodMatches(entry, request.method) &&
-        matchTemplate(entry.route.href, request.url) !== undefined);
+export function match(table, request) {
+    return table.entries.find((entry) => methodMatches(entry, request.method) && matchTemplate(entry.href, request.url) !== undefined);
 }
 export function methodMatches(entry, method) {
-    return entry.route.method === '*' || entry.route.method === method.toUpperCase();
+    return entry.method === '*' || entry.method === method.toUpperCase();
 }
-//# sourceMappingURL=match.js.map

package/dist/routes/placement.d.ts

@@ -0,0 +1,5 @@
+import type * as publication from '../publication/index.js';
+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;

package/dist/routes/placement.js

@@ -0,0 +1,18 @@
+/** 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, auth: _auth, output: _output, default: isDefault, ...wire } = entry;
+        return Object.freeze({
+            ...wire,
+            href: placePath(path, issuer),
+            ...(isDefault ? { default: true } : {}),
+            ...(target.kind === 'method' && target.dispatch === 'instance'
+                ? { receiver: target.receiver }
+                : {}),
+        });
+    }));
+}
+export function placePath(path, issuer) {
+    const base = new URL(issuer);
+    return `${base.origin}${path}`;
+}

package/dist/routes/plan.d.ts

@@ -0,0 +1,24 @@
+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 auth: FunctionAuth;
+    readonly output: OutputMode;
+    readonly path: string;
+    readonly method: HttpMethod;
+    readonly requestMethod?: string;
+    readonly default: boolean;
+    readonly query?: Readonly<Record<string, string>>;
+    readonly headers?: RouteHeaders;
+    readonly body?: RouteBody;
+    readonly credential?: CredentialSource;
+}
+export interface Plan {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly entries: readonly PlanEntry[];
+}

package/dist/routes/plan.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import type { HttpRequest } from './request.js';
+export interface ReleaseUnavailable {
+    readonly kind: 'release-unavailable';
+}
+export declare const HTTP_ROUTE_RELEASE_UNAVAILABLE: 'x-astrale-release-unavailable';
+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;