@astrale-os/kernel-protocol 0.5.0-beta.6 → 0.5.0-beta.61

package/dist/publication/publication.js

@@ -3,16 +3,22 @@ import { accept as acceptIssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import { Key, patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { admitCallableBinding, admitViewBinding } from './bindings/index.js';
+import { canonicalizeViewBinding } from './bindings/view.js';
 import { array, deepFreeze, exact, record, unique } from './content.js';
 import { admitEndpoint as admitDeliveryEndpoint } from './delivery-endpoint.js';
 import { fail } from './error.js';
 import { admitDigest, computeEtag } from './etag.js';
+import { decodeLegacyRequirements, encodeLegacyRequirements } from './legacy-requirements.js';
 import { admitManifest } from './manifest.js';
 import { admitRequirements } from './requirements.js';
 import { admitRoute } from './route.js';
 import { admitSchema } from './schema.js';
 export const PATH = '/.well-known/astrale/domain.json';
-export const MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=2';
+export const MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=3';
+export const LEGACY_MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=2';
+export function mediaType(input) {
+    return input.version === 2 ? LEGACY_MEDIA_TYPE : MEDIA_TYPE;
+}
 /** Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer. */
 export function url(input) {
     const admitted = admitIssuer(input);
@@ -33,19 +39,23 @@ export function url(input) {
     return `${admitted.replace(/\/+$/u, '')}${PATH}`;
 }
 export function seal(input) {
-    return acceptPublication({ ...input, etag: computeEtag(input) }, false);
+    const canonical = withoutEtag(acceptPublication({ ...input, etag: 'canonicalizing' }, 'seal'));
+    return acceptPublication({ ...canonical, etag: computeEtag(canonical) }, 'canonical');
 }
 export function accept(input) {
-    const publication = acceptPublication(input, true);
+    const publication = acceptPublication(input, 'wire');
     if (publication.etag !== computeEtag(withoutEtag(publication))) {
         fail('PUBLICATION_ETAG_MISMATCH', 'Publication ETag does not match its canonical content.');
     }
     return publication;
 }
 export function encode(input) {
-    return portable.json.encode(input);
+    const wire = input.version === 2
+        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
+        : input;
+    return portable.json.encode(wire);
 }
-function acceptPublication(input, requireEtag) {
+function acceptPublication(input, mode) {
     const value = record(input, 'PUBLICATION_INVALID', 'Expected a Publication object.');
     exact(value, [
         'format',
@@ -60,7 +70,8 @@ function acceptPublication(input, requireEtag) {
         'routes',
         'delivery',
     ], 'PUBLICATION_INVALID');
-    if (value.format !== 'astrale.domain.publication' || value.version !== 2) {
+    if (value.format !== 'astrale.domain.publication' ||
+        (value.version !== 2 && value.version !== 3)) {
         fail('PUBLICATION_INVALID', 'Unsupported Publication format or version.');
     }
     if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
@@ -74,13 +85,15 @@ function acceptPublication(input, requireEtag) {
         fail('PUBLICATION_INVALID', 'Publication identity subject must equal its root origin.');
     }
     const publishedSchema = admitSchema(value.schema);
-    const requirements = admitRequirements(value.requirements);
+    const requirements = value.version === 2 && mode === 'wire'
+        ? decodeLegacyRequirements(value.requirements)
+        : admitRequirements(value.requirements);
     const manifest = admitManifest(value.manifest);
     const bindingSet = record(value.bindings, 'PUBLICATION_BINDING_INVALID', 'Publication bindings are invalid.');
     exact(bindingSet, ['callables', 'views'], 'PUBLICATION_BINDING_INVALID');
     const callables = array(bindingSet.callables, 'PUBLICATION_BINDING_INVALID').map((entry) => admitCallableBinding(entry, origin));
     unique(callables.map(({ callable }) => callable), 'PUBLICATION_BINDING_INVALID', 'callable binding');
-    const views = array(bindingSet.views, 'PUBLICATION_VIEW_INVALID').map((entry) => admitViewBinding(entry, origin));
+    const views = array(bindingSet.views, 'PUBLICATION_VIEW_INVALID').map((entry) => mode === 'seal' ? canonicalizeViewBinding(entry, origin) : admitViewBinding(entry, origin));
     unique(views.map(({ view }) => view), 'PUBLICATION_VIEW_INVALID', 'View binding');
     const routes = array(value.routes, 'PUBLICATION_ROUTE_INVALID').map((entry) => admitRoute(entry, origin));
     unique(routes.map(({ name }) => name), 'PUBLICATION_ROUTE_INVALID', 'route name');
@@ -90,18 +103,21 @@ function acceptPublication(input, requireEtag) {
         }
     }
     if (manifest?.entrypoint !== undefined) {
-        const key = Key.of(origin, manifest.entrypoint);
+        if (manifest.entrypoint.origin !== origin) {
+            fail('PUBLICATION_VIEW_INVALID', 'Manifest entrypoint must belong to the root origin.');
+        }
+        const key = Key.of(manifest.entrypoint);
         if (!views.some(({ view }) => view === key)) {
             fail('PUBLICATION_VIEW_INVALID', 'Manifest entrypoint must have a published View binding.');
         }
     }
     const delivery = admitDeliveryEndpoint(value.delivery, publishedSchema.bundle.href);
-    const admittedEtag = requireEtag ? admitDigest(value.etag) : value.etag;
+    const admittedEtag = mode === 'wire' ? admitDigest(value.etag) : value.etag;
     if (typeof admittedEtag !== 'string')
         fail('PUBLICATION_INVALID', 'Publication ETag is missing.');
     return deepFreeze({
         format: 'astrale.domain.publication',
-        version: 2,
+        version: value.version,
         origin,
         identity: { issuer, subject: origin },
         etag: admittedEtag,
@@ -128,4 +144,3 @@ function withoutEtag(input) {
     const { etag: _etag, ...content } = input;
     return content;
 }
-//# sourceMappingURL=publication.js.map

package/dist/publication/reference.d.ts

@@ -1,4 +1,4 @@
-import type { Revision } from '@astrale-os/kernel-dsl/v1/schema';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Etag } from './etag.js';
 import type { Publication } from './publication.js';
@@ -15,4 +15,3 @@ export declare function acceptReference(input: unknown): PublicationRef;
 export declare function compareReferences(input: PublicationRef, expected: PublicationRef): PublicationReferenceRelation;
 export declare function compareReference(input: Publication, expected: PublicationRef): PublicationReferenceRelation;
 export declare function matchesReference(input: Publication, expected: PublicationRef): boolean;
-//# sourceMappingURL=reference.d.ts.map

package/dist/publication/reference.js

@@ -66,4 +66,3 @@ function acceptIssuer(input) {
         throw cause;
     }
 }
-//# sourceMappingURL=reference.js.map

package/dist/publication/requirements.d.ts

@@ -1,27 +1,34 @@
 import type { AuthorityOperation } from '@astrale-os/kernel-core/schema/authority/operation';
-import type { schema } from '@astrale-os/kernel-dsl/v1';
-import type { Key as SemanticKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { schema as schemaLanguage } from '@astrale-os/kernel-dsl/v1';
+import type { ClassRef, CoreRef, Key as SemanticKey } from '@astrale-os/kernel-dsl/v1/addressing';
 export type NonEmpty<Value> = readonly [Value, ...Value[]];
 export declare const ClassOperationOrder: readonly ["create", "read", "traverse", "update", "delete"];
 export type ClassOperation = (typeof ClassOperationOrder)[number];
 export interface ClassCapabilityRequirement {
-    readonly class: schema.ClassRef;
+    readonly class: ClassRef;
     readonly operations: NonEmpty<ClassOperation>;
 }
-export interface CapabilityAdminRequirements {
+export interface CapabilityAuthorityRequirements {
     readonly grant?: NonEmpty<AuthorityOperation>;
     readonly revoke?: NonEmpty<AuthorityOperation>;
 }
 export interface CapabilityRequirements {
     readonly functions?: NonEmpty<SemanticKey.Callable>;
     readonly classes?: NonEmpty<ClassCapabilityRequirement>;
-    readonly admin?: CapabilityAdminRequirements;
+    readonly authority?: CapabilityAuthorityRequirements;
+    readonly core?: NonEmpty<CoreCapabilityRequirement>;
+}
+/** Installation-owned authority materialized onto one local Core Identity. */
+export interface CoreCapabilityRequirement {
+    readonly subject: CoreRef;
+    readonly functions?: NonEmpty<SemanticKey.Callable>;
+    readonly classes?: NonEmpty<ClassCapabilityRequirement>;
+    readonly authority?: CapabilityAuthorityRequirements;
 }
 export interface PublicationRequirements {
     readonly capabilities: CapabilityRequirements;
 }
-/** Admit the exact closed Publication v2 requirements object. */
+/** Admit the exact closed canonical requirements object used by Publication v3. */
 export declare function admitRequirements(input: unknown): PublicationRequirements;
 /** Bind explicit capability targets to exact functional dependencies in the bundle closure. */
-export declare function validateRequirements(root: schema.DomainSchema, closure: readonly schema.DomainSchema[], requirements: PublicationRequirements): void;
-//# sourceMappingURL=requirements.d.ts.map
+export declare function validateRequirements(root: schemaLanguage.DomainSchema, closure: readonly schemaLanguage.DomainSchema[], requirements: PublicationRequirements): void;

package/dist/publication/requirements.js

@@ -1,9 +1,14 @@
-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 { isMethodExecutable } from '@astrale-os/kernel-dsl/v1/language';
+import { revision } from '@astrale-os/kernel-dsl/v1/schema/revision';
 import { array, deepFreeze, exact, record, unique } from './content.js';
 import { fail } from './error.js';
+const KernelIdentityClass = Object.freeze({
+    origin: 'kernel.astrale.ai',
+    kind: 'class',
+    name: 'Identity',
+});
 export const ClassOperationOrder = Object.freeze([
     'create',
     'read',
@@ -11,12 +16,12 @@ export const ClassOperationOrder = Object.freeze([
     'update',
     'delete',
 ]);
-/** Admit the exact closed Publication v2 requirements object. */
+/** Admit the exact closed canonical requirements object used by Publication v3. */
 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', 'core'], 'PUBLICATION_INVALID');
     const functions = capabilities.functions === undefined
         ? undefined
         : nonEmpty(capabilities.functions, 'Function capability requirements').map(admitCallable);
@@ -31,7 +36,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 core = capabilities.core === undefined
+        ? undefined
+        : nonEmpty(capabilities.core, 'Core capability requirements').map(admitCoreCapabilityRequirement);
+    if (core !== undefined) {
+        unique(core.map(({ subject }) => Key.of(subject)), 'PUBLICATION_INVALID', 'Core capability subject');
+        canonical(core, (left, right) => compare(Key.of(left.subject), Key.of(right.subject)), 'Core capability requirements');
+    }
     return deepFreeze({
         capabilities: {
             ...(functions === undefined
@@ -40,35 +54,113 @@ export function admitRequirements(input) {
             ...(classes === undefined
                 ? {}
                 : { classes: Object.freeze(classes) }),
-            ...(admin === undefined ? {} : { admin }),
+            ...(authority === undefined ? {} : { authority }),
+            ...(core === undefined
+                ? {}
+                : { core: Object.freeze(core) }),
         },
     });
 }
+function admitCoreCapabilityRequirement(input) {
+    const requirement = record(input, 'PUBLICATION_INVALID', 'Core capability requirement is invalid.');
+    exact(requirement, ['authority', 'classes', 'functions', 'subject'], 'PUBLICATION_INVALID');
+    const subject = admitCoreRef(requirement.subject);
+    const functions = requirement.functions === undefined
+        ? undefined
+        : nonEmpty(requirement.functions, 'Core capability Function requirements').map(admitCallable);
+    if (functions !== undefined) {
+        unique(functions, 'PUBLICATION_INVALID', 'Core capability Function requirement');
+        canonical(functions, compare, 'Core capability Function requirements');
+    }
+    const classes = requirement.classes === undefined
+        ? undefined
+        : nonEmpty(requirement.classes, 'Core capability Class requirements').map(admitClassRequirement);
+    if (classes !== undefined) {
+        unique(classes.map((entry) => classKey(entry.class)), 'PUBLICATION_INVALID', 'Core capability Class requirement');
+        canonical(classes, (left, right) => compare(classKey(left.class), classKey(right.class)), 'Core capability Class requirements');
+    }
+    const authority = requirement.authority === undefined
+        ? undefined
+        : admitAuthorityRequirements(requirement.authority);
+    if (functions === undefined && classes === undefined && authority === undefined) {
+        fail('PUBLICATION_INVALID', 'Core capability 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 ?? []) {
         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.');
         }
     }
+    for (const requirement of requirements.capabilities.core ?? []) {
+        const subject = root.core.nodes[requirement.subject.name];
+        if (requirement.subject.origin !== root.origin ||
+            subject === undefined ||
+            !classSatisfies(root, dependencies, subject.class, KernelIdentityClass)) {
+            fail('PUBLICATION_INVALID', 'Core capability subject must name one local Core Identity.');
+        }
+        for (const callable of requirement.functions ?? []) {
+            const owner = Key.origin(callable) === root.origin
+                ? root
+                : capabilityOwner(root, dependencies, callable, 'Function');
+            if (!hasCallable(owner, callable)) {
+                fail('PUBLICATION_INVALID', 'Core capability Function requirement names an unknown or non-executable callable.');
+            }
+        }
+        for (const classRequirement of requirement.classes ?? []) {
+            const key = Key.of(classRequirement.class);
+            const owner = classRequirement.class.origin === root.origin
+                ? root
+                : capabilityOwner(root, dependencies, key, 'Class');
+            if (owner.classes[classRequirement.class.name] === undefined) {
+                fail('PUBLICATION_INVALID', 'Core capability Class requirement names an unknown dependency Class.');
+            }
+        }
+    }
+}
+function classSatisfies(root, dependencies, candidate, expected) {
+    const expectedKey = Key.of(expected);
+    const visited = new Set();
+    const visit = (reference) => {
+        const key = Key.of(reference);
+        if (key === expectedKey)
+            return true;
+        if (visited.has(key))
+            return false;
+        visited.add(key);
+        const owner = reference.origin === root.origin ? root : dependencies.get(reference.origin);
+        const definition = owner?.classes[reference.name];
+        return definition?.kind === 'node' && definition.extends.some(visit);
+    };
+    return visit(candidate);
 }
 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 || 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 +176,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;
@@ -101,14 +195,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 }),
@@ -117,22 +211,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' ||
-        !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 admitCoreRef(input) {
+    let value;
+    try {
+        value = acceptDefinitionRef(input);
+    }
+    catch {
+        fail('PUBLICATION_INVALID', 'Core capability subject is invalid.');
+    }
+    if (value.kind !== 'core') {
+        fail('PUBLICATION_INVALID', 'Core capability subject must be one local Core reference.');
+    }
+    return value;
 }
 function nonEmpty(input, label) {
     const values = [...array(input, 'PUBLICATION_INVALID')];
@@ -158,28 +265,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 && isMethodExecutable(declaration, method);
 }
-//# 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, publicUrl?: string): Table;

package/dist/routes/binding.js

@@ -3,16 +3,15 @@ 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, publicUrl = deployed.identity.issuer) {
     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)) {
+    if (json.serialize(place(plan, publicUrl)) !== json.serialize(deployed.routes)) {
         fail('NATIVE_ROUTE_BINDING_INVALID', 'Publication routes differ from the placed Route Plan.');
     }
     const entries = plan.entries.map((entry, index) => {
@@ -25,4 +24,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