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

package/dist/graph/query/result/wire.js

@@ -1,33 +1,33 @@
-import { z } from 'zod';
+import { array, discriminatedUnion, literal, strictObject, string } from 'zod';
 import { edgeKeySchema, graphDataSchema, graphEdgeSchema, graphNodeSchema, } from '#graph/graph/model/wire';
-const text = z.string().min(1);
-const nodeReference = z.strictObject({ id: text, class: text });
-const nodeProjection = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('reference'), value: nodeReference }),
-    z.strictObject({ kind: z.literal('value'), value: graphNodeSchema }),
+const text = string().min(1);
+const nodeReference = strictObject({ id: text, class: text });
+const nodeProjection = discriminatedUnion('kind', [
+    strictObject({ kind: literal('reference'), value: nodeReference }),
+    strictObject({ kind: literal('value'), value: graphNodeSchema }),
 ]);
-const edgeProjection = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('reference'), value: edgeKeySchema }),
-    z.strictObject({ kind: z.literal('value'), value: graphEdgeSchema }),
+const edgeProjection = discriminatedUnion('kind', [
+    strictObject({ kind: literal('reference'), value: edgeKeySchema }),
+    strictObject({ kind: literal('value'), value: graphEdgeSchema }),
 ]);
-const edgeItem = z.strictObject({
+const edgeItem = strictObject({
     edge: edgeProjection,
     source: nodeProjection,
     target: nodeProjection,
 });
 /** Exact discriminated structural result; Runtime owns Query-relative closure and order. */
-export const queryResultSchema = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('graph'),
+export const queryResultSchema = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('graph'),
         graph: graphDataSchema,
-        selection: z.discriminatedUnion('kind', [
-            z.strictObject({ kind: z.literal('node'), ids: z.array(text) }),
-            z.strictObject({ kind: z.literal('edge'), keys: z.array(edgeKeySchema) }),
+        selection: discriminatedUnion('kind', [
+            strictObject({ kind: literal('node'), ids: array(text) }),
+            strictObject({ kind: literal('edge'), keys: array(edgeKeySchema) }),
         ]),
     }),
-    z.strictObject({
-        kind: z.literal('nodes'),
-        nodes: z.array(nodeProjection),
+    strictObject({
+        kind: literal('nodes'),
+        nodes: array(nodeProjection),
     }),
-    z.strictObject({ kind: z.literal('edges'), edges: z.array(edgeItem) }),
+    strictObject({ kind: literal('edges'), edges: array(edgeItem) }),
 ]);

package/dist/schema/authority/claims.d.ts

@@ -1,27 +1,26 @@
-import { z } from 'zod';
 /** Exact reusable schema for one ClaimConstraint in a graph or callable contract. */
-export declare const claimConstraintSchema: 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">;
+export declare const claimConstraintSchema: 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">;
 /** Exact reusable bounded schema for an Identity's required ClaimConstraints. */
-export declare const requiredClaimsSchema: 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">>;
+export declare const requiredClaimsSchema: 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">>;

package/dist/schema/authority/claims.js

@@ -1,12 +1,12 @@
-import { z } from 'zod';
+import { array, discriminatedUnion, literal, strictObject, string, unknown as unknownSchema, } from 'zod';
 import { claims } from '#auth';
-const claim = z.string().min(1);
-const portableValue = z.unknown().nonoptional();
+const claim = string().min(1);
+const portableValue = unknownSchema().nonoptional();
 /** Exact reusable schema for one ClaimConstraint in a graph or callable contract. */
-export const claimConstraintSchema = z.discriminatedUnion('op', [
-    z.strictObject({ claim, op: z.literal('contains'), value: portableValue }),
-    z.strictObject({ claim, op: z.literal('eq'), value: portableValue }),
-    z.strictObject({ claim, op: z.literal('exists') }),
+export const claimConstraintSchema = discriminatedUnion('op', [
+    strictObject({ claim, op: literal('contains'), value: portableValue }),
+    strictObject({ claim, op: literal('eq'), value: portableValue }),
+    strictObject({ claim, op: literal('exists') }),
 ]);
 /** Exact reusable bounded schema for an Identity's required ClaimConstraints. */
-export const requiredClaimsSchema = z.array(claimConstraintSchema).max(claims.MAX_REQUIRED_CLAIMS);
+export const requiredClaimsSchema = array(claimConstraintSchema).max(claims.MAX_REQUIRED_CLAIMS);

package/dist/schema/installation/operation-id.d.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 declare const OPERATION_ID: unique symbol;
 /** Caller-selected identity for one retryable Schema installation operation. */
 export type OperationId = string & {
@@ -7,5 +6,5 @@ export type OperationId = string & {
 /** Accept one canonical lowercase UUIDv4 without repair or case folding. */
 export declare function acceptOperationId(input: unknown): OperationId;
 /** Internal schema shared by Kernel-owned callable contracts. */
-export declare const operationIdSchema: z.ZodString;
+export declare const operationIdSchema: import("zod").ZodString;
 export {};

package/dist/schema/installation/operation-id.js

@@ -1,5 +1,5 @@
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
+import { string } from 'zod';
 const OPERATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 const OPERATION_ID_MESSAGE = 'OperationId must be a canonical lowercase RFC 9562 UUIDv4.';
 /** Accept one canonical lowercase UUIDv4 without repair or case folding. */
@@ -10,6 +10,4 @@ export function acceptOperationId(input) {
     return input;
 }
 /** Internal schema shared by Kernel-owned callable contracts. */
-export const operationIdSchema = z
-    .string()
-    .check(fullMatch('[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'));
+export const operationIdSchema = string().check(fullMatch('[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'));

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

@@ -1,12 +1,11 @@
-import { z } from 'zod';
-export declare const admitInput: z.ZodObject<{
-    call: z.ZodObject<{
-        target: z.ZodString;
-        input: z.ZodUnknown;
-    }, z.core.$strict>;
-    credential: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const admitOutput: z.ZodObject<{
-    callable: z.ZodString;
-    receiver: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
+export declare const admitInput: import("zod").ZodObject<{
+    call: import("zod").ZodObject<{
+        target: import("zod").ZodString;
+        input: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strict>;
+    credential: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;
+export declare const admitOutput: import("zod").ZodObject<{
+    callable: import("zod").ZodString;
+    receiver: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,12 +1,12 @@
-import { z } from 'zod';
-export const admitInput = z.strictObject({
-    call: z.strictObject({
-        target: z.string().min(1),
-        input: z.unknown(),
+import { strictObject, string, unknown as unknownSchema } from 'zod';
+export const admitInput = strictObject({
+    call: strictObject({
+        target: string().min(1),
+        input: unknownSchema(),
     }),
-    credential: z.string().optional(),
+    credential: string().optional(),
 });
-export const admitOutput = z.strictObject({
-    callable: z.string().min(1),
-    receiver: z.string().min(1).optional(),
+export const admitOutput = strictObject({
+    callable: string().min(1),
+    receiver: string().min(1).optional(),
 });

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

@@ -1,8 +1,7 @@
-import { z } from 'zod';
-export declare const canInput: z.ZodObject<{
-    policy: z.ZodString;
-    object: z.ZodString;
-}, z.core.$strict>;
-export declare const canOutput: z.ZodObject<{
-    allowed: z.ZodBoolean;
-}, z.core.$strict>;
+export declare const canInput: import("zod").ZodObject<{
+    policy: import("zod").ZodString;
+    object: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const canOutput: import("zod").ZodObject<{
+    allowed: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strict>;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-export const canInput = z.strictObject({ policy: text, object: text });
-export const canOutput = z.strictObject({ allowed: z.boolean() });
+import { boolean, strictObject, string } from 'zod';
+const text = string().min(1);
+export const canInput = strictObject({ policy: text, object: text });
+export const canOutput = strictObject({ allowed: boolean() });

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

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

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

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

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

@@ -1,6 +1,5 @@
-import { z } from 'zod';
 export declare const MAXIMUM_DOMAIN_EXPECTATIONS = 256;
-export declare const domainExpectations: z.ZodArray<z.ZodObject<{
-    origin: z.ZodString;
-    revision: z.ZodString;
-}, z.core.$strict>>;
+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

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