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

package/dist/schema/authority/operation-node.d.ts

@@ -1,16 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Operation: builder.NodeClass<{
-    readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-    readonly implements: readonly [builder.Interface<{
-        readonly family: "both";
-        readonly description: "Stable human-facing name metadata that never acts as a locator.";
+    readonly depth: 2;
+    readonly abstract: false;
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
         readonly properties: {
-            readonly name: {
-                readonly type: "string";
-                readonly minLength: 1;
-                readonly maxLength: 100;
-            };
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
         };
-    }>];
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", unknown, undefined>, never, never>, undefined>, never, never>];
+    readonly properties: never;
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly name: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", unknown, undefined>, never, never>, undefined>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=operation-node.d.ts.map

package/dist/schema/authority/operation-node.js

@@ -1,7 +1,7 @@
 import { nodeClass } from '@astrale-os/kernel-dsl/v1';
 import { Named } from '../meta/index.js';
 export const Operation = nodeClass({
+    abstract: false,
     description: 'One closed authority relation operation administered by can_grant and can_revoke.',
-    implements: [Named],
+    extends: [Named],
 });
-//# sourceMappingURL=operation-node.js.map

package/dist/schema/authority/operation.d.ts

@@ -1,3 +1,2 @@
 export declare const AuthorityOperationOrder: readonly ["create", "read", "update", "delete", "traverse", "use", "grant", "revoke"];
 export type AuthorityOperation = (typeof AuthorityOperationOrder)[number];
-//# sourceMappingURL=operation.d.ts.map

package/dist/schema/authority/operation.js

@@ -8,4 +8,3 @@ export const AuthorityOperationOrder = Object.freeze([
     'grant',
     'revoke',
 ]);
-//# sourceMappingURL=operation.js.map

package/dist/schema/authority/operations.d.ts

@@ -10,119 +10,14 @@ import { CanUse } from './can-use.js';
 import { AuthorityOperationOrder, type AuthorityOperation } from './operation.js';
 export { AuthorityOperationOrder, type AuthorityOperation };
 export declare const AuthorityOperations: Readonly<{
-    create: builder.Node<builder.NodeClass<{
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>>;
-    read: builder.Node<builder.NodeClass<{
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>>;
-    update: builder.Node<builder.NodeClass<{
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>>;
-    delete: builder.Node<builder.NodeClass<{
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>>;
-    traverse: builder.Node<builder.NodeClass<{
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>>;
-    use: builder.Node<builder.NodeClass<{
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>>;
-    grant: builder.Node<builder.NodeClass<{
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>>;
-    revoke: builder.Node<builder.NodeClass<{
-        readonly description: "One closed authority relation operation administered by can_grant and can_revoke.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Stable human-facing name metadata that never acts as a locator.";
-            readonly properties: {
-                readonly name: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                    readonly maxLength: 100;
-                };
-            };
-        }>];
-    }>>;
+    create: builder.CoreNode;
+    read: builder.CoreNode;
+    update: builder.CoreNode;
+    delete: builder.CoreNode;
+    traverse: builder.CoreNode;
+    use: builder.CoreNode;
+    grant: builder.CoreNode;
+    revoke: builder.CoreNode;
 }>;
 export type AuthorityRelation = typeof CanCreate | typeof CanRead | typeof CanUpdate | typeof CanDelete | typeof CanTraverse | typeof CanUse | typeof CanGrant | typeof CanRevoke;
 export declare function operationOf(relation: AuthorityRelation): AuthorityOperation;
-//# sourceMappingURL=operations.d.ts.map

package/dist/schema/authority/operations.js

@@ -1,4 +1,4 @@
-import { node } from '@astrale-os/kernel-dsl/v1';
+import { core } from '@astrale-os/kernel-dsl/v1';
 import { CanCreate } from './can-create.js';
 import { CanDelete } from './can-delete.js';
 import { CanGrant } from './can-grant.js';
@@ -10,14 +10,14 @@ import { Operation } from './operation-node.js';
 import { AuthorityOperationOrder } from './operation.js';
 export { AuthorityOperationOrder };
 export const AuthorityOperations = Object.freeze({
-    create: node(Operation, { name: 'create' }),
-    read: node(Operation, { name: 'read' }),
-    update: node(Operation, { name: 'update' }),
-    delete: node(Operation, { name: 'delete' }),
-    traverse: node(Operation, { name: 'traverse' }),
-    use: node(Operation, { name: 'use' }),
-    grant: node(Operation, { name: 'grant' }),
-    revoke: node(Operation, { name: 'revoke' }),
+    create: core.node(Operation, { name: 'create' }),
+    read: core.node(Operation, { name: 'read' }),
+    update: core.node(Operation, { name: 'update' }),
+    delete: core.node(Operation, { name: 'delete' }),
+    traverse: core.node(Operation, { name: 'traverse' }),
+    use: core.node(Operation, { name: 'use' }),
+    grant: core.node(Operation, { name: 'grant' }),
+    revoke: core.node(Operation, { name: 'revoke' }),
 });
 export function operationOf(relation) {
     if (relation === CanCreate)
@@ -36,4 +36,3 @@ export function operationOf(relation) {
         return 'grant';
     return 'revoke';
 }
-//# sourceMappingURL=operations.js.map

package/dist/schema/authority/policy.d.ts

@@ -1,18 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Policy: builder.NodeClass<{
-    readonly description: "The installed graph projection of one named closed Policy declaration owned by a Domain.";
-    readonly implements: readonly [builder.Interface<{
-        readonly family: "both";
-        readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
+    readonly depth: 2;
+    readonly abstract: false;
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
         readonly properties: {
-            description: builder.Property<Readonly<{
-                readonly type: 'string';
-                readonly minLength: 1;
-                readonly maxLength: 1000;
-            }>, {
-                readonly required: false;
-            }>;
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
         };
-    }>];
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>, never, never>];
+    readonly properties: never;
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=policy.d.ts.map

package/dist/schema/authority/policy.js

@@ -1,7 +1,7 @@
 import { nodeClass } from '@astrale-os/kernel-dsl/v1';
 import { Descriptable } from '../meta/index.js';
 export const Policy = nodeClass({
+    abstract: false,
     description: 'The installed graph projection of one named closed Policy declaration owned by a Domain.',
-    implements: [Descriptable],
+    extends: [Descriptable],
 });
-//# sourceMappingURL=policy.js.map

package/dist/schema/callables/execution.d.ts

@@ -0,0 +1,269 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Execution: builder.NodeClass<{
+    readonly depth: 1;
+    readonly abstract: false;
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>, builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly createdAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", "self", undefined>;
+            readonly updatedAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly createdAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", "self", undefined>;
+            readonly updatedAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", unknown, undefined> | builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", unknown, undefined>, never, never>, undefined> | builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly createdAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", "self", undefined>;
+            readonly updatedAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", unknown, undefined> | builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", unknown, undefined>, never, never>, undefined>, never, never>];
+    readonly properties: {
+        readonly function: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "function", "self", undefined>;
+        readonly version: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "version", "self", undefined>;
+        readonly domain: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "domain", "self", undefined>;
+        readonly principal: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "principal", "self", undefined>;
+        readonly receiver: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "receiver", "self", never>;
+        readonly key: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "key", "self", undefined>;
+        readonly input: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined>;
+    };
+    readonly methods: Readonly<{
+        status: builder.Method<builder.CallableProjection<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;
+            };
+        }, "authenticated", false, false, undefined>>;
+        result: builder.Method<builder.CallableProjection<{
+            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";
+            };
+        }, "authenticated", false, false, undefined>>;
+        cancel: builder.Method<builder.CallableProjection<{
+            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;
+            };
+        }, "authenticated", false, false, undefined>>;
+        signal: builder.Method<builder.CallableProjection<{
+            name: string;
+            value: unknown;
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authenticated", false, false, undefined>>;
+        resume: builder.Method<builder.CallableProjection<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;
+            };
+        }, "authenticated", false, false, undefined>>;
+        delete: builder.Method<builder.CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: Record<string, never>;
+        }, "authenticated", false, false, undefined>>;
+    }>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly createdAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", "self", undefined>;
+            readonly updatedAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", unknown, undefined> | builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", unknown, undefined>, never, never>, undefined> | builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly createdAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", "self", undefined>;
+            readonly updatedAt: builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", "self", undefined>;
+        };
+        readonly methods: Readonly<Record<never, never>>;
+    }, builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "createdAt", unknown, undefined> | builder.AuthoredPropertyProjection<never, import("@astrale-os/kernel-dsl/value").Value, true, "updatedAt", unknown, undefined>, never, never>, undefined> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "domain", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "function", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "key", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "principal", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "receiver", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "version", "self", undefined>);
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: Record<string, never>;
+    }, "authenticated", false, false, undefined>>, "delete", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<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;
+        };
+    }, "authenticated", false, false, undefined>>, "resume", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<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;
+        };
+    }, "authenticated", false, false, undefined>>, "status", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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";
+        };
+    }, "authenticated", false, false, undefined>>, "result", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+        };
+    }, "authenticated", false, false, undefined>>, "cancel", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        name: string;
+        value: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: Record<string, never>;
+    }, "authenticated", false, false, undefined>>, "signal", "self">;
+    readonly effectiveStaticMethods: never;
+}>;

package/dist/schema/callables/execution.js

@@ -0,0 +1,30 @@
+import { nodeClass, property } from '@astrale-os/kernel-dsl/v1';
+import { ExecutionMethods } from '../kernel/syscalls/declarations/index.js';
+import { Node, Timestamped } from '../meta/index.js';
+const nodeId = {
+    type: 'string',
+    minLength: 1,
+    maxLength: 255,
+    fullMatch: '[A-Za-z0-9._-]+',
+};
+// Immutable facts written once by the durable call path through trusted qualification. Generic
+// mutation cannot create an Execution, change its Properties or rewrite its created_by Edge; its
+// authority Domain deletes it by ordinary mutation. `function` is a scalar, not an Edge, so deleting
+// the Function never has to detach its Executions. State and outcome are read through the engine.
+// No Class Policy: Runtime admits every Execution method against these facts, and a relational
+// read Policy here would join every polymorphic Query reaching Node or Timestamped.
+export const Execution = nodeClass({
+    abstract: false,
+    description: 'One accepted durable call of a Function, recorded as immutable facts.',
+    extends: [Node, Timestamped],
+    properties: {
+        function: nodeId,
+        version: { type: 'string', fullMatch: 'sha256:[0-9a-f]{64}' },
+        domain: nodeId,
+        principal: nodeId,
+        receiver: property(nodeId, { required: false }),
+        key: { type: 'string', minLength: 1, maxLength: 128 },
+        input: {},
+    },
+    methods: ExecutionMethods,
+});