@phreshos/client 0.1.12 → 0.1.13

package/README.md

@@ -51,11 +51,11 @@ same canonical capability:
 ```ts
 const program = await current.program()
 
-await program.permissions.granted("pointer")
-await current.permissions.request("pointer")
-await current.permissions.timeout(5_000).request("pointer")
+await program.permission.granted("pointer")
+await current.permission.request("pointer")
+await current.permission.timeout(5_000).request("pointer")
 
-current.permissions === program.permissions
+current.permission === program.permission
 ```
 
 `granted()` reads the effective decision without prompting. `request()` asks
@@ -63,6 +63,20 @@ only when no known decision can answer immediately and returns `null` if its
 deadline expires. The desktop remains the internal enforcement boundary, but
 permission ownership does not alter the public shape of `host`.
 
+The Client Host exposes service preparation as its only service-registry
+capability. Preparing a handle does not read or start the service:
+
+```ts
+const service = host.service.prepare({
+  program: "counter",
+  endpoint: "server",
+  name: "state"
+})
+
+await service.waitReady()
+if (await service.enabled()) await service.channel.ask("value")
+```
+
 A Client may traverse `Process.parent()` through any number of ancestors in
 its own Program. The first parent outside that Program is structurally hidden
 and returned as `null`; no cross-Program Process handle enters the client. If

package/dist/current.d.ts

@@ -9,7 +9,7 @@ export interface Current<Events extends object = {}> extends Channel<Events>, Pi
     /** Presentation capability of this current Client. */
     readonly window: Window;
     /** The same permission capability exposed by the current Program. */
-    readonly permissions: Program["permissions"];
+    readonly permission: Program["permission"];
     /** Returns the Process represented by this Client. */
     process(): Promise<Process>;
     /** Returns the accessible parent Process, or `null` when none exists. */

package/dist/current.js

@@ -3,7 +3,7 @@ import Deadline from "./deadline.js";
 import { Client, Server, ServerTrafficHandle, TrafficHandle, bindEvents, endpointEvents, process, program, window as windowHandle } from "./domain.js";
 import wire from "./wire.js";
 import { endpointService } from "./service.js";
-import { currentProgramPermissions } from "./permissions.js";
+import { currentProgramPermission } from "./permissions.js";
 const ServerBase = Server;
 const ClientBase = Client;
 class CurrentServerHandle extends ServerBase {
@@ -41,7 +41,7 @@ let currentServer;
 let currentClient;
 function owner() {
     if (!ownerPromise) {
-        const resolving = wire.request(["process"]).then(answer => {
+        const resolving = wire.request(["current-process"]).then(answer => {
             return process(answer[0], { server: currentServer, client: currentClient });
         });
         const retained = resolving.catch(error => {
@@ -84,7 +84,7 @@ currentClient = new CurrentClientHandle(owner);
 class ClientCurrent {
     server = currentServer;
     window = currentClient.window;
-    permissions = currentProgramPermissions;
+    permission = currentProgramPermission;
     constructor() {
         bindChannel(this, channel);
     }
@@ -94,7 +94,7 @@ class ClientCurrent {
         return answer[0] ? process(answer[0]) : null;
     }
     async program() {
-        const answer = await wire.request(["program"]);
+        const answer = await wire.request(["current-program"]);
         return program(answer[0]);
     }
     async option(name) {

package/dist/domain.d.ts

@@ -1,4 +1,4 @@
-import { Client as CoreClient, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, type AnswerCapture as CoreAnswerCapture, type AnswerMessage as CoreAnswerMessage, type AnswerObserver as CoreAnswerObserver, type AskCapture as CoreAskCapture, type AskMessage as CoreAskMessage, type AskObserver as CoreAskObserver, type Cleanup, type ClientTraffic as CoreClientTraffic, type ClientDeclaration, type EndpointTraffic as CoreEndpointTraffic, type EndpointDeclaration, type Exit, type Launch, type LocalWindow, type Permissions, type ServerTraffic as CoreServerTraffic, type TrafficMessage as CoreTrafficMessage, type TrafficCapture as CoreTrafficCapture, type TrafficEvents as CoreTrafficEvents, type Window as CoreWindow, type WindowState } from "@phreshos/core";
+import { Client as CoreClient, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, type AnswerCapture as CoreAnswerCapture, type AnswerMessage as CoreAnswerMessage, type AnswerObserver as CoreAnswerObserver, type AskCapture as CoreAskCapture, type AskMessage as CoreAskMessage, type AskObserver as CoreAskObserver, type Cleanup, type ClientTraffic as CoreClientTraffic, type ClientDeclaration, type EndpointTraffic as CoreEndpointTraffic, type EndpointDeclaration, type Exit, type Launch, type LocalWindow, type Permission, type ProgramProcess as CoreProgramProcess, type ServerTraffic as CoreServerTraffic, type TrafficMessage as CoreTrafficMessage, type TrafficCapture as CoreTrafficCapture, type TrafficEvents as CoreTrafficEvents, type Window as CoreWindow, type WindowState } from "@phreshos/core";
 import Events from "./events.js";
 export interface HandleAddress {
     identity: string;
@@ -30,19 +30,24 @@ export interface EndpointReference {
 }
 export type WindowRecord = WindowState;
 /** Program handle visible inside a structurally isolated Client. */
-export type Program<Events extends object = {}> = Omit<CoreProgram<Events>, "processes" | "firstProcess" | "lastProcess" | "getProcess" | "createProcess"> & {
+export type Program<Events extends object = {}> = Omit<CoreProgram<Events>, "process"> & {
     /** Effective permission decisions owned by this Program. */
-    readonly permissions: Permissions;
+    readonly permission: Permission;
+    /** Operations and lifecycle observation for this Program's Processes. */
+    readonly process: ProgramProcess;
+};
+/** Client-visible Process operations scoped to one Program. */
+export type ProgramProcess = Omit<CoreProgramProcess, "list" | "first" | "last" | "find" | "create"> & {
     /** Returns every live Process of this Program visible to the current Client. */
-    processes(): Promise<Process[]>;
+    list(): Promise<Process[]>;
     /** Returns the earliest-started visible live Process, or `null` when none exist. */
-    firstProcess(): Promise<Process | null>;
+    first(): Promise<Process | null>;
     /** Returns the latest-started visible live Process, or `null` when none exist. */
-    lastProcess(): Promise<Process | null>;
+    last(): Promise<Process | null>;
     /** Finds a visible live Process by runtime identity or Program-local name. */
-    getProcess(identityOrName: string): Promise<Process | null>;
+    find(identityOrName: string): Promise<Process | null>;
     /** Creates one Process of this same Program. */
-    createProcess(launch?: Launch): Promise<Process>;
+    create(launch?: Launch): Promise<Process>;
 };
 /** Process handle visible inside a structurally isolated Client. */
 export type Process<Events extends object = {}> = Omit<CoreProcess<Events>, "server" | "client" | "program" | "parent"> & {

package/dist/domain.js

@@ -5,7 +5,7 @@ import HandleRegistry from "./handle-registry.js";
 import { area, sql, store } from "./storage.js";
 import wire from "./wire.js";
 import { endpointService } from "./service.js";
-import { currentProgramPermissions } from "./permissions.js";
+import { currentProgramPermission } from "./permissions.js";
 const handles = new HandleRegistry();
 const ProgramBase = CoreProgram;
 const ProcessBase = CoreProcess;
@@ -19,14 +19,16 @@ class ProgramHandle extends ProgramBase {
     store = store();
     logs = sql("logs");
     database = sql("database");
-    permissions = currentProgramPermissions;
+    permission = currentProgramPermission;
+    process;
     record;
     constructor(record) {
         super();
         this.identity = record.identity;
         this.reference = record.reference;
         this.record = record;
-        bindEvents(this, scoped("host-end", record.reference, programEvent));
+        this.process = new ProgramProcessHandle(record.reference);
+        bindEvents(this, scoped("program-host", record.reference, programEvent));
     }
     get name() { return this.record.name; }
     get version() { return this.record.version; }
@@ -38,24 +40,6 @@ class ProgramHandle extends ProgramBase {
             throw new Error("A Program handle cannot become another Program");
         this.record = record;
     }
-    async processes() {
-        const answer = await wire.request(["processes"]);
-        return answer[0].map(record => process(record));
-    }
-    async firstProcess() {
-        return chronological(await this.processes())[0] ?? null;
-    }
-    async lastProcess() {
-        return chronological(await this.processes()).at(-1) ?? null;
-    }
-    async getProcess(identityOrName) {
-        const answer = await wire.request(["program-process", undefined, identityOrName]);
-        return answer[0] ? process(answer[0]) : null;
-    }
-    async createProcess(launch = {}) {
-        const answer = await wire.request(["create-process", undefined, launch]);
-        return process(answer[0]);
-    }
     async icon(size = "medium") {
         const answer = await wire.request(["icon", size]);
         return new Blob([Uint8Array.from(answer[0])], { type: "image/png" });
@@ -66,8 +50,31 @@ class ProgramHandle extends ProgramBase {
     }
     async uninstall(everything = false) { await wire.request(["uninstall", undefined, everything]); }
     async forget() { await wire.request(["forget"]); }
+}
+class ProgramProcessHandle {
+    constructor(program) {
+        bindEvents(this, scoped("program-process", program, programProcessEvent));
+    }
+    async list() {
+        const answer = await wire.request(["program-process-list"]);
+        return answer[0].map(record => process(record));
+    }
+    async first() {
+        return chronological(await this.list())[0] ?? null;
+    }
+    async last() {
+        return chronological(await this.list()).at(-1) ?? null;
+    }
+    async find(identityOrName) {
+        const answer = await wire.request(["program-process-find", identityOrName]);
+        return answer[0] ? process(answer[0]) : null;
+    }
+    async create(launch = {}) {
+        const answer = await wire.request(["program-process-create", launch]);
+        return process(answer[0]);
+    }
     async exitAll() {
-        const answer = await wire.request(["exit-all"]);
+        const answer = await wire.request(["program-process-exit-all"]);
         return answer[0];
     }
 }
@@ -333,13 +340,16 @@ function unscoped(subject, values) {
         return values;
     return values[0] === subject ? values.slice(1) : null;
 }
-function programEvent(event, values) {
+function programProcessEvent(event, values) {
     if (event === "endpointStart" || event === "endpointStop")
         return lifecycleEndpoint(values[0], values[1]);
-    if (event === "processCreate")
+    if (event === "create")
         return process(values[0]);
-    if (event === "processExit")
+    if (event === "exit")
         return { process: process(values[0]), ...exit(values[1], values[2]) };
+    return undefined;
+}
+function programEvent(event, values) {
     if (event === "uninstall")
         return { everythingRemoved: values[0] === true };
     return undefined;

package/dist/host.d.ts

@@ -1,6 +1,11 @@
-import type { ClientServiceHandler, ServedFile, ServerServiceHandler, Theme, ThemeProperties } from "@phreshos/core";
+import type { ClientServiceHandler, ServedFile, ServerServiceHandler, ServiceKey, Theme, ThemeProperties } from "@phreshos/core";
 import { type HostPointer } from "./pointer.js";
 import { type HostDesktop } from "./desktop.js";
+type ServiceEndpoint = ServiceKey["endpoint"];
+type ServiceAddress<Endpoint extends ServiceEndpoint> = Omit<ServiceKey, "endpoint"> & Readonly<{
+    endpoint: Endpoint;
+}>;
+type ServiceHandle<Endpoint extends ServiceEndpoint, Events extends object> = Endpoint extends "server" ? ServerServiceHandler<Events> : ClientServiceHandler<Events>;
 /** Desktop capabilities structurally available to a Client endpoint. */
 export interface Host {
     /** Read-only system Theme explicitly read from and observed through the desktop host. */
@@ -13,14 +18,21 @@ export interface Host {
     serve(value: unknown): Promise<ServedFile>;
     /** Performs an unrestricted server-side fetch on behalf of this Client. */
     fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    /** Prepares exact public service handles without exposing the service registry. */
+    readonly service: HostService;
+}
+/** Exact public service preparation available to a Client endpoint. */
+export interface HostService {
+    /** Returns a precisely typed stable handle for either service endpoint. */
+    prepare<Endpoint extends ServiceEndpoint, ServiceEvents extends object = {}>(key: ServiceAddress<Endpoint>): ServiceHandle<Endpoint, ServiceEvents>;
     /** Returns a stable handle for one exact Server service identity. */
-    service<ServiceEvents extends object = {}>(key: {
+    prepare<ServiceEvents extends object = {}>(key: {
         program: string;
         endpoint: "server";
         name: string;
     }): ServerServiceHandler<ServiceEvents>;
     /** Returns a stable handle for one exact Client service identity. */
-    service<ServiceEvents extends object = {}>(key: {
+    prepare<ServiceEvents extends object = {}>(key: {
         program: string;
         endpoint: "client";
         name: string;
@@ -28,3 +40,4 @@ export interface Host {
 }
 /** Desktop capabilities available to this Client. */
 export declare const host: Host;
+export {};

package/dist/host.js

@@ -3,11 +3,12 @@ import ClientTheme from "./theme.js";
 import wire from "./wire.js";
 import ClientPointer, {} from "./pointer.js";
 import ClientDesktop, {} from "./desktop.js";
-import { service as serviceHandle } from "./service.js";
+import { prepareService } from "./service.js";
 class ClientHost {
     theme = new ClientTheme();
     desktop = new ClientDesktop();
     pointer = new ClientPointer();
+    service = new ClientHostService();
     async serve(value) {
         const source = content(value);
         const channel = new MessageChannel();
@@ -78,8 +79,10 @@ class ClientHost {
         });
         return response;
     }
-    service(key) {
-        return serviceHandle(key);
+}
+class ClientHostService {
+    prepare(key) {
+        return prepareService(key);
     }
 }
 function requestHeaders(normalized, supplied) {

package/dist/main.d.ts

@@ -1,8 +1,8 @@
-export { host, type Host } from "./host.js";
+export { host, type Host, type HostService } from "./host.js";
 export { type HostPointer, type PointerEvents, type PointerPosition } from "./pointer.js";
 export { type DesktopEvents, type DesktopSize, type HostDesktop } from "./desktop.js";
 export { current, type Current, type CurrentServer } from "./current.js";
 export { type Channel, type ChannelCapture, type ChannelEvents, type ChannelMessage } from "./channel.js";
 export { ClientServiceHandler, ServerServiceHandler, ServiceHandler, type ClientServiceChannel, type ServerServiceChannel, type ServiceChannel, type ServiceKey, type ServiceLifecycleEvents } from "@phreshos/core";
-export { Client, Endpoint, Process, Program, Server, type Window, type AnswerCapture, type AnswerMessage, type AnswerObserver, type AskCapture, type AskMessage, type AskObserver, type ClientTraffic, type EndpointTraffic, type ServerTraffic, type TrafficCapture, type TrafficEvents, type TrafficMessage } from "./domain.js";
-export type { Askable, Capture, Captures, ClientDeclaration, Cleanup, DirectoryStat, EndpointDeclaration, EntryStat, EventMessage, EventName, EventObserver, EventOptions, EventSubscriber, Exit, FileStat, Launch, LaunchClient, Layer, LogKind, LogRecord, LogSource, Message, OtherStat, Outcome, PermissionDecision, Permissions, Position, ProgramArea, ProgramEvents, ProgramProcessExit, ProgramSql, ProgramStore, ProcessEvents, Publishable, ServedFile, Size, Subscribable, SubscribableEvents, SubscribableFallback, TimedAskable, TimedPermissions, Timeoutable, Theme, ThemeEvents, ThemeProperties, Value, WritableTheme, WindowEvents, WindowGeometry, WindowLayer, WindowState, Easing, LocalWindow, LocalWindowSurface, SurfaceSettings, Transaction } from "@phreshos/core";
+export { Client, Endpoint, Process, Program, Server, type Window, type ProgramProcess, type AnswerCapture, type AnswerMessage, type AnswerObserver, type AskCapture, type AskMessage, type AskObserver, type ClientTraffic, type EndpointTraffic, type ServerTraffic, type TrafficCapture, type TrafficEvents, type TrafficMessage } from "./domain.js";
+export type { Askable, Capture, Captures, ClientDeclaration, Cleanup, DirectoryStat, EndpointDeclaration, EntryStat, EventMessage, EventName, EventObserver, EventOptions, EventSubscriber, Exit, FileStat, Launch, LaunchClient, Layer, LogKind, LogRecord, LogSource, Message, OtherStat, Outcome, PermissionDecision, Permission, Position, ProgramArea, ProgramEvents, ProgramProcessEvents, ProgramProcessExit, ProgramSql, ProgramStore, ProcessEvents, Publishable, ServedFile, Size, Subscribable, SubscribableEvents, SubscribableFallback, TimedAskable, TimedPermission, Timeoutable, Theme, ThemeEvents, ThemeProperties, Value, WritableTheme, WindowEvents, WindowGeometry, WindowLayer, WindowState, Easing, LocalWindow, LocalWindowSurface, SurfaceSettings, Transaction } from "@phreshos/core";

package/dist/permissions.d.ts

@@ -1,10 +1,10 @@
-import type { PermissionDecision, PermissionName, Permissions, TimedPermissions } from "@phreshos/core";
+import type { Permission, PermissionDecision, PermissionName, TimedPermission } from "@phreshos/core";
 /** Client access to the current Program's effective permission decisions. */
-export default class ClientPermissions implements Permissions {
+export default class ClientPermission implements Permission {
     granted(name: PermissionName): Promise<PermissionDecision>;
     request(name: PermissionName): Promise<PermissionDecision>;
-    timeout(milliseconds: number): TimedPermissions;
+    timeout(milliseconds: number): TimedPermission;
     private requestWithin;
 }
 /** The one Program-owned permission capability visible in this isolated Client. */
-export declare const currentProgramPermissions: ClientPermissions;
+export declare const currentProgramPermission: ClientPermission;

package/dist/permissions.js

@@ -1,7 +1,7 @@
 import wire from "./wire.js";
 const defaultPermissionTimeout = 30_000;
 /** Client access to the current Program's effective permission decisions. */
-export default class ClientPermissions {
+export default class ClientPermission {
     async granted(name) {
         const answer = await wire.request(["permission-granted", name]);
         return answer[0];
@@ -20,4 +20,4 @@ export default class ClientPermissions {
     }
 }
 /** The one Program-owned permission capability visible in this isolated Client. */
-export const currentProgramPermissions = new ClientPermissions();
+export const currentProgramPermission = new ClientPermission();

package/dist/service.d.ts

@@ -1,12 +1,12 @@
 import { type ClientServiceHandler, type ServerServiceHandler, type ServiceDefinition, type ServiceHandler, type ServiceKey } from "@phreshos/core";
 import type { HandleAddress } from "./domain.js";
-export declare function service<EventsMap extends object = {}>(key: ServiceKey & {
+export declare function prepareService<EventsMap extends object = {}>(key: ServiceKey & {
     endpoint: "server";
 }): ServerServiceHandler<EventsMap>;
-export declare function service<EventsMap extends object = {}>(key: ServiceKey & {
+export declare function prepareService<EventsMap extends object = {}>(key: ServiceKey & {
     endpoint: "client";
 }): ClientServiceHandler<EventsMap>;
-export declare function service(key: ServiceKey): ServiceHandler;
+export declare function prepareService(key: ServiceKey): ServiceHandler;
 export declare function enableCurrentService(definition: ServiceDefinition): Promise<void>;
 export declare function disableCurrentService(): Promise<void>;
 export declare function endpointService<EventsMap extends object = {}>(target: HandleAddress | null, endpoint: "server"): Promise<ServerServiceHandler<EventsMap> | null>;

package/dist/service.js

@@ -46,22 +46,22 @@ class ClientChannelHandle extends Events {
 }
 class ServerHandler extends ServerServiceBase {
     key;
-    program;
-    endpoint = "server";
     name;
     channel;
     constructor(key) {
         super();
         this.key = key;
-        this.program = key.program;
         this.name = key.name;
         this.channel = new ServerChannelHandle(key);
         bindEvents(this, new Events(...serviceEvents(key, "lifecycle")));
     }
-    async disabled() {
-        const answer = await wire.request(["service-disabled", this.key]);
+    async enabled() {
+        const answer = await wire.request(["service-enabled", this.key]);
         return answer[0];
     }
+    async waitReady(timeout) {
+        await wire.request(["service-wait-ready", this.key, timeout], timeout);
+    }
     async docs() {
         const answer = await wire.request(["service-docs", this.key]);
         return answer[0];
@@ -69,24 +69,24 @@ class ServerHandler extends ServerServiceBase {
 }
 class ClientHandler extends ClientServiceBase {
     key;
-    program;
-    endpoint = "client";
     name;
     channel;
     constructor(key) {
         super();
         this.key = key;
-        this.program = key.program;
         this.name = key.name;
         this.channel = new ClientChannelHandle(key);
         bindEvents(this, new Events(...serviceEvents(key, "lifecycle")));
     }
-    async disabled() {
-        const answer = await wire.request(["service-disabled", this.key]);
+    async enabled() {
+        const answer = await wire.request(["service-enabled", this.key]);
         return answer[0];
     }
+    async waitReady(timeout) {
+        await wire.request(["service-wait-ready", this.key, timeout], timeout);
+    }
 }
-export function service(key) {
+export function prepareService(key) {
     if (!isServiceKey(key))
         throw new Error("A complete service key is required");
     const normalized = Object.freeze({ program: key.program, endpoint: key.endpoint, name: key.name });
@@ -105,7 +105,7 @@ export async function disableCurrentService() {
 }
 export async function endpointService(target, endpoint) {
     const answer = await wire.request(["endpoint-service", target, endpoint]);
-    return answer[0] ? service(answer[0]) : null;
+    return answer[0] ? prepareService(answer[0]) : null;
 }
 function serviceEvents(key, scope) {
     return [

package/dist/theme.js

@@ -5,28 +5,14 @@ import wire from "./wire.js";
 export default class ClientTheme extends Events {
     constructor() {
         super((event, listener, impossible) => wire.on("host-theme", event, value => {
-            if (isObject(value))
-                listener(createThemeSnapshot(value));
+            listener(createThemeSnapshot(value));
         }, null, impossible), observer => wire.onAll("host-theme", (event, value) => {
-            if (typeof event === "string" && isObject(value))
+            if (typeof event === "string")
                 observer(event, createThemeSnapshot(value));
         }));
     }
     async snapshot() {
-        const answer = await wire.request(["theme"]);
-        if (!isObject(answer[0]))
-            throw new Error("The desktop returned an invalid Theme snapshot");
-        return createThemeSnapshot(answer[0]);
+        const [theme] = await wire.request(["theme"]);
+        return createThemeSnapshot(theme);
     }
 }
-function isObject(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return false;
-    const theme = value;
-    const surface = theme.surface;
-    return typeof theme.background === "string" && typeof theme.foreground === "string" && typeof theme.accent === "string"
-        && typeof theme.spacing === "number" && typeof theme.radius === "number"
-        && typeof surface === "object" && surface !== null
-        && typeof surface.grain === "number" && typeof surface.animation === "number"
-        && typeof surface.backdrop === "number" && typeof surface.opacity === "number";
-}

package/dist/wire.js

@@ -62,7 +62,7 @@ class Wire {
     /** Resolves this endpoint's Process address only for operations that need it. */
     identity() {
         if (!this.identityPromise) {
-            const resolving = this.request(["process"]).then(value => {
+            const resolving = this.request(["current-process"]).then(value => {
                 const [record] = value;
                 if (typeof record?.identity !== "string" || typeof record.reference !== "string") {
                     throw new Error("The desktop returned an invalid Process identity");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/client",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "The SDK used by a Program's client endpoint.",
   "type": "module",
   "main": "dist/main.js",
@@ -41,18 +41,19 @@
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "check": "tsc --noEmit",
     "build": "node --run clean && tsc --noEmit false --outDir dist --rootDir source",
+    "verify:completions": "node scripts/verify-completions.mjs",
     "verify:package": "node scripts/verify-package.mjs",
-    "verify": "node --run check && node --run build && node --run verify:package",
+    "verify": "node --run check && node --run verify:completions && node --run build && node --run verify:package",
     "prepack": "node --run build"
   },
   "peerDependencies": {
-    "@phreshos/core": "^0.1.8"
+    "@phreshos/core": "^0.1.9"
   },
   "dependencies": {
     "@msgpack/msgpack": "^3.1.3"
   },
   "devDependencies": {
-    "@phreshos/core": "^0.1.8",
+    "@phreshos/core": "^0.1.9",
     "typescript": "^6.0.3"
   }
 }