@camstack/system 1.2.317 → 1.2.319

package/dist/builtins/system-backup/system-backup.service.d.ts

@@ -160,20 +160,6 @@ export declare class SystemBackupService {
         signal?: AbortSignal;
         onArchiveBytes?: (bytesWritten: number) => void;
     }): Promise<CreateArchiveResult>;
-    /**
-     * Best-effort `wal_checkpoint(TRUNCATE)` on every live SQLite database
-     * under the locations about to be archived. Discovers a DB by its
-     * `-wal` sidecar (only WAL-mode DBs have one, and only those need
-     * folding), opens a short-lived second connection — SQLite permits
-     * concurrent connections, and a checkpoint is a supported concurrent
-     * operation against the hub's live writer — checkpoints, and closes.
-     *
-     * Every failure is swallowed: a `SQLITE_BUSY`, a locked file, a
-     * missing native binding, or a non-DB `.db` file must not fail the
-     * backup. A residual WAL still restores correctly; the checkpoint is a
-     * consistency *improvement*, not a precondition.
-     */
-    private checkpointDatabasesUnder;
     /**
      * without extracting payload files. Streams the tar.gz, parses the
      * one entry we care about, then aborts.
@@ -213,9 +199,8 @@ export declare class SystemBackupService {
     private getRestoreMarkerPath;
     /**
      * Absolute-path form of {@link isExcludedFromBackup}, anchored on
-     * this service's dataDir. Shared by the manifest walk, the location
-     * stats and the WAL-checkpoint scan so all three agree with the tar
-     * filter about what a backup contains.
+     * this service's dataDir. Shared by the manifest walk and the location
+     * stats so both agree with the tar filter about what a backup contains.
      */
     private exclusionPredicate;
 }

package/dist/builtins/system-config/system-config.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-a6p0V-IL.js");
+const require_dist = require("../../dist-Dcy0gVHu.js");
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/system-config/system-config.addon.mjs

@@ -1,4 +1,4 @@
-import { Gn as BaseAddon, Wn as errMsg, ar as hydrateSchema } from "../../dist-Dori4pf3.mjs";
+import { Gn as BaseAddon, Wn as errMsg, ar as hydrateSchema } from "../../dist-CQ9vXSUh.mjs";
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

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

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-a6p0V-IL.js");
+const require_dist = require("../../dist-Dcy0gVHu.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

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

@@ -1,4 +1,4 @@
-import { Gn as BaseAddon, Rt as logDestinationCapability } from "../../dist-Dori4pf3.mjs";
+import { Gn as BaseAddon, Rt as logDestinationCapability } from "../../dist-CQ9vXSUh.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";

package/dist/{composition-sources-Dep7nBwu.js → composition-sources-BjRPhWtU.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-a6p0V-IL.js");
+const require_dist = require("./dist-Dcy0gVHu.js");
 //#region src/builtins/core-blocks/composition-sources.ts
 /**
 * Describe what a composition reads and writes for SAVE-time validation

package/dist/{composition-sources-DVClu006.mjs → composition-sources-Cg2MP-qf.mjs}

@@ -1,4 +1,4 @@
-import { In as compositionSourceKey, Wn as errMsg } from "./dist-Dori4pf3.mjs";
+import { In as compositionSourceKey, Wn as errMsg } from "./dist-CQ9vXSUh.mjs";
 //#region src/builtins/core-blocks/composition-sources.ts
 /**
 * Describe what a composition reads and writes for SAVE-time validation

package/dist/{dist-Dori4pf3.mjs → dist-CQ9vXSUh.mjs}

@@ -20903,6 +20903,102 @@ var oauthIntegrationCapability = {
 getDescriptor: method(z.void(), OauthIntegrationDescriptorSchema, { auth: "admin" }) }
 };
 /**
+* What started a camera's onboard motion (D672). `camera` is the camera's own
+* firmware; `sensor` is a device the operator ATTACHED to it. Absent on the
+* wire means the camera: only the camera-sensors bridge ever says `sensor`.
+*/
+var MotionTriggeredBySchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("camera") }), z.object({
+	kind: z.literal("sensor"),
+	deviceId: z.number().int().positive()
+})]);
+Object.freeze({ kind: "camera" });
+var CameraSensorRefSchema = z.object({
+	addonId: z.string().min(1),
+	stableId: z.string().min(1)
+});
+function cameraSensorRefKey(ref) {
+	return `${ref.addonId}/${ref.stableId}`;
+}
+/** CS-1 accepts exactly one mode; CS-2 (D673) widens it to confirm / replace. */
+var CameraSensorsModeSchema = z.enum(["in-addition"]);
+z.object({
+	mode: CameraSensorsModeSchema,
+	sensors: z.array(CameraSensorRefSchema).min(1).max(8)
+}).superRefine((value, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	value.sensors.forEach((ref, index) => {
+		const key = cameraSensorRefKey(ref);
+		if (seen.has(key)) ctx.addIssue({
+			code: "custom",
+			path: ["sensors", index],
+			message: `duplicate camera sensor ${key}`
+		});
+		seen.add(key);
+	});
+});
+var RefFields = {
+	addonId: z.string(),
+	stableId: z.string()
+};
+var CameraSensorAttachmentSchema = z.discriminatedUnion("state", [
+	z.object({
+		...RefFields,
+		state: z.literal("ready"),
+		deviceId: z.number(),
+		name: z.string(),
+		caps: z.array(z.string()).readonly()
+	}),
+	z.object({
+		...RefFields,
+		state: z.literal("offline"),
+		deviceId: z.number(),
+		name: z.string(),
+		reason: z.enum(["offline", "disabled"])
+	}),
+	z.object({
+		...RefFields,
+		state: z.literal("missing"),
+		reason: z.string()
+	}),
+	z.object({
+		...RefFields,
+		state: z.literal("unsupported"),
+		deviceId: z.number(),
+		name: z.string(),
+		reason: z.string()
+	}),
+	z.object({
+		...RefFields,
+		state: z.literal("unreadable"),
+		reason: z.string()
+	})
+]);
+/**
+* Why a configured camera forwards NOTHING from its sensors, however ready they
+* are (D672): it does not list `onboard` in `motionSources` (attaching a sensor
+* does not add it), or it has no active detection config at all (the bridge
+* reads the active config). Absent = forwarded, or an older node that does not
+* say.
+*/
+var CameraSensorsNotForwardedSchema = z.enum(["onboard-not-listed", "no-active-detection"]);
+var CameraSensorsStatusSchema = z.discriminatedUnion("state", [
+	z.object({ state: z.literal("not-configured") }),
+	z.object({
+		state: z.literal("unreadable"),
+		reason: z.string()
+	}),
+	z.object({
+		state: z.literal("configured"),
+		mode: CameraSensorsModeSchema,
+		sensors: z.array(CameraSensorAttachmentSchema).readonly(),
+		notForwarded: CameraSensorsNotForwardedSchema.optional()
+	})
+]);
+Object.freeze({
+	state: "unreadable",
+	reason: "camera sensor mappings not loaded"
+});
+/**
 * A model choice has a SCOPE, and a scope change has a workflow.
 *
 * ## The two scopes
@@ -21651,6 +21747,12 @@ var MotionEventSchema = z.object({
 	/** Populated by B5 (recording playback URL for this event). */
 	mediaUrl: z.string().optional(),
 	/**
+	* The FIRST trigger of an `onboard` episode, written once at open (D672).
+	* Absent = not recorded (a row written before D672, or an analyzer /
+	* device-activity episode) — never read as "the camera" (D393).
+	*/
+	triggeredBy: MotionTriggeredBySchema.optional(),
+	/**
 	* One row per motion EPISODE, not one per push (D475). `null` while the
 	* episode is still open — a further rising edge extends it in place rather
 	* than inserting a new row. Set once, at close, to `lastOnAt - startedAt`
@@ -24860,6 +24962,23 @@ var MotionSourceEnum = z.enum([
 */
 var MotionSourcesSchema = z.array(MotionSourceEnum);
 /**
+* The operator-facing name of each MOTION source (D672: `onboard` = the
+* camera's sensors — its own motion plus any sensor attached to it). The wire
+* value stays `onboard`; only the label changed. `detectionSources: 'onboard'`
+* ("Camera onboard AI") and the notification source filter keep their labels.
+*/
+var MOTION_SOURCE_LABELS = {
+	analyzer: "Frame-diff Analyzer (motion addon)",
+	onboard: "Camera sensors",
+	"device-activity": "Device activity (the device says it is working)"
+};
+/** The order the motion-source picker offers them in (not the enum's order). */
+var MOTION_SOURCE_PICKER_ORDER = [
+	"analyzer",
+	"onboard",
+	"device-activity"
+];
+/**
 * Which root detector a camera runs — EXACTLY ONE.
 *
 * Deliberately the SAME vocabulary post-analysis already tags every detection
@@ -25206,7 +25325,14 @@ var RunnerCameraConfigSchema = z.object({
 	*/
 	inferenceDevices: z.array(RunnerInferenceDeviceSchema).readonly().optional()
 });
-motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, maxSessionHoldMsField.min, maxSessionHoldMsField.max, maxSessionHoldMsField.step, maxSessionHoldMsField.default, audioMotionWindowMsField.min, audioMotionWindowMsField.max, audioMotionWindowMsField.step, audioMotionWindowMsField.default, preRollInferenceFramesField.min, preRollInferenceFramesField.max, preRollInferenceFramesField.step, preRollInferenceFramesField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
+MOTION_SOURCE_PICKER_ORDER.map((value) => value === "onboard" ? {
+	value,
+	label: MOTION_SOURCE_LABELS[value],
+	description: "The camera's own motion, plus any sensor attached to it"
+} : {
+	value,
+	label: MOTION_SOURCE_LABELS[value]
+}), motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, maxSessionHoldMsField.min, maxSessionHoldMsField.max, maxSessionHoldMsField.step, maxSessionHoldMsField.default, audioMotionWindowMsField.min, audioMotionWindowMsField.max, audioMotionWindowMsField.step, audioMotionWindowMsField.default, preRollInferenceFramesField.min, preRollInferenceFramesField.max, preRollInferenceFramesField.step, preRollInferenceFramesField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
 /**
 * Runtime load summary returned by `getLocalLoad`. Used by the orchestrator's
 * load-balancing levels (L2 capacity-based, L3 hardware-aware) to decide
@@ -26002,6 +26128,11 @@ var CameraStatusSchema = z.object({
 	*/
 	switchedOff: z.array(CameraSwitchIdSchema).readonly(),
 	/**
+	* The camera's attached sensors (D672). Optional only for a status composed
+	* by an orchestrator older than D672; this orchestrator always sets it.
+	*/
+	cameraSensors: CameraSensorsStatusSchema.optional(),
+	/**
 	* Stages of the bounded fan-out that were CUT SHORT — a timeout or a
 	* rejection — and whose block is therefore `null` because we could not
 	* READ it, not because there is nothing there.
@@ -35248,7 +35379,9 @@ var MotionOnMotionChangedDataSchema = z.object({
 	detected: z.boolean(),
 	timestamp: z.number(),
 	source: MotionSourceEnum,
-	regions: z.array(MotionRegionSchema).readonly().optional()
+	regions: z.array(MotionRegionSchema).readonly().optional(),
+	/** Who started it (D672). Absent = the camera itself. Only `onboard` carries `sensor`. */
+	triggeredBy: MotionTriggeredBySchema.optional()
 });
 var motionCapability = {
 	name: "motion",

package/dist/{dist-a6p0V-IL.js → dist-Dcy0gVHu.js}

@@ -20903,6 +20903,102 @@ var oauthIntegrationCapability = {
 getDescriptor: method(zod.z.void(), OauthIntegrationDescriptorSchema, { auth: "admin" }) }
 };
 /**
+* What started a camera's onboard motion (D672). `camera` is the camera's own
+* firmware; `sensor` is a device the operator ATTACHED to it. Absent on the
+* wire means the camera: only the camera-sensors bridge ever says `sensor`.
+*/
+var MotionTriggeredBySchema = zod.z.discriminatedUnion("kind", [zod.z.object({ kind: zod.z.literal("camera") }), zod.z.object({
+	kind: zod.z.literal("sensor"),
+	deviceId: zod.z.number().int().positive()
+})]);
+Object.freeze({ kind: "camera" });
+var CameraSensorRefSchema = zod.z.object({
+	addonId: zod.z.string().min(1),
+	stableId: zod.z.string().min(1)
+});
+function cameraSensorRefKey(ref) {
+	return `${ref.addonId}/${ref.stableId}`;
+}
+/** CS-1 accepts exactly one mode; CS-2 (D673) widens it to confirm / replace. */
+var CameraSensorsModeSchema = zod.z.enum(["in-addition"]);
+zod.z.object({
+	mode: CameraSensorsModeSchema,
+	sensors: zod.z.array(CameraSensorRefSchema).min(1).max(8)
+}).superRefine((value, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	value.sensors.forEach((ref, index) => {
+		const key = cameraSensorRefKey(ref);
+		if (seen.has(key)) ctx.addIssue({
+			code: "custom",
+			path: ["sensors", index],
+			message: `duplicate camera sensor ${key}`
+		});
+		seen.add(key);
+	});
+});
+var RefFields = {
+	addonId: zod.z.string(),
+	stableId: zod.z.string()
+};
+var CameraSensorAttachmentSchema = zod.z.discriminatedUnion("state", [
+	zod.z.object({
+		...RefFields,
+		state: zod.z.literal("ready"),
+		deviceId: zod.z.number(),
+		name: zod.z.string(),
+		caps: zod.z.array(zod.z.string()).readonly()
+	}),
+	zod.z.object({
+		...RefFields,
+		state: zod.z.literal("offline"),
+		deviceId: zod.z.number(),
+		name: zod.z.string(),
+		reason: zod.z.enum(["offline", "disabled"])
+	}),
+	zod.z.object({
+		...RefFields,
+		state: zod.z.literal("missing"),
+		reason: zod.z.string()
+	}),
+	zod.z.object({
+		...RefFields,
+		state: zod.z.literal("unsupported"),
+		deviceId: zod.z.number(),
+		name: zod.z.string(),
+		reason: zod.z.string()
+	}),
+	zod.z.object({
+		...RefFields,
+		state: zod.z.literal("unreadable"),
+		reason: zod.z.string()
+	})
+]);
+/**
+* Why a configured camera forwards NOTHING from its sensors, however ready they
+* are (D672): it does not list `onboard` in `motionSources` (attaching a sensor
+* does not add it), or it has no active detection config at all (the bridge
+* reads the active config). Absent = forwarded, or an older node that does not
+* say.
+*/
+var CameraSensorsNotForwardedSchema = zod.z.enum(["onboard-not-listed", "no-active-detection"]);
+var CameraSensorsStatusSchema = zod.z.discriminatedUnion("state", [
+	zod.z.object({ state: zod.z.literal("not-configured") }),
+	zod.z.object({
+		state: zod.z.literal("unreadable"),
+		reason: zod.z.string()
+	}),
+	zod.z.object({
+		state: zod.z.literal("configured"),
+		mode: CameraSensorsModeSchema,
+		sensors: zod.z.array(CameraSensorAttachmentSchema).readonly(),
+		notForwarded: CameraSensorsNotForwardedSchema.optional()
+	})
+]);
+Object.freeze({
+	state: "unreadable",
+	reason: "camera sensor mappings not loaded"
+});
+/**
 * A model choice has a SCOPE, and a scope change has a workflow.
 *
 * ## The two scopes
@@ -21651,6 +21747,12 @@ var MotionEventSchema = zod.z.object({
 	/** Populated by B5 (recording playback URL for this event). */
 	mediaUrl: zod.z.string().optional(),
 	/**
+	* The FIRST trigger of an `onboard` episode, written once at open (D672).
+	* Absent = not recorded (a row written before D672, or an analyzer /
+	* device-activity episode) — never read as "the camera" (D393).
+	*/
+	triggeredBy: MotionTriggeredBySchema.optional(),
+	/**
 	* One row per motion EPISODE, not one per push (D475). `null` while the
 	* episode is still open — a further rising edge extends it in place rather
 	* than inserting a new row. Set once, at close, to `lastOnAt - startedAt`
@@ -24860,6 +24962,23 @@ var MotionSourceEnum = zod.z.enum([
 */
 var MotionSourcesSchema = zod.z.array(MotionSourceEnum);
 /**
+* The operator-facing name of each MOTION source (D672: `onboard` = the
+* camera's sensors — its own motion plus any sensor attached to it). The wire
+* value stays `onboard`; only the label changed. `detectionSources: 'onboard'`
+* ("Camera onboard AI") and the notification source filter keep their labels.
+*/
+var MOTION_SOURCE_LABELS = {
+	analyzer: "Frame-diff Analyzer (motion addon)",
+	onboard: "Camera sensors",
+	"device-activity": "Device activity (the device says it is working)"
+};
+/** The order the motion-source picker offers them in (not the enum's order). */
+var MOTION_SOURCE_PICKER_ORDER = [
+	"analyzer",
+	"onboard",
+	"device-activity"
+];
+/**
 * Which root detector a camera runs — EXACTLY ONE.
 *
 * Deliberately the SAME vocabulary post-analysis already tags every detection
@@ -25206,7 +25325,14 @@ var RunnerCameraConfigSchema = zod.z.object({
 	*/
 	inferenceDevices: zod.z.array(RunnerInferenceDeviceSchema).readonly().optional()
 });
-motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, maxSessionHoldMsField.min, maxSessionHoldMsField.max, maxSessionHoldMsField.step, maxSessionHoldMsField.default, audioMotionWindowMsField.min, audioMotionWindowMsField.max, audioMotionWindowMsField.step, audioMotionWindowMsField.default, preRollInferenceFramesField.min, preRollInferenceFramesField.max, preRollInferenceFramesField.step, preRollInferenceFramesField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
+MOTION_SOURCE_PICKER_ORDER.map((value) => value === "onboard" ? {
+	value,
+	label: MOTION_SOURCE_LABELS[value],
+	description: "The camera's own motion, plus any sensor attached to it"
+} : {
+	value,
+	label: MOTION_SOURCE_LABELS[value]
+}), motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, maxSessionHoldMsField.min, maxSessionHoldMsField.max, maxSessionHoldMsField.step, maxSessionHoldMsField.default, audioMotionWindowMsField.min, audioMotionWindowMsField.max, audioMotionWindowMsField.step, audioMotionWindowMsField.default, preRollInferenceFramesField.min, preRollInferenceFramesField.max, preRollInferenceFramesField.step, preRollInferenceFramesField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
 /**
 * Runtime load summary returned by `getLocalLoad`. Used by the orchestrator's
 * load-balancing levels (L2 capacity-based, L3 hardware-aware) to decide
@@ -26002,6 +26128,11 @@ var CameraStatusSchema = zod.z.object({
 	*/
 	switchedOff: zod.z.array(CameraSwitchIdSchema).readonly(),
 	/**
+	* The camera's attached sensors (D672). Optional only for a status composed
+	* by an orchestrator older than D672; this orchestrator always sets it.
+	*/
+	cameraSensors: CameraSensorsStatusSchema.optional(),
+	/**
 	* Stages of the bounded fan-out that were CUT SHORT — a timeout or a
 	* rejection — and whose block is therefore `null` because we could not
 	* READ it, not because there is nothing there.
@@ -35248,7 +35379,9 @@ var MotionOnMotionChangedDataSchema = zod.z.object({
 	detected: zod.z.boolean(),
 	timestamp: zod.z.number(),
 	source: MotionSourceEnum,
-	regions: zod.z.array(MotionRegionSchema).readonly().optional()
+	regions: zod.z.array(MotionRegionSchema).readonly().optional(),
+	/** Who started it (D672). Absent = the camera itself. Only `onboard` carries `sensor`. */
+	triggeredBy: MotionTriggeredBySchema.optional()
 });
 var motionCapability = {
 	name: "motion",

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-a6p0V-IL.js");
+const require_dist = require("./dist-Dcy0gVHu.js");
 const require_builtins_alerts_alerts_addon = require("./builtins/alerts/alerts.addon.js");
 require("./builtins/alerts/index.js");
 const require_builtins_composer_composer_addon = require("./builtins/composer/composer.addon.js");

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM$1, r as __exportAll, t as __commonJSMin$1 } from "./chunk-CNf5ZN-e.mjs";
-import { $n as asNumber, Bt as looseSchema, C as METHOD_ACCESS_MAP, Dt as isCollectionArrayMethod, Et as isArrayOutputSchema, Ft as lifecycleJobSchema, Jn as DEVICE_STATUS_METHOD, Jt as objectInputDeclaresRequiredDeviceId, Kn as DATAPLANE_SECRET_HEADER$1, Mt as kebabToCamel, O as RUNTIME_DEFAULTS, Qn as asJsonObject$1, Qt as procedureAuthKey, Wn as errMsg$1, Xn as ReadinessTimeoutError, Yn as ReadinessRegistry, b as LOG_LEVEL_RANK, dr as readinessKey, er as asString$1, fr as resolveCapMount, hr as EventCategory$1, in as resolveMethodAuth, ir as expandCapMethods, jt as isVoidInput, kt as isObjectInput, lr as parseJsonObject, nr as emitDownForOwnedCaps, on as scopesAllowAddon, pr as scopeKey, qn as DEVICE_SETTINGS_CONTRIBUTION_METHODS, qt as objectInputDeclaresAddonId, sn as scopesAllowDeviceCap, t as ALL_CAPABILITY_DEFINITIONS, tr as createEvent, ur as parseJsonUnknown, xt as extractNestedAddonId, z as addonSettingsCapability, zt as logLevelAtMost } from "./dist-Dori4pf3.mjs";
+import { $n as asNumber, Bt as looseSchema, C as METHOD_ACCESS_MAP, Dt as isCollectionArrayMethod, Et as isArrayOutputSchema, Ft as lifecycleJobSchema, Jn as DEVICE_STATUS_METHOD, Jt as objectInputDeclaresRequiredDeviceId, Kn as DATAPLANE_SECRET_HEADER$1, Mt as kebabToCamel, O as RUNTIME_DEFAULTS, Qn as asJsonObject$1, Qt as procedureAuthKey, Wn as errMsg$1, Xn as ReadinessTimeoutError, Yn as ReadinessRegistry, b as LOG_LEVEL_RANK, dr as readinessKey, er as asString$1, fr as resolveCapMount, hr as EventCategory$1, in as resolveMethodAuth, ir as expandCapMethods, jt as isVoidInput, kt as isObjectInput, lr as parseJsonObject, nr as emitDownForOwnedCaps, on as scopesAllowAddon, pr as scopeKey, qn as DEVICE_SETTINGS_CONTRIBUTION_METHODS, qt as objectInputDeclaresAddonId, sn as scopesAllowDeviceCap, t as ALL_CAPABILITY_DEFINITIONS, tr as createEvent, ur as parseJsonUnknown, xt as extractNestedAddonId, z as addonSettingsCapability, zt as logLevelAtMost } from "./dist-CQ9vXSUh.mjs";
 import { AlertCenterAddon } from "./builtins/alerts/alerts.addon.mjs";
 import "./builtins/alerts/index.mjs";
 import { ComposerAddon } from "./builtins/composer/composer.addon.mjs";

package/dist/{retired-settings-keys-DVcKRgzm.mjs → retired-settings-keys-DNIbyfTR.mjs}

@@ -1,4 +1,4 @@
-import { Qn as asJsonObject } from "./dist-Dori4pf3.mjs";
+import { Qn as asJsonObject } from "./dist-CQ9vXSUh.mjs";
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/dist/{retired-settings-keys-DC1uHWPZ.js → retired-settings-keys-pzlrLUbA.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-a6p0V-IL.js");
+const require_dist = require("./dist-Dcy0gVHu.js");
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/dist/wal-checkpoint-policy-BahrTtyD.mjs

@@ -0,0 +1,186 @@
+//#region src/builtins/sqlite-storage/wal-checkpoint-policy.ts
+/**
+* When the checkpoint worker folds the WAL — the judgement, pure.
+*
+* ## Why a worker checkpoints at all
+*
+* `hub/sqlite-settings` is one JS thread with a synchronous binding, and every
+* configuration read in the cluster queues behind whatever statement it is
+* inside. With `journal_mode = WAL` and the build default `synchronous =
+* NORMAL`, an ordinary commit is an append to the WAL with NO fsync. The
+* fsyncs — the only thing in a one-row write that can take seconds — happen
+* at the CHECKPOINT: the WAL is synced before the pages are copied, the
+* database file after. And SQLite runs the auto-checkpoint (1000 pages)
+* INSIDE the commit of whichever writer crosses the threshold.
+*
+* Measured on the hub, 2026-09-11 10:45–10:55 CEST, from outside the process
+* (`/proc/<pid>/syscall` at 10 Hz + the wal-index header at 1 Hz, D452): the
+* WAL refilled at ~54 frames/s, the auto-checkpoint fired every 12–25 s (42
+* in 9.5 min), and every D-state run on the settings thread that sat in a
+* syscall sat in `fsync` (74), each within ±2 s of a checkpoint event —
+* 12.6 s of the 569 s window, all of it inside writers' commits. In the two
+* saturated bursts earlier that morning (08:35–08:40, 09:30–09:39) the same
+* fsync took 1–10 s, once per checkpoint, and the profiler filed each as a
+* slow `set`. `synchronous` was never the lever: it was already NORMAL, and
+* `sqlite-pragmas.ts` had said so since 2026-08-08.
+*
+* So the checkpoint runs on a worker thread, over its own connection. The
+* settings thread's commits stay appends. What stays on the settings thread
+* is the WAL-header sync SQLite performs when a WAL is reused after a
+* completed checkpoint — one small fsync per cycle — and that residual is
+* named here so nobody reads "no fsync on the settings thread" into this.
+*
+* ## The rule this file reproduces
+*
+* The auto-checkpoint's own rule: fold when 1000 frames are pending. The
+* point of moving the checkpoint is to change WHO waits on the disk, not how
+* often the disk is asked to sync — a worker that folded every second would
+* multiply the fsync count on a drive the media plane already saturates.
+*
+* ## How the worker knows how much is pending — and how it must NOT learn it
+*
+* Until 2026-09-29 the worker read the wal-index header straight out of the
+* `-shm` file, once a second, with `openSync` / `readSync` / `closeSync`. That
+* `closeSync` was the SIGBUS of D468 (corrected by D679): on POSIX, closing
+* ANY descriptor of a file drops EVERY fcntl lock the process holds on that
+* file — including the shared lock on `-shm` byte 128 (the "DMS" lock) that
+* SQLite takes for the life of a connection and that tells every OTHER
+* process "a live connection is using this wal-index, do not rebuild it". With
+* the lock gone, the next process to open the database believed it was
+* first, truncated and re-initialised the `-shm` under the runner's mappings,
+* and the runner's next write past a 32 KiB wal-index region hit a page
+* beyond end-of-file.
+*
+* So the worker never touches a SQLite file except through its connection.
+* What it knows about the WAL it learns from the checkpoint it just ran:
+* `PRAGMA wal_checkpoint(PASSIVE)` answers `log` (frames in the WAL) and
+* `checkpointed` (frames now backfilled). Two consecutive answers give the
+* frames appended between them, hence a rate, hence WHEN the next 1000 frames
+* will have accumulated. The next checkpoint is scheduled for then —
+* {@link nextCheckpointPlan} — clamped between the worker's poll interval and
+* {@link WAL_CHECKPOINT_MAX_DELAY_MS}. A PASSIVE with nothing to fold performs
+* no fsync (the copy and both syncs sit behind `nBackfill < mxFrame` in
+* `wal.c`), so the clamp costs a quiet database nothing, and it bounds how
+* long a burst that follows a quiet spell goes unseen.
+*/
+/** The engine's own `wal_autocheckpoint` default, in frames. Reproduced, not changed. */
+var WAL_CHECKPOINT_THRESHOLD_FRAMES = 1e3;
+/**
+* Longest the worker waits between two checkpoints, in ms, whatever the
+* measured rate says. It is the bound on how late a burst after a steady or
+* quiet spell is noticed, and it is sized against the engine's own fallback
+* (`SQLITE_WAL_AUTOCHECKPOINT_BOUND_PAGES` = 10 000 frames), which runs INSIDE
+* a settings-thread commit — the stall D452 moved off that thread. No burst
+* rate has been measured on the hub (D452's 54 frames/s is the steady rate),
+* so the design point is 1 000 frames/s, ~18× steady: 8 s of it is 8 000
+* frames, under the fallback, so the worker looks before the engine has to.
+* A pass that finds more than {@link WAL_CHECKPOINT_LARGE_PASS_FRAMES} is
+* reported so this number can be tuned from the field.
+*
+* The cost, stated against D452: at the steady 54 frames/s the threshold
+* would fold every ~18.5 s; this clamp folds every 8 s, ~2.3× the fsync pairs
+* (≈ 432 frames per fold instead of 1 000). They are paid on the WORKER, a
+* thread nobody waits on — the settings thread's commits stay appends. A pass
+* with nothing pending does no fsync at all.
+*/
+var WAL_CHECKPOINT_MAX_DELAY_MS = 8e3;
+/**
+* A pass that folded more than this many appended frames is reported (WARN,
+* sampled: the first of each summary window, the rest counted). Half the
+* engine's fallback bound: a gap that let this much accumulate was within 2×
+* of handing the checkpoint back to the settings thread.
+*/
+var WAL_CHECKPOINT_LARGE_PASS_FRAMES = 5e3;
+/** Shortest gap between two checkpoints, in ms — the worker's poll interval. */
+var WAL_CHECKPOINT_POLL_MS = 1e3;
+/**
+* A checkpoint that took this long is reported at WARN with its numbers.
+* Matched to `SQLITE_SLOW_CALL_MS`: it is the same "the disk held us" event
+* the profiler used to file as a slow `set`, now on the thread that paid it.
+*/
+var WAL_CHECKPOINT_SLOW_MS = 1e3;
+/**
+* Frames appended to the WAL between two checkpoints.
+*
+* When the previous checkpoint backfilled EVERYTHING, the next writer restarts
+* the WAL from frame 1, so every frame now in it is new. When it did not (a
+* reader pinned a snapshot), the WAL kept growing and the difference is what
+* was added — unless it shrank, which only a restart can do.
+*
+* An IDLE WAL is the exception to "complete means restarted": the WAL restarts
+* only at the next write, so a fully checkpointed WAL nobody writes answers
+* the same `log == checkpointed` pass after pass. Identical answers after a
+* complete checkpoint are therefore 0 appended, not the whole WAL again —
+* otherwise an idle node would be scheduled at the poll interval forever and
+* every summary would count the same frames once per pass. (A restart that
+* appended exactly as many frames as the previous cycle is read as idle too;
+* it is scheduled at the max delay, which is the bounded case anyway.)
+*
+* The one remaining ambiguity — a complete checkpoint followed by writes the
+* writer could NOT restart the WAL for — counts old frames as new, which
+* over-estimates the rate and checkpoints EARLY: the safe direction. `-1`
+* (not a WAL database, or a busy pass) reads as 0.
+*/
+function framesAppendedBetween(previous, current) {
+	const prevWal = Math.max(0, previous.walFrames);
+	const prevDone = Math.max(0, previous.checkpointedFrames);
+	const curWal = Math.max(0, current.walFrames);
+	const curDone = Math.max(0, current.checkpointedFrames);
+	if (prevDone >= prevWal) {
+		if (curWal === prevWal && curDone === prevDone) return 0;
+		return curWal;
+	}
+	return curWal >= prevWal ? curWal - prevWal : curWal;
+}
+/**
+* What the worker "saw" before its first checkpoint: nothing, at the moment it
+* started. Against it, the first checkpoint counts every frame then in the WAL
+* as appended since the start — which over-estimates the rate when the WAL
+* held older frames, and so schedules the second checkpoint EARLY: the safe
+* direction, and the second one measures the real rate.
+*/
+function workerStartObservation(at) {
+	return {
+		at,
+		walFrames: 0,
+		checkpointedFrames: 0
+	};
+}
+/**
+* When to run the next checkpoint: the moment the measured rate says
+* {@link WAL_CHECKPOINT_THRESHOLD_FRAMES} more frames will be pending,
+* clamped to `[minDelayMs, maxDelayMs]`. Nothing appended since the last one
+* is `maxDelayMs`.
+*/
+function nextCheckpointPlan(input) {
+	const { previous, current, minDelayMs, maxDelayMs } = input;
+	const appendedFrames = framesAppendedBetween(previous, current);
+	const elapsedMs = Math.max(1, current.at - previous.at);
+	if (appendedFrames === 0) return {
+		appendedFrames,
+		nextDelayMs: maxDelayMs
+	};
+	const untilThresholdMs = WAL_CHECKPOINT_THRESHOLD_FRAMES / (appendedFrames / elapsedMs);
+	return {
+		appendedFrames,
+		nextDelayMs: Math.round(Math.min(maxDelayMs, Math.max(minDelayMs, untilThresholdMs)))
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Narrow a message off the worker port without a cast. */
+function isWorkerMessage(value) {
+	if (!isRecord(value)) return false;
+	switch (value["kind"]) {
+		case "ready": return true;
+		case "failed": return typeof value["error"] === "string";
+		case "checkpointed": return (value["reason"] === "first" || value["reason"] === "scheduled") && typeof value["appendedFrames"] === "number" && typeof value["nextDelayMs"] === "number" && typeof value["walFrames"] === "number" && typeof value["checkpointedFrames"] === "number" && typeof value["busy"] === "boolean" && typeof value["ms"] === "number";
+		default: return false;
+	}
+}
+function isWorkerStop(value) {
+	return isRecord(value) && value["kind"] === "stop";
+}
+//#endregion
+export { isWorkerMessage as a, workerStartObservation as c, WAL_CHECKPOINT_SLOW_MS as i, WAL_CHECKPOINT_MAX_DELAY_MS as n, isWorkerStop as o, WAL_CHECKPOINT_POLL_MS as r, nextCheckpointPlan as s, WAL_CHECKPOINT_LARGE_PASS_FRAMES as t };