@chrisalvir1/camera-ui-homekit-4k 0.0.0-stage → 0.6.14

package/CHANGELOG.md

@@ -0,0 +1,136 @@
+# Changelog
+
+## [0.6.14] — npm account scope correction
+
+- Rename the public package from `@chrisalvir/camera-ui-homekit-4k` to
+  `@chrisalvir1/camera-ui-homekit-4k` so its scope matches the authenticated npm
+  username. Update local bundle validation, Camera.UI's development registry,
+  and bundle smoke checks to use the same identity. No camera runtime behavior
+  changed.
+
+## [0.6.13] — public package preparation
+
+- Correct the public README to describe the 0.6.12 runtime evidence and its
+  limits instead of the obsolete 0.4.0 phase status.
+- Narrow the npm package allowlist to compiled runtime files, required HAP
+  runtime files, documentation, and the official logo. This removes stale
+  compiler copies, source maps, and nested binary shims from the release
+  tarball. No media, detection, pairing, or camera runtime behavior changed.
+- Add owner-selected proprietary use terms and public-release metadata. No media,
+  detection, pairing, or camera runtime behavior changed.
+
+## [0.6.12]
+
+- Keep very brief visual events asserted for at least one second so a same-tick SDK start/end cannot collapse into a missed HomeKit notification. Long detections still follow the SDK lifecycle; pending release is canceled on renewed motion and disposed on unpublish. Applies to both H.264 and HEVC exports.
+
+## [0.6.11]
+
+- Preserve Camera.UI motion/object events until their actual SDK end; remove the artificial 15-second motion reset that interrupted long detections for both H.264/HKSV and HEVC/HKSV3. Log HomeKit motion transitions per camera without retaining images or identities.
+- Keep HAP dependencies at the package root so Camera.UI extraction cannot remove them after dependency installation. Bundle smoke now imports the extracted HAP runtime rather than the workspace copy.
+
+## [0.6.10]
+
+- Accept valid legacy HomeKit live requests up to 1080p without rejecting an existing paired controller solely for a different requested resolution. The selected measured-source policy still determines actual video output: native passthrough up to 1080p and 1080p conversion above it. Logs distinguish requested and actual output dimensions.
+
+## [0.6.9]
+
+- H.264 live and HKSV use measured source dimensions: video up to 1920×1080 is passed through; larger sources use a verified H.264 encoder at 1920×1080. Existing negotiated audio routes are retained.
+- Shared Camera.UI detection bridge accepts visual object labels such as car, truck, dog and cat from assigned detectors, including future camera exports. Aggregate event end always releases motion even when closing metadata is empty.
+- HEVC/HKSV3 recording audio receives its persistent one-time first-export default after HAP restores state. Later HomeKit audio choices are retained.
+- HEVC video/audio transport, its recording implementation and pairing identities are preserved. A worker reload briefly interrupts every accessory served by that worker.
+
+## [0.6.8]
+
+- **Camera.UI bundle updates:** The loopback update registry now serves the official `cui bundle` package, including its `bundle.zip`. Camera.UI extracts that bundle into the worker runtime after installation; a source-only package archive could update package metadata while leaving the old runtime code active.
+
+## [0.6.7]
+
+- **Reliable Camera.UI self-updates:** Moved the scoped package registry to a detached loopback daemon with a storage-backed package snapshot and worker lease. Camera.UI can now stop the plugin worker before fetching its replacement without taking down the package endpoint; the daemon exits after the worker has been absent for five minutes.
+- **Fail closed on invalid packages:** Removed the fake 29-byte gzip fallback. The registry refuses to advertise an update unless it can create or verify a real package archive and matching SHA-1/SHA-512 integrity values.
+
+## [0.6.6]
+
+- **Simplified Camera.UI Admin:** Removed redundant global administration, diagnostic-mode, GitHub-updater, and HomeKit-camera tabs; pairing and unlink controls remain with each camera.
+- **Camera.UI-native updates:** Removed the duplicate in-plugin GitHub update flow so plugin updates are managed by Camera.UI.
+- **Removed unused audio settings UI:** Deleted the unconnected audio settings form while retaining the existing audio engines and runtime diagnostics.
+
+## [0.6.5]
+
+- **Camera.UI Backchannel Discovery:** Explicitly probes each exported Camera.UI source for microphone/backchannel support before constructing HAP services. H.264 and HEVC/HKSV3 expose HomeKit talkback only when the selected source reports a supported codec and does not disable backchannel; accessory service updates preserve existing pairing.
+
+## [0.6.3]
+
+- **Universal HEVC & HKSV3 Configuration Parity (IPCAM IPC Blueprint):** All Vimtag cameras (SALA, OFICINA, JARDIN, COCHERA, AREA DE CAFE, RECAMARA) and any newly added HEVC cameras automatically adopt the exact configuration established on IPCAM IPC. Automatically assigns `@chrisalvir/camera-ui-homekit-4k`, `@camera.ui/camera-ui-coreml`, and `@camera.ui/camera-ui-opencv` for full motion, object, face, person, and clip detection.
+- **Go2RTC Stream Preload & Elimination of Audio Teardown Collision:** Configured persistent Go2RTC stream preloading (`preload: audio=&video=`) and disabled RTSP backchannel handshakes (`backchannelDisabled: true`, `#backchannel=0#noBackchannel`) on Vimtag cloud relay sources, preventing WAN timeout disconnects (`i/o timeout`) and resolving Go2RTC's `error="start from CONN state"`.
+- **RTSP Direct Resolution Fallback for Multiplexed Sources:** Refined `resolveDirectCameraRtspUrl` to strictly return direct URLs only for verified private LAN IP addresses (`192.168.x.x`, `10.x.x.x`, `172.16-31.x.x`). For cloud and plugin cameras, gracefully falls back to Camera.UI multiplexed endpoints with proper query parameters (`?video&audio`), guaranteeing that FFmpeg HDS recordings generate complete `moov` initialization segments containing both video and AAC-LC audio tracks.
+- **Auto-Provisioning on Camera Addition (`CameraAutoConfig`):** Added automated configuration synchronization upon camera addition (`onCameraAdded`) and startup (`configureCameras`). Newly added HEVC cameras immediately receive HKSV3 configuration, continuous recording settings, and automatic HomeKit export without manual intervention.
+- **Permanent H.264 & Tapo Isolation:** Kept Tapo and all existing H.264 logic strictly untouched (`src/h264/*` unchanged); future H.264 cameras automatically inherit Tapo's standard H.264 configuration.
+- **FirmwareRevision Update:** Incremented firmware revision to `0.6.3`.
+
+## [0.6.2]
+
+- **Third-Party & Plugin Camera RTSP Direct Resolution Fallback:** Added local go2rtc RTSP endpoint fallback (`rtsp://127.0.0.1:2101/${streamName}`) for cameras integrated via third-party device plugins (e.g., Vimtag) that do not expose external ONVIF RTSP URLs or use `cui://` internal protocols. Eliminates FFmpeg `Protocol not found` exit crashes, restoring continuous live audio and HKSV recordings.
+- **Automatic Frame Worker Activation for Plugin Cameras:** Added proactive RPC connection (`camera.${id}.controller.rpc.connect()`) within `CameraUiAdapter` upon camera attachment. Ensures Camera.UI Frame Workers start automatically when plugin cameras initialize with `connected: false`, enabling instant OpenCV and CoreML motion/person detection.
+- **Dynamic Sensor Assignment Lifecycle Synchronization:** Implemented `onSensorsChanged` hook and notification pipeline in `CameraUiAdapter` to dynamically re-bind motion and occupancy sensors when sensors are attached or reassigned in Camera.UI without requiring a full plugin restart.
+- **Robust Motion Event Keying:** Provided timestamped fallback keys (`evt-${type}-${timestamp}`) for un-keyed detection triggers from OpenCV and CoreML trackers, ensuring reliable HomeKit `MotionDetected` assertions and event clearance.
+- **Dynamic FirmwareRevision Alignment:** Updated accessory creation to dynamically bind `FirmwareRevision` to `buildInfo.packageVersion` (`0.6.2`) across both H.264 and HEVC camera accessories.
+- **Permanent H.264 & HEVC Pipeline Isolation:** Strictly preserved the classic H.264 pipeline (Tapo and all future H.264 additions) with zero changes to `src/h264/*`, while extending HEVC HKSV3 enhancements universally to all current and future HEVC cameras.
+
+## [0.6.1]
+
+- **Automatic Camera Export & Removal of Manual Button:** Cameras assigned to the HOMEKIT 4K plugin are now automatically exported to Apple Home upon activation alongside other plugins (CoreML, OpenCV), eliminating the need for manual button clicks. Removed the redundant «Exportar esta cámara» button from the UI. Pre-warmed pairing QR generation renders the branded setup QR code and manual PIN immediately when entering the pairing section.
+- **HEVC HKSV3 Audio Clock Synchronization (16 kHz):** Scaled Opus RTP timestamps by $16\text{k} / 48\text{k}$ (320 ticks per 20ms frame) to match HomeKit's negotiated 16 kHz audio sample rate (`sampleRate: 1`), eliminating the 3x timestamp forward surge and completely resolving the cyclic 1-second audio / mute stutter.
+- **Parasitic Microphone Whine & Artifact Elimination:** Implemented a specialized Butterworth 2-pole bandpass filter (`highpass=f=150:poles=2,lowpass=f=3500:poles=2`), FFT adaptive noise reduction (`afftdn=nf=-40`), clean gain boost, and switched Opus encoding to `-application voip -b:a 48k -vbr off`, completely eliminating the 6.28 kHz hardware whistle, background cricket buzz, and metallic CELT ringing across all HEVC live streams and recordings.
+- **Independent Audio Jitter Buffer Operation:** Omitted periodic audio RTCP Sender Reports in HKSV3 Multi-Tier RTP so HomeKit plays live audio continuously without inter-stream clock clashes against video.
+- **Universal Multi-Camera Motion Detection:** Preserved unified event processing across Camera.UI plugins, OpenCV, CoreML, and YOLO with edge-trigger dwell safety timers to guarantee reliable successive HKSV recordings for all cameras.
+- **FirmwareRevision Update:** Bumped accessory firmware revision to `0.6.1` across all H.264 and H.265 camera accessories.
+
+## [0.6.0]
+
+- **Live H.264 Audio Engine (Opus + Genuine AAC-ELD):** Resolved silence in Apple Home live streams by implementing dual-engine routing: in-memory zero-latency Opus transcoding via `node-av` with 20ms frame pacing, and real-time AAC-ELD (480 samples/frame) transcoding via FFmpeg `libfdk_aac`.
+- **HomeKit Cache Invalidation:** Bumped accessory `FirmwareRevision` to `0.6.0` to force Apple Home clients to refresh their cached accessory profile and prioritize Opus streaming.
+- **Audio Clock Continuity Calibration:** Synchronized audio timeline continuity clocks with negotiated client sample rates (24kHz / 16kHz / 8kHz).
+- **Embedded Registry & UI Integration:** Updated local package manifests and registry endpoints to expose v0.6.0 and changelog directly within Camera.UI.
+
+## [0.5.9]
+
+- **Gapless stream handover on Wi-Fi reconfigure:** Connects the new FFmpeg live pipeline to Go2RTC before terminating the previous pipeline, eliminating RTSP socket teardown collisions (`read tcp: i/o timeout`) and resolving "Sin respuesta" when viewing on local Wi-Fi.
+- **Bitrate-only reconfigure skip:** Dynamically ignores reconfigure requests that only alter bitrate without changing resolution, avoiding unnecessary FFmpeg restarts.
+- **H.264 audio probe caching:** Caches RTSP audio probe results for 1 hour to prevent RTSP stream saturation during frequent motion and HKSV recording events.
+- **Embedded local registry integration:** Serves npm packuments and tarballs via loopback (`127.0.0.1:4873`), enabling seamless Camera.UI version discovery, one-click updates, and full changelog display.
+
+## [0.5.8]
+
+- **Hot stream reconfigure:** Dynamic resolution scaling and transition support for local Wi-Fi peer-to-peer HomeKit sessions.
+- **Resilient UDP track sockets:** Independent video/audio socket binding for bidirectional RTP and RTCP packets.
+
+## [0.5.6]
+
+- **Dynamic resolution scaling & MTU safety:** MTU-safe packet clamping and dynamic video profile scaling.
+- **Non-blocking audio probe:** Async probe execution with resilient fallback.
+
+## [0.5.5]
+
+- **Native 1080p enforcement for Tapo C402:** Fully removed any residual 2K (2304x1296) code assumptions; strictly enforce native 1080p (1920x1080) matching factory sensor specifications.
+
+## [0.5.0]
+
+- **HKSV classic H.264 recording:** Normalized H.264 recording pipeline with live AAC-LC 48kHz audio transcoding from PCMA/G.711a.
+
+## [0.4.0]
+
+- **HKSV3 preparation:** Integration foundations for HomeKit Secure Video and WebRTC RTP transport.
+
+## [0.3.0]
+
+- On-demand source inspection, conservative source selection and video-only plans.
+- Camera.UI source-to-output comparison and session lifecycle model.
+
+## [0.2.0]
+
+- SDK camera/sensor observables, idempotent subscriptions and neutral capability model.
+- Pinned local HAP compatibility build.
+
+## [0.1.0]
+
+- Phase 1 foundation: independent Camera.UI SDK entry and local bundle.

package/LICENSE

@@ -0,0 +1,21 @@
+HOMEKIT 4K PROPRIETARY SOFTWARE LICENSE
+
+Copyright (c) 2026 Chrisalvir. All rights reserved.
+
+Permission is granted to download, install, and run an unmodified copy of
+HOMEKIT 4K with Camera.UI for lawful personal or commercial use. This permission
+does not transfer ownership of the software.
+
+You may not modify, adapt, translate, or create derivative works from HOMEKIT
+4K. You may not redistribute, sublicense, republish, or sell copies of the
+software. Any permission beyond downloading, installing, and running an
+unmodified copy requires prior written permission from the copyright holder.
+
+The copyright notice and this license must accompany any permitted unmodified
+copy.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHOR OR COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY
+ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.

package/LICENSE.md

@@ -0,0 +1,8 @@
+# Licensing status
+
+Copyright Chrisalvir. All rights reserved.
+
+No public license is granted for the original HOMEKIT 4K implementation during
+Phase 1. package.json declares UNLICENSED. A distribution license must be chosen
+by the author before public release. Third-party dependencies retain their own
+licenses and notices; this file does not change those licenses.

package/README.md

@@ -1,3 +1,66 @@
-# Temporary Holding Version
+# HOMEKIT 4K — by Chrisalvir
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+![HOMEKIT 4K — by Chrisalvir](logo.png)
+
+HomeKit 4K exports cameras assigned to the plugin in Camera.UI as separate
+Apple Home accessories. Camera.UI remains the source of camera streams,
+capabilities, sensors, and detector configuration.
+
+**Version 0.6.14.** Runtime behavior was validated on the developer MacBook
+with Camera.UI 2.3.0 using the previous package, 0.6.12. Version 0.6.14 fixes
+the npm scope to match the owner's npm account and does not change camera runtime
+behavior. Runtime evidence and limits are in
+[`docs/deployment-0.6.12.md`](docs/deployment-0.6.12.md).
+
+## Current behavior
+
+- H.264 sources at or below 1920×1080 are sent without video transcoding;
+  measured larger H.264 sources use a 1920×1080 output path. Audio is handled
+  separately according to HomeKit negotiation.
+- HEVC/H.265 uses its separate live and HKSV3 paths. HEVC recording and live
+  implementations are isolated from the H.264 resolution policy.
+- Camera.UI motion and visual detection events feed HomeKit's motion trigger for
+  both H.264/HKSV and HEVC/HKSV3 accessories. The bridge forwards observations;
+  it does not force-enable CoreML/OpenCV, bypass their zones or thresholds, or
+  dictate Apple's final People/Animals/Vehicles classification.
+- HomeKit recording choices and clip classification are controlled by the
+  paired Home Hub and the settings in Apple Home. A plugin event or HDS media
+  request alone does not prove that Apple saved a clip. In the latest real
+  validation, a Tapo vehicle event reached the bridge and caused a Home Hub
+  media request; saved vehicle/animal clips were not yet confirmed.
+- Pairing identities and per-camera persistent settings are stored by the
+  Camera.UI plugin runtime. Do not delete them when updating the package.
+
+## Requirements and installation
+
+The package currently declares Camera.UI >=2.3.0 and Node.js >=22.18.0. The
+development validation used Camera.UI's official local bundle installer. Public
+npm installation is not available yet; use Camera.UI's supported plugin
+installer after a public release is announced.
+
+The current package manifest restricts installation to macOS ARM64. That limit
+must be confirmed or removed before promising support for other Camera.UI
+platforms.
+
+## Development
+
+```sh
+pnpm install --frozen-lockfile
+pnpm check
+pnpm test:coverage
+pnpm bundle:camera-ui
+pnpm smoke:bundle
+```
+
+Automated checks and real-host evidence are different: test results do not
+replace playback, recording, or detection confirmation in Apple Home. See the
+validation documents under [`docs/`](docs/).
+
+## Public release status
+
+The package uses a proprietary license: users may download, install, and run an
+unmodified copy; modifying or redistributing it is not permitted without the
+author's written permission. Check npm for the first public release and use
+Camera.UI's supported plugin installer when the package becomes available
+there. See
+[`docs/npm-publication-readiness.md`](docs/npm-publication-readiness.md).

package/dist/accessories/AccessoryConfigStore.d.ts

@@ -0,0 +1,36 @@
+export interface StoredPtzPosition {
+    pan: number;
+    tilt: number;
+    zoom: number;
+}
+export interface StoredPtzPreset {
+    name: string;
+    position: StoredPtzPosition;
+    savedAt: string;
+    includeInPatrol: boolean;
+}
+export type HomeKitVideoMode = 'CLASSIC_H264' | 'HKSV3_LOCAL_HEVC';
+export interface CameraAccessoryConfig {
+    exportEnabled: boolean;
+    /** True after the one-time first-export default for HEVC/HKSV3 recording audio was applied. */
+    recordingAudioDefaultInitialized: boolean;
+    sourceId?: string;
+    videoMode: HomeKitVideoMode;
+    ptzEnabled: boolean;
+    patrolEnabled: boolean;
+    patrolIntervalSeconds: number;
+    presets: Array<StoredPtzPreset | null>;
+    defaultPreset?: number;
+    tracking: {
+        person: boolean;
+        animal: boolean;
+        vehicle: boolean;
+    };
+}
+export declare class AccessoryConfigStore {
+    private readonly store;
+    constructor(root: string);
+    get(cameraId: string): Promise<CameraAccessoryConfig>;
+    update(cameraId: string, change: (current: CameraAccessoryConfig) => CameraAccessoryConfig): Promise<CameraAccessoryConfig>;
+    exportEnabled(): Promise<string[]>;
+}

package/dist/accessories/AccessoryConfigStore.js

@@ -0,0 +1,79 @@
+import { join } from 'node:path';
+import { AtomicJsonStore, record } from "../persistence/AtomicJsonStore.js";
+const initialCamera = () => ({ exportEnabled: false, recordingAudioDefaultInitialized: false,
+    videoMode: 'CLASSIC_H264', ptzEnabled: false, patrolEnabled: false, patrolIntervalSeconds: 15,
+    presets: [null, null, null, null, null],
+    tracking: { person: false, animal: false, vehicle: false } });
+function decode(value) {
+    if (!record(value) || value.schemaVersion !== 1 || !record(value.cameras))
+        throw new Error('Invalid accessory configuration schema');
+    const cameras = Object.create(null);
+    for (const [cameraId, raw] of Object.entries(value.cameras)) {
+        if (!cameraId || !record(raw) || typeof raw.exportEnabled !== 'boolean' || typeof raw.ptzEnabled !== 'boolean' ||
+            !Array.isArray(raw.presets) || raw.presets.length !== 5 || !record(raw.tracking) ||
+            typeof raw.tracking.person !== 'boolean' || typeof raw.tracking.animal !== 'boolean' || typeof raw.tracking.vehicle !== 'boolean') {
+            throw new Error('Invalid per-camera accessory configuration');
+        }
+        const presets = raw.presets.map(preset => {
+            if (preset === null)
+                return null;
+            if (!record(preset) || typeof preset.name !== 'string' || !preset.name.trim() || typeof preset.savedAt !== 'string' ||
+                !record(preset.position) || typeof preset.position.pan !== 'number' || typeof preset.position.tilt !== 'number' ||
+                typeof preset.position.zoom !== 'number' || ![preset.position.pan, preset.position.tilt, preset.position.zoom].every(Number.isFinite)) {
+                throw new Error('Invalid PTZ preset');
+            }
+            const pan = preset.position.pan;
+            const tilt = preset.position.tilt;
+            const zoom = preset.position.zoom;
+            if (pan < -1 || pan > 1 || tilt < -1 || tilt > 1 || zoom < 0 || zoom > 1)
+                throw new Error('PTZ position is outside normalized limits');
+            return { name: preset.name.trim().slice(0, 48), savedAt: preset.savedAt,
+                position: { pan, tilt, zoom }, includeInPatrol: typeof preset.includeInPatrol === 'boolean' ? preset.includeInPatrol : true };
+        });
+        const defaultPreset = raw.defaultPreset;
+        if (defaultPreset !== undefined && (typeof defaultPreset !== 'number' || !Number.isInteger(defaultPreset) || defaultPreset < 0 ||
+            defaultPreset >= 5 || presets[defaultPreset] === null)) {
+            throw new Error('Invalid default PTZ preset');
+        }
+        if (!record(raw.tracking) || typeof raw.tracking.person !== 'boolean' || typeof raw.tracking.animal !== 'boolean' ||
+            typeof raw.tracking.vehicle !== 'boolean')
+            throw new Error('Invalid tracking flags');
+        cameras[cameraId] = { exportEnabled: raw.exportEnabled,
+            // Older saved camera configs predate the default. Initialize HEVC/HKSV3
+            // once after HAP restore, then persist the marker so later user choices stick.
+            recordingAudioDefaultInitialized: typeof raw.recordingAudioDefaultInitialized === 'boolean'
+                ? raw.recordingAudioDefaultInitialized : false,
+            videoMode: raw.videoMode === 'HKSV3_LOCAL_HEVC' ? 'HKSV3_LOCAL_HEVC' : 'CLASSIC_H264', ptzEnabled: raw.ptzEnabled,
+            patrolEnabled: typeof raw.patrolEnabled === 'boolean' ? raw.patrolEnabled : false,
+            ...(typeof raw.sourceId === 'string' && raw.sourceId ? { sourceId: raw.sourceId } : {}), presets,
+            patrolIntervalSeconds: typeof raw.patrolIntervalSeconds === 'number' && Number.isInteger(raw.patrolIntervalSeconds) &&
+                raw.patrolIntervalSeconds >= 5 && raw.patrolIntervalSeconds <= 300 ? raw.patrolIntervalSeconds : 15,
+            ...(typeof defaultPreset === 'number' ? { defaultPreset } : {}),
+            tracking: { person: raw.tracking.person, animal: raw.tracking.animal, vehicle: raw.tracking.vehicle } };
+    }
+    return { schemaVersion: 1, cameras };
+}
+export class AccessoryConfigStore {
+    store;
+    constructor(root) {
+        this.store = new AtomicJsonStore(join(root, 'accessories', 'config.json'), () => ({ schemaVersion: 1, cameras: {} }), decode);
+    }
+    async get(cameraId) {
+        const value = (await this.store.read()).cameras[cameraId];
+        return structuredClone(value ?? initialCamera());
+    }
+    async update(cameraId, change) {
+        if (!cameraId.trim())
+            throw new Error('Camera ID required');
+        const state = await this.store.update(current => {
+            const previous = current.cameras[cameraId] ?? initialCamera();
+            const updated = change(structuredClone(previous));
+            return { schemaVersion: 1, cameras: { ...current.cameras, [cameraId]: updated } };
+        });
+        return structuredClone(state.cameras[cameraId]);
+    }
+    async exportEnabled() {
+        const state = await this.store.read();
+        return Object.entries(state.cameras).filter(([, config]) => config.exportEnabled).map(([cameraId]) => cameraId);
+    }
+}

package/dist/accessories/CameraAccessoryManager.d.ts

@@ -0,0 +1,125 @@
+import type { CameraUiAdapter } from '../camera-ui/CameraUiAdapter.ts';
+import type { IdentityStore } from '../identity/IdentityStore.ts';
+import type { NativeVideoEngine } from '../media/NativeVideoEngine.ts';
+import type { Diagnostics } from '../diagnostics/Diagnostics.ts';
+import type { InspectableHapAdapter } from '../hap/HapAdapter.ts';
+import { AccessoryConfigStore, type HomeKitVideoMode } from './AccessoryConfigStore.ts';
+import { type H264AudioRuntime } from '../h264/AudioRuntime.ts';
+export interface AccessoryView {
+    cameraId: string;
+    name: string;
+    published: boolean;
+    paired: boolean;
+    sourceId?: string;
+    videoCodec?: string;
+    width?: number;
+    height?: number;
+    processing: 'UNKNOWN_NOT_VERIFIED';
+    audio: 'H264_NORMALIZED_AUDIO_UNVERIFIED' | 'PCMA_8KHZ_ADVERTISED_UNVERIFIED' | 'OPUS_48KHZ_20MS_FROM_PCMA_8KHZ_UNVERIFIED' | 'OPUS_48KHZ_OR_AAC_ELD_24KHZ_20MS_FROM_PCMA_8KHZ_UNVERIFIED';
+    entities: Array<{
+        id: string;
+        type: string;
+        name: string;
+        capabilities: string[];
+    }>;
+    ptz?: {
+        available: boolean;
+        enabled: boolean;
+        patrolEnabled: boolean;
+        capabilities: string[];
+        nativePresets?: string[];
+        positions: Array<({
+            name: string;
+            position: {
+                pan: number;
+                tilt: number;
+                zoom: number;
+            };
+            includeInPatrol: boolean;
+        } | null)>;
+        defaultPositionSlot?: number;
+        patrolIntervalSeconds: number;
+        position?: {
+            pan: number;
+            tilt: number;
+            zoom: number;
+        };
+    };
+    error?: string;
+}
+export interface PairingView {
+    setupUri: string;
+    manualCode: string;
+    paired: false;
+}
+export declare function brandedHomeKitSetupQr(setupUri: string, manualCode?: string, accessoryName?: string): Promise<string>;
+export declare function brandedHomeKitPlaceholderQr(statusBadge: string, lines: string[], footerBadge?: string, accessoryName?: string, variant?: 'info' | 'success' | 'warn'): string;
+export declare function formatHomeKitPin(value: number): string;
+/** Publishes one independent classic HAP camera accessory for an explicitly selected Camera.UI camera. */
+export declare class CameraAccessoryManager {
+    private readonly host;
+    private readonly hapAdapter;
+    private readonly identities;
+    private readonly video;
+    private readonly diagnostics;
+    private readonly storagePath;
+    private readonly h264AudioRuntime;
+    readonly config: AccessoryConfigStore;
+    private readonly live;
+    private readonly statuses;
+    private readonly serial;
+    private closed;
+    private readonly patrolJobs;
+    private readonly pendingPositionMoves;
+    private readonly stoppingPtz;
+    private readonly ptzStateListeners;
+    constructor(host: CameraUiAdapter, hapAdapter: InspectableHapAdapter, identities: IdentityStore, video: NativeVideoEngine, diagnostics: Diagnostics, storagePath: string, h264AudioRuntime?: () => Promise<H264AudioRuntime>);
+    start(): Promise<void>;
+    cameraAvailable(cameraId: string): Promise<void>;
+    cameraUnavailable(cameraId: string): Promise<void>;
+    sensorsChanged(): Promise<void>;
+    onPtzPatrolStateChanged(listener: (cameraId: string, enabled: boolean) => void): () => void;
+    enable(cameraId: string, sourceId: string, videoMode?: HomeKitVideoMode): Promise<void>;
+    disable(cameraId: string): Promise<void>;
+    /** Clears this accessory's local HAP pairing records. The Home app may also require removal on the iPhone. */
+    unlink(cameraId: string): Promise<void>;
+    ptzInfo(cameraId: string): Promise<AccessoryView['ptz']>;
+    setPtzEnabled(cameraId: string, enabled: boolean): Promise<void>;
+    setPtzPatrolEnabled(cameraId: string, enabled: boolean): Promise<void>;
+    savePtzPreset(cameraId: string, slot: number, name: string): Promise<void>;
+    setDefaultPtzPreset(cameraId: string, slot: number): Promise<void>;
+    setPtzPresetIncludedInPatrol(cameraId: string, slot: number, included: boolean): Promise<void>;
+    deletePtzPreset(cameraId: string, slot: number): Promise<void>;
+    movePtzRelative(cameraId: string, panDelta: number, tiltDelta: number, zoomDelta: number): Promise<void>;
+    jogPtz(cameraId: string, pan: number, tilt: number, zoom: number): Promise<void>;
+    stopPtz(cameraId: string): Promise<void>;
+    moveToPtzPreset(cameraId: string, slot: number): Promise<void>;
+    moveToDefaultPtzPreset(cameraId: string): Promise<void>;
+    pairing(cameraId: string): Promise<PairingView | undefined>;
+    pairingQr(cameraId: string): Promise<string>;
+    snapshot(): Promise<AccessoryView[]>;
+    close(): Promise<void>;
+    private publish;
+    private measuredSecureVideoTiers;
+    private updateMotionState;
+    private bindMotion;
+    private bindCameraEntities;
+    private entityView;
+    private storedPairingState;
+    private rotatePin;
+    private unpublish;
+    private disposeLive;
+    private refreshStatus;
+    private findPtz;
+    private presetNames;
+    private schedulePatrol;
+    private advancePatrol;
+    private failPatrol;
+    private clearPatrol;
+    private requirePtz;
+    private moveToSavedPosition;
+    private stopPtzMovement;
+    private validPosition;
+    private runtime;
+    private queue;
+}