@astrale-os/kernel-core 0.9.0-beta.54 → 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,
@@ -71,6 +73,8 @@ export const AuthorityRelations = Object.freeze({
 export const KernelRootFunctions = Object.freeze([
     K.functions.query,
     K.functions.mutate,
+    K.functions.upload,
+    K.functions.download,
     K.functions.register,
     K.functions.install,
     K.functions.uninstall,

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

@@ -0,0 +1,21 @@
+export declare const MAXIMUM_BLOB_BYTES = 104857600;
+export declare const blobSlot: import("zod").ZodObject<{
+    node: import("zod").ZodString;
+    property: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const uploadInput: import("zod").ZodObject<{
+    mediaType: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const uploadOutput: import("zod").ZodObject<{
+    receipt: import("zod").ZodString;
+    ref: import("zod").ZodObject<{
+        digest: import("zod").ZodString;
+        mediaType: import("zod").ZodString;
+        size: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
+    expiresAt: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const downloadInput: import("zod").ZodObject<{
+    node: import("zod").ZodString;
+    property: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;

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

@@ -0,0 +1,16 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { strictObject, string } from 'zod';
+import { artifactRef } from './installation.js';
+export const MAXIMUM_BLOB_BYTES = 104_857_600;
+export const blobSlot = strictObject({
+    node: string().check(fullMatch('[A-Za-z0-9._-]{1,255}')),
+    property: string().check(fullMatch(patterns.propertyKeyFullMatch)),
+});
+export const uploadInput = strictObject({ mediaType: string().min(1) });
+export const uploadOutput = strictObject({
+    receipt: string().min(1),
+    ref: artifactRef,
+    expiresAt: string().min(1),
+});
+export const downloadInput = blobSlot;

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

@@ -2,6 +2,6 @@ export declare const delegateInput: import("zod").ZodObject<{
     principal: import("zod").ZodString;
     audience: import("zod").ZodString;
     ttlSeconds: import("zod").ZodNumber;
-    attenuation: import("zod").ZodUnknown;
+    attenuation: import("zod").ZodOptional<import("zod").ZodUnknown>;
 }, import("zod/v4/core").$strict>;
 export declare const delegateOutput: import("zod").ZodString;

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

@@ -4,6 +4,7 @@ export const delegateInput = strictObject({
     principal: text,
     audience: text,
     ttlSeconds: number().int().min(1),
-    attenuation: unknownSchema(),
+    /** Optional; absence means the self expression. */
+    attenuation: unknownSchema().optional(),
 });
 export const delegateOutput = text;

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

@@ -1,6 +1,8 @@
 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

@@ -1,6 +1,8 @@
 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

@@ -3,8 +3,8 @@ export declare const Delegate: builder.Method<builder.CallableProjection<{
     principal: string;
     audience: string;
     ttlSeconds: number;
-    attenuation: unknown;
+    attenuation?: unknown;
 }, {
     readonly mode: 'value';
     readonly value: string;
-}, "authenticated", true, false>>;
+}, "authenticated", true, false, undefined>>;

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

@@ -0,0 +1,7 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Download: builder.Function<builder.CallableProjection<{
+    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,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>>;