@astrale-os/kernel-core 0.9.0-beta.6 → 0.9.0-beta.60

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

@@ -0,0 +1,153 @@
+export declare const status: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "status", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        function: string;
+        version: string;
+        state: "cancelled" | "completed" | "expired" | "failed" | "paused" | "pending" | "running" | "waiting";
+        createdAt: string;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    };
+}, false, false, "authenticated", 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.Execution.method.status"> & {
+    readonly name: "status";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const result: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "result", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    waitMs?: number | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        kind: "completed";
+        value: unknown;
+    } | {
+        kind: "failed";
+        error: {
+            code: string;
+            message: string;
+            family?: string | undefined;
+            details?: unknown;
+        };
+    } | {
+        kind: "cancelled";
+    };
+}, false, false, "authenticated", 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.Execution.method.result"> & {
+    readonly name: "result";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const cancel: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "cancel", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    force?: boolean | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        function: string;
+        version: string;
+        state: "cancelled" | "completed" | "expired" | "failed" | "paused" | "pending" | "running" | "waiting";
+        createdAt: string;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    };
+}, false, false, "authenticated", 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.Execution.method.cancel"> & {
+    readonly name: "cancel";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const signal: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "signal", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    name: string;
+    value: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, false, false, "authenticated", 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.Execution.method.signal"> & {
+    readonly name: "signal";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const resume: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "resume", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        function: string;
+        version: string;
+        state: "cancelled" | "completed" | "expired" | "failed" | "paused" | "pending" | "running" | "waiting";
+        createdAt: string;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    };
+}, false, false, "authenticated", 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.Execution.method.resume"> & {
+    readonly name: "resume";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+declare const remove: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "delete", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, false, false, "authenticated", 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.Execution.method.delete"> & {
+    readonly name: "delete";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export { remove as delete };

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

@@ -0,0 +1,11 @@
+import { K } from '../../index.js';
+import * as references from '../references/execution.js';
+import { methodSyscall } from './model.js';
+// Instance Methods: the handler receives the Execution receiver as `self`.
+export const status = methodSyscall(references.status, K.classes.Execution.methods.status);
+export const result = methodSyscall(references.result, K.classes.Execution.methods.result);
+export const cancel = methodSyscall(references.cancel, K.classes.Execution.methods.cancel);
+export const signal = methodSyscall(references.signal, K.classes.Execution.methods.signal);
+export const resume = methodSyscall(references.resume, K.classes.Execution.methods.resume);
+const remove = methodSyscall(references.delete, K.classes.Execution.methods.delete);
+export { remove as delete };

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

@@ -1,32 +1,28 @@
-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;
+declare const Admit: import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    call: {
+        target: string | {
+            callable: string;
+            instance?: string | undefined;
+            revision?: string | undefined;
+            fingerprint?: string | undefined;
         };
-        readonly credential?: string;
+        input: unknown;
     };
-    readonly output: {
-        readonly mode: 'value';
-        readonly value: {
-            readonly callable: string;
-            readonly receiver?: string;
-        };
-    };
-    readonly static: true;
-    readonly inheritance: 'sealed';
-    readonly declaredBy: unknown;
-}> & {
-    readonly owner: schema.ClassRef<'Function'> & {
-        readonly origin: 'kernel.astrale.ai';
+    credential?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        callable: string;
+        receiver?: string | undefined;
     };
-    readonly name: 'admit';
+}, true, false, "authenticated", 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.Function.method.admit"> & {
+    readonly name: "admit";
+    readonly executable: true;
+    readonly execution: undefined;
 };
-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,11 @@
 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 register: FunctionSyscall<'kernel.astrale.ai', 'register', typeof K.functions.register>;
+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>;
+export declare const upload: FunctionSyscall<'kernel.astrale.ai', 'upload', typeof K.functions.upload>;
+export declare const download: FunctionSyscall<'kernel.astrale.ai', 'download', typeof K.functions.download>;

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

@@ -1,11 +1,12 @@
 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 register = functionSyscall(references.register, K.functions.register);
+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);
+export const upload = functionSyscall(references.upload, K.functions.upload);
+export const download = functionSyscall(references.download, K.functions.download);

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

@@ -1,19 +1,137 @@
-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<{
+    principal: string;
+    audience: string;
+    ttlSeconds: number;
+    attenuation?: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, true, false, "authenticated", 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.delegate"> & {
+    readonly name: "delegate";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+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;
+} | {
+    checks: {
+        policy: string;
+        object: string;
+    }[];
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        allowed: boolean;
+    } | {
+        decisions: {
+            allowed: boolean;
+        }[];
+    };
+}, true, false, "authenticated", 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.can"> & {
+    readonly name: "can";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+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;
+        iss: string;
+        sub: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    };
+}, true, false, "authenticated", 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.whoami"> & {
+    readonly name: "whoami";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+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<{
+    iss: string;
+    sub: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        iss: string;
+        sub: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    } | null;
+}, true, false, "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";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const impersonate: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Identity';
+}>, "impersonate", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+    grant?: unknown;
+    identity: string;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, true, false, "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.impersonate"> & {
+    readonly name: "impersonate";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+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, false, "authenticated", 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";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;

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

@@ -1,9 +1,9 @@
 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.static.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 impersonate = methodSyscall(references.impersonate, K.classes.Identity.static.methods.impersonate);
+export const mint = methodSyscall(references.mint, K.classes.Identity.static.methods.mint);

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

@@ -1,6 +1,6 @@
-export type { FunctionSyscall, MethodRef, MethodSyscall, Syscall, SyscallRef } from './model.js';
-export { install, introspect, journal, mutate, provision, query, uninstall } from './functions.js';
+export type { FunctionSyscall, MethodSyscall, Syscall, SyscallRef } from './model.js';
+export { download, install, introspect, journal, mutate, register, query, uninstall, upload, } from './functions.js';
+export * as execution from './execution.js';
 export * as identity from './identity.js';
 export * as function from './function.js';
 export * as view from './view.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +1,5 @@
-export { install, introspect, journal, mutate, provision, query, uninstall } from './functions.js';
+export { download, install, introspect, journal, mutate, register, query, uninstall, upload, } from './functions.js';
+export * as execution from './execution.js';
 export * as identity from './identity.js';
 export * as function from './function.js';
 export * as view from './view.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,48 +1,25 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
-import type { FunctionRef, MethodRef, SyscallRef } from '../references/index.js';
+import type { ClassRef, FunctionDefinition, FunctionRef as DefinitionFunctionRef, MethodDefinition, MethodAddress, ResolvedClass } from '@astrale-os/kernel-dsl/v1';
+import type { CallableDefinition } from '@astrale-os/kernel-dsl/v1/language';
+import type { FunctionRef, SyscallRef } from '../references/index.js';
 interface FunctionCallable {
-    readonly origin: string;
-    readonly kind: 'function';
-    readonly name: string;
-    readonly definition: schema.FunctionDeclaration;
+    readonly ref: DefinitionFunctionRef;
+    readonly definition: FunctionDefinition;
 }
 interface NodeMethodCallableBase {
     readonly name: string;
-    readonly owner: {
-        readonly origin: string;
-        readonly name: string;
-    };
-    readonly definition: schema.MethodDeclaration;
-}
-interface InterfaceMethodCallable extends NodeMethodCallableBase {
-    readonly owner: NodeMethodCallableBase['owner'] & {
-        readonly kind: 'interface';
-    };
-}
-interface ClassMethodCallable extends NodeMethodCallableBase {
-    readonly owner: NodeMethodCallableBase['owner'] & {
-        readonly kind: 'class';
-    };
+    readonly owner: ResolvedClass<'node'>;
+    readonly definition: MethodDefinition;
 }
-export type { MethodRef, SyscallRef };
+type ClassMethodCallable = NodeMethodCallableBase;
+export type { SyscallRef };
 /** Pure reference to one callable owned by the kernel DomainSchema. */
-export interface Syscall<out Ref extends SyscallRef = SyscallRef, out Declaration extends schema.CallableContract = schema.CallableContract, out Callable = unknown> {
+export interface Syscall<out Ref extends SyscallRef = SyscallRef, out Declaration extends CallableDefinition = CallableDefinition, out Callable = unknown> {
     readonly ref: Ref;
     readonly declaration: Declaration;
     /** Exact rich callable from which handler input, output, and receiver types are inferred. */
     readonly callable: Callable;
 }
-export type FunctionSyscall<Origin extends string = string, Name extends string = string, Callable = unknown> = Syscall<FunctionRef<Origin, Name>, schema.FunctionDeclaration, Callable>;
-export type MethodSyscall<Owner extends schema.DefinitionRef = schema.DefinitionRef, Name extends string = string, Callable = unknown> = Syscall<MethodRef<Owner, Name>, schema.MethodDeclaration, Callable>;
+export type FunctionSyscall<Origin extends string = string, Name extends string = string, Callable = unknown> = Syscall<FunctionRef<Origin, Name>, FunctionDefinition, Callable>;
+export type MethodSyscall<Owner extends ClassRef = ClassRef, Name extends string = string, Callable = unknown> = Syscall<MethodAddress<Owner, Name>, MethodDefinition, Callable>;
 export declare function functionSyscall<const Ref extends FunctionRef, const Callable extends FunctionCallable>(ref: Ref, callable: Callable): FunctionSyscall<Ref['origin'], Ref['name'], Callable>;
-export declare function methodSyscall<const Callable extends InterfaceMethodCallable>(ref: MethodRef<schema.InterfaceRef<Callable['owner']['name']> & {
-    readonly origin: Callable['owner']['origin'];
-}, Callable['name']>, callable: Callable): MethodSyscall<schema.InterfaceRef<Callable['owner']['name']> & {
-    readonly origin: Callable['owner']['origin'];
-}, Callable['name'], Callable>;
-export declare function methodSyscall<const Callable extends ClassMethodCallable>(ref: MethodRef<schema.ClassRef<Callable['owner']['name']> & {
-    readonly origin: Callable['owner']['origin'];
-}, Callable['name']>, callable: Callable): MethodSyscall<schema.ClassRef<Callable['owner']['name']> & {
-    readonly origin: Callable['owner']['origin'];
-}, Callable['name'], Callable>;
-//# sourceMappingURL=model.d.ts.map
+export declare function methodSyscall<const Ref extends MethodAddress, const Callable extends ClassMethodCallable>(ref: Ref, callable: Callable): MethodSyscall<Ref['owner'], Ref['name'], Callable>;

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

@@ -6,10 +6,14 @@ export function functionSyscall(ref, callable) {
     });
 }
 export function methodSyscall(ref, callable) {
+    if (ref.owner.origin !== callable.owner.ref.origin ||
+        ref.owner.name !== callable.owner.ref.name ||
+        ref.name !== callable.name) {
+        throw new TypeError('Kernel Method syscall reference disagrees with its resolved callable.');
+    }
     return Object.freeze({
         ref,
         declaration: callable.definition,
         callable,
     });
 }
-//# sourceMappingURL=model.js.map

package/dist/schema/kernel/syscalls/descriptors/results/view-resolution.d.ts

@@ -1,19 +1,27 @@
+import type { Revision, ViewDefinition } from '@astrale-os/kernel-dsl/v1';
 import type { Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
-import type * as schema from '@astrale-os/kernel-dsl/v1/schema';
 import type { IssuerId } from '../../../../../auth/index.js';
+import { type ViewHostRequirements } from '../../contracts/view-host-requirements.js';
+export { acceptViewHostRequirements, type ViewHostRequirements, } from '../../contracts/view-host-requirements.js';
 export interface ResolvedView {
     readonly key: KeyType.View;
-    readonly declaration: schema.ViewDeclaration;
+    readonly declaration: ViewDeclaration;
     readonly href: string;
     readonly handshake: 'shell' | 'none';
+    readonly iframe?: IframeRequirements;
+    readonly host?: ViewHostRequirements;
     readonly issuer: IssuerId;
     readonly etag: `sha256:${string}`;
-    readonly revision: schema.Revision;
+    readonly revision: Revision;
 }
+export interface IframeRequirements {
+    readonly sandbox?: readonly string[];
+    readonly allow?: readonly string[];
+}
+type ViewDeclaration = Omit<ViewDefinition, 'ref'>;
 export interface ViewResolution {
     readonly snapshot: `sha256:${string}`;
     readonly views: readonly ResolvedView[];
 }
 /** Admit one detached, deeply immutable result of the Kernel View.resolve syscall. */
 export declare function acceptViewResolution(input: unknown): ViewResolution;
-//# sourceMappingURL=view-resolution.d.ts.map