@gmickel/gno 2.11.0 → 2.12.0

package/src/serve/public/pages/Collections.tsx

@@ -81,6 +81,8 @@ interface CollectionStats {
   documentCount: number;
   chunkCount: number;
   embeddedCount: number;
+  /** Set while the folder is missing or unreadable; documents stay indexed. */
+  rootError?: { code: string; message: string };
   include?: string[];
   models?: Partial<Record<"embed" | "rerank" | "expand" | "gen", string>>;
   effectiveModels?: Record<"embed" | "rerank" | "expand" | "gen", string>;
@@ -277,6 +279,12 @@ function CollectionCard({
             </Tooltip>
           </TooltipProvider>
         )}
+        {collection.rootError && (
+          <p className="flex items-start gap-1.5 text-amber-500 text-xs">
+            <AlertCircleIcon className="mt-0.5 size-3.5 shrink-0" />
+            <span>{collection.rootError.message}</span>
+          </p>
+        )}
       </CardHeader>
 
       <CardContent className="pt-2">

package/src/serve/public/pages/Search.tsx

@@ -174,8 +174,12 @@ export default function Search({ navigate }: PageProps) {
     query.trim().length > 0 && !structuredQueryState.ok
       ? structuredQueryState.error.message
       : null;
+  // Without vectors, Fast is keyword search unless modes or intent need the
+  // hybrid endpoint. With vectors, Fast is always hybrid (no expansion,
+  // rerank or graph), the same path as CLI `--fast`.
   const forceHybridForModes =
     thoroughness === "fast" &&
+    !hybridAvailable &&
     (queryModes.length > 0 ||
       intent.trim().length > 0 ||
       (structuredQueryState.ok &&
@@ -325,6 +329,7 @@ export default function Search({ navigate }: PageProps) {
 
       const useBm25 =
         thoroughness === "fast" &&
+        !hybridAvailable &&
         queryModes.length === 0 &&
         intent.trim().length === 0 &&
         !structuredQueryState.value.usedStructuredQuerySyntax;
@@ -403,6 +408,7 @@ export default function Search({ navigate }: PageProps) {
       activePreset,
       category,
       exclude,
+      hybridAvailable,
       intent,
       query,
       queryModes,
@@ -448,7 +454,9 @@ export default function Search({ navigate }: PageProps) {
 
   const thoroughnessDesc =
     thoroughness === "fast"
-      ? "Keyword search (BM25)"
+      ? hybridAvailable
+        ? "Hybrid, no expansion or reranking"
+        : "Keyword search (no vectors)"
       : thoroughness === "balanced"
         ? resolveDepthPolicy({ presetId: activePreset })
             .balancedExpansionEnabled

package/src/serve/resident-request.ts

@@ -2,6 +2,7 @@ import type { ResidentRuntime } from "./resident-runtime";
 /** Admission and bounded-reader boundary for resident REST reads. */
 
 import { withInferenceScope } from "../llm/inference-scope";
+import { StaleCollectionsError } from "../store/sqlite/adapter";
 import { sessionsErrorResponse } from "./routes/sessions";
 
 /**
@@ -16,6 +17,13 @@ export async function refreshResidentConfig(
     await runtime.refreshConfig?.();
     return null;
   } catch (error) {
+    // Names collections only (no paths), and says how to resolve it.
+    if (error instanceof StaleCollectionsError) {
+      return Response.json(
+        { error: { code: "STALE_COLLECTIONS", message: error.message } },
+        { status: 409 }
+      );
+    }
     return sessionsErrorResponse(error);
   }
 }

package/src/serve/resident-runtime.ts

@@ -61,7 +61,11 @@ import {
   readInstanceConfig,
 } from "../sessions/config-refresh";
 import { remoteSafeSessionsError } from "../sessions/types";
-import { SqliteAdapter } from "../store/sqlite/adapter";
+import {
+  SqliteAdapter,
+  StaleCollectionsError,
+  staleCollectionsMessage,
+} from "../store/sqlite/adapter";
 import {
   createServerContext,
   type CreateServerContextOptions,
@@ -519,10 +523,23 @@ export async function startResidentRuntime(
       return undefined;
     }
   };
+  // Another client may index a collection the served config omits after this
+  // runtime started; requests fail instead of reading it.
+  const assertServedCollections = (): void => {
+    const stale = store.staleIndexedCollections(
+      ctxHolder.config.collections.map(({ name }) => name)
+    );
+    if (stale.length > 0) {
+      throw new StaleCollectionsError(staleCollectionsMessage(stale));
+    }
+  };
   const refreshConfig = (): Promise<void> => {
     configRefresh ??= (async () => {
       const stamp = await configStamp();
-      if (stamp !== undefined && stamp === loadedConfigStamp) return;
+      if (stamp !== undefined && stamp === loadedConfigStamp) {
+        assertServedCollections();
+        return;
+      }
       const file = await readInstanceConfig(
         instance,
         deps.loadConfig ?? loadConfig
@@ -535,6 +552,7 @@ export async function startResidentRuntime(
       };
       if (Bun.deepEquals(next, served)) {
         loadedConfigStamp = stamp;
+        assertServedCollections();
         return;
       }
       await adoptServedConfig(
@@ -816,7 +834,11 @@ export async function startResidentRuntime(
         await refreshConfig();
         lastRefreshError = undefined;
       } catch (error) {
-        const message = remoteSafeSessionsError(error).message;
+        // The stale-collections message names collections, never paths.
+        const message =
+          error instanceof StaleCollectionsError
+            ? error.message
+            : remoteSafeSessionsError(error).message;
         if (message !== lastRefreshError)
           console.warn(`gno ${mode}: config not reloaded: ${message}`);
         lastRefreshError = message;

package/src/serve/spa-production-build.ts

@@ -6,6 +6,8 @@ import { tmpdir } from "node:os";
 // node:path — no Bun path utils.
 import { basename, join, relative } from "node:path";
 
+import { moduleDir, modulePath } from "../core/module-path";
+
 export const ROOT_MOUNT_MARKER = 'getElementById("root")';
 
 export type ProductionSpaFile = {
@@ -19,7 +21,8 @@ export type ProductionSpaAssets = {
   sourceHash: string;
 };
 
-const productionSpaPublicDir = (): string => join(import.meta.dir, "public");
+const productionSpaPublicDir = (): string =>
+  join(moduleDir(import.meta), "public");
 
 export const productionSpaEntryPath = (): string =>
   join(productionSpaPublicDir(), "index.html");
@@ -79,13 +82,14 @@ const contentTypeFor = (path: string): string => {
   return "application/octet-stream";
 };
 
-export const isBunfsPath = (path: string): boolean => {
+export const isBunfsPath = (path: string | undefined): boolean => {
+  if (path === undefined) return false;
   const normalized = path.replaceAll("\\", "/");
   return normalized.includes("/$bunfs/") || normalized.startsWith("B:/~BUN/");
 };
 
 export const isStandaloneExecutable = (): boolean =>
-  isBunfsPath(import.meta.path);
+  isBunfsPath(modulePath(import.meta));
 
 const rewriteProductionHtml = (html: string, jsEntryPath: string): string => {
   const script = `<script type="module" src="/${basename(jsEntryPath)}"></script>`;

package/src/serve/status-model.ts

@@ -28,6 +28,8 @@ export interface StatusCollection {
   documentCount: number;
   chunkCount: number;
   embeddedCount: number;
+  /** Present while the collection root is missing or unreadable (path-free). */
+  rootError?: { code: string; message: string };
 }
 
 export interface SuggestedCollection {

package/src/serve/status.ts

@@ -20,6 +20,10 @@ import {
   type ActivationStatus,
   buildActivationStatus,
 } from "../core/activation-status";
+import {
+  checkCollectionRoots,
+  type CollectionRootError,
+} from "../ingestion/source-availability/root";
 import { ModelCache } from "../llm/cache";
 import { envIsSet, resolveDownloadPolicy } from "../llm/policy";
 import { getActivePreset, resolveModelUri } from "../llm/registry";
@@ -263,6 +267,25 @@ function buildCollectionCheck(status: IndexStatus): HealthCheck {
   };
 }
 
+/** Folders whose root is missing or unreadable right now; null when none. */
+function buildFolderAccessCheck(
+  rootErrors: Record<string, CollectionRootError>
+): HealthCheck | null {
+  const names = Object.keys(rootErrors);
+  if (names.length === 0) {
+    return null;
+  }
+  return {
+    id: "folder-access",
+    title: "Folder access",
+    status: "warn",
+    summary: `${names.join(", ")}: folder missing or unreadable`,
+    detail: `${names.map((name) => `${name}: ${rootErrors[name]?.message}.`).join(" ")} Reconnect the drive or restore the folder; this clears as soon as it is back. If the folder moved, change the collection's path.`,
+    actionLabel: "Manage folders",
+    actionKind: "open-collections",
+  };
+}
+
 function buildIndexingCheck(status: IndexStatus): HealthCheck {
   if (status.recentErrors > 0) {
     return {
@@ -688,6 +711,7 @@ export async function buildAppStatus(
     bootstrap,
     embedCached,
     connectorTargets,
+    rootErrors,
   ] = await Promise.all([
     buildModelCheck(ctx, deps),
     buildDiskCheck(status, deps),
@@ -695,6 +719,7 @@ export async function buildAppStatus(
     buildBootstrapState(ctx),
     isModelCached(preset.embed),
     (deps.listConnectorTargets ?? getConnectorVerificationTargets)(),
+    checkCollectionRoots(ctx.config.collections),
   ]);
   const activation = await (deps.buildActivation ?? buildActivationStatus)(
     ctx.store,
@@ -712,6 +737,7 @@ export async function buildAppStatus(
   const backgroundCheck = buildBackgroundCheck(ctx, status);
   const checks = [
     buildCollectionCheck(status),
+    buildFolderAccessCheck(rootErrors),
     buildIndexingCheck(status),
     buildActivationCheck(activation),
     buildConnectorActivationCheck(activation),
@@ -746,6 +772,9 @@ export async function buildAppStatus(
       documentCount: collection.activeDocuments,
       chunkCount: collection.totalChunks,
       embeddedCount: collection.embeddedChunks,
+      ...(rootErrors[collection.name]
+        ? { rootError: rootErrors[collection.name] }
+        : {}),
     })),
     totalDocuments: status.activeDocuments,
     totalChunks: status.totalChunks,

package/src/sessions/config-refresh.ts

@@ -13,6 +13,7 @@ import type { SqliteAdapter } from "../store/sqlite/adapter";
 import { getIndexDbPath } from "../app/constants";
 import { loadConfig } from "../config";
 import { collectionEgressPolicyEpoch } from "../core/collection-egress-policy-service";
+import { StaleCollectionsError } from "../store/sqlite/adapter";
 import { assertSessionBinding } from "./binding";
 import { SessionsError } from "./types";
 
@@ -76,7 +77,12 @@ export async function adoptServedConfig(
   served: ServedSessionsConfig,
   config: Config
 ): Promise<void> {
+  // A config edit never deletes indexed collections; one it dropped fails
+  // the refresh until it is added back or `gno cleanup` deletes it.
   const collections = await served.store.syncCollections(config.collections);
+  if (!collections.ok && collections.error.code === "STALE_COLLECTIONS") {
+    throw new StaleCollectionsError(collections.error.message);
+  }
   if (!collections.ok) {
     throw new Error(
       `Config saved but collection sync failed: ${collections.error.message}`

package/src/sessions/import-child.ts

@@ -26,6 +26,7 @@ import type { Config } from "../config/types";
 import type { SessionImportReceipt } from "./types";
 
 import { getIndexDbPath } from "../app/constants";
+import { modulePath } from "../core/module-path";
 import { isStandaloneExecutable } from "../serve/spa-production-build";
 import { SqliteAdapter } from "../store/sqlite/adapter";
 import { assertSessionBinding } from "./binding";
@@ -113,7 +114,9 @@ export async function importInChildProcess(
   // Shared check: covers the POSIX `/$bunfs/` and Windows `B:/~BUN/` roots.
   const compiled = isStandaloneExecutable();
   const child = Bun.spawn({
-    cmd: compiled ? [process.execPath] : [process.execPath, import.meta.path],
+    cmd: compiled
+      ? [process.execPath]
+      : [process.execPath, modulePath(import.meta)],
     env: compiled ? { ...process.env, [IMPORT_CHILD_ENV]: "1" } : process.env,
     // The request line, then held open as the child's lifeline.
     stdin: "pipe",

package/src/store/sqlite/adapter.ts

@@ -103,8 +103,10 @@ import type {
   SavedCapsuleReverificationState,
   SavedCapsuleVerificationExpectation,
   SavedCapsuleVerificationRecord,
+  StaleCollection,
   StorePort,
   StoreResult,
+  SyncCollectionsOptions,
   TagCount,
   TagRow,
   TagSource,
@@ -585,6 +587,27 @@ function resolveBusyTimeoutMs(busyTimeoutMs?: number): number {
   return busyTimeoutMs;
 }
 
+/** The index holds collections the config omits; the message names them. */
+export class StaleCollectionsError extends Error {}
+
+/** Names the collections a config omits and how to resolve it. */
+export function staleCollectionsMessage(
+  stale: readonly StaleCollection[]
+): string {
+  const names = stale
+    .map(
+      (c) =>
+        `${c.name} (${c.documents} ${c.documents === 1 ? "document" : "documents"})`
+    )
+    .join(", ");
+  return (
+    `This index holds collections the config does not list: ${names}. ` +
+    "Nothing was changed. Add them back to the config, open a separate index " +
+    '(--index <name>, or dbPath in the SDK), or run "gno cleanup" with this ' +
+    "config to delete their index data."
+  );
+}
+
 export class SqliteAdapter implements StorePort, SqliteDbProvider {
   private db: Database | null = null;
   private dbPath = "";
@@ -898,24 +921,36 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
   // Config Sync
   // ─────────────────────────────────────────────────────────────────────────
 
-  async syncCollections(collections: Collection[]): Promise<StoreResult<void>> {
+  async syncCollections(
+    collections: Collection[],
+    options: SyncCollectionsOptions = {}
+  ): Promise<StoreResult<void>> {
+    let stale: StaleCollection[] = [];
     try {
       const db = this.ensureOpen();
 
       const transaction = db.transaction(() => {
-        // Get existing collection names
-        const existing = new Set(
-          db
-            .query<{ name: string }, []>("SELECT name FROM collections")
-            .all()
-            .map((r) => r.name)
-        );
-
-        const incoming = new Set(collections.map((c) => c.name));
-
-        // Delete removed collections
-        for (const name of existing) {
-          if (!incoming.has(name)) {
+        // Opening an index with a config never deletes indexed collections
+        // that config omits (their documents follow by cascade): a different
+        // config on the same index would wipe it. Only explicit removals do.
+        const { remove } = options;
+        const removed = new Set(remove === "stale" ? [] : remove);
+        const unlisted = this.queryStaleCollections(
+          db,
+          collections.map((c) => c.name)
+        ).filter((c) => remove !== "stale" && !removed.has(c.name));
+        // Unlisted collections without documents stay too; they only block
+        // the sync when they hold indexed documents.
+        stale = unlisted.filter((c) => c.documents > 0);
+        if (stale.length > 0 && !options.keepStale) {
+          throw new StaleCollectionsError();
+        }
+        const keep = new Set(unlisted.map((c) => c.name));
+        for (const { name } of this.queryStaleCollections(
+          db,
+          collections.map((c) => c.name)
+        )) {
+          if (!keep.has(name)) {
             db.run("DELETE FROM collections WHERE name = ?", [name]);
           }
         }
@@ -985,6 +1020,9 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
       transaction.immediate();
       return ok(undefined);
     } catch (cause) {
+      if (cause instanceof StaleCollectionsError) {
+        return err("STALE_COLLECTIONS", staleCollectionsMessage(stale));
+      }
       return err(
         "QUERY_FAILED",
         cause instanceof Error ? cause.message : "Failed to sync collections",
@@ -993,6 +1031,55 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     }
   }
 
+  async listStaleCollections(
+    configured: readonly string[]
+  ): Promise<StoreResult<StaleCollection[]>> {
+    try {
+      return ok(this.queryStaleCollections(this.ensureOpen(), configured));
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error ? cause.message : "Failed to list collections",
+        cause
+      );
+    }
+  }
+
+  /**
+   * Indexed collections `configured` omits, checked cheaply on each read of a
+   * long-lived client: another client may add a collection after it opened.
+   */
+  staleIndexedCollections(configured: readonly string[]): StaleCollection[] {
+    const db = this.ensureOpen();
+    const listed = new Set(configured);
+    const indexed = db
+      .query<{ name: string }, []>(
+        `SELECT c.name AS name FROM collections c
+         WHERE EXISTS (SELECT 1 FROM documents d WHERE d.collection = c.name)`
+      )
+      .all();
+    return indexed.some(({ name }) => !listed.has(name))
+      ? this.queryStaleCollections(db, configured).filter(
+          (c) => c.documents > 0
+        )
+      : [];
+  }
+
+  private queryStaleCollections(
+    db: Database,
+    configured: readonly string[]
+  ): StaleCollection[] {
+    const listed = new Set(configured);
+    return db
+      .query<StaleCollection, []>(
+        `SELECT c.name AS name,
+           (SELECT COUNT(*) FROM documents d WHERE d.collection = c.name) AS documents
+         FROM collections c ORDER BY c.name`
+      )
+      .all()
+      .filter((c) => !listed.has(c.name));
+  }
+
   async upsertCollections(
     collections: Collection[]
   ): Promise<StoreResult<void>> {
@@ -3119,6 +3206,64 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     }
   }
 
+  async getChunkTermPresence(
+    mirrorHashes: string[],
+    terms: string[]
+  ): Promise<
+    StoreResult<{ mirrorHash: string; seq: number; present: boolean[] }[]>
+  > {
+    try {
+      const uniqueHashes = uniqueNonEmptyValues(mirrorHashes);
+      if (uniqueHashes.length === 0 || terms.length === 0) return ok([]);
+      const db = this.ensureOpen();
+      // SQLite lower() folds ASCII only, so a non-ASCII term is also looked
+      // up in its upper-case and capitalized spellings (ÜBERBLICK, Überblick).
+      const spellings = terms.flatMap((term) => [
+        term,
+        term.toUpperCase(),
+        `${term.charAt(0).toUpperCase()}${term.slice(1)}`,
+      ]);
+      const columns = terms
+        .map(
+          () =>
+            "(instr(lower(text), ?) > 0 OR instr(text, ?) > 0 OR instr(text, ?) > 0)"
+        )
+        .join(", ");
+      const batchSize = Math.max(
+        1,
+        SQLITE_SAFE_PARAMETER_BATCH_SIZE - spellings.length
+      );
+      const rows: { mirrorHash: string; seq: number; present: boolean[] }[] =
+        [];
+      for (let i = 0; i < uniqueHashes.length; i += batchSize) {
+        const batch = uniqueHashes.slice(i, i + batchSize);
+        const values = db
+          .query<unknown, string[]>(
+            `SELECT mirror_hash, seq, ${columns} FROM content_chunks
+             WHERE mirror_hash IN (${batch.map(() => "?").join(",")})
+             ORDER BY mirror_hash, seq`
+          )
+          .values(...spellings, ...batch) as unknown[][];
+        for (const [mirrorHash, seq, ...present] of values) {
+          rows.push({
+            mirrorHash: String(mirrorHash),
+            seq: Number(seq),
+            present: present.map((flag) => flag === 1),
+          });
+        }
+      }
+      return ok(rows);
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error
+          ? cause.message
+          : "Failed to read chunk term presence",
+        cause
+      );
+    }
+  }
+
   // ─────────────────────────────────────────────────────────────────────────
   // FTS Search
   // ─────────────────────────────────────────────────────────────────────────
@@ -3143,7 +3288,6 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         WITH fts_matches AS (
           SELECT
             rowid,
-            ${options.snippet ? "snippet(documents_fts, 2, '<mark>', '</mark>', '...', 32) as snippet," : ""}
             bm25(
               documents_fts,
               ${FTS5_FIELD_WEIGHTS.filepath},
@@ -3163,7 +3307,6 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
           d.mirror_hash,
           ${options.chunkLanguage ? "(SELECT min(lc.seq) FROM content_chunks lc WHERE lc.mirror_hash = d.mirror_hash AND lc.language = ?) as seq," : "0 as seq,"}
           fm.score as score,
-          ${options.snippet ? "fm.snippet as snippet," : ""}
           d.docid,
           d.uri,
           d.title,
@@ -3197,7 +3340,6 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         mirror_hash: string;
         seq: number;
         score: number;
-        snippet?: string;
         docid: string;
         uri: string;
         title: string | null;
@@ -3247,7 +3389,6 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
           mirrorHash: r.mirror_hash,
           seq: r.seq,
           score: r.score, // Raw bm25() - smaller (more negative) is better
-          snippet: r.snippet,
           docid: r.docid,
           uri: r.uri,
           title: r.title ?? undefined,

package/src/store/types.ts

@@ -68,7 +68,23 @@ export type StoreErrorCode =
   | "VEC_REBUILD_FAILED"
   | "VEC_SYNC_FAILED"
   /** Embedding would build a separate vector partition without confirmation. */
-  | "VECTOR_PARTITION_FORK";
+  | "VECTOR_PARTITION_FORK"
+  /** The index holds indexed collections the opening config does not list. */
+  | "STALE_COLLECTIONS";
+
+/** How a config sync treats collections the config no longer lists. */
+export interface SyncCollectionsOptions {
+  /** Explicitly removed names, or every unlisted collection ("stale"). */
+  remove?: readonly string[] | "stale";
+  /** Leave unlisted collections untouched instead of failing. */
+  keepStale?: boolean;
+}
+
+/** A collection in the index that the opening config does not list. */
+export interface StaleCollection {
+  name: string;
+  documents: number;
+}
 
 /** Store error with structured details */
 export interface StoreError {
@@ -738,8 +754,6 @@ export interface FtsSearchOptions extends DocumentEligibilityOptions {
    * so runtime language filtering is not currently implemented.
    */
   language?: string;
-  /** Include snippet with highlights */
-  snippet?: boolean;
   /** Match documents containing ANY positive term instead of ALL of them. */
   anyTerm?: boolean;
   /**
@@ -770,7 +784,6 @@ export interface FtsResult {
   mirrorHash: string;
   seq: number;
   score: number;
-  snippet?: string;
   // Joined from documents table
   docid?: string;
   uri?: string;
@@ -1614,10 +1627,21 @@ export interface StorePort {
   // ─────────────────────────────────────────────────────────────────────────
 
   /**
-   * Sync collections from config to DB.
-   * Adds new, updates existing, removes deleted.
+   * Sync collections from config to DB: adds new and updates existing ones.
+   * A collection in the index but not in `collections` is deleted only when
+   * `options.remove` names it (or is "stale"). One that holds documents
+   * otherwise fails the sync with STALE_COLLECTIONS and changes nothing,
+   * unless `keepStale` leaves it untouched.
    */
-  syncCollections(collections: Collection[]): Promise<StoreResult<void>>;
+  syncCollections(
+    collections: Collection[],
+    options?: SyncCollectionsOptions
+  ): Promise<StoreResult<void>>;
+
+  /** Collections in the index that `configured` does not list, with counts. */
+  listStaleCollections(
+    configured: readonly string[]
+  ): Promise<StoreResult<StaleCollection[]>>;
 
   /**
    * Sync contexts from config to DB.
@@ -2159,6 +2183,20 @@ export interface StorePort {
     keys: { mirrorHash: string; seq: number }[]
   ): Promise<StoreResult<Map<string, ChunkRow[]>>>;
 
+  /**
+   * Optional: for every chunk of the given documents, which of the given
+   * lowercase terms occur in its text (substring match on ASCII-lowercased
+   * text), computed in the database so chunk text is never loaded. Rows are
+   * ordered by mirrorHash, then seq; `present[i]` answers `terms[i]`. Callers
+   * fall back to getChunksBatch when this capability is absent.
+   */
+  getChunkTermPresence?(
+    mirrorHashes: string[],
+    terms: string[]
+  ): Promise<
+    StoreResult<{ mirrorHash: string; seq: number; present: boolean[] }[]>
+  >;
+
   // ─────────────────────────────────────────────────────────────────────────
   // FTS Search
   // ─────────────────────────────────────────────────────────────────────────

package/browser-extension/artifacts/gno-browser-clipper-v2.11.0.zip.sha256

@@ -1 +0,0 @@
-589f77b3c4d48d0922fccb9598fc5e07dc32e9f56afa899998d49a735309eae5  gno-browser-clipper-v2.11.0.zip