@flaxia/node 0.3.7 → 0.5.1

package/README.md

@@ -36,17 +36,27 @@ const controller = initFlaxiaNode({
 | `consent` | `ConsentConfig` | yes | 同意UIの設定 |
 | `consent.brandName` | `string` | yes | サイト名（内蔵UIに表示） |
 | `consent.position` | `'bottom-right' \| 'bottom-left' \| 'top-right' \| 'top-left'` | yes | 内蔵UIの表示位置 |
-| `consent.accentColor` | `string` | no | 内蔵UIのアクセントカラー |
+| `consent.accentColor` | `string` | no | 内蔵UIのアクセントカラー（許可リスト外は既定色） |
+| `consent.acceptLabel` / `consent.rejectLabel` | `string` | no | ボタン文言の上書き（テキストとして描画） |
+| `consent.privacyPolicyUrl` | `string` | no | プライバシーポリシーへのリンク（http/https のみ） |
+| `consent.minVisibleMs` | `number` | no | 同意ボタンが有効になるまでの最低表示時間。**延長のみ**（下限1500ms） |
 | `consent.onConsentRequired` | `(controls: ConsentControls) => void` | no | ホスト独自の同意UIを使う場合に指定。指定すると内蔵バナーは表示されない |
 | `maxCpuLoad` | `number` | no | CPU負荷制限（未実装） |
 
-### ホスト独自の同意UI
+### ホスト独自の同意UI（オプトインが必要）
 
 `consent.onConsentRequired` を渡すと、内蔵の Shadow DOM バナーは使われず、
-同意状態が `unset` のときだけホストが呼び出されます。ホストは `controls.accept()` /
-`controls.reject()` を呼ぶだけで、保存とノードの起動・停止はSDK側が行います。
+同意状態が `unset` のときだけホストが呼び出されます。
+
+ただし既定では **`accept()` を呼んでも同意は保存されません**。訪問者に実際の
+開示文を見せて操作させるのはホストの責任になるため、ホスト独自UIを使う場合は
+先に `setFlaxiaNodeHostManagedConsent(true)` で明示的にオプトインしてください。
 
 ```typescript
+import { initFlaxiaNode, setFlaxiaNodeHostManagedConsent } from '@flaxia/node'
+
+setFlaxiaNodeHostManagedConsent(true) // ホストが開示文を提示する責任を負う
+
 initFlaxiaNode({
   orchestratorUrl: 'https://crowd.flaxia.app',
   siteId: 'your-site-id',
@@ -54,7 +64,8 @@ initFlaxiaNode({
     brandName: 'あなたのサービス名',
     position: 'bottom-right',
     onConsentRequired: ({ state, accept, reject }) => {
-      // 自前のモーダルを表示し、ユーザーの選択に応じて accept() / reject()
+      // 現在の開示文（packages/node/docs/01-consent-ui.md）を提示し、
+      // ユーザーの選択に応じて accept() / reject()
       showMyConsentModal({
         onAccept: accept,
         onReject: reject,
@@ -64,6 +75,9 @@ initFlaxiaNode({
 })
 ```
 
+オプトインせずに `accept()` を呼んだ場合は `console.warn` が出て、状態は
+`unset` のまま（＝同意なし）になります。
+
 ### コントローラ（設定画面からの変更）
 
 `initFlaxiaNode()` は `FlaxiaNodeController` を返します。同一モジュール内で一度だけ
@@ -73,27 +87,36 @@ initFlaxiaNode({
 const controller = initFlaxiaNode({ /* ... */ })
 
 controller.getConsentState() // 'unset' | 'granted' | 'denied'
-controller.grant()           // 同意を保存（拒否を消去）
+controller.grant()           // 同意を保存（拒否を消去）※ホスト管理UIのオプトインが必要
 controller.deny()            // 拒否を保存して停止（同意を消去）
 controller.start()           // ノード起動
 controller.stop()            // ノード停止 + Web Worker 解放
 controller.isRunning()       // 稼働中か
-controller.clearConsent()    // 同意・拒否・失効時刻をすべて消去
+controller.clearConsent()    // 同意・拒否・HMAC鍵をすべて消去
 ```
 
-同意は localStorage に保存され、**30日**で失効します。`grant` と `deny` は排他で、
-片方を保存するともう片方は消去されます。
+同意は `localStorage` の `flaxia_consent_record` に保存され、**180日**で失効します
+（`grant` と `deny` は排他）。レコードは HMAC-SHA-256 で署名され、ページの
+オリジンと開示文バージョンに束縛されるため、`localStorage` に文字列を書いただけの
+偽造や、旧開示文に対する同意は「同意なし」として扱われます。
 
 ### 保存状態の読み取り（ノード初期化前）
 
 `getFlaxiaNodeConsentState()` はコントローラを作らず、ネットワークにも触れず、
-保存済みの同意状態だけを同期的に返します。設定画面をノード初期化前に描画する
-ホストはこれを使えます。
+保存済みの同意状態を同期的に返します。**fail closed** で、HMAC 検証が完了して
+いなければ `'granted'` は返しません。
+
+リロード後の自動再開を維持したいホストは、**`initFlaxiaNode()` を呼ぶ前に**
+`await initFlaxiaNodeConsent()` を実行してください。await せずに初期化すると、
+再訪した同意済みの訪問者にもバナーが表示され、ノードは自動起動しません
+（同意が無いものとして扱われるため）。
 
 ```typescript
-import { getFlaxiaNodeConsentState } from '@flaxia/node'
+import { getFlaxiaNodeConsentState, initFlaxiaNode, initFlaxiaNodeConsent } from '@flaxia/node'
 
-getFlaxiaNodeConsentState() // 'unset' | 'granted' | 'denied'
+await initFlaxiaNodeConsent()          // 冪等・例外を投げない
+if (getFlaxiaNodeConsentState() !== 'granted') showSettingsToggle()
+initFlaxiaNode({ /* ... */ })
 ```
 
 ## アーキテクチャ
@@ -105,7 +128,7 @@ getFlaxiaNodeConsentState() // 'unset' | 'granted' | 'denied'
 │  ┌──────────┐  ┌──────────────┐           │
 │  │ ConsentUI│  │ Signaling    │           │
 │  │ (Shadow  │  │ Client       │──WebSocket─┼──→ Worker
-│  │  DOM)    │  │ (WS + WebRTC)│           │
+│  │  DOM)    │  │ (WebSocket)  │           │
 │  └──────────┘  └──────┬───────┘           │
 │                       │                    │
 │                 ┌─────▼──────┐            │
@@ -133,11 +156,11 @@ getFlaxiaNodeConsentState() // 'unset' | 'granted' | 'denied'
 
 | レイヤー | ディレクトリ | 責務 |
 |---------|------------|------|
-| **同意** | `src/consent/` | Shadow DOM による同意バナー、localStorage への同意保存 |
-| **接続** | `src/client/` | WebSocket signaling、WebRTC ピア接続 |
+| **同意** | `src/consent/` | closed Shadow DOM の同意バナー、HMAC署名付き同意レコードの保存・検証 |
+| **接続** | `src/client/` | WebSocket signaling（登録・再接続・タスク授受） |
 | **実行** | `src/executor/` | WebWorker のライフサイクル管理、タイムアウト処理、WASM コンテナ実行 |
 | **Worker** | `src/worker/` | WebWorker エントリ、workload への動的ディスパッチ |
-| **Workload** | `src/workloads/` | AI推論・画像処理・コンテナ実行の実装 |
+| **Workload** | `src/workloads/` | AI推論・画像処理・NSFW判定・コンテナ実行の実装 |
 
 ## 対応ワークロード
 
@@ -146,11 +169,12 @@ getFlaxiaNodeConsentState() // 'unset' | 'granted' | 'denied'
 | `ai-inference` | `workloads/ai-inference.ts` | 🤗 Transformers.js (ONNX Runtime) |
 | `image-process` | `workloads/image-process.ts` | OffscreenCanvas API |
 | `container` | `workloads/container.ts` | container2wasm + WASI |
+| `nudenet` | `workloads/nudenet.ts` | NSFW（成人向け）画像判定 |
 
 ## フロー
 
-1. `initFlaxiaNode()` が呼ばれると、localStorage の同意状態を確認
-2. 未同意の場合、内蔵の Shadow DOM 同意バナー、または `onConsentRequired` でホストのUIを表示
+1. `initFlaxiaNode()` が呼ばれると、HMAC署名付きの同意レコードを確認
+2. 未同意の場合、内蔵の closed Shadow DOM 同意バナー、または `onConsentRequired` でホストのUIを表示
 3. 同意後、WebSocket でオーケストレーターに接続（`/crowd/signal`）
 4. タスクを受信すると WebWorker で実行
 5. 結果・中間トークンを WebSocket で返送

package/dist/__tests__/consent-policy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=consent-policy.test.d.ts.map

package/dist/__tests__/consent-policy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-policy.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/consent-policy.test.ts"],"names":[],"mappings":""}

package/dist/assets/VectorStoreEngine.js

@@ -1,47 +1,52 @@
 //#region src/vector-store/HNSWIndex.ts
-var e = class {
+var e = 1e5, t = 1024, n = class {
 	constructor(e, t = "cosine", n = 16, r = 200) {
 		this.dimensions = e, this.metric = t, this.M = n, this.efConstruction = r, this.nodes = /* @__PURE__ */ new Map(), this.docIdMap = /* @__PURE__ */ new Map(), this.enterPoint = null, this.nextNodeId = 0, this.maxLevel = 0;
 	}
-	insert(e, t) {
-		let n = this.nextNodeId++, r = this.randomLevel(), i = {
-			id: n,
-			docId: e,
-			vector: t,
-			level: r,
+	get dimensionsValue() {
+		return this.dimensions;
+	}
+	insert(t, n) {
+		if (this.nodes.size >= 1e5) throw Error(`HNSW index is full (${e} nodes); refusing to insert more`);
+		if (!(n instanceof Float32Array) || n.length !== this.dimensions) throw Error(`HNSW insert: vector must be a Float32Array of ${this.dimensions} dimensions, got ${n?.length ?? "none"}`);
+		let r = this.nextNodeId++, i = this.randomLevel(), a = {
+			id: r,
+			docId: t,
+			vector: n,
+			level: i,
 			neighbors: /* @__PURE__ */ new Map()
 		};
-		if (this.nodes.set(n, i), this.docIdMap.set(e, n), this.enterPoint === null) {
-			this.enterPoint = n, this.maxLevel = r;
+		if (this.nodes.set(r, a), this.docIdMap.set(t, r), this.enterPoint === null) {
+			this.enterPoint = r, this.maxLevel = i;
 			return;
 		}
-		let a = this.nodes.get(this.enterPoint), o = this.distance(t, a.vector);
-		for (let e = this.maxLevel; e > r; e--) {
-			let n = !0;
-			for (; n;) {
-				n = !1;
-				let r = a.neighbors.get(e) || [];
+		let o = this.nodes.get(this.enterPoint), s = this.distance(n, o.vector);
+		for (let e = this.maxLevel; e > i; e--) {
+			let t = !0;
+			for (; t;) {
+				t = !1;
+				let r = o.neighbors.get(e) || [];
 				for (let e of r) {
 					let r = this.nodes.get(e);
 					if (!r) continue;
-					let i = this.distance(t, r.vector);
-					i < o && (o = i, a = r, n = !0);
+					let i = this.distance(n, r.vector);
+					i < s && (s = i, o = r, t = !0);
 				}
 			}
 		}
-		for (let e = Math.min(r, this.maxLevel); e >= 0; e--) {
-			let r = this.searchLayer(t, a, e, this.efConstruction), i = this.selectNeighbors(r, this.M), o = a.neighbors.get(e) || [];
-			for (let e of i) o.includes(e.nodeId) || o.push(e.nodeId);
-			a.neighbors.set(e, o);
+		for (let e = Math.min(i, this.maxLevel); e >= 0; e--) {
+			let t = this.searchLayer(n, o, e, this.efConstruction), i = this.selectNeighbors(t, this.M), a = o.neighbors.get(e) || [];
+			for (let e of i) a.includes(e.nodeId) || a.push(e.nodeId);
+			o.neighbors.set(e, a);
 			for (let t of i) {
-				let r = this.nodes.get(t.nodeId);
-				if (r) {
-					let t = r.neighbors.get(e) || [];
-					t.includes(n) || t.push(n), r.neighbors.set(e, t.slice(-this.M));
+				let n = this.nodes.get(t.nodeId);
+				if (n) {
+					let t = n.neighbors.get(e) || [];
+					t.includes(r) || t.push(r), n.neighbors.set(e, t.slice(-this.M));
 				}
 			}
 		}
-		r > this.maxLevel && (this.enterPoint = n, this.maxLevel = r);
+		i > this.maxLevel && (this.enterPoint = r, this.maxLevel = i);
 	}
 	search(e, t) {
 		if (this.nodes.size === 0 || this.enterPoint === null) return [];
@@ -102,6 +107,7 @@ var e = class {
 		return e.sort((e, t) => e.distance - t.distance).slice(0, t);
 	}
 	distance(e, t) {
+		if (e.length !== t.length) throw Error(`HNSW distance: dimension mismatch (${e.length} vs ${t.length})`);
 		if (this.metric === "cosine") {
 			let n = 0, r = 0, i = 0;
 			for (let a = 0; a < e.length; a++) n += e[a] * t[a], r += e[a] * e[a], i += t[a] * t[a];
@@ -134,70 +140,112 @@ var e = class {
 		}
 		return e;
 	}
-	importNodes(e, t) {
-		for (let n of e) {
-			let e = /* @__PURE__ */ new Map();
-			for (let [t, r] of Object.entries(n.neighbors)) e.set(Number(t), r);
-			let r = {
-				id: n.id,
-				docId: n.docId,
-				vector: t.get(n.id) || new Float32Array(this.dimensions),
-				level: n.level,
-				neighbors: e
+	importNodes(n, r) {
+		if (!Array.isArray(n)) throw Error("HNSW import: nodes must be an array");
+		if (n.length > 1e5) throw Error(`HNSW import: ${n.length} nodes exceed the ${e} quota`);
+		let i = /* @__PURE__ */ new Set();
+		for (let e of n) {
+			if (!e || typeof e != "object") throw Error("HNSW import: node entry must be an object");
+			if (!Number.isInteger(e.id) || e.id < 0) throw Error(`HNSW import: node id must be a non-negative integer, got ${JSON.stringify(e.id)}`);
+			if (i.has(e.id)) throw Error(`HNSW import: duplicate node id ${e.id}`);
+			if (i.add(e.id), typeof e.docId != "string" || !e.docId) throw Error(`HNSW import: node ${e.id} has an invalid docId`);
+			if (!Number.isInteger(e.level) || e.level < 0 || e.level > 16) throw Error(`HNSW import: node ${e.id} level ${JSON.stringify(e.level)} is outside 0..16`);
+			let t = r.get(e.id);
+			if (!t) throw Error(`HNSW import: node ${e.id} has no vector`);
+			if (!(t instanceof Float32Array) || t.length !== this.dimensions) throw Error(`HNSW import: node ${e.id} vector must be a Float32Array of ${this.dimensions} dimensions`);
+			for (let n = 0; n < t.length; n++) if (!Number.isFinite(t[n])) throw Error(`HNSW import: node ${e.id} vector contains a non-finite value at ${n}`);
+		}
+		for (let e of n) {
+			let n = e.neighbors;
+			if (!n || typeof n != "object") throw Error(`HNSW import: node ${e.id} has invalid neighbors`);
+			for (let [r, a] of Object.entries(n)) {
+				let n = Number(r);
+				if (!Number.isInteger(n) || n < 0 || n > e.level) throw Error(`HNSW import: node ${e.id} has adjacency for level ${r} above its level ${e.level}`);
+				if (!Array.isArray(a)) throw Error(`HNSW import: node ${e.id} level ${r} adjacency must be an array`);
+				if (a.length > 1024) throw Error(`HNSW import: node ${e.id} level ${r} has ${a.length} neighbors, above the ${t} limit`);
+				for (let t of a) if (!Number.isInteger(t) || !i.has(t)) throw Error(`HNSW import: node ${e.id} references unknown neighbor ${JSON.stringify(t)}`);
+			}
+		}
+		for (let e of n) {
+			let t = /* @__PURE__ */ new Map();
+			for (let [n, r] of Object.entries(e.neighbors)) t.set(Number(n), [...r]);
+			let n = {
+				id: e.id,
+				docId: e.docId,
+				vector: r.get(e.id),
+				level: e.level,
+				neighbors: t
 			};
-			this.nodes.set(n.id, r), this.docIdMap.set(n.docId, n.id), n.id >= this.nextNodeId && (this.nextNodeId = n.id + 1), n.level > this.maxLevel && (this.maxLevel = n.level);
+			this.nodes.set(e.id, n), this.docIdMap.set(e.docId, e.id), e.id >= this.nextNodeId && (this.nextNodeId = e.id + 1), e.level > this.maxLevel && (this.maxLevel = e.level);
 		}
 		this.nodes.size > 0 && this.enterPoint === null && (this.enterPoint = this.nodes.keys().next().value);
 	}
-};
-//#endregion
-//#region src/vector-store/VectorStoreEngine.ts
-function t(e, t, n) {
+}, r = 4096, i = 1048576, a = e, o = 1e3;
+function s(e, t, n = r, a = i) {
+	if (!Array.isArray(e)) throw Error(`vector-store: ${t} must be an array of numbers`);
+	let o = e.length;
+	if (!Number.isInteger(o) || o <= 0) throw Error(`vector-store: ${t} length must be a positive integer, got ${String(o)}`);
+	if (o > n) throw Error(`vector-store: ${t} has ${o} dimensions, above the ${n} limit`);
+	if (o > a) throw Error(`vector-store: ${t} has ${o} elements, above the ${a} limit`);
+	for (let n = 0; n < o; n++) {
+		let r = e[n];
+		if (typeof r != "number" || !Number.isFinite(r)) throw Error(`vector-store: ${t}[${n}] must be a finite number`);
+	}
+	return o;
+}
+function c(e, t, n) {
+	if (typeof e != "string" && typeof e != "number") throw Error(`vector-store: shardKey must be a string or number, got ${typeof e}`);
+	let r = typeof e == "number" ? e : Number(e);
+	if (!Number.isInteger(r)) throw Error(`vector-store: shardKey must be an integer, got ${JSON.stringify(e)}`);
+	if (r < t || r > n) throw Error(`Shard key ${r} out of range`);
+	return r;
+}
+function l(e, t, n) {
 	return new Promise((r, i) => {
 		let a = indexedDB.open(e, t);
 		a.onupgradeneeded = () => n(a.result), a.onsuccess = () => r(a.result), a.onerror = () => i(a.error);
 	});
 }
-function n(e, t, n = "readonly") {
+function u(e, t, n = "readonly") {
 	return e.transaction(t, n).objectStore(t);
 }
-function r(e, t, r) {
-	return new Promise((i, a) => {
-		let o = n(e, t).get(r);
-		o.onsuccess = () => i(o.result), o.onerror = () => a(o.error);
+function d(e, t, n) {
+	return new Promise((r, i) => {
+		let a = u(e, t).get(n);
+		a.onsuccess = () => r(a.result), a.onerror = () => i(a.error);
 	});
 }
-function i(e, t, r) {
-	return new Promise((i, a) => {
-		let o = n(e, t, "readwrite").put(r);
-		o.onsuccess = () => i(), o.onerror = () => a(o.error);
+function f(e, t, n) {
+	return new Promise((r, i) => {
+		let a = u(e, t, "readwrite").put(n);
+		a.onsuccess = () => r(), a.onerror = () => i(a.error);
 	});
 }
-function a(e, t) {
-	return new Promise((r, i) => {
-		let a = n(e, t).getAll();
-		a.onsuccess = () => r(a.result), a.onerror = () => i(a.error);
+function p(e, t) {
+	return new Promise((n, r) => {
+		let i = u(e, t).getAll();
+		i.onsuccess = () => n(i.result), i.onerror = () => r(i.error);
 	});
 }
-var o = class {
+var m = class {
 	constructor() {
 		this.db = null, this.hnsw = null, this.shardInfo = null, this.saveCounter = 0;
 	}
 	async initialize() {
-		this.db = await t("flaxia-vector-store", 1, (e) => {
+		this.db = await l("flaxia-vector-store", 1, (e) => {
 			e.objectStoreNames.contains("vectors") || e.createObjectStore("vectors", { keyPath: "docId" }), e.objectStoreNames.contains("hnsw-graph") || e.createObjectStore("hnsw-graph", { keyPath: "nodeId" }), e.objectStoreNames.contains("shard-info") || e.createObjectStore("shard-info", { keyPath: "key" });
-		}), this.hnsw = new e(1024, "cosine", 16, 200), await this.loadGraphFromDB();
-		let n = await r(this.db, "shard-info", "shard_range");
-		n && (this.shardInfo = {
-			rangeStart: n.rangeStart,
-			rangeEnd: n.rangeEnd
+		}), this.hnsw = new n(1024, "cosine", 16, 200), await this.loadGraphFromDB();
+		let e = await d(this.db, "shard-info", "shard_range");
+		e && (this.shardInfo = {
+			rangeStart: e.rangeStart,
+			rangeEnd: e.rangeEnd
 		});
 	}
 	async assignShard(e, t) {
 		this.shardInfo = {
 			rangeStart: e,
 			rangeEnd: t
-		}, await i(this.db, "shard-info", {
+		}, await f(this.db, "shard-info", {
 			key: "shard_range",
 			rangeStart: e,
 			rangeEnd: t,
@@ -207,15 +255,17 @@ var o = class {
 	}
 	async store(e) {
 		if (!this.shardInfo) throw Error("No shard assigned");
-		let t = parseInt(e.shardKey, 10);
-		if (t < this.shardInfo.rangeStart || t > this.shardInfo.rangeEnd) throw Error(`Shard key ${t} out of range`);
-		return await i(this.db, "vectors", {
+		let t = c(e.shardKey, this.shardInfo.rangeStart, this.shardInfo.rangeEnd), n = s(e.vector, "vector");
+		if (this.hnsw && n !== this.hnsw.dimensionsValue) throw Error(`vector-store: vector has ${n} dimensions but this index stores ${this.hnsw.dimensionsValue}`);
+		if (this.hnsw && this.hnsw.size() >= a) throw Error(`vector-store: node storage quota reached (${a} vectors); refusing to store more`);
+		let r = new Float32Array(e.vector);
+		return await f(this.db, "vectors", {
 			docId: e.docId,
-			vector: new Float32Array(e.vector),
+			vector: r,
 			metadata: e.metadata,
-			shardKey: e.shardKey,
+			shardKey: String(t),
 			storedAt: Date.now()
-		}), this.hnsw.insert(e.docId, new Float32Array(e.vector)), this.saveCounter++, this.saveCounter % 100 == 0 && await this.saveGraphSnapshot(), {
+		}), this.hnsw.insert(e.docId, r), this.saveCounter++, this.saveCounter % 100 == 0 && await this.saveGraphSnapshot(), {
 			stored: !0,
 			nodeId: "",
 			totalVectors: this.hnsw.size()
@@ -223,9 +273,13 @@ var o = class {
 	}
 	async query(e) {
 		if (!this.hnsw) throw Error("HNSW not initialized");
-		let t = performance.now(), n = new Float32Array(e.queryVector);
+		let t = s(e.queryVector, "queryVector");
+		if (t !== this.hnsw.dimensionsValue) throw Error(`vector-store: queryVector has ${t} dimensions but this index stores ${this.hnsw.dimensionsValue}`);
+		let n = e.topK;
+		if (!Number.isInteger(n) || n <= 0 || n > 1e3) throw Error(`vector-store: topK must be an integer within 1..${o}, got ${JSON.stringify(n)}`);
+		let r = performance.now(), i = new Float32Array(e.queryVector);
 		return {
-			results: this.hnsw.search(n, e.topK).map((e) => ({
+			results: this.hnsw.search(i, n).map((e) => ({
 				docId: e.docId,
 				score: 1 - e.distance,
 				metadata: e.metadata || {
@@ -235,39 +289,40 @@ var o = class {
 				}
 			})),
 			nodeId: "",
-			searchDurationMs: Math.round(performance.now() - t)
+			searchDurationMs: Math.round(performance.now() - r)
 		};
 	}
 	async getVector(e) {
-		return r(this.db, "vectors", e);
+		return d(this.db, "vectors", e);
 	}
 	async deleteVector(e) {
-		return new Promise((t, r) => {
-			let i = n(this.db, "vectors", "readwrite").delete(e);
-			i.onsuccess = () => t(), i.onerror = () => r(i.error);
+		return new Promise((t, n) => {
+			let r = u(this.db, "vectors", "readwrite").delete(e);
+			r.onsuccess = () => t(), r.onerror = () => n(r.error);
 		});
 	}
 	getVectorCount() {
 		return this.hnsw?.size() || 0;
 	}
 	async loadGraphFromDB() {
-		let e = await a(this.db, "hnsw-graph");
+		let e = await p(this.db, "hnsw-graph");
 		if (e.length === 0) return;
+		if (e.length > a) throw Error(`vector-store: persisted graph holds ${e.length} nodes, above the ${a} quota`);
 		let t = /* @__PURE__ */ new Map(), n = [];
-		for (let i of e) {
-			let e = await r(this.db, "vectors", i.docId);
-			e && t.set(i.nodeId, e.vector), n.push({
-				id: i.nodeId,
-				docId: i.docId,
-				level: i.level,
-				neighbors: i.neighbors
+		for (let r of e) {
+			let e = await d(this.db, "vectors", r.docId);
+			e && e.vector && t.set(r.nodeId, e.vector instanceof Float32Array ? e.vector : new Float32Array(e.vector)), n.push({
+				id: r.nodeId,
+				docId: r.docId,
+				level: r.level,
+				neighbors: r.neighbors
 			});
 		}
 		this.hnsw.importNodes(n, t);
 	}
 	async saveGraphSnapshot() {
 		let e = this.hnsw.exportNodes();
-		for (let [t, n] of e) await i(this.db, "hnsw-graph", {
+		for (let [t, n] of e) await f(this.db, "hnsw-graph", {
 			nodeId: t,
 			docId: n.docId,
 			level: n.level,
@@ -276,4 +331,4 @@ var o = class {
 	}
 };
 //#endregion
-export { o as t };
+export { m as t };