@gmickel/gno 1.39.2 → 1.41.0

package/src/serve/server.ts

@@ -7,6 +7,7 @@
  */
 
 import type { HttpGatewayOverrides } from "../mcp/http-security";
+import type { RequestPeerServer } from "./request-locality";
 import type { ResidentRuntime } from "./resident-runtime";
 import type { ContextHolder } from "./routes/api";
 
@@ -22,6 +23,7 @@ import {
   handlePdfjsVendorRequest,
   isPdfjsVendorPath,
 } from "./fn112-routes";
+import { PDFJS_ASSET_CACHE_CONTROL } from "./pdfjs-assets";
 // HTML import - Bun handles bundling TSX/CSS automatically via routes
 import homepage from "./public/index.html";
 import { handleResidentRead } from "./resident-request";
@@ -57,6 +59,8 @@ import {
   handleHealth,
   handleImportPreview,
   handleInstallConnector,
+  handleMemoryRecall,
+  handleMemoryRemember,
   handleMoveDoc,
   handleNotePresets,
   handleJob,
@@ -209,6 +213,156 @@ export function withSecurityHeaders(
   }
 }
 
+/**
+ * Hashed SPA chunk paths emitted by the production split build
+ * (`/chunk-<hash>.js|css`). The entry HTML never matches, so it keeps its
+ * existing headers and ETag pass-through.
+ */
+const SPA_HASHED_CHUNK_RE = /^\/chunk-[A-Za-z0-9]+\.(?:js|css)$/u;
+
+/** One-year immutable policy shared with the version-pinned pdfjs assets. */
+export const SPA_CHUNK_CACHE_CONTROL = PDFJS_ASSET_CACHE_CONTROL;
+
+export const isHashedSpaChunkPath = (pathname: string): boolean =>
+  SPA_HASHED_CHUNK_RE.test(pathname);
+
+const GZIP_CODINGS = new Set(["gzip", "x-gzip"]);
+
+/**
+ * True when an Accept-Encoding value accepts gzip: gzip (or x-gzip) listed
+ * with a non-zero q-value, or a bare `*` with a non-zero q-value while gzip
+ * is not explicitly refused (RFC 9110 §12.5.3: `*` matches any coding not
+ * otherwise listed). Absent header → identity only.
+ */
+export function acceptsGzip(acceptEncoding: string | null): boolean {
+  if (!acceptEncoding) {
+    return false;
+  }
+  let gzipQ: number | undefined;
+  let wildcardQ: number | undefined;
+  for (const member of acceptEncoding.split(",")) {
+    const [rawCoding, ...params] = member.trim().toLowerCase().split(";");
+    const coding = rawCoding?.trim();
+    if (!coding) {
+      continue;
+    }
+    const q = params
+      .map((param) => param.trim())
+      .find((param) => param.startsWith("q="))
+      ?.slice(2);
+    const weight = q === undefined ? 1 : Number.parseFloat(q);
+    if (GZIP_CODINGS.has(coding)) {
+      gzipQ = Math.max(gzipQ ?? 0, Number.isNaN(weight) ? 0 : weight);
+    } else if (coding === "*") {
+      wildcardQ = Math.max(wildcardQ ?? 0, Number.isNaN(weight) ? 0 : weight);
+    }
+  }
+  if (gzipQ !== undefined) {
+    return gzipQ > 0;
+  }
+  return (wildcardQ ?? 0) > 0;
+}
+
+export type PublicFetchFallbackOptions = {
+  isDev: boolean;
+  spaBundleSource: SpaBundleSource | null;
+};
+
+/**
+ * Production catch-all `fetch` for the public listener: the pdfjs vendor
+ * prefix, then the private SPA source. Encoding negotiation lives here, not in
+ * the source, because `hostPrivateSource` re-issues internal requests with
+ * only the method, so `Accept-Encoding` never reaches it. Hashed chunks gain
+ * an immutable cache policy and a gzip body computed once per pathname;
+ * identity clients get the same cache headers on the original bytes. Tests
+ * mount this same factory on a real listener (fn-112 I1-04 discipline).
+ */
+export function createPublicFetchFallback(
+  options: PublicFetchFallbackOptions
+): (req: Request) => Promise<Response> {
+  const { isDev, spaBundleSource } = options;
+  const gzipBodies = new Map<string, Uint8Array<ArrayBuffer>>();
+
+  const gzipBodyFor = async (
+    req: Request,
+    pathname: string,
+    asset: Response
+  ): Promise<Uint8Array<ArrayBuffer>> => {
+    const cached = gzipBodies.get(pathname);
+    if (cached) {
+      await asset.body?.cancel();
+      return cached;
+    }
+    // HEAD reaches the source as HEAD, so its body is empty; fetch the bytes.
+    const identity =
+      req.method === "HEAD" && spaBundleSource
+        ? await spaBundleSource.fetch(new Request(req.url, { method: "GET" }))
+        : asset;
+    // Copy into an ArrayBuffer-backed view so the cached bytes are a BodyInit.
+    const encoded = new Uint8Array(
+      Bun.gzipSync(new Uint8Array(await identity.arrayBuffer()))
+    );
+    gzipBodies.set(pathname, encoded);
+    return encoded;
+  };
+
+  const serveHashedChunk = async (
+    req: Request,
+    pathname: string,
+    asset: Response
+  ): Promise<Response> => {
+    const headers = new Headers(asset.headers);
+    headers.set("Cache-Control", SPA_CHUNK_CACHE_CONTROL);
+    headers.set("Vary", "Accept-Encoding");
+    if (!acceptsGzip(req.headers.get("accept-encoding"))) {
+      if (req.method === "HEAD") {
+        // HEAD reaches the source as HEAD: its body is empty but its headers
+        // (Content-Length included) already describe the GET body. Keep them.
+        await asset.body?.cancel();
+        return new Response(null, { status: asset.status, headers });
+      }
+      // Buffer the identity bytes: re-wrapping the proxied stream would drop
+      // Content-Length and fall back to chunked transfer.
+      const identity = await asset.arrayBuffer();
+      headers.set("Content-Length", String(identity.byteLength));
+      return new Response(identity, { status: asset.status, headers });
+    }
+    const encoded = await gzipBodyFor(req, pathname, asset);
+    headers.set("Content-Encoding", "gzip");
+    headers.set("Content-Length", String(encoded.byteLength));
+    return new Response(req.method === "HEAD" ? null : encoded, {
+      status: asset.status,
+      headers,
+    });
+  };
+
+  return async (req: Request): Promise<Response> => {
+    const pathname = new URL(req.url).pathname;
+    if (isPdfjsVendorPath(pathname)) {
+      return handlePdfjsVendorRequest(req, {
+        isDev,
+        withSecurityHeaders,
+      });
+    }
+    if (spaBundleSource && (req.method === "GET" || req.method === "HEAD")) {
+      const asset = await spaBundleSource.fetch(req);
+      if (asset.status === 200 && !isDev && isHashedSpaChunkPath(pathname)) {
+        return withSecurityHeaders(
+          await serveHashedChunk(req, pathname, asset),
+          isDev
+        );
+      }
+      if (asset.status !== 404) {
+        return withSecurityHeaders(asset, isDev);
+      }
+    }
+    return withSecurityHeaders(
+      new Response("Not Found", { status: 404 }),
+      isDev
+    );
+  };
+}
+
 /** Build a loopback origin with correct IPv6 authority formatting. */
 export function loopbackHttpOrigin(host: string, port: number): string {
   const normalizedHost =
@@ -676,6 +830,30 @@ export async function startServer(
             );
           },
         },
+        "/api/memory/remember": {
+          POST: async (req: Request) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleMemoryRemember(ctxHolder, store, req),
+              isDev
+            );
+          },
+        },
+        "/api/memory/recall": {
+          POST: async (req: Request) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleResidentRead(runtime as ResidentRuntime, req, () =>
+                handleMemoryRecall(ctxHolder, store, req)
+              ),
+              isDev
+            );
+          },
+        },
         "/api/docs": {
           GET: async (req: Request) => {
             const url = new URL(req.url);
@@ -824,7 +1002,7 @@ export async function startServer(
           },
         },
         "/api/docs/:id/reveal": {
-          POST: async (req: Request) => {
+          POST: async (req: Request, server: RequestPeerServer) => {
             if (!isRequestAllowed(req, port)) {
               return withSecurityHeaders(forbiddenResponse(), isDev);
             }
@@ -832,7 +1010,7 @@ export async function startServer(
             const parts = url.pathname.split("/");
             const id = decodeURIComponent(parts[3] || "");
             return withSecurityHeaders(
-              await handleRevealDoc(ctxHolder, store, id, req),
+              await handleRevealDoc(ctxHolder, store, id, req, { server }),
               isDev
             );
           },
@@ -1015,8 +1193,11 @@ export async function startServer(
           },
         },
         "/api/capabilities": {
-          GET: () =>
-            withSecurityHeaders(handleCapabilities(ctxHolder.current), isDev),
+          GET: (req: Request, server: RequestPeerServer) =>
+            withSecurityHeaders(
+              handleCapabilities(ctxHolder.current, req, server),
+              isDev
+            ),
         },
         "/api/presets": {
           GET: () =>
@@ -1292,31 +1473,10 @@ export async function startServer(
           },
         },
       },
-      // Production vendor dispatcher for the entire /vendor/pdfjs prefix.
-      // Covers valid worker/cMap/font AND malformed/unknown/POST — same function
-      // that tests invoke (no test-only fallback path).
-      fetch: async (req: Request): Promise<Response> => {
-        const pathname = new URL(req.url).pathname;
-        if (isPdfjsVendorPath(pathname)) {
-          return handlePdfjsVendorRequest(req, {
-            isDev,
-            withSecurityHeaders,
-          });
-        }
-        if (
-          spaBundleSource &&
-          (req.method === "GET" || req.method === "HEAD")
-        ) {
-          const asset = await spaBundleSource.fetch(req);
-          if (asset.status !== 404) {
-            return withSecurityHeaders(asset, isDev);
-          }
-        }
-        return withSecurityHeaders(
-          new Response("Not Found", { status: 404 }),
-          isDev
-        );
-      },
+      // Production catch-all: /vendor/pdfjs prefix, then hashed SPA chunks
+      // (gzip + immutable) and the private SPA source — the same factory the
+      // tests mount (no test-only fallback path).
+      fetch: createPublicFetchFallback({ isDev, spaBundleSource }),
     });
   } catch (e) {
     removeShutdownHandlers();

package/src/store/migrations/027-memory-scopes.ts

@@ -0,0 +1,37 @@
+/**
+ * Migration: indexed memory scopes for managed memory records.
+ *
+ * Scopes are filterable inside retrieval queries (never post-hoc over a
+ * bounded candidate window), so they live in their own indexed table.
+ *
+ * @module src/store/migrations/027-memory-scopes
+ */
+
+import type { Database } from "bun:sqlite";
+
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 27,
+  name: "memory_scopes",
+
+  up(db: Database): void {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS doc_memory_scopes (
+        document_id INTEGER NOT NULL,
+        scope TEXT NOT NULL,
+        PRIMARY KEY (document_id, scope),
+        FOREIGN KEY (document_id) REFERENCES documents(id) ON DELETE CASCADE
+      )
+    `);
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_doc_memory_scopes_scope
+      ON doc_memory_scopes(scope, document_id)
+    `);
+  },
+
+  down(db: Database): void {
+    db.exec("DROP INDEX IF EXISTS idx_doc_memory_scopes_scope");
+    db.exec("DROP TABLE IF EXISTS doc_memory_scopes");
+  },
+};

package/src/store/migrations/index.ts

@@ -40,6 +40,7 @@ import { migration as m023 } from "./023-collection-egress-policy";
 import { migration as m024 } from "./024-egress-derived-lineage";
 import { migration as m025 } from "./025-collection-egress-policy-revision";
 import { migration as m026 } from "./026-file-refactor-recovery-journal";
+import { migration as m027 } from "./027-memory-scopes";
 
 /** All migrations in order */
 export const migrations = [
@@ -69,4 +70,5 @@ export const migrations = [
   m024,
   m025,
   m026,
+  m027,
 ];

package/src/store/sqlite/adapter.ts

@@ -75,6 +75,8 @@ import type {
   IndexStatus,
   IngestErrorInput,
   IngestErrorRow,
+  MemoryEligibleDocument,
+  MemoryEligibleDocumentsOptions,
   MigrationResult,
   RetrievalTraceAppendResult,
   RetrievalTraceBundle,
@@ -324,6 +326,13 @@ type FtsQueryBuildResult =
   | { ok: true; query: string }
   | { ok: false; error: string };
 
+/**
+ * SQL fragment excluding documents superseded by an active document via the
+ * typed `supersedes` edge. `docIdExpr` names the candidate document id column.
+ */
+const SUPERSEDED_EXCLUSION_SQL = (docIdExpr: string): string =>
+  `AND NOT EXISTS (SELECT 1 FROM doc_edges se JOIN documents sd ON sd.id = se.src_doc_id AND sd.active = 1 WHERE se.dst_doc_id = ${docIdExpr} AND se.edge_type = 'supersedes')`;
+
 /**
  * Narrow lexical grammar for BM25/FTS queries.
  *
@@ -333,7 +342,10 @@ type FtsQueryBuildResult =
  * - negation with at least one positive term
  * - hyphenated compounds handled intentionally
  */
-function buildFts5Query(query: string): FtsQueryBuildResult {
+function buildFts5Query(
+  query: string,
+  options: { anyTerm?: boolean } = {}
+): FtsQueryBuildResult {
   const trimmed = query.trim();
   if (!trimmed) {
     return { ok: false, error: "Search query cannot be empty" };
@@ -454,7 +466,9 @@ function buildFts5Query(query: string): FtsQueryBuildResult {
     };
   }
 
-  let ftsQuery = positive.join(" AND ");
+  let ftsQuery = options.anyTerm
+    ? `(${positive.join(" OR ")})`
+    : positive.join(" AND ");
   for (const negation of negative) {
     ftsQuery = `${ftsQuery} NOT ${negation}`;
   }
@@ -2635,7 +2649,7 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     try {
       const db = this.ensureOpen();
       const limit = options.limit ?? 20;
-      const builtQuery = buildFts5Query(query);
+      const builtQuery = buildFts5Query(query, { anyTerm: options.anyTerm });
       if (!builtQuery.ok) {
         return err("INVALID_INPUT", builtQuery.error);
       }
@@ -2683,6 +2697,21 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         params.push(`%${options.author.toLowerCase()}%`);
       }
 
+      // Scope and supersession filters run inside the candidate subquery so
+      // they narrow the corpus before the FTS LIMIT (never a post-filter).
+      const innerConditions: string[] = [];
+      const innerParams: string[] = [];
+      if (options.memoryScopesAny && options.memoryScopesAny.length > 0) {
+        const placeholders = options.memoryScopesAny.map(() => "?").join(",");
+        innerConditions.push(
+          `AND EXISTS (SELECT 1 FROM doc_memory_scopes ms WHERE ms.document_id = documents.id AND ms.scope IN (${placeholders}))`
+        );
+        innerParams.push(...options.memoryScopesAny);
+      }
+      if (options.excludeSuperseded) {
+        innerConditions.push(SUPERSEDED_EXCLUSION_SQL("documents.id"));
+      }
+
       const hasOuterFilters = tagConditions.length > 0;
       const ftsLimit = hasOuterFilters ? limit * 10 : limit;
       params.push(limit);
@@ -2711,6 +2740,7 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
                 ? "AND (COALESCE(NULLIF(record_source_path, ''), rel_path) = ? OR substr(COALESCE(NULLIF(record_source_path, ''), rel_path), 1, length(?) + 1) = ? || '/')"
                 : ""
             }
+            ${innerConditions.join("\n            ")}
           )
           ORDER BY score
           LIMIT ?
@@ -2789,6 +2819,7 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
               options.relPathPrefix,
             ]
           : []),
+        ...innerParams,
         ftsLimit,
         ...params,
       ];
@@ -3076,6 +3107,99 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     }
   }
 
+  async setDocMemoryScopes(
+    documentId: number,
+    scopes: string[]
+  ): Promise<StoreResult<void>> {
+    try {
+      const db = this.ensureOpen();
+      const transaction = db.transaction(() => {
+        db.run("DELETE FROM doc_memory_scopes WHERE document_id = ?", [
+          documentId,
+        ]);
+        if (scopes.length > 0) {
+          const stmt = db.prepare(
+            "INSERT OR IGNORE INTO doc_memory_scopes (document_id, scope) VALUES (?, ?)"
+          );
+          for (const scope of scopes) {
+            stmt.run(documentId, scope);
+          }
+        }
+      });
+      transaction();
+      return ok(undefined);
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error ? cause.message : "Failed to set memory scopes",
+        cause
+      );
+    }
+  }
+
+  async getDocMemoryScopes(documentId: number): Promise<StoreResult<string[]>> {
+    try {
+      const db = this.ensureOpen();
+      const rows = db
+        .query<{ scope: string }, [number]>(
+          "SELECT scope FROM doc_memory_scopes WHERE document_id = ? ORDER BY scope"
+        )
+        .all(documentId);
+      return ok(rows.map((row) => row.scope));
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error ? cause.message : "Failed to read memory scopes",
+        cause
+      );
+    }
+  }
+
+  async listMemoryEligibleDocuments(
+    options: MemoryEligibleDocumentsOptions
+  ): Promise<StoreResult<MemoryEligibleDocument[]>> {
+    try {
+      const db = this.ensureOpen();
+      if (options.scopes.length === 0) {
+        return ok([]);
+      }
+      const placeholders = options.scopes.map(() => "?").join(",");
+      const rows = db
+        .query<
+          { id: number; docid: string; uri: string; mirror_hash: string },
+          string[]
+        >(
+          `
+          SELECT d.id, d.docid, d.uri, d.mirror_hash
+          FROM documents d
+          WHERE d.active = 1
+            AND d.collection = ?
+            AND d.mirror_hash IS NOT NULL
+            AND EXISTS (SELECT 1 FROM doc_memory_scopes ms WHERE ms.document_id = d.id AND ms.scope IN (${placeholders}))
+            ${options.excludeSuperseded ? SUPERSEDED_EXCLUSION_SQL("d.id") : ""}
+          ORDER BY d.id
+          `
+        )
+        .all(options.collection, ...options.scopes);
+      return ok(
+        rows.map((row) => ({
+          id: row.id,
+          docid: row.docid,
+          uri: row.uri,
+          mirrorHash: row.mirror_hash,
+        }))
+      );
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error
+          ? cause.message
+          : "Failed to list memory-eligible documents",
+        cause
+      );
+    }
+  }
+
   /**
    * Get all tags for a document.
    */

package/src/store/types.ts

@@ -643,6 +643,35 @@ export interface FtsSearchOptions {
   categories?: string[];
   /** Filter by author field (case-insensitive contains) */
   author?: string;
+  /**
+   * Managed-memory scope filter: keep only documents carrying at least one of
+   * these normalized scopes. Applied inside the FTS candidate subquery, before
+   * any LIMIT, so an out-of-scope document never occupies the window.
+   */
+  memoryScopesAny?: string[];
+  /**
+   * Exclude documents that an active document supersedes (typed edge
+   * `supersedes` pointing at them). Applied inside the candidate subquery.
+   */
+  excludeSuperseded?: boolean;
+  /** Match documents containing ANY positive term instead of ALL of them. */
+  anyTerm?: boolean;
+}
+
+/** Managed-memory eligibility query (unbounded, executed in one SQL query). */
+export interface MemoryEligibleDocumentsOptions {
+  collection: string;
+  /** Normalized scopes; any-intersection semantics. */
+  scopes: string[];
+  excludeSuperseded?: boolean;
+}
+
+/** Minimal identity of a memory record eligible for managed recall. */
+export interface MemoryEligibleDocument {
+  id: number;
+  docid: string;
+  uri: string;
+  mirrorHash: string;
 }
 
 /** Single FTS search result */
@@ -2022,6 +2051,31 @@ export interface StorePort {
    */
   getTagsForDoc(documentId: number): Promise<StoreResult<TagRow[]>>;
 
+  // ─────────────────────────────────────────────────────────────────────────
+  // Memory scopes (managed memory records)
+  // ─────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Replace the indexed scope set of one document. An empty list clears it,
+   * which removes the document from managed recall.
+   */
+  setDocMemoryScopes(
+    documentId: number,
+    scopes: string[]
+  ): Promise<StoreResult<void>>;
+
+  /** Indexed scopes for one document (sorted). */
+  getDocMemoryScopes(documentId: number): Promise<StoreResult<string[]>>;
+
+  /**
+   * Every active document in the collection carrying at least one requested
+   * scope, optionally excluding superseded records. One unbounded query, so
+   * the result is the exact eligible set rather than a candidate window.
+   */
+  listMemoryEligibleDocuments(
+    options: MemoryEligibleDocumentsOptions
+  ): Promise<StoreResult<MemoryEligibleDocument[]>>;
+
   /**
    * Get tags for multiple documents in a single query.
    * Returns a map of documentId -> TagRow[].

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

@@ -1 +0,0 @@
-82afff37d4a331933c19bebb9c73972fd6eb665ffd1444bbdf65cfb0220dd692  gno-browser-clipper-v1.39.2.zip