@fortemi/core 2026.6.2 → 2026.6.4

package/dist/index.js

@@ -4700,16 +4700,126 @@ function suggestTags(noteEmbedding, tagEmbeddings, threshold = 0.6, maxTags = 5)
   return Array.from(tagEmbeddings.entries()).map(([tag, emb]) => ({ tag, score: cosineSimilarity(noteEmbedding, emb) })).filter(({ score }) => score > threshold).sort((a, b) => b.score - a.score).slice(0, maxTags).map(({ tag }) => tag);
 }
 
+// src/capabilities/embed-worker-transport.ts
+var EMBED_REQUEST_KIND = "fortemi:embed:request";
+var EMBED_RESPONSE_KIND = "fortemi:embed:response";
+var DEFAULT_TIMEOUT_MS = 3e4;
+function isEmbedResponse(data) {
+  return typeof data === "object" && data !== null && data.kind === EMBED_RESPONSE_KIND && typeof data.id === "number";
+}
+function isEmbedRequest(data) {
+  return typeof data === "object" && data !== null && data.kind === EMBED_REQUEST_KIND && typeof data.id === "number" && Array.isArray(data.texts);
+}
+function createWorkerEmbedFunction(port, options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  let disposed = false;
+  const onMessage = (event) => {
+    const data = event.data;
+    if (!isEmbedResponse(data)) return;
+    const entry = pending.get(data.id);
+    if (!entry) return;
+    pending.delete(data.id);
+    if (entry.timer !== null) clearTimeout(entry.timer);
+    if (data.error !== void 0) {
+      entry.reject(new Error(data.error));
+    } else if (Array.isArray(data.vectors)) {
+      entry.resolve(data.vectors);
+    } else {
+      entry.reject(new Error("Embed worker returned a malformed response (no vectors, no error)"));
+    }
+  };
+  port.addEventListener("message", onMessage);
+  port.start?.();
+  const embed = (texts) => {
+    if (disposed) {
+      return Promise.reject(new Error("Embed worker transport has been disposed"));
+    }
+    return new Promise((resolve, reject) => {
+      const id = nextId++;
+      let timer = null;
+      if (timeoutMs > 0) {
+        timer = setTimeout(() => {
+          if (pending.delete(id)) {
+            reject(new Error(`Embed worker request timed out after ${timeoutMs}ms`));
+          }
+        }, timeoutMs);
+      }
+      pending.set(id, { resolve, reject, timer });
+      try {
+        const message = { kind: EMBED_REQUEST_KIND, id, texts };
+        port.postMessage(message);
+      } catch (err) {
+        pending.delete(id);
+        if (timer !== null) clearTimeout(timer);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    port.removeEventListener("message", onMessage);
+    for (const [, entry] of pending) {
+      if (entry.timer !== null) clearTimeout(entry.timer);
+      entry.reject(new Error("Embed worker transport has been disposed"));
+    }
+    pending.clear();
+  };
+  return { embed, dispose };
+}
+function handleEmbedRequests(port, embed) {
+  const onMessage = (event) => {
+    const data = event.data;
+    if (!isEmbedRequest(data)) return;
+    const { id, texts } = data;
+    void Promise.resolve().then(() => embed(texts)).then((vectors) => {
+      const reply = { kind: EMBED_RESPONSE_KIND, id, vectors };
+      port.postMessage(reply);
+    }).catch((err) => {
+      const reply = {
+        kind: EMBED_RESPONSE_KIND,
+        id,
+        error: err instanceof Error ? err.message : String(err)
+      };
+      port.postMessage(reply);
+    });
+  };
+  port.addEventListener("message", onMessage);
+  port.start?.();
+  return () => {
+    port.removeEventListener("message", onMessage);
+  };
+}
+
 // src/capabilities/semantic-loader.ts
+var activeTransportDispose = null;
+function clearActiveTransport() {
+  if (activeTransportDispose) {
+    activeTransportDispose();
+    activeTransportDispose = null;
+  }
+}
 function registerSemanticCapability(manager, embedFn2, onProgress) {
   manager.registerLoader("semantic", async () => {
     if (onProgress) onProgress(0);
+    clearActiveTransport();
     setEmbedFunction(embedFn2);
     if (onProgress) onProgress(100);
   });
 }
+function registerSemanticCapabilityWorker(manager, port, options) {
+  manager.registerLoader("semantic", async () => {
+    clearActiveTransport();
+    const { embed, dispose } = createWorkerEmbedFunction(port, options);
+    activeTransportDispose = dispose;
+    setEmbedFunction(embed);
+  });
+}
 function unregisterSemanticCapability() {
   setEmbedFunction(null);
+  clearActiveTransport();
 }
 
 // src/capabilities/llm-loader.ts
@@ -6805,7 +6915,133 @@ function parseJsonArray(data) {
   return JSON.parse(decoder.decode(data));
 }
 
+// src/shard/prefetch.ts
+var DEFAULT_CACHE_NAME = "fortemi-shards";
+var warmStore = /* @__PURE__ */ new Map();
+var inFlight = /* @__PURE__ */ new Map();
+function toUint8(data) {
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+function getCacheStorage() {
+  return globalThis.caches;
+}
+async function readFromCacheStorage(url, cacheName) {
+  const caches = getCacheStorage();
+  if (!caches) return null;
+  try {
+    const cache = await caches.open(cacheName);
+    const res = await cache.match(url);
+    if (!res) return null;
+    return new Uint8Array(await res.arrayBuffer());
+  } catch {
+    return null;
+  }
+}
+async function writeToCacheStorage(url, bytes, cacheName) {
+  const caches = getCacheStorage();
+  if (!caches) return;
+  try {
+    const cache = await caches.open(cacheName);
+    const body = bytes.slice().buffer;
+    await cache.put(url, new Response(body));
+  } catch {
+  }
+}
+async function maybeHash(bytes, options) {
+  const expected = options?.expectedSha256;
+  if (expected !== void 0) {
+    const actual = await sha256Hex(bytes);
+    if (actual.toLowerCase() !== expected.toLowerCase()) {
+      throw new Error(
+        `Shard SHA-256 mismatch: expected ${expected.toLowerCase()}, got ${actual}`
+      );
+    }
+    return actual;
+  }
+  if (options?.verify) {
+    return sha256Hex(bytes);
+  }
+  return void 0;
+}
+function prefetchShard(url, options) {
+  if (options?.bytes !== void 0) {
+    const bytes = toUint8(options.bytes);
+    return (async () => {
+      const sha2562 = await maybeHash(bytes, options);
+      warmStore.set(url, { bytes, sha256: sha2562 });
+      if (options.useCacheStorage) {
+        await writeToCacheStorage(url, bytes, options.cacheName ?? DEFAULT_CACHE_NAME);
+      }
+      return { url, bytes, byteLength: bytes.byteLength, sha256: sha2562, fromCache: false };
+    })();
+  }
+  const existing = inFlight.get(url);
+  if (existing) return existing;
+  const cacheName = options?.cacheName ?? DEFAULT_CACHE_NAME;
+  const fetchImpl = options?.fetchImpl ?? globalThis.fetch;
+  const work = (async () => {
+    let bytes = null;
+    let fromCache = false;
+    if (options?.useCacheStorage) {
+      bytes = await readFromCacheStorage(url, cacheName);
+      fromCache = bytes !== null;
+    }
+    if (!bytes) {
+      if (typeof fetchImpl !== "function") {
+        throw new Error("prefetchShard: no fetch implementation available (pass options.fetchImpl)");
+      }
+      const res = await fetchImpl(url, options?.signal ? { signal: options.signal } : void 0);
+      if (!res.ok) {
+        throw new Error(`Failed to prefetch shard ${url}: HTTP ${res.status} ${res.statusText}`);
+      }
+      bytes = new Uint8Array(await res.arrayBuffer());
+    }
+    const sha2562 = await maybeHash(bytes, options);
+    warmStore.set(url, { bytes, sha256: sha2562 });
+    if (options?.useCacheStorage && !fromCache) {
+      await writeToCacheStorage(url, bytes, cacheName);
+    }
+    return { url, bytes, byteLength: bytes.byteLength, sha256: sha2562, fromCache };
+  })();
+  const tracked = work.finally(() => {
+    inFlight.delete(url);
+  });
+  inFlight.set(url, tracked);
+  return tracked;
+}
+function fromPrefetched(url) {
+  const entry = warmStore.get(url);
+  if (!entry) {
+    throw new Error(`Shard not prefetched: ${url}. Call prefetchShard(url) first.`);
+  }
+  return entry.bytes;
+}
+function isShardPrefetched(url) {
+  return warmStore.has(url);
+}
+function getPrefetchedSha256(url) {
+  return warmStore.get(url)?.sha256;
+}
+function clearPrefetchedShard(url) {
+  if (url === void 0) {
+    warmStore.clear();
+    return;
+  }
+  warmStore.delete(url);
+}
+
 // src/aiwg-index.ts
+var AIWG_SCAN_REQUIRED_FIELDS = [
+  "schema_version",
+  "id",
+  "type",
+  "title",
+  "text",
+  "facets",
+  "tags",
+  "concepts",
+  "privacy"
+];
 var REQUIRED_RECORD_FIELDS = [
   "schema_version",
   "id",
@@ -6917,6 +7153,20 @@ function validateAiwgFortemiChunkManifest(value) {
   if (data.facets !== void 0 && !isFacetCounts(data.facets)) {
     errors.push("facets must be a nested string-to-number count object");
   }
+  if (data.projection !== void 0) {
+    if (!Array.isArray(data.projection) || !data.projection.every((field) => typeof field === "string")) {
+      errors.push("projection must be an array of field names");
+    } else {
+      const present = new Set(data.projection);
+      for (const field of AIWG_SCAN_REQUIRED_FIELDS) {
+        if (!present.has(field)) errors.push("projection must include scan-required field " + field);
+      }
+    }
+  }
+  if (data.detail !== void 0) {
+    if (!hasString(data.detail.href)) errors.push("detail.href is required");
+    else if (!data.detail.href.includes("{id}")) errors.push("detail.href must contain the {id} placeholder");
+  }
   if (!Array.isArray(data?.parts)) errors.push("parts must be an array");
   let expectedOffset = 0;
   const parts = Array.isArray(data?.parts) ? data.parts : [];
@@ -6941,6 +7191,35 @@ function assertAiwgFortemiChunkManifest(value) {
   }
   return value;
 }
+function validateProjectedRecords(items) {
+  const errors = [];
+  const ids = /* @__PURE__ */ new Set();
+  let previousId = "";
+  for (const [index, item] of items.entries()) {
+    if (item.schema_version !== "aiwg.fortemi.index.record.v1") {
+      errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1");
+    }
+    if (!hasString(item.id)) errors.push("items[" + index + "].id is required");
+    if (hasString(item.id) && ids.has(item.id)) errors.push("duplicate id: " + item.id);
+    if (hasString(item.id)) ids.add(item.id);
+    if (previousId && hasString(item.id) && previousId.localeCompare(item.id) > 0) {
+      errors.push("items must be sorted by id: " + previousId + " before " + item.id);
+    }
+    if (hasString(item.id)) previousId = item.id;
+    if (!item.type || !VALID_TYPES.has(item.type)) errors.push("items[" + index + "].type is invalid");
+    if (!hasString(item.title)) errors.push("items[" + index + "].title is required");
+    if (typeof item.text !== "string") errors.push("items[" + index + "].text is required");
+    if (!item.facets || typeof item.facets !== "object" || Array.isArray(item.facets)) {
+      errors.push("items[" + index + "].facets must be an object");
+    }
+    if (!Array.isArray(item.tags)) errors.push("items[" + index + "].tags must be an array");
+    if (!Array.isArray(item.concepts)) errors.push("items[" + index + "].concepts must be an array");
+    if (!item.privacy || !hasString(item.privacy.classification)) {
+      errors.push("items[" + index + "].privacy.classification is required");
+    }
+  }
+  return errors;
+}
 function validateAiwgFortemiChunkPart(value, partRef, manifest) {
   const errors = [];
   const data = value;
@@ -6959,13 +7238,17 @@ function validateAiwgFortemiChunkPart(value, partRef, manifest) {
     errors.push("items length must match manifest part count " + partRef.count);
   }
   if (Array.isArray(data?.items)) {
-    const validation = validateAiwgFortemiIndexExport({
-      schema_version: "aiwg.fortemi.index.export.v1",
-      generated_at: manifest?.generated_at ?? "1970-01-01T00:00:00.000Z",
-      source: manifest?.source ?? { repo: "chunk", privacy: "public" },
-      items: data.items
-    });
-    errors.push(...validation.errors.map((error) => "items." + error));
+    if (manifest?.projection) {
+      errors.push(...validateProjectedRecords(data.items).map((error) => "items." + error));
+    } else {
+      const validation = validateAiwgFortemiIndexExport({
+        schema_version: "aiwg.fortemi.index.export.v1",
+        generated_at: manifest?.generated_at ?? "1970-01-01T00:00:00.000Z",
+        source: manifest?.source ?? { repo: "chunk", privacy: "public" },
+        items: data.items
+      });
+      errors.push(...validation.errors.map((error) => "items." + error));
+    }
   }
   return { valid: errors.length === 0, errors };
 }
@@ -6984,6 +7267,16 @@ function createAiwgFetchChunkLoader(baseUrl) {
     return response.json();
   };
 }
+function createAiwgFetchDetailLoader(baseUrl) {
+  return async (id, manifest) => {
+    if (!manifest.detail?.href) throw new Error("Manifest has no detail.href for record resolution");
+    const relative = manifest.detail.href.replace("{id}", encodeURIComponent(id));
+    const href = baseUrl ? new URL(relative, baseUrl).toString() : relative;
+    const response = await fetch(href);
+    if (!response.ok) throw new Error("Failed to fetch AIWG index detail " + href + ": " + response.status);
+    return response.json();
+  };
+}
 function getAiwgFortemiFacets(items) {
   const result = {};
   for (const item of items) {
@@ -6997,6 +7290,49 @@ function getAiwgFortemiFacets(items) {
   }
   return result;
 }
+function buildAiwgChunkedIndex(index, options = {}) {
+  const partSize = hasPositiveInteger(options.partSize) ? options.partSize : 500;
+  const projection = options.projection;
+  const items = index.items;
+  const pad = (value) => String(value).padStart(4, "0");
+  const project = (record) => {
+    if (!projection) return record;
+    const slim = {};
+    for (const field of projection) slim[field] = record[field];
+    return slim;
+  };
+  const parts = [];
+  const partRefs = [];
+  for (let offset = 0, partIndex = 0; offset < items.length; offset += partSize, partIndex += 1) {
+    const slice = items.slice(offset, offset + partSize);
+    const href = "part-" + pad(partIndex) + ".json";
+    parts.push({
+      href,
+      part: {
+        schema_version: "aiwg.fortemi.index.chunk.v1",
+        manifest_schema_version: "aiwg.fortemi.index.chunk-manifest.v1",
+        offset,
+        items: slice.map(project)
+      }
+    });
+    partRefs.push({ href, offset, count: slice.length });
+  }
+  const manifest = {
+    schema_version: "aiwg.fortemi.index.chunk-manifest.v1",
+    generated_at: options.generatedAt ?? index.generated_at,
+    source: index.source,
+    total: items.length,
+    part_size: partSize,
+    facets: getAiwgFortemiFacets(items),
+    parts: partRefs,
+    ...projection ? { projection, detail: { href: options.detailHref ?? "detail/{id}.json" } } : {}
+  };
+  return {
+    manifest,
+    parts,
+    details: projection ? items.map((record) => ({ id: record.id, record })) : []
+  };
+}
 function includesAll(actual, expected) {
   if (!expected || expected.length === 0) return true;
   const actualSet = new Set(actual);
@@ -7051,7 +7387,7 @@ function createRankedEntries(items, q, options, ordinalBase = 0) {
     if (!includesAll(item.tags, options.tags)) return false;
     if (!includesAll(item.concepts, options.concepts)) return false;
     if (!matchesFacetFilters(item, options.facets)) return false;
-    if (options.relationshipTargetId && !item.relationships.some((rel) => rel.target_id === options.relationshipTargetId)) {
+    if (options.relationshipTargetId && !(item.relationships ?? []).some((rel) => rel.target_id === options.relationshipTargetId)) {
       return false;
     }
     return true;
@@ -7100,6 +7436,10 @@ function clampMaxCachedParts(value) {
   if (!hasPositiveInteger(value)) return 3;
   return value;
 }
+function clampMaxCachedDetails(value) {
+  if (!hasPositiveInteger(value)) return 32;
+  return value;
+}
 function isDirectChunkBrowse(query, options) {
   return query.trim() === "" && !options.rank && !options.snippets && !options.includeMatches && !options.types && !options.facets && !options.tags && !options.concepts && !options.privacy && !options.relationshipTargetId;
 }
@@ -7124,6 +7464,40 @@ async function loadChunkPart(runtime, part) {
   }
   return { part: parsed, fetched: true };
 }
+async function getChunkRecord(runtime, id) {
+  const cached = runtime.detailCache.get(id);
+  if (cached) {
+    runtime.detailCache.delete(id);
+    runtime.detailCache.set(id, cached);
+    return cached;
+  }
+  if (!runtime.manifest.projection) {
+    for (const part of runtime.partCache.values()) {
+      const found = part.items.find((item) => item.id === id);
+      if (found) return found;
+    }
+  }
+  if (!runtime.detailLoader) {
+    throw new Error("No detailLoader configured to resolve record " + id);
+  }
+  const raw = await runtime.detailLoader(id, runtime.manifest);
+  const record = assertAiwgFortemiIndexExport({
+    schema_version: "aiwg.fortemi.index.export.v1",
+    generated_at: runtime.manifest.generated_at,
+    source: runtime.manifest.source,
+    items: [raw]
+  }).items[0];
+  if (record.id !== id) {
+    throw new Error("Detail record id mismatch: expected " + id + ", got " + record.id);
+  }
+  runtime.detailCache.set(id, record);
+  while (runtime.detailCache.size > runtime.maxCachedDetails) {
+    const oldest = runtime.detailCache.keys().next().value;
+    if (oldest === void 0) break;
+    runtime.detailCache.delete(oldest);
+  }
+  return record;
+}
 async function queryChunkedAiwgFortemiIndex(runtime, query = "", options = {}) {
   const q = query.trim().toLowerCase();
   let scannedParts = 0;
@@ -7228,7 +7602,10 @@ function createAiwgIndexController(initialIndex) {
           manifest: parsed,
           loader,
           maxCachedParts: clampMaxCachedParts(options.maxCachedParts),
-          partCache: /* @__PURE__ */ new Map()
+          partCache: /* @__PURE__ */ new Map(),
+          detailLoader: options.detailLoader,
+          maxCachedDetails: clampMaxCachedDetails(options.maxCachedDetails),
+          detailCache: /* @__PURE__ */ new Map()
         };
         data = null;
         reviewDecisions = [];
@@ -7271,8 +7648,23 @@ function createAiwgIndexController(initialIndex) {
         throw error;
       }
     },
+    async getRecord(id) {
+      if (chunked) {
+        try {
+          return await getChunkRecord(chunked, id);
+        } catch (err) {
+          error = err instanceof Error ? err : new Error(String(err));
+          notify();
+          throw error;
+        }
+      }
+      const found = requireIndex().items.find((item) => item.id === id);
+      if (!found) throw new Error("Record not found: " + id);
+      return found;
+    },
     clearChunkCache() {
       chunked?.partCache.clear();
+      chunked?.detailCache.clear();
       error = null;
       notify();
     },
@@ -7353,8 +7745,8 @@ function communityIdsFor(item, options) {
 }
 
 // src/index.ts
-var VERSION = "2026.6.2";
+var VERSION = "2026.6.4";
 
-export { ArchiveManager, AttachmentsRepository, CURRENT_SHARD_VERSION, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, EmbeddingSetsRepository, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LOCAL_ENDPOINTS, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProviderRegistry, SHARD_FORMAT, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexToCommunityGraph, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteInstance, createRoutes, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchPluginScript, fortemiManifest, generateId, getAiwgFortemiFacets, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getLlmFunction, getNote, hasFortemiSecureSecrets, importShard, isPluginScriptAllowed, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteSkosTagToShard, noteToShard, packTarGz, parseCspReport, provenanceEdgeToShard, queryAiwgFortemiIndex, registerLlmCapability, registerSemanticCapability, registerServiceWorker, searchTool, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateChecksums, verifySri };
+export { AIWG_SCAN_REQUIRED_FIELDS, ArchiveManager, AttachmentsRepository, CURRENT_SHARD_VERSION, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, EmbeddingSetsRepository, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LOCAL_ENDPOINTS, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProviderRegistry, SHARD_FORMAT, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexToCommunityGraph, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, buildAiwgChunkedIndex, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteInstance, createRoutes, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchPluginScript, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, isPluginScriptAllowed, isShardPrefetched, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteSkosTagToShard, noteToShard, packTarGz, parseCspReport, prefetchShard, provenanceEdgeToShard, queryAiwgFortemiIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, searchTool, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateChecksums, verifySri };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map