@astrale-os/kernel-protocol 0.5.0-beta.8 → 0.5.0

package/dist/release/requirements.js

@@ -0,0 +1,306 @@
+import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema/authority/operation';
+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 { fail } from './error.js';
+import { array, deepFreeze, exact, record, unique } from './shape.js';
+const KernelIdentityClass = Object.freeze({
+    origin: 'kernel.astrale.ai',
+    kind: 'class',
+    name: 'Identity',
+});
+export const ClassOperationOrder = Object.freeze([
+    'create',
+    'read',
+    'traverse',
+    'update',
+    'delete',
+]);
+/**
+ * Admit the exact closed canonical Release requirements object.
+ */
+export function admitRequirements(input) {
+    const requirements = record(input, 'RELEASE_INVALID', 'Release requirements are invalid.');
+    exact(requirements, ['capabilities'], 'RELEASE_INVALID');
+    const capabilities = record(requirements.capabilities, 'RELEASE_INVALID', 'Release capability requirements are invalid.');
+    exact(capabilities, ['authority', 'classes', 'functions', 'core'], 'RELEASE_INVALID');
+    const functions = capabilities.functions === undefined
+        ? undefined
+        : nonEmpty(capabilities.functions, 'Function capability requirements').map(admitCallable);
+    if (functions !== undefined) {
+        unique(functions, 'RELEASE_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)), 'RELEASE_INVALID', 'Class capability requirement');
+        canonical(classes, (left, right) => compare(classKey(left.class), classKey(right.class)), 'Class capability requirements');
+    }
+    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)), 'RELEASE_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
+                ? {}
+                : { functions: Object.freeze(functions) }),
+            ...(classes === undefined
+                ? {}
+                : { classes: Object.freeze(classes) }),
+            ...(authority === undefined ? {} : { authority }),
+            ...(core === undefined
+                ? {}
+                : { core: Object.freeze(core) }),
+        },
+    });
+}
+function admitCoreCapabilityRequirement(input) {
+    const requirement = record(input, 'RELEASE_INVALID', 'Core capability requirement is invalid.');
+    exact(requirement, ['authority', 'classes', 'functions', 'subject'], 'RELEASE_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, 'RELEASE_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)), 'RELEASE_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('RELEASE_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');
+        if (!hasCallable(dependency, callable)) {
+            fail('RELEASE_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('RELEASE_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('RELEASE_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('RELEASE_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('RELEASE_INVALID', 'Core capability Class requirement names an unknown dependency Class.');
+            }
+        }
+    }
+}
+/**
+ * Distinct Function, Method and Class Keys, including Core-scoped targets, in code-unit order.
+ * Core subjects and authority operations contribute no Keys. Results may span multiple origins.
+ */
+export function capabilityKeys(capabilities) {
+    const keys = new Set(capabilities.functions);
+    for (const requirement of capabilities.classes ?? [])
+        keys.add(Key.of(requirement.class));
+    for (const requirement of capabilities.core ?? []) {
+        for (const callable of requirement.functions ?? [])
+            keys.add(callable);
+        for (const classRequirement of requirement.classes ?? []) {
+            keys.add(Key.of(classRequirement.class));
+        }
+    }
+    return Object.freeze([...keys].sort(compare));
+}
+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 Object.values(owner.dependencies)) {
+            const dependency = supplied.get(coordinate.origin);
+            if (dependency === undefined || revision(dependency) !== coordinate.revision) {
+                fail('RELEASE_INVALID', 'Release 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('RELEASE_INVALID', 'Function capability reference is invalid.');
+    }
+    try {
+        callableAddress(input);
+    }
+    catch {
+        return fail('RELEASE_INVALID', 'Function capability reference must name a Function or Method.');
+    }
+    return input;
+}
+function admitClassRequirement(input) {
+    const requirement = record(input, 'RELEASE_INVALID', 'Class capability requirement is invalid.');
+    exact(requirement, ['class', 'operations'], 'RELEASE_INVALID');
+    const operations = nonEmpty(requirement.operations, 'Class capability operations').map((entry) => admitOperation(entry, ClassOperationOrder, 'Class capability operation'));
+    unique(operations, 'RELEASE_INVALID', 'Class capability operation');
+    canonical(operations, ordered(ClassOperationOrder), 'Class capability operations');
+    return Object.freeze({
+        class: admitClassRef(requirement.class),
+        operations: Object.freeze(operations),
+    });
+}
+function admitAuthorityRequirements(input) {
+    const authority = record(input, 'RELEASE_INVALID', 'Authority capability requirements are invalid.');
+    exact(authority, ['grant', 'revoke'], 'RELEASE_INVALID');
+    if (authority.grant === undefined && authority.revoke === undefined) {
+        fail('RELEASE_INVALID', 'Authority capability requirements cannot be empty.');
+    }
+    const grant = admitAuthorityOperations(authority.grant, 'grant');
+    const revoke = admitAuthorityOperations(authority.revoke, 'revoke');
+    return Object.freeze({
+        ...(grant === undefined ? {} : { grant }),
+        ...(revoke === undefined ? {} : { revoke }),
+    });
+}
+function admitAuthorityOperations(input, kind) {
+    if (input === undefined)
+        return undefined;
+    const values = nonEmpty(input, `Authority ${kind} operations`).map((entry) => admitOperation(entry, AuthorityOperationOrder, `Authority ${kind} operation`));
+    unique(values, 'RELEASE_INVALID', `authority ${kind} operation`);
+    canonical(values, ordered(AuthorityOperationOrder), `Authority ${kind} operations`);
+    return Object.freeze(values);
+}
+function admitClassRef(input) {
+    let value;
+    try {
+        value = acceptDefinitionRef(input);
+    }
+    catch {
+        fail('RELEASE_INVALID', 'Class capability reference is invalid.');
+    }
+    if (value.kind !== 'class')
+        fail('RELEASE_INVALID', 'Class capability reference is invalid.');
+    return value;
+}
+function admitCoreRef(input) {
+    let value;
+    try {
+        value = acceptDefinitionRef(input);
+    }
+    catch {
+        fail('RELEASE_INVALID', 'Core capability subject is invalid.');
+    }
+    if (value.kind !== 'core') {
+        fail('RELEASE_INVALID', 'Core capability subject must be one local Core reference.');
+    }
+    return value;
+}
+function nonEmpty(input, label) {
+    const values = [...array(input, 'RELEASE_INVALID')];
+    if (values.length === 0)
+        fail('RELEASE_INVALID', `${label} cannot be empty.`);
+    return values;
+}
+function admitOperation(input, vocabulary, label) {
+    if (typeof input !== 'string' || !vocabulary.includes(input)) {
+        return fail('RELEASE_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('RELEASE_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('RELEASE_INVALID', `${label} capability target cannot be local.`);
+    const dependency = dependencies.get(origin);
+    if (dependency === undefined) {
+        fail('RELEASE_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 && isMethodExecutable(declaration, method);
+}

package/dist/{publication → release}/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 → release}/route.js

@@ -1,31 +1,31 @@
 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';
+import { absoluteHttpUrl, deepFreeze, exact, record } from './shape.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 value = record(input, 'RELEASE_ROUTE_INVALID', 'Release HTTP route is invalid.');
     const common = admitRouteCommon(value, origin, 'href');
     return deepFreeze({
         ...common,
-        href: absoluteHttpUrl(value.href, false, 'PUBLICATION_ROUTE_INVALID', true),
+        href: absoluteHttpUrl(value.href, false, 'RELEASE_ROUTE_INVALID', true),
     });
 }
 export function admitRouteDeclaration(input, origin) {
-    const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'HTTP route declaration is invalid.');
+    const value = record(input, 'RELEASE_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.');
+        fail('RELEASE_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);
+        return fail('RELEASE_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.');
+        fail('RELEASE_ROUTE_INVALID', 'Route declaration path cannot select an origin, query, or fragment.');
     }
     return deepFreeze({ ...common, path: value.path });
 }
@@ -42,24 +42,24 @@ function admitRouteCommon(value, origin, location) {
         'headers',
         'body',
         'credential',
-    ], 'PUBLICATION_ROUTE_INVALID');
+    ], 'RELEASE_ROUTE_INVALID');
     if (typeof value.name !== 'string' || !ROUTE_NAME.test(value.name)) {
-        fail('PUBLICATION_ROUTE_INVALID', 'Route name is invalid.');
+        fail('RELEASE_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.');
+        fail('RELEASE_ROUTE_INVALID', 'Route method is invalid.');
     }
     if (value.default !== undefined && value.default !== true) {
-        fail('PUBLICATION_ROUTE_INVALID', 'Route default may only be true.');
+        fail('RELEASE_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.');
+        fail('RELEASE_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.');
+        fail('RELEASE_ROUTE_INVALID', 'Route receiver is invalid.');
     }
     const query = stringRecord(value.query);
     const headers = headerRecord(value.headers);
@@ -83,13 +83,13 @@ function admitCredential(input) {
         return undefined;
     const values = Array.isArray(input) ? input : [input];
     if (values.length === 0)
-        fail('PUBLICATION_ROUTE_INVALID', 'Credential source list is empty.');
+        fail('RELEASE_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');
+        const value = record(entry, 'RELEASE_ROUTE_INVALID', 'Credential source is invalid.');
+        exact(value, ['in', 'name'], 'RELEASE_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.');
+                fail('RELEASE_ROUTE_INVALID', 'Credential header name is invalid.');
             }
             return Object.freeze({
                 in: 'header',
@@ -101,14 +101,14 @@ function admitCredential(input) {
             value.name.length > 0) {
             return Object.freeze({ in: value.in, name: value.name });
         }
-        return fail('PUBLICATION_ROUTE_INVALID', 'Credential source is invalid.');
+        return fail('RELEASE_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 value = record(input, 'RELEASE_ROUTE_INVALID', 'Route body mapping is invalid.');
     const output = {};
     for (const [field, pick] of Object.entries(value)) {
         if (typeof pick === 'string' && pick.length > 0)
@@ -121,7 +121,7 @@ function admitBody(input) {
             output[field] = { as: 'text' };
         }
         else {
-            fail('PUBLICATION_ROUTE_INVALID', 'Route body pick is invalid.');
+            fail('RELEASE_ROUTE_INVALID', 'Route body pick is invalid.');
         }
     }
     return Object.freeze(output);
@@ -129,11 +129,11 @@ function admitBody(input) {
 function headerRecord(input) {
     if (input === undefined)
         return undefined;
-    const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'Route header mapping is invalid.');
+    const value = record(input, 'RELEASE_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.');
+            fail('RELEASE_ROUTE_INVALID', 'Route header pick is invalid.');
         }
         output[field] = pick;
     }
@@ -142,14 +142,13 @@ function headerRecord(input) {
 function stringRecord(input) {
     if (input === undefined)
         return undefined;
-    const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'Route mapping is invalid.');
+    const value = record(input, 'RELEASE_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.');
+            fail('RELEASE_ROUTE_INVALID', 'Route wire name is invalid.');
         }
         output[field] = wire;
     }
     return Object.freeze(output);
 }
-//# sourceMappingURL=route.js.map

package/dist/{publication → release}/schema.d.ts

@@ -5,4 +5,3 @@ export interface Schema {
     readonly bundle: BundleDescriptor;
 }
 export declare function admitSchema(input: unknown): Schema;
-//# sourceMappingURL=schema.d.ts.map

package/dist/{publication → release}/schema.js

@@ -1,16 +1,15 @@
 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';
+import { exact, record } from './shape.js';
 export function admitSchema(input) {
-    const value = record(input, 'PUBLICATION_INVALID', 'Published schema is invalid.');
-    exact(value, ['revision', 'bundle'], 'PUBLICATION_INVALID');
+    const value = record(input, 'RELEASE_INVALID', 'Release schema is invalid.');
+    exact(value, ['revision', 'bundle'], 'RELEASE_INVALID');
     if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
-        fail('PUBLICATION_INVALID', 'Published schema revision is invalid.');
+        fail('RELEASE_INVALID', 'Release schema revision is invalid.');
     }
     return Object.freeze({
         revision: value.revision,
         bundle: admitBundleDescriptor(value.bundle),
     });
 }
-//# sourceMappingURL=schema.js.map

package/dist/release/served.d.ts

@@ -0,0 +1,27 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { ServedRelease } from './bundle-admission.js';
+import type { Endpoint as DeliveryEndpoint } from './delivery-endpoint.js';
+import type { Requirements } from './requirements.js';
+/**
+ * Everything a served release document carries besides its format, version, digest and build:
+ * the content a bundle must match, the serving identity, and the optional Delivery endpoint.
+ */
+export interface ServedContent extends ServedRelease {
+    readonly identity: {
+        readonly issuer: IssuerId;
+        readonly subject: string;
+    };
+    readonly delivery?: DeliveryEndpoint;
+}
+interface ServedOptions {
+    /** `canonicalize` normalizes authored View bindings before sealing; `admit` requires canonical ones. */
+    readonly views: 'canonicalize' | 'admit';
+    /** Reads the requirements coordinate of the document version; canonical `core` by default. */
+    readonly requirements?: (input: unknown) => Requirements;
+}
+/**
+ * Admit the version-neutral content of one served release document. Every document version runs
+ * these checks in this order, so a document of any version admits exactly the same served content.
+ */
+export declare function admitServedContent(value: Readonly<Record<string, unknown>>, options: ServedOptions): ServedContent;
+export {};

package/dist/release/served.js

@@ -0,0 +1,56 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { admitCallableBinding, admitViewBinding } from './bindings/index.js';
+import { canonicalizeViewBinding } from './bindings/view.js';
+import { admitEndpoint as admitDeliveryEndpoint } from './delivery-endpoint.js';
+import { fail } from './error.js';
+import { admitIssuer } from './issuer.js';
+import { admitManifest } from './manifest.js';
+import { admitRequirements } from './requirements.js';
+import { admitRoute } from './route.js';
+import { admitSchema } from './schema.js';
+import { array, exact, record, unique } from './shape.js';
+/**
+ * Admit the version-neutral content of one served release document. Every document version runs
+ * these checks in this order, so a document of any version admits exactly the same served content.
+ */
+export function admitServedContent(value, options) {
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        fail('RELEASE_INVALID', 'Release origin is invalid.');
+    }
+    const origin = value.origin;
+    const identity = record(value.identity, 'RELEASE_INVALID', 'Release identity is invalid.');
+    exact(identity, ['issuer', 'subject'], 'RELEASE_INVALID');
+    const issuer = admitIssuer(identity.issuer);
+    if (identity.subject !== origin) {
+        fail('RELEASE_INVALID', 'Release identity subject must equal its root origin.');
+    }
+    const schema = admitSchema(value.schema);
+    const requirements = (options.requirements ?? admitRequirements)(value.requirements);
+    const manifest = admitManifest(value.manifest);
+    const bindingSet = record(value.bindings, 'RELEASE_BINDING_INVALID', 'Release bindings are invalid.');
+    exact(bindingSet, ['callables', 'views'], 'RELEASE_BINDING_INVALID');
+    const callables = array(bindingSet.callables, 'RELEASE_BINDING_INVALID').map((entry) => admitCallableBinding(entry, origin));
+    unique(callables.map(({ callable }) => callable), 'RELEASE_BINDING_INVALID', 'callable binding');
+    const views = array(bindingSet.views, 'RELEASE_VIEW_INVALID').map((entry) => options.views === 'canonicalize'
+        ? canonicalizeViewBinding(entry, origin)
+        : admitViewBinding(entry, origin));
+    unique(views.map(({ view }) => view), 'RELEASE_VIEW_INVALID', 'View binding');
+    const routes = array(value.routes, 'RELEASE_ROUTE_INVALID').map((entry) => admitRoute(entry, origin));
+    unique(routes.map(({ name }) => name), 'RELEASE_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('RELEASE_ROUTE_INVALID', `Callable ${callable} has more than one default route.`);
+        }
+    }
+    const delivery = admitDeliveryEndpoint(value.delivery, schema.bundle.href);
+    return {
+        origin,
+        identity: { issuer, subject: origin },
+        schema,
+        requirements,
+        ...(manifest === undefined ? {} : { manifest }),
+        bindings: { callables, views },
+        routes,
+        ...(delivery === undefined ? {} : { delivery }),
+    };
+}

package/dist/release/shape.d.ts

@@ -0,0 +1,8 @@
+import type { ReleaseErrorCode } from './error.js';
+export declare function record(input: unknown, code: ReleaseErrorCode, message: string): Record<string, unknown>;
+export declare function exact(value: Record<string, unknown>, allowed: readonly string[], code: ReleaseErrorCode): void;
+export declare function array(input: unknown, code: ReleaseErrorCode): readonly unknown[];
+export declare function unique(values: readonly string[], code: ReleaseErrorCode, label: string): void;
+export declare function deepFreeze<T>(value: T): T;
+export declare function absoluteHttpUrl(input: unknown, allowSearch: boolean, code: ReleaseErrorCode, allowTemplate?: boolean): string;
+export declare function absoluteUrl(input: unknown, protocols: readonly string[], allowSearch: boolean, code: ReleaseErrorCode, allowTemplate?: boolean): string;

package/dist/{publication/content.js → release/shape.js}

@@ -53,4 +53,3 @@ export function absoluteUrl(input, protocols, allowSearch, code, allowTemplate =
     }
     return input;
 }
-//# sourceMappingURL=content.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. */
+/** Admit one emitted portable release Table before Server composition. */
 export declare function acceptTable(input: unknown): Table;
-//# sourceMappingURL=admission.d.ts.map