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

package/dist/schema/installation/legacy/installation.js

@@ -0,0 +1,28 @@
+import { accept as acceptValue, defaultLimits } from '@astrale-os/kernel-dsl/value';
+import { accept } from '../codec.js';
+import { decode as decodeMessagePack } from './msgpack.js';
+/** @deprecated Read-only: Hosts older than beta.127 serve this; current Hosts serve `installation.MEDIA_TYPE`. */
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-installation.v1+msgpack';
+/**
+ * Decode version-one (MessagePack) installation evidence into the canonical result.
+ *
+ * @deprecated Read-only; use `installation.decode` with `installation.MEDIA_TYPE`.
+ */
+export async function decode(bytes, maximumBytes) {
+    if (!(bytes instanceof Uint8Array) ||
+        !Number.isSafeInteger(maximumBytes) ||
+        maximumBytes < 1 ||
+        bytes.byteLength > maximumBytes) {
+        throw new TypeError('Schema installation evidence is invalid or exceeds its bound.');
+    }
+    let value;
+    try {
+        value = acceptValue(decodeMessagePack(bytes, defaultLimits.maxDepth), {
+            limits: { maxBytes: maximumBytes },
+        });
+    }
+    catch (cause) {
+        throw new TypeError('Schema installation evidence is malformed.', { cause });
+    }
+    return accept(value);
+}

package/dist/schema/installation/legacy/introspection.d.ts

@@ -0,0 +1,10 @@
+import type { introspection } from '@astrale-os/kernel-core/schema';
+import type { Limits, ResultFor } from '../introspection/result.js';
+/** @deprecated Read-only: Hosts older than beta.127 serve this; current Hosts serve `introspection.MEDIA_TYPE`. */
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-introspection.v2+msgpack';
+/**
+ * Decode version-two (MessagePack) introspection evidence into the canonical result.
+ *
+ * @deprecated Read-only; use `introspection.decode` with `introspection.MEDIA_TYPE`.
+ */
+export declare function decode<Input extends introspection.Introspection>(input: Input, bytes: Uint8Array, limits: Limits): Promise<ResultFor<Input>>;

package/dist/schema/installation/legacy/introspection.js

@@ -0,0 +1,70 @@
+import { accept as acceptValue, defaultLimits } from '@astrale-os/kernel-dsl/value';
+import { acceptEvidence, admitLimits, admitRequest } from '../introspection/codec.js';
+import { decode as decodeMessagePack } from './msgpack.js';
+/** @deprecated Read-only: Hosts older than beta.127 serve this; current Hosts serve `introspection.MEDIA_TYPE`. */
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v2+msgpack';
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+/**
+ * Decode version-two (MessagePack) introspection evidence into the canonical result.
+ *
+ * @deprecated Read-only; use `introspection.decode` with `introspection.MEDIA_TYPE`.
+ */
+export async function decode(input, bytes, limits) {
+    const request = admitRequest(input);
+    if (!(bytes instanceof Uint8Array))
+        invalid('Schema introspection evidence must be binary.');
+    admitLimits(request, limits);
+    // Version two carried the Bundle as raw bytes: no escaping allowance.
+    const maximumEvidenceBytes = limits.maximumPublicationBytes +
+        (request.kind === 'bundle' ? limits.maximumBundleBytes : 0) +
+        4_096;
+    if (bytes.byteLength > maximumEvidenceBytes) {
+        invalid('Schema introspection evidence exceeds its declared bounds.');
+    }
+    let wire;
+    try {
+        wire = decodeMessagePack(bytes, defaultLimits.maxDepth);
+    }
+    catch (cause) {
+        throw new TypeError('Schema introspection evidence is malformed.', { cause });
+    }
+    if (request.kind === 'bundle')
+        wire = bundleAsText(wire);
+    let decoded;
+    try {
+        decoded = acceptValue(wire, {
+            limits: {
+                maxBytes: maximumEvidenceBytes,
+                ...(request.kind === 'bundle' ? { maxStringBytes: limits.maximumBundleBytes } : {}),
+            },
+        });
+    }
+    catch (cause) {
+        throw new TypeError('Schema introspection evidence is malformed.', { cause });
+    }
+    return acceptEvidence(request, decoded, limits);
+}
+/**
+ * Version two carried the Bundle as the UTF-8 bytes of its canonical JSON; the current wire value
+ * carries that JSON as text. Translate only that field; every other check stays canonical.
+ */
+function bundleAsText(wire) {
+    if (wire === null || typeof wire !== 'object' || Array.isArray(wire))
+        return wire;
+    if (!Object.hasOwn(wire, 'bundle'))
+        return wire;
+    const { bundle } = wire;
+    if (!(bundle instanceof Uint8Array))
+        invalid('Bundle evidence is invalid or exceeds its bound.');
+    let text;
+    try {
+        text = utf8.decode(bundle);
+    }
+    catch (cause) {
+        throw new TypeError('Installed Domain Bundle is invalid.', { cause });
+    }
+    return { ...wire, bundle: text };
+}
+function invalid(message) {
+    throw new TypeError(message);
+}

package/dist/schema/installation/legacy/msgpack.d.ts

@@ -0,0 +1 @@
+export declare function decode(bytes: Uint8Array, maximumDepth: number): unknown;

package/dist/schema/installation/legacy/msgpack.js

@@ -0,0 +1,143 @@
+/**
+ * Frozen, read-only MessagePack decoder for the schema evidence of Hosts older than beta.127.
+ *
+ * It reads the families that msgpackr 2.0.5 `pack` (`useRecords: false`) wrote for that evidence:
+ * nil, booleans, integers, floats, strings, binary, arrays and string-keyed maps. Extension types
+ * (msgpackr records and `undefined`, timestamps, structured clones) never occur in it and are
+ * rejected, as are truncated input, trailing bytes, invalid UTF-8, non-string or duplicate map keys,
+ * integers outside the safe range, and nesting deeper than `maximumDepth`. It never encodes.
+ */
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+export function decode(bytes, maximumDepth) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let position = 0;
+    const take = (length) => {
+        if (length > bytes.byteLength - position)
+            malformed('is truncated');
+        const start = position;
+        position += length;
+        return start;
+    };
+    const u8 = () => bytes[take(1)];
+    const u16 = () => view.getUint16(take(2));
+    const u32 = () => view.getUint32(take(4));
+    const text = (length) => {
+        const start = take(length);
+        return utf8.decode(bytes.subarray(start, start + length));
+    };
+    const binary = (length) => {
+        const start = take(length);
+        return bytes.slice(start, start + length);
+    };
+    const entries = (count, width) => {
+        // Every entry occupies at least one byte per item: refuse counts the input cannot hold.
+        if (count * width > bytes.byteLength - position)
+            malformed('declares more entries than it holds');
+    };
+    const nested = (depth) => {
+        if (depth >= maximumDepth)
+            malformed(`nests deeper than ${maximumDepth} containers`);
+        return depth + 1;
+    };
+    const array = (count, depth) => {
+        entries(count, 1);
+        const output = [];
+        for (let index = 0; index < count; index += 1)
+            output.push(value(depth));
+        return output;
+    };
+    const map = (count, depth) => {
+        entries(count, 2);
+        const output = {};
+        for (let index = 0; index < count; index += 1) {
+            const key = value(depth);
+            if (typeof key !== 'string')
+                malformed('has a non-string map key');
+            if (Object.hasOwn(output, key))
+                malformed('has a duplicate map key');
+            Object.defineProperty(output, key, {
+                value: value(depth),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        }
+        return output;
+    };
+    const integer = (input) => {
+        const output = Number(input);
+        if (!Number.isSafeInteger(output))
+            malformed('holds an integer outside the safe range');
+        return output;
+    };
+    function value(depth) {
+        const head = u8();
+        if (head <= 0x7f)
+            return head;
+        if (head >= 0xe0)
+            return head - 0x100;
+        if (head <= 0x8f)
+            return map(head & 0x0f, nested(depth));
+        if (head <= 0x9f)
+            return array(head & 0x0f, nested(depth));
+        if (head <= 0xbf)
+            return text(head & 0x1f);
+        switch (head) {
+            case 0xc0:
+                return null;
+            case 0xc2:
+                return false;
+            case 0xc3:
+                return true;
+            case 0xc4:
+                return binary(u8());
+            case 0xc5:
+                return binary(u16());
+            case 0xc6:
+                return binary(u32());
+            case 0xca:
+                return view.getFloat32(take(4));
+            case 0xcb:
+                return view.getFloat64(take(8));
+            case 0xcc:
+                return u8();
+            case 0xcd:
+                return u16();
+            case 0xce:
+                return u32();
+            case 0xcf:
+                return integer(view.getBigUint64(take(8)));
+            case 0xd0:
+                return view.getInt8(take(1));
+            case 0xd1:
+                return view.getInt16(take(2));
+            case 0xd2:
+                return view.getInt32(take(4));
+            case 0xd3:
+                return integer(view.getBigInt64(take(8)));
+            case 0xd9:
+                return text(u8());
+            case 0xda:
+                return text(u16());
+            case 0xdb:
+                return text(u32());
+            case 0xdc:
+                return array(u16(), nested(depth));
+            case 0xdd:
+                return array(u32(), nested(depth));
+            case 0xde:
+                return map(u16(), nested(depth));
+            case 0xdf:
+                return map(u32(), nested(depth));
+            default:
+                return malformed(`uses the unsupported type 0x${head.toString(16)}`);
+        }
+    }
+    const output = value(0);
+    if (position !== bytes.byteLength)
+        malformed('has trailing bytes');
+    return output;
+}
+function malformed(reason) {
+    throw new TypeError(`MessagePack evidence ${reason}.`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-protocol",
-  "version": "0.5.0-beta.66",
+  "version": "0.5.0-beta.68",
   "description": "Portable Astrale invocation, publication, installation, routing, and issuer protocols",
   "license": "Apache-2.0",
   "repository": {
@@ -47,6 +47,10 @@
       "types": "./dist/issuer/paths.d.ts",
       "import": "./dist/issuer/paths.js"
     },
+    "./issuer/workflow-engine": {
+      "types": "./dist/issuer/workflow-engine.d.ts",
+      "import": "./dist/issuer/workflow-engine.js"
+    },
     "./invocation": {
       "types": "./dist/invocation/index.d.ts",
       "import": "./dist/invocation/index.js"
@@ -60,40 +64,60 @@
       "import": "./dist/artifact/index.js"
     },
     "./publication": {
-      "types": "./dist/publication/index.d.ts",
-      "import": "./dist/publication/index.js"
+      "types": "./dist/release/legacy/index.d.ts",
+      "import": "./dist/release/legacy/index.js"
     },
     "./publication/publication": {
-      "types": "./dist/publication/publication.d.ts",
-      "import": "./dist/publication/publication.js"
+      "types": "./dist/release/legacy/publication.d.ts",
+      "import": "./dist/release/legacy/publication.js"
     },
     "./publication/reference": {
-      "types": "./dist/publication/reference.d.ts",
-      "import": "./dist/publication/reference.js"
+      "types": "./dist/release/legacy/reference.d.ts",
+      "import": "./dist/release/legacy/reference.js"
     },
     "./publication/requirements": {
-      "types": "./dist/publication/requirements.d.ts",
-      "import": "./dist/publication/requirements.js"
+      "types": "./dist/release/legacy/requirements.d.ts",
+      "import": "./dist/release/legacy/requirements.js"
     },
     "./publication/legacy-requirements": {
-      "types": "./dist/publication/legacy-requirements.d.ts",
-      "import": "./dist/publication/legacy-requirements.js"
-    },
-    "./publication/delivery": {
-      "types": "./dist/publication/delivery/index.d.ts",
-      "import": "./dist/publication/delivery/index.js"
+      "types": "./dist/release/legacy/profiles.d.ts",
+      "import": "./dist/release/legacy/profiles.js"
     },
     "./publication/bundle": {
-      "types": "./dist/publication/bundle.d.ts",
-      "import": "./dist/publication/bundle.js"
+      "types": "./dist/release/legacy/bundle.d.ts",
+      "import": "./dist/release/legacy/bundle.js"
     },
     "./publication/bundle-evidence": {
-      "types": "./dist/publication/bundle-evidence.d.ts",
-      "import": "./dist/publication/bundle-evidence.js"
+      "types": "./dist/release/legacy/bundle-evidence.d.ts",
+      "import": "./dist/release/legacy/bundle-evidence.js"
+    },
+    "./release": {
+      "types": "./dist/release/index.d.ts",
+      "import": "./dist/release/index.js"
+    },
+    "./release/bundle": {
+      "types": "./dist/release/bundle.d.ts",
+      "import": "./dist/release/bundle.js"
+    },
+    "./release/bundle-evidence": {
+      "types": "./dist/release/bundle-evidence.d.ts",
+      "import": "./dist/release/bundle-evidence.js"
+    },
+    "./release/delivery": {
+      "types": "./dist/release/delivery/index.d.ts",
+      "import": "./dist/release/delivery/index.js"
     },
-    "./publication/delivery-declaration": {
-      "types": "./dist/publication/delivery-declaration.d.ts",
-      "import": "./dist/publication/delivery-declaration.js"
+    "./release/delivery-declaration": {
+      "types": "./dist/release/delivery-declaration.d.ts",
+      "import": "./dist/release/delivery-declaration.js"
+    },
+    "./release/legacy": {
+      "types": "./dist/release/legacy/index.d.ts",
+      "import": "./dist/release/legacy/index.js"
+    },
+    "./release/requirements": {
+      "types": "./dist/release/requirements.d.ts",
+      "import": "./dist/release/requirements.js"
     },
     "./routes": {
       "types": "./dist/routes/index.d.ts",
@@ -103,6 +127,10 @@
       "types": "./dist/schema/index.d.ts",
       "import": "./dist/schema/index.js"
     },
+    "./schema/installation/legacy": {
+      "types": "./dist/schema/installation/legacy/index.d.ts",
+      "import": "./dist/schema/installation/legacy/index.js"
+    },
     "./routes/admission": {
       "types": "./dist/routes/admission.d.ts",
       "import": "./dist/routes/admission.js"
@@ -119,9 +147,13 @@
       "types": "./dist/routes/placement.d.ts",
       "import": "./dist/routes/placement.js"
     },
-    "./routes/release-unavailable": {
-      "types": "./dist/routes/release-unavailable.d.ts",
-      "import": "./dist/routes/release-unavailable.js"
+    "./routes/deployment-retired": {
+      "types": "./dist/routes/deployment-retired.d.ts",
+      "import": "./dist/routes/deployment-retired.js"
+    },
+    "./routes/legacy": {
+      "types": "./dist/routes/legacy/index.d.ts",
+      "import": "./dist/routes/legacy/index.js"
     },
     "./routes/routing": {
       "types": "./dist/routes/routing.d.ts",
@@ -137,24 +169,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "0.9.0-beta.60",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.43",
+    "@astrale-os/kernel-core": "0.9.0-beta.62",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.44",
     "@noble/hashes": "2.3.0"
   },
   "devDependencies": {
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
-    "msgpackr": "^2.0.5",
     "typescript": "7.0.2",
     "vitest": "^5.0.1"
   },
-  "peerDependencies": {
-    "msgpackr": "^2.0.5"
-  },
-  "peerDependenciesMeta": {
-    "msgpackr": {
-      "optional": true
-    }
-  },
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist",

package/dist/codecs/msgpack.d.ts

@@ -1,4 +0,0 @@
-import type { Codec } from './codec.js';
-export declare function loadMsgpack(): Promise<Codec>;
-/** Package-private canonical identity check used by Protocol binding selection. */
-export declare function isMsgpackCodec(input: Codec): boolean;

package/dist/codecs/msgpack.js

@@ -1,53 +0,0 @@
-import { accept as acceptValue, BoundaryError } from '@astrale-os/kernel-dsl/value';
-import { DecodeError } from './codec.js';
-import { CONTENT_TYPE_MSGPACK } from './media-types.js';
-let library = null;
-export async function loadMsgpack() {
-    if (library === null) {
-        // `as string` keeps TypeScript from pulling msgpackr's declarations, which assume
-        // `@types/node`, into consumer programs. The assertion is erased on emit, so bundlers
-        // still see literal specifiers; a variable would leave them unresolvable.
-        const [packing, unpacking] = await Promise.all([
-            import('msgpackr/pack'),
-            import('msgpackr'),
-        ]);
-        library = Object.freeze({ pack: packing.pack, unpack: unpacking.unpack });
-    }
-    return MSGPACK;
-}
-const MSGPACK = Object.freeze({
-    name: 'msgpack',
-    contentType: CONTENT_TYPE_MSGPACK,
-    binary: true,
-    encode(data) {
-        if (library === null)
-            throw new Error('MsgPack codec is not loaded');
-        return new Uint8Array(library.pack(acceptValue(data)));
-    },
-    decode(input) {
-        if (library === null)
-            throw new Error('MsgPack codec is not loaded');
-        if (typeof input === 'string')
-            throw new TypeError('MsgPack requires a binary envelope');
-        let decoded;
-        try {
-            decoded = library.unpack(input);
-        }
-        catch (cause) {
-            throw new DecodeError('MsgPack envelope is malformed.', { cause });
-        }
-        try {
-            return acceptValue(decoded);
-        }
-        catch (cause) {
-            if (cause instanceof BoundaryError) {
-                throw new DecodeError('MsgPack envelope is not a portable value.', { cause });
-            }
-            throw cause;
-        }
-    },
-});
-/** Package-private canonical identity check used by Protocol binding selection. */
-export function isMsgpackCodec(input) {
-    return input === MSGPACK;
-}

package/dist/publication/bindings/invocation.js

@@ -1,13 +0,0 @@
-import { absoluteHttpUrl, absoluteUrl, exact, record } from '../content.js';
-export function acceptInvocationEndpoints(input) {
-    const value = record(input, 'PUBLICATION_BINDING_INVALID', 'Invocation endpoints are invalid.');
-    exact(value, ['http', 'websocket'], 'PUBLICATION_BINDING_INVALID');
-    const http = absoluteHttpUrl(value.http, true, 'PUBLICATION_BINDING_INVALID');
-    const websocket = value.websocket === undefined
-        ? undefined
-        : absoluteUrl(value.websocket, ['ws:', 'wss:'], true, 'PUBLICATION_BINDING_INVALID');
-    return Object.freeze({
-        http,
-        ...(websocket === undefined ? {} : { websocket }),
-    });
-}

package/dist/publication/bundle-admission.d.ts

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

package/dist/publication/bundle-evidence.d.ts

@@ -1,3 +0,0 @@
-import type { Publication } from './publication.js';
-/** Verify exact artifact bytes without decoding an authored Schema Bundle. */
-export declare function verifyBundleBytes(publication: Publication, bytes: Uint8Array): void;

package/dist/publication/bundle-evidence.js

@@ -1,13 +0,0 @@
-import { fail } from './error.js';
-import { sha256Hex } from './etag.js';
-/** Verify exact artifact bytes without decoding an authored Schema Bundle. */
-export function verifyBundleBytes(publication, bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-        fail('PUBLICATION_INVALID', 'Bundle artifact bytes are invalid.');
-    }
-    const descriptor = publication.schema.bundle;
-    if (bytes.byteLength !== descriptor.ref.size ||
-        `sha256:${sha256Hex(bytes)}` !== descriptor.ref.digest) {
-        fail('PUBLICATION_INVALID', 'Bundle artifact does not match its descriptor.');
-    }
-}

package/dist/publication/content.d.ts

@@ -1,10 +0,0 @@
-import type { PublicationErrorCode } from './error.js';
-import type { Publication } from './publication.js';
-export type Content = Omit<Publication, 'etag'>;
-export declare function record(input: unknown, code: PublicationErrorCode, message: string): Record<string, unknown>;
-export declare function exact(value: Record<string, unknown>, allowed: readonly string[], code: PublicationErrorCode): void;
-export declare function array(input: unknown, code: PublicationErrorCode): readonly unknown[];
-export declare function unique(values: readonly string[], code: PublicationErrorCode, label: string): void;
-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;

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

@@ -1,9 +0,0 @@
-import type { Publication } from '../publication.js';
-import type { Attestation } from './attestation.js';
-export interface Delivery {
-    readonly format: 'astrale.domain.delivery';
-    readonly version: 1;
-    readonly publication: Publication;
-    readonly attestation: Attestation;
-}
-export declare function accept(input: unknown): Delivery;

package/dist/publication/delivery/limits.js

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

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

@@ -1,15 +0,0 @@
-import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
-import type { Etag } from '../etag.js';
-export interface Request {
-    readonly version: 1;
-    readonly kernel: IssuerId;
-    readonly nonce: string;
-    readonly etag: Etag;
-}
-/** Exact bearer credential admitted by a Delivery transport boundary. */
-export interface Token {
-    readonly kind: 'bearer';
-    readonly token: string;
-}
-/** Admit the exact request representation accepted by a Delivery transport boundary. */
-export declare function acceptRequest(input: unknown): Request;

package/dist/publication/delivery-endpoint.js

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

package/dist/publication/error.d.ts

@@ -1,7 +0,0 @@
-export type PublicationErrorCode = 'PUBLICATION_INVALID' | 'PUBLICATION_ETAG_MISMATCH' | 'PUBLICATION_BINDING_INVALID' | 'PUBLICATION_ROUTE_INVALID' | 'PUBLICATION_VIEW_INVALID';
-export declare class PublicationError extends Error {
-    readonly code: PublicationErrorCode;
-    readonly name = "PublicationError";
-    constructor(code: PublicationErrorCode, message: string, options?: ErrorOptions);
-}
-export declare function fail(code: PublicationErrorCode, message: string, cause?: unknown): never;

package/dist/publication/error.js

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

package/dist/publication/etag.d.ts

@@ -1,6 +0,0 @@
-import type { Content } from './content.js';
-export type Sha256Digest = `sha256:${string}`;
-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;

package/dist/publication/index.d.ts

@@ -1,17 +0,0 @@
-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, 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';
-export { placeDelivery } from './delivery-declaration.js';
-export type { Etag, Sha256Digest } from './etag.js';
-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 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 IframeRequirements, type InvocationEndpoints, type ViewBinding, } from './bindings/index.js';

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

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