@astrale-os/kernel-protocol 0.5.0-beta.5 → 0.5.0-beta.51

package/dist/publication/bundle.js

@@ -1,9 +1,15 @@
-import { bundle, schema } from '@astrale-os/kernel-dsl/v1';
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
 import * as artifact from '../artifact/index.js';
 import { BUNDLE_MEDIA_TYPE } from './bundle-descriptor.js';
 import { verifyBundleBytes } from './bundle-evidence.js';
 import { absoluteHttpUrl } from './content.js';
 import { fail } from './error.js';
+import { url as publicationUrl } from './publication.js';
+/** Resolve immutable bundle bytes beneath the exact serving issuer. */
+export function bundleUrl(issuer, ref) {
+    const digest = ref.digest.slice('sha256:'.length);
+    return `${publicationUrl(issuer).slice(0, -'domain.json'.length)}bundles/sha256/${digest}.json`;
+}
 export function describeBundle(input, href) {
     const bytes = bundle.encode(input);
     return Object.freeze({
@@ -19,7 +25,7 @@ export function acceptBundleValue(input) {
         return bundle.accept(input);
     }
     catch (cause) {
-        if (cause instanceof schema.Error) {
+        if (cause instanceof bundle.Error) {
             return fail('PUBLICATION_INVALID', 'Publication bundle is invalid.', cause);
         }
         throw cause;
@@ -34,7 +40,7 @@ export function decodeBundleValue(publication, bytes) {
         return bundle.decode(bytes);
     }
     catch (cause) {
-        if (cause instanceof schema.Error) {
+        if (cause instanceof bundle.Error) {
             return fail('PUBLICATION_INVALID', 'Bundle artifact cannot be decoded.', cause);
         }
         throw cause;
@@ -42,4 +48,3 @@ export function decodeBundleValue(publication, bytes) {
 }
 export { verifyBundleBytes };
 export { admitBundleDescriptor, BUNDLE_MEDIA_TYPE, } from './bundle-descriptor.js';
-//# sourceMappingURL=bundle.js.map

package/dist/publication/content.d.ts

@@ -8,4 +8,3 @@ export declare function unique(values: readonly string[], code: PublicationError
 export declare function deepFreeze<T>(value: T): T;
 export declare function absoluteHttpUrl(input: unknown, allowSearch: boolean, code: PublicationErrorCode, allowTemplate?: boolean): string;
 export declare function absoluteUrl(input: unknown, protocols: readonly string[], allowSearch: boolean, code: PublicationErrorCode, allowTemplate?: boolean): string;
-//# sourceMappingURL=content.d.ts.map

package/dist/publication/content.js

@@ -53,4 +53,3 @@ export function absoluteUrl(input, protocols, allowSearch, code, allowTemplate =
     }
     return input;
 }
-//# sourceMappingURL=content.js.map

package/dist/publication/declaration.d.ts

@@ -9,4 +9,3 @@ export interface Declaration {
     readonly routes: readonly HttpRouteDeclaration[];
     readonly delivery?: DeliveryDeclaration;
 }
-//# sourceMappingURL=declaration.d.ts.map

package/dist/publication/declaration.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=declaration.js.map

package/dist/publication/delivery/attestation.d.ts

@@ -4,4 +4,3 @@ export type Attestation = string & {
 };
 export declare function acceptAttestation(input: unknown): Attestation;
 export {};
-//# sourceMappingURL=attestation.d.ts.map

package/dist/publication/delivery/attestation.js

@@ -8,4 +8,3 @@ export function acceptAttestation(input) {
     }
     return input;
 }
-//# sourceMappingURL=attestation.js.map

package/dist/publication/delivery/claims.d.ts

@@ -1,5 +1,5 @@
 import type { Subject } from '@astrale-os/kernel-core/auth/identity';
-import type { Revision } from '@astrale-os/kernel-dsl/v1/schema';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { Etag } from '../etag.js';
 import { PURPOSE } from './limits.js';
@@ -14,4 +14,3 @@ export interface Claims {
     readonly exp: number;
 }
 export declare function acceptClaims(input: unknown): Claims;
-//# sourceMappingURL=claims.d.ts.map

package/dist/publication/delivery/claims.js

@@ -59,4 +59,3 @@ function deepFreeze(value) {
         deepFreeze(nested);
     return Object.freeze(value);
 }
-//# sourceMappingURL=claims.js.map

package/dist/publication/delivery/delivery.d.ts

@@ -7,4 +7,3 @@ export interface Delivery {
     readonly attestation: Attestation;
 }
 export declare function accept(input: unknown): Delivery;
-//# sourceMappingURL=delivery.d.ts.map

package/dist/publication/delivery/delivery.js

@@ -27,4 +27,3 @@ function deepFreeze(value) {
         deepFreeze(nested);
     return Object.freeze(value);
 }
-//# sourceMappingURL=delivery.js.map

package/dist/publication/delivery/error.d.ts

@@ -5,4 +5,3 @@ export declare class DeliveryError extends Error {
     constructor(code: DeliveryErrorCode, message: string, options?: ErrorOptions);
 }
 export declare function fail(code: DeliveryErrorCode, message: string, cause?: unknown): never;
-//# sourceMappingURL=error.d.ts.map

package/dist/publication/delivery/error.js

@@ -9,4 +9,3 @@ export class DeliveryError extends Error {
 export function fail(code, message, cause) {
     throw new DeliveryError(code, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=error.js.map

package/dist/publication/delivery/index.d.ts

@@ -4,4 +4,3 @@ export { DeliveryError as Error, type DeliveryErrorCode as ErrorCode } from './e
 export { accept, type Delivery } from './delivery.js';
 export { ATTESTATION_MAX_BYTES, NONCE_MAX_LENGTH, NONCE_MIN_LENGTH, PURPOSE } from './limits.js';
 export { acceptRequest, type Token, type Request } from './request.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/publication/delivery/index.js

@@ -4,4 +4,3 @@ export { DeliveryError as Error } from './error.js';
 export { accept } from './delivery.js';
 export { ATTESTATION_MAX_BYTES, NONCE_MAX_LENGTH, NONCE_MIN_LENGTH, PURPOSE } from './limits.js';
 export { acceptRequest } from './request.js';
-//# sourceMappingURL=index.js.map

package/dist/publication/delivery/limits.d.ts

@@ -2,4 +2,3 @@ export declare const PURPOSE: 'astrale.domain.delivery.v1';
 export declare const NONCE_MIN_LENGTH = 16;
 export declare const NONCE_MAX_LENGTH = 256;
 export declare const ATTESTATION_MAX_BYTES = 16384;
-//# sourceMappingURL=limits.d.ts.map

package/dist/publication/delivery/limits.js

@@ -2,4 +2,3 @@ export const PURPOSE = 'astrale.domain.delivery.v1';
 export const NONCE_MIN_LENGTH = 16;
 export const NONCE_MAX_LENGTH = 256;
 export const ATTESTATION_MAX_BYTES = 16_384;
-//# sourceMappingURL=limits.js.map

package/dist/publication/delivery/request.d.ts

@@ -13,4 +13,3 @@ export interface Token {
 }
 /** Admit the exact request representation accepted by a Delivery transport boundary. */
 export declare function acceptRequest(input: unknown): Request;
-//# sourceMappingURL=request.d.ts.map

package/dist/publication/delivery/request.js

@@ -50,4 +50,3 @@ export function acceptRequest(input) {
         etag: value.etag,
     });
 }
-//# sourceMappingURL=request.js.map

package/dist/publication/delivery-declaration.d.ts

@@ -2,4 +2,3 @@ import type { DeliveryDeclaration } from './declaration.js';
 import type { Endpoint } from './delivery-endpoint.js';
 /** Place one provider-neutral Delivery declaration beneath an exact serving issuer. */
 export declare function placeDelivery(input: DeliveryDeclaration, issuer: string, bundleHref: string): Endpoint;
-//# sourceMappingURL=delivery-declaration.d.ts.map

package/dist/publication/delivery-declaration.js

@@ -23,4 +23,3 @@ export function placeDelivery(input, issuer, bundleHref) {
     }
     return admitEndpoint({ href, method: 'POST', authentication: input.authentication }, bundleHref);
 }
-//# sourceMappingURL=delivery-declaration.js.map

package/dist/publication/delivery-endpoint.d.ts

@@ -9,4 +9,3 @@ export interface Endpoint {
     readonly authentication: Authentication;
 }
 export declare function admitEndpoint(input: unknown, publicUrl: string): Endpoint | undefined;
-//# sourceMappingURL=delivery-endpoint.d.ts.map

package/dist/publication/delivery-endpoint.js

@@ -20,4 +20,3 @@ export function admitEndpoint(input, publicUrl) {
         authentication: Object.freeze({ kind: authentication.kind }),
     });
 }
-//# sourceMappingURL=delivery-endpoint.js.map

package/dist/publication/error.d.ts

@@ -5,4 +5,3 @@ export declare class PublicationError extends Error {
     constructor(code: PublicationErrorCode, message: string, options?: ErrorOptions);
 }
 export declare function fail(code: PublicationErrorCode, message: string, cause?: unknown): never;
-//# sourceMappingURL=error.d.ts.map

package/dist/publication/error.js

@@ -9,4 +9,3 @@ export class PublicationError extends Error {
 export function fail(code, message, cause) {
     throw new PublicationError(code, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=error.js.map

package/dist/publication/etag.d.ts

@@ -4,4 +4,3 @@ export type Etag = Sha256Digest;
 export declare function admitDigest(input: unknown): Sha256Digest;
 export declare function computeEtag(input: Content): Etag;
 export declare function sha256Hex(input: Uint8Array): string;
-//# sourceMappingURL=etag.d.ts.map

package/dist/publication/etag.js

@@ -1,5 +1,6 @@
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { fail } from './error.js';
+import { encodeLegacyRequirements } from './legacy-requirements.js';
 const DIGEST = /^sha256:[0-9a-f]{64}$/u;
 export function admitDigest(input) {
     if (typeof input !== 'string' || !DIGEST.test(input)) {
@@ -8,7 +9,10 @@ export function admitDigest(input) {
     return input;
 }
 export function computeEtag(input) {
-    const bytes = portable.json.encode(input);
+    const wire = input.version === 2
+        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
+        : input;
+    const bytes = portable.json.encode(wire);
     return `sha256:${sha256Hex(bytes)}`;
 }
 export function sha256Hex(input) {
@@ -77,4 +81,3 @@ const ROUND = new Uint32Array([
     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
 ]);
-//# sourceMappingURL=etag.js.map

package/dist/publication/index.d.ts

@@ -1,6 +1,6 @@
-export { MEDIA_TYPE, PATH, url, seal, accept, encode, type Publication } from './publication.js';
+export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, PATH, url, seal, accept, encode, type Publication, } from './publication.js';
 export { acceptBundle, decodeBundle } from './bundle-admission.js';
-export { BUNDLE_MEDIA_TYPE, describeBundle, type BundleDescriptor } from './bundle.js';
+export { BUNDLE_MEDIA_TYPE, bundleUrl, describeBundle, type BundleDescriptor } from './bundle.js';
 export { verifyBundleBytes } from './bundle-evidence.js';
 export type { Content } from './content.js';
 export type { Declaration, DeliveryDeclaration } from './declaration.js';
@@ -10,9 +10,8 @@ export { PublicationError, type PublicationErrorCode } from './error.js';
 export * as delivery from './delivery/index.js';
 export type { Authentication as DeliveryAuthentication, Endpoint as DeliveryEndpoint, } from './delivery-endpoint.js';
 export type { Manifest } from './manifest.js';
-export { ClassOperationOrder, admitRequirements, validateRequirements, type CapabilityAdminRequirements, type CapabilityRequirements, type ClassCapabilityRequirement, type ClassOperation, type NonEmpty, type PublicationRequirements, } from './requirements.js';
+export { ClassOperationOrder, admitRequirements, validateRequirements, type CapabilityAuthorityRequirements, type CoreCapabilityRequirement, type CapabilityRequirements, type ClassCapabilityRequirement, type ClassOperation, type NonEmpty, type PublicationRequirements, } from './requirements.js';
 export { acceptReference, compareReference, compareReferences, matchesReference, reference, type PublicationRef, type PublicationReferenceRelation, } from './reference.js';
 export type { BodyPick, CredentialSource, HttpMethod, HttpRoute, HttpRouteDeclaration, RouteBody, RouteHeaders, SingleCredentialSource, } from './route.js';
 export type { Schema } from './schema.js';
-export { acceptInvocationEndpoints, type CallableBinding, type InvocationEndpoints, type ViewBinding, } from './bindings/index.js';
-//# sourceMappingURL=index.d.ts.map
+export { acceptInvocationEndpoints, type CallableBinding, type IframeRequirements, type InvocationEndpoints, type ViewBinding, } from './bindings/index.js';

package/dist/publication/index.js

@@ -1,6 +1,6 @@
-export { MEDIA_TYPE, PATH, url, seal, accept, encode } from './publication.js';
+export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, PATH, url, seal, accept, encode, } from './publication.js';
 export { acceptBundle, decodeBundle } from './bundle-admission.js';
-export { BUNDLE_MEDIA_TYPE, describeBundle } from './bundle.js';
+export { BUNDLE_MEDIA_TYPE, bundleUrl, describeBundle } from './bundle.js';
 export { verifyBundleBytes } from './bundle-evidence.js';
 export { placeDelivery } from './delivery-declaration.js';
 export { PublicationError } from './error.js';
@@ -8,4 +8,3 @@ export * as delivery from './delivery/index.js';
 export { ClassOperationOrder, admitRequirements, validateRequirements, } from './requirements.js';
 export { acceptReference, compareReference, compareReferences, matchesReference, reference, } from './reference.js';
 export { acceptInvocationEndpoints, } from './bindings/index.js';
-//# sourceMappingURL=index.js.map

package/dist/publication/legacy-requirements.d.ts

@@ -0,0 +1,12 @@
+import type { PublicationRequirements } from './requirements.js';
+/** Read the retired v2 wire coordinate without exposing it in canonical requirements. */
+export declare function decodeLegacyRequirements(input: unknown): PublicationRequirements;
+/** Preserve immutable v2 bytes and the historical installation-target digest vocabulary. */
+export declare function encodeLegacyRequirements(input: PublicationRequirements): Readonly<{
+    capabilities: Readonly<{
+        functions?: import("./requirements.js").NonEmpty<import("@astrale-os/kernel-dsl/v1").Key.Callable>;
+        classes?: import("./requirements.js").NonEmpty<import("./requirements.js").ClassCapabilityRequirement>;
+        authority?: import("./requirements.js").CapabilityAuthorityRequirements;
+        profiles?: import("./requirements.js").NonEmpty<import("./requirements.js").CoreCapabilityRequirement> | undefined;
+    }>;
+}>;

package/dist/publication/legacy-requirements.js

@@ -0,0 +1,23 @@
+import { exact, record } from './content.js';
+import { admitRequirements } from './requirements.js';
+/** Read the retired v2 wire coordinate without exposing it in canonical requirements. */
+export function decodeLegacyRequirements(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, ['authority', 'classes', 'functions', 'profiles'], 'PUBLICATION_INVALID');
+    const { profiles, ...principal } = capabilities;
+    return admitRequirements({
+        capabilities: { ...principal, ...(profiles === undefined ? {} : { core: profiles }) },
+    });
+}
+/** Preserve immutable v2 bytes and the historical installation-target digest vocabulary. */
+export function encodeLegacyRequirements(input) {
+    const { core, ...principal } = input.capabilities;
+    return Object.freeze({
+        capabilities: Object.freeze({
+            ...principal,
+            ...(core === undefined ? {} : { profiles: core }),
+        }),
+    });
+}

package/dist/publication/manifest.d.ts

@@ -1,7 +1,6 @@
-import { Ref } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type ViewRef } from '@astrale-os/kernel-dsl/v1/addressing';
 export interface Manifest {
     readonly logo?: string;
-    readonly entrypoint?: Ref.View;
+    readonly entrypoint?: ViewRef;
 }
 export declare function admitManifest(input: unknown): Manifest | undefined;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/publication/manifest.js

@@ -1,4 +1,4 @@
-import { Ref } from '@astrale-os/kernel-dsl/v1/addressing';
+import { acceptDefinitionRef } from '@astrale-os/kernel-dsl/v1/addressing';
 import { exact, record } from './content.js';
 import { fail } from './error.js';
 export function admitManifest(input) {
@@ -11,16 +11,20 @@ export function admitManifest(input) {
     }
     let entrypoint;
     if (value.entrypoint !== undefined) {
-        if (typeof value.entrypoint !== 'string' ||
-            !Ref.isDefinition(value.entrypoint) ||
-            !value.entrypoint.startsWith('view.')) {
+        let ref;
+        try {
+            ref = acceptDefinitionRef(value.entrypoint);
+        }
+        catch (cause) {
+            return fail('PUBLICATION_INVALID', 'Manifest entrypoint must be a root View reference.', cause);
+        }
+        if (ref.kind !== 'view') {
             fail('PUBLICATION_INVALID', 'Manifest entrypoint must be a root View reference.');
         }
-        entrypoint = value.entrypoint;
+        entrypoint = ref;
     }
     return Object.freeze({
         ...(value.logo === undefined ? {} : { logo: value.logo }),
         ...(entrypoint === undefined ? {} : { entrypoint }),
     });
 }
-//# sourceMappingURL=manifest.js.map

package/dist/publication/publication.d.ts

@@ -9,12 +9,14 @@ 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';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=3';
+export declare const LEGACY_MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=2';
+export declare function mediaType(input: Pick<Publication, 'version'>): typeof MEDIA_TYPE | typeof LEGACY_MEDIA_TYPE;
 /** 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 version: 2 | 3;
     readonly origin: Key.Origin;
     readonly identity: {
         readonly issuer: IssuerId;
@@ -34,4 +36,3 @@ export interface Publication {
 export declare function seal(input: Content): Publication;
 export declare function accept(input: unknown): Publication;
 export declare function encode(input: Publication): Uint8Array;
-//# sourceMappingURL=publication.d.ts.map

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;