@camstack/system 1.2.67 → 1.2.69

package/dist/{dist-CbS6uoSb.mjs → dist-C-QzFJ8v.mjs}

@@ -3200,6 +3200,104 @@ 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 = 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 = z.enum([
+	"adopted",
+	"already-adopted",
+	"failed",
+	"cancelled"
+]);
+var AdoptionCandidateResultSchema = z.object({
+	childNativeId: z.string(),
+	outcome: AdoptionOutcomeSchema,
+	/** The materialised parent device id — null for `failed` / `cancelled`. */
+	parentDeviceId: z.number().int().nonnegative().nullable(),
+	/** Accessory children created for this candidate. */
+	accessoryCount: z.number().int().nonnegative(),
+	/** Failure message; null unless `outcome === 'failed'`. */
+	error: z.string().nullable()
+});
+var AdoptionJobSchema = z.object({
+	jobId: z.string(),
+	/** The integration provider this job adopts through (the `addonId` pin). */
+	addonId: z.string(),
+	integrationId: z.string(),
+	state: AdoptionJobStateSchema,
+	/** Candidates the job was asked to adopt. Known up front, so never null. */
+	total: z.number().int().nonnegative(),
+	/** Candidates that have reached a terminal bucket. */
+	processed: z.number().int().nonnegative(),
+	adopted: z.number().int().nonnegative(),
+	alreadyAdopted: z.number().int().nonnegative(),
+	failed: 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: z.number().int().nonnegative(),
+	/** The candidate currently being adopted; null when idle or finished. */
+	currentChildNativeId: z.string().nullable(),
+	/** One entry per candidate, in the order they were processed. */
+	results: z.array(AdoptionCandidateResultSchema).readonly(),
+	startedAt: z.number(),
+	finishedAt: z.number().nullable(),
+	/** Set only when the job itself broke (not a per-candidate failure). */
+	error: 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: z.string() }), z.object({ jobId: 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(z.object({
+			addonId: z.string(),
+			integrationId: z.string().optional()
+		}), z.array(AdoptionJobSchema).readonly(), { auth: "admin" }),
+		/** Cooperative cancel: the in-flight candidate finishes, the rest never start. */
+		adoptionCancelJob: method(z.object({ jobId: z.string() }), z.object({ cancelled: 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: z.number().nullable(),
 			cacheAgeMs: z.number().nullable(),
 			etag: 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(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: z.array(z.object({
+			deviceId: 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: z.number().int().positive().optional()
+		})).min(1).max(200) }), z.array(z.object({
+			deviceId: 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: 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: z.number().nullable(),
+			/** Age of that frame at the moment the answer was built. */
+			ageMs: z.number().nullable(),
+			/** Epoch ms after which `url` stops verifying. */
+			expiresAt: z.number().nullable(),
+			/** Ladder rung the bytes are at; null = the frame as captured. */
+			width: 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: 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: z.boolean()
 		})))
 	},
 	status: {
@@ -19726,6 +19920,45 @@ onColorChanged: { data: z.object({
 	*/
 	runtimeState: ColorStatusSchema
 };
+var ConnectionTestOutcomeSchema = z.discriminatedUnion("outcome", [
+	z.object({
+		outcome: z.literal("validated"),
+		/** Round-trip of the sign-in, when the provider measured it. */
+		latencyMs: z.number().nonnegative().optional(),
+		/** Optional human detail worth showing next to the tick
+		*  ("3 devices visible on this account"). */
+		detail: z.string().optional()
+	}).strict(),
+	z.object({
+		outcome: z.literal("rejected"),
+		error: z.string()
+	}).strict(),
+	z.object({
+		outcome: z.literal("inconclusive"),
+		error: z.string()
+	}).strict()
+]);
+var ConnectionTestInputSchema = z.object({ 
+/** Candidate integration settings, exactly as the create form collected them. */
+settings: z.record(z.string(), 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 = z.object({ label: z.string() });
+var connectionTestCapability = {
+	name: "connection-test",
+	scope: "system",
+	mode: "collection",
+	methods: {
+		testSettings: method(ConnectionTestInputSchema, ConnectionTestOutcomeSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		describeTest: method(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 = z.object({
 	*  flow can import (e.g. HA areas). Drives the adopt modal's "import
 	*  locations" checkbox. Provider-declared in the addon manifest. */
 	supportsLocationImport: 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: z.boolean(),
 	existingInstances: z.array(z.object({
 		id: z.string(),
 		name: z.string()
 	})),
 	canAdd: 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 = z.enum([
+	"validated",
+	"rejected",
+	"inconclusive",
+	"unsupported"
+]);
 var TestConnectionResultSchema$1 = z.object({
+	/** True ONLY for `validated`. Never true for a test that did not run. */
 	success: z.boolean(),
-	error: z.string().optional()
+	error: 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: z.string().nullable().optional(),
+	latencyMs: z.number().nonnegative().optional(),
+	/** Human detail from a `validated` result ("3 devices on this account"). */
+	detail: z.string().optional()
 });
 var CreateIntegrationInputSchema = z.object({
 	addonId: 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",