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

package/dist/routes/scalar.js

@@ -59,4 +59,3 @@ function sameScalar(left, right) {
     return (Object.is(left, right) ||
         (typeof left === 'number' && typeof right === 'number' && left === 0 && right === 0));
 }
-//# sourceMappingURL=scalar.js.map

package/dist/routes/select.d.ts

@@ -1,4 +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;
-//# sourceMappingURL=select.d.ts.map
+export declare function select(table: Pick<Table, 'entries'>, callable: Key.Callable, route?: string): Route | undefined;

package/dist/routes/select.js

@@ -14,4 +14,3 @@ export function select(table, callable, route) {
         return candidates[0];
     return candidates.find((entry) => entry.default);
 }
-//# sourceMappingURL=select.js.map

package/dist/routes/stream.d.ts

@@ -12,4 +12,3 @@ export type StreamFrame = {
 };
 export declare function encodeStreamFrame(input: StreamFrame): string;
 export declare function decodeStreamFrame(event: string, data: string): StreamFrame;
-//# sourceMappingURL=stream.d.ts.map

package/dist/routes/stream.js

@@ -48,4 +48,3 @@ export function decodeStreamFrame(event, data) {
     }
     return fail('NATIVE_ROUTE_RESPONSE_INVALID', `Unknown native stream event ${JSON.stringify(event)}.`);
 }
-//# sourceMappingURL=stream.js.map

package/dist/routes/table.d.ts

@@ -1,10 +1,10 @@
-import type { PublicationRef } from '../publication/index.js';
+import type { ReleaseRef } from '../release/reference.js';
 import type { PlanEntry } from './plan.js';
 export interface Route extends Omit<PlanEntry, 'path'> {
     readonly href: string;
 }
+/** Serving proof tied to one exact release and its resolved Domain. */
 export interface Table {
-    readonly publication: PublicationRef;
+    readonly release: ReleaseRef;
     readonly entries: readonly Route[];
 }
-//# sourceMappingURL=table.d.ts.map

package/dist/routes/table.js

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

package/dist/routes/target.d.ts

@@ -1,3 +1,6 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { MeaningFingerprint } from '@astrale-os/kernel-dsl/v1/schema/fingerprint';
 export type RouteTarget = {
     readonly kind: 'function';
 } | {
@@ -11,4 +14,5 @@ export type RouteTarget = {
 export declare function requiresReceiver(entry: {
     readonly target: RouteTarget;
 }): boolean;
-//# sourceMappingURL=target.d.ts.map
+/** Fingerprint of the route Domain's callable meaning, which every native route Target pins. */
+export declare function routeFingerprint(domain: Pick<Domain, 'callable'>, callable: Key.Callable): MeaningFingerprint;

package/dist/routes/target.js

@@ -1,4 +1,19 @@
+import { callableFingerprint } from '@astrale-os/kernel-dsl/v1/schema/fingerprint';
+import { fail } from './error.js';
 export function requiresReceiver(entry) {
     return entry.target.kind === 'method' && entry.target.dispatch === 'instance';
 }
-//# sourceMappingURL=target.js.map
+const FINGERPRINTS = new WeakMap();
+/** Fingerprint of the route Domain's callable meaning, which every native route Target pins. */
+export function routeFingerprint(domain, callable) {
+    const meaning = domain.callable(callable);
+    if (meaning === undefined) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', `Route callable ${callable} is absent from its Domain.`);
+    }
+    let fingerprint = FINGERPRINTS.get(meaning);
+    if (fingerprint === undefined) {
+        fingerprint = callableFingerprint(meaning);
+        FINGERPRINTS.set(meaning, fingerprint);
+    }
+    return fingerprint;
+}

package/dist/routes/template.d.ts

@@ -1,9 +1,7 @@
 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;
-//# sourceMappingURL=template.d.ts.map

package/dist/routes/template.js

@@ -43,9 +43,6 @@ export function templateUrl(href) {
         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);
@@ -225,4 +222,3 @@ function segmentsOverlap(left, right) {
 function escapePattern(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
 }
-//# sourceMappingURL=template.js.map

package/dist/runtime/artifact.d.ts

@@ -1,7 +1,7 @@
 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';
+import type { Requirements } from '../release/requirements.js';
 export interface ExecutableDependency {
     readonly path: string;
     readonly ref: Ref;
@@ -31,13 +31,14 @@ export interface Module {
 /** Immutable portable closure selected by one local Schema installation source. */
 export interface RuntimeArtifact {
     readonly format: 'astrale.domain-runtime-artifact';
-    readonly version: 2;
+    readonly version: 3;
     readonly issuer: IssuerId;
     readonly bundle: Ref;
-    readonly requirements: PublicationRequirements;
+    readonly requirements: Requirements;
     readonly modules: readonly [Module, ...Module[]];
 }
-export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=2';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=3';
+export declare function mediaType(_input: Pick<RuntimeArtifact, 'version'>): typeof MEDIA_TYPE;
 export declare function accept(input: unknown): RuntimeArtifact;
 export declare function encode(input: RuntimeArtifact): Uint8Array;
 export declare function runtimeDigest(input: RuntimeArtifact): Digest;
@@ -45,4 +46,3 @@ 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 };
-//# sourceMappingURL=artifact.d.ts.map

package/dist/runtime/artifact.js

@@ -3,12 +3,15 @@ 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';
+import { admitRequirements } from '../release/requirements.js';
+export const MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=3';
+export function mediaType(_input) {
+    return MEDIA_TYPE;
+}
 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) {
+    if (root.format !== 'astrale.domain-runtime-artifact' || root.version !== 3) {
         invalid('Domain Runtime artifact format or version is unsupported.');
     }
     if (typeof root.issuer !== 'string')
@@ -26,7 +29,7 @@ export function accept(input) {
     }
     return Object.freeze({
         format: 'astrale.domain-runtime-artifact',
-        version: 2,
+        version: root.version,
         issuer: admittedIssuer,
         bundle,
         requirements,
@@ -174,4 +177,3 @@ function exact(input, expected) {
 function invalid(message) {
     throw new TypeError(message);
 }
-//# sourceMappingURL=artifact.js.map

package/dist/runtime/index.d.ts

@@ -1,2 +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';
-//# sourceMappingURL=index.d.ts.map
+export { MEDIA_TYPE, mediaType, 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

@@ -1,2 +1 @@
-export { MEDIA_TYPE, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, } from './artifact.js';
-//# sourceMappingURL=index.js.map
+export { MEDIA_TYPE, mediaType, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, } from './artifact.js';

package/dist/schema/index.d.ts

@@ -1,2 +1 @@
 export * as installation from './installation/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.js

@@ -1,2 +1 @@
 export * as installation from './installation/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,9 @@
+import type { InstalledGeneration, InstallResult } from './result.js';
+/**
+ * Admit one install result, the value a completed install execution ends with: strict, detached
+ * and frozen. Throws a TypeError when it is not exactly a changed receipt or the unchanged
+ * generations.
+ */
+export declare function acceptResult(input: unknown): InstallResult;
+/** One exact installed generation: its origin, Schema revision and Installation Target digest. */
+export declare function acceptGeneration(input: unknown): InstalledGeneration;

package/dist/schema/installation/codec.js

@@ -0,0 +1,82 @@
+import { installReceipt } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+/**
+ * Admit one install result, the value a completed install execution ends with: strict, detached
+ * and frozen. Throws a TypeError when it is not exactly a changed receipt or the unchanged
+ * generations.
+ */
+export function acceptResult(input) {
+    const value = record(input);
+    if (value.changed === true) {
+        exact(value, ['changed', 'receipt']);
+        const parsed = installReceipt.safeParse(value.receipt);
+        if (!parsed.success)
+            throw new TypeError('Schema installation receipt is invalid.');
+        const receipt = deepFreeze(parsed.data);
+        if (receipt.transitions.some((transition) => transition.intent.operation !== receipt.operation)) {
+            throw new TypeError('Schema installation Transition belongs to another operation.');
+        }
+        uniqueOrigins(receipt.transitions.map((transition) => transition.intent.origin), 'Schema installation Transitions');
+        return Object.freeze({
+            changed: true,
+            receipt,
+        });
+    }
+    if (value.changed === false) {
+        exact(value, ['changed', 'domains']);
+        if (!Array.isArray(value.domains) || value.domains.length === 0) {
+            throw new TypeError('Schema installation unchanged Domains are empty.');
+        }
+        const domains = value.domains.map(acceptGeneration);
+        uniqueOrigins(domains.map((domain) => domain.origin), 'Schema installation unchanged Domains');
+        return Object.freeze({
+            changed: false,
+            domains: Object.freeze(domains),
+        });
+    }
+    throw new TypeError('Schema installation result kind is invalid.');
+}
+/** One exact installed generation: its origin, Schema revision and Installation Target digest. */
+export function acceptGeneration(input) {
+    const value = record(input);
+    exact(value, ['generation', 'origin', 'revision']);
+    if (typeof value.origin !== 'string' ||
+        !patterns.origin.test(value.origin) ||
+        typeof value.revision !== 'string' ||
+        !patterns.revision.test(value.revision) ||
+        typeof value.generation !== 'string' ||
+        !/^sha256:[0-9a-f]{64}$/u.test(value.generation)) {
+        throw new TypeError('Schema installation unchanged Domain generation is invalid.');
+    }
+    return Object.freeze({
+        origin: value.origin,
+        revision: value.revision,
+        generation: value.generation,
+    });
+}
+function deepFreeze(input) {
+    if (input !== null && typeof input === 'object' && !Object.isFrozen(input)) {
+        for (const value of Object.values(input))
+            deepFreeze(value);
+        Object.freeze(input);
+    }
+    return input;
+}
+function uniqueOrigins(origins, label) {
+    if (new Set(origins).size !== origins.length) {
+        throw new TypeError(`${label} contain duplicate origins.`);
+    }
+}
+function record(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError('Schema installation result is invalid.');
+    }
+    return input;
+}
+function exact(input, expected) {
+    const keys = Object.keys(input).sort();
+    const wanted = [...expected].sort();
+    if (keys.length !== wanted.length || keys.some((key, index) => key !== wanted[index])) {
+        throw new TypeError('Schema installation result fields are invalid.');
+    }
+}

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

@@ -1,2 +1,3 @@
+export { acceptGeneration, acceptResult } from './codec.js';
 export * as introspection from './introspection/index.js';
-//# sourceMappingURL=index.d.ts.map
+export type { InstalledGeneration, InstallResult } from './result.js';

package/dist/schema/installation/index.js

@@ -1,2 +1,2 @@
+export { acceptGeneration, acceptResult } from './codec.js';
 export * as introspection from './introspection/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,6 +1,8 @@
 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';
+import type { DomainDependencies, DomainInfo, Limits, ResultFor } from './result.js';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-introspection.v4+json';
 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>>;
-//# sourceMappingURL=codec.d.ts.map
+/** Admit dependency bindings: origin-ordered, one per origin, each label agreeing with its revisions. */
+export declare function acceptDomainDependencies(input: unknown): DomainDependencies;
+export declare function acceptDomainInfo(input: unknown): DomainInfo;