@gmickel/gno 1.34.4 → 1.34.6

package/src/store/sqlite/adapter.ts

@@ -211,6 +211,51 @@ const SINGLE_LINE_QUERY_PATTERN = /[\r\n]/;
 const DOUBLE_QUOTE_PATTERN = /"/g;
 const DOC_EDGE_TYPE_PATTERN = /^[a-z][a-z0-9_]*$/;
 const SQLITE_SAFE_PARAMETER_BATCH_SIZE = 900;
+
+/**
+ * Effective physical source path for watcher fallback queries.
+ * Record-container logical rows resolve to their source container path.
+ */
+const WATCHER_SOURCE_PATH_SQL =
+  "COALESCE(NULLIF(record_source_path, ''), rel_path)";
+
+/**
+ * Parent directory of the effective source path (POSIX), with the collection
+ * root represented as the empty string.
+ */
+const WATCHER_SOURCE_PARENT_SQL = `CASE WHEN instr(${WATCHER_SOURCE_PATH_SQL}, '/') = 0 THEN '' ELSE substr(${WATCHER_SOURCE_PATH_SQL}, 1, length(rtrim(${WATCHER_SOURCE_PATH_SQL}, replace(${WATCHER_SOURCE_PATH_SQL}, '/', ''))) - 1) END`;
+
+/**
+ * Normalize a collection-relative directory argument for watcher source-path
+ * queries. Returns null for absolute, drive-shaped, or escaping paths.
+ */
+function normalizeWatcherSourceDirRelPath(dirRelPath: string): string | null {
+  const normalized = dirRelPath.replaceAll("\\", "/");
+  if (normalized.startsWith("/")) {
+    return null;
+  }
+  const segments: string[] = [];
+  for (const segment of normalized.split("/")) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      return null;
+    }
+    segments.push(segment);
+  }
+  const canonical = segments.join("/");
+  // `C:` / `C:/foo` after stripping `.` is a Windows absolute escape.
+  // A single segment like `a:notes` (no slash after the colon) stays legal.
+  if (
+    /^[A-Za-z]:(\/|$)/.test(canonical) &&
+    (canonical.length === 2 || canonical[2] === "/")
+  ) {
+    return null;
+  }
+  return canonical;
+}
+
 const FTS5_FIELD_WEIGHTS = {
   filepath: 1.5,
   title: 4.0,
@@ -1664,6 +1709,152 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     }
   }
 
+  async listActiveDirectChildSourcePaths(
+    collection: string,
+    dirRelPath: string,
+    max: number
+  ): Promise<StoreResult<string[]>> {
+    if (!Number.isInteger(max) || max <= 0) {
+      return err("INVALID_INPUT", "max must be a positive integer");
+    }
+    const parentPath = normalizeWatcherSourceDirRelPath(dirRelPath);
+    if (parentPath === null) {
+      return err(
+        "INVALID_INPUT",
+        `Directory path escapes the collection root: ${dirRelPath}`
+      );
+    }
+
+    try {
+      const db = this.ensureOpen();
+      // Effective source path: record containers resolve to physical container.
+      // Parent key: empty string for root-level sources.
+      // LIMIT max+1 detects overflow without returning a truncated success.
+      const rows = db
+        .query<{ source_path: string }, [string, string, number]>(
+          `SELECT DISTINCT ${WATCHER_SOURCE_PATH_SQL} AS source_path
+           FROM documents
+           WHERE collection = ?
+             AND active = 1
+             AND ${WATCHER_SOURCE_PARENT_SQL} = ?
+           ORDER BY source_path ASC
+           LIMIT ?`
+        )
+        .all(collection, parentPath, max + 1);
+
+      if (rows.length > max) {
+        return err(
+          "OVERFLOW",
+          `Active direct-child source paths exceed max=${max}`
+        );
+      }
+      return ok(rows.map((row) => row.source_path));
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error
+          ? cause.message
+          : "Failed to list active direct child source paths",
+        cause
+      );
+    }
+  }
+
+  async listActiveDescendantSourcePaths(
+    collection: string,
+    dirRelPath: string,
+    max: number
+  ): Promise<StoreResult<string[]>> {
+    if (!Number.isInteger(max) || max <= 0) {
+      return err("INVALID_INPUT", "max must be a positive integer");
+    }
+    const directory = normalizeWatcherSourceDirRelPath(dirRelPath);
+    if (directory === null) {
+      return err(
+        "INVALID_INPUT",
+        `Directory path escapes the collection root: ${dirRelPath}`
+      );
+    }
+    if (directory === "") {
+      return err(
+        "INVALID_INPUT",
+        "Descendant lookup requires a directory below the collection root"
+      );
+    }
+
+    try {
+      const db = this.ensureOpen();
+      // Exact prefix boundary: `dir1/` never matches `dir10/...`.
+      // length(?) is code-point-safe (JS prefix.length is UTF-16 and breaks non-BMP).
+      // LIMIT max+1 detects overflow without returning a truncated success.
+      const prefix = `${directory}/`;
+      const rows = db
+        .query<{ source_path: string }, [string, string, string, number]>(
+          `SELECT DISTINCT ${WATCHER_SOURCE_PATH_SQL} AS source_path
+           FROM documents
+           WHERE collection = ?
+             AND active = 1
+             AND substr(${WATCHER_SOURCE_PATH_SQL}, 1, length(?)) = ?
+           ORDER BY source_path ASC
+           LIMIT ?`
+        )
+        .all(collection, prefix, prefix, max + 1);
+
+      if (rows.length > max) {
+        return err(
+          "OVERFLOW",
+          `Active descendant source paths exceed max=${max}`
+        );
+      }
+      return ok(rows.map((row) => row.source_path));
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error
+          ? cause.message
+          : "Failed to list active descendant source paths",
+        cause
+      );
+    }
+  }
+
+  async listActiveSourcePaths(
+    collection: string,
+    max: number
+  ): Promise<StoreResult<string[]>> {
+    if (!Number.isInteger(max) || max <= 0) {
+      return err("INVALID_INPUT", "max must be a positive integer");
+    }
+
+    try {
+      const db = this.ensureOpen();
+      // Root-wide DISTINCT physical sources; overflow after collapse (max+1).
+      const rows = db
+        .query<{ source_path: string }, [string, number]>(
+          `SELECT DISTINCT ${WATCHER_SOURCE_PATH_SQL} AS source_path
+           FROM documents
+           WHERE collection = ?
+             AND active = 1
+           ORDER BY source_path ASC
+           LIMIT ?`
+        )
+        .all(collection, max + 1);
+
+      if (rows.length > max) {
+        return err("OVERFLOW", `Active source paths exceed max=${max}`);
+      }
+      return ok(rows.map((row) => row.source_path));
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error
+          ? cause.message
+          : "Failed to list active source paths",
+        cause
+      );
+    }
+  }
+
   async listActiveDocumentsForBrowse(
     collection?: string
   ): Promise<StoreResult<DocumentRow[]>> {

package/src/store/types.ts

@@ -24,6 +24,13 @@ import type {
 // Error Types
 // ─────────────────────────────────────────────────────────────────────────────
 
+/**
+ * Fixed service default maximum for watcher active source-path queries.
+ * Callers (watcher fallback later) pass this explicitly; methods never invent
+ * an unbounded success path.
+ */
+export const WATCHER_ACTIVE_SOURCE_PATH_MAX = 100_000;
+
 /** Store error codes */
 export type StoreErrorCode =
   | "NOT_FOUND"
@@ -38,6 +45,8 @@ export type StoreErrorCode =
   | "IO_ERROR"
   | "INTERNAL"
   | "EGRESS_DENIED"
+  /** Result set exceeded the caller-supplied positive maximum (never truncated). */
+  | "OVERFLOW"
   // Vector-specific error codes (EPIC 7)
   | "VECTOR_WRITE_FAILED"
   | "VECTOR_DELETE_FAILED"
@@ -1688,6 +1697,63 @@ export interface StorePort {
     sourcePath: string
   ): Promise<StoreResult<DocumentRow[]>>;
 
+  /**
+   * List distinct effective source paths of ACTIVE documents that are direct
+   * children of `dirRelPath` within `collection`.
+   *
+   * Effective source path is `COALESCE(NULLIF(record_source_path, ''), rel_path)`
+   * so record-container logical documents resolve to their physical container
+   * path. Deeper descendants, inactive rows, and other collections are excluded.
+   *
+   * `dirRelPath` is collection-relative and POSIX-style; the collection root is
+   * `""`. Paths that escape the collection root are rejected with
+   * `INVALID_INPUT`. An empty successful result is distinct from query failure.
+   *
+   * `max` must be a positive integer (see `WATCHER_ACTIVE_SOURCE_PATH_MAX` for
+   * the fixed service default the watcher will pass). Matching rows beyond
+   * `max` yield `OVERFLOW` — never a truncated successful list.
+   */
+  listActiveDirectChildSourcePaths(
+    collection: string,
+    dirRelPath: string,
+    max: number
+  ): Promise<StoreResult<string[]>>;
+
+  /**
+   * List distinct effective source paths of ACTIVE documents anywhere beneath
+   * `dirRelPath` (direct children and deeper descendants).
+   *
+   * Used when a directory is gone from disk so the whole removed subtree can be
+   * reconciled. Prefix containment is exact (`dir1` never matches `dir10/x.md`).
+   *
+   * `dirRelPath` must name a directory below the collection root: `""` is
+   * rejected with `INVALID_INPUT` because a root-wide scan is intentionally out
+   * of scope for this bounded seam. Escaping paths are also `INVALID_INPUT`.
+   *
+   * `max` must be a positive integer (see `WATCHER_ACTIVE_SOURCE_PATH_MAX` for
+   * the fixed service default the watcher will pass). Matching rows beyond
+   * `max` yield `OVERFLOW` — never a truncated successful list.
+   */
+  listActiveDescendantSourcePaths(
+    collection: string,
+    dirRelPath: string,
+    max: number
+  ): Promise<StoreResult<string[]>>;
+
+  /**
+   * Root-wide bounded DISTINCT active physical source paths for one collection.
+   *
+   * Effective source path is `COALESCE(NULLIF(record_source_path, ''), rel_path)`.
+   * Overflow is decided after DISTINCT collapse (`LIMIT max+1`), never on raw
+   * logical document row counts. Inactive rows and other collections are excluded.
+   * Results are ordered ascending. Matching unique sources beyond `max` yield
+   * `OVERFLOW` — never a truncated successful list.
+   */
+  listActiveSourcePaths(
+    collection: string,
+    max: number
+  ): Promise<StoreResult<string[]>>;
+
   /**
    * Fetch documents by mirror hashes in batch.
    * Useful for retrieval pipelines to avoid full document scans.

package/vendor/fts5-snowball/README.md

@@ -15,7 +15,11 @@ Prebuilt [fts5-snowball](https://github.com/abiliojr/fts5-snowball) SQLite exten
 
 Built via GitHub Actions: `.github/workflows/build-fts5-snowball.yml`
 
-Source: https://github.com/abiliojr/fts5-snowball (commit from main branch)
+Source: https://github.com/abiliojr/fts5-snowball at commit
+`f2a5450af5ce810cc3f981ff1ea8de2b4ff82a67`.
+
+The macOS build jobs verify the runner architecture, the emitted Mach-O
+architecture, and a real stemming query through Homebrew SQLite before upload.
 
 ## Supported Languages
 

package/browser-extension/artifacts/gno-browser-clipper-v1.34.4.zip.sha256

@@ -1 +0,0 @@
-645e1362d74ccaf55611a0d81d085de321106ee8befc6c3639870365655bd942  gno-browser-clipper-v1.34.4.zip