@camstack/system 1.2.314 → 1.2.315

package/dist/builtins/composer/composer.addon.mjs

@@ -1,5 +1,6 @@
-import { $ as compositionFieldKey, Bn as BaseAddon, Fn as toExpressionValue, J as buildCapabilityLookup, Mn as compositionItemFieldPath, Nn as compositionSliceKey, On as COMPOSER_ADDON_ID, Pn as compositionSourceKey, Q as composerCapability, Rn as DeviceType, bt as evaluateCompositionField, c as COMPOSED_ITEM_FIXED_FIELDS, en as planComposition, g as DeclaredDevices, i as BaseDevice, jn as composedDeviceStableId, t as ALL_CAPABILITY_DEFINITIONS, ur as EventCategory, zn as errMsg } from "../../dist-cH4t1ZEm.mjs";
-import { n as parseDeviceStateChanged, t as isRecord$1 } from "../../device-state-changed-DoBbkyEI.mjs";
+import { An as cloneStatefulExpressionMemory, Bn as toExpressionValue, Fn as compositionSliceKey, Gn as BaseAddon, In as compositionSourceKey, K as buildCapabilityLookup, Ln as createStatefulExpressionMemory, Mn as composedDeviceStableId, Nn as compositionFeatureEnabled, Pn as compositionItemFieldPath, Un as DeviceType, Wn as errMsg, X as composerCapability, Xt as planComposition, Z as compositionFieldKey, c as COMPOSED_ITEM_FIXED_FIELDS, h as DeclaredDevices, hr as EventCategory, i as BaseDevice, t as ALL_CAPABILITY_DEFINITIONS, tr as createEvent, vt as evaluateCompositionField, wn as COMPOSER_ADDON_ID } from "../../dist-MzYJVCLE.mjs";
+import { n as parseDeviceStateChanged, t as isRecord$2 } from "../../device-state-changed-DoBbkyEI.mjs";
+import { n as normalizedNativeOwner } from "../../composition-sources-yonsRneP.mjs";
 import { z } from "zod";
 //#region src/builtins/composer/composed-device.ts
 /**
@@ -419,6 +420,7 @@ var WithdrawalGate = class {
 var PLACEHOLDER_SHAPE = "placeholder";
 var NO_PLAN = {
 	fields: [],
+	events: [],
 	problems: [],
 	declaration: null,
 	shape: null,
@@ -465,6 +467,7 @@ function planNew(block, target, lookupCap, rows) {
 		};
 	}
 	const caps = block.composition.features.flatMap((f) => {
+		if (!compositionFeatureEnabled(f)) return [];
 		const def = lookupCap(f.cap);
 		return def === null ? [] : [def];
 	});
@@ -477,6 +480,7 @@ function planNew(block, target, lookupCap, rows) {
 	return {
 		block,
 		fields: plan.fields,
+		events: plan.events,
 		problems: [],
 		declaration: declarationFor(declarationInput),
 		shape: shapeOf(declarationInput),
@@ -524,6 +528,7 @@ async function planExisting(input) {
 		...NO_PLAN,
 		block,
 		fields: plan.problems.length > 0 ? [] : plan.fields,
+		events: plan.problems.length > 0 ? [] : plan.events,
 		problems: plan.problems.map((p) => `${p.path}: ${p.message}`),
 		target: {
 			...existing,
@@ -547,6 +552,20 @@ function waitingPlan(block, ref, deviceId, waiting) {
 		}
 	};
 }
+/**
+* Runtime preparation can still fail after a complete existing-target plan.
+* Preserve its fields and description for retry, but mark it waiting so claim
+* reconciliation cannot treat the unprepared candidate as live.
+*/
+function withExistingTargetWait(p, waiting) {
+	return p.target.kind === "existing" ? {
+		...p,
+		target: {
+			...p.target,
+			waiting
+		}
+	} : p;
+}
 /** What `logPlanTransition` compares: problems, and for an existing target its wait or its loss. */
 function planSummary(p) {
 	const target = p.target;
@@ -624,7 +643,7 @@ function logPlanTransition(logger, previous, p, liveTags) {
 * 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) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** `setPath(item, ['remaining', 'value'], 0)` → `{ ...item, remaining: { ...item.remaining, value: 0 } }`. */
@@ -638,7 +657,7 @@ function setPath(record, segments, value) {
 	const current = record[head];
 	return {
 		...record,
-		[head]: setPath(isRecord(current) ? current : {}, rest, value)
+		[head]: setPath(isRecord$1(current) ? current : {}, rest, value)
 	};
 }
 function itemArrayOf(group, lookupCap) {
@@ -701,6 +720,38 @@ var NO_FIELDS = /* @__PURE__ */ new Set();
 function fieldKey(plan) {
 	return compositionFieldKey(plan);
 }
+function isRecord(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);
+}
+function initialValue(plan, byCap, lookupCap) {
+	const slice = byCap?.get(plan.cap);
+	if (slice === void 0 || slice === null) return void 0;
+	const item = plan.item;
+	if (item === void 0) return valueAtPath$1(slice, plan.path);
+	const itemArray = lookupCap(plan.cap)?.status?.itemArray;
+	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);
+}
+function createFieldRecord(plan, byCap, lookupCap) {
+	const initial = initialValue(plan, byCap, lookupCap);
+	return {
+		plan,
+		outcome: null,
+		initial,
+		hasWritten: false,
+		written: void 0,
+		expressionMemory: createStatefulExpressionMemory(),
+		eventHighWater: typeof initial === "number" && Number.isFinite(initial) ? initial : null
+	};
+}
+function currentOutput(record) {
+	return record.hasWritten ? record.written : record.initial;
+}
 /** The top-level field a record writes: an item leaf writes its whole array. */
 function topLevelField(plan) {
 	return plan.item === void 0 ? plan.path : plan.item.arrayPath;
@@ -812,6 +863,11 @@ function pendingReason(cap, pending) {
 * - A target whose writes are asynchronous (claims on the hub) reports what did
 *   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.
 */
 /**
 * A refusal nothing on this side can retry away: another owner holds the
@@ -824,9 +880,13 @@ 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;
+	startedAtMs;
 	seeded = /* @__PURE__ */ new Set();
 	available = null;
 	failure = null;
@@ -848,11 +908,8 @@ var CompositionRuntime = class {
 	terminal = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
-		this.records = new Map(deps.fields.map((plan) => [fieldKey(plan), {
-			plan,
-			outcome: null,
-			written: void 0
-		}]));
+		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));
 	}
 	start() {
@@ -1011,15 +1068,18 @@ var CompositionRuntime = class {
 	pass(keys, trigger) {
 		const initial = trigger === "start";
 		const now = this.deps.now();
-		const derived = this.evaluate(keys.filter((k) => this.records.get(k)?.plan.role === "derived"), now);
-		const followers = [...this.records.values()].filter((r) => r.plan.role === "clock" ? initial || derived.valueCaps.has(r.plan.cap) : r.plan.role === "constant" && initial).map((r) => fieldKey(r.plan));
+		const calculated = this.evaluate(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 evaluatedCaps = new Set([...keys, ...followers].flatMap((k) => {
 			const cap = this.records.get(k)?.plan.cap;
 			return cap === void 0 ? [] : [cap];
 		}));
 		const retry = new Set([...this.pending.keys()].filter((cap) => trigger === "deadline" || evaluatedCaps.has(cap)));
-		this.writeCaps(new Set([...derived.keys, ...extra.keys]), retry);
+		this.writeCaps(new Set([...calculated.keys, ...extra.keys]), retry);
 		this.updateFailure();
 		this.updateAvailability();
 	}
@@ -1031,15 +1091,35 @@ var CompositionRuntime = class {
 			for (const key of keys) {
 				const record = next.get(key);
 				if (record === void 0) continue;
+				const candidateMemory = cloneStatefulExpressionMemory(record.expressionMemory);
 				const outcome = evaluateCompositionField({
 					source: record.plan.source,
 					read: this.deps.read,
-					now
+					now,
+					stateful: {
+						currentOutput: currentOutput(record),
+						expressionMemory: candidateMemory,
+						startedAtMs: this.startedAtMs,
+						callPathPrefix: fieldKey(record.plan)
+					}
 				});
-				next.set(key, {
+				const expressionSucceeded = outcome.state !== "unavailable";
+				let evaluated = {
 					...record,
-					outcome
-				});
+					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);
@@ -1053,6 +1133,39 @@ var CompositionRuntime = class {
 			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 !== EventCategory.DoorbellOnPressed) throw new Error(`unsupported state-derived event category \`${plan.category}\``);
+			const event = createEvent(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);
 	}
@@ -1081,8 +1194,9 @@ var CompositionRuntime = class {
 		const records = this.recordsOf(cap);
 		this.logReleaseTransitions(cap, records);
 		const releasedRecords = records.filter(isReleased);
-		this.records = new Map([...this.records].map(([k, r]) => releasedRecords.includes(r) && r.written !== void 0 ? [k, {
+		this.records = new Map([...this.records].map(([k, r]) => releasedRecords.includes(r) && r.hasWritten ? [k, {
 			...r,
+			hasWritten: false,
 			written: void 0
 		}] : [k, r]));
 		const withhold = this.deps.target.withhold;
@@ -1144,7 +1258,7 @@ var CompositionRuntime = class {
 		this.markWritten(cap, entries);
 	}
 	patchCap(cap, touched) {
-		const entries = this.entriesFor(cap, this.recordsOf(cap).filter((r) => touched.has(fieldKey(r.plan)) && writable(r) !== r.written));
+		const entries = this.entriesFor(cap, this.recordsOf(cap).filter((r) => touched.has(fieldKey(r.plan)) && (!r.hasWritten || writable(r) !== r.written)));
 		if (entries.length === 0) return;
 		if (this.write(cap, "patch", entries)) this.markWritten(cap, entries);
 	}
@@ -1276,6 +1390,7 @@ var CompositionRuntime = class {
 		const written = new Map(entries.map((e) => [fieldKey(e.plan), e.value]));
 		this.records = new Map([...this.records].map(([k, r]) => r.plan.cap === cap && written.has(k) ? [k, {
 			...r,
+			hasWritten: true,
 			written: written.get(k)
 		}] : [k, r]));
 	}
@@ -1413,6 +1528,16 @@ var ConfirmedSeed = class {
 *   is NOT decided here from the plan: it follows whether the claim has landed
 *   (`HeldClaims`, C-1).
 */
+/**
+* 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.
+*/
+async function readExistingTargetSeeds(targetDeviceId, caps, read) {
+	const byCap = /* @__PURE__ */ new Map();
+	for (const cap of new Set(caps)) byCap.set(cap, await read(targetDeviceId, cap));
+	return { byCap };
+}
 /** The reason every ungraft of a gone target carries (Task 9 rule 5 / Task 10 rule 2). */
 var TARGET_GONE_UNGRAFT_REASON = "target device gone";
 /**
@@ -1746,14 +1871,17 @@ function verdictOf(blockId, entry, unsynced, grafts = null) {
 		reason: "the composed device has not been constructed yet"
 	};
 	const runtime = entry.runtime;
-	if (runtime === null) return target.kind === "existing" ? {
-		blockId,
-		status: "starting",
-		reason: NOT_STARTED
-	} : {
-		blockId,
-		status: "running"
-	};
+	if (runtime === null) {
+		if (target.kind !== "existing" || target.features.length === 0) return {
+			blockId,
+			status: "running"
+		};
+		return {
+			blockId,
+			status: "starting",
+			reason: NOT_STARTED
+		};
+	}
 	if (unsynced) return {
 		blockId,
 		status: "starting",
@@ -2361,8 +2489,30 @@ var Composer = class {
 				});
 				continue;
 			}
+			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);
+			} catch (err) {
+				const reason = `the target device state could not be read before ownership (${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", {
+					tags: { deviceId: p.target.deviceId },
+					meta: {
+						blockId: p.block.id,
+						error: errMsg(err)
+					}
+				});
+				if (previous !== void 0) next.set(p.block.id, previous);
+				else next.set(p.block.id, {
+					planned: withExistingTargetWait(p, reason),
+					device: null,
+					runtime: null,
+					appliedName: null,
+					rebuildError: null,
+					heldFields: []
+				});
+				continue;
+			}
 			const heldFields = this.heldFieldsFor(p, previous);
-			previous?.runtime?.stop();
 			const operatorAction = previous === void 0 || restart.has(p.block.id) || previous.planned.block.updatedAt !== p.block.updatedAt;
 			const targetKey = p.target.kind === "existing" ? compositionSourceKey(p.target.ref) : null;
 			if (operatorAction) for (const f of p.fields) for (const r of f.reads) {
@@ -2370,6 +2520,7 @@ var Composer = class {
 				if (key !== targetKey) reset.add(key);
 			}
 			const writer = this.writerFor(p, device);
+			const runtime = writer === null || p.fields.length === 0 ? null : this.newRuntime(p, writer, targetSeed);
 			if (writer !== null && p.target.kind === "existing" && p.target.deviceId !== null) this.grafts.plan({
 				deviceId: p.target.deviceId,
 				ref: p.target.ref,
@@ -2378,7 +2529,7 @@ var Composer = class {
 				enabled: p.block.enabled,
 				settled: p.problems.length === 0
 			});
-			const runtime = writer === null || p.fields.length === 0 ? null : this.newRuntime(p, writer);
+			previous?.runtime?.stop();
 			if (runtime !== null) fresh.add(runtime);
 			next.set(p.block.id, {
 				planned: p,
@@ -2449,15 +2600,18 @@ var Composer = class {
 		if (previous.runtime === null) return previous.heldFields;
 		return heldFieldsOf(previous.runtime.state().fields, `the composition no longer plans — the field keeps its last value on the device: ${p.problems.join("; ")}`);
 	}
-	newRuntime(p, target) {
+	newRuntime(p, target, seed) {
 		const self = p.target.kind === "existing" ? selfReadCaps(p.fields, p.target.ref, p.target.features) : null;
 		const targetKey = p.target.kind === "existing" ? compositionSourceKey(p.target.ref) : null;
 		const nativeCaps = new Set(self?.native ?? []);
 		return new CompositionRuntime({
 			blockId: p.block.id,
 			fields: p.fields,
+			eventPlans: p.events,
+			events: this.deps.events,
 			target,
 			lookupCap: this.deps.lookupCap,
+			...seed === void 0 ? {} : { initialByCap: seed.byCap },
 			read: (read) => this.deps.tracker.read(read, compositionSourceKey(read.source) === targetKey && nativeCaps.has(read.cap) ? "native" : "effective"),
 			now: this.deps.now,
 			timer: this.deps.newTimer(),
@@ -2890,7 +3044,7 @@ function entriesOf(request) {
 	}))];
 }
 function valueAtPath(slice, path) {
-	return path.split(".").reduce((node, segment) => isRecord$1(node) ? node[segment] : void 0, slice);
+	return path.split(".").reduce((node, segment) => isRecord$2(node) ? node[segment] : void 0, slice);
 }
 function onlineOf(slice) {
 	const online = slice["online"];
@@ -3555,12 +3709,12 @@ var SourceTracker = class {
 var DECLARED_INTEGRATION_NAME_UNUSED = "Blocks";
 /** The owner-only shadow payload is not in the typed catalog: narrowed at the boundary, like `device.state-changed`. */
 function parseNativeShadowChanged(data) {
-	if (!isRecord$1(data)) return null;
+	if (!isRecord$2(data)) return null;
 	const deviceId = data["deviceId"];
 	const capName = data["capName"];
 	const native = data["native"];
 	if (typeof deviceId !== "number" || typeof capName !== "string") return null;
-	if (!isRecord$1(native)) return null;
+	if (!isRecord$2(native)) return null;
 	return {
 		deviceId,
 		capName,
@@ -3581,7 +3735,10 @@ var ComposerAddon = class extends BaseAddon {
 				const bindings = await api.deviceManager.getBindings.query({ deviceId });
 				return {
 					kind: "caps",
-					caps: new Map(bindings.entries.map((e) => [e.capName, e.nativeAddonId]))
+					caps: new Map(bindings.entries.flatMap((entry) => {
+						const owner = normalizedNativeOwner(entry.nativeAddonId);
+						return owner === null ? [] : [[entry.capName, owner]];
+					}))
 				};
 			} catch (err) {
 				return {
@@ -3693,6 +3850,11 @@ var ComposerAddon = class extends BaseAddon {
 				releaseClaim: (input) => api.deviceState.releaseClaim.mutate(input),
 				listClaims: (input) => api.deviceState.listClaims.query(input)
 			},
+			events: this.ctx.eventBus,
+			readExistingTargetCap: async (deviceId, capName) => await api.deviceState.getCapSlice.query({
+				deviceId,
+				capName
+			}) ?? null,
 			describeTarget: readBoundCaps,
 			grafts,
 			now: () => Date.now(),

package/dist/builtins/composer/composer.d.ts

@@ -2,7 +2,7 @@ import { CapabilityLookup, ComposerApplyInput, ComposerApplyResult, CompositionB
 import { DeviceStateChangedData } from '../shared/device-state-changed.js';
 import { ComposerDeclare, ComposerDevicePorts } from './composed-device-set.js';
 import { PersistedComposedRow } from './composition-declarations.js';
-import { DeadlineTimer } from './composition-runtime.js';
+import { CompositionEventEmitter, DeadlineTimer } from './composition-runtime.js';
 import { ComposerClaimsApi, ComposerGraftPorts, DescribeTarget } from './existing-target.js';
 import { SourceBindingsChangeReason, SourceTracker } from './source-tracker.js';
 export type { ComposerDerivedSpec } from './composer-plan.js';
@@ -31,6 +31,10 @@ export interface ComposerDeps {
     readonly devices: ComposerDevicePorts;
     /** The hub's per-field claims (D663): the write target's methods and the boot seed. */
     readonly claims: ComposerClaimsApi;
+    /** Typed state-derived events emitted by composed capability fields. */
+    readonly events: CompositionEventEmitter;
+    /** Effective target state, read before an existing-target runtime owns any field. */
+    readonly readExistingTargetCap: (deviceId: number, capName: string) => Promise<Readonly<Record<string, unknown>> | null>;
     /** ONE `getBindings` per target description read (rule 1). */
     readonly describeTarget: DescribeTarget;
     /** `GraftHost` (Task 10): a method-serving native for each ADDED cap. Absent, nothing is grafted. */

package/dist/builtins/composer/composition-runtime.d.ts

@@ -1,4 +1,4 @@
-import { CapabilityLookup, ClaimOutcome, CompositionFieldPlan, CompositionFieldState, IScopedLogger, SourceReader } from '@camstack/types';
+import { CapabilityLookup, ClaimOutcome, CompositionEventPlan, CompositionFieldPlan, CompositionFieldState, IScopedLogger, SourceReader, SystemEvent } from '@camstack/types';
 import { SlicePatch } from './slice-assembler.js';
 import { ReleasedField } from './field-record.js';
 export type { ReleasedField } from './field-record.js';
@@ -47,11 +47,18 @@ export interface DeadlineTimer {
     arm(at: number, fire: () => void): void;
     disarm(): void;
 }
+export interface CompositionEventEmitter {
+    emit(event: SystemEvent): void;
+}
 export interface CompositionRuntimeDeps {
     readonly blockId: string;
     readonly fields: readonly CompositionFieldPlan[];
+    readonly eventPlans: readonly CompositionEventPlan[];
+    readonly events: CompositionEventEmitter;
     readonly target: ComposedWriteTarget;
     readonly lookupCap: CapabilityLookup;
+    /** Effective target slices captured before an existing-target runtime takes ownership. */
+    readonly initialByCap?: ReadonlyMap<string, Readonly<Record<string, unknown>> | null>;
     readonly read: SourceReader;
     readonly now: () => number;
     readonly timer: DeadlineTimer;
@@ -68,6 +75,7 @@ export interface CompositionRuntimeState {
 export declare class CompositionRuntime {
     private readonly deps;
     private records;
+    private readonly startedAtMs;
     private seeded;
     private available;
     private failure;
@@ -117,6 +125,7 @@ export declare class CompositionRuntime {
     private logPassError;
     private pass;
     private evaluate;
+    private emitStateEvent;
     private recordsOf;
     /** `retry`: write-pending caps this pass re-writes WHOLE, whether or not a value changed. */
     private writeCaps;

package/dist/builtins/composer/existing-target.d.ts

@@ -9,6 +9,15 @@ export type ListClaimsInput = z.infer<typeof deviceStateCapability.methods.listC
 export interface ComposerClaimsApi extends OwnedFieldsApi {
     listClaims(input: ListClaimsInput): Promise<ClaimsListing>;
 }
+export interface ExistingTargetSeedRead {
+    readonly byCap: ReadonlyMap<string, Readonly<Record<string, unknown>> | null>;
+}
+/**
+ * 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.
+ */
+export declare function readExistingTargetSeeds(targetDeviceId: number, caps: readonly string[], read: (deviceId: number, capName: string) => Promise<Readonly<Record<string, unknown>> | null>): Promise<ExistingTargetSeedRead>;
 /**
  * The composer's grafts (`GraftHost`, Task 10): a method-serving native for each
  * cap a customization ADDS. Grafted at PLAN time only; removed when a foreign

package/dist/builtins/composer/field-record.d.ts

@@ -1,12 +1,21 @@
-import { CompositionFieldItem, CompositionFieldPlan, CompositionFieldState, ExpressionValue, FieldOutcome } from '@camstack/types';
+import { CapabilityLookup, CompositionFieldItem, CompositionFieldPlan, CompositionFieldState, ExpressionValue, FieldOutcome, StatefulExpressionMemory } from '@camstack/types';
 export declare const NO_FIELDS: ReadonlySet<string>;
 export interface FieldRecord {
     readonly plan: CompositionFieldPlan;
     readonly outcome: FieldOutcome | null;
-    /** What the target last ACCEPTED; `undefined` = never written. */
-    readonly written: ExpressionValue | undefined;
+    /** The effective target value observed before this runtime took ownership. Never changes. */
+    readonly initial: unknown;
+    /** Whether `written` is an accepted runtime answer; kept separate because every falsey value is valid. */
+    readonly hasWritten: boolean;
+    /** What the target last accepted from this runtime. */
+    readonly written: unknown;
+    readonly expressionMemory: StatefulExpressionMemory;
+    /** Last finite state value already represented by a derived event. */
+    readonly eventHighWater: number | null;
 }
 export declare function fieldKey(plan: CompositionFieldPlan): string;
+export declare function createFieldRecord(plan: CompositionFieldPlan, byCap: ReadonlyMap<string, Readonly<Record<string, unknown>> | null> | undefined, lookupCap: CapabilityLookup): FieldRecord;
+export declare function currentOutput(record: FieldRecord): unknown;
 /** The top-level field a record writes: an item leaf writes its whole array. */
 export declare function topLevelField(plan: CompositionFieldPlan): string;
 /** The field as a report or a log line names it: `items[desiccant].status` for an item leaf. */

package/dist/builtins/console-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BtNkk3Qz.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

package/dist/builtins/console-logging/index.mjs

@@ -1,4 +1,4 @@
-import { Bn as BaseAddon, Ht as logDestinationCapability } from "../../dist-cH4t1ZEm.mjs";
+import { Gn as BaseAddon, Rt as logDestinationCapability } from "../../dist-MzYJVCLE.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

package/dist/builtins/core-blocks/composition-sources.d.ts

@@ -7,7 +7,7 @@ export interface SourceRowView {
 /** One `getBindings` entry: the cap, and the addon serving it natively. */
 export interface BoundCapView {
     readonly capName: string;
-    readonly nativeAddonId: string;
+    readonly nativeAddonId?: string | null;
 }
 export interface CompositionSourcePorts {
     readonly listByAddon: (addonId: string) => Promise<readonly SourceRowView[]>;
@@ -18,4 +18,6 @@ export interface CompositionDescriptions {
     readonly sources: ReadonlyMap<string, CompositionSourceDescription>;
     readonly targets: ReadonlyMap<string, CompositionTargetDescription>;
 }
+/** Blank binding owners are not native providers and must not turn ADD into REPLACE. */
+export declare function normalizedNativeOwner(owner: string | null | undefined): string | null;
 export declare function describeCompositionSources(ports: CompositionSourcePorts, sources: readonly CompositionSourceRef[], targets?: readonly CompositionSourceRef[]): Promise<CompositionDescriptions>;