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

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}'));