@camstack/system 1.1.50 → 1.1.52

package/dist/builtins/doorbell/virtual-doorbell.addon.mjs

@@ -0,0 +1,483 @@
+import { C as doorbellCapability, _t as createEvent, it as BaseAddon, kt as EventCategory, rt as errMsg, ut as DeviceType } from "../../dist-B_PSvr-m.mjs";
+//#region src/builtins/doorbell/trigger-engine.ts
+var DOORBELL_TRIGGERS = [
+	"contact-open",
+	"contact-close",
+	"switch-on",
+	"event"
+];
+/** Type guard for {@link DoorbellTrigger}. */
+function isDoorbellTrigger(value) {
+	return typeof value === "string" && DOORBELL_TRIGGERS.includes(value);
+}
+/** Cap slices the engine understands as binary trigger sources. */
+var CONTACT_CAP = "contact";
+var SWITCH_CAP = "switch";
+/**
+* Map an observed boolean transition on a source cap to the trigger it
+* satisfies. `null` when the transition has no configured meaning
+* (e.g. switch turning OFF).
+*/
+function edgeToTrigger(capName, value) {
+	if (capName === CONTACT_CAP) return value ? "contact-open" : "contact-close";
+	if (capName === SWITCH_CAP) return value ? "switch-on" : null;
+	return null;
+}
+/** Extract the binary state carried by a contact / switch slice. */
+function sliceBinaryValue(capName, slice) {
+	const raw = capName === CONTACT_CAP ? slice["entryOpen"] : slice["on"];
+	return typeof raw === "boolean" ? raw : null;
+}
+/**
+* Stateful (but side-effect-free towards the outside) trigger engine.
+*
+* Tracks the last observed binary value per (sourceDevice, cap) so a
+* `DeviceStateChanged` re-emission (the slice's `lastChangedAt` moves
+* while the binary value does not) never double-fires, and the FIRST
+* observation after boot only seeds the baseline — a state hydration
+* at startup must not ring anybody's doorbell.
+*/
+var DoorbellTriggerEngine = class {
+	assignments = [];
+	/** Last observed binary value keyed by `${deviceId}:${capName}`. */
+	lastValues = /* @__PURE__ */ new Map();
+	/** Last fire timestamp per camera — debounce bookkeeping. */
+	lastFiredAt = /* @__PURE__ */ new Map();
+	debounceMs;
+	now;
+	constructor(options) {
+		this.debounceMs = options?.debounceMs ?? 2e3;
+		this.now = options?.now ?? Date.now;
+	}
+	/** Replace the full assignment set (rebuilt whenever settings change). */
+	setAssignments(assignments) {
+		this.assignments = [...assignments];
+	}
+	getAssignments() {
+		return this.assignments;
+	}
+	/** True when any assignment references `deviceId` as its source. */
+	hasSource(deviceId) {
+		return this.assignments.some((a) => a.sourceDeviceId === deviceId);
+	}
+	/**
+	* Feed one `DeviceStateChanged` slice. Returns the camera ids whose
+	* doorbell should ring (already debounced). Baseline-only sightings
+	* and non-transitions return an empty array.
+	*/
+	onStateSlice(deviceId, capName, slice) {
+		if (capName !== CONTACT_CAP && capName !== SWITCH_CAP) return [];
+		const value = sliceBinaryValue(capName, slice);
+		if (value === null) return [];
+		const key = `${deviceId}:${capName}`;
+		const prior = this.lastValues.get(key);
+		this.lastValues.set(key, value);
+		if (prior === void 0 || prior === value) return [];
+		const trigger = edgeToTrigger(capName, value);
+		if (!trigger) return [];
+		return this.matchAndDebounce((a) => a.sourceDeviceId === deviceId && a.trigger === trigger);
+	}
+	/**
+	* Feed one event-emitter `onEvent` firing. Returns the camera ids to
+	* ring — assignments with `trigger: 'event'`, a matching source and a
+	* verbatim `eventType` match. An assignment with no configured
+	* eventType never matches (misconfiguration must not ring on every
+	* event the device emits).
+	*/
+	onEmitterEvent(deviceId, eventType) {
+		return this.matchAndDebounce((a) => a.trigger === "event" && a.sourceDeviceId === deviceId && a.eventType !== null && a.eventType.length > 0 && a.eventType === eventType);
+	}
+	matchAndDebounce(predicate) {
+		const now = this.now();
+		const fired = [];
+		for (const assignment of this.assignments) {
+			if (!predicate(assignment)) continue;
+			const last = this.lastFiredAt.get(assignment.cameraId);
+			if (last !== void 0 && now - last < this.debounceMs) continue;
+			this.lastFiredAt.set(assignment.cameraId, now);
+			fired.push(assignment.cameraId);
+		}
+		return fired;
+	}
+};
+//#endregion
+//#region src/builtins/doorbell/virtual-doorbell.addon.ts
+/** Device-store keys (namespaced to avoid collisions in merged stores). */
+var KEY_SOURCE = "doorbellSourceDeviceId";
+var KEY_TRIGGER = "doorbellTrigger";
+var KEY_EVENT_TYPE = "doorbellEventType";
+var DEFAULT_TRIGGER = "contact-open";
+/**
+* Caps whose presence in a device's bindings marks it as a usable
+* doorbell SOURCE — anything with a binary-ish surface. Deliberately
+* not gated on device linking: which device rings which camera is an
+* operator decision.
+*/
+var SOURCE_CAPS = [
+	"contact",
+	"flood",
+	"gas",
+	"carbon-monoxide",
+	"enum-sensor",
+	"event-emitter",
+	"switch"
+];
+/** Reload the camera→source assignment map at most this often (lazily,
+*  on trigger traffic). Covers devices/settings appearing after boot
+*  without a settings save. */
+var ASSIGNMENTS_TTL_MS = 6e4;
+var TRIGGER_LABELS = {
+	"contact-open": "Contact opens",
+	"contact-close": "Contact closes",
+	"switch-on": "Switch turns on",
+	event: "Device event"
+};
+/** Structural narrowing helper for untrusted bus payloads. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Cast-free narrowing of the untyped `device.state-changed` payload
+* (the category is not part of the typed EventCatalog — subscribers
+* validate at the boundary).
+*/
+function parseDeviceStateChanged(data) {
+	if (!isRecord(data)) return null;
+	const deviceId = data["deviceId"];
+	const capName = data["capName"];
+	const slice = data["slice"];
+	if (typeof deviceId !== "number" || typeof capName !== "string") return null;
+	if (!isRecord(slice)) return null;
+	return {
+		deviceId,
+		capName,
+		slice
+	};
+}
+/** Narrow a raw `doorbell` runtime-state slice to counters (defaults on absence). */
+function parseDoorbellSlice(slice) {
+	const lastPressedAtRaw = slice?.["lastPressedAt"];
+	const countRaw = slice?.["pressCountSinceStart"];
+	return {
+		lastPressedAt: typeof lastPressedAtRaw === "number" ? lastPressedAtRaw : null,
+		pressCountSinceStart: typeof countRaw === "number" && Number.isFinite(countRaw) && countRaw >= 0 ? countRaw : 0
+	};
+}
+/**
+* VirtualDoorbellAddon — WRAPPER over the `doorbell` capability.
+*
+* Turns any binary-ish device (contact sensor, switch, event emitter,
+* flood/gas/CO sensor) into a doorbell for a camera:
+*
+*   1. The operator binds the wrapper to a camera in the bindings UI
+*      (`defaultActive: false` — never auto-bound).
+*   2. Per-camera settings pick the SOURCE device + trigger
+*      (`contact-open` / `contact-close` / `switch-on` / `event`
+*      with an event-type match).
+*   3. At runtime the addon watches `EventCategory.DeviceStateChanged`
+*      (contact/switch slice transitions — EDGE detected per trigger)
+*      and `EventCategory.EventEmitted` (event-emitter firings). On a
+*      matching, debounced trigger it emits
+*      `EventCategory.DoorbellOnPressed` with the CAMERA as source
+*      (`{deviceId: cameraId, timestamp}` — the same shape Reolink's
+*      native `emitDoorbellPressed` produces) and bumps the camera's
+*      `doorbell` runtime-state counters via the standard
+*      `deviceState.setCapSlice` plumbing.
+*
+* Fires ONLY for cameras where the wrapper is BOUND (checked against
+* `deviceManager.getBindings`) and a source device is configured.
+*/
+var VirtualDoorbellAddon = class extends BaseAddon {
+	engine;
+	/** Monotonic guard: assignments are reloaded lazily on trigger traffic. */
+	assignmentsLoadedAt = 0;
+	assignmentsLoading = null;
+	constructor() {
+		super({ debounceMs: 2e3 });
+		this.engine = new DoorbellTriggerEngine({ debounceMs: 2e3 });
+	}
+	async onInitialize() {
+		this.ctx.logger.info("Virtual doorbell wrapper initialized");
+		this.subscribe({ category: EventCategory.DeviceStateChanged }, (event) => {
+			const data = parseDeviceStateChanged(event.data);
+			if (!data) return;
+			this.handleStateChanged(data);
+		});
+		this.subscribe({ category: EventCategory.EventEmitted }, (event) => {
+			this.handleEmitterEvent(event.data.deviceId, event.data.eventType);
+		});
+		return [{
+			capability: doorbellCapability,
+			provider: {
+				getStatus: (input) => this.getStatus(input.deviceId),
+				getDeviceSettingsContribution: (input) => this.buildDeviceSettingsContribution(input.deviceId),
+				getDeviceLiveContribution: async () => null,
+				applyDeviceSettingsPatch: (input) => this.saveDeviceSettingsPatch(input.deviceId, input.patch)
+			}
+		}];
+	}
+	async handleStateChanged(data) {
+		if (data.capName !== "contact" && data.capName !== "switch") return;
+		await this.ensureAssignments();
+		const cameraIds = this.engine.onStateSlice(data.deviceId, data.capName, data.slice);
+		for (const cameraId of cameraIds) await this.fireDoorbell(cameraId, Date.now());
+	}
+	async handleEmitterEvent(sourceDeviceId, eventType) {
+		await this.ensureAssignments();
+		const cameraIds = this.engine.onEmitterEvent(sourceDeviceId, eventType);
+		for (const cameraId of cameraIds) await this.fireDoorbell(cameraId, Date.now());
+	}
+	/**
+	* Ring the camera's virtual doorbell: verify the wrapper is BOUND to
+	* the camera, bump the `doorbell` runtime-state counters through the
+	* canonical `deviceState.setCapSlice` write, and emit the typed
+	* `DoorbellOnPressed` event with the CAMERA as source — byte-shaped
+	* like a native firmware ring so every downstream consumer (UI
+	* toast, notifier rules, exporters) is agnostic to the origin.
+	*/
+	async fireDoorbell(cameraId, timestamp) {
+		if (!await this.isWrapperBound(cameraId)) {
+			this.ctx.logger.debug("virtual-doorbell: trigger matched but wrapper not bound — skipping", { tags: { deviceId: cameraId } });
+			return;
+		}
+		try {
+			const next = {
+				lastPressedAt: timestamp,
+				pressCountSinceStart: parseDoorbellSlice(await this.ctx.api.deviceState.getCapSlice.query({
+					deviceId: cameraId,
+					capName: doorbellCapability.name
+				})).pressCountSinceStart + 1
+			};
+			await this.ctx.api.deviceState.setCapSlice.mutate({
+				deviceId: cameraId,
+				capName: doorbellCapability.name,
+				slice: next
+			});
+		} catch (err) {
+			this.ctx.logger.warn("virtual-doorbell: runtime-state update failed", {
+				tags: { deviceId: cameraId },
+				meta: { error: errMsg(err) }
+			});
+		}
+		this.ctx.eventBus.emit(createEvent(EventCategory.DoorbellOnPressed, {
+			type: "device",
+			id: cameraId,
+			deviceId: cameraId,
+			addonId: this.ctx.id
+		}, {
+			deviceId: cameraId,
+			timestamp
+		}));
+		this.ctx.logger.info("virtual-doorbell: pressed", {
+			tags: { deviceId: cameraId },
+			meta: { timestamp }
+		});
+	}
+	/** True when THIS wrapper is the active `doorbell` binding for the camera. */
+	async isWrapperBound(cameraId) {
+		try {
+			return (await this.ctx.api.deviceManager.getBindings.query({ deviceId: cameraId })).entries.some((entry) => entry.capName === doorbellCapability.name && entry.kind === "wrapped" && entry.providerAddonId === this.ctx.id);
+		} catch (err) {
+			this.ctx.logger.debug("virtual-doorbell: getBindings failed — treating as unbound", {
+				tags: { deviceId: cameraId },
+				meta: { error: errMsg(err) }
+			});
+			return false;
+		}
+	}
+	/**
+	* Lazily (re)build the camera→source assignment set from every
+	* camera's device store. TTL-bounded so devices/settings appearing
+	* after boot are picked up without a settings save; invalidated
+	* eagerly by `applyDeviceSettingsPatch`.
+	*/
+	async ensureAssignments() {
+		if (Date.now() - this.assignmentsLoadedAt < ASSIGNMENTS_TTL_MS) return;
+		if (this.assignmentsLoading) return this.assignmentsLoading;
+		this.assignmentsLoading = this.loadAssignments().then(() => {
+			this.assignmentsLoadedAt = Date.now();
+		}).catch((err) => {
+			this.ctx.logger.warn("virtual-doorbell: assignment reload failed", { meta: { error: errMsg(err) } });
+		}).finally(() => {
+			this.assignmentsLoading = null;
+		});
+		return this.assignmentsLoading;
+	}
+	async loadAssignments() {
+		const cameras = (await this.ctx.api.deviceManager.listAll.query({})).filter((d) => d.type === DeviceType.Camera);
+		const assignments = [];
+		for (const camera of cameras) {
+			const settings = await this.readDeviceSettings(camera.id);
+			if (settings.sourceDeviceId === null) continue;
+			assignments.push({
+				cameraId: camera.id,
+				sourceDeviceId: settings.sourceDeviceId,
+				trigger: settings.trigger,
+				eventType: settings.eventType.length > 0 ? settings.eventType : null
+			});
+		}
+		this.engine.setAssignments(assignments);
+		this.ctx.logger.debug("virtual-doorbell: assignments loaded", { meta: { count: assignments.length } });
+	}
+	invalidateAssignments() {
+		this.assignmentsLoadedAt = 0;
+	}
+	/**
+	* Status from the kernel-managed `doorbell` runtime-state slice —
+	* the wrapper keeps NO parallel counter fields (the slice is the
+	* single source of truth, persisted across restarts).
+	*/
+	async getStatus(deviceId) {
+		try {
+			return parseDoorbellSlice(await this.ctx.api.deviceState.getCapSlice.query({
+				deviceId,
+				capName: doorbellCapability.name
+			}));
+		} catch (err) {
+			this.ctx.logger.debug("virtual-doorbell: getCapSlice failed during getStatus", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return null;
+		}
+	}
+	async readDeviceSettings(deviceId) {
+		if (!this.ctx.settings) return {
+			sourceDeviceId: null,
+			trigger: DEFAULT_TRIGGER,
+			eventType: ""
+		};
+		const raw = await this.ctx.settings.readDeviceStore(deviceId);
+		const sourceRaw = raw[KEY_SOURCE];
+		const triggerRaw = raw[KEY_TRIGGER];
+		const eventTypeRaw = raw[KEY_EVENT_TYPE];
+		return {
+			sourceDeviceId: typeof sourceRaw === "number" && Number.isFinite(sourceRaw) && sourceRaw > 0 ? sourceRaw : null,
+			trigger: isDoorbellTrigger(triggerRaw) ? triggerRaw : DEFAULT_TRIGGER,
+			eventType: typeof eventTypeRaw === "string" ? eventTypeRaw : ""
+		};
+	}
+	/**
+	* Single-trip, non-throwing device lookup (mirrors snapshot's
+	* `lookupDeviceMeta`). Null on any failure — callers fall back to
+	* rendering the section (better a spurious section than a thrown
+	* aggregator entry).
+	*/
+	async lookupDevice(deviceId) {
+		try {
+			const found = await this.ctx.api.deviceManager.getDevice.query({ deviceId });
+			return found ? { type: found.type } : null;
+		} catch (err) {
+			this.ctx.logger.debug("virtual-doorbell: getDevice failed during contribution", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return null;
+		}
+	}
+	/**
+	* Settings section for the device-detail page. Camera-only — the
+	* doorbell cap also applies to Button accessories (native providers),
+	* where a virtual-source picker is meaningless.
+	*/
+	async buildDeviceSettingsContribution(deviceId) {
+		const device = await this.lookupDevice(deviceId);
+		if (device && device.type !== DeviceType.Camera) return null;
+		const current = await this.readDeviceSettings(deviceId);
+		return { sections: [{
+			id: "virtual-doorbell",
+			title: "Virtual Doorbell",
+			tab: "doorbell",
+			order: 70,
+			fields: [
+				{
+					type: "select",
+					key: KEY_SOURCE,
+					label: "Source device",
+					description: "Device whose state change rings this camera’s doorbell (contact, switch, sensor, event emitter).",
+					options: await this.listSourceDeviceOptions(),
+					required: true,
+					value: current.sourceDeviceId === null ? "none" : String(current.sourceDeviceId)
+				},
+				{
+					type: "select",
+					key: KEY_TRIGGER,
+					label: "Trigger",
+					description: "Which transition of the source device counts as a ring.",
+					options: DOORBELL_TRIGGERS.map((t) => ({
+						value: t,
+						label: TRIGGER_LABELS[t]
+					})),
+					required: true,
+					value: current.trigger
+				},
+				{
+					type: "text",
+					key: KEY_EVENT_TYPE,
+					label: "Event type",
+					description: "Only used when Trigger is 'Device event' — matched verbatim against the source device's emitted event type (e.g. press_short).",
+					value: current.eventType
+				}
+			]
+		}] };
+	}
+	/**
+	* Cluster-wide picker options: every device whose BINDINGS expose one
+	* of the binary-ish source caps. Binding-sourced (not feature-flag
+	* sourced) because cap names are exactly what the runtime consumes.
+	*/
+	async listSourceDeviceOptions() {
+		const none = {
+			value: "none",
+			label: "None"
+		};
+		try {
+			const [devices, allBindings] = await Promise.all([this.ctx.api.deviceManager.listAll.query({}), this.ctx.api.deviceManager.getAllBindings.query({})]);
+			const eligibleIds = /* @__PURE__ */ new Set();
+			for (const deviceBindings of allBindings) if (deviceBindings.entries.some((e) => SOURCE_CAPS.includes(e.capName))) eligibleIds.add(deviceBindings.deviceId);
+			return [none, ...devices.filter((d) => eligibleIds.has(d.id)).map((d) => ({
+				value: String(d.id),
+				label: `${d.name} (#${d.id})`
+			})).toSorted((a, b) => a.label.localeCompare(b.label))];
+		} catch (err) {
+			this.ctx.logger.warn("virtual-doorbell: source-device enumeration failed", { meta: { error: errMsg(err) } });
+			return [none];
+		}
+	}
+	async saveDeviceSettingsPatch(deviceId, patch) {
+		if (!this.ctx.settings) throw new Error("[virtual-doorbell] settings store unavailable — cannot persist per-device settings");
+		const next = { ...await this.ctx.settings.readDeviceStore(deviceId) };
+		if (KEY_SOURCE in patch) {
+			const parsed = parseSourceDeviceId(patch[KEY_SOURCE]);
+			if (parsed === null) delete next[KEY_SOURCE];
+			else next[KEY_SOURCE] = parsed;
+		}
+		if (KEY_TRIGGER in patch) {
+			const v = patch[KEY_TRIGGER];
+			if (isDoorbellTrigger(v)) next[KEY_TRIGGER] = v;
+			else delete next[KEY_TRIGGER];
+		}
+		if (KEY_EVENT_TYPE in patch) {
+			const v = patch[KEY_EVENT_TYPE];
+			next[KEY_EVENT_TYPE] = typeof v === "string" ? v.trim() : "";
+		}
+		await this.ctx.settings.writeDeviceStore(deviceId, next);
+		this.invalidateAssignments();
+		return { success: true };
+	}
+};
+/**
+* Coerce the select value ('none' | numeric string | number) back to a
+* device id. The select field surfaces string values; a stored value
+* round-trips as a number.
+*/
+function parseSourceDeviceId(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+	if (typeof value === "string" && value !== "none" && value.trim().length > 0) {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	}
+	return null;
+}
+//#endregion
+export { VirtualDoorbellAddon, VirtualDoorbellAddon as default };

package/dist/builtins/hub-forwarder/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CQYo6Zp8.js");
+const require_dist = require("../../dist-BduBhv6N.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 //#region src/builtins/hub-forwarder/hub-forwarder-destination.ts
 var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;

package/dist/builtins/hub-forwarder/index.mjs

@@ -1,4 +1,4 @@
-import { I as logDestinationCapability, rt as BaseAddon } from "../../dist-CC3E-_3h.mjs";
+import { L as logDestinationCapability, it as BaseAddon } from "../../dist-B_PSvr-m.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 //#region src/builtins/hub-forwarder/hub-forwarder-destination.ts
 var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;

package/dist/builtins/local-auth/local-auth.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CQYo6Zp8.js");
+const require_dist = require("../../dist-BduBhv6N.js");
 let node_crypto = require("node:crypto");
 node_crypto = require_chunk.__toESM(node_crypto);
 let crypto$1 = require("crypto");
@@ -5957,7 +5957,7 @@ var AuthManager = class {
 	}
 	signToken(payload) {
 		const configured = this.config.get("auth.tokenExpiry");
-		const expiresIn = typeof configured === "string" && configured.trim() !== "" ? configured.trim() : "7d";
+		const expiresIn = typeof configured === "string" && configured.trim() !== "" ? configured.trim() : "30d";
 		return import_jsonwebtoken.sign({ ...payload }, this.jwtSecret, { expiresIn });
 	}
 	verifyToken(token) {

package/dist/builtins/local-auth/local-auth.addon.mjs

@@ -1,4 +1,4 @@
-import { _ as authProviderCapability, d as UserRecordSchema, et as userManagementCapability, l as ScopedTokenSchema, r as ApiKeyRecordSchema, rt as BaseAddon } from "../../dist-CC3E-_3h.mjs";
+import { _ as authProviderCapability, d as UserRecordSchema, it as BaseAddon, l as ScopedTokenSchema, r as ApiKeyRecordSchema, tt as userManagementCapability } from "../../dist-B_PSvr-m.mjs";
 import { createRequire } from "node:module";
 import * as crypto$1 from "node:crypto";
 import { randomUUID } from "node:crypto";
@@ -5984,7 +5984,7 @@ var AuthManager = class {
 	}
 	signToken(payload) {
 		const configured = this.config.get("auth.tokenExpiry");
-		const expiresIn = typeof configured === "string" && configured.trim() !== "" ? configured.trim() : "7d";
+		const expiresIn = typeof configured === "string" && configured.trim() !== "" ? configured.trim() : "30d";
 		return import_jsonwebtoken.sign({ ...payload }, this.jwtSecret, { expiresIn });
 	}
 	verifyToken(token) {

package/dist/builtins/local-network/local-network.addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CQYo6Zp8.js");
+const require_dist = require("../../dist-BduBhv6N.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 //#region src/builtins/local-network/local-network.addon.ts

package/dist/builtins/local-network/local-network.addon.mjs

@@ -1,4 +1,4 @@
-import { F as localNetworkCapability, rt as BaseAddon, ut as EventCategory } from "../../dist-CC3E-_3h.mjs";
+import { I as localNetworkCapability, it as BaseAddon, kt as EventCategory } from "../../dist-B_PSvr-m.mjs";
 import * as os from "node:os";
 //#region src/builtins/local-network/local-network.addon.ts
 /**

package/dist/builtins/native-metrics/native-metrics.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CQYo6Zp8.js");
+const require_dist = require("../../dist-BduBhv6N.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_child_process = require("node:child_process");

package/dist/builtins/native-metrics/native-metrics.addon.mjs

@@ -1,4 +1,4 @@
-import { R as metricsProviderCapability, _t as createEvent, rt as BaseAddon, ut as EventCategory } from "../../dist-CC3E-_3h.mjs";
+import { _t as createEvent, it as BaseAddon, kt as EventCategory, z as metricsProviderCapability } from "../../dist-B_PSvr-m.mjs";
 import * as fs from "node:fs";
 import { execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";

package/dist/builtins/platform-probe/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-CQYo6Zp8.js");
+const require_dist = require("../../dist-BduBhv6N.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_child_process = require("node:child_process");

package/dist/builtins/platform-probe/index.mjs

@@ -1,4 +1,4 @@
-import { K as scoreRuntimes, U as platformProbeCapability, nt as errMsg, rt as BaseAddon, ut as EventCategory, yt as emitReadiness } from "../../dist-CC3E-_3h.mjs";
+import { W as platformProbeCapability, it as BaseAddon, kt as EventCategory, q as scoreRuntimes, rt as errMsg, yt as emitReadiness } from "../../dist-B_PSvr-m.mjs";
 import * as fs from "node:fs";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";

package/dist/builtins/remote-access-orchestrator/remote-access-orchestrator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CQYo6Zp8.js");
+const require_dist = require("../../dist-BduBhv6N.js");
 //#region src/builtins/remote-access-orchestrator/enabled-providers-reconcile.ts
 /**
 * Reconcile the durable `enabledProviders` set against authoritative

package/dist/builtins/remote-access-orchestrator/remote-access-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { rt as BaseAddon, ut as EventCategory } from "../../dist-CC3E-_3h.mjs";
+import { it as BaseAddon, kt as EventCategory } from "../../dist-B_PSvr-m.mjs";
 //#region src/builtins/remote-access-orchestrator/enabled-providers-reconcile.ts
 /**
 * Reconcile the durable `enabledProviders` set against authoritative