@gmickel/gno 1.37.0 → 1.38.0

package/src/sdk/embed.ts

@@ -117,9 +117,10 @@ async function forceEmbedAll(
   vectorIndex: VectorIndexPort,
   modelUri: string,
   batchSize: number
-): Promise<{ embedded: number; errors: number }> {
+): Promise<{ embedded: number; errors: number; contentionErrors: number }> {
   let embedded = 0;
   let errors = 0;
+  let contentionErrors = 0;
   let cursor: { mirrorHash: string; seq: number } | undefined;
   const retryQueue = new Map<string, { item: BacklogItem; attempts: number }>();
   const embedFingerprint = getEmbeddingFingerprint({
@@ -164,6 +165,7 @@ async function forceEmbedAll(
       });
       embedded += retryResult.embedded;
       errors += retryResult.errors;
+      contentionErrors += retryResult.contentionErrors;
       retryEmbedded += retryResult.embedded;
 
       const retryByKey = new Set(
@@ -212,6 +214,7 @@ async function forceEmbedAll(
     });
     embedded += embedResult.embedded;
     errors += embedResult.errors;
+    contentionErrors += embedResult.contentionErrors;
     enqueueRetryItems(embedResult.retryItems, 1);
 
     if (embedded > beforeEmbedded) {
@@ -232,7 +235,7 @@ async function forceEmbedAll(
     }
   }
 
-  return { embedded, errors };
+  return { embedded, errors, contentionErrors };
 }
 
 async function checkVecAvailable(db: Database): Promise<boolean> {
@@ -343,7 +346,7 @@ export async function runEmbed(
     }
 
     const startedAt = Date.now();
-    let result: { embedded: number; errors: number };
+    let result: { embedded: number; errors: number; contentionErrors: number };
     if (force) {
       result = await forceEmbedAll(
         db,
@@ -369,12 +372,14 @@ export async function runEmbed(
       result = {
         embedded: processed.value.embedded,
         errors: processed.value.errors,
+        contentionErrors: processed.value.contentionErrors ?? 0,
       };
     }
 
     return {
       embedded: result.embedded,
       errors: result.errors,
+      contentionErrors: result.contentionErrors,
       duration: (Date.now() - startedAt) / 1000,
       model: modelUri,
       searchAvailable: vectorIndex.searchAvailable,

package/src/sdk/types.ts

@@ -204,6 +204,8 @@ export interface GnoEmbedOptions {
 export interface GnoEmbedResult {
   embedded: number;
   errors: number;
+  /** Persistence lock-contention failures; distinct from embedding-provider `errors`. */
+  contentionErrors?: number;
   duration: number;
   model: string;
   searchAvailable: boolean;

package/src/serve/embed-scheduler.ts

@@ -130,6 +130,14 @@ export function createEmbedScheduler(deps: EmbedSchedulerDeps): EmbedScheduler {
         console.error("[embed-scheduler] Embed failed:", result.error.message);
         return { embedded: 0, errors: 0 };
       }
+      if ((result.value.contentionErrors ?? 0) > 0) {
+        // Chunks deferred by SQLITE_BUSY stay in the backlog; retry the run
+        // instead of silently leaving embeddings a pass behind (fn-127 R6).
+        console.error(
+          `[embed-scheduler] ${result.value.contentionErrors} chunks deferred by index contention; rescheduling`
+        );
+        needsRerun = true;
+      }
       if (result.value.embedded > 0) onEmbedded?.(result.value);
       return result.value;
     } finally {

package/src/serve/resident-runtime.ts

@@ -212,7 +212,11 @@ export async function startResidentRuntime(
   const paths = (deps.getConfigPaths ?? getConfigPaths)();
   const actualConfigPath = resolve(options.configPath ?? paths.configFile);
   store.setConfigPath(actualConfigPath);
-  const openResult = await store.open(dbPath, initialConfig.ftsTokenizer);
+  const openResult = await store.open(
+    dbPath,
+    initialConfig.ftsTokenizer,
+    initialConfig.busyTimeoutMs
+  );
   if (!openResult.ok) {
     await ownerLock.release();
     return { success: false, error: openResult.error.message };

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

@@ -1,9 +1,10 @@
-// node:fs/promises — no Bun equivalent for mkdir/rm of the temporary SPA outdir.
-import { mkdir, rm } from "node:fs/promises";
+// node:fs/promises — no Bun equivalent for mkdir/rm of the temporary SPA
+// outdir, or for recursive directory listing.
+import { mkdir, readdir, rm } from "node:fs/promises";
 // node:os — no Bun equivalent for the platform temporary directory.
 import { tmpdir } from "node:os";
 // node:path — no Bun path utils.
-import { basename, join } from "node:path";
+import { basename, join, relative } from "node:path";
 
 export const ROOT_MOUNT_MARKER = 'getElementById("root")';
 
@@ -15,6 +16,50 @@ export type ProductionSpaFile = {
 export type ProductionSpaAssets = {
   files: Record<string, ProductionSpaFile>;
   html: string;
+  sourceHash: string;
+};
+
+const productionSpaPublicDir = (): string => join(import.meta.dir, "public");
+
+export const productionSpaEntryPath = (): string =>
+  join(productionSpaPublicDir(), "index.html");
+
+/**
+ * SHA-256 hex of every file under `src/serve/public/`, in sorted relative-path
+ * order. Used to detect a stale `assets/spa-production.json.gz` without
+ * comparing Bun.build output (minified symbols and chunk hashes differ
+ * across Bun binaries).
+ */
+export const computeSpaSourceHash = async (): Promise<string> => {
+  const publicDir = productionSpaPublicDir();
+  const entries = await readdir(publicDir, {
+    recursive: true,
+    withFileTypes: true,
+  });
+  const relativePaths: string[] = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    relativePaths.push(
+      relative(publicDir, join(entry.parentPath, entry.name)).replaceAll(
+        "\\",
+        "/"
+      )
+    );
+  }
+  relativePaths.sort();
+
+  const hasher = new Bun.CryptoHasher("sha256");
+  for (const relativePath of relativePaths) {
+    const bytes = await Bun.file(join(publicDir, relativePath)).bytes();
+    hasher.update(relativePath);
+    hasher.update("\0");
+    hasher.update(String(bytes.byteLength));
+    hasher.update("\0");
+    hasher.update(bytes);
+  }
+  return hasher.digest("hex");
 };
 
 const SCRIPT_TAG_RE = /<script\b[^>]*\bsrc="[^"]+"[^>]*><\/script>/iu;
@@ -41,9 +86,6 @@ export const isStandaloneExecutable = (): boolean =>
 export const isBunfsPath = (path: string): boolean =>
   path.includes("/$bunfs/") || path.includes("\\$bunfs\\");
 
-export const productionSpaEntryPath = (): string =>
-  join(import.meta.dir, "public", "index.html");
-
 const rewriteProductionHtml = (html: string, jsEntryPath: string): string => {
   const script = `<script type="module" src="/${basename(jsEntryPath)}"></script>`;
   let next = html.replace(BASE_TAG_RE, "");
@@ -123,7 +165,11 @@ export const buildProductionSpaAssets = async (
       };
     }
 
-    return { files, html };
+    return {
+      files,
+      html,
+      sourceHash: await computeSpaSourceHash(),
+    };
   } finally {
     await rm(outdir, { recursive: true, force: true });
   }

package/src/store/sqlite/adapter.ts

@@ -114,9 +114,12 @@ import { buildUri, deriveDocid, stripUriIndex } from "../../app/constants";
 import {
   type Collection,
   type Context,
+  DEFAULT_BUSY_TIMEOUT_MS,
   type EgressPolicy,
   type EgressPolicySource,
   type FtsTokenizer,
+  MAX_BUSY_TIMEOUT_MS,
+  MIN_BUSY_TIMEOUT_MS,
   resolveConfiguredEgressPolicy,
 } from "../../config/types";
 import {
@@ -476,6 +479,19 @@ function isDatabaseLockedError(cause: unknown): boolean {
   );
 }
 
+/** Resolve a caller-supplied busy_timeout, defaulting rather than using 0. */
+function resolveBusyTimeoutMs(busyTimeoutMs?: number): number {
+  if (
+    busyTimeoutMs === undefined ||
+    !Number.isInteger(busyTimeoutMs) ||
+    busyTimeoutMs < MIN_BUSY_TIMEOUT_MS ||
+    busyTimeoutMs > MAX_BUSY_TIMEOUT_MS
+  ) {
+    return DEFAULT_BUSY_TIMEOUT_MS;
+  }
+  return busyTimeoutMs;
+}
+
 export class SqliteAdapter implements StorePort, SqliteDbProvider {
   private db: Database | null = null;
   private dbPath = "";
@@ -492,7 +508,8 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
 
   async open(
     dbPath: string,
-    ftsTokenizer: FtsTokenizer
+    ftsTokenizer: FtsTokenizer,
+    busyTimeoutMs: number = DEFAULT_BUSY_TIMEOUT_MS
   ): Promise<StoreResult<MigrationResult>> {
     try {
       this.db = new Database(dbPath, { create: true });
@@ -501,7 +518,9 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
 
       // Enable pragmas for performance and safety
       this.db.exec("PRAGMA foreign_keys = ON");
-      this.db.exec("PRAGMA busy_timeout = 5000");
+      this.db.exec(
+        `PRAGMA busy_timeout = ${resolveBusyTimeoutMs(busyTimeoutMs)}`
+      );
 
       // Keep WAL everywhere so readers can continue while a writer is active.
       // CI still relaxes fsync/temp-store for speed, but MEMORY journal mode
@@ -558,12 +577,17 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
   }
 
   /** Open an existing index with SQLite enforced query-only semantics. */
-  openReadOnly(dbPath: string): StoreResult<void> {
+  openReadOnly(
+    dbPath: string,
+    busyTimeoutMs: number = DEFAULT_BUSY_TIMEOUT_MS
+  ): StoreResult<void> {
     try {
       this.db = new Database(dbPath, { readonly: true, strict: true });
       this.dbPath = dbPath;
       this.db.exec("PRAGMA query_only = ON");
-      this.db.exec("PRAGMA busy_timeout = 5000");
+      this.db.exec(
+        `PRAGMA busy_timeout = ${resolveBusyTimeoutMs(busyTimeoutMs)}`
+      );
       this.contextGeneration += 1;
       return ok(undefined);
     } catch (cause) {

package/src/store/sqlite/scoped-index.ts

@@ -38,7 +38,11 @@ export async function openScopedIndexStore(options: {
 
   const store = new SqliteAdapter();
   store.setConfigPath(options.configPath ?? "<inline-config>");
-  const openResult = await store.open(dbPath, options.config.ftsTokenizer);
+  const openResult = await store.open(
+    dbPath,
+    options.config.ftsTokenizer,
+    options.config.busyTimeoutMs
+  );
   if (!openResult.ok) {
     throw new Error(openResult.error.message);
   }

package/src/store/vector/sqlite-vec.ts

@@ -193,7 +193,8 @@ export async function createVectorIndexPort(
         return Promise.resolve(
           err(
             "VECTOR_WRITE_FAILED",
-            `Vector write failed: ${e instanceof Error ? e.message : String(e)}`
+            `Vector write failed: ${e instanceof Error ? e.message : String(e)}`,
+            e
           )
         );
       }

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

@@ -1 +0,0 @@
-497d8e90a34b7472eac55da861c3049b7453a33d9fdbd0a27e49f2ce36ccde9b  gno-browser-clipper-v1.37.0.zip