@camstack/core 0.1.14 → 0.1.16

package/dist/builtins/snapshot/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/builtins/snapshot/snapshot.addon.ts"],"sourcesContent":["import { execFile } from 'node:child_process'\nimport { DeviceFeature, DeviceType, snapshotCapability } from '@camstack/types'\nimport type { ConfigUISchemaWithValues, InferProvider, ProfileSlot, ProviderRegistration } from '@camstack/types'\nimport { BaseAddon, errMsg, streamQualityLabel } from '@camstack/types'\n\ntype ISnapshotProvider = InferProvider<typeof snapshotCapability>\ntype SnapshotImage = { base64: string; contentType: string }\n\n/**\n * Per-device snapshot settings stored via `ctx.settings.writeDeviceStore`.\n * Kept as a plain interface (not Zod) because the value set is tiny and\n * `snapshot` isn't worth the extra schema plumbing — runtime coercion\n * happens inline in `getDeviceStoreTyped` below.\n */\ninterface SnapshotDeviceSettings {\n  /** Quality profile to prefer when grabbing a snapshot (e.g. `high`, `mid`). Empty = auto. */\n  readonly snapshotStreamId?: string\n  /** If true, log extra detail (timing, selected stream, error paths). */\n  readonly snapshotDebug?: boolean\n  /**\n   * Maximum acceptable cache age in seconds. Below it the wrapper\n   * serves the cached image; above it (or on `force`) it falls\n   * through to the native (which on battery cams wakes the\n   * firmware). When unset the per-device default applies:\n   * `BATTERY_DEFAULT_MAX_AGE_S` for battery cams and\n   * `NON_BATTERY_DEFAULT_MAX_AGE_S` for everything else.\n   */\n  readonly snapshotMaxAgeS?: number\n}\n\n/** Default cache window for non-battery cams (seconds). 10s feels live. */\nconst NON_BATTERY_DEFAULT_MAX_AGE_S = 10\n/** Default cache window for battery cams (seconds). 1h ≈ \"don't wake the cam unless asked\". */\nconst BATTERY_DEFAULT_MAX_AGE_S = 3600\n\ninterface CacheEntry {\n  readonly data: SnapshotImage\n  readonly ts: number\n  /** Stream id resolved at capture time — 'high' | 'mid' | 'low' | custom | null. */\n  readonly streamId: string | null\n}\n\ninterface SnapshotAddonConfig {\n  /**\n   * Last-resort cache age (ms): if every live capture path fails\n   * (native + stream-broker fallback) AND a stale entry is older\n   * than this, the wrapper still returns the stale image rather\n   * than `null`. Keeps the UI from going blank during transient\n   * camera unreachability. Per-device freshness is governed by\n   * `snapshotMaxAgeS` instead.\n   */\n  readonly staleTtlMs: number\n}\n\n/**\n * SnapshotAddon — wrapper over the `snapshot` capability.\n *\n * Activated per-device (toggleable by user; default active). When active,\n * caches fresh snapshots in memory. On cache miss, delegates to the native\n * provider for this device via `ctx.getNativeProvider(snapshotCapability, id)`.\n *\n * No silent fallback — if the native fails, propagate the error up. Stale\n * cache is returned ONLY when the native throws AND a stale entry exists,\n * and the failure is logged so the fallback is never silent.\n *\n * Frame-grab fallback: when the native provider is absent (or returns null /\n * throws), we ask the `stream-broker` capability for the device's RTSP\n * restream URL and pipe one JPEG out of ffmpeg. stream-broker intentionally\n * does NOT expose a `grabFrame` method — the orchestration (native-first,\n * ffmpeg fallback, caching) is this addon's concern; stream-broker only\n * publishes stream endpoints.\n */\nexport class SnapshotAddon extends BaseAddon<SnapshotAddonConfig> {\n  private readonly cache = new Map<number, CacheEntry>()\n\n  constructor() {\n    super({\n      staleTtlMs: 60_000,\n    })\n  }\n\n  protected async onInitialize(): Promise<ProviderRegistration[]> {\n    this.ctx.logger.info('Snapshot wrapper initialized')\n    const provider: ISnapshotProvider = {\n      getSnapshot: (input) => this.getSnapshot(input),\n      invalidateCache: (input) => this.invalidateCache(input),\n      // DeviceSettingsContribution surface — numeric deviceId end-to-end.\n      getDeviceSettingsContribution: (input) => this.buildDeviceSettingsContribution(input.deviceId),\n      getDeviceLiveContribution: async () => null,\n      applyDeviceSettingsPatch: (input) => this.saveDeviceSettingsPatch(input.deviceId, input.patch),\n      // Status surface — derives a diagnostic snapshot from the cache\n      // bookkeeping (lastCapturedAt, cacheAgeMs, lastBytes, lastStreamId).\n      // Returns null when the device has never been captured.\n      getStatus: async (input) => this.getStatus(input.deviceId),\n    }\n    return [{\n      capability: snapshotCapability,\n      provider,\n      kind: 'wrapper',\n      defaultActive: true,\n    }]\n  }\n\n  protected async onShutdown(): Promise<void> {\n    this.cache.clear()\n  }\n\n  protected globalSettingsSchema() {\n    return this.schema({\n      sections: [{\n        id: 'snapshot-cache',\n        title: 'Snapshot Cache',\n        description: 'Stale fallback when live capture fails. Per-device freshness is configured under Device → Snapshot → Max cache age.',\n        columns: 1,\n        fields: [\n          this.field({\n            type: 'number', key: 'staleTtlMs', label: 'Stale fallback TTL (ms)',\n            description: 'If live capture fails, cached snapshot younger than this is still returned.',\n            min: 0, max: 3_600_000, step: 1_000, default: 60_000,\n          }),\n        ],\n      }],\n    })\n  }\n\n  // ── Capability methods ────────────────────────────────────────────────\n\n  private async getSnapshot(input: { deviceId: number; streamId?: string; force?: boolean }): Promise<SnapshotImage | null> {\n    const { deviceId, force } = input\n    // Pull device name + battery feature with a single device-scoped\n    // query. `getDevice` is cheaper than `listAll().find(...)` (one row\n    // returned, no client-side filter) and surfaces the same fields.\n    const meta = await this.lookupDeviceMeta(deviceId)\n    const deviceName = meta?.name\n    const isBatteryDevice = meta?.isBattery ?? false\n    const log = this.ctx.logger.withTags({ deviceId, ...(deviceName ? { deviceName } : {}) })\n    const now = Date.now()\n    const hit = this.cache.get(deviceId)\n\n    // Honour the per-device stored preference unless the caller specified\n    // an explicit streamId. `snapshotDebug` just flips log verbosity —\n    // read once per call so the flag can be toggled without restart.\n    const prefs: SnapshotDeviceSettings = await this.readDeviceSettings(deviceId).catch(() => ({}))\n    const rawPref = prefs.snapshotStreamId\n    const effectiveStreamId = input.streamId ?? (rawPref && rawPref !== 'auto' ? rawPref : undefined)\n    if (prefs.snapshotDebug) {\n      log.info('debug on', { tags: { deviceId }, meta: { stream: effectiveStreamId ?? 'auto' } })\n    }\n\n    // 1. Effective max-age check. A single per-device knob replaces\n    //    the legacy fresh/battery/sleeping cascade — defaults are 10s\n    //    for non-battery cams (matches the live-feel UI poll cadence)\n    //    and 1h for battery cams (avoids gratuitous wake-ups). The\n    //    operator can override via the per-device `snapshotMaxAgeS`\n    //    setting; a `force=true` call (UI refresh button) bypasses\n    //    the gate entirely. Behaviour matrix:\n    //\n    //      hit + ageMs < maxAgeMs + !force             → serve cache\n    //      hit + sleeping + ageMs < maxAgeMs + !force  → serve cache (no wake)\n    //      hit + sleeping + ageMs >= maxAgeMs + !force → cache is stale,\n    //                                                    let the native\n    //                                                    decide whether\n    //                                                    to wake (the\n    //                                                    native cap layer\n    //                                                    handles the\n    //                                                    \"are we awake?\"\n    //                                                    question)\n    //      no hit                                      → fall through (will wake)\n    //      force === true                              → fall through (will wake)\n    const defaultMaxAgeS = isBatteryDevice ? BATTERY_DEFAULT_MAX_AGE_S : NON_BATTERY_DEFAULT_MAX_AGE_S\n    const effectiveMaxAgeMs = (typeof prefs.snapshotMaxAgeS === 'number' && prefs.snapshotMaxAgeS >= 0\n      ? prefs.snapshotMaxAgeS\n      : defaultMaxAgeS) * 1_000\n    if (!force && hit && now - hit.ts < effectiveMaxAgeMs) {\n      if (prefs.snapshotDebug) {\n        log.debug('snapshot: cache hit', {\n          tags: { deviceId },\n          meta: { ageMs: now - hit.ts, maxAgeMs: effectiveMaxAgeMs, isBattery: isBatteryDevice },\n        })\n      }\n      return hit.data\n    }\n\n    // 2. Native provider (per-device, registered by the device-class addon).\n    //    Missing native is expected for cameras without a vendor snapshot\n    //    endpoint (e.g. a plain RTSP camera with no `snapshotUrl` configured).\n    //    We catch and fall through to the stream-broker ffmpeg path.\n    let nativeError: unknown = null\n    let nativeAbsent = false\n    try {\n      const native = this.ctx.getNativeProvider(snapshotCapability, deviceId)\n      if (native) {\n        const result = await native.getSnapshot(input)\n        if (result) {\n          this.cache.set(deviceId, { data: result, ts: now, streamId: effectiveStreamId ?? null })\n          return result\n        }\n      } else {\n        nativeAbsent = true\n      }\n    } catch (err) {\n      const msg = errMsg(err)\n      if (isAbsentNativeError(msg)) {\n        nativeAbsent = true\n        log.debug('native snapshot absent', { tags: { deviceId }, meta: { error: msg } })\n      } else {\n        nativeError = err\n        log.warn('native snapshot failed', { tags: { deviceId }, meta: { error: msg } })\n      }\n    }\n\n    // 3. Frame-grab fallback via stream-broker's RTSP restream. Passes\n    //    the effective streamId (explicit caller or stored preference) so\n    //    the fallback hits the same stream the user asked for instead of\n    //    always grabbing `main`.\n    //\n    // Battery-cam guard: skip the broker fallback only when the native\n    // was ABSENT for a battery device — that's the case where invoking\n    // the broker would be the first wake-up signal. If the native was\n    // present (whether it succeeded with null, threw, or returned a\n    // value), the camera is already being talked to (and likely awake);\n    // the additional broker dial costs nothing extra. When a streaming\n    // broker is already active, the fallback is unconditionally free\n    // (someone is watching), so allow it regardless.\n    const skipBrokerForBattery = isBatteryDevice\n      && nativeAbsent\n      && !(await this.hasStreamingBrokerForDevice(deviceId))\n    if (!skipBrokerForBattery) {\n      try {\n        const fallback = await this.grabFrameFromBroker(deviceId, effectiveStreamId)\n        if (fallback) {\n          this.cache.set(deviceId, { data: fallback, ts: now, streamId: effectiveStreamId ?? null })\n          return fallback\n        }\n      } catch (err) {\n        log.warn('stream-broker snapshot fallback failed', { tags: { deviceId }, meta: { error: errMsg(err) } })\n      }\n    } else {\n      log.debug('snapshot: skipping broker fallback — battery device with absent native and no streaming broker', {\n        tags: { deviceId },\n      })\n    }\n\n    // 4. Stale cache — last-resort \"don't go blank\" path.\n    //\n    // If ALL live paths failed and we have any cached entry, return\n    // it and log the age. The UI keeps showing the last known frame\n    // rather than a broken-image icon. The freshness gate at step 1\n    // (per-device `snapshotMaxAgeS`) is the cap that decides whether\n    // the cache is \"fresh enough\" in normal flow; this branch only\n    // runs when every live source refused.\n    if (hit) {\n      const ageMs = now - hit.ts\n      if (ageMs > this.config.staleTtlMs) {\n        log.warn('snapshot: all live paths failed — serving stale cache', { tags: { deviceId }, meta: { ageMs } })\n      }\n      return hit.data\n    }\n\n    // Nothing produced a frame and nothing in cache. If the native provider\n    // threw a real error (not just \"no provider registered for this\n    // device\"), surface it so callers see the cause. If the native was\n    // simply absent (camera has no snapshotUrl + no wrapper active),\n    // return null so the UI renders \"no image yet\" instead of a 500.\n    if (nativeError) throw nativeError\n    if (nativeAbsent) return null\n    return null\n  }\n\n  /**\n   * Tell apart \"native provider isn't registered for this device\" from\n   * \"native provider ran and threw a real error\". The former is the steady\n   * state for cameras without a vendor snapshot endpoint and should not\n   * propagate as a 500; the latter should.\n   */\n\n  /**\n   * Pull one JPEG from the device's stream-broker RTSP restream using\n   * a short-lived ffmpeg invocation.\n   *\n   * Stream selection strategy (picks the broker that won't stall):\n   *   1. Explicit `preferredStreamId` (user set in per-device settings)\n   *      — always honoured, even if currently idle. Operator choice\n   *      wins.\n   *   2. Auto: highest-quality broker currently in `streaming` state.\n   *      This is the whole point — prefer the stream that has active\n   *      subscribers (usually `low` for detection, but `mid`/`high`\n   *      if WebRTC is watching) so ffmpeg hits a warm pipe and\n   *      doesn't race the broker's resume.\n   *   3. Fallback: highest-quality enabled entry regardless of status\n   *      (will wake a suspended broker — retry-guarded against the\n   *      cold-start error).\n   *\n   * The stream-broker auto-suspends idle streams on the \"no demand\"\n   * signal; snapshots used to default to `high` which was often the\n   * first to go idle, racing every snapshot with a broker resume.\n   * Now we ask the orchestrator of streams which one is warm and grab\n   * from there.\n   */\n  private async grabFrameFromBroker(\n    deviceId: number,\n    preferredStreamId?: string,\n  ): Promise<SnapshotImage | null> {\n    const dev = await this.ctx.fetchDevice(deviceId)\n    const prefix = `${deviceId}/`\n\n    // Device-scoped fetch: broker filters by deviceId server-side, no\n    // cluster-wide list + client-side filter needed. Profile slot\n    // statuses come from the same per-device facade for the warmth\n    // ranking below.\n    const [deviceEntries, profileSlots] = await Promise.all([\n      dev.cameraStreams?.getRtspEntries({}) ?? [],\n      dev.cameraStreams?.getBrokerStreams({}) ?? [],\n    ])\n    const usable = deviceEntries.filter(e => e.enabled && !!e.url)\n    if (usable.length === 0) return null\n\n    // 1. Explicit preference — try it first without status gating.\n    if (preferredStreamId && preferredStreamId !== 'auto') {\n      const explicit = usable.find(e => e.brokerId === `${prefix}${preferredStreamId}`)\n      if (explicit) {\n        const grabbed = await this.runGrabWithResumeRetry(explicit.url, deviceId)\n        if (grabbed) return grabbed\n        // Explicit pick failed even after retry — fall through to auto\n        // rather than give up. Keeps the snapshot useful when the\n        // operator's preferred stream is momentarily unreachable.\n        this.ctx.logger.debug('grabFrame: explicit stream failed — falling back to auto', { meta: { preferredStreamId } })\n      }\n    }\n\n    // Rank entries by quality (high → mid → low → other).\n    const ranked = [...usable].sort(\n      (a, b) => qualityRank(b.brokerId, prefix) - qualityRank(a.brokerId, prefix),\n    )\n\n    // Per-device slot status lookup keyed by brokerId, sourced from\n    // the same `cameraStreams` facade — `status: 'streaming'` means the\n    // broker is warm and an ffmpeg grab is free of dial overhead.\n    const statusByBrokerId = new Map<string, ProfileSlot['status']>()\n    for (const slot of profileSlots) statusByBrokerId.set(slot.brokerId, slot.status)\n    const statuses = ranked.map(e => ({ entry: e, status: statusByBrokerId.get(e.brokerId) ?? 'idle' as const }))\n\n    // 2. Highest-quality broker currently `streaming`.\n    const warm = statuses.find(s => s.status === 'streaming')\n    if (warm) {\n      const grabbed = await this.runGrabWithResumeRetry(warm.entry.url, deviceId)\n      if (grabbed) return grabbed\n    }\n\n    // 3. Final fallback: wake whichever broker has the highest quality.\n    //    The retry handles the resume race window.\n    for (const { entry } of statuses) {\n      const grabbed = await this.runGrabWithResumeRetry(entry.url, deviceId).catch(() => null)\n      if (grabbed) return grabbed\n    }\n    return null\n  }\n\n  /**\n   * Ffmpeg grab with one retry on the broker-cold-start error\n   * signature. Covers the window between \"client connected\" and\n   * \"first keyframe\" when a suspended broker resumes.\n   */\n  private async runGrabWithResumeRetry(url: string, deviceId: number): Promise<SnapshotImage | null> {\n    let buf: Buffer\n    try {\n      buf = await runFfmpegFrameGrab(url, 15000)\n    } catch (err) {\n      const msg = errMsg(err)\n      if (isBrokerColdError(msg)) {\n        this.ctx.logger.debug('grabFrame: broker-resume race — retrying in 1500ms', { tags: { deviceId } })\n        await new Promise((r) => setTimeout(r, 1500))\n        buf = await runFfmpegFrameGrab(url, 15000)\n      } else {\n        throw err\n      }\n    }\n    if (buf.length === 0) return null\n    return { base64: buf.toString('base64'), contentType: 'image/jpeg' }\n  }\n\n  private async invalidateCache(input: { deviceId: number }): Promise<void> {\n    this.cache.delete(input.deviceId)\n  }\n\n  /**\n   * Non-throwing probe of the device's battery cap. Returns true only\n   * when a battery native is registered AND its current status says\n   * `sleeping: true`. Any error (no provider, native absent, getStatus\n   * missing, RPC timeout) is swallowed and treated as \"awake\" — we'd\n   * rather pay a wake-up than strand the caller on a cache that's\n   * semantically stale. Debug-logged for observability.\n   */\n  /**\n   * True when at least one of the device's brokers is actively\n   * streaming (status === 'streaming'). Used by the battery-cam guard\n   * around `grabFrameFromBroker` to allow the fallback ONLY when\n   * grabbing a frame is free (a consumer is already keeping the\n   * stream warm). When everything is suspended, the fallback would\n   * dial the camera and wake it — defeats the sleeping cache.\n   */\n  private async hasStreamingBrokerForDevice(deviceId: number): Promise<boolean> {\n    // `cameraStreams` is the device-scoped facade over the system\n    // `stream-broker` cap — `getBrokerStreams` returns this device's\n    // profile slots only (no cluster-wide scan + filter).\n    try {\n      const dev = await this.ctx.fetchDevice(deviceId)\n      const slots = await dev.cameraStreams?.getBrokerStreams({}) ?? []\n      return slots.some(s => s.status === 'streaming')\n    } catch {\n      return false\n    }\n  }\n\n  /**\n   * Diagnostic status for the `status` auto-injected cap method. Reports\n   * the cache bookkeeping for this device — when the last snapshot was\n   * captured, how stale the cached image is, its size, and which stream\n   * was used. Returns null when the device has never been captured\n   * (cache miss) since the addon started.\n   */\n  private async getStatus(deviceId: number): Promise<{\n    lastCapturedAt: number | null\n    cacheAgeMs: number | null\n    lastBytes: number | null\n    lastStreamId: string | null\n  } | null> {\n    const hit = this.cache.get(deviceId)\n    if (!hit) return null\n    return {\n      lastCapturedAt: hit.ts,\n      cacheAgeMs: Date.now() - hit.ts,\n      lastBytes: hit.data.base64.length,  // approx bytes = base64 length * 3/4, but length is stable enough\n      lastStreamId: hit.streamId,\n    }\n  }\n\n  // ── DeviceSettingsContribution ────────────────────────────────────────\n  //\n  // Snapshot carries two per-device knobs:\n  //   - `snapshotStreamId` — which stream to prefer when grabbing frames\n  //     (empty = auto / default \"main\")\n  //   - `snapshotDebug` — extra logging for troubleshooting snapshot paths\n  //\n  // Storage uses the addon's own per-device store (`ctx.settings\n  // .writeDeviceStore`), not the device's config. The schema isn't\n  // captured in a Zod object: the keys are optional and the UI layer\n  // validates shapes.\n\n  private async readDeviceSettings(deviceId: number): Promise<SnapshotDeviceSettings> {\n    if (!this.ctx.settings) return {}\n    const raw = await this.ctx.settings.readDeviceStore(deviceId)\n    const rawAge = raw['snapshotMaxAgeS']\n    const maxAgeS = typeof rawAge === 'number' && rawAge >= 0 && Number.isFinite(rawAge)\n      ? rawAge\n      : undefined\n    return {\n      snapshotStreamId: typeof raw['snapshotStreamId'] === 'string' ? raw['snapshotStreamId'] : undefined,\n      snapshotDebug: raw['snapshotDebug'] === true,\n      ...(maxAgeS !== undefined ? { snapshotMaxAgeS: maxAgeS } : {}),\n    }\n  }\n\n  private async buildDeviceSettingsContribution(deviceId: number): Promise<ConfigUISchemaWithValues | null> {\n    // Camera-only — snapshot settings are meaningless on Lights /\n    // Switches / Sensors / Buttons, and surfacing the section there\n    // produces ghost top-tabs (the device-detail UI builds the tab\n    // list off the contribution sections). Source-side gate keeps the\n    // policy with the addon that owns the cap; the admin-ui no longer\n    // needs the symmetric `device-section-policy` allow-list.\n    const meta = await this.lookupDeviceMeta(deviceId)\n    if (meta && meta.type !== DeviceType.Camera) return null\n    const current = await this.readDeviceSettings(deviceId)\n    const streamOptions = await this.getStreamOptions(deviceId)\n    const isBattery = await this.isDeviceBattery(deviceId)\n    const defaultMaxAgeS = isBattery ? BATTERY_DEFAULT_MAX_AGE_S : NON_BATTERY_DEFAULT_MAX_AGE_S\n    return {\n      sections: [{\n        id: 'snapshot-preferences',\n        title: 'Snapshot',\n        tab: 'snapshot',\n        order: 60,\n        fields: [\n          {\n            type: 'select' as const,\n            key: 'snapshotStreamId',\n            label: 'Preferred stream',\n            description: 'Stream used when grabbing a snapshot',\n            options: streamOptions,\n            required: true,\n            value: current.snapshotStreamId || 'auto',\n          },\n          {\n            type: 'number' as const,\n            key: 'snapshotMaxAgeS',\n            label: 'Max cache age (s)',\n            description:\n              `Serve cached snapshot up to this age before re-capturing. Default ${defaultMaxAgeS}s for ` +\n              `${isBattery ? 'battery cams (avoids gratuitous wake-ups)' : 'non-battery cams (live-feel)'}. ` +\n              'The UI refresh button always forces a fresh capture regardless of this value.',\n            min: 0,\n            max: 24 * 3600,\n            step: 1,\n            value: current.snapshotMaxAgeS ?? defaultMaxAgeS,\n          },\n          {\n            type: 'boolean' as const,\n            key: 'snapshotDebug',\n            label: 'Debug logging',\n            description: 'Log stream selection and timing details for this device.',\n            value: current.snapshotDebug ?? false,\n          },\n        ],\n      }],\n    }\n  }\n\n  /**\n   * Single-trip device lookup against device-manager. Returns the\n   * fields the wrapper actually consults — name (logging) + battery\n   * flag (cache window + broker-fallback gate). Sourced from the\n   * device-manager registry rather than the battery cap so the answer\n   * survives a momentarily-unreachable provider (the very condition\n   * we're trying to be resilient to).\n   *\n   * Logged at debug + null return on failure: every call site already\n   * has a sensible fallback path (cache hit, conservative default, …),\n   * so we don't want a transient device-manager hiccup to throw.\n   */\n  private async lookupDeviceMeta(\n    deviceId: number,\n  ): Promise<{ name?: string; isBattery: boolean; type?: DeviceType } | null> {\n    const api = this.ctx.api\n    if (!api) return null\n    try {\n      const found = await api.deviceManager.getDevice.query({ deviceId })\n      if (!found) return null\n      const features = (found.features as readonly string[] | undefined) ?? []\n      const rawType = (found as { type?: string }).type\n      return {\n        ...(found.name ? { name: found.name } : {}),\n        isBattery: features.includes(DeviceFeature.BatteryOperated),\n        ...(rawType ? { type: rawType as DeviceType } : {}),\n      }\n    } catch (err) {\n      this.ctx.logger.debug('deviceManager.getDevice failed during snapshot', {\n        tags: { deviceId },\n        meta: { error: err instanceof Error ? err.message : String(err) },\n      })\n      return null\n    }\n  }\n\n  /** Settings-UI helper — battery flag drives the default max-age in the field description. */\n  private async isDeviceBattery(deviceId: number): Promise<boolean> {\n    return (await this.lookupDeviceMeta(deviceId))?.isBattery ?? false\n  }\n\n  private async getStreamOptions(deviceId: number): Promise<Array<{ value: string; label: string }>> {\n    const prefix = `${deviceId}/`\n    try {\n      const dev = await this.ctx.fetchDevice(deviceId)\n      const entries = await dev.cameraStreams?.getRtspEntries({}) ?? []\n      const streamIds = entries\n        .filter(e => e.enabled)\n        .map(e => e.brokerId.slice(prefix.length))\n      return [\n        { value: 'auto', label: 'Auto' },\n        ...streamIds.map(id => ({ value: id, label: streamQualityLabel(id) })),\n      ]\n    } catch (err) {\n      this.ctx.logger.error('getStreamOptions failed', { tags: { deviceId }, meta: { error: errMsg(err) } })\n      return [{ value: 'auto', label: 'Auto' }]\n    }\n  }\n\n  private async saveDeviceSettingsPatch(\n    deviceId: number,\n    patch: Record<string, unknown>,\n  ): Promise<{ success: true }> {\n    if (!this.ctx.settings) {\n      throw new Error('[snapshot] settings store unavailable — cannot persist per-device settings')\n    }\n    const current = await this.ctx.settings.readDeviceStore(deviceId)\n    const next: Record<string, unknown> = { ...current }\n    if ('snapshotStreamId' in patch) {\n      const v = patch['snapshotStreamId']\n      next['snapshotStreamId'] = typeof v === 'string' && v.trim().length > 0 ? v.trim() : ''\n    }\n    if ('snapshotDebug' in patch) {\n      next['snapshotDebug'] = patch['snapshotDebug'] === true\n    }\n    if ('snapshotMaxAgeS' in patch) {\n      const v = patch['snapshotMaxAgeS']\n      // Persist a finite non-negative number; anything else (null,\n      // undefined, NaN, negative) falls back to the per-device\n      // default at read time.\n      if (typeof v === 'number' && Number.isFinite(v) && v >= 0) {\n        next['snapshotMaxAgeS'] = v\n      } else {\n        delete next['snapshotMaxAgeS']\n      }\n    }\n    await this.ctx.settings.writeDeviceStore(deviceId, next)\n    // Drop the cache so the next `getSnapshot` applies the new stream/debug flags.\n    this.cache.delete(deviceId)\n    return { success: true as const }\n  }\n}\n\nfunction isAbsentNativeError(msg: string): boolean {\n  return msg.includes('no provider for') || msg.includes('no native provider for capability')\n}\n\n/**\n * Quality ordering for broker picker: `high` > `mid` > `low` > other.\n * The streamId is the suffix after `${deviceId}/` in the brokerId.\n * Unknown labels fall through to 0 so they land at the bottom of the\n * preference list without crashing.\n */\nfunction qualityRank(brokerId: string, prefix: string): number {\n  const streamId = brokerId.startsWith(prefix) ? brokerId.slice(prefix.length) : brokerId\n  const normalized = streamId.toLowerCase()\n  if (normalized.includes('high') || normalized === 'main' || normalized === 'hd') return 3\n  if (normalized.includes('mid') || normalized === 'medium') return 2\n  if (normalized.includes('low') || normalized === 'sub' || normalized === 'sd') return 1\n  return 0\n}\n\n/**\n * Detect ffmpeg failure signatures that indicate the broker wasn't\n * streaming yet when we tried to read its RTSP restream — a race\n * window that closes as soon as the broker lands its first keyframe.\n * Used by `grabFrameFromBroker` to retry once instead of giving up.\n */\nfunction isBrokerColdError(msg: string): boolean {\n  return msg.includes('Invalid data found when processing input')\n    || msg.includes('Error opening input')\n    || msg.includes('Connection refused')\n    || msg.includes('No route to host')\n}\n\nfunction runFfmpegFrameGrab(url: string, timeoutMs: number): Promise<Buffer> {\n  return new Promise<Buffer>((resolve, reject) => {\n    // ── IDR-first snapshot ────────────────────────────────────────────────\n    //\n    // `-skip_frame nokey` decodes only keyframes — the first frame handed\n    // to the MJPEG encoder is guaranteed to be a complete IDR with all\n    // references present, so the JPEG can't come out as a half-decoded\n    // delta (the \"green stripe\" a non-keyframe decode produces).\n    //\n    // `-fflags +discardcorrupt` drops corrupt packets that slipped in\n    // before sync — otherwise they propagate as green/gray smears into\n    // the decoded output.\n    //\n    // No `-analyzeduration` / `-probesize` override: the old values\n    // (5_000_000 µs = 5 s) forced ffmpeg to buffer 5 s of RTP before\n    // decoding even when a keyframe was already in hand, which stacked\n    // with a cold stream-broker's upstream handshake and pushed the\n    // snapshot past the caller's ffmpeg timeout. Defaults are fine —\n    // `-skip_frame nokey` + `-frames:v 1` already bound the work to a\n    // single keyframe.\n    const child = execFile(\n      'ffmpeg',\n      [\n        '-loglevel', 'error',\n        '-rtsp_transport', 'tcp',\n        '-fflags', '+discardcorrupt',\n        '-skip_frame', 'nokey',\n        '-i', url,\n        '-vf', 'select=eq(pict_type\\\\,I)',\n        '-vsync', 'vfr',\n        '-frames:v', '1',\n        '-q:v', '3',\n        '-f', 'image2pipe',\n        '-vcodec', 'mjpeg',\n        'pipe:1',\n      ],\n      { encoding: 'buffer', maxBuffer: 16 * 1024 * 1024, timeout: timeoutMs },\n      (err, stdout, stderr) => {\n        if (err) {\n          // `execFile`'s default Error carries \"Command failed: …\" plus a\n          // `code`/`signal` that Node fills in. ffmpeg with `-loglevel\n          // error` is silent on RTSP-level failures; when the parent\n          // kills the child on timeout, `killed === true` and stderr is\n          // empty. Surface both sides so the log tells the real story.\n          const errWithMeta = err as (Error & { code?: string | number; signal?: string | null; killed?: boolean })\n          const stderrText = Buffer.isBuffer(stderr) ? stderr.toString('utf8').trim() : String(stderr ?? '').trim()\n          const parts: string[] = [err instanceof Error ? err.message : String(err)]\n          if (errWithMeta.killed) parts.push('killed=true')\n          if (errWithMeta.code !== undefined) parts.push(`code=${String(errWithMeta.code)}`)\n          if (errWithMeta.signal) parts.push(`signal=${errWithMeta.signal}`)\n          if (stderrText) parts.push(`stderr: ${stderrText.slice(0, 500)}`)\n          reject(new Error(parts.join(' — ')))\n          return\n        }\n        resolve(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout))\n      },\n    )\n    child.on('error', (e: Error) => reject(e))\n  })\n}\n"],"mappings":"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"}

package/dist/builtins/snapshot/snapshot.addon.d.ts

@@ -0,0 +1,121 @@
+import { ProviderRegistration, BaseAddon } from '@camstack/types';
+interface SnapshotAddonConfig {
+    /**
+     * Last-resort cache age (ms): if every live capture path fails
+     * (native + stream-broker fallback) AND a stale entry is older
+     * than this, the wrapper still returns the stale image rather
+     * than `null`. Keeps the UI from going blank during transient
+     * camera unreachability. Per-device freshness is governed by
+     * `snapshotMaxAgeS` instead.
+     */
+    readonly staleTtlMs: number;
+}
+/**
+ * SnapshotAddon — wrapper over the `snapshot` capability.
+ *
+ * Activated per-device (toggleable by user; default active). When active,
+ * caches fresh snapshots in memory. On cache miss, delegates to the native
+ * provider for this device via `ctx.getNativeProvider(snapshotCapability, id)`.
+ *
+ * No silent fallback — if the native fails, propagate the error up. Stale
+ * cache is returned ONLY when the native throws AND a stale entry exists,
+ * and the failure is logged so the fallback is never silent.
+ *
+ * Frame-grab fallback: when the native provider is absent (or returns null /
+ * throws), we ask the `stream-broker` capability for the device's RTSP
+ * restream URL and pipe one JPEG out of ffmpeg. stream-broker intentionally
+ * does NOT expose a `grabFrame` method — the orchestration (native-first,
+ * ffmpeg fallback, caching) is this addon's concern; stream-broker only
+ * publishes stream endpoints.
+ */
+export declare class SnapshotAddon extends BaseAddon<SnapshotAddonConfig> {
+    private readonly cache;
+    constructor();
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    protected onShutdown(): Promise<void>;
+    protected globalSettingsSchema(): import('@camstack/types').ConfigUISchema;
+    private getSnapshot;
+    /**
+     * Tell apart "native provider isn't registered for this device" from
+     * "native provider ran and threw a real error". The former is the steady
+     * state for cameras without a vendor snapshot endpoint and should not
+     * propagate as a 500; the latter should.
+     */
+    /**
+     * Pull one JPEG from the device's stream-broker RTSP restream using
+     * a short-lived ffmpeg invocation.
+     *
+     * Stream selection strategy (picks the broker that won't stall):
+     *   1. Explicit `preferredStreamId` (user set in per-device settings)
+     *      — always honoured, even if currently idle. Operator choice
+     *      wins.
+     *   2. Auto: highest-quality broker currently in `streaming` state.
+     *      This is the whole point — prefer the stream that has active
+     *      subscribers (usually `low` for detection, but `mid`/`high`
+     *      if WebRTC is watching) so ffmpeg hits a warm pipe and
+     *      doesn't race the broker's resume.
+     *   3. Fallback: highest-quality enabled entry regardless of status
+     *      (will wake a suspended broker — retry-guarded against the
+     *      cold-start error).
+     *
+     * The stream-broker auto-suspends idle streams on the "no demand"
+     * signal; snapshots used to default to `high` which was often the
+     * first to go idle, racing every snapshot with a broker resume.
+     * Now we ask the orchestrator of streams which one is warm and grab
+     * from there.
+     */
+    private grabFrameFromBroker;
+    /**
+     * Ffmpeg grab with one retry on the broker-cold-start error
+     * signature. Covers the window between "client connected" and
+     * "first keyframe" when a suspended broker resumes.
+     */
+    private runGrabWithResumeRetry;
+    private invalidateCache;
+    /**
+     * Non-throwing probe of the device's battery cap. Returns true only
+     * when a battery native is registered AND its current status says
+     * `sleeping: true`. Any error (no provider, native absent, getStatus
+     * missing, RPC timeout) is swallowed and treated as "awake" — we'd
+     * rather pay a wake-up than strand the caller on a cache that's
+     * semantically stale. Debug-logged for observability.
+     */
+    /**
+     * True when at least one of the device's brokers is actively
+     * streaming (status === 'streaming'). Used by the battery-cam guard
+     * around `grabFrameFromBroker` to allow the fallback ONLY when
+     * grabbing a frame is free (a consumer is already keeping the
+     * stream warm). When everything is suspended, the fallback would
+     * dial the camera and wake it — defeats the sleeping cache.
+     */
+    private hasStreamingBrokerForDevice;
+    /**
+     * Diagnostic status for the `status` auto-injected cap method. Reports
+     * the cache bookkeeping for this device — when the last snapshot was
+     * captured, how stale the cached image is, its size, and which stream
+     * was used. Returns null when the device has never been captured
+     * (cache miss) since the addon started.
+     */
+    private getStatus;
+    private readDeviceSettings;
+    private buildDeviceSettingsContribution;
+    /**
+     * Single-trip device lookup against device-manager. Returns the
+     * fields the wrapper actually consults — name (logging) + battery
+     * flag (cache window + broker-fallback gate). Sourced from the
+     * device-manager registry rather than the battery cap so the answer
+     * survives a momentarily-unreachable provider (the very condition
+     * we're trying to be resilient to).
+     *
+     * Logged at debug + null return on failure: every call site already
+     * has a sensible fallback path (cache hit, conservative default, …),
+     * so we don't want a transient device-manager hiccup to throw.
+     */
+    private lookupDeviceMeta;
+    /** Settings-UI helper — battery flag drives the default max-age in the field description. */
+    private isDeviceBattery;
+    private getStreamOptions;
+    private saveDeviceSettingsPatch;
+}
+export {};
+//# sourceMappingURL=snapshot.addon.d.ts.map

package/dist/builtins/snapshot/snapshot.addon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.addon.d.ts","sourceRoot":"","sources":["../../../src/builtins/snapshot/snapshot.addon.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAwD,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACjH,OAAO,EAAE,SAAS,EAA8B,MAAM,iBAAiB,CAAA;AAuCvE,UAAU,mBAAmB;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAc,SAAQ,SAAS,CAAC,mBAAmB,CAAC;IAC/D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;;cAQtC,YAAY,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;cAsB/C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3C,SAAS,CAAC,oBAAoB;YAoBhB,WAAW;IA8IzB;;;;;OAKG;IAEH;;;;;;;;;;;;;;;;;;;;;;OAsBG;YACW,mBAAmB;IA2DjC;;;;OAIG;YACW,sBAAsB;YAkBtB,eAAe;IAI7B;;;;;;;OAOG;IACH;;;;;;;OAOG;YACW,2BAA2B;IAazC;;;;;;OAMG;YACW,SAAS;YA4BT,kBAAkB;YAclB,+BAA+B;IAsD7C;;;;;;;;;;;OAWG;YACW,gBAAgB;IAwB9B,6FAA6F;YAC/E,eAAe;YAIf,gBAAgB;YAkBhB,uBAAuB;CAgCtC"}

package/dist/builtins/sqlite-storage/config-store.d.ts

@@ -0,0 +1,9 @@
+import { default as Database } from 'better-sqlite3';
+export declare class ConfigStore {
+    private readonly db;
+    constructor(db: Database.Database);
+    save(addonId: string, stableId: string | null, data: Record<string, unknown>): void;
+    load(addonId: string, stableId: string | null): Record<string, unknown>;
+    remove(addonId: string, stableId: string | null): void;
+}
+//# sourceMappingURL=config-store.d.ts.map

package/dist/builtins/sqlite-storage/config-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-store.d.ts","sourceRoot":"","sources":["../../../src/builtins/sqlite-storage/config-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAE1C,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ,CAAC,QAAQ;IAElD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAwBnF,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAYvE,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;CAOvD"}

package/dist/builtins/sqlite-storage/device-store.d.ts

@@ -0,0 +1,24 @@
+import { default as Database } from 'better-sqlite3';
+export interface DeviceRow {
+    readonly stableId: string;
+    readonly type: string;
+    readonly name: string;
+    readonly parentStableId: string | null;
+    readonly enabled: boolean;
+}
+interface InsertInput {
+    readonly stableId: string;
+    readonly type: string;
+    readonly name: string;
+    readonly parentStableId: string | null;
+}
+export declare class DeviceStore {
+    private readonly db;
+    constructor(db: Database.Database);
+    insert(addonId: string, device: InsertInput): void;
+    listByAddon(addonId: string): readonly DeviceRow[];
+    listChildren(addonId: string, parentStableId: string): readonly DeviceRow[];
+    remove(addonId: string, stableId: string): void;
+}
+export {};
+//# sourceMappingURL=device-store.d.ts.map

package/dist/builtins/sqlite-storage/device-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-store.d.ts","sourceRoot":"","sources":["../../../src/builtins/sqlite-storage/device-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAE1C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IACtC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CACvC;AAED,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ,CAAC,QAAQ;IAElD,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAQlD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE;IAQlD,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE;IAQ3E,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;CAGhD"}

package/dist/builtins/sqlite-storage/filesystem-storage-provider.d.ts

@@ -0,0 +1,87 @@
+import { IStorageProviderImpl, StorageLocation, StorageLocationType } from '@camstack/types';
+export declare class FilesystemStorageProvider implements IStorageProviderImpl {
+    static readonly providerId = "filesystem-storage";
+    static readonly displayName = "Filesystem";
+    private readonly uploads;
+    private readonly downloads;
+    getProviderInfo(): Promise<{
+        readonly providerId: string;
+        readonly displayName: string;
+        readonly supportedLocationTypes: readonly StorageLocationType[];
+        readonly configSchema: unknown;
+    }>;
+    testLocation({ config }: {
+        readonly config: Record<string, unknown>;
+    }): Promise<{
+        readonly ok: boolean;
+        readonly error?: string;
+    }>;
+    resolve({ location, relativePath, }: {
+        readonly location: StorageLocation;
+        readonly relativePath: string;
+    }): Promise<string>;
+    write({ location, relativePath, data, }: {
+        readonly location: StorageLocation;
+        readonly relativePath: string;
+        readonly data: Uint8Array;
+    }): Promise<void>;
+    read({ location, relativePath, }: {
+        readonly location: StorageLocation;
+        readonly relativePath: string;
+    }): Promise<Uint8Array<ArrayBuffer>>;
+    exists({ location, relativePath, }: {
+        readonly location: StorageLocation;
+        readonly relativePath: string;
+    }): Promise<boolean>;
+    list({ location, prefix, }: {
+        readonly location: StorageLocation;
+        readonly prefix?: string;
+    }): Promise<readonly string[]>;
+    delete({ location, relativePath, }: {
+        readonly location: StorageLocation;
+        readonly relativePath: string;
+    }): Promise<void>;
+    getAvailableSpace({ location, }: {
+        readonly location: StorageLocation;
+    }): Promise<number | null>;
+    beginUpload({ location, relativePath, }: {
+        readonly location: StorageLocation;
+        readonly relativePath: string;
+        readonly sizeBytes?: number;
+    }): Promise<{
+        readonly uploadId: string;
+    }>;
+    writeChunk({ uploadId, offset, data, }: {
+        readonly uploadId: string;
+        readonly offset: number;
+        readonly data: Uint8Array;
+    }): Promise<void>;
+    finalizeUpload({ uploadId }: {
+        readonly uploadId: string;
+    }): Promise<void>;
+    abortUpload({ uploadId }: {
+        readonly uploadId: string;
+    }): Promise<void>;
+    beginDownload({ location, relativePath, }: {
+        readonly location: StorageLocation;
+        readonly relativePath: string;
+    }): Promise<{
+        readonly downloadId: string;
+        readonly sizeBytes: number;
+    }>;
+    readChunk({ downloadId, offset, length, }: {
+        readonly downloadId: string;
+        readonly offset: number;
+        readonly length: number;
+    }): Promise<Uint8Array<ArrayBuffer>>;
+    endDownload({ downloadId }: {
+        readonly downloadId: string;
+    }): Promise<void>;
+    /**
+     * Abort all outstanding sessions. Called on addon shutdown so timers
+     * don't leak across hot-reload cycles.
+     */
+    dispose(): Promise<void>;
+}
+export default FilesystemStorageProvider;
+//# sourceMappingURL=filesystem-storage-provider.d.ts.map

package/dist/builtins/sqlite-storage/filesystem-storage-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-storage-provider.d.ts","sourceRoot":"","sources":["../../../src/builtins/sqlite-storage/filesystem-storage-provider.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACpB,MAAM,iBAAiB,CAAA;AAwDxB,qBAAa,yBAA0B,YAAW,oBAAoB;IACpE,MAAM,CAAC,QAAQ,CAAC,UAAU,wBAAuB;IACjD,MAAM,CAAC,QAAQ,CAAC,WAAW,gBAAe;IAE1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAIzD,eAAe,IAAI,OAAO,CAAC;QAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;QAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;QAC5B,QAAQ,CAAC,sBAAsB,EAAE,SAAS,mBAAmB,EAAE,CAAA;QAC/D,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;KAC/B,CAAC;IA+BI,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC;QACpF,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;QACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KACxB,CAAC;IA4BI,OAAO,CAAC,EACZ,QAAQ,EACR,YAAY,GACb,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;QAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;KAC9B,GAAG,OAAO,CAAC,MAAM,CAAC;IAIb,KAAK,CAAC,EACV,QAAQ,EACR,YAAY,EACZ,IAAI,GACL,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;QAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;QAC7B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;KAC1B,GAAG,OAAO,CAAC,IAAI,CAAC;IAMX,IAAI,CAAC,EACT,QAAQ,EACR,YAAY,GACb,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;QAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;KAC9B,GAAG,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAe9B,MAAM,CAAC,EACX,QAAQ,EACR,YAAY,GACb,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;QAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;KAC9B,GAAG,OAAO,CAAC,OAAO,CAAC;IAUd,IAAI,CAAC,EACT,QAAQ,EACR,MAAM,GACP,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;QAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KACzB,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;IAaxB,MAAM,CAAC,EACX,QAAQ,EACR,YAAY,GACb,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;QAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;KAC9B,GAAG,OAAO,CAAC,IAAI,CAAC;IAKX,iBAAiB,CAAC,EACtB,QAAQ,GACT,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;KACnC,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAqBpB,WAAW,CAAC,EAChB,QAAQ,EACR,YAAY,GACb,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;QAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;QAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAC5B,GAAG,OAAO,CAAC;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAsBpC,UAAU,CAAC,EACf,QAAQ,EACR,MAAM,EACN,IAAI,GACL,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;KAC1B,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BX,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAc1E,WAAW,CAAC,EAAE,QAAQ,EAAE,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAevE,aAAa,CAAC,EAClB,QAAQ,EACR,YAAY,GACb,EAAE;QACD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;QAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;KAC9B,GAAG,OAAO,CAAC;QAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAgBlE,SAAS,CAAC,EACd,UAAU,EACV,MAAM,EACN,MAAM,GACP,EAAE;QACD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;QAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KACxB,GAAG,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAsB9B,WAAW,CAAC,EAAE,UAAU,EAAE,EAAE;QAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjF;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAM/B;AAED,eAAe,yBAAyB,CAAA"}

package/dist/builtins/sqlite-storage/filesystem-storage.addon.d.ts

@@ -1,2 +1,32 @@
-import '@camstack/types';
-export { F as FilesystemStorageAddon, F as default } from '../../filesystem-storage.addon-C42r589X.js';
+import { ProviderRegistration, BaseAddon } from '@camstack/types';
+import { FilesystemStorageProvider } from './filesystem-storage-provider.js';
+interface FilesystemStorageConfig {
+    readonly rootPath: string;
+}
+/**
+ * Filesystem Storage addon — registers a filesystem-backed
+ * `storage-provider` (Task 7).
+ *
+ * Pre-Task 7 this addon registered against the (then-collection)
+ * `storage` cap. After Tasks 2/3/4 the consumer-facing `storage` cap is
+ * a singleton owned by `storage-orchestrator`; the orchestrator
+ * dispatches each call to whichever `storage-provider` matches
+ * `location.providerId`.
+ *
+ * The OLD `rootPath` config field is preserved for back-compat: the
+ * orchestrator's first-boot seeding step still uses the same env-var
+ * resolution chain (operator override → `CAMSTACK_DATA` → fallback) to
+ * derive the base path of every default location, then writes
+ * `config.basePath` into each persisted `StorageLocation` row. The
+ * provider itself is now stateless — every call carries the live
+ * `StorageLocation` inline.
+ */
+export declare class FilesystemStorageAddon extends BaseAddon<FilesystemStorageConfig> {
+    private provider;
+    constructor();
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    protected onShutdown(): Promise<void>;
+    getProvider(): FilesystemStorageProvider | null;
+}
+export default FilesystemStorageAddon;
+//# sourceMappingURL=filesystem-storage.addon.d.ts.map

package/dist/builtins/sqlite-storage/filesystem-storage.addon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-storage.addon.d.ts","sourceRoot":"","sources":["../../../src/builtins/sqlite-storage/filesystem-storage.addon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAC3D,OAAO,EAAE,SAAS,EAA6B,MAAM,iBAAiB,CAAA;AACtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAA;AAE5E,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,sBAAuB,SAAQ,SAAS,CAAC,uBAAuB,CAAC;IAC5E,OAAO,CAAC,QAAQ,CAAyC;;cAMzC,YAAY,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;cAM/C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3C,WAAW,IAAI,yBAAyB,GAAG,IAAI;CAGhD;AAED,eAAe,sBAAsB,CAAA"}