dsh-mnemon-source-memory-spaces 0.5.0-rc.1

package/lib/testing.js

@@ -0,0 +1,106 @@
+import { a as MemoryProviderCatalog, n as PrivateMemorySpaceProviderHost, t as createMemorySpaceProviderPlugin } from "./plugin-DlsNeZbQ.js";
+import { n as deepFreeze } from "./definitions-DfmOqJjR.js";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/testing.ts
+/** Real private-child registration and factory validation, without exposing its Host/Registry. */
+async function mountMemorySpaceProvider(module, options) {
+	const context = new Context();
+	const host = new PrivateMemorySpaceProviderHost(options.sourceInstanceId ?? "test-memory-spaces");
+	const instanceId = options.instanceId ?? module.id;
+	const plugin = createMemorySpaceProviderPlugin({
+		instanceId,
+		module,
+		config: options.config
+	}, host);
+	const bound = {
+		...plugin,
+		apply: (ctx, config) => plugin.apply(ctx, config)
+	};
+	const child = context.plugin(bound, options.config);
+	try {
+		await child.await();
+		if (!host.has(instanceId)) throw new Error(`Memory Space Provider child did not install a definition: ${instanceId}`);
+		const snapshot = host.snapshot();
+		const adapters = /* @__PURE__ */ new Set();
+		let closing;
+		return Object.freeze({
+			get registered() {
+				return host.has(instanceId);
+			},
+			descriptor: deepFreeze(snapshot.descriptors()[0]),
+			manifest: snapshot.entries[0].definition.manifest,
+			createAdapter: (input) => {
+				if (closing !== void 0) throw new Error("Memory Space Provider test is disposed");
+				const adapter = snapshot.adapterRegistry().create(input).get(instanceId);
+				adapters.add(adapter);
+				return adapter;
+			},
+			dispose: () => {
+				closing ??= Promise.resolve().then(async () => {
+					const failures = [];
+					for (const adapter of adapters) try {
+						await adapter.dispose?.();
+					} catch (error) {
+						failures.push(error);
+					}
+					adapters.clear();
+					try {
+						await context.fiber.dispose();
+					} catch (error) {
+						failures.push(error);
+					}
+					if (failures.length > 0) throw new AggregateError(failures, "Memory Space Provider test cleanup failed");
+				});
+				return closing;
+			}
+		});
+	} catch (error) {
+		await context.fiber.dispose();
+		throw error;
+	}
+}
+/** Driver fixture only: real descriptor validation, no Core or service singleton. */
+function createMemorySpaceProviderFixture(descriptor, input = {}, options) {
+	const instanceId = options.instanceId ?? descriptor.id;
+	const catalog = new MemoryProviderCatalog([{
+		...descriptor,
+		id: instanceId,
+		...instanceId === descriptor.id ? {} : { typeId: descriptor.id }
+	}]);
+	const connection = catalog.normalize(instanceId, input);
+	const publicConnection = catalog.public(instanceId, connection);
+	const body = {
+		id: options.memoryBodyId ?? "test-memory",
+		name: "Test memory",
+		description: "Provider-owned test fixture",
+		active: true,
+		dbPath: "",
+		createdAt: "2026-08-30T00:00:00.000Z",
+		updatedAt: "2026-08-30T00:00:00.000Z",
+		provider: {
+			id: instanceId,
+			...instanceId === descriptor.id ? {} : { typeId: descriptor.id },
+			label: descriptor.label,
+			kind: descriptor.kind,
+			origin: descriptor.origin,
+			location: String(connection.endpoint ?? options.dataDir),
+			apiKeyConfigured: publicConnection.configuredSecrets.includes("apiKey"),
+			...publicConnection,
+			capabilities: structuredClone(descriptor.capabilities)
+		}
+	};
+	return {
+		body,
+		authority: {
+			runner: { effectiveDataDir: () => options.dataDir },
+			list: () => [body],
+			providerConnection(id, expectedProviderId) {
+				if (id !== body.id || expectedProviderId !== void 0 && expectedProviderId !== instanceId) throw new Error("Provider attempted to cross its test authority boundary");
+				return structuredClone(connection);
+			}
+		},
+		connection
+	};
+}
+//#endregion
+export { createMemorySpaceProviderFixture, mountMemorySpaceProvider };

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

@@ -0,0 +1,10 @@
+import type { JSX } from 'react';
+import type { MemoryProviderIcon, MemoryProviderId } from '../contracts.ts';
+export interface ProviderIconProps {
+    providerId: MemoryProviderId;
+    icon?: MemoryProviderIcon | undefined;
+    className?: string | undefined;
+    title?: string | undefined;
+}
+/** Only the owning plugin supplies image data; unknown brands get a neutral mark. */
+export declare function ProviderIcon({ providerId, icon, className, title }: ProviderIconProps): JSX.Element;

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

@@ -0,0 +1,39 @@
+import type { CreateMemoryBodyRequest, EntityView, Insight, MemoryBody, MemoryBodyView, MemoryBodyMetadataMaintenanceResult, MemoryBodyCatalog, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryReadSource, RememberRequest, SearchRequest, UpdateMemoryBodyRequest } from '../contracts.ts';
+/** Source-owned structural page API; the default bundle may supply agent-assisted callbacks. */
+export interface MemorySpacesPageClient {
+    bodies(): Promise<MemoryBodyCatalog>;
+    bodyDirectory(): Promise<MemoryBodyCatalog>;
+    graph(memoryBodyIds?: string[]): Promise<MemoryGraphSnapshot>;
+    list(request?: MemoryListRequest): Promise<MemoryListView>;
+    entities(entity?: string, limit?: number): Promise<EntityView>;
+    search(request: SearchRequest): Promise<SearchResponse>;
+    agentSearch(request: SearchRequest): Promise<AgentSearchResponse>;
+    related(id: string, memoryBodyId?: string): Promise<Insight[]>;
+    remember(request: RememberRequest): Promise<Record<string, unknown>>;
+    supervise(content: string, idempotencyKey?: string): Promise<{
+        delegated: true;
+        sessionId: string;
+        runId: string;
+        provider: string;
+        summary: string;
+        action: string;
+        memoryBodyIds: string[];
+    }>;
+    forget(id: string, memoryBodyId?: string): Promise<Record<string, unknown>>;
+    createBody(request: CreateMemoryBodyRequest): Promise<MemoryBody>;
+    updateBody(memoryBodyId: string, request: UpdateMemoryBodyRequest): Promise<MemoryBody>;
+    reconnectBody(memoryBodyId: string): Promise<MemoryBodyView>;
+    maintainBodyMetadata(memoryBodyIds: string[]): Promise<MemoryBodyMetadataMaintenanceResult>;
+    deleteBody(memoryBodyId: string): Promise<MemoryBody>;
+}
+export interface SearchResponse {
+    results: Insight[];
+    sources?: MemoryReadSource[];
+}
+export interface AgentSearchResponse extends SearchResponse {
+    answer: string;
+    citations: string[];
+    delegation: {
+        runId: string;
+    };
+}

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

@@ -0,0 +1,72 @@
+import type { JSX } from 'react';
+import { type Insight, type MemoryBodyMetadataUpdate, type MemoryBodyProvider, type MemoryBodyView } 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 nativeBodyProvider(provider: MemoryBodyProvider): boolean;
+export declare function OverviewPage(props: {
+    client: MemorySpacesPageClient;
+    metadataClient: MemorySpacesPageClient;
+    revision: number;
+    activationEnabled: boolean;
+    writeEnabled: boolean;
+    agentAvailable: boolean;
+    fallbackBodies: MemoryBodyView[];
+    fallbackDirectory: string | undefined;
+    catalogKnown: boolean;
+    onMutate: () => void;
+    onAgentRefresh: () => void;
+    onBodyReconnect: (body: MemoryBodyView) => void;
+    onBodyMetadata: (updates: readonly MemoryBodyMetadataUpdate[]) => 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>;
+}): 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: MemoryBodyView[];
+    writeEnabled: boolean;
+    seed: string;
+    onMutate: () => void;
+    onClose: () => void;
+    onComplete?: () => 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;

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

@@ -0,0 +1,6 @@
+import type { MemoryProviderConfigField, MemoryProviderDescriptor } from '../contracts.ts';
+import type { MnemonTranslate } from 'dsh-mnemon/client';
+export declare function providerDisplayLabel(_providerId: string, label: string): string;
+export declare function providerSummary(t: MnemonTranslate, provider: MemoryProviderDescriptor): string;
+export declare function providerFieldLabel(t: MnemonTranslate, field: MemoryProviderConfigField): string;
+export declare function providerOptionLabel(t: MnemonTranslate, option: NonNullable<MemoryProviderConfigField['options']>[number]): string;

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

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import { installMemorySourceUI, type MemorySourcePageProps, type MnemonSourceManagementClient, type MnemonTranslate } from 'dsh-mnemon/client';
+import type { MemorySpacesStatus } from '../contracts.ts';
+import type { MemorySpacesPageClient } from './api.ts';
+/** The adapter never gets a transport or chooses another Source instance. */
+export declare function memorySpacesPageClient(management: MnemonSourceManagementClient): MemorySpacesPageClient & {
+    status(): Promise<MemorySpacesStatus>;
+    canAssist(operation: string): boolean;
+};
+type Page = 'spaces' | 'explore' | 'entities' | 'remember' | 'content';
+export declare function MemorySpacesSourcePage(props: MemorySourcePageProps & {
+    page: Page;
+}): ReactNode;
+export declare function installMemorySpacesUI(ctx: Parameters<typeof installMemorySourceUI>[0], t?: MnemonTranslate): () => void;
+export declare const inject: string[];
+export declare function apply(ctx: Parameters<typeof installMemorySourceUI>[0]): void;
+export {};

package/lib/types/client.d.ts

@@ -0,0 +1,3 @@
+export * from './client/pages.tsx';
+export type * from './client/api.ts';
+export * from './client/ui.tsx';