| title | Glossary |
|---|---|
| description | The Glossary of the ObjectStack Ecosystem. Speaking the same language. |
To navigate the ObjectStack ecosystem effectively, it is helpful to understand the specific vocabulary we use. While many terms are standard in computer science, some have specific nuances in our "Protocol-Driven" context.
The umbrella term for the entire suite of protocols and reference implementations. It is organized into 15 protocol namespaces grouped into three architectural layers.
A logical grouping of related schemas and types defined with Zod. ObjectStack has 15 protocol namespaces: Data, UI, System, Automation, AI, API, Identity, Security, Kernel, Cloud, QA, Contracts, Integration, Studio, and Shared.
The 15 namespaces collapse into three top-level layers:
| Layer | Also called | Namespaces it includes | Purpose |
|---|---|---|---|
| ObjectQL | Data Layer | Data | Objects, fields, queries, relations, validation, data access |
| Kernel | Control Layer / System Layer (formerly named "ObjectOS") | Kernel, System, Automation, AI, API, Identity, Security, Cloud, Integration, Studio, QA, Contracts, Shared | Runtime, permissions, automation, plugins, tenants, agent tools, artifact loading |
| ObjectUI | View Layer | UI | Apps, views, dashboards, actions, presentation metadata |
Older docs and talks used ObjectOS as the name of this control layer. That name now refers exclusively to the commercial ObjectOS runtime environment (docs.objectos.ai); the open control layer is called the Kernel, described by the System/Kernel/AI/API protocol namespaces below.
Defines the core business data model. Includes Object schema, Field types, Validation rules, Query AST, and Filter conditions. This is the foundation of ObjectQL.
Server-Driven UI specification for building user interfaces. Includes App structure, Views (List/Form/Kanban/Calendar), Dashboards, Reports, Themes, and Actions.
Infrastructure services including Event Bus, Job Scheduling, Translation (i18n), and Audit Logging. Manages system-level concerns.
Plugin system and runtime management. Includes Plugin lifecycle, Manifest definition, Logger configuration, and Runtime Context. The core of the control layer.
Platform AI primitives: AI Agents, Skills, Tools, Conversations, a multi-provider Model Registry, Embedding and vector-store references, Knowledge sources, and MCP server bindings, plus Usage (token accounting and per-call cost). Scope is deliberately narrow — higher-level concerns such as NLQ services, RAG pipeline orchestration, and predictive pipelines were removed in v1 and are meant to be built on top of these primitives.
External communication layer including REST contracts, API discovery, Realtime subscriptions (WebSocket/SSE), and Routing configuration.
Business process automation including Workflows (state machines), Flows (visual logic), and Webhooks (HTTP callbacks).
User, organization, and position schemas for identity management.
RBAC, permissions, policy, and access-control schemas.
Multi-tenant cloud, deployment, environment, and package distribution schemas.
Test, validation, and quality-assurance schemas.
Cross-package interface contracts shared by runtime packages and services.
External system integration schemas and connection metadata.
Studio UI metadata and builder-specific schemas.
Reusable error maps, suggestions, and metadata normalization utilities.
A development paradigm where logic is defined in static, declarative data formats (JSON/YAML) with Zod schemas rather than imperative code. The goal is to separate the Intent (Business Logic) from the Implementation (Tech Stack).
In ObjectStack, "local-first" refers to the development and runtime mode, not data sovereignty on end-user devices. Every project can boot against local drivers (in-memory, SQLite, Turso embedded replica) with zero cloud dependency, so authoring, testing, and demos work fully offline. Cloud is an enhancement, not a prerequisite.
The architectural commitment that AI agents act only through typed, permission-aware, auditable capabilities derived from the same metadata artifact that powers the application — never via raw SQL, scraped UI state, or hand-written glue tools. RBAC, RLS, and FLS apply to agent actions exactly as they apply to users.
A system that takes a high-level query AST (Abstract Syntax Tree) and compiles it into an optimized database query string (e.g., SQL). This contrasts with an ORM, which typically acts as a runtime wrapper object.
A field defined in the Data Protocol schema that does not exist physically in the database table but is computed on the fly.
- Example: A SQL subquery or expression injected into the
SELECTstatement at compile time.
The fundamental unit of data modeling in ObjectStack. Roughly equivalent to a "Table" in SQL or a "Collection" in NoSQL. An Object definition includes Fields, Actions, Triggers, and Permissions.
An adapter plugin in the Data Protocol runtime stack that allows the Data Layer to communicate with a specific underlying storage engine.
- Example (this repo):
@objectstack/driver-sql(Postgres / MySQL / SQLite via Knex),@objectstack/driver-mongodb,@objectstack/driver-memory(in-memory, for testing),@objectstack/driver-sqlite-wasm. - Cloud distribution:
@objectstack/driver-turso(edge-first SQLite) ships separately, not in this repository.
The intermediate representation of a query or schema. The Data Protocol parses a JSON request into an AST before the Driver translates it into SQL/NoSQL queries. This allows for security validation and optimization before execution.
The entry point configuration file (Kernel Protocol) for an ObjectStack Plugin. It declares dependencies, resources, and extensions using the Manifest schema.
The authoring form of an ObjectStack app or host: a TypeScript module that calls defineStack() (or composes one with composeStacks()). Source files reference Zod schemas, helper functions and imports — they only run inside the build/dev toolchain. Edit the source when you change what the app is.
The distribution form, produced by objectstack build. A single self-contained JSON document — plus an optional objectstack-runtime.<hash>.mjs sidecar for compiled hooks — that includes the manifest, objects, views, flows and requires: [] capability list. Artifacts are framework-agnostic, deterministic, signable, and the only thing a production runtime actually needs. objectstack start (or any host calling createDefaultHostConfig()) can boot directly from an artifact, with no source files on the target machine.
A JSON structure defined in the UI Protocol that describes the visual arrangement of components. Layouts can be nested and dynamic (e.g., Master-Detail, Grid, Kanban).
A business process (Automation Protocol) defined as a Finite State Machine (FSM). It consists of States (e.g., draft, approved), Transitions, and Guards.
A visual logic automation tool (Automation Protocol) that allows building business processes using a node-based editor. Supports screen flows, autolaunched flows, and scheduled flows.
A discrete unit of logic (UI Protocol) that can be triggered by a user (UI button) or a system event (Workflow transition). Actions define button behaviors and navigation.
A map within the UI Runtime that links a string identifier (e.g., "chart.bar") to a real React Component. This allows the UI Protocol to instantiate UI elements dynamically.
A logical isolation unit in the Cloud Protocol for multi-tenancy, modeled by the tenant schema (cloud/tenant.zod.ts). A single ObjectStack instance can host multiple tenants. Data is segregated by tenant isolation strategies. "Space" and "Workspace" are informal aliases for the same concept.
A granular permission model (Security Protocol) where access control is applied to individual fields (columns), not just the whole object (row).
The default sharing level (Security Protocol) for records in an object. Determines the baseline access level before sharing rules are applied.
A hierarchical access control model (Security Protocol) that grants data access based on geographic or organizational boundaries.
A planned suite of tests that would validate whether a Driver or Renderer complies with the official ObjectStack Protocol, certifying a passing driver as compatible. Not yet implemented — there is no TCK program or certification mechanism in the codebase today.