@astrale-os/kernel-protocol 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/errors/retry.d.ts

@@ -9,6 +9,8 @@ export declare const RETRY_REASONS: Readonly<{
     readonly CAPACITY_EXHAUSTED: 'CAPACITY_EXHAUSTED';
     /** The server stopped admitting work before it shuts down. */
     readonly SERVER_DRAINING: 'SERVER_DRAINING';
+    /** The Instance is under a maintenance session that admits only its root operator. */
+    readonly INSTANCE_MAINTENANCE: 'INSTANCE_MAINTENANCE';
 }>;
 export type RetryReasonCode = (typeof RETRY_REASONS)[keyof typeof RETRY_REASONS];
 export type RetryReason<Code extends RetryReasonCode = RetryReasonCode> = ErrorReason<Code, {
@@ -17,7 +19,7 @@ export type RetryReason<Code extends RetryReasonCode = RetryReasonCode> = ErrorR
 /** One hour bounds a hint that only schedules the next attempt. */
 export declare const MAXIMUM_RETRY_AFTER_MS = 3600000;
 export declare function retryReason<Code extends RetryReasonCode>(code: Code, retryAfterMs: number): RetryReason<Code>;
-/** Return the retry delay of a back-pressure or draining refusal, and nothing for other errors. */
+/** Return the retry delay of a back-pressure, draining or maintenance refusal, and nothing else. */
 export declare function retryAfterOf(error: ErrorPayload): number | undefined;
 /** Present a retry delay as an HTTP `Retry-After` delta in whole seconds, rounded up. */
 export declare function retryAfterField(retryAfterMs: number): string;

package/dist/errors/retry.js

@@ -9,6 +9,8 @@ export const RETRY_REASONS = Object.freeze({
     CAPACITY_EXHAUSTED: 'CAPACITY_EXHAUSTED',
     /** The server stopped admitting work before it shuts down. */
     SERVER_DRAINING: 'SERVER_DRAINING',
+    /** The Instance is under a maintenance session that admits only its root operator. */
+    INSTANCE_MAINTENANCE: 'INSTANCE_MAINTENANCE',
 });
 /** One hour bounds a hint that only schedules the next attempt. */
 export const MAXIMUM_RETRY_AFTER_MS = 3_600_000;
@@ -20,7 +22,7 @@ export function retryReason(code, retryAfterMs) {
         throw new TypeError('Retry reason retryAfterMs is invalid.');
     return Object.freeze({ code, details: Object.freeze({ retryAfterMs }) });
 }
-/** Return the retry delay of a back-pressure or draining refusal, and nothing for other errors. */
+/** Return the retry delay of a back-pressure, draining or maintenance refusal, and nothing else. */
 export function retryAfterOf(error) {
     if (error.code !== CODES.BACKEND_UNAVAILABLE)
         return undefined;

package/dist/invocation/index.d.ts

@@ -5,13 +5,14 @@ export { acceptIdempotencyKey, HTTP_IDEMPOTENCY_KEY, MAXIMUM_IDEMPOTENCY_KEY_LEN
 export { acceptInvocationId, InvocationError, MAXIMUM_INVOCATION_ID_LENGTH, sameInvocationId, type InvocationId, } from './identity.js';
 export * as http from './http/index.js';
 export { acceptDelegate, type Delegate } from './delegate.js';
+export { acceptMaintenance, MAXIMUM_MAINTENANCE_SESSION_LENGTH, type Maintenance, type MaintenanceSession, } from './maintenance.js';
 export { decodeMiss, miss, type Miss } from './miss.js';
 export { acceptRoute, acceptRedirection, decodeRedirectResponse, remoteRoute, type RemoteBindingInput, type Redirection, type RedirectResponse, type Route, } from './redirect.js';
 export { decodeRequest, type Request } from './request.js';
 export { admitTrace, MAXIMUM_TRACEPARENT_BYTES, MAXIMUM_TRACESTATE_BYTES, MAXIMUM_TRACESTATE_MEMBERS, type Trace, } from './trace.js';
 export { acceptRouting, routedDigest, routedRevision, type Refresh, type Routing, type Via, } from './routing.js';
 export { acceptSchemaTarget, type SchemaTarget } from './schema.js';
-export { decodeResponse, type ErrorResponse, type Response, type ResponseContext, type SuccessResponse, } from './response.js';
+export { decodeResponse, type ErrorResponse, type ExecutionResponse, type Response, type ResponseContext, type SuccessResponse, } from './response.js';
 export { CALLABLE_FINGERPRINT_MISMATCH, DEPLOYMENT_RETIRED, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, type CallableFingerprintMismatchDetails, type CallableFingerprintMismatchReason, type DeploymentRetiredDetails, type DeploymentRetiredReason, type ServiceCandidateInvalidDetails, type ServiceCandidateInvalidReason, type ServiceErrorPayload, type ServiceReason, type ServiceTrustRequiredDetails, type ServiceTrustRequiredReason, type ServiceUnavailableDetails, type ServiceUnavailableReason, } from './service-reason.js';
 export { decodeStale, stale, type Stale } from './stale-route.js';
 export { decodeStreamFrame, type StreamEndFrame, type StreamErrorFrame, type StreamFrame, type StreamItemFrame, type StreamStartFrame, } from './stream.js';

package/dist/invocation/index.js

@@ -5,6 +5,7 @@ export { acceptIdempotencyKey, HTTP_IDEMPOTENCY_KEY, MAXIMUM_IDEMPOTENCY_KEY_LEN
 export { acceptInvocationId, InvocationError, MAXIMUM_INVOCATION_ID_LENGTH, sameInvocationId, } from './identity.js';
 export * as http from './http/index.js';
 export { acceptDelegate } from './delegate.js';
+export { acceptMaintenance, MAXIMUM_MAINTENANCE_SESSION_LENGTH, } from './maintenance.js';
 export { decodeMiss, miss } from './miss.js';
 export { acceptRoute, acceptRedirection, decodeRedirectResponse, remoteRoute, } from './redirect.js';
 export { decodeRequest } from './request.js';

package/dist/invocation/maintenance.d.ts

@@ -0,0 +1,14 @@
+declare const MAINTENANCE_SESSION: unique symbol;
+/** Identity of the install Execution that owns one maintenance session; it grants no authority. */
+export type MaintenanceSession = string & {
+    readonly [MAINTENANCE_SESSION]: true;
+};
+/** Source-Kernel guard naming the maintenance session a root request expects to act within. */
+export interface Maintenance {
+    readonly session: MaintenanceSession;
+}
+/** An Execution identifier: 1-255 ASCII characters drawn from `[A-Za-z0-9._-]`. */
+export declare const MAXIMUM_MAINTENANCE_SESSION_LENGTH = 255;
+/** Admit one exact maintenance guard without deciding whether its session is active. */
+export declare function acceptMaintenance(input: unknown): Maintenance;
+export {};

package/dist/invocation/maintenance.js

@@ -0,0 +1,18 @@
+import { isNodeId } from '@astrale-os/kernel-core/graph/node';
+import { exactFields, invalid, portableObject, required } from './admission.js';
+/** An Execution identifier: 1-255 ASCII characters drawn from `[A-Za-z0-9._-]`. */
+export const MAXIMUM_MAINTENANCE_SESSION_LENGTH = 255;
+const FIELDS = new Set(['session']);
+/** Admit one exact maintenance guard without deciding whether its session is active. */
+export function acceptMaintenance(input) {
+    const object = portableObject(input, 'maintenance');
+    exactFields(object, FIELDS, 'maintenance');
+    required(object, ['session'], 'maintenance');
+    // An Execution identifier shares the Core NodeId grammar; it names no graph Node.
+    const session = object.session;
+    if (!isNodeId(session)) {
+        invalid('maintenance.session must contain 1-255 ASCII characters drawn from [A-Za-z0-9._-]');
+    }
+    const admitted = session;
+    return Object.freeze({ session: admitted });
+}

package/dist/invocation/request.d.ts

@@ -1,6 +1,7 @@
 import type { RequestId } from './correlation.js';
 import type { Delegate } from './delegate.js';
 import type { IdempotencyKey } from './idempotency.js';
+import type { Maintenance } from './maintenance.js';
 import type { Routing } from './routing.js';
 import type { SchemaTarget } from './schema.js';
 import type { Call } from './target.js';
@@ -15,6 +16,8 @@ export interface Request {
     readonly routing?: Routing;
     /** Source-Kernel precondition; forbidden on an already-routed destination request. */
     readonly schema?: SchemaTarget;
+    /** Source-Kernel maintenance session guard; forbidden on an already-routed destination request. */
+    readonly maintenance?: Maintenance;
     readonly idempotencyKey?: IdempotencyKey;
     readonly trace?: Trace;
 }

package/dist/invocation/request.js

@@ -1,6 +1,7 @@
 import { exactFields, invalid, portableObject, requestId, required, string } from './admission.js';
 import { acceptDelegate } from './delegate.js';
 import { acceptIdempotencyKey } from './idempotency.js';
+import { acceptMaintenance } from './maintenance.js';
 import { acceptRouting } from './routing.js';
 import { acceptSchemaTarget } from './schema.js';
 import { callFromSnapshot } from './target.js';
@@ -13,6 +14,7 @@ const REQUEST_FIELDS = new Set([
     'delegate',
     'routing',
     'schema',
+    'maintenance',
     'idempotencyKey',
     'trace',
 ]);
@@ -26,12 +28,16 @@ export function decodeRequest(input) {
     const delegate = object.delegate === undefined ? undefined : acceptDelegate(object.delegate);
     const routing = object.routing === undefined ? undefined : acceptRouting(object.routing);
     const schema = object.schema === undefined ? undefined : acceptSchemaTarget(object.schema);
+    const maintenance = object.maintenance === undefined ? undefined : acceptMaintenance(object.maintenance);
     const trace = object.trace === undefined ? undefined : admitTrace(object.trace);
     if (routing?.kind === 'via') {
         if (delegate !== undefined)
             invalid('destination requests with via routing forbid delegate');
         if (schema !== undefined)
             invalid('destination requests with via routing forbid schema target');
+        if (maintenance !== undefined) {
+            invalid('destination requests with via routing forbid maintenance');
+        }
     }
     else if ((credential === undefined) !== (delegate === undefined)) {
         invalid('source requests require credential and delegate together');
@@ -44,6 +50,7 @@ export function decodeRequest(input) {
         ...(delegate === undefined ? {} : { delegate }),
         ...(routing === undefined ? {} : { routing }),
         ...(schema === undefined ? {} : { schema }),
+        ...(maintenance === undefined ? {} : { maintenance }),
         ...(object.idempotencyKey === undefined
             ? {}
             : {

package/dist/invocation/response.d.ts

@@ -1,4 +1,5 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
+import { type NodeId } from '@astrale-os/kernel-core/graph/node';
 import type { ErrorPayload } from '../errors/index.js';
 import type { RequestId } from './correlation.js';
 import type { InvocationId } from './identity.js';
@@ -15,5 +16,14 @@ export interface SuccessResponse<Result extends Value = Value> extends ResponseC
 export interface ErrorResponse extends ResponseContext {
     readonly error: ErrorPayload;
 }
-export type Response<Result extends Value = Value> = SuccessResponse<Result> | ErrorResponse | RedirectResponse | Stale | Miss;
+/** A durable call's answer: the Execution it started or recovered, never a handler result. */
+export interface ExecutionResponse extends ResponseContext {
+    readonly execution: NodeId;
+    /**
+     * False when this call created the Execution, true when its key already named it; absent when
+     * the Host does not say.
+     */
+    readonly replayed?: boolean;
+}
+export type Response<Result extends Value = Value> = SuccessResponse<Result> | ErrorResponse | ExecutionResponse | RedirectResponse | Stale | Miss;
 export declare function decodeResponse(input: unknown): Response;

package/dist/invocation/response.js

@@ -1,17 +1,18 @@
+import { isNodeId } from '@astrale-os/kernel-core/graph/node';
 import { errorPayload, exactFields, invalid, invocation, portableObject, requestId, required, } from './admission.js';
 import { decodeMiss } from './miss.js';
 import { decodeRedirectResponse } from './redirect.js';
 import { decodeStale } from './stale-route.js';
 const SUCCESS_FIELDS = new Set(['result', 'requestId', 'invocation']);
 const ERROR_FIELDS = new Set(['error', 'requestId', 'invocation']);
+const EXECUTION_FIELDS = new Set(['execution', 'replayed', 'requestId', 'invocation']);
 export function decodeResponse(input) {
     const object = portableObject(input, 'response');
-    const hasResult = Object.hasOwn(object, 'result');
-    const hasError = Object.hasOwn(object, 'error');
-    if (hasResult || hasError) {
-        if (hasResult === hasError)
-            invalid('response must contain exactly one of result or error');
-        if (hasResult) {
+    const outcomes = ['result', 'error', 'execution'].filter((field) => Object.hasOwn(object, field));
+    if (outcomes.length > 1)
+        invalid('response must contain exactly one of result, error or execution');
+    switch (outcomes[0]) {
+        case 'result':
             exactFields(object, SUCCESS_FIELDS, 'response');
             required(object, ['requestId', 'invocation'], 'response');
             return Object.freeze({
@@ -19,14 +20,27 @@ export function decodeResponse(input) {
                 requestId: requestId(object.requestId, 'response.requestId'),
                 invocation: invocation(object.invocation, 'response.invocation'),
             });
-        }
-        exactFields(object, ERROR_FIELDS, 'response');
-        required(object, ['requestId', 'error', 'invocation'], 'response');
-        return Object.freeze({
-            error: errorPayload(object.error, 'response.error'),
-            requestId: requestId(object.requestId, 'response.requestId'),
-            invocation: invocation(object.invocation, 'response.invocation'),
-        });
+        case 'error':
+            exactFields(object, ERROR_FIELDS, 'response');
+            required(object, ['requestId', 'error', 'invocation'], 'response');
+            return Object.freeze({
+                error: errorPayload(object.error, 'response.error'),
+                requestId: requestId(object.requestId, 'response.requestId'),
+                invocation: invocation(object.invocation, 'response.invocation'),
+            });
+        case 'execution':
+            exactFields(object, EXECUTION_FIELDS, 'response');
+            required(object, ['requestId', 'execution', 'invocation'], 'response');
+            if (!isNodeId(object.execution))
+                invalid('response.execution must be a NodeId');
+            if (Object.hasOwn(object, 'replayed') && typeof object.replayed !== 'boolean')
+                invalid('response.replayed must be a boolean');
+            return Object.freeze({
+                execution: object.execution,
+                ...(typeof object.replayed === 'boolean' ? { replayed: object.replayed } : {}),
+                requestId: requestId(object.requestId, 'response.requestId'),
+                invocation: invocation(object.invocation, 'response.invocation'),
+            });
     }
     if (object.kind === 'redirect')
         return decodeRedirectResponse(object);
@@ -34,5 +48,5 @@ export function decodeResponse(input) {
         return decodeStale(object);
     if (object.kind === 'miss')
         return decodeMiss(object);
-    return invalid('response must contain a result, error, redirect, stale, or miss control');
+    return invalid('response must contain a result, error, execution, redirect, stale, or miss control');
 }

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

@@ -1,4 +1,9 @@
-import type { InstallResult } from './result.js';
-export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-installation.v3+json';
-export declare function encode(result: InstallResult): Promise<Uint8Array>;
-export declare function decode(bytes: Uint8Array, maximumBytes: number): Promise<InstallResult>;
+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

@@ -1,32 +1,18 @@
 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.v3+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);
-}
-function accept(input) {
+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 receipt = installReceipt.parse(value.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.');
         }
@@ -41,7 +27,7 @@ function accept(input) {
         if (!Array.isArray(value.domains) || value.domains.length === 0) {
             throw new TypeError('Schema installation unchanged Domains are empty.');
         }
-        const domains = value.domains.map(acceptDomainInfo);
+        const domains = value.domains.map(acceptGeneration);
         uniqueOrigins(domains.map((domain) => domain.origin), 'Schema installation unchanged Domains');
         return Object.freeze({
             changed: false,
@@ -50,6 +36,32 @@ function accept(input) {
     }
     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.`);

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

@@ -1,3 +1,3 @@
-export { MEDIA_TYPE, decode, encode } from './codec.js';
+export { acceptGeneration, acceptResult } from './codec.js';
 export * as introspection from './introspection/index.js';
-export type { InstallResult } from './result.js';
+export type { InstalledGeneration, InstallResult } from './result.js';

package/dist/schema/installation/index.js

@@ -1,2 +1,2 @@
-export { MEDIA_TYPE, decode, encode } from './codec.js';
+export { acceptGeneration, acceptResult } from './codec.js';
 export * as introspection from './introspection/index.js';

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

@@ -127,7 +127,10 @@ function acceptDependencyBinding(input) {
         binding: expected,
     });
 }
-/** Admit the installed listing: origin-ordered, one release per origin, each pin of one kind. */
+/**
+ * Admit the installed listing: origin-ordered, one installation per origin, each pin of one kind,
+ * with a deployment URL exactly for a release pin.
+ */
 function acceptInstalledReleases(input) {
     if (!Array.isArray(input))
         invalid('Installed releases are invalid.');
@@ -142,7 +145,11 @@ function acceptInstalledReleases(input) {
 }
 function acceptInstalledRelease(input) {
     const value = record(input, 'Installed release');
-    exact(value, ['inFlight', 'issuer', 'origin', 'pin', 'revision', 'url'], 'Installed release');
+    const pin = installedPin(value.pin);
+    // Only a release pin names a deployment: an artifact pin carries no URL.
+    exact(value, pin.kind === 'release'
+        ? ['inFlight', 'issuer', 'origin', 'pin', 'revision', 'url']
+        : ['inFlight', 'issuer', 'origin', 'pin', 'revision'], 'Installed release');
     if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
         invalid('Installed release origin is invalid.');
     }
@@ -154,8 +161,8 @@ function acceptInstalledRelease(input) {
         origin: value.origin,
         revision: value.revision,
         issuer,
-        url: deploymentUrl(value.url),
-        pin: installedPin(value.pin),
+        ...(pin.kind === 'release' ? { url: deploymentUrl(value.url) } : {}),
+        pin,
         inFlight: inFlightIssuers(value.inFlight, issuer),
     });
 }
@@ -169,6 +176,13 @@ function installedPin(input) {
             build: digest(value.build, 'Installed build'),
         });
     }
+    if (value.kind === 'artifact') {
+        exact(value, ['artifact', 'kind'], 'Installed artifact pin');
+        return Object.freeze({
+            kind: 'artifact',
+            artifact: digest(value.artifact, 'Installed artifact'),
+        });
+    }
     return invalid('Installed pin kind is invalid.');
 }
 function inFlightIssuers(input, current) {

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

@@ -38,12 +38,18 @@ export interface DomainDependencies {
     readonly domain: DomainInfo;
     readonly dependencies: readonly DependencyBinding[];
 }
-/** A DomainRelease v4 pin: its release digest beside the build digest it runs. */
-export interface InstalledPin {
+/**
+ * What one installation pins: a DomainRelease v4 pin, its release digest beside the build digest
+ * it runs, or, for a local install, the digest of the stored artifact its source named.
+ */
+export type InstalledPin = {
     readonly kind: 'release';
     readonly release: ReleaseDigest;
     readonly build: BuildDigest;
-}
+} | {
+    readonly kind: 'artifact';
+    readonly artifact: Digest;
+};
 /**
  * The issuer of a release one installation replaced, as the Kernel records it: accepted while its
  * work drains, and listed until a later consented install re-pins or prunes it, drained or not.
@@ -55,14 +61,20 @@ export interface InFlightIssuer {
     /** UTC millisecond ISO 8601 instant of the activation commit that replaced it. */
     readonly replacedAt: string;
 }
-/** One ready installation the Kernel pins to a deployment, as its caller can read it. */
+/**
+ * One ready installation the Kernel pins to a deployment or to a stored artifact, as its caller can
+ * read it.
+ */
 export interface InstalledRelease {
     readonly origin: Key.Origin;
     readonly revision: Revision;
     /** Issuer of the installation's Domain principal. */
     readonly issuer: IssuerId;
-    /** The deployment URL, an HTTP(S) origin, the Kernel discovered the pinned document at. */
-    readonly url: string;
+    /**
+     * The deployment URL, an HTTP(S) origin, the Kernel discovered the pinned document at: present
+     * exactly for a `release` pin, since an `artifact` pin names no deployment.
+     */
+    readonly url?: string;
     readonly pin: InstalledPin;
     /** Issuer-ordered, distinct, never the current issuer. */
     readonly inFlight: readonly InFlightIssuer[];

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

@@ -1,9 +1,15 @@
 import type { InstallReceipt } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
-import type { DomainInfo } from './introspection/index.js';
+import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
+/** One exact installed Domain generation: what an install that changes nothing reports. */
+export interface InstalledGeneration {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly generation: `sha256:${string}`;
+}
 export type InstallResult = {
     readonly changed: true;
     readonly receipt: InstallReceipt;
 } | {
     readonly changed: false;
-    readonly domains: readonly [DomainInfo, ...DomainInfo[]];
+    readonly domains: readonly [InstalledGeneration, ...InstalledGeneration[]];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-protocol",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.11",
   "description": "Portable Astrale invocation, Release, installation, routing, and issuer protocols",
   "license": "Apache-2.0",
   "repository": {
@@ -89,8 +89,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "1.0.0-beta.1",
-    "@astrale-os/kernel-dsl": "1.0.0-beta.1",
+    "@astrale-os/kernel-core": "1.0.0-beta.11",
+    "@astrale-os/kernel-dsl": "1.0.0-beta.5",
     "@noble/hashes": "2.3.0"
   },
   "devDependencies": {