@astrale-os/kernel-protocol 0.5.0-beta.66 → 0.5.0-beta.68

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

@@ -2,18 +2,18 @@ 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';
+import { servedUrl } from './issuer.js';
+import { absoluteHttpUrl } from './shape.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`;
+    return servedUrl(issuer, `/.well-known/astrale/bundles/sha256/${digest}.json`);
 }
 export function describeBundle(input, href) {
     const bytes = bundle.encode(input);
     return Object.freeze({
-        href: absoluteHttpUrl(href, true, 'PUBLICATION_INVALID'),
+        href: absoluteHttpUrl(href, true, 'RELEASE_INVALID'),
         ref: Object.freeze({
             ...artifact.identify(bytes, BUNDLE_MEDIA_TYPE),
             mediaType: BUNDLE_MEDIA_TYPE,
@@ -26,22 +26,22 @@ export function acceptBundleValue(input) {
     }
     catch (cause) {
         if (cause instanceof bundle.Error) {
-            return fail('PUBLICATION_INVALID', 'Publication bundle is invalid.', cause);
+            return fail('RELEASE_INVALID', 'Release bundle is invalid.', cause);
         }
         throw cause;
     }
 }
-export function decodeBundleValue(publication, bytes) {
+export function decodeBundleValue(release, bytes) {
     if (!(bytes instanceof Uint8Array)) {
-        fail('PUBLICATION_INVALID', 'Bundle artifact bytes are invalid.');
+        fail('RELEASE_INVALID', 'Bundle artifact bytes are invalid.');
     }
-    verifyBundleBytes(publication, bytes);
+    verifyBundleBytes(release, bytes);
     try {
         return bundle.decode(bytes);
     }
     catch (cause) {
         if (cause instanceof bundle.Error) {
-            return fail('PUBLICATION_INVALID', 'Bundle artifact cannot be decoded.', cause);
+            return fail('RELEASE_INVALID', 'Bundle artifact cannot be decoded.', cause);
         }
         throw cause;
     }

package/dist/{publication → release}/delivery/attestation.d.ts

@@ -1,4 +1,5 @@
 declare const ATTESTATION: unique symbol;
+/** Opaque, bounded attestation text a Delivery carries; Core Auth verifies it. */
 export type Attestation = string & {
     readonly [ATTESTATION]: true;
 };

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

@@ -0,0 +1,21 @@
+import type { Subject } from '@astrale-os/kernel-core/auth/identity';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { ReleaseDigest } from '../digest.js';
+import { PURPOSE } from './limits.js';
+/**
+ * What a verified Delivery v2 attestation asserts: the serving Domain identity delivers the release
+ * with this digest and schema revision to the requesting Kernel, for its challenge nonce.
+ */
+export interface Claims {
+    readonly purpose: typeof PURPOSE;
+    readonly iss: IssuerId;
+    readonly sub: Subject;
+    readonly aud: IssuerId;
+    readonly nonce: string;
+    readonly release: ReleaseDigest;
+    readonly schemaRevision: Revision;
+    readonly exp: number;
+}
+/** Admit the claims of an attestation Core Auth already verified. */
+export declare function acceptClaims(input: unknown): Claims;

package/dist/release/delivery/claims.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 } from '../shape.js';
+import { fail } from './error.js';
+import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH, PURPOSE } from './limits.js';
+const FIELDS = [
+    'purpose',
+    'iss',
+    'sub',
+    'aud',
+    'nonce',
+    'release',
+    'schemaRevision',
+    'exp',
+];
+/** Admit the claims of an attestation Core Auth already verified. */
+export function acceptClaims(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Expected delivery claims.');
+    }
+    const value = input;
+    if (Object.keys(value).some((field) => !FIELDS.includes(field))) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims contain unknown fields.');
+    }
+    if (value.purpose !== PURPOSE ||
+        typeof value.sub !== 'string' ||
+        value.sub.length === 0 ||
+        typeof value.nonce !== 'string' ||
+        value.nonce.length < NONCE_MIN_LENGTH ||
+        value.nonce.length > NONCE_MAX_LENGTH ||
+        typeof value.exp !== 'number' ||
+        !Number.isSafeInteger(value.exp)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims are invalid.');
+    }
+    const iss = acceptIssuer(value.iss);
+    const aud = acceptIssuer(value.aud);
+    if (typeof value.release !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(value.release)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims release digest is invalid.');
+    }
+    if (typeof value.schemaRevision !== 'string' || !patterns.revision.test(value.schemaRevision)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Schema revision is invalid.');
+    }
+    return deepFreeze({
+        purpose: PURPOSE,
+        iss,
+        sub: value.sub,
+        aud,
+        nonce: value.nonce,
+        release: value.release,
+        schemaRevision: value.schemaRevision,
+        exp: value.exp,
+    });
+}
+function acceptIssuer(input) {
+    if (typeof input !== 'string') {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims issuer is invalid.');
+    }
+    try {
+        return acceptIssuerId(input);
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims issuer is invalid.', cause);
+        }
+        throw cause;
+    }
+}

package/dist/release/delivery/delivery.d.ts

@@ -0,0 +1,11 @@
+import type { DomainRelease } from '../release.js';
+import type { Attestation } from './attestation.js';
+/** The challenge-bound envelope carrying the exact `DomainRelease` a Kernel asked for. */
+export interface Delivery {
+    readonly format: 'astrale.domain.delivery';
+    readonly version: 2;
+    readonly release: DomainRelease;
+    readonly attestation: Attestation;
+}
+/** Admit one Delivery v2 envelope: its release is admitted whole, its attestation stays opaque. */
+export declare function accept(input: unknown): Delivery;

package/dist/release/delivery/delivery.js

@@ -0,0 +1,24 @@
+import { accept as acceptRelease } from '../release.js';
+import { deepFreeze } from '../shape.js';
+import { acceptAttestation } from './attestation.js';
+import { fail } from './error.js';
+/** Admit one Delivery v2 envelope: its release is admitted whole, its attestation stays opaque. */
+export function accept(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        fail('DELIVERY_INVALID', 'Expected a Delivery object.');
+    }
+    const value = input;
+    const expected = new Set(['format', 'version', 'release', 'attestation']);
+    if (Object.keys(value).some((field) => !expected.has(field))) {
+        fail('DELIVERY_INVALID', 'Delivery contains unknown fields.');
+    }
+    if (value.format !== 'astrale.domain.delivery' || value.version !== 2) {
+        fail('DELIVERY_INVALID', 'Unsupported Delivery format or version.');
+    }
+    return deepFreeze({
+        format: 'astrale.domain.delivery',
+        version: 2,
+        release: acceptRelease(value.release),
+        attestation: acceptAttestation(value.attestation),
+    });
+}

package/dist/{publication → release}/delivery/error.d.ts

@@ -1,4 +1,6 @@
+/** Failure code of a Delivery request, envelope, or claims set, whatever its version. */
 export type DeliveryErrorCode = 'DELIVERY_INVALID' | 'DELIVERY_REQUEST_INVALID' | 'DELIVERY_CLAIMS_INVALID';
+/** Reported by every Delivery decoder, v1 and v2. */
 export declare class DeliveryError extends Error {
     readonly code: DeliveryErrorCode;
     readonly name = "DeliveryError";

package/dist/{publication → release}/delivery/error.js

@@ -1,3 +1,4 @@
+/** Reported by every Delivery decoder, v1 and v2. */
 export class DeliveryError extends Error {
     code;
     name = 'DeliveryError';

package/dist/{publication → release}/delivery/index.d.ts

@@ -1,6 +1,11 @@
+/**
+ * Delivery v2: the challenge-bound envelope carrying the exact `DomainRelease` a Kernel fetched at
+ * `release.json`, bound to its release digest. `acceptRequest` also admits the deprecated v1 request,
+ * discriminated by its `version`.
+ */
 export { type Attestation } from './attestation.js';
 export { acceptClaims, type Claims } from './claims.js';
 export { DeliveryError as Error, type DeliveryErrorCode as ErrorCode } from './error.js';
 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';
+export { acceptRequest, type Request, type Token } from './request.js';

package/dist/{publication → release}/delivery/index.js

@@ -1,3 +1,8 @@
+/**
+ * Delivery v2: the challenge-bound envelope carrying the exact `DomainRelease` a Kernel fetched at
+ * `release.json`, bound to its release digest. `acceptRequest` also admits the deprecated v1 request,
+ * discriminated by its `version`.
+ */
 export {} from './attestation.js';
 export { acceptClaims } from './claims.js';
 export { DeliveryError as Error } from './error.js';

package/dist/{publication → release}/delivery/limits.d.ts

@@ -1,4 +1,5 @@
-export declare const PURPOSE: 'astrale.domain.delivery.v1';
+/** Purpose of Delivery v2 attestations, which bind a release digest. */
+export declare const PURPOSE: 'astrale.domain.delivery.v2';
 export declare const NONCE_MIN_LENGTH = 16;
 export declare const NONCE_MAX_LENGTH = 256;
 export declare const ATTESTATION_MAX_BYTES = 16384;

package/dist/release/delivery/limits.js

@@ -0,0 +1,5 @@
+/** Purpose of Delivery v2 attestations, which bind a release digest. */
+export const PURPOSE = 'astrale.domain.delivery.v2';
+export const NONCE_MIN_LENGTH = 16;
+export const NONCE_MAX_LENGTH = 256;
+export const ATTESTATION_MAX_BYTES = 16_384;

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

@@ -0,0 +1,21 @@
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { ReleaseDigest } from '../digest.js';
+import { type Request as PublicationRequest } from '../legacy/delivery/request.js';
+/** Exact bearer credential admitted by a Delivery transport boundary; never inside a document. */
+export interface Token {
+    readonly kind: 'bearer';
+    readonly token: string;
+}
+/** A requesting Kernel's challenge for the one exact release it fetched at `release.json`. */
+export interface Request {
+    readonly version: 2;
+    readonly kernel: IssuerId;
+    readonly nonce: string;
+    readonly release: ReleaseDigest;
+}
+/**
+ * Admit the exact request representation accepted by a Delivery transport boundary. The request's
+ * own `version` selects the Delivery version: 2 names a release digest, and the deprecated 1 names
+ * the ETag of a v2/v3 Publication fetched at `domain.json`.
+ */
+export declare function acceptRequest(input: unknown): Request | PublicationRequest;

package/dist/release/delivery/request.js

@@ -0,0 +1,60 @@
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
+import { acceptRequest as acceptPublicationRequest, } from '../legacy/delivery/request.js';
+import { fail } from './error.js';
+import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH } from './limits.js';
+const FIELDS = ['version', 'kernel', 'nonce', 'release'];
+/**
+ * Admit the exact request representation accepted by a Delivery transport boundary. The request's
+ * own `version` selects the Delivery version: 2 names a release digest, and the deprecated 1 names
+ * the ETag of a v2/v3 Publication fetched at `domain.json`.
+ */
+export function acceptRequest(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        fail('DELIVERY_REQUEST_INVALID', 'Expected a Delivery request.');
+    }
+    const version = Object.getOwnPropertyDescriptor(input, 'version');
+    if (version !== undefined && 'value' in version && version.value === 1) {
+        return acceptPublicationRequest(input);
+    }
+    const value = {};
+    const fields = Reflect.ownKeys(input);
+    if (fields.length !== FIELDS.length) {
+        fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
+    }
+    for (const field of fields) {
+        if (typeof field !== 'string' || !FIELDS.includes(field)) {
+            fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(input, field);
+        if (descriptor === undefined || !descriptor.enumerable || !('value' in descriptor)) {
+            fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
+        }
+        value[field] = descriptor.value;
+    }
+    if (value.version !== 2 ||
+        typeof value.kernel !== 'string' ||
+        typeof value.nonce !== 'string' ||
+        value.nonce.length < NONCE_MIN_LENGTH ||
+        value.nonce.length > NONCE_MAX_LENGTH ||
+        typeof value.release !== 'string' ||
+        !/^sha256:[0-9a-f]{64}$/u.test(value.release)) {
+        fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
+    }
+    let kernel;
+    try {
+        kernel = acceptIssuer(value.kernel);
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('DELIVERY_REQUEST_INVALID', 'Delivery request issuer is invalid.', cause);
+        }
+        throw cause;
+    }
+    return Object.freeze({
+        version: 2,
+        kernel,
+        nonce: value.nonce,
+        release: value.release,
+    });
+}

package/dist/{publication → release}/delivery-declaration.js

@@ -3,23 +3,23 @@ import { fail } from './error.js';
 /** Place one provider-neutral Delivery declaration beneath an exact serving issuer. */
 export function placeDelivery(input, issuer, bundleHref) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        fail('PUBLICATION_INVALID', 'Delivery declaration is invalid.');
+        fail('RELEASE_INVALID', 'Delivery declaration is invalid.');
     }
     if (Reflect.ownKeys(input).some((key) => key !== 'path' && key !== 'authentication') ||
         typeof input.path !== 'string' ||
         !input.path.startsWith('/')) {
-        fail('PUBLICATION_INVALID', 'Delivery declaration is invalid.');
+        fail('RELEASE_INVALID', 'Delivery declaration is invalid.');
     }
     let href;
     try {
         const url = new URL(input.path, issuer);
         if (url.origin !== new URL(issuer).origin || url.search !== '' || url.hash !== '') {
-            fail('PUBLICATION_INVALID', 'Delivery declaration must be one relative path.');
+            fail('RELEASE_INVALID', 'Delivery declaration must be one relative path.');
         }
         href = url.href;
     }
     catch (cause) {
-        return fail('PUBLICATION_INVALID', 'Delivery declaration path is invalid.', cause);
+        return fail('RELEASE_INVALID', 'Delivery declaration path is invalid.', cause);
     }
     return admitEndpoint({ href, method: 'POST', authentication: input.authentication }, bundleHref);
 }

package/dist/release/delivery-endpoint.js

@@ -0,0 +1,22 @@
+import { fail } from './error.js';
+import { absoluteHttpUrl, exact, record } from './shape.js';
+export function admitEndpoint(input, publicUrl) {
+    if (input === undefined)
+        return undefined;
+    const value = record(input, 'RELEASE_INVALID', 'Delivery endpoint is invalid.');
+    exact(value, ['href', 'method', 'authentication'], 'RELEASE_INVALID');
+    const href = absoluteHttpUrl(value.href, true, 'RELEASE_INVALID');
+    if (new URL(href).origin !== new URL(publicUrl).origin || value.method !== 'POST') {
+        fail('RELEASE_INVALID', 'Delivery endpoint must be same-origin POST.');
+    }
+    const authentication = record(value.authentication, 'RELEASE_INVALID', 'Delivery authentication is invalid.');
+    exact(authentication, ['kind'], 'RELEASE_INVALID');
+    if (authentication.kind !== 'public' && authentication.kind !== 'bearer') {
+        fail('RELEASE_INVALID', 'Delivery authentication kind is invalid.');
+    }
+    return Object.freeze({
+        href,
+        method: 'POST',
+        authentication: Object.freeze({ kind: authentication.kind }),
+    });
+}

package/dist/release/digest.d.ts

@@ -0,0 +1,13 @@
+export type Sha256Digest = `sha256:${string}`;
+/**
+ * Digest of one canonical `DomainRelease`: its build, its addresses and issuer, and through the
+ * address the variables frozen at deploy. One per deployment.
+ */
+export type ReleaseDigest = Sha256Digest;
+/**
+ * Hash of the bytes one build produced (modules, assets, schema, requirements). An address, key or
+ * secret never enters those bytes, so the same build has the same digest in every environment.
+ */
+export type BuildDigest = Sha256Digest;
+export declare function admitDigest(input: unknown): Sha256Digest;
+export declare function sha256Hex(input: Uint8Array): string;

package/dist/{publication/etag.js → release/digest.js}

@@ -1,20 +1,11 @@
-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)) {
-        fail('PUBLICATION_INVALID', 'Digest is invalid.');
+        fail('RELEASE_INVALID', 'Digest is invalid.');
     }
     return input;
 }
-export function computeEtag(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) {
     const bitLength = input.length * 8;
     const paddedLength = Math.ceil((input.length + 9) / 64) * 64;

package/dist/release/error.d.ts

@@ -0,0 +1,7 @@
+export type ReleaseErrorCode = 'RELEASE_INVALID' | 'RELEASE_DIGEST_MISMATCH' | 'RELEASE_BINDING_INVALID' | 'RELEASE_ROUTE_INVALID' | 'RELEASE_VIEW_INVALID';
+export declare class ReleaseError extends Error {
+    readonly code: ReleaseErrorCode;
+    readonly name = "ReleaseError";
+    constructor(code: ReleaseErrorCode, message: string, options?: ErrorOptions);
+}
+export declare function fail(code: ReleaseErrorCode, message: string, cause?: unknown): never;

package/dist/release/error.js

@@ -0,0 +1,11 @@
+export class ReleaseError extends Error {
+    code;
+    name = 'ReleaseError';
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+export function fail(code, message, cause) {
+    throw new ReleaseError(code, message, cause === undefined ? undefined : { cause });
+}

package/dist/release/index.d.ts

@@ -0,0 +1,21 @@
+export { MEDIA_TYPE, PATH, accept, digestOf, encode, seal, url, type Content, type DomainRelease, } from './release.js';
+export type { Build } from './build.js';
+export { acceptReference, compareReferences, matchesReference, reference, type ReleaseRef, type ReleaseReferenceRelation, } from './reference.js';
+export { acceptBundle, decodeBundle, type ServedRelease } from './bundle-admission.js';
+export { BUNDLE_MEDIA_TYPE, bundleUrl, describeBundle, type BundleDescriptor } from './bundle.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
+export type { Declaration, DeliveryDeclaration } from './declaration.js';
+export { placeDelivery } from './delivery-declaration.js';
+export type { Authentication as DeliveryAuthentication, Endpoint as DeliveryEndpoint, } from './delivery-endpoint.js';
+export type { BuildDigest, ReleaseDigest, Sha256Digest } from './digest.js';
+export { ReleaseError, type ReleaseErrorCode } from './error.js';
+export type { Manifest } from './manifest.js';
+export { ClassOperationOrder, admitRequirements, capabilityKeys, validateRequirements, type CapabilityAuthorityRequirements, type CoreCapabilityRequirement, type CapabilityRequirements, type ClassCapabilityRequirement, type ClassOperation, type NonEmpty, type Requirements, } from './requirements.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 IframeRequirements, type InvocationEndpoints, type ViewBinding, } from './bindings/index.js';
+export * as delivery from './delivery/index.js';
+/**
+ * @deprecated Publication v2/v3 compatibility surface; use `DomainRelease` v4 from this module.
+ */
+export * as legacy from './legacy/index.js';

package/dist/release/index.js

@@ -0,0 +1,14 @@
+export { MEDIA_TYPE, PATH, accept, digestOf, encode, seal, url, } from './release.js';
+export { acceptReference, compareReferences, matchesReference, reference, } from './reference.js';
+export { acceptBundle, decodeBundle } from './bundle-admission.js';
+export { BUNDLE_MEDIA_TYPE, bundleUrl, describeBundle } from './bundle.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
+export { placeDelivery } from './delivery-declaration.js';
+export { ReleaseError } from './error.js';
+export { ClassOperationOrder, admitRequirements, capabilityKeys, validateRequirements, } from './requirements.js';
+export { acceptInvocationEndpoints, } from './bindings/index.js';
+export * as delivery from './delivery/index.js';
+/**
+ * @deprecated Publication v2/v3 compatibility surface; use `DomainRelease` v4 from this module.
+ */
+export * as legacy from './legacy/index.js';

package/dist/release/issuer.d.ts

@@ -0,0 +1,5 @@
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+/** Admit the exact serving issuer a served release document names. */
+export declare function admitIssuer(input: unknown): IssuerId;
+/** Resolve one served path beneath one exact HTTP(S) serving issuer, keeping its complete path. */
+export declare function servedUrl(issuer: string, path: `/${string}`): string;

package/dist/release/issuer.js

@@ -0,0 +1,34 @@
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import { fail } from './error.js';
+/** Admit the exact serving issuer a served release document names. */
+export function admitIssuer(input) {
+    try {
+        return acceptIssuerId(String(input));
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('RELEASE_INVALID', 'Release issuer is invalid.', cause);
+        }
+        throw cause;
+    }
+}
+/** Resolve one served path beneath one exact HTTP(S) serving issuer, keeping its complete path. */
+export function servedUrl(issuer, path) {
+    const admitted = admitIssuer(issuer);
+    let value;
+    try {
+        value = new URL(admitted);
+    }
+    catch (cause) {
+        return fail('RELEASE_INVALID', 'Release issuer is not an HTTP(S) URL.', cause);
+    }
+    if ((value.protocol !== 'https:' && value.protocol !== 'http:') ||
+        value.username !== '' ||
+        value.password !== '' ||
+        value.search !== '' ||
+        value.hash !== '') {
+        fail('RELEASE_INVALID', 'Release issuer is not an HTTP(S) URL.');
+    }
+    return `${admitted.replace(/\/+$/u, '')}${path}`;
+}

package/dist/release/legacy/bindings.d.ts

@@ -0,0 +1,14 @@
+import * as bindings from '../bindings/index.js';
+/** @deprecated Use `CallableBinding` from `@astrale-os/kernel-protocol/release`. */
+export type CallableBinding = bindings.CallableBinding;
+/** @deprecated Use `ViewBinding` from `@astrale-os/kernel-protocol/release`. */
+export type ViewBinding = bindings.ViewBinding;
+/** @deprecated Use `InvocationEndpoints` from `@astrale-os/kernel-protocol/release`. */
+export type InvocationEndpoints = bindings.InvocationEndpoints;
+/**
+ * Admit the complete HTTP/WebSocket endpoint pair shared by Publication and redirect routing.
+ *
+ * @deprecated Use `acceptInvocationEndpoints` from `@astrale-os/kernel-protocol/release`, which
+ * reports `ReleaseError`.
+ */
+export declare function acceptInvocationEndpoints(input: unknown): InvocationEndpoints;

package/dist/release/legacy/bindings.js

@@ -0,0 +1,11 @@
+import * as bindings from '../bindings/index.js';
+import { withPublicationError } from './error.js';
+/**
+ * Admit the complete HTTP/WebSocket endpoint pair shared by Publication and redirect routing.
+ *
+ * @deprecated Use `acceptInvocationEndpoints` from `@astrale-os/kernel-protocol/release`, which
+ * reports `ReleaseError`.
+ */
+export function acceptInvocationEndpoints(input) {
+    return withPublicationError(() => bindings.acceptInvocationEndpoints(input));
+}

package/dist/release/legacy/bundle-admission.d.ts

@@ -0,0 +1,6 @@
+import type * as dslBundle from '@astrale-os/kernel-dsl/v1/bundle';
+import type { Publication } from './publication.js';
+/** @deprecated Use `acceptBundle` from `@astrale-os/kernel-protocol/release`, which reports `ReleaseError`. */
+export declare function acceptBundle(input: Publication, artifact: unknown): dslBundle.Bundle;
+/** @deprecated Use `decodeBundle` from `@astrale-os/kernel-protocol/release`, which reports `ReleaseError`. */
+export declare function decodeBundle(input: Publication, bytes: Uint8Array): dslBundle.Bundle;

package/dist/release/legacy/bundle-admission.js

@@ -0,0 +1,10 @@
+import * as admission from '../bundle-admission.js';
+import { withPublicationError } from './error.js';
+/** @deprecated Use `acceptBundle` from `@astrale-os/kernel-protocol/release`, which reports `ReleaseError`. */
+export function acceptBundle(input, artifact) {
+    return withPublicationError(() => admission.acceptBundle(input, artifact));
+}
+/** @deprecated Use `decodeBundle` from `@astrale-os/kernel-protocol/release`, which reports `ReleaseError`. */
+export function decodeBundle(input, bytes) {
+    return withPublicationError(() => admission.decodeBundle(input, bytes));
+}

package/dist/release/legacy/bundle-evidence.d.ts

@@ -0,0 +1,8 @@
+import type { Publication } from './publication.js';
+/**
+ * Verify exact artifact bytes without decoding an authored Schema Bundle.
+ *
+ * @deprecated Use `verifyBundleBytes` from `@astrale-os/kernel-protocol/release/bundle-evidence`,
+ * which reports `ReleaseError`.
+ */
+export declare function verifyBundleBytes(publication: Publication, bytes: Uint8Array): void;

package/dist/release/legacy/bundle-evidence.js

@@ -0,0 +1,11 @@
+import * as evidence from '../bundle-evidence.js';
+import { withPublicationError } from './error.js';
+/**
+ * Verify exact artifact bytes without decoding an authored Schema Bundle.
+ *
+ * @deprecated Use `verifyBundleBytes` from `@astrale-os/kernel-protocol/release/bundle-evidence`,
+ * which reports `ReleaseError`.
+ */
+export function verifyBundleBytes(publication, bytes) {
+    withPublicationError(() => evidence.verifyBundleBytes(publication, bytes));
+}

package/dist/release/legacy/bundle.d.ts

@@ -0,0 +1,24 @@
+import type * as transport from '@astrale-os/kernel-dsl/v1/bundle/transport';
+import type * as artifact from '../../artifact/index.js';
+import type { Publication } from './publication.js';
+import * as descriptor from '../bundle-descriptor.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
+/** @deprecated Use `BUNDLE_MEDIA_TYPE` from `@astrale-os/kernel-protocol/release/bundle`. */
+export declare const BUNDLE_MEDIA_TYPE: "application/vnd.astrale.domain-bundle+json;v=1";
+/** @deprecated Use `BundleDescriptor` from `@astrale-os/kernel-protocol/release/bundle`. */
+export type BundleDescriptor = descriptor.BundleDescriptor;
+/**
+ * Resolve immutable bundle bytes beneath the exact serving issuer.
+ *
+ * @deprecated Use `bundleUrl` from `@astrale-os/kernel-protocol/release/bundle`, which reports
+ * `ReleaseError`.
+ */
+export declare function bundleUrl(issuer: string, ref: artifact.Ref): string;
+/** @deprecated Use `describeBundle` from `@astrale-os/kernel-protocol/release/bundle`. */
+export declare function describeBundle(input: transport.Bundle, href: string): BundleDescriptor;
+/** @deprecated Use `acceptBundleValue` from `@astrale-os/kernel-protocol/release/bundle`. */
+export declare function acceptBundleValue(input: unknown): transport.Bundle;
+/** @deprecated Use `decodeBundleValue` from `@astrale-os/kernel-protocol/release/bundle`. */
+export declare function decodeBundleValue(publication: Publication, bytes: Uint8Array): transport.Bundle;
+/** @deprecated Use `admitBundleDescriptor` from `@astrale-os/kernel-protocol/release/bundle`. */
+export declare function admitBundleDescriptor(input: unknown): BundleDescriptor;