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

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

@@ -1,229 +1,157 @@
-import type { ClassRef, Key } from '@astrale-os/kernel-dsl/v1';
-import { z } from 'zod';
-import type { AuthorityOperation } from '../../../authority/operation.js';
 import type { OperationId } from '../../../installation/operation-id.js';
-export declare const installInput: z.ZodObject<{
-    operation: z.ZodString;
-    domains: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        source: z.ZodObject<{
-            kind: z.ZodLiteral<"local">;
-            artifact: z.ZodObject<{
-                digest: z.ZodString;
-                mediaType: z.ZodString;
-                size: z.ZodNumber;
-            }, z.core.$strict>;
-        }, z.core.$strict>;
-        currentRevision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>, z.ZodObject<{
-        source: z.ZodObject<{
-            kind: z.ZodLiteral<"remote">;
-            url: z.ZodString;
-            token: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        targetRevision: z.ZodOptional<z.ZodString>;
-        targetEtag: z.ZodOptional<z.ZodString>;
-        currentRevision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>]>>;
-}, z.core.$strict>;
-export declare const installOutput: z.ZodObject<{
-    operation: z.ZodString;
-    transitions: z.ZodArray<z.ZodObject<{
-        intent: z.ZodObject<{
-            transition: z.ZodString;
-            operation: z.ZodString;
-            installation: z.ZodString;
-            origin: z.ZodString;
-            source: z.ZodNullable<z.ZodObject<{
-                origin: z.ZodString;
-                schemaRevision: z.ZodString;
-                schemaBundle: z.ZodString;
-                service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"local">;
-                    artifact: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"remote">;
-                    etag: z.ZodString;
-                }, z.core.$strict>], "kind">;
-                capabilities: z.ZodObject<{
-                    functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                    classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                        class: z.ZodObject<{
-                            origin: z.ZodString;
-                            kind: z.ZodLiteral<"class">;
-                            name: z.ZodString;
-                        }, z.core.$strict>;
-                        operations: z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            read: "read";
-                            traverse: "traverse";
-                            update: "update";
-                        }>>;
-                    }, z.core.$strict>>>;
-                    admin: z.ZodOptional<z.ZodObject<{
-                        grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            grant: "grant";
-                            read: "read";
-                            revoke: "revoke";
-                            traverse: "traverse";
-                            update: "update";
-                            use: "use";
-                        }>>>;
-                        revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            grant: "grant";
-                            read: "read";
-                            revoke: "revoke";
-                            traverse: "traverse";
-                            update: "update";
-                            use: "use";
-                        }>>>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>;
-                dependencies: z.ZodArray<z.ZodObject<{
-                    origin: z.ZodString;
-                    installation: z.ZodString;
-                    target: z.ZodString;
-                    readinessReceipt: z.ZodString;
-                    meaningComparison: z.ZodString;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-            target: z.ZodNullable<z.ZodObject<{
-                origin: z.ZodString;
-                schemaRevision: z.ZodString;
-                schemaBundle: z.ZodString;
-                service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"local">;
-                    artifact: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"remote">;
-                    etag: z.ZodString;
-                }, z.core.$strict>], "kind">;
-                capabilities: z.ZodObject<{
-                    functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                    classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                        class: z.ZodObject<{
-                            origin: z.ZodString;
-                            kind: z.ZodLiteral<"class">;
-                            name: z.ZodString;
-                        }, z.core.$strict>;
-                        operations: z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            read: "read";
-                            traverse: "traverse";
-                            update: "update";
-                        }>>;
-                    }, z.core.$strict>>>;
-                    admin: z.ZodOptional<z.ZodObject<{
-                        grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            grant: "grant";
-                            read: "read";
-                            revoke: "revoke";
-                            traverse: "traverse";
-                            update: "update";
-                            use: "use";
-                        }>>>;
-                        revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                            create: "create";
-                            delete: "delete";
-                            grant: "grant";
-                            read: "read";
-                            revoke: "revoke";
-                            traverse: "traverse";
-                            update: "update";
-                            use: "use";
-                        }>>>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>;
-                dependencies: z.ZodArray<z.ZodObject<{
-                    origin: z.ZodString;
-                    installation: z.ZodString;
-                    target: z.ZodString;
-                    readinessReceipt: z.ZodString;
-                    meaningComparison: z.ZodString;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        phase: z.ZodEnum<{
+export declare const domainRequest: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    artifact: import("zod").ZodObject<{
+        digest: import("zod").ZodString;
+        mediaType: import("zod").ZodString;
+        size: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
+    currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    release: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        token: import("zod").ZodOptional<import("zod").ZodString>;
+        digest: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+    consent: import("zod").ZodOptional<import("zod").ZodObject<{
+        issuer: import("zod").ZodObject<{
+            from: import("zod").ZodString;
+            to: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        previous: import("zod").ZodOptional<import("zod").ZodEnum<{
+            drain: "drain";
+            revoke: "revoke";
+        }>>;
+    }, import("zod/v4/core").$strict>>;
+    revision: import("zod").ZodOptional<import("zod").ZodString>;
+    currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}, import("zod/v4/core").$strict>]>;
+export declare const installInput: import("zod").ZodObject<{
+    operation: import("zod").ZodString;
+    domains: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        artifact: import("zod").ZodObject<{
+            digest: import("zod").ZodString;
+            mediaType: import("zod").ZodString;
+            size: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        release: import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            token: import("zod").ZodOptional<import("zod").ZodString>;
+            digest: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+        consent: import("zod").ZodOptional<import("zod").ZodObject<{
+            issuer: import("zod").ZodObject<{
+                from: import("zod").ZodString;
+                to: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            previous: import("zod").ZodOptional<import("zod").ZodEnum<{
+                drain: "drain";
+                revoke: "revoke";
+            }>>;
+        }, import("zod/v4/core").$strict>>;
+        revision: import("zod").ZodOptional<import("zod").ZodString>;
+        currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strict>]>>;
+}, import("zod/v4/core").$strict>;
+export declare const installReceipt: import("zod").ZodObject<{
+    operation: import("zod").ZodString;
+    transitions: import("zod").ZodArray<import("zod").ZodObject<{
+        intent: import("zod").ZodObject<{
+            transition: import("zod").ZodString;
+            operation: import("zod").ZodString;
+            origin: import("zod").ZodString;
+            previous: import("zod").ZodNullable<import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                revision: import("zod").ZodString;
+                generation: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            generation: import("zod").ZodNullable<import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                revision: import("zod").ZodString;
+                generation: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            consent: import("zod").ZodOptional<import("zod").ZodObject<{
+                issuer: import("zod").ZodObject<{
+                    from: import("zod").ZodString;
+                    to: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                previous: import("zod").ZodEnum<{
+                    drain: "drain";
+                    revoke: "revoke";
+                }>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        phase: import("zod").ZodEnum<{
             converge: "converge";
             cutover: "cutover";
         }>;
-        state: z.ZodLiteral<"committed">;
-        readiness: z.ZodOptional<z.ZodObject<{
-            installation: z.ZodString;
-            target: z.ZodString;
-            transition: z.ZodString;
-            dependencies: z.ZodArray<z.ZodObject<{
-                origin: z.ZodString;
-                installation: z.ZodString;
-                target: z.ZodString;
-                readinessReceipt: z.ZodString;
-                meaningComparison: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+        state: import("zod").ZodLiteral<"committed">;
+        readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+            generation: import("zod").ZodString;
+            transition: import("zod").ZodString;
+            dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                generation: import("zod").ZodString;
+                readiness: import("zod").ZodString;
+                meaning: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;
 type NonEmpty<Value> = readonly [Value, ...Value[]];
 export type InstallationDigest = `sha256:${string}`;
+export type ReleaseDigest = InstallationDigest;
 export interface ArtifactRef {
     readonly digest: InstallationDigest;
     readonly mediaType: string;
     readonly size: number;
 }
-export interface DependencyReadinessCoordinate {
+export interface DependencyReadinessEvidence {
     readonly origin: string;
-    readonly installation: string;
-    readonly target: InstallationDigest;
-    readonly readinessReceipt: InstallationDigest;
-    readonly meaningComparison: InstallationDigest;
+    readonly generation: InstallationDigest;
+    readonly readiness: InstallationDigest;
+    readonly meaning: InstallationDigest;
 }
-export type ServiceTarget = {
-    readonly kind: 'local';
-    readonly artifact: InstallationDigest;
-} | {
-    readonly kind: 'remote';
-    readonly etag: InstallationDigest;
-};
-export type ClassOperation = 'create' | 'read' | 'traverse' | 'update' | 'delete';
-export interface ClassCapabilityRequirement {
-    readonly class: ClassRef;
-    readonly operations: NonEmpty<ClassOperation>;
+export interface DomainGeneration {
+    readonly origin: string;
+    readonly revision: string;
+    readonly generation: InstallationDigest;
 }
-export interface CapabilityRequirements {
-    readonly functions?: NonEmpty<Key.Callable>;
-    readonly classes?: NonEmpty<ClassCapabilityRequirement>;
-    readonly admin?: {
-        readonly grant?: NonEmpty<AuthorityOperation>;
-        readonly revoke?: NonEmpty<AuthorityOperation>;
+/**
+ * The operator's consent to replace the issuer an installation runs under (D7): a compare-and-swap
+ * of the exact installed issuer `from` for the exact issuer `to` the source serves.
+ */
+export interface IssuerConsent {
+    readonly issuer: {
+        readonly from: string;
+        readonly to: string;
     };
-}
-export interface InstallationTarget {
-    readonly origin: string;
-    readonly schemaRevision: string;
-    readonly schemaBundle: InstallationDigest;
-    readonly service: ServiceTarget;
-    readonly capabilities: CapabilityRequirements;
-    readonly dependencies: readonly DependencyReadinessCoordinate[];
+    /**
+     * What the replaced issuer keeps: `drain` (default) accepts it for a bounded time after the
+     * activation, then only for the steps of its durable runs; `revoke` cuts it at the activation.
+     */
+    readonly previous?: 'drain' | 'revoke';
 }
 export interface TransitionIntent {
     readonly transition: string;
     readonly operation: OperationId;
-    readonly installation: string;
     readonly origin: string;
-    readonly source: InstallationTarget | null;
-    readonly target: InstallationTarget | null;
+    readonly previous: DomainGeneration | null;
+    readonly generation: DomainGeneration | null;
+    /** Present only on a replacement that changed its issuer under consent. */
+    readonly consent?: {
+        readonly issuer: {
+            readonly from: string;
+            readonly to: string;
+        };
+        readonly previous: 'drain' | 'revoke';
+    };
 }
 export interface ReadinessReceipt {
-    readonly installation: string;
-    readonly target: InstallationDigest;
+    readonly generation: InstallationDigest;
     readonly transition: string;
-    readonly dependencies: readonly DependencyReadinessCoordinate[];
+    readonly dependencies: readonly DependencyReadinessEvidence[];
 }
 export interface TransitionReceipt {
     readonly intent: TransitionIntent;
@@ -231,27 +159,31 @@ export interface TransitionReceipt {
     readonly state: 'committed';
     readonly readiness?: ReadinessReceipt;
 }
-export type DesiredInstallation = {
-    readonly source: {
-        readonly kind: 'local';
-        readonly artifact: ArtifactRef;
-    };
-    readonly currentRevision?: string | null;
-} | {
-    readonly source: {
-        readonly kind: 'remote';
+/** Installs the exact DomainRelease served by the URL. */
+export interface ReleaseRequest {
+    readonly release: {
         readonly url: string;
         readonly token?: string;
+        /** Requires an exact release digest. Omit to accept the served release. */
+        readonly digest?: ReleaseDigest;
     };
-    readonly targetRevision?: string;
-    readonly targetEtag?: InstallationDigest;
+    /**
+     * Required when the source serves another issuer than the installed one, refused otherwise:
+     * `from` must be the installed issuer and `to` the served one, neither the Kernel issuer.
+     */
+    readonly consent?: IssuerConsent;
+    readonly revision?: string;
+    readonly currentRevision?: string | null;
+}
+export type DomainRequest = {
+    readonly artifact: ArtifactRef;
     readonly currentRevision?: string | null;
-};
+} | ReleaseRequest;
 export interface InstallInput {
     readonly operation: OperationId;
-    readonly domains: NonEmpty<DesiredInstallation>;
+    readonly domains: NonEmpty<DomainRequest>;
 }
-export interface InstallOutput {
+export interface InstallReceipt {
     readonly operation: OperationId;
     readonly transitions: NonEmpty<TransitionReceipt>;
 }

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

@@ -1,30 +1,26 @@
-import { z } from 'zod';
-import { artifactRef, installationDigest, installationText, operationIdSchema, transitionReceipt, } from './installation.js';
-export const installInput = z.strictObject({
-    operation: operationIdSchema,
-    domains: z
-        .array(z.union([
-        z.strictObject({
-            source: z.strictObject({
-                kind: z.literal('local'),
-                artifact: artifactRef,
-            }),
-            currentRevision: installationText.nullable().optional(),
-        }),
-        z.strictObject({
-            source: z.strictObject({
-                kind: z.literal('remote'),
-                url: installationText,
-                token: installationText.optional(),
-            }),
-            targetRevision: installationText.optional(),
-            targetEtag: installationDigest.optional(),
-            currentRevision: installationText.nullable().optional(),
+import { array, strictObject, union } from 'zod';
+import { artifactRef, installationDigest, installationText, issuerConsent, operationIdSchema, transitionReceipt, } from './installation.js';
+export const domainRequest = union([
+    strictObject({
+        artifact: artifactRef,
+        currentRevision: installationText.nullable().optional(),
+    }),
+    strictObject({
+        release: strictObject({
+            url: installationText,
+            token: installationText.optional(),
+            digest: installationDigest.optional(),
         }),
-    ]))
-        .min(1),
+        consent: issuerConsent.optional(),
+        revision: installationText.optional(),
+        currentRevision: installationText.nullable().optional(),
+    }),
+]);
+export const installInput = strictObject({
+    operation: operationIdSchema,
+    domains: array(domainRequest).min(1),
 });
-export const installOutput = z.strictObject({
+export const installReceipt = strictObject({
     operation: operationIdSchema,
-    transitions: z.array(transitionReceipt).min(1),
+    transitions: array(transitionReceipt).min(1),
 });