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

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

@@ -1,21 +1,27 @@
 import { Admit } from './admit.js';
 import { Can } from './can.js';
 import { Delegate } from './delegate.js';
+import { Download } from './download.js';
+import { ExecutionCancel, ExecutionDelete, ExecutionResult, ExecutionResume, ExecutionSignal, ExecutionStatus, } from './execution.js';
+import { Impersonate } from './impersonate.js';
 import { Install } from './install.js';
 import { Introspect } from './introspect.js';
 import { Journal } from './journal.js';
 import { Mint } from './mint.js';
 import { Mutate } from './mutate.js';
-import { Provision } from './provision.js';
 import { Query } from './query.js';
+import { Register } from './register.js';
 import { Uninstall } from './uninstall.js';
+import { Upload } from './upload.js';
 import { ViewResolve } from './view-resolve.js';
 import { Whoami } from './whoami.js';
 import { Whois } from './whois.js';
 export const Functions = Object.freeze({
     query: Query,
+    upload: Upload,
+    download: Download,
     mutate: Mutate,
-    provision: Provision,
+    register: Register,
     install: Install,
     introspect: Introspect,
     uninstall: Uninstall,
@@ -27,6 +33,7 @@ export const IdentityMethods = Object.freeze({
     whoami: Whoami,
     whois: Whois,
     mint: Mint,
+    impersonate: Impersonate,
 });
 export const FunctionMethods = Object.freeze({
     admit: Admit,
@@ -34,3 +41,12 @@ export const FunctionMethods = Object.freeze({
 export const ViewMethods = Object.freeze({
     resolve: ViewResolve,
 });
+export const ExecutionMethods = Object.freeze({
+    status: ExecutionStatus,
+    result: ExecutionResult,
+    cancel: ExecutionCancel,
+    signal: ExecutionSignal,
+    resume: ExecutionResume,
+    delete: ExecutionDelete,
+});
+export { CanUseSyscall } from './use-policy.js';

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

@@ -1,172 +1,85 @@
-import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Install: builder.Function<{
-    readonly description: "Durably install one or more exact Schema targets and return a terminal receipt.";
-    readonly auth: "authorized";
-    readonly input: import("zod").ZodObject<{
-        operation: import("zod").ZodString;
-        domains: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-            source: import("zod").ZodObject<{
-                kind: import("zod").ZodLiteral<"local">;
-                artifact: import("zod").ZodObject<{
-                    digest: import("zod").ZodString;
-                    mediaType: import("zod").ZodString;
-                    size: import("zod").ZodNumber;
-                }, import("zod/v4/core").$strict>;
-            }, import("zod/v4/core").$strict>;
-            currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-            source: import("zod").ZodObject<{
-                kind: import("zod").ZodLiteral<"remote">;
-                url: import("zod").ZodString;
-                token: import("zod").ZodOptional<import("zod").ZodString>;
-            }, import("zod/v4/core").$strict>;
-            targetRevision: import("zod").ZodOptional<import("zod").ZodString>;
-            targetEtag: import("zod").ZodOptional<import("zod").ZodString>;
-            currentRevision: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-        }, import("zod/v4/core").$strict>]>>;
-    }, import("zod/v4/core").$strict>;
-    readonly output: import("zod").ZodObject<{
-        operation: import("zod").ZodString;
-        transitions: import("zod").ZodArray<import("zod").ZodObject<{
-            intent: import("zod").ZodObject<{
-                transition: import("zod").ZodString;
-                operation: import("zod").ZodString;
-                installation: import("zod").ZodString;
-                origin: import("zod").ZodString;
-                source: import("zod").ZodNullable<import("zod").ZodObject<{
-                    origin: import("zod").ZodString;
-                    schemaRevision: import("zod").ZodString;
-                    schemaBundle: import("zod").ZodString;
-                    service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        kind: import("zod").ZodLiteral<"local">;
-                        artifact: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        kind: import("zod").ZodLiteral<"remote">;
-                        etag: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>], "kind">;
-                    capabilities: import("zod").ZodObject<{
-                        functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                        classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                            class: import("zod").ZodObject<{
-                                origin: import("zod").ZodString;
-                                kind: import("zod").ZodLiteral<"class">;
-                                name: import("zod").ZodString;
-                            }, import("zod/v4/core").$strict>;
-                            operations: import("zod").ZodArray<import("zod").ZodEnum<{
-                                create: "create";
-                                delete: "delete";
-                                read: "read";
-                                traverse: "traverse";
-                                update: "update";
-                            }>>;
-                        }, import("zod/v4/core").$strict>>>;
-                        admin: import("zod").ZodOptional<import("zod").ZodObject<{
-                            grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
-                                create: "create";
-                                delete: "delete";
-                                grant: "grant";
-                                read: "read";
-                                revoke: "revoke";
-                                traverse: "traverse";
-                                update: "update";
-                                use: "use";
-                            }>>>;
-                            revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
-                                create: "create";
-                                delete: "delete";
-                                grant: "grant";
-                                read: "read";
-                                revoke: "revoke";
-                                traverse: "traverse";
-                                update: "update";
-                                use: "use";
-                            }>>>;
-                        }, import("zod/v4/core").$strict>>;
-                    }, import("zod/v4/core").$strict>;
-                    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
-                        origin: import("zod").ZodString;
-                        installation: import("zod").ZodString;
-                        target: import("zod").ZodString;
-                        readinessReceipt: import("zod").ZodString;
-                        meaningComparison: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>>;
-                }, import("zod/v4/core").$strict>>;
-                target: import("zod").ZodNullable<import("zod").ZodObject<{
-                    origin: import("zod").ZodString;
-                    schemaRevision: import("zod").ZodString;
-                    schemaBundle: import("zod").ZodString;
-                    service: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        kind: import("zod").ZodLiteral<"local">;
-                        artifact: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        kind: import("zod").ZodLiteral<"remote">;
-                        etag: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>], "kind">;
-                    capabilities: import("zod").ZodObject<{
-                        functions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                        classes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                            class: import("zod").ZodObject<{
-                                origin: import("zod").ZodString;
-                                kind: import("zod").ZodLiteral<"class">;
-                                name: import("zod").ZodString;
-                            }, import("zod/v4/core").$strict>;
-                            operations: import("zod").ZodArray<import("zod").ZodEnum<{
-                                create: "create";
-                                delete: "delete";
-                                read: "read";
-                                traverse: "traverse";
-                                update: "update";
-                            }>>;
-                        }, import("zod/v4/core").$strict>>>;
-                        admin: import("zod").ZodOptional<import("zod").ZodObject<{
-                            grant: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
-                                create: "create";
-                                delete: "delete";
-                                grant: "grant";
-                                read: "read";
-                                revoke: "revoke";
-                                traverse: "traverse";
-                                update: "update";
-                                use: "use";
-                            }>>>;
-                            revoke: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
-                                create: "create";
-                                delete: "delete";
-                                grant: "grant";
-                                read: "read";
-                                revoke: "revoke";
-                                traverse: "traverse";
-                                update: "update";
-                                use: "use";
-                            }>>>;
-                        }, import("zod/v4/core").$strict>>;
-                    }, import("zod/v4/core").$strict>;
-                    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
-                        origin: import("zod").ZodString;
-                        installation: import("zod").ZodString;
-                        target: import("zod").ZodString;
-                        readinessReceipt: import("zod").ZodString;
-                        meaningComparison: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>>;
-                }, import("zod/v4/core").$strict>>;
-            }, import("zod/v4/core").$strict>;
-            phase: import("zod").ZodEnum<{
-                converge: "converge";
-                cutover: "cutover";
-            }>;
-            state: import("zod").ZodLiteral<"committed">;
-            readiness: import("zod").ZodOptional<import("zod").ZodObject<{
-                installation: import("zod").ZodString;
-                target: import("zod").ZodString;
-                transition: import("zod").ZodString;
-                dependencies: import("zod").ZodArray<import("zod").ZodObject<{
-                    origin: import("zod").ZodString;
-                    installation: import("zod").ZodString;
-                    target: import("zod").ZodString;
-                    readinessReceipt: import("zod").ZodString;
-                    meaningComparison: import("zod").ZodString;
-                }, import("zod/v4/core").$strict>>;
-            }, import("zod/v4/core").$strict>>;
-        }, import("zod/v4/core").$strict>>;
-    }, import("zod/v4/core").$strict>;
-}>;
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Install: builder.Function<builder.CallableProjection<{
+    operation: string;
+    domains: ({
+        artifact: {
+            digest: string;
+            mediaType: string;
+            size: number;
+        };
+        currentRevision?: string | null | undefined;
+    } | {
+        release: {
+            url: string;
+            token?: string | undefined;
+            digest?: string | undefined;
+        };
+        consent?: {
+            issuer: {
+                from: string;
+                to: string;
+            };
+            previous?: "drain" | "revoke" | undefined;
+        } | undefined;
+        revision?: string | undefined;
+        currentRevision?: string | null | undefined;
+    })[];
+    mode?: "maintenance" | "online" | undefined;
+    validation?: {
+        scope?: "full" | "incremental" | undefined;
+        counts?: "exact" | "sample" | undefined;
+    } | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        changed: true;
+        receipt: {
+            operation: string;
+            transitions: {
+                intent: {
+                    transition: string;
+                    operation: string;
+                    origin: string;
+                    previous: {
+                        origin: string;
+                        revision: string;
+                        generation: string;
+                    } | null;
+                    generation: {
+                        origin: string;
+                        revision: string;
+                        generation: string;
+                    } | null;
+                    consent?: {
+                        issuer: {
+                            from: string;
+                            to: string;
+                        };
+                        previous: "drain" | "revoke";
+                    } | undefined;
+                };
+                phase: "converge" | "cutover";
+                state: "committed";
+                readiness?: {
+                    generation: string;
+                    transition: string;
+                    dependencies: {
+                        origin: string;
+                        generation: string;
+                        readiness: string;
+                        meaning: string;
+                    }[];
+                } | undefined;
+            }[];
+        };
+    } | {
+        changed: false;
+        domains: {
+            origin: string;
+            revision: string;
+            generation: string;
+        }[];
+    };
+}, "authorized", false, false, {
+    readonly durable: true;
+}>>;

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

@@ -1,8 +1,12 @@
+import { func } from '@astrale-os/kernel-dsl/v1';
 import { installInput, installOutput } from '../contracts/index.js';
-import { defineFunction } from './define.js';
-export const Install = defineFunction({
-    description: 'Durably install one or more exact Schema targets and return a terminal receipt.',
+import { usePolicy } from './use-policy.js';
+export const Install = func({
+    description: 'Authorize and atomically converge a non-empty set of exact ready Domain generations, as the durable Execution it is.',
     auth: 'authorized',
+    policy: usePolicy(() => Install),
     input: installInput,
     output: installOutput,
+    // A durable syscall: the call returns its Execution, the Kernel's install workflow runs it.
+    execution: { durable: true },
 });

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

@@ -1,20 +1,9 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Introspect: builder.Function<{
-    readonly description: "Return bounded installed-Publication evidence to an authenticated Kernel session.";
-    readonly auth: "authenticated";
-    readonly input: import("zod").ZodObject<{
-        from: import("zod").ZodObject<{
-            kind: import("zod").ZodLiteral<"installation">;
-            origin: import("zod").ZodString;
-        }, import("zod/v4/core").$strict>;
-        select: import("zod").ZodObject<{
-            state: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
-            target: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
-            source: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
-            bundle: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
-            readiness: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
-            capabilities: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
-        }, import("zod/v4/core").$strict>;
-    }, import("zod/v4/core").$strict>;
-    readonly output: builder.BinaryOutput;
-}>;
+export declare const Introspect: builder.Function<builder.CallableProjection<{
+    kind: "bundle" | "dependencies" | "inspect";
+    origin: string;
+} | {
+    kind: "installed";
+}, {
+    readonly mode: 'binary';
+}, "authenticated", false, false, undefined>>;

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

@@ -1,8 +1,7 @@
-import { output } from '@astrale-os/kernel-dsl/v1';
+import { func, output } from '@astrale-os/kernel-dsl/v1';
 import { introspectInput } from '../contracts/index.js';
-import { defineFunction } from './define.js';
-export const Introspect = defineFunction({
-    description: 'Return bounded installed-Publication evidence to an authenticated Kernel session.',
+export const Introspect = func({
+    description: 'Return bounded ready-installation evidence to an authenticated Kernel session.',
     auth: 'authenticated',
     input: introspectInput,
     output: output.binary(),

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

@@ -1,31 +1,29 @@
-import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Journal: builder.Function<{
-    readonly description: "Read one authorized page of semantic operations from the kernel journal.";
-    readonly auth: "authorized";
-    readonly input: import("zod").ZodObject<{
-        invocation: import("zod").ZodOptional<import("zod").ZodObject<{
-            source: import("zod").ZodString;
-            id: import("zod").ZodString;
-        }, import("zod/v4/core").$strict>>;
-        topics: import("zod").ZodOptional<import("zod").ZodObject<{
-            exact: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-            prefixes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-        }, import("zod/v4/core").$strict>>;
-        principal: import("zod").ZodOptional<import("zod").ZodString>;
-        since: import("zod").ZodOptional<import("zod").ZodString>;
-        until: import("zod").ZodOptional<import("zod").ZodString>;
-        cursor: import("zod").ZodOptional<import("zod").ZodString>;
-        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
-    }, import("zod/v4/core").$strict>;
-    readonly output: import("zod").ZodObject<{
-        records: import("zod").ZodArray<import("zod").ZodUnknown>;
-        frontier: import("zod").ZodObject<{
-            id: import("zod").ZodString;
-            first: import("zod").ZodOptional<import("zod").ZodNumber>;
-            committed: import("zod").ZodNumber;
-            durable: import("zod").ZodNumber;
-        }, import("zod/v4/core").$strict>;
-        cursor: import("zod").ZodOptional<import("zod").ZodString>;
-        gap: import("zod").ZodOptional<import("zod").ZodUnknown>;
-    }, import("zod/v4/core").$strict>;
-}>;
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Journal: builder.Function<builder.CallableProjection<{
+    invocation?: {
+        source: string;
+        id: string;
+    } | undefined;
+    topics?: {
+        exact?: string[] | undefined;
+        prefixes?: string[] | undefined;
+    } | undefined;
+    principal?: string | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        records: unknown[];
+        frontier: {
+            id: string;
+            first?: number | undefined;
+            committed: number;
+            durable: number;
+        };
+        cursor?: string | undefined;
+        gap?: unknown;
+    };
+}, "authorized", false, false, undefined>>;

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

@@ -1,8 +1,10 @@
+import { func } from '@astrale-os/kernel-dsl/v1';
 import { journalInput, journalOutput } from '../contracts/index.js';
-import { defineFunction } from './define.js';
-export const Journal = defineFunction({
+import { usePolicy } from './use-policy.js';
+export const Journal = func({
     description: 'Read one authorized page of semantic operations from the kernel journal.',
     auth: 'authorized',
+    policy: usePolicy(() => Journal),
     input: journalInput,
     output: journalOutput,
 });

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

@@ -1,13 +1,8 @@
-import type { builder } from '@astrale-os/kernel-dsl/v1';
-export declare const Mint: builder.Method<{
-    readonly description: "Resolve and sign one authorized Grant credential.";
-    readonly auth: "authorized";
-    readonly input: import("zod").ZodObject<{
-        audience: import("zod").ZodOptional<import("zod").ZodString>;
-        ttlSeconds: import("zod").ZodNumber;
-        grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-    }, import("zod/v4/core").$strict>;
-    readonly output: import("zod").ZodString;
-    readonly static: true;
-    readonly inheritance: "default";
-}>;
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Mint: builder.Method<builder.CallableProjection<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, "authenticated", true, false, undefined>>;

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

@@ -1,10 +1,10 @@
+import { method } from '@astrale-os/kernel-dsl/v1';
 import { mintInput, mintOutput } from '../contracts/index.js';
-import { defineMethod } from './define.js';
-export const Mint = defineMethod({
-    description: 'Resolve and sign one authorized Grant credential.',
-    auth: 'authorized',
+export const Mint = method({
+    description: 'Issue one Kernel credential attenuated from the authenticated principal.',
+    auth: 'authenticated',
     input: mintInput,
     output: mintOutput,
     static: true,
-    inheritance: 'default',
+    abstract: false,
 });