@projectqai/proto 0.0.26 → 0.0.29

package/device.ts

@@ -1,5 +1,6 @@
 import { createClient, type Client, ConnectError, Code } from "@connectrpc/connect";
-import { createGrpcTransport } from "@connectrpc/connect-node";
+import { createTransport } from "@connectrpc/connect/protocol-connect";
+import type { UniversalClientFn } from "@connectrpc/connect/protocol";
 import { create, clone } from "@bufbuild/protobuf";
 import {
 	WorldService,
@@ -37,9 +38,72 @@ export {
 	type Entity,
 } from "./dist/world_pb.js";
 
+// fetch-based universal HTTP client for the Connect protocol.
+// Works in Node, Bun, browsers, and goja — no http2 dependency.
+const universalFetch: UniversalClientFn = async (req) => {
+	const body = req.body ? await collectBytes(req.body) : undefined;
+	// Prevent the server from gzip-encoding responses — the Connect
+	// transport handles its own compression negotiation.
+	req.header.set("Accept-Encoding", "identity");
+	const resp = await fetch(req.url, {
+		method: req.method,
+		headers: req.header,
+		body,
+		signal: (req as any).signal,
+	});
+	return {
+		status: resp.status,
+		header: resp.headers,
+		body: responseBodyStream(resp),
+		trailer: new Headers(),
+	};
+};
+
+async function collectBytes(iter: AsyncIterable<Uint8Array>): Promise<Uint8Array> {
+	const chunks: Uint8Array[] = [];
+	for await (const value of iter) {
+		chunks.push(value);
+	}
+	const len = chunks.reduce((n, c) => n + c.length, 0);
+	const out = new Uint8Array(len);
+	let off = 0;
+	for (const c of chunks) { out.set(c, off); off += c.length; }
+	return out;
+}
+
+function responseBodyStream(resp: Response): AsyncIterable<Uint8Array> {
+	if (!resp.body) return { [Symbol.asyncIterator]() { return { next: () => Promise.resolve({ done: true as const, value: undefined }), throw: () => Promise.resolve({ done: true as const, value: undefined }) }; } };
+	const reader = resp.body.getReader();
+	return {
+		[Symbol.asyncIterator]() {
+			return {
+				async next() {
+					const { done, value } = await reader.read();
+					if (done) { reader.releaseLock(); return { done: true as const, value: undefined }; }
+					return { done: false as const, value };
+				},
+				async throw(e: unknown) {
+					reader.releaseLock();
+					return { done: true as const, value: undefined };
+				},
+			};
+		}
+	};
+}
+
 export function connect(serverURL?: string): WorldClient {
 	const base = serverURL ?? process.env.HYDRIS_SERVER ?? "http://localhost:50051";
-	const transport = createGrpcTransport({ baseUrl: base, httpVersion: "2" });
+	const transport = createTransport({
+		baseUrl: base,
+		httpClient: universalFetch,
+		useBinaryFormat: true,
+		interceptors: [],
+		acceptCompression: [],
+		sendCompression: null,
+		compressMinBytes: Number.MAX_SAFE_INTEGER,
+		readMaxBytes: Number.MAX_SAFE_INTEGER,
+		writeMaxBytes: Number.MAX_SAFE_INTEGER,
+	});
 	return createClient(WorldService, transport);
 }
 
@@ -83,6 +147,7 @@ export interface AttachOptions<S extends SchemaProperties> {
 	device?: { category?: string };
 	icon?: string;
 	schema: S;
+	init?: (client: WorldClient, config: InferConfig<S>, signal: AbortSignal) => Promise<void>;
 	run: (client: WorldClient, config: InferConfig<S>, signal: AbortSignal) => Promise<void>;
 	health?: () => HealthResult | Promise<HealthResult>;
 	interval?: number;
@@ -138,10 +203,13 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 
 	let heartbeatId: ReturnType<typeof setInterval> | null = null;
 
+	let initialized = false;
+
 	const pushHeartbeat = (result?: Record<number, { label: string; value: number | bigint }>) => {
+		const state = initialized ? DeviceState.DeviceStateActive : DeviceState.DeviceStatePending;
 		const e = create(EntitySchema, {
 			id: entityID,
-			device: create(DeviceComponentSchema, { ...entity.device, state: DeviceState.DeviceStateActive }),
+			device: create(DeviceComponentSchema, { ...entity.device, state }),
 			lifetime: create(LifetimeSchema, {
 				until: create(TimestampSchema, { seconds: BigInt(Math.floor((Date.now() + interval + 1_000) / 1000)) }),
 			}),
@@ -177,7 +245,7 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 			: create(ConfigurableComponentSchema);
 		cfg.state = state;
 		cfg.error = error;
-		if (entity.config && state === ConfigurableState.ConfigurableStateActive) {
+		if (entity.config && (state === ConfigurableState.ConfigurableStateStarting || state === ConfigurableState.ConfigurableStateActive)) {
 			cfg.appliedVersion = entity.config.version;
 		}
 		await push(client, create(EntitySchema, { id: entityID, configurable: cfg })).catch(() => { });
@@ -193,6 +261,7 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 			runningAbort.abort();
 			runningAbort = null;
 			currentEntity = null;
+			initialized = false;
 			console.log(`stopped entity=${entityID}`);
 			if (e) pushState(e, ConfigurableState.ConfigurableStateInactive);
 		}
@@ -206,6 +275,18 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 		(async () => {
 			while (!childSignal.aborted) {
 				await pushState(e, ConfigurableState.ConfigurableStateStarting);
+
+				try {
+					if (opts.init) await opts.init(client, extractConfig(e, opts.schema), childSignal);
+				} catch (err) {
+					if (childSignal.aborted || isCanceled(err)) return;
+					console.error(`init failed entity=${entityID}`, err);
+					await pushState(e, ConfigurableState.ConfigurableStateFailed, String(err));
+					await sleep(5_000, childSignal);
+					continue;
+				}
+
+				initialized = true;
 				await pushState(e, ConfigurableState.ConfigurableStateActive);
 
 				try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectqai/proto",
-  "version": "0.0.26",
+  "version": "0.0.29",
   "author": "projectq-release-bot",
   "type": "module",
   "exports": {
@@ -23,8 +23,7 @@
     "@bufbuild/protobuf": "^2.10.1"
   },
   "dependencies": {
-    "@connectrpc/connect": "^2.0.0",
-    "@connectrpc/connect-node": "^2.0.0"
+    "@connectrpc/connect": "^2.0.0"
   },
   "devDependencies": {
     "@bufbuild/protoc-gen-es": "^2.10.1"