Skip to content

Glossary

The DUST platform vocabulary, in alphabetical order. Docs prose uses these terms consistently; API endpoint paths and field names sometimes keep older implementation names (noted per term).

A Thread that aggregates other Threads as its attached parts, while remaining a fully first-class Thread itself — with its own name, Fields, Identifiers, and Certificate. An Assembly can be nested inside another Assembly. Every Thread reachable inside an Assembly belongs to the same owning Team.

The act of associating an Identifier with a Thread, performed through the Identifier endpoints. Once bound, scanning the Identifier resolves back to that Thread.

A cross-cutting grouping that classifies Threads. Unlike a Folder, a Thread can belong to many Categories at once. Categories can nest under a parent Category (subcategories); membership is direct, not rolled up.

An immutable, point-in-time PDF generated from a Thread’s data and issued by the platform. It is stored as a Resource attached to the Thread, with a record carrying its trust status (issued or voided) and provenance. The Resource checksum is the certificate hash.

A reusable, Team-owned design that defines how a Certificate is laid out and which Thread data fills it. A Certificate Form locates values by field name (with optional aliases), not by Template, so it can generate Certificates for owned, shared, and transferred Threads alike.

The standing relationship between two Teams in different Organizations — the channel for all cross-team exchange. Sharing and Shipments are only initiated over a Connection, and its lifecycle (pending, connected, paused, deleted) and direction (send, receive, or both) govern what may flow between the pair. Teams within one Organization collaborate without a Connection.

An immutable, numbered version of a Public Page Design — v1, v2, v3 — frozen when the design is published, and the only thing “version” names in the Public Pages module (a page’s own publications are identified by date, never numbered). Publishing a version does not change any live page; pages move onto it only through a rollout, which is forward-only: a Design Version is never restored, and a bad one is corrected by publishing a newer one.

The explicit act by which a Thread owner makes selected data — Fields, Resources, Identifiers, or Certificates — visible downstream through Fabric. Transferred copies are snapshots: source edits propagate only when the owner explicitly discloses them, and a made disclosure is visible to every downstream consumer on the chain.

The physical DUST mark applied to an object, scanned as an image capture and resolved server-side by identifying or verifying it against enrolled Identifiers. A DUST Identifier represents a physical identity and is never copied between Threads. See Identifiers and Scanning.

The cross-team provenance graph of the platform. When a Thread is transferred or sliced, Fabric records the resulting links between source and derived Threads, and carries Disclosures along them — independent of live sharing or Connection state.

A named, typed value on a Thread — text, numbers, dates, images, and other attributes that describe the item the Thread represents. Templates define reusable sets of Fields.

A nestable container that organizes Threads and other Folders. A Thread lives in at most one Folder (single-home — contrast with Category). Sharing a Folder cascades access to its contents.

A scannable physical or digital code associated with a Thread: DUST, QR, barcode, Data Matrix, or NFC. The user-facing term for what the API calls a tag — endpoint paths and field names keep the legacy naming (/api/v1/tags, tagType). See Identifiers and Identifiers and Scanning.

The act of finding a Thread by scanning or entering an Identifier. The Teams searched are set per request (the API’s searchGroupIds). See Identifiers.

The draft contents of a Shipment or other Fabric operation: the selected Threads, their selected assets, and any Assembly, Folder, or Category structure to carry along. The manifest freezes when the Shipment is sent.

The top-level account boundary, containing Teams and their members. API requests carry the active Organization in the Dust-Ctx-Org-Id header. See Conventions.

A Part is a Thread attached to an Assembly — each Thread is a part of at most one Assembly, and by default inherits the Assembly’s access. A Position is a named Thread-valued Field on an Assembly assigned to one of its attached Threads (for example “front wheel”).

The public, unauthenticated web view of a Thread — the digital product passport a consumer reaches by scanning an Identifier or following a printed link. Its URL is permanent and can be reserved (and its QR code printed) before anything is published; until then it serves a “registered” notice. A Public Page carries no content configuration of its own: it shows exactly what its Public Page Design pulls, pinning one Design Version and one publication of its data. See Public Pages.

A reusable, Team-owned design that determines the content and appearance of every Public Page published through it — an ordered stack of blocks that pull Thread data by field name, in the same way a Certificate Form does. One design serves a whole product line; editing it changes nothing public until a Design Version is published and rolled out.

A scoped background run that publishes or republishes every Public Page in a Folder, Category, Template, or explicit selection through one Design Version, with per-Thread success and failure accounting. A wave can be retried for its failures, or cancelled — which stops the remaining pages without moving already-published ones back.

A grant on a Team membership meaning “may make this Team’s data public”. It gates every change in the Public Pages module — authoring and publishing Public Page Designs, publishing and unpublishing pages, rollouts, and Publish Waves. Team admins always hold it; members without it have read-only access to the module. Service Accounts can hold it, for pipeline publishing.

A directional link type used to connect two Threads owned by the same Team (for example “supplied by”). Relationship links are free-form annotations; unlike Part attachment they do not grant access and do not nest.

A file attached to a Thread — documents, images, and other uploads. Resources can be selected into Manifests, Slices, and Disclosures.

The user-facing name in DICE for a Transfer: an outbound or inbound package of Threads exchanged between connected Teams, moving through draft, sent, accepted, and processing states, with the recipient able to accept, reject, or request changes.

Deriving new Threads from a source Thread by copying or linking selected Fields, files, and Identifiers, with Fabric recording the lineage. DUST Identifiers represent a physical identity and are never copied into a slice.

The access and collaboration scope within an Organization. Teams own Threads and Folders, and are the unit of sharing, Connections, and request context. The request header is Dust-Ctx-Team-Id; some API names keep the legacy “group” naming (searchGroupIds, and Dust-Ctx-Grp-Id as a still-accepted header alias). See Conventions.

A comparison of a fresh scan of a DUST Identifier against the reference captured when it was bound, producing marker coverage measurements and visual evidence layers — and no conclusion. The platform reports what it measured and shows the evidence; it never states whether the Identifier was tampered with, and offers no summary number, rating, or threshold. See Tamper Analysis.

A person’s own conclusion drawn from one Tamper Analysis — the only conclusion the platform stores. Its result is one of Consistent, Expected (normal wear and tear for the identifier’s use case and substrate), Inconsistent, or Unknown, chosen actively with no default. Observations are attributed, immutable, and never replaced: an Analysis retains the whole series. The subject is the Identifier surface, not the Thread or the goods it represents.

A reusable definition of the Fields a Thread carries, used when creating Threads individually or importing them in bulk (for example from CSV).

The core record of the platform: a digital identity for a physical thing or item. A Thread holds Fields, Resources, Identifiers, and Certificates, lives in a Folder, and can be classified, shared, shipped, sliced, and disclosed.

Moving Threads from one Team to another over a Connection: the recipient receives new Threads it owns outright, the source Threads are closed out, and Fabric links the two sides. Surfaced in DICE as Shipments; acceptance is the point of no return.

Confirming that a scanned Identifier matches an expected Identifier bound to a specific Thread — a yes/no check against a claimed identity, as opposed to Identify’s open-ended search. See Identifiers.

Marking an Identifier as no longer the live marking for an item — the DUST was destroyed, re-applied, or the marked material was cut away. Void is a label: the Identifier stays bound to its Thread with its full history, stays visible in the Identifier list (in red, marked Voided), and can still be identified, verified, and unbound. It is reversible, and it does not change the underlying DUST record. Distinct from archiving, which hides an Identifier from the default view, and from a Certificate void, which is permanent. See Identifiers and Scanning.