@astrale-os/kernel-protocol 0.5.0-beta.6 → 0.5.0-beta.61

package/dist/routes/template.js

@@ -225,4 +225,3 @@ function segmentsOverlap(left, right) {
 function escapePattern(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
 }
-//# sourceMappingURL=template.js.map

package/dist/runtime/artifact.d.ts

@@ -1,5 +1,5 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
-import type { Key, schema } from '@astrale-os/kernel-dsl/v1';
+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 {
@@ -24,20 +24,22 @@ export interface Export {
 }
 export interface Module {
     readonly origin: Key.Origin;
-    readonly revision: schema.Revision;
+    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 version: 2 | 3;
     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 const MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=3';
+export declare const LEGACY_MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=2';
+export declare function mediaType(input: Pick<RuntimeArtifact, 'version'>): typeof MEDIA_TYPE | typeof LEGACY_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 +47,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

@@ -1,21 +1,29 @@
 import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
-import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+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 { decodeLegacyRequirements, encodeLegacyRequirements, } from '../publication/legacy-requirements.js';
+export const MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=3';
+export const LEGACY_MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=2';
+export function mediaType(input) {
+    return input.version === 2 ? LEGACY_MEDIA_TYPE : 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 !== 2 && root.version !== 3)) {
         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);
+    const requirements = root.version === 2
+        ? decodeLegacyRequirements(root.requirements)
+        : admitRequirements(root.requirements);
     if (!Array.isArray(root.modules) || root.modules.length === 0) {
         invalid('Domain Runtime artifact requires at least one Module.');
     }
@@ -26,7 +34,7 @@ export function accept(input) {
     }
     return Object.freeze({
         format: 'astrale.domain-runtime-artifact',
-        version: 2,
+        version: root.version,
         issuer: admittedIssuer,
         bundle,
         requirements,
@@ -34,10 +42,15 @@ export function accept(input) {
     });
 }
 export function encode(input) {
-    return portable.json.encode(accept(input));
+    return portable.json.encode(wire(accept(wire(input))));
 }
 export function runtimeDigest(input) {
-    return digestBytes(portable.json.encode(input));
+    return digestBytes(portable.json.encode(wire(input)));
+}
+function wire(input) {
+    return input.version === 2
+        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
+        : input;
 }
 export function acceptExecutable(input) {
     return executable(input, 0);
@@ -51,10 +64,10 @@ export function executableClosure(input) {
 function module(input, index) {
     const value = record(input, `Domain Runtime Module ${index}`);
     exact(value, ['configuration', 'factory', 'origin', 'revision']);
-    if (typeof value.origin !== 'string' || !dslSchema.patterns.origin.test(value.origin)) {
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
         invalid(`Domain Runtime Module ${index} origin is invalid.`);
     }
-    if (typeof value.revision !== 'string' || !dslSchema.patterns.revision.test(value.revision)) {
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
         invalid(`Domain Runtime Module ${index} revision is invalid.`);
     }
     const factory = executableExport(value.factory, index);
@@ -174,4 +187,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, LEGACY_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, LEGACY_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,4 @@
+import type { InstallResult } from './result.js';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-installation.v1+msgpack';
+export declare function encode(result: InstallResult): Promise<Uint8Array>;
+export declare function decode(bytes: Uint8Array, maximumBytes: number): Promise<InstallResult>;

package/dist/schema/installation/codec.js

@@ -0,0 +1,71 @@
+import { installReceipt } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
+import { acceptDomainInfo } from './introspection/index.js';
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-installation.v1+msgpack';
+export async function encode(result) {
+    // Non-literal specifiers keep msgpackr's Node-typed declarations out of consumers (see codecs/msgpack.ts).
+    const { pack } = await import('msgpackr/pack');
+    return new Uint8Array(pack(accept(result)));
+}
+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.');
+    }
+    const { unpack } = await import('msgpackr');
+    let value;
+    try {
+        value = unpack(bytes);
+    }
+    catch (cause) {
+        throw new TypeError('Schema installation evidence is malformed.', { cause });
+    }
+    return accept(value);
+}
+function accept(input) {
+    const value = record(input);
+    if (value.changed === true) {
+        exact(value, ['changed', 'receipt']);
+        const receipt = installReceipt.parse(value.receipt);
+        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(acceptDomainInfo);
+        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.');
+}
+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 { MEDIA_TYPE, decode, encode } from './codec.js';
 export * as introspection from './introspection/index.js';
-//# sourceMappingURL=index.d.ts.map
+export type { InstallResult } from './result.js';

package/dist/schema/installation/index.js

@@ -1,2 +1,2 @@
+export { MEDIA_TYPE, decode, encode } 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.v2+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>>;
-//# 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;