@astrale-os/kernel-core 0.9.0-beta.26 → 0.9.0-beta.28

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

@@ -1,78 +1,77 @@
-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 dependencyReadinessEvidence: z.ZodObject<{
-    origin: z.ZodString;
-    generation: z.ZodString;
-    readiness: z.ZodString;
-    meaning: z.ZodString;
-}, z.core.$strict>;
-export declare const domainGeneration: z.ZodObject<{
-    origin: z.ZodString;
-    revision: z.ZodString;
-    generation: z.ZodString;
-}, z.core.$strict>;
-export declare const transitionIntent: z.ZodObject<{
-    transition: z.ZodString;
-    operation: z.ZodString;
-    origin: z.ZodString;
-    previous: z.ZodNullable<z.ZodObject<{
-        origin: z.ZodString;
-        revision: z.ZodString;
-        generation: z.ZodString;
-    }, z.core.$strict>>;
-    generation: z.ZodNullable<z.ZodObject<{
-        origin: z.ZodString;
-        revision: z.ZodString;
-        generation: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const readinessReceipt: z.ZodObject<{
-    generation: z.ZodString;
-    transition: z.ZodString;
-    dependencies: z.ZodArray<z.ZodObject<{
-        origin: z.ZodString;
-        generation: z.ZodString;
-        readiness: z.ZodString;
-        meaning: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const transitionReceipt: z.ZodObject<{
-    intent: z.ZodObject<{
-        transition: z.ZodString;
-        operation: z.ZodString;
-        origin: z.ZodString;
-        previous: z.ZodNullable<z.ZodObject<{
-            origin: z.ZodString;
-            revision: z.ZodString;
-            generation: z.ZodString;
-        }, z.core.$strict>>;
-        generation: z.ZodNullable<z.ZodObject<{
-            origin: z.ZodString;
-            revision: z.ZodString;
-            generation: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    phase: z.ZodEnum<{
+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 dependencyReadinessEvidence: import("zod").ZodObject<{
+    origin: import("zod").ZodString;
+    generation: import("zod").ZodString;
+    readiness: import("zod").ZodString;
+    meaning: import("zod").ZodString;
+}, 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 transitionIntent: 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>>;
+}, 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>>;
+    }, import("zod/v4/core").$strict>;
+    phase: import("zod").ZodEnum<{
         converge: "converge";
         cutover: "cutover";
     }>;
-    state: z.ZodLiteral<"committed">;
-    readiness: z.ZodOptional<z.ZodObject<{
-        generation: z.ZodString;
-        transition: z.ZodString;
-        dependencies: z.ZodArray<z.ZodObject<{
-            origin: z.ZodString;
-            generation: z.ZodString;
-            readiness: z.ZodString;
-            meaning: z.ZodString;
-        }, 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>;

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

@@ -1,40 +1,40 @@
 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 dependencyReadinessEvidence = z.strictObject({
+export const dependencyReadinessEvidence = strictObject({
     origin: installationText,
     generation: installationDigest,
     readiness: installationDigest,
     meaning: installationDigest,
 });
-export const domainGeneration = z.strictObject({
+export const domainGeneration = strictObject({
     origin: installationText,
     revision: installationText,
     generation: installationDigest,
 });
-export const transitionIntent = z.strictObject({
+export const transitionIntent = strictObject({
     transition: installationText,
     operation: operationIdSchema,
     origin: installationText,
     previous: domainGeneration.nullable(),
     generation: domainGeneration.nullable(),
 });
-export const readinessReceipt = z.strictObject({
+export const readinessReceipt = strictObject({
     generation: installationDigest,
     transition: installationText,
-    dependencies: z.array(dependencyReadinessEvidence),
+    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(),
 });

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

@@ -1,8 +1,7 @@
-import { z } from 'zod';
-export declare const introspectInput: z.ZodObject<{
-    kind: z.ZodEnum<{
+export declare const introspectInput: import("zod").ZodObject<{
+    kind: import("zod").ZodEnum<{
         bundle: "bundle";
         inspect: "inspect";
     }>;
-    origin: z.ZodString;
-}, z.core.$strict>;
+    origin: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;

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

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-export const introspectInput = z.strictObject({
-    kind: z.enum(['inspect', 'bundle']),
-    origin: z.string().min(1),
+import { enum as enumeration, strictObject, string } from 'zod';
+export const introspectInput = strictObject({
+    kind: enumeration(['inspect', 'bundle']),
+    origin: string().min(1),
 });

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

@@ -1,27 +1,26 @@
-import { z } from 'zod';
-export declare const journalInput: z.ZodObject<{
-    invocation: z.ZodOptional<z.ZodObject<{
-        source: z.ZodString;
-        id: z.ZodString;
-    }, z.core.$strict>>;
-    topics: z.ZodOptional<z.ZodObject<{
-        exact: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        prefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-    principal: z.ZodOptional<z.ZodString>;
-    since: z.ZodOptional<z.ZodString>;
-    until: z.ZodOptional<z.ZodString>;
-    cursor: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-export declare const journalOutput: z.ZodObject<{
-    records: z.ZodArray<z.ZodUnknown>;
-    frontier: z.ZodObject<{
-        id: z.ZodString;
-        first: z.ZodOptional<z.ZodNumber>;
-        committed: z.ZodNumber;
-        durable: z.ZodNumber;
-    }, z.core.$strict>;
-    cursor: z.ZodOptional<z.ZodString>;
-    gap: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strict>;
+export declare const journalInput: import("zod").ZodObject<{
+    invocation: import("zod").ZodOptional<import("zod").ZodObject<{
+        source: import("zod").ZodString;
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+    topics: import("zod").ZodOptional<import("zod").ZodObject<{
+        exact: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        prefixes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strict>>;
+    principal: import("zod").ZodOptional<import("zod").ZodString>;
+    since: import("zod").ZodOptional<import("zod").ZodString>;
+    until: import("zod").ZodOptional<import("zod").ZodString>;
+    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+    limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strict>;
+export declare const journalOutput: import("zod").ZodObject<{
+    records: import("zod").ZodArray<import("zod").ZodUnknown>;
+    frontier: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        first: import("zod").ZodOptional<import("zod").ZodNumber>;
+        committed: import("zod").ZodNumber;
+        durable: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
+    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+    gap: import("zod").ZodOptional<import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,26 +1,26 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-const eventTopicPattern = z.strictObject({
-    exact: z.array(text).optional(),
-    prefixes: z.array(text).optional(),
+import { array, number, strictObject, string, unknown as unknownSchema } from 'zod';
+const text = string().min(1);
+const eventTopicPattern = strictObject({
+    exact: array(text).optional(),
+    prefixes: array(text).optional(),
 });
-export const journalInput = z.strictObject({
-    invocation: z.strictObject({ source: text, id: text }).optional(),
+export const journalInput = strictObject({
+    invocation: strictObject({ source: text, id: text }).optional(),
     topics: eventTopicPattern.optional(),
     principal: text.optional(),
     since: text.optional(),
     until: text.optional(),
     cursor: text.optional(),
-    limit: z.number().int().min(1).optional(),
+    limit: number().int().min(1).optional(),
 });
-export const journalOutput = z.strictObject({
-    records: z.array(z.unknown()),
-    frontier: z.strictObject({
+export const journalOutput = strictObject({
+    records: array(unknownSchema()),
+    frontier: strictObject({
         id: text,
-        first: z.number().int().min(1).optional(),
-        committed: z.number().int().min(0),
-        durable: z.number().int().min(0),
+        first: number().int().min(1).optional(),
+        committed: number().int().min(0),
+        durable: number().int().min(0),
     }),
     cursor: text.optional(),
-    gap: z.unknown().optional(),
+    gap: unknownSchema().optional(),
 });

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

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

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

@@ -1,8 +1,8 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-export const mintInput = z.strictObject({
+import { number, strictObject, string, unknown as unknownSchema } from 'zod';
+const text = string().min(1);
+export const mintInput = strictObject({
     audience: text.optional(),
-    ttlSeconds: z.number().int().min(1),
-    grant: z.unknown().optional(),
+    ttlSeconds: number().int().min(1),
+    grant: unknownSchema().optional(),
 });
 export const mintOutput = text;