@camstack/system 1.2.13 → 1.2.14

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

@@ -0,0 +1,431 @@
+import { st as BaseAddon, z as logDestinationCapability } from "../../dist-eOaraBhT.mjs";
+//#region src/builtins/loki-logging/loki-payload.ts
+/**
+* Loki rejects a label name that is not a valid Prometheus label
+* (`[a-zA-Z_][a-zA-Z0-9_]*`), so operator-supplied keys are sanitised rather
+* than passed through — a 400 from the push endpoint on every batch is a much
+* worse outcome than a renamed label.
+*/
+function sanitizeLabelName(raw) {
+	const replaced = raw.replaceAll(/[^a-zA-Z0-9_]/g, "_");
+	return /^[a-zA-Z_]/.test(replaced) ? replaced : `_${replaced}`;
+}
+/** Parse an operator's `key=value,key2=value2` label string. */
+function parseExtraLabels(raw) {
+	const out = {};
+	for (const pair of raw.split(",")) {
+		const trimmed = pair.trim();
+		if (trimmed.length === 0) continue;
+		const eq = trimmed.indexOf("=");
+		if (eq <= 0) continue;
+		const name = sanitizeLabelName(trimmed.slice(0, eq).trim());
+		const value = trimmed.slice(eq + 1).trim();
+		if (value.length > 0) out[name] = value;
+	}
+	return out;
+}
+/** `Date` → Loki's nanosecond-precision string timestamp. */
+function toUnixNano(timestamp) {
+	const ms = timestamp instanceof Date ? timestamp.getTime() : typeof timestamp === "number" ? timestamp : Date.parse(timestamp);
+	return `${String(Math.trunc(Number.isFinite(ms) ? ms : 0))}000000`;
+}
+/**
+* The line body: JSON carrying everything that must NOT be a label. Loki can
+* parse this with `| json` at query time, so `scope` and `tags.deviceId` stay
+* filterable without ever being indexed.
+*/
+function formatLokiLine(entry) {
+	const line = { message: entry.message };
+	if (entry.scope !== void 0 && entry.scope.length > 0) line["scope"] = entry.scope;
+	if (entry.tags !== void 0 && Object.keys(entry.tags).length > 0) line["tags"] = entry.tags;
+	if (entry.meta !== void 0 && Object.keys(entry.meta).length > 0) line["meta"] = entry.meta;
+	return JSON.stringify(line);
+}
+/**
+* Group a batch into one stream per distinct label set, and sort each stream's
+* values by timestamp.
+*
+* The sort is not cosmetic. Loki historically rejected a stream whose entries
+* were not in ascending time order, and even with out-of-order ingestion enabled
+* it is bounded by a window. Entries reach a destination from several concurrent
+* producers, so a batch is NOT naturally ordered — without this, some pushes
+* fail with `entry out of order` and those log lines are simply gone.
+*/
+function buildPushBody(entries, labels) {
+	if (entries.length === 0) return null;
+	const base = {
+		job: labels.job,
+		node: labels.node
+	};
+	for (const [key, value] of Object.entries(labels.extra ?? {})) base[key] = value;
+	const byLevel = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const values = byLevel.get(entry.level) ?? [];
+		values.push([toUnixNano(entry.timestamp), formatLokiLine(entry)]);
+		byLevel.set(entry.level, values);
+	}
+	const streams = [];
+	for (const [level, values] of byLevel) streams.push({
+		stream: {
+			...base,
+			level
+		},
+		values: values.toSorted((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
+	});
+	return { streams };
+}
+//#endregion
+//#region src/builtins/loki-logging/loki-destination.ts
+var LEVEL_ORDER = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/**
+* Bounded so an unreachable Loki cannot grow the heap without limit. 10k entries
+* of a few hundred bytes is a handful of MB — enough to ride out a restart of the
+* Loki container, not enough to matter if it never comes back.
+*/
+var MAX_QUEUE = 1e4;
+var LokiDestination = class {
+	config = null;
+	queue = [];
+	timer;
+	flushing = false;
+	pushed = 0;
+	dropped = 0;
+	failures = 0;
+	lastError = null;
+	lastPushAtMs = null;
+	fetchFn;
+	setIntervalFn;
+	clearIntervalFn;
+	constructor(deps) {
+		this.fetchFn = deps?.fetchFn ?? ((url, init) => globalThis.fetch(url, {
+			method: init.method,
+			headers: { ...init.headers },
+			body: init.body,
+			...init.signal ? { signal: init.signal } : {}
+		}));
+		this.setIntervalFn = deps?.setIntervalFn ?? setInterval;
+		this.clearIntervalFn = deps?.clearIntervalFn ?? clearInterval;
+	}
+	async initialize(config) {
+		this.config = config ?? null;
+		if (!this.isActive()) return;
+		this.timer = this.setIntervalFn(() => {
+			this.flush();
+		}, Math.max(250, config?.batchIntervalMs ?? 5e3));
+		const timer = this.timer;
+		if (typeof timer === "object" && timer !== null && "unref" in timer) timer.unref();
+	}
+	/** Enabled AND pointed somewhere. An enabled destination with no URL is inert. */
+	isActive() {
+		return this.config !== null && this.config.enabled && this.config.url.trim().length > 0;
+	}
+	write(entry) {
+		if (!this.isActive() || this.config === null) return;
+		if (LEVEL_ORDER[entry.level] < LEVEL_ORDER[this.config.level]) return;
+		this.queue.push(entry);
+		if (this.queue.length > MAX_QUEUE) {
+			const overflow = this.queue.length - MAX_QUEUE;
+			this.queue.splice(0, overflow);
+			this.dropped += overflow;
+		}
+		if (this.queue.length >= this.config.batchSize) this.flush();
+	}
+	/**
+	* Push whatever is queued. Never throws and never logs.
+	*
+	* On failure the batch is put BACK at the front of the queue so a transient
+	* Loki outage does not lose lines; `MAX_QUEUE` is what stops that from growing
+	* without bound.
+	*/
+	async flush() {
+		if (this.flushing || !this.isActive() || this.config === null) return;
+		if (this.queue.length === 0) return;
+		this.flushing = true;
+		const batch = this.queue;
+		this.queue = [];
+		try {
+			const body = buildPushBody(batch, {
+				job: this.config.job,
+				node: this.config.node,
+				extra: parseExtraLabels(this.config.extraLabels)
+			});
+			if (body !== null) {
+				await this.push(body, this.config);
+				this.pushed += batch.length;
+				this.lastPushAtMs = Date.now();
+				this.lastError = null;
+			}
+		} catch (error) {
+			this.failures += 1;
+			this.lastError = error instanceof Error ? error.message : String(error);
+			this.queue = [...batch, ...this.queue];
+			if (this.queue.length > MAX_QUEUE) {
+				const overflow = this.queue.length - MAX_QUEUE;
+				this.queue.splice(0, overflow);
+				this.dropped += overflow;
+			}
+		} finally {
+			this.flushing = false;
+		}
+	}
+	async push(body, config) {
+		const endpoint = `${config.url.replace(/\/+$/, "")}/loki/api/v1/push`;
+		const headers = { "content-type": "application/json" };
+		if (config.tenantId.trim().length > 0) headers["X-Scope-OrgID"] = config.tenantId.trim();
+		if (config.username.length > 0) headers["authorization"] = `Basic ${Buffer.from(`${config.username}:${config.password}`).toString("base64")}`;
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), Math.max(1e3, config.timeoutMs));
+		try {
+			const response = await this.fetchFn(endpoint, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(body),
+				signal: controller.signal
+			});
+			if (!response.ok) {
+				const detail = await response.text().catch(() => "");
+				throw new Error(`Loki push failed: ${String(response.status)}${detail.length > 0 ? ` — ${detail.slice(0, 200)}` : ""}`);
+			}
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+	getStatus() {
+		return {
+			enabled: this.config?.enabled === true,
+			configured: this.isActive(),
+			queued: this.queue.length,
+			pushed: this.pushed,
+			dropped: this.dropped,
+			failures: this.failures,
+			lastError: this.lastError,
+			lastPushAtMs: this.lastPushAtMs
+		};
+	}
+	/**
+	* One-shot reachability probe for the Admin UI's "Test connection" button.
+	* Pushes a single synthetic entry, which validates the URL, the auth, the
+	* tenant header AND the label policy in one go — a bare GET would validate
+	* none of them.
+	*/
+	async testConnection(config) {
+		if (config.url.trim().length === 0) return {
+			ok: false,
+			error: "No Loki URL configured"
+		};
+		const body = buildPushBody([{
+			timestamp: /* @__PURE__ */ new Date(),
+			level: "info",
+			scope: "loki-logging",
+			message: "CamStack connection test"
+		}], {
+			job: config.job,
+			node: config.node,
+			extra: parseExtraLabels(config.extraLabels)
+		});
+		if (body === null) return {
+			ok: false,
+			error: "Nothing to send"
+		};
+		try {
+			await this.push(body, config);
+			return {
+				ok: true,
+				error: null
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	async query(_filter) {
+		return [];
+	}
+	async shutdown() {
+		if (this.timer !== void 0) {
+			this.clearIntervalFn(this.timer);
+			this.timer = void 0;
+		}
+		await this.flush();
+		this.config = null;
+	}
+};
+//#endregion
+//#region src/builtins/loki-logging/loki-logging.addon.ts
+var DEFAULTS = {
+	enabled: false,
+	url: "",
+	job: "camstack",
+	level: "info",
+	batchIntervalMs: 5e3,
+	batchSize: 200,
+	extraLabels: "",
+	tenantId: "",
+	username: "",
+	password: "",
+	timeoutMs: 1e4
+};
+var LokiLoggingAddon = class extends BaseAddon {
+	destination = null;
+	constructor() {
+		super({ ...DEFAULTS });
+	}
+	async onInitialize() {
+		this.destination = new LokiDestination();
+		await this.destination.initialize(this.destinationConfig());
+		this.ctx.logger.info(this.config.enabled && this.config.url.length > 0 ? `Loki logging initialized → ${this.config.url}` : "Loki logging registered but inactive (set a URL and enable it)");
+		return [{
+			capability: logDestinationCapability,
+			provider: this.destination
+		}];
+	}
+	async onShutdown() {
+		await this.destination?.shutdown();
+		this.destination = null;
+	}
+	/**
+	* `node` is a Loki LABEL, so it must be the node's real identity and must not
+	* be operator-editable — a typo would fork the stream and split a node's history
+	* in two. `kernel.localNodeId` is the Moleculer node id (`'hub'` on the hub, the
+	* agent's own name elsewhere), which is exactly the bounded value wanted here.
+	*
+	* NOT named `resolveConfig`: `BaseAddon` already has a protected
+	* `resolveConfig()` that reloads persisted settings, and shadowing it with a
+	* different signature is a type error — usefully, since silently overriding it
+	* would have broken this addon's settings reload.
+	*/
+	destinationConfig() {
+		return {
+			...this.config,
+			node: this.ctx.kernel.localNodeId ?? "hub"
+		};
+	}
+	getDestination() {
+		if (!this.destination) throw new Error("Loki logging not initialized");
+		return this.destination;
+	}
+	globalSettingsSchema() {
+		return this.schema({ sections: [{
+			id: "loki-logging",
+			title: "Loki",
+			description: "Ship this node’s logs to a Grafana Loki instance. Independent of the rotated-file and console destinations — enabling this does not disable those.",
+			columns: 2,
+			fields: [
+				this.field({
+					type: "boolean",
+					key: "enabled",
+					label: "Enabled",
+					description: "Off by default. Needs a URL below to do anything.",
+					default: false
+				}),
+				this.field({
+					type: "text",
+					key: "url",
+					label: "Loki URL",
+					description: "Base URL, e.g. http://loki:3100 — the /loki/api/v1/push path is added.",
+					placeholder: "http://loki:3100",
+					default: ""
+				}),
+				this.field({
+					type: "select",
+					key: "level",
+					label: "Minimum level",
+					default: "info",
+					options: [
+						{
+							value: "debug",
+							label: "Debug"
+						},
+						{
+							value: "info",
+							label: "Info"
+						},
+						{
+							value: "warn",
+							label: "Warn"
+						},
+						{
+							value: "error",
+							label: "Error"
+						}
+					]
+				}),
+				this.field({
+					type: "text",
+					key: "job",
+					label: "Job label",
+					description: "The Loki `job` label. Keep it fixed — labels are indexed.",
+					default: "camstack"
+				}),
+				this.field({
+					type: "text",
+					key: "extraLabels",
+					label: "Extra labels",
+					description: "Static `key=value,key2=value2`. Low-cardinality only: per-entry values belong in the line body, and a high-cardinality label will bring Loki down.",
+					placeholder: "env=home,site=garage",
+					default: ""
+				}),
+				this.field({
+					type: "text",
+					key: "tenantId",
+					label: "Tenant ID",
+					description: "Sent as X-Scope-OrgID. Required by Grafana Cloud and multi-tenant Loki.",
+					default: ""
+				}),
+				this.field({
+					type: "text",
+					key: "username",
+					label: "Username",
+					description: "HTTP basic auth. Leave empty for none.",
+					default: ""
+				}),
+				this.field({
+					type: "password",
+					key: "password",
+					label: "Password",
+					default: ""
+				}),
+				this.field({
+					type: "number",
+					key: "batchIntervalMs",
+					label: "Flush interval",
+					description: "How often a partial batch is pushed.",
+					min: 250,
+					max: 6e4,
+					step: 250,
+					default: 5e3,
+					unit: "ms"
+				}),
+				this.field({
+					type: "number",
+					key: "batchSize",
+					label: "Batch size",
+					description: "Push early once this many entries are queued.",
+					min: 1,
+					max: 5e3,
+					step: 10,
+					default: 200
+				}),
+				this.field({
+					type: "number",
+					key: "timeoutMs",
+					label: "Request timeout",
+					min: 1e3,
+					max: 6e4,
+					step: 500,
+					default: 1e4,
+					unit: "ms"
+				})
+			]
+		}] });
+	}
+};
+//#endregion
+export { LokiDestination, LokiLoggingAddon, LokiLoggingAddon as default, buildPushBody, formatLokiLine, parseExtraLabels, sanitizeLabelName, toUnixNano };

package/dist/builtins/loki-logging/loki-destination.d.ts

@@ -0,0 +1,88 @@
+import { ILogDestination, LogEntry, LogFilter, LogLevel } from '@camstack/types';
+export interface LokiConfig {
+    readonly enabled: boolean;
+    /** Base URL of the Loki instance, e.g. `http://loki:3100`. */
+    readonly url: string;
+    readonly job: string;
+    readonly node: string;
+    readonly level: LogLevel;
+    /** Flush period in ms. */
+    readonly batchIntervalMs: number;
+    /** Flush early once this many entries are queued. */
+    readonly batchSize: number;
+    /** `key=value,key2=value2` static labels. Must stay low-cardinality. */
+    readonly extraLabels: string;
+    /** Grafana Cloud / multi-tenant Loki: sent as `X-Scope-OrgID`. */
+    readonly tenantId: string;
+    /** Optional HTTP basic auth. */
+    readonly username: string;
+    readonly password: string;
+    readonly timeoutMs: number;
+}
+export interface LokiStatus {
+    readonly enabled: boolean;
+    readonly configured: boolean;
+    readonly queued: number;
+    readonly pushed: number;
+    readonly dropped: number;
+    readonly failures: number;
+    readonly lastError: string | null;
+    readonly lastPushAtMs: number | null;
+}
+/** Injected in tests. Matches the shape of global `fetch` that is actually used. */
+export type LokiFetch = (url: string, init: {
+    readonly method: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: string;
+    readonly signal?: AbortSignal;
+}) => Promise<{
+    readonly ok: boolean;
+    readonly status: number;
+    text(): Promise<string>;
+}>;
+export interface LokiDestinationDeps {
+    readonly fetchFn?: LokiFetch;
+    readonly setIntervalFn?: typeof setInterval;
+    readonly clearIntervalFn?: typeof clearInterval;
+}
+export declare class LokiDestination implements ILogDestination {
+    private config;
+    private queue;
+    private timer;
+    private flushing;
+    private pushed;
+    private dropped;
+    private failures;
+    private lastError;
+    private lastPushAtMs;
+    private readonly fetchFn;
+    private readonly setIntervalFn;
+    private readonly clearIntervalFn;
+    constructor(deps?: LokiDestinationDeps);
+    initialize(config?: LokiConfig): Promise<void>;
+    /** Enabled AND pointed somewhere. An enabled destination with no URL is inert. */
+    private isActive;
+    write(entry: LogEntry): void;
+    /**
+     * Push whatever is queued. Never throws and never logs.
+     *
+     * On failure the batch is put BACK at the front of the queue so a transient
+     * Loki outage does not lose lines; `MAX_QUEUE` is what stops that from growing
+     * without bound.
+     */
+    flush(): Promise<void>;
+    private push;
+    getStatus(): LokiStatus;
+    /**
+     * One-shot reachability probe for the Admin UI's "Test connection" button.
+     * Pushes a single synthetic entry, which validates the URL, the auth, the
+     * tenant header AND the label policy in one go — a bare GET would validate
+     * none of them.
+     */
+    testConnection(config: LokiConfig): Promise<{
+        ok: boolean;
+        error: string | null;
+    }>;
+    query(_filter: LogFilter): Promise<readonly LogEntry[]>;
+    shutdown(): Promise<void>;
+}

package/dist/builtins/loki-logging/loki-logging.addon.d.ts

@@ -0,0 +1,36 @@
+import { LogLevel, ProviderRegistration, BaseAddon } from '@camstack/types';
+import { LokiDestination } from './loki-destination.js';
+interface LokiAddonConfig {
+    readonly enabled: boolean;
+    readonly url: string;
+    readonly job: string;
+    readonly level: LogLevel;
+    readonly batchIntervalMs: number;
+    readonly batchSize: number;
+    readonly extraLabels: string;
+    readonly tenantId: string;
+    readonly username: string;
+    readonly password: string;
+    readonly timeoutMs: number;
+}
+export declare class LokiLoggingAddon extends BaseAddon<LokiAddonConfig> {
+    private destination;
+    constructor();
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    protected onShutdown(): Promise<void>;
+    /**
+     * `node` is a Loki LABEL, so it must be the node's real identity and must not
+     * be operator-editable — a typo would fork the stream and split a node's history
+     * in two. `kernel.localNodeId` is the Moleculer node id (`'hub'` on the hub, the
+     * agent's own name elsewhere), which is exactly the bounded value wanted here.
+     *
+     * NOT named `resolveConfig`: `BaseAddon` already has a protected
+     * `resolveConfig()` that reloads persisted settings, and shadowing it with a
+     * different signature is a type error — usefully, since silently overriding it
+     * would have broken this addon's settings reload.
+     */
+    private destinationConfig;
+    getDestination(): LokiDestination;
+    protected globalSettingsSchema(): import('@camstack/types').ConfigUISchema;
+}
+export {};

package/dist/builtins/loki-logging/loki-payload.d.ts

@@ -0,0 +1,46 @@
+import { LogEntry } from '@camstack/types';
+/** One `[unixNano, line]` pair, exactly as Loki's push API expects. */
+export type LokiValue = readonly [string, string];
+export interface LokiStream {
+    readonly stream: Readonly<Record<string, string>>;
+    readonly values: readonly LokiValue[];
+}
+export interface LokiPushBody {
+    readonly streams: readonly LokiStream[];
+}
+export interface LokiLabelInput {
+    /** Fixed `job` label. Bounded by configuration, never per-entry. */
+    readonly job: string;
+    /** This node's id. Bounded by cluster size. */
+    readonly node: string;
+    /** Extra static labels from configuration. Values must be low-cardinality. */
+    readonly extra?: Readonly<Record<string, string>>;
+}
+/**
+ * Loki rejects a label name that is not a valid Prometheus label
+ * (`[a-zA-Z_][a-zA-Z0-9_]*`), so operator-supplied keys are sanitised rather
+ * than passed through — a 400 from the push endpoint on every batch is a much
+ * worse outcome than a renamed label.
+ */
+export declare function sanitizeLabelName(raw: string): string;
+/** Parse an operator's `key=value,key2=value2` label string. */
+export declare function parseExtraLabels(raw: string): Readonly<Record<string, string>>;
+/** `Date` → Loki's nanosecond-precision string timestamp. */
+export declare function toUnixNano(timestamp: Date | string | number): string;
+/**
+ * The line body: JSON carrying everything that must NOT be a label. Loki can
+ * parse this with `| json` at query time, so `scope` and `tags.deviceId` stay
+ * filterable without ever being indexed.
+ */
+export declare function formatLokiLine(entry: LogEntry): string;
+/**
+ * Group a batch into one stream per distinct label set, and sort each stream's
+ * values by timestamp.
+ *
+ * The sort is not cosmetic. Loki historically rejected a stream whose entries
+ * were not in ascending time order, and even with out-of-order ingestion enabled
+ * it is bounded by a window. Entries reach a destination from several concurrent
+ * producers, so a batch is NOT naturally ordered — without this, some pushes
+ * fail with `entry out of order` and those log lines are simply gone.
+ */
+export declare function buildPushBody(entries: readonly LogEntry[], labels: LokiLabelInput): LokiPushBody | null;

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-BQOCTD5b.js");
+const require_dist = require("../../dist-yttC1aUI.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 { V as metricsProviderCapability, jt as EventCategory, ot as BaseAddon, yt as createEvent } from "../../dist-DpKeSZel.mjs";
+import { H as metricsProviderCapability, Mt as EventCategory, bt as createEvent, st as BaseAddon } from "../../dist-eOaraBhT.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-BQOCTD5b.js");
+const require_dist = require("../../dist-yttC1aUI.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 platformProbeCapability, T as enumerateInferenceDevices, Y as scoreRuntimes, at as errMsg, jt as EventCategory, ot as BaseAddon, xt as emitReadiness } from "../../dist-DpKeSZel.mjs";
+import { Mt as EventCategory, St as emitReadiness, T as enumerateInferenceDevices, X as scoreRuntimes, ot as errMsg, q as platformProbeCapability, st as BaseAddon } from "../../dist-eOaraBhT.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-BQOCTD5b.js");
+const require_dist = require("../../dist-yttC1aUI.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 { jt as EventCategory, ot as BaseAddon } from "../../dist-DpKeSZel.mjs";
+import { Mt as EventCategory, st as BaseAddon } from "../../dist-eOaraBhT.mjs";
 //#region src/builtins/remote-access-orchestrator/enabled-providers-reconcile.ts
 /**
 * Reconcile the durable `enabledProviders` set against authoritative

package/dist/builtins/snapshot/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BQOCTD5b.js");
+const require_dist = require("../../dist-yttC1aUI.js");
 let node_child_process = require("node:child_process");
 //#region src/builtins/snapshot/snapshot-coalescing.ts
 /**

package/dist/builtins/snapshot/index.mjs

@@ -1,4 +1,4 @@
-import { H as nodePin, Q as snapshotCapability, at as errMsg, ft as DeviceType, i as BatteryStatusSchema, ot as BaseAddon, tt as streamQualityLabel, ut as DeviceFeature } from "../../dist-DpKeSZel.mjs";
+import { $ as snapshotCapability, U as nodePin, dt as DeviceFeature, i as BatteryStatusSchema, nt as streamQualityLabel, ot as errMsg, pt as DeviceType, st as BaseAddon } from "../../dist-eOaraBhT.mjs";
 import { execFile } from "node:child_process";
 //#region src/builtins/snapshot/snapshot-coalescing.ts
 /**

package/dist/builtins/sqlite-storage/filesystem-storage.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-BQOCTD5b.js");
+const require_dist = require("../../dist-yttC1aUI.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");