@astrale-os/kernel-core 0.9.0-beta.25 → 0.9.0-beta.27

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;
-    iss: z.ZodString;
-    sub: 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,9 +1,9 @@
-import { z } from 'zod';
+import { boolean, strictObject, string } from 'zod';
 import { requiredClaimsSchema } from '../../../authority/claims.js';
-export const identityOutput = z.strictObject({
-    id: z.string().min(1),
-    iss: z.string().min(1),
-    sub: z.string().min(1),
-    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/install.d.ts

@@ -1,75 +1,74 @@
-import { z } from 'zod';
 import type { OperationId } from '../../../installation/operation-id.js';
-export declare const domainRequest: z.ZodUnion<readonly [z.ZodObject<{
-    artifact: z.ZodObject<{
-        digest: z.ZodString;
-        mediaType: z.ZodString;
-        size: z.ZodNumber;
-    }, z.core.$strict>;
-    currentRevision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>, z.ZodObject<{
-    publication: z.ZodObject<{
-        url: z.ZodString;
-        token: z.ZodOptional<z.ZodString>;
-        etag: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    revision: z.ZodOptional<z.ZodString>;
-    currentRevision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>]>;
-export declare const installInput: z.ZodObject<{
-    operation: z.ZodString;
-    domains: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        artifact: z.ZodObject<{
-            digest: z.ZodString;
-            mediaType: z.ZodString;
-            size: z.ZodNumber;
-        }, z.core.$strict>;
-        currentRevision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>, z.ZodObject<{
-        publication: z.ZodObject<{
-            url: z.ZodString;
-            token: z.ZodOptional<z.ZodString>;
-            etag: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        revision: z.ZodOptional<z.ZodString>;
-        currentRevision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>]>>;
-}, z.core.$strict>;
-export declare const installReceipt: z.ZodObject<{
-    operation: z.ZodString;
-    transitions: z.ZodArray<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 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<{
+    publication: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        token: import("zod").ZodOptional<import("zod").ZodString>;
+        etag: import("zod").ZodOptional<import("zod").ZodString>;
+    }, 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<{
+        publication: import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            token: import("zod").ZodOptional<import("zod").ZodString>;
+            etag: import("zod").ZodOptional<import("zod").ZodString>;
+        }, 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>>;
+        }, 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>>;
-}, 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 interface ArtifactRef {

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

@@ -1,12 +1,12 @@
-import { z } from 'zod';
+import { array, strictObject, union } from 'zod';
 import { artifactRef, installationText, operationIdSchema, transitionReceipt, } from './installation.js';
-export const domainRequest = z.union([
-    z.strictObject({
+export const domainRequest = union([
+    strictObject({
         artifact: artifactRef,
         currentRevision: installationText.nullable().optional(),
     }),
-    z.strictObject({
-        publication: z.strictObject({
+    strictObject({
+        publication: strictObject({
             url: installationText,
             token: installationText.optional(),
             etag: installationText.optional(),
@@ -15,11 +15,11 @@ export const domainRequest = z.union([
         currentRevision: installationText.nullable().optional(),
     }),
 ]);
-export const installInput = z.strictObject({
+export const installInput = strictObject({
     operation: operationIdSchema,
-    domains: z.array(domainRequest).min(1),
+    domains: array(domainRequest).min(1),
 });
-export const installReceipt = z.strictObject({
+export const installReceipt = strictObject({
     operation: operationIdSchema,
-    transitions: z.array(transitionReceipt).min(1),
+    transitions: array(transitionReceipt).min(1),
 });

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;