@canopy-iiif/app 0.8.3 → 0.8.5

package/lib/search/search-app.jsx

@@ -6,6 +6,49 @@ import {
   SearchFiltersDialog,
 } from "@canopy-iiif/app/ui";
 
+function readBasePath() {
+  const normalize = (val) => {
+    const raw = typeof val === "string" ? val.trim() : "";
+    if (!raw) return "";
+    const withLead = raw.startsWith("/") ? raw : `/${raw}`;
+    return withLead.replace(/\/+$/, "");
+  };
+  try {
+    if (typeof window !== "undefined" && window.CANOPY_BASE_PATH != null) {
+      const fromWindow = normalize(window.CANOPY_BASE_PATH);
+      if (fromWindow) return fromWindow;
+    }
+  } catch (_) {}
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.CANOPY_BASE_PATH != null) {
+      const fromGlobal = normalize(globalThis.CANOPY_BASE_PATH);
+      if (fromGlobal) return fromGlobal;
+    }
+  } catch (_) {}
+  try {
+    if (typeof process !== "undefined" && process.env && process.env.CANOPY_BASE_PATH) {
+      const fromEnv = normalize(process.env.CANOPY_BASE_PATH);
+      if (fromEnv) return fromEnv;
+    }
+  } catch (_) {}
+  return "";
+}
+
+function withBasePath(href) {
+  try {
+    const raw = typeof href === "string" ? href.trim() : "";
+    if (!raw) return href;
+    if (/^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i.test(raw)) return raw;
+    if (!raw.startsWith("/")) return raw;
+    const base = readBasePath();
+    if (!base || base === "/") return raw;
+    if (raw === base || raw.startsWith(`${base}/`)) return raw;
+    return `${base}${raw}`;
+  } catch (_) {
+    return href;
+  }
+}
+
 // Lightweight IndexedDB utilities (no deps) with defensive guards
 function hasIDB() {
   try {
@@ -116,6 +159,7 @@ function createSearchStore() {
     facetsDocsMap: {},
     filters: {},
     activeFilterCount: 0,
+    annotationsEnabled: false,
   };
   const listeners = new Set();
   function notify() {
@@ -209,22 +253,34 @@ function createSearchStore() {
         counts = {};
       }
 
-      results =
-        type === "all"
-          ? base
-          : base.filter(
-              (r) => String(r.type).toLowerCase() === String(type).toLowerCase()
-            );
-      if (shouldFilterWorks && allowed) {
-        results = results.filter((r) => allowed.has(r && r.__docIndex));
-      }
+      const annotationMatches = base.filter((r) => r && r.annotation);
+      if (annotationMatches.length)
+        counts.annotation = annotationMatches.length;
 
-      if (type !== "all") {
-        try {
-          totalForType = records.filter(
-            (r) => String(r.type).toLowerCase() === String(type).toLowerCase()
-          ).length;
-        } catch (_) {}
+      const typeLower = String(type).toLowerCase();
+      if (typeLower === "annotation") {
+        results = annotationMatches.map((r) => ({
+          ...r,
+          type: "annotation",
+          originalType: r ? r.type : undefined,
+        }));
+        totalForType = annotationMatches.length;
+      } else {
+        results =
+          typeLower === "all"
+            ? base
+            : base.filter((r) => String(r.type).toLowerCase() === typeLower);
+        if (shouldFilterWorks && allowed) {
+          results = results.filter((r) => allowed.has(r && r.__docIndex));
+        }
+
+        if (typeLower !== "all") {
+          try {
+            totalForType = records.filter(
+              (r) => String(r.type).toLowerCase() === typeLower
+            ).length;
+          } catch (_) {}
+        }
       }
     }
     const {facetsDocsMap: _fMap, ...publicState} = state;
@@ -390,6 +446,7 @@ function createSearchStore() {
       // Try to load meta for cache-busting and tab order; fall back to hash of JSON
       let version = "";
       let tabsOrder = [];
+      let annotationsAssetPath = "";
       try {
         const meta = await fetch("./api/index.json")
           .then((r) => (r && r.ok ? r.json() : null))
@@ -403,11 +460,17 @@ function createSearchStore() {
             ? meta.search.tabs.order
             : [];
         tabsOrder = ord.map((s) => String(s)).filter(Boolean);
+        const annotationsAsset =
+          meta &&
+          meta.search &&
+          meta.search.assets &&
+          meta.search.assets.annotations;
+        if (annotationsAsset && annotationsAsset.path) {
+          annotationsAssetPath = String(annotationsAsset.path);
+        }
       } catch (_) {}
-      const res = await fetch(
-        "./api/search-index.json" +
-          (version ? `?v=${encodeURIComponent(version)}` : "")
-      );
+      const suffix = version ? `?v=${encodeURIComponent(version)}` : "";
+      const res = await fetch(`./api/search-index.json${suffix}`);
       const text = await res.text();
       const parsed = (() => {
         try {
@@ -416,16 +479,89 @@ function createSearchStore() {
           return [];
         }
       })();
-      const rawData = Array.isArray(parsed)
+      const indexRecords = Array.isArray(parsed)
         ? parsed
         : parsed && parsed.records
         ? parsed.records
         : [];
-      const data = rawData.map((rec, i) => ({...(rec || {}), __docIndex: i}));
+
+      let displayRecords = [];
+      try {
+        const displayRes = await fetch(`./api/search-records.json${suffix}`);
+        if (displayRes && displayRes.ok) {
+          const displayJson = await displayRes.json().catch(() => []);
+          displayRecords = Array.isArray(displayJson)
+            ? displayJson
+            : displayJson && Array.isArray(displayJson.records)
+            ? displayJson.records
+            : [];
+        }
+      } catch (_) {}
+
+      const displayMap = new Map();
+      displayRecords.forEach((rec) => {
+        if (!rec || typeof rec !== "object") return;
+        const key = rec.id ? String(rec.id) : rec.href ? String(rec.href) : "";
+        if (!key) return;
+        displayMap.set(key, rec);
+      });
+
+      let annotationsRecords = [];
+      if (annotationsAssetPath) {
+        try {
+          const annotationsUrl = `./api/${annotationsAssetPath.replace(/^\/+/, '')}` + (version ? `?v=${encodeURIComponent(version)}` : "");
+          const annotationsRes = await fetch(annotationsUrl);
+          if (annotationsRes && annotationsRes.ok) {
+            const annotationsJson = await annotationsRes.json().catch(() => []);
+            annotationsRecords = Array.isArray(annotationsJson)
+              ? annotationsJson
+              : annotationsJson && Array.isArray(annotationsJson.records)
+              ? annotationsJson.records
+              : [];
+          }
+        } catch (_) {}
+      }
+
+      const annotationsMap = new Map();
+      annotationsRecords.forEach((rec, idx) => {
+        if (!rec || typeof rec !== "object") return;
+        const key = rec.id ? String(rec.id) : String(idx);
+        const text = rec.annotation ? String(rec.annotation) : rec.text ? String(rec.text) : "";
+        if (!key || !text) return;
+        annotationsMap.set(key, text);
+      });
+
+      const data = indexRecords.map((rec, i) => {
+        const key = rec && rec.id ? String(rec.id) : String(i);
+        const display = key ? displayMap.get(key) : null;
+        const merged = { ...(display || {}), ...(rec || {}), __docIndex: i };
+        if (!merged.id && key) merged.id = key;
+        if (!merged.href && display && display.href) merged.href = String(display.href);
+        if (merged.href) merged.href = withBasePath(merged.href);
+        if (!merged.title) merged.title = merged.href || "";
+        if (!Array.isArray(merged.metadata)) {
+          const meta = Array.isArray(rec && rec.metadata) ? rec.metadata : [];
+          merged.metadata = meta;
+        }
+        if (annotationsMap.has(key) && !merged.annotation)
+          merged.annotation = annotationsMap.get(key);
+        return merged;
+      });
       if (!version)
         version = (parsed && parsed.version) || (await sha256Hex(text));
 
       const idx = new Flex.Index({tokenize: "forward"});
+      const collectSearchText = (rec) => {
+        const parts = [];
+        if (rec && rec.title) parts.push(String(rec.title));
+        const metadata = Array.isArray(rec && rec.metadata) ? rec.metadata : [];
+        for (const value of metadata) {
+          if (value) parts.push(String(value));
+        }
+        if (rec && rec.summary) parts.push(String(rec.summary));
+        if (rec && rec.annotation) parts.push(String(rec.annotation));
+        return parts.join(" ").trim();
+      };
       let hydrated = false;
       const t0 =
         typeof performance !== "undefined" && performance.now
@@ -455,7 +591,8 @@ function createSearchStore() {
       if (!hydrated) {
         data.forEach((rec, i) => {
           try {
-            idx.add(i, rec && rec.title ? String(rec.title) : "");
+            const payload = collectSearchText(rec);
+            idx.add(i, payload);
           } catch (_) {}
         });
         try {
@@ -521,6 +658,8 @@ function createSearchStore() {
       const ts = Array.from(
         new Set(data.map((r) => String((r && r.type) || "page")))
       );
+      if (annotationsRecords.length && !ts.includes("annotation"))
+        ts.push("annotation");
       const order =
         Array.isArray(tabsOrder) && tabsOrder.length
           ? tabsOrder
@@ -548,7 +687,13 @@ function createSearchStore() {
           set({type: def});
         }
       } catch (_) {}
-      set({index: idx, records: data, types: ts, loading: false});
+      set({
+        index: idx,
+        records: data,
+        types: ts,
+        loading: false,
+        annotationsEnabled: annotationsRecords.length > 0,
+      });
       await hydrateFacets();
     } catch (_) {
       set({loading: false});
@@ -609,10 +754,17 @@ function useStore() {
 }
 
 function ResultsMount(props = {}) {
-  const {results, type, loading} = useStore();
+  const {results, type, loading, query} = useStore();
   if (loading) return <div className="text-slate-600">Loading…</div>;
   const layout = (props && props.layout) || "grid";
-  return <SearchResultsUI results={results} type={type} layout={layout} />;
+  return (
+    <SearchResultsUI
+      results={results}
+      type={type}
+      layout={layout}
+      query={query}
+    />
+  );
 }
 function TabsMount() {
   const {

package/lib/search/search-form-runtime.js

@@ -79,17 +79,99 @@ async function loadRecords() {
       try {
         const base = rootBase();
         let version = '';
+        let annotationsAssetPath = '';
         try {
           const meta = await fetch(`${base}/api/index.json`).then((r) => (r && r.ok ? r.json() : null)).catch(() => null);
           if (meta && typeof meta.version === 'string') version = meta.version;
+          const annotationsAsset =
+            meta &&
+            meta.search &&
+            meta.search.assets &&
+            meta.search.assets.annotations;
+          if (annotationsAsset && annotationsAsset.path) {
+            annotationsAssetPath = String(annotationsAsset.path);
+          }
         } catch (_) {}
         const suffix = version ? `?v=${encodeURIComponent(version)}` : '';
-        const response = await fetch(`${base}/api/search-index.json${suffix}`).catch(() => null);
-        if (!response || !response.ok) return [];
-        const json = await response.json().catch(() => []);
-        if (Array.isArray(json)) return json;
-        if (json && Array.isArray(json.records)) return json.records;
-        return [];
+        const indexUrl = `${base}/api/search-index.json${suffix}`;
+        const recordsUrl = `${base}/api/search-records.json${suffix}`;
+        const [indexRes, displayRes] = await Promise.all([
+          fetch(indexUrl).catch(() => null),
+          fetch(recordsUrl).catch(() => null),
+        ]);
+        let indexRecords = [];
+        if (indexRes && indexRes.ok) {
+          try {
+            const raw = await indexRes.json();
+            indexRecords = Array.isArray(raw)
+              ? raw
+              : raw && Array.isArray(raw.records)
+              ? raw.records
+              : [];
+          } catch (_) {
+            indexRecords = [];
+          }
+        }
+        let displayRecords = [];
+        if (displayRes && displayRes.ok) {
+          try {
+            const raw = await displayRes.json();
+            displayRecords = Array.isArray(raw)
+              ? raw
+              : raw && Array.isArray(raw.records)
+              ? raw.records
+              : [];
+          } catch (_) {
+            displayRecords = [];
+          }
+        }
+        let annotationsRecords = [];
+        if (annotationsAssetPath) {
+          try {
+            const annotationsUrl = `${base}/api/${annotationsAssetPath.replace(/^\/+/, '')}${suffix}`;
+            const annotationsRes = await fetch(annotationsUrl).catch(() => null);
+            if (annotationsRes && annotationsRes.ok) {
+              const raw = await annotationsRes.json().catch(() => []);
+              annotationsRecords = Array.isArray(raw)
+                ? raw
+                : raw && Array.isArray(raw.records)
+                ? raw.records
+                : [];
+            }
+          } catch (_) {}
+        }
+        if (!indexRecords.length && displayRecords.length) {
+          return displayRecords;
+        }
+        const displayMap = new Map();
+        displayRecords.forEach((rec) => {
+          if (!rec || typeof rec !== 'object') return;
+          const key = rec.id ? String(rec.id) : rec.href ? String(rec.href) : '';
+          if (!key) return;
+          displayMap.set(key, rec);
+        });
+        const annotationsMap = new Map();
+        annotationsRecords.forEach((rec, idx) => {
+          if (!rec || typeof rec !== 'object') return;
+          const key = rec.id ? String(rec.id) : String(idx);
+          const text = rec.annotation ? String(rec.annotation) : rec.text ? String(rec.text) : '';
+          if (!key || !text) return;
+          annotationsMap.set(key, text);
+        });
+        return indexRecords.map((rec, idx) => {
+          const key = rec && rec.id ? String(rec.id) : String(idx);
+          const display = key ? displayMap.get(key) : null;
+          const merged = { ...(display || {}), ...(rec || {}) };
+          if (!merged.id && key) merged.id = key;
+          if (!merged.href && display && display.href) merged.href = String(display.href);
+          if (!Array.isArray(merged.metadata)) {
+            const meta = Array.isArray(rec && rec.metadata) ? rec.metadata : [];
+            merged.metadata = meta;
+          }
+          if (annotationsMap.has(key) && !merged.annotation)
+            merged.annotation = annotationsMap.get(key);
+          return merged;
+        });
       } catch (_) {
         return [];
       }
@@ -129,22 +211,43 @@ function renderList(list, records, groupOrder) {
     header.style.cssText = 'padding:6px 12px;font-weight:600;color:#374151';
     list.appendChild(header);
     const entries = groups.get(key) || [];
-    entries.forEach((record, index) => {
-      const item = document.createElement('div');
+    entries.forEach((record) => {
+      const href = withBase(String(record && record.href || ''));
+      const item = document.createElement('a');
       item.setAttribute('data-canopy-item', '');
+      item.href = href;
       item.tabIndex = 0;
-      item.style.cssText = 'display:flex;align-items:center;gap:8px;padding:8px 12px;cursor:pointer;outline:none;';
+      item.className = 'canopy-card canopy-card--teaser';
+      item.style.cssText = 'display:flex;gap:12px;padding:8px 12px;text-decoration:none;color:#030712;border-radius:8px;align-items:center;outline:none;';
+
       const showThumb = String(record && record.type || '') === 'work' && record && record.thumbnail;
       if (showThumb) {
+        const media = document.createElement('div');
+        media.style.cssText = 'flex:0 0 48px;height:48px;border-radius:6px;overflow:hidden;background:#f1f5f9;display:flex;align-items:center;justify-content:center;';
         const img = document.createElement('img');
         img.src = record.thumbnail;
         img.alt = '';
-        img.style.cssText = 'width:40px;height:40px;object-fit:cover;border-radius:4px';
-        item.appendChild(img);
+        img.loading = 'lazy';
+        img.style.cssText = 'width:100%;height:100%;object-fit:cover;';
+        media.appendChild(img);
+        item.appendChild(media);
+      }
+
+      const textWrap = document.createElement('div');
+      textWrap.style.cssText = 'display:flex;flex-direction:column;gap:2px;min-width:0;';
+      const title = document.createElement('span');
+      title.textContent = record.title || record.href || '';
+      title.style.cssText = 'font-weight:600;font-size:0.95rem;line-height:1.3;color:#111827;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;';
+      textWrap.appendChild(title);
+      const meta = Array.isArray(record && record.metadata) ? record.metadata : [];
+      if (meta.length) {
+        const metaLine = document.createElement('span');
+        metaLine.textContent = meta.slice(0, 2).join(' • ');
+        metaLine.style.cssText = 'font-size:0.8rem;color:#475569;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;';
+        textWrap.appendChild(metaLine);
       }
-      const span = document.createElement('span');
-      span.textContent = record.title || record.href || '';
-      item.appendChild(span);
+      item.appendChild(textWrap);
+
       item.onmouseenter = () => { item.style.background = '#f8fafc'; };
       item.onmouseleave = () => { item.style.background = 'transparent'; };
       item.onfocus = () => {
@@ -152,9 +255,6 @@ function renderList(list, records, groupOrder) {
         try { item.scrollIntoView({ block: 'nearest' }); } catch (_) {}
       };
       item.onblur = () => { item.style.background = 'transparent'; };
-      item.onclick = () => {
-        try { window.location.href = withBase(String(record.href || '')); } catch (_) {}
-      };
       list.appendChild(item);
     });
   });
@@ -278,8 +378,15 @@ async function attachSearchForm(host) {
       for (let i = 0; i < records.length; i += 1) {
         const record = records[i];
         const title = String(record && record.title || '');
-        if (!title) continue;
-        if (toLower(title).includes(q)) out.push(record);
+        const parts = [toLower(title)];
+        const metadata = Array.isArray(record && record.metadata) ? record.metadata : [];
+        for (const value of metadata) {
+          parts.push(toLower(value));
+        }
+        if (record && record.summary) parts.push(toLower(record.summary));
+        if (record && record.annotation) parts.push(toLower(record.annotation));
+        const haystack = parts.join(' ');
+        if (haystack.includes(q)) out.push(record);
         if (out.length >= maxResults) break;
       }
       render(out);

package/lib/search/search.js

@@ -173,7 +173,7 @@ async function buildSearchPage() {
       }
     } catch (_) {}
     let html = htmlShell({ title: 'Search', body, cssHref: null, scriptHref: jsRel, headExtra });
-    try { html = require('./common').applyBaseToHtml(html); } catch (_) {}
+    try { html = require('../common').applyBaseToHtml(html); } catch (_) {}
     await fsp.writeFile(outPath, html, 'utf8');
     console.log('Search: Built', path.relative(process.cwd(), outPath));
   } catch (e) {
@@ -185,14 +185,66 @@ async function buildSearchPage() {
 function toSafeString(val, defaultValue = '') {
   try { return String(val == null ? defaultValue : val); } catch (_) { return defaultValue; }
 }
-function sanitizeRecord(r) {
+
+function sanitizeMetadataValues(list) {
+  const arr = Array.isArray(list) ? list : [];
+  const out = [];
+  const seen = new Set();
+  for (const val of arr) {
+    if (val && typeof val === 'object' && Array.isArray(val.values)) {
+      for (const v of val.values) {
+        const str = toSafeString(v, '').trim();
+        if (!str) continue;
+        const clipped = str.length > 500 ? str.slice(0, 500) + '…' : str;
+        if (seen.has(clipped)) continue;
+        seen.add(clipped);
+        out.push(clipped);
+      }
+      continue;
+    }
+    const str = toSafeString(val, '').trim();
+    if (!str) continue;
+    const clipped = str.length > 500 ? str.slice(0, 500) + '…' : str;
+    if (seen.has(clipped)) continue;
+    seen.add(clipped);
+    out.push(clipped);
+  }
+  return out;
+}
+
+function sanitizeRecordForIndex(r) {
   const title = toSafeString(r && r.title, '');
-  const hrefRaw = toSafeString(r && r.href, '');
-  const href = rootRelativeHref(hrefRaw);
   const type = toSafeString(r && r.type, 'page');
-  const thumbnail = toSafeString(r && r.thumbnail, '');
   const safeTitle = title.length > 300 ? title.slice(0, 300) + '…' : title;
-  const out = { title: safeTitle, href, type };
+  const out = { title: safeTitle, type };
+  const metadataSource =
+    (r && r.metadataValues) ||
+    (r && r.searchMetadataValues) ||
+    (r && r.search && r.search.metadata) ||
+    [];
+  const metadata = sanitizeMetadataValues(metadataSource);
+  if (metadata.length) out.metadata = metadata;
+  const summaryVal = toSafeString(
+    (r && r.summaryValue) ||
+      (r && r.searchSummary) ||
+      (r && r.search && r.search.summary),
+    ''
+  ).trim();
+  if (summaryVal) {
+    const clipped = summaryVal.length > 1000 ? summaryVal.slice(0, 1000) + '…' : summaryVal;
+    out.summary = clipped;
+  }
+  return out;
+}
+
+function sanitizeRecordForDisplay(r) {
+  const base = sanitizeRecordForIndex(r);
+  const out = { ...base };
+  if (out.metadata) delete out.metadata;
+  if (out.summary) out.summary = toSafeString(out.summary, '');
+  const hrefRaw = toSafeString(r && r.href, '');
+  out.href = rootRelativeHref(hrefRaw);
+  const thumbnail = toSafeString(r && r.thumbnail, '');
   if (thumbnail) out.thumbnail = thumbnail;
   // Preserve optional thumbnail dimensions for aspect ratio calculations in the UI
   try {
@@ -204,28 +256,76 @@ function sanitizeRecord(r) {
   return out;
 }
 
+/**
+ * Write search datasets consumed by the runtime layers.
+ *
+ * Outputs:
+ * - search-index.json: compact payload (title/href/type/metadata + stable id) for FlexSearch
+ * - search-records.json: richer display data (thumbnail/dimensions + id) for UI rendering
+ */
 async function writeSearchIndex(records) {
   const apiDir = path.join(OUT_DIR, 'api');
   ensureDirSync(apiDir);
   const idxPath = path.join(apiDir, 'search-index.json');
   const list = Array.isArray(records) ? records : [];
-  const safe = list.map(sanitizeRecord);
-  const json = JSON.stringify(safe, null, 2);
-  const approxBytes = Buffer.byteLength(json, 'utf8');
+  const indexRecords = list.map(sanitizeRecordForIndex);
+  const displayRecords = list.map(sanitizeRecordForDisplay);
+  for (let i = 0; i < indexRecords.length; i += 1) {
+    const id = String(i);
+    if (indexRecords[i]) indexRecords[i].id = id;
+    if (displayRecords[i]) displayRecords[i].id = id;
+    if (displayRecords[i] && !displayRecords[i].href) {
+      const original = list[i];
+      const href = original && original.href ? rootRelativeHref(String(original.href)) : '';
+      if (href) displayRecords[i].href = href;
+    }
+  }
+  const annotationsPath = path.join(apiDir, 'search-index-annotations.json');
+  const annotationRecords = [];
+  for (let i = 0; i < list.length; i += 1) {
+    const raw = list[i];
+    const annotationVal = toSafeString(
+      (raw && raw.annotationValue) ||
+        (raw && raw.searchAnnotation) ||
+        (raw && raw.search && raw.search.annotation),
+      ''
+    ).trim();
+    if (!annotationVal) continue;
+    annotationRecords.push({ id: String(i), annotation: annotationVal });
+  }
+
+  const indexJson = JSON.stringify(indexRecords);
+  const approxBytes = Buffer.byteLength(indexJson, 'utf8');
   if (approxBytes > 10 * 1024 * 1024) {
     console.warn('Search: index size is large (', Math.round(approxBytes / (1024 * 1024)), 'MB ). Consider narrowing sources.');
   }
-  await fsp.writeFile(idxPath, json, 'utf8');
+  await fsp.writeFile(idxPath, indexJson, 'utf8');
+
+  const displayPath = path.join(apiDir, 'search-records.json');
+  const displayJson = JSON.stringify(displayRecords);
+  const displayBytes = Buffer.byteLength(displayJson, 'utf8');
+  await fsp.writeFile(displayPath, displayJson, 'utf8');
+  let annotationsBytes = 0;
+  if (annotationRecords.length) {
+    const annotationsJson = JSON.stringify(annotationRecords);
+    annotationsBytes = Buffer.byteLength(annotationsJson, 'utf8');
+    await fsp.writeFile(annotationsPath, annotationsJson, 'utf8');
+  } else {
+    try {
+      if (fs.existsSync(annotationsPath)) await fsp.unlink(annotationsPath);
+    } catch (_) {}
+  }
   // Also write a small metadata file with a stable version hash for cache-busting and IDB keying
   try {
-    const version = crypto.createHash('sha256').update(json).digest('hex');
+    const version = crypto.createHash('sha256').update(indexJson).digest('hex');
     // Read optional search tabs order from canopy.yml
     let tabsOrder = [];
     try {
       const yaml = require('js-yaml');
-      const cfgPath = require('./common').path.resolve(process.env.CANOPY_CONFIG || 'canopy.yml');
-      if (require('./common').fs.existsSync(cfgPath)) {
-        const raw = require('./common').fs.readFileSync(cfgPath, 'utf8');
+      const common = require('../common');
+      const cfgPath = common.path.resolve(process.env.CANOPY_CONFIG || 'canopy.yml');
+      if (common.fs.existsSync(cfgPath)) {
+        const raw = common.fs.readFileSync(cfgPath, 'utf8');
         const data = yaml.load(raw) || {};
         const searchCfg = data && data.search ? data.search : {};
         const tabs = searchCfg && searchCfg.tabs ? searchCfg.tabs : {};
@@ -235,17 +335,25 @@ async function writeSearchIndex(records) {
     } catch (_) {}
     const meta = {
       version,
-      records: safe.length,
+      records: indexRecords.length,
       bytes: approxBytes,
       updatedAt: new Date().toISOString(),
       // Expose optional search config to the client runtime
-      search: { tabs: { order: tabsOrder } },
+      search: {
+        tabs: { order: tabsOrder },
+        assets: {
+          display: { path: 'search-records.json', bytes: displayBytes },
+          ...(annotationRecords.length
+            ? { annotations: { path: 'search-index-annotations.json', bytes: annotationsBytes } }
+            : {}),
+        },
+      },
     };
     const metaPath = path.join(apiDir, 'index.json');
     await fsp.writeFile(metaPath, JSON.stringify(meta, null, 2), 'utf8');
     try {
       const { logLine } = require('./log');
-      logLine(`✓ Search index version ${version.slice(0, 8)} (${safe.length} records)`, 'cyan');
+      logLine(`✓ Search index version ${version.slice(0, 8)} (${indexRecords.length} records)`, 'cyan');
     } catch (_) {}
     // Propagate version into IIIF cache index for a single, shared build identifier
     try {
@@ -263,7 +371,11 @@ async function writeSearchIndex(records) {
 
 // Compatibility: keep ensureResultTemplate as a no-op builder (template unused by React search)
 async function ensureResultTemplate() {
-  try { const { path } = require('./common'); const p = path.join(OUT_DIR, 'search-result.html'); await fsp.writeFile(p, '', 'utf8'); } catch (_) {}
+  try {
+    const { path } = require('../common');
+    const p = path.join(OUT_DIR, 'search-result.html');
+    await fsp.writeFile(p, '', 'utf8');
+  } catch (_) {}
 }
 
 module.exports = { ensureSearchRuntime, ensureResultTemplate, buildSearchPage, writeSearchIndex };