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

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

@@ -0,0 +1,116 @@
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { boolean, enum as enumeration, literal, number, strictObject, string, union, unknown as unknownSchema, } from 'zod';
+import { INSTALL_CLASSES, INSTALL_MODES, validationOptions, } from './install.js';
+const nodeId = string().min(1).max(255).check(fullMatch('[A-Za-z0-9._-]+'));
+const empty = strictObject({});
+/** Engine-observed state; never persisted on the Execution. */
+const state = enumeration([
+    'pending',
+    'running',
+    'waiting',
+    'paused',
+    'completed',
+    'failed',
+    'cancelled',
+    'expired',
+]);
+const failure = strictObject({
+    code: string(),
+    message: string(),
+    family: string().optional(),
+    details: unknownSchema().optional(),
+});
+/** Terminal outcome of one durable call; a handler failure is an outcome, not a call error. */
+export const executionOutcome = union([
+    strictObject({ kind: literal('completed'), value: unknownSchema() }),
+    strictObject({ kind: literal('failed'), error: failure }),
+    strictObject({ kind: literal('cancelled') }),
+]);
+/**
+ * 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 const SYSTEM_EXECUTION_PHASES = Object.freeze([
+    'classifying',
+    'validating',
+    'activating',
+    'draining',
+    'awaiting',
+    'attempting',
+    'completed',
+    'rejected',
+    'cancelled',
+]);
+/** Continuity interruptions a validation survives before it ends. */
+export const MAXIMUM_VALIDATION_INTERRUPTIONS = 3;
+const destination = enumeration(['target', 'previous']);
+const ordinal = number().int().min(1);
+/**
+ * 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 const systemExecutionDetail = strictObject({
+    phase: enumeration(SYSTEM_EXECUTION_PHASES),
+    class: enumeration(INSTALL_CLASSES).optional(),
+    mode: enumeration(INSTALL_MODES).optional(),
+    validation: validationOptions.optional(),
+    progress: strictObject({
+        pages: number().int().min(0),
+        interruptions: number().int().min(0).max(MAXIMUM_VALIDATION_INTERRUPTIONS),
+    }).optional(),
+    instance: enumeration(['open', 'draining', 'repair', 'attempt']).optional(),
+    command: ordinal.optional(),
+    expires: number().int().min(0).optional(),
+    attempt: strictObject({ number: ordinal, destination }).optional(),
+    report: strictObject({
+        attempt: ordinal,
+        destination,
+        result: enumeration(['migration-required', 'interrupted', 'aborted']),
+        reason: string().check(fullMatch('[A-Z][A-Z0-9_]{0,63}')).optional(),
+        summary: unknownSchema().optional(),
+    }).optional(),
+    uncertified: strictObject({
+        since: number().int().min(0),
+        session: nodeId.optional(),
+        operator: string().min(1).max(64).optional(),
+        reason: string().min(1).max(256).optional(),
+    }).optional(),
+});
+/**
+ * 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 const executionStatus = union([
+    strictObject({
+        id: nodeId,
+        function: nodeId,
+        version: string().check(fullMatch('sha256:[0-9a-f]{64}')),
+        state,
+        createdAt: string().min(1),
+        detail: systemExecutionDetail.optional(),
+        outcome: executionOutcome.optional(),
+    }),
+    strictObject({ id: nodeId, state: literal('deleted'), outcome: executionOutcome }),
+]);
+/** What a durable call answers at once: the Execution it created or recovered. */
+export const executionRef = strictObject({ id: nodeId });
+export const executionStatusInput = empty;
+export const executionResultInput = strictObject({ waitMs: number().int().min(0).optional() });
+export const executionCancelInput = strictObject({ force: boolean().optional() });
+export const executionSignalInput = strictObject({
+    name: string().min(1).max(128),
+    value: unknownSchema(),
+});
+export const executionSignalOutput = empty;
+export const executionResumeInput = empty;
+export const executionDeleteInput = empty;
+export const executionDeleteOutput = empty;

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

@@ -0,0 +1,5 @@
+export declare const MAXIMUM_DOMAIN_EXPECTATIONS = 256;
+export declare const domainExpectations: import("zod").ZodArray<import("zod").ZodObject<{
+    origin: import("zod").ZodString;
+    revision: import("zod").ZodString;
+}, import("zod/v4/core").$strict>>;

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

@@ -0,0 +1,9 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { array, strictObject, string } from 'zod';
+export const MAXIMUM_DOMAIN_EXPECTATIONS = 256;
+const expectation = strictObject({
+    origin: string().check(fullMatch(patterns.originFullMatch)),
+    revision: string().check(fullMatch(patterns.revisionFullMatch)),
+});
+export const domainExpectations = array(expectation).max(MAXIMUM_DOMAIN_EXPECTATIONS);

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

@@ -1,19 +1,18 @@
-import { z } from 'zod';
-export declare const identityOutput: z.ZodObject<{
-    id: z.ZodString;
-    issuer: z.ZodString;
-    subject: z.ZodString;
-    frozen: z.ZodBoolean;
-    requiredClaims: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"contains">;
-        value: z.ZodNonOptional<z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"eq">;
-        value: z.ZodNonOptional<z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        claim: z.ZodString;
-        op: z.ZodLiteral<"exists">;
-    }, z.core.$strict>], "op">>;
-}, z.core.$strict>;
+export declare const identityOutput: import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    iss: import("zod").ZodString;
+    sub: import("zod").ZodString;
+    frozen: import("zod").ZodBoolean;
+    requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"contains">;
+        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"eq">;
+        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        claim: import("zod").ZodString;
+        op: import("zod").ZodLiteral<"exists">;
+    }, import("zod/v4/core").$strict>], "op">>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,10 +1,9 @@
-import { z } from 'zod';
+import { boolean, strictObject, string } from 'zod';
 import { requiredClaimsSchema } from '../../../authority/claims.js';
-const text = z.string().min(1);
-export const identityOutput = z.strictObject({
-    id: text,
-    issuer: text,
-    subject: text,
-    frozen: z.boolean(),
+export const identityOutput = strictObject({
+    id: string().min(1),
+    iss: string().min(1),
+    sub: string().min(1),
+    frozen: boolean(),
     requiredClaims: requiredClaimsSchema,
 });

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

@@ -0,0 +1,6 @@
+export declare const impersonateInput: import("zod").ZodObject<{
+    audience: import("zod").ZodOptional<import("zod").ZodString>;
+    ttlSeconds: import("zod").ZodNumber;
+    identity: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const impersonateOutput: import("zod").ZodString;

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

@@ -0,0 +1,4 @@
+import { string } from 'zod';
+import { mintInput, mintOutput } from './mint.js';
+export const impersonateInput = mintInput.extend({ identity: string().min(1) });
+export const impersonateOutput = mintOutput;

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

@@ -1,12 +1,15 @@
 export { admitInput, admitOutput } from './admit.js';
-export { canInput, canOutput } from './can.js';
+export { blobSlot, DOWNLOAD_PARTS_MEDIA_TYPE, downloadInput, MAXIMUM_BLOB_BYTES, MAXIMUM_DOWNLOAD_SLOTS, uploadInput, uploadOutput, } from './blob.js';
+export { MAXIMUM_CHECKS, canInput, canOutput } from './can.js';
 export { delegateInput, delegateOutput } from './delegate.js';
-export { installInput, installOutput, type DesiredInstallation, type InstallInput, type InstallOutput, } from './install.js';
+export { executionCancelInput, executionDeleteInput, executionDeleteOutput, executionOutcome, executionRef, executionResultInput, executionResumeInput, executionSignalInput, executionSignalOutput, executionStatus, executionStatusInput, MAXIMUM_VALIDATION_INTERRUPTIONS, SYSTEM_EXECUTION_PHASES, systemExecutionDetail, type AttemptReport, type SystemExecutionDetail, type SystemExecutionPhase, type UncertifiedMark, } from './execution.js';
+export { abortSignal, commandSignal, INSTALL_CLASSES, INSTALL_MODES, installInput, installOutput, installReceipt, installSessionAbort, installSessionCommand, validationOptions, type DomainRequest, type InstallClass, type InstallInput, type InstallMode, type InstallOutput, type InstallReceipt, type InstallSessionAbort, type InstallSessionCommand, type InstallValidation, type ValidationOptions, } from './install.js';
 export { introspectInput } from './introspect.js';
 export { journalInput, journalOutput } from './journal.js';
+export { impersonateInput, impersonateOutput } from './impersonate.js';
 export { mintInput, mintOutput } from './mint.js';
 export { mutateInput, mutateOutput } from './mutate.js';
-export { provisionInput, provisionOutput } from './provision.js';
+export { registerInput, registerOutput } from './register.js';
 export { MAXIMUM_QUERY_EXPECTATIONS, queryInput, queryOutput } from './query.js';
 export { uninstallInput, uninstallOutput, type UninstallInput, type UninstallOutput, } from './uninstall.js';
 export { viewResolveInput, viewResolveOutput } from './view-resolve.js';

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

@@ -1,12 +1,15 @@
 export { admitInput, admitOutput } from './admit.js';
-export { canInput, canOutput } from './can.js';
+export { blobSlot, DOWNLOAD_PARTS_MEDIA_TYPE, downloadInput, MAXIMUM_BLOB_BYTES, MAXIMUM_DOWNLOAD_SLOTS, uploadInput, uploadOutput, } from './blob.js';
+export { MAXIMUM_CHECKS, canInput, canOutput } from './can.js';
 export { delegateInput, delegateOutput } from './delegate.js';
-export { installInput, installOutput, } from './install.js';
+export { executionCancelInput, executionDeleteInput, executionDeleteOutput, executionOutcome, executionRef, executionResultInput, executionResumeInput, executionSignalInput, executionSignalOutput, executionStatus, executionStatusInput, MAXIMUM_VALIDATION_INTERRUPTIONS, SYSTEM_EXECUTION_PHASES, systemExecutionDetail, } from './execution.js';
+export { abortSignal, commandSignal, INSTALL_CLASSES, INSTALL_MODES, installInput, installOutput, installReceipt, installSessionAbort, installSessionCommand, validationOptions, } from './install.js';
 export { introspectInput } from './introspect.js';
 export { journalInput, journalOutput } from './journal.js';
+export { impersonateInput, impersonateOutput } from './impersonate.js';
 export { mintInput, mintOutput } from './mint.js';
 export { mutateInput, mutateOutput } from './mutate.js';
-export { provisionInput, provisionOutput } from './provision.js';
+export { registerInput, registerOutput } from './register.js';
 export { MAXIMUM_QUERY_EXPECTATIONS, queryInput, queryOutput } from './query.js';
 export { uninstallInput, uninstallOutput, } from './uninstall.js';
 export { viewResolveInput, viewResolveOutput } from './view-resolve.js';