@astrale-os/kernel-core 0.9.0-beta.9 → 0.9.0

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

@@ -1,15 +1,11 @@
-import { z } from 'zod';
-export declare const introspectInput: z.ZodObject<{
-    from: z.ZodObject<{
-        kind: z.ZodLiteral<"installation">;
-        origin: z.ZodString;
-    }, z.core.$strict>;
-    select: z.ZodObject<{
-        state: z.ZodOptional<z.ZodLiteral<true>>;
-        target: z.ZodOptional<z.ZodLiteral<true>>;
-        source: z.ZodOptional<z.ZodLiteral<true>>;
-        bundle: z.ZodOptional<z.ZodLiteral<true>>;
-        readiness: z.ZodOptional<z.ZodLiteral<true>>;
-        capabilities: z.ZodOptional<z.ZodLiteral<true>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+/** One ready Domain by origin, or the installed listing, which names no origin. */
+export declare const introspectInput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    kind: import("zod").ZodEnum<{
+        bundle: "bundle";
+        dependencies: "dependencies";
+        inspect: "inspect";
+    }>;
+    origin: import("zod").ZodString;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"installed">;
+}, import("zod/v4/core").$strict>]>;

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

@@ -1,16 +1,9 @@
-import { z } from 'zod';
-const selection = z.strictObject({
-    state: z.literal(true).optional(),
-    target: z.literal(true).optional(),
-    source: z.literal(true).optional(),
-    bundle: z.literal(true).optional(),
-    readiness: z.literal(true).optional(),
-    capabilities: z.literal(true).optional(),
-});
-export const introspectInput = z.strictObject({
-    from: z.strictObject({
-        kind: z.literal('installation'),
-        origin: z.string().min(1),
+import { enum as enumeration, literal, strictObject, string, union } from 'zod';
+/** One ready Domain by origin, or the installed listing, which names no origin. */
+export const introspectInput = union([
+    strictObject({
+        kind: enumeration(['inspect', 'bundle', 'dependencies']),
+        origin: string().min(1),
     }),
-    select: selection,
-});
+    strictObject({ kind: literal('installed') }),
+]);

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,5 @@
-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;
+}, import("zod/v4/core").$strict>;
+export declare const mintOutput: import("zod").ZodString;

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

@@ -1,8 +1,7 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-export const mintInput = z.strictObject({
+import { number, strictObject, string } 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),
 });
 export const mintOutput = text;