dsh-mnemon-source-memory-spaces 0.5.20 → 0.5.22

package/lib/space-identity.js

@@ -0,0 +1,365 @@
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/mnemon-store-identity.ts
+/**
+* What a Mnemon store holds, as opposed to how it was used, and the merge of two versions of one.
+* The public `./space-identity` entry exposes it; its limits and test hooks stay here.
+*
+* Mnemon writes to a space whenever it is read: a recall, search or show raises
+* `access_count`, stamps `last_accessed_at` and logs the read in `oplog`. Two machines
+* that only read the same space therefore never hold the same `mnemon.db` bytes, and a
+* merge that compares bytes kept the other machine's space as a new one on every sync,
+* doubling the spaces each round (#370). Spaces are compared by their content instead:
+* every table, column and row, the edges included, except the usage columns, the read log
+* and the derived embedding and effective importance. An edge is the two memories it links
+* and its type, its table's key: a merge of spaces or a new link writes its weight, note and
+* time again, so the same edge with other values is still the same edge (#391). A memory's
+* update time is left out too: filling in its vector or keeping it from pruning moves it, while
+* an edit or a forget changes what is compared.
+*
+* Rows are compared by their columns in name order, so the order a table declares them in
+* does not matter. One version contains another when it holds every row of it. Two versions
+* of one space merge by adding to this machine's database the rows only the other holds:
+* this machine's rows, read counts, read log and schema stay as they are, and the result holds
+* the memories of both; an edge both hold keeps this machine's values. A row both sides hold
+* differently, a memory edited or forgotten on one of them, refuses the merge, and the caller
+* keeps a copy instead.
+*
+* It needs `node:sqlite` (Node 22.13, 23.4 and later). Without it, for bytes that are not a
+* readable database, for a database with a virtual table, or past the row limits, the identity
+* is the bytes' digest, and such a store contains and merges with no other, so a caller keeps
+* both versions rather than losing a memory.
+*/
+/** Written by reading a space: the read log. */
+const USAGE_TABLES = /* @__PURE__ */ new Set(["oplog"]);
+/** Written by reading a space, or derived from what it holds. */
+const USAGE_COLUMNS = /* @__PURE__ */ new Set([
+	"access_count",
+	"last_accessed_at",
+	"effective_importance",
+	"embedding"
+]);
+/**
+* Values a row carries beside what it holds, which Mnemon writes again without changing that
+* (#391): an edge is its key, and an import or a new link writes its weight, note and time
+* again; a memory's update time moves when its vector is filled in or it is kept from pruning.
+*/
+const ROW_VALUES = /* @__PURE__ */ new Map([["edges", /* @__PURE__ */ new Set([
+	"weight",
+	"metadata",
+	"created_at"
+])], ["insights", /* @__PURE__ */ new Set(["updated_at"])]]);
+const SCRATCH_PREFIX = ".dsh-space-identity-";
+/**
+* Past this many rows a store is compared by its bytes, and past the second limit, counted over
+* all of one identity's reads, so is every store it reads after that. Its caller may hold a lock
+* while it compares, so a crafted database must not take long: 120,000 real rows read in about
+* 0.4 s.
+*/
+const IDENTITY_MAX_ROWS = 5e5;
+const MERGE_MAX_ROWS = 2e6;
+function sqlite() {
+	try {
+		return process.getBuiltinModule?.("node:sqlite");
+	} catch {
+		return;
+	}
+}
+function quote(name) {
+	return "\"" + name.replaceAll("\"", "\"\"") + "\"";
+}
+/** A cell as JSON that keeps SQLite's types apart: 1, 1.0, '1', x'01' and NULL all differ. */
+function cell(value) {
+	if (value instanceof Uint8Array) return { blob: Buffer.from(value).toString("base64") };
+	if (typeof value === "bigint") return { integer: String(value) };
+	if (typeof value === "number") return { real: Object.is(value, -0) ? "-0" : String(value) };
+	return value;
+}
+/** 128 bits of a row's digest: enough to tell rows apart, half the memory of the whole digest. */
+function rowDigest(columns, row) {
+	return createHash("sha256").update(JSON.stringify(columns.map((column) => cell(row[column])))).digest("base64").slice(0, 22);
+}
+function digest(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+function sameBytes(left, right) {
+	return left === right || Buffer.from(left.buffer, left.byteOffset, left.byteLength).equals(right);
+}
+/** Cleanup never fails a merge: a copy another process holds open is swept by the next one. */
+function remove(path) {
+	try {
+		rmSync(path, {
+			recursive: true,
+			force: true,
+			maxRetries: 3
+		});
+	} catch {}
+}
+/**
+* Reads what each database holds once, and merges two of them. Make one per comparison or merge
+* and dispose of it at the end. A process that stopped midway leaves its copies behind; the next
+* identity on the same parent sweeps them before it makes its own.
+*/
+var MnemonStoreIdentity = class {
+	parent;
+	scratch;
+	known = /* @__PURE__ */ new WeakMap();
+	projections = /* @__PURE__ */ new WeakMap();
+	module;
+	maxRows;
+	remaining;
+	/** `parent` holds the short-lived copies a database is read from. */
+	constructor(parent, options = {}) {
+		this.parent = parent;
+		this.module = options.sqlite ?? sqlite;
+		this.maxRows = options.maxRows ?? IDENTITY_MAX_ROWS;
+		this.remaining = options.maxMergeRows ?? MERGE_MAX_ROWS;
+	}
+	of(bytes) {
+		return this.contents(bytes)?.identity ?? "bytes:" + digest(bytes);
+	}
+	/** Whether `outer` holds every row `inner` holds; `outer` may have columns `inner` lacks. */
+	contains(outer, inner) {
+		if (sameBytes(outer, inner)) return true;
+		const whole = this.contents(outer);
+		const part = this.contents(inner);
+		if (whole === void 0 || part === void 0) return false;
+		for (const [name, table] of part.tables) {
+			const present = this.rowsOn(outer, whole, name, table.columns);
+			if (present === void 0) return false;
+			for (const row of table.rows) if (!present.has(row)) return false;
+		}
+		return true;
+	}
+	/**
+	* `local` with the rows only `incoming` holds added to it, or undefined when the two cannot
+	* merge: a row both hold differently, a table or column `local` lacks, or a database that
+	* cannot be read. `local` itself comes back when it already holds everything.
+	*/
+	merge(local, incoming) {
+		if (sameBytes(local, incoming)) return local;
+		const mine = this.contents(local);
+		const theirs = this.contents(incoming);
+		if (mine === void 0 || theirs === void 0) return void 0;
+		const missing = /* @__PURE__ */ new Map();
+		for (const [name, table] of theirs.tables) {
+			const present = this.rowsOn(local, mine, name, table.columns);
+			if (present === void 0) return void 0;
+			const rows = new Set([...table.rows].filter((row) => !present.has(row)));
+			if (rows.size > 0) missing.set(name, rows);
+		}
+		if (missing.size === 0) return local;
+		const module = this.module();
+		const directory = this.directory();
+		if (module === void 0 || directory === void 0) return void 0;
+		const target = join(directory, randomUUID() + ".db");
+		const source = join(directory, randomUUID() + ".db");
+		let writer;
+		let reader;
+		try {
+			writeFileSync(target, local, { mode: 384 });
+			writeFileSync(source, incoming, { mode: 384 });
+			writer = this.open(module, target, false);
+			reader = this.open(module, source, true);
+			if (writer === void 0 || reader === void 0) return void 0;
+			writer.exec("BEGIN IMMEDIATE");
+			writer.exec("PRAGMA defer_foreign_keys = ON");
+			for (const [name, rows] of missing) {
+				const table = theirs.tables.get(name);
+				const own = mine.tables.get(name);
+				const written = table.all.filter((column) => own.all.includes(column));
+				const insert = writer.prepare(`INSERT INTO ${quote(name)} (${written.map(quote).join(", ")}) VALUES (${written.map(() => "?").join(", ")})`);
+				const statement = reader.prepare(`SELECT ${written.map(quote).join(", ")} FROM ${quote(name)}`);
+				statement.setReadBigInts(true);
+				for (const row of statement.iterate()) {
+					if (!this.spend()) throw new Error("the merge read limit was reached");
+					if (!rows.has(rowDigest(table.columns, row))) continue;
+					insert.run(...written.map((column) => row[column]));
+				}
+			}
+			writer.exec("COMMIT");
+			writer.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+			writer.close();
+			writer = void 0;
+			return readFileSync(target);
+		} catch {
+			return;
+		} finally {
+			for (const database of [writer, reader]) try {
+				database?.close();
+			} catch {}
+			for (const path of [target, source]) for (const suffix of [
+				"",
+				"-wal",
+				"-shm",
+				"-journal"
+			]) remove(path + suffix);
+		}
+	}
+	dispose() {
+		if (this.scratch !== void 0) remove(this.scratch);
+		this.scratch = void 0;
+	}
+	spend() {
+		this.remaining -= 1;
+		return this.remaining >= 0;
+	}
+	contents(bytes) {
+		const known = this.known.get(bytes);
+		if (known !== void 0) return known ?? void 0;
+		const contents = this.read(bytes);
+		this.known.set(bytes, contents ?? null);
+		return contents;
+	}
+	/** The digests of a table's rows over `columns`, which may leave out columns the table has. */
+	rowsOn(bytes, contents, name, columns) {
+		const table = contents.tables.get(name);
+		if (table === void 0 || !columns.every((column) => table.columns.includes(column))) return void 0;
+		if (columns.length === table.columns.length) return table.rows;
+		const key = JSON.stringify([name, columns]);
+		const cached = this.projections.get(bytes) ?? /* @__PURE__ */ new Map();
+		this.projections.set(bytes, cached);
+		if (!cached.has(key)) cached.set(key, this.withCopy(bytes, true, (database) => this.digests(database, name, columns) ?? null) ?? null);
+		return cached.get(key) ?? void 0;
+	}
+	digests(database, name, columns) {
+		const rows = /* @__PURE__ */ new Set();
+		if (columns.length === 0) return rows;
+		const statement = database.prepare(`SELECT ${columns.map(quote).join(", ")} FROM ${quote(name)}`);
+		statement.setReadBigInts(true);
+		let budget = this.maxRows;
+		for (const row of statement.iterate()) {
+			budget -= 1;
+			if (budget < 0 || !this.spend()) return void 0;
+			rows.add(rowDigest(columns, row));
+		}
+		return rows;
+	}
+	directory() {
+		try {
+			if (this.scratch === void 0) {
+				for (const name of readdirSync(this.parent)) if (name.startsWith(SCRATCH_PREFIX)) remove(join(this.parent, name));
+			}
+			if (this.scratch === void 0 || !existsSync(this.scratch)) this.scratch = mkdtempSync(join(this.parent, SCRATCH_PREFIX));
+		} catch {
+			return;
+		}
+		return this.scratch;
+	}
+	/** A connection to a private copy, refused when the copy is missing or empty rather than created. */
+	open(module, path, readOnly) {
+		if (!existsSync(path)) return void 0;
+		const database = new module.DatabaseSync(path, { readOnly });
+		database.exec("PRAGMA trusted_schema = OFF");
+		const pages = database.prepare("PRAGMA page_count").get();
+		if (Number(pages?.page_count ?? 0) <= 0) {
+			database.close();
+			return;
+		}
+		return database;
+	}
+	withCopy(bytes, readOnly, use) {
+		const module = this.module();
+		if (module === void 0) return void 0;
+		const directory = this.directory();
+		if (directory === void 0) return void 0;
+		const path = join(directory, randomUUID() + ".db");
+		let database;
+		try {
+			writeFileSync(path, bytes, { mode: 384 });
+			database = this.open(module, path, readOnly);
+			return database === void 0 ? void 0 : use(database);
+		} catch {
+			return;
+		} finally {
+			try {
+				database?.close();
+			} catch {}
+			for (const suffix of [
+				"",
+				"-wal",
+				"-shm",
+				"-journal"
+			]) remove(path + suffix);
+		}
+	}
+	read(bytes) {
+		return this.withCopy(bytes, true, (database) => {
+			const listed = database.prepare("SELECT name, type FROM pragma_table_list WHERE schema = 'main'").all();
+			if (listed.some((entry) => entry.type !== "table" && entry.type !== "view")) return void 0;
+			const names = listed.filter((entry) => entry.type === "table" && !entry.name.startsWith("sqlite_") && !USAGE_TABLES.has(entry.name)).map((entry) => entry.name).sort();
+			const hash = createHash("sha256");
+			const tables = /* @__PURE__ */ new Map();
+			let budget = this.maxRows;
+			for (const name of names) {
+				const all = database.prepare(`PRAGMA table_info(${quote(name)})`).all().map((column) => column.name);
+				const columns = all.filter((column) => !USAGE_COLUMNS.has(column) && ROW_VALUES.get(name)?.has(column) !== true).sort();
+				const rows = [];
+				if (columns.length > 0) {
+					const statement = database.prepare(`SELECT ${columns.map(quote).join(", ")} FROM ${quote(name)}`);
+					statement.setReadBigInts(true);
+					for (const row of statement.iterate()) {
+						budget -= 1;
+						if (budget < 0 || !this.spend()) return void 0;
+						rows.push(rowDigest(columns, row));
+					}
+				}
+				rows.sort();
+				hash.update(JSON.stringify([
+					"table",
+					name,
+					columns,
+					rows.length
+				]));
+				for (const row of rows) hash.update(row);
+				tables.set(name, {
+					columns,
+					all,
+					rows: new Set(rows)
+				});
+			}
+			return {
+				identity: "content:" + hash.digest("hex"),
+				tables
+			};
+		});
+	}
+};
+//#endregion
+//#region src/space-identity.ts
+/**
+* Whether two copies of a Mnemon Native space hold the same memories, and the merge of two
+* versions of one (#370, #391). Reading a space changes its bytes, so copies are compared by what
+* they hold; mnemon-store-identity.ts says exactly what that is. Node-only: it reads stores with
+* `node:sqlite` where Node has it and compares bytes where it does not.
+*/
+var MemorySpaceIdentity = class {
+	#identity;
+	/** `parent` holds the short-lived copies a store is read from; dispose of the identity when done. */
+	constructor(parent) {
+		this.#identity = new MnemonStoreIdentity(parent);
+	}
+	/** The store's content identity, or the digest of its bytes when its content cannot be read. */
+	of(bytes) {
+		return this.#identity.of(bytes);
+	}
+	/** Whether `outer` holds every row `inner` holds; `outer` may have columns `inner` lacks. */
+	contains(outer, inner) {
+		return this.#identity.contains(outer, inner);
+	}
+	/**
+	* `local` with the rows only `incoming` holds added to it, or undefined when the two cannot
+	* merge: a row both hold differently, a table or column `local` lacks, or a store that cannot
+	* be read. `local` itself comes back when it already holds everything.
+	*/
+	merge(local, incoming) {
+		return this.#identity.merge(local, incoming);
+	}
+	/** Remove the short-lived copies the identity made. */
+	dispose() {
+		this.#identity.dispose();
+	}
+};
+//#endregion
+export { MemorySpaceIdentity };

package/lib/testing.js

@@ -1,4 +1,4 @@
-import { a as MemoryProviderCatalog, n as PrivateMemorySpaceProviderHost, t as createMemorySpaceProviderPlugin } from "./plugin-DlsNeZbQ.js";
+import { a as MemoryProviderCatalog, n as PrivateMemorySpaceProviderHost, t as createMemorySpaceProviderPlugin } from "./plugin-m1PeU1IE.js";
 import { n as deepFreeze } from "./definitions-DfmOqJjR.js";
 import { Context } from "@deepseek-ai/cordis";
 //#region src/testing.ts

package/lib/types/client/entities-page.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from 'react';
+import { type Insight } from '../contracts.ts';
+import type { MemorySpacesPageClient } from './api.ts';
+export declare function EntitiesPage(props: {
+    client: MemorySpacesPageClient;
+    revision: number;
+    writeEnabled: boolean;
+    onForget: (insight: Insight) => Promise<void>;
+    onExplore: (query: string) => void;
+}): JSX.Element;

package/lib/types/client/explore-page.d.ts

@@ -0,0 +1,16 @@
+import type { JSX } from 'react';
+import { type Insight } from '../contracts.ts';
+import type { MemorySpacesPageClient } from './api.ts';
+export interface MemorySpacesPageStatus {
+    defaultRecallLimit?: number;
+}
+export declare function ExplorePage(props: {
+    client: MemorySpacesPageClient;
+    agentClient: MemorySpacesPageClient;
+    agentAvailable: boolean;
+    status: MemorySpacesPageStatus | null;
+    seed: string;
+    writeEnabled: boolean;
+    onForget: (insight: Insight) => Promise<void>;
+    onRevealElement?(element: HTMLElement): void;
+}): JSX.Element;

package/lib/types/client/list-page.d.ts

@@ -0,0 +1,11 @@
+import type { JSX } from 'react';
+import { type Insight } from '../contracts.ts';
+import type { MemorySpacesPageClient } from './api.ts';
+export declare function ListPage(props: {
+    client: MemorySpacesPageClient;
+    revision: number;
+    writeEnabled: boolean;
+    onForget: (insight: Insight) => Promise<void>;
+    onClone: (insight: Insight) => void;
+    onExplore: (query: string) => void;
+}): JSX.Element;

package/lib/types/client/memory-graph.d.ts

@@ -0,0 +1,13 @@
+import type { JSX } from 'react';
+import { type MemorySpaceView, type MemoryGraphNode, type MemoryGraphSnapshot } from '../contracts.ts';
+import { type MnemonTranslate } from 'dsh-mnemon/client';
+export declare function graphNodeKey(node: MemoryGraphNode): string;
+export declare function graphNodeKind(node: MemoryGraphNode): NonNullable<MemoryGraphNode['kind']>;
+/** Add routing scopes and entity indexes without issuing another recall. */
+export declare function enrichMultiSpaceGraph(graph: MemoryGraphSnapshot, bodies: MemorySpaceView[]): MemoryGraphSnapshot;
+export declare function graphKindLabel(t: MnemonTranslate, node: MemoryGraphNode): string;
+export declare function MemoryGraph(props: {
+    graph: MemoryGraphSnapshot;
+    selectedId?: string | undefined;
+    onSelect: (node: MemoryGraphNode) => void;
+}): JSX.Element;

package/lib/types/client/overview-page.d.ts

@@ -0,0 +1,20 @@
+import type { JSX } from 'react';
+import { type MemorySpaceMetadataUpdate, type MemorySpaceView } from '../contracts.ts';
+import type { MemorySpacesPageClient } from './api.ts';
+export declare function OverviewPage(props: {
+    client: MemorySpacesPageClient;
+    metadataClient: MemorySpacesPageClient;
+    revision: number;
+    reloadKey?: number;
+    activationEnabled: boolean;
+    writeEnabled: boolean;
+    agentAvailable: boolean;
+    fallbackBodies: MemorySpaceView[];
+    fallbackDirectory: string | undefined;
+    catalogKnown: boolean;
+    onMutate: () => void;
+    onAgentRefresh: () => void;
+    onBodyReconnect: (body: MemorySpaceView) => void;
+    onBodyMetadata: (updates: readonly MemorySpaceMetadataUpdate[]) => void;
+    onExplore: (query: string) => void;
+}): JSX.Element;

package/lib/types/client/pages.d.ts

@@ -1,76 +1,7 @@
-import type { JSX } from 'react';
-import { type Insight, type MemorySpaceMetadataUpdate, type MemorySpaceProvider, type MemorySpaceView } from '../contracts.ts';
-import type { MemorySpacesPageClient } from './api.ts';
-import type { MemoryPersistenceStrategy } from '../contracts.ts';
-export interface MemoryPlacementSettings {
-    setPath(path: string[], value: unknown): Promise<void>;
-}
-export interface MemoryPlacementPageConfig {
-    persistenceStrategy?: MemoryPersistenceStrategy;
-}
-export interface MemorySpacesPageStatus {
-    defaultRecallLimit?: number;
-}
-export declare function nativeSpaceProvider(provider: MemorySpaceProvider): boolean;
-export declare function OverviewPage(props: {
-    client: MemorySpacesPageClient;
-    metadataClient: MemorySpacesPageClient;
-    revision: number;
-    reloadKey?: number;
-    activationEnabled: boolean;
-    writeEnabled: boolean;
-    agentAvailable: boolean;
-    fallbackBodies: MemorySpaceView[];
-    fallbackDirectory: string | undefined;
-    catalogKnown: boolean;
-    onMutate: () => void;
-    onAgentRefresh: () => void;
-    onBodyReconnect: (body: MemorySpaceView) => void;
-    onBodyMetadata: (updates: readonly MemorySpaceMetadataUpdate[]) => void;
-    onExplore: (query: string) => void;
-}): JSX.Element;
-export declare function ExplorePage(props: {
-    client: MemorySpacesPageClient;
-    agentClient: MemorySpacesPageClient;
-    agentAvailable: boolean;
-    status: MemorySpacesPageStatus | null;
-    seed: string;
-    writeEnabled: boolean;
-    onForget: (insight: Insight) => Promise<void>;
-    onRevealElement?(element: HTMLElement): void;
-}): JSX.Element;
-export declare function EntitiesPage(props: {
-    client: MemorySpacesPageClient;
-    revision: number;
-    writeEnabled: boolean;
-    onForget: (insight: Insight) => Promise<void>;
-    onExplore: (query: string) => void;
-}): JSX.Element;
-export declare function PersistenceStrategyDialog(props: {
-    client: MemorySpacesPageClient;
-    settingsScope: MemoryPlacementSettings;
-    config: MemoryPlacementPageConfig | undefined;
-    writable: boolean;
-    agentAvailable: boolean;
-    onClose: () => void;
-}): JSX.Element;
-export declare function RememberPage(props: {
-    client: MemorySpacesPageClient;
-    agentAvailable: boolean;
-    memoryBodies: MemorySpaceView[];
-    writeEnabled: boolean;
-    seed: string;
-    onMutate: () => void;
-    onClose: () => void;
-    onView?: () => void;
-}): JSX.Element;
-export declare function ListPage(props: {
-    client: MemorySpacesPageClient;
-    revision: number;
-    writeEnabled: boolean;
-    onForget: (insight: Insight) => Promise<void>;
-    onClone: (insight: Insight) => void;
-    onExplore: (query: string) => void;
-}): JSX.Element;
-/** @deprecated Use nativeSpaceProvider. */
-export declare const nativeBodyProvider: typeof nativeSpaceProvider;
+export { OverviewPage } from './overview-page.tsx';
+export { ExplorePage, type MemorySpacesPageStatus } from './explore-page.tsx';
+export { EntitiesPage } from './entities-page.tsx';
+export { PersistenceStrategyDialog, type MemoryPlacementPageConfig, type MemoryPlacementSettings } from './persistence-strategy-dialog.tsx';
+export { RememberPage } from './remember-page.tsx';
+export { ListPage } from './list-page.tsx';
+export { nativeBodyProvider, nativeSpaceProvider } from './widgets.tsx';

package/lib/types/client/persistence-strategy-dialog.d.ts

@@ -0,0 +1,17 @@
+import type { JSX } from 'react';
+import { type MemoryPersistenceStrategy } from '../contracts.ts';
+import type { MemorySpacesPageClient } from './api.ts';
+export interface MemoryPlacementSettings {
+    setPath(path: string[], value: unknown): Promise<void>;
+}
+export interface MemoryPlacementPageConfig {
+    persistenceStrategy?: MemoryPersistenceStrategy;
+}
+export declare function PersistenceStrategyDialog(props: {
+    client: MemorySpacesPageClient;
+    settingsScope: MemoryPlacementSettings;
+    config: MemoryPlacementPageConfig | undefined;
+    writable: boolean;
+    agentAvailable: boolean;
+    onClose: () => void;
+}): JSX.Element;

package/lib/types/client/presentation.d.ts

@@ -3,4 +3,32 @@ import type labels from 'dsh-mnemon-source-memory-spaces/presentation/locales.js
 export type SourceKey = keyof typeof labels.zh;
 export declare const css: Readonly<Record<string, string>>;
 export declare const sidebarCss: Readonly<Record<string, string>>;
-export declare function useT(): (key: SourceKey | MnemonKey, params?: Record<string, unknown>) => string;
+type Translate = (key: SourceKey | MnemonKey, params?: Record<string, unknown>) => string;
+/** DSH's language service, as a client context carries it. */
+export interface DshLocale {
+    bind(namespace: 'mnemon'): (key: MnemonKey, params?: Record<string, unknown>) => string;
+    getSnapshot?(): DshLocaleSnapshot;
+    subscribe?(listener: () => void): () => void;
+}
+/** The part of DSH's locale snapshot a lookup chain needs. */
+export interface DshLocaleSnapshot {
+    active: string;
+    locales: readonly {
+        id: string;
+        fallback?: string;
+    }[];
+}
+export declare const SourceTranslation: import("react").Provider<Translate | undefined>;
+export declare function useT(): Translate;
+/** The languages DSH asks for a key: the active one, then each one's fallback. */
+export declare function languageChain(snapshot: DshLocaleSnapshot): string[];
+/**
+ * Translate as dsh-mnemon drew these settings, through DSH's language chain
+ * and the `mnemon` namespace it registers this copy in. This copy answers in
+ * the first of zh and en the chain reaches; a language pack ahead of that one
+ * is asked first, through the namespace, as dsh-mnemon asked it; a key this
+ * copy lacks goes to the namespace too. Without DSH's chain the page's
+ * language picks the copy, as the page frame does.
+ */
+export declare function settingsTranslate(locale: DshLocale, chain: readonly string[] | undefined, language: string): Translate;
+export {};

package/lib/types/client/provider-field.d.ts

@@ -0,0 +1,24 @@
+import { type JSX } from 'react';
+import type { MemoryProviderConfigField } from '../contracts.ts';
+export interface ProviderFieldProps {
+    field: MemoryProviderConfigField;
+    value: string | number | boolean | undefined;
+    /** The Provider keeps a saved credential for this field; it never comes back to the page. */
+    saved: boolean;
+    /** In a dialog, the saved credential is being cleared, so a required field needs a value again. */
+    clearing?: boolean;
+    disabled?: boolean;
+    /**
+     * `settings`, a service field on the configuration page; `dialog`, a space's
+     * field in this Source's dialogs. Each draws a field and shows a saved
+     * credential as it always has: the configuration page fills the field with a
+     * mask that a typed value replaces, and can show what is typed; a dialog
+     * leaves the field empty with a note and can clear the credential.
+     */
+    layout: 'settings' | 'dialog';
+    onChange: (value: string | number | boolean) => void;
+    /** Offers clearing the saved credential, in a dialog that edits a space. */
+    onClearChange?: (clearing: boolean) => void;
+}
+/** One field of a Provider descriptor, wherever it is edited. */
+export declare function ProviderField(props: ProviderFieldProps): JSX.Element;

package/lib/types/client/provider-settings.d.ts

@@ -0,0 +1,26 @@
+import { type JSX, type ReactNode } from 'react';
+import type { MemorySpacesSettingsClient } from './settings-client.ts';
+interface ProviderSettingsSectionProps {
+    /** Absent while the page has no Host connection: nothing is read or written then. */
+    client?: MemorySpacesSettingsClient | undefined;
+    /** Where the list keeps the Providers it last read or saved: the host's store, which outlives a mount. */
+    retained: Map<string, unknown>;
+    workspaceLabel?: string;
+    activeScope: 'global' | 'workspace';
+    refreshKey: number;
+    disabled: boolean;
+    scopeChanging: boolean;
+    /** Rendered first in the list; Settings puts Mnemon Native here as a peer of the others. */
+    leading?: ReactNode;
+    /** Why the other Providers cannot be listed now; they are not read while it is set. */
+    blocked?: ReactNode;
+    /** Whether it is not yet known if the Providers can be listed; they are read once it is. */
+    pending?: boolean;
+    /** Why the listed Providers cannot be switched; rendered above them. */
+    notice?: ReactNode;
+    /** A Provider was saved or switched, so pages that list Providers re-read them. */
+    onChanged?: () => void;
+}
+/** The Providers that store Memory Spaces, one card each, with what their services need. */
+export declare function ProviderSettingsSection(props: ProviderSettingsSectionProps): JSX.Element;
+export {};

package/lib/types/client/remember-page.d.ts

@@ -0,0 +1,15 @@
+import type { JSX } from 'react';
+import { type MemorySpaceView } from '../contracts.ts';
+import type { MemorySpacesPageClient } from './api.ts';
+/** `embeddingManaged`, from this Source's status, words a memory saved without a vector; left out, the receipt keeps the caution. */
+export declare function RememberPage(props: {
+    client: MemorySpacesPageClient;
+    agentAvailable: boolean;
+    memoryBodies: MemorySpaceView[];
+    writeEnabled: boolean;
+    seed: string;
+    embeddingManaged?: boolean | undefined;
+    onMutate: () => void;
+    onClose: () => void;
+    onView?: () => void;
+}): JSX.Element;