@astrale-os/kernel-protocol 0.5.0-beta.5 → 0.5.0-beta.51

package/dist/schema/installation/codec.js

@@ -0,0 +1,70 @@
+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) {
+    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,6 @@
 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 { 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
+export declare function acceptDomainInfo(input: unknown): DomainInfo;

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

@@ -1,24 +1,35 @@
-import { bundle } from '@astrale-os/kernel-dsl/v1';
-import * as artifact from '../../../artifact/index.js';
-import { json } from '../../../codecs/index.js';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
+import { revision as schemaRevision } from '@astrale-os/kernel-dsl/v1/schema/revision';
+import { admitCallableBinding, admitViewBinding } from '../../../publication/bindings/index.js';
 import * as publication from '../../../publication/index.js';
-import * as runtime from '../../../runtime/index.js';
-export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v1+msgpack';
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v2+msgpack';
+const encodedBundles = new WeakMap();
+const admittedBundles = new Map();
+const MAXIMUM_ADMITTED_BUNDLES = 128;
 export async function encode(input, result) {
-    const fields = selected(input);
-    const wire = result === null ? null : encodeResult(fields, result);
-    const { pack } = await import(/* @vite-ignore */ 'msgpackr/pack');
+    const request = admitRequest(input);
+    const wire = request.kind === 'bundle'
+        ? encodeDomainBundle(result)
+        : encodeDomainInfo(result);
+    proveRequestedOrigin(request, result);
+    const { pack } = await import('msgpackr/pack');
     return new Uint8Array(pack(wire));
 }
 export async function decode(input, bytes, limits) {
+    const request = admitRequest(input);
     if (!(bytes instanceof Uint8Array))
         invalid('Schema introspection evidence must be binary.');
     admitLimit(limits.maximumPublicationBytes, 'Publication');
-    admitLimit(limits.maximumBundleBytes, 'Bundle');
-    if (bytes.byteLength > limits.maximumPublicationBytes + limits.maximumBundleBytes + 2_048) {
+    if (request.kind === 'bundle')
+        admitLimit(limits.maximumBundleBytes, 'Bundle');
+    const maximumEvidenceBytes = limits.maximumPublicationBytes +
+        (request.kind === 'bundle' ? limits.maximumBundleBytes : 0) +
+        4_096;
+    if (bytes.byteLength > maximumEvidenceBytes) {
         invalid('Schema introspection evidence exceeds its declared bounds.');
     }
-    const { unpack } = await import(/* @vite-ignore */ 'msgpackr/unpack');
+    const { unpack } = await import('msgpackr');
     let decoded;
     try {
         decoded = unpack(bytes);
@@ -26,202 +37,147 @@ export async function decode(input, bytes, limits) {
     catch (cause) {
         throw new TypeError('Schema introspection evidence is malformed.', { cause });
     }
-    if (decoded === null)
-        return null;
-    if (!isRecord(decoded))
-        invalid('Schema introspection result must be an object or null.');
-    const fields = selected(input);
-    exact(decoded, fields, 'Schema introspection result');
-    return decodeResult(fields, decoded, limits);
-}
-function encodeResult(fields, result) {
-    exact(result, fields, 'Schema introspection result');
-    const source = fields.includes('source') ? encodeSource(result.source) : undefined;
-    const output = {};
-    for (const field of fields) {
-        switch (field) {
-            case 'state':
-                output.state = state(result.state);
-                break;
-            case 'target':
-                output.target = digest(result.target, 'Installation target');
-                break;
-            case 'source':
-                output.source = source;
-                break;
-            case 'bundle':
-                output.bundle = encodeBundle(result.bundle, result.source);
-                break;
-            case 'readiness':
-                output.readiness =
-                    result.readiness === null ? null : digest(result.readiness, 'Installation readiness');
-                break;
-            case 'capabilities':
-                output.capabilities = capabilities(result.capabilities);
-                break;
-        }
-    }
-    return Object.freeze(output);
-}
-function decodeResult(fields, input, limits) {
-    const source = fields.includes('source') ? decodeSource(input.source, limits) : undefined;
-    const output = {};
-    for (const field of fields) {
-        switch (field) {
-            case 'state':
-                output.state = state(input.state);
-                break;
-            case 'target':
-                output.target = digest(input.target, 'Installation target');
-                break;
-            case 'source':
-                output.source = source;
-                break;
-            case 'bundle':
-                output.bundle = decodeBundle(input.bundle, source, limits.maximumBundleBytes);
-                break;
-            case 'readiness':
-                output.readiness =
-                    input.readiness === null ? null : digest(input.readiness, 'Installation readiness');
-                break;
-            case 'capabilities':
-                output.capabilities = capabilities(input.capabilities);
-                break;
-        }
+    const result = (request.kind === 'bundle'
+        ? decodeDomainBundle(decoded, limits.maximumBundleBytes)
+        : acceptDomainInfo(decoded));
+    proveRequestedOrigin(request, result);
+    return result;
+}
+function proveRequestedOrigin(request, result) {
+    const origin = request.kind === 'bundle'
+        ? result.domain.origin
+        : result.origin;
+    if (origin !== request.origin)
+        invalid('Schema introspection evidence does not match the requested origin.');
+}
+function encodeDomainBundle(input) {
+    exact(input, ['bundle', 'domain'], 'Domain Bundle result');
+    const admittedDomain = acceptDomainInfo(input.domain);
+    const domain = encodeDomainInfo(admittedDomain);
+    proveBundle(input.bundle, admittedDomain);
+    const encoded = encodedBundles.get(input.bundle) ?? bundle.encode(input.bundle);
+    if (!encodedBundles.has(input.bundle))
+        encodedBundles.set(input.bundle, encoded);
+    return Object.freeze({ domain, bundle: encoded });
+}
+function decodeDomainBundle(input, maximum) {
+    const value = record(input, 'Domain Bundle result');
+    exact(value, ['bundle', 'domain'], 'Domain Bundle result');
+    const domain = acceptDomainInfo(value.domain);
+    const encoded = boundedBytes(value.bundle, maximum, 'Bundle');
+    const cached = admittedBundles.get(domain.generation);
+    if (cached !== undefined && sameBytes(cached.bytes, encoded)) {
+        return Object.freeze({ domain, bundle: cached.bundle });
     }
-    if (output.state === 'ready' && Object.hasOwn(output, 'readiness') && output.readiness === null) {
-        invalid('A ready Installation requires readiness evidence.');
+    let admitted;
+    try {
+        admitted = bundle.decode(encoded);
     }
-    return Object.freeze(output);
-}
-function encodeSource(input) {
-    if (input?.kind === 'builtin') {
-        return Object.freeze({
-            kind: 'builtin',
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Builtin schema Bundle'),
-        });
+    catch (cause) {
+        throw new TypeError('Installed Domain Bundle is invalid.', { cause });
+    }
+    proveBundle(admitted, domain);
+    admittedBundles.delete(domain.generation);
+    admittedBundles.set(domain.generation, Object.freeze({ bytes: encoded, bundle: admitted }));
+    if (admittedBundles.size > MAXIMUM_ADMITTED_BUNDLES) {
+        admittedBundles.delete(admittedBundles.keys().next().value);
+    }
+    return Object.freeze({ domain, bundle: admitted });
+}
+function sameBytes(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        if (left[index] !== right[index])
+            return false;
+    }
+    return true;
+}
+function encodeDomainInfo(input) {
+    return acceptDomainInfo(input);
+}
+export function acceptDomainInfo(input) {
+    const value = record(input, 'Domain info');
+    exact(value, ['bindings', 'capabilities', 'generation', 'origin', 'publication', 'readiness', 'revision'], 'Domain info');
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Domain info origin is invalid.');
+    }
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
+        invalid('Domain info revision is invalid.');
+    }
+    const origin = value.origin;
+    const revision = value.revision;
+    const published = publicationReference(value.publication, origin, revision);
+    return Object.freeze({
+        origin,
+        revision,
+        generation: digest(value.generation, 'Domain generation'),
+        publication: published,
+        readiness: digest(value.readiness, 'Domain readiness'),
+        capabilities: capabilities(value.capabilities),
+        bindings: bindings(value.bindings, origin),
+    });
+}
+function publicationReference(input, origin, revision) {
+    if (input === null)
+        return null;
+    let admitted;
+    try {
+        admitted = publication.acceptReference(input);
     }
-    if (input?.kind === 'local') {
-        return Object.freeze({
-            kind: 'local',
-            artifact: ref(input.artifact, runtime.MEDIA_TYPE, 'Local Runtime Artifact'),
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Local schema Bundle'),
-        });
+    catch (cause) {
+        throw new TypeError('Domain Publication metadata is invalid.', { cause });
     }
-    if (input?.kind === 'remote') {
-        return Object.freeze({
-            kind: 'remote',
-            publication: publication.encode(publication.accept(input.publication)),
-        });
+    if (admitted.origin !== origin || admitted.revision !== revision) {
+        invalid('Domain Publication metadata does not match its Schema coordinate.');
     }
-    return invalid('Installation source is invalid.');
+    return admitted;
 }
-function decodeSource(input, limits) {
-    if (!isRecord(input))
-        invalid('Installation source is invalid.');
-    if (input.kind === 'builtin') {
-        exact(input, ['bundle', 'kind'], 'Builtin installation source');
-        return Object.freeze({
-            kind: 'builtin',
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Builtin schema Bundle'),
-        });
+function bindings(input, origin) {
+    const value = record(input, 'Domain bindings');
+    exact(value, ['callables', 'views'], 'Domain bindings');
+    if (!Array.isArray(value.callables) || !Array.isArray(value.views)) {
+        invalid('Domain bindings are invalid.');
     }
-    if (input.kind === 'local') {
-        exact(input, ['artifact', 'bundle', 'kind'], 'Local installation source');
+    try {
         return Object.freeze({
-            kind: 'local',
-            artifact: ref(input.artifact, runtime.MEDIA_TYPE, 'Local Runtime Artifact'),
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Local schema Bundle'),
+            callables: Object.freeze(value.callables.map((entry) => admitCallableBinding(entry, origin))),
+            views: Object.freeze(value.views.map((entry) => admitViewBinding(entry, origin))),
         });
     }
-    if (input.kind === 'remote') {
-        exact(input, ['kind', 'publication'], 'Remote installation source');
-        const encoded = boundedBytes(input.publication, limits.maximumPublicationBytes, 'Publication');
-        let admitted;
-        try {
-            admitted = publication.accept(json.decode(encoded));
-        }
-        catch (cause) {
-            throw new TypeError('Remote installed Publication is invalid.', { cause });
-        }
-        if (!equal(encoded, publication.encode(admitted))) {
-            invalid('Remote installed Publication is not canonical.');
-        }
-        return Object.freeze({ kind: 'remote', publication: admitted });
-    }
-    return invalid('Installation source kind is invalid.');
-}
-function encodeBundle(input, source) {
-    if (source === undefined || input === undefined)
-        invalid('Bundle source evidence is missing.');
-    const admitted = source.kind === 'remote'
-        ? publication.acceptBundle(source.publication, input)
-        : bundle.accept(input);
-    const encoded = bundle.encode(admitted);
-    if (source.kind !== 'remote' &&
-        !same(artifact.identify(encoded, publication.BUNDLE_MEDIA_TYPE), source.bundle)) {
-        invalid('Local schema Bundle does not match its source Ref.');
-    }
-    return encoded;
-}
-function decodeBundle(input, source, maximum) {
-    const encoded = boundedBytes(input, maximum, 'Bundle');
-    let admitted;
-    try {
-        admitted =
-            source.kind === 'remote'
-                ? publication.decodeBundle(source.publication, encoded)
-                : bundle.decode(encoded);
-    }
     catch (cause) {
-        throw new TypeError('Installed schema Bundle is invalid.', { cause });
-    }
-    if (!equal(encoded, bundle.encode(admitted)))
-        invalid('Installed schema Bundle is not canonical.');
-    if (source.kind !== 'remote' &&
-        !same(artifact.identify(encoded, publication.BUNDLE_MEDIA_TYPE), source.bundle)) {
-        invalid('Local schema Bundle does not match its source Ref.');
+        throw new TypeError('Domain bindings are invalid.', { cause });
     }
-    return admitted;
 }
-function selected(input) {
-    if (input === null ||
-        typeof input !== 'object' ||
-        input.from?.kind !== 'installation' ||
-        input.select === null ||
-        typeof input.select !== 'object') {
-        invalid('Schema introspection request is invalid.');
-    }
-    const allowed = ['state', 'target', 'source', 'bundle', 'readiness', 'capabilities'];
-    const fields = Object.keys(input.select);
-    if (fields.length === 0 ||
-        fields.some((field) => !allowed.includes(field) ||
-            input.select[field] !== true) ||
-        (input.select.bundle === true && input.select.source !== true)) {
-        invalid('Schema introspection selection is invalid.');
+function proveBundle(input, domain) {
+    if (input.root.origin !== domain.origin || schemaRevision(input.root) !== domain.revision) {
+        invalid('Installed Bundle root does not match the ready Domain coordinate.');
     }
-    return Object.freeze(allowed.filter((field) => input.select[field] === true));
 }
 function capabilities(input) {
-    if (!isRecord(input))
-        invalid('Installation capabilities are invalid.');
-    exact(input, ['materialized', 'requested'], 'Installation capabilities');
+    const value = record(input, 'Domain capabilities');
+    exact(value, ['materialized', 'requested'], 'Domain capabilities');
     try {
-        const requested = publication.admitRequirements({ capabilities: input.requested }).capabilities;
+        const requested = publication.admitRequirements({ capabilities: value.requested }).capabilities;
         const materialized = publication.admitRequirements({
-            capabilities: input.materialized,
+            capabilities: value.materialized,
         }).capabilities;
         return Object.freeze({ requested, materialized });
     }
     catch (cause) {
-        throw new TypeError('Installation capabilities are invalid.', { cause });
+        throw new TypeError('Domain capabilities are invalid.', { cause });
     }
 }
-function state(input) {
-    if (input !== 'installed' && input !== 'ready' && input !== 'removing') {
-        invalid('Installation state is invalid.');
+function admitRequest(input) {
+    const value = record(input, 'Schema introspection request');
+    exact(value, ['kind', 'origin'], 'Schema introspection request');
+    if (value.kind !== 'inspect' && value.kind !== 'bundle') {
+        invalid('Schema introspection kind is invalid.');
     }
-    return input;
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Schema introspection origin is invalid.');
+    }
+    return Object.freeze({ kind: value.kind, origin: value.origin });
 }
 function digest(input, label) {
     if (typeof input !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(input)) {
@@ -229,21 +185,6 @@ function digest(input, label) {
     }
     return input;
 }
-function ref(input, mediaType, label) {
-    let admitted;
-    try {
-        admitted = artifact.accept(input);
-    }
-    catch (cause) {
-        throw new TypeError(`${label} Ref is invalid.`, { cause });
-    }
-    if (admitted.mediaType !== mediaType)
-        invalid(`${label} media type is invalid.`);
-    return admitted;
-}
-function same(left, right) {
-    return (left.digest === right.digest && left.mediaType === right.mediaType && left.size === right.size);
-}
 function boundedBytes(input, maximum, label) {
     if (!(input instanceof Uint8Array) || input.byteLength === 0 || input.byteLength > maximum) {
         invalid(`${label} evidence is invalid or exceeds its bound.`);
@@ -254,6 +195,12 @@ function admitLimit(input, label) {
     if (!Number.isSafeInteger(input) || input < 1)
         invalid(`${label} evidence bound is invalid.`);
 }
+function record(input, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        invalid(`${label} is invalid.`);
+    }
+    return input;
+}
 function exact(input, expected, label) {
     const keys = Object.keys(input).sort();
     const wanted = [...expected].sort();
@@ -261,13 +208,6 @@ function exact(input, expected, label) {
         invalid(`${label} fields are invalid.`);
     }
 }
-function equal(left, right) {
-    return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
-}
-function isRecord(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input);
-}
 function invalid(message) {
     throw new TypeError(message);
 }
-//# sourceMappingURL=codec.js.map

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

@@ -1,3 +1,2 @@
-export { MEDIA_TYPE, decode, encode } from './codec.js';
-export type { Digest, Installation, Limits, ResultFor, Source } from './result.js';
-//# sourceMappingURL=index.d.ts.map
+export { MEDIA_TYPE, acceptDomainInfo, decode, encode } from './codec.js';
+export type { Digest, DomainBundle, DomainInfo, Limits, ResultFor } from './result.js';

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

@@ -1,2 +1 @@
-export { MEDIA_TYPE, decode, encode } from './codec.js';
-//# sourceMappingURL=index.js.map
+export { MEDIA_TYPE, acceptDomainInfo, decode, encode } from './codec.js';

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

@@ -1,34 +1,29 @@
 import type { introspection } from '@astrale-os/kernel-core/schema';
-import type { bundle } from '@astrale-os/kernel-dsl/v1';
-import type { Ref } from '../../../artifact/index.js';
-import type { Publication } from '../../../publication/index.js';
-import type { PublicationRequirements } from '../../../publication/index.js';
+import type { bundle, Key, Revision } from '@astrale-os/kernel-dsl/v1';
+import type { Publication, PublicationRef, PublicationRequirements } from '../../../publication/index.js';
 export type Digest = `sha256:${string}`;
-export type Source = {
-    readonly kind: 'builtin';
-    readonly bundle: Ref;
-} | {
-    readonly kind: 'local';
-    readonly artifact: Ref;
-    readonly bundle: Ref;
-} | {
-    readonly kind: 'remote';
-    readonly publication: Publication;
-};
-export interface Installation {
-    readonly state: 'installed' | 'ready' | 'removing';
-    readonly target: Digest;
-    readonly source: Source;
-    readonly bundle: bundle.Bundle;
-    readonly readiness: Digest | null;
+/** Lightweight proof of one exact ready installed Domain generation. */
+export interface DomainInfo {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly generation: Digest;
+    readonly publication: PublicationRef | null;
+    readonly readiness: Digest;
     readonly capabilities: {
         readonly requested: PublicationRequirements['capabilities'];
         readonly materialized: PublicationRequirements['capabilities'];
     };
+    readonly bindings: Publication['bindings'];
+}
+/** Explicit complete Bundle observed coherently with its ready Domain generation. */
+export interface DomainBundle {
+    readonly domain: DomainInfo;
+    readonly bundle: bundle.Bundle;
 }
-export type ResultFor<Input extends introspection.Introspection> = Pick<Installation, Extract<keyof Input['select'], keyof Installation>> | null;
+export type ResultFor<Input extends introspection.Introspection> = Input extends {
+    readonly kind: 'bundle';
+} ? DomainBundle : DomainInfo;
 export interface Limits {
     readonly maximumPublicationBytes: number;
     readonly maximumBundleBytes: number;
 }
-//# sourceMappingURL=result.d.ts.map

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

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

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

@@ -0,0 +1,9 @@
+import type { InstallReceipt } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
+import type { DomainInfo } from './introspection/index.js';
+export type InstallResult = {
+    readonly changed: true;
+    readonly receipt: InstallReceipt;
+} | {
+    readonly changed: false;
+    readonly domains: readonly [DomainInfo, ...DomainInfo[]];
+};

package/dist/schema/installation/result.js

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