@astrale-os/kernel-protocol 0.5.0-beta.7 → 0.5.0-beta.70

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 { InstallResult } from './result.js';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-installation.v2+json';
+export declare function encode(result: InstallResult): Promise<Uint8Array>;
+export declare function decode(bytes: Uint8Array, maximumBytes: number): Promise<InstallResult>;
+/**
+ * Package-private: admit one decoded installation result. Shared with the pre-R1 representation in
+ * `./legacy/`, which decodes other bytes into this same wire value.
+ */
+export declare function accept(input: unknown): InstallResult;

package/dist/schema/installation/codec.js

@@ -0,0 +1,74 @@
+import { installReceipt } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
+import { json } from '@astrale-os/kernel-dsl/value';
+import { acceptDomainInfo } from './introspection/index.js';
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-installation.v2+json';
+const encoder = new TextEncoder();
+export async function encode(result) {
+    return encoder.encode(json.serialize(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.');
+    }
+    let value;
+    try {
+        value = json.decode(bytes, { limits: { maxBytes: maximumBytes } });
+    }
+    catch (cause) {
+        throw new TypeError('Schema installation evidence is malformed.', { cause });
+    }
+    return accept(value);
+}
+/**
+ * Package-private: admit one decoded installation result. Shared with the pre-R1 representation in
+ * `./legacy/`, which decodes other bytes into this same wire value.
+ */
+export 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,17 @@
 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 { DomainBundle, DomainDependencies, DomainInfo, InstalledRelease, Limits, ResultFor } from './result.js';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-introspection.v3+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
+/**
+ * Package-private: admit one decoded evidence value for an admitted request. Shared with the
+ * pre-R1 representation in `../legacy/`, which decodes other bytes into this same wire value.
+ */
+export declare function acceptEvidence(request: introspection.Introspection, decoded: unknown, limits: Limits): DomainInfo | DomainBundle | DomainDependencies | readonly InstalledRelease[];
+/** Package-private: admit the evidence bounds a request declares. Shared with `../legacy/`. */
+export declare function admitLimits(request: introspection.Introspection, limits: Limits): void;
+/** 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;
+/** Package-private: admit one introspection request. Shared with `../legacy/`. */
+export declare function admitRequest(input: introspection.Introspection): introspection.Introspection;