Skip to main content

Glossary

The vocabulary Cobblr uses, defined plainly. Most terms link to the page that covers them in full.

Action​

A named operation a module registers on its records, like "use one" on a part or "mark task done." An action declares which kinds it applies to, so it can be a button in the UI and the target of a wire at the same time.

Activity log​

The append-only record of what happened in a workspace: edits, state changes, and every wire that fired, failed, or hit the depth guard. See Activity log.

API token​

A long-lived credential a script or agent uses to authenticate to the REST API. It starts with cbt_, is stored hashed, can carry scopes, and can be revoked. See API tokens.

Band​

A module's tier: foundational modules are always on, stock modules ship with Cobblr and you enable the ones you want, and marketplace modules come from elsewhere.

Browser driving​

An opt-in mode where an agent operates your own open Cobblr tab (opens pages, points, follows along) through the drive:control scope. It reads and writes no workspace data. See Connecting Claude.

Bundle​

A ready-made starting point that sets up modules, fields, views, and features for a use case, named for the thing it tracks rather than a workflow. See Bundles.

Computed field​

A field whose value is rendered read-only from a {{ }} template every time the record is read, rather than stored. See Computed fields.

Condition​

A structured check on a wire that must hold for it to fire, written as a list of clauses over the record's fields and the event payload. See wires.

Digifab​

The module that sends a design file to the software running a machine (FDM Monster, OctoPrint, and the like) and tracks the job to completion. It talks to each manager's API; it does not drive the hardware. See Digital fabrication.

Edge bridge​

On-site software that dials in and relays commands to machines on a local network for one workspace, authenticating with a devices:edge scoped token. See Using the edge bridge.

Event​

A thing that happened to a record, named module.thing.verb (for example inventory.stock.low). Events are what wires fire on and what webhooks can carry out. See Events and webhooks.

Field​

One value a record carries. Fields are either native (shipped by a module) or custom (added per workspace). See Fields and field types.

Field role​

A job assigned to a field (title, quantity, image, and others) that the platform keys off, independent of the field's name, so a feature can find "the quantity" on any kind.

Instance​

A skinned copy of a module that supports it, each with its own name, nav entry, and fields. One Machines module becomes a 3D Printers area, a Lasers area, and a CNC area at once. Also called a specialisation. See Instances.

Kind​

A type of record a module defines, identified as module:kind (inventory:part, projects:task). A module can provide several kinds.

Location​

A record for where a thing is, of the kind core-locations:location. Locations nest, so you can narrow from a room to a bin. See Locations and tags.

MCP server​

A server that wraps the REST API so your own Claude can read records, run actions, and draft bundles for a workspace over stdio or HTTP. See Connecting Claude.

Module​

The unit a workspace is built from. A domain module is an area you manage (Inventory, Projects, Machines); a capability module (named core-*) is plumbing other modules use. See Modules.

Notification channel​

A destination a workspace sends notifications to: in-app, email, Slack, Discord, browser push, or a webhook URL you own. See Notifications.

OpenAPI spec​

A generated OpenAPI 3.1 description of a workspace's API, served at the core-openapi module route, reflecting that workspace's actual kinds and fields. See REST API.

Pairing​

A directional link between two records carrying a relationship kind. It is the graph a wire walks to act across related records. See Relationships.

Placement​

The containment primitive: which container a thing is inside. A location is one kind of container, a machine another. See Locations and tags.

Record​

One row of a kind. When resolved it carries an id, a title, and a fields map. See Data model.

Relation field​

A custom field that points a record at another record of a named kind, storing the target's id and showing its name. See Relationships.

Renderer​

The built-in style a custom field's value is drawn with (color-hex, qr, markdown, and others). A field with no renderer draws as plain text.

Scope​

A capability grant on an API token that clamps it to a narrow set of routes, deny-by-default. See API tokens.

Sync source​

A JSON manifest that tells the generic sync engine how to read an external system and where its records land in Cobblr, so mirroring a new source needs no release. See Sync-source manifests.

Tag​

A polymorphic label attached to records across modules; the same tag can sit on a part, a task, and a machine. See Locations and tags.

Target​

The part of a wire that decides which records its action runs on: the source record itself, or related records reached by walking a pairing. See wires.

Template​

A {{ }} string rendered against a record's data, used in computed fields and in a wire's messages and arguments, with filters like | default and | slug. | relative works in computed fields only.

Trait​

An axis label on a kind (physical or digital, unique or fungible, container or containable, and others) that lets an action apply by capability rather than by naming each kind.

Trigger​

What starts a wire: an event, a record's create / update / delete, a schedule (an RRULE), or a manual tap. See wires.

View​

A way of looking at a set of records (table, kanban, calendar, gallery, list) without changing the data. See Views.

Webhook​

An HTTP link between a workspace and an outside system: outbound sends an event to a URL you own, inbound lets another system ping the workspace through a tokened URL. See Events and webhooks.

Wire​

A stored "when this happens, do that" binding connecting a trigger to an action, built without code. See Wires and the reference.

Workspace​

A single Cobblr instance with its own database, modules, members, and slug. Everything a token, wire, or query does happens within one workspace. See Workspaces.