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

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

@@ -1,22 +1,173 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const 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;
+export declare const 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">>;
+}>;
 //# sourceMappingURL=install.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/install.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAOxD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;gBAOS,CAAA"}
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/install.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKxD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKS,CAAA"}

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

@@ -1,12 +1,8 @@
-import { InstallCapability } from '../../../core/index.js';
 import { installInput, installOutput } from '../contracts/index.js';
-import { requiresCapability } from './capability-policy.js';
 import { defineSyscall } from './define.js';
 export const Install = defineSyscall({
-    description: 'Fetch, verify, and atomically activate one or more explicit Domain roots.',
-    auth: 'required',
-    admission: 'policy',
-    policy: requiresCapability(InstallCapability),
+    description: 'Durably install one or more exact Schema targets and return a terminal receipt.',
+    auth: 'authorized',
     input: installInput,
     output: installOutput,
 });

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

@@ -1 +1 @@
-{"version":3,"file":"install.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/install.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC;IACnC,WAAW,EAAE,2EAA2E;IACxF,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,kBAAkB,CAAC,iBAAiB,CAAC;IAC7C,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,aAAa;CACtB,CAA4B,CAAA"}
+{"version":3,"file":"install.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/install.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC;IACnC,WAAW,EAAE,iFAAiF;IAC9F,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,aAAa;CACtB,CAA4B,CAAA"}

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

@@ -0,0 +1,21 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const 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;
+}>;
+//# sourceMappingURL=introspect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/introspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKhE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;EAKM,CAAA"}

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

@@ -0,0 +1,10 @@
+import { output } from '@astrale-os/kernel-dsl/v1';
+import { introspectInput } from '../contracts/index.js';
+import { defineSyscall } from './define.js';
+export const Introspect = defineSyscall({
+    description: 'Return bounded installed-Publication evidence to an authenticated Kernel session.',
+    auth: 'authenticated',
+    input: introspectInput,
+    output: output.binary(),
+});
+//# sourceMappingURL=introspect.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/introspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,2BAA2B,CAAA;AAEhE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CAAC;IACtC,WAAW,EAAE,mFAAmF;IAChG,IAAI,EAAE,eAAe;IACrB,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;CACxB,CAA4B,CAAA"}

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

@@ -1,10 +1,12 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Journal: builder.Function<Omit<{
-    readonly description: "Read one authorized page from the kernel journal.";
-    readonly auth: "required";
-    readonly admission: "policy";
-    readonly policy: builder.CallablePolicyBuilder;
+export declare const 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>>;
@@ -17,7 +19,14 @@ export declare const Journal: builder.Function<Omit<{
     }, 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">>;
+}>;
 //# sourceMappingURL=journal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"journal.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/journal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAOxD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;gBAOS,CAAA"}
+{"version":3,"file":"journal.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/journal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKxD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKS,CAAA"}

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

@@ -1,12 +1,8 @@
-import { JournalCapability } from '../../../core/index.js';
 import { journalInput, journalOutput } from '../contracts/index.js';
-import { requiresCapability } from './capability-policy.js';
 import { defineSyscall } from './define.js';
 export const Journal = defineSyscall({
-    description: 'Read one authorized page from the kernel journal.',
-    auth: 'required',
-    admission: 'policy',
-    policy: requiresCapability(JournalCapability),
+    description: 'Read one authorized page of semantic operations from the kernel journal.',
+    auth: 'authorized',
     input: journalInput,
     output: journalOutput,
 });

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

@@ -1 +1 @@
-{"version":3,"file":"journal.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/journal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC;IACnC,WAAW,EAAE,mDAAmD;IAChE,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,kBAAkB,CAAC,iBAAiB,CAAC;IAC7C,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,aAAa;CACtB,CAA4B,CAAA"}
+{"version":3,"file":"journal.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/journal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC;IACnC,WAAW,EAAE,0EAA0E;IACvF,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,aAAa;CACtB,CAA4B,CAAA"}

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

@@ -1,9 +1,7 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Mint: builder.Function<Omit<{
+export declare const 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;
@@ -12,5 +10,5 @@ export declare const Mint: builder.Function<Omit<{
     readonly output: import("zod").ZodString;
     readonly static: true;
     readonly inheritance: "default";
-}, "admission">>;
+}>;
 //# sourceMappingURL=mint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/mint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAOxD,eAAO,MAAM,IAAI;;;;;;;;;;;;;gBASY,CAAA"}
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/mint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKxD,eAAO,MAAM,IAAI;;;;;;;;;;;EAOY,CAAA"}

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

@@ -1,12 +1,8 @@
-import { MintCapability } from '../../../core/index.js';
 import { mintInput, mintOutput } from '../contracts/index.js';
-import { requiresCapability } from './capability-policy.js';
 import { defineSyscall } from './define.js';
 export const Mint = defineSyscall({
     description: 'Resolve and sign one authorized Grant credential.',
-    auth: 'required',
-    admission: 'policy',
-    policy: requiresCapability(MintCapability),
+    auth: 'authorized',
     input: mintInput,
     output: mintOutput,
     static: true,

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

@@ -1 +1 @@
-{"version":3,"file":"mint.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/mint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,IAAI,GAAG,aAAa,CAAC;IAChC,WAAW,EAAE,mDAAmD;IAChE,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,kBAAkB,CAAC,cAAc,CAAC;IAC1C,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,IAAI;IACZ,WAAW,EAAE,SAAS;CACvB,CAA4B,CAAA"}
+{"version":3,"file":"mint.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/mint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,IAAI,GAAG,aAAa,CAAC;IAChC,WAAW,EAAE,mDAAmD;IAChE,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,IAAI;IACZ,WAAW,EAAE,SAAS;CACvB,CAA4B,CAAA"}

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

@@ -1,9 +1,7 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Mutate: builder.Function<Omit<{
+export declare const 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">;
@@ -260,5 +258,5 @@ export declare const Mutate: builder.Function<Omit<{
     readonly output: import("zod").ZodObject<{
         createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     }, import("zod/v4/core").$strict>;
-}, "admission">>;
+}>;
 //# sourceMappingURL=mutate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mutate.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/mutate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAOxD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAOU,CAAA"}
+{"version":3,"file":"mutate.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/mutate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKxD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKU,CAAA"}

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

@@ -1,12 +1,8 @@
-import { MutateCapability } from '../../../core/index.js';
 import { mutateInput, mutateOutput } from '../contracts/index.js';
-import { requiresCapability } from './capability-policy.js';
 import { defineSyscall } from './define.js';
 export const Mutate = defineSyscall({
     description: 'Validate, authorize, and commit one atomic graph mutation.',
-    auth: 'required',
-    admission: 'policy',
-    policy: requiresCapability(MutateCapability),
+    auth: 'authorized',
     input: mutateInput,
     output: mutateOutput,
 });

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

@@ -1 +1 @@
-{"version":3,"file":"mutate.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/mutate.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,MAAM,GAAG,aAAa,CAAC;IAClC,WAAW,EAAE,4DAA4D;IACzE,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,kBAAkB,CAAC,gBAAgB,CAAC;IAC5C,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,YAAY;CACrB,CAA4B,CAAA"}
+{"version":3,"file":"mutate.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/mutate.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,MAAM,GAAG,aAAa,CAAC;IAClC,WAAW,EAAE,4DAA4D;IACzE,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,YAAY;CACrB,CAA4B,CAAA"}

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

@@ -1,9 +1,7 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Provision: builder.Function<Omit<{
+export declare const 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<{
@@ -300,5 +298,5 @@ export declare const Provision: builder.Function<Omit<{
             subject: import("zod").ZodString;
         }, import("zod/v4/core").$strict>>;
     }, import("zod/v4/core").$strict>;
-}, "admission">>;
+}>;
 //# sourceMappingURL=provision.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"provision.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/provision.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAOxD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAQO,CAAA"}
+{"version":3,"file":"provision.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/provision.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKxD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMO,CAAA"}

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

@@ -1,12 +1,8 @@
-import { ProvisionCapability } from '../../../core/index.js';
 import { provisionInput, provisionOutput } from '../contracts/index.js';
-import { requiresCapability } from './capability-policy.js';
 import { defineSyscall } from './define.js';
 export const Provision = defineSyscall({
     description: 'Atomically execute a graph transition whose designated Identities are born complete.',
-    auth: 'required',
-    admission: 'policy',
-    policy: requiresCapability(ProvisionCapability),
+    auth: 'authorized',
     input: provisionInput,
     output: provisionOutput,
 });

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

@@ -1 +1 @@
-{"version":3,"file":"provision.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/provision.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,SAAS,GAAG,aAAa,CAAC;IACrC,WAAW,EACT,sFAAsF;IACxF,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,kBAAkB,CAAC,mBAAmB,CAAC;IAC/C,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,eAAe;CACxB,CAA4B,CAAA"}
+{"version":3,"file":"provision.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/provision.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,SAAS,GAAG,aAAa,CAAC;IACrC,WAAW,EACT,sFAAsF;IACxF,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,eAAe;CACxB,CAA4B,CAAA"}

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

@@ -1,9 +1,7 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Query: builder.Function<Omit<{
+export declare const 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">;
@@ -260,5 +258,5 @@ export declare const Query: builder.Function<Omit<{
             next: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strict>;
     }, import("zod/v4/core").$strict>;
-}, "admission">>;
+}>;
 //# sourceMappingURL=query.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAOxD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAOW,CAAA"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAKxD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKW,CAAA"}

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

@@ -1,12 +1,8 @@
-import { QueryCapability } from '../../../core/index.js';
 import { queryInput, queryOutput } from '../contracts/index.js';
-import { requiresCapability } from './capability-policy.js';
 import { defineSyscall } from './define.js';
 export const Query = defineSyscall({
     description: 'Execute one finite authorized graph query.',
-    auth: 'required',
-    admission: 'policy',
-    policy: requiresCapability(QueryCapability),
+    auth: 'authorized',
     input: queryInput,
     output: queryOutput,
 });

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

@@ -1 +1 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/query.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,KAAK,GAAG,aAAa,CAAC;IACjC,WAAW,EAAE,4CAA4C;IACzD,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,kBAAkB,CAAC,eAAe,CAAC;IAC3C,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,WAAW;CACpB,CAA4B,CAAA"}
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../../../schema/kernel/syscalls/declarations/query.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,CAAC,MAAM,KAAK,GAAG,aAAa,CAAC;IACjC,WAAW,EAAE,4CAA4C;IACzD,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,WAAW;CACpB,CAA4B,CAAA"}