@camstack/system 1.2.475 → 1.2.477

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

@@ -19,7 +19,11 @@
 * filter in `composer.addon.ts` stays load-bearing. Its fields are CLAIMED on
 * the hub under the block id (`OwnedFieldsTarget`), and released through the
 * `ClaimGate` — two applies must agree, seeded at boot from the claims index —
-* when the block is gone, disabled, or lost the feature. Its own replaced
+* when the block merely vanished from one snapshot. An operator delete
+* (`retiredBlockIds`) or an edit that drops a cap releases those claims on
+* THIS apply, after the old runtime has quiesced and before any replacement
+* claims; a release that does not land is logged with `tags: { deviceId }` and
+* returned on the apply. Its own replaced
 * fields are read in the NATIVE view (rule 6). Its target row gone on two
 * agreeing index reads fails the block by name and ungrafts what it added —
 * whether the loss was seen on `device.unregistered` or on a later plan; its
@@ -49,6 +53,7 @@ import { type ComposerDeclare, type ComposerDevicePorts } from "./composed-devic
 import { type PersistedComposedRow } from "./composition-declarations.js";
 import type { CompositionEventEmitter, DeadlineTimer } from "./composition-runtime.js";
 import { type ComposerClaimsApi, type ComposerGraftPorts, type DescribeTarget } from "./existing-target.js";
+import { type ReadPulseHistory } from "./pulse-seed-resolve.js";
 import type { SourceBindingsChangeReason, SourceTracker } from "./source-tracker.js";
 export type { ComposerDerivedSpec } from "./composer-plan.js";
 export type { ComposerDeclareResult, ComposerDevicePorts } from "./composed-device-set.js";
@@ -80,6 +85,11 @@ export interface ComposerDeps {
 	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>;
+	/**
+	* Raw history of a source field, for a pulse override's start seed (D938).
+	* Absent (tests that predate the seed) leaves the boot slice as the initial.
+	*/
+	readonly readPulseHistory?: ReadPulseHistory;
 	/** 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. */
@@ -139,6 +149,9 @@ export declare class Composer {
 	private syncTracker;
 	/** Rule 3: release what no live customization wants, once two applies agree (`wantedClaims`). */
 	private reconcileClaims;
+	/** Confirmed releases, awaited. A failure is the string the hub gave; the gate retries it later. */
+	private releaseConfirmed;
+	/** Null when the hub confirmed the release (or held nothing of ours). */
 	private release;
 	/**
 	* Rule 5: a customization whose target row is gone — the tracker's two

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

@@ -54,6 +54,7 @@
 import { type CapabilityLookup, type CompositionEventPlan, type CompositionFieldPlan, type CompositionFieldRead, type CompositionFieldState, type IScopedLogger, type SourceReader } from "@camstack/types";
 import type { ComposedWriteTarget, CompositionEventEmitter, DeadlineTimer } from "./composition-target.js";
 import { type ReleasedField } from "./field-record.js";
+import type { PulseFieldSeed } from "./pulse-seed.js";
 export type { ReleasedField } from "./field-record.js";
 export type { ComposedWriteTarget, CompositionEventEmitter, DeadlineTimer, TargetAsyncFailure, WriteOk, WriteOutcome, WriteRefused } from "./composition-target.js";
 export interface CompositionRuntimeDeps {
@@ -65,6 +66,8 @@ export interface CompositionRuntimeDeps {
 	readonly lookupCap: CapabilityLookup;
 	/** Effective target slices captured before an existing-target runtime takes ownership. */
 	readonly initialByCap?: ReadonlyMap<string, Readonly<Record<string, unknown>> | null>;
+	/** Pulse start seed (D938). Absent keeps `initialByCap`. `hold` publishes nothing. */
+	readonly pulseSeeds?: ReadonlyMap<string, PulseFieldSeed>;
 	readonly read: SourceReader;
 	/**
 	* Whether `read` is of this composition's OWN output (an added cap on its
@@ -115,6 +118,8 @@ export declare class CompositionRuntime {
 	disable(reason: string): void;
 	/** Terminal: no write, no evaluation and no timer after this. */
 	stop(): void;
+	/** `stop`, then wait until the target has sent nothing further. */
+	quiesce(): Promise<void>;
 	state(): CompositionRuntimeState;
 	/**
 	* The target's enqueued write of `cap` did not land: the cap is write-pending

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

@@ -44,6 +44,12 @@ export interface ComposedWriteTarget {
 	* existing targets.
 	*/
 	withhold?(cap: string, fields: readonly string[]): WriteOutcome;
+	/**
+	* Drop writes not yet sent and resolve once the one in flight has settled.
+	* A stopped block calls this before its claims are released, so that claim
+	* cannot land afterwards.
+	*/
+	quiesce?(): Promise<void>;
 }
 export interface DeadlineTimer {
 	arm(at: number, fire: () => void): void;

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

@@ -6,6 +6,7 @@
 * behaviour.
 */
 import { type CapabilityLookup, type CompositionFieldItem, type CompositionFieldPlan, type CompositionFieldState, type ExpressionValue, type FieldOutcome, type StatefulExpressionMemory } from "@camstack/types";
+import type { PulseFieldSeed } from "./pulse-seed.js";
 export declare const NO_FIELDS: ReadonlySet<string>;
 export interface FieldRecord {
 	readonly plan: CompositionFieldPlan;
@@ -19,9 +20,15 @@ export interface FieldRecord {
 	readonly expressionMemory: StatefulExpressionMemory;
 	/** Last finite state value already represented by a derived event. */
 	readonly eventHighWater: number | null;
+	/**
+	* A pulse timestamp whose start seed could not be read (D49, D938). A null
+	* result is not published, so a failed read is not "no ring".
+	*/
+	readonly pulseHold: boolean;
 }
 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 fieldRecords(fields: readonly CompositionFieldPlan[], byCap: ReadonlyMap<string, Readonly<Record<string, unknown>> | null> | undefined, lookupCap: CapabilityLookup, pulseSeeds: ReadonlyMap<string, PulseFieldSeed> | undefined): ReadonlyMap<string, 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;

package/dist/builtins/composer/owned-fields-target.d.ts

@@ -64,11 +64,20 @@ export declare class OwnedFieldsTarget implements ComposedWriteTarget {
 	private listeners;
 	/** Per cap, bumped by every `withhold`: a claim that settles under another epoch claimed a stale field set and does not land (I-2). */
 	private epoch;
+	/** Set by `quiesce`: nothing further is sent. */
+	private closed;
+	private idle;
+	private markIdle;
 	constructor(deps: OwnedFieldsTargetDeps);
 	seed(cap: string, slice: SlicePatch): WriteOutcome;
 	patch(cap: string, patch: SlicePatch): WriteOutcome;
 	/** `device-status` belongs to the native device; availability lives in the block report only. */
 	setAvailable(_available: boolean): void;
+	/**
+	* The block has stopped. Writes still queued are dropped; the call in flight
+	* is allowed to finish, and then nothing else is sent.
+	*/
+	quiesce(): Promise<void>;
 	onAsyncFailure(listener: AsyncFailureListener): void;
 	withhold(cap: string, fields: readonly string[]): WriteOutcome;
 	private claimableFields;

package/dist/builtins/composer/pulse-seed-resolve.d.ts

@@ -0,0 +1,59 @@
+/**
+* Gather a pulse override's start seed (D938). The stored expression is not
+* changed. A failed read holds the field: no seed, and a claimed stamp is
+* not cleared (D49).
+*/
+import { type CapabilityLookup, type ClaimsListing, type CompositionFieldPlan, type CompositionSourceRef, type IScopedLogger } from "@camstack/types";
+import type { ExistingTargetSeedRead } from "./existing-target.js";
+import { type PulseFieldSeed, type PulseHistoryPoint } from "./pulse-seed.js";
+import type { SourceResolution } from "./source-readings.js";
+export type { PulseFieldSeed } from "./pulse-seed.js";
+export interface PulseHistorySeries {
+	readonly beforeOn: boolean | null;
+	readonly points: readonly PulseHistoryPoint[];
+}
+export type PulseHistoryAnswer = {
+	readonly kind: "unread";
+	readonly error: string;
+} | {
+	readonly kind: "series";
+	readonly series: PulseHistorySeries;
+};
+export type ReadPulseHistory = (deviceId: number, cap: string, fieldPath: string, fromMs: number, toMs: number) => Promise<PulseHistoryAnswer>;
+export interface PulseClaimListing {
+	listClaims(input: {
+		readonly ownerPrefix?: string;
+	}): Promise<ClaimsListing>;
+}
+export interface PulseSourceLookup {
+	resolve(ref: CompositionSourceRef, reset: boolean): Promise<SourceResolution>;
+}
+export interface ResolvePulseSeedsInput {
+	readonly blockId: string;
+	readonly deviceId: number;
+	readonly fields: readonly CompositionFieldPlan[];
+	readonly targetSeed: ExistingTargetSeedRead;
+	readonly lookupCap: CapabilityLookup;
+	readonly claims: PulseClaimListing;
+	readonly sources: PulseSourceLookup;
+	readonly readCap: (deviceId: number, capName: string) => Promise<Readonly<Record<string, unknown>> | null>;
+	readonly readPulseHistory: ReadPulseHistory;
+	readonly now: () => number;
+	readonly logger: IScopedLogger;
+}
+export declare function historySeriesKey(cap: string, fieldPath: string): string;
+export declare function resolvePulseSeeds(input: ResolvePulseSeedsInput): Promise<ReadonlyMap<string, PulseFieldSeed>>;
+export interface PulseHistoryQueryPoint {
+	readonly t: number;
+	readonly last: number | null;
+}
+export interface PulseHistoryQueryBefore {
+	readonly value: number | null;
+}
+export interface PulseHistoryQuerySeries {
+	readonly scope: string;
+	readonly before: PulseHistoryQueryBefore | null;
+	readonly points: readonly PulseHistoryQueryPoint[];
+}
+/** Raw boolean points of the device-level series (`scope` empty). 1 is on. */
+export declare function pulseHistoryFromQuery(series: readonly PulseHistoryQuerySeries[]): PulseHistorySeries;

package/dist/builtins/composer/pulse-seed.d.ts

@@ -0,0 +1,75 @@
+/**
+* What `lastPressedAt` is at the start of a pulse override (D938).
+*
+* The stored formula stays `latest(rose(...))` — the seed is not an argument
+* of `rose` or `latest`, so compile/decode stay a round trip (D936). A stamp
+* this block already claimed is kept. Anything else comes from the source,
+* and a read that failed is not a seed and not "no ring" (D49).
+*/
+export interface PulseHistoryPoint {
+	readonly t: number;
+	readonly on: boolean;
+}
+export type PulseHistoryRead = {
+	readonly kind: "unread";
+} | {
+	readonly kind: "absent";
+} | {
+	readonly kind: "series";
+	readonly beforeOn: boolean | null;
+	readonly points: readonly PulseHistoryPoint[];
+};
+export type PulseSourceLevel = {
+	readonly kind: "unread";
+} | {
+	readonly kind: "off";
+	readonly changedAt: number | null;
+} | {
+	readonly kind: "on";
+	readonly changedAt: number | null;
+};
+/** What this block already wrote. `none` means it holds no claim. */
+export type OwnedPulse = {
+	readonly kind: "none";
+} | {
+	readonly kind: "never";
+} | {
+	readonly kind: "stamp";
+	readonly at: number;
+	readonly count: number;
+};
+export interface PulseSeedFacts {
+	readonly owned: OwnedPulse;
+	/** The target's native `lastPressedAt`. Compared only with a changed-at bound. */
+	readonly nativeStamp: number | null;
+	readonly history: PulseHistoryRead;
+	readonly level: PulseSourceLevel;
+}
+export type PulseStampDecision = {
+	readonly kind: "keep";
+} | {
+	readonly kind: "hold";
+	readonly reason: string;
+} | {
+	readonly kind: "none";
+	readonly count: number;
+} | {
+	readonly kind: "stamp";
+	readonly at: number;
+	readonly count: number;
+	readonly via: "history" | "changed-at-bound";
+};
+/** What one field's record is seeded with. `keep` leaves the boot slice alone. */
+export type PulseFieldSeed = {
+	readonly kind: "keep";
+} | {
+	readonly kind: "hold";
+} | {
+	readonly kind: "value";
+	readonly value: number | null;
+};
+/** The last false→true in time order. A series that opens already on is not a transition. */
+export declare function lastOffToOn(points: readonly PulseHistoryPoint[], beforeOn: boolean | null): number | null;
+export declare function decidePulseSeed(facts: PulseSeedFacts): PulseStampDecision;
+/** One failed source blocks "no ring". A rise from another source still stands. */
+export declare function mergePulseDecisions(decisions: readonly PulseStampDecision[]): PulseStampDecision;

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-BtDdPdZ7.js");
+const require_dist = require("../../dist-CNU7cdFf.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 { Ln as logDestinationCapability, ti as BaseAddon } from "../../dist-DygMs3Qc.mjs";
+import { Ln as logDestinationCapability, ti as BaseAddon } from "../../dist-B_V9r61Z.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/block-supervisor.d.ts

@@ -19,7 +19,7 @@
 * status the operator can see, with the reason attached. A block that is
 * silently absent is the failure mode this whole feature has to avoid.
 */
-import { type ComposerApplyInput, type ComposerApplyResult, type ComposerUnreadableBlock, type CoreBlock, type IScopedLogger } from "@camstack/types";
+import { type ComposerApplyInput, type ComposerApplyResult, type ComposerUnreadableBlock, type CoreBlock, type IScopedLogger, type UnreleasedClaim } from "@camstack/types";
 /** The runner lifecycle states `$process.list` reports. `stopping`/`stopped`
 *  are transient states of a runner on its way out and are treated as absent. */
 export type BlockRunnerState = "starting" | "running" | "stopping" | "stopped" | "crashed" | "failed";
@@ -107,6 +107,10 @@ export declare class BlockSupervisor {
 	private emptyAppliesOwed;
 	/** Consecutive applies that could not reach the composer: warned once per run. */
 	private failedApplies;
+	/** Composition ids the operator deleted. Passed until their claims are released. */
+	private retiredBlockIds;
+	/** What the last composition apply said about claim releases. */
+	private releaseReport;
 	constructor(deps: BlockSupervisorDeps);
 	/** Start the reconcile timer. The first pass runs immediately. */
 	start(intervalMs: number): void;
@@ -128,6 +132,17 @@ export declare class BlockSupervisor {
 	* timer tick could stop a runner the tick had just decided was healthy and
 	* then never re-launch it.
 	*/
+	/**
+	* The block row is already gone. The next apply names it retired so its
+	* claims are released before this resolves. A release that does not land is
+	* returned; the id stays retired so the following pass tries again.
+	*/
+	retireComposition(blockId: string): Promise<readonly UnreleasedClaim[]>;
+	/**
+	* One apply, awaited. Used when an edit replaced a block's caps: the
+	* composer releases what the new plan dropped before this resolves.
+	*/
+	convergeForClaims(): Promise<readonly UnreleasedClaim[]>;
 	restart(blockId: string): Promise<void>;
 	private runRestart;
 	private runPass;
@@ -139,6 +154,9 @@ export declare class BlockSupervisor {
 	* pass of this same converge is the retry — no timer of its own (D3).
 	*/
 	private convergeCompositions;
+	private claimsOf;
+	/** Remember which retired ids still hold a claim. An apply that did not act keeps every id. */
+	private noteRelease;
 	/** Compile, write the package, spawn. Each failure is reported ON the block
 	*  — the author asked for this to run, so they are owed the reason it does
 	*  not. */

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

@@ -12,7 +12,7 @@
 * server derives it (`customizationBlockName`), refuses one the client sends,
 * and never lets it move to another device. One per device, by block id (S2).
 */
-import { type CapabilityDefinition, type CapabilityLookup, type CompositionBlockPatch, type CompositionBlockState, type CompositionSourceRef, type CoreBlock, type ICoreBlocksProvider, type IScopedLogger } from "@camstack/types";
+import { type CapabilityDefinition, type CapabilityLookup, type CompositionBlockPatch, type CompositionBlockState, type CompositionSourceRef, type CoreBlock, type ICoreBlocksProvider, type IScopedLogger, type UnreleasedClaim } from "@camstack/types";
 import type { NamedCompositionInput } from "./core-block-store.js";
 import type { CompositionDescriptions } from "./composition-sources.js";
 export interface CompositionStoreView {
@@ -30,6 +30,12 @@ export interface CompositionApiDeps {
 	readonly lookupCap: CapabilityLookup;
 	readonly composerStates: (blockIds: readonly string[]) => Promise<readonly CompositionBlockState[]>;
 	readonly convergeSoon: () => void;
+	/**
+	* One composer apply, awaited. An edit that replaces caps does not return
+	* until the caps it dropped have been released, or the release has failed
+	* and is in the list.
+	*/
+	readonly convergeForClaims: () => Promise<readonly UnreleasedClaim[]>;
 	readonly logger: IScopedLogger;
 	/** Every capability definition — the listing is derived from them, never from the registry's live state. */
 	readonly capabilityDefinitions: readonly CapabilityDefinition[];

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

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BtDdPdZ7.js");
+const require_dist = require("../../dist-CNU7cdFf.js");
 const require_read_all_rows$1 = require("../../read-all-rows-CVoO1ONM.js");
-const require_composition_sources = require("../../composition-sources-DeUSUid6.js");
+const require_composition_sources = require("../../composition-sources-BNOP9mFp.js");
 const require_prefix_range = require("../../prefix-range-D_KueXbQ.js");
 const require_prefix_walk = require("../../prefix-walk-Dv6MLZlM.js");
 let zod = require("zod");
@@ -246,6 +246,13 @@ var BlockSupervisor = class {
 	emptyAppliesOwed = 2;
 	/** Consecutive applies that could not reach the composer: warned once per run. */
 	failedApplies = 0;
+	/** Composition ids the operator deleted. Passed until their claims are released. */
+	retiredBlockIds = /* @__PURE__ */ new Set();
+	/** What the last composition apply said about claim releases. */
+	releaseReport = {
+		error: null,
+		unreleased: []
+	};
 	constructor(deps) {
 		this.deps = deps;
 	}
@@ -281,6 +288,26 @@ var BlockSupervisor = class {
 	* timer tick could stop a runner the tick had just decided was healthy and
 	* then never re-launch it.
 	*/
+	/**
+	* The block row is already gone. The next apply names it retired so its
+	* claims are released before this resolves. A release that does not land is
+	* returned; the id stays retired so the following pass tries again.
+	*/
+	retireComposition(blockId) {
+		this.retiredBlockIds = new Set([...this.retiredBlockIds, blockId]);
+		return this.converge().then(() => this.claimsOf(blockId));
+	}
+	/**
+	* One apply, awaited. Used when an edit replaced a block's caps: the
+	* composer releases what the new plan dropped before this resolves.
+	*/
+	convergeForClaims() {
+		if (this.deps.composer === null) return Promise.reject(/* @__PURE__ */ new Error("core-blocks: no composer is available — a replaced claim cannot be released"));
+		return this.converge().then(() => {
+			if (this.releaseReport.error !== null) throw new Error(`core-blocks: a replaced claim was not released — ${this.releaseReport.error}`);
+			return this.releaseReport.unreleased;
+		});
+	}
 	restart(blockId) {
 		const block = this.deps.store.get(blockId);
 		if (block !== null && require_dist.coreBlockSourceKind(block) === "composition") {
@@ -369,9 +396,13 @@ var BlockSupervisor = class {
 		});
 		const unreadable = this.deps.store.unreadableCompositions();
 		const nothingToSay = compositions.length === 0 && unreadable.length === 0;
-		if (nothingToSay && this.emptyAppliesOwed === 0) return;
+		if (nothingToSay && this.emptyAppliesOwed === 0 && this.retiredBlockIds.size === 0) return;
 		const composer = this.deps.composer;
 		if (composer === null) {
+			if (this.retiredBlockIds.size > 0) this.releaseReport = {
+				error: "no composer is available on this node — claims cannot be released",
+				unreleased: []
+			};
 			for (const { block } of compositions) await this.report(block.id, "failed", "no composer is available on this node — a composition cannot run here");
 			return;
 		}
@@ -394,7 +425,8 @@ var BlockSupervisor = class {
 					composition
 				})),
 				restartBlockIds: [...restart],
-				unreadableBlocks: [...unreadable]
+				unreadableBlocks: [...unreadable],
+				retiredBlockIds: [...this.retiredBlockIds]
 			});
 			if (this.failedApplies > 0) {
 				this.deps.logger.info("the composer answered again", { meta: { failedApplies: this.failedApplies } });
@@ -402,6 +434,7 @@ var BlockSupervisor = class {
 			}
 			this.pendingCompositionRestarts = new Set([...this.pendingCompositionRestarts].filter((id) => !restart.has(id)));
 			this.emptyAppliesOwed = !nothingToSay || !result.acted ? 2 : Math.max(0, this.emptyAppliesOwed - 1);
+			this.noteRelease(result);
 			const verdicts = new Map(result.blocks.map((v) => [v.blockId, v]));
 			for (const { block } of compositions) {
 				const verdict = verdicts.get(block.id);
@@ -409,13 +442,39 @@ var BlockSupervisor = class {
 				else await this.report(block.id, verdict.status, verdict.reason);
 			}
 		} catch (err) {
+			const error = require_dist.errMsg(err);
+			this.releaseReport = {
+				error,
+				unreleased: []
+			};
 			this.failedApplies += 1;
 			if (this.failedApplies === 1) this.deps.logger.warn("the composer could not be reached — compositions keep their last status", { meta: {
-				error: require_dist.errMsg(err),
+				error,
 				compositions: compositions.length
 			} });
-			for (const { block } of compositions) if (block.status === "stopped" && block.enabled) await this.report(block.id, "starting", `the composer is not reachable yet: ${require_dist.errMsg(err)}`);
+			for (const { block } of compositions) if (block.status === "stopped" && block.enabled) await this.report(block.id, "starting", `the composer is not reachable yet: ${error}`);
+		}
+	}
+	claimsOf(blockId) {
+		if (this.releaseReport.error !== null) throw new Error(`core-blocks: claims of "${blockId}" were not released — ${this.releaseReport.error}`);
+		return this.releaseReport.unreleased.filter((claim) => claim.owner === blockId);
+	}
+	/** Remember which retired ids still hold a claim. An apply that did not act keeps every id. */
+	noteRelease(result) {
+		const unreleased = result.unreleasedClaims ?? [];
+		if (!result.acted) {
+			this.releaseReport = {
+				error: "the composer did not apply — claims stay until it does",
+				unreleased
+			};
+			return;
 		}
+		this.releaseReport = {
+			error: null,
+			unreleased
+		};
+		const failed = new Set(unreleased.map((claim) => claim.owner));
+		this.retiredBlockIds = new Set([...this.retiredBlockIds].filter((id) => failed.has(id)));
 	}
 	/** Compile, write the package, spawn. Each failure is reported ON the block
 	*  — the author asked for this to run, so they are owed the reason it does
@@ -2082,7 +2141,21 @@ function buildCompositionApi(deps) {
 				blockId,
 				by: caller.userId
 			} });
-			deps.convergeSoon();
+			if (block.composition !== void 0) {
+				const unreleased = (await deps.convergeForClaims()).filter((claim) => claim.owner === blockId);
+				if (unreleased.length > 0) {
+					for (const claim of unreleased) deps.logger.error("composition saved but a replaced claim was not released", {
+						tags: { deviceId: claim.deviceId },
+						meta: {
+							blockId,
+							cap: claim.capName,
+							error: claim.error
+						}
+					});
+					const detail = unreleased.map((claim) => `${claim.capName} on device ${claim.deviceId}: ${claim.error}`).join("; ");
+					throw new Error(`core-blocks: "${blockId}" was saved but a replaced claim was not released — ${detail}`);
+				}
+			} else deps.convergeSoon();
 			return { block: updated };
 		}),
 		getComposition: async ({ blockId }) => {
@@ -2458,9 +2531,30 @@ var CoreBlocksAddon = class extends require_dist.BaseAddon {
 				return { block: updated };
 			},
 			delete: async ({ blockId }) => {
+				const existing = this.requireStore().get(blockId);
+				const composition = existing !== null && require_dist.coreBlockComposition(existing) !== null;
 				await this.requireStore().delete(blockId);
 				await this.requirePrefs().delete(blockId);
-				this.convergeSoon();
+				if (composition && this.supervisor === null) {
+					this.ctx.logger.error("composition deleted but no supervisor can release its claims", { meta: { blockId } });
+					throw new Error(`core-blocks: "${blockId}" was deleted but no supervisor runs here — its claims were not released`);
+				}
+				if (composition && this.supervisor !== null) {
+					const unreleased = await this.supervisor.retireComposition(blockId);
+					if (unreleased.length > 0) {
+						for (const claim of unreleased) this.ctx.logger.error("composition deleted but its claim was not released", {
+							tags: { deviceId: claim.deviceId },
+							meta: {
+								blockId,
+								cap: claim.capName,
+								owner: claim.owner,
+								error: claim.error
+							}
+						});
+						const detail = unreleased.map((claim) => `${claim.capName} on device ${claim.deviceId}: ${claim.error}`).join("; ");
+						throw new Error(`core-blocks: "${blockId}" was deleted but its claims were not released — ${detail}`);
+					}
+				} else this.convergeSoon();
 				return { success: true };
 			},
 			setEnabled: async ({ blockId, enabled }) => {
@@ -2469,9 +2563,9 @@ var CoreBlocksAddon = class extends require_dist.BaseAddon {
 				return { block: updated };
 			},
 			/**
-			* Awaited, unlike every other write here.
+			* Awaited, like a composition delete.
 			*
-			* `create`/`update` deliberately do not wait — the write is already
+			* `create`/`update` of a code block deliberately do not wait — the write is already
 			* durable and converging forks a process. A restart has no durable half:
 			* the whole thing IS the converge, so returning before it ran would hand
 			* the operator the old status and read as "nothing happened".
@@ -2552,6 +2646,10 @@ var CoreBlocksAddon = class extends require_dist.BaseAddon {
 			lookupCap: require_dist.buildCapabilityLookup(require_dist.ALL_CAPABILITY_DEFINITIONS),
 			composerStates: async (blockIds) => (await requireApi().composer.getStates.query({ blockIds: [...blockIds] })).states,
 			convergeSoon: () => this.convergeSoon(),
+			convergeForClaims: () => {
+				if (this.supervisor === null) return Promise.reject(/* @__PURE__ */ new Error("core-blocks: no block supervisor runs on this node — claims cannot be released"));
+				return this.supervisor.convergeForClaims();
+			},
 			logger: this.ctx.logger.child("compositions"),
 			capabilityDefinitions: require_dist.ALL_CAPABILITY_DEFINITIONS
 		});