homebridge-securitysystem 9.1.2-beta.3 → 10.0.0-beta.2

package/.github/workflows/publish.yml

@@ -74,6 +74,9 @@ jobs:
           node-version: ${{ vars.NPM_VERSION }}
           registry-url: https://registry.npmjs.org/
 
+      - name: Install dependencies
+        run: npm ci
+
       - name: Get version
         run: |
           echo "NPM_VERSION=${{ needs.create-tag.outputs.tag-name }}" >> $GITHUB_ENV

package/AGENTS.md

@@ -0,0 +1,214 @@
+# AGENTS.md — Architecture & Development Rules
+
+This document defines the architecture, naming conventions, and rules that all contributors and AI agents must follow when working on this codebase.
+
+---
+
+## Project Overview
+
+`homebridge-securitysystem` is a Homebridge v2 accessory plugin (not a platform plugin) that exposes a fully-featured security system to HomeKit. It is written in TypeScript with ESM modules.
+
+The plugin:
+- Exposes one `SecuritySystem` HAP service plus up to 22 optional switch/sensor accessories.
+- Uses an event-driven architecture: core state changes emit domain events; side-effect services (audio, webhook, command) listen and react.
+- Uses an abstract `Condition` class hierarchy to encapsulate all blocking-logic decisions.
+- Provides an optional Hono HTTP server for remote control.
+
+---
+
+## Source Layout
+
+```
+src/
+  @types/            Third-party type declarations
+  conditions/        Abstract Condition base + concrete condition classes
+  constants/         Compile-time constants (no logic)
+  handlers/          Stateful handlers wired by security-system.ts
+  interfaces/        TypeScript interfaces (plain object shapes)
+  services/          Stateful services (audio, webhook, command, storage, server, event bus)
+  tests/             Vitest test suites
+  types/             TypeScript enums and type aliases
+  utils/             Pure utility functions
+  index.ts           Homebridge plugin entry point
+  security-system.ts Root AccessoryPlugin class
+```
+
+---
+
+## Layer Rules
+
+| Layer | What belongs here | What does NOT belong |
+|---|---|---|
+| `types/` | Enums, type aliases | Logic, classes |
+| `interfaces/` | Plain object shape interfaces | Logic, classes, enums |
+| `constants/` | `const` objects, literal values | Logic, mutable state |
+| `utils/` | Pure functions with no side effects | Classes, state, I/O |
+| `conditions/` | Classes extending `Condition` | Handlers, services |
+| `services/` | Stateful singleton classes, I/O | Embedded types, enums, interfaces |
+| `handlers/` | State-machine logic classes | Embedded types, enums, interfaces |
+
+**Types, enums, and interfaces must never be defined inside a service or handler file.** Always create a separate file in `types/` or `interfaces/` and import it.
+
+---
+
+## File Naming Conventions
+
+All filenames use **kebab-case** with a mandatory suffix describing their kind:
+
+| Kind | Suffix | Example |
+|---|---|---|
+| Enum or type alias | `-type.ts` | `security-state-type.ts` |
+| Interface | `-interface.ts` | `system-state-interface.ts` |
+| Constant object | `-constant.ts` | `homekit-constant.ts` |
+| Utility functions | `-util.ts` | `state-util.ts` |
+| Service class | `-service.ts` | `audio-service.ts` |
+| Handler class | `-handler.ts` | `state-handler.ts` |
+| Condition class | `-condition.ts` | `double-knock-condition.ts` |
+| Test suite | `.test.ts` | `conditions.test.ts` |
+
+---
+
+## Naming Conventions
+
+### No Abbreviations
+
+**Variable names, parameter names, and type names must not use abbreviations.**
+
+This rule applies everywhere: source files, test files, and any new code.
+
+Forbidden examples and their correct replacements:
+
+| Forbidden | Use instead |
+|---|---|
+| `s`, `st` for state | `state` |
+| `o`, `opts` for options | `options` |
+| `v` for value | `value` |
+| `req` for request | `request` |
+| `res` for response | `response` |
+| `c` for context | `context` |
+| `e` for error | `error` |
+| `cb` for callback | `callback` |
+| `fn` for function | the actual semantic name |
+| `svc` for service | `service` |
+| `char` for characteristic | `characteristic` |
+| `Char` for Characteristic constructor | `Characteristic` |
+| `Svc` for Service constructor | `Service` |
+| `proc` for process | `process` |
+| `dir` for directory | `directory` |
+| `msg` for message | `message` |
+| `buf` for buffer | `buffer` |
+| `idx` for index | `index` |
+| `len` for length | `length` |
+| `num` for number | `number` or a semantic name |
+| `str` for string | the semantic name |
+| `tmp` for temporary | the semantic name |
+| `args` for arguments | `arguments` (or a semantic name) |
+
+**Exception:** loop variables `i`, `j`, `k` in tight numeric loops where the name carries no domain meaning are acceptable. All other names must be descriptive.
+
+### Class Names
+
+- PascalCase, no abbreviations.
+- Suffix matches the layer: `...Service`, `...Handler`, `...Condition`.
+
+### Enum Members
+
+- UPPER_SNAKE_CASE (e.g. `SecurityState.TRIGGERED`).
+
+### Interface Names
+
+- PascalCase, no `I` prefix.
+- Suffix: `...Interface` is not used in the filename's export — the filename carries it.
+
+---
+
+## Architecture: Event-Driven Side Effects
+
+The core state machine (`StateHandler`, `TripHandler`, `SwitchHandler`) never calls side-effect services directly. Instead it emits domain events via `EventBusService`:
+
+```
+StateHandler → bus.emit(EventType.CURRENT_CHANGED, payload)
+                         ↓              ↓              ↓
+                  AudioService   WebhookService  CommandService
+```
+
+Each side-effect service calls `attachToBus(bus)` during construction in `security-system.ts`.
+
+**New side effects must follow this pattern** — never add direct calls from handlers to services.
+
+Events and their payload types are defined in `src/types/event-type.ts`. The mapping from event to payload is in `src/types/event-payload-map-type.ts`.
+
+---
+
+## Architecture: Condition System
+
+All trip-blocking decisions use the `Condition` abstract base class:
+
+```typescript
+abstract class Condition {
+  abstract readonly name: string;
+  abstract evaluate(context: ConditionContext): boolean;
+}
+```
+
+`evaluate` returns `true` to **block** the action, `false` to **allow** it.
+
+Conditions are instantiated once inside `TripHandler` and evaluated in order. To add a new blocking rule, create a new file in `conditions/`, extend `Condition`, and add it to `TripHandler`.
+
+---
+
+## Architecture: Circular Dependency Resolution
+
+`StateHandler` ↔ `TripHandler` and `StateHandler` ↔ `SwitchHandler` are mutually dependent. This is resolved with **setter injection**:
+
+1. Construct all handlers independently.
+2. Wire them with `setHandlers()` / `setStateHandler()` after all instances exist.
+
+Do not introduce `new` calls between these classes at construction time.
+
+---
+
+## Code Style Rules
+
+### File Length
+Maximum **400 lines** per file. Split into smaller focused files if the limit is reached.
+
+### Inline Guards
+Use early-return guard clauses rather than deep nesting:
+```typescript
+if (!value) {
+  return false;
+}
+```
+
+### Imports
+- Use `import type` for types and interfaces that are not needed at runtime.
+- Always use `.js` extensions on relative imports (required for ESM).
+
+### Async
+- Use `async`/`await`. Avoid `.then()` chains except when fire-and-forget is intentional.
+
+### Error Handling
+- Validate only at system boundaries (config parsing, HTTP input, external storage).
+- Do not add defensive null-checks for values guaranteed by the type system.
+
+---
+
+## Testing
+
+- Framework: **Vitest** (`npm test`).
+- Test files live in `src/tests/` and are named `<subject>.test.ts`.
+- Tests cover: conditions (all blocking paths), handler logic, and event-driven interactions.
+- Mock only what is strictly necessary. Prefer structural mocks over full mock libraries.
+- Do not test private methods directly — test through the public API.
+
+---
+
+## Adding a New Feature
+
+1. **Types/interfaces first** — create files in `types/` or `interfaces/` before writing logic.
+2. **Condition** — if the feature blocks a trip, add a `Condition` subclass.
+3. **Service** — if the feature is a side effect, implement `attachToBus(bus)` and wire in `security-system.ts`.
+4. **Handler** — if the feature changes state-machine logic, modify the relevant handler.
+5. **Tests** — add a test covering the happy path and the main blocking/edge case.
+6. **No abbreviations** — all new identifiers must be fully spelled out.

package/dist/conditions/already-triggered-condition.d.ts

@@ -0,0 +1,10 @@
+import type { ConditionContext } from '../interfaces/condition-context-interface.js';
+import { Condition } from './condition.js';
+/**
+ * Blocks a new trip activation when the alarm has already been triggered.
+ * Prevents stacking multiple trigger events on an active alarm.
+ */
+export declare class AlreadyTriggeredCondition extends Condition {
+    readonly name = "already-triggered";
+    evaluate({ state, value }: ConditionContext): boolean;
+}

package/dist/conditions/already-triggered-condition.js

@@ -0,0 +1,16 @@
+import { SecurityState } from '../types/security-state-type.js';
+import { Condition } from './condition.js';
+/**
+ * Blocks a new trip activation when the alarm has already been triggered.
+ * Prevents stacking multiple trigger events on an active alarm.
+ */
+export class AlreadyTriggeredCondition extends Condition {
+    name = 'already-triggered';
+    evaluate({ state, value }) {
+        if (!value) {
+            return false;
+        }
+        return state.currentState === SecurityState.TRIGGERED;
+    }
+}
+//# sourceMappingURL=already-triggered-condition.js.map

package/dist/conditions/already-triggered-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"already-triggered-condition.js","sourceRoot":"","sources":["../../src/conditions/already-triggered-condition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,MAAM,OAAO,yBAA0B,SAAQ,SAAS;IAC7C,IAAI,GAAG,mBAAmB,CAAC;IAEpC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,EAAoB;QACzC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,KAAK,CAAC,YAAY,KAAK,aAAa,CAAC,SAAS,CAAC;IACxD,CAAC;CACF"}

package/dist/conditions/arming-in-progress-condition.d.ts

@@ -0,0 +1,10 @@
+import type { ConditionContext } from '../interfaces/condition-context-interface.js';
+import { Condition } from './condition.js';
+/**
+ * Blocks a trip action while the arm delay countdown is still running.
+ * Prevents an intruder from tripping the system before it has fully armed.
+ */
+export declare class ArmingInProgressCondition extends Condition {
+    readonly name = "arming-in-progress";
+    evaluate({ state, value }: ConditionContext): boolean;
+}

package/dist/conditions/arming-in-progress-condition.js

@@ -0,0 +1,15 @@
+import { Condition } from './condition.js';
+/**
+ * Blocks a trip action while the arm delay countdown is still running.
+ * Prevents an intruder from tripping the system before it has fully armed.
+ */
+export class ArmingInProgressCondition extends Condition {
+    name = 'arming-in-progress';
+    evaluate({ state, value }) {
+        if (!value) {
+            return false;
+        }
+        return state.isArming;
+    }
+}
+//# sourceMappingURL=arming-in-progress-condition.js.map

package/dist/conditions/arming-in-progress-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arming-in-progress-condition.js","sourceRoot":"","sources":["../../src/conditions/arming-in-progress-condition.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,MAAM,OAAO,yBAA0B,SAAQ,SAAS;IAC7C,IAAI,GAAG,oBAAoB,CAAC;IAErC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,EAAoB;QACzC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,KAAK,CAAC,QAAQ,CAAC;IACxB,CAAC;CACF"}

package/dist/conditions/arming-lock-condition.d.ts

@@ -0,0 +1,13 @@
+import type { ConditionContext } from '../interfaces/condition-context-interface.js';
+import type { CharacteristicConstructor } from '../interfaces/hap-types-interface.js';
+import { Condition } from './condition.js';
+/**
+ * Blocks arming when an arming-lock switch (global or mode-specific) is active.
+ * Does NOT block disarming.
+ */
+export declare class ArmingLockCondition extends Condition {
+    private readonly Characteristic;
+    readonly name = "arming-lock";
+    constructor(Characteristic: CharacteristicConstructor);
+    evaluate({ state, services, options }: ConditionContext): boolean;
+}

package/dist/conditions/arming-lock-condition.js

@@ -0,0 +1,42 @@
+import { SecurityState } from '../types/security-state-type.js';
+import { Condition } from './condition.js';
+/**
+ * Blocks arming when an arming-lock switch (global or mode-specific) is active.
+ * Does NOT block disarming.
+ */
+export class ArmingLockCondition extends Condition {
+    Characteristic;
+    name = 'arming-lock';
+    constructor(Characteristic) {
+        super();
+        this.Characteristic = Characteristic;
+    }
+    evaluate({ state, services, options }) {
+        const hasLockFeature = options.armingLockSwitch || options.armingLockSwitches;
+        if (!hasLockFeature) {
+            return false;
+        }
+        const targetState = state.targetState;
+        if (targetState === SecurityState.OFF) {
+            return false;
+        }
+        // Check global arming-lock switch.
+        const globalOn = services.armingLockSwitchService
+            .getCharacteristic(this.Characteristic.On).value;
+        if (globalOn) {
+            return true;
+        }
+        // Check mode-specific arming-lock switch.
+        switch (targetState) {
+            case SecurityState.HOME:
+                return Boolean(services.armingLockHomeSwitchService.getCharacteristic(this.Characteristic.On).value);
+            case SecurityState.AWAY:
+                return Boolean(services.armingLockAwaySwitchService.getCharacteristic(this.Characteristic.On).value);
+            case SecurityState.NIGHT:
+                return Boolean(services.armingLockNightSwitchService.getCharacteristic(this.Characteristic.On).value);
+            default:
+                return false;
+        }
+    }
+}
+//# sourceMappingURL=arming-lock-condition.js.map

package/dist/conditions/arming-lock-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arming-lock-condition.js","sourceRoot":"","sources":["../../src/conditions/arming-lock-condition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAGhE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,MAAM,OAAO,mBAAoB,SAAQ,SAAS;IAGnB;IAFpB,IAAI,GAAG,aAAa,CAAC;IAE9B,YAA6B,cAAyC;QACpE,KAAK,EAAE,CAAC;QADmB,mBAAc,GAAd,cAAc,CAA2B;IAEtE,CAAC;IAED,QAAQ,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAoB;QACrD,MAAM,cAAc,GAAG,OAAO,CAAC,gBAAgB,IAAI,OAAO,CAAC,kBAAkB,CAAC;QAC9E,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACtC,IAAI,WAAW,KAAK,aAAa,CAAC,GAAG,EAAE,CAAC;YACtC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,mCAAmC;QACnC,MAAM,QAAQ,GAAG,QAAQ,CAAC,uBAAuB;aAC9C,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC;QAEnD,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,IAAI,CAAC;QACd,CAAC;QAED,0CAA0C;QAC1C,QAAQ,WAAW,EAAE,CAAC;YACtB,KAAK,aAAa,CAAC,IAAI;gBACrB,OAAO,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAC,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;YACvG,KAAK,aAAa,CAAC,IAAI;gBACrB,OAAO,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAC,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;YACvG,KAAK,aAAa,CAAC,KAAK;gBACtB,OAAO,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAAC,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;YACxG;gBACE,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;CACF"}

package/dist/conditions/condition.d.ts

@@ -0,0 +1,15 @@
+import type { ConditionContext } from '../interfaces/condition-context-interface.js';
+/**
+ * Base class for all conditions that can block a trip/trigger action.
+ *
+ * Extend this class and implement `evaluate()` to return `true` when the
+ * condition should prevent the action from proceeding.
+ */
+export declare abstract class Condition {
+    abstract readonly name: string;
+    /**
+     * Returns `true` if this condition blocks the action described by `context`.
+     * When `true` is returned the caller must reject the HomeKit request.
+     */
+    abstract evaluate(context: ConditionContext): boolean;
+}

package/dist/conditions/condition.js

@@ -0,0 +1,9 @@
+/**
+ * Base class for all conditions that can block a trip/trigger action.
+ *
+ * Extend this class and implement `evaluate()` to return `true` when the
+ * condition should prevent the action from proceeding.
+ */
+export class Condition {
+}
+//# sourceMappingURL=condition.js.map

package/dist/conditions/condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition.js","sourceRoot":"","sources":["../../src/conditions/condition.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,OAAgB,SAAS;CAQ9B"}

package/dist/conditions/double-knock-condition.d.ts

@@ -0,0 +1,22 @@
+import type { ConditionContext } from '../interfaces/condition-context-interface.js';
+import { Condition } from './condition.js';
+/**
+ * Implements the double-knock pattern: the first activation within a mode that
+ * has double-knock enabled sets a "knocked" flag and rejects the trip. Only the
+ * second activation within the configured window proceeds.
+ *
+ * The caller is responsible for managing `state.isKnocked` and the timeout
+ * via the `onFirstKnock` callback injected at construction.
+ */
+export declare class DoubleKnockCondition extends Condition {
+    private readonly onFirstKnock;
+    readonly name = "double-knock";
+    /**
+     * @param onFirstKnock Called when the first knock is detected.
+     *   The callback receives the window duration in seconds and a reset function
+     *   to invoke when the window expires.
+     */
+    constructor(onFirstKnock: (seconds: number, onExpire: () => void) => void);
+    evaluate({ state, options, value, origin }: ConditionContext): boolean;
+    private resolveWindow;
+}

package/dist/conditions/double-knock-condition.js

@@ -0,0 +1,70 @@
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import { modeToState } from '../utils/state-util.js';
+import { Condition } from './condition.js';
+/**
+ * Implements the double-knock pattern: the first activation within a mode that
+ * has double-knock enabled sets a "knocked" flag and rejects the trip. Only the
+ * second activation within the configured window proceeds.
+ *
+ * The caller is responsible for managing `state.isKnocked` and the timeout
+ * via the `onFirstKnock` callback injected at construction.
+ */
+export class DoubleKnockCondition extends Condition {
+    onFirstKnock;
+    name = 'double-knock';
+    /**
+     * @param onFirstKnock Called when the first knock is detected.
+     *   The callback receives the window duration in seconds and a reset function
+     *   to invoke when the window expires.
+     */
+    constructor(onFirstKnock) {
+        super();
+        this.onFirstKnock = onFirstKnock;
+    }
+    evaluate({ state, options, value, origin }) {
+        if (!value || !options.doubleKnock) {
+            return false;
+        }
+        if (origin === OriginType.OVERRIDE_SWITCH) {
+            return false;
+        }
+        if (state.isArming) {
+            return false;
+        }
+        const knockableStates = options.doubleKnockModes.map(m => modeToState(m.toLowerCase()));
+        if (!knockableStates.includes(state.currentState)) {
+            return false;
+        }
+        if (state.isKnocked) {
+            // Second knock — clear the flag and allow through.
+            state.isKnocked = false;
+            if (state.doubleKnockTimeout !== null) {
+                clearTimeout(state.doubleKnockTimeout);
+                state.doubleKnockTimeout = null;
+            }
+            return false;
+        }
+        // First knock — block and schedule expiry.
+        state.isKnocked = true;
+        const seconds = this.resolveWindow(state.currentState, options);
+        this.onFirstKnock(seconds, () => {
+            state.isKnocked = false;
+            state.doubleKnockTimeout = null;
+        });
+        return true;
+    }
+    resolveWindow(currentState, options) {
+        if (currentState === SecurityState.HOME && options.homeDoubleKnockSeconds !== null) {
+            return options.homeDoubleKnockSeconds;
+        }
+        if (currentState === SecurityState.AWAY && options.awayDoubleKnockSeconds !== null) {
+            return options.awayDoubleKnockSeconds;
+        }
+        if (currentState === SecurityState.NIGHT && options.nightDoubleKnockSeconds !== null) {
+            return options.nightDoubleKnockSeconds;
+        }
+        return options.doubleKnockSeconds;
+    }
+}
+//# sourceMappingURL=double-knock-condition.js.map

package/dist/conditions/double-knock-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"double-knock-condition.js","sourceRoot":"","sources":["../../src/conditions/double-knock-condition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,OAAO,oBAAqB,SAAQ,SAAS;IAS9B;IARV,IAAI,GAAG,cAAc,CAAC;IAE/B;;;;OAIG;IACH,YACmB,YAA6D;QAE9E,KAAK,EAAE,CAAC;QAFS,iBAAY,GAAZ,YAAY,CAAiD;IAGhF,CAAC;IAED,QAAQ,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAoB;QAC1D,IAAI,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YACnC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,MAAM,KAAK,UAAU,CAAC,eAAe,EAAE,CAAC;YAC1C,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACnB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QACxF,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC;YAClD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YACpB,mDAAmD;YACnD,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC;YACxB,IAAI,KAAK,CAAC,kBAAkB,KAAK,IAAI,EAAE,CAAC;gBACtC,YAAY,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;gBACvC,KAAK,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAClC,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,2CAA2C;QAC3C,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QAEhE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE;YAC9B,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC;YACxB,KAAK,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAClC,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,aAAa,CACnB,YAA2B,EAC3B,OAAoC;QAEpC,IAAI,YAAY,KAAK,aAAa,CAAC,IAAI,IAAI,OAAO,CAAC,sBAAsB,KAAK,IAAI,EAAE,CAAC;YACnF,OAAO,OAAO,CAAC,sBAAsB,CAAC;QACxC,CAAC;QACD,IAAI,YAAY,KAAK,aAAa,CAAC,IAAI,IAAI,OAAO,CAAC,sBAAsB,KAAK,IAAI,EAAE,CAAC;YACnF,OAAO,OAAO,CAAC,sBAAsB,CAAC;QACxC,CAAC;QACD,IAAI,YAAY,KAAK,aAAa,CAAC,KAAK,IAAI,OAAO,CAAC,uBAAuB,KAAK,IAAI,EAAE,CAAC;YACrF,OAAO,OAAO,CAAC,uBAAuB,CAAC;QACzC,CAAC;QACD,OAAO,OAAO,CAAC,kBAAkB,CAAC;IACpC,CAAC;CACF"}

package/dist/conditions/not-armed-condition.d.ts

@@ -0,0 +1,10 @@
+import type { ConditionContext } from '../interfaces/condition-context-interface.js';
+import { Condition } from './condition.js';
+/**
+ * Blocks a trip action when the system is disarmed and neither
+ * `override_off` nor the override switch is in use.
+ */
+export declare class NotArmedCondition extends Condition {
+    readonly name = "not-armed";
+    evaluate({ state, options, value, origin }: ConditionContext): boolean;
+}

package/dist/conditions/not-armed-condition.js

@@ -0,0 +1,20 @@
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import { Condition } from './condition.js';
+/**
+ * Blocks a trip action when the system is disarmed and neither
+ * `override_off` nor the override switch is in use.
+ */
+export class NotArmedCondition extends Condition {
+    name = 'not-armed';
+    evaluate({ state, options, value, origin }) {
+        if (!value) {
+            return false;
+        }
+        const isDisarmed = state.currentState === SecurityState.OFF;
+        const isNotOverridingOff = !options.overrideOff;
+        const isNotOverrideSwitch = origin !== OriginType.OVERRIDE_SWITCH;
+        return isDisarmed && isNotOverridingOff && isNotOverrideSwitch;
+    }
+}
+//# sourceMappingURL=not-armed-condition.js.map

package/dist/conditions/not-armed-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-armed-condition.js","sourceRoot":"","sources":["../../src/conditions/not-armed-condition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,MAAM,OAAO,iBAAkB,SAAQ,SAAS;IACrC,IAAI,GAAG,WAAW,CAAC;IAE5B,QAAQ,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAoB;QAC1D,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,UAAU,GAAG,KAAK,CAAC,YAAY,KAAK,aAAa,CAAC,GAAG,CAAC;QAC5D,MAAM,kBAAkB,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC;QAChD,MAAM,mBAAmB,GAAG,MAAM,KAAK,UAAU,CAAC,eAAe,CAAC;QAElE,OAAO,UAAU,IAAI,kBAAkB,IAAI,mBAAmB,CAAC;IACjE,CAAC;CACF"}

package/dist/constants/default-constant.d.ts

@@ -0,0 +1,26 @@
+/** Default configuration values applied when a config property is not set. */
+export declare const DEFAULTS: {
+    readonly NAME: "Security System";
+    readonly SERIAL_NUMBER: "S3CUR1TYSYST3M";
+    readonly DEFAULT_MODE: "off";
+    readonly ARM_SECONDS: 0;
+    readonly TRIGGER_SECONDS: 0;
+    readonly RESET_MINUTES: 10;
+    readonly DOUBLE_KNOCK_SECONDS: 90;
+    readonly TRIPPED_SENSOR_SECONDS: 5;
+    readonly TRIGGERED_SENSOR_SECONDS: 5;
+    readonly PAUSE_MINUTES: 0;
+    readonly AUDIO_LANGUAGE: "en-US";
+    readonly TRIP_SWITCH_NAME: "Trip";
+    readonly TRIP_HOME_SWITCH_NAME: "Trip Home";
+    readonly TRIP_AWAY_SWITCH_NAME: "Trip Away";
+    readonly TRIP_NIGHT_SWITCH_NAME: "Trip Night";
+    readonly TRIP_OVERRIDE_SWITCH_NAME: "Trip Override";
+    readonly MODE_HOME_SWITCH_NAME: "Mode Home";
+    readonly MODE_AWAY_SWITCH_NAME: "Mode Away";
+    readonly MODE_NIGHT_SWITCH_NAME: "Mode Night";
+    readonly MODE_OFF_SWITCH_NAME: "Mode Off";
+    readonly MODE_AWAY_EXTENDED_SWITCH_NAME: "Mode Away Extended";
+    readonly MODE_PAUSE_SWITCH_NAME: "Mode Pause";
+    readonly AUDIO_SWITCH_NAME: "Audio";
+};

package/dist/constants/default-constant.js

@@ -0,0 +1,28 @@
+/** Default configuration values applied when a config property is not set. */
+export const DEFAULTS = {
+    NAME: 'Security System',
+    SERIAL_NUMBER: 'S3CUR1TYSYST3M',
+    DEFAULT_MODE: 'off',
+    ARM_SECONDS: 0,
+    TRIGGER_SECONDS: 0,
+    RESET_MINUTES: 10,
+    DOUBLE_KNOCK_SECONDS: 90,
+    TRIPPED_SENSOR_SECONDS: 5,
+    TRIGGERED_SENSOR_SECONDS: 5,
+    PAUSE_MINUTES: 0,
+    AUDIO_LANGUAGE: 'en-US',
+    // Switch display names
+    TRIP_SWITCH_NAME: 'Trip',
+    TRIP_HOME_SWITCH_NAME: 'Trip Home',
+    TRIP_AWAY_SWITCH_NAME: 'Trip Away',
+    TRIP_NIGHT_SWITCH_NAME: 'Trip Night',
+    TRIP_OVERRIDE_SWITCH_NAME: 'Trip Override',
+    MODE_HOME_SWITCH_NAME: 'Mode Home',
+    MODE_AWAY_SWITCH_NAME: 'Mode Away',
+    MODE_NIGHT_SWITCH_NAME: 'Mode Night',
+    MODE_OFF_SWITCH_NAME: 'Mode Off',
+    MODE_AWAY_EXTENDED_SWITCH_NAME: 'Mode Away Extended',
+    MODE_PAUSE_SWITCH_NAME: 'Mode Pause',
+    AUDIO_SWITCH_NAME: 'Audio',
+};
+//# sourceMappingURL=default-constant.js.map

package/dist/constants/default-constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-constant.js","sourceRoot":"","sources":["../../src/constants/default-constant.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,iBAAiB;IACvB,aAAa,EAAE,gBAAgB;IAC/B,YAAY,EAAE,KAAK;IACnB,WAAW,EAAE,CAAC;IACd,eAAe,EAAE,CAAC;IAClB,aAAa,EAAE,EAAE;IACjB,oBAAoB,EAAE,EAAE;IACxB,sBAAsB,EAAE,CAAC;IACzB,wBAAwB,EAAE,CAAC;IAC3B,aAAa,EAAE,CAAC;IAChB,cAAc,EAAE,OAAO;IAEvB,uBAAuB;IACvB,gBAAgB,EAAE,MAAM;IACxB,qBAAqB,EAAE,WAAW;IAClC,qBAAqB,EAAE,WAAW;IAClC,sBAAsB,EAAE,YAAY;IACpC,yBAAyB,EAAE,eAAe;IAC1C,qBAAqB,EAAE,WAAW;IAClC,qBAAqB,EAAE,WAAW;IAClC,sBAAsB,EAAE,YAAY;IACpC,oBAAoB,EAAE,UAAU;IAChC,8BAA8B,EAAE,oBAAoB;IACpD,sBAAsB,EAAE,YAAY;IACpC,iBAAiB,EAAE,OAAO;CAClB,CAAC"}

package/dist/constants/homekit-constant.d.ts

@@ -0,0 +1,4 @@
+/** HomeKit HAP status code returned when an action is not permitted in the current state. */
+export declare const HK_NOT_ALLOWED_IN_CURRENT_STATE = -70412;
+/** Pulse duration in ms used by motion sensors to emit a brief motion event. */
+export declare const SENSOR_PULSE_MS = 750;

package/dist/constants/homekit-constant.js

@@ -0,0 +1,5 @@
+/** HomeKit HAP status code returned when an action is not permitted in the current state. */
+export const HK_NOT_ALLOWED_IN_CURRENT_STATE = -70412;
+/** Pulse duration in ms used by motion sensors to emit a brief motion event. */
+export const SENSOR_PULSE_MS = 750;
+//# sourceMappingURL=homekit-constant.js.map

package/dist/constants/homekit-constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"homekit-constant.js","sourceRoot":"","sources":["../../src/constants/homekit-constant.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,KAAK,CAAC;AAEtD,gFAAgF;AAChF,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,CAAC"}

package/dist/constants/switch-uuid-constant.d.ts

@@ -0,0 +1,23 @@
+/** Stable subtype UUIDs for each HomeKit service. Must not change between restarts. */
+export declare const SWITCH_UUIDS: {
+    readonly TRIP: "siren-switch";
+    readonly TRIP_HOME: "siren-home";
+    readonly TRIP_AWAY: "siren-away";
+    readonly TRIP_NIGHT: "siren-night";
+    readonly TRIP_OVERRIDE: "pink-sheep";
+    readonly ARMING_LOCK: "arming-lock";
+    readonly ARMING_LOCK_HOME: "arming-lock-home";
+    readonly ARMING_LOCK_AWAY: "arming-lock-away";
+    readonly ARMING_LOCK_NIGHT: "arming-lock-night";
+    readonly MODE_HOME: "mode-home";
+    readonly MODE_AWAY: "mode-away";
+    readonly MODE_NIGHT: "mode-night";
+    readonly MODE_OFF: "mode-off";
+    readonly MODE_AWAY_EXTENDED: "mode-away-extended";
+    readonly MODE_PAUSE: "mode-pause";
+    readonly AUDIO: "kx82r64zN3txDXKFiX9JDi";
+    readonly ARMING_SENSOR: "arming-motion-sensor";
+    readonly TRIPPED_SENSOR: "siren-tripped";
+    readonly TRIGGERED_SENSOR: "siren-triggered";
+    readonly RESET_SENSOR: "reset-event";
+};

package/dist/constants/switch-uuid-constant.js

@@ -0,0 +1,24 @@
+/** Stable subtype UUIDs for each HomeKit service. Must not change between restarts. */
+export const SWITCH_UUIDS = {
+    TRIP: 'siren-switch',
+    TRIP_HOME: 'siren-home',
+    TRIP_AWAY: 'siren-away',
+    TRIP_NIGHT: 'siren-night',
+    TRIP_OVERRIDE: 'pink-sheep',
+    ARMING_LOCK: 'arming-lock',
+    ARMING_LOCK_HOME: 'arming-lock-home',
+    ARMING_LOCK_AWAY: 'arming-lock-away',
+    ARMING_LOCK_NIGHT: 'arming-lock-night',
+    MODE_HOME: 'mode-home',
+    MODE_AWAY: 'mode-away',
+    MODE_NIGHT: 'mode-night',
+    MODE_OFF: 'mode-off',
+    MODE_AWAY_EXTENDED: 'mode-away-extended',
+    MODE_PAUSE: 'mode-pause',
+    AUDIO: 'kx82r64zN3txDXKFiX9JDi',
+    ARMING_SENSOR: 'arming-motion-sensor',
+    TRIPPED_SENSOR: 'siren-tripped',
+    TRIGGERED_SENSOR: 'siren-triggered',
+    RESET_SENSOR: 'reset-event',
+};
+//# sourceMappingURL=switch-uuid-constant.js.map

package/dist/constants/switch-uuid-constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch-uuid-constant.js","sourceRoot":"","sources":["../../src/constants/switch-uuid-constant.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,SAAS,EAAE,YAAY;IACvB,SAAS,EAAE,YAAY;IACvB,UAAU,EAAE,aAAa;IACzB,aAAa,EAAE,YAAY;IAC3B,WAAW,EAAE,aAAa;IAC1B,gBAAgB,EAAE,kBAAkB;IACpC,gBAAgB,EAAE,kBAAkB;IACpC,iBAAiB,EAAE,mBAAmB;IACtC,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;IACtB,UAAU,EAAE,YAAY;IACxB,QAAQ,EAAE,UAAU;IACpB,kBAAkB,EAAE,oBAAoB;IACxC,UAAU,EAAE,YAAY;IACxB,KAAK,EAAE,wBAAwB;IAC/B,aAAa,EAAE,sBAAsB;IACrC,cAAc,EAAE,eAAe;IAC/B,gBAAgB,EAAE,iBAAiB;IACnC,YAAY,EAAE,aAAa;CACnB,CAAC"}