pi-cursor-sdk 0.1.46 → 0.1.48

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 0.1.48 - 2026-06-22
+
+### Fixed
+
+- Bundle Cursor's Node ConnectRPC transport seam with `undici` `7.28.0` so downstream `pi install npm:pi-cursor-sdk` production installs inherit the audited transport dependency instead of npm's root-only `overrides` fix.
+
+## 0.1.47 - 2026-06-22
+
+### Changed
+
+- Update the local pi validation baseline to `@earendil-works/pi-ai`, `@earendil-works/pi-coding-agent`, and `@earendil-works/pi-tui` `0.79.10` after reviewing the Pi 0.79.10 changelog, extension compaction events, provider/package docs, and release workflow.
+
+### Fixed
+
+- Refresh the test event harness for Pi 0.79.10's required `session_before_compact` and `session_compact` `reason` / `willRetry` metadata.
+
 ## 0.1.46 - 2026-06-21
 
 ### Changed

package/README.md

@@ -51,10 +51,10 @@ If pi started without a key, run `/cursor-refresh-models` after `/login` to refr
 ## Requirements
 
 - Node.js 22.19+
-- pi 0.79.9 or newer recommended; pi core peer metadata is intentionally unpinned so newer pi releases are not blocked
+- pi 0.79.10 or newer recommended; pi core peer metadata is intentionally unpinned so newer pi releases are not blocked
 - a Cursor SDK API key saved through `/login`, available as `CURSOR_API_KEY`, or passed with pi's `--api-key`
 
-No global `@cursor/sdk` install is required. This package depends on exact `@cursor/sdk@1.0.19`, so normal package installation brings in the SDK version this extension was built and tested against. It also declares `@connectrpc/connect-node@1.7.0` directly because Cursor SDK 1.0.19 still dynamically loads the Node ConnectRPC transport during local-agent runs. Cursor SDK 1.0.19 removes the older `sqlite3 -> node-gyp@8` dependency chain, so deprecated install warnings for `inflight`, `rimraf`, `glob@7`, `npmlog`, `gauge`, `are-we-there-yet`, and `tar@6` from that chain are no longer expected. This package follows pi package guidance by declaring pi core package peers with `"*"` ranges, so users who update pi before this extension is republished are not blocked by peer metadata. The current recommended and validated pi baseline is 0.79.9 plus Cursor SDK 1.0.19; older pi compatibility paths are best-effort and older Cursor SDK compatibility paths are not maintained.
+No global `@cursor/sdk` install is required. This package depends on exact `@cursor/sdk@1.0.19`, so normal package installation brings in the SDK version this extension was built and tested against. It also declares and bundles `@connectrpc/connect-node@1.7.0` with `undici@7.28.0` because Cursor SDK 1.0.19 still dynamically loads the Node ConnectRPC transport during local-agent runs, and npm dependency consumers do not inherit this package's root-only `overrides`. Cursor SDK 1.0.19 removes the older `sqlite3 -> node-gyp@8` dependency chain, so deprecated install warnings for `inflight`, `rimraf`, `glob@7`, `npmlog`, `gauge`, `are-we-there-yet`, and `tar@6` from that chain are no longer expected. This package follows pi package guidance by declaring pi core package peers with `"*"` ranges, so users who update pi before this extension is republished are not blocked by peer metadata. The current recommended and validated pi baseline is 0.79.10 plus Cursor SDK 1.0.19; older pi compatibility paths are best-effort and older Cursor SDK compatibility paths are not maintained.
 
 ## Install
 

package/docs/cursor-live-smoke-checklist.md

@@ -67,8 +67,8 @@ The replay scan flags only error `toolResult` / error assistant messages with `T
 
 Pass criteria:
 
-- `pi --version` reports pi 0.79.9 for this cutover baseline.
-- `npm ls` shows `@cursor/sdk@1.0.19` and local `@earendil-works/*@0.79.9` packages.
+- `pi --version` reports pi 0.79.10 for this cutover baseline.
+- `npm ls` shows `@cursor/sdk@1.0.19` and local `@earendil-works/*@0.79.10` packages.
 - `cursor/composer-2-5` appears in the model list.
 - No Cursor key or auth token is printed.
 - If neither `~/.pi/agent/auth.json` cursor auth nor `CURSOR_API_KEY` is available, stop and report the live smoke as blocked.
@@ -125,7 +125,7 @@ Observe with `tmux capture-pane -pt "$SESSION"` or attach manually.
 Pass criteria:
 
 - Footer shows `(cursor) composer-2-5`. With `--cursor-no-fast`, Cursor fast mode is off and the Cursor extension status should not show `cursor fast`; ignore unrelated status text from other extensions.
-- The run uses pi 0.79.9 `--session-id` successfully.
+- The run uses pi 0.79.10 `--session-id` successfully.
 - Assistant answer appears correctly.
 - `/session` shows one user and one assistant message for the simple run.
 - Persisted JSONL has one assistant message. If the screen appears duplicated, inspect JSONL before deciding whether it is a rendering bug.
@@ -133,7 +133,7 @@ Pass criteria:
 
 ## 4. Focused visual card/color rendering check
 
-This is the canonical inner-loop visual debug path for Cursor provider/runtime changes. It requires offscreen TUI visual inspection, not only JSONL or code review. Use pi 0.79.9, `@cursor/sdk@1.0.19`, a fresh temporary session dir, Cursor SDK `plan` mode, native replay enabled, and the checked-in visual runner. The runner resolves `pi` by directly walking the parent `PATH`, uses `process.execPath` for Node, and prepends that Node directory for both prereq checks and tmux launches so `#!/usr/bin/env node` shims use the validated Node. The default matrix is native replay only: native replay registration is forced on, settings sources are `none`, the pi bridge is off, overlapping built-in pi tools are not exposed, and inherited Cursor SDK event-debug artifact env is cleared. With `--event-debug`, debug capture writes to a deterministic directory under `VISUAL_DIR`.
+This is the canonical inner-loop visual debug path for Cursor provider/runtime changes. It requires offscreen TUI visual inspection, not only JSONL or code review. Use pi 0.79.10, `@cursor/sdk@1.0.19`, a fresh temporary session dir, Cursor SDK `plan` mode, native replay enabled, and the checked-in visual runner. The runner resolves `pi` by directly walking the parent `PATH`, uses `process.execPath` for Node, and prepends that Node directory for both prereq checks and tmux launches so `#!/usr/bin/env node` shims use the validated Node. The default matrix is native replay only: native replay registration is forced on, settings sources are `none`, the pi bridge is off, overlapping built-in pi tools are not exposed, and inherited Cursor SDK event-debug artifact env is cleared. With `--event-debug`, debug capture writes to a deterministic directory under `VISUAL_DIR`.
 
 ```bash
 VISUAL_DIR="$(mktemp -d /tmp/pi-cursor-sdk-1016-visual.XXXXXX)"

package/docs/cursor-model-ux-spec.md

@@ -15,7 +15,7 @@ Current implementation notes:
 - Cursor status uses one coordinated `ctx.ui.setStatus("cursor", ...)` value for fast and non-default plan mode; the default pi footer remains intact.
 - Installed `@cursor/sdk` user messages accept images, and Cursor models are treated as image-capable; registered input metadata is `text` plus `image`.
 - Image payload forwarding sends images only from the latest user message. If the latest user turn is plain text after an earlier image turn, the transcript keeps an `[image omitted from transcript]` placeholder but no image bytes are sent to Cursor. The prompt explicitly tells Cursor that prior image bytes are unavailable and to ask the user to reattach or describe a prior image when needed. Carrying images forward across turns remains a future product decision because it affects token cost, privacy, stale visual context, and expected multimodal follow-up behavior.
-- Exact `@cursor/sdk@1.0.19` is a package dependency of this extension; users should not need a global SDK install. pi 0.79.9 is the current recommended validation baseline, while published pi core peer dependencies use `"*"` ranges per current pi package guidance. Newer pi versions are allowed to attempt loading this extension before a matching extension release exists; compatibility is best-effort until validated.
+- Exact `@cursor/sdk@1.0.19` is a package dependency of this extension; users should not need a global SDK install. pi 0.79.10 is the current recommended validation baseline, while published pi core peer dependencies use `"*"` ranges per current pi package guidance. Newer pi versions are allowed to attempt loading this extension before a matching extension release exists; compatibility is best-effort until validated.
 - Cursor auth uses pi-native API-key resolution for provider `cursor`: CLI `--api-key`, stored `~/.pi/agent/auth.json` API key from `/login`, then `CURSOR_API_KEY`. The extension config file stores only non-secret Cursor-only state such as fast defaults.
 - Local agents pass `settingSources: ["all"]` by default so Cursor MCP servers, plugin tools, project/user settings, and related Cursor-native capabilities are available. Users can narrow loading with a comma-separated list such as `PI_CURSOR_SETTING_SOURCES=project,user,plugins`, or disable ambient setting sources with `PI_CURSOR_SETTING_SOURCES=none`. The provider suppresses direct Cursor SDK bootstrap stdout/stderr/console noise (including late first-send workspace loading such as hook compatibility warnings) so it does not pollute pi's TUI.
 - On `cursor/*` models, pi-cursor-sdk removes only pi-generated `<project_instructions>` blocks that overlap the effective Cursor `settingSources`: `user` for `~/.pi/agent/AGENTS.md`; `project` for discovered repo/parent `AGENTS.md` and `CLAUDE.md` (verified Cursor behavior: local agents load project `AGENTS.md` and `CLAUDE.md`). `~/.pi/agent/CLAUDE.md` is not removed (Cursor user layer uses `~/.claude/CLAUDE.md`). Blocks are removed by exact pi serialization match from structured `contextFiles` via the `before_agent_start` hook, not in `buildCursorPrompt` sanitization. Suppression is skipped with `-nc`, `PI_CURSOR_SETTING_SOURCES=none`, narrowed sources such as `plugins` that omit the matching layer, or `PI_CURSOR_PRESERVE_PI_AGENTS_MD=1`. Switching away from a Cursor model restores pi's full context block on the next user message.

package/docs/cursor-native-tool-visual-audit.md

@@ -6,7 +6,7 @@ This workflow is the canonical repo path for verifying Cursor SDK tool replay th
 
 Use it before accepting replay-card commits or PRs, and for every Cursor provider/runtime release where TUI card/color behavior could regress. Text logs and JSONL are necessary, but they are not enough when the claim is visual parity: always keep PNGs for the exact prompt, and keep before/after PNGs when reviewing a rendering change.
 
-Current validation baseline: pi 0.79.9, exact `@cursor/sdk@1.0.19`, local validation packages `@earendil-works/pi-ai`, `@earendil-works/pi-coding-agent`, and `@earendil-works/pi-tui` at 0.79.9. Published pi core peer dependencies use `"*"` ranges per current pi package guidance, so newer pi installs can try the extension before a matching validation release exists.
+Current validation baseline: pi 0.79.10, exact `@cursor/sdk@1.0.19`, local validation packages `@earendil-works/pi-ai`, `@earendil-works/pi-coding-agent`, and `@earendil-works/pi-tui` at 0.79.10. Published pi core peer dependencies use `"*"` ranges per current pi package guidance, so newer pi installs can try the extension before a matching validation release exists.
 
 ## Cursor SDK 1.0.17 / pi 0.79.0 cutover visual record
 

package/docs/cursor-testing-lessons.md

@@ -243,7 +243,7 @@ The script writes timestamped artifacts under `--out` (default `/tmp/pi-cursor-s
 
 Stdout prints artifact paths and summary counts only. Raw payloads stay on disk and may contain local paths, project text, tool args/results, or secrets — do not commit or share them.
 
-Hard repo rule: Cursor SDK behavior claims must come from the installed `@cursor/sdk` package and/or https://cursor.com/docs/sdk/typescript, not from memory or ad-hoc probes alone. Current cutover validation targets exact `@cursor/sdk@1.0.19` and pi 0.79.9 local packages.
+Hard repo rule: Cursor SDK behavior claims must come from the installed `@cursor/sdk` package and/or https://cursor.com/docs/sdk/typescript, not from memory or ad-hoc probes alone. Current cutover validation targets exact `@cursor/sdk@1.0.19` and pi 0.79.10 local packages.
 
 ## Pi provider SDK event capture
 

package/node_modules/@connectrpc/connect-node/README.md

@@ -0,0 +1,141 @@
+# @connectrpc/connect-node
+
+Connect is a family of libraries for building and consuming APIs on different languages and platforms, and
+[@connectrpc/connect](https://www.npmjs.com/package/@connectrpc/connect) brings type-safe APIs with Protobuf to
+TypeScript.
+
+`@connectrpc/connect-node` provides the following adapters for Node.js:
+
+### createConnectTransport()
+
+Lets your clients running on Node.js talk to a server with the Connect protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createConnectTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the Connect protocol with Node.js `http` module
++ const transport = createConnectTransport({
++   baseUrl: "https://demo.connectrpc.com",
++   httpVersion: "1.1"
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### createGrpcTransport()
+
+Lets your clients running on Node.js talk to a server with the gRPC protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createGrpcTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the gRPC protocol with Node.js `http2` module
++ const transport = createGrpcTransport({
++   baseUrl: "https://demo.connectrpc.com",
++   httpVersion: "2"
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### createGrpcWebTransport()
+
+Lets your clients running on Node.js talk to a server with the gRPC-web protocol:
+
+```diff
+import { createClient } from "@connectrpc/connect";
++ import { createGrpcWebTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
++ // A transport for clients using the Connect protocol with Node.js `http` module
++ const transport = createGrpcWebTransport({
++   baseUrl: "https://demo.connectrpc.com",
++   httpVersion: "1.1"
++ });
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence) // you said: I feel happy.
+```
+
+### connectNodeAdapter()
+
+Run your Connect RPCs on the Node.js `http`, `https`, or `http2` modules.
+
+```ts
+// connect.ts
+import { ConnectRouter } from "@connectrpc/connect";
+
+export default function (router: ConnectRouter) {
+  // implement rpc Say(SayRequest) returns (SayResponse)
+  router.rpc(ElizaService, ElizaService.methods.say, async (req) => ({
+    sentence: `you said: ${req.sentence}`,
+  }));
+}
+```
+
+```diff
+// server.ts
+import * as http2 from "http2";
++ import routes from "connect";
++ import { connectNodeAdapter } from "@connectrpc/connect-node";
+
+http2.createServer(
++ connectNodeAdapter({ routes }) // responds with 404 for other requests
+).listen(8080);
+```
+
+With that server running, you can make requests with any gRPC, gRPC-Web, or Connect client.
+
+`buf curl` with the gRPC protocol:
+
+```bash
+buf curl --schema buf.build/connectrpc/eliza \
+  --protocol grpc --http2-prior-knowledge \
+  -d '{"sentence": "I feel happy."}' \
+  http://localhost:8080/connectrpc.eliza.v1.ElizaService/Say
+```
+
+`curl` with the Connect protocol:
+
+```bash
+curl \
+    --header "Content-Type: application/json" \
+    --data '{"sentence": "I feel happy."}' \
+     --http2-prior-knowledge \
+    http://localhost:8080/connectrpc.eliza.v1.ElizaService/Say
+```
+
+Node.js with the gRPC protocol:
+
+```ts
+import { createClient } from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+import { ElizaService } from "./gen/eliza_connect.js";
+
+const transport = createGrpcTransport({
+  baseUrl: "http://localhost:8080",
+  httpVersion: "2",
+});
+
+const client = createClient(ElizaService, transport);
+const { sentence } = await client.say({ sentence: "I feel happy." });
+console.log(sentence); // you said: I feel happy.
+```
+
+A client for the web browser actually looks identical to this example - it would
+simply use `createConnectTransport` from [@connectrpc/connect-web](https://www.npmjs.com/package/@connectrpc/connect-web)
+instead.
+
+## Getting started
+
+To get started with Connect, head over to the [docs](https://connectrpc.com/docs/node/getting-started)
+for a tutorial, or take a look at [our example](https://github.com/connectrpc/connect-es/tree/main/packages/example).

package/node_modules/@connectrpc/connect-node/dist/cjs/compression.d.ts

@@ -0,0 +1,15 @@
+import type { Compression } from "@connectrpc/connect/protocol";
+/**
+ * The gzip compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+export declare const compressionGzip: Compression;
+/**
+ * The brotli compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+export declare const compressionBrotli: Compression;

package/node_modules/@connectrpc/connect-node/dist/cjs/compression.js

@@ -0,0 +1,89 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressionBrotli = exports.compressionGzip = void 0;
+const zlib = require("zlib");
+const util_1 = require("util");
+const connect_1 = require("@connectrpc/connect");
+const node_error_js_1 = require("./node-error.js");
+const gzip = (0, util_1.promisify)(zlib.gzip);
+const gunzip = (0, util_1.promisify)(zlib.gunzip);
+const brotliCompress = (0, util_1.promisify)(zlib.brotliCompress);
+const brotliDecompress = (0, util_1.promisify)(zlib.brotliDecompress);
+/**
+ * The gzip compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+exports.compressionGzip = {
+    name: "gzip",
+    compress(bytes) {
+        return gzip(bytes, {});
+    },
+    decompress(bytes, readMaxBytes) {
+        if (bytes.length == 0) {
+            return Promise.resolve(new Uint8Array(0));
+        }
+        return wrapZLibErrors(gunzip(bytes, {
+            maxOutputLength: readMaxBytes,
+        }), readMaxBytes);
+    },
+};
+/**
+ * The brotli compression algorithm, implemented with the Node.js built-in module
+ * zlib. This value can be used for the `sendCompression` and `acceptCompression`
+ * option of client transports, or for the `acceptCompression` option of server
+ * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
+ */
+exports.compressionBrotli = {
+    name: "br",
+    compress(bytes) {
+        return brotliCompress(bytes, {});
+    },
+    decompress(bytes, readMaxBytes) {
+        if (bytes.length == 0) {
+            return Promise.resolve(new Uint8Array(0));
+        }
+        return wrapZLibErrors(brotliDecompress(bytes, {
+            maxOutputLength: readMaxBytes,
+        }), readMaxBytes);
+    },
+};
+function wrapZLibErrors(promise, readMaxBytes) {
+    return promise.catch((e) => {
+        const props = (0, node_error_js_1.getNodeErrorProps)(e);
+        let code = connect_1.Code.Internal;
+        let message = "decompression failed";
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (props.code) {
+            case "ERR_BUFFER_TOO_LARGE":
+                code = connect_1.Code.ResourceExhausted;
+                message = `message is larger than configured readMaxBytes ${readMaxBytes} after decompression`;
+                break;
+            case "Z_DATA_ERROR":
+            case "ERR_PADDING_2":
+                code = connect_1.Code.InvalidArgument;
+                break;
+            default:
+                if (props.code !== undefined &&
+                    props.code.startsWith("ERR__ERROR_FORMAT_")) {
+                    code = connect_1.Code.InvalidArgument;
+                }
+                break;
+        }
+        return Promise.reject(new connect_1.ConnectError(message, code, undefined, undefined, e));
+    });
+}

package/node_modules/@connectrpc/connect-node/dist/cjs/connect-node-adapter.d.ts

@@ -0,0 +1,42 @@
+import type { ConnectRouter, ConnectRouterOptions, ContextValues } from "@connectrpc/connect";
+import type { NodeHandlerFn, NodeServerRequest } from "./node-universal-handler.js";
+export interface ConnectNodeAdapterOptions extends ConnectRouterOptions {
+    /**
+     * Route definitions. We recommend the following pattern:
+     *
+     * Create a file `connect.ts` with a default export such as this:
+     *
+     * ```ts
+     * import {ConnectRouter} from "@connectrpc/connect";
+     *
+     * export default (router: ConnectRouter) => {
+     *   router.service(ElizaService, {});
+     * }
+     * ```
+     *
+     * Then pass this function here.
+     */
+    routes: (router: ConnectRouter) => void;
+    /**
+     * If none of the handler request paths match, a 404 is served. This option
+     * can provide a custom fallback for this case.
+     */
+    fallback?: NodeHandlerFn;
+    /**
+     * Serve all handlers under this prefix. For example, the prefix "/something"
+     * will serve the RPC foo.FooService/Bar under "/something/foo.FooService/Bar".
+     * Note that many gRPC client implementations do not allow for prefixes.
+     */
+    requestPathPrefix?: string;
+    /**
+     * Context values to extract from the request. These values are passed to
+     * the handlers.
+     */
+    contextValues?: (req: NodeServerRequest) => ContextValues;
+}
+/**
+ * Create a Node.js request handler from a ConnectRouter.
+ *
+ * The returned function is compatible with http.RequestListener and its equivalent for http2.
+ */
+export declare function connectNodeAdapter(options: ConnectNodeAdapterOptions): NodeHandlerFn;

package/node_modules/@connectrpc/connect-node/dist/cjs/connect-node-adapter.js

@@ -0,0 +1,61 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectNodeAdapter = connectNodeAdapter;
+const connect_1 = require("@connectrpc/connect");
+const protocol_1 = require("@connectrpc/connect/protocol");
+const node_universal_handler_js_1 = require("./node-universal-handler.js");
+const compression_js_1 = require("./compression.js");
+/**
+ * Create a Node.js request handler from a ConnectRouter.
+ *
+ * The returned function is compatible with http.RequestListener and its equivalent for http2.
+ */
+function connectNodeAdapter(options) {
+    var _a;
+    if (options.acceptCompression === undefined) {
+        options.acceptCompression = [compression_js_1.compressionGzip, compression_js_1.compressionBrotli];
+    }
+    const router = (0, connect_1.createConnectRouter)(options);
+    options.routes(router);
+    const prefix = (_a = options.requestPathPrefix) !== null && _a !== void 0 ? _a : "";
+    const paths = new Map();
+    for (const uHandler of router.handlers) {
+        paths.set(prefix + uHandler.requestPath, uHandler);
+    }
+    return function nodeRequestHandler(req, res) {
+        var _a, _b, _c, _d;
+        // Strip the query parameter when matching paths.
+        const uHandler = paths.get((_b = (_a = req.url) === null || _a === void 0 ? void 0 : _a.split("?", 2)[0]) !== null && _b !== void 0 ? _b : "");
+        if (!uHandler) {
+            ((_c = options.fallback) !== null && _c !== void 0 ? _c : fallback)(req, res);
+            return;
+        }
+        const uReq = (0, node_universal_handler_js_1.universalRequestFromNodeRequest)(req, res, undefined, (_d = options.contextValues) === null || _d === void 0 ? void 0 : _d.call(options, req));
+        uHandler(uReq)
+            .then((uRes) => (0, node_universal_handler_js_1.universalResponseToNodeResponse)(uRes, res))
+            .catch((reason) => {
+            if (connect_1.ConnectError.from(reason).code == connect_1.Code.Aborted) {
+                return;
+            }
+            // eslint-disable-next-line no-console
+            console.error(`handler for rpc ${uHandler.method.name} of ${uHandler.service.typeName} failed`, reason);
+        });
+    };
+}
+const fallback = (request, response) => {
+    response.writeHead(protocol_1.uResponseNotFound.status);
+    response.end();
+};

package/node_modules/@connectrpc/connect-node/dist/cjs/connect-transport.d.ts

@@ -0,0 +1,100 @@
+import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
+import type { Interceptor, Transport } from "@connectrpc/connect";
+import type { Compression } from "@connectrpc/connect/protocol";
+import type { NodeTransportOptions } from "./node-transport-options.js";
+/**
+ * Options used to configure the Connect transport.
+ *
+ * See createConnectTransport().
+ */
+export type ConnectTransportOptions = NodeTransportOptions & {
+    /**
+     * Base URI for all HTTP requests.
+     *
+     * Requests will be made to <baseUrl>/<package>.<service>/method
+     *
+     * Example: `baseUrl: "https://example.com/my-api"`
+     *
+     * This will make a `POST /my-api/my_package.MyService/Foo` to
+     * `example.com` via HTTPS.
+     */
+    baseUrl: string;
+    /**
+     * By default, connect-node clients use the binary format.
+     */
+    useBinaryFormat?: boolean;
+    /**
+     * Interceptors that should be applied to all calls running through
+     * this transport. See the Interceptor type for details.
+     */
+    interceptors?: Interceptor[];
+    /**
+     * Options for the JSON format.
+     * By default, unknown fields are ignored.
+     */
+    jsonOptions?: Partial<JsonReadOptions & JsonWriteOptions>;
+    /**
+     * Options for the binary wire format.
+     */
+    binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>;
+    /**
+     * Compression algorithms available to a client. Clients ask servers to
+     * compress responses using any of the registered algorithms. The first
+     * registered algorithm is the most preferred.
+     *
+     * It is safe to use this option liberally: servers will ignore any
+     * compression algorithms they don't support. To compress requests, pair this
+     * option with `sendCompression`.
+     *
+     * If this option is not provided, the compression algorithms "gzip" and "br"
+     * (Brotli) are accepted. To opt out of response compression, pass an
+     * empty array.
+     */
+    acceptCompression?: Compression[];
+    /**
+     * Configures the client to use the specified algorithm to compress request
+     * messages.
+     *
+     * Because some servers don't support compression, clients default to sending
+     * uncompressed requests.
+     */
+    sendCompression?: Compression;
+    /**
+     * Sets a minimum size threshold for compression: Messages that are smaller
+     * than the configured minimum are sent uncompressed.
+     *
+     * The default value is 1 kibibyte, because the CPU cost of compressing very
+     * small messages usually isn't worth the small reduction in network I/O.
+     */
+    compressMinBytes?: number;
+    /**
+     * Limits the performance impact of pathologically large messages sent by the
+     * server. Limits apply to each individual message, not to the stream as a
+     * whole.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    readMaxBytes?: number;
+    /**
+     * Prevents sending messages too large for the server to handle.
+     *
+     * The default limit is the maximum supported value of ~4GiB.
+     */
+    writeMaxBytes?: number;
+    /**
+     * Controls whether or not Connect GET requests should be used when
+     * available, on side-effect free methods. Defaults to false.
+     */
+    useHttpGet?: boolean;
+    /**
+     * The timeout in milliseconds to apply to all requests.
+     *
+     * This can be overridden on a per-request basis by passing a timeoutMs.
+     */
+    defaultTimeoutMs?: number;
+};
+/**
+ * Create a Transport for the Connect protocol using the Node.js `http`, `http2`,
+ * or `http2` module.
+ */
+export declare function createConnectTransport(options: ConnectTransportOptions): Transport;

package/node_modules/@connectrpc/connect-node/dist/cjs/connect-transport.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright 2021-2024 The Connect Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnectTransport = createConnectTransport;
+const protocol_connect_1 = require("@connectrpc/connect/protocol-connect");
+const node_transport_options_js_1 = require("./node-transport-options.js");
+/**
+ * Create a Transport for the Connect protocol using the Node.js `http`, `http2`,
+ * or `http2` module.
+ */
+function createConnectTransport(options) {
+    return (0, protocol_connect_1.createTransport)((0, node_transport_options_js_1.validateNodeTransportOptions)(options));
+}