@astrale-os/kernel-protocol 0.5.0-beta.10

package/dist/publication/publication.d.ts

@@ -0,0 +1,36 @@
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { CallableBinding, ViewBinding } from './bindings/index.js';
+import type { Content } from './content.js';
+import type { Endpoint as DeliveryEndpoint } from './delivery-endpoint.js';
+import type { Etag } from './etag.js';
+import type { Manifest } from './manifest.js';
+import type { PublicationRequirements } from './requirements.js';
+import type { HttpRoute } from './route.js';
+import type { Schema } from './schema.js';
+export declare const PATH: '/.well-known/astrale/domain.json';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=2';
+/** Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer. */
+export declare function url(input: string): string;
+export interface Publication {
+    readonly format: 'astrale.domain.publication';
+    readonly version: 2;
+    readonly origin: Key.Origin;
+    readonly identity: {
+        readonly issuer: IssuerId;
+        readonly subject: string;
+    };
+    readonly etag: Etag;
+    readonly schema: Schema;
+    readonly requirements: PublicationRequirements;
+    readonly manifest?: Manifest;
+    readonly bindings: {
+        readonly callables: readonly CallableBinding[];
+        readonly views: readonly ViewBinding[];
+    };
+    readonly routes: readonly HttpRoute[];
+    readonly delivery?: DeliveryEndpoint;
+}
+export declare function seal(input: Content): Publication;
+export declare function accept(input: unknown): Publication;
+export declare function encode(input: Publication): Uint8Array;

package/dist/publication/publication.js

@@ -0,0 +1,133 @@
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+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 { 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 { 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';
+/** Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer. */
+export function url(input) {
+    const admitted = admitIssuer(input);
+    let value;
+    try {
+        value = new URL(admitted);
+    }
+    catch (cause) {
+        return fail('PUBLICATION_INVALID', 'Publication issuer is not an HTTP(S) URL.', cause);
+    }
+    if ((value.protocol !== 'https:' && value.protocol !== 'http:') ||
+        value.username !== '' ||
+        value.password !== '' ||
+        value.search !== '' ||
+        value.hash !== '') {
+        fail('PUBLICATION_INVALID', 'Publication issuer is not an HTTP(S) URL.');
+    }
+    return `${admitted.replace(/\/+$/u, '')}${PATH}`;
+}
+export function seal(input) {
+    return acceptPublication({ ...input, etag: computeEtag(input) }, false);
+}
+export function accept(input) {
+    const publication = acceptPublication(input, true);
+    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);
+}
+function acceptPublication(input, requireEtag) {
+    const value = record(input, 'PUBLICATION_INVALID', 'Expected a Publication object.');
+    exact(value, [
+        'format',
+        'version',
+        'origin',
+        'identity',
+        'etag',
+        'schema',
+        'requirements',
+        'manifest',
+        'bindings',
+        'routes',
+        'delivery',
+    ], 'PUBLICATION_INVALID');
+    if (value.format !== 'astrale.domain.publication' || value.version !== 2) {
+        fail('PUBLICATION_INVALID', 'Unsupported Publication format or version.');
+    }
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        fail('PUBLICATION_INVALID', 'Publication origin is invalid.');
+    }
+    const origin = value.origin;
+    const identity = record(value.identity, 'PUBLICATION_INVALID', 'Publication identity is invalid.');
+    exact(identity, ['issuer', 'subject'], 'PUBLICATION_INVALID');
+    const issuer = admitIssuer(identity.issuer);
+    if (identity.subject !== origin) {
+        fail('PUBLICATION_INVALID', 'Publication identity subject must equal its root origin.');
+    }
+    const publishedSchema = admitSchema(value.schema);
+    const 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));
+    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');
+    for (const callable of new Set(routes.map(({ callable }) => callable))) {
+        if (routes.filter((route) => route.callable === callable && route.default === true).length > 1) {
+            fail('PUBLICATION_ROUTE_INVALID', `Callable ${callable} has more than one default route.`);
+        }
+    }
+    if (manifest?.entrypoint !== undefined) {
+        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;
+    if (typeof admittedEtag !== 'string')
+        fail('PUBLICATION_INVALID', 'Publication ETag is missing.');
+    return deepFreeze({
+        format: 'astrale.domain.publication',
+        version: 2,
+        origin,
+        identity: { issuer, subject: origin },
+        etag: admittedEtag,
+        schema: publishedSchema,
+        requirements,
+        ...(manifest === undefined ? {} : { manifest }),
+        bindings: { callables, views },
+        routes,
+        ...(delivery === undefined ? {} : { delivery }),
+    });
+}
+function admitIssuer(input) {
+    try {
+        return acceptIssuerId(String(input));
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('PUBLICATION_INVALID', 'Publication issuer is invalid.', cause);
+        }
+        throw cause;
+    }
+}
+function withoutEtag(input) {
+    const { etag: _etag, ...content } = input;
+    return content;
+}

package/dist/publication/reference.d.ts

@@ -0,0 +1,17 @@
+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';
+/** Compact untrusted projection that witnesses one exact Publication. */
+export interface PublicationRef {
+    readonly origin: Key.Origin;
+    readonly identity: Publication['identity'];
+    readonly revision: Revision;
+    readonly etag: Etag;
+}
+export type PublicationReferenceRelation = 'exact' | 'same-schema' | 'schema-drift' | 'identity-drift' | 'origin-drift';
+export declare function reference(input: Publication): PublicationRef;
+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;

package/dist/publication/reference.js

@@ -0,0 +1,68 @@
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { deepFreeze, exact, record } from './content.js';
+import { fail } from './error.js';
+import { admitDigest } from './etag.js';
+export function reference(input) {
+    return deepFreeze({
+        origin: input.origin,
+        identity: { ...input.identity },
+        revision: input.schema.revision,
+        etag: input.etag,
+    });
+}
+export function acceptReference(input) {
+    const value = record(input, 'PUBLICATION_INVALID', 'Publication reference is invalid.');
+    exact(value, ['origin', 'identity', 'revision', 'etag'], 'PUBLICATION_INVALID');
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        fail('PUBLICATION_INVALID', 'Publication reference origin is invalid.');
+    }
+    const origin = value.origin;
+    const identity = record(value.identity, 'PUBLICATION_INVALID', 'Publication reference identity is invalid.');
+    exact(identity, ['issuer', 'subject'], 'PUBLICATION_INVALID');
+    const issuer = acceptIssuer(identity.issuer);
+    if (identity.subject !== origin) {
+        fail('PUBLICATION_INVALID', 'Publication reference subject must equal its root origin.');
+    }
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
+        fail('PUBLICATION_INVALID', 'Publication reference revision is invalid.');
+    }
+    return deepFreeze({
+        origin,
+        identity: { issuer, subject: origin },
+        revision: value.revision,
+        etag: admitDigest(value.etag),
+    });
+}
+export function compareReferences(input, expected) {
+    if (input.origin !== expected.origin)
+        return 'origin-drift';
+    if (input.identity.issuer !== expected.identity.issuer ||
+        input.identity.subject !== expected.identity.subject) {
+        return 'identity-drift';
+    }
+    if (input.revision !== expected.revision)
+        return 'schema-drift';
+    return input.etag === expected.etag ? 'exact' : 'same-schema';
+}
+export function compareReference(input, expected) {
+    return compareReferences(reference(input), expected);
+}
+export function matchesReference(input, expected) {
+    return compareReference(input, expected) === 'exact';
+}
+function acceptIssuer(input) {
+    if (typeof input !== 'string') {
+        fail('PUBLICATION_INVALID', 'Publication reference issuer is invalid.');
+    }
+    try {
+        return acceptIssuerId(input);
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('PUBLICATION_INVALID', 'Publication reference issuer is invalid.', cause);
+        }
+        throw cause;
+    }
+}

package/dist/publication/requirements.d.ts

@@ -0,0 +1,26 @@
+import type { AuthorityOperation } from '@astrale-os/kernel-core/schema/authority/operation';
+import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { ClassRef, 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: ClassRef;
+    readonly operations: NonEmpty<ClassOperation>;
+}
+export interface CapabilityAdminRequirements {
+    readonly grant?: NonEmpty<AuthorityOperation>;
+    readonly revoke?: NonEmpty<AuthorityOperation>;
+}
+export interface CapabilityRequirements {
+    readonly functions?: NonEmpty<SemanticKey.Callable>;
+    readonly classes?: NonEmpty<ClassCapabilityRequirement>;
+    readonly admin?: CapabilityAdminRequirements;
+}
+export interface PublicationRequirements {
+    readonly capabilities: CapabilityRequirements;
+}
+/** Admit the exact closed Publication v2 requirements object. */
+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;

package/dist/publication/requirements.js

@@ -0,0 +1,180 @@
+import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema/authority/operation';
+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([
+    'create',
+    'read',
+    'traverse',
+    'update',
+    'delete',
+]);
+/** Admit the exact closed Publication v2 requirements object. */
+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');
+    const functions = capabilities.functions === undefined
+        ? undefined
+        : nonEmpty(capabilities.functions, 'Function capability requirements').map(admitCallable);
+    if (functions !== undefined) {
+        unique(functions, 'PUBLICATION_INVALID', 'Function capability requirement');
+        canonical(functions, compare, 'Function capability requirements');
+    }
+    const classes = capabilities.classes === undefined
+        ? undefined
+        : nonEmpty(capabilities.classes, 'Class capability requirements').map(admitClassRequirement);
+    if (classes !== undefined) {
+        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);
+    return deepFreeze({
+        capabilities: {
+            ...(functions === undefined
+                ? {}
+                : { functions: Object.freeze(functions) }),
+            ...(classes === undefined
+                ? {}
+                : { classes: Object.freeze(classes) }),
+            ...(admin === undefined ? {} : { admin }),
+        },
+    });
+}
+/** 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');
+        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.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.');
+        }
+    }
+}
+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 Object.values(owner.dependencies)) {
+            const dependency = supplied.get(coordinate.origin);
+            if (dependency === undefined || revision(dependency) !== coordinate.revision) {
+                fail('PUBLICATION_INVALID', 'Publication Bundle omits an exact dependency.');
+            }
+            if (reachable.has(dependency.origin))
+                continue;
+            reachable.set(dependency.origin, dependency);
+            visit(dependency);
+        }
+    };
+    visit(root);
+    return reachable;
+}
+function admitCallable(input) {
+    if (typeof input !== 'string' || !Key.is(input)) {
+        return fail('PUBLICATION_INVALID', 'Function capability reference is invalid.');
+    }
+    try {
+        callableAddress(input);
+    }
+    catch {
+        return fail('PUBLICATION_INVALID', 'Function capability reference must name a Function or Method.');
+    }
+    return input;
+}
+function admitClassRequirement(input) {
+    const requirement = record(input, 'PUBLICATION_INVALID', 'Class capability requirement is invalid.');
+    exact(requirement, ['class', 'operations'], 'PUBLICATION_INVALID');
+    const operations = nonEmpty(requirement.operations, 'Class capability operations').map((entry) => admitOperation(entry, ClassOperationOrder, 'Class capability operation'));
+    unique(operations, 'PUBLICATION_INVALID', 'Class capability operation');
+    canonical(operations, ordered(ClassOperationOrder), 'Class capability operations');
+    return Object.freeze({
+        class: admitClassRef(requirement.class),
+        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.');
+    }
+    const grant = admitAuthorityOperations(admin.grant, 'grant');
+    const revoke = admitAuthorityOperations(admin.revoke, 'revoke');
+    return Object.freeze({
+        ...(grant === undefined ? {} : { grant }),
+        ...(revoke === undefined ? {} : { revoke }),
+    });
+}
+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`);
+    return Object.freeze(values);
+}
+function admitClassRef(input) {
+    let value;
+    try {
+        value = acceptDefinitionRef(input);
+    }
+    catch {
+        fail('PUBLICATION_INVALID', 'Class capability reference is invalid.');
+    }
+    if (value.kind !== 'class')
+        fail('PUBLICATION_INVALID', 'Class capability reference is invalid.');
+    return value;
+}
+function nonEmpty(input, label) {
+    const values = [...array(input, 'PUBLICATION_INVALID')];
+    if (values.length === 0)
+        fail('PUBLICATION_INVALID', `${label} cannot be empty.`);
+    return values;
+}
+function admitOperation(input, vocabulary, label) {
+    if (typeof input !== 'string' || !vocabulary.includes(input)) {
+        return fail('PUBLICATION_INVALID', `${label} is unknown.`);
+    }
+    return input;
+}
+function canonical(values, comparator, label) {
+    if (values.some((entry, index) => index > 0 && comparator(values[index - 1], entry) >= 0)) {
+        fail('PUBLICATION_INVALID', `${label} must be sorted canonically.`);
+    }
+}
+function ordered(order) {
+    return (left, right) => order.indexOf(left) - order.indexOf(right);
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function classKey(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.`);
+    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, 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';
+}

package/dist/publication/route.d.ts

@@ -0,0 +1,37 @@
+import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | '*';
+export type SingleCredentialSource = {
+    readonly in: 'header';
+    readonly name?: string;
+} | {
+    readonly in: 'cookie';
+    readonly name: string;
+} | {
+    readonly in: 'query';
+    readonly name: string;
+};
+export type CredentialSource = SingleCredentialSource | readonly [SingleCredentialSource, ...SingleCredentialSource[]];
+export type BodyPick = string | {
+    readonly as: 'text';
+};
+export type RouteBody = '*' | Readonly<Record<string, BodyPick>>;
+export type RouteHeaders = Readonly<Record<string, string | '*'>>;
+export interface HttpRoute {
+    readonly name: string;
+    readonly callable: Key.Callable;
+    readonly href: string;
+    readonly method: HttpMethod;
+    readonly requestMethod?: string;
+    readonly default?: true;
+    readonly receiver?: string;
+    readonly query?: Readonly<Record<string, string>>;
+    readonly headers?: RouteHeaders;
+    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;
+export declare function admitRouteDeclaration(input: unknown, origin: string): HttpRouteDeclaration;

package/dist/publication/route.js

@@ -0,0 +1,154 @@
+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',
+        location,
+        'method',
+        'requestMethod',
+        'default',
+        'receiver',
+        'query',
+        'headers',
+        'body',
+        'credential',
+    ], 'PUBLICATION_ROUTE_INVALID');
+    if (typeof value.name !== 'string' || !ROUTE_NAME.test(value.name)) {
+        fail('PUBLICATION_ROUTE_INVALID', 'Route name is invalid.');
+    }
+    const callable = admitCallableKey(value.callable, origin);
+    if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE', '*'].includes(value.method)) {
+        fail('PUBLICATION_ROUTE_INVALID', 'Route method is invalid.');
+    }
+    if (value.default !== undefined && value.default !== true) {
+        fail('PUBLICATION_ROUTE_INVALID', 'Route default may only be true.');
+    }
+    if (value.requestMethod !== undefined &&
+        (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' || !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 {
+        name: value.name,
+        callable,
+        method: value.method,
+        ...(value.requestMethod === undefined ? {} : { requestMethod: value.requestMethod }),
+        ...(value.default === true ? { default: true } : {}),
+        ...(value.receiver === undefined ? {} : { receiver: value.receiver }),
+        ...(query === undefined ? {} : { query }),
+        ...(headers === undefined ? {} : { headers }),
+        ...(body === undefined ? {} : { body }),
+        ...(credential === undefined ? {} : { credential }),
+    };
+}
+function admitCredential(input) {
+    if (input === undefined)
+        return undefined;
+    const values = Array.isArray(input) ? input : [input];
+    if (values.length === 0)
+        fail('PUBLICATION_ROUTE_INVALID', 'Credential source list is empty.');
+    const admitted = values.map((entry) => {
+        const value = record(entry, 'PUBLICATION_ROUTE_INVALID', 'Credential source is invalid.');
+        exact(value, ['in', 'name'], 'PUBLICATION_ROUTE_INVALID');
+        if (value.in === 'header') {
+            if (value.name !== undefined && (typeof value.name !== 'string' || value.name.length === 0)) {
+                fail('PUBLICATION_ROUTE_INVALID', 'Credential header name is invalid.');
+            }
+            return Object.freeze({
+                in: 'header',
+                ...(value.name === undefined ? {} : { name: value.name }),
+            });
+        }
+        if ((value.in === 'cookie' || value.in === 'query') &&
+            typeof value.name === 'string' &&
+            value.name.length > 0) {
+            return Object.freeze({ in: value.in, name: value.name });
+        }
+        return fail('PUBLICATION_ROUTE_INVALID', 'Credential source is invalid.');
+    });
+    return Array.isArray(input) ? Object.freeze(admitted) : admitted[0];
+}
+function admitBody(input) {
+    if (input === undefined || input === '*')
+        return input;
+    const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'Route body mapping is invalid.');
+    const output = {};
+    for (const [field, pick] of Object.entries(value)) {
+        if (typeof pick === 'string' && pick.length > 0)
+            output[field] = pick;
+        else if (pick !== null &&
+            typeof pick === 'object' &&
+            !Array.isArray(pick) &&
+            Object.keys(pick).length === 1 &&
+            pick.as === 'text') {
+            output[field] = { as: 'text' };
+        }
+        else {
+            fail('PUBLICATION_ROUTE_INVALID', 'Route body pick is invalid.');
+        }
+    }
+    return Object.freeze(output);
+}
+function headerRecord(input) {
+    if (input === undefined)
+        return undefined;
+    const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'Route header mapping is invalid.');
+    const output = {};
+    for (const [field, pick] of Object.entries(value)) {
+        if (typeof pick !== 'string' || pick.length === 0) {
+            fail('PUBLICATION_ROUTE_INVALID', 'Route header pick is invalid.');
+        }
+        output[field] = pick;
+    }
+    return Object.freeze(output);
+}
+function stringRecord(input) {
+    if (input === undefined)
+        return undefined;
+    const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'Route mapping is invalid.');
+    const output = {};
+    for (const [field, wire] of Object.entries(value)) {
+        if (typeof wire !== 'string' || wire.length === 0) {
+            fail('PUBLICATION_ROUTE_INVALID', 'Route wire name is invalid.');
+        }
+        output[field] = wire;
+    }
+    return Object.freeze(output);
+}

package/dist/publication/schema.d.ts

@@ -0,0 +1,7 @@
+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;