@camstack/system 1.2.313 → 1.2.315

package/dist/builtins/core-blocks/core-blocks.addon.js

@@ -1,7 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CkRwnhbo.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
+const require_composition_sources = require("../../composition-sources-DYqQLRzF.js");
 let node_crypto = require("node:crypto");
+let _camstack_types_node = require("@camstack/types/node");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_chunk.__toESM(node_fs_promises);
 let node_path = require("node:path");
@@ -340,7 +342,7 @@ var BlockSupervisor = class {
 			for (const { block } of compositions) await this.report(block.id, "failed", "no composer is available on this node — a composition cannot run here");
 			return;
 		}
-		if (runners.find((r) => r.name === "composer")?.state === "failed") {
+		if (runners.find((r) => r.name === require_dist.COMPOSER_RUNNER_ID)?.state === "failed") {
 			for (const { block } of compositions) await this.report(block.id, "failed", "the composer runner's crash circuit-breaker tripped — no composition runs until it is restarted");
 			return;
 		}
@@ -1013,15 +1015,103 @@ function armBlocksIntegration(options) {
 	})() };
 }
 //#endregion
+//#region src/builtins/core-blocks/composition-peers.ts
+/**
+* The stored compositions a save is judged against, as graph peers (D663,
+* ruling S2). Each is identified by its BLOCK ID, targets the device it writes
+* — `composedDeviceRef(block.id)` for a new device, the customized device for an
+* existing one — and, on an existing device, names the fields it REPLACES, so
+* its self-read of a replaced field is the native value and never an edge.
+*
+* `replaced` is not stored anywhere: it is recomputed at save time from the
+* peer's target description (`planComposition(..., target)`), read in the same
+* batch as the candidate's. A peer whose device could not be read has unknown
+* replaced fields: it is OVER-approximated — nothing replaced, every self-read
+* an edge (edges only added, never a cycle hidden) — and its device is listed
+* in `unread`, so the validator refuses a cyclic component only when it holds
+* a candidate node, and names the device (`findCandidateCycles`). An unreadable
+* device never blocks an unrelated save. A peer whose device is GONE is treated
+* the same way (M-1): a stored peer validated earlier may still read it, and
+* assuming every field replaced would remove edges.
+*
+* The candidate's own old version is kept in the list: the graph drops it BY ID
+* (`compositionEdges`), never by target — that is how a second block on
+* the same device reaches `duplicate-target`.
+*/
+function storedCompositions(blocks) {
+	return blocks.flatMap((block) => {
+		const composition = require_dist.coreBlockComposition(block);
+		return composition === null ? [] : [{
+			blockId: block.id,
+			composition
+		}];
+	});
+}
+/** The existing devices the stored customizations write — each read once with the candidate's. */
+function storedCustomizationTargets(blocks) {
+	return storedCompositions(blocks).flatMap(({ composition }) => composition.target.kind === "existing" ? [composition.target.device] : []);
+}
+/** The fields a stored customization replaces, or why they are unknown. */
+function replacedOf(stored, description, lookupCap) {
+	if (description === void 0) return { error: "it was not read" };
+	if (description.kind === "unreadable") return { error: description.error };
+	if (description.kind === "absent") return { error: "the device does not exist" };
+	return require_dist.replacedFieldKeys(require_dist.planComposition(stored.composition, lookupCap, description));
+}
+function peerOf(stored, targets, lookupCap, candidateBlockId) {
+	const { blockId, composition } = stored;
+	if (composition.target.kind === "new") return {
+		peer: {
+			blockId,
+			target: require_dist.composedDeviceRef(blockId),
+			composition
+		},
+		unread: null
+	};
+	const device = composition.target.device;
+	const key = require_dist.compositionSourceKey(device);
+	const replaced = replacedOf(stored, targets.get(key), lookupCap);
+	if (!("error" in replaced)) return {
+		peer: {
+			blockId,
+			target: device,
+			composition,
+			replaced
+		},
+		unread: null
+	};
+	return {
+		peer: {
+			blockId,
+			target: device,
+			composition,
+			replaced: /* @__PURE__ */ new Set()
+		},
+		unread: blockId === candidateBlockId ? null : [key, replaced.error]
+	};
+}
+function storedPeers(blocks, targets, lookupCap, candidateBlockId) {
+	const read = storedCompositions(blocks).map((stored) => peerOf(stored, targets, lookupCap, candidateBlockId));
+	return {
+		peers: read.map((r) => r.peer),
+		unread: new Map(read.flatMap((r) => r.unread === null ? [] : [r.unread]))
+	};
+}
+//#endregion
 //#region src/builtins/core-blocks/composition-api.ts
 /**
 * The composition half of the `core-blocks` provider (D659). Flat methods,
 * spread into the provider: no nested sub-object.
 *
-* Every save is VALIDATED against the live sources and every other stored
-* composition first; a refusal names each problem by path and reason (D391)
-* and stores nothing. The store's own refusals (not loaded, unknown block, a
-* code block) propagate unchanged — this layer never swallows them.
+* Every save is VALIDATED against the live sources, its existing target (read
+* once: slim row + `getBindings`) and every stored composition first; a refusal
+* names each problem by path and reason (D391) and stores nothing. The store's
+* own refusals (not loaded, unknown block, a code block) propagate unchanged —
+* this layer never swallows them.
+*
+* A customization of an existing device (D663) has no name of its own: the
+* server derives it (`customizationBlockName`), refuses one the client sends,
+* and never lets it move to another device. One per device, by block id (S2).
 */
 var NOT_LOADED_REASON = "core_blocks has not loaded yet";
 function writeQueue() {
@@ -1048,24 +1138,30 @@ function refuseIfChanged(deps, blockId, expectedUpdatedAt) {
 	} });
 	throw new Error(`core-blocks: the composition "${stored.name}" changed since you read it: stored updatedAt ${stored.updatedAt}, yours ${expectedUpdatedAt} — reload and re-apply your edit`);
 }
+/** The device a composition writes, when it is an EXISTING one; null for a new device. */
+function existingTarget(composition) {
+	return composition.target.kind === "existing" ? composition.target.device : null;
+}
 async function validateAgainstStore(deps, composition, blockId) {
 	if (!deps.store.isLoaded()) throw new Error(`${NOT_LOADED_REASON} — a composition cannot be judged against the stored ones until it has; retry shortly`);
 	const self = blockId === null ? null : require_dist.composedDeviceRef(blockId);
-	const peers = deps.store.list().flatMap((block) => {
-		const peer = require_dist.coreBlockComposition(block);
-		return peer === null || block.id === blockId ? [] : [{
-			target: require_dist.composedDeviceRef(block.id),
-			composition: peer
-		}];
-	});
-	const selfKey = self === null ? null : require_dist.compositionSourceKey(self);
-	const refs = require_dist.compositionSourceRefs(composition).filter((r) => require_dist.compositionSourceKey(r) !== selfKey);
-	const sources = await deps.describeSources(refs);
+	const target = existingTarget(composition);
+	const ownKeys = new Set([self, target].flatMap((ref) => ref === null ? [] : [require_dist.compositionSourceKey(ref)]));
+	const refs = require_dist.compositionSourceRefs(composition).filter((r) => !ownKeys.has(require_dist.compositionSourceKey(r)));
+	const blocks = deps.store.list();
+	const read = await deps.describe(refs, [...target === null ? [] : [target], ...storedCustomizationTargets(blocks)]);
+	const stored = storedPeers(blocks, read.targets, deps.lookupCap, blockId);
 	return require_dist.validateComposition(composition, {
 		lookupCap: deps.lookupCap,
-		sources,
+		sources: read.sources,
 		self,
-		peers
+		blockId,
+		target: target === null ? null : read.targets.get(require_dist.compositionSourceKey(target)) ?? {
+			kind: "unreadable",
+			error: "it was not read"
+		},
+		peers: stored.peers,
+		unreadTargets: stored.unread
 	});
 }
 function describeProblems(validation) {
@@ -1100,6 +1196,16 @@ async function readStates(deps, blockIds) {
 		}]));
 	}
 }
+/**
+* One block's composer state. A block the answer leaves out is UNREACHABLE,
+* never folded into "no composition" (D315, M-4).
+*/
+async function readState(deps, blockId) {
+	return (await readStates(deps, [blockId])).get(blockId) ?? {
+		kind: "unreachable",
+		error: "the composer state read returned no entry for the block"
+	};
+}
 function toViews(blocks, states) {
 	return blocks.flatMap((block) => {
 		const state = states.get(block.id);
@@ -1109,6 +1215,98 @@ function toViews(blocks, states) {
 		}];
 	});
 }
+var NO_NAME_OF_ITS_OWN = "a customization has no name of its own — the device's name is shown; omit `name`";
+var NEW_DEVICE_NEEDS_NAME = "a new device needs a name";
+var DEVICE_IS_FIXED = "a customization's device cannot be changed — delete it and customize the other device";
+var NEVER_BECOMES_CUSTOMIZATION = "a composed device cannot become the customization of another device — create the customization instead";
+/**
+* The numeric id of a save's existing target, for the refusal line's tag
+* (D391: a line about a device carries `tags.deviceId`). Read only on a
+* refusal — one listing — and a failed read names itself on the line instead.
+*/
+async function resolveTarget(deps, target) {
+	try {
+		const found = (await deps.describe([], [target])).targets.get(require_dist.compositionSourceKey(target));
+		if (found?.kind === "found") return {
+			kind: "device",
+			deviceId: found.deviceId
+		};
+		return {
+			kind: "unresolved",
+			why: found?.kind ?? "not described"
+		};
+	} catch (err) {
+		return {
+			kind: "unresolved",
+			why: require_dist.errMsg(err)
+		};
+	}
+}
+/** A save refused before validation, by name (D391): logged, then thrown. */
+async function refuseSave(deps, subject, target, reason) {
+	const resolved = target === null ? null : await resolveTarget(deps, target);
+	deps.logger.warn("composition save refused", {
+		...resolved?.kind === "device" ? { tags: { deviceId: resolved.deviceId } } : {},
+		meta: {
+			name: subject.name,
+			blockId: subject.blockId,
+			target: target === null ? null : require_dist.compositionSourceKey(target),
+			...resolved?.kind === "unresolved" ? { targetUnresolved: resolved.why } : {},
+			reason
+		}
+	});
+	throw new Error(`core-blocks: the composition "${subject.name}" was refused — ${reason}`);
+}
+/**
+* The name a new block is stored under (rule 1): a new device's own, required;
+* a customization's DERIVED from its device (ruling S2), never the client's.
+*/
+async function nameOnCreate(deps, block) {
+	const target = existingTarget(block.composition);
+	if (target === null) {
+		if (block.name === void 0) return refuseSave(deps, {
+			name: "(unnamed)",
+			blockId: null
+		}, null, NEW_DEVICE_NEEDS_NAME);
+		return block.name;
+	}
+	if (block.name !== void 0) return refuseSave(deps, {
+		name: block.name,
+		blockId: null
+	}, target, NO_NAME_OF_ITS_OWN);
+	return (0, _camstack_types_node.customizationBlockName)(target);
+}
+/**
+* A customization is pinned to its device and carries no client name (rule 2);
+* a composed device never turns into one — its name would be the client's. An
+* unknown or code block falls through to the store, whose refusal names it.
+*/
+async function refuseRetarget(deps, blockId, patch) {
+	const stored = deps.store.get(blockId);
+	const current = stored === null ? null : require_dist.coreBlockComposition(stored);
+	if (stored === null || current === null) return;
+	const subject = {
+		name: stored.name,
+		blockId
+	};
+	const pinned = existingTarget(current);
+	const next = patch.composition === void 0 ? pinned : existingTarget(patch.composition);
+	if (pinned === null) {
+		if (next !== null) return refuseSave(deps, subject, next, NEVER_BECOMES_CUSTOMIZATION);
+		return;
+	}
+	if (patch.name !== void 0) return refuseSave(deps, subject, pinned, NO_NAME_OF_ITS_OWN);
+	if (next === null || require_dist.compositionSourceKey(next) !== require_dist.compositionSourceKey(pinned)) return refuseSave(deps, subject, pinned, DEVICE_IS_FIXED);
+}
+/** The block customizing `device`, found by TARGET — never by its derived name (rule 4). */
+function customizationOf(blocks, device) {
+	const key = require_dist.compositionSourceKey(device);
+	return blocks.find((block) => {
+		const composition = require_dist.coreBlockComposition(block);
+		const target = composition === null ? null : existingTarget(composition);
+		return target !== null && require_dist.compositionSourceKey(target) === key;
+	}) ?? null;
+}
 /**
 * Every write runs validate-then-persist on ONE chain. Validation awaits a
 * source read before the save lands; two unserialized saves (A reads B, B
@@ -1119,12 +1317,16 @@ function buildCompositionApi(deps) {
 	const serialized = writeQueue();
 	return {
 		createComposition: ({ block, caller }) => serialized(async () => {
+			const name = await nameOnCreate(deps, block);
 			const validation = await validateAgainstStore(deps, block.composition, null);
 			if (!validation.ok) refuse(deps, {
-				name: block.name,
+				name,
 				blockId: null
 			}, validation);
-			const created = await deps.store.createComposition(block, caller.userId);
+			const created = await deps.store.createComposition({
+				...block,
+				name
+			}, caller.userId);
 			deps.logger.info("composition created", { meta: {
 				blockId: created.id,
 				name: created.name,
@@ -1135,6 +1337,7 @@ function buildCompositionApi(deps) {
 		}),
 		updateComposition: ({ blockId, expectedUpdatedAt, block, caller }) => serialized(async () => {
 			refuseIfChanged(deps, blockId, expectedUpdatedAt);
+			await refuseRetarget(deps, blockId, block);
 			if (block.composition !== void 0) {
 				const validation = await validateAgainstStore(deps, block.composition, blockId);
 				if (!validation.ok) refuse(deps, {
@@ -1160,10 +1363,12 @@ function buildCompositionApi(deps) {
 				state: "loaded",
 				view: null
 			};
-			const [view] = toViews([block], await readStates(deps, [blockId]));
 			return {
 				state: "loaded",
-				view: view ?? null
+				view: {
+					block,
+					state: await readState(deps, blockId)
+				}
 			};
 		},
 		listCompositions: async () => {
@@ -1181,61 +1386,31 @@ function buildCompositionApi(deps) {
 				views: toViews(blocks, await readStates(deps, blocks.map((b) => b.id)))
 			};
 		},
+		getCustomization: async ({ addonId, stableId }) => {
+			if (!deps.store.isLoaded()) return {
+				state: "not-loaded",
+				reason: NOT_LOADED_REASON
+			};
+			const block = customizationOf(deps.store.list(), {
+				addonId,
+				stableId
+			});
+			if (block === null) return {
+				state: "loaded",
+				view: null
+			};
+			return {
+				state: "loaded",
+				view: {
+					block,
+					state: await readState(deps, block.id)
+				}
+			};
+		},
 		validateComposition: async ({ composition, blockId }) => validateAgainstStore(deps, composition, blockId ?? null)
 	};
 }
 //#endregion
-//#region src/builtins/core-blocks/composition-sources.ts
-/**
-* Describe a composition's sources for SAVE-time validation (D659): one
-* `listAll` per owning addon, one `getBindings` per found device. A read that
-* fails makes the source `unreadable`, and the save is REFUSED rather than
-* stored unchecked. Refusing a save destroys nothing (D49).
-*
-* Sources are keyed by `{addonId, stableId}` — never a numeric device id,
-* which is this node's allocation and not the composition's identity.
-*/
-async function listOwners(ports, refs) {
-	const addons = [...new Set(refs.map((r) => r.addonId))];
-	const listed = await Promise.all(addons.map(async (addonId) => {
-		try {
-			return [addonId, await ports.listByAddon(addonId)];
-		} catch (err) {
-			return [addonId, { error: require_dist.errMsg(err) }];
-		}
-	}));
-	return new Map(listed);
-}
-async function describeOne(ports, ref, listing) {
-	if (listing === void 0) return {
-		kind: "unreadable",
-		error: `\`${ref.addonId}\` was not listed`
-	};
-	if ("error" in listing) return {
-		kind: "unreadable",
-		error: listing.error
-	};
-	const row = listing.find((r) => r.stableId === ref.stableId);
-	if (row === void 0) return { kind: "absent" };
-	try {
-		return {
-			kind: "found",
-			deviceId: row.id,
-			caps: new Set(await ports.boundCaps(row.id))
-		};
-	} catch (err) {
-		return {
-			kind: "unreadable",
-			error: require_dist.errMsg(err)
-		};
-	}
-}
-async function describeCompositionSources(ports, refs) {
-	const owners = await listOwners(ports, refs);
-	const described = await Promise.all(refs.map(async (ref) => [require_dist.compositionSourceKey(ref), await describeOne(ports, ref, owners.get(ref.addonId))]));
-	return new Map(described);
-}
-//#endregion
 //#region src/builtins/core-blocks/core-blocks.addon.ts
 /**
 * The `core-blocks` provider — CRUD over user-authored TypeScript, with the
@@ -1507,9 +1682,10 @@ var CoreBlocksAddon = class extends require_dist.BaseAddon {
 		};
 	}
 	/**
-	* The composition methods (D659), flat. Sources are read over `ctx.api` at
-	* SAVE time — one listing per owning addon, one binding read per found
-	* device — and a read that fails refuses the save rather than skipping it.
+	* The composition methods (D659), flat. Sources and existing targets are read
+	* over `ctx.api` at SAVE time — one slim listing per owning addon, one binding
+	* read per found device — and a read that fails refuses the save rather than
+	* skipping it.
 	*/
 	buildCompositionApi() {
 		const requireApi = () => {
@@ -1519,13 +1695,13 @@ var CoreBlocksAddon = class extends require_dist.BaseAddon {
 		};
 		return buildCompositionApi({
 			store: this.requireStore(),
-			describeSources: (refs) => describeCompositionSources({
+			describe: (sources, targets) => require_composition_sources.describeCompositionSources({
 				listByAddon: async (addonId) => requireApi().deviceManager.listAll.query({
 					addonId,
 					projection: "slim"
 				}),
-				boundCaps: async (deviceId) => (await requireApi().deviceManager.getBindings.query({ deviceId })).entries.map((e) => e.capName)
-			}, refs),
+				bindings: async (deviceId) => (await requireApi().deviceManager.getBindings.query({ deviceId })).entries
+			}, sources, targets),
 			lookupCap: require_dist.buildCapabilityLookup(require_dist.ALL_CAPABILITY_DEFINITIONS),
 			composerStates: async (blockIds) => (await requireApi().composer.getStates.query({ blockIds: [...blockIds] })).states,
 			convergeSoon: () => this.convergeSoon(),