@phreshos/node 0.1.11 → 0.1.13

package/dist/system.js

@@ -1,39 +1,49 @@
-import { Client as CoreClient, ClientService as CoreClientService, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, ServerService as CoreServerService, isServiceKey } from "@phreshos/core";
+import { ClientEndpoint as CoreClientEndpoint, ClientService as CoreClientService, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, ServerEndpoint as CoreServerEndpoint, ServerService as CoreServerService, isServiceKey } from "@phreshos/core";
 import { homedir } from "node:os";
 import { gatewayAddress } from "./address.js";
 import Events from "./events.js";
 import HandleRegistry from "./handle-registry.js";
 import { resolveHome } from "./home.js";
-import { filesystemStorage } from "./storage.js";
-import { programSql, programStore } from "./program-resources.js";
+import { filesystemStorage, nativeStorage } from "./storage.js";
+import { programPermissions, programSql, programStore } from "./program-resources.js";
 import { EndpointTrafficHandle, ServerTrafficHandle } from "./traffic.js";
-import { openConnection, request, streamProgram } from "./transport.js";
+import { openConnection, request, stream } from "./transport.js";
 import Uploads from "./uploads.js";
+import shell from "./shell.js";
 const systems = new WeakMap();
 const ProgramBase = CoreProgram;
 const ProcessBase = CoreProcess;
-const ServerBase = CoreServer;
-const ClientBase = CoreClient;
+const ServerEndpointBase = CoreServerEndpoint;
+const ClientEndpointBase = CoreClientEndpoint;
 /** One connected owner-local implementation of the shared System contract. */
 export class System {
-    storage = filesystemStorage(homedir(), "the native home directory");
+    storage;
     appearance;
     program;
     process;
     uploads;
+    async fetch(input, init) {
+        const request = new Request(input, init);
+        return await fetch(request, { signal: connectedSignal(this, request.signal) });
+    }
+    async *shell(command, options = {}) {
+        yield* shell(command, { ...options, signal: connectedSignal(this, options.signal) });
+    }
     constructor(address, connection) {
         const lifetime = new AbortController();
         const handles = new HandleRegistry();
         const transport = {
             control: (value, signal) => request(address, "system", value, connectedSignal(this, signal)),
             api: (value, signal) => request(address, "api", value, connectedSignal(this, signal)),
-            lifecycle: (value, signal) => streamProgram(address, value, connectedSignal(this, signal))
+            stream: (target, value, signal) => stream(address, target, value, connectedSignal(this, signal))
         };
         systems.set(this, { address, connection, handles, lifetime, transport, closed: false });
+        connection.once("close", () => closeSystem(this, new Error("This System connection is closed")));
+        this.storage = nativeStorage(homedir(), "the native filesystem", () => connectedSignal(this));
         this.appearance = new SystemAppearance(transport);
         this.program = new ProgramRegistry(this);
         this.process = new ProcessRegistry(this);
-        this.uploads = new Uploads(value => transport.api(value));
+        this.uploads = new Uploads(value => transport.api(value), () => connectedSignal(this));
     }
     /** Connect to the System selected by argument, environment, or owner default. */
     static async connect(home) {
@@ -44,7 +54,7 @@ export class System {
     /** Atomically replace one runtime Program without touching its installed form. */
     async forceCreateProgram(source) {
         requireConnected(this);
-        for await (const event of transport(this).lifecycle({ word: "force-create", program: source })) {
+        for await (const event of transport(this).stream("program", { word: "force-create", program: source })) {
             if (event.event === "created")
                 return programHandle(this, required(event.program));
         }
@@ -52,13 +62,7 @@ export class System {
     }
     /** Close this owner connection and abort every attached operation it owns. */
     async disconnect() {
-        const state = systemState(this);
-        if (state.closed)
-            return;
-        state.closed = true;
-        state.lifetime.abort(new Error("This System connection is closed"));
-        state.connection.destroy();
-        state.handles.clear();
+        closeSystem(this, new Error("This System connection is closed"));
     }
     service(key) {
         requireConnected(this);
@@ -81,6 +85,15 @@ function systemState(system) {
         throw new Error("Unknown System connection");
     return state;
 }
+function closeSystem(system, reason) {
+    const state = systemState(system);
+    if (state.closed)
+        return;
+    state.closed = true;
+    state.lifetime.abort(reason);
+    state.connection.destroy();
+    state.handles.clear();
+}
 function requireConnected(system) {
     if (systemState(system).closed)
         throw new Error("This System connection is closed");
@@ -149,7 +162,7 @@ class ProgramRegistry extends Events {
         }
     }
     async create(source) {
-        for await (const event of transport(this.system).lifecycle({ word: "create", program: source })) {
+        for await (const event of transport(this.system).stream("program", { word: "create", program: source })) {
             if (event.event === "created")
                 return programHandle(this.system, required(event.program));
         }
@@ -175,26 +188,30 @@ class ProgramHandle extends ProgramBase {
     database;
     process;
     startup;
+    permissions;
     snapshot;
     constructor(system, snapshot) {
         super();
         this.system = system;
         this.snapshot = snapshot;
-        bindEvents(this, new Events(["forget", "uninstall"], (event, signal, timeout) => transport(system).control({
-            capability: "program", operation: "wait", input: { program: snapshot.identity, event, timeout }
-        }, signal).then(value => programEntityEvent(event, value))));
         this.reference = snapshot.reference;
         this.identity = snapshot.identity;
+        const address = this.address();
+        bindEvents(this, new Events(["forget", "uninstall"], (event, signal, timeout) => transport(system).api({
+            capability: "program", operation: "wait", handle: address, event, timeout
+        }, signal)));
         const request = (value) => transport(system).api(value);
-        this.data = filesystemStorage(() => programStoragePath(system, this.identity, "data"), `Program "${this.identity}" data`);
-        this.cache = filesystemStorage(() => programStoragePath(system, this.identity, "cache"), `Program "${this.identity}" cache`);
-        this.store = programStore(request, this.identity);
-        this.logs = programSql(request, this.identity, "logs");
-        this.database = programSql(request, this.identity, "database");
+        this.data = filesystemStorage(() => programStoragePath(system, address, "data"), `Program "${this.identity}" data`, () => connectedSignal(system));
+        this.cache = filesystemStorage(() => programStoragePath(system, address, "cache"), `Program "${this.identity}" cache`, () => connectedSignal(system));
+        this.store = programStore(request, address);
+        this.logs = programSql(request, address, "logs");
+        this.database = programSql(request, address, "database");
         this.process = new ProgramProcesses(system, this);
         this.startup = new ProgramStartup(system, this);
+        this.permissions = programPermissions(request, address);
     }
     get name() { return this.snapshot.name; }
+    get assetId() { return this.snapshot.assetId; }
     get version() { return this.snapshot.version; }
     get description() { return this.snapshot.description; }
     get hasAgent() { return this.snapshot.hasAgent; }
@@ -212,7 +229,8 @@ class ProgramHandle extends ProgramBase {
             size: this.snapshot.client.size,
             position: this.snapshot.client.position,
             layer: this.snapshot.client.layer,
-            minimize: this.snapshot.client.minimize
+            minimize: this.snapshot.client.minimize,
+            permissions: Object.freeze(Object.fromEntries(Object.entries(this.snapshot.client.permissions).map(([name, values]) => [name, Object.freeze([...values])])))
         }) : null;
     }
     update(snapshot) {
@@ -221,7 +239,7 @@ class ProgramHandle extends ProgramBase {
         this.snapshot = snapshot;
     }
     async icon(size = "medium") {
-        const value = await transport(this.system).api({ capability: "program", operation: "icon", program: this.identity, size });
+        const value = await transport(this.system).api({ capability: "program", operation: "icon", handle: this.address(), size });
         if (!Array.isArray(value) || value.some(byte => typeof byte !== "number"))
             throw new Error("The System returned an invalid Program icon");
         return new Blob([Uint8Array.from(value)], { type: "image/png" });
@@ -229,11 +247,11 @@ class ProgramHandle extends ProgramBase {
     async agent() {
         if (!this.hasAgent)
             return null;
-        const value = await transport(this.system).control({ capability: "program", operation: "agent", input: { program: this.identity } });
-        return typeof value.content === "string" ? value.content : null;
+        const value = await transport(this.system).api({ capability: "program", operation: "agent", handle: this.address() });
+        return typeof value === "string" ? value : null;
     }
     async installed() {
-        for await (const event of transport(this.system).lifecycle({ word: "installed", handle: this.address() })) {
+        for await (const event of transport(this.system).stream("program", { word: "installed", handle: this.address() })) {
             if (event.event === "installedState")
                 return event.installed === true;
         }
@@ -241,8 +259,15 @@ class ProgramHandle extends ProgramBase {
     }
     install() { return command(this.system, { word: "install-existing", handle: this.address() }); }
     uninstall(everything = false) { return command(this.system, { word: "uninstall-existing", handle: this.address(), everything }); }
+    async fork(identity) {
+        for await (const event of transport(this.system).stream("program", { word: "fork", handle: this.address(), identity })) {
+            if (event.event === "created")
+                return programHandle(this.system, required(event.program));
+        }
+        throw new Error("The System did not confirm the forked Program");
+    }
     async forget() {
-        for await (const _event of transport(this.system).lifecycle({ word: "forget", handle: this.address() })) { /* consume completion */ }
+        for await (const _event of transport(this.system).stream("program", { word: "forget", handle: this.address() })) { /* consume completion */ }
     }
     address() { return Object.freeze({ identity: this.identity, reference: this.reference }); }
 }
@@ -254,7 +279,7 @@ class ProgramStartup {
         this.program = program;
     }
     async get() {
-        for await (const event of transport(this.system).lifecycle({
+        for await (const event of transport(this.system).stream("program", {
             word: "startup", handle: this.program.address(), operation: "get"
         })) {
             if (event.event === "startup")
@@ -269,7 +294,7 @@ class ProgramStartup {
         await this.change("disable");
     }
     async change(operation, launch) {
-        for await (const event of transport(this.system).lifecycle({
+        for await (const event of transport(this.system).stream("program", {
             word: "startup", handle: this.program.address(), operation, launch
         })) {
             if (event.event === "startup")
@@ -282,13 +307,18 @@ class ProgramProcesses extends Events {
     system;
     program;
     constructor(system, program) {
-        super(["create", "exit"], (event, signal, timeout) => transport(system).control({
-            capability: "process", operation: "wait", input: { program: program.identity, event, timeout }
-        }, signal).then(value => processEvent(system, value)));
+        super(["create", "exit"], (event, signal, timeout) => transport(system).api({
+            capability: "programProcess", operation: "wait", handle: program.address(), event, timeout
+        }, signal).then(value => programProcessEvent(system, event, value)));
         this.system = system;
         this.program = program;
     }
-    async list() { return await listProcesses(this.system, this.program.identity); }
+    async list() {
+        const value = await transport(this.system).api({ capability: "programProcess", operation: "list", handle: this.program.address() });
+        if (!Array.isArray(value))
+            throw new Error("The System returned an invalid Program Process list");
+        return value.map(snapshot => processHandle(this.system, snapshot));
+    }
     async first() { return (await this.list()).sort(chronological)[0] ?? null; }
     async last() { return (await this.list()).sort(chronological).at(-1) ?? null; }
     async find(identityOrName) {
@@ -298,7 +328,7 @@ class ProgramProcesses extends Events {
     create(launch = {}) { return this.createExact("create-process", launch); }
     async *run(launch = {}, options = {}) {
         let process = null;
-        for await (const event of transport(this.system).lifecycle({
+        for await (const event of transport(this.system).stream("program", {
             word: "run-process",
             handle: this.program.address(),
             launch
@@ -345,7 +375,7 @@ class ProgramProcesses extends Events {
         return processes.map(process => process.identity);
     }
     async createExact(word, launch) {
-        for await (const event of transport(this.system).lifecycle({ word, handle: this.program.address(), launch })) {
+        for await (const event of transport(this.system).stream("program", { word, handle: this.program.address(), launch })) {
             if (event.event === "createdProcess")
                 return processHandle(this.system, required(event.process));
         }
@@ -391,8 +421,8 @@ class ProcessHandle extends ProcessBase {
         this.identity = snapshot.identity;
         this.name = snapshot.name;
         this.startedAt = new Date(snapshot.startedAt);
-        this.server = new ServerEndpoint(system, this);
-        this.client = new ClientEndpoint(system, this);
+        this.server = new ServerEndpointHandle(system, this);
+        this.client = new ClientEndpointHandle(system, this);
     }
     program() { return programHandle(this.system, required(this.snapshot.programSnapshot, this.snapshot.program)); }
     async parent() {
@@ -437,6 +467,11 @@ class EndpointOperations extends Events {
     }
     async start(launch = {}) { await this.operation("start", launch); }
     async stop() { await this.operation("stop"); }
+    async waitReady(timeout) {
+        await transport(this.system).control({ capability: "endpoint", operation: "waitReady", input: {
+                process: this.owner.identity, endpoint: this.endpoint, timeout
+            } });
+    }
     async isService() {
         return await transport(this.system).api({
             capability: "endpoint", operation: "isService", process: this.owner.identity, endpoint: this.endpoint
@@ -458,7 +493,7 @@ class EndpointOperations extends Events {
             } });
     }
 }
-class ServerEndpoint extends ServerBase {
+class ServerEndpointHandle extends ServerEndpointBase {
     system;
     owner;
     endpoint = "server";
@@ -476,6 +511,7 @@ class ServerEndpoint extends ServerBase {
     }
     process() { return this.base.process(); }
     exists() { return this.base.exists(); }
+    waitReady(timeout) { return this.base.waitReady(timeout); }
     isService() { return this.base.isService(); }
     start(launch) { return this.base.start(launch); }
     stop() { return this.base.stop(); }
@@ -490,11 +526,8 @@ class ServerEndpoint extends ServerBase {
                 capability: "endpoint", operation: "ask", input: { process: this.owner.identity, endpoint: "server", event, payload, timeout: milliseconds }
             }) };
     }
-    async waitReady(timeout) {
-        await transport(this.system).control({ capability: "endpoint", operation: "waitReady", input: { process: this.owner.identity, endpoint: "server", timeout } });
-    }
 }
-class ClientEndpoint extends ClientBase {
+class ClientEndpointHandle extends ClientEndpointBase {
     endpoint = "client";
     traffic;
     lifecycle;
@@ -510,6 +543,7 @@ class ClientEndpoint extends ClientBase {
     }
     process() { return this.base.process(); }
     exists() { return this.base.exists(); }
+    waitReady(timeout) { return this.base.waitReady(timeout); }
     isService() { return this.base.isService(); }
     start(launch) { return this.base.start(launch); }
     stop() { return this.base.stop(); }
@@ -557,11 +591,14 @@ class ServiceBase {
         }, signal));
     }
     async exists() { return await transport(this.system).api({ capability: "service", operation: "exists", key: this.key }); }
+    async waitReady(timeout) {
+        await transport(this.system).api({ capability: "service", operation: "waitReady", key: this.key, timeout });
+    }
     publish(event, payload) {
         void transport(this.system).api({ capability: "service", operation: "publish", key: this.key, event, payload });
     }
 }
-/** Node-SDK handle for a Service provided by a Server Endpoint. */
+/** Node SDK handle for a Service provided by a Server Endpoint. */
 export class ServerService extends CoreServerService {
     constructor() { super(); }
 }
@@ -581,9 +618,7 @@ class ServerServiceHandle extends ServerService {
         }, signal)));
     }
     exists() { return this.base.exists(); }
-    async waitReady(timeout) {
-        await transport(this.system).api({ capability: "service", operation: "waitReady", key: this.key, timeout });
-    }
+    waitReady(timeout) { return this.base.waitReady(timeout); }
     publish = (event, payload) => this.base.publish(event, payload);
     async ask(event, payload) {
         return await transport(this.system).api({ capability: "service", operation: "ask", key: this.key, event, payload });
@@ -594,7 +629,7 @@ class ServerServiceHandle extends ServerService {
             }) };
     }
 }
-/** Node-SDK handle for a Service provided by a Client Endpoint. */
+/** Node SDK handle for a Service provided by a Client Endpoint. */
 export class ClientService extends CoreClientService {
     constructor() { super(); }
 }
@@ -610,13 +645,14 @@ class ClientServiceHandle extends ClientService {
         }, signal)));
     }
     exists() { return this.base.exists(); }
+    waitReady(timeout) { return this.base.waitReady(timeout); }
     publish = (event, payload) => this.base.publish(event, payload);
 }
-async function listProcesses(system, program) {
+async function listProcesses(system) {
     const processes = [];
     let offset = 0;
     while (true) {
-        const page = await transport(system).control({ capability: "process", operation: "list", input: { program, limit: 100, offset } });
+        const page = await transport(system).control({ capability: "process", operation: "list", input: { limit: 100, offset } });
         processes.push(...page.data.map(snapshot => processHandle(system, snapshot)));
         offset += page.data.length;
         if (!page.truncated || !page.data.length)
@@ -624,7 +660,7 @@ async function listProcesses(system, program) {
     }
 }
 async function* command(system, request) {
-    for await (const event of transport(system).lifecycle(request)) {
+    for await (const event of transport(system).stream("program", request)) {
         if (event.event === "output")
             yield {
                 stream: event.stream === "stderr" ? "stderr" : "stdout",
@@ -641,10 +677,6 @@ async function waitEndpointLifecycle(system, owner, endpoint, event, signal, tim
         input: { process: owner.identity, endpoint, event, timeout }
     }, signal);
 }
-function programEntityEvent(event, value) {
-    const payload = value.payload;
-    return event === "uninstall" ? payload?.everything === true : undefined;
-}
 function processEvent(system, value) {
     const waited = value;
     const payload = waited.payload;
@@ -659,6 +691,17 @@ function processEvent(system, value) {
         return processHandle(system, payload);
     return payload;
 }
+function programProcessEvent(system, event, value) {
+    if (event === "create")
+        return processHandle(system, value);
+    const exit = value;
+    return {
+        process: processHandle(system, required(exit.process)),
+        status: exit.status,
+        code: exit.code,
+        signal: exit.signal
+    };
+}
 function exactProcessEvent(value) {
     const payload = value.payload;
     if (!payload)
@@ -680,8 +723,8 @@ function eventsOf(events) {
     };
 }
 function chronological(left, right) { return left.startedAt.getTime() - right.startedAt.getTime(); }
-async function programStoragePath(system, program, area) {
-    const value = await transport(system).api({ capability: "program", operation: "storagePath", program, area });
+async function programStoragePath(system, handle, area) {
+    const value = await transport(system).api({ capability: "program", operation: "storagePath", handle, area });
     if (typeof value !== "string")
         throw new Error("The System returned an invalid Program storage path");
     return value;
@@ -719,5 +762,5 @@ function required(value, identity = "") {
 export const Program = CoreProgram;
 export const Process = CoreProcess;
 export const Endpoint = CoreEndpoint;
-export const Server = CoreServer;
-export const Client = CoreClient;
+export const ServerEndpoint = CoreServerEndpoint;
+export const ClientEndpoint = CoreClientEndpoint;

package/dist/traffic.d.ts

@@ -15,20 +15,20 @@ export declare class EndpointTrafficHandle<Definitions extends object = {}> exte
         event: string;
         questionId: string;
         message: Readonly<{
-            to: import("@phreshos/core").Server<{}> | null;
+            to: import("@phreshos/core").ServerEndpoint<{}, unknown> | null;
             payload: Payload;
         }>;
     }>>;
     protected follow<Capture>(kind: Kind, convert: (value: unknown) => Capture, subscriber: (capture: Capture) => unknown, impossible?: (error: Error) => void): Cleanup;
 }
-/** Directed traffic originating from one canonical Server. */
+/** Directed traffic originating from one canonical Server Endpoint. */
 export declare class ServerTrafficHandle<Definitions extends object = {}> extends EndpointTrafficHandle<Definitions> implements ServerTraffic<Definitions> {
     subscribeAnswers<Result = unknown>(subscriber: AnswerSubscriber<Result>): Cleanup;
     answers<Result = unknown>(options?: EventOptions): AsyncIterableIterator<Readonly<{
         event: string;
         questionId: string;
         message: Readonly<{
-            to: Endpoint<{}> | null;
+            to: Endpoint<{}, unknown> | null;
             outcome: import("@phreshos/core").Outcome<Result>;
         }>;
     }>>;

package/dist/traffic.js

@@ -52,7 +52,7 @@ export class EndpointTrafficHandle extends Events {
         return () => controller.abort();
     }
 }
-/** Directed traffic originating from one canonical Server. */
+/** Directed traffic originating from one canonical Server Endpoint. */
 export class ServerTrafficHandle extends EndpointTrafficHandle {
     subscribeAnswers(subscriber) {
         return this.follow("answer", value => answer(value, this.resolveEndpoint), subscriber);

package/dist/transport.d.ts

@@ -7,5 +7,5 @@ export interface TransportEvent {
 export declare function openConnection(path: string): Promise<Socket>;
 /** Execute one short authoritative System-control request. */
 export declare function request(path: string, target: "api" | "system", request: unknown, signal?: AbortSignal): Promise<unknown>;
-/** Stream one Program lifecycle operation until the System completes it. */
-export declare function streamProgram(path: string, request: unknown, signal?: AbortSignal): AsyncGenerator<TransportEvent, void, unknown>;
+/** Stream one long-running authoritative System operation. */
+export declare function stream(path: string, target: "program", request: unknown, signal?: AbortSignal): AsyncGenerator<TransportEvent, void, unknown>;

package/dist/transport.js

@@ -1,4 +1,5 @@
 import { connect } from "node:net";
+const maximumStreamQueue = 256;
 /** Open and retain one owner-local System connection. */
 export function openConnection(path) {
     return new Promise((resolve, reject) => {
@@ -52,8 +53,8 @@ export function request(path, target, request, signal) {
             cancel();
     });
 }
-/** Stream one Program lifecycle operation until the System completes it. */
-export function streamProgram(path, request, signal) {
+/** Stream one long-running authoritative System operation. */
+export function stream(path, target, request, signal) {
     const events = [];
     let wake = null;
     let ended = false;
@@ -65,14 +66,27 @@ export function streamProgram(path, request, signal) {
     else
         signal?.addEventListener("abort", cancel, { once: true });
     let buffer = "";
-    socket.on("connect", () => socket.write(`${JSON.stringify({ target: "program", request })}\n`));
+    socket.on("connect", () => socket.write(`${JSON.stringify({ target, request })}\n`));
     socket.on("data", chunk => {
         buffer += String(chunk);
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
         for (const line of lines)
             if (line.trim()) {
-                const event = JSON.parse(line);
+                if (events.length >= maximumStreamQueue) {
+                    failure = new Error(`System stream queue exceeded its capacity of ${maximumStreamQueue}`);
+                    socket.destroy();
+                    break;
+                }
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    failure = new Error("The System returned an invalid stream event");
+                    socket.destroy();
+                    break;
+                }
                 if (event.event === "error")
                     failure = new Error(String(event.message));
                 else

package/dist/uploads.d.ts

@@ -3,8 +3,10 @@ type Ask = (request: object) => Promise<unknown>;
 /** Owner-local implementation of the System's opaque upload collection. */
 export default class Uploads implements SystemUploads {
     private readonly ask;
+    private readonly lifetime;
     private accessPromise;
-    constructor(ask: Ask);
+    constructor(ask: Ask, lifetime: () => AbortSignal);
+    path(): Promise<string>;
     write(value: unknown): Promise<Upload>;
     stream(file: string): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
     bytes(file: string): Promise<Uint8Array<ArrayBuffer>>;
@@ -17,5 +19,6 @@ export default class Uploads implements SystemUploads {
         time: number;
     }> | null>;
     private access;
+    private active;
 }
 export {};

package/dist/uploads.js

@@ -2,17 +2,23 @@ import { isUploadFile } from "@phreshos/core";
 import { randomUUID } from "node:crypto";
 import { createReadStream, createWriteStream, mkdirSync } from "node:fs";
 import { rename, rm } from "node:fs/promises";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 /** Owner-local implementation of the System's opaque upload collection. */
 export default class Uploads {
     ask;
+    lifetime;
     accessPromise = null;
-    constructor(ask) {
+    constructor(ask, lifetime) {
         this.ask = ask;
+        this.lifetime = lifetime;
+    }
+    async path() {
+        return (await this.access()).path;
     }
     async write(value) {
+        const signal = this.active();
         const access = await this.access();
         const source = content(value);
         const identity = randomUUID();
@@ -29,7 +35,8 @@ export default class Uploads {
                         throw new Error(`The upload exceeds ${access.limit / 1024 / 1024 / 1024} GB`);
                     yield chunk;
                 }
-            }, createWriteStream(temporary, { flags: "wx" }));
+            }, createWriteStream(temporary, { flags: "wx" }), { signal });
+            signal.throwIfAborted();
             await rename(temporary, destination);
         }
         catch (error) {
@@ -42,22 +49,25 @@ export default class Uploads {
         return upload;
     }
     async stream(file) {
+        const signal = this.active();
         requireFile(file);
         const access = await this.access();
-        return Readable.toWeb(createReadStream(join(access.path, file)));
+        return Readable.toWeb(createReadStream(join(access.path, file), { signal }));
     }
     async bytes(file) { return new Uint8Array(await new Response(await this.stream(file)).arrayBuffer()); }
     async text(file) { return new Response(await this.stream(file)).text(); }
     async json(file) { return JSON.parse(await this.text(file)); }
     async stat(file) {
+        this.active();
         requireFile(file);
         return await this.ask({ capability: "uploads", operation: "stat", file });
     }
     access() {
+        this.active();
         if (!this.accessPromise) {
             const resolving = this.ask({ capability: "uploads", operation: "access" }).then(value => {
                 const access = value;
-                if (!access || typeof access.path !== "string" || typeof access.limit !== "number")
+                if (!access || typeof access.path !== "string" || !isAbsolute(access.path) || typeof access.limit !== "number")
                     throw new Error("The System returned invalid upload access");
                 return { path: access.path, limit: access.limit };
             });
@@ -70,6 +80,11 @@ export default class Uploads {
         }
         return this.accessPromise;
     }
+    active() {
+        const signal = this.lifetime();
+        signal.throwIfAborted();
+        return signal;
+    }
 }
 function requireFile(file) {
     if (!isUploadFile(file))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/node",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Node.js access to PhreshOS and Program projects.",
   "type": "module",
   "main": "dist/main.js",
@@ -29,14 +29,14 @@
   "packageManager": "bun@1.3.14",
   "scripts": {
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
-    "check": "tsc --noEmit",
+    "check": "tsc --noEmit && tsc -p tsconfig.test.json",
     "build": "node --run clean && tsc --noEmit false --outDir dist --rootDir source",
     "test": "node --run build && node --test tests/*.test.mjs",
     "verify": "node --run check && node --run test",
     "prepack": "node --run build"
   },
   "dependencies": {
-    "@phreshos/core": "^0.1.34",
+    "@phreshos/core": "^0.1.37",
     "adm-zip": "^0.6.0",
     "jiti": "^2.7.0"
   },