@base44-preview/cli 0.1.32-pr.663.7602773 → 0.1.32-pr.663.d01623b

package/dist/cli/index.js

@@ -249106,12 +249106,7 @@ var BOOST = { path: 8, summary: 5, description: 2, parameters: 0.5 };
 var MIN_RELATIVE_SCORE = 0.2;
 var TOKEN_SEPARATOR = /[\n\r\p{Z}\p{P}\p{S}]+/u;
 function toOperationSummary(op) {
-  return {
-    method: op.method,
-    path: op.path,
-    summary: op.summary,
-    readOnly: op.readOnly
-  };
+  return { endpoint: op.endpoint, summary: op.summary };
 }
 function buildSearchIndex(operations) {
   const index = new MiniSearch({
@@ -249145,6 +249140,7 @@ function searchOperations(operations, query, options = {}) {
 // src/core/api-spec/catalog.ts
 var INLINE_AREA_MAX = 2;
 var AREA_SAMPLE_MAX = 3;
+var AREA_OPERATIONS_MAX = 200;
 var byCodePoint = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 function areaOf(path) {
   const parts = path.split("/").filter(Boolean);
@@ -249166,24 +249162,39 @@ function groupByArea(operations) {
   }
   return new Map([...areas].sort(([a], [b]) => byCodePoint(a, b)));
 }
+function readsFirst(ops) {
+  const isRead = (op) => op.method === "GET" ? 0 : 1;
+  return [...ops].sort((a, b) => isRead(a) - isRead(b));
+}
 function catalogIndex(operations) {
   const areas = [...groupByArea(operations)].map(([area, ops]) => ops.length <= INLINE_AREA_MAX ? { area, operations: ops.map(toOperationSummary) } : {
     area,
     operationCount: ops.length,
-    sample: ops.slice(0, AREA_SAMPLE_MAX).map((op) => op.summary)
+    sample: readsFirst(ops).slice(0, AREA_SAMPLE_MAX).map((op) => op.summary)
   });
   return { areas, total: operations.length };
 }
+function areaListing(area, operations, max = AREA_OPERATIONS_MAX) {
+  return {
+    area,
+    operations: operations.slice(0, max).map(toOperationSummary),
+    total: operations.length,
+    truncated: operations.length > max
+  };
+}
 // src/core/api-spec/grep.ts
 var CONTEXT_CHARS = 40;
 var MAX_SNIPPETS = 3;
 var MAX_SNIPPET_CHARS = 200;
+function unescapeJson(snippet) {
+  return snippet.replace(/\\[nrt]/g, " ").replace(/\\"/g, '"');
+}
 function snippets(text, pattern) {
   const found = [];
   for (const match of text.matchAll(pattern)) {
     const start = Math.max(0, match.index - CONTEXT_CHARS);
     const end = match.index + match[0].length + CONTEXT_CHARS;
-    found.push(text.slice(start, Math.min(end, start + MAX_SNIPPET_CHARS)));
+    found.push(unescapeJson(text.slice(start, Math.min(end, start + MAX_SNIPPET_CHARS))));
     if (found.length === MAX_SNIPPETS || match[0].length === 0) {
       break;
     }
@@ -249193,14 +249204,15 @@ function snippets(text, pattern) {
 function grepSpec(spec, operations, pattern, options = {}) {
   const regex = new RegExp(pattern, options.ignoreCase ? "gi" : "g");
   const hits = [];
-  const inArea = (op) => options.area === undefined || areaOf(op.path) === options.area;
-  for (const op of operations.filter(inArea)) {
-    const matches = snippets(`${op.method} ${op.path} ${JSON.stringify(op.operation)}`, regex);
+  const selected = (op) => (options.area === undefined || areaOf(op.path) === options.area) && (!options.readOnly || op.readOnly);
+  for (const op of operations.filter(selected)) {
+    const { summary, description, parameters, requestBody, responses } = op.operation;
+    const matches = snippets(`${op.endpoint} ${JSON.stringify({ summary, description, parameters, requestBody, responses })}`, regex);
     if (matches.length > 0) {
       hits.push({ ...toOperationSummary(op), matches });
     }
   }
-  const schemas = options.area === undefined ? spec.components?.schemas : {};
+  const schemas = options.area === undefined && !options.readOnly ? spec.components?.schemas : {};
   for (const [schema, definition] of Object.entries(schemas ?? {})) {
     const matches = snippets(JSON.stringify(definition), regex);
     if (matches.length > 0) {
@@ -249225,7 +249237,16 @@ var ParameterSchema = looseObject({
   in: string2(),
   required: boolean2().optional(),
   description: string2().optional(),
-  schema: unknown().optional()
+  schema: unknown().optional(),
+  example: unknown().optional()
+});
+var MediaTypesSchema = record(string2(), looseObject({ schema: unknown().optional() }));
+var RequestBodySchema = looseObject({
+  content: MediaTypesSchema.optional()
+});
+var ResponseObjectSchema = looseObject({
+  description: string2().optional(),
+  content: MediaTypesSchema.optional()
 });
 var SecurityRequirementSchema = record(string2(), array(string2()));
 var OperationSchema = looseObject({
@@ -249268,6 +249289,7 @@ function listOperations(spec) {
     }
     return [
       {
+        endpoint: `${method.toUpperCase()} ${path}`,
         method: method.toUpperCase(),
         path,
         summary: operation.summary ?? "",
@@ -249310,46 +249332,73 @@ function matchOperation(operations, method, concretePath) {
   });
   return candidates.sort((a, b) => compareSpecificity(specificity(pathSegments(a.path)), specificity(pathSegments(b.path))))[0];
 }
-function collectRefs(value, spec, found) {
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      collectRefs(item, spec, found);
-    }
-    return;
+var SCHEMA_REF_PREFIX = "#/components/schemas/";
+var MAX_REF_DEPTH = 4;
+var FRAMEWORK_VALIDATION_ERROR = "Validation Error";
+function inlineRefs(node, schemas, seen = new Set, depth = 0) {
+  if (depth > MAX_REF_DEPTH) {
+    return node;
   }
-  if (value === null || typeof value !== "object") {
-    return;
+  if (Array.isArray(node)) {
+    return node.map((item) => inlineRefs(item, schemas, seen, depth));
   }
-  for (const [key, child] of Object.entries(value)) {
-    if (key === "$ref" && typeof child === "string" && !found.has(child)) {
-      const target = resolvePointer(spec, child);
-      found.set(child, target);
-      collectRefs(target, spec, found);
-    } else {
-      collectRefs(child, spec, found);
+  if (node === null || typeof node !== "object") {
+    return node;
+  }
+  const { $ref, ...siblings } = node;
+  if (typeof $ref === "string" && $ref.startsWith(SCHEMA_REF_PREFIX)) {
+    const name = $ref.slice(SCHEMA_REF_PREFIX.length);
+    if (seen.has(name) || !(name in schemas)) {
+      return node;
     }
+    const resolved = inlineRefs(schemas[name], schemas, new Set([...seen, name]), depth + 1);
+    return resolved !== null && typeof resolved === "object" ? { ...resolved, ...siblings } : resolved;
   }
+  return Object.fromEntries(Object.entries(node).map(([key, value]) => [
+    key,
+    inlineRefs(value, schemas, seen, depth)
+  ]));
 }
-function resolvePointer(spec, ref) {
-  if (!ref.startsWith("#/")) {
-    return;
-  }
-  return ref.slice(2).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~")).reduce((node, part) => node !== null && typeof node === "object" ? node[part] : undefined, spec);
+function jsonSchemaOf(value) {
+  const parsed = RequestBodySchema.safeParse(value);
+  return parsed.success ? parsed.data.content?.["application/json"]?.schema : undefined;
 }
 function getOperationContract(spec, op) {
-  const { parameters, requestBody, responses } = op.operation;
-  const refs = new Map;
-  collectRefs({ parameters, requestBody, responses }, spec, refs);
+  const schemas = spec.components?.schemas ?? {};
+  const inline = (node) => node === undefined ? null : inlineRefs(node, schemas);
+  const responses = Object.entries(op.operation.responses ?? {}).flatMap(([status, response]) => {
+    const parsed = ResponseObjectSchema.safeParse(response);
+    return parsed.success ? [[status, parsed.data]] : [];
+  });
+  const success = responses.filter(([status]) => status.startsWith("2")).sort(([a], [b]) => a.localeCompare(b)).map(([, response]) => jsonSchemaOf(response)).find(Boolean);
+  const errors = responses.filter(([status, response]) => !status.startsWith("2") && response.description !== FRAMEWORK_VALIDATION_ERROR);
   return {
+    endpoint: op.endpoint,
     method: op.method,
     path: op.path,
     summary: op.summary,
     description: op.description,
-    readOnly: op.readOnly,
-    parameters: parameters ?? [],
-    requestBody: requestBody ?? null,
-    responses: responses ?? {},
-    refs: Object.fromEntries(refs)
+    parameters: (op.operation.parameters ?? []).flatMap((parameter) => {
+      const parsed = ParameterSchema.safeParse(parameter);
+      if (!parsed.success) {
+        return [];
+      }
+      const { name, in: location2, required, schema, description } = parsed.data;
+      const inSchema = schema !== null && typeof schema === "object" && "description" in schema;
+      return [
+        {
+          name,
+          in: location2,
+          required: required ?? false,
+          schema: inline(schema ?? {}),
+          ...description && !inSchema ? { description } : {},
+          ..."example" in parsed.data ? { example: parsed.data.example } : {}
+        }
+      ];
+    }),
+    requestBodySchema: inline(jsonSchemaOf(op.operation.requestBody)),
+    responseSchema: inline(success),
+    errors: Object.fromEntries(errors.map(([status, response]) => [status, response.description ?? ""]))
   };
 }
 // src/core/api-spec/request.ts
@@ -249360,7 +249409,11 @@ async function sendApiRequest(method, path, body) {
       body,
       headers: body === undefined ? {} : { "Content-Type": "application/json" }
     });
-    return await response.text();
+    return {
+      status: response.status,
+      contentType: response.headers.get("content-type") ?? "",
+      body: new Uint8Array(await response.arrayBuffer())
+    };
   } catch (error) {
     throw await ApiError.fromHttpError(error, `calling ${method} ${path}`);
   }
@@ -249421,18 +249474,6 @@ function formatJson(value) {
   return `${JSON.stringify(value, null, process.stdout.isTTY ? 2 : undefined)}
 `;
 }
-function formatResponseBody(text) {
-  if (!text) {
-    return "";
-  }
-  try {
-    return formatJson(JSON.parse(text));
-  } catch {
-    return text.endsWith(`
-`) ? text : `${text}
-`;
-  }
-}
 function parseLimit(value) {
   if (value === undefined) {
     return;
@@ -249443,6 +249484,7 @@ function parseLimit(value) {
   }
   return n;
 }
+var READ_ONLY_FILTER_HELP = "Only read-only operations";
 var REFRESH_OPTION_HELP = "Fetch the API spec again instead of using the cached copy (kept 1 hour)";
 function loadSpecTask({ runTask }, refresh) {
   return runTask("Loading the API spec", () => loadSpec({ refresh }), {
@@ -249480,24 +249522,19 @@ async function readRequestBody(method, flag) {
 // src/cli/commands/api/catalog.ts
 async function catalogAction(ctx, area, options) {
   const { spec } = await loadSpecTask(ctx, options.refresh);
-  const operations = listOperations(spec);
+  const operations = listOperations(spec).filter((op) => !options.readOnly || op.readOnly);
   if (area === undefined) {
     return { stdout: formatJson(catalogIndex(operations)) };
   }
-  const inArea = operationsInArea(operations, area);
   return {
-    stdout: formatJson({
-      area,
-      operations: inArea.map(toOperationSummary),
-      total: inArea.length
-    })
+    stdout: formatJson(areaListing(area, operationsInArea(operations, area)))
   };
 }
 function getApiCatalogCommand() {
   return new Base44Command("catalog", {
     requireAuth: false,
     requireAppContext: false
-  }).description("List the API's areas, or every operation in one area (same areas as the MCP bridge)").argument("[area]", 'An area from the list, e.g. "workflows"').option("--refresh", REFRESH_OPTION_HELP).action(catalogAction);
+  }).description("List the API's areas, or every operation in one area").argument("[area]", 'An area from the list, e.g. "workflows"').option("--read-only", READ_ONLY_FILTER_HELP).option("--refresh", REFRESH_OPTION_HELP).action(catalogAction);
 }
 
 // src/cli/commands/api/fetch.ts
@@ -249516,6 +249553,36 @@ async function findOperation(ctx, method, path, refresh) {
   }
   return { spec, op };
 }
+var TEXT_CONTENT_TYPES = [
+  "json",
+  "text/",
+  "xml",
+  "javascript",
+  "x-www-form-urlencoded"
+];
+function isText(contentType) {
+  return !contentType || TEXT_CONTENT_TYPES.some((hint) => contentType.toLowerCase().includes(hint));
+}
+async function formatResponse({ status, contentType, body }, output) {
+  if (output !== undefined) {
+    await writeFile(output, body);
+    return formatJson({ status, contentType, bytes: body.length, output });
+  }
+  if (body.length === 0) {
+    return formatJson({ status });
+  }
+  if (!isText(contentType)) {
+    throw new InvalidInputError(`The response is binary (${contentType}, ${body.length} bytes), so it was not printed. The request was sent; add --output <file> to save the response.`);
+  }
+  const text = new TextDecoder().decode(body);
+  try {
+    return formatJson(JSON.parse(text));
+  } catch {
+    return text.endsWith(`
+`) ? text : `${text}
+`;
+  }
+}
 async function fetchAction(ctx, methodArg, path, options, command) {
   if (!methodArg || !path) {
     if (options.help) {
@@ -249536,14 +249603,17 @@ async function fetchAction(ctx, methodArg, path, options, command) {
   }
   await ensureAuth(ctx);
   const body = await readRequestBody(method, options.body);
-  const text = await ctx.runTask(`Calling ${method} ${path}`, () => sendApiRequest(method, path, body), { successMessage: `Called ${method} ${path}` });
-  return { stdout: formatResponseBody(text) };
+  const response = await ctx.runTask(`Calling ${method} ${path}`, () => sendApiRequest(method, path, body), {
+    successMessage: `Called ${method} ${path}`,
+    errorMessage: "Request failed"
+  });
+  return { stdout: await formatResponse(response, options.output) };
 }
 function getApiFetchCommand() {
   return new Base44Command("fetch", {
     requireAuth: false,
     requireAppContext: false
-  }).description("Call a Base44 API operation, like curl; add --help after a path for its contract").helpOption(false).argument("[method]", "HTTP method, e.g. GET or POST").argument("[path]", 'Concrete path with any query string, e.g. "/api/apps/<app-id>/workflows/runs?status=failed"').option("--body <json>", "Request body: JSON, @file.json, or @- for stdin (piped stdin is read too)").option("--read-only", "Refuse, before sending, any operation the spec does not mark read-only").option("--refresh", REFRESH_OPTION_HELP).option("-h, --help", "With a method and path, print that operation's contract; otherwise this help").action(fetchAction);
+  }).description("Call a Base44 API operation, like curl; add --help after a path for its contract").helpOption(false).argument("[method]", "HTTP method, e.g. GET or POST").argument("[path]", 'Concrete path with any query string, e.g. "/api/apps/<app-id>/workflows/runs?status=failed"').option("--body <json>", "Request body: JSON, @file.json, or @- for stdin (piped stdin is read too)").option("--output <file>", "Save the response body to a file").option("--read-only", "Refuse, before sending, any operation the spec does not mark read-only").option("--refresh", REFRESH_OPTION_HELP).option("-h, --help", "With a method and path, print that operation's contract; otherwise this help").action(fetchAction);
 }
 
 // src/cli/commands/api/grep.ts
@@ -249565,7 +249635,8 @@ async function grepAction(ctx, pattern, options) {
   const hits = grepSpec(spec, operations, pattern, {
     area: options.area,
     ignoreCase: options.ignoreCase,
-    limit
+    limit,
+    readOnly: options.readOnly
   });
   return { stdout: formatJson(hits) };
 }
@@ -249573,7 +249644,7 @@ function getApiGrepCommand() {
   return new Base44Command("grep", {
     requireAuth: false,
     requireAppContext: false
-  }).description("Search the raw API spec with a regular expression, for when search misses").argument("<pattern>", 'Regular expression, e.g. "runs.*status"').option("--area <area>", "Search only one area's operations (see base44 api catalog)").option("-i, --ignore-case", "Case-insensitive match").option("--limit <n>", "Most operations or schemas to return (default 20)").option("--refresh", REFRESH_OPTION_HELP).action(grepAction);
+  }).description("Search the raw API spec with a regular expression, for when search misses").argument("<pattern>", 'Regular expression, e.g. "runs.*status"').option("--area <area>", "Search only one area's operations (see base44 api catalog)").option("-i, --ignore-case", "Case-insensitive match").option("--limit <n>", "Most operations or schemas to return (default 20)").option("--read-only", READ_ONLY_FILTER_HELP).option("--refresh", REFRESH_OPTION_HELP).action(grepAction);
 }
 
 // src/cli/commands/api/search.ts
@@ -249590,7 +249661,7 @@ function getApiSearchCommand() {
   return new Base44Command("search", {
     requireAuth: false,
     requireAppContext: false
-  }).description("Search every Base44 API operation by what it does").argument("<text...>", 'What you are looking for, e.g. "failed workflow runs"').option("--limit <n>", "Most results to return (default 5)").option("--read-only", "Return only read-only operations").option("--refresh", REFRESH_OPTION_HELP).action(searchAction);
+  }).description("Search every Base44 API operation by what it does").argument("<text...>", 'What you are looking for, e.g. "failed workflow runs"').option("--limit <n>", "Most results to return (default 5)").option("--read-only", READ_ONLY_FILTER_HELP).option("--refresh", REFRESH_OPTION_HELP).action(searchAction);
 }
 
 // src/cli/commands/api/index.ts
@@ -254959,6 +255030,12 @@ var deno2 = Object.freeze({
 });
 globalThis.Deno = deno2;
 globalThis.Buffer = Buffer2;
+try {
+  new AsyncLocalStorage().enterWith(void 0);
+} catch {
+  AsyncLocalStorage.prototype.enterWith = () => {
+  };
+}
 function getRegisteredHandler() {
   return registeredHandler;
 }
@@ -257924,7 +258001,7 @@ var TELEMETRY_PATCH = [
 var TELEMETRY_STORE_FIELDS = "reqId: crypto.randomUUID(), respondedAt: null, inflight: new Map(), inflightTotal: 0, hadRejection: false, hadNonOk: false, logBudget: 5";
 
 // ../functions-compiler/src/version.ts
-var COMPILER_VERSION = "0.1.7";
+var COMPILER_VERSION = "0.1.8";
 
 // ../functions-compiler/src/worker-entry.ts
 function denoShimSource() {
@@ -262548,6 +262625,174 @@ function runtimeVirtualPlugin() {
   };
 }
 
+// ../functions-compiler/src/esbuild/ws-native-virtual.ts
+var NAMESPACE4 = "base44-ws-native";
+var WS_SPECIFIER = /^(npm:)?ws(@[^/]+)?$/;
+var ADAPTER = `"use strict";
+const toBuffer = (value) => (globalThis.Buffer ? globalThis.Buffer.from(value) : value);
+const READY_STATES = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+const later = (fn, ...args) => queueMicrotask(() => fn(...args));
+const upgradeHeaders = (options) => {
+  const headers = new Headers(options?.headers);
+  for (const name of headers.keys()) if (name !== "user-agent") return headers;
+  return null;
+};
+class WebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  #socket = null;
+  #state = 0;
+  #url;
+  #closeRequested = null;
+  #terminated = false;
+  #listeners = new Map();
+  constructor(address, protocols, options) {
+    if (protocols && typeof protocols === "object" && !Array.isArray(protocols)) {
+      options = protocols;
+      protocols = undefined;
+    }
+    this.#url = String(address);
+    const headers = upgradeHeaders(options);
+    if (headers) {
+      this.#upgrade(headers, protocols);
+    } else {
+      this.#attach(new globalThis.WebSocket(this.#url, protocols));
+    }
+  }
+  get readyState() {
+    if (this.#terminated) return 3;
+    return this.#socket ? this.#socket.readyState : this.#state;
+  }
+  get url() { return this.#url; }
+  get protocol() { return this.#socket ? this.#socket.protocol ?? "" : ""; }
+  on(name, listener) { return this.#add(name, listener, false); }
+  addListener(name, listener) { return this.#add(name, listener, false); }
+  once(name, listener) { return this.#add(name, listener, true); }
+  off(name, listener) { return this.removeListener(name, listener); }
+  removeListener(name, listener) {
+    const listeners = this.#listeners.get(name);
+    if (listeners) this.#listeners.set(name, listeners.filter((entry) => entry.listener !== listener));
+    return this;
+  }
+  removeAllListeners(name) {
+    if (name === undefined) this.#listeners.clear();
+    else this.#listeners.delete(name);
+    return this;
+  }
+  emit(name, ...args) {
+    const listeners = this.#listeners.get(name) ?? [];
+    this.#listeners.set(name, listeners.filter((entry) => !entry.once));
+    for (const entry of listeners) entry.listener.apply(this, args);
+    return listeners.length > 0;
+  }
+  send(data, options, callback) {
+    const done = typeof options === "function" ? options : callback;
+    try {
+      if (!this.#socket) {
+        throw new Error("WebSocket is not open: readyState " + this.#state + " (" + READY_STATES[this.#state] + ")");
+      }
+      this.#socket.send(data);
+      done?.();
+    } catch (error) {
+      if (!done) throw error;
+      done(error);
+    }
+  }
+  close(code, reason) {
+    if (this.#socket) this.#socket.close(code, reason);
+    else if (this.#state === 0) {
+      // Upgrade still in flight: close as soon as it lands.
+      this.#closeRequested = [code, reason];
+      this.#state = 2;
+    }
+  }
+  // \`ws\` tears the connection down at once. workerd has no abrupt close, so the
+  // socket is closed normally and "close" is reported now, not on the reply.
+  terminate() {
+    if (this.#terminated || this.readyState === 3) return;
+    this.#terminated = true;
+    if (this.#socket) {
+      try { this.#socket.close(); } catch {}
+    } else {
+      // Upgrade still in flight: close it on arrival, without an "open".
+      this.#closeRequested = [];
+      this.#state = 3;
+    }
+    later(() => this.emit("close", 1006, toBuffer("")));
+  }
+  #attach(socket) {
+    this.#socket = socket;
+    try { socket.binaryType = "arraybuffer"; } catch {}
+    socket.addEventListener("open", () => this.emit("open"));
+    socket.addEventListener("message", (event) => {
+      const isBinary = typeof event.data !== "string";
+      this.emit("message", toBuffer(isBinary ? new Uint8Array(event.data) : event.data), isBinary);
+    });
+    socket.addEventListener("error", (event) => this.emit("error", event.error ?? new Error(event.message || "WebSocket error")));
+    socket.addEventListener("close", (event) => {
+      if (!this.#terminated) this.emit("close", event.code, toBuffer(event.reason ?? ""));
+    });
+  }
+  #upgrade(headers, protocols) {
+    headers.set("Upgrade", "websocket");
+    if (protocols) headers.set("Sec-WebSocket-Protocol", [].concat(protocols).join(", "));
+    const httpUrl = this.#url.replace(/^ws(s?):/i, "http$1:");
+    const fail = (error) => {
+      this.#state = 3;
+      if (this.#terminated) return;
+      this.emit("error", error);
+      this.emit("close", 1006, toBuffer(""));
+    };
+    // Two-argument then(): an exception from an "open" listener must not be
+    // reported as a failed upgrade.
+    fetch(httpUrl, { headers }).then((response) => {
+      const socket = response.webSocket;
+      if (!socket) {
+        response.body?.cancel();
+        return fail(new Error("Unexpected server response: " + response.status));
+      }
+      socket.accept();
+      this.#attach(socket);
+      if (this.#closeRequested) return socket.close(...this.#closeRequested);
+      // accept() opens the socket without dispatching an "open" event.
+      this.emit("open");
+    }, fail);
+  }
+  #add(name, listener, once) {
+    const listeners = this.#listeners.get(name) ?? [];
+    listeners.push({ listener, once });
+    this.#listeners.set(name, listeners);
+    return this;
+  }
+}
+class WebSocketServer {
+  constructor() {
+    throw new Error("ws WebSocketServer is not available in Base44 functions: a function can open WebSocket connections but cannot listen for them.");
+  }
+}
+module.exports = WebSocket;
+module.exports.WebSocket = WebSocket;
+module.exports.WebSocketServer = WebSocketServer;
+module.exports.default = WebSocket;
+`;
+function wsNativeVirtualPlugin() {
+  return {
+    name: "base44-ws-native",
+    setup(build) {
+      build.onResolve({ filter: WS_SPECIFIER }, () => ({
+        path: "ws",
+        namespace: NAMESPACE4
+      }));
+      build.onLoad({ filter: /.*/, namespace: NAMESPACE4 }, () => ({
+        contents: ADAPTER,
+        loader: "js"
+      }));
+    }
+  };
+}
+
 // ../functions-compiler/src/deno-bundle.ts
 async function bundleToModule(prepared, nodeModulesDir = "none") {
   const dir = await mkdtemp(path21.join(tmpdir2(), "b44-bundle-"));
@@ -262571,6 +262816,7 @@ async function bundleToModule(prepared, nodeModulesDir = "none") {
         sourcemap: false,
         logLevel: "silent",
         plugins: [
+          wsNativeVirtualPlugin(),
           nodeBuiltinRequirePlugin(),
           userFilesPlugin(prepared.files, prepared.entry),
           privateDataSourcesVirtualPlugin(),
@@ -272960,4 +273206,4 @@ export {
   runCLI
 };
 
-//# debugId=9595882D8F2B0F6464756E2164756E21
+//# debugId=874A12DB9A1B72DD64756E2164756E21