@astrale-os/kernel-core 0.9.0-beta.55 → 0.9.0-beta.56

package/dist/schema/kernel/schema.js

@@ -1,11 +1,11 @@
 import { defineSchema, schema } from '@astrale-os/kernel-dsl/v1';
 import { AuthorityOperations, CanCreate, CanDelete, CanGrant, CanRead, CanRevoke, CanTraverse, CanUse, CanUpdate, GovernedBy, Operation, Policy, } from '../authority/index.js';
-import { Function as FunctionClass, MethodOf, View, ViewFor } from '../callables/index.js';
+import { Execution, Function as FunctionClass, MethodOf, View, ViewFor, } from '../callables/index.js';
 import { OperationCore } from '../core/index.js';
 import { Class, Extends, InstanceOf } from '../definitions/index.js';
 import { Domain as DomainClass, OfDomain } from '../domain/index.js';
 import { ConstrainedBy, ExcludedFrom, ExtendsWith, Identity } from '../identity/index.js';
-import { Descriptable, Edge, Iconable, Named, Node, Remotable, Statused, Timestamped, } from '../meta/index.js';
+import { CreatedBy, Descriptable, Edge, Iconable, Named, Node, Remotable, Statused, Timestamped, } from '../meta/index.js';
 import { Functions, CanUseSyscall } from './syscalls/declarations/index.js';
 const KernelDefinitions = {
     classes: {
@@ -20,6 +20,7 @@ const KernelDefinitions = {
         Timestamped,
         Class,
         Domain: DomainClass,
+        Execution,
         Function: FunctionClass,
         Operation,
         Policy,
@@ -33,6 +34,7 @@ const KernelDefinitions = {
         can_revoke: CanRevoke,
         can_use: CanUse,
         constrained_by: ConstrainedBy,
+        created_by: CreatedBy,
         excluded_from: ExcludedFrom,
         extends: Extends,
         extends_with: ExtendsWith,

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

@@ -0,0 +1,60 @@
+/** Terminal outcome of one durable call; a handler failure is an outcome, not a call error. */
+export declare const executionOutcome: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"completed">;
+    value: import("zod").ZodUnknown;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"failed">;
+    error: import("zod").ZodObject<{
+        code: import("zod").ZodString;
+        message: import("zod").ZodString;
+        family: import("zod").ZodOptional<import("zod").ZodString>;
+        details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"cancelled">;
+}, import("zod/v4/core").$strict>]>;
+export declare const executionStatus: import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    function: import("zod").ZodString;
+    version: import("zod").ZodString;
+    state: import("zod").ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        expired: "expired";
+        failed: "failed";
+        paused: "paused";
+        pending: "pending";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    createdAt: import("zod").ZodString;
+    outcome: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"completed">;
+        value: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"failed">;
+        error: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            message: import("zod").ZodString;
+            family: import("zod").ZodOptional<import("zod").ZodString>;
+            details: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"cancelled">;
+    }, import("zod/v4/core").$strict>]>>;
+}, import("zod/v4/core").$strict>;
+export declare const executionStatusInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionResultInput: import("zod").ZodObject<{
+    waitMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strict>;
+export declare const executionCancelInput: import("zod").ZodObject<{
+    force: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strict>;
+export declare const executionSignalInput: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    value: import("zod").ZodUnknown;
+}, import("zod/v4/core").$strict>;
+export declare const executionSignalOutput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionResumeInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionDeleteInput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+export declare const executionDeleteOutput: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;

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

@@ -0,0 +1,46 @@
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { boolean, enum as enumeration, literal, number, strictObject, string, union, unknown as unknownSchema, } from 'zod';
+const nodeId = string().min(1).max(255).check(fullMatch('[A-Za-z0-9._-]+'));
+const empty = strictObject({});
+/** Engine-observed state; never persisted on the Execution. */
+const state = enumeration([
+    'pending',
+    'running',
+    'waiting',
+    'paused',
+    'completed',
+    'failed',
+    'cancelled',
+    'expired',
+]);
+const failure = strictObject({
+    code: string(),
+    message: string(),
+    family: string().optional(),
+    details: unknownSchema().optional(),
+});
+/** Terminal outcome of one durable call; a handler failure is an outcome, not a call error. */
+export const executionOutcome = union([
+    strictObject({ kind: literal('completed'), value: unknownSchema() }),
+    strictObject({ kind: literal('failed'), error: failure }),
+    strictObject({ kind: literal('cancelled') }),
+]);
+export const executionStatus = strictObject({
+    id: nodeId,
+    function: nodeId,
+    version: string().check(fullMatch('sha256:[0-9a-f]{64}')),
+    state,
+    createdAt: string().min(1),
+    outcome: executionOutcome.optional(),
+});
+export const executionStatusInput = empty;
+export const executionResultInput = strictObject({ waitMs: number().int().min(0).optional() });
+export const executionCancelInput = strictObject({ force: boolean().optional() });
+export const executionSignalInput = strictObject({
+    name: string().min(1).max(128),
+    value: unknownSchema(),
+});
+export const executionSignalOutput = empty;
+export const executionResumeInput = empty;
+export const executionDeleteInput = empty;
+export const executionDeleteOutput = empty;

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

@@ -2,6 +2,7 @@ export { admitInput, admitOutput } from './admit.js';
 export { blobSlot, downloadInput, MAXIMUM_BLOB_BYTES, uploadInput, uploadOutput } from './blob.js';
 export { MAXIMUM_CHECKS, canInput, canOutput } from './can.js';
 export { delegateInput, delegateOutput } from './delegate.js';
+export { executionCancelInput, executionDeleteInput, executionDeleteOutput, executionOutcome, executionResultInput, executionResumeInput, executionSignalInput, executionSignalOutput, executionStatus, executionStatusInput, } from './execution.js';
 export { installInput, installReceipt, type DomainRequest, type InstallInput, type InstallReceipt, } from './install.js';
 export { introspectInput } from './introspect.js';
 export { journalInput, journalOutput } from './journal.js';

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

@@ -2,6 +2,7 @@ export { admitInput, admitOutput } from './admit.js';
 export { blobSlot, downloadInput, MAXIMUM_BLOB_BYTES, uploadInput, uploadOutput } from './blob.js';
 export { MAXIMUM_CHECKS, canInput, canOutput } from './can.js';
 export { delegateInput, delegateOutput } from './delegate.js';
+export { executionCancelInput, executionDeleteInput, executionDeleteOutput, executionOutcome, executionResultInput, executionResumeInput, executionSignalInput, executionSignalOutput, executionStatus, executionStatusInput, } from './execution.js';
 export { installInput, installReceipt, } from './install.js';
 export { introspectInput } from './introspect.js';
 export { journalInput, journalOutput } from './journal.js';

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

@@ -16,4 +16,4 @@ export declare const Admit: builder.Method<builder.CallableProjection<{
         callable: string;
         receiver?: string | undefined;
     };
-}, "authenticated", true, false>>;
+}, "authenticated", true, false, undefined>>;

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

@@ -16,4 +16,4 @@ export declare const Can: builder.Method<builder.CallableProjection<{
             allowed: boolean;
         }[];
     };
-}, "authenticated", true, false>>;
+}, "authenticated", true, false, undefined>>;

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

@@ -7,4 +7,4 @@ export declare const Delegate: builder.Method<builder.CallableProjection<{
 }, {
     readonly mode: 'value';
     readonly value: string;
-}, "authenticated", true, false>>;
+}, "authenticated", true, false, undefined>>;

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

@@ -4,4 +4,4 @@ export declare const Download: builder.Function<builder.CallableProjection<{
     property: string;
 }, {
     readonly mode: 'binary';
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

@@ -0,0 +1,105 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const ExecutionStatus: 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>>;
+export declare const ExecutionResult: 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>>;
+export declare const ExecutionCancel: 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>>;
+export declare const ExecutionSignal: builder.Method<builder.CallableProjection<{
+    name: string;
+    value: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, "authenticated", false, false, undefined>>;
+export declare const ExecutionResume: 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>>;
+export declare const ExecutionDelete: builder.Method<builder.CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, "authenticated", false, false, undefined>>;

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

@@ -0,0 +1,52 @@
+import { method } from '@astrale-os/kernel-dsl/v1';
+import { executionCancelInput, executionDeleteInput, executionDeleteOutput, executionOutcome, executionResultInput, executionResumeInput, executionSignalInput, executionSignalOutput, executionStatus, executionStatusInput, } from '../contracts/index.js';
+// Runtime admits every Execution method against its receiver's immutable facts: observe for
+// status, result and cooperative cancel; administer for forced cancel, signal, resume and delete.
+export const ExecutionStatus = method({
+    description: 'Read the engine state and, once terminal, the outcome of this Execution.',
+    auth: 'authenticated',
+    input: executionStatusInput,
+    output: executionStatus,
+    static: false,
+    abstract: false,
+});
+export const ExecutionResult = method({
+    description: 'Wait at most waitMs, bounded by the request deadline, for the terminal outcome.',
+    auth: 'authenticated',
+    input: executionResultInput,
+    output: executionOutcome,
+    static: false,
+    abstract: false,
+});
+export const ExecutionCancel = method({
+    description: 'Cancel this Execution cooperatively, or kill it without compensation when forced.',
+    auth: 'authenticated',
+    input: executionCancelInput,
+    output: executionStatus,
+    static: false,
+    abstract: false,
+});
+export const ExecutionSignal = method({
+    description: 'Resolve the named durable promise of this Execution once.',
+    auth: 'authenticated',
+    input: executionSignalInput,
+    output: executionSignalOutput,
+    static: false,
+    abstract: false,
+});
+export const ExecutionResume = method({
+    description: 'Resume this paused Execution; a running Execution is unchanged.',
+    auth: 'authenticated',
+    input: executionResumeInput,
+    output: executionStatus,
+    static: false,
+    abstract: false,
+});
+export const ExecutionDelete = method({
+    description: 'Delete the record of this Execution, then kill and purge its run.',
+    auth: 'authenticated',
+    input: executionDeleteInput,
+    output: executionDeleteOutput,
+    static: false,
+    abstract: false,
+});

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

@@ -7,4 +7,4 @@ export declare const Impersonate: builder.Method<builder.CallableProjection<{
 }, {
     readonly mode: 'value';
     readonly value: string;
-}, "authorized", true, false>>;
+}, "authorized", true, false, undefined>>;

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

@@ -222,7 +222,7 @@ export declare const Functions: Readonly<{
                 next?: string | undefined;
             };
         };
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
     upload: builder.Function<builder.CallableProjection<import("@astrale-os/kernel-dsl/v1").BinaryInputProjection<{
         mediaType: string;
     }>, {
@@ -236,13 +236,13 @@ export declare const Functions: Readonly<{
             };
             expiresAt: string;
         };
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
     download: builder.Function<builder.CallableProjection<{
         node: string;
         property: string;
     }, {
         readonly mode: 'binary';
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
     mutate: builder.Function<builder.CallableProjection<{
         ast: {
             format: "astrale.graph.mutation";
@@ -399,6 +399,29 @@ export declare const Functions: Readonly<{
                 };
             })[];
             operations: ({
+                op: "edge.update";
+                edge: {
+                    source: string;
+                    target: string;
+                    class: string;
+                };
+                slug: unknown;
+                props?: {
+                    set: Record<string, unknown>;
+                    unset: string[];
+                } | undefined;
+            } | {
+                op: "edge.update";
+                edge: {
+                    source: string;
+                    target: string;
+                    class: string;
+                };
+                props: {
+                    set: Record<string, unknown>;
+                    unset: string[];
+                };
+            } | {
                 op: "node.create";
                 as: string;
                 class: string;
@@ -426,29 +449,6 @@ export declare const Functions: Readonly<{
                 };
                 slug?: unknown;
                 props: Record<string, unknown>;
-            } | {
-                op: "edge.update";
-                edge: {
-                    source: string;
-                    target: string;
-                    class: string;
-                };
-                slug: unknown;
-                props?: {
-                    set: Record<string, unknown>;
-                    unset: string[];
-                } | undefined;
-            } | {
-                op: "edge.update";
-                edge: {
-                    source: string;
-                    target: string;
-                    class: string;
-                };
-                props: {
-                    set: Record<string, unknown>;
-                    unset: string[];
-                };
             } | {
                 op: "edge.delete";
                 edge: {
@@ -467,7 +467,7 @@ export declare const Functions: Readonly<{
         readonly value: {
             createdNodes: Record<string, string>;
         };
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
     register: builder.Function<builder.CallableProjection<{
         idempotencyKey: string;
         identities: ({
@@ -489,7 +489,7 @@ export declare const Functions: Readonly<{
                 sub: string;
             }[];
         };
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
     install: builder.Function<builder.CallableProjection<{
         operation: string;
         domains: ({
@@ -510,13 +510,13 @@ export declare const Functions: Readonly<{
         })[];
     }, {
         readonly mode: 'binary';
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
     introspect: builder.Function<builder.CallableProjection<{
         kind: "bundle" | "dependencies" | "inspect";
         origin: string;
     }, {
         readonly mode: 'binary';
-    }, "authenticated", false, false>>;
+    }, "authenticated", false, false, undefined>>;
     uninstall: builder.Function<builder.CallableProjection<{
         operation: string;
         domains: string[];
@@ -557,7 +557,7 @@ export declare const Functions: Readonly<{
                 } | undefined;
             }[];
         };
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
     journal: builder.Function<builder.CallableProjection<{
         invocation?: {
             source: string;
@@ -585,7 +585,7 @@ export declare const Functions: Readonly<{
             cursor?: string | undefined;
             gap?: unknown;
         };
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
 }>;
 export declare const IdentityMethods: Readonly<{
     delegate: builder.Method<builder.CallableProjection<{
@@ -596,7 +596,7 @@ export declare const IdentityMethods: Readonly<{
     }, {
         readonly mode: 'value';
         readonly value: string;
-    }, "authenticated", true, false>>;
+    }, "authenticated", true, false, undefined>>;
     can: builder.Method<builder.CallableProjection<{
         policy: string;
         object: string;
@@ -614,7 +614,7 @@ export declare const IdentityMethods: Readonly<{
                 allowed: boolean;
             }[];
         };
-    }, "authenticated", true, false>>;
+    }, "authenticated", true, false, undefined>>;
     whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
         readonly mode: 'value';
         readonly value: {
@@ -635,7 +635,7 @@ export declare const IdentityMethods: Readonly<{
                 op: "exists";
             })[];
         };
-    }, "authenticated", true, false>>;
+    }, "authenticated", true, false, undefined>>;
     whois: builder.Method<builder.CallableProjection<{
         iss: string;
         sub: string;
@@ -659,7 +659,7 @@ export declare const IdentityMethods: Readonly<{
                 op: "exists";
             })[];
         } | null;
-    }, "authorized", true, false>>;
+    }, "authorized", true, false, undefined>>;
     mint: builder.Method<builder.CallableProjection<{
         audience?: string | undefined;
         ttlSeconds: number;
@@ -667,7 +667,7 @@ export declare const IdentityMethods: Readonly<{
     }, {
         readonly mode: 'value';
         readonly value: string;
-    }, "authenticated", true, false>>;
+    }, "authenticated", true, false, undefined>>;
     impersonate: builder.Method<builder.CallableProjection<{
         audience?: string | undefined;
         ttlSeconds: number;
@@ -676,7 +676,7 @@ export declare const IdentityMethods: Readonly<{
     }, {
         readonly mode: 'value';
         readonly value: string;
-    }, "authorized", true, false>>;
+    }, "authorized", true, false, undefined>>;
 }>;
 export declare const FunctionMethods: Readonly<{
     admit: builder.Method<builder.CallableProjection<{
@@ -696,7 +696,7 @@ export declare const FunctionMethods: Readonly<{
             callable: string;
             receiver?: string | undefined;
         };
-    }, "authenticated", true, false>>;
+    }, "authenticated", true, false, undefined>>;
 }>;
 export declare const ViewMethods: Readonly<{
     resolve: builder.Method<builder.CallableProjection<{
@@ -738,6 +738,112 @@ export declare const ViewMethods: Readonly<{
                 revision: string;
             }[];
         };
-    }, "authorized", true, false>>;
+    }, "authorized", true, false, undefined>>;
+}>;
+export declare const ExecutionMethods: 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>>;
 }>;
 export { CanUseSyscall } from './use-policy.js';