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

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

@@ -1,257 +1,274 @@
-import { z } from 'zod';
 export declare const MAXIMUM_QUERY_EXPECTATIONS = 256;
-export declare const queryInput: z.ZodObject<{
-    ast: z.ZodObject<{
-        format: z.ZodLiteral<"astrale.graph.query">;
-        version: z.ZodLiteral<"v6">;
-        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"node">;
-            terms: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"path">;
-                path: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"class">;
-                class: z.ZodObject<{
-                    origin: z.ZodString;
-                    kind: z.ZodLiteral<"class">;
-                    name: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>], "kind">>;
-            binding: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"edge">;
-            terms: z.ZodArray<z.ZodObject<{
-                kind: z.ZodLiteral<"class">;
-                class: z.ZodObject<{
-                    origin: z.ZodString;
-                    kind: z.ZodLiteral<"class">;
-                    name: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>>;
-            bindings: z.ZodObject<{
-                source: z.ZodString;
-                edge: z.ZodString;
-                target: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "kind">;
-        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            op: z.ZodLiteral<"filter">;
-            binding: z.ZodString;
-            predicate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"class.satisfies">;
-                class: z.ZodObject<{
-                    origin: z.ZodString;
-                    kind: z.ZodLiteral<"class">;
-                    name: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"class.equal">;
-                class: z.ZodObject<{
-                    origin: z.ZodString;
-                    kind: z.ZodLiteral<"class">;
-                    name: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"property.equal">;
-                property: z.ZodString;
-                value: z.ZodUnknown;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"property.present">;
-                property: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"identity.equal">;
-                identity: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    source: z.ZodString;
-                    target: z.ZodString;
-                    class: z.ZodString;
-                }, z.core.$strict>]>;
-            }, z.core.$strict>], "kind">;
-        }, z.core.$strict>, z.ZodObject<{
-            op: z.ZodLiteral<"expand">;
-            from: z.ZodString;
-            via: z.ZodArray<z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>>;
-            direction: z.ZodEnum<{
+export declare const queryInput: import("zod").ZodObject<{
+    ast: import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"astrale.graph.query">;
+        version: import("zod").ZodLiteral<"v6">;
+        source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"node">;
+            terms: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"path">;
+                path: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"class">;
+                class: 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">>;
+            binding: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"edge">;
+            terms: import("zod").ZodArray<import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"class">;
+                class: 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>>;
+            bindings: import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                edge: import("zod").ZodString;
+                target: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>], "kind">;
+        steps: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"filter">;
+            binding: import("zod").ZodString;
+            predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"class.satisfies">;
+                class: 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>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"class.equal">;
+                class: 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>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"property.equal">;
+                property: import("zod").ZodString;
+                value: import("zod").ZodUnknown;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"property.present">;
+                property: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"property.range">;
+                property: import("zod").ZodString;
+                lower: import("zod").ZodOptional<import("zod").ZodObject<{
+                    value: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodString]>;
+                    inclusive: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strict>>;
+                upper: import("zod").ZodOptional<import("zod").ZodObject<{
+                    value: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodString]>;
+                    inclusive: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"identity.equal">;
+                identity: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>]>;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            op: import("zod").ZodLiteral<"expand">;
+            from: import("zod").ZodString;
+            via: import("zod").ZodArray<import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            direction: import("zod").ZodEnum<{
                 incident: "incident";
                 incoming: "incoming";
                 outgoing: "outgoing";
             }>;
-            bindings: z.ZodObject<{
-                edge: z.ZodString;
-                node: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "op">>;
-        select: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"graph">;
-            binding: z.ZodString;
-            order: z.ZodOptional<z.ZodObject<{
-                property: z.ZodString;
-                direction: z.ZodEnum<{
+            bindings: import("zod").ZodObject<{
+                edge: import("zod").ZodString;
+                node: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>], "op">>;
+        select: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"graph">;
+            binding: import("zod").ZodString;
+            order: import("zod").ZodOptional<import("zod").ZodObject<{
+                property: import("zod").ZodString;
+                direction: import("zod").ZodEnum<{
                     asc: "asc";
                     desc: "desc";
                 }>;
-                unranked: z.ZodEnum<{
+                unranked: import("zod").ZodEnum<{
                     first: "first";
                     last: "last";
                 }>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"nodes">;
-            binding: z.ZodString;
-            projection: z.ZodObject<{
-                kind: z.ZodEnum<{
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"nodes">;
+            binding: import("zod").ZodString;
+            projection: import("zod").ZodObject<{
+                kind: import("zod").ZodEnum<{
                     reference: "reference";
                     value: "value";
                 }>;
-            }, z.core.$strict>;
-            order: z.ZodOptional<z.ZodObject<{
-                property: z.ZodString;
-                direction: z.ZodEnum<{
+            }, import("zod/v4/core").$strict>;
+            order: import("zod").ZodOptional<import("zod").ZodObject<{
+                property: import("zod").ZodString;
+                direction: import("zod").ZodEnum<{
                     asc: "asc";
                     desc: "desc";
                 }>;
-                unranked: z.ZodEnum<{
+                unranked: import("zod").ZodEnum<{
                     first: "first";
                     last: "last";
                 }>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"edges">;
-            binding: z.ZodString;
-            projection: z.ZodObject<{
-                edge: z.ZodEnum<{
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"edges">;
+            binding: import("zod").ZodString;
+            projection: import("zod").ZodObject<{
+                edge: import("zod").ZodEnum<{
                     reference: "reference";
                     value: "value";
                 }>;
-                source: z.ZodEnum<{
+                source: import("zod").ZodEnum<{
                     reference: "reference";
                     value: "value";
                 }>;
-                target: z.ZodEnum<{
+                target: import("zod").ZodEnum<{
                     reference: "reference";
                     value: "value";
                 }>;
-            }, z.core.$strict>;
-            order: z.ZodOptional<z.ZodObject<{
-                property: z.ZodString;
-                direction: z.ZodEnum<{
+            }, import("zod/v4/core").$strict>;
+            order: import("zod").ZodOptional<import("zod").ZodObject<{
+                property: import("zod").ZodString;
+                direction: import("zod").ZodEnum<{
                     asc: "asc";
                     desc: "desc";
                 }>;
-                unranked: z.ZodEnum<{
+                unranked: import("zod").ZodEnum<{
                     first: "first";
                     last: "last";
                 }>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>], "kind">;
-    }, z.core.$strict>;
-    expected: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        origin: z.ZodString;
-        revision: z.ZodString;
-    }, z.core.$strict>>>;
-    page: z.ZodObject<{
-        size: z.ZodNumber;
-        after: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const queryOutput: z.ZodObject<{
-    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"graph">;
-        graph: z.ZodObject<{
-            nodes: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                class: z.ZodString;
-                props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            }, z.core.$strict>>;
-            edges: z.ZodArray<z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-                slug: z.ZodOptional<z.ZodType<import("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/edge/index.js").EdgeSlug, unknown>>>;
-                props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"node">;
-            ids: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"edge">;
-            keys: z.ZodArray<z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>], "kind">;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"nodes">;
-        nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"reference">;
-            value: z.ZodObject<{
-                id: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"value">;
-            value: z.ZodObject<{
-                id: z.ZodString;
-                class: z.ZodString;
-                props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "kind">>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"edges">;
-        edges: z.ZodArray<z.ZodObject<{
-            edge: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"reference">;
-                value: z.ZodObject<{
-                    source: z.ZodString;
-                    target: z.ZodString;
-                    class: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"value">;
-                value: z.ZodObject<{
-                    source: z.ZodString;
-                    target: z.ZodString;
-                    class: z.ZodString;
-                    slug: z.ZodOptional<z.ZodType<import("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/edge/index.js").EdgeSlug, unknown>>>;
-                    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                }, z.core.$strict>;
-            }, z.core.$strict>], "kind">;
-            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"reference">;
-                value: z.ZodObject<{
-                    id: z.ZodString;
-                    class: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"value">;
-                value: z.ZodObject<{
-                    id: z.ZodString;
-                    class: z.ZodString;
-                    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                }, z.core.$strict>;
-            }, z.core.$strict>], "kind">;
-            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"reference">;
-                value: z.ZodObject<{
-                    id: z.ZodString;
-                    class: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"value">;
-                value: z.ZodObject<{
-                    id: z.ZodString;
-                    class: z.ZodString;
-                    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                }, z.core.$strict>;
-            }, z.core.$strict>], "kind">;
-        }, z.core.$strict>>;
-    }, z.core.$strict>], "kind">;
-    page: z.ZodObject<{
-        next: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>], "kind">;
+    }, import("zod/v4/core").$strict>;
+    expected: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        origin: import("zod").ZodString;
+        revision: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>>;
+    page: import("zod").ZodObject<{
+        size: import("zod").ZodNumber;
+        after: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>;
+/**
+ * One Query page. `certification` is present exactly on a repair read inside a maintenance
+ * session, and on a page that holds a fact the active contract refutes while the Instance carries
+ * the break-glass `uncertified` mark: its facts were admitted for structure and authority, never
+ * for conformance.
+ */
+export declare const queryOutput: import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"graph">;
+        graph: import("zod").ZodObject<{
+            nodes: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                class: import("zod").ZodString;
+                props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>>;
+            edges: import("zod").ZodArray<import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+                slug: import("zod").ZodOptional<import("zod").ZodType<import("../../../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../../../graph/edge/index.js").EdgeSlug, unknown>>>;
+                props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        selection: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"node">;
+            ids: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"edge">;
+            keys: import("zod").ZodArray<import("zod").ZodObject<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>], "kind">;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"nodes">;
+        nodes: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"reference">;
+            value: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"value">;
+            value: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                class: import("zod").ZodString;
+                props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>], "kind">>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"edges">;
+        edges: import("zod").ZodArray<import("zod").ZodObject<{
+            edge: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"reference">;
+                value: import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"value">;
+                value: import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                    slug: import("zod").ZodOptional<import("zod").ZodType<import("../../../../graph/edge/index.js").EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<import("../../../../graph/edge/index.js").EdgeSlug, unknown>>>;
+                    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>], "kind">;
+            source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"reference">;
+                value: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"value">;
+                value: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>], "kind">;
+            target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"reference">;
+                value: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"value">;
+                value: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    class: import("zod").ZodString;
+                    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>], "kind">;
+    page: import("zod").ZodObject<{
+        next: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+    certification: import("zod").ZodOptional<import("zod").ZodLiteral<"uncertified">>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,21 +1,23 @@
-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 { literal, number, strictObject, string } from 'zod';
 import { queryAstSchema, queryResultSchema } from '#graph/query/wire';
-export const MAXIMUM_QUERY_EXPECTATIONS = 256;
-const expectation = z.strictObject({
-    origin: z.string().check(fullMatch(patterns.originFullMatch)),
-    revision: z.string().check(fullMatch(patterns.revisionFullMatch)),
-});
-export const queryInput = z.strictObject({
+import { domainExpectations, MAXIMUM_DOMAIN_EXPECTATIONS } from './expected.js';
+export const MAXIMUM_QUERY_EXPECTATIONS = MAXIMUM_DOMAIN_EXPECTATIONS;
+export const queryInput = strictObject({
     ast: queryAstSchema,
-    expected: z.array(expectation).max(MAXIMUM_QUERY_EXPECTATIONS).optional(),
-    page: z.strictObject({
-        size: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-        after: z.string().min(1).optional(),
+    expected: domainExpectations.optional(),
+    page: strictObject({
+        size: number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+        after: string().min(1).optional(),
     }),
 });
-export const queryOutput = z.strictObject({
+/**
+ * One Query page. `certification` is present exactly on a repair read inside a maintenance
+ * session, and on a page that holds a fact the active contract refutes while the Instance carries
+ * the break-glass `uncertified` mark: its facts were admitted for structure and authority, never
+ * for conformance.
+ */
+export const queryOutput = strictObject({
     result: queryResultSchema,
-    page: z.strictObject({ next: z.string().min(1).optional() }),
+    page: strictObject({ next: string().min(1).optional() }),
+    certification: literal('uncertified').optional(),
 });

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

@@ -0,0 +1,20 @@
+export declare const registerInput: import("zod").ZodObject<{
+    idempotencyKey: import("zod").ZodString;
+    identities: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        mode: import("zod").ZodLiteral<"external">;
+        credential: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        mode: import("zod").ZodLiteral<"self">;
+        publicKey: import("zod").ZodUnknown;
+        credential: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>]>>;
+}, import("zod/v4/core").$strict>;
+export declare const registerOutput: import("zod").ZodObject<{
+    identities: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        iss: import("zod").ZodString;
+        sub: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;

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

@@ -0,0 +1,24 @@
+import { array, literal, strictObject, string, union, unknown as unknownSchema } from 'zod';
+import { REGISTER_REQUEST_LIMITS } from '../../../../auth/register/request/limits.js';
+const text = string().min(1);
+const credential = text.max(REGISTER_REQUEST_LIMITS.credentialBytes);
+const external = strictObject({
+    id: text,
+    mode: literal('external'),
+    credential,
+});
+const self = strictObject({
+    id: text,
+    mode: literal('self'),
+    publicKey: unknownSchema(),
+    credential,
+});
+export const registerInput = strictObject({
+    idempotencyKey: text.max(REGISTER_REQUEST_LIMITS.idempotencyKeyCharacters),
+    identities: array(union([external, self]))
+        .nonempty()
+        .max(REGISTER_REQUEST_LIMITS.identities),
+});
+export const registerOutput = strictObject({
+    identities: array(strictObject({ id: text, iss: text, sub: text })).nonempty(),
+});