@silverbulletmd/silverbullet 2.9.0 → 2.11.0

package/client/space_lua/pretty_print.ts

@@ -29,9 +29,28 @@ function resolveOptions(opts?: PrintOptions): ResolvedOptions {
 }
 
 const RESERVED = new Set([
-  "and", "break", "do", "else", "elseif", "end", "false", "for", "function",
-  "goto", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then",
-  "true", "until", "while",
+  "and",
+  "break",
+  "do",
+  "else",
+  "elseif",
+  "end",
+  "false",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "in",
+  "local",
+  "nil",
+  "not",
+  "or",
+  "repeat",
+  "return",
+  "then",
+  "true",
+  "until",
+  "while",
 ]);
 
 function isLuaIdentifier(s: string): boolean {
@@ -39,16 +58,26 @@ function isLuaIdentifier(s: string): boolean {
 }
 
 const BINARY_PREC: Record<string, number> = {
-  "or": 1,
-  "and": 2,
-  "<": 3, ">": 3, "<=": 3, ">=": 3, "~=": 3, "==": 3,
+  or: 1,
+  and: 2,
+  "<": 3,
+  ">": 3,
+  "<=": 3,
+  ">=": 3,
+  "~=": 3,
+  "==": 3,
   "|": 4,
   "~": 5, // binary bitwise xor
   "&": 6,
-  "<<": 7, ">>": 7,
+  "<<": 7,
+  ">>": 7,
   "..": 8,
-  "+": 9, "-": 9,
-  "*": 10, "/": 10, "//": 10, "%": 10,
+  "+": 9,
+  "-": 9,
+  "*": 10,
+  "/": 10,
+  "//": 10,
+  "%": 10,
   "^": 12,
 };
 const UNARY_PREC = 11;
@@ -62,7 +91,7 @@ function exprPrec(e: LuaExpression): number {
 }
 
 class Printer {
-  constructor(private opts: ResolvedOptions) { }
+  constructor(private opts: ResolvedOptions) {}
 
   private indent(depth: number): string {
     return " ".repeat(depth * this.opts.indentWidth);
@@ -129,22 +158,29 @@ class Printer {
       case "TableConstructor":
         return this.tableConstructor(e.fields, depth);
       case "FunctionDefinition":
-        return "function" +
-          this.functionRest(e.body.parameters, e.body.block, depth);
+        return `function${this.functionRest(
+          e.body.parameters,
+          e.body.block,
+          depth,
+        )}`;
       case "FunctionCall":
         return this.functionCall(e, depth);
       case "Query": {
-        const lines = e.clauses.map((c) =>
-          this.indent(depth + 1) + this.queryClause(c, depth + 1)
+        const lines = e.clauses.map(
+          (c) => this.indent(depth + 1) + this.queryClause(c, depth + 1),
         );
         return `query[[\n${lines.join("\n")}\n${this.indent(depth)}]]`;
       }
       case "FilteredCall":
-        return `${this.expression(e.call, depth)} filter ${this.expression(e.filter, depth)
-          }`;
+        return `${this.expression(e.call, depth)} filter ${this.expression(
+          e.filter,
+          depth,
+        )}`;
       case "AggregateCall":
-        return `${this.expression(e.call, depth)} order by ${this.orderByList(e.orderBy, depth)
-          }`;
+        return `${this.expression(e.call, depth)} order by ${this.orderByList(
+          e.orderBy,
+          depth,
+        )}`;
       default:
         throw new Error(
           `pretty_print: unsupported expression type: ${(e as any).type}`,
@@ -193,8 +229,8 @@ class Printer {
   private tableConstructor(fields: LuaTableField[], depth: number): string {
     if (fields.length === 0) return "{}";
     if (fields.length === 1) return `{${this.field(fields[0], depth)}}`;
-    const lines = fields.map((f) =>
-      this.indent(depth + 1) + this.field(f, depth + 1)
+    const lines = fields.map(
+      (f) => this.indent(depth + 1) + this.field(f, depth + 1),
     );
     const tail = this.opts.trailingComma ? "," : "";
     return `{\n${lines.join(",\n")}${tail}\n${this.indent(depth)}}`;
@@ -224,7 +260,8 @@ class Printer {
       ? ` order by ${this.orderByList(e.orderBy, depth)}`
       : "";
     if (
-      !e.orderBy && args.length === 1 &&
+      !e.orderBy &&
+      args.length === 1 &&
       (args[0].type === "TableConstructor" || args[0].type === "String")
     ) {
       return `${base} ${this.expression(args[0], depth)}`;
@@ -254,8 +291,10 @@ class Printer {
       case "Where":
         return `where ${this.expression(c.expression, depth)}`;
       case "Limit":
-        return `limit ${this.expression(c.limit, depth)}` +
-          (c.offset ? ` offset ${this.expression(c.offset, depth)}` : "");
+        return (
+          `limit ${this.expression(c.limit, depth)}` +
+          (c.offset ? ` offset ${this.expression(c.offset, depth)}` : "")
+        );
       case "Offset":
         return `offset ${this.expression(c.offset, depth)}`;
       case "OrderBy":
@@ -271,16 +310,32 @@ class Printer {
 
   block(b: LuaBlock, depth: number): string {
     const stmts = b.statements.filter((s) => s.type !== "Semicolon");
-    const isDef = (s: LuaStatement) =>
+    const items: (LuaStatement | NonNullable<LuaBlock["comments"]>[number])[] =
+      [...stmts, ...(b.comments ?? [])].sort(
+        (a, z) => (a.ctx.from ?? 0) - (z.ctx.from ?? 0),
+      );
+    const isDef = (s: (typeof items)[number]) =>
       s.type === "Function" || s.type === "LocalFunction";
     let out = "";
-    for (let i = 0; i < stmts.length; i++) {
+    for (let i = 0; i < items.length; i++) {
       if (i > 0) {
         out += "\n";
         // blank line separating function definitions from neighbours
-        if (isDef(stmts[i - 1]) || isDef(stmts[i])) out += "\n";
+        const previous = items[i - 1];
+        const isDocumentationPair =
+          previous.type === "Comment" &&
+          previous.text.startsWith("---") &&
+          isDef(items[i]);
+        if (!isDocumentationPair && (isDef(previous) || isDef(items[i]))) {
+          out += "\n";
+        }
       }
-      out += this.statement(stmts[i], depth);
+      const item = items[i];
+      out +=
+        item.type === "Comment"
+          ? this.indent(depth) +
+            item.text.replaceAll("\n", `\n${this.indent(depth)}`)
+          : this.statement(item, depth);
     }
     return out;
   }
@@ -290,11 +345,14 @@ class Printer {
     switch (s.type) {
       case "Local": {
         const names = s.names
-          .map((n) =>
-            n.name +
-            (n.attribute
-              ? ` <${n.attribute}>`
-              : (n.attributes?.length ? ` <${n.attributes[0]}>` : ""))
+          .map(
+            (n) =>
+              n.name +
+              (n.attribute
+                ? ` <${n.attribute}>`
+                : n.attributes?.length
+                  ? ` <${n.attributes[0]}>`
+                  : ""),
           )
           .join(", ");
         const exprs = s.expressions?.length
@@ -303,12 +361,16 @@ class Printer {
         return `${ind}local ${names}${exprs}`;
       }
       case "Assignment":
-        return `${ind}${s.variables.map((v) => this.expression(v, depth)).join(", ")
-          } = ${s.expressions.map((e) => this.expression(e, depth)).join(", ")}`;
+        return `${ind}${s.variables
+          .map((v) => this.expression(v, depth))
+          .join(
+            ", ",
+          )} = ${s.expressions.map((e) => this.expression(e, depth)).join(", ")}`;
       case "Return":
         return s.expressions.length
-          ? `${ind}return ${s.expressions.map((e) => this.expression(e, depth)).join(", ")
-          }`
+          ? `${ind}return ${s.expressions
+              .map((e) => this.expression(e, depth))
+              .join(", ")}`
           : `${ind}return`;
       case "FunctionCallStatement":
         return ind + this.expression(s.call, depth);
@@ -328,7 +390,8 @@ class Printer {
           const kw = i === 0 ? "if" : "elseif";
           const head = i === 0 ? `${ind}${kw} ` : `\n${ind}${kw} `;
           const body = this.block(c.block, depth + 1);
-          out += `${head}${this.expression(c.condition, depth)} then` +
+          out +=
+            `${head}${this.expression(c.condition, depth)} then` +
             (body ? `\n${body}` : "");
         });
         if (s.elseBlock) {
@@ -340,34 +403,48 @@ class Printer {
       }
       case "While": {
         const body = this.block(s.block, depth + 1);
-        return `${ind}while ${this.expression(s.condition, depth)} do` +
-          (body ? `\n${body}` : "") + `\n${ind}end`;
+        return (
+          `${ind}while ${this.expression(s.condition, depth)} do` +
+          (body ? `\n${body}` : "") +
+          `\n${ind}end`
+        );
       }
       case "Repeat": {
         const body = this.block(s.block, depth + 1);
-        return `${ind}repeat` + (body ? `\n${body}` : "") +
-          `\n${ind}until ${this.expression(s.condition, depth)}`;
+        return (
+          `${ind}repeat` +
+          (body ? `\n${body}` : "") +
+          `\n${ind}until ${this.expression(s.condition, depth)}`
+        );
       }
       case "For": {
         const step = s.step ? `, ${this.expression(s.step, depth)}` : "";
         const body = this.block(s.block, depth + 1);
-        return `${ind}for ${s.name} = ${this.expression(s.start, depth)}, ${this.expression(s.end, depth)
-          }${step} do${body ? `\n${body}` : ""}\n${ind}end`;
+        return `${ind}for ${s.name} = ${this.expression(s.start, depth)}, ${this.expression(
+          s.end,
+          depth,
+        )}${step} do${body ? `\n${body}` : ""}\n${ind}end`;
       }
       case "ForIn": {
         const body = this.block(s.block, depth + 1);
-        return `${ind}for ${s.names.join(", ")} in ${s.expressions.map((e) => this.expression(e, depth)).join(", ")
-          } do${body ? `\n${body}` : ""}\n${ind}end`;
+        return `${ind}for ${s.names.join(", ")} in ${s.expressions
+          .map((e) => this.expression(e, depth))
+          .join(", ")} do${body ? `\n${body}` : ""}\n${ind}end`;
       }
       case "Function": {
-        const name = s.name.propNames.join(".") +
+        const name =
+          s.name.propNames.join(".") +
           (s.name.colonName ? `:${s.name.colonName}` : "");
-        return `${ind}function ${name}` +
-          this.functionRest(s.body.parameters, s.body.block, depth);
+        return (
+          `${ind}function ${name}` +
+          this.functionRest(s.body.parameters, s.body.block, depth)
+        );
       }
       case "LocalFunction":
-        return `${ind}local function ${s.name}` +
-          this.functionRest(s.body.parameters, s.body.block, depth);
+        return (
+          `${ind}local function ${s.name}` +
+          this.functionRest(s.body.parameters, s.body.block, depth)
+        );
       default:
         throw new Error(
           `pretty_print: unsupported statement type: ${(s as any).type}`,
@@ -383,9 +460,6 @@ export function prettyPrintExpression(
   return new Printer(resolveOptions(opts)).expression(expr, 0);
 }
 
-export function prettyPrintBlock(
-  block: LuaBlock,
-  opts?: PrintOptions,
-): string {
+export function prettyPrintBlock(block: LuaBlock, opts?: PrintOptions): string {
   return new Printer(resolveOptions(opts)).block(block, 0);
 }

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,11 +171,8 @@ 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[]) { }
+  constructor(private readonly array: T[]) {}
   query(
     query: LuaCollectionQuery,
     env: LuaEnv,
@@ -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]);
           }
@@ -842,12 +803,11 @@ export async function applyQuery(
 
   const mkEnv = grouped
     ? (ov: string | undefined, item: any, e: LuaEnv, s: LuaStackFrame) =>
-      buildGroupItemEnv(ov, groupByNames, item, e, s)
+        buildGroupItemEnv(ov, groupByNames, item, e, s)
     : buildItemEnvLocal;
 
   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(
@@ -1002,7 +958,7 @@ export async function queryLua<T = any>(
   for await (let { key, value } of kv.query({ prefix })) {
     if (enricher) {
       value = enricher(key, value);
-      // Enrichers may return undefined to filter a row out 
+      // Enrichers may return undefined to filter a row out
       if (value === undefined) continue;
     }
     results.push(value);
@@ -1056,7 +1012,7 @@ export class DataStoreQueryCollection implements LuaQueryCollection {
   constructor(
     private readonly dataStore: DataStore,
     readonly prefix: string[],
-  ) { }
+  ) {}
   query(
     query: LuaCollectionQuery,
     env: LuaEnv,

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);