@camstack/system 1.2.316 → 1.2.318

package/dist/builtins/composer/composer.addon.js

@@ -3,9 +3,9 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-RAl10EfG.js");
+const require_dist = require("../../dist-Dcy0gVHu.js");
 const require_device_state_changed = require("../../device-state-changed-Bk7cvTnz.js");
-const require_composition_sources = require("../../composition-sources-BwE1POnF.js");
+const require_composition_sources = require("../../composition-sources-BjRPhWtU.js");
 //#region src/builtins/composer/composed-device.ts
 /**
 * A composed device: an ordinary `BaseDevice` whose caps are served by the
@@ -630,88 +630,6 @@ function logPlanTransition(logger, previous, p, liveTags) {
 	else logger.warn(p.declaration === null ? "composition does not plan — no device is declared for it" : "composition no longer plans — its device is kept offline with no capabilities", extras);
 }
 //#endregion
-//#region src/builtins/composer/slice-assembler.ts
-/**
-* From the runtime's flat field values to the slice a target takes (D663).
-*
-* A top-level field is written under its path. An item leaf
-* (`consumables.items[desiccant].remaining.value`) is one entry of an ARRAY:
-* every leaf of one item is grouped by `(cap, arrayPath, key)` and set, by
-* path segment, onto the cap's OWN `status.itemArray.emptyItem` — so an
-* unsourced nullable leaf is `null` because the cap says so, not because this
-* module guessed. The key, the label and {@link COMPOSED_ITEM_FIXED_FIELDS}
-* are the composer's; items are sorted by key so two writes of the same
-* values are one slice.
-*
-* A cap the lookup does not know as an item array cannot be assembled: that
-* is thrown by name, and the runtime's write path turns a throw into a named,
-* retried failure — never a half-built array.
-*/
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** `setPath(item, ['remaining', 'value'], 0)` → `{ ...item, remaining: { ...item.remaining, value: 0 } }`. */
-function setPath(record, segments, value) {
-	const [head, ...rest] = segments;
-	if (head === void 0) return record;
-	if (rest.length === 0) return {
-		...record,
-		[head]: value
-	};
-	const current = record[head];
-	return {
-		...record,
-		[head]: setPath(isRecord$1(current) ? current : {}, rest, value)
-	};
-}
-function itemArrayOf(group, lookupCap) {
-	const itemArray = lookupCap(group.cap)?.status?.itemArray;
-	if (itemArray === void 0 || itemArray.path !== group.arrayPath) throw new Error(`\`${group.cap}\` has no item array at \`${group.arrayPath}\` — \`${require_dist.compositionItemFieldPath(group.arrayPath, group.key, "*")}\` cannot be assembled`);
-	return itemArray;
-}
-function assembleItem(group, lookupCap) {
-	const itemArray = itemArrayOf(group, lookupCap);
-	const base = {
-		...itemArray.emptyItem,
-		[itemArray.keyField]: group.key,
-		...itemArray.labelField === void 0 ? {} : { [itemArray.labelField]: group.label },
-		...require_dist.COMPOSED_ITEM_FIXED_FIELDS
-	};
-	return group.leaves.reduce((item, leaf) => setPath(item, leaf.plan.path.split("."), leaf.value), base);
-}
-function groupItems(entries) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const item = entry.plan.item;
-		if (item === void 0) continue;
-		const id = `${entry.plan.cap}\u0000${item.arrayPath}\u0000${item.key}`;
-		const group = groups.get(id) ?? {
-			cap: entry.plan.cap,
-			arrayPath: item.arrayPath,
-			key: item.key,
-			label: item.label,
-			leaves: []
-		};
-		groups.set(id, {
-			...group,
-			leaves: [...group.leaves, entry]
-		});
-	}
-	return [...groups.values()];
-}
-function compareKeys(a, b) {
-	return a < b ? -1 : a > b ? 1 : 0;
-}
-function assembleSlice(entries, lookupCap) {
-	const top = Object.fromEntries(entries.filter((e) => e.plan.item === void 0).map((e) => [e.plan.path, e.value]));
-	const groups = groupItems(entries);
-	const arrays = [...new Set(groups.map((g) => g.arrayPath))].map((arrayPath) => [arrayPath, groups.filter((g) => g.arrayPath === arrayPath).toSorted((a, b) => compareKeys(a.key, b.key)).map((g) => assembleItem(g, lookupCap))]);
-	return {
-		...top,
-		...Object.fromEntries(arrays)
-	};
-}
-//#endregion
 //#region src/builtins/composer/field-record.ts
 /**
 * One composed field's record and the pure judgements over it (D659, D663):
@@ -724,11 +642,11 @@ var NO_FIELDS = /* @__PURE__ */ new Set();
 function fieldKey(plan) {
 	return require_dist.compositionFieldKey(plan);
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function valueAtPath$1(value, path) {
-	return path.split(".").reduce((node, segment) => isRecord(node) ? node[segment] : void 0, value);
+	return path.split(".").reduce((node, segment) => isRecord$1(node) ? node[segment] : void 0, value);
 }
 function initialValue(plan, byCap, lookupCap) {
 	const slice = byCap?.get(plan.cap);
@@ -739,7 +657,7 @@ function initialValue(plan, byCap, lookupCap) {
 	if (itemArray === void 0 || itemArray.path !== item.arrayPath) return void 0;
 	const entries = valueAtPath$1(slice, item.arrayPath);
 	if (!Array.isArray(entries)) return void 0;
-	return valueAtPath$1(entries.find((entry) => isRecord(entry) && entry[itemArray.keyField] === item.key), plan.path);
+	return valueAtPath$1(entries.find((entry) => isRecord$1(entry) && entry[itemArray.keyField] === item.key), plan.path);
 }
 function createFieldRecord(plan, byCap, lookupCap) {
 	const initial = initialValue(plan, byCap, lookupCap);
@@ -820,6 +738,283 @@ function pendingReason(cap, pending) {
 	return pending.kind === "refused" ? `the \`${cap}\` capability refused the value: ${pending.error}` : `writing the \`${cap}\` capability threw: ${pending.error}`;
 }
 //#endregion
+//#region src/builtins/composer/own-field-reads.ts
+/** Derived fields before accumulators: a count reads the value its own pass just computed. */
+var EVALUATION_ORDER = {
+	derived: 0,
+	accumulator: 1
+};
+/** `keys` in evaluation order: derived, then accumulators, then the rest; stable within a rank. */
+function orderForEvaluation(keys, records) {
+	const rank = (k) => EVALUATION_ORDER[records.get(k)?.plan.role ?? ""] ?? 2;
+	return [...keys].toSorted((a, b) => rank(a) - rank(b));
+}
+/**
+* The own field `key` as the runtime holds it right now (`records`: the pass in
+* progress) — exactly what the runtime PUBLISHES for it, which is what the hub
+* answered before (review H1). An unavailable field under the `null` or
+* `unknown` policy is published as `null` / `'unknown'`, so a reader sees that
+* value; only a field nothing is written for (`release`, `offline`) reads as
+* unavailable. Answering those as unavailable left `count` unprimed while a
+* source was late at boot, and it then swallowed the first press as its seed.
+*
+* Not evaluated yet is unavailable: nothing is published, and unknown is never
+* `null` (D393). The evaluation order makes this unreachable for a derived
+* reader of a derived field. Never fatal here: a gone source fails the block
+* through the field that reads it directly.
+*/
+function ownFieldReading(records, key) {
+	const record = records.get(key);
+	const outcome = record?.outcome ?? null;
+	if (record === void 0 || outcome === null) return {
+		state: "unavailable",
+		reason: `own field \`${key}\` not evaluated yet`,
+		fatal: false
+	};
+	if (outcome.state === "unavailable") {
+		const published = writable(record);
+		if (published !== void 0) return {
+			state: "fresh",
+			value: published
+		};
+		return {
+			state: "unavailable",
+			reason: `own field \`${key}\`: ${outcome.reason}`,
+			fatal: false,
+			...outcome.confirmed === true ? { confirmed: true } : {}
+		};
+	}
+	if (outcome.state === "stale") return {
+		state: "stale",
+		value: outcome.value,
+		reason: `own field \`${key}\`: ${outcome.reason ?? "stale"}`
+	};
+	return {
+		state: "fresh",
+		value: outcome.value
+	};
+}
+//#endregion
+//#region src/builtins/composer/composition-evaluation.ts
+/**
+* Evaluating a composition's fields (D659, D670): one pass over the keys a
+* change affects, the own-field readers it must re-run (D670 amendment), and
+* the state-derived events it emits. Split from `composition-runtime.ts`,
+* which owns the records and hands them in through {@link EvaluationHost}.
+*
+* - Stateful expression memory commits only when the whole expression
+*   succeeds.
+* - A declared state-derived event advances its high-water and is emitted
+*   BEFORE the corresponding target write; the committed records are visible
+*   to a synchronous subscriber first.
+* - Derived fields are evaluated before accumulators, and every field reading
+*   an own field that changed is re-evaluated in the same pass.
+*/
+function strictFiniteAdvance(previous, next) {
+	return typeof next === "number" && Number.isFinite(next) && (previous === null || next > previous);
+}
+/** The record key an own read is answered from; null when `read` is a source's. */
+function ownKeyOf(host, read) {
+	if (host.isOwnRead === void 0 || !host.isOwnRead(read)) return null;
+	const key = `${read.cap}.${read.fieldPath}`;
+	return host.records().has(key) ? key : null;
+}
+/**
+* `keys`, derived before accumulators, then — in the same pass — every
+* derived/accumulator field that reads an own field that changed. Bounded by
+* the record count: the validator refuses a cycle, so a chain is at most that
+* long (D6).
+*/
+function evaluateWithOwnReaders(host, keys, now) {
+	const changed = /* @__PURE__ */ new Set();
+	const valueCaps = /* @__PURE__ */ new Set();
+	let round = orderForEvaluation(keys, host.records());
+	for (let hop = 0; round.length > 0 && hop <= host.records().size; hop++) {
+		const delta = evaluateFields(host, round, now);
+		for (const k of delta.keys) changed.add(k);
+		for (const c of delta.valueCaps) valueCaps.add(c);
+		round = orderForEvaluation([...host.records().values()].filter((r) => (r.plan.role === "derived" || r.plan.role === "accumulator") && r.plan.reads.some((read) => {
+			const own = ownKeyOf(host, read);
+			return own !== null && delta.keys.has(own);
+		})).map((r) => fieldKey(r.plan)), host.records());
+	}
+	return {
+		keys: changed,
+		valueCaps
+	};
+}
+/** Evaluate `keys` in order against the records in progress; commit whatever was evaluated, even on a throw. */
+function evaluateFields(host, keys, now) {
+	const changed = /* @__PURE__ */ new Set();
+	const valueCaps = /* @__PURE__ */ new Set();
+	const next = new Map(host.records());
+	const read = (r) => {
+		const own = ownKeyOf(host, r);
+		return own === null ? host.read(r) : ownFieldReading(next, own);
+	};
+	try {
+		for (const key of keys) {
+			const record = next.get(key);
+			if (record === void 0) continue;
+			const candidateMemory = require_dist.cloneStatefulExpressionMemory(record.expressionMemory);
+			const outcome = require_dist.evaluateCompositionField({
+				source: record.plan.source,
+				read,
+				now,
+				stateful: {
+					currentOutput: currentOutput(record),
+					expressionMemory: candidateMemory,
+					startedAtMs: host.startedAtMs,
+					callPathPrefix: fieldKey(record.plan)
+				}
+			});
+			const expressionSucceeded = outcome.state !== "unavailable";
+			let evaluated = {
+				...record,
+				outcome,
+				...expressionSucceeded ? { expressionMemory: candidateMemory } : {}
+			};
+			const eventPlans = host.eventPlans.filter((eventPlan) => eventPlan.fieldKey === fieldKey(record.plan));
+			if (expressionSucceeded && eventPlans.length > 0 && strictFiniteAdvance(record.eventHighWater, outcome.value)) {
+				const timestamp = outcome.value;
+				evaluated = {
+					...evaluated,
+					eventHighWater: timestamp
+				};
+				next.set(key, evaluated);
+				host.commit(next);
+				for (const eventPlan of eventPlans) host.emit(eventPlan, timestamp);
+			} else next.set(key, evaluated);
+			if (sameOutcome(record.outcome, outcome)) continue;
+			if (record.outcome?.state !== outcome.state) host.logTransition(record, outcome);
+			if (valueOf(record.outcome) !== valueOf(outcome)) valueCaps.add(record.plan.cap);
+			changed.add(key);
+		}
+	} finally {
+		host.commit(next);
+	}
+	return {
+		keys: changed,
+		valueCaps
+	};
+}
+/** Emit one state-derived event; a delivery failure is logged, never thrown (D670). */
+function emitStateDerivedEvent(ctx, plan, timestamp) {
+	const extras = {
+		tags: { deviceId: ctx.deviceId },
+		meta: {
+			blockId: ctx.blockId,
+			cap: plan.cap,
+			eventName: plan.eventName,
+			category: plan.category,
+			timestamp
+		}
+	};
+	try {
+		if (plan.category !== require_dist.EventCategory.DoorbellOnPressed) throw new Error(`unsupported state-derived event category \`${plan.category}\``);
+		const event = require_dist.createEvent(require_dist.EventCategory.DoorbellOnPressed, {
+			type: "device",
+			id: ctx.deviceId,
+			deviceId: ctx.deviceId
+		}, {
+			deviceId: ctx.deviceId,
+			timestamp
+		});
+		ctx.events.emit(event);
+		ctx.logger.debug("composition: state-derived event emitted", extras);
+	} catch (error) {
+		ctx.logger.warn("composition: state-derived event delivery failed", {
+			...extras,
+			meta: {
+				...extras.meta,
+				error: errorText(error)
+			}
+		});
+	}
+}
+//#endregion
+//#region src/builtins/composer/slice-assembler.ts
+/**
+* From the runtime's flat field values to the slice a target takes (D663).
+*
+* A top-level field is written under its path. An item leaf
+* (`consumables.items[desiccant].remaining.value`) is one entry of an ARRAY:
+* every leaf of one item is grouped by `(cap, arrayPath, key)` and set, by
+* path segment, onto the cap's OWN `status.itemArray.emptyItem` — so an
+* unsourced nullable leaf is `null` because the cap says so, not because this
+* module guessed. The key, the label and {@link COMPOSED_ITEM_FIXED_FIELDS}
+* are the composer's; items are sorted by key so two writes of the same
+* values are one slice.
+*
+* A cap the lookup does not know as an item array cannot be assembled: that
+* is thrown by name, and the runtime's write path turns a throw into a named,
+* retried failure — never a half-built array.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** `setPath(item, ['remaining', 'value'], 0)` → `{ ...item, remaining: { ...item.remaining, value: 0 } }`. */
+function setPath(record, segments, value) {
+	const [head, ...rest] = segments;
+	if (head === void 0) return record;
+	if (rest.length === 0) return {
+		...record,
+		[head]: value
+	};
+	const current = record[head];
+	return {
+		...record,
+		[head]: setPath(isRecord(current) ? current : {}, rest, value)
+	};
+}
+function itemArrayOf(group, lookupCap) {
+	const itemArray = lookupCap(group.cap)?.status?.itemArray;
+	if (itemArray === void 0 || itemArray.path !== group.arrayPath) throw new Error(`\`${group.cap}\` has no item array at \`${group.arrayPath}\` — \`${require_dist.compositionItemFieldPath(group.arrayPath, group.key, "*")}\` cannot be assembled`);
+	return itemArray;
+}
+function assembleItem(group, lookupCap) {
+	const itemArray = itemArrayOf(group, lookupCap);
+	const base = {
+		...itemArray.emptyItem,
+		[itemArray.keyField]: group.key,
+		...itemArray.labelField === void 0 ? {} : { [itemArray.labelField]: group.label },
+		...require_dist.COMPOSED_ITEM_FIXED_FIELDS
+	};
+	return group.leaves.reduce((item, leaf) => setPath(item, leaf.plan.path.split("."), leaf.value), base);
+}
+function groupItems(entries) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const item = entry.plan.item;
+		if (item === void 0) continue;
+		const id = `${entry.plan.cap}\u0000${item.arrayPath}\u0000${item.key}`;
+		const group = groups.get(id) ?? {
+			cap: entry.plan.cap,
+			arrayPath: item.arrayPath,
+			key: item.key,
+			label: item.label,
+			leaves: []
+		};
+		groups.set(id, {
+			...group,
+			leaves: [...group.leaves, entry]
+		});
+	}
+	return [...groups.values()];
+}
+function compareKeys(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function assembleSlice(entries, lookupCap) {
+	const top = Object.fromEntries(entries.filter((e) => e.plan.item === void 0).map((e) => [e.plan.path, e.value]));
+	const groups = groupItems(entries);
+	const arrays = [...new Set(groups.map((g) => g.arrayPath))].map((arrayPath) => [arrayPath, groups.filter((g) => g.arrayPath === arrayPath).toSorted((a, b) => compareKeys(a.key, b.key)).map((g) => assembleItem(g, lookupCap))]);
+	return {
+		...top,
+		...Object.fromEntries(arrays)
+	};
+}
+//#endregion
 //#region src/builtins/composer/composition-runtime.ts
 /**
 * One running composition: per-field state, writes to the composed device, and
@@ -868,10 +1063,11 @@ function pendingReason(cap, pending) {
 *   not land through `onAsyncFailure`: the cap is marked write-pending by name
 *   and re-written whole on the next pass — no retry timer (D3).
 *
-* Slice 2b (D670): stateful expression memory commits only when the whole
-* expression succeeds. A declared state-derived event advances its seeded
-* high-water and is emitted before the corresponding target write; neither an
-* event-bus failure nor a refused write can replay the event.
+* Slice 2b (D670): evaluation — stateful memory, state-derived events before
+* their write, and reads of the composition's OWN fields answered from the
+* records rather than the hub (D670 amendment) — is `composition-evaluation.ts`.
+* Neither an event-bus failure nor a refused write can replay an event, and the
+* hub's echo of the runtime's own write re-runs nothing.
 */
 /**
 * A refusal nothing on this side can retry away: another owner holds the
@@ -884,9 +1080,6 @@ var TERMINAL_REFUSALS = new Set([
 	"invalid-slice",
 	"unknown-device"
 ]);
-function strictFiniteAdvance(previous, next) {
-	return typeof next === "number" && Number.isFinite(next) && (previous === null || next > previous);
-}
 var CompositionRuntime = class {
 	deps;
 	records;
@@ -910,11 +1103,31 @@ var CompositionRuntime = class {
 	releaseFlaps = /* @__PURE__ */ new Map();
 	/** Caps the target refused for good (`TERMINAL_REFUSALS`): never written again by this runtime. */
 	terminal = /* @__PURE__ */ new Map();
+	/** What `composition-evaluation.ts` reads and commits through. */
+	evaluation;
 	constructor(deps) {
 		this.deps = deps;
 		this.startedAtMs = deps.now();
 		this.records = new Map(deps.fields.map((plan) => [fieldKey(plan), createFieldRecord(plan, deps.initialByCap, deps.lookupCap)]));
 		deps.target.onAsyncFailure?.((cap, failure) => this.onTargetWriteFailed(cap, failure));
+		const eventContext = {
+			deviceId: deps.target.id,
+			blockId: deps.blockId,
+			events: deps.events,
+			logger: deps.logger
+		};
+		this.evaluation = {
+			records: () => this.records,
+			commit: (records) => {
+				this.records = records;
+			},
+			read: deps.read,
+			...deps.isOwnRead === void 0 ? {} : { isOwnRead: deps.isOwnRead },
+			eventPlans: deps.eventPlans,
+			startedAtMs: this.startedAtMs,
+			emit: (plan, timestamp) => emitStateDerivedEvent(eventContext, plan, timestamp),
+			logTransition: (record, outcome) => this.logTransition(record, outcome)
+		};
 	}
 	start() {
 		if (this.disabledReason !== null) return;
@@ -923,7 +1136,7 @@ var CompositionRuntime = class {
 	onSourcesChanged(sliceKeys) {
 		if (this.disabledReason !== null) return;
 		this.guarded("source", true, () => {
-			const affected = [...this.records.values()].filter((r) => r.plan.reads.some((read) => sliceKeys.has(require_dist.compositionSliceKey(read.source, read.cap)))).map((r) => fieldKey(r.plan));
+			const affected = [...this.records.values()].filter((r) => r.plan.reads.some((read) => ownKeyOf(this.evaluation, read) === null && sliceKeys.has(require_dist.compositionSliceKey(read.source, read.cap)))).map((r) => fieldKey(r.plan));
 			if (affected.length > 0) this.pass(affected, "source");
 		});
 	}
@@ -1072,12 +1285,12 @@ var CompositionRuntime = class {
 	pass(keys, trigger) {
 		const initial = trigger === "start";
 		const now = this.deps.now();
-		const calculated = this.evaluate(keys.filter((k) => {
+		const calculated = evaluateWithOwnReaders(this.evaluation, keys.filter((k) => {
 			const role = this.records.get(k)?.plan.role;
 			return role === "derived" || role === "accumulator";
 		}), now);
 		const followers = [...this.records.values()].filter((r) => r.plan.role === "clock" ? initial || calculated.valueCaps.has(r.plan.cap) : r.plan.role === "constant" && initial).map((r) => fieldKey(r.plan));
-		const extra = this.evaluate(followers, now);
+		const extra = evaluateFields(this.evaluation, followers, now);
 		const evaluatedCaps = new Set([...keys, ...followers].flatMap((k) => {
 			const cap = this.records.get(k)?.plan.cap;
 			return cap === void 0 ? [] : [cap];
@@ -1087,89 +1300,6 @@ var CompositionRuntime = class {
 		this.updateFailure();
 		this.updateAvailability();
 	}
-	evaluate(keys, now) {
-		const changed = /* @__PURE__ */ new Set();
-		const valueCaps = /* @__PURE__ */ new Set();
-		const next = new Map(this.records);
-		try {
-			for (const key of keys) {
-				const record = next.get(key);
-				if (record === void 0) continue;
-				const candidateMemory = require_dist.cloneStatefulExpressionMemory(record.expressionMemory);
-				const outcome = require_dist.evaluateCompositionField({
-					source: record.plan.source,
-					read: this.deps.read,
-					now,
-					stateful: {
-						currentOutput: currentOutput(record),
-						expressionMemory: candidateMemory,
-						startedAtMs: this.startedAtMs,
-						callPathPrefix: fieldKey(record.plan)
-					}
-				});
-				const expressionSucceeded = outcome.state !== "unavailable";
-				let evaluated = {
-					...record,
-					outcome,
-					...expressionSucceeded ? { expressionMemory: candidateMemory } : {}
-				};
-				const eventPlans = this.deps.eventPlans.filter((eventPlan) => eventPlan.fieldKey === fieldKey(record.plan));
-				if (expressionSucceeded && eventPlans.length > 0 && strictFiniteAdvance(record.eventHighWater, outcome.value)) {
-					const timestamp = outcome.value;
-					evaluated = {
-						...evaluated,
-						eventHighWater: timestamp
-					};
-					next.set(key, evaluated);
-					this.records = next;
-					for (const eventPlan of eventPlans) this.emitStateEvent(eventPlan, timestamp);
-				} else next.set(key, evaluated);
-				if (sameOutcome(record.outcome, outcome)) continue;
-				if (record.outcome?.state !== outcome.state) this.logTransition(record, outcome);
-				if (valueOf(record.outcome) !== valueOf(outcome)) valueCaps.add(record.plan.cap);
-				changed.add(key);
-			}
-		} finally {
-			this.records = next;
-		}
-		return {
-			keys: changed,
-			valueCaps
-		};
-	}
-	emitStateEvent(plan, timestamp) {
-		const extras = {
-			tags: { deviceId: this.deps.target.id },
-			meta: {
-				blockId: this.deps.blockId,
-				cap: plan.cap,
-				eventName: plan.eventName,
-				category: plan.category,
-				timestamp
-			}
-		};
-		try {
-			if (plan.category !== require_dist.EventCategory.DoorbellOnPressed) throw new Error(`unsupported state-derived event category \`${plan.category}\``);
-			const event = require_dist.createEvent(require_dist.EventCategory.DoorbellOnPressed, {
-				type: "device",
-				id: this.deps.target.id,
-				deviceId: this.deps.target.id
-			}, {
-				deviceId: this.deps.target.id,
-				timestamp
-			});
-			this.deps.events.emit(event);
-			this.deps.logger.debug("composition: state-derived event emitted", extras);
-		} catch (error) {
-			this.deps.logger.warn("composition: state-derived event delivery failed", {
-				...extras,
-				meta: {
-					...extras.meta,
-					error: errorText(error)
-				}
-			});
-		}
-	}
 	recordsOf(cap) {
 		return [...this.records.values()].filter((r) => r.plan.cap === cap);
 	}
@@ -1533,6 +1663,29 @@ var ConfirmedSeed = class {
 *   (`HeldClaims`, C-1).
 */
 /**
+* Review M3: an ADDED `restored` cap seeded from NOTHING says so, once per
+* runtime build, on its device. After a restart its state comes from the
+* target's runtime-state row; a row that lost the slice (D677: 615's doorbell,
+* dropped at a hub boot) used to surface as "not seeded yet" and now seeds a
+* clean `{ null, 0 }` — a lifetime count silently reset unless this line
+* names it. A first composition of a device that never had the slice logs it
+* too: the line cannot tell the two apart, and says both.
+*/
+function reportSeedlessRestoredCaps(input) {
+	for (const cap of addedCapsOf(input.features)) {
+		if (input.lookupCap(cap)?.durability !== "restored") continue;
+		if ((input.seed.byCap.get(cap) ?? null) !== null) continue;
+		input.logger.info("composed restored capability seeded from nothing — the target had no slice for it (a first composition, or a lost runtime-state row)", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				blockId: input.blockId,
+				cap,
+				seededFrom: "none"
+			}
+		});
+	}
+}
+/**
 * Read every affected effective capability exactly once, before the composer
 * grafts or claims any of them. A null slice is a successful empty seed; a
 * rejection is deliberately left to the caller so ownership cannot begin.
@@ -2496,6 +2649,14 @@ var Composer = class {
 			let targetSeed;
 			if (p.target.kind === "existing" && p.target.deviceId !== null && p.target.waiting === null && p.target.gone === null && p.block.enabled && p.fields.length > 0) try {
 				targetSeed = await readExistingTargetSeeds(p.target.deviceId, p.fields.map((field) => field.cap), this.deps.readExistingTargetCap);
+				reportSeedlessRestoredCaps({
+					logger: this.deps.logger,
+					blockId: p.block.id,
+					deviceId: p.target.deviceId,
+					features: p.target.features,
+					seed: targetSeed,
+					lookupCap: this.deps.lookupCap
+				});
 			} catch (err) {
 				const reason = `the target device state could not be read before ownership (${require_dist.errMsg(err)}) — nothing is grafted or claimed until it is; retried on the next apply`;
 				this.deps.logger.warn(previous?.runtime === null || previous === void 0 ? "customization target state could not be read — ownership is held" : "customization edit target state could not be read — the previous runtime stays installed", {
@@ -2608,6 +2769,7 @@ var Composer = class {
 		const self = p.target.kind === "existing" ? selfReadCaps(p.fields, p.target.ref, p.target.features) : null;
 		const targetKey = p.target.kind === "existing" ? require_dist.compositionSourceKey(p.target.ref) : null;
 		const nativeCaps = new Set(self?.native ?? []);
+		const ownKey = targetKey ?? require_dist.compositionSourceKey(require_dist.composedDeviceRef(p.block.id));
 		return new CompositionRuntime({
 			blockId: p.block.id,
 			fields: p.fields,
@@ -2617,6 +2779,7 @@ var Composer = class {
 			lookupCap: this.deps.lookupCap,
 			...seed === void 0 ? {} : { initialByCap: seed.byCap },
 			read: (read) => this.deps.tracker.read(read, require_dist.compositionSourceKey(read.source) === targetKey && nativeCaps.has(read.cap) ? "native" : "effective"),
+			isOwnRead: (read) => require_dist.compositionSourceKey(read.source) === ownKey && !nativeCaps.has(read.cap),
 			now: this.deps.now,
 			timer: this.deps.newTimer(),
 			logger: this.deps.logger.child("runtime")
@@ -2842,7 +3005,10 @@ var NodeDeadlineTimer = class {
 *   this runner must never answer `{}`.
 * - The context is `createContext(stableId, id)` on a FOREIGN device id: the
 *   second use of the forked-runner native path D659 lists as unverified live
-*   (D659 live item 1). Task 16 step 4.1 is its live proof.
+*   (D659 live item 1). Task 16 step 4.1 is its live proof. Its EMPTY runtime
+*   state is correct and deliberate (D677): no device is built from it and no
+*   slice is written through it — the graft only registers method-serving
+*   natives, and `getStatus` reads the hub's merged slice.
 * - `ungraft` removes only what THIS host registered, through the context's
 *   optional `unregisterNativeCap`. An older kernel without it leaves the graft
 *   routable until the composer respawns — warned once per device, never