dsh-mnemon 0.4.7 → 0.5.0

package/lib/contracts.js

@@ -1,9 +1,18 @@
-//#region packages/contracts/src/index.ts
-const BUILTIN_MEMORY_LAYER_IDS = [
-	"runtime",
-	"documents",
-	"memory-spaces"
-];
+//#region src/core/contracts/plugin.ts
+/** Declarative identity and graph relations shared by every Mnemon plugin. */
+const MEMORY_PLUGIN_API_VERSION = "dsh-mnemon/plugin/v1";
+//#endregion
+//#region src/core/contracts/view.ts
+const COMPOSABLE_MEMORY_API_VERSION = "dsh-mnemon/v1";
+const DEFAULT_MEMORY_VIEW_BUDGET = Object.freeze({
+	maxProjectionCharacters: 65536,
+	maxRoutes: 16,
+	maxActions: 16,
+	maxEvidenceResults: 16,
+	maxEvidenceCharacters: 16384
+});
+//#endregion
+//#region src/core/contracts/index.ts
 const MEMORY_CAPABILITIES = [
 	"status",
 	"project",
@@ -21,16 +30,6 @@ const MEMORY_CAPABILITIES = [
 	"export",
 	"import"
 ];
-const MEMORY_STRATEGY_HOOKS = [
-	"admission",
-	"placement",
-	"retrieval-planning",
-	"quality-fusion",
-	"projection",
-	"promotion-demotion",
-	"retention",
-	"maintenance"
-];
 const MEMORY_SOURCE_MODES = ["eager", "routed"];
 //#endregion
-export { BUILTIN_MEMORY_LAYER_IDS, MEMORY_CAPABILITIES, MEMORY_SOURCE_MODES, MEMORY_STRATEGY_HOOKS };
+export { COMPOSABLE_MEMORY_API_VERSION, DEFAULT_MEMORY_VIEW_BUDGET, MEMORY_CAPABILITIES, MEMORY_PLUGIN_API_VERSION, MEMORY_SOURCE_MODES };

package/lib/core.js

@@ -0,0 +1,11 @@
+import { t as provideMemoryRuntime } from "./runtime-AtIOTeP1.js";
+//#region src/core/plugin.ts
+const name = "dsh-mnemon-core";
+const provide = ["mnemonMemory"];
+const inject = [];
+/** No built-in Source, Provider, filesystem, settings, tools, or Web dependency. */
+function apply(context) {
+	provideMemoryRuntime(context);
+}
+//#endregion
+export { apply, inject, name, provide };

package/lib/definitions-j0FLgE0-.js

@@ -0,0 +1,251 @@
+import { MEMORY_CAPABILITIES, MEMORY_PLUGIN_API_VERSION } from "./contracts.js";
+//#region src/core/definitions.ts
+const ID = /^[a-z][a-z0-9-]{0,127}$/u;
+const PACKAGE = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u;
+const CAPABILITIES = new Set(MEMORY_CAPABILITIES);
+const PLUGIN_CAPABILITY = /^[a-z][a-z0-9.-]{0,127}$/u;
+function requiredText(value, label, maximum = 500) {
+	if (typeof value !== "string") throw new Error(`${label} must be a string`);
+	const normalized = value.trim();
+	if (normalized === "") throw new Error(`${label} is required`);
+	if (normalized.length > maximum) throw new Error(`${label} is too long (max ${maximum} characters)`);
+	return normalized;
+}
+function id(value, label) {
+	const normalized = requiredText(value, label, 128);
+	if (!ID.test(normalized)) throw new Error(`${label} must match [a-z][a-z0-9-]{0,127}`);
+	return normalized;
+}
+function positiveInteger(value, label, maximum = 1e6) {
+	if (!Number.isInteger(value) || value < 1 || value > maximum) throw new Error(`${label} must be an integer within 1..${maximum}`);
+	return value;
+}
+/** Canonical JSON representation shared by validation, digest, and replay. */
+function canonicalMemoryJson(value, label = "memory value", ancestors = /* @__PURE__ */ new Set(), depth = 0) {
+	if (depth > 48) throw new Error(`${label} is nested too deeply`);
+	if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error(`${label} contains a non-finite number`);
+		return JSON.stringify(value);
+	}
+	if (typeof value !== "object") throw new Error(`${label} contains a non-JSON value`);
+	if (ancestors.has(value)) throw new Error(`${label} contains a cycle`);
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return `[${value.map((item) => canonicalMemoryJson(item, label, ancestors, depth + 1)).join(",")}]`;
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw new Error(`${label} contains a non-JSON object`);
+		return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonicalMemoryJson(item, label, ancestors, depth + 1)}`).join(",")}}`;
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function deepFreeze(value) {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	for (const child of Object.values(value)) deepFreeze(child);
+	return Object.freeze(value);
+}
+/** Validate the JSON boundary without allocating a discarded canonical string. */
+function assertMemoryJson(value, label, ancestors = /* @__PURE__ */ new Set(), depth = 0) {
+	if (depth > 48) throw new Error(`${label} is nested too deeply`);
+	if (value === null || typeof value === "boolean" || typeof value === "string") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error(`${label} contains a non-finite number`);
+		return;
+	}
+	if (typeof value !== "object") throw new Error(`${label} contains a non-JSON value`);
+	if (ancestors.has(value)) throw new Error(`${label} contains a cycle`);
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			const length = value.length;
+			for (let index = 0; index < length; index++) if (index in value) assertMemoryJson(value[index], label, ancestors, depth + 1);
+			return;
+		}
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw new Error(`${label} contains a non-JSON object`);
+		const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+		for (const [, item] of entries) assertMemoryJson(item, label, ancestors, depth + 1);
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function jsonClone(value, label) {
+	assertMemoryJson(value, label);
+	return deepFreeze(structuredClone(value));
+}
+function uniqueIds(values, label) {
+	const output = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		const normalized = id(value, label);
+		if (seen.has(normalized)) throw new Error(`${label} is duplicated: ${normalized}`);
+		seen.add(normalized);
+		output.push(normalized);
+	}
+	return output;
+}
+function validateProvenance(value, expectedPackage) {
+	const packageName = requiredText(value.packageName, "memory package name", 214);
+	if (!PACKAGE.test(packageName)) throw new Error(`invalid memory package name: ${packageName}`);
+	if (packageName !== expectedPackage) throw new Error(`memory package provenance does not match manifest: ${packageName} != ${expectedPackage}`);
+	const entryId = requiredText(value.entryId, "memory Entry id", 300);
+	const artifactDigest = value.artifactDigest === void 0 ? void 0 : requiredText(value.artifactDigest, "memory artifact digest", 500);
+	return deepFreeze({
+		packageName,
+		entryId,
+		...artifactDigest === void 0 ? {} : { artifactDigest }
+	});
+}
+function validateCapabilities(values, label) {
+	const normalized = uniqueIds(values, label);
+	for (const capability of normalized) if (!CAPABILITIES.has(capability)) throw new Error(`${label} contains unsupported capability: ${capability}`);
+	return normalized;
+}
+function localizedText(value, label) {
+	return deepFreeze({
+		en: requiredText(value.en, `${label} (English)`, 4e3),
+		"zh-CN": requiredText(value["zh-CN"], `${label} (Simplified Chinese)`, 4e3)
+	});
+}
+function pluginCapabilities(values, label) {
+	const output = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		const normalized = requiredText(value, label, 128);
+		if (!PLUGIN_CAPABILITY.test(normalized)) throw new Error(`${label} must match [a-z][a-z0-9.-]{0,127}`);
+		if (seen.has(normalized)) throw new Error(`${label} is duplicated: ${normalized}`);
+		seen.add(normalized);
+		output.push(normalized);
+	}
+	return output;
+}
+/** Validate a plugin node independently of whether its Fiber is active. */
+function defineMemoryPlugin(value) {
+	if ("apiVersion" in value && value.apiVersion !== "dsh-mnemon/plugin/v1") throw new Error(`unsupported memory plugin API: ${String(value.apiVersion)}`);
+	const packageName = requiredText(value.packageName, "memory plugin packageName", 214);
+	if (!PACKAGE.test(packageName)) throw new Error(`invalid memory plugin packageName: ${packageName}`);
+	const roles = uniqueIds(value.roles, "memory plugin role");
+	if (roles.length === 0 || roles.some((role) => ![
+		"source",
+		"strategy",
+		"strategy-extension"
+	].includes(role))) throw new Error("memory plugin must declare at least one supported contribution role");
+	const providedIds = pluginCapabilities(value.provides.map((capability) => capability.id), "memory plugin provided capability");
+	const provides = value.provides.map((capability, index) => deepFreeze({
+		id: providedIds[index],
+		...capability.exclusive === true ? { exclusive: true } : {}
+	}));
+	if (provides.length === 0) throw new Error("memory plugin must provide at least one capability");
+	const requires = pluginCapabilities(value.requires ?? [], "memory plugin required capability");
+	const selfProvided = new Set(providedIds);
+	for (const requirement of requires) if (selfProvided.has(requirement)) throw new Error(`memory plugin cannot require its own capability: ${requirement}`);
+	return deepFreeze({
+		apiVersion: MEMORY_PLUGIN_API_VERSION,
+		packageName,
+		label: localizedText(value.label, "memory plugin label"),
+		description: localizedText(value.description, "memory plugin description"),
+		roles,
+		provides,
+		...requires.length === 0 ? {} : { requires }
+	});
+}
+function validateRoute(route) {
+	const normalized = {
+		id: id(route.id, "memory Source route id"),
+		description: requiredText(route.description, "memory Source route description", 2e3),
+		capability: id(route.capability, "memory Source route capability"),
+		inputSchema: jsonClone(route.inputSchema, "memory Source route input schema"),
+		maxCalls: positiveInteger(route.maxCalls, "memory Source route maxCalls", 100),
+		...route.maxResults === void 0 ? {} : { maxResults: positiveInteger(route.maxResults, "memory Source route maxResults", 1e4) },
+		...route.maxCharacters === void 0 ? {} : { maxCharacters: positiveInteger(route.maxCharacters, "memory Source route maxCharacters", 1e7) }
+	};
+	if (!CAPABILITIES.has(normalized.capability)) throw new Error(`unsupported memory Source route capability: ${normalized.capability}`);
+	return deepFreeze(normalized);
+}
+function validateAction(action) {
+	const normalized = {
+		id: id(action.id, "memory Source action id"),
+		description: requiredText(action.description, "memory Source action description", 2e3),
+		capability: id(action.capability, "memory Source action capability"),
+		inputSchema: jsonClone(action.inputSchema, "memory Source action input schema"),
+		...action.authority === void 0 ? {} : { authority: requiredText(action.authority, "memory Source action authority", 300) }
+	};
+	if (!CAPABILITIES.has(normalized.capability)) throw new Error(`unsupported memory Source action capability: ${normalized.capability}`);
+	return deepFreeze(normalized);
+}
+function defineMemorySource(definition) {
+	const manifest = definition.manifest;
+	if (manifest.apiVersion !== "dsh-mnemon/v1") throw new Error(`unsupported memory Source API: ${String(manifest.apiVersion)}`);
+	if (manifest.kind !== "source") throw new Error("memory Source manifest kind must be source");
+	const typeId = id(manifest.typeId, "memory Source typeId");
+	const packageName = requiredText(manifest.packageName, "memory Source packageName", 214);
+	if (!PACKAGE.test(packageName)) throw new Error(`invalid memory Source packageName: ${packageName}`);
+	const role = id(manifest.role, "memory Source role");
+	if (manifest.consistency !== "exact-snapshot" && manifest.consistency !== "namespace-pinned-live-read") throw new Error(`unsupported memory Source consistency: ${String(manifest.consistency)}`);
+	if (typeof definition.create !== "function") throw new Error(`memory Source create() is required: ${typeId}`);
+	const routes = (manifest.routes ?? []).map(validateRoute);
+	uniqueIds(routes.map((route) => route.id), "memory Source route id");
+	const actions = (manifest.actions ?? []).map(validateAction);
+	uniqueIds(actions.map((action) => action.id), "memory Source action id");
+	const normalizedManifest = jsonClone({
+		...manifest,
+		typeId,
+		packageName,
+		role,
+		capabilities: validateCapabilities(manifest.capabilities, "memory Source capability"),
+		routes,
+		actions
+	}, "memory Source manifest");
+	return Object.freeze({
+		manifest: normalizedManifest,
+		create: definition.create
+	});
+}
+function defineMemoryStrategy(definition) {
+	const manifest = definition.manifest;
+	if (manifest.apiVersion !== "dsh-mnemon/v1") throw new Error(`unsupported memory Strategy API: ${String(manifest.apiVersion)}`);
+	if (manifest.kind !== "strategy") throw new Error("memory Strategy manifest kind must be strategy");
+	const typeId = id(manifest.typeId, "memory Strategy typeId");
+	const packageName = requiredText(manifest.packageName, "memory Strategy packageName", 214);
+	if (!PACKAGE.test(packageName)) throw new Error(`invalid memory Strategy packageName: ${packageName}`);
+	if (manifest.deterministic !== true) throw new Error("memory Strategy must declare deterministic: true");
+	if (typeof definition.compose !== "function") throw new Error(`memory Strategy compose() is required: ${typeId}`);
+	if (definition.createTurn !== void 0 && typeof definition.createTurn !== "function") throw new Error("memory Strategy createTurn must be a function");
+	const normalizedManifest = jsonClone({
+		...manifest,
+		typeId,
+		packageName,
+		supportedSourceRoles: uniqueIds(manifest.supportedSourceRoles, "memory Strategy supported Source role"),
+		maxSources: positiveInteger(manifest.maxSources, "memory Strategy maxSources", 1e3),
+		maxRoutes: positiveInteger(manifest.maxRoutes, "memory Strategy maxRoutes", 1e3),
+		maxActions: positiveInteger(manifest.maxActions, "memory Strategy maxActions", 1e3),
+		...manifest.extensionSlots === void 0 ? {} : { extensionSlots: uniqueIds(manifest.extensionSlots, "memory Strategy extension slot") }
+	}, "memory Strategy manifest");
+	return Object.freeze({
+		manifest: normalizedManifest,
+		compose: definition.compose,
+		...definition.createTurn === void 0 ? {} : { createTurn: definition.createTurn }
+	});
+}
+function defineMemoryStrategyExtension(definition) {
+	const manifest = definition.manifest;
+	if (manifest.apiVersion !== "dsh-mnemon/v1") throw new Error(`unsupported memory Strategy extension API: ${String(manifest.apiVersion)}`);
+	if (manifest.kind !== "strategy-extension") throw new Error("memory Strategy extension kind must be strategy-extension");
+	const packageName = requiredText(manifest.packageName, "memory Strategy extension packageName", 214);
+	if (!PACKAGE.test(packageName)) throw new Error(`invalid memory Strategy extension packageName: ${packageName}`);
+	if (manifest.deterministic !== true) throw new Error("memory Strategy extension must declare deterministic: true");
+	if (typeof definition.contribute !== "function") throw new Error("memory Strategy extension contribute() is required");
+	return Object.freeze({
+		manifest: jsonClone({
+			...manifest,
+			packageName,
+			typeId: id(manifest.typeId, "memory Strategy extension typeId"),
+			strategyTypeId: id(manifest.strategyTypeId, "memory Strategy extension target"),
+			slot: id(manifest.slot, "memory Strategy extension slot")
+		}, "memory Strategy extension manifest"),
+		contribute: definition.contribute
+	});
+}
+//#endregion
+export { defineMemoryStrategy as a, jsonClone as c, uniqueIds as d, validateCapabilities as f, defineMemorySource as i, positiveInteger as l, deepFreeze as n, defineMemoryStrategyExtension as o, validateProvenance as p, defineMemoryPlugin as r, id as s, canonicalMemoryJson as t, requiredText as u };

package/lib/extension-sdk.js

@@ -1,238 +1,102 @@
-//#region packages/extension-sdk/src/index.ts
-const EXTENSION_ID = /^[a-z][a-z0-9-]{0,127}$/u;
-function reverseDispose(disposers) {
-	for (const dispose of disposers.reverse()) dispose();
-}
-function deepFreeze(value) {
-	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
-	for (const child of Object.values(value)) deepFreeze(child);
-	return Object.freeze(value);
-}
-function captureExtension(extension, id) {
-	const layers = extension.layers?.map((registration) => Object.freeze({
-		descriptor: deepFreeze(structuredClone(registration.descriptor)),
-		...registration.execute === void 0 ? {} : { execute: registration.execute }
-	}));
-	const adapters = extension.adapters?.map((registration) => Object.freeze({ descriptor: deepFreeze(structuredClone(registration.descriptor)) }));
-	const strategies = extension.strategies?.map((registration) => Object.freeze({
-		descriptor: deepFreeze(structuredClone(registration.descriptor)),
-		propose: registration.propose
-	}));
-	const sources = extension.sources?.map((source) => Object.freeze({
-		layerId: source.layerId,
-		mode: source.mode,
-		snapshot: source.snapshot
-	}));
-	const guards = extension.guards?.map((guard) => Object.freeze({
-		id: guard.id,
-		decide: guard.decide
-	}));
-	return Object.freeze({
-		descriptor: deepFreeze({
-			...structuredClone(extension.descriptor),
-			id
-		}),
-		...layers === void 0 ? {} : { layers: Object.freeze(layers) },
-		...adapters === void 0 ? {} : { adapters: Object.freeze(adapters) },
-		...strategies === void 0 ? {} : { strategies: Object.freeze(strategies) },
-		...sources === void 0 ? {} : { sources: Object.freeze(sources) },
-		...guards === void 0 ? {} : { guards: Object.freeze(guards) }
-	});
+import { t as withMemoryStorageLock } from "./storage-lock-Bqrhkyag.js";
+import { a as defineMemoryStrategy, i as defineMemorySource, o as defineMemoryStrategyExtension, r as defineMemoryPlugin, t as canonicalMemoryJson } from "./definitions-j0FLgE0-.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/sdk/install.ts
+function stableEntryId(ctx, explicit) {
+	const configured = explicit?.trim();
+	if (configured !== void 0 && configured !== "") return configured;
+	const located = ctx.get("loader", false)?.locate(ctx.fiber)?.trim();
+	if (located !== void 0 && located !== "") return located;
+	const entryId = ctx.fiber.entry?.options?.id;
+	if (typeof entryId === "string" && entryId.trim() !== "") return entryId.trim();
+	throw new Error("installMemory requires a stable Loader Entry id; pass options.instanceId for direct ctx.plugin() mounts");
 }
 /**
-* Minimal Boot assembler for one Host. It applies the same captured extension
-* set to every runtime graph while each graph owns its Catalog, Kernel, and
-* TurnView state. Cordis remains responsible for lifecycle and isolation.
+* Register a plugin's Source and/or Strategy definitions as one Fiber-owned batch.
+* Contribution roles do not dictate package or repository boundaries.
 */
-var MemoryBoot = class {
-	extensions = /* @__PURE__ */ new Map();
-	targets = /* @__PURE__ */ new Set();
-	register(extension) {
-		const id = extension.descriptor.id.trim();
-		if (!EXTENSION_ID.test(id)) throw new Error("memory extension id must match [a-z][a-z0-9-]{0,127}");
-		if (this.extensions.has(id)) throw new Error(`memory extension is already registered: ${id}`);
-		const normalized = captureExtension(extension, id);
-		const applied = [];
-		try {
-			for (const target of this.targets) {
-				target.releases.set(id, this.applyChecked(normalized, target));
-				applied.push(target);
-			}
-		} catch (error) {
-			for (const target of applied.reverse()) {
-				target.releases.get(id)?.();
-				target.releases.delete(id);
-			}
-			throw error;
-		}
-		this.extensions.set(id, normalized);
-		let active = true;
-		return () => {
-			if (!active) return;
-			if (this.extensions.get(id) !== normalized) {
-				active = false;
-				return;
-			}
-			this.unregister(normalized);
-			active = false;
-		};
-	}
-	attach(catalog) {
-		const target = {
-			catalog,
-			releases: /* @__PURE__ */ new Map(),
-			released: false
+function installMemory(ctx, contribution, options = {}) {
+	const entryId = stableEntryId(ctx, options.instanceId);
+	ctx.effect(() => ctx.mnemonMemory.installContributions(contribution, {
+		...options,
+		instanceId: entryId
+	}), `dsh-mnemon: install ${entryId}`);
+}
+//#endregion
+//#region src/sdk/input.ts
+/** Stable digest of validated configuration; raw values never enter diagnostics. */
+function memoryConfigurationDigest(value) {
+	return `config:${createHash("sha256").update(canonicalMemoryJson(value, "memory configuration")).digest("hex")}`;
+}
+function record(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} must be an object`);
+	return value;
+}
+function text(value, label, maximum, required = true) {
+	if (value === void 0 && !required) return void 0;
+	if (typeof value !== "string") throw new Error(`${label} must be a string`);
+	const normalized = value.trim();
+	if (required && normalized === "") throw new Error(`${label} is required`);
+	if (normalized.length > maximum) throw new Error(`${label} is too long (max ${maximum} characters)`);
+	return normalized === "" ? void 0 : normalized;
+}
+function integer(value, fallback, minimum, maximum) {
+	if (value === void 0) return fallback;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < minimum || value > maximum) throw new Error(`value must be an integer within ${minimum}..${maximum}`);
+	return value;
+}
+function stringArray(value, label, maximum = 50) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || value.length > maximum || value.some((item) => typeof item !== "string")) throw new Error(`${label} must be a string array`);
+	return value.map((item) => item.trim()).filter(Boolean);
+}
+function truncate(value, maximum) {
+	if (maximum <= 0) return "";
+	if (value.length <= maximum) return value;
+	let end = maximum - 1;
+	if (end > 0 && /[\uD800-\uDBFF]/u.test(value[end - 1])) end--;
+	return `${value.slice(0, end)}…`;
+}
+function receipt(viewId, offerId, sourceInstanceKey, revision, details, completion = "unknown") {
+	return {
+		id: `receipt:${randomUUID()}`,
+		viewId,
+		offerId,
+		sourceInstanceKey,
+		status: completion === "failed" ? "failed" : completion === "partial" || completion === "unknown" ? "partial" : "succeeded",
+		completion,
+		...completion === "committed" ? { committedAt: (/* @__PURE__ */ new Date()).toISOString() } : {},
+		...revision === void 0 ? {} : { revision },
+		details
+	};
+}
+/** Validate migration proof supplied by an authorized Source management caller. */
+function migrationLineage(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.length > 1e3) throw new Error("lineage must be an array of at most 1000 entries");
+	return value.map((item) => {
+		const entry = record(item, "lineage");
+		const endpoint = (value) => {
+			const fields = record(value, "lineage endpoint");
+			return {
+				layerId: text(fields.layerId, "lineage layerId", 300),
+				reference: text(fields.reference, "lineage reference", 2e3),
+				digest: text(fields.digest, "lineage digest", 300)
+			};
 		};
-		try {
-			for (const extension of this.extensions.values()) target.releases.set(extension.descriptor.id, this.apply(extension, target));
-		} catch (error) {
-			reverseDispose([...target.releases.values()]);
-			throw error;
-		}
-		this.targets.add(target);
 		return {
-			bindKernel: (kernel) => {
-				if (target.released) throw new Error("memory extension attachment is released");
-				if (target.kernel !== void 0) throw new Error("memory extension attachment already has a kernel");
-				target.kernel = kernel;
-				const guardReleases = /* @__PURE__ */ new Map();
-				try {
-					for (const extension of this.extensions.values()) {
-						const disposers = [];
-						try {
-							for (const guard of extension.guards ?? []) disposers.push(kernel.registerGuard(guard));
-							guardReleases.set(extension.descriptor.id, () => reverseDispose(disposers));
-						} catch (error) {
-							reverseDispose(disposers);
-							throw error;
-						}
-					}
-					for (const [id, releaseGuards] of guardReleases) {
-						const releaseCatalog = target.releases.get(id) ?? (() => {});
-						target.releases.set(id, () => {
-							releaseGuards();
-							releaseCatalog();
-						});
-					}
-				} catch (error) {
-					reverseDispose([...guardReleases.values()]);
-					delete target.kernel;
-					throw error;
-				}
-			},
-			bindTurnViews: (manager) => {
-				if (target.released) throw new Error("memory extension attachment is released");
-				if (target.viewManager !== void 0) throw new Error("memory Boot attachment already has a TurnView manager");
-				target.viewManager = manager;
-				const sourceReleases = /* @__PURE__ */ new Map();
-				try {
-					for (const extension of this.extensions.values()) {
-						const disposers = [];
-						try {
-							for (const source of extension.sources ?? []) {
-								if (target.catalog.layer(source.layerId) === void 0) throw new Error(`MemorySource layer is unavailable: ${source.layerId}`);
-								disposers.push(manager.registerSource(source));
-							}
-							sourceReleases.set(extension.descriptor.id, () => reverseDispose(disposers));
-						} catch (error) {
-							reverseDispose(disposers);
-							throw error;
-						}
-					}
-					manager.assertSourcesReady();
-					for (const [id, releaseSources] of sourceReleases) {
-						const releasePrevious = target.releases.get(id) ?? (() => {});
-						target.releases.set(id, () => {
-							releaseSources();
-							releasePrevious();
-						});
-					}
-				} catch (error) {
-					reverseDispose([...sourceReleases.values()]);
-					delete target.viewManager;
-					throw error;
-				}
-			},
-			dispose: () => {
-				if (target.released) return;
-				target.released = true;
-				this.targets.delete(target);
-				reverseDispose([...target.releases.values()]);
-				target.releases.clear();
-			},
-			release: () => {
-				if (target.released) return;
-				target.released = true;
-				this.targets.delete(target);
-				target.releases.clear();
-			}
+			source: endpoint(entry.source),
+			destination: endpoint(entry.destination)
 		};
-	}
-	descriptors() {
-		return [...this.extensions.values()].map((extension) => ({ ...extension.descriptor })).sort((left, right) => left.id.localeCompare(right.id));
-	}
-	apply(extension, target) {
-		const disposers = [];
-		try {
-			for (const layer of extension.layers ?? []) disposers.push(target.catalog.registerLayer(layer));
-			for (const adapter of extension.adapters ?? []) disposers.push(target.catalog.registerAdapter(adapter));
-			for (const strategy of extension.strategies ?? []) disposers.push(target.catalog.registerStrategy(strategy));
-			if (target.kernel !== void 0) for (const guard of extension.guards ?? []) disposers.push(target.kernel.registerGuard(guard));
-			if (target.viewManager !== void 0) for (const source of extension.sources ?? []) {
-				if (target.catalog.layer(source.layerId) === void 0) throw new Error(`MemorySource layer is unavailable: ${source.layerId}`);
-				disposers.push(target.viewManager.registerSource(source));
-			}
-			return () => reverseDispose(disposers);
-		} catch (error) {
-			reverseDispose(disposers);
-			throw error;
-		}
-	}
-	applyChecked(extension, target) {
-		const release = this.apply(extension, target);
-		try {
-			target.viewManager?.assertSourcesReady();
-			return release;
-		} catch (error) {
-			release();
-			throw error;
-		}
-	}
-	/** Remove one global extension from every live graph, or restore it everywhere. */
-	unregister(extension) {
-		const id = extension.descriptor.id;
-		const removed = [];
-		try {
-			for (const target of this.targets) {
-				const release = target.releases.get(id);
-				if (release === void 0) continue;
-				release();
-				target.releases.delete(id);
-				removed.push(target);
-				target.viewManager?.assertSourcesReady();
-			}
-		} catch (error) {
-			const rollbackFailures = [];
-			for (const target of removed.reverse()) try {
-				target.releases.set(id, this.applyChecked(extension, target));
-			} catch (rollbackError) {
-				rollbackFailures.push(rollbackError);
-			}
-			if (rollbackFailures.length > 0) throw new AggregateError([error, ...rollbackFailures], `memory extension ${id} unload failed and could not be fully rolled back`);
-			throw error;
-		}
-		this.extensions.delete(id);
-	}
-};
-function defineMemoryExtension(extension) {
-	return extension;
+	});
 }
-/** Process-global Boot, allowing extensions to contribute before the DSH Host mounts. */
-const memoryBoot = new MemoryBoot();
-/** Compatibility name for the v0.3 pre-release API. */
-const memoryExtensions = memoryBoot;
-function registerMemoryExtension(extension) {
-	return memoryBoot.register(extension);
+//#endregion
+//#region src/sdk/strategy-configuration.ts
+function defineMemoryStrategyConfiguration(value) {
+	return Object.freeze({
+		...value,
+		apiVersion: "dsh-mnemon/strategy-configuration/v1"
+	});
 }
 //#endregion
-export { MemoryBoot, MemoryBoot as MemoryExtensionHost, defineMemoryExtension, memoryBoot, memoryExtensions, registerMemoryExtension };
+export { receipt as createMemoryMutationReceipt, defineMemoryPlugin, defineMemorySource, defineMemoryStrategy, defineMemoryStrategyConfiguration, defineMemoryStrategyExtension, installMemory, memoryConfigurationDigest, integer as memoryInputInteger, migrationLineage as memoryInputMigrationLineage, record as memoryInputRecord, stringArray as memoryInputStringArray, text as memoryInputText, truncate as truncateMemoryText, withMemoryStorageLock };