@silverbulletmd/silverbullet 2.10.0 → 2.11.0

package/client/space_lua/numeric.ts

@@ -7,7 +7,6 @@ export interface LuaTaggedFloat {
   readonly isFloat: true;
 }
 
-// Pre-allocated singletons for float zeros
 const FLOAT_POS_ZERO: LuaTaggedFloat = { value: 0, isFloat: true };
 const FLOAT_NEG_ZERO: LuaTaggedFloat = { value: -0, isFloat: true };
 
@@ -159,7 +158,6 @@ export function coerceNumericPair(
 ): CoerceNumericPairResult {
   const forceFloat = op === "/" || op === "^";
 
-  // Both plain numbers
   if (typeof a === "number" && typeof b === "number") {
     const lt = leftType ?? inferNumericType(a);
     const rt = rightType ?? inferNumericType(b);
@@ -175,7 +173,6 @@ export function coerceNumericPair(
     };
   }
 
-  // One tagged float, one plain number
   if (typeof a === "number" && isTaggedFloat(b)) {
     return {
       left: a,
@@ -192,7 +189,6 @@ export function coerceNumericPair(
     };
   }
 
-  // Both tagged floats
   if (isTaggedFloat(a) && isTaggedFloat(b)) {
     return {
       left: a.value,
@@ -201,7 +197,6 @@ export function coerceNumericPair(
     };
   }
 
-  // General fallback
   const A = coerceNumeric(a, leftType);
   const B = coerceNumeric(b, rightType);
 

package/client/space_lua/parse.ts

@@ -50,7 +50,6 @@ const customIndent = indentNodeProp.add({
   },
 });
 
-// Use the customIndent in your language support
 export const luaLanguage = LRLanguage.define({
   name: "space-lua",
   parser: parser.configure({
@@ -547,7 +546,6 @@ function functionBodyCapturesNames(
   return blockReferencesNames(body.block, check);
 }
 
-// Walk block using `exprReferencesNames` (inside a function body).
 function blockReferencesNames(block: LuaBlock, names: Set<string>): boolean {
   for (let i = 0; i < block.statements.length; i++) {
     if (statementReferencesNames(block.statements[i], names)) return true;
@@ -650,7 +648,6 @@ function statementReferencesNames(
   }
 }
 
-// Walk block looking for `FunctionDefinition` nodes that capture `names`.
 function blockCapturesNames(block: LuaBlock, names: Set<string>): boolean {
   for (let i = 0; i < block.statements.length; i++) {
     if (statementCapturesNames(block.statements[i], names)) return true;
@@ -743,8 +740,6 @@ function statementCapturesNames(s: LuaStatement, names: Set<string>): boolean {
   }
 }
 
-// At loop block level find `FunctionDefinition` and check if it
-// captures `names`.
 function exprCapturesNames(e: LuaExpression, names: Set<string>): boolean {
   if (!e) return false;
   switch (e.type) {
@@ -871,7 +866,6 @@ function parseBlockNode(t: ParseTree, ctx: ASTCtx): LuaBlock {
       case "Label": {
         hasLabel = true;
         hasLabelHere = true;
-        // Duplicate labels in the same block are illegal
         const name = (s as any).name as string;
         if (!dup) {
           if (seen.has(name)) {
@@ -1207,7 +1201,6 @@ function parseStatement(t: ParseTree, ctx: ASTCtx): LuaStatement {
     case "break":
       return { type: "Break", ctx: context(t, ctx) };
     default:
-      // Gracefully ignore unknown empty nodes
       if (!t.children || t.children.length === 0) {
         return {
           type: "Semicolon",
@@ -1363,10 +1356,7 @@ function parseExpList(t: ParseTree, ctx: ASTCtx): LuaExpression[] {
 
 const delimiterRegex = /^(\[=*\[)([\s\S]*)(\]=*\])$/;
 
-// In case of quoted strings, remove the quotes and unescape the string
-// In case of a [[ type ]] literal string, remove the brackets
 function parseString(s: string): string {
-  // Handle long strings with delimiters
   const delimiterMatch = s.match(delimiterRegex);
   if (delimiterMatch) {
     let text = delimiterMatch[2];
@@ -1403,11 +1393,9 @@ function parseString(s: string): string {
           case "'":
             return "'"; // Single quote
           default:
-            // Handle hexadecimal \x00
             if (capture.startsWith("x")) {
               return String.fromCharCode(parseInt(capture.slice(1), 16));
             }
-            // Handle unicode \u{XXXX}
             if (capture.startsWith("u{")) {
               const codePoint = parseInt(capture.slice(2, -1), 16);
               return String.fromCodePoint(codePoint);
@@ -1435,7 +1423,6 @@ function parseExpression(t: ParseTree, ctx: ASTCtx): LuaExpression {
       const text = t.children![0].text!.toLowerCase();
       return {
         type: "Number",
-        // Use the integer parser fox 0x literals
         // biome-ignore lint/correctness/useParseIntRadix: hex strings need auto-detect radix
         value: text.includes("x") ? parseInt(text) : parseFloat(text),
         numericType: /[.eEpP]/.test(text) ? "float" : "int",
@@ -1651,7 +1638,6 @@ function parseQueryClause(t: ParseTree, ctx: ASTCtx): LuaQueryClause {
   }
 }
 
-// Parse a single OrderBy node (shared by query OrderByClause and AggOrderBy)
 function parseOrderByNode(child: ParseTree, ctx: ASTCtx): LuaOrderBy {
   const kids = child.children!;
   let direction: "asc" | "desc" = "asc";
@@ -1685,7 +1671,6 @@ function parseOrderByNode(child: ParseTree, ctx: ASTCtx): LuaOrderBy {
   return ob;
 }
 
-// Parse an AggOrderBy node into LuaOrderBy[]
 function parseAggOrderBy(t: ParseTree, ctx: ASTCtx): LuaOrderBy[] {
   if (t.type !== "AggOrderBy") {
     throw new Error(`Expected AggOrderBy, got ${t.type}`);
@@ -1699,7 +1684,6 @@ function parseAggOrderBy(t: ParseTree, ctx: ASTCtx): LuaOrderBy[] {
   return orderBy;
 }
 
-// Parse function args, extracting AggOrderBy if present inside funcParams
 function parseFunctionArgsWithOrderBy(
   ts: ParseTree[],
   ctx: ASTCtx,
@@ -1808,7 +1792,6 @@ export function parseBlock(s: string, ctx: ASTCtx = {}): LuaBlock {
     const result = parseChunk(withoutComments(concreteTree), ctx);
     assignCommentsToBlocks(result, comments, s);
     attachFunctionDocumentation(result, comments, s);
-    // console.log("Parsed AST", JSON.stringify(result, null, 2));
     getBlockGotoMeta(result);
     return result;
   } catch (e: any) {

package/client/space_lua/quarantine.ts

@@ -0,0 +1,127 @@
+export const QUARANTINE_KEY = "spaceLuaQuarantine";
+
+export type QuarantineStore = {
+  getItem(k: string): string | null;
+  setItem(k: string, v: string): void;
+};
+
+function defaultStore(): QuarantineStore {
+  return localStorage;
+}
+
+/**
+ * Dashboard can host multiple spaces on the same origin, sharing
+ * localStorage. Namespace by document.baseURI the same way boot.ts's
+ * cachedFetch does (and client.ts's deriveDbName), so one space's
+ * quarantine entries never collide with or get pruned by another's.
+ */
+export function quarantineStorageKey(): string {
+  const namespace = typeof document !== "undefined" ? document.baseURI : "";
+  return `silverbullet.${namespace}.${QUARANTINE_KEY}`;
+}
+
+export function hashScript(source: string): string {
+  let h = 2166136261;
+  for (let i = 0; i < source.length; i++) {
+    h ^= source.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+}
+
+function read(store: QuarantineStore): Record<string, string> {
+  let raw: string | null;
+  try {
+    raw = store.getItem(quarantineStorageKey());
+  } catch {
+    return {};
+  }
+  if (!raw) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function write(store: QuarantineStore, v: Record<string, string>): void {
+  try {
+    store.setItem(quarantineStorageKey(), JSON.stringify(v));
+  } catch {
+    // Quarantine is a convenience: a store that refuses to persist must never
+    // prevent scripts from loading.
+  }
+}
+
+export function isQuarantined(
+  ref: string,
+  source: string,
+  store: QuarantineStore = defaultStore(),
+): boolean {
+  const entries = read(store);
+  const stored = entries[ref];
+  if (stored === undefined) {
+    return false;
+  }
+  if (stored === hashScript(source)) {
+    return true;
+  }
+  delete entries[ref];
+  write(store, entries);
+  return false;
+}
+
+export function quarantine(
+  ref: string,
+  source: string,
+  store: QuarantineStore = defaultStore(),
+): void {
+  const entries = read(store);
+  entries[ref] = hashScript(source);
+  write(store, entries);
+}
+
+export function unquarantine(
+  ref: string,
+  store: QuarantineStore = defaultStore(),
+): void {
+  const entries = read(store);
+  delete entries[ref];
+  write(store, entries);
+}
+
+export function listQuarantined(
+  store: QuarantineStore = defaultStore(),
+): string[] {
+  return Object.keys(read(store));
+}
+
+/**
+ * Drops quarantine entries whose ref no longer appears among the live
+ * scripts. A ref changes whenever the script it belongs to moves (e.g. an
+ * edit shifts its page@charOffset), so the hash-mismatch self-heal in
+ * isQuarantined never revisits the old ref to prune it. Call this with the
+ * full live ref list before quarantine state is read for display.
+ */
+export function reconcileQuarantine(
+  liveRefs: string[],
+  store: QuarantineStore = defaultStore(),
+): void {
+  const entries = read(store);
+  const live = new Set(liveRefs);
+  let changed = false;
+  for (const ref of Object.keys(entries)) {
+    if (!live.has(ref)) {
+      delete entries[ref];
+      changed = true;
+    }
+  }
+  if (changed) {
+    write(store, entries);
+  }
+}

package/client/space_lua/query_collection.ts

@@ -33,6 +33,7 @@ import type { DataStore } from "../data/datastore.ts";
 import type { KvPrimitives } from "../data/kv_primitives.ts";
 
 import type { QueryCollationConfig } from "../../plug-api/types/config.ts";
+import { compareCollated } from "../../plug-api/lib/collation.ts";
 
 import type { KvKey } from "../../plug-api/types/datastore.ts";
 
@@ -77,7 +78,6 @@ function buildGroupItemEnv(
       itemEnv.setLocal("group", groupVal);
     }
 
-    // Unpack named fields from multi-key LuaTable keys
     if (keyVal instanceof LuaTable) {
       for (const k of luaKeys(keyVal)) {
         if (typeof k !== "string") continue;
@@ -85,12 +85,8 @@ function buildGroupItemEnv(
       }
     }
 
-    // Bind all `group by` aliases/names to their key values.  For
-    // single key bind the name to the scalar `keyVal`.  For multi-key
-    // bind each name to the field from the key table.
     if (groupByNames && groupByNames.length > 0) {
       if (!(keyVal instanceof LuaTable)) {
-        // Bind all names to scalar
         for (const gbn of groupByNames) {
           itemEnv.setLocal(gbn, keyVal);
         }
@@ -109,8 +105,6 @@ function buildGroupItemEnv(
 }
 
 /**
- * Build an environment for evaluating per-item expressions in queries.
- *
  * When `objectVariable` is NOT set: item fields are unpacked as locals
  * and shadow any globals. The item is also bound to `_`.
  *
@@ -128,7 +122,6 @@ function buildItemEnvLocal(
   if (objectVariable) {
     itemEnv.setLocal(objectVariable, item);
   } else {
-    // Unpack item fields as locals so unqualified access works
     itemEnv.setLocal("_", item);
     if (item instanceof LuaTable) {
       for (const key of luaKeys(item)) {
@@ -157,26 +150,15 @@ export type LuaGroupByEntry = {
   alias?: string;
 };
 
-/**
- * Represents a query for a collection
- */
 export type LuaCollectionQuery = {
   objectVariable?: string;
-  // The filter expression evaluated with Lua
   where?: LuaExpression;
-  // The order by expression evaluated with Lua
   orderBy?: LuaOrderBy[];
-  // The select expression evaluated with Lua
   select?: LuaExpression;
-  // The limit of the query
   limit?: number;
-  // The offset of the query
   offset?: number;
-  // Whether to return only distinct values
   distinct?: boolean;
-  // The group by entries evaluated with Lua
   groupBy?: LuaGroupByEntry[];
-  // The having expression evaluated with Lua
   having?: LuaExpression;
 };
 
@@ -189,9 +171,6 @@ export interface LuaQueryCollection {
   ): Promise<any[]>;
 }
 
-/**
- * Implements a query collection for a regular JavaScript array
- */
 export class ArrayQueryCollection<T> implements LuaQueryCollection {
   constructor(private readonly array: T[]) {}
   query(
@@ -204,7 +183,6 @@ export class ArrayQueryCollection<T> implements LuaQueryCollection {
   }
 }
 
-// Wrap any object, array, or LuaQueryCollection as a queryable collection
 export function toCollection(obj: any): LuaQueryCollection {
   if (
     obj instanceof ArrayQueryCollection ||
@@ -515,7 +493,6 @@ function resolveUsing(
   return new LuaFunction(using, env);
 }
 
-// Compare values using a custom comparator with SWO violation detection
 async function usingCompare(
   luaCmp: LuaValue,
   aVal: any,
@@ -621,7 +598,6 @@ async function sortKeyCompare(
     const aVal = aKeys[idx];
     const bVal = bKeys[idx];
 
-    // Handle nulls positioning
     const aIsNull = aVal === null || aVal === undefined || isSqlNull(aVal);
     const bIsNull = bVal === null || bVal === undefined || isSqlNull(bVal);
     if (aIsNull || bIsNull) {
@@ -646,25 +622,16 @@ async function sortKeyCompare(
         idx,
       );
       if (cmp !== 0) return cmp;
-    } else if (
-      collation?.enabled &&
-      typeof aVal === "string" &&
-      typeof bVal === "string"
-    ) {
-      const order = collator.compare(aVal, bVal);
+    } else {
+      const order = compareCollated(aVal, bVal, collation, collator);
       if (order !== 0) {
         return desc ? -order : order;
       }
-    } else if (aVal < bVal) {
-      return desc ? 1 : -1;
-    } else if (aVal > bVal) {
-      return desc ? -1 : 1;
     }
   }
   return 0;
 }
 
-// Build a select-result table from a non-aggregate select expression
 async function evalSelectExpression(
   selectExpr: LuaExpression,
   itemEnv: LuaEnv,
@@ -711,14 +678,11 @@ export async function applyQuery(
 
   const grouped = !!query.groupBy;
 
-  // Collect group-by key names for unpacking into the post-group environment.
   let groupByNames: string[] | undefined;
 
   if (query.groupBy) {
-    // Extract expressions and names from `group by` entries
     const groupByEntries = query.groupBy;
 
-    // Derive canonical name (explicit alias first, or from expression)
     groupByNames = groupByEntries
       .map((entry) => {
         if (entry.alias) return entry.alias;
@@ -740,7 +704,6 @@ export async function applyQuery(
         const entry = groupByEntries[ei];
         const v = await evalExpression(entry.expr, itemEnv, sf);
         keyParts.push(v);
-        // Use alias if provided, or from expression
         const name =
           entry.alias ??
           (entry.expr.type === "Variable" ? entry.expr.name : undefined) ??
@@ -769,11 +732,9 @@ export async function applyQuery(
           keyVal = keyParts[0];
         } else {
           const kt = new LuaTable();
-          // Always populate array indices from keyParts
           for (let i = 0; i < keyParts.length; i++) {
             kt.rawSetArrayIndex(i + 1, keyParts[i]);
           }
-          // Additionally set named fields for Variable/PropertyAccess exprs
           for (const name in keyRecord) {
             void kt.rawSet(name, keyRecord[name]);
           }
@@ -847,7 +808,6 @@ export async function applyQuery(
 
   let selectResults: any[] | undefined;
 
-  // Pre-compute select for grouped + ordered queries
   if (grouped && query.select && query.orderBy) {
     const selectExpr = query.select;
     selectResults = [];
@@ -879,7 +839,6 @@ export async function applyQuery(
       violated.push(false);
     }
 
-    // Decorate: pre-compute all sort keys once (Schwartzian transform)
     const sortKeys = await precomputeSortKeys(
       results,
       query.orderBy,
@@ -892,10 +851,8 @@ export async function applyQuery(
       config,
     );
 
-    // Tag each result with its original index for stable sorting
     const tagged = results.map((val, idx) => ({ val, idx }));
 
-    // Sort: compare cached keys only, no Lua eval in comparator
     await asyncMergeSort(tagged, (a, b) =>
       sortKeyCompare(
         a,
@@ -911,7 +868,6 @@ export async function applyQuery(
       ),
     );
 
-    // Check for SWO violations in comparators
     for (let i = 0; i < violated.length; i++) {
       if (violated[i]) {
         throw new LuaRuntimeError(

package/client/space_lua/query_env.ts

@@ -13,11 +13,9 @@ export function buildItemEnv(
 ): LuaEnv {
   const itemEnv = new LuaEnv(env);
   if (!objectVariable) {
-    // Inject all item keys as variables
     for (const key of luaKeys(item)) {
       itemEnv.setLocal(key, luaGet(item, key, sf.astCtx ?? null, sf));
     }
-    // As well as _
     itemEnv.setLocal("_", item);
   } else {
     itemEnv.setLocal(objectVariable, item);

package/client/space_lua/render_lua_markdown.ts

@@ -99,8 +99,7 @@ export type Classified =
       headers: string[];
       rowCount: number;
       getCell: (rowIndex: number, header: string) => any;
-      // LuaTable record-arrays are historically tagged as "list", while
-      // JS record-arrays are tagged as "table". Preserved for compatibility.
+      // Compatibility contract: LuaTable record-arrays use "list"; JS arrays use "table".
       dataType: "table" | "list";
     }
   | { kind: "scalarArray"; items: any[]; dataType: "list" };
@@ -138,7 +137,6 @@ export function classifyResult(result: any): Classified {
     const arrayLen = result.length;
     const hasStrKeys = keys.some((k) => typeof k === "string");
 
-    // Pure array
     if (arrayLen > 0 && !hasStrKeys) {
       const elements: any[] = [];
       for (let i = 1; i <= arrayLen; i++) elements.push(result.rawGet(i));
@@ -162,7 +160,6 @@ export function classifyResult(result: any): Classified {
       return { kind: "scalarArray", items: elements, dataType: "list" };
     }
 
-    // Has string keys (record or mixed) — single-row table
     const headers = keys.map(String);
     return {
       kind: "record",
@@ -267,9 +264,7 @@ export function renderResultToMarkdown(
 /**
  * Cell transformer for the clean-markdown (copy) path. Renders:
  *  - `ref` columns as wiki links,
- *  - scalar arrays as `<br/>`-joined lines (mirrors the HTML display
- *    path, and relies on the markdown renderer now handling self-closing
- *    `<br/>` inside GFM table cells),
+ *  - scalar arrays as `<br/>`-joined lines inside GFM table cells,
  *  - everything else via `defaultTransformer` (which Lua-encodes nested
  *    tables and escapes pipes for scalars).
  */

package/client/space_lua/render_widget.ts

@@ -11,6 +11,11 @@ import {
   luaValueToJS,
   singleResult,
 } from "./runtime.ts";
+import {
+  BUSY_LIMIT_DEFAULT_MS,
+  LuaBudgetStopped,
+  makeLuaBudget,
+} from "./budget.ts";
 import { isTaggedFloat } from "./numeric.ts";
 import {
   encodeRef,
@@ -18,6 +23,7 @@ import {
 } from "@silverbulletmd/silverbullet/lib/ref";
 import { resolveASTReference } from "../space_lua.ts";
 import type { Client } from "../client.ts";
+import { isViewValue } from "../navigator/view_value.ts";
 import {
   classifyResult,
   renderResultToCleanMarkdown,
@@ -48,6 +54,12 @@ export async function renderLuaWidgetResult(
       client.clientSystem.spaceLuaEnv.env,
       ctx,
     );
+    sf.threadState.budget = makeLuaBudget({
+      busyLimitMs: BUSY_LIMIT_DEFAULT_MS,
+      onLimit: (b) => {
+        b.stopped = true;
+      },
+    });
     const env = new LuaEnv(client.clientSystem.spaceLuaEnv.env);
     env.setLocal("_CTX", tl);
     const rawResult = singleResult(await compute(env, sf));
@@ -62,6 +74,9 @@ export async function renderLuaWidgetResult(
     }
     return luaValueToJS(rawResult, sf);
   } catch (e: any) {
+    if (e instanceof LuaBudgetStopped) {
+      return `**Lua timeout:** this widget took too long to render and was stopped. Reload the page to try again.`;
+    }
     if (e instanceof LuaRuntimeError && e.sf?.astCtx) {
       const source = resolveASTReference(e.sf.astCtx);
       if (source) {
@@ -128,6 +143,9 @@ export async function expressionToPortableMarkdown(
     expressionText,
     currentPageMeta,
   );
+  if (isViewValue(rawResult)) {
+    return { ok: false, reason: "A view has no portable Markdown rendering" };
+  }
   if (rawResult === null || rawResult === undefined) {
     return { ok: true, markdown: "" };
   }
@@ -147,7 +165,6 @@ export async function expressionToPortableMarkdown(
     }
     return { ok: false, reason: "html-only widget (no markdown rendering)" };
   }
-  // Scalars, tables, arrays, plain strings → clean GFM markdown.
   const markdown = await renderResultToCleanMarkdown(
     rawResult,
     classifyResult(rawResult),