@camstack/system 1.2.67 → 1.2.69

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.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-NRYjb8qK.js");
+const require_dist = require("../../dist-D7wC-S4p.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { _ as addonPagesCapability, ft as errMsg, pt as BaseAddon, zt as EventCategory } from "../../dist-CbS6uoSb.mjs";
+import { _ as addonPagesCapability, ft as errMsg, pt as BaseAddon, zt as EventCategory } from "../../dist-C-QzFJ8v.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.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-NRYjb8qK.js");
+const require_dist = require("../../dist-D7wC-S4p.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { ft as errMsg, pt as BaseAddon, y as addonWidgetsCapability, zt as EventCategory } from "../../dist-CbS6uoSb.mjs";
+import { ft as errMsg, pt as BaseAddon, y as addonWidgetsCapability, zt as EventCategory } from "../../dist-C-QzFJ8v.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";

package/dist/builtins/alerts/alerts.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-NRYjb8qK.js");
+const require_dist = require("../../dist-D7wC-S4p.js");
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,4 @@
-import { Et as createEvent, b as alertsCapability, ft as errMsg, n as AlertSchema, pt as BaseAddon, zt as EventCategory } from "../../dist-CbS6uoSb.mjs";
+import { Et as createEvent, b as alertsCapability, ft as errMsg, n as AlertSchema, pt as BaseAddon, zt as EventCategory } from "../../dist-C-QzFJ8v.mjs";
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/backup-orchestrator/backup-orchestrator.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-NRYjb8qK.js");
+const require_dist = require("../../dist-D7wC-S4p.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 let node_fs$1 = require_chunk.__toESM(node_fs, 1);

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { S as backupCapability, pt as BaseAddon, zt as EventCategory } from "../../dist-CbS6uoSb.mjs";
+import { S as backupCapability, pt as BaseAddon, zt as EventCategory } from "../../dist-C-QzFJ8v.mjs";
 import { randomBytes, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import Kt from "node:fs";

package/dist/builtins/console-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-NRYjb8qK.js");
+const require_dist = require("../../dist-D7wC-S4p.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

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

@@ -1,4 +1,4 @@
-import { pt as BaseAddon, q as logDestinationCapability } from "../../dist-CbS6uoSb.mjs";
+import { pt as BaseAddon, q as logDestinationCapability } from "../../dist-C-QzFJ8v.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

package/dist/builtins/core-blocks/core-blocks.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-NRYjb8qK.js");
+const require_dist = require("../../dist-D7wC-S4p.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

package/dist/builtins/core-blocks/core-blocks.addon.mjs

@@ -1,4 +1,4 @@
-import { D as coreBlocksCapability, E as coreBlockIdFromAddonId, T as coreBlockAddonId, c as CoreBlockSchema, l as DeclaredDevices, o as CORE_BLOCKS_ADDON_ID, pt as BaseAddon, s as CORE_BLOCK_ADDON_PREFIX } from "../../dist-CbS6uoSb.mjs";
+import { D as coreBlocksCapability, E as coreBlockIdFromAddonId, T as coreBlockAddonId, c as CoreBlockSchema, l as DeclaredDevices, o as CORE_BLOCKS_ADDON_ID, pt as BaseAddon, s as CORE_BLOCK_ADDON_PREFIX } from "../../dist-C-QzFJ8v.mjs";
 import { randomUUID } from "node:crypto";
 import * as path$1 from "node:path";
 import * as fs from "node:fs/promises";

package/dist/builtins/device-manager/adoption-job-engine.d.ts

@@ -0,0 +1,89 @@
+import { AdoptionJob, IScopedLogger } from '@camstack/types';
+/**
+ * The slice of a `device-adoption` provider this engine drives. Structural on
+ * purpose: the real provider satisfies it, and a spec can exercise the whole
+ * loop without standing up a registry.
+ */
+export interface AdoptionJobProvider {
+    listCandidates(input: {
+        integrationId: string;
+        page: number;
+        pageSize: number;
+        filter?: string;
+    }): Promise<{
+        readonly candidates: readonly {
+            readonly childNativeId: string;
+            readonly alreadyAdopted?: boolean;
+        }[];
+    }>;
+    adopt(input: {
+        integrationId: string;
+        childNativeIds: readonly string[];
+        filter?: string;
+        importLocations?: boolean;
+        perCandidate?: Record<string, {
+            name?: string;
+            hiddenChildIds?: string[];
+        }>;
+    }): Promise<{
+        readonly adopted: readonly {
+            readonly childNativeId: string;
+            readonly parentDeviceId: number;
+            readonly accessoryDeviceIds: readonly number[];
+        }[];
+    }>;
+}
+export interface AdoptionJobEngineDeps {
+    /** Resolve the integration's adoption provider for an `addonId` pin. */
+    resolveProvider(addonId: string): Promise<AdoptionJobProvider>;
+    readonly logger: IScopedLogger;
+    readonly now?: () => number;
+    readonly newId?: () => string;
+}
+export interface StartAdoptionJobInput {
+    readonly addonId: string;
+    readonly integrationId: string;
+    readonly childNativeIds: readonly string[];
+    readonly filter?: string;
+    readonly importLocations?: boolean;
+    readonly perCandidate?: Record<string, {
+        name?: string;
+        hiddenChildIds?: string[];
+    }>;
+}
+export declare class AdoptionJobEngine {
+    private readonly deps;
+    private readonly jobs;
+    private seq;
+    constructor(deps: AdoptionJobEngineDeps);
+    private now;
+    private newId;
+    /**
+     * Accept the batch and return immediately. The provider is resolved BEFORE
+     * returning so an unroutable `addonId` is refused at the call the operator
+     * made, not buried in a job they have to go looking for.
+     */
+    start(input: StartAdoptionJobInput): Promise<{
+        jobId: string;
+    }>;
+    get(jobId: string): AdoptionJob | null;
+    list(filter: {
+        addonId?: string;
+        integrationId?: string;
+    }): readonly AdoptionJob[];
+    /** Cooperative cancel — the in-flight candidate finishes, the rest do not start. */
+    cancel(jobId: string): boolean;
+    /** Test-only: await the detached loop. Never called by production code. */
+    waitForTest(jobId: string): Promise<void>;
+    private prune;
+    private run;
+    /**
+     * One `listCandidates` snapshot at job start. A read that FAILS must not be
+     * read as "nothing is adopted" — that would send every candidate to the
+     * provider and turn a safe retry back into a wall of duplicate-stableId
+     * errors — so a failure yields an empty set AND a warning, and the
+     * per-candidate failure path stays the backstop.
+     */
+    private alreadyAdopted;
+    private adoptOne;
+}

package/dist/builtins/device-manager/device-manager.addon.d.ts

@@ -48,6 +48,8 @@ export declare class DeviceManagerAddon extends BaseAddon {
      * the D3 re-handshake after device restore is the reliable replacement.
      */
     private remoteNativeCaps;
+    /** Background adoption jobs — lazily constructed (needs `ctx.logger`). */
+    private adoptionJobEngine;
     /** The runtime-state mirror, asserted present (constructed in onInitialize). */
     private get stateMirror();
     /** Build the `ProviderHost` the extracted provider-method modules
@@ -57,6 +59,12 @@ export declare class DeviceManagerAddon extends BaseAddon {
      *  `remoteNativeCaps` is mutated in place (never reassigned) so a direct
      *  reference preserves the live semantics. */
     private get providerHost();
+    /**
+     * Background adoption jobs. In-RAM and process-lifetime: a restart forgets
+     * them, which is safe because adoption is keyed by a stable id — re-running a
+     * job re-adopts nothing (see `AdoptionJobEngine`).
+     */
+    private get adoptionJobsImpl();
     /** Wait for a device-provider by addonId, returning null on timeout. */
     private waitDeviceProvider;
     /** Require a device-provider by addonId — throws if not found. */

package/dist/builtins/device-manager/device-manager.addon.js

@@ -3,9 +3,297 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-NRYjb8qK.js");
+const require_dist = require("../../dist-D7wC-S4p.js");
 let _camstack_types_node = require("@camstack/types/node");
 let node_crypto = require("node:crypto");
+//#region src/builtins/device-manager/adoption-job-engine.ts
+/** How many finished jobs are kept per (addonId, integrationId). */
+var JOB_HISTORY = 20;
+function snapshot(j) {
+	let adopted = 0;
+	let alreadyAdopted = 0;
+	let failed = 0;
+	let processed = 0;
+	let accessoriesCreated = 0;
+	for (const r of j.results) {
+		if (r.outcome === "cancelled") continue;
+		processed += 1;
+		accessoriesCreated += r.accessoryCount;
+		if (r.outcome === "adopted") adopted += 1;
+		else if (r.outcome === "already-adopted") alreadyAdopted += 1;
+		else if (r.outcome === "failed") failed += 1;
+	}
+	return {
+		jobId: j.jobId,
+		addonId: j.addonId,
+		integrationId: j.integrationId,
+		state: j.state,
+		total: j.total,
+		processed,
+		adopted,
+		alreadyAdopted,
+		failed,
+		accessoriesCreated,
+		currentChildNativeId: j.currentChildNativeId,
+		results: j.results.map((r) => ({
+			childNativeId: r.childNativeId,
+			outcome: r.outcome,
+			parentDeviceId: r.parentDeviceId,
+			accessoryCount: r.accessoryCount,
+			error: r.error
+		})),
+		startedAt: j.startedAt,
+		finishedAt: j.finishedAt,
+		error: j.error
+	};
+}
+var AdoptionJobEngine = class {
+	deps;
+	jobs = /* @__PURE__ */ new Map();
+	seq = 0;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	now() {
+		return this.deps.now?.() ?? Date.now();
+	}
+	newId() {
+		if (this.deps.newId) return this.deps.newId();
+		this.seq += 1;
+		return `adopt-${Date.now().toString(36)}-${this.seq}`;
+	}
+	/**
+	* Accept the batch and return immediately. The provider is resolved BEFORE
+	* returning so an unroutable `addonId` is refused at the call the operator
+	* made, not buried in a job they have to go looking for.
+	*/
+	async start(input) {
+		const provider = await this.deps.resolveProvider(input.addonId);
+		const job = {
+			jobId: this.newId(),
+			addonId: input.addonId,
+			integrationId: input.integrationId,
+			state: "running",
+			total: input.childNativeIds.length,
+			currentChildNativeId: null,
+			results: [],
+			startedAt: this.now(),
+			finishedAt: null,
+			error: null,
+			cancelRequested: false,
+			done: Promise.resolve()
+		};
+		this.jobs.set(job.jobId, job);
+		this.prune(input.addonId, input.integrationId);
+		this.deps.logger.info("adoption job started", {
+			tags: { addonId: input.addonId },
+			meta: {
+				jobId: job.jobId,
+				integrationId: input.integrationId,
+				total: job.total
+			}
+		});
+		job.done = this.run(job, provider, input);
+		return { jobId: job.jobId };
+	}
+	get(jobId) {
+		const j = this.jobs.get(jobId);
+		return j ? snapshot(j) : null;
+	}
+	list(filter) {
+		return [...this.jobs.values()].filter((j) => (filter.addonId === void 0 || j.addonId === filter.addonId) && (filter.integrationId === void 0 || j.integrationId === filter.integrationId)).sort((a, b) => b.startedAt - a.startedAt || b.jobId.localeCompare(a.jobId)).map(snapshot);
+	}
+	/** Cooperative cancel — the in-flight candidate finishes, the rest do not start. */
+	cancel(jobId) {
+		const job = this.jobs.get(jobId);
+		if (!job || job.state !== "running") return false;
+		job.cancelRequested = true;
+		this.deps.logger.info("adoption job cancel requested", {
+			tags: { addonId: job.addonId },
+			meta: {
+				jobId,
+				integrationId: job.integrationId
+			}
+		});
+		return true;
+	}
+	/** Test-only: await the detached loop. Never called by production code. */
+	async waitForTest(jobId) {
+		await this.jobs.get(jobId)?.done;
+	}
+	prune(addonId, integrationId) {
+		const finished = [...this.jobs.values()].filter((j) => j.addonId === addonId && j.integrationId === integrationId && j.state !== "running").sort((a, b) => b.startedAt - a.startedAt);
+		for (const j of finished.slice(JOB_HISTORY)) this.jobs.delete(j.jobId);
+	}
+	async run(job, provider, input) {
+		try {
+			const already = await this.alreadyAdopted(provider, input, job);
+			for (const childNativeId of input.childNativeIds) {
+				if (job.cancelRequested) {
+					job.results.push({
+						childNativeId,
+						outcome: "cancelled",
+						parentDeviceId: null,
+						accessoryCount: 0,
+						error: null
+					});
+					continue;
+				}
+				if (already.has(childNativeId)) {
+					job.results.push({
+						childNativeId,
+						outcome: "already-adopted",
+						parentDeviceId: null,
+						accessoryCount: 0,
+						error: null
+					});
+					this.deps.logger.info("adoption job: candidate already adopted, skipped", {
+						tags: { addonId: job.addonId },
+						meta: {
+							jobId: job.jobId,
+							integrationId: job.integrationId,
+							childNativeId
+						}
+					});
+					continue;
+				}
+				job.currentChildNativeId = childNativeId;
+				await this.adoptOne(job, provider, input, childNativeId);
+				job.currentChildNativeId = null;
+			}
+			job.state = job.cancelRequested ? "cancelled" : "done";
+		} catch (err) {
+			job.state = "failed";
+			job.error = require_dist.errMsg(err);
+			this.deps.logger.error("adoption job failed", {
+				tags: { addonId: job.addonId },
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					error: job.error
+				}
+			});
+		} finally {
+			job.currentChildNativeId = null;
+			job.finishedAt = this.now();
+			const s = snapshot(job);
+			this.deps.logger.info("adoption job finished", {
+				tags: { addonId: job.addonId },
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					state: s.state,
+					total: s.total,
+					adopted: s.adopted,
+					alreadyAdopted: s.alreadyAdopted,
+					failed: s.failed,
+					accessoriesCreated: s.accessoriesCreated,
+					durationMs: (s.finishedAt ?? 0) - s.startedAt
+				}
+			});
+		}
+	}
+	/**
+	* One `listCandidates` snapshot at job start. A read that FAILS must not be
+	* read as "nothing is adopted" — that would send every candidate to the
+	* provider and turn a safe retry back into a wall of duplicate-stableId
+	* errors — so a failure yields an empty set AND a warning, and the
+	* per-candidate failure path stays the backstop.
+	*/
+	async alreadyAdopted(provider, input, job) {
+		try {
+			const page = await provider.listCandidates({
+				integrationId: input.integrationId,
+				page: 1,
+				pageSize: 2e4,
+				...input.filter !== void 0 ? { filter: input.filter } : {}
+			});
+			const out = /* @__PURE__ */ new Set();
+			for (const c of page.candidates) if (c.alreadyAdopted === true) out.add(c.childNativeId);
+			return out;
+		} catch (err) {
+			this.deps.logger.warn("adoption job: pre-flight listCandidates failed — every candidate will be attempted", {
+				tags: { addonId: job.addonId },
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					error: require_dist.errMsg(err)
+				}
+			});
+			return /* @__PURE__ */ new Set();
+		}
+	}
+	async adoptOne(job, provider, input, childNativeId) {
+		const startedAt = this.now();
+		try {
+			const per = input.perCandidate?.[childNativeId];
+			const entry = (await provider.adopt({
+				integrationId: input.integrationId,
+				childNativeIds: [childNativeId],
+				...input.filter !== void 0 ? { filter: input.filter } : {},
+				...input.importLocations !== void 0 ? { importLocations: input.importLocations } : {},
+				...per !== void 0 ? { perCandidate: { [childNativeId]: per } } : {}
+			})).adopted[0];
+			if (!entry) {
+				job.results.push({
+					childNativeId,
+					outcome: "failed",
+					parentDeviceId: null,
+					accessoryCount: 0,
+					error: "provider returned no adopted entry"
+				});
+				this.deps.logger.warn("adoption job: provider adopted nothing for candidate", {
+					tags: { addonId: job.addonId },
+					meta: {
+						jobId: job.jobId,
+						integrationId: job.integrationId,
+						childNativeId
+					}
+				});
+				return;
+			}
+			job.results.push({
+				childNativeId,
+				outcome: "adopted",
+				parentDeviceId: entry.parentDeviceId,
+				accessoryCount: entry.accessoryDeviceIds.length,
+				error: null
+			});
+			this.deps.logger.info("adoption job: candidate adopted", {
+				tags: {
+					deviceId: entry.parentDeviceId,
+					addonId: job.addonId
+				},
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					childNativeId,
+					accessories: entry.accessoryDeviceIds.length,
+					durationMs: this.now() - startedAt
+				}
+			});
+		} catch (err) {
+			job.results.push({
+				childNativeId,
+				outcome: "failed",
+				parentDeviceId: null,
+				accessoryCount: 0,
+				error: require_dist.errMsg(err)
+			});
+			this.deps.logger.warn("adoption job: candidate failed", {
+				tags: { addonId: job.addonId },
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					childNativeId,
+					durationMs: this.now() - startedAt,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+	}
+};
+//#endregion
 //#region src/builtins/device-manager/day-night-config-schema.ts
 var MODE_LABELS = {
 	auto: "Auto",
@@ -1128,6 +1416,27 @@ async function adoptionRelease(pctx, input) {
 	const { addonId, ...rest } = input;
 	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).release(rest);
 }
+async function adoptionStartJob(pctx, input) {
+	const { addonId, integrationId, childNativeIds, filter, importLocations, perCandidate } = input;
+	return pctx.host.adoptionJobs.start({
+		addonId,
+		integrationId,
+		childNativeIds,
+		...filter !== void 0 ? { filter } : {},
+		...importLocations !== void 0 ? { importLocations } : {},
+		...perCandidate !== void 0 ? { perCandidate } : {}
+	});
+}
+async function adoptionListJobs(pctx, input) {
+	const { addonId, integrationId } = input;
+	return pctx.host.adoptionJobs.list({
+		addonId,
+		...integrationId !== void 0 ? { integrationId } : {}
+	});
+}
+async function adoptionCancelJob(pctx, input) {
+	return { cancelled: pctx.host.adoptionJobs.cancel(input.jobId) };
+}
 async function adoptionResync(pctx, input) {
 	const { camDeviceId, resetToSource } = input;
 	let owningAddonId = pctx.registry?.getAddonId(camDeviceId) ?? null;
@@ -3929,6 +4238,8 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 	* the D3 re-handshake after device restore is the reliable replacement.
 	*/
 	remoteNativeCaps = /* @__PURE__ */ new Map();
+	/** Background adoption jobs — lazily constructed (needs `ctx.logger`). */
+	adoptionJobEngine = null;
 	/** The runtime-state mirror, asserted present (constructed in onInitialize). */
 	get stateMirror() {
 		if (!this.stateMirrorImpl) throw new Error("DeviceManagerAddon: state mirror accessed before onInitialize");
@@ -3954,9 +4265,22 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			resolveDeviceProbed: (deviceId) => this.stateMirror.resolveDeviceProbed(deviceId),
 			waitDeviceProvider: (addonId, timeoutMs) => this.waitDeviceProvider(addonId, timeoutMs),
 			requireDeviceProvider: (addonId) => this.requireDeviceProvider(addonId),
-			requireDeviceAdoptionProvider: (addonId) => this.requireDeviceAdoptionProvider(addonId)
+			requireDeviceAdoptionProvider: (addonId) => this.requireDeviceAdoptionProvider(addonId),
+			adoptionJobs: this.adoptionJobsImpl
 		};
 	}
+	/**
+	* Background adoption jobs. In-RAM and process-lifetime: a restart forgets
+	* them, which is safe because adoption is keyed by a stable id — re-running a
+	* job re-adopts nothing (see `AdoptionJobEngine`).
+	*/
+	get adoptionJobsImpl() {
+		if (!this.adoptionJobEngine) this.adoptionJobEngine = new AdoptionJobEngine({
+			resolveProvider: async (addonId) => this.requireDeviceAdoptionProvider(addonId),
+			logger: this.ctx.logger
+		});
+		return this.adoptionJobEngine;
+	}
 	/** Wait for a device-provider by addonId, returning null on timeout. */
 	async waitDeviceProvider(addonId, timeoutMs = 5e3) {
 		const provider = await this.capabilityRegistry?.waitForProvider("device-provider", addonId, timeoutMs);
@@ -4136,6 +4460,9 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			adoptionRefresh: (input) => adoptionRefresh(pctx, input),
 			adoptionAdopt: (input) => adoptionAdopt(pctx, input),
 			adoptionRelease: (input) => adoptionRelease(pctx, input),
+			adoptionStartJob: (input) => adoptionStartJob(pctx, input),
+			adoptionListJobs: (input) => adoptionListJobs(pctx, input),
+			adoptionCancelJob: (input) => adoptionCancelJob(pctx, input),
 			adoptionResync: (input) => adoptionResync(pctx, input),
 			discoveryProviders: async () => {
 				return { providers: (await this.listDiscoveryCapableProviderIds()).map((addonId) => ({