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

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

@@ -222,7 +222,27 @@ 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;
+    }>, {
+        readonly mode: 'value';
+        readonly value: {
+            receipt: string;
+            ref: {
+                digest: string;
+                mediaType: string;
+                size: number;
+            };
+            expiresAt: string;
+        };
+    }, "authorized", false, false, undefined>>;
+    download: builder.Function<builder.CallableProjection<{
+        node: string;
+        property: string;
+    }, {
+        readonly mode: 'binary';
+    }, "authorized", false, false, undefined>>;
     mutate: builder.Function<builder.CallableProjection<{
         ast: {
             format: "astrale.graph.mutation";
@@ -379,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;
@@ -406,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: {
@@ -447,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: ({
@@ -469,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: ({
@@ -490,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[];
@@ -537,7 +557,7 @@ export declare const Functions: Readonly<{
                 } | undefined;
             }[];
         };
-    }, "authorized", false, false>>;
+    }, "authorized", false, false, undefined>>;
     journal: builder.Function<builder.CallableProjection<{
         invocation?: {
             source: string;
@@ -565,18 +585,18 @@ 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<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation: unknown;
+        attenuation?: unknown;
     }, {
         readonly mode: 'value';
         readonly value: string;
-    }, "authenticated", true, false>>;
+    }, "authenticated", true, false, undefined>>;
     can: builder.Method<builder.CallableProjection<{
         policy: string;
         object: string;
@@ -594,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: {
@@ -615,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;
@@ -639,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;
@@ -647,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;
@@ -656,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<{
@@ -676,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<{
@@ -718,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';

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

@@ -1,6 +1,8 @@
 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';
@@ -10,11 +12,14 @@ import { Mutate } from './mutate.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,
     register: Register,
     install: Install,
@@ -36,4 +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

@@ -19,4 +19,4 @@ export declare const Install: builder.Function<builder.CallableProjection<{
     })[];
 }, {
     readonly mode: 'binary';
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

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

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

@@ -26,4 +26,4 @@ export declare const Journal: builder.Function<builder.CallableProjection<{
         cursor?: string | undefined;
         gap?: unknown;
     };
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

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

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

@@ -223,4 +223,4 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
     readonly value: {
         createdNodes: Record<string, string>;
     };
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

@@ -221,4 +221,4 @@ export declare const Query: builder.Function<builder.CallableProjection<{
             next?: string | undefined;
         };
     };
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

@@ -20,4 +20,4 @@ export declare const Register: builder.Function<builder.CallableProjection<{
             sub: string;
         }[];
     };
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

@@ -39,4 +39,4 @@ export declare const Uninstall: builder.Function<builder.CallableProjection<{
             } | undefined;
         }[];
     };
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

@@ -0,0 +1,15 @@
+import { type builder } from '@astrale-os/kernel-dsl/v1';
+export declare const Upload: builder.Function<builder.CallableProjection<import("@astrale-os/kernel-dsl/v1").BinaryInputProjection<{
+    mediaType: string;
+}>, {
+    readonly mode: 'value';
+    readonly value: {
+        receipt: string;
+        ref: {
+            digest: string;
+            mediaType: string;
+            size: number;
+        };
+        expiresAt: string;
+    };
+}, "authorized", false, false, undefined>>;

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

@@ -0,0 +1,10 @@
+import { func, input } from '@astrale-os/kernel-dsl/v1';
+import { MAXIMUM_BLOB_BYTES, uploadInput, uploadOutput } from '../contracts/index.js';
+import { usePolicy } from './use-policy.js';
+export const Upload = func({
+    description: 'Store application bytes in an upload receipt.',
+    auth: 'authorized',
+    policy: usePolicy(() => Upload),
+    input: input.binary(uploadInput, { maximumBytes: MAXIMUM_BLOB_BYTES }),
+    output: uploadOutput,
+});

package/dist/schema/kernel/syscalls/declarations/view-resolve.d.ts

@@ -38,4 +38,4 @@ export declare const ViewResolve: builder.Method<builder.CallableProjection<{
             revision: string;
         }[];
     };
-}, "authorized", true, false>>;
+}, "authorized", true, false, undefined>>;

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

@@ -19,4 +19,4 @@ export declare const Whoami: builder.Method<builder.CallableProjection<Record<st
             op: "exists";
         })[];
     };
-}, "authenticated", true, false>>;
+}, "authenticated", true, false, undefined>>;

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

@@ -22,4 +22,4 @@ export declare const Whois: builder.Method<builder.CallableProjection<{
             op: "exists";
         })[];
     } | null;
-}, "authorized", true, false>>;
+}, "authorized", true, false, undefined>>;

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

@@ -0,0 +1,153 @@
+export declare const status: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "status", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<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;
+    };
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Execution.method.status"> & {
+    readonly name: "status";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const result: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "result", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    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";
+    };
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Execution.method.result"> & {
+    readonly name: "result";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const cancel: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "cancel", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    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;
+    };
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Execution.method.cancel"> & {
+    readonly name: "cancel";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const signal: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "signal", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    name: string;
+    value: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Execution.method.signal"> & {
+    readonly name: "signal";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export declare const resume: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "resume", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<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;
+    };
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Execution.method.resume"> & {
+    readonly name: "resume";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+declare const remove: import("./model.js").MethodSyscall<Readonly<{
+    origin: 'kernel.astrale.ai';
+    kind: 'class';
+    name: 'Execution';
+}>, "delete", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, false, false, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Execution.method.delete"> & {
+    readonly name: "delete";
+    readonly executable: true;
+    readonly execution: undefined;
+}>;
+export { remove as delete };

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

@@ -0,0 +1,11 @@
+import { K } from '../../index.js';
+import * as references from '../references/execution.js';
+import { methodSyscall } from './model.js';
+// Instance Methods: the handler receives the Execution receiver as `self`.
+export const status = methodSyscall(references.status, K.classes.Execution.methods.status);
+export const result = methodSyscall(references.result, K.classes.Execution.methods.result);
+export const cancel = methodSyscall(references.cancel, K.classes.Execution.methods.cancel);
+export const signal = methodSyscall(references.signal, K.classes.Execution.methods.signal);
+export const resume = methodSyscall(references.resume, K.classes.Execution.methods.resume);
+const remove = methodSyscall(references.delete, K.classes.Execution.methods.delete);
+export { remove as delete };

package/dist/schema/kernel/syscalls/descriptors/function.d.ts

@@ -20,6 +20,7 @@ declare const Admit: import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
 }, true, false, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Function.method.admit"> & {
     readonly name: "admit";
     readonly executable: true;
+    readonly execution: undefined;
 };
 export declare const admit: MethodSyscall<ClassRef<'Function'> & {
     readonly origin: 'kernel.astrale.ai';

package/dist/schema/kernel/syscalls/descriptors/functions.d.ts

@@ -7,3 +7,5 @@ export declare const install: FunctionSyscall<'kernel.astrale.ai', 'install', ty
 export declare const introspect: FunctionSyscall<'kernel.astrale.ai', 'introspect', typeof K.functions.introspect>;
 export declare const uninstall: FunctionSyscall<'kernel.astrale.ai', 'uninstall', typeof K.functions.uninstall>;
 export declare const journal: FunctionSyscall<'kernel.astrale.ai', 'journal', typeof K.functions.journal>;
+export declare const upload: FunctionSyscall<'kernel.astrale.ai', 'upload', typeof K.functions.upload>;
+export declare const download: FunctionSyscall<'kernel.astrale.ai', 'download', typeof K.functions.download>;

package/dist/schema/kernel/syscalls/descriptors/functions.js

@@ -8,3 +8,5 @@ export const install = functionSyscall(references.install, K.functions.install);
 export const introspect = functionSyscall(references.introspect, K.functions.introspect);
 export const uninstall = functionSyscall(references.uninstall, K.functions.uninstall);
 export const journal = functionSyscall(references.journal, K.functions.journal);
+export const upload = functionSyscall(references.upload, K.functions.upload);
+export const download = functionSyscall(references.download, K.functions.download);