dsh-mnemon 0.5.16 → 0.5.17

package/lib/{runtime-BEX0sc1z.js → runtime-Bk6lFgxd.js}

@@ -1,5 +1,5 @@
-import { i as DEFAULT_MEMORY_VIEW_BUDGET } from "./contracts-D4ghDRK4.js";
-import { a as defineMemoryStrategy, c as jsonClone, d as uniqueIds, f as validateCapabilities, i as defineMemorySource, l as positiveInteger, n as deepFreeze, o as defineMemoryStrategyExtension, p as validateProvenance, r as defineMemoryPlugin, s as id, t as canonicalMemoryJson, u as requiredText } from "./definitions-CSPV0ER1.js";
+import { DEFAULT_MEMORY_VIEW_BUDGET } from "./contracts.js";
+import { a as defineMemoryStrategy, c as jsonClone, d as uniqueIds, f as validateCapabilities, i as defineMemorySource, l as positiveInteger, n as deepFreeze, o as defineMemoryStrategyExtension, p as validateProvenance, r as defineMemoryPlugin, s as id, t as canonicalMemoryJson, u as requiredText } from "./definitions-j9QPbrXb.js";
 import { createHash } from "node:crypto";
 import { setMaxListeners } from "node:events";
 //#region src/core/contributions.ts
@@ -165,13 +165,16 @@ function captureMemoryContributionSnapshot(snapshot) {
 	const strategies = snapshot.strategies.map(captureStrategy);
 	const extensions = (snapshot.strategyExtensions ?? []).map(captureExtension).sort((a, b) => a.instanceKey.localeCompare(b.instanceKey));
 	const plugins = (snapshot.plugins ?? []).map(capturePlugin).sort((a, b) => a.instanceKey.localeCompare(b.instanceKey));
-	const slots = /* @__PURE__ */ new Map();
+	const owners = [];
 	for (const extension of extensions) {
-		const manifest = extension.definition.manifest;
-		const slot = `${manifest.strategyTypeId}/${manifest.slot}`;
-		const occupied = slots.get(slot);
-		if (occupied !== void 0) throw new Error(`memory Strategy extension slot conflict: ${slot} (${occupied}, ${extension.instanceKey})`);
-		slots.set(slot, extension.instanceKey);
+		const { strategyTypeId, slot } = extension.definition.manifest;
+		const owner = owners.find((item) => item.slot === slot && (item.strategyTypeId === strategyTypeId || item.strategyTypeId === "*" || strategyTypeId === "*"));
+		if (owner !== void 0) throw new Error(`memory Strategy extension slot conflict: ${strategyTypeId}/${slot} (${owner.instanceKey}, ${extension.instanceKey})`);
+		owners.push({
+			strategyTypeId,
+			slot,
+			instanceKey: extension.instanceKey
+		});
 	}
 	const keys = /* @__PURE__ */ new Set();
 	for (const contribution of [
@@ -214,6 +217,7 @@ function selectStrategy(strategies, options) {
 	if (options.strategyTypeId !== void 0) {
 		const type = id(options.strategyTypeId, "selected memory Strategy typeId");
 		const matches = strategies.filter((strategy) => strategy.definition.manifest.typeId === type);
+		if (matches.length === 0 && options.strategyFallback === "sole-strategy" && strategies.length === 1) return strategies[0];
 		if (matches.length === 0) throw new Error(`selected memory Strategy type is unavailable: ${type}`);
 		if (matches.length > 1) throw new Error(`selected memory Strategy type is ambiguous: ${type}`);
 		return matches[0];
@@ -274,7 +278,8 @@ function normalizeViewSpec(value, strategy, facts, budget) {
 		seen.add(key);
 		const sourceFacts = facts.get(key);
 		if (sourceFacts === void 0) throw new Error(`memory Strategy selected unavailable Source: ${key}`);
-		if (!strategy.definition.manifest.supportedSourceRoles.includes(sourceFacts.role)) throw new Error(`memory Strategy selected an unsupported Source role: ${sourceFacts.role}`);
+		const roles = strategy.definition.manifest.supportedSourceRoles;
+		if (!roles.includes("*") && !roles.includes(sourceFacts.role)) throw new Error(`memory Strategy selected an unsupported Source role: ${sourceFacts.role}`);
 		if (source.required !== void 0 && typeof source.required !== "boolean") throw new Error(`memory Source requirement must be boolean: ${key}`);
 		if (sourceFacts.availability === "unavailable") {
 			if (source.required === false) return [];
@@ -490,8 +495,12 @@ var MemoryCompositionGeneration = class {
 			...snapshot.strategies.length === 0 ? [] : ["strategy"]
 		]);
 		this.strategy = selectStrategy(snapshot.strategies, options);
-		this.extensions = (snapshot.strategyExtensions ?? []).filter((extension) => extension.definition.manifest.strategyTypeId === this.strategy.definition.manifest.typeId);
-		for (const extension of this.extensions) if (!this.strategy.definition.manifest.extensionSlots?.includes(extension.definition.manifest.slot)) throw new Error(`memory Strategy does not support extension slot: ${extension.definition.manifest.slot} (${extension.instanceKey})`);
+		const strategyManifest = this.strategy.definition.manifest;
+		this.extensions = (snapshot.strategyExtensions ?? []).filter((extension) => extension.definition.manifest.strategyTypeId === strategyManifest.typeId || extension.definition.manifest.strategyTypeId === "*" && strategyManifest.extensionSlots?.includes(extension.definition.manifest.slot) === true);
+		for (const extension of this.extensions) {
+			const slot = extension.definition.manifest.slot;
+			if (!strategyManifest.extensionSlots?.includes(slot)) throw new Error(`memory Strategy does not support extension slot: ${slot} (${extension.instanceKey})`);
+		}
 		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
 		this.sourceTimeoutMs = positiveInteger(options.sourceTimeoutMs ?? 1e4, "memory Source timeoutMs", 3e5);
 		const configurations = /* @__PURE__ */ new Map();
@@ -548,11 +557,15 @@ var MemoryCompositionGeneration = class {
 			strategyInstanceKey: this.strategy.instanceKey,
 			...this.extensions.length === 0 ? {} : { strategyExtensionInstanceKeys: this.extensions.map((extension) => extension.instanceKey) },
 			sourceInstanceKeys: [...this.sources.keys()],
-			diagnostics: (snapshot.strategyExtensions ?? []).filter((extension) => !this.extensions.includes(extension)).map((extension) => ({
+			diagnostics: [...options.strategyTypeId === void 0 || strategyManifest.typeId === options.strategyTypeId ? [] : [{
+				code: "strategy-fallback",
+				contributionInstanceKey: this.strategy.instanceKey,
+				message: `Selected Strategy ${options.strategyTypeId} is unavailable; composing with the only installed Strategy ${strategyManifest.typeId}.`
+			}], ...(snapshot.strategyExtensions ?? []).filter((extension) => !this.extensions.includes(extension)).map((extension) => ({
 				code: "strategy-extension-inactive",
 				contributionInstanceKey: extension.instanceKey,
-				message: `Strategy extension targets ${extension.definition.manifest.strategyTypeId}; selected Strategy is ${this.strategy.definition.manifest.typeId}.`
-			}))
+				message: extension.definition.manifest.strategyTypeId === "*" ? `Selected Strategy ${strategyManifest.typeId} does not accept the ${extension.definition.manifest.slot} slot.` : `Strategy extension targets ${extension.definition.manifest.strategyTypeId}; selected Strategy is ${strategyManifest.typeId}.`
+			}))]
 		});
 	}
 	async compose(requestValue, signal) {
@@ -955,6 +968,21 @@ var MemoryCompositionGeneration = class {
 };
 //#endregion
 //#region src/core/generation.ts
+/** No generation serves new work: the composition is incomplete or was rejected. */
+var MemoryCompositionUnavailableError = class extends Error {
+	evaluation;
+	code = "memory-composition-unavailable";
+	constructor(evaluation) {
+		const reason = evaluation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+		super(`no Serving memory generation is available${reason === "" ? "" : `: ${reason}`}`);
+		this.evaluation = evaluation;
+		this.name = "MemoryCompositionUnavailableError";
+	}
+};
+/** Matched by code, so a copy of Core bundled into another entry point still qualifies. */
+function isMemoryCompositionUnavailable(error) {
+	return error instanceof Error && error.code === "memory-composition-unavailable";
+}
 function report(state, snapshot, diagnostics) {
 	return Object.freeze({
 		state,
@@ -1040,10 +1068,7 @@ var MemoryGenerationHost = class {
 	acquire(generationId) {
 		this.assertOpen();
 		const record = generationId === void 0 ? this.serving : this.records.get(generationId);
-		if (record === void 0 || generationId === void 0 && record.state !== "serving") {
-			const reason = this.evaluation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
-			throw new Error(`no Serving memory generation is available${reason === "" ? "" : `: ${reason}`}`);
-		}
+		if (record === void 0 || generationId === void 0 && record.state !== "serving") throw new MemoryCompositionUnavailableError(this.evaluation);
 		record.leases += 1;
 		let active = true;
 		return Object.freeze({
@@ -1313,4 +1338,4 @@ var MemoryRuntime = class {
 	}
 };
 //#endregion
-export { prepareMemoryContributions as a, validateMemoryPluginGraph as i, MemoryCompositionGeneration as n, captureMemoryContributionSnapshot as r, provideMemoryRuntime as t };
+export { validateMemoryPluginGraph as a, captureMemoryContributionSnapshot as i, isMemoryCompositionUnavailable as n, prepareMemoryContributions as o, MemoryCompositionGeneration as r, provideMemoryRuntime as t };

package/lib/{strategy-configuration-D8IEKZdS.js → strategy-configuration-sVkKToSW.js}

@@ -1,4 +1,4 @@
-import { n as deepFreeze, t as canonicalMemoryJson } from "./definitions-CSPV0ER1.js";
+import { n as deepFreeze, t as canonicalMemoryJson } from "./definitions-j9QPbrXb.js";
 import { resolve } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/sdk/storage-lock.ts

package/lib/testing.js

@@ -1,6 +1,6 @@
-import { t as provideMemoryRuntime } from "./runtime-BEX0sc1z.js";
-import { i as DEFAULT_MEMORY_VIEW_BUDGET } from "./contracts-D4ghDRK4.js";
-import { c as jsonClone } from "./definitions-CSPV0ER1.js";
+import { t as provideMemoryRuntime } from "./runtime-Bk6lFgxd.js";
+import { DEFAULT_MEMORY_VIEW_BUDGET } from "./contracts.js";
+import { c as jsonClone } from "./definitions-j9QPbrXb.js";
 import { Context } from "@deepseek-ai/cordis";
 import { readFileSync } from "node:fs";
 //#region src/sdk/testing.ts

package/lib/types/src/client/component-ui.d.ts

@@ -0,0 +1,118 @@
+import { type ReactNode } from 'react';
+/**
+ * A component's own settings, on its page: keyed by the component's package
+ * name, rendered after the page's generated state, relations and options.
+ */
+export declare const MNEMON_COMPONENT_SETTINGS_SLOT: "mnemon.component.settings";
+/**
+ * What a component's card on the Memory System's Status page says while it
+ * runs, keyed by the component's package name. A card that is not running
+ * shows the page's own note instead.
+ */
+export declare const MNEMON_COMPONENT_STATUS_SLOT: "mnemon.component.status";
+type ComponentRegion = typeof MNEMON_COMPONENT_SETTINGS_SLOT | typeof MNEMON_COMPONENT_STATUS_SLOT;
+/** What the host tells a component's settings about the page they are on. */
+export interface MemoryComponentSettingsProps {
+    /** The component the page is about, as the host shows it. */
+    component: {
+        packageName: string;
+        label: string;
+        /** Whether the component is switched on. */
+        enabled: boolean;
+    };
+    /** Whether the configuration can be written now; settings stay read-only otherwise. */
+    writable: boolean;
+    /** The active DSH locale id. */
+    language: string;
+    /** The conversation and workspace the page was opened for, when there is one. */
+    sessionId?: string;
+    workspace?: {
+        id: string;
+        label?: string;
+    };
+}
+export type MemoryComponentSettingsComponent = (props: MemoryComponentSettingsProps) => ReactNode;
+/** What the Status page tells a component's card: the component it is about. */
+export interface MemoryComponentStatusProps {
+    component: {
+        packageName: string;
+        label: string;
+        enabled: boolean;
+    };
+    /** The active DSH locale id. */
+    language: string;
+    /** The conversation and workspace the Memory System shows, when there is one. */
+    sessionId?: string;
+    workspace?: {
+        id: string;
+        label?: string;
+    };
+}
+export type MemoryComponentStatusComponent = (props: MemoryComponentStatusProps) => ReactNode;
+/** Everything one component adds to dsh-mnemon's interface beyond its declaration. */
+export interface MemoryComponentUIContribution {
+    /** The npm package name the component's plugin declaration names. */
+    packageName: string;
+    /** Its own settings, shown on its page. Each saves on its own. */
+    settings?: MemoryComponentSettingsComponent;
+    /** What its card on the Status page says while it runs: a headline and one line. */
+    status?: MemoryComponentStatusComponent;
+}
+/** The DSH Slot capability narrowed to the component regions. */
+export interface MemoryComponentUIContext {
+    slots: {
+        inject(name: ComponentRegion, setup: () => () => void): () => void;
+        register(options: {
+            name: typeof MNEMON_COMPONENT_SETTINGS_SLOT;
+            key: string;
+        }, component: MemoryComponentSettingsComponent): () => void;
+        register(options: {
+            name: typeof MNEMON_COMPONENT_STATUS_SLOT;
+            key: string;
+        }, component: MemoryComponentStatusComponent): () => void;
+    };
+}
+/**
+ * Register a component's interface into the regions dsh-mnemon declares, the
+ * way shipped components do. Registration waits for each region to exist and
+ * is released by the returned function.
+ */
+export declare function installMemoryComponentUI(ctx: MemoryComponentUIContext, contribution: MemoryComponentUIContribution): () => void;
+interface ComponentRegionDirectoryContext {
+    slots: {
+        getVersion(name: ComponentRegion): number;
+        entriesOfSlot(name: ComponentRegion): readonly {
+            options: {
+                key?: string;
+            };
+        }[];
+        subscribe(name: ComponentRegion, listener: () => void): () => void;
+    };
+}
+/** The components that registered into one region, as the pages that show it need to know. */
+export interface ComponentRegionDirectory {
+    getSnapshot(): ReadonlySet<string>;
+    subscribe(listener: () => void): () => void;
+}
+/** The components that registered settings. */
+export type ComponentSettingsDirectory = ComponentRegionDirectory;
+/** Thin adapter over a DSH child Slot: it keeps no registry of its own. */
+export declare function createComponentRegionDirectory(ctx: ComponentRegionDirectoryContext, region: ComponentRegion): ComponentRegionDirectory;
+export declare function createComponentSettingsDirectory(ctx: ComponentRegionDirectoryContext): ComponentSettingsDirectory;
+interface ComponentRegionEntriesContext {
+    slots: {
+        entriesOfSlot(name: ComponentRegion): readonly {
+            component: unknown;
+            options: {
+                key?: string;
+            };
+        }[];
+    };
+}
+/**
+ * Render what one component registered into a region, where the page is not
+ * the region's declaring owner, as DSH's row page for a component is not:
+ * a child slot has one declaring entry, the configuration's.
+ */
+export declare function renderComponentRegion<P extends object>(ctx: ComponentRegionEntriesContext, region: ComponentRegion, packageName: string, props: P): ReactNode;
+export {};

package/lib/types/src/client/extension-sdk.d.ts

@@ -1,5 +1,6 @@
 export { installMemorySourceUI, memorySourcePageEntryId, MNEMON_SOURCE_PAGE_SLOT, MNEMON_SOURCE_CONFIGURATION_MUTATE, MNEMON_SOURCE_CONFIGURATION_READ, type MemorySourcePageComponent, type MemorySourcePageDefinition, type MemorySourcePageProps, type MemorySourceUIContribution, type MemorySourceUIContext, type MemorySourcePageNavigation, } from './source-pages.tsx';
 export type { MnemonSourceManagementClient, MemorySourcePageInstance } from './source-contracts.ts';
+export { installMemoryComponentUI, MNEMON_COMPONENT_SETTINGS_SLOT, MNEMON_COMPONENT_STATUS_SLOT, type MemoryComponentSettingsComponent, type MemoryComponentSettingsProps, type MemoryComponentStatusComponent, type MemoryComponentStatusProps, type MemoryComponentUIContext, type MemoryComponentUIContribution, } from './component-ui.tsx';
 export * from './page-kit.tsx';
 export * from './page-client.tsx';
 export { MnemonDialog, type MnemonDialogProps } from './MnemonDialog.tsx';