fix: Clear the initialized condition state when the card is not usable (#2646)

The `initialized` state (used in conditions/triggers) was written once
and never cleared, so it meant "has this card ever been initialized"
while everything reading it took it as "is this card usable now". Home
Assistant takes a card off the page and puts it back whenever its
dashboard tab is left and returned to, so the card initialized again
while the state claimed it was initialized throughout: `trigger:
initialized` fired once per card rather than once per startup, and
automations were dropped in between.

The card lifecycle is now an explicit state machine (`SessionManager`),
the only writer of `initialized`, which separates a card that is
starting up from one initializing part of itself again while it runs. A
new `ever` parameter (conditions/triggers) selects the old latched
behaviour.

`remote_control` uses that parameter to keep its two camera priorities
correct under repeated starts. With `camera_priority: entity` the card
now re-reads the entity every time it starts, so a camera selected while
the card was away is picked up on return. With `camera_priority: card`
the card writes the entity on its first start only, unchanged, since
repeating that write would overwrite a camera the user had selected.

Closes: #2642


BREAKING CHANGE: `condition: initialized` is now `false` whenever the
card is not usable, and `trigger: initialized` fires each time the card
starts up rather than only the first time. Set `ever: true` on either to
keep the previous behaviour.

tests/condition-trigger/conditions/conditions/initialized.test.ts

@@ -6,7 +6,7 @@ import { createEvaluatorContext } from './test-utils';
 describe('initialized condition', () => {
   it('should match an initialized condition', () => {
     const evaluator = createConditionEvaluator(
-      { condition: 'initialized' as const },
+      { condition: 'initialized' as const, ever: false },
       createEvaluatorContext(),
     );
 
@@ -14,4 +14,18 @@ describe('initialized condition', () => {
     expect(evaluator.evaluate({ initialized: true }).result).toBeTruthy();
     expect(evaluator.evaluate({ initialized: false }).result).toBeFalsy();
   });
+
+  it('should match an ever initialized condition', () => {
+    const evaluator = createConditionEvaluator(
+      { condition: 'initialized' as const, ever: true },
+      createEvaluatorContext(),
+    );
+
+    expect(evaluator.evaluate({}).result).toBeFalsy();
+    expect(evaluator.evaluate({ everInitialized: true }).result).toBeTruthy();
+
+    expect(
+      evaluator.evaluate({ initialized: false, everInitialized: true }).result,
+    ).toBeTruthy();
+  });
 });

tests/condition-trigger/triggers/factory.test.ts

@@ -52,7 +52,7 @@ describe('createTriggerEvaluator', () => {
     [{ trigger: 'microphone', muted: true }, MicrophoneTrigger],
     [{ trigger: 'triggered' }, TriggeredTrigger],
     [{ trigger: 'view', views: ['live'] }, ViewTrigger],
-    [{ trigger: 'initialized' }, InitializedTrigger],
+    [{ trigger: 'initialized', ever: false }, InitializedTrigger],
     [{ trigger: 'key', key: 'a' }, KeyTrigger],
     [{ trigger: 'screen' }, ScreenTrigger],
   ])('should create the dedicated evaluator for a %o trigger', (trigger, expected) => {

tests/condition-trigger/triggers/triggers/initialized.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi, type Mock } from 'vitest';
+
+import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
+import { InitializedTrigger } from '../../../../src/condition-trigger/triggers/triggers/initialized';
+import type { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
+import { createTriggerEvaluatorContext } from './test-utils';
+
+describe('InitializedTrigger', () => {
+  const create = (
+    trigger: TriggerOfType<'initialized'>,
+  ): {
+    initializedTrigger: InitializedTrigger;
+    stateManager: ConditionStateManager;
+    callback: Mock;
+  } => {
+    const stateManager = new ConditionStateManager();
+    const callback = vi.fn();
+    const initializedTrigger = new InitializedTrigger(
+      trigger,
+      createTriggerEvaluatorContext({ stateManager }),
+    );
+    return { initializedTrigger, stateManager, callback };
+  };
+
+  it('should trigger every time the card initializes', () => {
+    const { initializedTrigger, stateManager, callback } = create({
+      trigger: 'initialized',
+      ever: false,
+    });
+    initializedTrigger.subscribe(callback);
+
+    stateManager.setState({ initialized: true });
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith({ platform: 'acc', type: 'initialized' });
+
+    // The card goes down, as it does when taken off the page, and comes back.
+    stateManager.setState({ initialized: false });
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    stateManager.setState({ initialized: true });
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+
+  it('should trigger only on the first time the card initializes when ever', () => {
+    const { initializedTrigger, stateManager, callback } = create({
+      trigger: 'initialized',
+      ever: true,
+    });
+    initializedTrigger.subscribe(callback);
+
+    stateManager.setState({ initialized: true, everInitialized: true });
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    stateManager.setState({ initialized: false });
+    stateManager.setState({ initialized: true, everInitialized: true });
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it('should stop triggering after destroy', () => {
+    const { initializedTrigger, stateManager, callback } = create({
+      trigger: 'initialized',
+      ever: false,
+    });
+    initializedTrigger.subscribe(callback);
+    initializedTrigger.destroy();
+
+    stateManager.setState({ initialized: true });
+    expect(callback).not.toHaveBeenCalled();
+  });
+});