@astrale-os/kernel-core 0.9.0-beta.9 → 0.9.0

package/dist/schema/kernel/schema.js

@@ -1,12 +1,12 @@
 import { defineSchema, schema } from '@astrale-os/kernel-dsl/v1';
 import { AuthorityOperations, CanCreate, CanDelete, CanGrant, CanRead, CanRevoke, CanTraverse, CanUse, CanUpdate, GovernedBy, Operation, Policy, } from '../authority/index.js';
-import { Function as FunctionClass, MethodOf, View, ViewFor } from '../callables/index.js';
+import { Entrypoint, Execution, Function as FunctionClass, MethodOf, View, } from '../callables/index.js';
 import { OperationCore } from '../core/index.js';
 import { Class, Extends, InstanceOf } from '../definitions/index.js';
 import { Domain as DomainClass, OfDomain } from '../domain/index.js';
 import { ConstrainedBy, ExcludedFrom, ExtendsWith, Identity } from '../identity/index.js';
-import { Descriptable, Edge, Iconable, Named, Node, Remotable, Statused, Timestamped, } from '../meta/index.js';
-import { Functions } from './syscalls/declarations/index.js';
+import { CreatedBy, Descriptable, Edge, Iconable, Named, Node, Remotable, Statused, Timestamped, } from '../meta/index.js';
+import { Functions, CanUseSyscall } from './syscalls/declarations/index.js';
 const KernelDefinitions = {
     classes: {
         Descriptable,
@@ -20,6 +20,7 @@ const KernelDefinitions = {
         Timestamped,
         Class,
         Domain: DomainClass,
+        Execution,
         Function: FunctionClass,
         Operation,
         Policy,
@@ -33,6 +34,8 @@ const KernelDefinitions = {
         can_revoke: CanRevoke,
         can_use: CanUse,
         constrained_by: ConstrainedBy,
+        created_by: CreatedBy,
+        entrypoint: Entrypoint,
         excluded_from: ExcludedFrom,
         extends: Extends,
         extends_with: ExtendsWith,
@@ -40,9 +43,8 @@ const KernelDefinitions = {
         instance_of: InstanceOf,
         method_of: MethodOf,
         of_domain: OfDomain,
-        view_for: ViewFor,
     },
-    policies: {},
+    policies: { canUseSyscall: CanUseSyscall },
     functions: Functions,
 };
 const KernelCore = Object.freeze({
@@ -50,6 +52,7 @@ const KernelCore = Object.freeze({
     edges: OperationCore.edges,
 });
 const KernelSchemaInput = {
+    name: 'Kernel',
     ...KernelDefinitions,
     core: KernelCore,
 };
@@ -71,13 +74,14 @@ export const AuthorityRelations = Object.freeze({
 export const KernelRootFunctions = Object.freeze([
     K.functions.query,
     K.functions.mutate,
-    K.functions.provision,
+    K.functions.upload,
+    K.functions.download,
+    K.functions.register,
     K.functions.install,
-    K.functions.introspect,
     K.functions.uninstall,
     K.functions.journal,
     K.classes.Identity.static.methods.whois,
-    K.classes.Identity.static.methods.mint,
+    K.classes.Identity.static.methods.impersonate,
     K.classes.View.static.methods.resolve,
 ].sort((left, right) => (left.key < right.key ? -1 : left.key > right.key ? 1 : 0)));
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';

package/dist/schema/kernel/syscalls/contracts/admit.d.ts

@@ -1,12 +1,15 @@
-import { z } from 'zod';
-export declare const admitInput: z.ZodObject<{
-    call: z.ZodObject<{
-        target: z.ZodString;
-        input: z.ZodUnknown;
-    }, z.core.$strict>;
-    credential: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const admitOutput: z.ZodObject<{
-    callable: z.ZodString;
-    receiver: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
+export declare const admitInput: import("zod").ZodObject<{
+    call: import("zod").ZodObject<{
+        target: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            callable: import("zod").ZodString;
+            instance: import("zod").ZodOptional<import("zod").ZodString>;
+            fingerprint: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>]>;
+        input: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strict>;
+    credential: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;
+export declare const admitOutput: import("zod").ZodObject<{
+    callable: import("zod").ZodString;
+    receiver: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;

package/dist/schema/kernel/syscalls/contracts/admit.js

@@ -1,12 +1,19 @@
-import { z } from 'zod';
-export const admitInput = z.strictObject({
-    call: z.strictObject({
-        target: z.string().min(1),
-        input: z.unknown(),
+import { strictObject, string, union, unknown as unknownSchema } from 'zod';
+export const admitInput = strictObject({
+    call: strictObject({
+        target: union([
+            string().min(1),
+            strictObject({
+                callable: string().min(1),
+                instance: string().min(1).optional(),
+                fingerprint: string().min(1).optional(),
+            }),
+        ]),
+        input: unknownSchema(),
     }),
-    credential: z.string().optional(),
+    credential: string().optional(),
 });
-export const admitOutput = z.strictObject({
-    callable: z.string().min(1),
-    receiver: z.string().min(1).optional(),
+export const admitOutput = strictObject({
+    callable: string().min(1),
+    receiver: string().min(1).optional(),
 });

package/dist/schema/kernel/syscalls/contracts/blob.d.ts

@@ -0,0 +1,31 @@
+export declare const MAXIMUM_BLOB_BYTES = 104857600;
+export declare const blobSlot: import("zod").ZodObject<{
+    node: import("zod").ZodString;
+    property: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const uploadInput: import("zod").ZodObject<{
+    mediaType: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const uploadOutput: import("zod").ZodObject<{
+    receipt: import("zod").ZodString;
+    ref: import("zod").ZodObject<{
+        digest: import("zod").ZodString;
+        mediaType: import("zod").ZodString;
+        size: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
+    expiresAt: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+/** Upper bound of one multi-slot download; a client splits larger slot lists. */
+export declare const MAXIMUM_DOWNLOAD_SLOTS = 256;
+/** Media type of a multi-slot download body: one length-prefixed part per slot, in slot order. */
+export declare const DOWNLOAD_PARTS_MEDIA_TYPE = "application/vnd.astrale.download-parts";
+/** One slot, the original contract, or an ordered slot list answered part by part. */
+export declare const downloadInput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    node: import("zod").ZodString;
+    property: import("zod").ZodString;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    slots: import("zod").ZodArray<import("zod").ZodObject<{
+        node: import("zod").ZodString;
+        property: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>]>;

package/dist/schema/kernel/syscalls/contracts/blob.js

@@ -0,0 +1,24 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { array, strictObject, string, union } from 'zod';
+import { artifactRef } from './installation.js';
+export const MAXIMUM_BLOB_BYTES = 104_857_600;
+export const blobSlot = strictObject({
+    node: string().check(fullMatch('[A-Za-z0-9._-]{1,255}')),
+    property: string().check(fullMatch(patterns.propertyKeyFullMatch)),
+});
+export const uploadInput = strictObject({ mediaType: string().min(1) });
+export const uploadOutput = strictObject({
+    receipt: string().min(1),
+    ref: artifactRef,
+    expiresAt: string().min(1),
+});
+/** Upper bound of one multi-slot download; a client splits larger slot lists. */
+export const MAXIMUM_DOWNLOAD_SLOTS = 256;
+/** Media type of a multi-slot download body: one length-prefixed part per slot, in slot order. */
+export const DOWNLOAD_PARTS_MEDIA_TYPE = 'application/vnd.astrale.download-parts';
+/** One slot, the original contract, or an ordered slot list answered part by part. */
+export const downloadInput = union([
+    blobSlot,
+    strictObject({ slots: array(blobSlot).min(1).max(MAXIMUM_DOWNLOAD_SLOTS) }),
+]);

package/dist/schema/kernel/syscalls/contracts/can.d.ts

@@ -1,8 +1,19 @@
-import { z } from 'zod';
-export declare const canInput: z.ZodObject<{
-    policy: z.ZodString;
-    object: z.ZodString;
-}, z.core.$strict>;
-export declare const canOutput: z.ZodObject<{
-    allowed: z.ZodBoolean;
-}, z.core.$strict>;
+/** Upper bound of one Identity.can batch; a client splits larger check sets. */
+export declare const MAXIMUM_CHECKS = 256;
+/** One check, the original contract, or an ordered batch answered check by check. */
+export declare const canInput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    policy: import("zod").ZodString;
+    object: import("zod").ZodString;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    checks: import("zod").ZodArray<import("zod").ZodObject<{
+        policy: import("zod").ZodString;
+        object: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>]>;
+export declare const canOutput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    allowed: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    decisions: import("zod").ZodArray<import("zod").ZodObject<{
+        allowed: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>]>;

package/dist/schema/kernel/syscalls/contracts/can.js

@@ -1,4 +1,12 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-export const canInput = z.strictObject({ policy: text, object: text });
-export const canOutput = z.strictObject({ allowed: z.boolean() });
+import { array, boolean, strictObject, string, union } from 'zod';
+/** Upper bound of one Identity.can batch; a client splits larger check sets. */
+export const MAXIMUM_CHECKS = 256;
+const text = string().min(1);
+const check = strictObject({ policy: text, object: text });
+const decision = strictObject({ allowed: boolean() });
+/** One check, the original contract, or an ordered batch answered check by check. */
+export const canInput = union([
+    check,
+    strictObject({ checks: array(check).min(1).max(MAXIMUM_CHECKS) }),
+]);
+export const canOutput = union([decision, strictObject({ decisions: array(decision) })]);

package/dist/schema/kernel/syscalls/contracts/delegate.d.ts

@@ -1,7 +1,6 @@
-import { z } from 'zod';
-export declare const delegateInput: z.ZodObject<{
-    audience: z.ZodString;
-    ttlSeconds: z.ZodNumber;
-    attenuation: z.ZodUnknown;
-}, z.core.$strict>;
-export declare const delegateOutput: z.ZodString;
+export declare const delegateInput: import("zod").ZodObject<{
+    principal: import("zod").ZodString;
+    audience: import("zod").ZodString;
+    ttlSeconds: import("zod").ZodNumber;
+}, import("zod/v4/core").$strict>;
+export declare const delegateOutput: import("zod").ZodString;

package/dist/schema/kernel/syscalls/contracts/delegate.js

@@ -1,8 +1,8 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-export const delegateInput = z.strictObject({
+import { number, strictObject, string } from 'zod';
+const text = string().min(1);
+export const delegateInput = strictObject({
+    principal: text,
     audience: text,
-    ttlSeconds: z.number().int().min(1),
-    attenuation: z.unknown(),
+    ttlSeconds: number().int().min(1),
 });
 export const delegateOutput = text;

package/dist/schema/kernel/syscalls/contracts/execution.d.ts

@@ -0,0 +1,300 @@
+import { type InstallClass, type InstallMode, type ValidationOptions } from './install.js';
+/** Terminal outcome of one durable call; a handler failure is an outcome, not a call error. */
+export declare const executionOutcome: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"completed">;
+    value: import("zod").ZodUnknown;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"failed">;
+    error: import("zod").ZodObject<{
+        code: import("zod").ZodString;
+        message: import("zod").ZodString;
+        family: import("zod").ZodOptional<import("zod").ZodString>;
+        details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"cancelled">;
+}, import("zod/v4/core").$strict>]>;
+/**
+ * The steps a system execution reports as its `phase`: an install classifies, validates and
+ * activates; a repair session drains, awaits a command, attempts and activates; each ends
+ * `completed`, `rejected` or `cancelled`.
+ */
+export declare const SYSTEM_EXECUTION_PHASES: readonly ["classifying", "validating", "activating", "draining", "awaiting", "attempting", "completed", "rejected", "cancelled"];
+/** Continuity interruptions a validation survives before it ends. */
+export declare const MAXIMUM_VALIDATION_INTERRUPTIONS = 3;
+/**
+ * What a system execution shows beside its engine state, as the Runtime writes it and the Client
+ * reads it. `phase` is its own step; every other member is present only where it applies: the
+ * install's class, mode and validation options, the validation progress the store keeps, and for a
+ * repair session the admission it holds the Instance in, the `n` of the `command:<n>` signal it
+ * awaits and, while that wait is bounded, when it expires, the attempt running now, which the
+ * `abort:<number>` signal stops, and the last attempt that ended without activating, with its
+ * report. `uncertified` is the break-glass mark the Instance carries, shown on a live execution
+ * and on the session the mark names.
+ */
+export declare const systemExecutionDetail: import("zod").ZodObject<{
+    phase: import("zod").ZodEnum<{
+        activating: "activating";
+        attempting: "attempting";
+        awaiting: "awaiting";
+        cancelled: "cancelled";
+        classifying: "classifying";
+        completed: "completed";
+        draining: "draining";
+        rejected: "rejected";
+        validating: "validating";
+    }>;
+    class: import("zod").ZodOptional<import("zod").ZodEnum<{
+        immediate: "immediate";
+        noop: "noop";
+        revalidate: "revalidate";
+    }>>;
+    mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+        maintenance: "maintenance";
+        online: "online";
+    }>>;
+    validation: import("zod").ZodOptional<import("zod").ZodObject<{
+        scope: import("zod").ZodEnum<{
+            full: "full";
+            incremental: "incremental";
+        }>;
+        counts: import("zod").ZodEnum<{
+            exact: "exact";
+            sample: "sample";
+        }>;
+    }, import("zod/v4/core").$strict>>;
+    progress: import("zod").ZodOptional<import("zod").ZodObject<{
+        pages: import("zod").ZodNumber;
+        interruptions: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>>;
+    instance: import("zod").ZodOptional<import("zod").ZodEnum<{
+        attempt: "attempt";
+        draining: "draining";
+        open: "open";
+        repair: "repair";
+    }>>;
+    command: import("zod").ZodOptional<import("zod").ZodNumber>;
+    expires: import("zod").ZodOptional<import("zod").ZodNumber>;
+    attempt: import("zod").ZodOptional<import("zod").ZodObject<{
+        number: import("zod").ZodNumber;
+        destination: import("zod").ZodEnum<{
+            previous: "previous";
+            target: "target";
+        }>;
+    }, import("zod/v4/core").$strict>>;
+    report: import("zod").ZodOptional<import("zod").ZodObject<{
+        attempt: import("zod").ZodNumber;
+        destination: import("zod").ZodEnum<{
+            previous: "previous";
+            target: "target";
+        }>;
+        result: import("zod").ZodEnum<{
+            aborted: "aborted";
+            interrupted: "interrupted";
+            "migration-required": "migration-required";
+        }>;
+        reason: import("zod").ZodOptional<import("zod").ZodString>;
+        summary: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>>;
+    uncertified: import("zod").ZodOptional<import("zod").ZodObject<{
+        since: import("zod").ZodNumber;
+        session: import("zod").ZodOptional<import("zod").ZodString>;
+        operator: import("zod").ZodOptional<import("zod").ZodString>;
+        reason: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;
+/**
+ * The status of one Execution: the engine state of one whose node exists, `detail` present on a
+ * system execution only; or, for Root alone, the state `deleted` of a system execution whose node
+ * was deleted, with the outcome its lifecycle record keeps for ever, so that it is never read as a
+ * live run.
+ */
+export declare const executionStatus: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    function: import("zod").ZodString;
+    version: import("zod").ZodString;
+    state: import("zod").ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        expired: "expired";
+        failed: "failed";
+        paused: "paused";
+        pending: "pending";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    createdAt: import("zod").ZodString;
+    detail: import("zod").ZodOptional<import("zod").ZodObject<{
+        phase: import("zod").ZodEnum<{
+            activating: "activating";
+            attempting: "attempting";
+            awaiting: "awaiting";
+            cancelled: "cancelled";
+            classifying: "classifying";
+            completed: "completed";
+            draining: "draining";
+            rejected: "rejected";
+            validating: "validating";
+        }>;
+        class: import("zod").ZodOptional<import("zod").ZodEnum<{
+            immediate: "immediate";
+            noop: "noop";
+            revalidate: "revalidate";
+        }>>;
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            maintenance: "maintenance";
+            online: "online";
+        }>>;
+        validation: import("zod").ZodOptional<import("zod").ZodObject<{
+            scope: import("zod").ZodEnum<{
+                full: "full";
+                incremental: "incremental";
+            }>;
+            counts: import("zod").ZodEnum<{
+                exact: "exact";
+                sample: "sample";
+            }>;
+        }, import("zod/v4/core").$strict>>;
+        progress: import("zod").ZodOptional<import("zod").ZodObject<{
+            pages: import("zod").ZodNumber;
+            interruptions: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>>;
+        instance: import("zod").ZodOptional<import("zod").ZodEnum<{
+            attempt: "attempt";
+            draining: "draining";
+            open: "open";
+            repair: "repair";
+        }>>;
+        command: import("zod").ZodOptional<import("zod").ZodNumber>;
+        expires: import("zod").ZodOptional<import("zod").ZodNumber>;
+        attempt: import("zod").ZodOptional<import("zod").ZodObject<{
+            number: import("zod").ZodNumber;
+            destination: import("zod").ZodEnum<{
+                previous: "previous";
+                target: "target";
+            }>;
+        }, import("zod/v4/core").$strict>>;
+        report: import("zod").ZodOptional<import("zod").ZodObject<{
+            attempt: import("zod").ZodNumber;
+            destination: import("zod").ZodEnum<{
+                previous: "previous";
+                target: "target";
+            }>;
+            result: import("zod").ZodEnum<{
+                aborted: "aborted";
+                interrupted: "interrupted";
+                "migration-required": "migration-required";
+            }>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            summary: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>>;
+        uncertified: import("zod").ZodOptional<import("zod").ZodObject<{
+            since: import("zod").ZodNumber;
+            session: import("zod").ZodOptional<import("zod").ZodString>;
+            operator: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>>;
+    outcome: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"completed">;
+        value: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"failed">;
+        error: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            message: import("zod").ZodString;
+            family: import("zod").ZodOptional<import("zod").ZodString>;
+            details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"cancelled">;
+    }, import("zod/v4/core").$strict>]>>;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    state: import("zod").ZodLiteral<"deleted">;
+    outcome: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"completed">;
+        value: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"failed">;
+        error: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            message: import("zod").ZodString;
+            family: import("zod").ZodOptional<import("zod").ZodString>;
+            details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"cancelled">;
+    }, import("zod/v4/core").$strict>]>;
+}, import("zod/v4/core").$strict>]>;
+/** What a durable call answers at once: the Execution it created or recovered. */
+export declare const executionRef: import("zod").ZodObject<{
+    id: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const executionStatusInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionResultInput: import("zod").ZodObject<{
+    waitMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strict>;
+export declare const executionCancelInput: import("zod").ZodObject<{
+    force: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strict>;
+export declare const executionSignalInput: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    value: import("zod").ZodUnknown;
+}, import("zod/v4/core").$strict>;
+export declare const executionSignalOutput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionResumeInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionDeleteInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionDeleteOutput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export type SystemExecutionPhase = (typeof SYSTEM_EXECUTION_PHASES)[number];
+/** One attempt of a repair session that ended without activating its destination. */
+export interface AttemptReport {
+    readonly attempt: number;
+    /** `target` for an `apply`, `previous` for a cooperative cancel or an idle expiry. */
+    readonly destination: 'target' | 'previous';
+    readonly result: 'migration-required' | 'interrupted' | 'aborted';
+    /** The public failure code that interrupted it. */
+    readonly reason?: string;
+    /** The public migration report of a refuted attempt, versioned by its owner. */
+    readonly summary?: unknown;
+}
+/** The detail of a system execution's status; see `systemExecutionDetail`. */
+export interface SystemExecutionDetail {
+    readonly phase: SystemExecutionPhase;
+    readonly class?: InstallClass;
+    readonly mode?: InstallMode;
+    readonly validation?: ValidationOptions;
+    /** Pages validated so far, and continuity interruptions of at most three. */
+    readonly progress?: {
+        readonly pages: number;
+        readonly interruptions: number;
+    };
+    /** The admission a repair session holds the Instance in. */
+    readonly instance?: 'open' | 'draining' | 'repair' | 'attempt';
+    /** The `n` of the `command:<n>` signal a waiting session awaits. */
+    readonly command?: number;
+    /**
+     * When a waiting session's idle bound passes (epoch milliseconds): without a command by then, it
+     * tries to return to its source. Absent once an idle return was refuted: it then waits for Root.
+     */
+    readonly expires?: number;
+    /** The attempt running now; the `abort:<number>` signal stops it. */
+    readonly attempt?: {
+        readonly number: number;
+        readonly destination: 'target' | 'previous';
+    };
+    /** The last attempt that ended without activating. */
+    readonly report?: AttemptReport;
+    /** The break-glass mark the Instance carries: no certificate covers its stored facts. */
+    readonly uncertified?: UncertifiedMark;
+}
+/**
+ * The mark a break-glass exit leaves on the Instance until a `full` validation commits: when it
+ * was set (epoch milliseconds), the session it closed, and the operator and reason the Host named.
+ */
+export interface UncertifiedMark {
+    readonly since: number;
+    readonly session?: string;
+    readonly operator?: string;
+    readonly reason?: string;
+}