module-federation/aegis

Aegis is a modular Node.js framework designed for building distributed, event-driven applications with a focus on extensibility and hot-reloadable configuration. It provides a flexible adapter layer supporting diverse backends including file systems, in-memory caches, MongoDB, and WebAssembly modules. The system integrates a configurable service mesh for inter-service communication and includes built-in support for IoT data streams, serverless functions, and automated certificate management.

26 changes.

The project established its foundational structure by implementing the Aegis core module, introducing a modular adapter system for persistence, serverless, and WebAssembly components, and enabling Node.js runtime support for module federation. This period focused on building out the service mesh with multiple transport backends and adding comprehensive test coverage for the new domain and adapter layers.

8 changes.

This period focused on implementing core domain logic for model lifecycle and eventing, alongside integrating LiDAR hardware support and a WebSocket-based service mesh. The work established the foundational use cases and adapters required for real-time object detection and inter-client communication.

A new parser for AWS API Gateway events has been added to the serverless adapter. The \aws-parser.js\ file implements request and response handling, including a helper to parse multi-line JSON bodies. The \index.js\ file exports this parser, while stubs for Azure and Google parsers are included but currently commented out.

src/adapters/serverless/parsers · high confidence

A new CLI adapter has been introduced to provide a test harness for simulating serverless requests. The \expressless.js\ module allows users to interact with the \aegis\ core by piping input via stdin, supporting HTTP methods (post, get, patch, delete) and specific model IDs. This enables interactive testing of API models through the command line interface.

src/adapters/cli · high confidence

Introduced a new WebAssembly adapter in \src/adapters/webassembly\ that enables the application to load, instantiate, and interact with WebAssembly modules. The \repo-client.js\ module provides a client for fetching WASM bytecode from GitHub repositories or HTTP endpoints. The \wasm-interop.js\ module handles the serialization and deserialization of data between JavaScript and WebAssembly, supporting string, array, and object conversions. The \wasm-wrap.js\ module wraps the WASM exports into standard Model, Adapter, and Service interfaces, allowing the rest of the application to interact with WASM-based components as if they were native JavaScript objects.

src/adapters/webassembly · high confidence

A new file, src/services/iot/lidar/cepton.js, has been added to the codebase. This introduces a new component for handling Cepton LiDAR integration within the IoT services.

src/services/iot · high confidence

The middleware layer now includes new capabilities for domain name system (DNS) management and WHOIS lookups. A new DNS service has been introduced, featuring a provider abstraction that defaults to a local implementation (currently supporting Namecheap) while allowing for remote client fallback. Additionally, a WHOIS lookup utility has been added to retrieve domain registration information, which is useful for certificate requests. The directory also contains placeholder files for OpenTelemetry, Prometheus, NATS, and Kubernetes integrations, indicating the beginning of observability and infrastructure management features.

src/services/middleware · medium confidence

New files have been added to the IoT adapter layer to support LiDAR integration. This includes modules for handling LiDAR device connections, frame processing, point cloud data, and coordinate transformations. The object detection module is introduced to retrieve and classify objects (such as persons or vehicles) from connected LiDARs, with support for asynchronous notifications of newly detected objects in real time. Additionally, zone management and transform utilities are added to support these capabilities.

src/adapters/iot · medium confidence

Introduced new Webpack plugins and runtime modules to enable module federation in Node.js environments. The \NodeTemplatePlugin\ and \ReadFileChunkLoadingRuntimeModule\ provide the necessary infrastructure for loading remote chunks via the Node.js \http\ and \vm\ modules, allowing Node.js applications to consume federated modules. Additionally, \fetch-remotes.js\ was added to handle downloading remote entry files from GitHub or HTTP sources, and \http-node-demo.js\ wires the Node template into the compiler. This change allows users to build and run federated microservices on the server side.

webpack · high confidence

The domain utilities layer now includes new helpers for structured error handling (AppError, async-error), asynchronous context management via AsyncLocalStorage (async-context), and change data capture for tracking object mutations (change-data-capture). Additional utilities for function composition, piping, and data transformation (compose, pipe, async-pipe, make-array, make-object) have also been added to support these capabilities.

src/domain/util · high confidence

The repository is initialized with essential configuration and tooling files to support the project's build, linting, formatting, and development workflows. This includes a Babel configuration for ES6+ Node.js targets, an ESLint setup with Prettier integration, and a Prettier configuration. Development convenience is enhanced by a Gitpod environment file that automates the setup of multiple related repositories (aegis, aegis-host, aegis-app) and manages ports for local services. Additionally, a file watcher script is added to monitor source changes and trigger hot-reloads, while a C utility is introduced to spawn child processes for running commands. The project also includes a standard .gitignore, .npmignore, and a README.md with project documentation and roadmap.

(repo-wide) · high confidence

The Aegis application now exposes a new \aegis\ module that handles HTTP routing, model CRUD operations, and port invocations. This module registers routes for managing models (GET, POST, PATCH, DELETE) and invoking ports, while also supporting user-defined routes and admin endpoints. The system now supports idempotency keys for request tracking and includes a configuration loader for \aegis.config.json\.

src · high confidence

A new WebAssembly module built with AssemblyScript has been added to the project. This includes the core implementation in \wasm/assembly/index.ts\, which exposes functions to compute the Fibonacci sequence, along with configuration files (\asconfig.json\, \tsconfig.json\) and a demo HTML page (\wasm/index.html\) that loads and executes the compiled WebAssembly. This adds a new capability to perform Fibonacci calculations within the WebAssembly environment.

wasm/assembly · high confidence

Added the core WebSwitch implementation for the service mesh, including the main switch logic, multicast routing for domain-based network overlays, and a stubbed QUIC server interface. The switch manages WebSocket connections, handles client initialization, and routes events between nodes and browsers.

src/services/service-mesh/web-switch · high confidence

Added new adapter modules for file-system operations and data persistence (save, remove, find, update, close). These adapters provide a consistent interface for managing model state and file operations, supporting the service mesh architecture by abstracting storage and file I/O concerns.

src/adapters · high confidence

Added new service modules to the application: \auth.js\ for JWT-based route protection, \cert.js\ for automated certificate provisioning via ACME/Let's Encrypt, \cluster.js\ for multi-process cluster management, \event-bus.js\ for event handling, and \persistence.js\ for data source operations. These modules are exported via \src/services/index.js\, which also configures the active service mesh plugin based on the \activeServiceMesh\ configuration. The \auth\ service checks the \AUTH\_ENABLED\ environment variable before applying JWT middleware, while the \cert\ service uses DNS or HTTP challenges to manage certificates. The \cluster\ service handles worker process management and hot reloading. These changes provide new capabilities for security, infrastructure, and scalability.

src/services · high confidence

A new serverless adapter has been added to the codebase, providing a mechanism to integrate with cloud functions. The implementation includes a main entry point (index.js) that exports a serverless adapter factory, which relies on a parser system to transform input and output for the core controller. The adapter supports multiple cloud providers (defaulting to AWS) and allows for extensibility by adding new parsers for different cloud environments.

src/adapters/serverless · high confidence

Added new files in src/adapters/service-mesh to implement a WebSocket-based service mesh. This includes a ServiceLocator for multicast DNS-based service discovery, a WebSocket adapter for binary message encoding/decoding, and a domain model (webswitch) that manages connections, heartbeats, and message broadcasting. The configuration in config/webswitch.js defines the ports for service locator and websocket operations, enabling the system to discover and connect to a common WebSocket server for inter-client communication.

src/adapters/service-mesh · high confidence

The domain layer now includes a comprehensive set of new modules to support a more robust architecture. A new eventing system is introduced, featuring an EventBroker for managing subscriptions and notifications, a PortEventRouter for inter-thread and remote communication, and a DomainEvents registry for standardizing event names. Additionally, a DistributedCache is added to handle remote object caching and synchronization, while a DataSourceFactory and base DataSource class provide a unified interface for data access with built-in caching, serialization, and streaming support. The system also adds a CircuitBreaker to manage fault tolerance for network calls, and a FederatedQuery mixin to support querying remote objects. Finally, the model specification and port generation logic have been updated to support these new capabilities, including configurable timeouts, retries, and event-driven port behavior.

src/domain · high confidence

The public directory now includes a new aegis.config.json file that defines hot-reloadable configuration variables, including general settings, adapter settings (cache size, federated queries, and data sources), service mesh configurations (WebSwitch, MeshLink, NatsMesh, QuicMesh), authentication key sets, and certificate paths. A corresponding aegis.config.test.json file has also been added, containing identical configuration data for testing purposes.

public · high confidence

The \src/domain/use-cases\ directory has been populated with new files implementing core domain logic. This includes \broker-events.js\ for handling event routing between thread pools and service mesh, \create-model.js\ and \edit-model.js\ for managing model state, \find-model.js\ for querying models, and \remove-model.js\ for deletion. Additionally, \invoke-port.js\ handles port invocations, \hot-reload.js\ manages hot reloading, and \forward-events.js\ bridges internal events to external buses. These changes establish the foundational use cases for the application's domain layer.

src/domain/use-cases · high confidence

The system now supports persistent storage on the local filesystem and temporary in-memory storage alongside the existing MongoDB adapter. The new \DataSourceFile\ adapter enables models to be saved to and loaded from local JSON files, while \DataSourceMemory\ provides a cluster-aware, in-memory cache that broadcasts changes to other cluster nodes. These adapters are registered in the \datasources/index.js\ entry point, allowing the application to route data operations to the appropriate storage backend.

src/adapters/datasources · high confidence

The service mesh has been refactored to support multiple transport backends, including MeshLink, NATS, and QUIC. This change introduces a modular architecture where different mesh implementations can be used interchangeably, allowing for greater flexibility in how services communicate within the mesh. Users can now choose the most appropriate transport mechanism for their specific use case, whether it be the existing MeshLink or the newly added NATS and QUIC options.

src/services/service-mesh · high confidence

A new ML Ops workflow file was added, defining the model lifecycle stages (deployment, training, activation, archival, and destruction) and their associated service ports and event flows.

workflow · high confidence

The HTTP adapter layer has been refactored to use a consistent \httpController\ interface, where each controller (e.g., \post-model\, \get-models\) returns a standardized response object containing headers, status code, and body. This change ensures that all RESTful mutations and queries return a uniform structure, simplifying how the application handles HTTP requests and responses.

src/adapters/controllers · high confidence

Added initial test for WASM add function; Added initial test scaffolding for adapters; Added initial test suite for template; Added test cases for use-case scenarios; Added test coverage for model and controller logic; Added test fixtures for ACME client, CA certificate provisioning, event service, and WHOIS lookup; Added test utilities for change data capture and function composition; Added tests for datasource file and inheritance; Added tests for shared memory functionality; Added thread-safety and inter-thread communication tests.

The package.json files for the main module and the WASM subdirectory are introduced, establishing the project's dependency graph. This includes runtime dependencies such as express, mongodb, and assemblyscript, alongside development tools like Jest, Mocha, and Babel, effectively defining the build and test environment for the Aegis framework.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 45 → 44 (-1.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 58 → 54 (-4.5)
• Architecture 71 → 48 (-22.3)
• Maturity 50 → 50 (-0.3)
• Readiness 33 → 35 (+1.1)
• Security 53 → 65 (+12.7)
• Accessibility 61 → 61 (+0.0)

• Boundary-crossing change coupling: service-locator.js ↔ switch.js (src/adapters/service-mesh/adapters/service-locator.js)
• Change coupling clique: create-model.js, edit-model.js, remove-model.js (src/domain/use-cases/create-model.js)
• Change coupling: broker-events.js ↔ index.js (src/domain/use-cases/broker-events.js)
• Change coupling: delete-model.js ↔ thread-pool.js (src/adapters/controllers/delete-model.js)
• Change coupling: live-update.js ↔ hot-reload.js (src/adapters/controllers/live-update.js)
• Change coupling: live-update.js ↔ thread-pool.js (src/adapters/controllers/live-update.js)
• Change coupling: post-invoke-port.js ↔ aegis.js (src/adapters/controllers/post-invoke-port.js)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Scanner failed to run — not a clean result
• Test reliability not included

• (anonymous) (cognitive 17) (src/domain/model.js)
• (anonymous) (cognitive 18) (src/domain/datasource-factory.js)
• (anonymous) (cognitive 46) (src/domain/thread-pool.js)
• (anonymous) (cyclomatic 18) (src/domain/model.js)
• (anonymous) (cyclomatic 19) (src/domain/datasource-factory.js)
• (anonymous) (cyclomatic 38) (src/domain/thread-pool.js)
• Change coupling: datasource-mongodb.js ↔ list-models.js (src/adapters/datasources/datasource-mongodb.js)
• Change coupling: index.js ↔ broker-events.js (src/adapters/index.js)
• CircuitBreaker::invoke (cognitive 16) (src/domain/circuit-breaker.js)
• Coverage not measured — JavaScript/TypeScript suite
• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no committed lockfile, so no resolved version to grade)
• Documentation: no installation or build instructions (README.md)
• FileTooLong: domain/thread-pool.js (src/domain/thread-pool.js)
• FunctionTooLong: distributed-cache.DistributedCache (src/domain/distributed-cache.js)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 43 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

module-federation/aegis was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.