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

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

@@ -40,13 +40,10 @@ export declare const Mutate: builder.Function<{
                         kind: import("zod").ZodLiteral<"path">;
                         path: import("zod").ZodString;
                     }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        kind: import("zod").ZodLiteral<"definition">;
-                        definition: import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"class">;
+                        class: import("zod").ZodObject<{
                             origin: import("zod").ZodString;
-                            kind: import("zod").ZodEnum<{
-                                class: "class";
-                                interface: "interface";
-                            }>;
+                            kind: import("zod").ZodLiteral<"class">;
                             name: import("zod").ZodString;
                         }, import("zod/v4/core").$strict>;
                     }, import("zod/v4/core").$strict>], "kind">>;
@@ -54,13 +51,10 @@ export declare const Mutate: builder.Function<{
                 }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
                     kind: import("zod").ZodLiteral<"edge">;
                     terms: import("zod").ZodArray<import("zod").ZodObject<{
-                        kind: import("zod").ZodLiteral<"definition">;
-                        definition: import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"class">;
+                        class: import("zod").ZodObject<{
                             origin: import("zod").ZodString;
-                            kind: import("zod").ZodEnum<{
-                                class: "class";
-                                interface: "interface";
-                            }>;
+                            kind: import("zod").ZodLiteral<"class">;
                             name: import("zod").ZodString;
                         }, import("zod/v4/core").$strict>;
                     }, import("zod/v4/core").$strict>>;
@@ -74,13 +68,17 @@ export declare const Mutate: builder.Function<{
                     op: import("zod").ZodLiteral<"filter">;
                     binding: import("zod").ZodString;
                     predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        kind: import("zod").ZodLiteral<"definition.satisfies">;
-                        definition: import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"class.satisfies">;
+                        class: import("zod").ZodObject<{
                             origin: import("zod").ZodString;
-                            kind: import("zod").ZodEnum<{
-                                class: "class";
-                                interface: "interface";
-                            }>;
+                            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<{
@@ -103,10 +101,7 @@ export declare const Mutate: builder.Function<{
                     from: import("zod").ZodString;
                     via: import("zod").ZodArray<import("zod").ZodObject<{
                         origin: import("zod").ZodString;
-                        kind: import("zod").ZodEnum<{
-                            class: "class";
-                            interface: "interface";
-                        }>;
+                        kind: import("zod").ZodLiteral<"class">;
                         name: import("zod").ZodString;
                     }, import("zod/v4/core").$strict>>;
                     direction: import("zod").ZodEnum<{
@@ -259,4 +254,3 @@ export declare const Mutate: builder.Function<{
         createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     }, import("zod/v4/core").$strict>;
 }>;
-//# sourceMappingURL=mutate.d.ts.map

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

@@ -1,9 +1,8 @@
 import { mutateInput, mutateOutput } from '../contracts/index.js';
-import { defineSyscall } from './define.js';
-export const Mutate = defineSyscall({
+import { defineFunction } from './define.js';
+export const Mutate = defineFunction({
     description: 'Validate, authorize, and commit one atomic graph mutation.',
     auth: 'authorized',
     input: mutateInput,
     output: mutateOutput,
 });
-//# sourceMappingURL=mutate.js.map

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

@@ -42,13 +42,10 @@ export declare const Provision: builder.Function<{
                             kind: import("zod").ZodLiteral<"path">;
                             path: import("zod").ZodString;
                         }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                            kind: import("zod").ZodLiteral<"definition">;
-                            definition: import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"class">;
+                            class: import("zod").ZodObject<{
                                 origin: import("zod").ZodString;
-                                kind: import("zod").ZodEnum<{
-                                    class: "class";
-                                    interface: "interface";
-                                }>;
+                                kind: import("zod").ZodLiteral<"class">;
                                 name: import("zod").ZodString;
                             }, import("zod/v4/core").$strict>;
                         }, import("zod/v4/core").$strict>], "kind">>;
@@ -56,13 +53,10 @@ export declare const Provision: builder.Function<{
                     }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
                         kind: import("zod").ZodLiteral<"edge">;
                         terms: import("zod").ZodArray<import("zod").ZodObject<{
-                            kind: import("zod").ZodLiteral<"definition">;
-                            definition: import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"class">;
+                            class: import("zod").ZodObject<{
                                 origin: import("zod").ZodString;
-                                kind: import("zod").ZodEnum<{
-                                    class: "class";
-                                    interface: "interface";
-                                }>;
+                                kind: import("zod").ZodLiteral<"class">;
                                 name: import("zod").ZodString;
                             }, import("zod/v4/core").$strict>;
                         }, import("zod/v4/core").$strict>>;
@@ -76,13 +70,17 @@ export declare const Provision: builder.Function<{
                         op: import("zod").ZodLiteral<"filter">;
                         binding: import("zod").ZodString;
                         predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                            kind: import("zod").ZodLiteral<"definition.satisfies">;
-                            definition: import("zod").ZodObject<{
+                            kind: import("zod").ZodLiteral<"class.satisfies">;
+                            class: import("zod").ZodObject<{
                                 origin: import("zod").ZodString;
-                                kind: import("zod").ZodEnum<{
-                                    class: "class";
-                                    interface: "interface";
-                                }>;
+                                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<{
@@ -105,10 +103,7 @@ export declare const Provision: builder.Function<{
                         from: import("zod").ZodString;
                         via: import("zod").ZodArray<import("zod").ZodObject<{
                             origin: import("zod").ZodString;
-                            kind: import("zod").ZodEnum<{
-                                class: "class";
-                                interface: "interface";
-                            }>;
+                            kind: import("zod").ZodLiteral<"class">;
                             name: import("zod").ZodString;
                         }, import("zod/v4/core").$strict>>;
                         direction: import("zod").ZodEnum<{
@@ -299,4 +294,3 @@ export declare const Provision: builder.Function<{
         }, import("zod/v4/core").$strict>>;
     }, import("zod/v4/core").$strict>;
 }>;
-//# sourceMappingURL=provision.d.ts.map

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

@@ -1,9 +1,8 @@
 import { provisionInput, provisionOutput } from '../contracts/index.js';
-import { defineSyscall } from './define.js';
-export const Provision = defineSyscall({
+import { defineFunction } from './define.js';
+export const Provision = defineFunction({
     description: 'Atomically execute a graph transition whose designated Identities are born complete.',
     auth: 'authorized',
     input: provisionInput,
     output: provisionOutput,
 });
-//# sourceMappingURL=provision.js.map

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

@@ -12,13 +12,10 @@ export declare const Query: builder.Function<{
                     kind: import("zod").ZodLiteral<"path">;
                     path: import("zod").ZodString;
                 }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    kind: import("zod").ZodLiteral<"definition">;
-                    definition: import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"class">;
+                    class: import("zod").ZodObject<{
                         origin: import("zod").ZodString;
-                        kind: import("zod").ZodEnum<{
-                            class: "class";
-                            interface: "interface";
-                        }>;
+                        kind: import("zod").ZodLiteral<"class">;
                         name: import("zod").ZodString;
                     }, import("zod/v4/core").$strict>;
                 }, import("zod/v4/core").$strict>], "kind">>;
@@ -26,13 +23,10 @@ export declare const Query: builder.Function<{
             }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
                 kind: import("zod").ZodLiteral<"edge">;
                 terms: import("zod").ZodArray<import("zod").ZodObject<{
-                    kind: import("zod").ZodLiteral<"definition">;
-                    definition: import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"class">;
+                    class: import("zod").ZodObject<{
                         origin: import("zod").ZodString;
-                        kind: import("zod").ZodEnum<{
-                            class: "class";
-                            interface: "interface";
-                        }>;
+                        kind: import("zod").ZodLiteral<"class">;
                         name: import("zod").ZodString;
                     }, import("zod/v4/core").$strict>;
                 }, import("zod/v4/core").$strict>>;
@@ -46,13 +40,17 @@ export declare const Query: builder.Function<{
                 op: import("zod").ZodLiteral<"filter">;
                 binding: import("zod").ZodString;
                 predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                    kind: import("zod").ZodLiteral<"definition.satisfies">;
-                    definition: import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"class.satisfies">;
+                    class: import("zod").ZodObject<{
                         origin: import("zod").ZodString;
-                        kind: import("zod").ZodEnum<{
-                            class: "class";
-                            interface: "interface";
-                        }>;
+                        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<{
@@ -75,10 +73,7 @@ export declare const Query: builder.Function<{
                 from: import("zod").ZodString;
                 via: import("zod").ZodArray<import("zod").ZodObject<{
                     origin: import("zod").ZodString;
-                    kind: import("zod").ZodEnum<{
-                        class: "class";
-                        interface: "interface";
-                    }>;
+                    kind: import("zod").ZodLiteral<"class">;
                     name: import("zod").ZodString;
                 }, import("zod/v4/core").$strict>>;
                 direction: import("zod").ZodEnum<{
@@ -155,6 +150,10 @@ export declare const Query: builder.Function<{
                 }, 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>;
@@ -259,4 +258,3 @@ export declare const Query: builder.Function<{
         }, import("zod/v4/core").$strict>;
     }, import("zod/v4/core").$strict>;
 }>;
-//# sourceMappingURL=query.d.ts.map

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

@@ -1,9 +1,8 @@
 import { queryInput, queryOutput } from '../contracts/index.js';
-import { defineSyscall } from './define.js';
-export const Query = defineSyscall({
+import { defineFunction } from './define.js';
+export const Query = defineFunction({
     description: 'Execute one finite authorized graph query.',
     auth: 'authorized',
     input: queryInput,
     output: queryOutput,
 });
-//# sourceMappingURL=query.js.map

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

@@ -151,4 +151,3 @@ export declare const Uninstall: builder.Function<{
         }, import("zod/v4/core").$strict>;
     }, import("zod/v4/core").$strict>;
 }>;
-//# sourceMappingURL=uninstall.d.ts.map

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

@@ -1,9 +1,8 @@
 import { uninstallInput, uninstallOutput } from '../contracts/index.js';
-import { defineSyscall } from './define.js';
-export const Uninstall = defineSyscall({
+import { defineFunction } from './define.js';
+export const Uninstall = defineFunction({
     description: 'Durably uninstall one Domain installation epoch and return its terminal receipt.',
     auth: 'authorized',
     input: uninstallInput,
     output: uninstallOutput,
 });
-//# sourceMappingURL=uninstall.js.map

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

@@ -1,5 +1,5 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const ViewResolve: builder.Function<{
+export declare const ViewResolve: builder.Method<{
     readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
     readonly auth: "authorized";
     readonly input: import("zod").ZodObject<{
@@ -15,15 +15,11 @@ export declare const ViewResolve: builder.Function<{
                     kind: import("zod").ZodLiteral<"domain">;
                 }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
                     kind: import("zod").ZodLiteral<"definition">;
-                    definitions: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    definitions: import("zod").ZodArray<import("zod").ZodObject<{
                         origin: import("zod").ZodString;
                         kind: import("zod").ZodLiteral<"class">;
                         name: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        origin: import("zod").ZodString;
-                        kind: import("zod").ZodLiteral<"interface">;
-                        name: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>], "kind">>;
+                    }, import("zod/v4/core").$strict>>;
                 }, import("zod/v4/core").$strict>], "kind">;
             }, import("zod/v4/core").$strict>;
             href: import("zod").ZodString;
@@ -39,4 +35,3 @@ export declare const ViewResolve: builder.Function<{
     readonly static: true;
     readonly inheritance: "sealed";
 }>;
-//# sourceMappingURL=view-resolve.d.ts.map

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

@@ -1,6 +1,6 @@
 import { viewResolveInput, viewResolveOutput } from '../contracts/index.js';
-import { defineSyscall } from './define.js';
-export const ViewResolve = defineSyscall({
+import { defineMethod } from './define.js';
+export const ViewResolve = defineMethod({
     description: 'Resolve the installed View declarations applicable to one authorized graph target.',
     auth: 'authorized',
     input: viewResolveInput,
@@ -8,4 +8,3 @@ export const ViewResolve = defineSyscall({
     static: true,
     inheritance: 'sealed',
 });
-//# sourceMappingURL=view-resolve.js.map

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

@@ -1,5 +1,5 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Whoami: builder.Function<{
+export declare const Whoami: builder.Method<{
     readonly description: "Return the Identity authenticated for this invocation.";
     readonly auth: "authenticated";
     readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
@@ -24,4 +24,3 @@ export declare const Whoami: builder.Function<{
     readonly static: true;
     readonly inheritance: "default";
 }>;
-//# sourceMappingURL=whoami.d.ts.map

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

@@ -1,6 +1,6 @@
 import { whoamiInput, whoamiOutput } from '../contracts/index.js';
-import { defineSyscall } from './define.js';
-export const Whoami = defineSyscall({
+import { defineMethod } from './define.js';
+export const Whoami = defineMethod({
     description: 'Return the Identity authenticated for this invocation.',
     auth: 'authenticated',
     input: whoamiInput,
@@ -8,4 +8,3 @@ export const Whoami = defineSyscall({
     static: true,
     inheritance: 'default',
 });
-//# sourceMappingURL=whoami.js.map

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

@@ -1,5 +1,5 @@
 import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Whois: builder.Function<{
+export declare const Whois: builder.Method<{
     readonly description: "Resolve one issuer-and-subject Identity.";
     readonly auth: "authorized";
     readonly input: import("zod").ZodObject<{
@@ -27,4 +27,3 @@ export declare const Whois: builder.Function<{
     readonly static: true;
     readonly inheritance: "default";
 }>;
-//# sourceMappingURL=whois.d.ts.map

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

@@ -1,6 +1,6 @@
 import { whoisInput, whoisOutput } from '../contracts/index.js';
-import { defineSyscall } from './define.js';
-export const Whois = defineSyscall({
+import { defineMethod } from './define.js';
+export const Whois = defineMethod({
     description: 'Resolve one issuer-and-subject Identity.',
     auth: 'authorized',
     input: whoisInput,
@@ -8,4 +8,3 @@ export const Whois = defineSyscall({
     static: true,
     inheritance: 'default',
 });
-//# sourceMappingURL=whois.js.map

package/dist/schema/kernel/syscalls/descriptors/function.d.ts

@@ -1,32 +1,21 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
-import type { Method } from '#domain';
+import type { ClassRef } from '@astrale-os/kernel-dsl/v1';
 import { type MethodSyscall } from './model.js';
-declare const Admit: Method<{
-    readonly input: {
-        readonly call: {
-            readonly target: string;
-            readonly input: unknown;
-        };
-        readonly credential?: string;
+declare const Admit: import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    call: {
+        target: string;
+        input: unknown;
     };
-    readonly output: {
-        readonly mode: 'value';
-        readonly value: {
-            readonly callable: string;
-            readonly receiver?: string;
-        };
+    credential?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        callable: string;
+        receiver?: string | undefined;
     };
-    readonly static: true;
-    readonly inheritance: 'sealed';
-    readonly declaredBy: unknown;
-}> & {
-    readonly owner: schema.ClassRef<'Function'> & {
-        readonly origin: 'kernel.astrale.ai';
-    };
-    readonly name: 'admit';
+}, true, "sealed", "authenticated", never, "kernel.astrale.ai:class.Function.method.admit"> & {
+    readonly name: "admit";
 };
-export declare const admit: MethodSyscall<schema.ClassRef<'Function'> & {
+export declare const admit: MethodSyscall<ClassRef<'Function'> & {
     readonly origin: 'kernel.astrale.ai';
 }, 'admit', typeof Admit>;
 export {};
-//# sourceMappingURL=function.d.ts.map

package/dist/schema/kernel/syscalls/descriptors/function.js

@@ -1,6 +1,5 @@
 import { K } from '../../index.js';
 import { admit as admitRef } from '../references/function.js';
 import { methodSyscall } from './model.js';
-const Admit = K.$.class('Function').$.method('admit');
+const Admit = K.classes.Function.static.methods.admit;
 export const admit = methodSyscall(admitRef, Admit);
-//# sourceMappingURL=function.js.map

package/dist/schema/kernel/syscalls/descriptors/functions.d.ts

@@ -1,10 +1,9 @@
 import { K } from '../../index.js';
 import { type FunctionSyscall } from './model.js';
-export declare const query: FunctionSyscall<'kernel.astrale.ai', 'query', typeof K.query>;
-export declare const mutate: FunctionSyscall<'kernel.astrale.ai', 'mutate', typeof K.mutate>;
-export declare const provision: FunctionSyscall<'kernel.astrale.ai', 'provision', typeof K.provision>;
-export declare const install: FunctionSyscall<'kernel.astrale.ai', 'install', typeof K.install>;
-export declare const introspect: FunctionSyscall<'kernel.astrale.ai', 'introspect', typeof K.introspect>;
-export declare const uninstall: FunctionSyscall<'kernel.astrale.ai', 'uninstall', typeof K.uninstall>;
-export declare const journal: FunctionSyscall<'kernel.astrale.ai', 'journal', typeof K.journal>;
-//# sourceMappingURL=functions.d.ts.map
+export declare const query: FunctionSyscall<'kernel.astrale.ai', 'query', typeof K.functions.query>;
+export declare const mutate: FunctionSyscall<'kernel.astrale.ai', 'mutate', typeof K.functions.mutate>;
+export declare const provision: FunctionSyscall<'kernel.astrale.ai', 'provision', typeof K.functions.provision>;
+export declare const install: FunctionSyscall<'kernel.astrale.ai', 'install', typeof K.functions.install>;
+export declare const introspect: FunctionSyscall<'kernel.astrale.ai', 'introspect', typeof K.functions.introspect>;
+export declare const uninstall: FunctionSyscall<'kernel.astrale.ai', 'uninstall', typeof K.functions.uninstall>;
+export declare const journal: FunctionSyscall<'kernel.astrale.ai', 'journal', typeof K.functions.journal>;

package/dist/schema/kernel/syscalls/descriptors/functions.js

@@ -1,11 +1,10 @@
 import { K } from '../../index.js';
 import * as references from '../references/functions.js';
 import { functionSyscall } from './model.js';
-export const query = functionSyscall(references.query, K.query);
-export const mutate = functionSyscall(references.mutate, K.mutate);
-export const provision = functionSyscall(references.provision, K.provision);
-export const install = functionSyscall(references.install, K.install);
-export const introspect = functionSyscall(references.introspect, K.introspect);
-export const uninstall = functionSyscall(references.uninstall, K.uninstall);
-export const journal = functionSyscall(references.journal, K.journal);
-//# sourceMappingURL=functions.js.map
+export const query = functionSyscall(references.query, K.functions.query);
+export const mutate = functionSyscall(references.mutate, K.functions.mutate);
+export const provision = functionSyscall(references.provision, K.functions.provision);
+export const install = functionSyscall(references.install, K.functions.install);
+export const introspect = functionSyscall(references.introspect, K.functions.introspect);
+export const uninstall = functionSyscall(references.uninstall, K.functions.uninstall);
+export const journal = functionSyscall(references.journal, K.functions.journal);

package/dist/schema/kernel/syscalls/descriptors/identity.d.ts

@@ -1,19 +1,100 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
-import { K } from '../../index.js';
-import { type MethodSyscall } from './model.js';
-export declare const delegate: MethodSyscall<schema.InterfaceRef<'Identity'> & {
-    readonly origin: 'kernel.astrale.ai';
-}, 'delegate', typeof K.Identity.delegate>;
-export declare const can: MethodSyscall<schema.InterfaceRef<'Identity'> & {
-    readonly origin: 'kernel.astrale.ai';
-}, 'can', typeof K.Identity.can>;
-export declare const whoami: MethodSyscall<schema.InterfaceRef<'Identity'> & {
-    readonly origin: 'kernel.astrale.ai';
-}, 'whoami', typeof K.Identity.whoami>;
-export declare const whois: MethodSyscall<schema.InterfaceRef<'Identity'> & {
-    readonly origin: 'kernel.astrale.ai';
-}, 'whois', typeof K.Identity.whois>;
-export declare const mint: MethodSyscall<schema.InterfaceRef<'Identity'> & {
-    readonly origin: 'kernel.astrale.ai';
-}, 'mint', typeof K.Identity.mint>;
-//# sourceMappingURL=identity.d.ts.map
+export declare const delegate: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Identity';
+}>, "delegate", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    audience: string;
+    ttlSeconds: number;
+    attenuation: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+    readonly name: "delegate";
+}>;
+export declare const can: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Identity';
+}>, "can", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    policy: string;
+    object: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        allowed: boolean;
+    };
+}, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+    readonly name: "can";
+}>;
+export declare const whoami: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Identity';
+}>, "whoami", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        issuer: string;
+        subject: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    };
+}, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+    readonly name: "whoami";
+}>;
+export declare const whois: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Identity';
+}>, "whois", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    issuer: string;
+    subject: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        issuer: string;
+        subject: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    } | null;
+}, true, "default", "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+    readonly name: "whois";
+}>;
+export declare const mint: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Identity';
+}>, "mint", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+    grant?: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, true, "default", "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+    readonly name: "mint";
+}>;

package/dist/schema/kernel/syscalls/descriptors/identity.js

@@ -1,9 +1,8 @@
 import { K } from '../../index.js';
 import * as references from '../references/identity.js';
 import { methodSyscall } from './model.js';
-export const delegate = methodSyscall(references.delegate, K.Identity.delegate);
-export const can = methodSyscall(references.can, K.Identity.can);
-export const whoami = methodSyscall(references.whoami, K.Identity.whoami);
-export const whois = methodSyscall(references.whois, K.Identity.whois);
-export const mint = methodSyscall(references.mint, K.Identity.mint);
-//# sourceMappingURL=identity.js.map
+export const delegate = methodSyscall(references.delegate, K.classes.Identity.methods.delegate);
+export const can = methodSyscall(references.can, K.classes.Identity.static.methods.can);
+export const whoami = methodSyscall(references.whoami, K.classes.Identity.static.methods.whoami);
+export const whois = methodSyscall(references.whois, K.classes.Identity.static.methods.whois);
+export const mint = methodSyscall(references.mint, K.classes.Identity.static.methods.mint);