@camstack/system 1.2.67 → 1.2.69

package/dist/{dist-NRYjb8qK.js → dist-D7wC-S4p.js}

@@ -3200,6 +3200,104 @@ zod.z.object({
 	})
 });
 /**
+* Adoption job — the background form of `device-adoption.adopt`.
+*
+* ## Why this exists
+*
+* `adopt({childNativeIds: [...]})` materialises one CamStack device per
+* candidate PLUS every accessory child, and the whole array shares ONE UDS
+* request deadline (60s). Measured on the live hub against Home Assistant:
+* each device the kernel creates costs ~450 ms — `devices.create` pre-seeds
+* meta with up to eleven SEQUENTIAL round trips (`setName`, `setType`,
+* `setRole`, … `persistConfig`) before the class is constructed — and an
+* accessory child costs the same as its parent. So the real unit of work is
+* the CHILD, not the candidate:
+*
+* - 25 candidates averaging 6 children  → ~150 devices → **>60s, times out**
+* - ONE candidate with 217 children     → ~217 devices → **>60s, times out**
+*
+* That second line is why this is a job and not a smaller batch. No chunking,
+* no bounded concurrency over candidates and no per-call tuning can fix a
+* shape where **N=1 already exceeds the deadline** — the count that blows the
+* budget is the source system's accessory fan-out, which the operator does not
+* choose and cannot see. A design that only works below some N is the same bug
+* deferred.
+*
+* ## What the timeout did NOT do
+*
+* It did not stop the work. The UDS deadline ends the CALLER's wait; the
+* provider's loop runs to completion. Measured: a 25-candidate adopt that
+* "failed" at 60s had adopted 17 by 87s and all 25 by ~130s. The operator saw
+* an error and had no way to learn that. Every field below exists so that
+* question has an answer.
+*
+* ## Idempotency
+*
+* Jobs are in-RAM; a restart forgets them. That is safe here because adoption
+* is keyed by a stable id (`ha:<broker>:dev:<nativeId>` and equivalents), so
+* re-running a job re-adopts nothing: an already-adopted candidate is SKIPPED
+* by the engine before any provider call and lands in `alreadyAdopted`. It is
+* never a duplicate device, and never an error the operator has to interpret.
+*/
+var AdoptionJobStateSchema = zod.z.enum([
+	"running",
+	"done",
+	"failed",
+	"cancelled"
+]);
+/**
+* Per-candidate result. Every candidate the job was asked to adopt ends in
+* exactly one of these buckets — there is no silent drop, and the operator can
+* always answer "which of my 25 landed?".
+*
+* - `adopted` — created now by this job.
+* - `already-adopted` — a device for this candidate existed before the job
+*   reached it (a re-run, or a retry after a timeout). Not an error.
+* - `failed` — the provider threw; `error` carries the message.
+* - `cancelled` — the operator cancelled before this candidate was reached.
+*/
+var AdoptionOutcomeSchema = zod.z.enum([
+	"adopted",
+	"already-adopted",
+	"failed",
+	"cancelled"
+]);
+var AdoptionCandidateResultSchema = zod.z.object({
+	childNativeId: zod.z.string(),
+	outcome: AdoptionOutcomeSchema,
+	/** The materialised parent device id — null for `failed` / `cancelled`. */
+	parentDeviceId: zod.z.number().int().nonnegative().nullable(),
+	/** Accessory children created for this candidate. */
+	accessoryCount: zod.z.number().int().nonnegative(),
+	/** Failure message; null unless `outcome === 'failed'`. */
+	error: zod.z.string().nullable()
+});
+var AdoptionJobSchema = zod.z.object({
+	jobId: zod.z.string(),
+	/** The integration provider this job adopts through (the `addonId` pin). */
+	addonId: zod.z.string(),
+	integrationId: zod.z.string(),
+	state: AdoptionJobStateSchema,
+	/** Candidates the job was asked to adopt. Known up front, so never null. */
+	total: zod.z.number().int().nonnegative(),
+	/** Candidates that have reached a terminal bucket. */
+	processed: zod.z.number().int().nonnegative(),
+	adopted: zod.z.number().int().nonnegative(),
+	alreadyAdopted: zod.z.number().int().nonnegative(),
+	failed: zod.z.number().int().nonnegative(),
+	/** Accessory child devices created across every candidate — the real unit
+	*  of work, surfaced so a slow job is legible rather than mysterious. */
+	accessoriesCreated: zod.z.number().int().nonnegative(),
+	/** The candidate currently being adopted; null when idle or finished. */
+	currentChildNativeId: zod.z.string().nullable(),
+	/** One entry per candidate, in the order they were processed. */
+	results: zod.z.array(AdoptionCandidateResultSchema).readonly(),
+	startedAt: zod.z.number(),
+	finishedAt: zod.z.number().nullable(),
+	/** Set only when the job itself broke (not a per-candidate failure). */
+	error: zod.z.string().nullable()
+});
+/**
 * Per-camera FUNCTION SWITCHES — the one coherent on/off surface over the
 * pipeline functions an operator thinks in terms of.
 *
@@ -9484,6 +9582,31 @@ var deviceManagerCapability = {
 			auth: "admin"
 		}),
 		/**
+		* Start a background adoption and return its `jobId` immediately. The job
+		* adopts ONE candidate per provider call, so no single request can exceed
+		* the transport deadline, and it skips candidates that are already adopted
+		* — which makes re-submitting a batch after a timeout safe and silent
+		* rather than a wall of duplicate-stableId errors.
+		*/
+		adoptionStartJob: method(AdoptInputSchema.extend({ addonId: zod.z.string() }), zod.z.object({ jobId: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Adoption jobs for an integration, newest first. This is the answer to
+		* "which of my 25 landed?" — `results` carries one entry per candidate,
+		* every one of them in a named bucket.
+		*/
+		adoptionListJobs: method(zod.z.object({
+			addonId: zod.z.string(),
+			integrationId: zod.z.string().optional()
+		}), zod.z.array(AdoptionJobSchema).readonly(), { auth: "admin" }),
+		/** Cooperative cancel: the in-flight candidate finishes, the rest never start. */
+		adoptionCancelJob: method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Re-sync a device with its source via the device-adoption provider of the
 		* device's OWNING addon (resolved from `camDeviceId`). Unlike the singleton
 		* `device-adoption.resync`, this routes to the correct integration so a
@@ -17112,6 +17235,77 @@ var snapshotCapability = {
 			lastCapturedAt: zod.z.number().nullable(),
 			cacheAgeMs: zod.z.number().nullable(),
 			etag: zod.z.string().nullable()
+		}))),
+		/**
+		* Signed, expiring links to a CLIENT-SIZED frame — and the demand signal
+		* that makes those frames current.
+		*
+		* ## The problem it replaces
+		*
+		* `getSnapshotOverview` is cache-only by contract: it answers from whatever
+		* the wrapper happens to hold and never captures. Under D93 the client
+		* versions its image URL on that answer, and an image REQUEST is what enrols
+		* a camera in the keep-warm loop. Both of those are satisfiable by the
+		* client's own image cache — `expo-image` is URL-keyed and never revalidates
+		* — so a URL painted in a previous session comes off disk with no network,
+		* no enrolment, and nothing warming. Measured on the live hub: reopening
+		* after two minutes idle painted 15 of 16 tiles at **168 s old** with zero
+		* HTTP requests, and the fleet only recovered because a later poll happened
+		* to observe a different identity.
+		*
+		* ## The two properties that fix it
+		*
+		* **It is an RPC, so no client cache can answer it.** The demand signal
+		* always reaches the wrapper. This method therefore MAY create keep-warm
+		* subscriptions, where `getSnapshotOverview` must never (D93) — the
+		* distinction is not "one is newer" but that the overview poll is app-wide
+		* (a creating overview would warm every camera on the install) while this is
+		* called by a rendered surface naming the tiles it is actually painting, at
+		* the width it is painting them.
+		*
+		* **It waits, briefly and boundedly, for the capture it triggered.** The
+		* returned `capturedAt` is the frame the link will serve, not the frame the
+		* cache held when the client asked, so a first paint is honest and current
+		* instead of a generation behind. A device that does not settle inside the
+		* bound still gets a link and its real (older) `capturedAt` — the next poll
+		* carries it forward.
+		*
+		* `force` is never set on behalf of a client here. A sleeping battery camera
+		* is reported with `sleeping: true` and the last frame it produced, however
+		* old; the wrapper's existing sleep gate owns that decision and this method
+		* adds no second one.
+		*/
+		getSnapshotLinks: systemMethod(zod.z.object({ 
+		/** The tiles a surface is actually rendering. One entry per (device,
+		*  width) the caller will paint — the width is snapped to the server's
+		*  ladder and becomes part of the link's SIGNED identity. */
+targets: zod.z.array(zod.z.object({
+			deviceId: zod.z.number(),
+			/** Target width in px. Omit for the frame as captured — correct
+			*  for a full-bleed surface, wrong (and expensive) for a grid. */
+			width: zod.z.number().int().positive().optional()
+		})).min(1).max(200) }), zod.z.array(zod.z.object({
+			deviceId: zod.z.number(),
+			/** Root-relative signed path, or null when the link plane is not
+			*  served (no data-plane facility). Present even for a device that has
+			*  never captured — the request is what triggers the first one (D94). */
+			url: zod.z.string().nullable(),
+			/** Epoch ms of the frame this link serves. Null = never captured.
+			*  THE honest age: the tRPC path carried none before this. */
+			capturedAt: zod.z.number().nullable(),
+			/** Age of that frame at the moment the answer was built. */
+			ageMs: zod.z.number().nullable(),
+			/** Epoch ms after which `url` stops verifying. */
+			expiresAt: zod.z.number().nullable(),
+			/** Ladder rung the bytes are at; null = the frame as captured. */
+			width: zod.z.number().nullable(),
+			/** The device has never produced a frame. An empty state, not a
+			*  failure — and never a reason to withhold the link (D94). */
+			neverCaptured: zod.z.boolean(),
+			/** A sleeping battery camera: the frame is deliberately stale and will
+			*  NOT refresh in the background. A surface should say so rather than
+			*  present it as current. */
+			sleeping: zod.z.boolean()
 		})))
 	},
 	status: {
@@ -19726,6 +19920,45 @@ onColorChanged: { data: zod.z.object({
 	*/
 	runtimeState: ColorStatusSchema
 };
+var ConnectionTestOutcomeSchema = zod.z.discriminatedUnion("outcome", [
+	zod.z.object({
+		outcome: zod.z.literal("validated"),
+		/** Round-trip of the sign-in, when the provider measured it. */
+		latencyMs: zod.z.number().nonnegative().optional(),
+		/** Optional human detail worth showing next to the tick
+		*  ("3 devices visible on this account"). */
+		detail: zod.z.string().optional()
+	}).strict(),
+	zod.z.object({
+		outcome: zod.z.literal("rejected"),
+		error: zod.z.string()
+	}).strict(),
+	zod.z.object({
+		outcome: zod.z.literal("inconclusive"),
+		error: zod.z.string()
+	}).strict()
+]);
+var ConnectionTestInputSchema = zod.z.object({ 
+/** Candidate integration settings, exactly as the create form collected them. */
+settings: zod.z.record(zod.z.string(), zod.z.unknown()) });
+/**
+* What the provider's test actually DOES, so the UI can say it in words before
+* the operator presses the button ("Signs in to the Dreo cloud"). Purely
+* descriptive — it never changes routing.
+*/
+var ConnectionTestDescriptorSchema = zod.z.object({ label: zod.z.string() });
+var connectionTestCapability = {
+	name: "connection-test",
+	scope: "system",
+	mode: "collection",
+	methods: {
+		testSettings: method(ConnectionTestInputSchema, ConnectionTestOutcomeSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		describeTest: method(zod.z.void(), ConnectionTestDescriptorSchema, { auth: "admin" })
+	}
+};
 /**
 * Upstream-system connectivity sensor — distinct from `device-status`,
 * which is the kernel-managed online/offline flag for the device's
@@ -21169,15 +21402,57 @@ var AvailableIntegrationTypeSchema = zod.z.object({
 	*  flow can import (e.g. HA areas). Drives the adopt modal's "import
 	*  locations" checkbox. Provider-declared in the addon manifest. */
 	supportsLocationImport: zod.z.boolean(),
+	/**
+	* True when this integration DECLARES a pre-creation test (the
+	* `connection-test` cap, or a broker whose settings it stores). Drives the
+	* Test button: an integration that cannot be tested must say so up front
+	* rather than offering a button that always answers the same nonsense.
+	*/
+	canTest: zod.z.boolean(),
 	existingInstances: zod.z.array(zod.z.object({
 		id: zod.z.string(),
 		name: zod.z.string()
 	})),
 	canAdd: zod.z.boolean()
 });
+/**
+* Why a test could not be answered as a plain boolean.
+*
+* `success` alone collapsed four different situations into one red box, and the
+* one that mattered most — "nobody ever asked the remote anything" — looked
+* exactly like "the remote said no". The status is the discriminator:
+*
+*   - `validated`    — a provider-declared test ran and the remote ACCEPTED.
+*   - `rejected`     — a provider-declared test ran and the remote REFUSED.
+*                      The only status that blocks `integrations.create`.
+*   - `inconclusive` — a test IS declared but could not complete (timeout,
+*                      DNS, 5xx). Nothing was observed; not a failure.
+*   - `unsupported`  — this integration declares NO test. Nothing was
+*                      observed either; not a failure, and not a pass.
+*
+* `unsupported` and `inconclusive` both carry `success: false` so an older
+* client can never read them as a green tick, and both carry an `error` string
+* that SAYS the test did not run rather than inventing a failure.
+*/
+var TestConnectionStatusEnum = zod.z.enum([
+	"validated",
+	"rejected",
+	"inconclusive",
+	"unsupported"
+]);
 var TestConnectionResultSchema$1 = zod.z.object({
+	/** True ONLY for `validated`. Never true for a test that did not run. */
 	success: zod.z.boolean(),
-	error: zod.z.string().optional()
+	error: zod.z.string().optional(),
+	/** Optional for wire back-compat with clients built before the tri-state;
+	*  the server always sets it. */
+	status: TestConnectionStatusEnum.optional(),
+	/** Addon id whose declared test answered — `null` when none did. Lets the UI
+	*  attribute a result instead of blaming "the integration". */
+	testedBy: zod.z.string().nullable().optional(),
+	latencyMs: zod.z.number().nonnegative().optional(),
+	/** Human detail from a `validated` result ("3 devices on this account"). */
+	detail: zod.z.string().optional()
 });
 var CreateIntegrationInputSchema = zod.z.object({
 	addonId: zod.z.string(),
@@ -26975,6 +27250,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	carbonMonoxideCapability,
 	climateControlCapability,
 	colorCapability,
+	connectionTestCapability,
 	connectivityCapability,
 	consumablesCapability,
 	contactCapability,
@@ -27867,6 +28143,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"connectionTest.describeTest": {
+		capName: "connection-test",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"connectionTest.testSettings": {
+		capName: "connection-test",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"consumables.reset": {
 		capName: "consumables",
 		capScope: "device",
@@ -28257,6 +28545,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.adoptionCancelJob": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.adoptionListCandidateFilters": {
 		capName: "device-manager",
 		capScope: "system",
@@ -28269,6 +28563,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.adoptionListJobs": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.adoptionRefresh": {
 		capName: "device-manager",
 		capScope: "system",
@@ -28287,6 +28587,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.adoptionStartJob": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.allocateDeviceId": {
 		capName: "device-manager",
 		capScope: "system",
@@ -31425,6 +31731,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"snapshot.getSnapshotLinks": {
+		capName: "snapshot",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"snapshot.getSnapshotOverview": {
 		capName: "snapshot",
 		capScope: "device",

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-NRYjb8qK.js");
+const require_dist = require("./dist-D7wC-S4p.js");
 const require_model_download_service = require("./model-download-service-Caj1kaSi.js");
 const require_manifest_python_deps = require("./manifest-python-deps-BE6l8Y4W.js");
 const require_resource_monitor = require("./resource-monitor-DNNomR-i.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 { $ as objectInputDeclaresAddonId, B as isCollectionArrayMethod, Ct as asJsonObject$1, Dt as emitDownForOwnedCaps, Et as createEvent, Ft as readinessKey, G as lifecycleJobSchema, It as resolveCapMount, J as logLevelAtMost, L as extractNestedAddonId, Lt as scopeKey, Nt as parseJsonObject, Pt as parseJsonUnknown$1, Tt as asString$1, U as isVoidInput, V as isObjectInput, W as kebabToCamel, Y as looseSchema, bt as ReadinessRegistry, d as METHOD_ACCESS_MAP, f as RUNTIME_DEFAULTS, ft as errMsg$1, gt as DEVICE_STATUS_METHOD, ht as DEVICE_SETTINGS_CONTRIBUTION_METHODS, kt as expandCapMethods, mt as DATAPLANE_SECRET_HEADER$1, nt as procedureAuthKey, t as ALL_CAPABILITY_DEFINITIONS, v as addonSettingsCapability, wt as asNumber, xt as ReadinessTimeoutError, z as isArrayOutputSchema, zt as EventCategory$1 } from "./dist-CbS6uoSb.mjs";
+import { $ as objectInputDeclaresAddonId, B as isCollectionArrayMethod, Ct as asJsonObject$1, Dt as emitDownForOwnedCaps, Et as createEvent, Ft as readinessKey, G as lifecycleJobSchema, It as resolveCapMount, J as logLevelAtMost, L as extractNestedAddonId, Lt as scopeKey, Nt as parseJsonObject, Pt as parseJsonUnknown$1, Tt as asString$1, U as isVoidInput, V as isObjectInput, W as kebabToCamel, Y as looseSchema, bt as ReadinessRegistry, d as METHOD_ACCESS_MAP, f as RUNTIME_DEFAULTS, ft as errMsg$1, gt as DEVICE_STATUS_METHOD, ht as DEVICE_SETTINGS_CONTRIBUTION_METHODS, kt as expandCapMethods, mt as DATAPLANE_SECRET_HEADER$1, nt as procedureAuthKey, t as ALL_CAPABILITY_DEFINITIONS, v as addonSettingsCapability, wt as asNumber, xt as ReadinessTimeoutError, z as isArrayOutputSchema, zt as EventCategory$1 } from "./dist-C-QzFJ8v.mjs";
 import { a as downloadModel, c as getModelFilePath, d as contentTypeFor, f as createAuthenticatedFileServer, h as resolveFilePath, i as downloadFile, l as isModelDownloaded, m as parseTokenizedUrl, n as collectModelFiles, o as ensureModel, p as parseRangeHeader, r as deleteModelFromDisk, s as fetchJson, t as ModelDownloadService, u as createFileDataPlaneHandler } from "./model-download-service-CTBHzORJ.mjs";
 import { $ as buildNativeCapProxy, A as createHubCapForwardService, B as AGENT_CAP_FWD_ACTION, C as brokerTransportLink, Ct as resolveAddonClass, D as localProviderLink, E as ipcParentLink, F as createUdsLogger, G as callWithServiceDiscovery, H as CapRouteResolver, I as createUdsLoggerWithControl, J as UdsLocalTransportServer, K as createLocalTransport, L as LocalChildClient, M as createUdsEventBridge, N as createUdsEventBus, O as HUB_CAP_FWD_ACTION, P as udsChildLogToWorkerEntry, Q as encodeFrame, R as LocalChildRegistry, S as brokerCallForCap, St as runNpm, T as ipcChildLink, U as CapRouteError, V as AGENT_CAP_FWD_SERVICE, W as classifyCapRoute, X as localEndpointPath, Y as SocketChannel, Z as FrameDecoder, _ as createKernelHwAccel, _t as CapabilityHandle, a as getWorkerDeviceRegistry, b as __resetCapUsageRegistryForTests, bt as installManifestNativeDeps, c as setHubConnected, ct as NATIVE_PROVIDER_SERVICE_INFIX, d as getBrokerEventBus, dt as capBareAction, et as buildUdsNativeCapProxy, f as getMoleculerEventStats, ft as capServiceName, g as AddonDepsManager, gt as DeviceRegistry, h as subscribePassthrough, ht as serializeTypedArrays, i as createUdsAddonContext, it as mountNativeCapService, j as createParentUnownedCallHandler, k as HUB_CAP_FWD_SERVICE, l as EVENT_TOPIC_PREFIX, lt as capActionName, m as setNodeEventInterest, mt as deserializeTypedArrays, n as adaptBrokerToCluster, o as getOrInitReadinessRegistry, ot as createAddonService, p as registerEventBusService, pt as parseCapAction, q as UdsLocalTransportClient, r as createAddonContext, s as getOrInitReadinessRegistryForClient, st as validateProviderRegistrations, t as installManifestPythonDeps, tt as createBrokerDeviceManagerApi, u as clusterEventTopic, ut as capActionSuffix, v as resolveHwAccel, vt as CapabilityUnavailableError, w as buildLinkChain, wt as createAddonDataPlaneFacility, x as getCapUsageRegistry, xt as resolveNpmInvocation, y as CapUsageRegistry, yt as copyBundledNativeModules, z as UDS_NO_ROUTE_PREFIX } from "./manifest-python-deps-Dz1ryHIN.mjs";
 import { n as getSinglePidStats, t as getPidStats } from "./resource-monitor-BkP504Vq.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.67",
+  "version": "1.2.69",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",