@camstack/addon-pipeline 0.1.18 → 0.1.19

package/dist/{index-asZs8U_s.mjs → index-Bmlkm0Fd.mjs}

@@ -4778,6 +4778,16 @@ function record(keyType, valueType, params) {
     ...normalizeParams(params)
   });
 }
+function partialRecord(keyType, valueType, params) {
+  const k = clone(keyType);
+  k._zod.values = void 0;
+  return new ZodRecord({
+    type: "record",
+    keyType: k,
+    valueType,
+    ...normalizeParams(params)
+  });
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
@@ -5054,6 +5064,37 @@ function _instanceof(cls, params = {}) {
   };
   return inst;
 }
+const wiringProbeKindSchema = _enum(["singleton", "device", "widget"]);
+const wiringProbeResultSchema = object({
+  capName: string(),
+  kind: wiringProbeKindSchema,
+  deviceId: number().optional(),
+  reachable: boolean(),
+  latencyMs: number(),
+  error: string().optional()
+});
+const wiringAddonHealthSchema = object({
+  addonId: string(),
+  caps: array(wiringProbeResultSchema).readonly(),
+  widgets: array(wiringProbeResultSchema).readonly()
+});
+const wiringNodeHealthSchema = object({
+  nodeId: string(),
+  addons: array(wiringAddonHealthSchema).readonly()
+});
+object({
+  /** True only when every probed target is reachable. */
+  ok: boolean(),
+  /** True when at least one target is unreachable. */
+  degraded: boolean(),
+  checkedAt: string(),
+  nodes: array(wiringNodeHealthSchema).readonly(),
+  summary: object({
+    total: number(),
+    reachable: number(),
+    unreachable: number()
+  })
+});
 const MODEL_FORMATS = ["onnx", "coreml", "openvino", "tflite", "pt"];
 const WELL_KNOWN_TABS = [
   { id: "overview", label: "Overview", icon: "layout-dashboard", order: -10 },
@@ -6618,7 +6659,7 @@ const SpatialDetectionSchema = object({
   bbox: BoundingBoxSchema
 });
 const AudioChunkInputSchema = object({
-  data: _instanceof(Float32Array),
+  data: _instanceof(Uint8Array),
   sampleRate: number(),
   channels: number(),
   timestamp: number(),
@@ -7298,7 +7339,23 @@ const RunnerCameraConfigSchema = object({
    * whenever its `zones` device-state slice changes, so the runner's
    * copy stays in sync. Empty array → no zone filtering.
    */
-  zones: array(ZoneSchema).readonly().default([])
+  zones: array(ZoneSchema).readonly().default([]),
+  /**
+   * When true (default) and the camera's `motionSources` contains only
+   * `'onboard'`, the runner dynamically opens the same WASM frame-diff
+   * motion-frames subscription on each `MotionOnMotionChanged
+   * source:'onboard'` event and tears it down after `motionCooldownMs`.
+   * This causes `runMotionAnalysis` to emit `MotionZonesRaw` /
+   * `MotionAnalysis` during active-motion windows without the
+   * substream being held open continuously.
+   *
+   * Set to `false` to disable the dynamic analyzer for this camera
+   * (e.g. very low-bandwidth links where the extra substream is
+   * undesirable). Has no effect when `motionSources` already includes
+   * `'analyzer'` — the analyzer runs continuously in that case and
+   * this gate is bypassed.
+   */
+  onboardMotionDrivesAnalyzer: boolean().default(true)
 });
 const RunnerLocalLoadSchema = object({
   /** Moleculer node id of this runner instance. */
@@ -7438,22 +7495,68 @@ MotionTriggerStatusSchema.extend({
     }) }
   }
 });
+const MaskPointSchema = object({
+  x: number(),
+  y: number()
+});
+const MaskRectShapeSchema = object({
+  kind: literal("rect"),
+  x: number(),
+  y: number(),
+  width: number(),
+  height: number()
+});
+const MaskPolygonShapeSchema = object({
+  kind: literal("polygon"),
+  points: array(MaskPointSchema)
+});
+const MaskGridShapeSchema = object({
+  kind: literal("grid"),
+  gridWidth: number(),
+  gridHeight: number(),
+  cells: array(boolean())
+});
+const MaskLineShapeSchema = object({
+  kind: literal("line"),
+  points: array(MaskPointSchema)
+});
+discriminatedUnion("kind", [
+  MaskRectShapeSchema,
+  MaskPolygonShapeSchema,
+  MaskGridShapeSchema,
+  MaskLineShapeSchema
+]);
+const MaskShapeKindSchema = _enum(["rect", "polygon", "grid", "line"]);
+const MaskPolygonVerticesSchema = object({
+  min: number(),
+  max: number()
+});
+const MaskGridDimsSchema = object({
+  width: number(),
+  height: number()
+});
+const MotionZoneRegionSchema = object({
+  id: number(),
+  enabled: boolean(),
+  shape: MaskGridShapeSchema
+});
 object({
   enabled: boolean(),
   sensitivity: number(),
-  /** Row-major active-cell grid. Length = gridWidth*gridHeight (see getOptions). */
-  cells: array(boolean()),
+  /** Grid region(s). Today exactly one `grid` shape. */
+  regions: array(MotionZoneRegionSchema),
   lastFetchedAt: number()
 });
 const MotionZoneOptionsSchema = object({
-  gridWidth: number(),
-  gridHeight: number(),
+  maxRegions: number(),
+  supportedShapes: array(MaskShapeKindSchema),
+  grid: MaskGridDimsSchema,
   sensitivity: object({ min: number(), max: number(), step: number() })
 });
 const MotionZonePatchSchema = object({
   enabled: boolean().optional(),
   sensitivity: number().optional(),
-  cells: array(boolean()).optional()
+  regions: array(MotionZoneRegionSchema).optional()
 });
 ({
   deviceTypes: [DeviceType.Camera],
@@ -7466,6 +7569,102 @@ const MotionZonePatchSchema = object({
     )
   }
 });
+const NativeObjectClassEnum = _enum([
+  "person",
+  "vehicle",
+  "animal",
+  "face",
+  "package",
+  "other"
+]);
+const NativeDetectionSchema = object({
+  class: NativeObjectClassEnum,
+  timestamp: number(),
+  /** Firmware-provided confidence [0..1]. Reolink pushes don't carry it → undefined. */
+  confidence: number().min(0).max(1).optional()
+});
+const NativeObjectDetectionStatusSchema = object({
+  /**
+   * Last observed instance per class. Missing entries mean the class
+   * is supported but nothing has been seen since the provider started.
+   *
+   * MUST be a partial record: providers seed an empty `{}` on cold-start
+   * and write one class at a time as detections arrive. In Zod 4
+   * `z.record(enum, …)` is EXHAUSTIVE (requires every enum key), so a
+   * partial write throws "expected object, received undefined" for every
+   * unseen class. `z.partialRecord` keeps the enum-key narrowing while
+   * allowing the sparse shape the providers actually write.
+   */
+  lastByClass: partialRecord(NativeObjectClassEnum, NativeDetectionSchema.nullable()),
+  /** Classes the firmware is capable of detecting — enumerated at device register. */
+  supportedClasses: array(NativeObjectClassEnum).readonly(),
+  /**
+   * Whether forwarding of onboard AI detections is enabled for this device.
+   * Default true (on cold-start) — detections flow unconditionally before
+   * the toggle is saved, so defaulting true preserves existing behaviour.
+   */
+  enabled: boolean()
+});
+NativeObjectDetectionStatusSchema.extend({
+  /** Required by createRuntimeStateBridge — epoch ms of last refresh. */
+  lastFetchedAt: number()
+});
+({
+  deviceTypes: [DeviceType.Camera],
+  methods: {
+    setEnabled: method(
+      object({ deviceId: number(), enabled: boolean() }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  },
+  events: {
+    onDetected: { data: object({
+      deviceId: number(),
+      detection: NativeDetectionSchema
+    }) }
+  }
+});
+const PrivacyMaskShapeSchema = discriminatedUnion("kind", [
+  MaskRectShapeSchema,
+  MaskPolygonShapeSchema
+]);
+const PrivacyMaskRegionSchema = object({
+  /** Slot id, 0-based. Stable across read/write. */
+  id: number(),
+  /** Whether this zone is active (blanked out by the camera). */
+  enabled: boolean(),
+  shape: PrivacyMaskShapeSchema
+});
+object({
+  enabled: boolean(),
+  /** Active zones (normalized 0..1). Length ≤ maxRegions. */
+  regions: array(PrivacyMaskRegionSchema),
+  lastFetchedAt: number()
+});
+const PrivacyMaskOptionsSchema = object({
+  /** Maximum number of supported zones. */
+  maxRegions: number(),
+  /** Shape kinds this camera accepts — Reolink: ['rect']; Hikvision: ['rect','polygon']. */
+  supportedShapes: array(MaskShapeKindSchema),
+  /** Polygon vertex bounds when 'polygon' is supported (Hikvision: {min:4,max:4}). */
+  polygonVertices: MaskPolygonVerticesSchema.optional()
+});
+const PrivacyMaskPatchSchema = object({
+  enabled: boolean().optional(),
+  regions: array(PrivacyMaskRegionSchema).optional()
+});
+({
+  deviceTypes: [DeviceType.Camera],
+  methods: {
+    getOptions: method(object({ deviceId: number() }), PrivacyMaskOptionsSchema),
+    setMask: method(
+      object({ deviceId: number(), patch: PrivacyMaskPatchSchema }),
+      _void(),
+      { kind: "mutation", auth: "admin" }
+    )
+  }
+});
 const AutotrackTargetTypeSchema = string().describe("Vendor target string (people/vehicle/pet); empty = camera default");
 const PtzAutotrackSettingsSchema = object({
   targetType: AutotrackTargetTypeSchema,
@@ -7984,7 +8183,8 @@ const SettingsUpdateResultSchema = object({
       object({
         addonId: string(),
         nodeId: string().optional(),
-        overlay: record(string(), unknown()).optional()
+        overlay: record(string(), unknown()).optional(),
+        cap: string().optional()
       }),
       SettingsSchemaWithValuesSchema.nullable()
     ),
@@ -8715,7 +8915,14 @@ const OauthIntegrationDescriptorSchema = object({
   /** Allowed redirect_uri prefixes. /api/oauth2/authorize rejects any
    *  redirect_uri that does not start with one of these. Required —
    *  an empty list means the integration can never complete linking. */
-  allowedRedirectPrefixes: array(string()).min(1)
+  allowedRedirectPrefixes: array(string()).min(1),
+  /** Optional public origin (no trailing slash) that this integration's
+   *  issued codes/tokens should carry as the `hubUrl` claim — typically the
+   *  operator-selected external-access endpoint resolved by the addon. When
+   *  present, /api/oauth2/authorize bakes THIS into the code instead of the
+   *  hub-global `publicHubUrl()`, so a forked exporter addon (which can't set
+   *  the hub's env) drives the claim that its cloud Lambda routes back on. */
+  hubUrl: string().optional()
 });
 ({
   methods: {
@@ -9365,7 +9572,20 @@ const webrtcSessionCapability = {
       object({
         deviceId: number().int().nonnegative(),
         target: WebrtcStreamTargetSchema,
-        hints: webrtcClientHintsSchema.optional()
+        hints: webrtcClientHintsSchema.optional(),
+        /**
+         * SERVER-INJECTED — NOT a client hint. The hub layer that holds
+         * the tRPC request context (and therefore the client IP) sets
+         * this to `true` when the viewer's source IP is non-LAN
+         * (4G/CGNAT/internet). The broker then forces TURN-relay-only
+         * ICE for the session so a CGNAT client (which can only offer a
+         * relay candidate) gets a clean relay↔relay media path instead
+         * of werift nominating a dead host/hairpin-srflx pair. LAN
+         * clients leave this absent/false and keep the low-latency
+         * direct (host/srflx) path. Clients MUST NOT send this — the
+         * server overwrites it from the request context.
+         */
+        relayOnly: boolean().optional()
       }),
       object({ sessionId: string(), sdpOffer: string() }),
       { kind: "mutation" }
@@ -9388,7 +9608,22 @@ const webrtcSessionCapability = {
         deviceId: number().int().nonnegative(),
         target: WebrtcStreamTargetSchema.optional(),
         sdpOffer: string(),
-        sessionId: string().optional()
+        sessionId: string().optional(),
+        /**
+         * Force TURN-relay-only ICE for this session. Two kinds of caller
+         * set it:
+         *  - A cloud peer like Alexa's RTCSessionController (reachable
+         *    only via TURN, never our host/srflx behind NAT) passes
+         *    `true` from its own trusted addon context.
+         *  - The hub injects it for browser client-offer viewers from the
+         *    request's source IP (non-LAN ⇒ true), exactly as it does for
+         *    `createSession`.
+         * A LAN/Tailscale browser doing client-offer passthrough leaves it
+         * absent/false so a direct host pair carries full native quality.
+         * Untrusted browser clients MUST NOT send it — the hub overwrites
+         * it from the request context.
+         */
+        relayOnly: boolean().optional()
       }),
       object({ sessionId: string(), sdpAnswer: string() }),
       { kind: "mutation" }
@@ -9402,6 +9637,46 @@ const webrtcSessionCapability = {
       _void(),
       { kind: "mutation" }
     ),
+    /**
+     * Trickle ICE — add a remote (client) ICE candidate to a live session.
+     * Lets the client send its SDP offer/answer IMMEDIATELY (before ICE
+     * gathering finishes) and deliver candidates as they arrive, so the
+     * connection establishes in ~0s instead of waiting for full gathering.
+     * The dual of `getIceCandidates`. Mirrors Scrypted's signaling.
+     */
+    addIceCandidate: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        sessionId: string(),
+        candidate: string(),
+        sdpMid: string().nullable().optional(),
+        sdpMLineIndex: number().int().nullable().optional()
+      }),
+      _void(),
+      { kind: "mutation" }
+    ),
+    /**
+     * Trickle ICE — poll the server's gathered ICE candidates for a session.
+     * The server answers immediately (no gathering wait) and the client polls
+     * this to receive host/srflx/relay candidates as werift gathers them,
+     * adding each to its PeerConnection. Returns all candidates gathered so
+     * far; the client dedupes. `done` flips true once gathering completes.
+     */
+    getIceCandidates: method(
+      object({
+        deviceId: number().int().nonnegative(),
+        sessionId: string()
+      }),
+      object({
+        candidates: array(object({
+          candidate: string(),
+          sdpMid: string().nullable(),
+          sdpMLineIndex: number().int().nullable()
+        })),
+        done: boolean()
+      }),
+      { kind: "query" }
+    ),
     closeSession: method(
       object({
         deviceId: number().int().nonnegative(),
@@ -11102,6 +11377,9 @@ const detectionPipelineCapability = {
   exposesDeviceSettings: true,
   methods: {}
 };
+({
+  deviceTypes: [DeviceType.Camera]
+});
 const TrackStateSchema = _enum(["new", "entered", "left", "moving", "idle"]);
 const EventKindSchema = _enum(["motion", "object", "audio"]);
 const TrackPositionSchema = object({
@@ -11929,36 +12207,28 @@ const IntercomStatusSchema = object({
     }) }
   }
 });
-const NativeObjectClassEnum = _enum([
-  "person",
-  "vehicle",
-  "animal",
-  "face",
-  "package",
-  "other"
-]);
-const NativeDetectionSchema = object({
-  class: NativeObjectClassEnum,
-  timestamp: number(),
-  /** Firmware-provided confidence [0..1]. Reolink pushes don't carry it → undefined. */
-  confidence: number().min(0).max(1).optional()
-});
-object({
-  /**
-   * Last observed instance per class. Undefined entries mean the class
-   * is supported but nothing has been seen since the provider started.
-   */
-  lastByClass: record(NativeObjectClassEnum, NativeDetectionSchema.nullable()),
-  /** Classes the firmware is capable of detecting — enumerated at device register. */
-  supportedClasses: array(NativeObjectClassEnum).readonly()
+const CamStreamDescriptorSchema = object({
+  camStreamId: string().min(1),
+  kind: CamStreamKindSchema,
+  url: string().optional(),
+  codec: string().optional(),
+  resolution: CamStreamResolutionSchema.optional(),
+  fps: number().positive().optional(),
+  label: string().optional(),
+  /** Device-level features (e.g. `battery-operated`) — drives broker policy. */
+  deviceFeatures: array(string()).optional(),
+  /** Eligible for automatic profile assignment. Absent = `true`. */
+  autoEligible: boolean().optional(),
+  /** Transport-specific opaque metadata (e.g. rfc4571 SDP). */
+  metadata: record(string(), unknown()).optional()
 });
 ({
   deviceTypes: [DeviceType.Camera],
-  events: {
-    onDetected: { data: object({
-      deviceId: number(),
-      detection: NativeDetectionSchema
-    }) }
+  methods: {
+    getCatalog: method(
+      object({ deviceId: number().int().nonnegative() }),
+      array(CamStreamDescriptorSchema).readonly()
+    )
   }
 });
 const ModelFormatSchema = _enum(MODEL_FORMATS);
@@ -13166,7 +13436,8 @@ const PackageUpdateSchema = object({
   currentVersion: string(),
   latestVersion: string(),
   category: _enum(["addon", "core"]),
-  requiresRestart: boolean()
+  requiresRestart: boolean(),
+  isSystem: boolean()
 });
 const PackageVersionInfoSchema = object({
   version: string(),
@@ -13199,6 +13470,42 @@ const UpdateFrameworkPackageResultSchema = object({
   /** Ms-epoch the server scheduled its self-restart. */
   restartingAt: number()
 });
+const BulkUpdateItemStatusSchema = _enum([
+  "queued",
+  "updating",
+  "done",
+  "done-pending-restart",
+  "failed"
+]);
+const BulkUpdateItemSchema = object({
+  name: string(),
+  isSystem: boolean(),
+  fromVersion: string(),
+  toVersion: string(),
+  status: BulkUpdateItemStatusSchema,
+  error: string().optional(),
+  startedAtMs: number().optional(),
+  completedAtMs: number().optional()
+});
+const BulkUpdatePhaseSchema = _enum([
+  "regular",
+  "system",
+  "restarting",
+  "finalizing"
+]);
+const BulkUpdateStateSchema = object({
+  id: string(),
+  nodeId: string(),
+  startedAtMs: number(),
+  completedAtMs: number().optional(),
+  total: number(),
+  completed: number(),
+  failed: number(),
+  current: string().nullable(),
+  phase: BulkUpdatePhaseSchema,
+  cancelled: boolean(),
+  items: array(BulkUpdateItemSchema).readonly()
+});
 const FrameworkPackageStatusSchema = object({
   packageName: string(),
   currentVersion: string(),
@@ -13336,7 +13643,7 @@ const CustomActionInputSchema = object({
     getLastRestart: method(
       _void(),
       object({
-        kind: _enum(["framework-update", "manual", "system"]),
+        kind: _enum(["framework-update", "manual", "system", "framework-bulk-update"]),
         packageName: string().optional(),
         fromVersion: string().optional(),
         toVersion: string().optional(),
@@ -13426,11 +13733,70 @@ const CustomActionInputSchema = object({
     updateFrameworkPackage: method(
       object({
         packageName: string().min(1),
-        version: string().optional()
+        version: string().optional(),
+        deferRestart: boolean().optional()
       }),
       UpdateFrameworkPackageResultSchema,
       { kind: "mutation", auth: "admin" }
     ),
+    /**
+     * Kicks off a server-side bulk update operation and returns the bulk
+     * id immediately. The operation runs asynchronously; observe progress
+     * via the `AddonsBulkUpdateProgress` event or `getBulkUpdateState`.
+     * Items with `isSystem: true` use `deferRestart` — the hub restarts
+     * ONCE at the end of the system phase, after all system packages are
+     * installed.
+     *
+     * `items[].version` is REQUIRED — callers must pass the resolved
+     * version from `listUpdates`. There is no `'latest'` default here
+     * (unlike `updatePackage`) to guarantee deterministic bulk rolls.
+     */
+    startBulkUpdate: method(
+      object({
+        nodeId: string(),
+        items: array(object({
+          name: string(),
+          version: string(),
+          isSystem: boolean()
+        })).readonly()
+      }),
+      object({ id: string() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Returns the current state of a bulk update by id.
+     * Returns `null` if the id is unknown or has been auto-cleaned
+     * (5 minutes after `completedAt` the record is evicted from memory).
+     */
+    getBulkUpdateState: method(
+      object({ id: string() }),
+      BulkUpdateStateSchema.nullable(),
+      { auth: "admin" }
+    ),
+    /**
+     * Cancels an in-flight bulk update. The update loop exits after the
+     * currently-processing item completes — cancellation is not
+     * instantaneous. Has no effect once the `restarting` phase has been
+     * entered (the hub is already shutting down at that point).
+     * Returns `{ cancelled: false }` if the id is unknown, the operation
+     * has already completed, or the `restarting` phase is active.
+     */
+    cancelBulkUpdate: method(
+      object({ id: string() }),
+      object({ cancelled: boolean() }),
+      { kind: "mutation", auth: "admin" }
+    ),
+    /**
+     * Lists all currently active (non-completed) bulk updates.
+     * If `nodeId` is provided, filters to only bulk updates targeting
+     * that node. Useful for restoring an in-progress banner on a fresh
+     * page load when the UI reconnects mid-operation.
+     */
+    listActiveBulkUpdates: method(
+      object({ nodeId: string().optional() }),
+      array(BulkUpdateStateSchema).readonly(),
+      { auth: "admin" }
+    ),
     getVersions: method(
       object({ name: string() }),
       array(PackageVersionInfoSchema).readonly()
@@ -13558,6 +13924,7 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["StreamBrokerOnCamStreamDemand"] = "stream-broker.onCamStreamDemand";
   EventCategory2["StreamBrokerOnCamStreamIdle"] = "stream-broker.onCamStreamIdle";
   EventCategory2["StreamBrokerOnRequestStreamSourceRefresh"] = "stream-broker.onRequestStreamSourceRefresh";
+  EventCategory2["StreamParamsChanged"] = "stream-params.changed";
   EventCategory2["DeviceStateChanged"] = "device.state-changed";
   EventCategory2["BatteryOnStatusChanged"] = "battery.onStatusChanged";
   EventCategory2["DoorbellOnPressed"] = "doorbell.onPressed";
@@ -13605,6 +13972,7 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["NetworkTunnelStarted"] = "network.tunnel.started";
   EventCategory2["NetworkTunnelStopped"] = "network.tunnel.stopped";
   EventCategory2["LocalNetworkChanged"] = "network.local.changed";
+  EventCategory2["MeshNetworkChanged"] = "network.mesh.changed";
   EventCategory2["BackupCompleted"] = "backup.completed";
   EventCategory2["BackupRestored"] = "backup.restored";
   EventCategory2["NotificationDispatched"] = "notification.dispatched";
@@ -13615,6 +13983,7 @@ var EventCategory = /* @__PURE__ */ ((EventCategory2) => {
   EventCategory2["DeviceAwake"] = "device.awake";
   EventCategory2["DeviceSleeping"] = "device.sleeping";
   EventCategory2["RetentionCleanup"] = "retention.cleanup";
+  EventCategory2["AddonsBulkUpdateProgress"] = "addons.bulk-update-progress";
   return EventCategory2;
 })(EventCategory || {});
 function createEvent(category, source, data) {
@@ -13764,7 +14133,7 @@ class BaseAddon {
   }
   // ── Settings schemas (override to provide UI) ─────────────────────────
   /** Override to provide global-level settings UI schema. */
-  globalSettingsSchema() {
+  globalSettingsSchema(_cap) {
     return null;
   }
   /** Override to provide device-level settings UI schema. */
@@ -13778,8 +14147,8 @@ class BaseAddon {
   // blob and every addon used exactly one of them; the distinction was
   // never semantically load-bearing. `global` won because it was the
   // widely-used one and the name reads naturally (per-node addon config).
-  async getGlobalSettings(overlay) {
-    const schema = this.globalSettingsSchema();
+  async getGlobalSettings(overlay, cap) {
+    const schema = this.globalSettingsSchema(cap);
     if (!schema) return { sections: [] };
     const raw = await this._ctx?.settings?.readAddonStore() ?? {};
     return hydrateSchema(schema, overlay ? { ...raw, ...overlay } : raw);
@@ -14311,4 +14680,4 @@ export {
   DEFAULT_AUDIO_ANALYZER_CONFIG as y,
   AUDIO_BACKEND_CHOICES as z
 };
-//# sourceMappingURL=index-asZs8U_s.mjs.map
+//# sourceMappingURL=index-Bmlkm0Fd.mjs.map