@vived/component-abb-controller 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to `@vived/component-abb-controller` will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] — Unreleased
+
+### Added
+
+- Initial scaffold of the **ABB Controller** VIVED smart component:
+  domain (Entity, Repo, UCs, PM, Adapter, Controllers, Factory), a
+  `AbbControllerFacade` implementing the `SmartComponent` contract, versioned
+  persisted state, a Babylon view implementing `SmartComponentView`, and a
+  per-scene asset cache.

package/COMPONENT_KNOWLEDGE.md

@@ -0,0 +1,198 @@
+# **ABB Controller** — VIVED Smart Component
+
+## Summary
+
+`@vived/component-abb-controller` provides **ABB Controller** behavior and 3D integration for slide applications. Use it when you need to create and control one or more **ABB Controller** instances in a Babylon.js scene. The package exposes setup helpers, view bindings, and typed APIs for state-driven interactions.
+
+- **Package**: `@vived/component-abb-controller`
+- **Version**: `0.1.0`
+- **GitHub**: `vivedlearning/component-abb-controller`
+
+## Discovery
+
+- **Category**: `TODO: Domain / Subdomain`
+- **Tags**: `TODO: add at least 5 tags with synonyms`
+- **Visual Description**: `TODO: describe color, shape, size, and notable features`
+- **Multi-instance**: `Yes`
+
+## Quick Start
+
+1. **Install package and peers**
+
+```bash
+npm install @vived/component-abb-controller @vived/core @vived/app @babylonjs/core @babylonjs/loaders
+```
+
+2. **Register the feature factory**
+
+```typescript
+import { makeAppObjectRepo, makeDomainFactoryRepo } from "@vived/core";
+import { makeAbbControllerFeatureFactory } from "@vived/component-abb-controller";
+
+const appObjects = makeAppObjectRepo();
+const factoryRepo = makeDomainFactoryRepo(appObjects);
+
+makeAbbControllerFeatureFactory(appObjects);
+factoryRepo.setupDomain();
+```
+
+3. **Create the facade and load its view**
+
+```typescript
+import { AbbControllerFacade } from "@vived/component-abb-controller";
+
+const facade = new AbbControllerFacade("my-instance-1", appObjects); // sync, no Babylon
+await facade.load(); // attaches the Babylon view
+```
+
+4. **Drive it and observe the view model**
+
+```typescript
+const unsubscribe = facade.onViewModel((vm) => {
+  console.log(vm); // { isActive: boolean }
+});
+
+facade.toggleActive();
+
+// Persist / restore
+const state = facade.getState();
+facade.applyState(state);
+```
+
+See `docs/host-integration.md` for wiring the component into a host scene (placing the
+model, shadows, picking, and host-owned highlight/selection presentation).
+
+## API Reference
+
+### Primary API — the facade
+
+- `new AbbControllerFacade(id: string, appObjects: AppObjectRepo)` — wire the domain
+  instance synchronously (no Babylon).
+- `load(variant?: string): Promise<void>` — load and attach the Babylon view.
+- `onViewModel(cb: (vm: AbbControllerVM) => void): () => void` — subscribe to VM updates.
+- `onEvent(event, cb): () => void` — subscribe to a typed event (`AbbControllerEventKeys`).
+- `getState(): AbbControllerState` / `applyState(state): void` — versioned persisted state.
+- `destroy(): void` — dispose the instance.
+
+### Advanced / host-integration API
+
+- `makeAbbControllerFeatureFactory(appObjects)` — register the feature (required once).
+- `AbbControllerBabylonView.get(appObject)` — the `SmartComponentView` seam
+  (`rootTransformNode`, `nodesByObjectId`, `shadowCasters`, `highlightGroupsByObjectId`).
+- Flat controllers (`createAbbController`, `toggleActive`, `get/applyAbbControllerState`,
+  `onActivated`, `onDeactivated`) and `abbControllerPMAdapter` for observer-driven use.
+
+### Public Types
+
+```typescript
+interface AbbControllerVM {
+  isActive: boolean;
+}
+
+type AbbControllerState = {
+  version: number;
+  isActive: boolean;
+};
+```
+
+## 3D View
+
+### Asset Manifest
+
+| Name    | Asset ID        | File                     |
+| ------- | --------------- | ------------------------ |
+| default | `TODO_ASSET_ID` | `AbbController.glb` |
+
+### Exposed Transform Nodes
+
+- `TODO_NODE_1`
+- `TODO_NODE_2`
+
+## Recipes
+
+### Recipe 1: Create and Toggle an Instance
+
+```typescript
+import { AbbControllerFacade } from "@vived/component-abb-controller";
+
+const facade = new AbbControllerFacade("machine-1", appObjects);
+await facade.load();
+
+facade.toggleActive();
+```
+
+### Recipe 2: Observe the View Model for UI
+
+```typescript
+import type { AbbControllerVM } from "@vived/component-abb-controller";
+
+const unsubscribe = facade.onViewModel((vm: AbbControllerVM) => {
+  console.log("isActive", vm.isActive);
+});
+```
+
+### Recipe 3: Persist and Restore State
+
+```typescript
+const snapshot = facade.getState(); // { version, isActive }
+
+// ...later / after reload...
+facade.applyState(snapshot); // best-effort: absent fields default, no throw on version drift
+```
+
+### Recipe 4: React to a Typed Event
+
+```typescript
+import { AbbControllerEventKeys } from "@vived/component-abb-controller";
+
+const off = facade.onEvent(AbbControllerEventKeys.activated, () => {
+  console.log("activated");
+});
+```
+
+## Constraints & Defaults
+
+- Default VM: `{ isActive: false }`; default state: `{ version, isActive: false }`.
+- The facade constructor is synchronous and Babylon-free; call `await load()` before the
+  component renders in a scene.
+- `applyState` is best-effort: it applies present fields, defaults absent ones, and never throws
+  on version mismatch.
+- `@vived/app` must be provided by the host (peer dependency) so asset loading resolves against
+  the host's shared asset system.
+
+## Repository
+
+| Field          | Value                                        |
+| -------------- | -------------------------------------------- |
+| Package        | `@vived/component-abb-controller`        |
+| GitHub         | `vivedlearning/component-abb-controller` |
+| Version        | `0.1.0`                                      |
+| Multi-instance | `Yes`                                        |
+
+## Full Export List
+
+Facade (primary surface):
+
+- `AbbControllerFacade`
+- `SmartComponent` (type)
+- `AbbControllerState` (type) / `ABB_CONTROLLER_STATE_VERSION`
+- `AbbControllerEvents` (type) / `AbbControllerEventKeys`
+
+Advanced / host-integration surface:
+
+- `AbbControllerEntity`, `makeAbbControllerEntity`
+- `AbbControllerRepo`, `makeAbbControllerRepo`, `AbbControllerEntityFactory`
+- `AbbControllerToggleActiveUC`, `makeAbbControllerToggleActiveUC`
+- `AbbControllerPM`, `makeAbbControllerPM`, `AbbControllerVM`
+- `abbControllerPMAdapter`
+- Controllers: `createAbbController`, `toggleActive`, `onActivated`, `onDeactivated`, `getAbbControllerState`, `applyAbbControllerState`
+- `AbbControllerFeatureFactory`, `makeAbbControllerFeatureFactory`
+- `AbbControllerBabylonView`, `makeAbbControllerBabylonView`, `SmartComponentView` (type)
+- `createBabylonAbbController`, `CreateBabylonAbbControllerOptions`
+- `getAbbControllerAssetContainer`, `clearAbbControllerAssetCache`
+- `MockAbbControllerPM`, `MockAbbControllerToggleActiveUC`
+- `componentConfig`
+
+---
+
+Maintainer note: internal architecture and contributor-focused implementation details belong in `COMPONENT_ARCHITECTURE.md`.

package/LICENSE

@@ -0,0 +1,15 @@
+Copyright © 2026 VIVED Learning. All rights reserved.
+
+This software and its associated documentation (the "Software") are the
+proprietary and confidential property of VIVED Learning. The Software is
+intended for internal use with VIVED Learning's player and infrastructure only.
+
+No license, right, or permission is granted to any party to use, copy, modify,
+merge, publish, distribute, sublicense, or sell the Software, in whole or in
+part, except as expressly authorized in writing by VIVED Learning. Publication
+of this package to a public registry does not constitute such authorization or
+grant any license to it.
+
+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.

package/dist/AbbControllerEvents.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Typed event catalog for ABB Controller.
+ *
+ * All events are payload-free — the host reads current state off `getState()` /
+ * `onViewModel()`, never off the event itself (per canon, pending
+ * vivian-knowledge#62). Each key has a matching subscribe-controller in
+ * `Domain/Controllers/` (`onPoweredOn`, `onPoweredOff`, etc.) wired into the
+ * facade's `onEvent` dispatch map.
+ */
+export type AbbControllerEvents = {
+    /** A power-on attempt succeeded. */
+    poweredOn: () => void;
+    /** A power-off attempt succeeded (always succeeds). */
+    poweredOff: () => void;
+    /** A power-on attempt was refused because the controller is locked out. */
+    powerOnBlockedByLockout: () => void;
+    /** A lockout attempt succeeded. */
+    lockoutEngaged: () => void;
+    /** An unlock attempt succeeded (always succeeds). */
+    lockoutDisengaged: () => void;
+    /** A lockout attempt was refused because the controller is powered on. */
+    lockoutBlockedByPower: () => void;
+    /** A voltage check was performed. */
+    voltageChecked: () => void;
+    /** The whole-controller hitbox was clicked/selected. */
+    selected: () => void;
+};
+/**
+ * Exported event keys, so a host maps the facade's events without re-typing
+ * string literals. Keep in sync with `AbbControllerEvents`.
+ */
+export declare const AbbControllerEventKeys: {
+    readonly poweredOn: "poweredOn";
+    readonly poweredOff: "poweredOff";
+    readonly powerOnBlockedByLockout: "powerOnBlockedByLockout";
+    readonly lockoutEngaged: "lockoutEngaged";
+    readonly lockoutDisengaged: "lockoutDisengaged";
+    readonly lockoutBlockedByPower: "lockoutBlockedByPower";
+    readonly voltageChecked: "voltageChecked";
+    readonly selected: "selected";
+};
+//# sourceMappingURL=AbbControllerEvents.d.ts.map

package/dist/AbbControllerEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbbControllerEvents.d.ts","sourceRoot":"","sources":["../src/AbbControllerEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,oCAAoC;IACpC,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,uDAAuD;IACvD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,2EAA2E;IAC3E,uBAAuB,EAAE,MAAM,IAAI,CAAC;IACpC,mCAAmC;IACnC,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,qDAAqD;IACrD,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,0EAA0E;IAC1E,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,qCAAqC;IACrC,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;CAS2B,CAAC"}

package/dist/AbbControllerFacade.d.ts

@@ -0,0 +1,80 @@
+import { AppObjectRepo } from "@vived/core";
+import type { AbbControllerVM } from "./Domain/PMs/AbbControllerPM";
+import type { SmartComponent } from "./SmartComponent";
+import type { AbbControllerEvents } from "./AbbControllerEvents";
+import { AbbControllerState } from "./AbbControllerState";
+/**
+ * AbbControllerFacade
+ *
+ * Host-facing facade for the ABB Controller smart component. It is the
+ * primary public surface: a host holds a component behind the `SmartComponent`
+ * structural contract and drives it entirely through this class. Internally it is
+ * pure composition — every method delegates to a flat controller.
+ *
+ * Two-phase lifecycle:
+ *  1. **construct** (sync, Babylon-free) — wires the domain via `createAbbController`.
+ *  2. **load** (async) — dynamically imports the Babylon view and attaches it, so
+ *     constructing the facade pulls in zero Babylon and stays node-testable.
+ *
+ * This class references NO Babylon type — the framework-bound view surface is the
+ * separate `SmartComponentView` contract, obtained by the host through the Babylon
+ * layer, never through the facade.
+ */
+export declare class AbbControllerFacade implements SmartComponent {
+    readonly id: string;
+    readonly interfaceVersion = 1;
+    private appObjects;
+    /**
+     * Dispatch map: event key → subscribe controller.
+     * Each controller has signature `(id, appObjects, cb: () => void) => () => void`.
+     */
+    private eventDispatchMap;
+    /**
+     * Synchronously wire the domain instance (entity, UCs, PM, adapter).
+     * Does NOT touch Babylon.
+     */
+    constructor(id: string, appObjects: AppObjectRepo);
+    /**
+     * Asynchronously load and attach the Babylon view. Required before the
+     * component renders in a 3D scene.
+     *
+     * @param variant - Optional asset variant. No variants are implemented in the
+     *   starter, so an omitted or unrecognized variant loads the default asset
+     *   (best-effort, per Contract v1).
+     */
+    load(variant?: string): Promise<void>;
+    /** Tear down the component and release all resources. */
+    destroy(): void;
+    /** Toggle the power state of the component. Returns true if successful. */
+    togglePower(): boolean;
+    /** Power on. Returns true if successful, false if refused (locked out). */
+    powerOn(): boolean;
+    /** Power off. Always succeeds. */
+    powerOff(): boolean;
+    /** Toggle the lockout state. Returns true if successful. */
+    toggleLockout(): boolean;
+    /** Engage the lockout. Returns true if successful, false if refused (powered on). */
+    lockOut(): boolean;
+    /** Disengage the lockout. Always succeeds. */
+    unlock(): boolean;
+    /** Check the controller's voltage. Notifies subscribers of the check. */
+    checkVoltage(): void;
+    /** Show or hide the always-visible ghost lock hint (training mode). */
+    setShowGhostLockHint(show: boolean): void;
+    /** Enable the whole-controller hitbox for single-target selection. */
+    enableHitbox(): void;
+    /** Disable the whole-controller hitbox, restoring sub-component interactivity. */
+    disableHitbox(): void;
+    getState(): AbbControllerState;
+    applyState(state: AbbControllerState): void;
+    /**
+     * Subscribe to a typed event. Returns an unsubscribe function.
+     */
+    onEvent<K extends keyof AbbControllerEvents>(event: K, cb: AbbControllerEvents[K]): () => void;
+    /**
+     * Subscribe to the reactive view model. Emits the current VM immediately,
+     * then on every change. Returns an unsubscribe function.
+     */
+    onViewModel(cb: (vm: AbbControllerVM) => void): () => void;
+}
+//# sourceMappingURL=AbbControllerFacade.d.ts.map

package/dist/AbbControllerFacade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbbControllerFacade.d.ts","sourceRoot":"","sources":["../src/AbbControllerFacade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAuB5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EACL,kBAAkB,EAEnB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,mBAAoB,YAAW,cAAc;IACxD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,gBAAgB,KAAK;IAC9B,OAAO,CAAC,UAAU,CAAgB;IAElC;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAYtB;IAEF;;;OAGG;gBACS,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa;IAMjD;;;;;;;OAOG;IAEG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW3C,yDAAyD;IACzD,OAAO,IAAI,IAAI;IAIf,2EAA2E;IAC3E,WAAW,IAAI,OAAO;IAItB,2EAA2E;IAC3E,OAAO,IAAI,OAAO;IAIlB,kCAAkC;IAClC,QAAQ,IAAI,OAAO;IAInB,4DAA4D;IAC5D,aAAa,IAAI,OAAO;IAIxB,qFAAqF;IACrF,OAAO,IAAI,OAAO;IAIlB,8CAA8C;IAC9C,MAAM,IAAI,OAAO;IAIjB,yEAAyE;IACzE,YAAY,IAAI,IAAI;IAIpB,uEAAuE;IACvE,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAIzC,sEAAsE;IACtE,YAAY,IAAI,IAAI;IAIpB,kFAAkF;IAClF,aAAa,IAAI,IAAI;IAIrB,QAAQ,IAAI,kBAAkB;IAQ9B,UAAU,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAI3C;;OAEG;IACH,OAAO,CAAC,CAAC,SAAS,MAAM,mBAAmB,EACzC,KAAK,EAAE,CAAC,EACR,EAAE,EAAE,mBAAmB,CAAC,CAAC,CAAC,GACzB,MAAM,IAAI;IAKb;;;OAGG;IACH,WAAW,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,eAAe,KAAK,IAAI,GAAG,MAAM,IAAI;CAK3D"}

package/dist/AbbControllerState.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Versioned persisted state for ABB Controller.
+ *
+ * `powerOnVoltage` is deliberately excluded — it is an internal entity detail
+ * with no facade command to change it, so it is never part of the persisted
+ * snapshot.
+ *
+ * `applyState` restores `isPoweredOn` / `isLockedOut` through the entity's
+ * interlocked try-ops (never a raw setter), best-effort and forward-compatible:
+ * absent fields fall back to defaults, an unrecognized `version` is tolerated
+ * (never throws), and a snapshot claiming both powered-on and locked-out is
+ * rejected wholesale for that pair, leaving the entity's power/lockout state
+ * untouched. See `Domain/Controllers/applyAbbControllerState.ts`.
+ */
+export declare const ABB_CONTROLLER_STATE_VERSION = 1;
+export type AbbControllerState = {
+    /** Schema version; stamped by getState, tolerated by applyState. */
+    version: number;
+    /** Whether the controller is currently powered on. */
+    isPoweredOn: boolean;
+    /** Whether the controller is currently locked out. */
+    isLockedOut: boolean;
+    /** Whether the ghost lock hint is always shown (training mode). */
+    isShowingGhostLockHint: boolean;
+    /** Whether the whole-controller hitbox is enabled for selection. */
+    isHitboxEnabled: boolean;
+};
+//# sourceMappingURL=AbbControllerState.d.ts.map

package/dist/AbbControllerState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbbControllerState.d.ts","sourceRoot":"","sources":["../src/AbbControllerState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAE9C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,WAAW,EAAE,OAAO,CAAC;IACrB,sDAAsD;IACtD,WAAW,EAAE,OAAO,CAAC;IACrB,mEAAmE;IACnE,sBAAsB,EAAE,OAAO,CAAC;IAChC,oEAAoE;IACpE,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC"}

package/dist/Domain/Adapters/abbControllerPMAdapter.d.ts

@@ -0,0 +1,10 @@
+import { type PmAdapter } from "@vived/core";
+import { type AbbControllerVM } from "../PMs/AbbControllerPM";
+/**
+ * PM Adapter for ABB Controller
+ *
+ * Connects UI views to the AbbControllerPM. Use this adapter in
+ * React components or Babylon views to subscribe to VM updates.
+ */
+export declare const abbControllerPMAdapter: PmAdapter<AbbControllerVM>;
+//# sourceMappingURL=abbControllerPMAdapter.d.ts.map

package/dist/Domain/Adapters/abbControllerPMAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abbControllerPMAdapter.d.ts","sourceRoot":"","sources":["../../../src/Domain/Adapters/abbControllerPMAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,wBAAwB,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,CAAC,eAAe,CAyC3D,CAAC"}

package/dist/Domain/Controllers/abbControllerHitboxClicked.d.ts

@@ -0,0 +1,8 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Framework boundary controller — called by the Babylon HitboxView when the
+ * `abb_controller_hitbox` mesh is picked. Notifies domain subscribers that
+ * the controller was selected.
+ */
+export declare function abbControllerHitboxClicked(id: string, appObjects: AppObjectRepo): void;
+//# sourceMappingURL=abbControllerHitboxClicked.d.ts.map

package/dist/Domain/Controllers/abbControllerHitboxClicked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abbControllerHitboxClicked.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/abbControllerHitboxClicked.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,GACxB,IAAI,CAYN"}

package/dist/Domain/Controllers/abbControllerStateDefaults.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Default field values used to fill absent keys during best-effort state restore.
+ * Keep these in sync with the fields on `AbbControllerState` (minus `version`).
+ */
+export declare const ABB_CONTROLLER_DEFAULT_STATE_FIELDS: {
+    readonly isPoweredOn: false;
+    readonly isLockedOut: false;
+    readonly isShowingGhostLockHint: false;
+    readonly isHitboxEnabled: false;
+};
+//# sourceMappingURL=abbControllerStateDefaults.d.ts.map

package/dist/Domain/Controllers/abbControllerStateDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abbControllerStateDefaults.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/abbControllerStateDefaults.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,mCAAmC;;;;;CAKtC,CAAC"}

package/dist/Domain/Controllers/applyAbbControllerState.d.ts

@@ -0,0 +1,24 @@
+import { AppObjectRepo } from "@vived/core";
+import type { AbbControllerState } from "../../AbbControllerState";
+/**
+ * Controller: apply a persisted state to an instance, best-effort.
+ *
+ * Never throws: an absent field falls back to its default, and an
+ * unrecognized `version` is tolerated (the shape is applied field-by-field,
+ * not gated on version).
+ *
+ * Drives the interlocked entity through its try-ops only (never a raw
+ * setter), in the order that lets each of the three valid target
+ * combinations succeed:
+ *  - off + unlocked → `tryPowerOff()` then `tryUnlock()`
+ *  - off + locked   → `tryPowerOff()` then `tryLockOut()`
+ *  - on  + unlocked → `tryUnlock()` then `tryPowerOn()`
+ *  - on  + locked   → invalid combination (violates the interlock); the
+ *    power/lockout portion is rejected wholesale and the entity's power/lockout
+ *    state is left untouched.
+ *
+ * The ghost-lock-hint and hitbox flags are not interlocked, so they always
+ * apply directly regardless of the power/lockout branch above.
+ */
+export declare function applyAbbControllerState(id: string, appObjects: AppObjectRepo, state: Partial<AbbControllerState>): void;
+//# sourceMappingURL=applyAbbControllerState.d.ts.map

package/dist/Domain/Controllers/applyAbbControllerState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyAbbControllerState.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/applyAbbControllerState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,KAAK,EAAE,OAAO,CAAC,kBAAkB,CAAC,GACjC,IAAI,CAwCN"}

package/dist/Domain/Controllers/checkVoltage.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Controller to check the voltage of an ABB Controller instance.
+ * Resolves the per-instance UC and delegates to it.
+ */
+export declare function checkVoltage(id: string, appObjects: AppObjectRepo): void;
+//# sourceMappingURL=checkVoltage.d.ts.map

package/dist/Domain/Controllers/checkVoltage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkVoltage.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/checkVoltage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,GAAG,IAAI,CAYxE"}

package/dist/Domain/Controllers/createAbbController.d.ts

@@ -0,0 +1,12 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Controller to create a new ABB Controller instance.
+ * Resolves the singleton AbbControllerRepo and delegates to its
+ * createAbbControllerEntity method.
+ *
+ * @param id - The ID for the new instance.
+ * @param appObjects - The AppObject repository.
+ * @returns The created AppObject, or undefined if the repo is not found.
+ */
+export declare function createAbbController(id: string, appObjects: AppObjectRepo): import("@vived/core").AppObject | undefined;
+//# sourceMappingURL=createAbbController.d.ts.map

package/dist/Domain/Controllers/createAbbController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAbbController.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/createAbbController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,+CAc1B"}

package/dist/Domain/Controllers/disableHitbox.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Disables the whole-controller hitbox on the given controller, restoring
+ * sub-component interactions (knob, lock, ghost lock) in the view.
+ */
+export declare function disableHitbox(id: string, appObjects: AppObjectRepo): void;
+//# sourceMappingURL=disableHitbox.d.ts.map

package/dist/Domain/Controllers/disableHitbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disableHitbox.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/disableHitbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,GAAG,IAAI,CAYzE"}

package/dist/Domain/Controllers/enableHitbox.d.ts

@@ -0,0 +1,6 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Enables the whole-controller hitbox for selection on the given controller.
+ */
+export declare function enableHitbox(id: string, appObjects: AppObjectRepo): void;
+//# sourceMappingURL=enableHitbox.d.ts.map

package/dist/Domain/Controllers/enableHitbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enableHitbox.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/enableHitbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;GAEG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,GAAG,IAAI,CAYxE"}

package/dist/Domain/Controllers/getAbbControllerState.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "@vived/core";
+import type { AbbControllerState } from "../../AbbControllerState";
+/**
+ * Controller: read the versioned persisted state for an instance.
+ */
+export declare function getAbbControllerState(id: string, appObjects: AppObjectRepo, version: number): AbbControllerState;
+//# sourceMappingURL=getAbbControllerState.d.ts.map

package/dist/Domain/Controllers/getAbbControllerState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAbbControllerState.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/getAbbControllerState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,OAAO,EAAE,MAAM,GACd,kBAAkB,CAqBpB"}

package/dist/Domain/Controllers/onAbbControllerSelected.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Subscribes to controller-selected events on the given controller.
+ * Returns an unsubscribe function.
+ */
+export declare function onAbbControllerSelected(id: string, appObjects: AppObjectRepo, callback: () => void): () => void;
+//# sourceMappingURL=onAbbControllerSelected.d.ts.map

package/dist/Domain/Controllers/onAbbControllerSelected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onAbbControllerSelected.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/onAbbControllerSelected.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CAYZ"}

package/dist/Domain/Controllers/onLockoutBlockedByPower.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Subscribes to lockout attempts blocked by power on the given controller.
+ * Returns an unsubscribe function.
+ */
+export declare function onLockoutBlockedByPower(id: string, appObjects: AppObjectRepo, callback: () => void): () => void;
+//# sourceMappingURL=onLockoutBlockedByPower.d.ts.map

package/dist/Domain/Controllers/onLockoutBlockedByPower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onLockoutBlockedByPower.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/onLockoutBlockedByPower.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CAYZ"}

package/dist/Domain/Controllers/onLockoutDisengaged.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Subscribes to successful lockout-disengaged transitions on the given
+ * controller. Returns an unsubscribe function.
+ */
+export declare function onLockoutDisengaged(id: string, appObjects: AppObjectRepo, callback: () => void): () => void;
+//# sourceMappingURL=onLockoutDisengaged.d.ts.map

package/dist/Domain/Controllers/onLockoutDisengaged.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onLockoutDisengaged.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/onLockoutDisengaged.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CAYZ"}

package/dist/Domain/Controllers/onLockoutEngaged.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Subscribes to successful lockout-engaged transitions on the given
+ * controller. Returns an unsubscribe function.
+ */
+export declare function onLockoutEngaged(id: string, appObjects: AppObjectRepo, callback: () => void): () => void;
+//# sourceMappingURL=onLockoutEngaged.d.ts.map

package/dist/Domain/Controllers/onLockoutEngaged.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onLockoutEngaged.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/onLockoutEngaged.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CAYZ"}

package/dist/Domain/Controllers/onPowerOnBlockedByLockout.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Subscribes to power-on attempts blocked by lockout on the given controller.
+ * Returns an unsubscribe function.
+ */
+export declare function onPowerOnBlockedByLockout(id: string, appObjects: AppObjectRepo, callback: () => void): () => void;
+//# sourceMappingURL=onPowerOnBlockedByLockout.d.ts.map

package/dist/Domain/Controllers/onPowerOnBlockedByLockout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPowerOnBlockedByLockout.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/onPowerOnBlockedByLockout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CAYZ"}

package/dist/Domain/Controllers/onPoweredOff.d.ts

@@ -0,0 +1,11 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Subscribes to successful power-off transitions on the given controller.
+ * Returns an unsubscribe function.
+ *
+ * NOTE: placeholder subscribe-controller (renamed from the scaffold's
+ * `onDeactivated`) so the facade compiles against the real, ported
+ * `AbbControllerPowerUC`. The next slice wires the full 8-event catalog.
+ */
+export declare function onPoweredOff(id: string, appObjects: AppObjectRepo, callback: () => void): () => void;
+//# sourceMappingURL=onPoweredOff.d.ts.map

package/dist/Domain/Controllers/onPoweredOff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPoweredOff.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/onPoweredOff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CAYZ"}

package/dist/Domain/Controllers/onPoweredOn.d.ts

@@ -0,0 +1,11 @@
+import { AppObjectRepo } from "@vived/core";
+/**
+ * Subscribes to successful power-on transitions on the given controller.
+ * Returns an unsubscribe function.
+ *
+ * NOTE: placeholder subscribe-controller (renamed from the scaffold's
+ * `onActivated`) so the facade compiles against the real, ported
+ * `AbbControllerPowerUC`. The next slice wires the full 8-event catalog.
+ */
+export declare function onPoweredOn(id: string, appObjects: AppObjectRepo, callback: () => void): () => void;
+//# sourceMappingURL=onPoweredOn.d.ts.map

package/dist/Domain/Controllers/onPoweredOn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPoweredOn.d.ts","sourceRoot":"","sources":["../../../src/Domain/Controllers/onPoweredOn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CAYZ"}