sensemaking 0.25.0 → 0.26.0

package/dist/cjs/embed/cohere.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "cohereProvider", {
     }
 });
 var _errorsts = require("../errors.js");
+var _endpointts = require("./endpoint.js");
 var _httpts = require("./http.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -135,13 +136,37 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 var BATCH_CAP = 96;
+function isNumberArray(value) {
+    return Array.isArray(value) && value.every(function(part) {
+        return typeof part === 'number';
+    });
+}
+function isEmbeddingArray(value) {
+    return Array.isArray(value) && value.every(isNumberArray);
+}
+function parseBody(body, endpoint) {
+    var decoded;
+    try {
+        decoded = JSON.parse(new TextDecoder().decode(body));
+    } catch (unused) {
+        throw new _errorsts.SenseError('EMBED_MODEL', "".concat(endpoint, " returned invalid JSON"));
+    }
+    if (decoded === null || (typeof decoded === "undefined" ? "undefined" : _type_of(decoded)) !== 'object' || !('embeddings' in decoded) || decoded.embeddings === null || _type_of(decoded.embeddings) !== 'object' || !('float' in decoded.embeddings) || !isEmbeddingArray(decoded.embeddings.float)) {
+        throw new _errorsts.SenseError('EMBED_MODEL', "".concat(endpoint, " returned an invalid embedding response"));
+    }
+    return decoded.embeddings.float;
+}
 function cohereProvider(model, url, keyEnv) {
     return _async_to_generator(function() {
         var base, headers, key, dims;
-        function post(texts, inputType) {
+        function post(texts, inputType, options) {
             return _async_to_generator(function() {
-                var res, body, vectors;
+                var _options_signal, res, body, vectors;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
@@ -158,21 +183,20 @@ function cohereProvider(model, url, keyEnv) {
                                             'float'
                                         ]
                                     })
+                                }, {
+                                    signal: options === null || options === void 0 ? void 0 : options.signal,
+                                    attemptTimeoutMs: _httpts.HTTP_ATTEMPT_TIMEOUT_MS
                                 })
                             ];
                         case 1:
                             res = _state.sent();
-                            if (!res.ok) throw new _errorsts.SenseError('EMBED_MODEL', "".concat(base, "/v2/embed -> HTTP ").concat(res.status));
-                            return [
-                                4,
-                                res.json()
-                            ];
-                        case 2:
-                            body = _state.sent();
+                            options === null || options === void 0 ? void 0 : (_options_signal = options.signal) === null || _options_signal === void 0 ? void 0 : _options_signal.throwIfAborted();
+                            if (!res.ok) throw new _errorsts.SenseError('EMBED_MODEL', "".concat(res.url, " -> HTTP ").concat(res.status));
+                            body = parseBody(res.body, res.url);
                             // Cohere returns one vector per text in order, with no index field to re-sort by; a caller
                             // maps them positionally, so the count below must be trustworthy.
-                            vectors = body.embeddings.float;
-                            if (vectors.length !== texts.length) throw new _errorsts.SenseError('EMBED_MODEL', "".concat(base, "/v2/embed returned ").concat(vectors.length, " embeddings for ").concat(texts.length, " inputs"));
+                            vectors = body;
+                            if (vectors.length !== texts.length) throw new _errorsts.SenseError('EMBED_MODEL', "".concat(res.url, " returned ").concat(vectors.length, " embeddings for ").concat(texts.length, " inputs"));
                             return [
                                 2,
                                 vectors.map(function(v) {
@@ -186,7 +210,8 @@ function cohereProvider(model, url, keyEnv) {
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    base = (url !== null && url !== void 0 ? url : 'https://api.cohere.com').replace(/\/+$/, '');
+                    base = (0, _endpointts.effectiveEmbedEndpoint)('cohere', url);
+                    if (!base) throw new _errorsts.SenseError('EMBED_MODEL', 'cohere endpoint resolution failed');
                     headers = {
                         'content-type': 'application/json'
                     };
@@ -206,10 +231,10 @@ function cohereProvider(model, url, keyEnv) {
                             id: "cohere:".concat(base, ":").concat(model),
                             dims: dims,
                             batchCap: BATCH_CAP,
-                            embedDocuments: function embedDocuments(texts) {
-                                return post(texts, 'search_document');
+                            embedDocuments: function embedDocuments(texts, options) {
+                                return post(texts, 'search_document', options);
                             },
-                            embedQuery: function embedQuery(text) {
+                            embedQuery: function embedQuery(text, options) {
                                 return _async_to_generator(function() {
                                     return _ts_generator(this, function(_state) {
                                         switch(_state.label){
@@ -218,7 +243,7 @@ function cohereProvider(model, url, keyEnv) {
                                                     4,
                                                     post([
                                                         text
-                                                    ], 'search_query')
+                                                    ], 'search_query', options)
                                                 ];
                                             case 1:
                                                 return [

package/dist/cjs/embed/cohere.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/cohere.ts"],"sourcesContent":["import { SenseError } from '../errors.ts';\nimport { fetchWithRetry } from './http.ts';\nimport type { EmbedProvider } from './types.ts';\n\nconst BATCH_CAP = 96;\n\n// Cohere's native /v2/embed: input_type distinguishes doc vs query embeddings, which the\n// OpenAI-compatible shape cannot express.\nexport async function cohereProvider(model: string, url: string | undefined, keyEnv: string | undefined): Promise<EmbedProvider> {\n  const base = (url ?? 'https://api.cohere.com').replace(/\\/+$/, '');\n  const headers: Record<string, string> = { 'content-type': 'application/json' };\n  const key = keyEnv ? process.env[keyEnv] : undefined;\n  if (key) headers.authorization = `Bearer ${key}`;\n\n  async function post(texts: string[], inputType: 'search_document' | 'search_query'): Promise<Float32Array[]> {\n    const res = await fetchWithRetry(`${base}/v2/embed`, { method: 'POST', headers, body: JSON.stringify({ model, input_type: inputType, texts, embedding_types: ['float'] }) });\n    if (!res.ok) throw new SenseError('EMBED_MODEL', `${base}/v2/embed -> HTTP ${res.status}`);\n    const body = (await res.json()) as { embeddings: { float: number[][] } };\n    // Cohere returns one vector per text in order, with no index field to re-sort by; a caller\n    // maps them positionally, so the count below must be trustworthy.\n    const vectors = body.embeddings.float;\n    if (vectors.length !== texts.length) throw new SenseError('EMBED_MODEL', `${base}/v2/embed returned ${vectors.length} embeddings for ${texts.length} inputs`);\n    return vectors.map((v) => Float32Array.from(v));\n  }\n\n  const dims = (await post(['dimension probe'], 'search_query'))[0].length;\n  return { id: `cohere:${base}:${model}`, dims, batchCap: BATCH_CAP, embedDocuments: (texts) => post(texts, 'search_document'), embedQuery: async (text) => (await post([text], 'search_query'))[0] };\n}\n"],"names":["cohereProvider","BATCH_CAP","model","url","keyEnv","base","headers","key","dims","post","texts","inputType","res","body","vectors","fetchWithRetry","method","JSON","stringify","input_type","embedding_types","ok","SenseError","status","json","embeddings","float","length","map","v","Float32Array","from","replace","process","env","undefined","authorization","id","batchCap","embedDocuments","embedQuery","text"],"mappings":";;;;+BAQsBA;;;eAAAA;;;wBARK;sBACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG/B,IAAMC,YAAY;AAIX,SAAeD,eAAeE,KAAa,EAAEC,GAAuB,EAAEC,MAA0B;;YAC/FC,MACAC,SACAC,KAcAC;QAXN,SAAeC,KAAKC,KAAe,EAAEC,SAA6C;;oBAC1EC,KAEAC,MAGAC;;;;4BALM;;gCAAMC,IAAAA,sBAAc,EAAC,AAAC,GAAO,OAALV,MAAK,cAAY;oCAAEW,QAAQ;oCAAQV,SAAAA;oCAASO,MAAMI,KAAKC,SAAS,CAAC;wCAAEhB,OAAAA;wCAAOiB,YAAYR;wCAAWD,OAAAA;wCAAOU,eAAe;4CAAG;;oCAAS;gCAAG;;;4BAApKR,MAAM;4BACZ,IAAI,CAACA,IAAIS,EAAE,EAAE,MAAM,IAAIC,oBAAU,CAAC,eAAe,AAAC,GAA2BV,OAAzBP,MAAK,sBAA+B,OAAXO,IAAIW,MAAM;4BACzE;;gCAAMX,IAAIY,IAAI;;;4BAAtBX,OAAQ;4BACd,2FAA2F;4BAC3F,kEAAkE;4BAC5DC,UAAUD,KAAKY,UAAU,CAACC,KAAK;4BACrC,IAAIZ,QAAQa,MAAM,KAAKjB,MAAMiB,MAAM,EAAE,MAAM,IAAIL,oBAAU,CAAC,eAAe,AAAC,GAA4BR,OAA1BT,MAAK,uBAAsDK,OAAjCI,QAAQa,MAAM,EAAC,oBAA+B,OAAbjB,MAAMiB,MAAM,EAAC;4BACpJ;;gCAAOb,QAAQc,GAAG,CAAC,SAACC;2CAAMC,aAAaC,IAAI,CAACF;;;;;YAC9C;;;;;oBAdMxB,OAAO,CAACF,gBAAAA,iBAAAA,MAAO,0BAA0B6B,OAAO,CAAC,QAAQ;oBACzD1B,UAAkC;wBAAE,gBAAgB;oBAAmB;oBACvEC,MAAMH,SAAS6B,QAAQC,GAAG,CAAC9B,OAAO,GAAG+B;oBAC3C,IAAI5B,KAAKD,QAAQ8B,aAAa,GAAG,AAAC,UAAa,OAAJ7B;oBAa7B;;wBAAME;4BAAM;2BAAoB;;;oBAAxCD,OAAO,AAAC,aAAgD,CAAC,EAAE,CAACmB,MAAM;oBACxE;;wBAAO;4BAAEU,IAAI,AAAC,UAAiBnC,OAARG,MAAK,KAAS,OAANH;4BAASM,MAAAA;4BAAM8B,UAAUrC;4BAAWsC,gBAAgB,SAAhBA,eAAiB7B;uCAAUD,KAAKC,OAAO;;4BAAoB8B,YAAY,SAAZA,WAAmBC;;;;;gDAAU;;oDAAMhC;wDAAMgC;uDAAO;;;;;oDAAnB,aAAmC,CAAC,EAAE;;;;;;wBAAC;;;;IACpM"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/cohere.ts"],"sourcesContent":["import { SenseError } from '../errors.ts';\nimport { effectiveEmbedEndpoint } from './endpoint.ts';\nimport { fetchWithRetry, HTTP_ATTEMPT_TIMEOUT_MS } from './http.ts';\nimport type { EmbedCallOptions, EmbedProvider } from './types.ts';\n\nconst BATCH_CAP = 96;\n\nfunction isNumberArray(value: unknown): value is number[] {\n  return Array.isArray(value) && value.every((part) => typeof part === 'number');\n}\n\nfunction isEmbeddingArray(value: unknown): value is number[][] {\n  return Array.isArray(value) && value.every(isNumberArray);\n}\n\nfunction parseBody(body: ArrayBuffer, endpoint: string): number[][] {\n  let decoded: unknown;\n  try {\n    decoded = JSON.parse(new TextDecoder().decode(body));\n  } catch {\n    throw new SenseError('EMBED_MODEL', `${endpoint} returned invalid JSON`);\n  }\n  if (decoded === null || typeof decoded !== 'object' || !('embeddings' in decoded) || decoded.embeddings === null || typeof decoded.embeddings !== 'object' || !('float' in decoded.embeddings) || !isEmbeddingArray(decoded.embeddings.float)) {\n    throw new SenseError('EMBED_MODEL', `${endpoint} returned an invalid embedding response`);\n  }\n  return decoded.embeddings.float;\n}\n\n// Cohere's native /v2/embed: input_type distinguishes doc vs query embeddings, which the\n// OpenAI-compatible shape cannot express.\nexport async function cohereProvider(model: string, url: string | undefined, keyEnv: string | undefined): Promise<EmbedProvider> {\n  const base = effectiveEmbedEndpoint('cohere', url);\n  if (!base) throw new SenseError('EMBED_MODEL', 'cohere endpoint resolution failed');\n  const headers: Record<string, string> = { 'content-type': 'application/json' };\n  const key = keyEnv ? process.env[keyEnv] : undefined;\n  if (key) headers.authorization = `Bearer ${key}`;\n\n  async function post(texts: string[], inputType: 'search_document' | 'search_query', options?: EmbedCallOptions): Promise<Float32Array[]> {\n    const res = await fetchWithRetry(`${base}/v2/embed`, { method: 'POST', headers, body: JSON.stringify({ model, input_type: inputType, texts, embedding_types: ['float'] }) }, { signal: options?.signal, attemptTimeoutMs: HTTP_ATTEMPT_TIMEOUT_MS });\n    options?.signal?.throwIfAborted();\n    if (!res.ok) throw new SenseError('EMBED_MODEL', `${res.url} -> HTTP ${res.status}`);\n    const body = parseBody(res.body, res.url);\n    // Cohere returns one vector per text in order, with no index field to re-sort by; a caller\n    // maps them positionally, so the count below must be trustworthy.\n    const vectors = body;\n    if (vectors.length !== texts.length) throw new SenseError('EMBED_MODEL', `${res.url} returned ${vectors.length} embeddings for ${texts.length} inputs`);\n    return vectors.map((v) => Float32Array.from(v));\n  }\n\n  const dims = (await post(['dimension probe'], 'search_query'))[0].length;\n  return { id: `cohere:${base}:${model}`, dims, batchCap: BATCH_CAP, embedDocuments: (texts, options) => post(texts, 'search_document', options), embedQuery: async (text, options) => (await post([text], 'search_query', options))[0] };\n}\n"],"names":["cohereProvider","BATCH_CAP","isNumberArray","value","Array","isArray","every","part","isEmbeddingArray","parseBody","body","endpoint","decoded","JSON","parse","TextDecoder","decode","SenseError","embeddings","float","model","url","keyEnv","base","headers","key","dims","post","texts","inputType","options","res","vectors","fetchWithRetry","method","stringify","input_type","embedding_types","signal","attemptTimeoutMs","HTTP_ATTEMPT_TIMEOUT_MS","throwIfAborted","ok","status","length","map","v","Float32Array","from","effectiveEmbedEndpoint","process","env","undefined","authorization","id","batchCap","embedDocuments","embedQuery","text"],"mappings":"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"}

package/dist/cjs/embed/endpoint.d.cts

@@ -0,0 +1,2 @@
+export declare function effectiveEmbedEndpoint(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined;
+export declare function embedEndpointIdentity(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined;

package/dist/cjs/embed/endpoint.d.ts

@@ -0,0 +1,2 @@
+export declare function effectiveEmbedEndpoint(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined;
+export declare function embedEndpointIdentity(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined;

package/dist/cjs/embed/endpoint.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get effectiveEmbedEndpoint () {
+        return effectiveEmbedEndpoint;
+    },
+    get embedEndpointIdentity () {
+        return embedEndpointIdentity;
+    }
+});
+var _nodecrypto = require("node:crypto");
+var DEFAULT_COHERE_ENDPOINT = 'https://api.cohere.com';
+function effectiveEmbedEndpoint(provider, url) {
+    if (provider === 'static') return undefined;
+    var endpoint = provider === 'cohere' ? url !== null && url !== void 0 ? url : DEFAULT_COHERE_ENDPOINT : url;
+    return endpoint === null || endpoint === void 0 ? void 0 : endpoint.replace(/\/+$/, '');
+}
+function embedEndpointIdentity(provider, url) {
+    var endpoint = effectiveEmbedEndpoint(provider, url);
+    return endpoint === undefined ? undefined : (0, _nodecrypto.createHash)('sha256').update(endpoint).digest('hex');
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/embed/endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/endpoint.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\nconst DEFAULT_COHERE_ENDPOINT = 'https://api.cohere.com';\n\nexport function effectiveEmbedEndpoint(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined {\n  if (provider === 'static') return undefined;\n  const endpoint = provider === 'cohere' ? (url ?? DEFAULT_COHERE_ENDPOINT) : url;\n  return endpoint?.replace(/\\/+$/, '');\n}\n\nexport function embedEndpointIdentity(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined {\n  const endpoint = effectiveEmbedEndpoint(provider, url);\n  return endpoint === undefined ? undefined : createHash('sha256').update(endpoint).digest('hex');\n}\n"],"names":["effectiveEmbedEndpoint","embedEndpointIdentity","DEFAULT_COHERE_ENDPOINT","provider","url","undefined","endpoint","replace","createHash","update","digest"],"mappings":";;;;;;;;;;;QAIgBA;eAAAA;;QAMAC;eAAAA;;;0BAVW;AAE3B,IAAMC,0BAA0B;AAEzB,SAASF,uBAAuBG,QAAwC,EAAEC,GAAuB;IACtG,IAAID,aAAa,UAAU,OAAOE;IAClC,IAAMC,WAAWH,aAAa,WAAYC,gBAAAA,iBAAAA,MAAOF,0BAA2BE;IAC5E,OAAOE,qBAAAA,+BAAAA,SAAUC,OAAO,CAAC,QAAQ;AACnC;AAEO,SAASN,sBAAsBE,QAAwC,EAAEC,GAAuB;IACrG,IAAME,WAAWN,uBAAuBG,UAAUC;IAClD,OAAOE,aAAaD,YAAYA,YAAYG,IAAAA,sBAAU,EAAC,UAAUC,MAAM,CAACH,UAAUI,MAAM,CAAC;AAC3F"}

package/dist/cjs/embed/handoff.d.cts

@@ -1,3 +1,8 @@
-export declare function stashChunkText(key: object, texts: Map<string, string[]>): void;
+export interface ChunkText {
+    text: string;
+    identity: string;
+}
+export declare function identifyChunkText(text: string): ChunkText;
+export declare function stashChunkText(key: object, texts: Map<string, ChunkText[]>): void;
 export declare function rekeyChunkText(from: object, to: object): void;
-export declare function takeChunkText(key: object): Map<string, string[]> | undefined;
+export declare function takeChunkText(key: object): Map<string, ChunkText[]> | undefined;

package/dist/cjs/embed/handoff.d.ts

@@ -1,3 +1,8 @@
-export declare function stashChunkText(key: object, texts: Map<string, string[]>): void;
+export interface ChunkText {
+    text: string;
+    identity: string;
+}
+export declare function identifyChunkText(text: string): ChunkText;
+export declare function stashChunkText(key: object, texts: Map<string, ChunkText[]>): void;
 export declare function rekeyChunkText(from: object, to: object): void;
-export declare function takeChunkText(key: object): Map<string, string[]> | undefined;
+export declare function takeChunkText(key: object): Map<string, ChunkText[]> | undefined;

package/dist/cjs/embed/handoff.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get identifyChunkText () {
+        return identifyChunkText;
+    },
     get rekeyChunkText () {
         return rekeyChunkText;
     },
@@ -19,6 +22,13 @@ _export(exports, {
         return takeChunkText;
     }
 });
+var _nodecrypto = require("node:crypto");
+function identifyChunkText(text) {
+    return {
+        text: text,
+        identity: (0, _nodecrypto.createHash)('sha256').update(text).digest('hex')
+    };
+}
 // Chunk text from reconcile to embed time when both run in one process, so the text is neither
 // re-derived nor persisted. Keyed by the store it was stashed against, so an entry dies with it.
 var HANDOFF = new WeakMap();

package/dist/cjs/embed/handoff.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/handoff.ts"],"sourcesContent":["// Chunk text from reconcile to embed time when both run in one process, so the text is neither\n// re-derived nor persisted. Keyed by the store it was stashed against, so an entry dies with it.\nconst HANDOFF = new WeakMap<object, Map<string, string[]>>();\n\nexport function stashChunkText(key: object, texts: Map<string, string[]>): void {\n  if (texts.size > 0) HANDOFF.set(key, texts);\n}\n\n// Moves an entry from one key to another: reconcile runs before the store object exists, so it\n// stashes against the connection and open() re-keys onto the store it then builds.\nexport function rekeyChunkText(from: object, to: object): void {\n  const texts = HANDOFF.get(from);\n  if (!texts) return;\n  HANDOFF.delete(from);\n  HANDOFF.set(to, texts);\n}\n\n// Read once and drop: the text is consumed by the embed pass that follows reconcile, and holding\n// it past that would pin the tree's prose in memory for the life of the store.\nexport function takeChunkText(key: object): Map<string, string[]> | undefined {\n  const texts = HANDOFF.get(key);\n  HANDOFF.delete(key);\n  return texts;\n}\n"],"names":["rekeyChunkText","stashChunkText","takeChunkText","HANDOFF","WeakMap","key","texts","size","set","from","to","get","delete"],"mappings":";;;;;;;;;;;QAUgBA;eAAAA;;QANAC;eAAAA;;QAeAC;eAAAA;;;AAnBhB,+FAA+F;AAC/F,iGAAiG;AACjG,IAAMC,UAAU,IAAIC;AAEb,SAASH,eAAeI,GAAW,EAAEC,KAA4B;IACtE,IAAIA,MAAMC,IAAI,GAAG,GAAGJ,QAAQK,GAAG,CAACH,KAAKC;AACvC;AAIO,SAASN,eAAeS,IAAY,EAAEC,EAAU;IACrD,IAAMJ,QAAQH,QAAQQ,GAAG,CAACF;IAC1B,IAAI,CAACH,OAAO;IACZH,QAAQS,MAAM,CAACH;IACfN,QAAQK,GAAG,CAACE,IAAIJ;AAClB;AAIO,SAASJ,cAAcG,GAAW;IACvC,IAAMC,QAAQH,QAAQQ,GAAG,CAACN;IAC1BF,QAAQS,MAAM,CAACP;IACf,OAAOC;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/handoff.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\nexport interface ChunkText {\n  text: string;\n  identity: string;\n}\n\nexport function identifyChunkText(text: string): ChunkText {\n  return { text, identity: createHash('sha256').update(text).digest('hex') };\n}\n\n// Chunk text from reconcile to embed time when both run in one process, so the text is neither\n// re-derived nor persisted. Keyed by the store it was stashed against, so an entry dies with it.\nconst HANDOFF = new WeakMap<object, Map<string, ChunkText[]>>();\n\nexport function stashChunkText(key: object, texts: Map<string, ChunkText[]>): void {\n  if (texts.size > 0) HANDOFF.set(key, texts);\n}\n\n// Moves an entry from one key to another: reconcile runs before the store object exists, so it\n// stashes against the connection and open() re-keys onto the store it then builds.\nexport function rekeyChunkText(from: object, to: object): void {\n  const texts = HANDOFF.get(from);\n  if (!texts) return;\n  HANDOFF.delete(from);\n  HANDOFF.set(to, texts);\n}\n\n// Read once and drop: the text is consumed by the embed pass that follows reconcile, and holding\n// it past that would pin the tree's prose in memory for the life of the store.\nexport function takeChunkText(key: object): Map<string, ChunkText[]> | undefined {\n  const texts = HANDOFF.get(key);\n  HANDOFF.delete(key);\n  return texts;\n}\n"],"names":["identifyChunkText","rekeyChunkText","stashChunkText","takeChunkText","text","identity","createHash","update","digest","HANDOFF","WeakMap","key","texts","size","set","from","to","get","delete"],"mappings":";;;;;;;;;;;QAOgBA;eAAAA;;QAcAC;eAAAA;;QANAC;eAAAA;;QAeAC;eAAAA;;;0BA9BW;AAOpB,SAASH,kBAAkBI,IAAY;IAC5C,OAAO;QAAEA,MAAAA;QAAMC,UAAUC,IAAAA,sBAAU,EAAC,UAAUC,MAAM,CAACH,MAAMI,MAAM,CAAC;IAAO;AAC3E;AAEA,+FAA+F;AAC/F,iGAAiG;AACjG,IAAMC,UAAU,IAAIC;AAEb,SAASR,eAAeS,GAAW,EAAEC,KAA+B;IACzE,IAAIA,MAAMC,IAAI,GAAG,GAAGJ,QAAQK,GAAG,CAACH,KAAKC;AACvC;AAIO,SAASX,eAAec,IAAY,EAAEC,EAAU;IACrD,IAAMJ,QAAQH,QAAQQ,GAAG,CAACF;IAC1B,IAAI,CAACH,OAAO;IACZH,QAAQS,MAAM,CAACH;IACfN,QAAQK,GAAG,CAACE,IAAIJ;AAClB;AAIO,SAAST,cAAcQ,GAAW;IACvC,IAAMC,QAAQH,QAAQQ,GAAG,CAACN;IAC1BF,QAAQS,MAAM,CAACP;IACf,OAAOC;AACT"}

package/dist/cjs/embed/http.d.cts

@@ -1,2 +1,19 @@
-export declare function fetchWithRetry(url: string, init: RequestInit, baseDelayMs?: number): Promise<Response>;
+export declare const HTTP_ATTEMPT_TIMEOUT_MS = 30000;
+export declare const MODEL_FILE_ATTEMPT_TIMEOUT_MS: number;
+export type FetchRequestInit = Omit<RequestInit, 'signal'> & {
+    signal?: never;
+};
+export interface FetchRetryOptions {
+    signal?: AbortSignal;
+    attemptTimeoutMs?: number;
+    baseDelayMs?: number;
+}
+export interface BufferedResponse {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly headers: Headers;
+    readonly body: ArrayBuffer;
+    readonly url: string;
+}
+export declare function fetchWithRetry(url: string, init: FetchRequestInit, options?: FetchRetryOptions): Promise<BufferedResponse>;
 export declare function probeReachable(url: string, timeoutMs?: number): Promise<boolean>;

package/dist/cjs/embed/http.d.ts

@@ -1,2 +1,19 @@
-export declare function fetchWithRetry(url: string, init: RequestInit, baseDelayMs?: number): Promise<Response>;
+export declare const HTTP_ATTEMPT_TIMEOUT_MS = 30000;
+export declare const MODEL_FILE_ATTEMPT_TIMEOUT_MS: number;
+export type FetchRequestInit = Omit<RequestInit, 'signal'> & {
+    signal?: never;
+};
+export interface FetchRetryOptions {
+    signal?: AbortSignal;
+    attemptTimeoutMs?: number;
+    baseDelayMs?: number;
+}
+export interface BufferedResponse {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly headers: Headers;
+    readonly body: ArrayBuffer;
+    readonly url: string;
+}
+export declare function fetchWithRetry(url: string, init: FetchRequestInit, options?: FetchRetryOptions): Promise<BufferedResponse>;
 export declare function probeReachable(url: string, timeoutMs?: number): Promise<boolean>;