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

package/dist/routes/scalar.js

@@ -0,0 +1,61 @@
+import { invalidRequest } from './error.js';
+const JSON_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
+export function encodeScalar(entry, name, value, domain) {
+    const encoded = scalar(value);
+    if (name === receiver(entry))
+        return encoded;
+    const decoded = decodeScalar(entry, name, encoded, domain);
+    if (!sameScalar(decoded, value)) {
+        invalidRequest(`Native route field ${name} does not round-trip through its declared value schema.`);
+    }
+    return encoded;
+}
+export function decodeScalar(entry, name, encoded, domain) {
+    if (name === receiver(entry))
+        return encoded;
+    const meaning = domain.callable(entry.callable);
+    if (meaning?.inputFields?.includes(name) !== true) {
+        invalidRequest(`Native route maps unknown input field ${name}.`);
+    }
+    const candidates = [encoded];
+    if (encoded === 'true')
+        candidates.push(true);
+    else if (encoded === 'false')
+        candidates.push(false);
+    else if (encoded === 'null')
+        candidates.push(null);
+    if (JSON_NUMBER.test(encoded)) {
+        const number = Number(encoded);
+        if (Number.isFinite(number))
+            candidates.push(number);
+    }
+    const accepted = candidates.filter((candidate) => meaning.validateInputField(name, candidate).length === 0);
+    if (accepted.length === 0) {
+        invalidRequest(`Native route field ${name} is invalid under its declared value schema.`);
+    }
+    if (accepted.length > 1) {
+        invalidRequest(`Native route field ${name} has an ambiguous scalar wire representation.`);
+    }
+    return accepted[0];
+}
+function receiver(entry) {
+    return entry.target.kind === 'method' && entry.target.dispatch === 'instance'
+        ? entry.target.receiver
+        : undefined;
+}
+export function scalar(value) {
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return invalidRequest('Native route field must be a string, number, or boolean at this wire source.');
+}
+export function asObject(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        invalidRequest('Native route input must be an object.');
+    }
+    return value;
+}
+function sameScalar(left, right) {
+    return (Object.is(left, right) ||
+        (typeof left === 'number' && typeof right === 'number' && left === 0 && right === 0));
+}

package/dist/routes/select.d.ts

@@ -0,0 +1,3 @@
+import type { Key } from '@astrale-os/kernel-dsl/v1';
+import type { Route, Table } from './table.js';
+export declare function select(table: Table, callable: Key.Callable, route?: string): Route | undefined;

package/dist/routes/select.js

@@ -0,0 +1,16 @@
+import { RouteError } from './error.js';
+export function select(table, callable, route) {
+    const candidates = table.entries.filter((entry) => entry.callable === callable);
+    if (route !== undefined) {
+        const selected = candidates.find((entry) => entry.name === route);
+        if (selected === undefined) {
+            throw new RouteError('NATIVE_ROUTE_NOT_FOUND', `Unknown route ${route} for ${callable}.`);
+        }
+        return selected;
+    }
+    if (candidates.length === 0)
+        return undefined;
+    if (candidates.length === 1)
+        return candidates[0];
+    return candidates.find((entry) => entry.default);
+}

package/dist/routes/stream.d.ts

@@ -0,0 +1,14 @@
+import { type Value } from '@astrale-os/kernel-dsl/value';
+import type { ErrorPayload } from '../errors/index.js';
+export declare const STREAM_MEDIA_TYPE: 'text/event-stream';
+export type StreamFrame = {
+    readonly kind: 'item';
+    readonly value: Value;
+} | {
+    readonly kind: 'end';
+} | {
+    readonly kind: 'error';
+    readonly error: ErrorPayload;
+};
+export declare function encodeStreamFrame(input: StreamFrame): string;
+export declare function decodeStreamFrame(event: string, data: string): StreamFrame;

package/dist/routes/stream.js

@@ -0,0 +1,50 @@
+import { DecodeError, json } from '@astrale-os/kernel-dsl/value';
+import { acceptPayload } from '../errors/index.js';
+import { fail } from './error.js';
+export const STREAM_MEDIA_TYPE = 'text/event-stream';
+export function encodeStreamFrame(input) {
+    switch (input.kind) {
+        case 'item':
+            return `data: ${json.serialize(input.value)}\n\n`;
+        case 'end':
+            return 'event: end\ndata: {}\n\n';
+        case 'error':
+            return `event: error\ndata: ${json.serialize(input.error)}\n\n`;
+    }
+}
+export function decodeStreamFrame(event, data) {
+    let value;
+    try {
+        value = json.decode(data);
+    }
+    catch (cause) {
+        if (cause instanceof DecodeError) {
+            return fail('NATIVE_ROUTE_RESPONSE_INVALID', 'Native stream event data is invalid.', cause);
+        }
+        throw cause;
+    }
+    if (event === '' || event === 'message') {
+        return Object.freeze({ kind: 'item', value });
+    }
+    if (event === 'end') {
+        if (value === null ||
+            typeof value !== 'object' ||
+            Array.isArray(value) ||
+            Reflect.ownKeys(value).length !== 0) {
+            fail('NATIVE_ROUTE_RESPONSE_INVALID', 'Native stream end event is invalid.');
+        }
+        return Object.freeze({ kind: 'end' });
+    }
+    if (event === 'error') {
+        try {
+            return Object.freeze({ kind: 'error', error: acceptPayload(value) });
+        }
+        catch (cause) {
+            if (cause instanceof TypeError) {
+                return fail('NATIVE_ROUTE_RESPONSE_INVALID', 'Native stream error event is invalid.', cause);
+            }
+            throw cause;
+        }
+    }
+    return fail('NATIVE_ROUTE_RESPONSE_INVALID', `Unknown native stream event ${JSON.stringify(event)}.`);
+}

package/dist/routes/table.d.ts

@@ -0,0 +1,9 @@
+import type { PublicationRef } from '../publication/index.js';
+import type { PlanEntry } from './plan.js';
+export interface Route extends Omit<PlanEntry, 'path'> {
+    readonly href: string;
+}
+export interface Table {
+    readonly publication: PublicationRef;
+    readonly entries: readonly Route[];
+}

package/dist/routes/table.js

@@ -0,0 +1 @@
+export {};

package/dist/routes/target.d.ts

@@ -0,0 +1,13 @@
+export type RouteTarget = {
+    readonly kind: 'function';
+} | {
+    readonly kind: 'method';
+    readonly dispatch: 'static';
+} | {
+    readonly kind: 'method';
+    readonly dispatch: 'instance';
+    readonly receiver: string;
+};
+export declare function requiresReceiver(entry: {
+    readonly target: RouteTarget;
+}): boolean;

package/dist/routes/target.js

@@ -0,0 +1,3 @@
+export function requiresReceiver(entry) {
+    return entry.target.kind === 'method' && entry.target.dispatch === 'instance';
+}

package/dist/routes/template.d.ts

@@ -0,0 +1,8 @@
+export declare const PLACEHOLDER: RegExp;
+export declare function validateTemplate(href: string): void;
+export declare function templateUrl(href: string): URL;
+export declare function routePattern(href: string): string;
+export declare function templatesOverlap(left: string, right: string): boolean;
+export declare function matchTemplate(template: string, input: string): Record<string, string> | undefined;
+export declare function encodeTemplate(value: unknown, catchall: string | undefined, host: boolean): string;
+export declare function authorityEnd(input: string): number;

package/dist/routes/template.js

@@ -0,0 +1,227 @@
+import { fail, invalidRequest } from './error.js';
+export const PLACEHOLDER = /\{([A-Za-z][A-Za-z0-9_]*)([+*])?\}/gu;
+const WHOLE_PLACEHOLDER = /^\{([A-Za-z][A-Za-z0-9_]*)([+*])?\}$/u;
+const HOST_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
+export function validateTemplate(href) {
+    validateHostTemplate(href);
+    const pathname = rawTemplatePath(href);
+    for (const segment of pathname.split('/')) {
+        if ((segment.includes('{') || segment.includes('}')) && !WHOLE_PLACEHOLDER.test(segment)) {
+            fail('NATIVE_ROUTE_DECLARATION_INVALID', 'Route placeholders must occupy one complete path segment.');
+        }
+    }
+    const placeholders = [...href.matchAll(PLACEHOLDER)];
+    const names = placeholders.map((match) => match[1]);
+    if (new Set(names).size !== names.length) {
+        fail('NATIVE_ROUTE_MAPPING_AMBIGUOUS', 'Route href uses one placeholder more than once.');
+    }
+    const catchalls = placeholders.filter((match) => match[2] !== undefined);
+    if (catchalls.length > 1 ||
+        (catchalls[0] !== undefined && catchalls[0].index + catchalls[0][0].length !== href.length)) {
+        fail('NATIVE_ROUTE_DECLARATION_INVALID', 'A catchall placeholder must be unique and terminal.');
+    }
+    templateUrl(href);
+}
+export function templateUrl(href) {
+    try {
+        const substituted = href.replaceAll(PLACEHOLDER, 'astrale-placeholder');
+        const url = new URL(substituted);
+        if ((url.protocol !== 'http:' && url.protocol !== 'https:') ||
+            url.username !== '' ||
+            url.password !== '' ||
+            url.search !== '' ||
+            url.hash !== '' ||
+            url.toString() !== substituted) {
+            throw new TypeError();
+        }
+        return url;
+    }
+    catch (cause) {
+        if (cause instanceof TypeError) {
+            return fail('NATIVE_ROUTE_DECLARATION_INVALID', 'Route href must be an absolute HTTP(S) template without credentials, query, or fragment.', cause);
+        }
+        throw cause;
+    }
+}
+export function routePattern(href) {
+    return href.replaceAll(PLACEHOLDER, (_whole, _name, catchall) => catchall === '+' ? '{+}' : catchall === '*' ? '{*}' : '{}');
+}
+export function templatesOverlap(left, right) {
+    const leftUrl = templateUrl(left);
+    const rightUrl = templateUrl(right);
+    if (leftUrl.protocol !== rightUrl.protocol || leftUrl.port !== rightUrl.port)
+        return false;
+    const leftHost = templateHostSegments(left);
+    const rightHost = templateHostSegments(right);
+    if (leftHost.length !== rightHost.length ||
+        leftHost.some((segment, index) => !hostSegmentsOverlap(segment, rightHost[index]))) {
+        return false;
+    }
+    const leftSegments = templateSegments(left);
+    const rightSegments = templateSegments(right);
+    const leftCatchall = leftSegments.findIndex((segment) => segment.kind.endsWith('catchall'));
+    const rightCatchall = rightSegments.findIndex((segment) => segment.kind.endsWith('catchall'));
+    const shared = Math.min(leftCatchall < 0 ? leftSegments.length : leftCatchall, rightCatchall < 0 ? rightSegments.length : rightCatchall);
+    for (let index = 0; index < shared; index += 1) {
+        if (!segmentsOverlap(leftSegments[index], rightSegments[index]))
+            return false;
+    }
+    if (leftCatchall < 0 && rightCatchall < 0) {
+        return leftSegments.length === rightSegments.length;
+    }
+    if (leftCatchall >= 0 && rightCatchall >= 0)
+        return true;
+    const catchall = leftCatchall >= 0 ? leftCatchall : rightCatchall;
+    const catchallSegment = (leftCatchall >= 0 ? leftSegments : rightSegments)[catchall];
+    const fixed = leftCatchall >= 0 ? rightSegments : leftSegments;
+    const remainder = fixed.slice(catchall);
+    if (catchallSegment.kind === 'optional-catchall')
+        return remainder.length > 0;
+    return (remainder.length > 1 ||
+        (remainder[0] !== undefined &&
+            (remainder[0].kind !== 'literal' || remainder[0].value.length > 0)));
+}
+export function matchTemplate(template, input) {
+    try {
+        const url = new URL(input);
+        url.search = '';
+        url.hash = '';
+        input = url.toString();
+    }
+    catch (cause) {
+        if (cause instanceof TypeError)
+            return undefined;
+        throw cause;
+    }
+    const names = [];
+    let cursor = 0;
+    let pattern = '^';
+    for (const match of template.matchAll(PLACEHOLDER)) {
+        pattern += escapePattern(template.slice(cursor, match.index));
+        names.push(match[1]);
+        pattern +=
+            match.index < authorityEnd(template)
+                ? '([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)'
+                : match[2] === '+'
+                    ? '(.+)'
+                    : match[2] === '*'
+                        ? '(.*)'
+                        : '([^/?#]+)';
+        cursor = match.index + match[0].length;
+    }
+    pattern += `${escapePattern(template.slice(cursor))}$`;
+    const matched = new RegExp(pattern, 'u').exec(input);
+    if (matched === null)
+        return undefined;
+    const output = {};
+    for (const [index, name] of names.entries()) {
+        try {
+            output[name] = decodeURIComponent(matched[index + 1]);
+        }
+        catch (cause) {
+            if (cause instanceof URIError)
+                return undefined;
+            throw cause;
+        }
+    }
+    return output;
+}
+export function encodeTemplate(value, catchall, host) {
+    if (typeof value !== 'string')
+        invalidRequest('Native route template value must be a string.');
+    if (host) {
+        if (!HOST_LABEL.test(value)) {
+            invalidRequest('Native route host field must be one canonical DNS label.');
+        }
+        return value;
+    }
+    if (catchall === '+' && value.length === 0) {
+        invalidRequest('A required catchall route value cannot be empty.');
+    }
+    return catchall === '+' || catchall === '*'
+        ? value.split('/').map(encodeURIComponent).join('/')
+        : encodeURIComponent(value);
+}
+export function authorityEnd(input) {
+    const start = input.indexOf('://') + 3;
+    const end = input.indexOf('/', start);
+    return end < 0 ? input.length : end;
+}
+function templateHostSegments(input) {
+    validateHostTemplate(input);
+    const url = templateUrl(input);
+    const raw = authority(input);
+    const hostname = raw.startsWith('[')
+        ? raw.slice(0, raw.indexOf(']') + 1)
+        : url.port === ''
+            ? raw
+            : raw.slice(0, -(url.port.length + 1));
+    return hostname
+        .split('.')
+        .map((segment) => WHOLE_PLACEHOLDER.test(segment)
+        ? Object.freeze({ kind: 'parameter' })
+        : Object.freeze({ kind: 'literal', value: segment }));
+}
+function hostSegmentsOverlap(left, right) {
+    if (left.kind === 'literal' && right.kind === 'literal')
+        return left.value === right.value;
+    const literal = left.kind === 'literal' ? left.value : right.kind === 'literal' ? right.value : undefined;
+    return literal === undefined || HOST_LABEL.test(literal);
+}
+function validateHostTemplate(input) {
+    const start = input.indexOf('://') + 3;
+    const end = authorityEnd(input);
+    for (const match of input.matchAll(PLACEHOLDER)) {
+        if (match.index >= end)
+            continue;
+        const after = match.index + match[0].length;
+        if (match[2] !== undefined ||
+            (match.index !== start && input[match.index - 1] !== '.') ||
+            (after !== end && input[after] !== '.' && input[after] !== ':')) {
+            fail('NATIVE_ROUTE_DECLARATION_INVALID', 'A host placeholder must occupy one complete DNS label and cannot be a catchall.');
+        }
+    }
+}
+function authority(input) {
+    const start = input.indexOf('://') + 3;
+    return input.slice(start, authorityEnd(input));
+}
+function rawTemplatePath(input) {
+    const authority = input.indexOf('://');
+    const start = input.indexOf('/', authority + 3);
+    return start < 0 ? '/' : input.slice(start);
+}
+function templateSegments(input) {
+    templateUrl(input);
+    validateHostTemplate(input);
+    return rawTemplatePath(input)
+        .split('/')
+        .slice(1)
+        .map((segment) => {
+        const placeholder = WHOLE_PLACEHOLDER.exec(segment);
+        if (placeholder !== null) {
+            return Object.freeze({
+                kind: placeholder[2] === '+'
+                    ? 'catchall'
+                    : placeholder[2] === '*'
+                        ? 'optional-catchall'
+                        : 'parameter',
+            });
+        }
+        if (segment.includes('{') || segment.includes('}')) {
+            fail('NATIVE_ROUTE_DECLARATION_INVALID', 'Route placeholders must occupy one complete path segment.');
+        }
+        return Object.freeze({ kind: 'literal', value: segment });
+    });
+}
+function segmentsOverlap(left, right) {
+    if (left.kind !== 'literal' && right.kind !== 'literal')
+        return true;
+    if (left.kind === 'literal' && right.kind === 'literal')
+        return left.value === right.value;
+    const literal = left.kind === 'literal' ? left.value : right.value;
+    return literal.length > 0;
+}
+function escapePattern(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}

package/dist/runtime/artifact.d.ts

@@ -0,0 +1,47 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
+import type { Digest, Ref } from '../artifact/index.js';
+import type { PublicationRequirements } from '../publication/index.js';
+export interface ExecutableDependency {
+    readonly path: string;
+    readonly ref: Ref;
+}
+export interface Executable {
+    readonly format: 'astrale.executable-artifact';
+    readonly version: 2;
+    readonly content: Ref;
+    readonly loader: 'node-esm' | 'oci-image' | 'immutable-package';
+    readonly entrypoint: string;
+    readonly runtimeAbi: string;
+    readonly dependencies: readonly ExecutableDependency[];
+    readonly closure: Digest;
+    readonly sbom: Ref;
+    readonly digest: Digest;
+}
+export interface Export {
+    readonly executable: Executable;
+    readonly name: string;
+}
+export interface Module {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly factory: Export;
+    readonly configuration: Ref | null;
+}
+/** Immutable portable closure selected by one local Schema installation source. */
+export interface RuntimeArtifact {
+    readonly format: 'astrale.domain-runtime-artifact';
+    readonly version: 2;
+    readonly issuer: IssuerId;
+    readonly bundle: Ref;
+    readonly requirements: PublicationRequirements;
+    readonly modules: readonly [Module, ...Module[]];
+}
+export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=2';
+export declare function accept(input: unknown): RuntimeArtifact;
+export declare function encode(input: RuntimeArtifact): Uint8Array;
+export declare function runtimeDigest(input: RuntimeArtifact): Digest;
+export declare function acceptExecutable(input: unknown): Executable;
+export declare function executableDigest(input: Omit<Executable, 'digest'>): Digest;
+export declare function executableClosure(input: readonly ExecutableDependency[]): Digest;
+export type { Digest, Ref };

package/dist/runtime/artifact.js

@@ -0,0 +1,176 @@
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import * as portable from '@astrale-os/kernel-dsl/value';
+import { sha256 } from '@noble/hashes/sha2.js';
+import * as artifact from '../artifact/index.js';
+import { admitRequirements } from '../publication/index.js';
+export const MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=2';
+export function accept(input) {
+    const root = record(input, 'Domain Runtime artifact');
+    exact(root, ['bundle', 'format', 'issuer', 'modules', 'requirements', 'version']);
+    if (root.format !== 'astrale.domain-runtime-artifact' || root.version !== 2) {
+        invalid('Domain Runtime artifact format or version is unsupported.');
+    }
+    if (typeof root.issuer !== 'string')
+        invalid('Domain Runtime artifact issuer is invalid.');
+    const admittedIssuer = acceptIssuer(root.issuer);
+    const bundle = artifact.accept(root.bundle);
+    const requirements = admitRequirements(root.requirements);
+    if (!Array.isArray(root.modules) || root.modules.length === 0) {
+        invalid('Domain Runtime artifact requires at least one Module.');
+    }
+    const modules = root.modules.map((value, index) => module(value, index));
+    const identities = modules.map(({ origin, revision }) => `${origin}\0${revision}`);
+    if (identities.some((identity, index) => index > 0 && identities[index - 1] >= identity)) {
+        invalid('Domain Runtime Modules must be unique and canonically ordered.');
+    }
+    return Object.freeze({
+        format: 'astrale.domain-runtime-artifact',
+        version: 2,
+        issuer: admittedIssuer,
+        bundle,
+        requirements,
+        modules: Object.freeze(modules),
+    });
+}
+export function encode(input) {
+    return portable.json.encode(accept(input));
+}
+export function runtimeDigest(input) {
+    return digestBytes(portable.json.encode(input));
+}
+export function acceptExecutable(input) {
+    return executable(input, 0);
+}
+export function executableDigest(input) {
+    return digestBytes(portable.json.encode(input));
+}
+export function executableClosure(input) {
+    return digestBytes(portable.json.encode(input));
+}
+function module(input, index) {
+    const value = record(input, `Domain Runtime Module ${index}`);
+    exact(value, ['configuration', 'factory', 'origin', 'revision']);
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid(`Domain Runtime Module ${index} origin is invalid.`);
+    }
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
+        invalid(`Domain Runtime Module ${index} revision is invalid.`);
+    }
+    const factory = executableExport(value.factory, index);
+    return Object.freeze({
+        origin: value.origin,
+        revision: value.revision,
+        factory,
+        configuration: value.configuration === null ? null : artifact.accept(value.configuration),
+    });
+}
+function executableExport(input, index) {
+    const value = record(input, `Domain Runtime Module ${index} factory`);
+    exact(value, ['executable', 'name']);
+    if (typeof value.name !== 'string' || value.name.length === 0) {
+        invalid(`Domain Runtime Module ${index} export name is invalid.`);
+    }
+    return Object.freeze({ executable: executable(value.executable, index), name: value.name });
+}
+function executable(input, index) {
+    const value = record(input, `Domain Runtime Module ${index} executable`);
+    exact(value, [
+        'closure',
+        'content',
+        'dependencies',
+        'digest',
+        'entrypoint',
+        'format',
+        'loader',
+        'runtimeAbi',
+        'sbom',
+        'version',
+    ]);
+    if (value.format !== 'astrale.executable-artifact' || value.version !== 2) {
+        invalid(`Domain Runtime Module ${index} executable format or version is unsupported.`);
+    }
+    if (value.loader !== 'node-esm' &&
+        value.loader !== 'oci-image' &&
+        value.loader !== 'immutable-package') {
+        invalid(`Domain Runtime Module ${index} executable loader is unsupported.`);
+    }
+    if (typeof value.entrypoint !== 'string' ||
+        value.entrypoint.length === 0 ||
+        typeof value.runtimeAbi !== 'string' ||
+        value.runtimeAbi.length === 0) {
+        invalid(`Domain Runtime Module ${index} executable coordinate is invalid.`);
+    }
+    if (!Array.isArray(value.dependencies)) {
+        invalid(`Domain Runtime Module ${index} executable dependencies are invalid.`);
+    }
+    const dependencies = value.dependencies.map((entry, dependencyIndex) => {
+        const dependency = record(entry, `Executable dependency ${dependencyIndex}`);
+        exact(dependency, ['path', 'ref']);
+        if (typeof dependency.path !== 'string' || dependency.path.length === 0) {
+            invalid(`Executable dependency ${dependencyIndex} is invalid.`);
+        }
+        return Object.freeze({
+            path: dependency.path,
+            ref: artifact.accept(dependency.ref),
+        });
+    });
+    if (dependencies.some((dependency, dependencyIndex) => dependencyIndex > 0 && dependencies[dependencyIndex - 1].path >= dependency.path)) {
+        invalid(`Domain Runtime Module ${index} executable dependencies are not canonical.`);
+    }
+    const closure = admittedDigest(value.closure, `Domain Runtime Module ${index} executable closure`);
+    if (executableClosure(dependencies) !== closure) {
+        invalid(`Domain Runtime Module ${index} executable dependency closure is invalid.`);
+    }
+    const body = Object.freeze({
+        format: 'astrale.executable-artifact',
+        version: 2,
+        content: artifact.accept(value.content),
+        loader: value.loader,
+        entrypoint: value.entrypoint,
+        runtimeAbi: value.runtimeAbi,
+        dependencies: Object.freeze(dependencies),
+        closure,
+        sbom: artifact.accept(value.sbom),
+    });
+    const digest = admittedDigest(value.digest, `Domain Runtime Module ${index} executable`);
+    if (executableDigest(body) !== digest) {
+        invalid(`Domain Runtime Module ${index} executable digest is invalid.`);
+    }
+    return Object.freeze({ ...body, digest });
+}
+function admittedDigest(input, label) {
+    if (typeof input !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(input)) {
+        invalid(`${label} digest is invalid.`);
+    }
+    return input;
+}
+function digestBytes(input) {
+    let hexadecimal = '';
+    for (const byte of sha256(input))
+        hexadecimal += byte.toString(16).padStart(2, '0');
+    return `sha256:${hexadecimal}`;
+}
+function record(input, label) {
+    let admitted;
+    try {
+        admitted = portable.accept(input);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} is not a portable value.`, { cause });
+    }
+    if (admitted === null || typeof admitted !== 'object' || Array.isArray(admitted)) {
+        invalid(`${label} must be an object.`);
+    }
+    return admitted;
+}
+function exact(input, expected) {
+    const actual = Object.keys(input).sort();
+    const wanted = [...expected].sort();
+    if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
+        invalid('Domain Runtime artifact fields are invalid.');
+    }
+}
+function invalid(message) {
+    throw new TypeError(message);
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1 @@
+export { MEDIA_TYPE, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, type Digest, type Executable, type ExecutableDependency, type Export, type Module, type RuntimeArtifact, type Ref, } from './artifact.js';

package/dist/runtime/index.js

@@ -0,0 +1 @@
+export { MEDIA_TYPE, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, } from './artifact.js';

package/dist/schema/index.d.ts

@@ -0,0 +1 @@
+export * as installation from './installation/index.js';

package/dist/schema/index.js

@@ -0,0 +1 @@
+export * as installation from './installation/index.js';

package/dist/schema/installation/index.d.ts

@@ -0,0 +1 @@
+export * as introspection from './introspection/index.js';

package/dist/schema/installation/index.js

@@ -0,0 +1 @@
+export * as introspection from './introspection/index.js';

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

@@ -0,0 +1,5 @@
+import type { introspection } from '@astrale-os/kernel-core/schema';
+import type { Limits, ResultFor } from './result.js';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-introspection.v1+msgpack';
+export declare function encode<Input extends introspection.Introspection>(input: Input, result: ResultFor<Input>): Promise<Uint8Array>;
+export declare function decode<Input extends introspection.Introspection>(input: Input, bytes: Uint8Array, limits: Limits): Promise<ResultFor<Input>>;