@fortemi/core 2026.6.3 → 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,6 +6915,121 @@ 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",
@@ -7520,8 +7745,8 @@ function communityIdsFor(item, options) {
 }
 
 // src/index.ts
-var VERSION = "2026.6.2";
+var VERSION = "2026.6.4";
 
-export { AIWG_SCAN_REQUIRED_FIELDS, 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, buildAiwgChunkedIndex, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, 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