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

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

@@ -1,31 +1,72 @@
-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, enum as enumeration, literal, strictObject, union } from 'zod';
+import { artifactRef, domainGeneration, installationDigest, installationText, issuerConsent, operationIdSchema, transitionReceipt, } from './installation.js';
+/**
+ * What an install does to the stored data: nothing changes (`noop`), it applies at once without
+ * reading the data (`immediate`), or it revalidates the data before it applies (`revalidate`).
+ */
+export const INSTALL_CLASSES = Object.freeze(['noop', 'immediate', 'revalidate']);
+/**
+ * How an install runs. `online` (the default) keeps the Instance open: it validates online and
+ * only its activation briefly pauses writes. `maintenance`, for Root only, opens a maintenance
+ * session: the Instance is closed to every other caller while Root repairs the data in it, then
+ * applies the target.
+ */
+export const INSTALL_MODES = Object.freeze(['online', 'maintenance']);
+const scope = enumeration(['incremental', 'full']);
+const counts = enumeration(['sample', 'exact']);
+/** The validation options an install runs with, defaults filled in. */
+export const validationOptions = strictObject({ scope, counts });
+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(),
+    }),
+]);
+const installValidation = strictObject({ scope: scope.optional(), counts: counts.optional() });
+/** One install, all of it its intent: its operation, its Domains, its mode and validation options. */
+export const installInput = strictObject({
+    operation: operationIdSchema,
+    domains: array(domainRequest).min(1),
+    mode: enumeration(INSTALL_MODES).optional(),
+    validation: installValidation.optional(),
 });
-export const installOutput = z.strictObject({
+export const installReceipt = strictObject({
     operation: operationIdSchema,
-    transitions: z.array(transitionReceipt).min(1),
+    transitions: array(transitionReceipt).min(1),
+});
+/**
+ * What a completed install ends with, the value its Execution's `result` yields: the committed
+ * receipt, or the exact generation of each root it proved unchanged.
+ */
+export const installOutput = union([
+    strictObject({ changed: literal(true), receipt: installReceipt }),
+    strictObject({ changed: literal(false), domains: array(domainGeneration).min(1) }),
+]);
+/**
+ * The value of the `command:<n>` signal of a waiting repair session: attempt the target, with
+ * validation options that only widen the default.
+ */
+export const installSessionCommand = strictObject({
+    kind: literal('apply'),
+    validation: installValidation.optional(),
 });
-//# sourceMappingURL=install.js.map
+/** The value of the `abort:<n>` signal of a repair session: stop attempt `n`, then wait again. */
+export const installSessionAbort = strictObject({ kind: literal('abort') });
+/** The name of the signal that sends the `n`th command to a repair session. */
+export function commandSignal(n) {
+    return `command:${n}`;
+}
+/** The name of the signal that aborts attempt `n` of a repair session. */
+export function abortSignal(n) {
+    return `abort:${n}`;
+}

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

@@ -1,358 +1,76 @@
-import { z } from 'zod';
 import { operationIdSchema } from '../../../installation/operation-id.js';
 export { operationIdSchema };
-export declare const installationText: z.ZodString;
-export declare const installationDigest: z.ZodString;
-export declare const artifactRef: z.ZodObject<{
-    digest: z.ZodString;
-    mediaType: z.ZodString;
-    size: z.ZodNumber;
-}, z.core.$strict>;
-export declare const dependencyReadinessCoordinate: z.ZodObject<{
-    origin: z.ZodString;
-    installation: z.ZodString;
-    target: z.ZodString;
-    readinessReceipt: z.ZodString;
-    meaningComparison: z.ZodString;
-}, z.core.$strict>;
-export declare const serviceTarget: 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">;
-export declare const installationTarget: 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";
+export declare const installationText: import("zod").ZodString;
+export declare const installationDigest: import("zod").ZodString;
+export declare const artifactRef: import("zod").ZodObject<{
+    digest: import("zod").ZodString;
+    mediaType: import("zod").ZodString;
+    size: import("zod").ZodNumber;
+}, import("zod/v4/core").$strict>;
+export declare const domainGeneration: import("zod").ZodObject<{
+    origin: import("zod").ZodString;
+    revision: import("zod").ZodString;
+    generation: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const issuerConsent: 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>;
+export declare const readinessReceipt: 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>;
+export declare const transitionReceipt: 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";
-                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>;
-export declare const transitionIntent: 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>;
-export declare const readinessReceipt: 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>;
-export declare const transitionReceipt: 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<{
+            }>;
+        }, 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>;
-//# sourceMappingURL=installation.d.ts.map
+    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>;

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

@@ -1,88 +1,49 @@
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
+import { array, enum as enumeration, literal, number, strictObject, string } from 'zod';
 import { operationIdSchema } from '../../../installation/operation-id.js';
 export { operationIdSchema };
-export const installationText = z.string().min(1);
+export const installationText = string().min(1);
 export const installationDigest = installationText.check(fullMatch('sha256:[0-9a-f]{64}'));
-export const artifactRef = z.strictObject({
+export const artifactRef = strictObject({
     digest: installationDigest,
     mediaType: installationText,
-    size: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    size: number().int().min(0).max(Number.MAX_SAFE_INTEGER),
 });
-export const dependencyReadinessCoordinate = z.strictObject({
+const dependencyReadinessEvidence = strictObject({
     origin: installationText,
-    installation: installationText,
-    target: installationDigest,
-    readinessReceipt: installationDigest,
-    meaningComparison: installationDigest,
+    generation: installationDigest,
+    readiness: installationDigest,
+    meaning: installationDigest,
 });
-export const serviceTarget = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('local'),
-        artifact: installationDigest,
-    }),
-    z.strictObject({
-        kind: z.literal('remote'),
-        etag: installationDigest,
-    }),
-]);
-const authorityOperation = z.enum([
-    'use',
-    'create',
-    'read',
-    'traverse',
-    'update',
-    'delete',
-    'grant',
-    'revoke',
-]);
-const classOperation = z.enum(['create', 'read', 'traverse', 'update', 'delete']);
-const capabilityRequirements = z.strictObject({
-    functions: z.array(installationText).min(1).optional(),
-    classes: z
-        .array(z.strictObject({
-        class: z.strictObject({
-            origin: installationText,
-            kind: z.literal('class'),
-            name: installationText,
-        }),
-        operations: z.array(classOperation).min(1),
-    }))
-        .min(1)
-        .optional(),
-    admin: z
-        .strictObject({
-        grant: z.array(authorityOperation).min(1).optional(),
-        revoke: z.array(authorityOperation).min(1).optional(),
-    })
-        .optional(),
-});
-export const installationTarget = z.strictObject({
+export const domainGeneration = strictObject({
     origin: installationText,
-    schemaRevision: installationText,
-    schemaBundle: installationDigest,
-    service: serviceTarget,
-    capabilities: capabilityRequirements,
-    dependencies: z.array(dependencyReadinessCoordinate),
+    revision: installationText,
+    generation: installationDigest,
+});
+const consentIssuers = strictObject({ from: installationText, to: installationText });
+export const issuerConsent = strictObject({
+    issuer: consentIssuers,
+    previous: enumeration(['drain', 'revoke']).optional(),
 });
-export const transitionIntent = z.strictObject({
+const transitionIntent = strictObject({
     transition: installationText,
     operation: operationIdSchema,
-    installation: installationText,
     origin: installationText,
-    source: installationTarget.nullable(),
-    target: installationTarget.nullable(),
+    previous: domainGeneration.nullable(),
+    generation: domainGeneration.nullable(),
+    consent: strictObject({
+        issuer: consentIssuers,
+        previous: enumeration(['drain', 'revoke']),
+    }).optional(),
 });
-export const readinessReceipt = z.strictObject({
-    installation: installationText,
-    target: installationDigest,
+export const readinessReceipt = strictObject({
+    generation: installationDigest,
     transition: installationText,
-    dependencies: z.array(dependencyReadinessCoordinate),
+    dependencies: array(dependencyReadinessEvidence),
 });
-export const transitionReceipt = z.strictObject({
+export const transitionReceipt = strictObject({
     intent: transitionIntent,
-    phase: z.enum(['cutover', 'converge']),
-    state: z.literal('committed'),
+    phase: enumeration(['cutover', 'converge']),
+    state: literal('committed'),
     readiness: readinessReceipt.optional(),
 });
-//# sourceMappingURL=installation.js.map