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

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

@@ -1,45 +1,44 @@
-import { z } from 'zod';
 import type { OperationId } from '../../../installation/operation-id.js';
 import type { TransitionReceipt } from './install.js';
-export declare const uninstallInput: z.ZodObject<{
-    operation: z.ZodString;
-    origin: z.ZodString;
-}, z.core.$strict>;
-export declare const uninstallOutput: z.ZodObject<{
-    operation: z.ZodString;
-    transition: 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 uninstallInput: import("zod").ZodObject<{
+    operation: import("zod").ZodString;
+    origin: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const uninstallOutput: import("zod").ZodObject<{
+    operation: import("zod").ZodString;
+    transition: 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>;
 export interface UninstallInput {
     readonly operation: OperationId;
     readonly origin: string;

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

@@ -1,10 +1,10 @@
-import { z } from 'zod';
+import { strictObject } from 'zod';
 import { installationText, operationIdSchema, transitionReceipt } from './installation.js';
-export const uninstallInput = z.strictObject({
+export const uninstallInput = strictObject({
     operation: operationIdSchema,
     origin: installationText,
 });
-export const uninstallOutput = z.strictObject({
+export const uninstallOutput = strictObject({
     operation: operationIdSchema,
     transition: transitionReceipt,
 });

package/dist/schema/kernel/syscalls/contracts/view-resolve.d.ts

@@ -1,35 +1,34 @@
-import { z } from 'zod';
-export declare const viewResolveInput: z.ZodObject<{
-    target: z.ZodString;
-}, z.core.$strict>;
-export declare const viewResolveOutput: z.ZodObject<{
-    snapshot: z.ZodString;
-    views: z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        declaration: z.ZodObject<{
-            description: z.ZodOptional<z.ZodString>;
-            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"domain">;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"definition">;
-                definitions: z.ZodArray<z.ZodObject<{
-                    origin: z.ZodString;
-                    kind: z.ZodLiteral<"class">;
-                    name: z.ZodString;
-                }, z.core.$strict>>;
-            }, z.core.$strict>], "kind">;
-        }, z.core.$strict>;
-        href: z.ZodString;
-        handshake: z.ZodEnum<{
+export declare const viewResolveInput: import("zod").ZodObject<{
+    target: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const viewResolveOutput: import("zod").ZodObject<{
+    snapshot: import("zod").ZodString;
+    views: import("zod").ZodArray<import("zod").ZodObject<{
+        key: import("zod").ZodString;
+        declaration: import("zod").ZodObject<{
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"domain">;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"definition">;
+                definitions: import("zod").ZodArray<import("zod").ZodObject<{
+                    origin: import("zod").ZodString;
+                    kind: import("zod").ZodLiteral<"class">;
+                    name: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>;
+        href: import("zod").ZodString;
+        handshake: import("zod").ZodEnum<{
             none: "none";
             shell: "shell";
         }>;
-        iframe: z.ZodOptional<z.ZodObject<{
-            sandbox: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-        issuer: z.ZodString;
-        etag: z.ZodString;
-        revision: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+        iframe: import("zod").ZodOptional<import("zod").ZodObject<{
+            sandbox: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            allow: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strict>>;
+        issuer: import("zod").ZodString;
+        etag: import("zod").ZodString;
+        revision: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;

package/dist/schema/kernel/syscalls/contracts/view-resolve.js

@@ -1,33 +1,33 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
-const definition = z.strictObject({
-    origin: z.string().check(fullMatch(patterns.originFullMatch)),
-    kind: z.literal('class'),
-    name: z.string().check(fullMatch(patterns.memberNameFullMatch)),
+import { array, discriminatedUnion, enum as enumeration, literal, strictObject, string } from 'zod';
+const definition = strictObject({
+    origin: string().check(fullMatch(patterns.originFullMatch)),
+    kind: literal('class'),
+    name: string().check(fullMatch(patterns.memberNameFullMatch)),
 });
-const declaration = z.strictObject({
-    description: z.string().optional(),
-    target: z.discriminatedUnion('kind', [
-        z.strictObject({ kind: z.literal('domain') }),
-        z.strictObject({ kind: z.literal('definition'), definitions: z.array(definition).min(1) }),
+const declaration = strictObject({
+    description: string().optional(),
+    target: discriminatedUnion('kind', [
+        strictObject({ kind: literal('domain') }),
+        strictObject({ kind: literal('definition'), definitions: array(definition).min(1) }),
     ]),
 });
-const iframeRequirements = z.strictObject({
-    sandbox: z.array(z.string()).optional(),
-    allow: z.array(z.string()).optional(),
+const iframeRequirements = strictObject({
+    sandbox: array(string()).optional(),
+    allow: array(string()).optional(),
 });
-export const viewResolveInput = z.strictObject({ target: z.string().min(1) });
-export const viewResolveOutput = z.strictObject({
-    snapshot: z.string().min(1),
-    views: z.array(z.strictObject({
-        key: z.string().min(1),
+export const viewResolveInput = strictObject({ target: string().min(1) });
+export const viewResolveOutput = strictObject({
+    snapshot: string().min(1),
+    views: array(strictObject({
+        key: string().min(1),
         declaration,
-        href: z.string().min(1),
-        handshake: z.enum(['shell', 'none']),
+        href: string().min(1),
+        handshake: enumeration(['shell', 'none']),
         iframe: iframeRequirements.optional(),
-        issuer: z.string().min(1),
-        etag: z.string().min(1),
-        revision: z.string().min(1),
+        issuer: string().min(1),
+        etag: string().min(1),
+        revision: string().min(1),
     })),
 });

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

@@ -1,20 +1,19 @@
-import { z } from 'zod';
-export declare const whoamiInput: z.ZodObject<{}, z.core.$strict>;
-export declare const whoamiOutput: 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 whoamiInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const whoamiOutput: 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/whoami.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { strictObject } from 'zod';
 import { identityOutput } from './identity.js';
-export const whoamiInput = z.strictObject({});
+export const whoamiInput = strictObject({});
 export const whoamiOutput = identityOutput;

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

@@ -1,23 +1,22 @@
-import { z } from 'zod';
-export declare const whoisInput: z.ZodObject<{
-    iss: z.ZodString;
-    sub: z.ZodString;
-}, z.core.$strict>;
-export declare const whoisOutput: z.ZodNullable<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 whoisInput: import("zod").ZodObject<{
+    iss: import("zod").ZodString;
+    sub: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const whoisOutput: import("zod").ZodNullable<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/whois.js

@@ -1,5 +1,5 @@
-import { z } from 'zod';
+import { strictObject, string } from 'zod';
 import { identityOutput } from './identity.js';
-const text = z.string().min(1);
-export const whoisInput = z.strictObject({ iss: text, sub: text });
+const text = string().min(1);
+export const whoisInput = strictObject({ iss: text, sub: text });
 export const whoisOutput = identityOutput.nullable();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.26",
+  "version": "0.9.0-beta.28",
   "description": "Astrale Kernel Core - Types, Invariants, and Pure Logic",
   "license": "Apache-2.0",
   "repository": {
@@ -160,7 +160,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-dsl": "0.2.0-beta.19",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.21",
     "@noble/hashes": "2.3.0",
     "@types/json-schema": "^7.0.15",
     "dequal": "2.0.3"