@sdux-vault/devtools 0.0.7

package/LICENSE

@@ -0,0 +1,249 @@
+# MIT License
+
+(with SDuX Clarification Notice)
+
+---
+
+## MIT License (Standard Text)
+
+Copyright (c) 2026 NextGen Luminary
+
+Permission is hereby granted, free of charge, to any person obtaining a copy  
+of this software and associated documentation files (the “Software”), to deal  
+in the Software without restriction, including without limitation the rights  
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+copies of the Software, and to permit persons to whom the Software is  
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all  
+copies or substantial portions of the Software.
+
+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  
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE  
+SOFTWARE.
+
+---
+
+## SDuX Clarification Notice (Non-License Commentary)
+
+**IMPORTANT:**  
+The following sections are **clarifying notices** provided for transparency, auditability, ecosystem boundary clarity, acquisition readiness, and architectural separation within the SDuX ecosystem. They **do not modify, amend, replace, restrict, supersede, or reinterpret** the MIT License above.
+
+If any conflict is perceived between this clarification notice and the MIT License text above, the MIT License text **controls in all cases**.
+
+The MIT License text above applies **only** to the specific SDuX repositories and npm packages explicitly designated as open source by NextGen Luminary.
+
+---
+
+## 1. Scope of This License
+
+This MIT License applies exclusively to the following SDuX components:
+
+### SDuX Framework Source
+
+- @sdux-vault/core
+- @sdux-vault/add-ons
+- @sdux-vault/shared
+- @sdux-vault/devtools/tooling
+- @sdux-vault/devtools/ui
+- @sdux-vault/ui/web-components
+
+### SDuX Open-Source npm Packages
+
+- Identical package names as listed above when distributed via npm
+
+No other SDuX components are licensed under the MIT License unless explicitly stated in writing by NextGen Luminary.
+
+The MIT License does **not** apply to any repository, package, module, runtime, binary, service, distribution artifact, hosted system, entitlement service, or enforcement subsystem that is not expressly designated as MIT-licensed.
+
+---
+
+## 2. Explicit Exclusion of Proprietary Components
+
+For the avoidance of doubt:
+
+This MIT License **does not apply** to:
+
+- @sdux-vault/engine
+- SDuX Vault runtime components
+- Persistence modules
+- Encryption modules
+- Licensing enforcement modules
+- Telemetry systems
+- Commercial-only features
+- Runtime gating mechanisms
+- Deterministic license validation infrastructure
+- Any proprietary binaries, services, network services, entitlement servers, or internal source code
+
+Use of proprietary SDuX components is governed exclusively by their applicable commercial or community licenses.
+
+No rights—express or implied—are granted to proprietary components by virtue of this MIT License.
+
+In particular, this MIT License does **not** grant rights to:
+
+- Proprietary runtime enforcement systems
+- Deterministic gating or validation logic
+- License timeout mechanisms
+- Runtime license tokens
+- Production-gating systems
+- Commercial entitlement APIs
+- Proprietary network services or validation endpoints
+- Internal orchestration engines not explicitly released under MIT
+
+---
+
+## 3. No Transitive or Implied Licensing
+
+This MIT License:
+
+- Does **not** grant rights to dependencies that are not themselves MIT-licensed
+- Does **not** extend rights to runtime engines, orchestrators, execution layers, or enforcement systems
+- Does **not** create any obligation for NextGen Luminary to open-source additional components
+- Does **not** grant rights to use proprietary licensing APIs, enforcement surfaces, runtime validation endpoints, or commercial network services outside their intended licensed boundaries
+
+Each SDuX package is licensed independently and must be evaluated on its own terms.
+
+No transitive, derivative, architectural, structural, or implied licensing rights arise merely because MIT-licensed components may interoperate with proprietary components.
+
+Interoperability does not imply relicensing, source disclosure obligations, or any grant of rights to non-MIT components.
+
+---
+
+## 4. Use in Commercial and Enterprise Environments
+
+The MIT-licensed SDuX framework components:
+
+- May be used in commercial, enterprise, and production environments
+- May be modified and redistributed in accordance with the MIT License
+- May be included in proprietary products, subject to MIT attribution requirements
+
+This permissive licensing is intentional and designed to:
+
+- Encourage adoption
+- Support long-term maintainability
+- Reduce legal friction during audits and acquisitions
+
+No additional enterprise license is required for the MIT-designated components themselves.
+
+---
+
+## 5. Separation From Third-Party Extensions
+
+Third-party extensions, add-ons, Behaviors, Controllers, integrations, or other modules developed by independent Vendors are **independently licensed**.
+
+This MIT License:
+
+- Does **not** apply to third-party extensions unless explicitly stated by their respective authors
+- Does **not** grant rights to any Vendor-developed Licensed Extension
+- Does **not** modify, override, validate, or enforce any Vendor commercial license
+
+MIT-licensed SDuX components may be used to build extensions.  
+However:
+
+- Any proprietary enforcement components used by such extensions remain separately licensed
+- Runtime gating systems remain governed by their applicable community or commercial licenses
+- Validation, entitlement, or enforcement behavior implemented outside MIT-designated repositories remains subject to its own governing license
+
+No open-source contamination, copyleft effect, reciprocal licensing obligation, or forced disclosure requirement is created by virtue of integrating MIT-licensed SDuX components with proprietary or third-party components.
+
+---
+
+## 6. No Grant of Rights to Commercial Services or APIs
+
+For clarity:
+
+This MIT License does **not** grant rights to:
+
+- Access proprietary commercial APIs
+- Access proprietary network services
+- Access entitlement servers
+- Access validation infrastructure
+- Access hosted SDuX services
+- Bypass production-gating or enforcement systems
+
+Any such rights, if available, are governed exclusively by their respective commercial or community licenses.
+
+---
+
+## 7. Trademark and Branding Clarification
+
+This MIT License does **not** grant any trademark rights in the names, logos, product branding, or service marks of NextGen Luminary or SDuX, except as required for reasonable and customary attribution consistent with the MIT License.
+
+Use of SDuX or NextGen Luminary trademarks in product names, marketplace listings, or marketing materials may require separate permission.
+
+Nothing in this clarification notice modifies the trademark rights (or lack thereof) under the MIT License; it is provided solely for clarity and avoidance of confusion.
+
+---
+
+## 8. Relationship to Other SDuX Licenses
+
+This MIT License operates independently from:
+
+- NGL Commercial License 1.0
+- SDuX / Vault Community License
+- Any enterprise or custom licensing agreements
+
+Possession or use of MIT-licensed SDuX components does **not** grant access to or rights under those other licenses.
+
+Likewise, possession of proprietary SDuX licenses does not alter the terms of the MIT License for designated open-source components.
+
+Each license operates independently and must be interpreted separately.
+
+---
+
+## 9. Assignment and Acquisition Clarity
+
+The MIT License is inherently **assignable** and **transferable**.
+
+Accordingly:
+
+- Use of MIT-licensed SDuX components **does not prevent acquisition**
+- No special approval is required to transfer ownership of products containing these components
+- Auditors and acquiring entities may rely on standard MIT interpretations without exception
+
+This aligns with industry-standard expectations for permissive open-source frameworks.
+
+---
+
+## 10. Audit and Due-Diligence Statement
+
+During security reviews, license audits, or acquisition due diligence:
+
+- MIT-licensed SDuX components should be reviewed as standard permissive open-source software
+- No copyleft, reciprocity, source disclosure, or distribution obligations apply beyond standard MIT attribution
+- No viral or contaminating license effects exist
+- No patent retaliation, field-of-use restrictions, sublicense limitations, or production-gating obligations exist beyond those inherent in MIT
+
+These characteristics are intentional and designed to be acquisition-safe and enterprise-friendly.
+
+---
+
+## 11. No Modification of License Terms
+
+Nothing in this clarification notice:
+
+- Modifies the MIT License text
+- Adds restrictions to the MIT License
+- Removes rights granted by the MIT License
+- Expands rights beyond those granted by the MIT License
+
+If any conflict is perceived between this clarification notice and the MIT License text above, the MIT License text **controls**.
+
+---
+
+## 12. Entire Notice
+
+This document consists of:
+
+1. The unmodified MIT License text
+2. A non-binding clarification notice for transparency, architectural boundary clarity, compliance certainty, and acquisition readiness
+
+Together, they provide a complete and accurate description of how MIT licensing is applied within the SDuX ecosystem.
+
+---
+
+**END OF MIT LICENSE (WITH SDUX CLARIFICATION NOTICE)**

package/README.md

@@ -0,0 +1,267 @@
+# @sdux-vault/devtools
+
+> Observability, debugging, and runtime inspection for the SDuX platform.
+
+`@sdux-vault/devtools-tooling` provides the developer-facing tooling layer for SDuX.  
+It enables deep insight into pipeline execution, controller decisions, and state transitions in real time.
+
+---
+
+## TL;DR
+
+For full documentation, guides, and API references:  
+https://www.sdux-vault.com
+
+---
+
+## Overview
+
+SDuX is built as a layered system:
+
+```plaintext
+shared → engine → core → core-extensions → apps
+           └─────────---------───────────→ devtools
+```
+
+- **apps** → end-user applications
+- **core** → behavior runtime + execution layer
+- **core-extensions** → framework integrations
+- **devtools** → debugging and inspection (this package)
+- **engine** → runtime engine and orchestration
+- **shared** → contracts, types, utilities
+
+---
+
+## What This Package Provides
+
+- Runtime instrumentation layer
+- Pipeline inspection tools
+- Controller decision tracing
+- State transition visualization hooks
+- DevTools integration bridge
+- Debug-safe monitoring utilities
+
+---
+
+## Key Characteristics
+
+- ✅ Non-invasive instrumentation
+- ✅ Dev-only execution (no production overhead)
+- ✅ Framework-agnostic
+- ✅ Real-time pipeline visibility
+- ✅ Deterministic and traceable execution insights
+
+---
+
+## Installation
+
+```bash
+npm install @sdux-vault/devtools-tooling
+```
+
+---
+
+## Usage
+
+### Basic Import
+
+```ts
+import '@sdux-vault/devtools-tooling';
+```
+
+This enables:
+
+- runtime instrumentation
+- DevTools communication
+- feature cell registration tracking
+
+---
+
+## Example: Dev Mode Integration
+
+```ts
+import { DevMode } from '@sdux-vault/shared';
+
+if (DevMode.active) {
+  // DevTools will automatically attach
+}
+```
+
+---
+
+## How It Works
+
+This package integrates with the SDuX runtime through:
+
+- VaultMonitor hooks
+- DecisionEngine events
+- Behavior + controller lifecycle signals
+
+It observes:
+
+- pipeline execution
+- controller outcomes
+- state mutations
+- error propagation
+
+All without mutating runtime behavior.
+
+---
+
+## Instrumentation Model
+
+### Passive Observation
+
+Devtools tooling:
+
+- does not alter execution
+- does not mutate state
+- does not introduce side effects in production
+
+---
+
+## Event Sources
+
+Instrumentation is driven by:
+
+- FeatureCell lifecycle events
+- Behavior execution stages
+- Controller decision flow
+- Orchestrator pipeline phases
+
+---
+
+## Traceability
+
+Each pipeline run is tracked via:
+
+```ts
+traceId: string;
+```
+
+This enables:
+
+- deterministic debugging
+- replayable execution flows
+- cross-layer correlation
+
+---
+
+## DevTools Integration
+
+This package acts as the bridge between runtime and DevTools UI.
+
+It enables:
+
+- feature cell inspection
+- timeline visualization
+- state diffing
+- controller decision tracing
+
+---
+
+## Environment Behavior
+
+Instrumentation is:
+
+- ✅ Enabled in DevMode
+- 🚫 No-op in production
+- ✅ Safe for SSR and browser environments
+
+---
+
+## Side Effects
+
+This package performs controlled, dev-only side effects:
+
+```ts
+import '@sdux-vault/devtools-tooling';
+```
+
+Triggers:
+
+- DevTools registration
+- runtime instrumentation wiring
+
+Behavior:
+
+- no-op in production
+- idempotent
+- safe across all runtimes
+
+---
+
+## Development
+
+### Build
+
+```bash
+npm run build:devtools-tooling
+```
+
+Output:
+
+```
+dist/devtools/tooling
+```
+
+---
+
+## Test
+
+```bash
+npm run test:devtools-tooling
+```
+
+---
+
+## Verify
+
+```bash
+npm run verify
+```
+
+Includes:
+
+- linting
+- formatting
+- type checking
+- tests
+
+---
+
+## Publishing
+
+See `RELEASE.md` for full publishing instructions.
+
+---
+
+## Ecosystem
+
+- `@sdux-vault/addons` — optional, composable extensions for runtime behavior ([README](../addons/README.md))
+- `@sdux-vault/core` — execution engine for pipelines and state orchestration ([README](../core/README.md))
+- `@sdux-vault/core-extensions/angular` — Angular integration layer (signals, DI, reactive bindings) ([README](../core-extensions/angular/README.md))
+- `@sdux-vault/engine` — orchestration, conductor, decision engine
+- `@sdux-vault/shared` — contracts, types, utilities([README](../shared/README.md))
+
+---
+
+## Tree Shaking & Side Effects
+
+This package includes intentional side effects for:
+
+- runtime instrumentation
+- DevTools registration
+
+These are required for debugging capabilities.
+
+As a result, the bundle is marked as side-effectful.
+
+---
+
+## License
+
+For full licensing details:  
+https://www.sdux-vault.com/docs/welcome/license#license-texts
+
+MIT © SDuX Vault

package/fesm2022/sdux-vault-devtools.mjs

@@ -0,0 +1,99 @@
+import { registerVersion, DevMode } from '@sdux-vault/shared';
+import { Subject } from 'rxjs';
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > dev-tools > tooling > src > lib > version > version.register.ts
+// Updated: 2026-03-03 07:56
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const SDUX_PACKAGE = '@sdux-vault/devtools';
+const SDUX_VERSION = '0.0.7';
+registerVersion(SDUX_PACKAGE, SDUX_VERSION);
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > dev-tools > tooling > src > lib > interfaces > event-bus.contract.ts
+// Updated: 2026-03-04 08:11
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > dev-tools > tooling > src > lib > utils > event-bus.ts
+// Updated: 2026-03-02 19:26
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+/**
+ * Holds the singleton EventBus instance used for global event dispatch.
+ */
+let instance = null;
+/**
+ * Returns the global EventBus singleton used to emit and observe DevTools events.
+ * This function ensures a single EventBus instance is created and reused for the application lifecycle.
+ *
+ * --RelatedStart--
+ * EventBusInterface
+ * --RelatedEnd--
+ *
+ * @returns The global EventBus instance.
+ */
+function EventBus() {
+    if (!instance) {
+        instance = new EventBusInstance();
+    }
+    return instance;
+}
+/**
+ * Implements the EventBusInterface by managing pipeline and queue event streams.
+ * This class provides gated event emission based on development mode and exposes observable streams for subscribers.
+ * It is instantiated once and registered globally to support DevTools integration.
+ */
+class EventBusInstance {
+    /**
+     * Subject used to emit pipeline events to subscribers.
+     */
+    #pipeline$ = new Subject();
+    /**
+     * Creates a new EventBus instance and exposes it on the global object for DevTools access.
+     */
+    constructor() {
+        window.sdux ??= {};
+        window.sdux.vaultEventBus = this;
+    }
+    /**
+     * Emits a pipeline event to subscribed observers when development mode is active.
+     *
+     * @param event Pipeline event instance to emit.
+     */
+    nextPipeline(event) {
+        if (DevMode.active && event) {
+            this.#pipeline$.next(event);
+        }
+    }
+    /**
+     * Provides an observable stream of emitted pipeline events.
+     *
+     * @returns Observable stream of pipeline events.
+     */
+    pipeline$() {
+        return this.#pipeline$.asObservable();
+    }
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > devtools > tooling > src > public-api.ts
+// Updated: 2026-03-28 11:45
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+/**
+ * This is for version support in dev mode and tracking in the devtools
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { EventBus };
+//# sourceMappingURL=sdux-vault-devtools.mjs.map

package/fesm2022/sdux-vault-devtools.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdux-vault-devtools.mjs","sources":["../../../../libs/devtools/tooling/src/lib/version/version.register.ts","../../../../libs/devtools/tooling/src/lib/interfaces/event-bus.contract.ts","../../../../libs/devtools/tooling/src/lib/utils/event-bus.ts","../../../../libs/devtools/tooling/src/public-api.ts","../../../../libs/devtools/tooling/src/sdux-vault-devtools.ts"],"sourcesContent":["// --- AI Model File Path (DO NOT DELETE) ---\n// FilePath: libs > dev-tools > tooling > src > lib > version > version.register.ts\n// Updated: 2026-03-03 07:56\n//\t Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or\n//\t cmd+alt+j (see .vscode/keybindings.json)\n// --- END AI MODEL FILE PATH ---\n\nimport { registerVersion } from '@sdux-vault/shared';\n\nconst SDUX_PACKAGE = '@sdux-vault/devtools';\nconst SDUX_VERSION = '0.0.7';\n\nregisterVersion(SDUX_PACKAGE, SDUX_VERSION);\n","// --- AI Model File Path (DO NOT DELETE) ---\n// FilePath: libs > dev-tools > tooling > src > lib > interfaces > event-bus.contract.ts\n// Updated: 2026-03-04 08:11\n//\t Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or\n//\t cmd+alt+j (see .vscode/keybindings.json)\n// --- END AI MODEL FILE PATH ---\n\nimport { EventShape } from '@sdux-vault/shared';\nimport { Observable } from 'rxjs';\n\n/**\n * Defines the contract for an event bus responsible for emitting and observing pipeline and queue events.\n * This interface provides methods for publishing events and subscribing to their corresponding event streams.\n *\n * --RelatedStart--\n * EventShape\n * EventQueueShape\n * --RelatedEnd--\n */\nexport interface EventBusContract {\n  /**\n   * Emits a pipeline event to all subscribed observers.\n   *\n   * @param event Pipeline event instance to be dispatched.\n   */\n  nextPipeline(event: EventShape): void;\n\n  /**\n   * Provides an observable stream of emitted pipeline events.\n   *\n   * @returns Observable stream of pipeline events.\n   */\n  pipeline$(): Observable<EventShape>;\n}\n","// --- AI Model File Path (DO NOT DELETE) ---\n// FilePath: libs > dev-tools > tooling > src > lib > utils > event-bus.ts\n// Updated: 2026-03-02 19:26\n//\t Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or\n//\t cmd+alt+j (see .vscode/keybindings.json)\n// --- END AI MODEL FILE PATH ---\n\nimport { Subject } from 'rxjs';\n\nimport type { EventShape, SDuXShape } from '@sdux-vault/shared';\nimport { DevMode } from '@sdux-vault/shared';\nimport type { EventBusContract } from '../interfaces/event-bus.contract';\n\n/**\n * Holds the singleton EventBus instance used for global event dispatch.\n */\nlet instance: EventBusContract | null = null;\n\n/**\n * Returns the global EventBus singleton used to emit and observe DevTools events.\n * This function ensures a single EventBus instance is created and reused for the application lifecycle.\n *\n * --RelatedStart--\n * EventBusInterface\n * --RelatedEnd--\n *\n * @returns The global EventBus instance.\n */\nexport function EventBus(): EventBusContract {\n  if (!instance) {\n    instance = new EventBusInstance();\n  }\n\n  return instance;\n}\n\n/**\n * Implements the EventBusInterface by managing pipeline and queue event streams.\n * This class provides gated event emission based on development mode and exposes observable streams for subscribers.\n * It is instantiated once and registered globally to support DevTools integration.\n */\nclass EventBusInstance implements EventBusContract {\n  /**\n   * Subject used to emit pipeline events to subscribers.\n   */\n  #pipeline$ = new Subject<EventShape>();\n\n  /**\n   * Creates a new EventBus instance and exposes it on the global object for DevTools access.\n   */\n  constructor() {\n    window.sdux ??= {} as SDuXShape;\n    window.sdux.vaultEventBus = this;\n  }\n\n  /**\n   * Emits a pipeline event to subscribed observers when development mode is active.\n   *\n   * @param event Pipeline event instance to emit.\n   */\n  nextPipeline(event: EventShape): void {\n    if (DevMode.active && event) {\n      this.#pipeline$.next(event);\n    }\n  }\n\n  /**\n   * Provides an observable stream of emitted pipeline events.\n   *\n   * @returns Observable stream of pipeline events.\n   */\n  pipeline$() {\n    return this.#pipeline$.asObservable();\n  }\n}\n","// --- AI Model File Path (DO NOT DELETE) ---\n// FilePath: libs > devtools > tooling > src > public-api.ts\n// Updated: 2026-03-28 11:45\n//\t Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or\n//\t cmd+alt+j (see .vscode/keybindings.json)\n// --- END AI MODEL FILE PATH ---\n\n/**\n * This is for version support in dev mode and tracking in the devtools\n */\nimport './lib/version/version.register';\n\nexport * from './lib/interfaces/event-bus.contract';\nexport * from './lib/utils/event-bus';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;;AAAA;AACA;AACA;AACA;AACA;AACA;AAIA,MAAM,YAAY,GAAG,sBAAsB;AAC3C,MAAM,YAAY,GAAG,OAAO;AAE5B,eAAe,CAAC,YAAY,EAAE,YAAY,CAAC;;ACZ3C;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AAQA;;AAEG;AACH,IAAI,QAAQ,GAA4B,IAAI;AAE5C;;;;;;;;;AASG;SACa,QAAQ,GAAA;IACtB,IAAI,CAAC,QAAQ,EAAE;AACb,QAAA,QAAQ,GAAG,IAAI,gBAAgB,EAAE;IACnC;AAEA,IAAA,OAAO,QAAQ;AACjB;AAEA;;;;AAIG;AACH,MAAM,gBAAgB,CAAA;AACpB;;AAEG;AACH,IAAA,UAAU,GAAG,IAAI,OAAO,EAAc;AAEtC;;AAEG;AACH,IAAA,WAAA,GAAA;AACE,QAAA,MAAM,CAAC,IAAI,KAAK,EAAe;AAC/B,QAAA,MAAM,CAAC,IAAI,CAAC,aAAa,GAAG,IAAI;IAClC;AAEA;;;;AAIG;AACH,IAAA,YAAY,CAAC,KAAiB,EAAA;AAC5B,QAAA,IAAI,OAAO,CAAC,MAAM,IAAI,KAAK,EAAE;AAC3B,YAAA,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC;QAC7B;IACF;AAEA;;;;AAIG;IACH,SAAS,GAAA;AACP,QAAA,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE;IACvC;AACD;;AC1ED;AACA;AACA;AACA;AACA;AACA;AAEA;;AAEG;;ACTH;;AAEG;;;;"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@sdux-vault/devtools",
+  "version": "0.0.7",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sdux-vault/core.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://www.sdux-vault.com",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@sdux-vault/shared": ">=0.0.6 <0.1.0",
+    "rxjs": "^7.0.0"
+  },
+  "files": [
+    "fesm2022/",
+    "types/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "types": "./types/sdux-vault-devtools.d.ts",
+  "main": "./fesm2022/sdux-vault-devtools.mjs",
+  "sideEffects": [
+    "./fesm2022/*.mjs",
+    "src/lib/version/version.register.ts"
+  ],
+  "module": "fesm2022/sdux-vault-devtools.mjs",
+  "typings": "types/sdux-vault-devtools.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/sdux-vault-devtools.d.ts",
+      "default": "./fesm2022/sdux-vault-devtools.mjs"
+    }
+  }
+}

package/types/sdux-vault-devtools.d.ts

@@ -0,0 +1,41 @@
+import { EventShape } from '@sdux-vault/shared';
+import { Observable } from 'rxjs';
+
+/**
+ * Defines the contract for an event bus responsible for emitting and observing pipeline and queue events.
+ * This interface provides methods for publishing events and subscribing to their corresponding event streams.
+ *
+ * --RelatedStart--
+ * EventShape
+ * EventQueueShape
+ * --RelatedEnd--
+ */
+interface EventBusContract {
+    /**
+     * Emits a pipeline event to all subscribed observers.
+     *
+     * @param event Pipeline event instance to be dispatched.
+     */
+    nextPipeline(event: EventShape): void;
+    /**
+     * Provides an observable stream of emitted pipeline events.
+     *
+     * @returns Observable stream of pipeline events.
+     */
+    pipeline$(): Observable<EventShape>;
+}
+
+/**
+ * Returns the global EventBus singleton used to emit and observe DevTools events.
+ * This function ensures a single EventBus instance is created and reused for the application lifecycle.
+ *
+ * --RelatedStart--
+ * EventBusInterface
+ * --RelatedEnd--
+ *
+ * @returns The global EventBus instance.
+ */
+declare function EventBus(): EventBusContract;
+
+export { EventBus };
+export type { EventBusContract };