@silverbulletmd/silverbullet 2.4.1

package/client/space_lua/stdlib/js.ts

@@ -0,0 +1,73 @@
+import {
+  jsToLuaValue,
+  LuaBuiltinFunction,
+  LuaTable,
+  luaValueToJS,
+} from "../runtime.ts";
+
+export const jsApi = new LuaTable({
+  /**
+   * Creates a new instance of a JavaScript class.
+   * @param constructorFn - The constructor function.
+   * @param args - The arguments to pass to the constructor.
+   * @returns The new instance.
+   */
+  new: new LuaBuiltinFunction(
+    (sf, constructorFn: any, ...args) => {
+      return new constructorFn(
+        ...args.map((v) => luaValueToJS(v, sf)),
+      );
+    },
+  ),
+  /**
+   * Imports a JavaScript module.
+   * @param url - The URL of the module to import.
+   * @returns The imported module.
+   */
+  import: new LuaBuiltinFunction(async (_sf, url) => {
+    let m = await import(url);
+    // Unwrap default if it exists
+    if (Object.keys(m).length === 1 && m.default) {
+      m = m.default;
+    }
+    return m;
+  }),
+  eachIterable: new LuaBuiltinFunction((_sf, val) => {
+    const iterator = val[Symbol.asyncIterator]();
+    return async () => {
+      const result = await iterator.next();
+      if (result.done) {
+        return;
+      }
+      return result.value;
+    };
+  }),
+  /**
+   * Converts a JavaScript value to a Lua value.
+   * @param val - The JavaScript value to convert.
+   * @returns The Lua value.
+   */
+  tolua: new LuaBuiltinFunction((_sf, val) => jsToLuaValue(val)),
+  /**
+   * Converts a Lua value to a JavaScript value.
+   * @param val - The Lua value to convert.
+   * @returns The JavaScript value.
+   */
+  tojs: new LuaBuiltinFunction((sf, val) => luaValueToJS(val, sf)),
+  /**
+   * Logs a message to the console.
+   * @param args - The arguments to log.
+   */
+  log: new LuaBuiltinFunction((_sf, ...args) => {
+    console.log(...args);
+  }),
+  /**
+   * Converts a Lua value to a JSON string.
+   * @param val - The Lua value to convert.
+   * @returns The JSON string.
+   */
+  stringify: new LuaBuiltinFunction((_sf, val) => JSON.stringify(val)),
+
+  // Expose the global window object
+  window: globalThis,
+});

package/client/space_lua/stdlib/load.ts

@@ -0,0 +1,52 @@
+import {
+  LuaBuiltinFunction,
+  type LuaEnv,
+  LuaMultiRes,
+  type LuaStackFrame,
+  type LuaValue,
+} from "../runtime.ts";
+import { parse } from "../parse.ts";
+import { evalStatement } from "../eval.ts";
+
+// Returns a function (callable chunk) or (nil, "error message") pair.
+export function luaLoad(code: LuaValue, sf: LuaStackFrame): LuaValue {
+  const s = typeof code === "string" ? code : String(code);
+
+  try {
+    const block = parse(s, sf.astCtx || {});
+    const globalEnvMaybe = sf.threadLocal.get("_GLOBAL");
+
+    // Be vocal when no _GLOBAL is set
+    if (!globalEnvMaybe) {
+      console.warn(
+        "load() called without _GLOBAL in thread-local environment",
+      );
+      return new LuaMultiRes([null, "Global environment not set"]);
+    }
+
+    const globalEnv: LuaEnv = globalEnvMaybe as LuaEnv;
+
+    const runner = new LuaBuiltinFunction(async (innerSf: LuaStackFrame) => {
+      const res = await evalStatement(block, globalEnv, innerSf, true);
+      if (res === undefined) {
+        return null;
+      } else {
+        if (res && typeof res === "object" && (res as any).ctrl === "return") {
+          return new LuaMultiRes((res as any).values);
+        }
+        if (res && typeof res === "object" && (res as any).ctrl === "break") {
+          throw new Error("break outside loop");
+        }
+        if (res && typeof res === "object" && (res as any).ctrl === "goto") {
+          throw new Error("unexpected goto signal");
+        }
+        return null;
+      }
+    });
+
+    return runner;
+  } catch (e: any) {
+    const msg = e && typeof e.message === "string" ? e.message : String(e);
+    return new LuaMultiRes([null, msg]);
+  }
+}

package/client/space_lua/stdlib/math.ts

@@ -0,0 +1,193 @@
+import {
+  LuaBuiltinFunction,
+  LuaMultiRes,
+  LuaRuntimeError,
+  LuaTable,
+} from "../runtime.ts";
+import { isNegativeZero, isTaggedFloat } from "../numeric.ts";
+
+// Fast unwrap: avoids function call overhead for the common plain-number case
+function untagNumber(x: any): number {
+  if (typeof x === "number") return x;
+  if (isTaggedFloat(x)) return x.value;
+  return Number(x);
+}
+
+export const mathApi = new LuaTable({
+  // math constants
+  huge: 1 / 0,
+  pi: Math.PI,
+
+  // math.type(x) => "integer" | "float" | nil
+  type: new LuaBuiltinFunction((_sf, x?: any) => {
+    if (x === undefined) {
+      throw new LuaRuntimeError(
+        "bad argument #1 to 'math.type' (value expected)",
+        _sf,
+      );
+    }
+    if (isTaggedFloat(x)) {
+      return "float";
+    }
+    if (typeof x === "number") {
+      if (!Number.isFinite(x) || isNegativeZero(x)) {
+        return "float";
+      }
+      return Number.isInteger(x) ? "integer" : "float";
+    }
+    if (typeof x === "bigint") {
+      return "integer";
+    }
+    return null;
+  }),
+  /**
+   * When called without arguments, returns a pseudo-random float with
+   * uniform distribution in the range [0,1). When called with two
+   * integers m and n, math.random returns a pseudo-random integer
+   * with uniform distribution in the range [m, n]. The call
+   * math.random(n), for a positive n, is equivalent to
+   * math.random(1,n). The call math.random(0) produces an integer
+   * with all bits (pseudo)random.
+   */
+  random: new LuaBuiltinFunction((_sf, m?: number, n?: number) => {
+    if (m !== undefined) m = untagNumber(m);
+    if (n !== undefined) n = untagNumber(n);
+
+    if (m === undefined && n === undefined) {
+      return Math.random();
+    }
+
+    if (!Number.isInteger(m)) {
+      throw new LuaRuntimeError(
+        "bad argument #1 to 'math.random' (integer expected)",
+        _sf,
+      );
+    }
+
+    if (n === undefined) {
+      if (m! == 0) {
+        const high = Math.floor(Math.random() * 0x100000000);
+        const low = Math.floor(Math.random() * 0x100000000);
+        let result = (BigInt(high) << 32n) | BigInt(low);
+        if (result & (1n << 63n)) {
+          result -= 1n << 64n;
+        }
+        return result;
+      }
+      if (m! < 1) {
+        throw new LuaRuntimeError(
+          "bad argument #1 to 'math.random' (interval is empty)",
+          _sf,
+        );
+      }
+      return Math.floor(Math.random() * m!) + 1;
+    }
+
+    if (!Number.isInteger(n!)) {
+      throw new LuaRuntimeError(
+        "bad argument #2 to 'math.random' (integer expected)",
+        _sf,
+      );
+    }
+
+    if (n! < m!) {
+      throw new LuaRuntimeError(
+        "bad argument #1 to 'math.random' (interval is empty)",
+        _sf,
+      );
+    }
+    return Math.floor(Math.random() * (n! - m! + 1)) + m!;
+  }),
+
+  // Basic functions
+  abs: new LuaBuiltinFunction((_sf, x: number) => Math.abs(untagNumber(x))),
+  ceil: new LuaBuiltinFunction((_sf, x: number) => Math.ceil(untagNumber(x))),
+  floor: new LuaBuiltinFunction((_sf, x: number) => Math.floor(untagNumber(x))),
+  max: new LuaBuiltinFunction((_sf, ...args: number[]) =>
+    Math.max(...args.map(untagNumber))
+  ),
+  min: new LuaBuiltinFunction((_sf, ...args: number[]) =>
+    Math.min(...args.map(untagNumber))
+  ),
+
+  // Rounding and remainder
+  fmod: new LuaBuiltinFunction((_sf, x: number, y: number) =>
+    untagNumber(x) % untagNumber(y)
+  ),
+  modf: new LuaBuiltinFunction((_sf, x: number) => {
+    const xn = untagNumber(x);
+    const int = Math.trunc(xn);
+    const frac = xn - int;
+    return new LuaMultiRes([int, frac]);
+  }),
+
+  // Power and logarithms
+  exp: new LuaBuiltinFunction((_sf, x: number) => Math.exp(untagNumber(x))),
+  log: new LuaBuiltinFunction((_sf, x: number, base?: number) => {
+    if (base === undefined) {
+      return Math.log(untagNumber(x));
+    }
+    return Math.log(untagNumber(x)) / Math.log(untagNumber(base));
+  }),
+  pow: new LuaBuiltinFunction((_sf, x: number, y: number) =>
+    Math.pow(untagNumber(x), untagNumber(y))
+  ),
+  sqrt: new LuaBuiltinFunction((_sf, x: number) => Math.sqrt(untagNumber(x))),
+
+  // Trigonometric functions
+  cos: new LuaBuiltinFunction((_sf, x: number) => Math.cos(untagNumber(x))),
+  sin: new LuaBuiltinFunction((_sf, x: number) => Math.sin(untagNumber(x))),
+  tan: new LuaBuiltinFunction((_sf, x: number) => Math.tan(untagNumber(x))),
+  acos: new LuaBuiltinFunction((_sf, x: number) => Math.acos(untagNumber(x))),
+  asin: new LuaBuiltinFunction((_sf, x: number) => Math.asin(untagNumber(x))),
+  atan: new LuaBuiltinFunction((_sf, y: number, x?: number) => {
+    if (x === undefined) {
+      return Math.atan(untagNumber(y));
+    }
+    return Math.atan2(untagNumber(y), untagNumber(x));
+  }),
+
+  // Hyperbolic functions
+  cosh: new LuaBuiltinFunction((_sf, x: number) => Math.cosh(untagNumber(x))),
+  sinh: new LuaBuiltinFunction((_sf, x: number) => Math.sinh(untagNumber(x))),
+  tanh: new LuaBuiltinFunction((_sf, x: number) => Math.tanh(untagNumber(x))),
+
+  // Additional utility
+  deg: new LuaBuiltinFunction((_sf, x: number) =>
+    untagNumber(x) * 180 / Math.PI
+  ),
+  rad: new LuaBuiltinFunction((_sf, x: number) =>
+    untagNumber(x) * Math.PI / 180
+  ),
+  ult: new LuaBuiltinFunction((_sf, m: number, n: number) => {
+    return (untagNumber(m) >>> 0) < (untagNumber(n) >>> 0);
+  }),
+
+  // Keep the cosineSimilarity utility function
+  cosineSimilarity: new LuaBuiltinFunction(
+    (sf, vecA: LuaTable | number[], vecB: LuaTable | number[]) => {
+      if (vecA instanceof LuaTable) {
+        vecA = vecA.toJSArray();
+      }
+      if (vecB instanceof LuaTable) {
+        vecB = vecB.toJSArray();
+      }
+
+      if (vecA.length !== vecB.length) {
+        throw new LuaRuntimeError("Vectors must be of the same length", sf);
+      }
+
+      let dotProduct = 0;
+      let normA = 0;
+      let normB = 0;
+
+      for (let i = 0; i < vecA.length; i++) {
+        dotProduct += vecA[i] * vecB[i];
+        normA += vecA[i] ** 2;
+        normB += vecB[i] ** 2;
+      }
+
+      return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    },
+  ),
+});

package/client/space_lua/stdlib/net.ts

@@ -0,0 +1,113 @@
+import type { Client } from "../../client.ts";
+import type {
+  ProxyFetchRequest,
+  ProxyFetchResponse,
+} from "../../plugos/proxy_fetch.ts";
+import { fsEndpoint } from "../../spaces/constants.ts";
+import { LuaNativeJSFunction, LuaTable } from "../runtime.ts";
+
+export const netApi = new LuaTable({
+  proxyFetch: new LuaNativeJSFunction(
+    async (
+      url: string,
+      options: ProxyFetchRequest = {},
+    ): Promise<ProxyFetchResponse> => {
+      // JSONify any non-serializable body
+      if (
+        options?.body && typeof options.body !== "string" &&
+        !(options.body instanceof Uint8Array)
+      ) {
+        options.body = JSON.stringify(options.body);
+      }
+      const fetchOptions = options
+        ? {
+          method: options.method,
+          headers: {} as Record<string, string>,
+          body: options.body,
+        }
+        : {};
+      fetchOptions.headers = buildProxyHeaders(options.headers);
+      const resp = await client.httpSpacePrimitives.authenticatedFetch(
+        buildProxyUrl(client, url),
+        fetchOptions,
+      );
+      if (resp.status !== 200) {
+        return {
+          ok: false,
+          status: resp.status,
+          headers: extractProxyHeaders(resp.headers),
+          body: await resp.text(),
+        };
+      }
+      // Do sensible things with the body based on the content type
+      let body: any;
+      const contentTypeHeader = options.responseEncoding ||
+        resp.headers.get("x-proxy-header-content-type");
+      const statusCode = +(resp.headers.get("x-proxy-status-code") || "200");
+      if (contentTypeHeader?.startsWith("application/json")) {
+        body = await resp.json();
+      } else if (
+        contentTypeHeader?.startsWith("application/xml") ||
+        contentTypeHeader?.startsWith("text/")
+      ) {
+        body = await resp.text();
+      } else {
+        body = new Uint8Array(await resp.arrayBuffer());
+      }
+      return {
+        ok: resp.ok,
+        status: statusCode,
+        headers: extractProxyHeaders(resp.headers),
+        body: body,
+      };
+    },
+  ),
+  readURI: new LuaNativeJSFunction(
+    (uri: string, options: { uri?: string; encoding?: string } = {}) => {
+      options.uri = uri;
+      return client.clientSystem.serviceRegistry.invokeBestMatch(
+        "net.readURI:" + uri,
+        options,
+      );
+    },
+  ),
+  writeURI: new LuaNativeJSFunction(
+    (uri: string, content: string | Uint8Array) => {
+      return client.clientSystem.serviceRegistry.invokeBestMatch(
+        "net.writeURI:" + uri,
+        { uri, content },
+      );
+    },
+  ),
+});
+
+// Utility functions
+function buildProxyUrl(client: Client, url: string) {
+  url = url.replace(/^https?:\/\//, "");
+  // Strip off the /.fs and replace with /.proxy
+  return client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length) +
+    "/.proxy/" + url;
+}
+
+function buildProxyHeaders(headers?: Record<string, any>): Record<string, any> {
+  const newHeaders: Record<string, any> = { "X-Proxy-Request": "true" };
+  if (!headers) {
+    return newHeaders;
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    newHeaders[`X-Proxy-Header-${key}`] = value;
+  }
+  return newHeaders;
+}
+
+function extractProxyHeaders(
+  headers: Headers,
+): Record<string, any> {
+  const newHeaders: Record<string, any> = {};
+  for (const [key, value] of headers.entries()) {
+    if (key.toLowerCase().startsWith("x-proxy-header-")) {
+      newHeaders[key.slice("x-proxy-header-".length)] = value;
+    }
+  }
+  return newHeaders;
+}