@camstack/system 1.2.431 → 1.2.433

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-DxJdci75.js");
+const require_dist = require("../../dist-C6Yvfhpq.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 { _r as BaseAddon, an as logDestinationCapability } from "../../dist-CXG6muCR.mjs";
+import { sn as logDestinationCapability, yr as BaseAddon } from "../../dist-DJnlnL7P.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-Cw_TXEq9.mjs → composition-sources-8-cpAt1c.mjs}

@@ -1,4 +1,4 @@
-import { gr as errMsg, lr as compositionSourceKey } from "./dist-CXG6muCR.mjs";
+import { dr as compositionSourceKey, vr as errMsg } from "./dist-DJnlnL7P.mjs";
 //#region src/builtins/core-blocks/composition-sources.ts
 /**
 * Describe what a composition reads and writes for SAVE-time validation

package/dist/{composition-sources-o5MPSlk6.js → composition-sources-BgJWQMjr.js}

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

package/dist/{constants-BcNaVkvI.js → constants-Ah3T_KAW.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DxJdci75.js");
+const require_dist = require("./dist-C6Yvfhpq.js");
 let node_crypto = require("node:crypto");
 //#region src/kernel/moleculer/cluster-secret.ts
 /**
@@ -87,7 +87,7 @@ var MESH_CA_KEY_REF = require_dist.buildSecretRef({
 });
 /** `system-settings` key holding the public CA certificate PEM. */
 var MESH_CA_SETTINGS_KEY = "cluster.meshCa";
-/** Field inside the `cluster` section (same row as the secret). */
+/** Field inside the `cluster` section. */
 var MESH_CA_FIELD = "meshCa";
 /** Join-token / leaf lifetimes. */
 var MESH_JOIN_TOKEN_MAX_TTL_SEC = 3600;

package/dist/{constants-CttE77VF.mjs → constants-Cg9ve13y.mjs}

@@ -1,4 +1,4 @@
-import { Ar as buildSecretRef } from "./dist-CXG6muCR.mjs";
+import { Mr as buildSecretRef } from "./dist-DJnlnL7P.mjs";
 import { createHash, timingSafeEqual } from "node:crypto";
 //#region src/kernel/moleculer/cluster-secret.ts
 /**
@@ -87,7 +87,7 @@ var MESH_CA_KEY_REF = buildSecretRef({
 });
 /** `system-settings` key holding the public CA certificate PEM. */
 var MESH_CA_SETTINGS_KEY = "cluster.meshCa";
-/** Field inside the `cluster` section (same row as the secret). */
+/** Field inside the `cluster` section. */
 var MESH_CA_FIELD = "meshCa";
 /** Join-token / leaf lifetimes. */
 var MESH_JOIN_TOKEN_MAX_TTL_SEC = 3600;

package/dist/{device-ca-B-BTxeCj.mjs → device-ca-DUrcTW5h.mjs}

@@ -1,4 +1,4 @@
-import { Ar as buildSecretRef, C as DEVICE_SAN_CREDENTIAL_PREFIX, w as DEVICE_SAN_USER_PREFIX } from "./dist-CXG6muCR.mjs";
+import { E as DEVICE_SAN_USER_PREFIX, Mr as buildSecretRef, T as DEVICE_SAN_CREDENTIAL_PREFIX } from "./dist-DJnlnL7P.mjs";
 import { a as KeyUsagesExtension, d as X509Certificate$1, f as X509CertificateGenerator, i as KeyUsageFlags, l as SubjectAlternativeNameExtension, n as BasicConstraintsExtension, o as PemConverter, p as cryptoProvider, r as ExtendedKeyUsageExtension, t as AuthorityKeyIdentifierExtension, u as SubjectKeyIdentifierExtension } from "./x509.es-CAjSsrkk.mjs";
 import { X509Certificate, createPublicKey, randomBytes, verify, webcrypto } from "node:crypto";
 //#region src/auth/jwt-signing-key.ts

package/dist/{device-ca-CKiqh2Iu.js → device-ca-NNP4Jz0P.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DxJdci75.js");
+const require_dist = require("./dist-C6Yvfhpq.js");
 const require_x509_es = require("./x509.es-Dzl0BbmG.js");
 let node_crypto = require("node:crypto");
 //#region src/auth/jwt-signing-key.ts

package/dist/{dist-DxJdci75.js → dist-C6Yvfhpq.js}

@@ -718,7 +718,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-DxJdzHni.mjs
+//#region ../types/dist/sleep--g-h2_c_.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -16213,6 +16213,241 @@ var keychainCapability = {
 		getState: method(zod.z.object({}), KeychainStateSchema, { auth: "admin" })
 	}
 };
+/**
+* device-history — the ONE mechanism for numeric history (D850).
+*
+* A device value is recorded because its capability says so (the `history`
+* block of a `*.cap.ts`, captured hub-side from `DeviceStateChanged`); any
+* other series is DECLARED by the addon that produces it and fed with points
+* (`record`) or closed five-minute buckets (`recordBuckets`). Rollups 5m / 1h /
+* 1d are computed here and nowhere else. Storage is `history.db` (D851).
+*
+* Who the PRODUCER is: `declareSeries`, `record` and `recordBuckets` are owner
+* checked against the `callerAddonId` the transport stamps into a call that
+* crossed a process (never in an input schema, so a session cannot supply it).
+* A call with no stamp is refused `not-owner`. The methods are `admin` so a
+* non-admin session never reaches them; an addon's `ctx.api` call bypasses the
+* tier by design.
+*/
+/** Whose history: a real device, or a cluster node (load, memory). */
+var DeviceHistorySubjectSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("device"),
+	deviceId: zod.z.number().int()
+}), zod.z.object({
+	kind: zod.z.literal("node"),
+	nodeId: zod.z.string().min(1)
+})]);
+var DeviceHistoryKindSchema = zod.z.enum([
+	"gauge",
+	"counter",
+	"boolean"
+]);
+var DeviceHistoryResolutionSchema = zod.z.enum([
+	"raw",
+	"5m",
+	"1h",
+	"1d"
+]);
+/** Why a producer's point or bucket was not stored. Counted, never silent (D391). */
+var DeviceHistoryRefusalReasonSchema = zod.z.enum([
+	"undeclared",
+	"not-owner",
+	"opted-out",
+	"not-a-real-device",
+	"rate",
+	"ingest-mismatch",
+	"out-of-range"
+]);
+var RefusalSchema = zod.z.object({
+	key: zod.z.string(),
+	reason: DeviceHistoryRefusalReasonSchema,
+	count: zod.z.number().int()
+});
+var IngestResultSchema = zod.z.object({
+	accepted: zod.z.number().int(),
+	refused: zod.z.array(RefusalSchema).readonly()
+});
+var SeriesInfoSchema = zod.z.object({
+	key: zod.z.string(),
+	scope: zod.z.string(),
+	kind: DeviceHistoryKindSchema,
+	/** `null` is unknown (a `unitFrom` series whose device does not state a unit right now), never a guess. */
+	unit: zod.z.string().nullable(),
+	displayName: zod.z.string(),
+	source: zod.z.enum(["cap", "addon"]),
+	firstTs: zod.z.number(),
+	lastTs: zod.z.number()
+});
+var QueryPointSchema = zod.z.object({
+	/** Raw: the point's time. Rollup: the bucket start. */
+	t: zod.z.number(),
+	samples: zod.z.number().int(),
+	/** `sum / samples`. */
+	mean: zod.z.number().nullable(),
+	/** Time-weighted mean (`tw_sum / tw_ms`); `null` for bucket-ingested series. For a boolean: the fraction of time true. */
+	twMean: zod.z.number().nullable(),
+	min: zod.z.number(),
+	max: zod.z.number(),
+	/** `null` is unknown, never zero (D393). */
+	last: zod.z.number().nullable()
+});
+var QuerySeriesSchema = zod.z.object({
+	scope: zod.z.string(),
+	/** The last point STRICTLY BEFORE `from` in the chosen tier, so a step chart can start at the held value. */
+	before: zod.z.object({
+		t: zod.z.number(),
+		value: zod.z.number().nullable()
+	}).nullable(),
+	points: zod.z.array(QueryPointSchema).readonly()
+});
+/** The window part of a query, shared by the device and node forms. */
+var QueryWindowShape = {
+	key: zod.z.string(),
+	scope: zod.z.string().optional(),
+	from: zod.z.number(),
+	to: zod.z.number(),
+	resolution: zod.z.union([DeviceHistoryResolutionSchema, zod.z.literal("auto")]).default("auto"),
+	maxPoints: zod.z.number().int().positive().max(5e3).default(1e3)
+};
+var QueryResultSchema = zod.z.object({
+	resolution: DeviceHistoryResolutionSchema,
+	series: zod.z.array(QuerySeriesSchema).readonly(),
+	truncated: zod.z.boolean()
+});
+var TierStatusSchema = zod.z.object({
+	tier: DeviceHistoryResolutionSchema,
+	/** `null` until the first background count answered. */
+	rows: zod.z.number().int().nullable(),
+	/** `rows` times a fixed per-row estimate — approximate, labelled so. */
+	approxBytes: zod.z.number().nullable(),
+	countedAt: zod.z.number().nullable()
+});
+/** Operator/diagnostic view: rows per tier, last runs, refusals and drops since boot. */
+var DeviceHistoryStatusSchema = zod.z.object({
+	startedAt: zod.z.number(),
+	/** The store is declared, series loaded and the first reconcile has answered. */
+	ready: zod.z.boolean(),
+	series: zod.z.number().int(),
+	metrics: zod.z.number().int(),
+	optedOutDevices: zod.z.number().int(),
+	tiers: zod.z.array(TierStatusSchema).readonly(),
+	capture: zod.z.object({
+		eventsSeen: zod.z.number().int(),
+		pointsEmitted: zod.z.number().int(),
+		pointsWritten: zod.z.number().int(),
+		pointsDropped: zod.z.number().int(),
+		bufferDepth: zod.z.number().int(),
+		trailingEmitted: zod.z.number().int(),
+		reconciledPoints: zod.z.number().int(),
+		reconcileRuns: zod.z.number().int(),
+		reconcileFailures: zod.z.number().int(),
+		lastReconcileAt: zod.z.number().nullable(),
+		lastFlushAt: zod.z.number().nullable(),
+		flushFailures: zod.z.number().int(),
+		skipped: zod.z.record(zod.z.string(), zod.z.number().int())
+	}),
+	ingest: zod.z.object({
+		accepted: zod.z.number().int(),
+		refused: zod.z.record(zod.z.string(), zod.z.number().int())
+	}),
+	rollup: zod.z.object({
+		last5mAt: zod.z.number().nullable(),
+		last1hAt: zod.z.number().nullable(),
+		last1dAt: zod.z.number().nullable(),
+		errors: zod.z.number().int(),
+		dirty5m: zod.z.number().int(),
+		dirty1h: zod.z.number().int(),
+		dirty1d: zod.z.number().int()
+	}),
+	retention: zod.z.object({
+		lastRunAt: zod.z.number().nullable(),
+		deleted: zod.z.record(zod.z.string(), zod.z.number().int()),
+		purgedSeries: zod.z.number().int()
+	}),
+	directory: zod.z.object({
+		devices: zod.z.number().int(),
+		lastRefreshAt: zod.z.number().nullable()
+	})
+});
+var deviceHistoryCapability = {
+	name: "device-history",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		/**
+		* The series a DEVICE has, and their span. `deviceId` is a flat top-level field
+		* on purpose: the generated device selector (and so the scope gate) only sees
+		* top-level ids, and a nested `subject.deviceId` would let a principal limited
+		* to one device read another's history. Node series are the admin-only
+		* `listNodeSeries` / `queryNode`.
+		*/
+		listSeries: method(zod.z.object({ deviceId: zod.z.number().int() }), zod.z.array(SeriesInfoSchema).readonly()),
+		listNodeSeries: method(zod.z.object({ nodeId: zod.z.string().min(1) }), zod.z.array(SeriesInfoSchema).readonly(), { auth: "admin" }),
+		/**
+		* One series (or every scope of it) at one resolution. `auto` picks the
+		* finest tier whose retention covers `from` and whose point count fits
+		* `maxPoints`; when even the coarsest tier does not fit, the newest
+		* `maxPoints` points are returned and `truncated` is true.
+		*/
+		query: method(zod.z.object({
+			deviceId: zod.z.number().int(),
+			...QueryWindowShape
+		}), QueryResultSchema),
+		queryNode: method(zod.z.object({
+			nodeId: zod.z.string().min(1),
+			...QueryWindowShape
+		}), QueryResultSchema, { auth: "admin" }),
+		/** Producer: declare (idempotent) a series key this addon owns: `addon:<callerAddonId>/<name>`. */
+		declareSeries: method(zod.z.object({
+			name: zod.z.string().regex(/^[a-z0-9-]+$/),
+			subjectKind: zod.z.enum(["device", "node"]),
+			kind: DeviceHistoryKindSchema,
+			unit: zod.z.string().optional(),
+			displayName: zod.z.string().min(1),
+			ingest: zod.z.enum(["points", "buckets"])
+		}), zod.z.object({ key: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Producer: points. Low rate: at most one per 10 s per series, sustained. */
+		record: method(zod.z.object({ points: zod.z.array(zod.z.object({
+			key: zod.z.string(),
+			subject: DeviceHistorySubjectSchema,
+			scope: zod.z.string().default(""),
+			ts: zod.z.number(),
+			value: zod.z.number()
+		})).max(5e3) }), IngestResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Producer: CLOSED five-minute buckets. Idempotent upsert keyed (series, bucketStart). */
+		recordBuckets: method(zod.z.object({ buckets: zod.z.array(zod.z.object({
+			key: zod.z.string(),
+			subject: DeviceHistorySubjectSchema,
+			scope: zod.z.string().default(""),
+			bucketStart: zod.z.number(),
+			samples: zod.z.number().int().positive(),
+			sum: zod.z.number(),
+			min: zod.z.number(),
+			max: zod.z.number(),
+			last: zod.z.number().nullable(),
+			lastTs: zod.z.number().nullable()
+		})).max(5e3) }), IngestResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Per-device opt-out. This addon IS the authority: the switch stores nothing elsewhere (D62). */
+		getDeviceEnabled: method(zod.z.object({ deviceId: zod.z.number().int() }), zod.z.object({ enabled: zod.z.boolean() })),
+		setDeviceEnabled: method(zod.z.object({
+			deviceId: zod.z.number().int(),
+			enabled: zod.z.boolean()
+		}), zod.z.object({ enabled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getStatus: method(zod.z.object({}), DeviceHistoryStatusSchema, { auth: "admin" })
+	}
+};
 var DeviceCaStatusSchema = zod.z.discriminatedUnion("state", [
 	zod.z.object({ state: zod.z.literal("absent") }),
 	zod.z.object({
@@ -16410,6 +16645,16 @@ var nodeCertificatesCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* The hub unpairs this node (D857): it erases its mesh material, goes back to the
+		* unpaired state and advertises itself again. The call is answered first; the wire
+		* goes down right after, so the hub revokes the node's certificates BEFORE this
+		* connection drops, never after.
+		*/
+		forgetHub: method(zod.z.object({}), zod.z.object({ ok: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Install the hub-signed HTTPS leaf and hot-swap the serving context (no restart). */
 		installHttpsCertificate: method(zod.z.object({
 			certPem: zod.z.string().min(1),
@@ -39937,6 +40182,21 @@ var HUB_MDNS_TXT_KEYS = {
 	url: "url"
 };
 /**
+* How a hub finds agents to pair (D857): every agent publishes ONE mDNS service for its API
+* port, paired or not. The TXT record carries only public facts. Finding an agent grants
+* nothing: pairing still needs the six-digit code confirmed on both screens.
+*/
+var AGENT_MDNS_SERVICE_TYPE = "camstack-agent";
+/** The TXT keys of the agent advertisement. Every value is public. */
+var AGENT_MDNS_TXT_KEYS = {
+	nodeId: "nodeId",
+	version: "version",
+	/** `unpaired` | `pending` | `paired`. */
+	state: "state",
+	/** First 16 hex chars of the SHA-256 of the agent's mesh leaf; present once paired. */
+	keyFingerprint: "fp"
+};
+/**
 * Transport bounds for AI capability methods.
 *
 * Its own module because `llm.cap.ts` and `llm-runtime.cap.ts` already import
@@ -74293,6 +74553,66 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceHistory.declareSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.getDeviceEnabled": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.getStatus": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.listNodeSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.listSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.query": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.queryNode": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.record": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.recordBuckets": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.setDeviceEnabled": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.addLocation": {
 		capName: "device-manager",
 		capScope: "system",
@@ -76357,6 +76677,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodeCertificates.forgetHub": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"nodeCertificates.getCertificates": {
 		capName: "node-certificates",
 		capScope: "system",
@@ -80763,6 +81089,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	deviceDiscoveryCapability,
 	deviceExportCapability,
 	deviceExtensionCapability,
+	deviceHistoryCapability,
 	deviceManagerCapability,
 	deviceOpsCapability,
 	deviceProviderCapability,
@@ -81346,6 +81673,26 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"deviceHistory.getDeviceEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.listSeries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.query": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.setDeviceEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceManager.adoptionRelease": [{
 		name: "camDeviceId",
 		form: "single",
@@ -85167,6 +85514,18 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
+Object.defineProperty(exports, "AGENT_MDNS_SERVICE_TYPE", {
+	enumerable: true,
+	get: function() {
+		return AGENT_MDNS_SERVICE_TYPE;
+	}
+});
+Object.defineProperty(exports, "AGENT_MDNS_TXT_KEYS", {
+	enumerable: true,
+	get: function() {
+		return AGENT_MDNS_TXT_KEYS;
+	}
+});
 Object.defineProperty(exports, "ALL_CAPABILITY_DEFINITIONS", {
 	enumerable: true,
 	get: function() {