@camstack/addon-pipeline 1.2.136 → 1.2.138

package/dist/{dist-C1dXLLQq.mjs → dist-CmEYRK7G.mjs}

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-//#region ../types/dist/event-category-CIa_iT6b.mjs
+//#region ../types/dist/event-category-BZL-fdNj.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -436,7 +436,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["MetricsNodeResourcesSnapshot"] = "metrics.node-resources-snapshot";
 	/**
 	* Periodic per-node process-tree snapshot (camstack-related pids
-	* with ghost / managed / root classification). Emitted ~0.2 Hz by
+	* with root / managed / system classification). Emitted ~0.2 Hz by
 	* the metrics-provider addon. Drives the Cluster → Processes tab
 	* without polling `metricsProvider.listNodeProcesses`.
 	*/
@@ -7173,6 +7173,40 @@ method(object({ deviceId: number() }), array(StreamSourceEntrySchema)), method(o
 	input: unknown()
 }), unknown(), { kind: "mutation" }), method(object({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), unknown().nullable()), method(object({ deviceId: number() }), RawStateResultSchema.nullable(), { auth: "protected" });
 /**
+* The ONE retry schedule for work that can fail simply because the node was
+* still booting.
+*
+* The measured failure (docs/design/boot-to-usable-camera.md, item E): a hub
+* boot that serialised its addon graph starved every driver dial on it. Fifteen
+* Hikvision devices logged `Initial probe did not complete — scheduling retry
+* chain {firstRetryMs=300000}` and then sat unprobed for five minutes, long
+* after the condition that caused the failure had gone. The Tailscale addon's
+* auto-rejoin carried a byte-identical schedule, armed from `initialize()`, for
+* the same reason.
+*
+* The shape that fixes it: **two cheap attempts first, then the long tail.**
+*
+*  - 15 s / 60 s — the boot window. Anything that failed because the node was
+*    busy is recovered here, before an operator can open the UI and see a
+*    camera that is wrong about itself.
+*  - 5 m → 90 m — the genuinely-offline case. A battery cam that is asleep, a
+*    VLAN that is down, a peer that has not come back. Unchanged in intent from
+*    the schedule this replaces (~3 h 30 m of coverage): here ~3 h 21 m, then
+*    the chain ends and manual re-arm (reprobe / restart) is the only path.
+*
+* Bounded on purpose — see D6. A chain that never gives up is a busy loop with
+* extra steps.
+*/
+var BOOT_RECOVERY_BACKOFF_MS = [
+	15e3,
+	6e4,
+	5 * 6e4,
+	15 * 6e4,
+	30 * 6e4,
+	60 * 6e4,
+	90 * 6e4
+];
+/**
 * Type-safe JSON parsing helpers.
 *
 * `JSON.parse` is typed as `any` in lib.es5.d.ts, which triggers
@@ -12868,6 +12902,19 @@ var SettingsRecordSchema = object({
 	data: record(string(), unknown())
 });
 /**
+* One record of a BULK insert — {@link SettingsRecordSchema} with the id made
+* optional.
+*
+* A separate schema rather than loosening the shared one: every other method
+* on this cap addresses a row BY its id, and making that field optional
+* everywhere would turn a forgotten key into a silently generated one on
+* `update` and `delete` as well.
+*/
+var BulkRecordSchema = object({
+	id: string().optional(),
+	data: record(string(), unknown())
+});
+/**
 * Column declaration for a structured (SQL-backed) collection.
 *
 * Logical types — the backend translates each to the matching SQLite
@@ -12924,6 +12971,10 @@ method(object({
 	collection: string(),
 	record: SettingsRecordSchema
 }), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	records: array(BulkRecordSchema).readonly()
+}), object({ inserted: number().int() }), { kind: "mutation" }), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	id: string(),
@@ -13032,6 +13083,13 @@ method(_void(), EngineInfoSchema, { auth: "admin" }), method(object({
 }), _void(), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	records: array(BulkRecordSchema).readonly()
+}), object({ inserted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	namespace: string().optional(),
 	collection: string(),
@@ -14852,6 +14910,82 @@ method(LogEntrySchema, _void(), { kind: "mutation" }), method(object({
 	limit: number().optional(),
 	tags: record(string(), string()).optional()
 }), array(LogEntrySchema).readonly());
+var LoadContributionSchema = object({
+	role: _enum([
+		"decode",
+		"transcode",
+		"recording",
+		"streaming",
+		"detection"
+	]),
+	/**
+	* The NUMERIC device id — the same value every log line carries as
+	* `tags.deviceId`. `null` means this cost genuinely belongs to no single
+	* camera (a shared pool), NOT that the contributor forgot to look it up: a
+	* contributor that cannot name its camera must not emit the entry at all,
+	* because an unnamed per-camera entry is indistinguishable from a shared one
+	* and would quietly turn one camera's cost into everybody's.
+	*/
+	deviceId: number().int().positive().nullable(),
+	attribution: _enum([
+		"measured",
+		"accounted",
+		"unattributable"
+	]),
+	/**
+	* What ONE entry is, in the contributor's own words — `615/high`,
+	* `617/native`, `cuda:0 shared pool`. Free text because the unit differs per
+	* family and inventing a common one would lose the only information that
+	* makes two entries for the same camera distinguishable.
+	*/
+	unit: string(),
+	/**
+	* The OS process this cost lives in, when there is one. Present so a
+	* consumer can (a) tell two generations of the same unit apart across a
+	* restart, and (b) subtract claimed processes from the node's process
+	* snapshot to see what NOBODY claimed. Absent for an entry that owns no
+	* process of its own.
+	*/
+	pid: number().int().positive().optional(),
+	/**
+	* When this generation started. The pid's incarnation marker: a consumer
+	* differencing {@link LoadContributionSchema.shape.cpuSeconds} must drop the
+	* window when this changes, because the counter restarted from zero in a new
+	* process.
+	*/
+	startedAtMs: number().optional(),
+	/**
+	* CUMULATIVE CPU seconds this unit has consumed since it started — user +
+	* system, read from the child's own `/proc/<pid>/stat` at the moment the
+	* contribution is asked for.
+	*
+	* Cumulative and not a rate on purpose: a rate needs a window, a window
+	* needs a sampler, and a new per-node sampler is the defect half of
+	* `docs/architecture/load-ledger.md` documents. A counter can be differenced
+	* by whoever already keeps a history; a rate cannot be un-averaged.
+	*
+	* Absent — never zero — on a node with no `/proc`, on a read failure, and on
+	* an entry with no process.
+	*/
+	cpuSeconds: number().optional(),
+	/** Resident bytes of this unit's process, same source and same rules. */
+	rssBytes: number().optional()
+});
+var loadContributionCapability = {
+	name: "load-contribution",
+	scope: "system",
+	mode: "collection",
+	internal: true,
+	methods: { 
+	/**
+	* This addon's own cost entries, computed live from state it already
+	* holds. Inert: no persistence, no sampling, no timer. It is answered on
+	* whatever beat the caller already has.
+	*/
+list: method(_void(), array(LoadContributionSchema).readonly()) },
+	/** In-process only — enumerated through `addons.listCapabilityProviders`. */
+	mount: { kind: "skip" }
+};
 /**
 * `login-method` — collection cap through which auth addons contribute
 * their pre-auth login surfaces to the login page. This is the SINGLE,
@@ -15055,8 +15189,7 @@ var NodeProcessSchema = object({
 	classification: _enum([
 		"root",
 		"managed",
-		"system",
-		"ghost"
+		"system"
 	]),
 	/** `$process` addon binding when `managed`, else null. */
 	addonId: string().nullable(),
@@ -15064,22 +15197,39 @@ var NodeProcessSchema = object({
 	nodeId: string().nullable(),
 	/** Truncated command line. */
 	command: string(),
+	/**
+	* `ps pcpu` — CPU averaged over the process's WHOLE LIFETIME, not a rate.
+	* On a runner up for days it barely moves. Fine as a column, useless as a
+	* series: use `cpuMainPercent + cpuGcPercent` for anything time-varying.
+	*/
 	cpuPercent: number(),
 	memoryRssBytes: number(),
+	/**
+	* Instantaneous CPU% of the process's own threads over the last
+	* process-snapshot window, from a `/proc/<pid>/task/*` tick delta.
+	*
+	* `null` = UNKNOWN, never zero: no previous sample yet (first tick after
+	* boot), the pid was recycled, or this node is not Linux.
+	*/
+	cpuMainPercent: number().nullable(),
+	/**
+	* Instantaneous CPU% of V8's `V8Worker` platform pool over the same window.
+	*
+	* This is the number that rewrote the 2026-08-27 diagnosis — hub-main 73%,
+	* `stream-broker` 61% (`docs/architecture/load-ledger.md`). A CPU chart that
+	* does not separate it from `cpuMainPercent` shows "busy" where the truth is
+	* "allocating too much".
+	*
+	* Concurrent GC is the dominant tenant of that pool but not the only one
+	* (background compilation runs there too), so it is reported as
+	* "GC / V8 helpers" rather than as pure collection time. `null` has the same
+	* meaning as on `cpuMainPercent`.
+	*/
+	cpuGcPercent: number().nullable(),
+	/** Threads seen in the tick scan. `null` under the same conditions. */
+	threadCount: number().nullable(),
 	/** Wall-clock uptime (seconds). Parsed from `ps etime`. */
-	uptimeSec: number(),
-	/** True when ancestor walk reaches `ppid=1` (reparented to init/launchd). */
-	orphaned: boolean()
-});
-var KillProcessInputSchema = object({
-	pid: number(),
-	/** Force = SIGKILL. Default is SIGTERM. */
-	force: boolean().optional()
-});
-var KillProcessResultSchema = object({
-	success: boolean(),
-	reason: string().optional(),
-	signal: _enum(["SIGTERM", "SIGKILL"]).optional()
+	uptimeSec: number()
 });
 var DumpHeapSnapshotInputSchema = object({ 
 /** The addon whose runner should dump a heap snapshot. */
@@ -15092,6 +15242,104 @@ var DumpHeapSnapshotResultSchema = object({
 	pid: number().optional(),
 	reason: string().optional()
 });
+/**
+* One point of one function's series.
+*
+* The unsuffixed fields are the bucket's **MAXIMUM**, and that choice is the
+* point of the whole surface. The two obvious reductions both lie: a mean per
+* bucket smears a spike away, and taking every Nth sample skips it outright.
+* Either would give us a tool built to find peaks that does not show peaks.
+* `...Min` carries the other end, `samples` says how many raw snapshots folded
+* into the bucket, and a mean stays derivable where it is wanted.
+*
+* An UNREDUCED point is a one-sample bucket: `samples === 1` and each `...Min`
+* equals its unsuffixed twin. Reduced and unreduced are the same shape, so a
+* caller cannot tell which it received — which is what "one reader" means.
+*/
+var LoadPointSchema = object({
+	/** Bucket START, or the snapshot's own timestamp when unreduced. */
+	atMs: number(),
+	/** Raw snapshots in this bucket. Never 0 — AN EMPTY BUCKET IS ABSENT. */
+	samples: number().int(),
+	/**
+	* `null` = UNKNOWN and it PROPAGATES: a bucket is null unless every process
+	* of every snapshot in it reported a thread split. A partial sum is a
+	* smaller number that looks exactly as real as a complete one.
+	*/
+	cpuMainPercent: number().nullable(),
+	cpuMainPercentMin: number().nullable(),
+	cpuGcPercent: number().nullable(),
+	cpuGcPercentMin: number().nullable(),
+	/** Lifetime-average CPU%, summed. Always known — and never a rate. */
+	cpuLifetimePercent: number(),
+	cpuLifetimePercentMin: number(),
+	memoryRssBytes: number(),
+	memoryRssBytesMin: number(),
+	processCount: number().int(),
+	processCountMin: number().int()
+});
+/** One function's series. `key` is an addonId, `__root__` or `__unattributed__`. */
+var LoadFunctionSeriesSchema = object({
+	key: string(),
+	kind: _enum([
+		"addon",
+		"root",
+		"unattributed"
+	]),
+	/** Oldest-first. A missing interval is MISSING — never zero-filled. */
+	points: array(LoadPointSchema).readonly()
+});
+var NodeLoadSeriesSchema = object({
+	nodeId: string(),
+	/** One entry per function seen in the window, heaviest-first. */
+	series: array(LoadFunctionSeriesSchema).readonly(),
+	/**
+	* Width of one returned bucket, in ms. Equals the sampling cadence when no
+	* reduction was needed — so a caller can always say what one point covers
+	* without having to know whether it was reduced.
+	*/
+	bucketMs: number(),
+	/** Raw snapshots that went into this answer, across both tiers. */
+	retainedSamples: number(),
+	/** Oldest snapshot represented, or `null` when nothing is retained. */
+	oldestAtMs: number().nullable(),
+	/** The fixed sampling cadence in force on the cluster, in ms. */
+	cadenceMs: number(),
+	/**
+	* Did the DURABLE tier contribute? `false` means the answer is the hot ring
+	* alone — an agent (which holds no table), or a store that refused.
+	* Reported because "the last hour" and "the last six hours" are different
+	* questions and an operator must not have to guess which was answered.
+	*/
+	durable: boolean()
+});
+var GetLoadSeriesInputSchema = object({
+	/**
+	* The node whose series is wanted.
+	*
+	* NOT named `nodeId`: the generated cap router strips a top-level
+	* `nodeId` from every method input and uses it to ROUTE the call to
+	* that node's provider (`generated-cap-routers.ts`). A series target
+	* called `nodeId` would silently become a routing pin and never reach
+	* the provider. The hub holds every node it hears from, so the
+	* ordinary call is unpinned — answered by the hub, for any node.
+	*/
+	forNodeId: string(),
+	/**
+	* EXCLUSIVE lower bound. A caller passes the newest `atMs` it already
+	* holds and receives only what it is missing, so seeding a live chart
+	* from this method cannot double a point already drawn.
+	*/
+	sinceMs: number().optional(),
+	/**
+	* Most points the caller wants PER FUNCTION. The window is reduced to fit,
+	* preserving min and max per bucket.
+	*
+	* Absent means NO reduction — legitimate for a short window and a trap for a
+	* long one, which is why a chart passes its own pixel width.
+	*/
+	maxPoints: number().int().positive().optional()
+});
 var SystemMetricsSchema = object({
 	cpuPercent: number(),
 	memoryPercent: number(),
@@ -15102,10 +15350,7 @@ var SystemMetricsSchema = object({
 	gpuPercent: number().optional(),
 	gpuMemoryPercent: number().optional()
 });
-method(_void(), SystemResourceSnapshotSchema), method(_void(), SystemResourceSnapshotSchema.nullable()), method(_void(), SystemMetricsSchema), method(object({ dirPath: string() }), DiskSpaceInfoSchema), method(_void(), MetricsGpuInfoSchema.nullable()), method(_void(), number().nullable()), method(object({ pids: array(number()) }), array(PidResourceStatsSchema)), method(_void(), array(AddonInstanceSchema).readonly()), method(object({ addonId: string() }), PidResourceStatsSchema.nullable()), method(_void(), array(NodeProcessSchema).readonly()), method(KillProcessInputSchema, KillProcessResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(DumpHeapSnapshotInputSchema, DumpHeapSnapshotResultSchema, {
+method(_void(), SystemResourceSnapshotSchema), method(_void(), SystemResourceSnapshotSchema.nullable()), method(_void(), SystemMetricsSchema), method(object({ dirPath: string() }), DiskSpaceInfoSchema), method(_void(), MetricsGpuInfoSchema.nullable()), method(_void(), number().nullable()), method(object({ pids: array(number()) }), array(PidResourceStatsSchema)), method(_void(), array(AddonInstanceSchema).readonly()), method(object({ addonId: string() }), PidResourceStatsSchema.nullable()), method(_void(), array(NodeProcessSchema).readonly()), method(GetLoadSeriesInputSchema, NodeLoadSeriesSchema), method(DumpHeapSnapshotInputSchema, DumpHeapSnapshotResultSchema, {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -29405,6 +29650,15 @@ var LoggingSettingsPatchSchema = object({
 * authority over the whole hierarchy and answers for every layer, so the
 * layer selector needs a name the transport does not already own.
 */
+/**
+* One contribution, plus WHO reported it.
+*
+* The addon and node are added by the hub as it enumerates providers, never by
+* the contributor: an addon reporting its own identity could report somebody
+* else's, and the whole point of this surface is that no claim is made by
+* anyone but its owner.
+*/
+var ReportedLoadContributionSchema = LoadContributionSchema.extend({ addonId: string() });
 var GetLoggingSettingsInputSchema = object({
 	scopeNodeId: string().optional(),
 	/**
@@ -29463,7 +29717,7 @@ method(_void(), FeatureManifestSchema), method(_void(), HealthStatusSchema), met
 }), method(_void(), SiteLocationStatusSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), RequestCensusStatusSchema, { auth: "admin" }), method(GetLoggingSettingsInputSchema, LoggingSettingsStateSchema, { auth: "admin" }), method(SetLoggingSettingsInputSchema, LoggingSettingsStateSchema, {
+}), method(_void(), RequestCensusStatusSchema, { auth: "admin" }), method(_void(), array(ReportedLoadContributionSchema).readonly(), { auth: "admin" }), method(GetLoggingSettingsInputSchema, LoggingSettingsStateSchema, { auth: "admin" }), method(SetLoggingSettingsInputSchema, LoggingSettingsStateSchema, {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -31238,6 +31492,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"dataStoreProvider.insertMany": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"dataStoreProvider.isEmpty": {
 		capName: "data-store-provider",
 		capScope: "system",
@@ -32552,6 +32812,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"loadContribution.list": {
+		capName: "load-contribution",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.downloadCa": {
 		capName: "local-network",
 		capScope: "system",
@@ -32852,17 +33118,17 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"metricsProvider.getProcessStats": {
+	"metricsProvider.getLoadSeries": {
 		capName: "metrics-provider",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"metricsProvider.killProcess": {
+	"metricsProvider.getProcessStats": {
 		capName: "metrics-provider",
 		capScope: "system",
 		addonId: null,
-		access: "create"
+		access: "view"
 	},
 	"metricsProvider.listAddonInstances": {
 		capName: "metrics-provider",
@@ -34874,6 +35140,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"settingsStore.insertMany": {
+		capName: "settings-store",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"settingsStore.isEmpty": {
 		capName: "settings-store",
 		capScope: "system",
@@ -35486,6 +35758,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"system.getLoadContributions": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"system.getLoggingSettings": {
 		capName: "system",
 		capScope: "system",
@@ -39467,4 +39745,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { logChannelsCapability as $, EventCategory as $t, audioAnalysisCapability as A, DeviceFeature as At, defineCustomActions as B, selectAssignedProfileSlots as Bt, RATE_CONTROL_RELAXED as C, AUDIO_PRESETS as Ct, RingBuffer as D, isSoftwareDecode as Dt, RecordingConfigSchema as E, invocationFromEncodeProfile as Et, createHwAccelCache as F, makeProfileBrokerId as Ft, egressTranscodeSharingKey as G, discriminatedUnion as Gt, deriveDetailCropRect as H, _enum as Ht, createLogChannelsProvider as I, makeSourceBrokerId as It, evaluateSensorEdge as J, number as Jt, egressTransportFromRequest as K, lazy as Kt, customAction as L, nodePin as Lt, audioKindId as M, createEvent as Mt, batteryCapability as N, hydrateSchema as Nt, YAMNET_TO_MACRO as O, BaseAddon as Ot, cameraStreamsCapability as P, isEvent as Pt, isFirstLevelMacroClass as Q, union as Qt, declareLogChannel as R, parseJsonUnknown as Rt, PoolMemoryWatchdog as S, errMsg as St, RECORDING_EXPORT_MAX_READ_BYTES as T, buildFfmpegArgs as Tt, deriveRecordingMode as U, array as Ut, deriveBatteryPresence as V, sleep as Vt, detectionPipelineCapability as W, boolean as Wt, hfModelUrl as X, record as Xt, evaluateZoneRules as Y, object as Yt, inferModelProvider as Z, string as Zt, ExportRecordSchema as _, runtimeDevices as _t, COCO_80_LABELS as a, pickClusterStepModels as at, NativeLeaseSettingsSchema as b, supportedRuntimes as bt, DEFAULT_CLUSTER_STEP_MODELS as c, pickNativeLeaseOverride as ct, DEFAULT_EVENTS_BAND_BUFFER_SEC as d, recordingCapability as dt, mapAudioLabelToMacro as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, recordingExportCapability as ft, EncodeProfileSchema as g, resolveRecordingProfiles as gt, EVENT_PAD_MS as h, resolvePoolMemoryPolicy as ht, BatteryStatusSchema as i, parseProcStatus as it, audioAnalyzerCapability as j, DeviceType as jt, addonWidgetsSourceCapability as k, CAM_PROFILE_ORDER as kt, DEFAULT_CLUSTER_STEP_SETTINGS as l, pipelineExecutorCapability as lt, DEVICE_BACKEND_TO_FORMAT as m, resolveEgressDecodeHwAccel as mt, AUDIO_BACKEND_CHOICES as n, motionDetectionCapability as nt, COCO_TO_MACRO as o, pickClusterStepSettings as ot, DEFAULT_NATIVE_LEASE_SETTINGS as p, resolveClusterStepModelId as pt, enumerateInferenceDevices as q, literal as qt, AUDIO_MACRO_LABELS as r, overlayClusterStepSettings as rt, DEFAULT_AUDIO_ANALYZER_CONFIG as s, pickDetailCropConvention as st, APPLE_SA_TO_MACRO as t, maskUrlCredentials as tt, DEFAULT_DETAIL_CROP_CONVENTION as u, pipelineRunnerCapability as ut, HF_BASE_URL as v, storageEvictableCapability as vt, RATE_CONTROL_TIGHT as w, Fmp4BoxSplitter as wt, OpsLogEntrySchema as x, webrtcSessionCapability as xt, NativeLeaseAdmissionSchema as y, streamBrokerCapability as yt, defaultDeviceFor as z, parseProfileBrokerId as zt };
+export { loadContributionCapability as $, string as $t, audioAnalysisCapability as A, BaseAddon as At, defineCustomActions as B, parseJsonUnknown as Bt, RATE_CONTROL_RELAXED as C, errMsg as Ct, RingBuffer as D, invocationFromEncodeProfile as Dt, RecordingConfigSchema as E, buildFfmpegArgs as Et, createHwAccelCache as F, hydrateSchema as Ft, egressTranscodeSharingKey as G, array as Gt, deriveDetailCropRect as H, selectAssignedProfileSlots as Ht, createLogChannelsProvider as I, isEvent as It, evaluateSensorEdge as J, lazy as Jt, egressTransportFromRequest as K, boolean as Kt, customAction as L, makeProfileBrokerId as Lt, audioKindId as M, DeviceFeature as Mt, batteryCapability as N, DeviceType as Nt, YAMNET_TO_MACRO as O, isSoftwareDecode as Ot, cameraStreamsCapability as P, createEvent as Pt, isFirstLevelMacroClass as Q, record as Qt, declareLogChannel as R, makeSourceBrokerId as Rt, PoolMemoryWatchdog as S, webrtcSessionCapability as St, RECORDING_EXPORT_MAX_READ_BYTES as T, Fmp4BoxSplitter as Tt, deriveRecordingMode as U, sleep as Ut, deriveBatteryPresence as V, parseProfileBrokerId as Vt, detectionPipelineCapability as W, _enum as Wt, hfModelUrl as X, number as Xt, evaluateZoneRules as Y, literal as Yt, inferModelProvider as Z, object as Zt, ExportRecordSchema as _, resolveRecordingProfiles as _t, COCO_80_LABELS as a, parseProcStatus as at, NativeLeaseSettingsSchema as b, streamBrokerCapability as bt, DEFAULT_CLUSTER_STEP_MODELS as c, pickDetailCropConvention as ct, DEFAULT_EVENTS_BAND_BUFFER_SEC as d, pipelineRunnerCapability as dt, union as en, logChannelsCapability as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, recordingCapability as ft, EncodeProfileSchema as g, resolvePoolMemoryPolicy as gt, EVENT_PAD_MS as h, resolveEgressDecodeHwAccel as ht, BatteryStatusSchema as i, overlayClusterStepSettings as it, audioAnalyzerCapability as j, CAM_PROFILE_ORDER as jt, addonWidgetsSourceCapability as k, BOOT_RECOVERY_BACKOFF_MS as kt, DEFAULT_CLUSTER_STEP_SETTINGS as l, pickNativeLeaseOverride as lt, DEVICE_BACKEND_TO_FORMAT as m, resolveClusterStepModelId as mt, AUDIO_BACKEND_CHOICES as n, maskUrlCredentials as nt, COCO_TO_MACRO as o, pickClusterStepModels as ot, DEFAULT_NATIVE_LEASE_SETTINGS as p, recordingExportCapability as pt, enumerateInferenceDevices as q, discriminatedUnion as qt, AUDIO_MACRO_LABELS as r, motionDetectionCapability as rt, DEFAULT_AUDIO_ANALYZER_CONFIG as s, pickClusterStepSettings as st, APPLE_SA_TO_MACRO as t, EventCategory as tn, mapAudioLabelToMacro as tt, DEFAULT_DETAIL_CROP_CONVENTION as u, pipelineExecutorCapability as ut, HF_BASE_URL as v, runtimeDevices as vt, RATE_CONTROL_TIGHT as w, AUDIO_PRESETS as wt, OpsLogEntrySchema as x, supportedRuntimes as xt, NativeLeaseAdmissionSchema as y, storageEvictableCapability as yt, defaultDeviceFor as z, nodePin as zt };

package/dist/{event-loop-stall-monitor-DjV4Bow7.js → event-loop-stall-monitor-Bef2jXMX.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-BzLiQ8Ue.js");
+const require_dist = require("./dist-BuIP0499.js");
 let node_crypto = require("node:crypto");
 let node_perf_hooks = require("node:perf_hooks");
 //#region src/detection-pipeline/registry/model-catalogs.ts

package/dist/{event-loop-stall-monitor-CU-xxX5c.mjs → event-loop-stall-monitor-JGTFb0Uv.mjs}

@@ -1,4 +1,4 @@
-import { M as audioKindId, X as hfModelUrl, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-C1dXLLQq.mjs";
+import { M as audioKindId, X as hfModelUrl, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-CmEYRK7G.mjs";
 import { randomUUID } from "node:crypto";
 import { PerformanceObserver } from "node:perf_hooks";
 //#region src/detection-pipeline/registry/model-catalogs.ts

package/dist/{lazy-sharp-DxWmhTqk.js → lazy-sharp-DH2eVehm.js}

@@ -1,8 +1,8 @@
-const require_dist = require("./dist-BzLiQ8Ue.js");
-let node_url = require("node:url");
-let node_module = require("node:module");
+const require_dist = require("./dist-BuIP0499.js");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
+let node_url = require("node:url");
+let node_module = require("node:module");
 //#region src/shared/host-external-import.ts
 /**
 * Resolving a HOST-EXTERNAL package (`sharp`, `node-av`, …) from a process that

package/dist/motion-wasm/index.js

@@ -2,10 +2,10 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BzLiQ8Ue.js");
-const require_lazy_sharp = require("../lazy-sharp-DxWmhTqk.js");
-let node_path = require("node:path");
+const require_dist = require("../dist-BuIP0499.js");
+const require_lazy_sharp = require("../lazy-sharp-DH2eVehm.js");
 let node_fs = require("node:fs");
+let node_path = require("node:path");
 //#region src/motion-wasm/wasm-motion-detector.ts
 /**
 * WasmMotionDetector — loads the AssemblyScript WASM module and provides

package/dist/motion-wasm/index.mjs

@@ -1,7 +1,7 @@
-import { Nt as hydrateSchema, Ot as BaseAddon, Y as evaluateZoneRules, jt as DeviceType, nt as motionDetectionCapability } from "../dist-C1dXLLQq.mjs";
-import { t as getSharp } from "../lazy-sharp-BtT5x-qP.mjs";
-import { join } from "node:path";
+import { At as BaseAddon, Ft as hydrateSchema, Nt as DeviceType, Y as evaluateZoneRules, rt as motionDetectionCapability } from "../dist-CmEYRK7G.mjs";
+import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { readFileSync } from "node:fs";
+import { join } from "node:path";
 //#region src/motion-wasm/wasm-motion-detector.ts
 /**
 * WasmMotionDetector — loads the AssemblyScript WASM module and provides