@astrale-os/kernel-core 0.9.0-beta.1 → 0.9.0-beta.3

package/dist/schema/kernel/syscalls/declarations/index.d.ts

@@ -1,10 +1,8 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Functions: Readonly<{
-    query: builder.Function<Omit<{
+    query: builder.Function<{
         readonly description: "Execute one finite authorized graph query.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+        readonly auth: "authorized";
         readonly input: import("zod").ZodObject<{
             ast: import("zod").ZodObject<{
                 format: import("zod").ZodLiteral<"astrale.graph.query">;
@@ -261,12 +259,10 @@ export declare const Functions: Readonly<{
                 next: import("zod").ZodOptional<import("zod").ZodString>;
             }, import("zod/v4/core").$strict>;
         }, import("zod/v4/core").$strict>;
-    }, "admission">>;
-    mutate: builder.Function<Omit<{
+    }>;
+    mutate: builder.Function<{
         readonly description: "Validate, authorize, and commit one atomic graph mutation.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+        readonly auth: "authorized";
         readonly input: import("zod").ZodObject<{
             format: import("zod").ZodLiteral<"astrale.graph.mutation">;
             version: import("zod").ZodLiteral<"v3">;
@@ -523,12 +519,10 @@ export declare const Functions: Readonly<{
         readonly output: import("zod").ZodObject<{
             createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
         }, import("zod/v4/core").$strict>;
-    }, "admission">>;
-    provision: builder.Function<Omit<{
+    }>;
+    provision: builder.Function<{
         readonly description: "Atomically execute a graph transition whose designated Identities are born complete.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+        readonly auth: "authorized";
         readonly input: import("zod").ZodObject<{
             idempotencyKey: import("zod").ZodString;
             mutation: import("zod").ZodObject<{
@@ -825,46 +819,357 @@ export declare const Functions: Readonly<{
                 subject: import("zod").ZodString;
             }, import("zod/v4/core").$strict>>;
         }, import("zod/v4/core").$strict>;
-    }, "admission">>;
-    install: builder.Function<Omit<{
-        readonly description: "Fetch, verify, and atomically activate one or more explicit Domain roots.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+    }>;
+    install: builder.Function<{
+        readonly description: "Durably install one or more exact Schema targets and return a terminal receipt.";
+        readonly auth: "authorized";
         readonly input: import("zod").ZodObject<{
-            domains: import("zod").ZodArray<import("zod").ZodObject<{
-                url: import("zod").ZodString;
-                token: import("zod").ZodOptional<import("zod").ZodString>;
+            operation: import("zod").ZodString;
+            domains: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                source: import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"local">;
+                    artifact: import("zod").ZodObject<{
+                        digest: import("zod").ZodString;
+                        mediaType: import("zod").ZodString;
+                        size: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>;
+                currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                source: import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"remote">;
+                    url: import("zod").ZodString;
+                    token: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>;
                 targetRevision: import("zod").ZodOptional<import("zod").ZodString>;
                 targetEtag: 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>;
+        readonly output: 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;
+                    installation: import("zod").ZodString;
+                    origin: import("zod").ZodString;
+                    source: import("zod").ZodNullable<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        schemaRevision: import("zod").ZodString;
+                        schemaBundle: import("zod").ZodString;
+                        service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"local">;
+                            artifact: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"remote">;
+                            etag: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>], "kind">;
+                        capabilities: import("zod").ZodObject<{
+                            functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                            classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                class: import("zod").ZodObject<{
+                                    origin: import("zod").ZodString;
+                                    kind: import("zod").ZodLiteral<"class">;
+                                    name: import("zod").ZodString;
+                                }, import("zod/v4/core").$strict>;
+                                operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    read: "read";
+                                    traverse: "traverse";
+                                    update: "update";
+                                }>>;
+                            }, import("zod/v4/core").$strict>>>;
+                            admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                                grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    grant: "grant";
+                                    read: "read";
+                                    revoke: "revoke";
+                                    traverse: "traverse";
+                                    update: "update";
+                                    use: "use";
+                                }>>>;
+                                revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    grant: "grant";
+                                    read: "read";
+                                    revoke: "revoke";
+                                    traverse: "traverse";
+                                    update: "update";
+                                    use: "use";
+                                }>>>;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>;
+                        dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            installation: import("zod").ZodString;
+                            target: import("zod").ZodString;
+                            readinessReceipt: import("zod").ZodString;
+                            meaningComparison: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
+                    target: import("zod").ZodNullable<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        schemaRevision: import("zod").ZodString;
+                        schemaBundle: import("zod").ZodString;
+                        service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"local">;
+                            artifact: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"remote">;
+                            etag: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>], "kind">;
+                        capabilities: import("zod").ZodObject<{
+                            functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                            classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                class: import("zod").ZodObject<{
+                                    origin: import("zod").ZodString;
+                                    kind: import("zod").ZodLiteral<"class">;
+                                    name: import("zod").ZodString;
+                                }, import("zod/v4/core").$strict>;
+                                operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    read: "read";
+                                    traverse: "traverse";
+                                    update: "update";
+                                }>>;
+                            }, import("zod/v4/core").$strict>>>;
+                            admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                                grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    grant: "grant";
+                                    read: "read";
+                                    revoke: "revoke";
+                                    traverse: "traverse";
+                                    update: "update";
+                                    use: "use";
+                                }>>>;
+                                revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    grant: "grant";
+                                    read: "read";
+                                    revoke: "revoke";
+                                    traverse: "traverse";
+                                    update: "update";
+                                    use: "use";
+                                }>>>;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>;
+                        dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            installation: import("zod").ZodString;
+                            target: import("zod").ZodString;
+                            readinessReceipt: import("zod").ZodString;
+                            meaningComparison: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>;
+                phase: import("zod").ZodEnum<{
+                    converge: "converge";
+                    cutover: "cutover";
+                }>;
+                state: import("zod").ZodLiteral<"committed">;
+                readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+                    installation: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    transition: import("zod").ZodString;
+                    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        installation: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        readinessReceipt: import("zod").ZodString;
+                        meaningComparison: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>;
             }, import("zod/v4/core").$strict>>;
         }, import("zod/v4/core").$strict>;
-        readonly output: import("zod").ZodArray<import("zod").ZodObject<{
-            origin: import("zod").ZodString;
-            revision: import("zod").ZodString;
-            etag: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strict>>;
-    }, "admission">>;
-    uninstall: builder.Function<Omit<{
-        readonly description: "Atomically deactivate one installed Domain.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+    }>;
+    introspect: builder.Function<{
+        readonly description: "Return bounded installed-Publication evidence to an authenticated Kernel session.";
+        readonly auth: "authenticated";
+        readonly input: import("zod").ZodObject<{
+            from: import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"installation">;
+                origin: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            select: import("zod").ZodObject<{
+                state: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                target: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                source: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                bundle: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                readiness: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+                capabilities: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>;
+        readonly output: builder.BinaryOutput;
+    }>;
+    uninstall: builder.Function<{
+        readonly description: "Durably uninstall one Domain installation epoch and return its terminal receipt.";
+        readonly auth: "authorized";
         readonly input: import("zod").ZodObject<{
+            operation: import("zod").ZodString;
             origin: import("zod").ZodString;
         }, import("zod/v4/core").$strict>;
         readonly output: import("zod").ZodObject<{
-            origin: import("zod").ZodString;
-            revision: import("zod").ZodString;
+            operation: import("zod").ZodString;
+            transition: import("zod").ZodObject<{
+                intent: import("zod").ZodObject<{
+                    transition: import("zod").ZodString;
+                    operation: import("zod").ZodString;
+                    installation: import("zod").ZodString;
+                    origin: import("zod").ZodString;
+                    source: import("zod").ZodNullable<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        schemaRevision: import("zod").ZodString;
+                        schemaBundle: import("zod").ZodString;
+                        service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"local">;
+                            artifact: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"remote">;
+                            etag: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>], "kind">;
+                        capabilities: import("zod").ZodObject<{
+                            functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                            classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                class: import("zod").ZodObject<{
+                                    origin: import("zod").ZodString;
+                                    kind: import("zod").ZodLiteral<"class">;
+                                    name: import("zod").ZodString;
+                                }, import("zod/v4/core").$strict>;
+                                operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    read: "read";
+                                    traverse: "traverse";
+                                    update: "update";
+                                }>>;
+                            }, import("zod/v4/core").$strict>>>;
+                            admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                                grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    grant: "grant";
+                                    read: "read";
+                                    revoke: "revoke";
+                                    traverse: "traverse";
+                                    update: "update";
+                                    use: "use";
+                                }>>>;
+                                revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    grant: "grant";
+                                    read: "read";
+                                    revoke: "revoke";
+                                    traverse: "traverse";
+                                    update: "update";
+                                    use: "use";
+                                }>>>;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>;
+                        dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            installation: import("zod").ZodString;
+                            target: import("zod").ZodString;
+                            readinessReceipt: import("zod").ZodString;
+                            meaningComparison: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
+                    target: import("zod").ZodNullable<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        schemaRevision: import("zod").ZodString;
+                        schemaBundle: import("zod").ZodString;
+                        service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"local">;
+                            artifact: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"remote">;
+                            etag: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>], "kind">;
+                        capabilities: import("zod").ZodObject<{
+                            functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                            classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                class: import("zod").ZodObject<{
+                                    origin: import("zod").ZodString;
+                                    kind: import("zod").ZodLiteral<"class">;
+                                    name: import("zod").ZodString;
+                                }, import("zod/v4/core").$strict>;
+                                operations: import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    read: "read";
+                                    traverse: "traverse";
+                                    update: "update";
+                                }>>;
+                            }, import("zod/v4/core").$strict>>>;
+                            admin: import("zod").ZodOptional<import("zod").ZodObject<{
+                                grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    grant: "grant";
+                                    read: "read";
+                                    revoke: "revoke";
+                                    traverse: "traverse";
+                                    update: "update";
+                                    use: "use";
+                                }>>>;
+                                revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                                    create: "create";
+                                    delete: "delete";
+                                    grant: "grant";
+                                    read: "read";
+                                    revoke: "revoke";
+                                    traverse: "traverse";
+                                    update: "update";
+                                    use: "use";
+                                }>>>;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>;
+                        dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                            origin: import("zod").ZodString;
+                            installation: import("zod").ZodString;
+                            target: import("zod").ZodString;
+                            readinessReceipt: import("zod").ZodString;
+                            meaningComparison: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>;
+                phase: import("zod").ZodEnum<{
+                    converge: "converge";
+                    cutover: "cutover";
+                }>;
+                state: import("zod").ZodLiteral<"committed">;
+                readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+                    installation: import("zod").ZodString;
+                    target: import("zod").ZodString;
+                    transition: import("zod").ZodString;
+                    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+                        origin: import("zod").ZodString;
+                        installation: import("zod").ZodString;
+                        target: import("zod").ZodString;
+                        readinessReceipt: import("zod").ZodString;
+                        meaningComparison: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>;
         }, import("zod/v4/core").$strict>;
-    }, "admission">>;
-    journal: builder.Function<Omit<{
-        readonly description: "Read one authorized page from the kernel journal.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+    }>;
+    journal: builder.Function<{
+        readonly description: "Read one authorized page of semantic operations from the kernel journal.";
+        readonly auth: "authorized";
         readonly input: 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>>;
@@ -877,29 +1182,32 @@ export declare const Functions: Readonly<{
         }, import("zod/v4/core").$strict>;
         readonly output: 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>;
-    }, "admission">>;
+    }>;
 }>;
 export declare const IdentityMethods: Readonly<{
-    delegate: builder.Function<Omit<{
-        readonly description: "Issue one attenuated credential from this Identity.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+    delegate: builder.Function<{
+        readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
+        readonly auth: "authenticated";
         readonly input: import("zod").ZodObject<{
             audience: import("zod").ZodString;
             ttlSeconds: import("zod").ZodNumber;
-            delegation: import("zod").ZodUnknown;
-            attestation: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            attenuation: import("zod").ZodUnknown;
         }, import("zod/v4/core").$strict>;
         readonly output: import("zod").ZodString;
         readonly inheritance: "default";
-    }, "admission">>;
-    can: builder.Function<Omit<{
+    }>;
+    can: builder.Function<{
         readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-        readonly auth: "required";
-        readonly admission: "authenticated";
+        readonly auth: "authenticated";
         readonly input: import("zod").ZodObject<{
             policy: import("zod").ZodString;
             object: import("zod").ZodString;
@@ -909,11 +1217,10 @@ export declare const IdentityMethods: Readonly<{
         }, import("zod/v4/core").$strict>;
         readonly static: true;
         readonly inheritance: "default";
-    }, "admission">>;
-    whoami: builder.Function<Omit<{
+    }>;
+    whoami: builder.Function<{
         readonly description: "Return the Identity authenticated for this invocation.";
-        readonly auth: "required";
-        readonly admission: "authenticated";
+        readonly auth: "authenticated";
         readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
         readonly output: import("zod").ZodObject<{
             id: import("zod").ZodString;
@@ -935,12 +1242,10 @@ export declare const IdentityMethods: Readonly<{
         }, import("zod/v4/core").$strict>;
         readonly static: true;
         readonly inheritance: "default";
-    }, "admission">>;
-    whois: builder.Function<Omit<{
+    }>;
+    whois: builder.Function<{
         readonly description: "Resolve one issuer-and-subject Identity.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+        readonly auth: "authorized";
         readonly input: import("zod").ZodObject<{
             issuer: import("zod").ZodString;
             subject: import("zod").ZodString;
@@ -965,12 +1270,10 @@ export declare const IdentityMethods: Readonly<{
         }, import("zod/v4/core").$strict>>;
         readonly static: true;
         readonly inheritance: "default";
-    }, "admission">>;
-    mint: builder.Function<Omit<{
+    }>;
+    mint: builder.Function<{
         readonly description: "Resolve and sign one authorized Grant credential.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+        readonly auth: "authorized";
         readonly input: import("zod").ZodObject<{
             audience: import("zod").ZodOptional<import("zod").ZodString>;
             ttlSeconds: import("zod").ZodNumber;
@@ -979,13 +1282,12 @@ export declare const IdentityMethods: Readonly<{
         readonly output: import("zod").ZodString;
         readonly static: true;
         readonly inheritance: "default";
-    }, "admission">>;
+    }>;
 }>;
 export declare const FunctionMethods: Readonly<{
-    admit: builder.Function<Omit<{
+    admit: builder.Function<{
         readonly description: "Admit one remote path-only attempt and return its request-scoped execution target.";
-        readonly auth: "required";
-        readonly admission: "authenticated";
+        readonly auth: "authenticated";
         readonly input: import("zod").ZodObject<{
             call: import("zod").ZodObject<{
                 target: import("zod").ZodString;
@@ -999,14 +1301,12 @@ export declare const FunctionMethods: Readonly<{
         }, import("zod/v4/core").$strict>;
         readonly static: true;
         readonly inheritance: "sealed";
-    }, "admission">>;
+    }>;
 }>;
 export declare const ViewMethods: Readonly<{
-    resolve: builder.Function<Omit<{
+    resolve: builder.Function<{
         readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
-        readonly auth: "required";
-        readonly admission: "policy";
-        readonly policy: builder.CallablePolicyBuilder;
+        readonly auth: "authorized";
         readonly input: import("zod").ZodObject<{
             target: import("zod").ZodString;
         }, import("zod/v4/core").$strict>;
@@ -1048,6 +1348,6 @@ export declare const ViewMethods: Readonly<{
         }, import("zod/v4/core").$strict>;
         readonly static: true;
         readonly inheritance: "sealed";
-    }, "admission">>;
+    }>;
 }>;
 //# sourceMappingURL=index.d.ts.map

package/dist/schema/kernel/syscalls/declarations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAgBxD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOiC,CAAA;AAEvD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM2B,CAAA;AAEvD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;EAE2B,CAAA;AAEvD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE+B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAiBxD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQiC,CAAA;AAEvD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM2B,CAAA;AAEvD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;EAE2B,CAAA;AAEvD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE+B,CAAA"}

package/dist/schema/kernel/syscalls/declarations/index.js

@@ -2,6 +2,7 @@ import { Admit } from './admit.js';
 import { Can } from './can.js';
 import { Delegate } from './delegate.js';
 import { Install } from './install.js';
+import { Introspect } from './introspect.js';
 import { Journal } from './journal.js';
 import { Mint } from './mint.js';
 import { Mutate } from './mutate.js';
@@ -16,6 +17,7 @@ export const Functions = Object.freeze({
     mutate: Mutate,
     provision: Provision,
     install: Install,
+    introspect: Introspect,
     uninstall: Uninstall,
     journal: Journal,
 });

package/dist/schema/kernel/syscalls/declarations/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;IACrC,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,OAAO;IAChB,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,OAAO;CACjB,CAAsD,CAAA;AAEvD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3C,QAAQ,EAAE,QAAQ;IAClB,GAAG,EAAE,GAAG;IACR,MAAM,EAAE,MAAM;IACd,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,IAAI;CACX,CAAsD,CAAA;AAEvD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3C,KAAK,EAAE,KAAK;CACb,CAAsD,CAAA;AAEvD,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;IACvC,OAAO,EAAE,WAAW;CACrB,CAAsD,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;IACrC,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,UAAU;IACtB,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,OAAO;CACjB,CAAsD,CAAA;AAEvD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3C,QAAQ,EAAE,QAAQ;IAClB,GAAG,EAAE,GAAG;IACR,MAAM,EAAE,MAAM;IACd,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,IAAI;CACX,CAAsD,CAAA;AAEvD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3C,KAAK,EAAE,KAAK;CACb,CAAsD,CAAA;AAEvD,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;IACvC,OAAO,EAAE,WAAW;CACrB,CAAsD,CAAA"}