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

package/dist/publication/requirements.js

@@ -1,5 +1,8 @@
-import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema';
-import { Key, Ref, schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+import { K } from '@astrale-os/kernel-core/schema';
+import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema/authority/operation';
+import { schema as schemaApi } from '@astrale-os/kernel-dsl/v1';
+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([
@@ -14,7 +17,7 @@ export function admitRequirements(input) {
     const requirements = record(input, 'PUBLICATION_INVALID', 'Publication requirements are invalid.');
     exact(requirements, ['capabilities'], 'PUBLICATION_INVALID');
     const capabilities = record(requirements.capabilities, 'PUBLICATION_INVALID', 'Publication capability requirements are invalid.');
-    exact(capabilities, ['admin', 'classes', 'functions'], 'PUBLICATION_INVALID');
+    exact(capabilities, ['authority', 'classes', 'functions', 'profiles'], 'PUBLICATION_INVALID');
     const functions = capabilities.functions === undefined
         ? undefined
         : nonEmpty(capabilities.functions, 'Function capability requirements').map(admitCallable);
@@ -29,7 +32,16 @@ export function admitRequirements(input) {
         unique(classes.map((entry) => classKey(entry.class)), 'PUBLICATION_INVALID', 'Class capability requirement');
         canonical(classes, (left, right) => compare(classKey(left.class), classKey(right.class)), 'Class capability requirements');
     }
-    const admin = capabilities.admin === undefined ? undefined : admitAdminRequirements(capabilities.admin);
+    const authority = capabilities.authority === undefined
+        ? undefined
+        : admitAuthorityRequirements(capabilities.authority);
+    const profiles = capabilities.profiles === undefined
+        ? undefined
+        : nonEmpty(capabilities.profiles, 'Capability profiles').map(admitCapabilityProfile);
+    if (profiles !== undefined) {
+        unique(profiles.map(({ subject }) => Key.of(subject)), 'PUBLICATION_INVALID', 'Capability profile subject');
+        canonical(profiles, (left, right) => compare(Key.of(left.subject), Key.of(right.subject)), 'Capability profiles');
+    }
     return deepFreeze({
         capabilities: {
             ...(functions === undefined
@@ -38,36 +50,100 @@ export function admitRequirements(input) {
             ...(classes === undefined
                 ? {}
                 : { classes: Object.freeze(classes) }),
-            ...(admin === undefined ? {} : { admin }),
+            ...(authority === undefined ? {} : { authority }),
+            ...(profiles === undefined
+                ? {}
+                : { profiles: Object.freeze(profiles) }),
         },
     });
 }
+function admitCapabilityProfile(input) {
+    const profile = record(input, 'PUBLICATION_INVALID', 'Capability profile requirement is invalid.');
+    exact(profile, ['authority', 'classes', 'functions', 'subject'], 'PUBLICATION_INVALID');
+    const subject = admitCoreRef(profile.subject);
+    const functions = profile.functions === undefined
+        ? undefined
+        : nonEmpty(profile.functions, 'Capability profile Function requirements').map(admitCallable);
+    if (functions !== undefined) {
+        unique(functions, 'PUBLICATION_INVALID', 'Capability profile Function requirement');
+        canonical(functions, compare, 'Capability profile Function requirements');
+    }
+    const classes = profile.classes === undefined
+        ? undefined
+        : nonEmpty(profile.classes, 'Capability profile Class requirements').map(admitClassRequirement);
+    if (classes !== undefined) {
+        unique(classes.map((entry) => classKey(entry.class)), 'PUBLICATION_INVALID', 'Capability profile Class requirement');
+        canonical(classes, (left, right) => compare(classKey(left.class), classKey(right.class)), 'Capability profile Class requirements');
+    }
+    const authority = profile.authority === undefined ? undefined : admitAuthorityRequirements(profile.authority);
+    if (functions === undefined && classes === undefined && authority === undefined) {
+        fail('PUBLICATION_INVALID', 'Capability profile requirements cannot be empty.');
+    }
+    return Object.freeze({
+        subject,
+        ...(functions === undefined
+            ? {}
+            : { functions: Object.freeze(functions) }),
+        ...(classes === undefined
+            ? {}
+            : { classes: Object.freeze(classes) }),
+        ...(authority === undefined ? {} : { authority }),
+    });
+}
 /** Bind explicit capability targets to exact functional dependencies in the bundle closure. */
 export function validateRequirements(root, closure, requirements) {
     const dependencies = exactDependencyClosure(root, closure);
     for (const callable of requirements.capabilities.functions ?? []) {
-        validateForeignTarget(root, dependencies, callable, 'Function');
-        const dependency = dependencies.get(Key.origin(callable));
-        const reference = Key.ref(callable);
-        if (!hasCallable(dependency, reference)) {
+        const dependency = capabilityOwner(root, dependencies, callable, 'Function');
+        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);
-        validateForeignTarget(root, dependencies, key, 'Class');
-        if (dependencies.get(requirement.class.origin).classes[requirement.class.name] === undefined) {
+        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.');
         }
     }
+    const resolvedRoot = requirements.capabilities.profiles === undefined
+        ? undefined
+        : schemaApi.resolve(schemaApi.accept(root, {
+            get(origin, expectedRevision) {
+                return closure.find((dependency) => dependency.origin === origin && revision(dependency) === expectedRevision);
+            },
+        }));
+    for (const profile of requirements.capabilities.profiles ?? []) {
+        const subject = resolvedRoot.core.nodes[profile.subject.name];
+        if (profile.subject.origin !== root.origin ||
+            subject === undefined ||
+            !subject.class.satisfies(K.classes.Identity)) {
+            fail('PUBLICATION_INVALID', 'Capability profile subject must name one local Core Identity.');
+        }
+        for (const callable of profile.functions ?? []) {
+            const dependency = capabilityOwner(root, dependencies, callable, 'Function');
+            if (!hasCallable(dependency, callable)) {
+                fail('PUBLICATION_INVALID', 'Capability profile Function requirement names an unknown dependency callable.');
+            }
+        }
+        for (const requirement of profile.classes ?? []) {
+            const key = Key.of(requirement.class);
+            const owner = requirement.class.origin === root.origin
+                ? root
+                : capabilityOwner(root, dependencies, key, 'Class');
+            if (owner.classes[requirement.class.name] === undefined) {
+                fail('PUBLICATION_INVALID', 'Capability profile Class requirement names an unknown dependency Class.');
+            }
+        }
+    }
 }
 function exactDependencyClosure(root, closure) {
     const supplied = new Map(closure.map((dependency) => [dependency.origin, dependency]));
     const reachable = new Map();
     const visit = (owner) => {
-        for (const coordinate of owner.dependencies) {
+        for (const coordinate of Object.values(owner.dependencies)) {
             const dependency = supplied.get(coordinate.origin);
-            if (dependency === undefined || dslSchema.revision(dependency) !== coordinate.revision) {
+            if (dependency === undefined || revision(dependency) !== coordinate.revision) {
                 fail('PUBLICATION_INVALID', 'Publication Bundle omits an exact dependency.');
             }
             if (reachable.has(dependency.origin))
@@ -83,8 +159,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;
@@ -100,14 +178,14 @@ function admitClassRequirement(input) {
         operations: Object.freeze(operations),
     });
 }
-function admitAdminRequirements(input) {
-    const admin = record(input, 'PUBLICATION_INVALID', 'Administrative capability requirements are invalid.');
-    exact(admin, ['grant', 'revoke'], 'PUBLICATION_INVALID');
-    if (admin.grant === undefined && admin.revoke === undefined) {
-        fail('PUBLICATION_INVALID', 'Administrative capability requirements cannot be empty.');
+function admitAuthorityRequirements(input) {
+    const authority = record(input, 'PUBLICATION_INVALID', 'Authority capability requirements are invalid.');
+    exact(authority, ['grant', 'revoke'], 'PUBLICATION_INVALID');
+    if (authority.grant === undefined && authority.revoke === undefined) {
+        fail('PUBLICATION_INVALID', 'Authority capability requirements cannot be empty.');
     }
-    const grant = admitAuthorityOperations(admin.grant, 'grant');
-    const revoke = admitAuthorityOperations(admin.revoke, 'revoke');
+    const grant = admitAuthorityOperations(authority.grant, 'grant');
+    const revoke = admitAuthorityOperations(authority.revoke, 'revoke');
     return Object.freeze({
         ...(grant === undefined ? {} : { grant }),
         ...(revoke === undefined ? {} : { revoke }),
@@ -116,22 +194,35 @@ function admitAdminRequirements(input) {
 function admitAuthorityOperations(input, kind) {
     if (input === undefined)
         return undefined;
-    const values = nonEmpty(input, `Administrative ${kind} operations`).map((entry) => admitOperation(entry, AuthorityOperationOrder, `Administrative ${kind} operation`));
-    unique(values, 'PUBLICATION_INVALID', `administrative ${kind} operation`);
-    canonical(values, ordered(AuthorityOperationOrder), `Administrative ${kind} operations`);
+    const values = nonEmpty(input, `Authority ${kind} operations`).map((entry) => admitOperation(entry, AuthorityOperationOrder, `Authority ${kind} operation`));
+    unique(values, 'PUBLICATION_INVALID', `authority ${kind} operation`);
+    canonical(values, ordered(AuthorityOperationOrder), `Authority ${kind} operations`);
     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' ||
-        !dslSchema.patterns.origin.test(value.origin) ||
-        typeof value.name !== 'string' ||
-        !dslSchema.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 admitCoreRef(input) {
+    let value;
+    try {
+        value = acceptDefinitionRef(input);
+    }
+    catch {
+        fail('PUBLICATION_INVALID', 'Capability profile subject is invalid.');
+    }
+    if (value.kind !== 'core') {
+        fail('PUBLICATION_INVALID', 'Capability profile subject must be one local Core reference.');
+    }
+    return value;
 }
 function nonEmpty(input, label) {
     const values = [...array(input, 'PUBLICATION_INVALID')];
@@ -157,24 +248,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 validateForeignTarget(root, dependencies, key, label) {
+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 (!dependencies.has(origin)) {
+    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

@@ -1,4 +1,4 @@
-import { type Key } from '@astrale-os/kernel-dsl/v1';
+import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | '*';
 export type SingleCredentialSource = {
     readonly in: 'header';
@@ -29,5 +29,9 @@ export interface HttpRoute {
     readonly body?: RouteBody;
     readonly credential?: CredentialSource;
 }
+/** Provider-neutral build input; placement replaces path with the canonical absolute href. */
+export interface HttpRouteDeclaration extends Omit<HttpRoute, 'href'> {
+    readonly path: string;
+}
 export declare function admitRoute(input: unknown, origin: string): HttpRoute;
-//# sourceMappingURL=route.d.ts.map
+export declare function admitRouteDeclaration(input: unknown, origin: string): HttpRouteDeclaration;

package/dist/publication/route.js

@@ -1,14 +1,39 @@
-import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { admitCallableKey } from './bindings/callable.js';
 import { absoluteHttpUrl, deepFreeze, exact, record } from './content.js';
 import { fail } from './error.js';
 const ROUTE_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/u;
 export function admitRoute(input, origin) {
     const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'Published HTTP route is invalid.');
+    const common = admitRouteCommon(value, origin, 'href');
+    return deepFreeze({
+        ...common,
+        href: absoluteHttpUrl(value.href, false, 'PUBLICATION_ROUTE_INVALID', true),
+    });
+}
+export function admitRouteDeclaration(input, origin) {
+    const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'HTTP route declaration is invalid.');
+    const common = admitRouteCommon(value, origin, 'path');
+    if (typeof value.path !== 'string' || !value.path.startsWith('/')) {
+        fail('PUBLICATION_ROUTE_INVALID', 'Route declaration path must be relative to one issuer.');
+    }
+    let parsed;
+    try {
+        parsed = new URL(value.path, 'https://placement.invalid');
+    }
+    catch (cause) {
+        return fail('PUBLICATION_ROUTE_INVALID', 'Route declaration path is invalid.', cause);
+    }
+    if (parsed.origin !== 'https://placement.invalid' || parsed.search !== '' || parsed.hash !== '') {
+        fail('PUBLICATION_ROUTE_INVALID', 'Route declaration path cannot select an origin, query, or fragment.');
+    }
+    return deepFreeze({ ...common, path: value.path });
+}
+function admitRouteCommon(value, origin, location) {
     exact(value, [
         'name',
         'callable',
-        'href',
+        location,
         'method',
         'requestMethod',
         'default',
@@ -29,22 +54,20 @@ export function admitRoute(input, origin) {
         fail('PUBLICATION_ROUTE_INVALID', 'Route default may only be true.');
     }
     if (value.requestMethod !== undefined &&
-        (typeof value.requestMethod !== 'string' ||
-            !dslSchema.patterns.memberName.test(value.requestMethod))) {
+        (typeof value.requestMethod !== 'string' || !patterns.memberName.test(value.requestMethod))) {
         fail('PUBLICATION_ROUTE_INVALID', 'Route request-method mapping is invalid.');
     }
     if (value.receiver !== undefined &&
-        (typeof value.receiver !== 'string' || !dslSchema.patterns.memberName.test(value.receiver))) {
+        (typeof value.receiver !== 'string' || !patterns.memberName.test(value.receiver))) {
         fail('PUBLICATION_ROUTE_INVALID', 'Route receiver is invalid.');
     }
     const query = stringRecord(value.query);
     const headers = headerRecord(value.headers);
     const body = admitBody(value.body);
     const credential = admitCredential(value.credential);
-    return deepFreeze({
+    return {
         name: value.name,
         callable,
-        href: absoluteHttpUrl(value.href, false, 'PUBLICATION_ROUTE_INVALID', true),
         method: value.method,
         ...(value.requestMethod === undefined ? {} : { requestMethod: value.requestMethod }),
         ...(value.default === true ? { default: true } : {}),
@@ -53,7 +76,7 @@ export function admitRoute(input, origin) {
         ...(headers === undefined ? {} : { headers }),
         ...(body === undefined ? {} : { body }),
         ...(credential === undefined ? {} : { credential }),
-    });
+    };
 }
 function admitCredential(input) {
     if (input === undefined)
@@ -129,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 { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
-import type { BundleDescriptor } from './bundle.js';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { BundleDescriptor } from './bundle-descriptor.js';
 export interface Schema {
-    readonly revision: dslSchema.Revision;
+    readonly revision: Revision;
     readonly bundle: BundleDescriptor;
 }
 export declare function admitSchema(input: unknown): Schema;
-//# sourceMappingURL=schema.d.ts.map

package/dist/publication/schema.js

@@ -1,11 +1,11 @@
-import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
-import { admitBundleDescriptor } from './bundle.js';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { admitBundleDescriptor } from './bundle-descriptor.js';
 import { exact, record } from './content.js';
 import { fail } from './error.js';
 export function admitSchema(input) {
     const value = record(input, 'PUBLICATION_INVALID', 'Published schema is invalid.');
     exact(value, ['revision', 'bundle'], 'PUBLICATION_INVALID');
-    if (typeof value.revision !== 'string' || !dslSchema.patterns.revision.test(value.revision)) {
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
         fail('PUBLICATION_INVALID', 'Published schema revision is invalid.');
     }
     return Object.freeze({
@@ -13,4 +13,3 @@ export function admitSchema(input) {
         bundle: admitBundleDescriptor(value.bundle),
     });
 }
-//# sourceMappingURL=schema.js.map

package/dist/routes/admission.d.ts

@@ -0,0 +1,3 @@
+import type { Table } from './table.js';
+/** Admit one emitted portable Table before Server composition. */
+export declare function acceptTable(input: unknown): Table;

package/dist/routes/admission.js

@@ -0,0 +1,89 @@
+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 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) {
+    const value = object(acceptPortable(input), 'Route Table');
+    exact(value, ['publication', 'entries'], 'Route Table');
+    const reference = acceptReference(value.publication);
+    if (!Array.isArray(value.entries))
+        invalid('Route Table entries');
+    const entries = value.entries.map((entry) => acceptRoute(entry, reference.origin));
+    if (new Set(entries.map(({ name }) => name)).size !== entries.length) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Table names must be unique.');
+    }
+    return Object.freeze({ publication: reference, entries: Object.freeze(entries) });
+}
+function acceptRoute(input, origin) {
+    const value = object(input, 'Route Table entry');
+    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.auth !== 'string' || !AUTH.has(value.auth)) {
+        invalid('Route Table auth');
+    }
+    if (typeof value.output !== 'string' || !OUTPUT.has(value.output))
+        invalid('Route Table output');
+    const wire = admitRoute({
+        name: value.name,
+        callable: value.callable,
+        href: value.href,
+        method: value.method,
+        ...(value.default === true ? { default: true } : {}),
+        ...(value.requestMethod === undefined ? {} : { requestMethod: value.requestMethod }),
+        ...(value.query === undefined ? {} : { query: value.query }),
+        ...(value.headers === undefined ? {} : { headers: value.headers }),
+        ...(value.body === undefined ? {} : { body: value.body }),
+        ...(value.credential === undefined ? {} : { credential: value.credential }),
+        ...receiver(value.target),
+    }, origin);
+    const { default: _default, receiver: _receiver, ...common } = wire;
+    return Object.freeze({
+        ...common,
+        target: target(value.target),
+        auth: value.auth,
+        output: value.output,
+        default: value.default,
+    });
+}
+function target(input) {
+    const value = object(input, 'Route target');
+    if (value.kind === 'function') {
+        exact(value, ['kind'], 'Route Function target');
+        return Object.freeze({ kind: 'function' });
+    }
+    if (value.kind !== 'method' || (value.dispatch !== 'static' && value.dispatch !== 'instance')) {
+        invalid('Route Method target');
+    }
+    if (value.dispatch === 'static') {
+        exact(value, ['kind', 'dispatch'], 'Route static Method target');
+        return Object.freeze({ kind: 'method', dispatch: 'static' });
+    }
+    exact(value, ['kind', 'dispatch', 'receiver'], 'Route instance Method target');
+    if (typeof value.receiver !== 'string')
+        invalid('Route receiver');
+    return Object.freeze({ kind: 'method', dispatch: 'instance', receiver: value.receiver });
+}
+function receiver(input) {
+    const admitted = target(input);
+    return admitted.kind === 'method' && admitted.dispatch === 'instance'
+        ? { receiver: admitted.receiver }
+        : {};
+}
+function object(input, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid(label);
+    return input;
+}
+function exact(value, required, label, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    if (Object.keys(value).some((key) => !allowed.has(key)) ||
+        required.some((key) => !Object.hasOwn(value, key)))
+        invalid(label);
+}
+function invalid(label) {
+    return fail('NATIVE_ROUTE_BINDING_INVALID', `${label} is invalid.`);
+}

package/dist/routes/binding.d.ts

@@ -0,0 +1,6 @@
+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 resolved Domain. */
+export declare function bind(plan: Plan, deployed: Publication, domain: Domain): Table;

package/dist/routes/binding.js

@@ -0,0 +1,27 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+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 resolved Domain. */
+export function bind(plan, deployed, domain) {
+    if (plan.origin !== deployed.origin ||
+        plan.origin !== domain.origin ||
+        plan.revision !== deployed.schema.revision ||
+        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)) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Publication routes differ from the placed Route Plan.');
+    }
+    const entries = plan.entries.map((entry, index) => {
+        const { path: _path, ...portable } = entry;
+        return Object.freeze({ ...portable, href: deployed.routes[index].href });
+    });
+    rejectReserved(deployed, entries);
+    return Object.freeze({
+        publication: reference(deployed),
+        entries: Object.freeze(entries),
+    });
+}

package/dist/routes/collision.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from './table.js';
+export declare function rejectCollisions(entries: readonly Route[]): void;

package/dist/routes/collision.js

@@ -0,0 +1,16 @@
+import { fail } from './error.js';
+import { templatesOverlap } from './template.js';
+export function rejectCollisions(entries) {
+    const accepted = [];
+    for (const entry of entries) {
+        for (const previous of accepted) {
+            if (overlap(entry.method, previous.method) && templatesOverlap(entry.href, previous.href)) {
+                fail('NATIVE_ROUTE_COLLISION', `Route ${entry.name} collides with ${previous.name}.`);
+            }
+        }
+        accepted.push(entry);
+    }
+}
+function overlap(left, right) {
+    return left === '*' || right === '*' || left === right;
+}

package/dist/routes/compiler.d.ts

@@ -0,0 +1,8 @@
+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 domain: Domain;
+}
+export declare function compile(input: CompileInput): Plan;

package/dist/routes/compiler.js

@@ -0,0 +1,50 @@
+import { admitRouteDeclaration } from '../publication/route.js';
+import { rejectCollisions } from './collision.js';
+import { fail } from './error.js';
+import { validateCredentialMapping, validateMapping, validateWireMapping } from './mapping.js';
+import { placePath } from './placement.js';
+import { validateTemplate } from './template.js';
+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.domain.origin));
+    const entries = authored.map((declaration) => {
+        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.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 = !isMethod(meaning)
+            ? { kind: 'function' }
+            : 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,
+            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.domain.origin,
+        revision: input.domain.revision,
+        entries: Object.freeze(entries),
+    });
+}
+function isMethod(meaning) {
+    return 'owner' in meaning;
+}

package/dist/routes/credential.d.ts

@@ -1,9 +1,8 @@
 import type { HttpRoute, SingleCredentialSource } from '../publication/index.js';
-import type { CompiledRoute } from './route.js';
-export declare function credentialSources(route: HttpRoute): readonly SingleCredentialSource[];
-export declare function firstCredentialIsAmbient(entry: CompiledRoute): boolean;
-export declare function specificHeaderWires(entry: CompiledRoute): ReadonlySet<string>;
-export declare function putCredential(entry: CompiledRoute, url: URL, headers: Record<string, string>, credential: string): void;
-export declare function withoutCredentialHeaders(entry: CompiledRoute, input: Readonly<Record<string, string>>): Record<string, string>;
-export declare function readCredential(entry: CompiledRoute, url: URL, headers: Record<string, string>): string | undefined;
-//# sourceMappingURL=credential.d.ts.map
+import type { Route } from './table.js';
+export declare function credentialSources(route: Pick<HttpRoute, 'credential'>): readonly SingleCredentialSource[];
+export declare function firstCredentialIsAmbient(entry: Route): boolean;
+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;