v0.1.0-alpha.497¶

Released 2026-11-01.

Features¶

Business Glossary & Ontology¶

A term's lifecycle is one status: draft, live, deprecated or retired.
- PII on terms is its refusals in every UI locale
- A term's status -- draft, live, deprecated, retired
- A term's status -- Draft, Live, Deprecated, Retired -- and Deprecate, with a retired term's record
- Term status is set by people, grounding is computed; agents see approved grounded vocabulary
- Term list chips are icons (Box, Tag, Lightbulb, Eye, PencilLine)
The ontology reports what a curator should look at as findings: GET /admin/glossary/findings (glossary_read, scoped to the caller's domains) returns each term with its findings, each a kind, a message code with its parameters, and a message.
- Findings -- what a curator should look at, per term
- To review reads the server's findings; Retire takes a successor and asks about lost tags
- A product's status -- draft, live, deprecated, retired -- its lifecycle dialogs, findings and withdrawal from catalogs

Column Masking¶

Every regex a user gives Provisa, a mask's pattern and replacement among them, is written in one universal dialect: the portable subset of literals,., sets [...] with ranges and negation, the greedy quantifiers * + ? {n} {n,} {n,m}, the anchors ^ and $ (the whole value), groups ( ) and (?: ), alternation |, and \d \s \w as their ASCII classes; a replacement is literal text with $1-$9 and $$.
- One universal regex dialect, refused by name at save and lowered per engine
- Preset placeholders as {first}/{last}; alternation warnings in patterns with ok true
- A regex mask fails closed -- an unmatched value is fully masked
- A null result value arrives unset, not as its type's zero

File & Lake Sources¶

A files source reads each Excel workbook as the tables it holds.
- A files source's Excel hints, on its form and in its mapping

Changes¶

3d¶

A 3D stage draws on demand and nothing while unseen, so an idle page costs no CPU
A turning stage stops after 10 s with no input on the page, and the core e2e lane runs with reduced motion
Every network graph opens on its best view, turns about its spread plane's normal, and has a 2D view

admin¶

The catalog and a table save stay within the acting role's grants
A column's dependents are answered as their caller may read them
Refusals name only what their caller may read; new tables answered at once
The profiler, DQ and findings answer within the caller's grants
fakes, synthetic data and the glossary within the caller's grants
profiling, audit text and observability within the caller's grants
Edits and delegations stay within the caller's reads
Refusal texts name only what their caller reads
capgrants10 -- a request's acting role reaches every surface
capgrants11 -- the workbook answers a table saved since the build
An OpenAPI source whose document is out of reach fails no Tables listing; its tables say why

agentdata¶

Ask over two weeks, where customers do order twice

aggregates¶

An aggregate or group-by with its nodes is one statement

analyze¶

Cap the drawn plan tree under Mermaid's 500-edge limit

api¶

The build loads each domain's stored graphql_alias
Answer a MERGE/form or RETURNING write refusal as a 400 by name
A client's error never names an internal schema
An error naming no org word has no internal schema to take out

askamerica¶

Prepare the adapter's catalog on first use; a key-check timeout is AskAmericaUnavailable

athena¶

registerTable records the table format; a Hive MERGE is refused as a MERGE

audit¶

A governance read on the writer thread runs in the request org

auth¶

The login throttle keeps no failure past its window
A named role set acts as its meta-role on every route, unsecured
Unsecured gRPC and Flight bind a derived role's attribute; Bolt databases name derived roles
A principal's role assignments are read one way on every transport
HTTP's rules after the read apply on every transport

bench¶

The lifecycle sizes every device's boot disk with one flag
A ready device waiting for the others keeps its idle hold; each device's setup log is kept before destroy
The backends device can be given its own machine type, its stores being sized for a large box
One service builds the perf Postgres image; the engine runs it, so a parallel build no longer fails on the shared tag
The backends agent is started when it does not answer, and the serve stop matches no shell of its own
Seeding is its own job stored as an image; runs boot from it, checkpoint each variant and resume after a preemption
Soak profile, sampled server tree, leak probe maps and pools
The features test's first CI run, triaged
Masks are checked per table, and MCP is pinned every role a features request names
A local soak validation on the test instance, its contract readable everywhere
A step's first error names the request it answered
A sparql transport, its own dialect, rendered from the same contract
The row-level refusal on gRPC, table TTLs in the apply phase, optimistic cells
The Artillery ramps check their answers; the Cypher ramp uses live labels
A saturation ramp's failed expectations do not end the sweep
Bolt saturation coverage, Cypher cache opt-in, GraphQL ramp, no pg stand-ins
The three-device server names a public URL for the SPARQL vocabulary
The governance pass reads only orders, with columns to mask

bolt¶

One statement per RUN; a transaction's results pulled by qid
The browser's graph totals are unknown, not 0, when a count fails
A commit and an auto-commit result end with a bookmark
Temporal and point values travel as Bolt structures
Only the parse decides a statement is a write; a write's own error is its answer
neo4j names the home database
Summary counters for Cypher writes on both write paths
A Bolt RUN runs in its principal's graph session
Answer CREATE/DROP DATABASE and select a created database

bolt, cypher¶

Bolt and the Cypher route run a write through written()

build¶

The model stamp is read after the build's own effective-name writes
A reload writes no relationship name already stored
A column transform's grants are folded over each role's ancestors

calendars¶

The saved message names a calendar's version once ('v1', not 'vv1')

catalogs¶

A Catalogs panel holds each catalog connection once, by domain

clickhouse¶

A query that matches no row still names its columns
The engine runtime's query names its columns when ClickHouse sends no block

codesource¶

No engine attaches a code host; the image's front end serves no reads
Code sources answer their own statements, direct and attached
Code rows streamed end to end, a connection per concurrent call
A code statement is complete only when read direct; a null test names an aggregate's expression
Credit flow control, and a code source's DuckDB under the operator's bounds
The read context, (inputs, context) for every table and stream, no parameter-as-filter
Speed and memory as built, measured
SQL and GraphQL mutations on a code table, routed to its commands
A statement that fails stops reading the function's rows
A worker closes its socket only once its reader has left it
Connecting a remote host dials it to pair and to check, no third time
A worker closes a lane's socket only once its reader has left it
A code host's DuckDB is opened capped, by its source's own bounds
The image copies core's engine_memory beside its front end; no symlink
A column transform streams its read through the workers in 1000-row batches
A column transform in a CTE is a staged, selective step
An INSERT... SELECT whose CTE holds a column transform is refused saying so
A staged CTE is typed by the model, its reads take their own parameters, embed() folds with them
A pulled call keeps the request that asked for it
A dropped pairing connection is a named refusal

commands¶

SQL expression functions in SQL statements, acceptance test, locales
Implicit meta reach for schema build and command admission only; defaults fill without refusing
APOC path walks either way from a label back to it; docs for defaults
A function the engine cannot write is refused by name at compile; sources route around; anomalies page generated
A domain-prefixed command field is registered under the alias the schema names it by
VOID commands; implicit-argument CALL in Cypher

compiler¶

A where states a relationship's condition, compiled to EXISTS over its target; ilike matches with case ignored
A session's temporary table comes ahead of a model table of its name
Dropping an API table's union branches keeps a recursive CTE valid (#312)
A relationship target is read under its join alias
Pg engine reads a key-bounded nested field once

config-export¶

A contract's created_at is the store's stamp, not written into the config export

conformance¶

Type the pgwire fixture's columns as registration does
The pgwire seed types a subtype as registration does, never sampling money
TCK setups run with their query in one ephemeral session over Bolt
The TCK's Bolt sessions sign in as a user mapped to tck_empty
Bolt examples run as written under a role of their own
TCK session setup ignores post-query steps; compare side effects
TCK named graphs run their script in a session; test procedures are commands
Every case is passed, skipped by design or failed
Client and suite skips are skipped by design
Cite driver and suite source for client and suite skips
A TCK procedure's command is assigned to the roles that call it
A control query on an empty graph reads the empty session
A Bolt date time at offset zero is written Z, naming no region
A pg_catalog function not served is failed
Skip internal and index catalog functions by design
Hash functions leave the Index functions group
Form checked, a third status in the functions run
Catalog function results by engine with rule footnotes

contract¶

A column is declared, never promised; Promise means a data quality check
Panels in three tiers on a shared layout

contracts¶

A contract keeps its versions and names its breaking changes

core-lane¶

DuckDB databases opened capped; a Kaggle token is its own credential; provision.py argv; tour clickBefore once; a single-file draft table
Every DuckDB the base opens bare is capped too; OpenRouter passed once; Fuseki's heap sized for the e2e

cypher¶

A GraphQL query of several root fields is a Cypher statement per root
A GraphQL root's Cypher means what its SQL means
A junction root is Cypher only for its declared types; one-table columns and IN lists
A Cypher box of several statements answers one result per statement, each under its own tab
A Cypher read answers what the statement says
A single-hop type alternation over one junction's types
A filtered root keeps its filter; a junction field or condition is its relationships
A table semantic SQL names before its physical alias has its label
$3 is the parameter named "3", not the number 3
A query's Cypher carries the values its SQL binds
A read using the engine's functions is answered by the engine
A list function answers on DuckDB, and a slice is 0-based
A map's key is read with.key, and a carried variable returns only itself
A junction field's end node, built as one JSON object, has its Cypher form
Open as query keeps a to-many field's own order and limit, or refuses
A WITH right after a WITH reads the rows that WITH carries
An UNWIND variable is each element, not its UNNEST's whole row
An unlabelled node read backward is the relationship's target
A node a property narrows to one type is built from its arm; a property of a node is a value, not the node (#292,)
DESC puts nulls first; LIKE exported exactly; DuckDB LIKE escapes as PostgreSQL
=~ matches the whole string; ENDS WITH is literal; Trino LIKE escapes as PostgreSQL
A read missing a required parameter is a 400 naming it, each parameter once
Every graph-route error is the app's error body; the frame says the reason and lists each access violation
A mistake in the user's statement is refused at translation in their own terms
An unbound name that is a bound variable's property is offered as it
Every surface offers a bound variable's property for an unbound name
A returned map literal answers its values, not their JSON encoding
A property the label has not is null; every node's key is its _id
Every node object and every walk holds a node's whole key
What a read cannot answer has a code -- a failed conversion is null, Infinity is a 400, an engine's refusal is a 400 on every engine
A read refused by name is answered with its own status and code, not a 500
A refusal by name in a CALL, a write or the Neo4j endpoint is answered as itself
A MATCH takes comma-separated patterns
An OPTIONAL MATCH's WHERE is that match's condition and never removes a row
An OPTIONAL MATCH takes comma-separated patterns and matches whole or not at all
length(p) of a recursive path is its hop count; an undirected walk recurses both ways
A statement with no pattern is a SELECT with no FROM
Map arguments in CALL; number literal forms, ^, RETURN *, WITH DISTINCT, deep literals; parse errors are refusals
mixed-type list literals, time values, deep-literal and map-temporal refusals by name; write refusals name the forms read
Unaliased RETURN expressions named as written; sequence() is engine-only
Relationships written without brackets (--, <--, <-->) are read; a single dash is refused
A variable naming two things, an aggregate in a list comprehension and length() of a node are refused
A WITH carries each node it names as that node (#293,)
date(), datetime(), localdatetime(), time() and localtime() are casts or the engine's current value
Column name conflicts, UNION column and kind mismatches, integer overflow, unknown string escapes, non-boolean operands, aggregates of rand() and a value matched as a node are refused
Every unaliased RETURN expression, a property included, is named as written (a.name)
Durations -- ISO-8601 answers, properties, duration(), between/inMonths/inDays/inSeconds and arithmetic, on the engine's interval
Temporal values from component maps, Cypher's written forms and other values; answered as Cypher writes them
date.truncate, datetime.truncate and the rest, with components put in after
A date's, a time's and a date time's parts read as properties
A zone the query names is computed with and presented; microsecond precision, nanoseconds as zero
size() of a list written in the statement is counted there, size(null) is null; tested on DuckDB, PostgreSQL and Trino
size() of a registered text column is its character count on every engine
size() of any string -- a string function's value, a concatenation, a variable bound to one -- is its character count
An edge touching a table SQL alone serves is no relationship of the graph
A float divided by zero is Infinity or NaN, as openCypher answers; an integer divided by zero stays an error
A statement that is not Cypher is "Invalid input", as Neo4j says it
A node matched with no label keeps each property's type, and has labels
XOR is two booleans differing, written as SQL reads it
An integer divided by an integer is an integer
IN, string predicates and IS NULL bind between + and a comparison
List quantifiers over nulls are three-valued
A list + an element appends it, an element + a list prepends it
reverse() of a list reads it last to first on every engine
keys() of a map answers its keys; m['k'] reads the key's value
Values of two kinds are never equal and have no order
A function inside collect() or another renamed one is lowered too
properties() of a map is the map, of null null
A CREATE answers its RETURN, and a junction relationship is written between matched nodes
A string + a value is the two as one string
time.truncate() of a time or a date time keeps its offset
A node CREATE without a variable is a write
duration() reads a computed ISO-8601 string with negative or fractional parts
collect() skips nulls, and collects nothing as []
A relationship CREATE reads each matched node apart
toInteger() cuts toward zero; SPARQL's xsd:integer casts as XPath does
Values the statement writes wholly are equal, in, and ordered as Cypher says
A CREATE giving its node no property is refused naming the forms read
A map a WITH carries keeps keys that differ in case apart
A list of several types built from lists answers its values
CASE, string predicates and indexes across kinds; UNWIND null; RETURN * by name
An item of a list of several types has its size
A key every unwound map literal gives one type reads as that type
An item of a list of several types answers its value, in openCypher's order
toString() of an item of a mixed list, and a key of a nested map literal
NaN is equal to nothing and has no order, on every engine
A string's \uXXXX escapes are read; the TCK runner reads cells as Gherkin writes them
range() with a step of 0 is refused by name
[..] is refused as [] is; unbounded patterns are by design
A list or map literal of any depth is read; MAX_LITERAL_DEPTH is gone
range() with a computed step of 0 is refused by the engine
An OPTIONAL MATCH from a variable bound to null matches nothing
A deep literal with computed items reaches the engine without its nesting
A list slice counts a negative bound from the end
Temporal values beyond the engine's bounds are refused by name
A computed list index is 0-based, as a written one is
A key of a map read from a list of several types is read
A string indexed like a list is refused; a string parameter is a string
A map or key bound to null indexes to null
datetime.fromepoch() and datetime.fromepochmillis() are read
Values the client gives are read by the engine, never written into the SQL
A collect inside size() collects; an answer of no rows names its columns
ORDER BY reads ASCENDING/DESCENDING and nested items; a pattern is a predicate
A collect() after WITH... ORDER BY collects in that order
One graph session per principal, the same on every client
Graph session id is hex, grants read through the one rule, locales
A kept translation is reused only for parameters of the same temporal kind and zone
A junction CREATE may end on rows the same statement creates
Governed DETACH DELETE of model nodes and junction-row DELETE
A MERGE reads unrelated leading MATCHes apart
REMOVE on model nodes follows Class labels and properties refused by name
A node of several labels carries the columns its readers use
An unlabelled match over no node type reads an empty relation
Row counts of openCypher TCK scenarios over a session's graph
A graph session walks a path function's unlabelled end
An empty node union registers its columns like an arm does
Session caps refused by name; TCK scenarios start empty; duration lists
An undirected variable-length walk takes only relationships its start can reach (#311)
A path search needs one end bound or labelled; a pattern no relationship matches is no rows (#313)
A session path from an end the model places walks the model's relationships (#313)
An undirected hop reads both ends; an unlabelled match keeps every node
A path variable read as a value
Arguments the engine has no overload for
ORDER BY ranks nodes, relationships and paths in openCypher's order
A WITH's WHERE reads the variables before the WITH
A comprehension's bound target is that node; a union node keeps its types
A list of graph elements and literals is a list of several types
one-hop pattern comprehensions with unnamed ends, a named relationship or several types
Ordering comparison of two lists is element by element
TCK side effects as observed; Bolt session reads keep graph identities
One command-call runner; a standalone YIELD of a VOID command is refused
A node only a session holds carries no _id
SET of maps and session nodes answered with every label
Nodes a returned map holds get their own Bolt ids
CALL as openCypher reads it; a Bolt read of no rows names its columns
MERGE writes ON CREATE / ON MATCH properties of the session's objects
openCypher value semantics for the TCK expression features
SKIP/LIMIT expressions, keyword variables, carried unlabelled nodes
A conversion of a kind it does not take is a TypeError
keys() and n[key] of a session relationship read with any ends
A projection is read by what it keeps; a shadowed alias is its new value
A node a WITH carries is read on as that WITH's node
Maps a WITH carries; a WITH ordered by nothing
Lists of union elements; variables a WITH drops; sub-microsecond orderings named
collect() is the elements, count() counts rows
A date moves by a duration's whole days of time; a session time keeps its accessors
A session node's _id is left out of the answer, not its reads
Session DELETE of any target, REMOVE keys, CREATE {} and graph functions
A read after a write finds unlabeled session nodes among the session's; DeletedEntityAccess
A session hop's ends are the session's nodes and the model labels its relationships end at
Session reads the TCK found wanting: types told apart by case, r:T, deleted type(r), WITH *, map expressions

data¶

Reading over GraphQL and SQL needs no query_development

data-contracts¶

The meta goldens, the editor's service levels in form fields, the page's mocks
A contract's column and type stay on one line in its card

data-products¶

A product's quality claims on its detail panel, from the meta domain
The claim field's hint on its FormField within 90 characters, the claims' SQL name built apart, the read view's exemption for the claim label
The panel's query text has a bounded height, so the sections around it pack
One Inputs section, and Related lists the directly related tables only
Edge lists keyed by the edge's id; a source input is named by its address
Every reference the panel shows is the model's name; cards hold their content; related detail clamps
Cards keep their content and remember their state; the product graph has the Ontology View's controls
The Knowledge graph card is compact again, the full explorer in its expanded view; the product's lineage DAG is back across the panel's foot
Input Ports are one row per upstream table, its columns behind an expand; the lineage DAG names tables as the catalog does, heads its lanes in words and opens legible; no Queries card
A lineage relation is named by the catalog when it is a registered table, by its relation when it is not; the knowledge graph's outside tables too
Each Related Tables entry is held to three lines; the Knowledge graph card is a glance with no controls
The knowledge graph card is drawn from the panel's own meta read
The panel reads relationships, source types and DQ rules from meta
A product's lineage is its own endpoint, read by any reader of it
A product's data quality is its expectations, promises, related and unattached checks
The data quality section is three rows, Expectations, Promises and Related
A check's latest run sits beside what it scans, so neither is clipped
The owner sees the product's own side; any other reader its promises
Edit follows the right to edit a product, not the owner's view
A product's lineage names its consumers, one hop downstream
The owner sees who reads the product, one hop downstream
data_product_owned_rw edits the products whose owner role the caller holds
Each output port declares its own versioned ODCS contract; the product's prose SLA moves into it
ODPS document complete; created_at shown read-only
Contracts panel as ODCS section rows; derived ODCS 3.1 elements in the exported contract
Read contracts.json only for a product with a contract
Contract summaries use i18n plurals; schema properties open to every element
Contract Quality card spans two grid columns at 3+
Contract cards flow in columns; Promises is a full-width panel of separate items
The promises table builds its results name through the shared helper
A contract's sections are peer cards and its Promises count is its rows
A contract has no consumers and its Columns runs full width
How to use replaces a contract's Servers section

database¶

The LISTEN thread's wake pipe is closed only once the thread has ended

demo¶

groupexposure's terms step opens the ontology page
Publish groupexposure, its card from its real answer
The sandbox tier serves groupexposure, now published
An open during a template's preparation waits for it, never builds it again
Insurance and weblogs vocabularies grounded by narrowing and synonym edges
Raise DEMO_FORMAT to 3 and requires_provisa to a496 for demos using role parents or code inputs
Refuse a bundle in a newer demo format than this Provisa reads
Provisioning close step reads true inside its window too

demo warm-up¶

Each tour statement is sent with the time travel the steps before it set

demo-bundles¶

A seeding run that times out names each template replica's build state
A regions demo is set up and seeded on one set of region stores
A regions demo's bundle carries its bitemporal views' setup history
A regions demo's seeding nodes run together, each on its region's address
A seeding run that cannot seed its template ends the build at once, by name
A seeding run builds each view it keeps that nothing else builds
A regions demo's setup history is found in its region stores, not its config
A region's views are seeded after its replicas land; a regions sandbox runs in its region's store

demo-stores¶

A taken-down version's ES marks are deleted; a missing index is restored

demo-templates¶

A node without a ready template's folder prepares it again
The version a template was built from is the control plane's, never a node's file
A regions tier records its finished template, so an open does not replace it
One step writes every carried setting a demo declares to its template

demos¶

Publish the data room demo on the sandbox tier
first-launch's sandbox tier offers the data room demo too
Publish the reproduce demo on the sandbox tier
Publish the opioids demo: its card, the sandbox tier's bundles, the first launch and the live demos page
Publish the pharma demo: its card, the sandbox tier's bundles, the first launch and the live demos page
A scaffolded demo's init script is executable; the walk's unpublished example is perf
groupexposure, a bank's loan book rolled up through Wikidata by LEI
groupexposure's borrowers are fictional, their owners real
Publish the retail demo on the regions sandbox tier
A seeding run that never finished shows its node's log, the tables it re-created and its embedded store file
A seeding node's whole log is printed into the build's output once it stops
The regions sandbox tier runs a node per visitor region and serves banking
A published demo in regions must be one the regions tier serves
The regions check reads each demo of name=region entries
"Give an agent your data" named demo on the MCP explorer
The profiling demo's card is its run's terrain
A bundle started locally loads the profile runs it carries
The visitor walk sends agentdata's Connect step, so its bundle can be published
A live demo comes up from cold with a true wait and no failure on the way
A source save rebuilds the schemas once, and slow steps are named
Shared connector servers, a consumer group per listener, public limits
per-schema bootstrap lock, one commit per seeded table, no template runtime without stores

deploy¶

The deploy package ships the vendored buenavista with provisa

deploy-cloud¶

The regions sandbox tier gets the deployed tree and its own config
Drop each org schema in its own transaction so the reset never runs out of locks
The sandbox reset drops sandbox schemas in the databases each store holds

deps¶

Black 26.10.1, graphql-core 3.2.13, setuptools 84.2.1, virtualenv 21.14.13 past their CVEs
Filelock 4.2.4 and opentelemetry 1.45.1 past their CVEs
msgpack, dnspython, pymongo and oauthlib past their CVEs
Pypdf 6.21.4 and pyasn1 0.6.5 past their CVEs

discovery¶

Registration records the keys the source declares
FK tracking raises all but a starting server; tests recorded
A catalog read cancelled while the source prepares its catalog is retried, not left unindexed
No adapter read is sent while its catalog is being prepared; answered STARTING at once
A PostgreSQL source's keys are read from pg_catalog by the table's name

docker¶

The image trusts Microsoft's 2025 signing key, which signs its Debian 13 repository

docs¶

Fix gen_docs_index.py to rewrite docs/ fragment links
Conformance overview as overview.md (docs/*/index.md is gitignored), unblocking the site deploy

dq¶

A checker table's latest run, in the meta domain
A preflight calls Provisa's services in-process, dq among them; a view may hold on failing checks
Name tables as the model does, in what dq reads and answers
A read governance refuses is a 403 naming why
A checker the role does not reach is left out, not read
A table with no contract stores dq_rules as SQL NULL
Each checker run logs its checker, its time and how it ended
A checker source's connection is what its steward entered; the model never resolves it (#276)

dq,types¶

A checker's empty password is stored empty; Exasol's character-set spellings are text (#276)

dq-claims¶

The merged panel, its fixtures and the corpus agree with main

duckdb¶

A statement's null order is a sort key, never NULLS FIRST/LAST (#294,)
What the server store's own connection writes is readable through the engine's attach
PostgreSQL's json_build_object and jsonb_build_object run on DuckDB as json_object
A division inside another's divisor divides and is guarded too
A table landed in a server store is seen through the engine attach

embedded-pg¶

A sign-extended segment key matches the key the system lists
A segment key with its top bit set is read as the system lists it
A segment key with its top bit set is found, and so released

engine¶

A statement the engine answers answers as PostgreSQL does -- division by zero, infinity, a function aliased in FROM
A function named in pg_catalog is that function
A UUID read beside a date is the uuid.UUID it is

ephemeral¶

A session's ephemeral graph store, typed and widening
The governing rule and label resolution for a CREATE
An ephemeral CREATE makes its nodes and relationships in the session
The read overlay, and proof the governed path is unchanged
A node naming two model tables is the session's, carrying both
A match of any node reads each node once
A mixed CREATE splits across the governed and session paths
Bolt holds a connection's ephemeral graph; SET and REMOVE labels
A CREATE and a label SET/REMOVE are read from the graph IR
A session's graph is written in place, its tables indexed on their keys
MERGE is MATCH, then CREATE under the same rules
An unlabeled node is every label's, session relationships with an unlabeled end read; several CREATE clauses are one
store.key_of is public, so a restore indexes a table on its key
DELETE and DETACH DELETE over the session's graph
A session relation is one CTE, an instance's own conditions inside it
A label's resolution lives in the session's lookup tables
A session graph is indexed where it is looked up, and counted
A session table not created yet reads as an empty table
A session write followed by reads is one statement; session property REMOVE and indexes

errors¶

An engine's error is answered in the model's names
Every transport answers an engine's error in the model's names
An error is named only by the org its request bound
A client's error is named from the model-wide context, not every role's
A JSON error body stays JSON when its names are the model's

events¶

A second landing before the rewire runs keeps the first landing's views

explore¶

A restored result comes back only beside the exact query that produced it

explorer¶

The Cypher pane prints the read's graph IR in its three projections
A read's nodes and relationships are its graph pattern; a graph view opens as one

export¶

Each catalog is published as a role; the workbook is its caller's
A role's publish keeps every domain the role reaches
Governance tags name the standard roles too
The tag roster is every role that reaches a domain

fabric¶

Wait until Fabric serves a resumed capacity; suspend only from Active
A resumed capacity's warehouse is waited for by its own answer

fakes¶

The pg engine's fake functions import with no sqlglot

federation¶

The DuckDB Snowflake attach creates the secret it names; the Kaggle and warehouse e2e clean up as their own
The DuckDB snowflake extension is loaded with the ADBC driver Provisa ships
Apollo subgraph served as the org's declared role
The subgraph SDL publishes no operation directive
A store table's time with its offset keeps the offset through the engine's copy
Unity Catalog 429 is waited out for every REST call
Send a source hint to Trino only if it is a session property
The pg engine's ClickHouse attach uses the source's declared port
Only the @provisa vocabulary reaches an engine session
Load the crypto extension through the duckdb owner

flight¶

A worker's Flight servers are held by wait(), never serve()
Each relayed send is one bounded non-blocking call into room it already has
A Flight RPC's unexpected failure is logged with its traceback
Flight SQL statement query and SqlInfo on the Flight endpoint
Flight SQL prepared statements, bound parameters through DoPut, statement schemas
Flight SQL catalogs, database schemas, tables, table types and keys, as the role is served
Flight SQL statement and prepared statement updates through the governed pipeline
Flight SQL session options: the current catalog and schema, as pgwire answers them
Flight SQL transaction actions, acknowledged and holding nothing
Flight SQL sessions: SetSessionOptions, CloseSession, the session's current schema
Flight SQL bulk ingest into the model's tables, through the governed pipeline
Flight SQL temporary ingest into the session's own temporary table
An ingest writes timestamps as their instants, and a missing table does not exist
A lazy stream is pulled in the caller's Flight session
A column transform plan streams from Flight's engine route too
A Flight SQL prepared statement answers its parameter schema
Flight SQL lists each column's nullability as the model records it
An ingest writes the model's table by its schema

front door¶

The waking page's streams are binary, drawn from one glyph sprite

glossary¶

A class term grounds whole tables and views
No requirement id inside the class-term view's SQL
A table grounds its class term, in the model and the admission rule
A term's list row and detail count the tables it grounds
A term is a Class or a Property, never both
Abstract is derived from grounding, the flag retired
Tables propose their Class; keys are the Class's
A proposal is a stored sync grounding on an uncurated term, not a name
RELATED_TO is the last resort; resolving shapes offered
Choosing RELATED_TO opens the alternatives
Find terms in a document, with a review queue
Ontology drift from the model history

governance¶

A role's row limit bounds every list a read nests
Cypher's collect() and COLLECT { } lists are bounded by the row limit too
One governance context per role and model version; catalog views out of the landing list
Every caller reads the one role governance context
The kept context is read-only; the scan finds any naming of its builder

gql¶

A table with no column to identify its rows by is refused, not given "id"
A WHERE's ISO date-time string compares as a TIMESTAMP again
A variable-length path keeps its lower bound (#283)
The graph depth limit is an operator setting, and a result cut there says so
Path expressions, path modes and label expressions in the graph IR
RDF terms, typed literals, variable predicates and CONSTRUCT in the graph IR
A SPARQL term and the depth limit's cut flag pass through the graph rewrite
A path expression's step relation holds a node's whole key
A relationship to a node the statement already holds is a condition, not a second join (#303)
A node or relationship variable is null by its own row, not a column of its name (#304)
Two node or relationship variables are compared by identity, not by table alias (#305)
A later MATCH that starts at a node not yet held joins that node's table (#306)
A stored edge keeps its direction; a read of every relationship types its edges
Two anonymous nodes of one label are two nodes
find_paths keys the relationships a path has used by mapping, not type name

gql-ir¶

Graph writes are clauses of the graph IR

grants¶

An empty grant is no role on every list; a registration grants its registrant and Viewer
Listed names, the registration grant on new tables, and every list naming its roles
Command fields and Flight metrics read the one assignment rule; an empty list names no role
A command's response column with no grant is the command's own; tests name their roles
batch-2b integration fallout of empty grant = no role
A role served no tables is not refused

graph¶

A label the engine could not count is said, with why; the total is null then
A refused graph-counts request is shown in the sidebar, not stored as counts
A refused graph-schema request is shown in the sidebar, not read as an empty schema
A parameterized table is uncounted in /data/graph-counts, not a 500
A result frame's query shows Copy and Delete on hover
An Overview pill picks out its label's nodes, or its type's edges, in its frame
GraphFrame no longer imports CopySymbolButton, which both its uses moved into FrameParts
A node's properties are every column under its own name, id included; an OPTIONAL MATCH that matched nothing is null
A frame of rows counts its rows, never "0 nodes · 0 rels"
An expansion names only the relationship types the server registers for the role (#307, #308)
The mouse wheel over any graph zooms it and never scrolls the page
A label dropped on a frame expands from every variable the query binds
A comparison of two kinds is one IR operation whose language states it
A LIMIT needs no full union; graph.union_limit defaults to 256
A registry entry with no columns says nothing of its key
Paths skip parameterized tables; a join declared twice is one edge
?s ?p ?o stays refused; recursive walks tested where the join guard admits them

graph-session¶

A cleared session never repeats a plan-cache key

graph3d¶

One neighbourhood, two hops; a product's counted from its member tables
Each legend glyph is the shape its nodes are drawn with -- a data product a hexagon
A summary select's closed text stays on one line, ending in an ellipsis
The product panel is the Graph panel, with All, Ontology and Products presets and no Lineage preset
A product's graph draws its lineage from the product lineage endpoint
A product's graph draws its column lineage from the product lineage endpoint
The 2D view is a lane diagram
Every lane node informs and links; 2D shows only 2D controls
Lane view fixture and fallback use term status, not live
Lane nodes without a status carry no status attribute

graphql¶

A nested field's where, order_by, offset and distinct_on hold at every depth
A nested field is built as one JSON value; a list with no rows is []
A nested field read through its own join is answered under its alias
Each nested column of a query's SQL is named by its response path
GraphQL front end of the graph IR and the Cypher printer
Aggregate roots lowered to the graph IR; nodes keep a column's alias
GraphQL over HTTP recommendations on /data/graphql
A column typed character varying is a String
Prefix the ontology and ops schemas' SDL names on_ and op_

graphql-front¶

The fields projection names each flat property itself; tests follow the one naming rule; LangChain reads deptId

graphql-http¶

GET forwards no time-travel headers, and the test's state has no config file

graphql-remote¶

A remote table is replicated row by row where its schema fetches rows by keys

graphs¶

Each graph's detail panel links its item and its connections to their own pages

groupexposure¶

Owners reach their group by a declared relationship, and Tier 1 is read as a value, not cross-joined

grpc¶

An aggregate over no rows arrives unset, not as zero
A row read lowers to GraphQL, and a where compares text as its column's type
A row read honours the offset on the servicer and the proxy

guard¶

Branches reading the same instances are one alternative

helm¶

The chart's analyst role and row rule say what they are for

i18n¶

Record English sources for translated graph3d, kaggle, serverErrors, sourceDetailPanel and tour keys
re-record English sources for graph3d and banking tour keys
The contracts list's strings in every locale

import¶

A Hasura v2 source keeps its pool's minimum connections

install¶

banking's regions node, run as its visitor region warehouse
The regions tier lists banking

integrity¶

Declare the term-finding foreign keys; a LINK standing for SET NULL

introspect¶

Redshift lists its tables from pg_catalog; a Synapse pool offers its views

json¶

The JSON family of catalog functions on DuckDB
jsonb_concat of an empty value, a NULL key of jsonb_exists_all
A call is rewritten once, whatever its nesting

kafka¶

A landing's offsets name the topic's partitions from the metadata fetched for them

landing¶

A failed landing or an unparsable rewrite fails the read
Whether a table is landed is read from its store's catalog

leak-probe¶

Live threads by name, so a rise in threads names its pool
Thread stacks on request, and a named background thread keeps its name

lineage¶

Every lineage read is cut to the caller's read rights
Column lineage is answered only by the lineage reads that cut it
A native box without its source's details is named by the source and the names it gives the object

live teardown¶

An external link reuses only a parent location; UC listings wait out 429; Dataplex terms approved

llm¶

Raise on None message content; give reasoning model enough max_tokens in LLM eval

locks¶

A CrossLoopLock is never held for a waiter that cannot take it

masks¶

Common regex masks beside a regex entry, and the server's universal-dialect verdict as it is typed
A refusal reads under both regex fields; the guards list the regex fields' menu and its not-a-form row

materialization¶

A nested statement drops none of the outer statement's scratch tables

mcp¶

A loopback call's statements are audited, as the anonymous user's
A loopback call naming a derived role acts as its meta-role and binds its attribute
A local call naming a role set acts as its meta-role, derived roles bound
Cypher runs in the caller's graph session; clear_graph_session
Hold the catalog search index per org and scope its roles to the org

merge¶

Restore main's pipeline lost in the 449e8d99a merge

meta¶

Product inputs, related tables, derivations and checker states
A glossary term reaches its edges out and in, and an edge its two terms; an empty _or holds for no row, an empty _and for every row
A registered table reaches its sensitive columns (sensitiveColumns)
A column, not its table, reaches its sensitivity (table_columns -> sensitive_coverage by column_key)
Glossary refs and domain links are junctions; a table's class term is registered_tables.class_term_id
The semantic-address resolver is the meta domain's resolve
Register governed metrics as meta.metric_definitions
A promoted primary key is NOT NULL, meta golden carries the catalog views

metadata export¶

Provisa assigns its terms to data as each catalog's automated assignment
Each term's ontology role on every glossary target
The role property is declared on glossaryTerm; a role not exported fails the publish
The glossary on Purview's Unified Catalog, Dataplex and DataZone
A Dataplex definition link waits, bounded, for its table's entry

metadata-export¶

Views seat in the derived layer's container; OpenMetadata reads the contract team as members; an escaped refusal fails its target by name
OpenMetadata gets a contract's latency in its own units; the Purview e2e reads its product back by the adapter's id
OpenMetadata searches its own Elasticsearch 9; Atlas assignment errors carry Atlas's body
Atlas assignments are ACTIVE; Dataplex term entries by project number; OpenMetadata members through its bulk asset calls
Dataplex links a term once its catalog entry appears
A failed pre-write read refuses that asset; every adapter keeps what a steward owns
Atlan is shown as "Atlan (beta)", from one flag on its adapter
DataHub owners name their source in OwnershipSource; Atlas finds Provisa's unbound terms
A Unified Catalog data asset is created with its name and type
A Unified Catalog data product has a type, a data asset names its Data Map source
Unified Catalog terms and products go by the ids the service gives them
Atlas, OpenMetadata and DataHub e2e publish what the real services accept
OpenMetadata views and contract SLAs import; harness audience is the org's roles
OpenMetadata data product members through its asset calls; the ODCS read-back asserts what 2.0.5 keeps
A Unified Catalog data product relates each data asset by the flat relationship body; the e2e expects the status the service stores
Purview counts its Unified Catalog terms apart from its Data Map terms
Purview tells its term relationships from a steward's by the record of what it wrote
A mask tag names only the roles the column is served to
Name gRPC, JSON:API, OpenAPI and SPARQL as contract servers

model¶

No table label may equal a domain label

mongodb¶

The driver reader reads each column at its document path

mutations¶

An update's or delete's where takes every operator a read's does; a ServiceNow API document is fetched as the instance serves it

mv¶

A view never answers its own build
A deleted view leaves no build; one unresolvable view never fails the org's wiring
A view's build is pruned by the view it was built from, never by its id
A first build creates its store table keyed as the reconcile keys it
A materialized view is indexed as a replica is

mysql¶

A TIMESTAMP is read as its instant in UTC, with its zone

naming¶

No domain's computed alias is another's; ontology and ops are named apart

nl¶

non-strict NL is the guard bypass's, and no panel shows a query with an error
A V002 refusal names the condition as written, and a refused NL query is retried with the registered path between its tables
non-strict NL's Cypher is refined against the role's label map

ontology¶

The Ontology View reads one root, its terms with the edges leaving them
A relationship can say the rows it joins are the same entity
Mark a relationship same entity in its editor; the gap on the term and the Ontology view
Data on keeps the graph's spread and the camera frames it all
Taxonomy draws a tree, its columns under their terms
The Ontology View's choices as dropdowns; Loose–Tight; Set Defaults; one toolbar order, guarded
A term is read, or edited as one form: Edit, then Save or Cancel; Claim columns
No Abstract in the UI: a term is a Concept, a Class or a Property
A term and the list are read again together; the glossary spec waits a round-trip's time
A key column follows from its table's class; a property claims attribute columns
The Ontology View reads its search on the server, two hops deep, within a budget
The searched view's edge filter compiles in a nested where; the spec reads the view's own query
One To review bucket in place of Gaps, its findings in the term's panel
The page reopens as it was left -- its view, search and To review
A term in a domain drawn is connected, whatever other layers are on
Step 1 -- the glossary's definitions are the ontology schema's
Step 3 -- SPARQL serves the ontology schema as RDFS/OWL/SKOS
-- SPARQL joins the ontology's axioms to instance data
Each Class term is a table of the ontology schema
A Class table never takes a model table's bare label
A Class table is read only where the ontology schema is named
A bare name a Class shares with a table names the table
Refuse a Class that takes a definition table's GraphQL name
No requirement id in the terms view's SQL
A catalog description names no requirement

ontology-view¶

The owner-tables layer reads each column's table and the relationships declared from it

opioids¶

The tour's answers put the counties with a rate first, and show the ratio

ops¶

Ontology quality standard report

orgs¶

Serialize registry-view rebuild with org schema drops

otel¶

Define the native traces view without opening a batch
The audit writer's own work exports no trace
A request scope ends with its request span
A read of the native traces never opens a batch compaction removed

packaging¶

First launch offers groupexposure, as the sandbox tier's list does

perf¶

Starting the backends' host agent leaves the ssh session free
The server's serve stops on SIGINT; a stop that does not end says why
The checkpoint copy runs in one process; gsutil -m hangs on macOS
GraphQL audit rows reuse their governance; bench gRPC callers own their connections; the agent's backlog holds the RTT probe

pgwire¶

A read of ops/meta tables keeps its bound values (#279)
trust-mode auth reads the deployment org's derived roles
PostgreSQL wire conformance -- arrays, error fields, extended errors, cancel, transaction status, exact numerics
COPY on temporary tables, more temporary-table types, cancel without a torn message, length of a bytea on DuckDB, RAISE NOTICE
A passthrough statement deallocated behind it is prepared again; length() of a list on DuckDB
A catalog column and a catalog function answer as the type PostgreSQL 17 declares
A catalog column is stored as the type PostgreSQL 17 declares
A regproc or regtype catalog column is its name as text and its oid as binary
oid[], oidvector and int2vector catalog columns are written and sent as PostgreSQL does
An int2vector or oidvector catalog column is subscripted from 0, as in PostgreSQL
pgjdbc's getIndexInfo lists an index's columns
aclitem[], "char"[], inet and pg_lsn catalog columns are sent as PostgreSQL does
The catalog relations psql, pgAdmin and DBeaver browse with, with PostgreSQL 17's columns
The statistics relations pgAdmin and DBeaver read, empty, with PostgreSQL 17's columns
The text search, extension, large object and parameter ACL catalogs, with PostgreSQL 17's columns
Every remaining PostgreSQL 17 catalog relation, with its columns
A command on a subtyped model answers its command, not a read's shape
A catalog function a client calls is answered on its own
The server functions act on pgwire's own connections
A server function's pid is evaluated on a capped DuckDB, through its owner
The catalog functions clients call that had no answer
record-returning statistics functions and pg_sleep answer as PostgreSQL types them
pg_sleep opens DuckDB through the capped factory
Answer has_table_privilege and pg_get_expr from governed grants
A discovery read is never sent behind another of ours; it is STARTING at once
Send numeric(p,s) typmods and keep varchar/char native types
An oid column no longer breaks the catalog
Serve every catalog relation with PostgreSQL 17's shape
Catalog functions answer PostgreSQL's type and semantics
Serve the client-called server functions as PostgreSQL answers them
Catalog gaps - regclass vs name, typelem, key action codes, masked rolpassword, pg_stat_activity session
Serve pg_catalog function families as PostgreSQL answers them
Serve the remaining pg_catalog families as PostgreSQL answers them
Evaluate only constant arguments outside governance; test every signature
Answer the server functions as PostgreSQL 17.11 answered them
Tand is never minus zero; to_regclass gives a catalog relation PostgreSQL's oid
Serve money through the IR as PostgreSQL answers it
Serve the xml type, its syntax, xpath, xmltable and the governed SQL/XML mapping
float8 text as float8out, literals hold no placeholders, xids start at 3
A mapped document is xml on a PostgreSQL target
Metadata lives in meta, its functions in the compiler
The catalog views are listed to no person
pg_catalog and information_schema as views in meta
No catalog view in a subscription or a proto message
Placeholders with no space between them parse
A catalog route is not kept for its shape; types the wire has no form for
List a json column as json in the metadata type forms
Column privileges are the catalog's, xml is the compiler's; a catalog view refused off the admin terminal
Only named metadata reads the control plane; a statement with no table is the engines
Held types after functions; provisa_raise does not stop a pg engine; query errors in every locale
Every client statement on the admin terminal runs as the client role
A ClickHouse time is a time on the wire

pgwire, flight¶

A column transform plan streams to the caller

pgwire,flight¶

Every catalog a client sees is the served database

pipeline¶

A statement waits only for the servers its engine reads through
A statement that reads no source is the engine's; the default-source fallback is gone
A compiled read of a session temporary table goes to the engine
A compiled plan is kept per temporary-table session

polly¶

Every Explore page and the ERD, ontology, products read and set by Polly

profiler¶

A window whose MAD is 0 has no spread to measure a distance in
Columns classified from their sampled values; a steward accepts or rejects each
The classification statement's read is recorded as classification_attempts
No requirement id in the classification_attempts column's description
A run read as "Role: All" is read as the selected set

query¶

The GraphQL page's Semantic SQL panel opens its SQL on the SQL page (→)

ranges¶

Ranges and multiranges on every federation engine
Multiranges from columns are SQL for each dialect; ranges land on DuckDB
Forms corrected on real Trino, ClickHouse, MariaDB and SQL Server

rebuild¶

A role surface is built against the runtime that registered it

redis¶

A failed connect gives its pool slot back once (#284)

reference-library¶

Read PDF and Word documents
Lay the document domains out with the shared form layout
Declare documents, their domains and passages in the model-store inventory
re-embed documents of an earlier model from stored passages

regions tier¶

It names its demos with the sandbox tier's domain prefix

relationship-names¶

Names a change of naming convention respells are written in a model change

replica¶

A replica's name is lower case, so Trino reaches it
A floored MongoDB source's replica is built over its driver

replicas¶

A table declared again while its replica is dropped is built again
A replica's build lock is its region's, so each region builds its own copy
A held build and a waiting template say why
A reconcile keeps a landed replica whose key is not built yet
A replica re-created empty is recorded unbuilt and built again
A DuckDB engine's replicas are identified by the store they are written into
The landing reconcile leaves a row-level table's row cache alone
A build claim's locks are free once its close returns
A row-level replica's first read and first fetch need no schema made before
The pg engine's store is its own database; row landing runs in sets

replication¶

Log every replica build's start and end at WARNING

report¶

The model workbook's Ontology, Data Products and Data Profiling sheets, naming only what the caller is served
The model workbook's Data Quality sheet, and a product's inputs as its panel finds them
The model workbook's Data Contracts sheet and each term's axioms

residency¶

A read waiting on a build of a table with cache_ttl 0 is answered by its landing

rights¶

A column is read by the roles its grant names; scopes are domain, listed and public
A right is exercised in the domains of the roles that carry it, for relationships too
A listed role reads meta and ontology as a "*" role does
System domains are capabilities, flattened into domain_access

roles¶

CI fixes for the standard roles
The sandbox manages no environment; integration suites follow the standard roles

routing¶

Sources share a direct connection only under the same login
A statement is landed unless it passes every gate
The source contract decides trusted_to_answer; Qdrant keeps its exact reads
A route hint written as a SQL or Cypher comment is applied on every SQL and Cypher transport

row-level¶

A filter's record is created in its schema when the schema is not there yet
The key pushdown probe keeps a statement's own LEFT JOIN single

row-materialize¶

A source type declares whether it fetches rows by keys
A keyed fetch that lands no row says so in the server log; the flight healthcheck reads each answer until it is fully loaded
A join-reached row-level replica exists before the key-pushdown probe reads it

sandbox¶

The sandbox tier merges the traces it lands
A region template's store is pinned once its model is loaded
The disk cannot fill and a source error names no address

sandboxes¶

A demo's visitor carries the attributes its demo.yaml declares

scheduler¶

A closing holder releases its lock before its session ends

schema¶

An existing relationships table gains same_entity at startup
A derived view's columns are the ones it is registered with, not an engine's information_schema
table_columns.subtype in schema.sql, as schema_org has it
A per-domain schema offers only the asked domains' root fields; meta filters like any domain

scripts¶

The startup banner lists the SPARQL endpoint

security¶

Standard roles composed by union over several parents
Owned environment management, dq_read for profile reads, tour standard roles
A role's panel shows its capabilities with the role each comes from
A capability comes from every branch it enters in; the role lineage reads at body size
column_served is the only column-visibility rule
The read_restricted capability is removed
A role's Data access tab and a table's Access section
A role's LLM budget: a per-call cap and rolling windows counted in the control plane
An LLM service call's output is held to its role's allowance, never withheld
A row rule has a right, and U and D rules hold data and model writes
A row rule carries a set of rights
The Owner field gives RW on data products with generated row rules
A role's refusal names no requirement; tests follow the read signature and the capability refusal

server¶

The health probe answers fast and says busy; a rebuild compiles with no connection held
A request still waiting for a thread says what holds them all
On a timer, what every request awaits and where every thread is

servicenow¶

Offer only import sets the instance can read; the e2e grants its writes
A companion's operations are offered once it is saved; the e2e writes name published columns

settings¶

Every catalog setting is named and explained, in every locale
Network and TLS opens General and HTTP at first
Drop the settings text no catalog setting reads

site¶

Every page's navigation has the home page's "How it works"
Hero shows one hook pair even with a stale cached stylesheet
Six problem cards in two rows of three; one-model copy says keep your tools in sync, or use Provisa alone
Download section: one-line licence pointer; sandbox sentence without the stale hosted-service plan
Starburst comparison reflects Gravity, data products, MCP; contrasts SQL-analytics centre with one model across tools
Comparison sources are the verified ones; drop an unverified Denodo claim
Provisa defines federation; the engine you choose runs it
Shorter nav labels (Works, Demos) to fit the navbar
Crawler copy states per-format table detection (confirmed by the maintainer)
One Download in the navbar (the button)
Catalogs page states what Collibra Protect and Atlan actually push, with sources
Compare hub engines row: partial reach, varying governance, data gravity, cloud lock; adds Fabric
Engines row: pros and cons, use the best one for each job and switch when wrong
Space between consecutive section paragraphs
Four language panels across, narrower padding and gap
Every page carries the home page's footer
The How it works page's own nav says How too
Landing pages carry the home nav label and footer
Consecutive spotlight paragraphs are spaced apart

sources¶

A source save is one createSource/updateSource carrying every setting
A deleted source's catalog walk is stopped before its catalog goes
A deleted source's server is stopped and none outlives its deletion

sparql¶

Type a table's columns by its bindings' XSD datatypes
Push a statement's conditions and LIMIT into a SPARQL table's query
A source's HermiT reasoner serves inferred classes and properties as tables
Every call to a SPARQL endpoint names Provisa in its User-Agent
A source's tables are asked for JSON results, and an answer that is not JSON says what it is
The SPARQL front end, rdflib's algebra lowered to the graph IR
The SPARQL 1.1 Protocol endpoint, GET and POST /data/sparql
GROUP BY, HAVING and aggregates
Results serialize to a buffer, so the writer returns bytes; requirements.md regenerated
Every SPARQL refusal is the app's error body with its own code
GET /data/sparql/vocabulary, the role's vocabulary as IRIs
A negated set of forward and inverse edges, !(a|^b)
REGEX flags, and REGEX finds its pattern anywhere in the text
GROUP BY an expression
Scalar functions -- string, numeric, date parts, NOW and xsd casts
A group's FILTER and a BIND that reads an OPTIONAL's variable are read after the OPTIONALs (#301)
An OPTIONAL binds its variables only where it matches as a whole (#302)
An OPTIONAL nested in an OPTIONAL is lowered, never dropped
The response-cache opt-in and provisa_stats on /data/sparql; the bench profiles and caches SPARQL
The SPARQL tab under Explore -- the graph visualizer with SPARQL's vocabulary
Open as query exports a GraphQL read as SPARQL, exact or refused
A read with no SPARQL form is answered with why, never a failed compile
A local install sets server.public_url; the refusal names where and what
The SPARQL tab exports RDF and SPARQL results, not Neo4j
Integer and decimal division by zero is an expression error
A term-bound column is published under the term's property IRI
The open pattern answers what a role can name, with no self-join
Selecting a node lists its properties; classes grouped by prefix
A variable predicate reads as its parts in every position

sparql-tab¶

The vocabulary is read as main's endpoint answers it, with superclasses; a CONSTRUCT's edges are drawn
One vocabulary pill per IRI; the e2e CONSTRUCT gives its subject a class
A SPARQL frame reads as SPARQL and offers no auto-impute

sql¶

A batch on /sql answers one result per statement, each under its own tab
A result's columns are keyed by position, so two of one name each keep their value

sql-canvas¶

Select every column at once; joins built from what SQL allows

store¶

A session's temporary tables are dropped through the embedded store's broker

subscriptions¶

A subscription keeps delivering

tables¶

Registering a checker table asks why the check exists, its quality claim
A snapshot calendar's version is named once in the picker; its create dialog's close gets the test's budget

tags¶

Pii on a Property term covers its columns; a move confirms the tags it takes
A move asks to confirm only a tag the column stops carrying
Pii terms in environment trees, the REQ, and the rest of the tests
No requirement id in view SQL; a ref move reports its tag changes

term-finding¶

A document scan always finishes or stops saying why
schema.sql carries the scan progress columns
One dense batch no longer fails a scan

time-travel¶

Time travel as arguments of the relation
One versions read, on the governed statement, at each reference's time
A bound time keeps the relation's name as written; the banking test reads by arguments

tour¶

A profile graph step stops at once when the table has no run
A relationship step on the open page searches its own alias
Demo tours run what they explain and cancel what they show

tour,e2e¶

The Deep Dives menu reads the cached catalog; two core-lane specs stop paying cold loads they do not test

traces¶

One process compacts a trace folder at a time, an input at a time, and every test server lands its own

transpile¶

An instant literal reaches the MySQL family as its UTC wall time
Snowflake, MySQL and ClickHouse write a null-on-failure cast too; every route transpiles

transpiler¶

A JSON value read whole and a filtered list survive the semantic SQL's rewrites
One rule for PostgreSQL functions; shapes, tsvector, inet and money as forms
time(x) reads the function table on every dialect
Crypto hashes give PostgreSQL's answer or are refused by name
operator-named functions as one generated table
PostgreSQL json functions as a table of forms, replayed on DuckDB, Trino and ClickHouse
The array functions as forms, replayed on DuckDB, Trino and ClickHouse
VARIADIC multiranges, multirange_cmp and range_union of a NULL
The enum functions, a source's enum resolved in its catalog, gate fixes
No function gives a wrong answer on the replayed engines
A bound percentile fraction is the engine's to check
A JSON aggregate's FILTER is its inner aggregate's on DuckDB
A timestamp in JSON answers the same at any depth on DuckDB
ts_filter's row has its own name, refusals pinned
A list of timestamps stays a JSON array on DuckDB
Trino's regexp_extract is NULL where it finds nothing

trino¶

A MySQL-family catalog names no database in its URL
A JDBC catalog sets statistics.enabled only where the connector takes it
An instant read live through Trino is carried at UTC with its zone
A ClickHouse source gets a Trino catalog; a JDBC source with no URL is refused by name

ttl¶

A parameterized table keeps its rows only for a TTL of its own

types¶

GraphQL and proto map a long-form SQL type as the Arrow catalog does
IR subtypes recorded at registration, reported by pgwire and its catalog
A timestamp column keeps its declared precision and is read at its unit
One subtype per distinct PostgreSQL type
A source type that fits no IR type registers as text
Subtypes keep native semantics; land in their own form or not at all
Trino's inet emulation from the functions Trino 481 has
An inet or cidr operation on Trino is refused by name
A time column keeps its declared precision and is read at its unit
Register ClickHouse Nullable/LowCardinality IPv4/IPv6 as inet; document subtype mappings

ui¶

A checker table is assigned to a product as any member is
The Glossary toolbar is search, an Ontology view icon, + Term, one AI menu, then help
Glossary is renamed Ontology, at /admin/ontology, in the UI, the tours, Polly and the docs
A SPARQL source names its reasoner and OWL axioms
The page chunk warm-up starts after the opened route's page, never ahead of it
Every 3D graph remembers its view settings across reloads, per graph, with a reset
The page chunk warm-up stops with the app and leaves no import in flight
The Ontology View's Data layer shows each product's dataset columns; a Tables checkbox draws the tables of the columns drawn
A table is a cylinder in every graph, a profile result a torus; the Tables checkbox is remembered with the graph's settings
The legend's cylinder and ring are drawn with radius and border alone, so an exported image paints them
Every 3D view exports an image or a recorded turn
The export's scale, length and last formats are remembered, the last formats checked
The Ontology View opens as its query (→): GraphQL as it runs, SQL and Cypher as it compiles, SPARQL later; its filters are in the query
Open as query says why a focus leaves it closed
The product graph is one query with its domain, tag, sensitivity and edge type filters in it, and opens as that query (→)
A term grounded in tables, a table's rows as instances of a term, and each term's role
A search focus with Tables stops at each table it reaches
A hint held open waits for its target; a page that fails says so in place
The graph sidebar shows the page it can, when a domain deselected shortens its lists
The app's splash runs the front door's binary streams, from one shared renderer
Pii on a term or a column, and one tag-loss question for every move a person makes
A linked item's panel leaves the focus in a dialog open over the page
Escape in a popover or menu inside a detail panel closes only it
Every icon-only button is borderless but five drawn filled or bordered on purpose
The splash's binary streams inline into index.html only, so the build's other HTML entries build again
The SQL explorer's schema list filters meta and ops by the Domains menu like any domain
The SQL canvas wires one join per relationship, so removing a join clears its line
Ids come from crypto.getRandomValues, so pages render outside a secure context
The GraphQL page never scrolls past GraphiQL
A glossary term's read view draws its neighbourhood as a layered graph
The Ontology view names a relationship by its served Cypher type, never its id
An assembling-cube loader for long waits, on the demo-opening page
js-yaml is declared for the typecheck
The listed names use the naming module; tests name the roles their grants and masks are for
A table's access column picker is a form field, its explanation the hint below it
The lifecycle status type lives in types/, so types/admin.ts imports no component
Every read the picker makes acts as the selected roles, "Role: All" included
A column's subtype beside its base wherever its type is shown
Layered layout for network graphs, Force/Layered control, lateral arcs
A layered layout opens face-on and fitted in 3D, refitted when the layout kind changes
SPARQL page pills by direction, domain selector and per-label colours
SPARQL answers drawn as the Cypher view draws them
SPARQL nodes captioned by name or IRI tail, drawn SELECT labelled by class
SPARQL class nodes captioned by local name, compacted name kept
A graph caption longer than its node scales down before it truncates, full name on hover
The literals toggle is a toolbar chip, as the graph explorers' toggles are
A graph caption stays inside its node or goes beneath it in two lines, no font scaling
A role's LLM budget on its form, and each window's use on its page
One caption source for the node canvas; its placement is no longer overridden per node
The Cypher page lists the graph session's labels and types, dashed and counted, with Clear session
A table whose source's API document could not be read says so: a mark in its row, the reason beside the endpoint
The endpoint-error mark uses the shared Tip, not the library Tooltip
Only the session's language catalog is loaded; English stays bundled
Ontology term chips show a ground icon in place of the "grounded" text chip
SPARQL vocabulary terms and concepts follow the checked domains
Three random demo-sandbox loaders (cube, cardboard box, gift box)
Explorer groups ontology/ops root fields by SDL prefix alone
Escape Mermaid chart labels; show an unparsable chart in place
Graph detail names wrap; crossing minimisation in the layered and lane layouts
Readable 3D graph labels; the Ontology graph follows the navbar's domains
3D graph keeps its layout; crowded pairs are moved apart in 2D only
Keep every Analyze operator row on screen for a deep plan
The Ontology view draws only what a shown term reaches
Plan diagram zooms to the pane width; tall plans scroll
A product's contracts are a list beneath its lineage (WIP)
Open in ERD from the Ontology table detail
The ground symbol shows on Concept terms only
Explorer clear-query button; SPARQL class/property pills run their own result card
Contract version types live with the admin types, so the graph renderer build reaches no api code
Graph labels at half the size they were drawn
Term review queue meets form and collapsible guards
The SPARQL explorer as an RDF person expects it
One ERD view in place on Tables and Relationships, each with its own panel, and a focus that is a link
A contract shows Versions and changes right after its Details
Input Ports and Consumers cards always shown
Show ontology drift with the quality report
SPARQL endpoint prefixes use the shared collapsible; guard entries for in-place inputs
The page filter dims what the ERD does not match, and is not in the link
The explorer fork's content is part of Vite's optimizer hash, so an edit reaches the page
Meta queries answer under the GraphQL field names
Meta rows arrive under camelCase keys in any convention
Graph and panel table labels use catalogTableName
Open a live demo for every browser, signed in or not
SPARQL page reads as Cypher: panel prefixes on Run, class prefixes, group union, plain relationship names
Browser storage cannot crash or stop the app
List HTTP surfaces in health, multiselect term status
A pill dropped on a SPARQL frame edits its query
Read the node under a dragged node before the nudge moves it
A tour step pending stands alone, a visit opens in no environment, the nav holds one line
Correct why a visit starts in no environment
A full browser store gives up other control planes' entries, oldest first

ui-dev¶

The dev server forwards a product's own reads (/data-products/…) to the backend

ui-server¶

A regions sandbox or demo whose region no node serves is refused by name

warehouse lane¶

No Snowflake credit cap; Databricks stop re-sent until taken; Dataplex teardown polls only operations

General¶

A rewired replica runner stops the one it replaces; schema_gen binds its config's settings
The vulnerabilities demo grounds CWE in the weakness class; bounded-memory reads are ordered
A deleted org's entries leave every process cache; one org's row counts are never another's
A DuckDB order by an output name a source column shares sorts by the output; the pg engine lands into a schema its store does not hold yet
Team page title keeps a gap above its subtitle (J206)
Integration fallout -- composites land as JSON, system schemas take no domain's alias, tests pin their state