STAXIS

C B staxis js platform -> gitlab project
This site is currently under construction. Feel free to take a look around, but please come back in a few days

Design Principles

This document summarizes the main software engineering principles that guide the Staxis Core and its extension system.

Staxis is developed by engineers who use AI as a professional tool (so it's not vibe-coded). Engineers make the design decisions and take responsibility for the code that ships. Code produced with AI assistance is subject to the same in-depth review and verification as any other contribution before it is accepted. That includes checking how the code works, how it fits the architecture, and what it changes at security boundaries.

Building Ideas: Security first • Clean code • Plain JavaScript • Node.js module compatibility • Ethical business (see the Core licence and the official pack licence)

Design Principles: KISS • DRY • SRP • LSP • ISP • OCP (open to extension) • DIP • Extensibility • Zero third-party runtime dependencies in the Core • External dependencies in packs only when needed • Encapsulation and information hiding • Separation of concerns • Fail-fast validation • Tamper evidence and integrity • Least privilege • Defence in depth • Vault for managed secrets

  • Simplicity and Code Quality

    Keep the execution flow easy to follow. Share code when it represents the same responsibility, and add a dependency or abstraction when it solves a concrete problem. The Core uses built-in Node.js APIs. Packs can bring in libraries that their own functionality requires.

  • Separation of Responsibilities

    The Core coordinates the layer lifecycle, the Vault handles access to managed secrets, and the integrity subsystem verifies covered files. The Manager handles provisioning and distribution. Each pack implements a specific application concern.

  • Extensibility Through Contracts

    The Core loads packs through a shared contract, with stack order in the project configuration and requirements in pack manifests. A new pack can extend the application without changing the Core. Layers expose focused interfaces so callers can rely on a specific contract. Any replacement must preserve the behaviour its callers rely on.

  • Encapsulation and Runtime Control

    The Core keeps orchestration state private and exposes selected operations through frozen bundles. Layers can still manage mutable resources such as server instances and connection pools. The shared lifecycle gives them a defined place to initialize and release those resources. Logging and diagnostics can live in dedicated packs.

  • Integrity and Least Privilege

    Validate managed layers when they are loaded or authorized. Under the applicable security profile, HMAC checks detect changes to covered files, permissions govern access to managed APIs and Vault resources, and Guardian checks imports and filesystem access within its supported scope. These controls assume a protected host, Core, and key material. See How it works for the runtime checks.

  • Pack Distribution

    Keep pack installation separate from runtime orchestration. The Manager installs and removes individual packs and provisions a stack from a .roll profile. The official and community catalogues point to pack repositories so developers can inspect the source before installing it.