@astrale-os/kernel-protocol 0.5.0-beta.2 → 0.5.0-beta.21

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;

package/dist/routes/release-unavailable.js

@@ -0,0 +1,32 @@
+import { fail } from './error.js';
+export const HTTP_ROUTE_RELEASE_UNAVAILABLE = 'x-astrale-release-unavailable';
+export const HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS = 410;
+export function releaseUnavailableHeaders() {
+    return Object.freeze({
+        [HTTP_ROUTE_RELEASE_UNAVAILABLE]: '1',
+        'cache-control': 'no-store',
+    });
+}
+export function decodeReleaseUnavailable(status, headers) {
+    const encoded = header(headers, HTTP_ROUTE_RELEASE_UNAVAILABLE);
+    if (encoded === undefined)
+        return undefined;
+    if (status !== HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS || encoded !== '1') {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_ROUTE_RELEASE_UNAVAILABLE} is reserved for status ${HTTP_ROUTE_RELEASE_UNAVAILABLE_STATUS} with value 1.`);
+    }
+    return Object.freeze({ kind: 'release-unavailable' });
+}
+function header(input, name) {
+    if (input instanceof Headers)
+        return input.get(name) ?? undefined;
+    let found;
+    for (const [candidate, value] of Object.entries(input ?? {})) {
+        if (candidate.toLowerCase() !== name || value === undefined)
+            continue;
+        if (found !== undefined || (Array.isArray(value) && value.length !== 1)) {
+            fail('NATIVE_ROUTE_ROUTING_INVALID', `Header ${name} must occur at most once.`);
+        }
+        found = typeof value === 'string' ? value : value[0];
+    }
+    return found;
+}

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/index.js';
-import type { CompiledRoute } from './route.js';
-export declare function rejectReserved(publication: Publication, entries: readonly CompiledRoute[]): void;
-//# sourceMappingURL=reservation.d.ts.map
+import type { Publication } from '../publication/publication.js';
+import type { Route } from './table.js';
+export declare function rejectReserved(publication: Publication, entries: readonly Route[]): void;

package/dist/routes/reservation.js

@@ -1,5 +1,5 @@
 import * as issuer from '../issuer/index.js';
-import { PATH as PUBLICATION_PATH } from '../publication/index.js';
+import { PATH as PUBLICATION_PATH } from '../publication/publication.js';
 import { fail } from './error.js';
 import { templateUrl, templatesOverlap } from './template.js';
 const STATIC_RESERVED_PATHS = new Set([PUBLICATION_PATH]);
@@ -15,10 +15,10 @@ export function rejectReserved(publication, entries) {
         ]),
     ];
     for (const entry of entries) {
-        const claimed = [...reservedPaths].some((path) => templateClaimsPath(entry.route.href, path)) ||
-            reservedUrls.some((reserved) => templatesOverlap(entry.route.href, reserved));
+        const claimed = [...reservedPaths].some((path) => templateClaimsPath(entry.href, path)) ||
+            reservedUrls.some((reserved) => templatesOverlap(entry.href, routeLocation(reserved)));
         if (claimed) {
-            fail('NATIVE_ROUTE_RESERVED', `Route ${entry.name} claims reserved URL ${templateUrl(entry.route.href).href}.`);
+            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,7 +1,7 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
 import type * as portable from '@astrale-os/kernel-dsl/value';
-import type { CompiledRoute } from './route.js';
-export declare function encodeScalar(entry: CompiledRoute, name: string, value: unknown): string;
-export declare function decodeScalar(entry: CompiledRoute, name: string, encoded: string): portable.Value;
+import type { Route } from './table.js';
+export declare function encodeScalar(entry: Route, name: string, value: unknown, domain: Domain): string;
+export declare function decodeScalar(entry: Route, name: string, encoded: string, domain: Domain): portable.Value;
 export declare function scalar(value: unknown): string;
 export declare function asObject(value: unknown): Record<string, portable.Value>;
-//# sourceMappingURL=scalar.d.ts.map

package/dist/routes/scalar.js

@@ -1,23 +1,22 @@
-import { schema } from '@astrale-os/kernel-dsl/v1';
 import { invalidRequest } from './error.js';
 const JSON_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
-export function encodeScalar(entry, name, value) {
+export function encodeScalar(entry, name, value, domain) {
     const encoded = scalar(value);
-    if (name === entry.route.receiver)
+    if (name === receiver(entry))
         return encoded;
-    const decoded = decodeScalar(entry, name, encoded);
+    const decoded = decodeScalar(entry, name, encoded, domain);
     if (!sameScalar(decoded, value)) {
         invalidRequest(`Native route field ${name} does not round-trip through its declared value schema.`);
     }
     return encoded;
 }
-export function decodeScalar(entry, name, encoded) {
-    if (name === entry.route.receiver)
+export function decodeScalar(entry, name, encoded, domain) {
+    if (name === receiver(entry))
         return encoded;
-    const input = asObject(entry.declaration.input);
-    const contract = asObject(input.properties)[name];
-    if (contract === undefined)
+    const meaning = domain.callable(entry.callable);
+    if (meaning?.inputFields?.includes(name) !== true) {
         invalidRequest(`Native route maps unknown input field ${name}.`);
+    }
     const candidates = [encoded];
     if (encoded === 'true')
         candidates.push(true);
@@ -30,7 +29,7 @@ export function decodeScalar(entry, name, encoded) {
         if (Number.isFinite(number))
             candidates.push(number);
     }
-    const accepted = candidates.filter((candidate) => schema.values.validate(entry.owner, contract, candidate).length === 0);
+    const accepted = candidates.filter((candidate) => meaning.validateInputField(name, candidate).length === 0);
     if (accepted.length === 0) {
         invalidRequest(`Native route field ${name} is invalid under its declared value schema.`);
     }
@@ -39,6 +38,11 @@ export function decodeScalar(entry, name, encoded) {
     }
     return accepted[0];
 }
+function receiver(entry) {
+    return entry.target.kind === 'method' && entry.target.dispatch === 'instance'
+        ? entry.target.receiver
+        : undefined;
+}
 export function scalar(value) {
     if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
         return String(value);
@@ -55,4 +59,3 @@ function sameScalar(left, right) {
     return (Object.is(left, right) ||
         (typeof left === 'number' && typeof right === 'number' && left === 0 && right === 0));
 }
-//# sourceMappingURL=scalar.js.map

package/dist/routes/select.d.ts

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

package/dist/routes/select.js

@@ -1,6 +1,6 @@
 import { RouteError } from './error.js';
-export function select(entries, callable, route) {
-    const candidates = entries.filter((entry) => entry.callable === callable);
+export function select(table, callable, route) {
+    const candidates = table.entries.filter((entry) => entry.callable === callable);
     if (route !== undefined) {
         const selected = candidates.find((entry) => entry.name === route);
         if (selected === undefined) {
@@ -14,4 +14,3 @@ export function select(entries, callable, route) {
         return candidates[0];
     return candidates.find((entry) => entry.default);
 }
-//# sourceMappingURL=select.js.map

package/dist/routes/stream.d.ts

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

package/dist/routes/stream.js

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

package/dist/routes/table.d.ts

@@ -0,0 +1,9 @@
+import type { PublicationRef } from '../publication/index.js';
+import type { PlanEntry } from './plan.js';
+export interface Route extends Omit<PlanEntry, 'path'> {
+    readonly href: string;
+}
+export interface Table {
+    readonly publication: PublicationRef;
+    readonly entries: readonly Route[];
+}

package/dist/routes/table.js

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

package/dist/routes/target.d.ts

@@ -0,0 +1,13 @@
+export type RouteTarget = {
+    readonly kind: 'function';
+} | {
+    readonly kind: 'method';
+    readonly dispatch: 'static';
+} | {
+    readonly kind: 'method';
+    readonly dispatch: 'instance';
+    readonly receiver: string;
+};
+export declare function requiresReceiver(entry: {
+    readonly target: RouteTarget;
+}): boolean;

package/dist/routes/target.js

@@ -0,0 +1,3 @@
+export function requiresReceiver(entry) {
+    return entry.target.kind === 'method' && entry.target.dispatch === 'instance';
+}

package/dist/routes/template.d.ts

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

package/dist/routes/template.js

@@ -225,4 +225,3 @@ function segmentsOverlap(left, right) {
 function escapePattern(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
 }
-//# sourceMappingURL=template.js.map

package/dist/runtime/artifact.d.ts

@@ -1,5 +1,5 @@
-import type { IssuerId } from '@astrale-os/kernel-core/auth';
-import type { Key, schema } from '@astrale-os/kernel-dsl/v1';
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
 import type { Digest, Ref } from '../artifact/index.js';
 import type { PublicationRequirements } from '../publication/index.js';
 export interface ExecutableDependency {
@@ -24,7 +24,7 @@ export interface Export {
 }
 export interface Module {
     readonly origin: Key.Origin;
-    readonly revision: schema.Revision;
+    readonly revision: Revision;
     readonly factory: Export;
     readonly configuration: Ref | null;
 }
@@ -45,4 +45,3 @@ export declare function acceptExecutable(input: unknown): Executable;
 export declare function executableDigest(input: Omit<Executable, 'digest'>): Digest;
 export declare function executableClosure(input: readonly ExecutableDependency[]): Digest;
 export type { Digest, Ref };
-//# sourceMappingURL=artifact.d.ts.map

package/dist/runtime/artifact.js

@@ -1,5 +1,5 @@
-import { issuer } from '@astrale-os/kernel-core/auth';
-import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { sha256 } from '@noble/hashes/sha2.js';
 import * as artifact from '../artifact/index.js';
@@ -13,7 +13,7 @@ export function accept(input) {
     }
     if (typeof root.issuer !== 'string')
         invalid('Domain Runtime artifact issuer is invalid.');
-    const admittedIssuer = issuer.accept(root.issuer);
+    const admittedIssuer = acceptIssuer(root.issuer);
     const bundle = artifact.accept(root.bundle);
     const requirements = admitRequirements(root.requirements);
     if (!Array.isArray(root.modules) || root.modules.length === 0) {
@@ -51,10 +51,10 @@ export function executableClosure(input) {
 function module(input, index) {
     const value = record(input, `Domain Runtime Module ${index}`);
     exact(value, ['configuration', 'factory', 'origin', 'revision']);
-    if (typeof value.origin !== 'string' || !dslSchema.patterns.origin.test(value.origin)) {
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
         invalid(`Domain Runtime Module ${index} origin is invalid.`);
     }
-    if (typeof value.revision !== 'string' || !dslSchema.patterns.revision.test(value.revision)) {
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
         invalid(`Domain Runtime Module ${index} revision is invalid.`);
     }
     const factory = executableExport(value.factory, index);
@@ -174,4 +174,3 @@ function exact(input, expected) {
 function invalid(message) {
     throw new TypeError(message);
 }
-//# sourceMappingURL=artifact.js.map

package/dist/runtime/index.d.ts

@@ -1,2 +1 @@
 export { MEDIA_TYPE, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, type Digest, type Executable, type ExecutableDependency, type Export, type Module, type RuntimeArtifact, type Ref, } from './artifact.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.js

@@ -1,2 +1 @@
 export { MEDIA_TYPE, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, } from './artifact.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/index.d.ts

@@ -1,2 +1 @@
 export * as installation from './installation/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.js

@@ -1,2 +1 @@
 export * as installation from './installation/index.js';
-//# sourceMappingURL=index.js.map

package/dist/schema/installation/codec.d.ts

@@ -0,0 +1,4 @@
+import type { InstallResult } from './result.js';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-installation.v1+msgpack';
+export declare function encode(result: InstallResult): Promise<Uint8Array>;
+export declare function decode(bytes: Uint8Array, maximumBytes: number): Promise<InstallResult>;