@rebasepro/server-postgresql 0.1.0 → 0.2.1

package/test/data-transformer.test.ts

@@ -172,4 +172,47 @@ path: "authors" }
             expect(serializePropertyToServer(false, boolProp)).toBe(false);
         });
     });
+
+    // ── Vector property ──
+    describe("vector property", () => {
+        const vectorProp: Property = { type: "vector", dimensions: 3 } as Property;
+
+        it("should serialize a Vector instance to a flat array", () => {
+            const vectorVal = { __type: "Vector", value: [1.5, -2.0, 3.14] };
+            expect(serializePropertyToServer(vectorVal, vectorProp)).toEqual([1.5, -2.0, 3.14]);
+        });
+
+        it("should serialize a raw number array to a flat array", () => {
+            expect(serializePropertyToServer([0.5, 0.6, 0.7], vectorProp)).toEqual([0.5, 0.6, 0.7]);
+        });
+
+        it("should return null for null values", () => {
+            expect(serializePropertyToServer(null, vectorProp)).toBeNull();
+        });
+
+        it("should return undefined for undefined values", () => {
+            expect(serializePropertyToServer(undefined, vectorProp)).toBeUndefined();
+        });
+    });
+
+    // ── Binary property ──
+    describe("binary property", () => {
+        const binaryProp: Property = { type: "binary" } as Property;
+
+        it("should serialize a base64 data URL to a Buffer", () => {
+            const base64Data = "data:application/octet-stream;base64,aGVsbG8=";
+            const result = serializePropertyToServer(base64Data, binaryProp);
+            expect(Buffer.isBuffer(result)).toBe(true);
+            expect((result as Buffer).toString("utf8")).toBe("hello");
+        });
+
+        it("should pass through a Buffer as-is", () => {
+            const buffer = Buffer.from("world");
+            expect(serializePropertyToServer(buffer, binaryProp)).toBe(buffer);
+        });
+
+        it("should return null for null values", () => {
+            expect(serializePropertyToServer(null, binaryProp)).toBeNull();
+        });
+    });
 });

package/test/generate-drizzle-schema.test.ts

@@ -116,6 +116,8 @@ relationName: "tags" }
         expect(cleanResult).toContain("tag_id: varchar(\"tag_id\").notNull().references(() => tags.id, { onDelete: \"cascade\" })");
         expect(cleanResult).toContain("(table) => ({ pk: primaryKey({ columns: [table.post_id, table.tag_id] }) })");
         expect(cleanResult).toContain("export const postsRelations = drizzleRelations(posts, ({ one, many }) => ({ \"tags\": many(postsToTags, { relationName: \"tags\" }) }));");
+        const expectedJunctionRelations = "export const postsToTagsRelations = drizzleRelations(postsToTags, ({ one, many }) => ({ \"post_id\": one(posts, { fields: [postsToTags.post_id], references: [posts.id], relationName: \"tags\" }), \"tag_id\": one(tags, { fields: [postsToTags.tag_id], references: [tags.id], relationName: \"posts_to_tags_tag_id\" }) }));";
+        expect(cleanResult).toContain(cleanSchema(expectedJunctionRelations));
     });
 
     describe("generateDrizzleSchema Column Types", () => {
@@ -391,7 +393,7 @@ ownerField: "user_id" }
             expect(result).toContain("pgPolicy");
             expect(result).toContain('as: "permissive"');
             expect(result).toContain('for: "all"');
-            expect(result).toContain("${table.user_id} = auth.uid()");
+            expect(result).toContain("user_id = auth.uid()");
             // 'all' needs both using and withCheck
             expect(result).toContain("using:");
             expect(result).toContain("withCheck:");
@@ -565,7 +567,7 @@ using: "{is_locked} = false" }
 
             const result = await generateSchema(collections);
             expect(result).toContain('as: "restrictive"');
-            expect(result).toContain("${table.is_locked} = false");
+            expect(result).toContain("is_locked = false");
         });
 
         it("should generate raw SQL using clause with column references", async () => {
@@ -584,7 +586,7 @@ using: "{published_at} > now() - interval '30 days'" }
             }];
 
             const result = await generateSchema(collections);
-            expect(result).toContain("${table.published_at} > now() - interval '30 days'");
+            expect(result).toContain("published_at > now() - interval '30 days'");
         });
 
         it("should generate raw SQL withCheck clause", async () => {
@@ -609,8 +611,8 @@ using: "{published_at} > now() - interval '30 days'" }
             const result = await generateSchema(collections);
             expect(result).toContain("using:");
             expect(result).toContain("withCheck:");
-            expect(result).toContain("${table.user_id} = auth.uid()");
-            expect(result).toContain("${table.status} != 'archived'");
+            expect(result).toContain("user_id = auth.uid()");
+            expect(result).toContain("status != 'archived'");
         });
 
         it("should use custom policy names when provided", async () => {

package/test/introspect-db-utils.test.ts

@@ -200,10 +200,13 @@ describe("mapPgType", () => {
         expect(mapPgType("_text")).toBe("array");
     });
     it("maps string-like types to string", () => {
-        for (const t of ["text", "varchar", "character varying", "char", "character", "uuid", "bytea", "inet", "cidr", "macaddr", "macaddr8", "interval"]) {
+        for (const t of ["text", "varchar", "character varying", "char", "character", "uuid", "inet", "cidr", "macaddr", "macaddr8", "interval"]) {
             expect(mapPgType(t)).toBe("string");
         }
     });
+    it("maps bytea to binary", () => {
+        expect(mapPgType("bytea")).toBe("binary");
+    });
     it("defaults unknown types to string", () => {
         expect(mapPgType("tsvector")).toBe("string");
         expect(mapPgType("xml")).toBe("string");

package/test/postgresDataDriver.test.ts

@@ -644,5 +644,22 @@ status: "new" });
             expect(mockRealtimeService.notifyEntityUpdate).toHaveBeenNthCalledWith(2, "call-2", "2", {}, undefined);
         });
     });
+
+    describe("PostgresBackendDriver Admin operations", () => {
+        it("fetchAvailableRoles should query roles filtered by current user membership", async () => {
+            const executeSqlSpy = jest.spyOn(delegate, "executeSql").mockResolvedValueOnce([
+                { rolname: "demo" },
+                { rolname: "cloudsqlsuperuser" }
+            ]);
+
+            const result = await delegate.fetchAvailableRoles();
+
+            expect(executeSqlSpy).toHaveBeenCalledWith(
+                "SELECT rolname FROM pg_roles WHERE pg_has_role(current_user, rolname, 'member') ORDER BY rolname;"
+            );
+            expect(result).toEqual(["demo", "cloudsqlsuperuser"]);
+            executeSqlSpy.mockRestore();
+        });
+    });
 });
 

package/test/realtimeService.test.ts

@@ -3,12 +3,13 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { PostgresCollectionRegistry } from "../src/collections/PostgresCollectionRegistry";
 import { EntityCollection } from "@rebasepro/types";
 
+const mockFetchCollection = jest.fn().mockResolvedValue([{ id: 1, path: "posts", values: { title: "Refetched Title" } }]);
+const mockFetchEntity = jest.fn().mockResolvedValue({ id: 1, path: "posts", values: { title: "Refetched Entity Title" } });
+
 jest.mock("../src/services/entityService", () => ({
     EntityService: jest.fn().mockImplementation(() => ({
-        fetchCollection: jest.fn().mockResolvedValue([{ id: 1,
-_rebase_invalidated: false }]),
-        fetchEntity: jest.fn().mockResolvedValue({ id: 1,
-_rebase_invalidated: false }),
+        fetchCollection: mockFetchCollection,
+        fetchEntity: mockFetchEntity,
         searchEntities: jest.fn().mockResolvedValue([])
     }))
 }));
@@ -134,7 +135,7 @@ values: { _rebase_invalidated: true } } as any;
             await Promise.resolve();
 
             // It should fetch the collection with auth
-            expect(mockDriver.fetchCollection).toHaveBeenCalled();
+            expect(mockFetchCollection).toHaveBeenCalled();
 
             // It should send the refetched data
             expect(ws.send).toHaveBeenCalled();
@@ -207,8 +208,7 @@ values: { _rebase_invalidated: true } } as any;
             await Promise.resolve();
 
             // It should fetch the single entity
-            expect(mockDriver.fetchEntity).toHaveBeenCalledWith(expect.objectContaining({ path: "posts",
-entityId: "1" }));
+            expect(mockFetchEntity).toHaveBeenCalledWith("posts", "1", undefined);
 
             // It should send entity update
             expect(ws.send).toHaveBeenCalled();

package/test/websocket.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, jest, beforeEach } from "@jest/globals";
+import { WebSocket, WebSocketServer } from "ws";
+import { Server } from "http";
+
+let mockWssInstance: any = null;
+
+jest.mock("ws", () => {
+    return {
+        WebSocketServer: jest.fn().mockImplementation(() => {
+            const instance = {
+                on: jest.fn()
+            };
+            mockWssInstance = instance;
+            return instance;
+        }),
+        WebSocket: jest.fn()
+    };
+});
+
+jest.mock("@rebasepro/server-core", () => {
+    return {
+        extractUserFromToken: jest.fn().mockReturnValue({
+            userId: "admin-user",
+            roles: ["admin"]
+        })
+    };
+});
+
+import { createPostgresWebSocket } from "../src/websocket";
+import { RealtimeService } from "../src/services/realtimeService";
+import { PostgresBackendDriver } from "../src/PostgresBackendDriver";
+
+describe("WebSocket Server SQL error handling", () => {
+    let mockServer: Server;
+    let mockRealtimeService: RealtimeService;
+    let mockDriver: PostgresBackendDriver;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockWssInstance = null;
+
+        mockServer = {} as Server;
+        mockRealtimeService = {
+            addClient: jest.fn(),
+            registerDataDriverSubscription: jest.fn()
+        } as unknown as RealtimeService;
+
+        // Mock PostgresBackendDriver admin capabilities
+        mockDriver = {
+            key: "postgres",
+            initialised: true,
+            admin: {
+                executeSql: jest.fn()
+            }
+        } as unknown as PostgresBackendDriver;
+
+        // Trigger the wss initialization with requireAuth: true
+        createPostgresWebSocket(mockServer, mockRealtimeService, mockDriver, { requireAuth: true });
+    });
+
+    it("should handle EXECUTE_SQL errors cleanly and return ERROR message without throwing", async () => {
+        expect(mockWssInstance).toBeDefined();
+        expect(mockWssInstance.on).toHaveBeenCalledWith("connection", expect.any(Function));
+        
+        const connectionCallback = mockWssInstance.on.mock.calls.find(
+            (call: any[]) => call[0] === "connection"
+        )[1];
+
+        // Simulate client connection
+        const mockWs = {
+            on: jest.fn(),
+            send: jest.fn()
+        } as unknown as any;
+
+        connectionCallback(mockWs);
+
+        // Retrieve the message callback
+        expect(mockWs.on).toHaveBeenCalledWith("message", expect.any(Function));
+        const messageCallback = mockWs.on.mock.calls.find(
+            (call: any[]) => call[0] === "message"
+        )[1];
+
+        // 1. Authenticate first as an admin
+        await messageCallback(
+            Buffer.from(
+                JSON.stringify({
+                    type: "AUTHENTICATE",
+                    requestId: "auth-req",
+                    payload: {
+                        token: "mock-admin-token"
+                    }
+                })
+            )
+        );
+
+        expect(mockWs.send).toHaveBeenCalled();
+        const authResponse = JSON.parse(mockWs.send.mock.calls[0][0]);
+        expect(authResponse.type).toBe("AUTH_SUCCESS");
+
+        // Clear mock send calls before executing SQL
+        mockWs.send.mockClear();
+
+        // Mock executeSql to throw a permission denied error
+        (mockDriver.admin.executeSql as jest.Mock).mockRejectedValueOnce(
+            new Error("permission denied for table orders")
+        );
+
+        // 2. Simulate receiving EXECUTE_SQL message
+        await messageCallback(
+            Buffer.from(
+                JSON.stringify({
+                    type: "EXECUTE_SQL",
+                    requestId: "req-1",
+                    payload: {
+                        sql: "SELECT * FROM orders",
+                        options: { role: "demo" }
+                    }
+                })
+            )
+        );
+
+        // Verify executeSql was called
+        expect(mockDriver.admin.executeSql).toHaveBeenCalledWith("SELECT * FROM orders", { role: "demo" });
+
+        // Verify the client received a clean ERROR payload rather than crashing the socket
+        expect(mockWs.send).toHaveBeenCalled();
+        const sentMessage = JSON.parse(mockWs.send.mock.calls[0][0]);
+        expect(sentMessage).toEqual({
+            type: "ERROR",
+            requestId: "req-1",
+            payload: {
+                error: {
+                    message: "permission denied for table orders",
+                    code: "SQL_ERROR"
+                }
+            }
+        });
+    });
+});

package/examples/sdk-demo/node_modules/esbuild/LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Evan Wallace
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/examples/sdk-demo/node_modules/esbuild/README.md

@@ -1,3 +0,0 @@
-# esbuild
-
-This is a JavaScript bundler and minifier. See https://github.com/evanw/esbuild and the [JavaScript API documentation](https://esbuild.github.io/api/) for details.

package/examples/sdk-demo/node_modules/esbuild/bin/esbuild

@@ -1,223 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// lib/npm/node-platform.ts
-var fs = require("fs");
-var os = require("os");
-var path = require("path");
-var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
-var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
-var packageDarwin_arm64 = "@esbuild/darwin-arm64";
-var packageDarwin_x64 = "@esbuild/darwin-x64";
-var knownWindowsPackages = {
-  "win32 arm64 LE": "@esbuild/win32-arm64",
-  "win32 ia32 LE": "@esbuild/win32-ia32",
-  "win32 x64 LE": "@esbuild/win32-x64"
-};
-var knownUnixlikePackages = {
-  "aix ppc64 BE": "@esbuild/aix-ppc64",
-  "android arm64 LE": "@esbuild/android-arm64",
-  "darwin arm64 LE": "@esbuild/darwin-arm64",
-  "darwin x64 LE": "@esbuild/darwin-x64",
-  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
-  "freebsd x64 LE": "@esbuild/freebsd-x64",
-  "linux arm LE": "@esbuild/linux-arm",
-  "linux arm64 LE": "@esbuild/linux-arm64",
-  "linux ia32 LE": "@esbuild/linux-ia32",
-  "linux mips64el LE": "@esbuild/linux-mips64el",
-  "linux ppc64 LE": "@esbuild/linux-ppc64",
-  "linux riscv64 LE": "@esbuild/linux-riscv64",
-  "linux s390x BE": "@esbuild/linux-s390x",
-  "linux x64 LE": "@esbuild/linux-x64",
-  "linux loong64 LE": "@esbuild/linux-loong64",
-  "netbsd arm64 LE": "@esbuild/netbsd-arm64",
-  "netbsd x64 LE": "@esbuild/netbsd-x64",
-  "openbsd arm64 LE": "@esbuild/openbsd-arm64",
-  "openbsd x64 LE": "@esbuild/openbsd-x64",
-  "sunos x64 LE": "@esbuild/sunos-x64"
-};
-var knownWebAssemblyFallbackPackages = {
-  "android arm LE": "@esbuild/android-arm",
-  "android x64 LE": "@esbuild/android-x64",
-  "openharmony arm64 LE": "@esbuild/openharmony-arm64"
-};
-function pkgAndSubpathForCurrentPlatform() {
-  let pkg;
-  let subpath;
-  let isWASM2 = false;
-  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
-  if (platformKey in knownWindowsPackages) {
-    pkg = knownWindowsPackages[platformKey];
-    subpath = "esbuild.exe";
-  } else if (platformKey in knownUnixlikePackages) {
-    pkg = knownUnixlikePackages[platformKey];
-    subpath = "bin/esbuild";
-  } else if (platformKey in knownWebAssemblyFallbackPackages) {
-    pkg = knownWebAssemblyFallbackPackages[platformKey];
-    subpath = "bin/esbuild";
-    isWASM2 = true;
-  } else {
-    throw new Error(`Unsupported platform: ${platformKey}`);
-  }
-  return { pkg, subpath, isWASM: isWASM2 };
-}
-function pkgForSomeOtherPlatform() {
-  const libMainJS = require.resolve("esbuild");
-  const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
-  if (path.basename(nodeModulesDirectory) === "node_modules") {
-    for (const unixKey in knownUnixlikePackages) {
-      try {
-        const pkg = knownUnixlikePackages[unixKey];
-        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
-      } catch {
-      }
-    }
-    for (const windowsKey in knownWindowsPackages) {
-      try {
-        const pkg = knownWindowsPackages[windowsKey];
-        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
-      } catch {
-      }
-    }
-  }
-  return null;
-}
-function downloadedBinPath(pkg, subpath) {
-  const esbuildLibDir = path.dirname(require.resolve("esbuild"));
-  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
-}
-function generateBinPath() {
-  if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
-    if (!fs.existsSync(ESBUILD_BINARY_PATH)) {
-      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
-    } else {
-      return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
-    }
-  }
-  const { pkg, subpath, isWASM: isWASM2 } = pkgAndSubpathForCurrentPlatform();
-  let binPath2;
-  try {
-    binPath2 = require.resolve(`${pkg}/${subpath}`);
-  } catch (e) {
-    binPath2 = downloadedBinPath(pkg, subpath);
-    if (!fs.existsSync(binPath2)) {
-      try {
-        require.resolve(pkg);
-      } catch {
-        const otherPkg = pkgForSomeOtherPlatform();
-        if (otherPkg) {
-          let suggestions = `
-Specifically the "${otherPkg}" package is present but this platform
-needs the "${pkg}" package instead. People often get into this
-situation by installing esbuild on Windows or macOS and copying "node_modules"
-into a Docker image that runs Linux, or by copying "node_modules" between
-Windows and WSL environments.
-
-If you are installing with npm, you can try not copying the "node_modules"
-directory when you copy the files over, and running "npm ci" or "npm install"
-on the destination platform after the copy. Or you could consider using yarn
-instead of npm which has built-in support for installing a package on multiple
-platforms simultaneously.
-
-If you are installing with yarn, you can try listing both this platform and the
-other platform in your ".yarnrc.yml" file using the "supportedArchitectures"
-feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
-Keep in mind that this means multiple copies of esbuild will be present.
-`;
-          if (pkg === packageDarwin_x64 && otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 && otherPkg === packageDarwin_x64) {
-            suggestions = `
-Specifically the "${otherPkg}" package is present but this platform
-needs the "${pkg}" package instead. People often get into this
-situation by installing esbuild with npm running inside of Rosetta 2 and then
-trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta
-2 is Apple's on-the-fly x86_64-to-arm64 translation service).
-
-If you are installing with npm, you can try ensuring that both npm and node are
-not running under Rosetta 2 and then reinstalling esbuild. This likely involves
-changing how you installed npm and/or node. For example, installing node with
-the universal installer here should work: https://nodejs.org/en/download/. Or
-you could consider using yarn instead of npm which has built-in support for
-installing a package on multiple platforms simultaneously.
-
-If you are installing with yarn, you can try listing both "arm64" and "x64"
-in your ".yarnrc.yml" file using the "supportedArchitectures" feature:
-https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
-Keep in mind that this means multiple copies of esbuild will be present.
-`;
-          }
-          throw new Error(`
-You installed esbuild for another platform than the one you're currently using.
-This won't work because esbuild is written with native code and needs to
-install a platform-specific binary executable.
-${suggestions}
-Another alternative is to use the "esbuild-wasm" package instead, which works
-the same way on all platforms. But it comes with a heavy performance cost and
-can sometimes be 10x slower than the "esbuild" package, so you may also not
-want to do that.
-`);
-        }
-        throw new Error(`The package "${pkg}" could not be found, and is needed by esbuild.
-
-If you are installing esbuild with npm, make sure that you don't specify the
-"--no-optional" or "--omit=optional" flags. The "optionalDependencies" feature
-of "package.json" is used by esbuild to install the correct binary executable
-for your current platform.`);
-      }
-      throw e;
-    }
-  }
-  if (/\.zip\//.test(binPath2)) {
-    let pnpapi;
-    try {
-      pnpapi = require("pnpapi");
-    } catch (e) {
-    }
-    if (pnpapi) {
-      const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
-      const binTargetPath = path.join(
-        root,
-        "node_modules",
-        ".cache",
-        "esbuild",
-        `pnpapi-${pkg.replace("/", "-")}-${"0.27.3"}-${path.basename(subpath)}`
-      );
-      if (!fs.existsSync(binTargetPath)) {
-        fs.mkdirSync(path.dirname(binTargetPath), { recursive: true });
-        fs.copyFileSync(binPath2, binTargetPath);
-        fs.chmodSync(binTargetPath, 493);
-      }
-      return { binPath: binTargetPath, isWASM: isWASM2 };
-    }
-  }
-  return { binPath: binPath2, isWASM: isWASM2 };
-}
-
-// lib/npm/node-shim.ts
-var { binPath, isWASM } = generateBinPath();
-if (isWASM) {
-  require("child_process").execFileSync("node", [binPath].concat(process.argv.slice(2)), { stdio: "inherit" });
-} else {
-  require("child_process").execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
-}