@plexspaces/sdk 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { PlexSpacesActor, WorkflowActor } from "./actor.js";
+export { decodeWitPayloadUtf8, encodeWitPayloadUtf8 } from "./wit-payload.js";
+export { actor, gen_server_actor, event_actor, fsm_actor, workflow_actor, handler, init_handler, run_handler, signal_handler, query_handler, getActorDefinition, } from "./decorators.js";
+export { Host, ProcessGroups, TupleSpace, host, pgFirst, pgFirstOrThrow, ServiceHttpClient } from "./host.js";
+export { ActorRouter } from "./router.js";
+export { defaultRetryConfig, withRetry, type RetryConfig, } from "./workflow.js";
+export { LeaderWorkerClient, listWorkerNodeIds, } from "./leader_worker.js";
+export { ActorID } from "./actor_id.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2025 PlexSpaces Contributors
+//
+// PlexSpaces TypeScript SDK
+//
+// Build actors with minimal boilerplate via inheritance (mirrors Python SDK's decorators).
+export { PlexSpacesActor, WorkflowActor } from "./actor.js";
+export { decodeWitPayloadUtf8, encodeWitPayloadUtf8 } from "./wit-payload.js";
+export { actor, gen_server_actor, event_actor, fsm_actor, workflow_actor, handler, init_handler, run_handler, signal_handler, query_handler, getActorDefinition, } from "./decorators.js";
+export { Host, ProcessGroups, TupleSpace, host, pgFirst, pgFirstOrThrow, ServiceHttpClient } from "./host.js";
+export { ActorRouter } from "./router.js";
+export { defaultRetryConfig, withRetry, } from "./workflow.js";
+export { LeaderWorkerClient, listWorkerNodeIds, } from "./leader_worker.js";
+export { ActorID } from "./actor_id.js";

package/dist/leader_worker.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Client for leader-worker multi-node patterns. Connect to the entry (leader) node
+ * via HTTP; list worker node IDs and spawn non-virtual actors on specific nodes.
+ * Virtual actors are created lazily on first message—no explicit spawn or ensure.
+ */
+export declare class LeaderWorkerClient {
+    private readonly entryUrl;
+    private readonly nodeIdToHttp;
+    /**
+     * @param entryHttpUrl - Base URL of the entry/leader node (e.g. "http://localhost:8092").
+     */
+    constructor(entryHttpUrl: string);
+    /**
+     * Derive HTTP URL from gRPC node_address (convention: HTTP = gRPC port + 1).
+     */
+    private static grpcPortToHttp;
+    /**
+     * List node IDs that can run workers (peers + self). Populates internal
+     * cache so spawnActorOnNode can resolve nodeId to node HTTP URL.
+     *
+     * @returns List of node_id strings.
+     */
+    listWorkerNodeIds(cluster?: string | null, pageSize?: number, pageToken?: string): Promise<string[]>;
+    /**
+     * Spawn a non-virtual actor on a specific node. The node must be reachable;
+     * call listWorkerNodeIds first so the client can resolve nodeId to URL.
+     *
+     * @returns Actor ref string (e.g. "worker-ulid@node_id").
+     */
+    spawnActorOnNode(nodeId: string, actorType: string, actorId?: string, initialState?: Uint8Array, config?: Record<string, unknown> | null, labels?: Record<string, string> | null): Promise<string>;
+}
+/**
+ * Convenience: list worker node IDs using a one-off client.
+ * For multiple calls or spawnActorOnNode, use LeaderWorkerClient.
+ */
+export declare function listWorkerNodeIds(entryHttpUrl: string, cluster?: string | null, pageSize?: number): Promise<string[]>;

package/dist/leader_worker.js

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2025 PlexSpaces Contributors
+//
+// Leader-worker client for multi-node: same API surface as Rust/Python/Go SDKs.
+// Virtual actors are created lazily on first message; use spawnActorOnNode
+// only for non-virtual workers.
+/**
+ * Client for leader-worker multi-node patterns. Connect to the entry (leader) node
+ * via HTTP; list worker node IDs and spawn non-virtual actors on specific nodes.
+ * Virtual actors are created lazily on first message—no explicit spawn or ensure.
+ */
+export class LeaderWorkerClient {
+    /**
+     * @param entryHttpUrl - Base URL of the entry/leader node (e.g. "http://localhost:8092").
+     */
+    constructor(entryHttpUrl) {
+        this.nodeIdToHttp = new Map();
+        this.entryUrl = entryHttpUrl.replace(/\/$/, "");
+    }
+    /**
+     * Derive HTTP URL from gRPC node_address (convention: HTTP = gRPC port + 1).
+     */
+    static grpcPortToHttp(url) {
+        if (!url)
+            return url;
+        const match = url.trim().match(/:(\d+)\s*$/);
+        if (match) {
+            const port = parseInt(match[1], 10) + 1;
+            return url.trim().replace(/:(\d+)\s*$/, `:${port}`);
+        }
+        return url;
+    }
+    /**
+     * List node IDs that can run workers (peers + self). Populates internal
+     * cache so spawnActorOnNode can resolve nodeId to node HTTP URL.
+     *
+     * @returns List of node_id strings.
+     */
+    async listWorkerNodeIds(cluster, pageSize = 100, pageToken = "") {
+        const params = new URLSearchParams({ pageSize: String(pageSize) });
+        if (cluster)
+            params.set("cluster", cluster);
+        if (pageToken)
+            params.set("pageToken", pageToken);
+        const url = `${this.entryUrl}/api/v1/nodes?${params.toString()}`;
+        const res = await fetch(url, {
+            method: "GET",
+            headers: { Accept: "application/json" },
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`listWorkerNodeIds failed: ${res.status} ${body}`);
+        }
+        const data = (await res.json());
+        const nodes = data.nodes ?? data.nodeRegistrations ?? [];
+        const ids = [];
+        for (const n of nodes) {
+            const nodeId = n.nodeId ?? n.node_id ?? "";
+            const nodeAddress = n.nodeAddress ?? n.node_address ?? "";
+            if (nodeId) {
+                ids.push(nodeId);
+                if (nodeAddress) {
+                    this.nodeIdToHttp.set(nodeId, LeaderWorkerClient.grpcPortToHttp(nodeAddress));
+                }
+            }
+        }
+        return ids;
+    }
+    /**
+     * Spawn a non-virtual actor on a specific node. The node must be reachable;
+     * call listWorkerNodeIds first so the client can resolve nodeId to URL.
+     *
+     * @returns Actor ref string (e.g. "worker-ulid@node_id").
+     */
+    async spawnActorOnNode(nodeId, actorType, actorId = "", initialState = new Uint8Array(0), config, labels) {
+        const nodeHttp = this.nodeIdToHttp.get(nodeId);
+        if (!nodeHttp) {
+            throw new Error(`unknown nodeId "${nodeId}"; call listWorkerNodeIds first`);
+        }
+        const payload = { actorType };
+        if (actorId)
+            payload.actorId = actorId;
+        if (initialState.byteLength > 0) {
+            let binary = "";
+            for (let i = 0; i < initialState.length; i++) {
+                binary += String.fromCharCode(initialState[i]);
+            }
+            payload.initialState = btoa(binary);
+        }
+        if (config != null)
+            payload.config = config;
+        if (labels != null)
+            payload.labels = labels;
+        const body = JSON.stringify(payload);
+        const url = `${nodeHttp.replace(/\/$/, "")}/api/v1/actors/spawn`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "application/json" },
+            body,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`spawnActorOnNode failed: ${res.status} ${text}`);
+        }
+        const out = (await res.json());
+        const actorRef = out.actorRef ?? out.actor_ref ?? "";
+        if (!actorRef)
+            throw new Error("spawnActorOnNode returned empty actorRef");
+        return actorRef;
+    }
+}
+/**
+ * Convenience: list worker node IDs using a one-off client.
+ * For multiple calls or spawnActorOnNode, use LeaderWorkerClient.
+ */
+export async function listWorkerNodeIds(entryHttpUrl, cluster, pageSize = 100) {
+    const client = new LeaderWorkerClient(entryHttpUrl);
+    return client.listWorkerNodeIds(cluster, pageSize);
+}

package/dist/process_groups.d.ts

@@ -0,0 +1,4 @@
+/** Return the first process-group member, or null if the group is empty. */
+export declare function firstGroupMember(members: string[]): string | null;
+/** Return the first process-group member, throwing if the group is empty. */
+export declare function firstGroupMemberOrThrow(group: string, members: string[]): string;

package/dist/process_groups.js

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2025 PlexSpaces Contributors
+/** Return the first process-group member, or null if the group is empty. */
+export function firstGroupMember(members) {
+    return members.length > 0 ? members[0] : null;
+}
+/** Return the first process-group member, throwing if the group is empty. */
+export function firstGroupMemberOrThrow(group, members) {
+    const first = firstGroupMember(members);
+    if (first === null) {
+        throw new Error(`no members in process group '${group}'`);
+    }
+    return first;
+}

package/dist/proto.d.ts

@@ -0,0 +1,33 @@
+export interface RetryConfig {
+    max_attempts?: number;
+    initial_interval_ms?: number;
+    backoff_rate?: number;
+    max_interval_ms?: number;
+    retryable_errors?: string[];
+}
+export interface Facet {
+    type: string;
+    config?: Record<string, string>;
+    priority?: number;
+}
+export interface Message {
+    id?: string;
+    message_type?: string;
+    payload?: Uint8Array | string;
+}
+export interface RequestContext {
+    tenant_id?: string;
+    namespace?: string;
+}
+export interface ErrorDetail {
+    code?: string;
+    message?: string;
+    details?: Record<string, unknown>;
+}
+export interface ActorConfig {
+    max_mailbox_size?: number;
+    enable_persistence?: boolean;
+    actor_groups?: string[];
+    properties?: Record<string, unknown>;
+    config_schema_version?: number;
+}

package/dist/proto.js

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2025 PlexSpaces Contributors
+//
+// Proto-shaped SDK types.
+//
+// The repository can generate richer TypeScript models via `make proto-typescript`,
+// but the SDK itself must still build in environments where those generated files
+// are absent. These interfaces preserve the canonical proto field names so
+// application code stays proto-first at the SDK boundary.
+export {};

package/dist/router.d.ts

@@ -0,0 +1,37 @@
+import { PlexSpacesActor } from "./actor.js";
+/** Factory function that creates an actor instance. */
+type ActorFactory = () => PlexSpacesActor;
+/**
+ * Routes messages to multiple actor types within a single WASM module.
+ *
+ * Register each actor type under its exact class name, which matches what
+ * the framework places in ``config.actor_type``:
+ *
+ *   const router = new ActorRouter({
+ *     "ChatRoomActor":  () => new ChatRoomActor(),
+ *     "RateLimiterActor": () => new RateLimiterActor(),
+ *   });
+ *   export const actor = router;
+ *
+ * For same-class multi-instance dispatch, register under the role name:
+ *
+ *   const router = new ActorRouter({
+ *     "AbstractionsActor": () => new AbstractionsActor(),
+ *     "ephemeral":         () => new AbstractionsActor(),
+ *     "channel":           () => new AbstractionsActor(),
+ *   });
+ */
+export declare class ActorRouter {
+    private readonly factories;
+    private active;
+    constructor(routes: Record<string, ActorFactory>);
+    /** WIT `init(config: payload) -> result<_, actor-error>` */
+    init(configJson: string | Uint8Array | ArrayBuffer | ArrayBufferView): void;
+    /** WIT `handle(...) -> result<payload, actor-error>` */
+    handle(fromActor: string, msgType: string, payloadJson: string | Uint8Array | ArrayBuffer | ArrayBufferView): Uint8Array;
+    /** WIT `get-state() -> result<payload, actor-error>` */
+    getState(): Uint8Array;
+    /** WIT `set-state(state: payload) -> result<_, actor-error>` */
+    setState(stateJson: string | Uint8Array | ArrayBuffer | ArrayBufferView): void;
+}
+export {};

package/dist/router.js

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2025 PlexSpaces Contributors
+//
+// PlexSpaces TypeScript SDK - Multi-Actor Router
+//
+// Routes messages to multiple actor types within a single WASM module.
+//
+// Dispatch rule (matches Python and Go SDKs):
+//   1. config.actor_type — exact lookup (the normal case; always set by the framework).
+//   2. config.role       — exact lookup (same-actor_type multi-instance only,
+//                          e.g. "ephemeral"/"channel" both map to AbstractionsActor).
+//   3. Error — no silent fallback; a missing registration is always a bug.
+import { decodeWitPayloadUtf8, encodeWitPayloadUtf8 } from "./wit-payload.js";
+/**
+ * Routes messages to multiple actor types within a single WASM module.
+ *
+ * Register each actor type under its exact class name, which matches what
+ * the framework places in ``config.actor_type``:
+ *
+ *   const router = new ActorRouter({
+ *     "ChatRoomActor":  () => new ChatRoomActor(),
+ *     "RateLimiterActor": () => new RateLimiterActor(),
+ *   });
+ *   export const actor = router;
+ *
+ * For same-class multi-instance dispatch, register under the role name:
+ *
+ *   const router = new ActorRouter({
+ *     "AbstractionsActor": () => new AbstractionsActor(),
+ *     "ephemeral":         () => new AbstractionsActor(),
+ *     "channel":           () => new AbstractionsActor(),
+ *   });
+ */
+export class ActorRouter {
+    constructor(routes) {
+        this.active = null;
+        this.factories = routes;
+    }
+    /** WIT `init(config: payload) -> result<_, actor-error>` */
+    init(configJson) {
+        const text = decodeWitPayloadUtf8(configJson);
+        const config = text.trim() ? JSON.parse(text) : {};
+        const actorType = config.actor_type || "";
+        const role = config.role || "";
+        // 1. actor_type — exact match (primary dispatch key set by framework)
+        let factory = actorType ? this.factories[actorType] : undefined;
+        // 2. role — exact match (same-actor_type multi-instance only)
+        if (!factory && role) {
+            factory = this.factories[role];
+        }
+        if (!factory) {
+            throw new Error(`ERROR: no actor registered for actor_type='${actorType}' role='${role}'`);
+        }
+        this.active = factory();
+        this.active.init(text);
+    }
+    /** WIT `handle(...) -> result<payload, actor-error>` */
+    handle(fromActor, msgType, payloadJson) {
+        if (!this.active) {
+            return encodeWitPayloadUtf8('{"error":"no active actor (init not called)"}');
+        }
+        return this.active.handle(fromActor, msgType, payloadJson);
+    }
+    /** WIT `get-state() -> result<payload, actor-error>` */
+    getState() {
+        if (!this.active) {
+            return encodeWitPayloadUtf8("{}");
+        }
+        return this.active.getState();
+    }
+    /** WIT `set-state(state: payload) -> result<_, actor-error>` */
+    setState(stateJson) {
+        if (!this.active) {
+            throw new Error("ERROR: no active actor");
+        }
+        this.active.setState(stateJson);
+    }
+}

package/dist/wire/http-fetch-proto-wire.d.ts

@@ -0,0 +1,7 @@
+/** Build HttpFetchRequest: repeated map entry (field 1), body (field 2). */
+export declare function encodeHttpFetchRequestWire(headers: Record<string, string>, body: Uint8Array | null): Uint8Array;
+export declare function decodeHttpFetchResponseWire(data: Uint8Array): {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+};

package/dist/wire/http-fetch-proto-wire.js

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2025 PlexSpaces Contributors
+//
+// Manual protobuf wire for plexspaces.wasm.v1 HttpFetchRequest / HttpFetchResponse.
+// Matches sdks/go/plexspaces/http_fetch_proto_wire.go.
+import { appendLengthDelimited, readLengthDelimited, readVarint, skipField } from './proto-wire-common.js';
+function utf8Valid(bytes) {
+    try {
+        new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function bytesToBase64Sync(bytes) {
+    let bin = '';
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    if (typeof btoa !== 'undefined')
+        return btoa(bin);
+    const Buf = globalThis.Buffer;
+    if (Buf)
+        return Buf.from(bytes).toString('base64');
+    throw new Error('base64 encode unavailable');
+}
+/** Build HttpFetchRequest: repeated map entry (field 1), body (field 2). */
+export function encodeHttpFetchRequestWire(headers, body) {
+    let buf = new Uint8Array(0);
+    const enc = new TextEncoder();
+    for (const [k, v] of Object.entries(headers)) {
+        const kb = new Uint8Array(enc.encode(k));
+        const vb = new Uint8Array(enc.encode(v));
+        let entry = appendLengthDelimited(new Uint8Array(0), 1, kb);
+        entry = appendLengthDelimited(entry, 2, vb);
+        buf = appendLengthDelimited(buf, 1, entry);
+    }
+    const bodyUse = body && body.length > 0 ? new Uint8Array(body) : new Uint8Array(0);
+    buf = appendLengthDelimited(buf, 2, bodyUse);
+    return buf;
+}
+function parseStringStringMapEntry(entry) {
+    let pos = 0;
+    let key = '';
+    let val = '';
+    while (pos < entry.length) {
+        const { value: tag, n: tn } = readVarint(entry, pos);
+        pos += tn;
+        const fn = Number(tag >> 3n);
+        const wt = Number(tag & 7n);
+        if (fn === 1 && wt === 2) {
+            const { slice, nextPos } = readLengthDelimited(entry, pos);
+            pos = nextPos;
+            key = new TextDecoder('utf-8', { fatal: false }).decode(slice);
+        }
+        else if (fn === 2 && wt === 2) {
+            const { slice, nextPos } = readLengthDelimited(entry, pos);
+            pos = nextPos;
+            val = new TextDecoder('utf-8', { fatal: false }).decode(slice);
+        }
+        else {
+            pos = skipField(entry, pos, wt);
+        }
+    }
+    return { key, val };
+}
+export function decodeHttpFetchResponseWire(data) {
+    const out = {
+        status: 0,
+        headers: {},
+        body: '',
+    };
+    let pos = 0;
+    while (pos < data.length) {
+        const { value: tag, n: tn } = readVarint(data, pos);
+        pos += tn;
+        const fn = Number(tag >> 3n);
+        const wt = Number(tag & 7n);
+        if (fn === 1 && wt === 0) {
+            const { value: v, n: m } = readVarint(data, pos);
+            pos += m;
+            out.status = Number(v);
+        }
+        else if (fn === 2 && wt === 2) {
+            const { slice: sl, nextPos } = readLengthDelimited(data, pos);
+            pos = nextPos;
+            const { key, val } = parseStringStringMapEntry(sl);
+            if (key)
+                out.headers[key] = val;
+        }
+        else if (fn === 3 && wt === 2) {
+            const { slice: sl, nextPos } = readLengthDelimited(data, pos);
+            pos = nextPos;
+            out.body = utf8Valid(sl) ? new TextDecoder('utf-8', { fatal: false }).decode(sl) : bytesToBase64Sync(sl);
+        }
+        else {
+            pos = skipField(data, pos, wt);
+        }
+    }
+    return out;
+}

package/dist/wire/proto-wire-common.d.ts

@@ -0,0 +1,18 @@
+/** Append non-negative protobuf varint (field tags, lengths, enums). */
+export declare function appendVarint(buf: Uint8Array, xIn: number): Uint8Array<ArrayBuffer>;
+export declare function appendFixed64LE(buf: Uint8Array, v: number): Uint8Array<ArrayBuffer>;
+export declare function appendLengthDelimited(buf: Uint8Array, fieldNum: number, inner: Uint8Array): Uint8Array<ArrayBuffer>;
+/**
+ * Concatenate byte buffers into a new ArrayBuffer-backed Uint8Array.
+ * Explicit return type avoids TS 5.9+ inferring ArrayBufferLike from subarrays / TextEncoder.
+ */
+export declare function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array<ArrayBuffer>;
+export declare function readVarint(data: Uint8Array, pos: number): {
+    value: bigint;
+    n: number;
+};
+export declare function skipField(data: Uint8Array, pos: number, wireType: number): number;
+export declare function readLengthDelimited(data: Uint8Array, pos: number): {
+    slice: Uint8Array;
+    nextPos: number;
+};

package/dist/wire/proto-wire-common.js

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2025 PlexSpaces Contributors
+//
+// Shared protobuf wire primitives for WASM host payloads.
+// Matches sdks/go/plexspaces/tuplespace_proto_wire.go and http_fetch_proto_wire.go.
+/** Append non-negative protobuf varint (field tags, lengths, enums). */
+export function appendVarint(buf, xIn) {
+    if (!Number.isFinite(xIn) || xIn < 0 || xIn > Number.MAX_SAFE_INTEGER) {
+        throw new Error('appendVarint expects a non-negative safe integer');
+    }
+    let n = BigInt(Math.floor(xIn));
+    const parts = [];
+    while (n >= 0x80n) {
+        parts.push(Number(n & 0xffn) | 0x80);
+        n >>= 7n;
+    }
+    parts.push(Number(n));
+    return concatBytes(buf, new Uint8Array(parts));
+}
+export function appendFixed64LE(buf, v) {
+    const out = new Uint8Array(buf.length + 8);
+    out.set(buf, 0);
+    const view = new DataView(out.buffer, buf.length, 8);
+    view.setFloat64(0, v, true);
+    return out;
+}
+export function appendLengthDelimited(buf, fieldNum, inner) {
+    const tag = BigInt(fieldNum << 3 | 2);
+    let b = appendVarint(buf, Number(tag));
+    b = appendVarint(b, inner.length);
+    return concatBytes(b, inner);
+}
+/**
+ * Concatenate byte buffers into a new ArrayBuffer-backed Uint8Array.
+ * Explicit return type avoids TS 5.9+ inferring ArrayBufferLike from subarrays / TextEncoder.
+ */
+export function concatBytes(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+export function readVarint(data, pos) {
+    let x = 0n;
+    let s = 0n;
+    const orig = pos;
+    for (let i = 0; i < 10; i++) {
+        if (pos >= data.length)
+            throw new Error('varint buffer underflow');
+        const b = data[pos];
+        pos++;
+        if (b < 0x80) {
+            return { value: x | (BigInt(b) << s), n: pos - orig };
+        }
+        x |= BigInt(b & 0x7f) << s;
+        s += 7n;
+    }
+    throw new Error('varint too long');
+}
+export function skipField(data, pos, wireType) {
+    switch (wireType) {
+        case 0: {
+            const { n } = readVarint(data, pos);
+            return pos + n;
+        }
+        case 1:
+            if (pos + 8 > data.length)
+                throw new Error('fixed64 underflow');
+            return pos + 8;
+        case 2: {
+            const { value: ln, n } = readVarint(data, pos);
+            return pos + n + Number(ln);
+        }
+        case 5:
+            if (pos + 4 > data.length)
+                throw new Error('fixed32 underflow');
+            return pos + 4;
+        default:
+            throw new Error(`unknown wire type ${wireType}`);
+    }
+}
+export function readLengthDelimited(data, pos) {
+    const { value: ln, n } = readVarint(data, pos);
+    const start = pos + n;
+    const end = start + Number(ln);
+    if (end > data.length)
+        throw new Error('length-delimited field truncated');
+    const copy = new Uint8Array(end - start);
+    copy.set(data.subarray(start, end));
+    return { slice: copy, nextPos: end };
+}

package/dist/wire/registry-proto-wire.d.ts

@@ -0,0 +1,41 @@
+type WireU8 = Uint8Array<ArrayBuffer>;
+export declare const ObjectType: {
+    readonly UNSPECIFIED: 0;
+    readonly ACTOR: 1;
+    readonly TUPLESPACE: 2;
+    readonly SERVICE: 3;
+    readonly VM: 4;
+    readonly APPLICATION: 5;
+    readonly WORKFLOW: 6;
+    readonly NODE: 7;
+    readonly PROCESS_GROUP: 8;
+};
+export type ObjectTypeValue = typeof ObjectType[keyof typeof ObjectType];
+export interface ObjectRegistration {
+    objectId: string;
+    objectType: string;
+    grpcAddress?: string;
+    objectCategory?: string;
+    tenantId?: string;
+    namespace?: string;
+    capabilities?: string[];
+    labels?: string[];
+    alias?: string;
+    healthStatus?: string;
+}
+export declare function encodeRegisterRequest(reg: ObjectRegistration): WireU8;
+export declare function encodeUnregisterRequest(objectId: string, objectType: number, tenantId?: string, namespace?: string): WireU8;
+export declare function encodeLookupRequest(objectId: string, objectType: number, tenantId?: string, namespace?: string, alias?: string): WireU8;
+export declare function encodeDiscoverRequest(opts: {
+    objectType?: number;
+    objectCategory?: string;
+    tenantId?: string;
+    namespace?: string;
+    capabilities?: string[];
+    labels?: string[];
+    pageSize?: number;
+}): WireU8;
+export declare function encodeHeartbeatRequest(objectId: string, objectType: number, tenantId?: string, namespace?: string): WireU8;
+export declare function decodeLookupResponse(data: Uint8Array): ObjectRegistration | null;
+export declare function decodeDiscoverResponse(data: Uint8Array): ObjectRegistration[];
+export {};