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

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

@@ -1,12 +1,9 @@
-import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Delegate: builder.Method<{
-    readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-    readonly auth: "authenticated";
-    readonly input: import("zod").ZodObject<{
-        audience: import("zod").ZodString;
-        ttlSeconds: import("zod").ZodNumber;
-        attenuation: import("zod").ZodUnknown;
-    }, import("zod/v4/core").$strict>;
-    readonly output: import("zod").ZodString;
-    readonly inheritance: "default";
-}>;
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Delegate: builder.Method<builder.CallableProjection<{
+    principal: string;
+    audience: string;
+    ttlSeconds: number;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, "authenticated", true, false, undefined>>;

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

@@ -1,9 +1,9 @@
+import { method } from '@astrale-os/kernel-dsl/v1';
 import { delegateInput, delegateOutput } from '../contracts/index.js';
-import { defineMethod } from './define.js';
-export const Delegate = defineMethod({
-    description: 'Issue one strictly attenuated credential from this authenticated Identity.',
+export const Delegate = method({
+    description: 'Issue one strictly attenuated credential from the authenticated execution principal.',
     auth: 'authenticated',
     input: delegateInput,
     output: delegateOutput,
-    inheritance: 'default',
+    static: true,
 });

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

@@ -0,0 +1,12 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Download: builder.Function<builder.CallableProjection<{
+    node: string;
+    property: string;
+} | {
+    slots: {
+        node: string;
+        property: string;
+    }[];
+}, {
+    readonly mode: 'binary';
+}, "authorized", false, false, undefined>>;

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

@@ -0,0 +1,10 @@
+import { func, output } from '@astrale-os/kernel-dsl/v1';
+import { downloadInput } from '../contracts/index.js';
+import { usePolicy } from './use-policy.js';
+export const Download = func({
+    description: 'Stream an application blob from an authorized Node property.',
+    auth: 'authorized',
+    policy: usePolicy(() => Download),
+    input: downloadInput,
+    output: output.binary(),
+});

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

@@ -0,0 +1,255 @@
+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;
+        detail?: {
+            phase: "activating" | "attempting" | "awaiting" | "cancelled" | "classifying" | "completed" | "draining" | "rejected" | "validating";
+            class?: "immediate" | "noop" | "revalidate" | undefined;
+            mode?: "maintenance" | "online" | undefined;
+            validation?: {
+                scope: "full" | "incremental";
+                counts: "exact" | "sample";
+            } | undefined;
+            progress?: {
+                pages: number;
+                interruptions: number;
+            } | undefined;
+            instance?: "attempt" | "draining" | "open" | "repair" | undefined;
+            command?: number | undefined;
+            expires?: number | undefined;
+            attempt?: {
+                number: number;
+                destination: "previous" | "target";
+            } | undefined;
+            report?: {
+                attempt: number;
+                destination: "previous" | "target";
+                result: "aborted" | "interrupted" | "migration-required";
+                reason?: string | undefined;
+                summary?: unknown;
+            } | undefined;
+            uncertified?: {
+                since: number;
+                session?: string | undefined;
+                operator?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        } | undefined;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    } | {
+        id: string;
+        state: "deleted";
+        outcome: {
+            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 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;
+        detail?: {
+            phase: "activating" | "attempting" | "awaiting" | "cancelled" | "classifying" | "completed" | "draining" | "rejected" | "validating";
+            class?: "immediate" | "noop" | "revalidate" | undefined;
+            mode?: "maintenance" | "online" | undefined;
+            validation?: {
+                scope: "full" | "incremental";
+                counts: "exact" | "sample";
+            } | undefined;
+            progress?: {
+                pages: number;
+                interruptions: number;
+            } | undefined;
+            instance?: "attempt" | "draining" | "open" | "repair" | undefined;
+            command?: number | undefined;
+            expires?: number | undefined;
+            attempt?: {
+                number: number;
+                destination: "previous" | "target";
+            } | undefined;
+            report?: {
+                attempt: number;
+                destination: "previous" | "target";
+                result: "aborted" | "interrupted" | "migration-required";
+                reason?: string | undefined;
+                summary?: unknown;
+            } | undefined;
+            uncertified?: {
+                since: number;
+                session?: string | undefined;
+                operator?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        } | undefined;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    } | {
+        id: string;
+        state: "deleted";
+        outcome: {
+            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 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;
+        detail?: {
+            phase: "activating" | "attempting" | "awaiting" | "cancelled" | "classifying" | "completed" | "draining" | "rejected" | "validating";
+            class?: "immediate" | "noop" | "revalidate" | undefined;
+            mode?: "maintenance" | "online" | undefined;
+            validation?: {
+                scope: "full" | "incremental";
+                counts: "exact" | "sample";
+            } | undefined;
+            progress?: {
+                pages: number;
+                interruptions: number;
+            } | undefined;
+            instance?: "attempt" | "draining" | "open" | "repair" | undefined;
+            command?: number | undefined;
+            expires?: number | undefined;
+            attempt?: {
+                number: number;
+                destination: "previous" | "target";
+            } | undefined;
+            report?: {
+                attempt: number;
+                destination: "previous" | "target";
+                result: "aborted" | "interrupted" | "migration-required";
+                reason?: string | undefined;
+                summary?: unknown;
+            } | undefined;
+            uncertified?: {
+                since: number;
+                session?: string | undefined;
+                operator?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        } | undefined;
+        outcome?: {
+            kind: "completed";
+            value: unknown;
+        } | {
+            kind: "failed";
+            error: {
+                code: string;
+                message: string;
+                family?: string | undefined;
+                details?: unknown;
+            };
+        } | {
+            kind: "cancelled";
+        } | undefined;
+    } | {
+        id: string;
+        state: "deleted";
+        outcome: {
+            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 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

@@ -0,0 +1,9 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Impersonate: builder.Method<builder.CallableProjection<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+    identity: string;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, "authorized", true, false, undefined>>;

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

@@ -0,0 +1,12 @@
+import { method } from '@astrale-os/kernel-dsl/v1';
+import { impersonateInput, impersonateOutput } from '../contracts/index.js';
+import { usePolicy } from './use-policy.js';
+export const Impersonate = method({
+    description: 'Issue a Kernel credential bounded by the active target Identity authority.',
+    auth: 'authorized',
+    policy: usePolicy(() => Impersonate),
+    input: impersonateInput,
+    output: impersonateOutput,
+    static: true,
+    abstract: false,
+});