Expand description
ingraph — the indexing framework, regrown demand-driven.
A declaration is a Rust type wearing one of ingraph-derive’s words, and what it buys is the
road under it: the key and lineage types the record is addressed by, the rows a backend stores
it as, the node it is computed in and the edges data crosses to reach one, and the filters,
orderings and GraphQL face a client asks it with.
§0.1 is a first cut
Everything here may change or disappear in a later 0.x. No API is settled and no migration is
promised. The surface is not a design that was drawn and then filled in — it is what the entry
rule below has admitted so far.
§The entry rule, which is not a phase
Nothing enters until something LIVE asks for it: the codegen emits a path that has to resolve, a test names a type it cannot compile without, a downstream crate breaks for the want of it. There is no round where an item is added because it will probably be needed and revisited later. This crate was empty when that rule was written and it is not empty now; the rule is what the difference was grown by, and it is what the next version will be grown by too.
§Where items come from
legacy/ingraph — the previous ingraph, moved and renamed ingraph-legacy, still building
and still green. It is a source to pull from, not a codebase under repair.
The rule for taking something out of it is MOVE, NOT REWRITE. The item crosses as it stands, together with its tests, and it is re-read on the way. The re-reading is where judgement is spent; the keystroke is a move. An item that arrives rewritten has lost the one thing the legacy crate was keeping for it, which is the record of what it was already made to survive.
§Why a demand filter and not a cleanup pass
What the previous crate accumulated was not bad code. It was items whose REASONS had died: a seam for a backend nobody ever opened, a knob belonging to a design that had since been replaced, a conversion for a vocabulary two refactors ago. Reading such a crate to decide what to delete does not scale — every item still reads as defensible on its own, and the evidence that would condemn it is the ABSENCE of a caller, which is not visible from the item.
A demand filter never has to make that judgement. An item with a dead reason is structurally impossible here, because entry requires something live to ask, and a dead reason has nothing left to ask with.
§When legacy/ingraph is deleted
When nothing points at it. That is the acceptance criterion, and it is mechanical on purpose — not a call about whether the remainder still looks worth keeping, and not a final pass to decide. While one edge into it survives, it stays. When the last edge goes, it goes.
§Why items travel with their tests
legacy/ingraph carries ~41k lines of tests, and what those encode is not structure — it is
MEASUREMENT. Engine probe results (what a deleter does rather than what its docs say; what a
maintenance call corrupts under concurrent writes), byte fences over durable rows, mutation
pins standing exactly where a plausible-looking change was proven wrong. None of it is
recoverable by reading the item it guards, and re-deriving it costs what it cost the first
time. The tests are therefore not a follow-up to a move — they are part of one.
§What the root re-exports, and what it does not
The root carries what a PERSON writes: the traits a downstream implements or names —
FromFilter, TryFromFilter, ToDatabaseComparison, and Carrier and TemporalStorage
where their features are on — and the storage types a declaration names, which are resolved in
the DECLARER’s own scope and so have to be reachable under a name a declarer can use.
Those storage types are the one group whose re-export carries NO backend’s feature, and the
difference is load-bearing rather than tidy. BeU64 and its neighbours are declared in
storage, beside no family at all, because a big-endian encoding names no database: gating them
on sqlx — which is where they used to sit — made a u64 field declarable on SQLite and
undeclarable on MongoDB for a reason belonging to neither.
FieldName is here for a second reason on top of that one: it is what every backend family
addresses a column or a key by, so putting it beside one of them would make the other’s use of
it read as a borrowing. SlotName joins it under no feature for the first reason alone — an
index’s name is written where the impl naming it is, and a const is spent in the declarer’s
scope.
Transformer, FulltextRecord and FulltextTable are on the first count and share the
second: they are what a full-text declaration implements, and a document, a key and a slot name
no engine, so a build with no backend family has to be able to spell all three. The engine’s
half of that surface is no longer a record trait at all: A′ took the record off the engine
seams, so what an engine names is its own entry builder and its own address vocabulary — and
there is no per-engine capability left at all, since a key reports itself in COLUMNS (Field,
one impl per TYPE) and every engine reads every row. LocalFsBlobRecord is still here under
nothing, a backend that needs no feature having no gate to carry.
The QUERY layer is not lifted either, and this one is a NAME rather than a family: Edge is
already the arrangement layer’s word for a channel between two nodes, and a relay edge is a row
with a cursor on it. Two vocabularies, one word — which the module structure has already solved,
so query::Page and query::Edge stay together at their real path rather than one of them
being renamed to reach a root the other could not. query is public for that reason.
The TRANSPORT is not lifted either, and it is the same argument at a different register:
Sender, Receiver and bounded are the plainest words a channel has, and a root that already
carries Outbox, Inbox, Feed and a channel FUNCTION would be answering to two
vocabularies through one door. So conduit is public and its household stays at that path —
where conduit::Sender reads as the general transport and cannot be mistaken for the declared
data edge one layer up.
shard keeps its household for the same reason and one of its own: Router, Bench and
Crew are a DEVICE’s vocabulary rather than the framework’s, and a root that answered to them
would be saying that a node’s internal crew is something this crate arranges. It is not — the
framework knows what nodes exist and how they connect, and what stands behind a node’s door is a
library a body reaches for by name.
A backend family’s implementation surface stays at its real path. The comparison types, their
conjunction accumulator and the render helpers are what an expansion emits rather than what
anyone writes, so they live at comparison::sql and are not lifted. The rule is worth stating
because the alternative looks harmless: flattening a family into the root costs nothing at the
moment it is done and quietly makes the second family’s SqlNullable and MongoNullable a
naming problem the module structure had already solved.
§The four gates
if_sqlite!, if_postgres!, if_mysql! and if_mongo! are the root’s BACKEND macro
surface and the whole of it: each expands the tokens it is given where THIS crate was built with
that backend, and to nothing where it was not. (bare_options!, bare_origin_options! and
bare_resource_options! are the root’s three other macros, and they are a different kind of
thing — see the launch walk’s own note for why a question about a trait impl can only be asked
at a call site.)
What they are public FOR is that a per-backend half of a declaration is not always emitted. A composite comparison, a conversion only the declaring crate knows how to write, a kind this crate does not ship — those are written BY HAND beside the emission, and a hand-written half for one backend has exactly the coupling an emitted one has. The gate is what relieves it, and it is the same macro the emission spends rather than a second one shaped like it.
§Why a #[cfg] asks a different question
#[cfg(feature = "postgres")] is evaluated in the crate it is WRITTEN in, against that crate’s
Cargo.toml. A declaration living in an application has no postgres feature of its own, so the
predicate is false wherever the application did not happen to declare a same-named feature — and
true, wrongly, wherever it declared one meaning something else. The attribute reads as though it
asked is Postgres compiled in, and asks did this crate name a feature postgres, which is a
different question with a coincidentally similar spelling.
A macro moves the decision to where the answer is. The #[cfg] that selects which definition is
compiled is ingraph’s own, read against ingraph’s feature table; the crate invoking it only
invokes it. So the condition is evaluated once, by the crate that knows, and the expansion carries
no predicate at all.
§A gate may name what the build does not have
Each gate slurps tts rather than items, and that is the property a hand-written half spends.
An item fragment is PARSED before it is matched, so a gate over tokens naming a type only some
builds have would fail to parse in the builds that do not — which is the failure a shut gate
exists to avoid. Tokens are matched without being parsed, so a shut gate discards them before
anything in them has to resolve: use ingraph::comparison::mongo::… inside if_mongo! is
silence in a build without MongoDB rather than E0432.
§What a gate makes a declaration MEAN
An item behind one of these exists per declared ∩ compiled-in backend. A declaration naming
three databases in a build carrying one gets the one, and the other two are not deferred — there
is no impl, so a party demanding one is E0277 where it demands it.
That is what keeps DECLARE-MANY/BUILD-ONE intact while the storability audit is on. Naming a
concrete backend in an impl discharges every column’s crossing at that backend, which is the audit
and is the point; done ungated it would also make a declaration that names Postgres fail to
compile in a build without the Postgres driver, which is the invariant query::sql states from
the other side. Gated, the audit runs for exactly the backends the build has, and a build
compiling two engines and choosing between them by an options file at runtime has proved at
COMPILE time that every record it stores is storable in both.
§The words a declaration is written in
record, entity, fields, operator, fulltext,
vector,
blob, interface, graph, resource,
journal and mutation are ingraph-derive’s attribute macros, re-exported
here whole under the derive feature. #[ingraph::record(…)] is the spelling.
Enum and Union are the two DECLARATION DERIVES, and the form is the
difference in what the word does: the attributes above REWRITE the item they sit on, where these
two add impls beside a type they never change. #[derive(ingraph::Enum)] is the WHOLE of what a
vocabulary takes — the storage citizenship, the filter and the wire face are one word, because
which schema an enum reaches is reachability rather than a second declaration — and
#[derive(ingraph::Union)] equips a payload-carrying enum with the way Rust asks which member it
holds, plus whichever of the two schema positions its graphql(…) word asked for.
They are at the root for the reason everything above is, and the rule needed no widening to reach them: THE ROOT CARRIES WHAT A PERSON WRITES, and a declaration is the thing a person writes most. What is new is only that the surface is not a type — a trait a downstream implements and an attribute a downstream applies are the same kind of name from the vantage that matters, which is the one where somebody is holding a pen.
§ONE dependency, and the expansion is what makes it one
A macro crate re-exported at its framework’s root is usually a convenience. Here it is what makes
the default expansion correct. Every one of these emits ::ingraph::__private::… absolutely —
see [__private] for why an emitted path is rooted and not resolved — so an expansion lands in a
crate where the name ingraph has to denote the framework. Reaching the attribute through the
same crate is what guarantees that: the dependency supplying the word and the dependency
supplying the path it writes are one entry in one manifest, and cannot be half-present.
crate = "path::to::ingraph" is the escape for a consumer that renamed the dependency or reaches
the framework through a shim of its own, and it stays what it was — the option is for a crate
whose ingraph is somewhere else, not for one that has to assemble the framework from two.
§Why the words are DEFAULT-ON
Every feature outside the tier ladder below is something a build ASKS for: a vocabulary it declares fields of, a wire binding, a dialect, an engine. This one is what the crate looks like to the party that declares against it, and a root surface reachable only by naming a feature is not a root surface — a declarer would meet the framework by first being told the framework is off.
The opt-out is what makes that defensible rather than a decision taken for everybody:
default-features = false, features = ["runtime"] declines the whole proc-macro tier, and a
consumer that RUNS a graph and declares nothing gets exactly what it had. The tier is spelled
back because this feature IMPLIES it — see the tiers — so dropping the default
drops the layer with it unless the layer is asked for by name.
§ingraph::interface is a module AND an attribute
It is not a collision and needs no rename on either side: a module lives in the type namespace
and an attribute macro in the macro namespace, so ingraph::interface::InterfaceKind and
#[ingraph::interface(…)] resolve past each other. record and operator are the same shape
against private modules. The claim is pinned from outside the crate in tests/downstream.rs,
which is the only vantage a public name can be judged from.
§The macro crate keeps its own name
ingraph-derive is still a crate, still published, still tested directly — this is a SECOND name
rather than a move. Its own corpus spells ingraph_derive::record on purpose: that suite’s
subject is the macro, and a fixture reaching it through this re-export would be testing the
re-export instead.
§The tiers
Three features cut the crate into a LADDER rather than a lattice — derive ⊃ runtime ⊃
engine ⊃ the core — each naming the one below it. A build picks a rung; there is no
combination to get wrong and no powerset to test.
- The core, which is
default-features = false, is the VOCABULARY layer: what a declaration is spelled in and what it lowers through. The scalar roster and the filter machine, the marker interpretation, the comparison crossing traits, the storage forms, the keys and cursors, the column shapes and the schema descriptions. A downstream crate that declares field types of its own and joins this crate’s filter vocabulary — implementingToGraphqlFilter,Marker,ScalarFilterand their neighbours for its own types — needs exactly this and no rung above it. engineaddsretrieve: the road a question travels, the mechanisms adedup(…)word selects between, the fold semantics, the fusion tree and the search tower. It pulls no dependency at all, which is why it is a rung rather than part of the one above.runtimeaddsarrange,drive,operator,resourceandsource— the layer that RUNS a graph — and six dependencies with them:flume,cronpandagnostic-lite, which are what the layer cannot run without, andderive_more,futures-coreandfutures-sink, which are what nothing BELOW the layer ever named. The five modules arrive as one word because they name one another: no cut inside the block leaves a compilable half. It also carriesjiff-tz, jiff’s TIME ZONE DATABASE, becausedrive::poll::calendaris the one thing here that asks for a zone by name — a build below this rung keeps every jiff type and loses only the resolution of an IANA name. That word is public, so a build wanting the database and not the scheduler names it and stops.deriveadds the words a declaration is written in, and impliesruntime.
§Why derive implies runtime
Because an expansion writes ::ingraph::__private::<segment>::<Item> ABSOLUTELY and cannot put
a #[cfg] over one. A #[cfg(feature = "runtime")] written inside an expansion asks whether
the DECLARING crate has a feature by that name, which is the four gates’
whole subject — so the alternative is a gate macro pair of this crate’s own wrapped around every
emitted path that names a tiered segment. The implication states it once instead, and states it
where a consumer can read it.
What the implication forbids is a build that can DECLARE a graph and has no layer to run one, which is not a configuration anyone asked for: a declaration IS a graph.
A consumer reaching the attributes as ingraph_derive::record rather than ingraph::record is
outside the implication and names the tier itself. That is one crate — this workspace’s own
fixture corpus — and its manifest says so where the dependency is declared.
Re-exports§
pub use comparison::TemporalStorage;jiffandtimepub use comparison::mongo::Mongo;mongopub use comparison::mongo::MongoCarrier;mongopub use comparison::sql::BindCeiling;sqlxpub use comparison::sql::Carrier;sqlxpub use comparison::sql::JsonElement;sqlxpub use comparison::sql::NullOrder;sqlxpub use comparison::sql::QuoteIdent;sqlxpub use comparison::sql::MySqlDuration;jiffandmysqlpub use comparison::sql::MySqlDurationError;jiffandmysqlpub use comparison::sql::PgDuration;jiffandpostgrespub use comparison::sql::PgDurationError;jiffandpostgrespub use comparison::At;pub use comparison::Backend;pub use comparison::CollapsibleComparison;pub use comparison::ComplexComparison;pub use comparison::CompositeComparison;pub use comparison::Frame;pub use comparison::FromFilter;pub use comparison::Path;pub use comparison::RecordAddress;pub use comparison::ReferentialComparison;pub use comparison::ToDatabaseComparison;pub use comparison::ToRelatedComparison;pub use comparison::TryFromFilter;pub use drive::Ack;runtimepub use drive::AckMode;runtimepub use drive::AckReceiver;runtimepub use drive::AckSender;runtimepub use drive::AfterClock;runtimepub use drive::Answer;runtimepub use drive::Answered;runtimepub use drive::Answers;runtimepub use drive::App;runtimepub use drive::Arm;runtimepub use drive::ArrangementError;runtimepub use drive::Arrival;runtimepub use drive::Assembly;runtimepub use drive::AsyncAnswers;runtimepub use drive::AsyncChanges;runtimepub use drive::AsyncConstructor;runtimepub use drive::AsyncInitialize;runtimepub use drive::AsyncLands;runtimepub use drive::AsyncServes;runtimepub use drive::AsyncSpawn;runtimepub use drive::AsyncTeardown;runtimepub use drive::AsyncTick;runtimepub use drive::AtMostOne;runtimepub use drive::Attached;runtimepub use drive::Attaches;runtimepub use drive::Attributes;runtimepub use drive::Autonomous;runtimepub use drive::AutonomousBody;runtimepub use drive::Awaiting;runtimepub use drive::Backpressure;runtimepub use drive::BareOptions;runtimepub use drive::Blueprint;runtimepub use drive::BoxedError;runtimepub use drive::Buffered;runtimepub use drive::CURRENT_TABLE_PREFIX;runtimepub use drive::Cadence;runtimepub use drive::Calendar;runtimepub use drive::CalendarError;runtimepub use drive::CatchUp;runtimepub use drive::Cell;runtimepub use drive::ChangeIntake;runtimepub use drive::ChannelOptions;runtimepub use drive::ChannelShelf;runtimepub use drive::Channels;runtimepub use drive::Coalesce;runtimepub use drive::Commit;runtimepub use drive::Concern;runtimepub use drive::Context;runtimepub use drive::Creation;runtimepub use drive::Culled;runtimepub use drive::Curator;runtimepub use drive::CuratorBody;runtimepub use drive::CuratorReport;runtimepub use drive::CurrentRow;runtimepub use drive::CurrentTable;runtimepub use drive::Custody;runtimepub use drive::DEFAULT_BATCH_MAX_ITEMS;runtimepub use drive::DEFAULT_BATCH_MAX_WAIT;runtimepub use drive::DEFAULT_DEBOUNCE;runtimepub use drive::DEFAULT_FEED_DEPTH;runtimepub use drive::DEFAULT_IN_FLIGHT;runtimepub use drive::DEFAULT_KEEP;runtimepub use drive::DEFAULT_RETIRE_DRAIN;runtimepub use drive::DEFAULT_SETTLE;runtimepub use drive::DeadlinePolicy;runtimepub use drive::Deadlines;runtimepub use drive::Declared;runtimepub use drive::DeclaredResident;runtimepub use drive::DefaultServe;runtimepub use drive::Delivery;runtimepub use drive::DisabledUpstreamError;runtimepub use drive::Door;runtimepub use drive::Doorbell;runtimepub use drive::Downstream;runtimepub use drive::Drained;runtimepub use drive::DriverEngine;runtimepub use drive::Drives;runtimepub use drive::DropNewest;runtimepub use drive::DropOldest;runtimepub use drive::DroppingUnboundedError;runtimepub use drive::EdgeTypeError;runtimepub use drive::Effect;runtimepub use drive::Enablement;runtimepub use drive::Enrolled;runtimepub use drive::Evictor;runtimepub use drive::Failure;runtimepub use drive::Fate;runtimepub use drive::FeedContext;runtimepub use drive::FeedPolicy;runtimepub use drive::Feeder;runtimepub use drive::FeederAbsentError;runtimepub use drive::Fixed;runtimepub use drive::Flip;runtimepub use drive::Flow;runtimepub use drive::FulltextAsk;runtimepub use drive::FulltextScope;runtimepub use drive::GenerationLedger;runtimepub use drive::Generational;runtimepub use drive::GenerationsEngine;runtimepub use drive::GenerationsOptions;runtimepub use drive::GenerationsOverride;runtimepub use drive::GenerationsStore;runtimepub use drive::GenerationsStoreError;runtimepub use drive::Goodbye;runtimepub use drive::Grant;runtimepub use drive::GrantsNoStoreError;runtimepub use drive::Group;runtimepub use drive::Habitats;runtimepub use drive::Handover;runtimepub use drive::Harvest;runtimepub use drive::Helm;runtimepub use drive::Hint;runtimepub use drive::Ignition;runtimepub use drive::InFlight;runtimepub use drive::Inbox;runtimepub use drive::Initialize;runtimepub use drive::Initializes;runtimepub use drive::Intake;runtimepub use drive::IntakeError;runtimepub use drive::Invoke;runtimepub use drive::Invokes;runtimepub use drive::Item;runtimepub use drive::ItemId;runtimepub use drive::Joins;runtimepub use drive::JournalDrain;runtimepub use drive::JournalQueue;runtimepub use drive::JournalRow;runtimepub use drive::JournalTap;runtimepub use drive::JournalWriter;runtimepub use drive::Keeper;runtimepub use drive::KeeperBody;runtimepub use drive::KeeperReport;runtimepub use drive::Landing;runtimepub use drive::Lands;runtimepub use drive::LandsNowhereError;runtimepub use drive::LaneMount;runtimepub use drive::LaunchError;runtimepub use drive::Ledger;runtimepub use drive::Lifecycle;runtimepub use drive::LifecycleTap;runtimepub use drive::Lineage;runtimepub use drive::Listen;runtimepub use drive::MakesNothing;runtimepub use drive::MandatoryOptionsError;runtimepub use drive::MandatoryResourceOptionsError;runtimepub use drive::MemoryAware;runtimepub use drive::MemoryProbe;runtimepub use drive::Missed;runtimepub use drive::MissingResourceError;runtimepub use drive::Mount;runtimepub use drive::MountBody;runtimepub use drive::MountedLane;runtimepub use drive::NoDeadline;runtimepub use drive::NoDefaultOptions;runtimepub use drive::NoRetry;runtimepub use drive::NodeAttribution;runtimepub use drive::NodeBody;runtimepub use drive::NodeName;runtimepub use drive::NodeSection;runtimepub use drive::NodeWiring;runtimepub use drive::Notified;runtimepub use drive::Nudge;runtimepub use drive::Observation;runtimepub use drive::Occupancy;runtimepub use drive::Onward;runtimepub use drive::Outbound;runtimepub use drive::Outbox;runtimepub use drive::OverflowDecision;runtimepub use drive::OverflowPolicy;runtimepub use drive::Owed;runtimepub use drive::Owing;runtimepub use drive::Page;runtimepub use drive::Pairing;runtimepub use drive::Party;runtimepub use drive::Payload;runtimepub use drive::PayloadIter;runtimepub use drive::Plan;runtimepub use drive::Policies;runtimepub use drive::PolicyShelf;runtimepub use drive::PollUpstream;runtimepub use drive::PositionKey;runtimepub use drive::Positions;runtimepub use drive::Posted;runtimepub use drive::Pressure;runtimepub use drive::ProductSeatError;runtimepub use drive::Pulled;runtimepub use drive::PureLeafError;runtimepub use drive::QueryArm;runtimepub use drive::QueryDeadline;runtimepub use drive::QueryError;runtimepub use drive::RETIRED_TABLE_PREFIX;runtimepub use drive::RUN_COLUMN;runtimepub use drive::ReceiptMap;runtimepub use drive::RecordedPositions;runtimepub use drive::RecordingTap;runtimepub use drive::Recurrence;runtimepub use drive::Refusal;runtimepub use drive::Registries;runtimepub use drive::Registry;runtimepub use drive::RegistryCounts;runtimepub use drive::RegistryDriver;runtimepub use drive::RegistryOptions;runtimepub use drive::RegistryOverride;runtimepub use drive::Reply;runtimepub use drive::Resident;runtimepub use drive::ResourceSourceError;runtimepub use drive::Resources;runtimepub use drive::Responding;runtimepub use drive::RetireOrigin;runtimepub use drive::RetiredEngine;runtimepub use drive::RetiredLedger;runtimepub use drive::RetiredMirror;runtimepub use drive::RetiredOptions;runtimepub use drive::RetiredReader;runtimepub use drive::RetiredReaders;runtimepub use drive::RetiredRow;runtimepub use drive::RetiredStore;runtimepub use drive::RetiredStoreError;runtimepub use drive::RetiredTable;runtimepub use drive::Retirement;runtimepub use drive::Retries;runtimepub use drive::RetryDecision;runtimepub use drive::RetryPolicy;runtimepub use drive::Rings;runtimepub use drive::RootAction;runtimepub use drive::RootAdvance;runtimepub use drive::RootKey;runtimepub use drive::RootProjection;runtimepub use drive::RootState;runtimepub use drive::RunId;runtimepub use drive::Rung;runtimepub use drive::Runs;runtimepub use drive::Schedule;runtimepub use drive::Scope;runtimepub use drive::Seats;runtimepub use drive::Serve;runtimepub use drive::Served;runtimepub use drive::Serves;runtimepub use drive::Settled;runtimepub use drive::SettledParts;runtimepub use drive::ShedKey;runtimepub use drive::Sheds;runtimepub use drive::Shutdown;runtimepub use drive::Sink;runtimepub use drive::SlotBinding;runtimepub use drive::SlotLane;runtimepub use drive::Socket;runtimepub use drive::Spawn;runtimepub use drive::SplitOriginError;runtimepub use drive::Staging;runtimepub use drive::Stamp;runtimepub use drive::Station;runtimepub use drive::Steady;runtimepub use drive::Stopped;runtimepub use drive::StreamBody;runtimepub use drive::StreamLane;runtimepub use drive::StreamOptions;runtimepub use drive::StreamWires;runtimepub use drive::Streamed;runtimepub use drive::Streaming;runtimepub use drive::Streams;runtimepub use drive::Sweeper;runtimepub use drive::Swept;runtimepub use drive::TakenInboxError;runtimepub use drive::Tally;runtimepub use drive::Taps;runtimepub use drive::Tasks;runtimepub use drive::Terminal;runtimepub use drive::Thread;runtimepub use drive::Tick;runtimepub use drive::TickDecision;runtimepub use drive::TickPolicy;runtimepub use drive::Ticked;runtimepub use drive::Ticker;runtimepub use drive::Ticks;runtimepub use drive::TracingLevel;runtimepub use drive::Track;runtimepub use drive::Turning;runtimepub use drive::UNDIVIDABLE;runtimepub use drive::UnboundCorpus;runtimepub use drive::UnboundSlotError;runtimepub use drive::UnbridgedOriginError;runtimepub use drive::UnbuiltTargetError;runtimepub use drive::UncataloguedResourceError;runtimepub use drive::Unchanneled;runtimepub use drive::UndeclaredResourceError;runtimepub use drive::UnknownGenerationsEngine;runtimepub use drive::UnknownGrantError;runtimepub use drive::UnknownNodeError;runtimepub use drive::UnknownRetiredEngine;runtimepub use drive::UnknownUpstreamError;runtimepub use drive::UnnameableFamily;runtimepub use drive::UnnameableScope;runtimepub use drive::UnnameableTable;runtimepub use drive::Unpoliced;runtimepub use drive::Unpolled;runtimepub use drive::Unpressured;runtimepub use drive::Unreceipted;runtimepub use drive::Unruntimed;runtimepub use drive::Unsettled;runtimepub use drive::Untorn;runtimepub use drive::Unwritten;runtimepub use drive::Upstream;runtimepub use drive::UpstreamWiring;runtimepub use drive::Upstreams;runtimepub use drive::Vanished;runtimepub use drive::VectorAsk;runtimepub use drive::VectorScope;runtimepub use drive::Wake;runtimepub use drive::Wanted;runtimepub use drive::Wired;runtimepub use drive::Wiring;runtimepub use drive::Worn;runtimepub use drive::Written;runtimepub use drive::ack_channel;runtimepub use drive::arm;runtimepub use drive::channel;runtimepub use drive::door;runtimepub use drive::doorbell;runtimepub use drive::drive_awaited_origin;runtimepub use drive::drive_origin;runtimepub use drive::journal_queue;runtimepub use drive::open;runtimepub use drive::park_on;runtimepub use drive::prepare;runtimepub use drive::rebuild;runtimepub use drive::reply;runtimepub use drive::select;runtimepub use flags::FlagBit;flagspub use flags::FlagsValue;flagspub use flags::UnknownFlag;flagspub use interface::HydrationError;pub use interface::InterfaceArm;pub use interface::InterfaceColumn;pub use interface::InterfaceKind;pub use interface::UnknownKind;
Modules§
- batch
- COALESCING WITH NO CLOCK OF ITS OWN: the size-or-time batch, and the quiet-window debounce.
- comparison
- The storage side of a query: the COMPARISON types, and the crossing a filter makes to reach one.
- conduit
runtime - THE HOUSE CHANNEL: one bounded transport with a door on each side for each engine, and the select a loop waiting on several of them parks in.
- detect
- DETECT: what an analyzer says it FOUND — the word, the confidence, and the two shapes a finding comes in.
- dialect
- WHICH DIALECT a byte form belongs to — the markers
DialectCursoris keyed on. - flags
flags - The FLAGS VOCABULARY — a bit set a column holds, and the free functions that read one.
- geometry
- GEOMETRY: the shapes an analyzer reports a FINDING’S LOCATION as, and the one coordinate this crate names to measure them in.
- interface
- The INTERFACE’s own vocabulary: which member a row came from, what each arm projects, and the refusal a discriminant nobody declared gets.
- lang
derive - WHAT LANGUAGE IT IS IN: the identity a track’s words carry, and the vendored registries that identity is read against.
- mediaframe
mediaframe - THE STREAM DESCRIPTOR’s vocabulary, and the newtypes that make a foreign
mediaframeword declarable. - mediatime
mediatime - MEDIA TIME: a position measured against a STREAM’s own timebase, and the four newtypes that make
a foreign
mediatimevalue declarable. - query
- What a record ANSWERS and what STORES it:
getby address,findover a filter and the three lanes a plural query can be asked in, beside the verbs a record is written and REMOVED with. - shard
runtime - THE NODE’S OWN CREW: resident workers behind a key router, built inside a body’s
runand owned by it. - signal
tokio-signal - EXIT SOURCES, ready-made — the one adapter this crate ships, behind the one feature that names a runtime.
Macros§
- bare_
options runtime - The options a BARE section of
$noderuns at —Someat the options’Default,Nonewhere the type has none. - bare_
origin_ options runtime - The options a BARE section of the ORIGIN
$originruns at —Someat the options’Default,Nonewhere the type has none. - bare_
resource_ options runtime - The options a resource mounted with NO document section runs at —
Someat the options’Default,Nonewhere the type has none. - filter_
input_ object async-graphql - Emit the hand-written wire face for ONE concrete filter instantiation: its
async_graphql::InputType(+InputObjectType) pair, and theNullableFacerow a NULLABLE column of that type reaches its face through.$filteris the concrete type (e.g.ScalarFilter<i64>),$gqlits GraphQL input name, and each$field: $fty => $nameis a struct field, itsInputTypefield type, and its GraphQL name. - if_
mongo - Expand the tokens where
ingraphwas built with MongoDB, and to nothing where it was not. - if_
mysql - Expand the tokens where
ingraphwas built with MySQL, and to nothing where it was not. - if_
postgres - Expand the tokens where
ingraphwas built with PostgreSQL, and to nothing where it was not. - if_
sqlite - Expand the tokens where
ingraphwas built with SQLite, and to nothing where it was not. - via_
filter_ input_ object async-graphql - Emit the
InputType(+InputObjectType) pair AND theNullableFacerow for one filter whose OPERANDS cross through a WIRE CARRIER — [filter_input_object!]’s twin, for the rows that macro cannot serve.
Structs§
- Ack
runtime - A consumer’s answer to one delivery: WHICH items it released, WHO did the work, and where it says they got to.
- AckReceiver
runtime - The receiving half, kept by the sender of the delivery until it is answered or hung up.
- AckSender
runtime - The sending half of one delivery’s oneshot.
- Acked
runtime - ONE ACKED GIVE’S RECEIPT: which item went out, WHAT it was, and the answer it is owed.
- After
Clock runtime - The ASYNC engine’s clock: one self-re-arming timer per cadence, on the runtime’s own After family.
- Anon
- The SPACE an embedding is in when nobody named one — the third parameter’s default.
- Answered
runtime - ONE answer as its sender reads it: who did the work, what they said, and which keys it spoke for.
- App
runtime - A started deployment of the indexer
I. - Arity
Mismatch - The payload of
CursorError::Arity: how wide the cursor’s tuple is, and how wide the order is. - ArmWeights
engine - WHAT ONE ARM OF AN EXPANSION FAMILY COUNTS FOR —
Expansion’s own knobs seat, and the ARM half of the fan’s weight product. - Arrangement
Error runtime - The payload of
Refusal::Arrangement: the arrangement layer’s own sentence. - Arrival
runtime - One
Lifecycleas a tap sees it: the station, the framework’s own payloads, and the consumer’s info held for whoever knows its type. - AsLoader
async-graphqlanddataloader - Any
AsyncBatchLoadas one of async-graphql’sLoaders. - Assembly
runtime - A wired deployment, ready to be started.
- Async
runtime - The ASYNCHRONOUS MODE —
Block’s partner, and what anasyncdeclaration buys. - AtMost
One runtime - AT MOST ONE IN FLIGHT: the cell a detached SYNC clock claims per tick.
- Audio
Codec mediaframe - What an audio track’s bytes are encoded with — an FFmpeg audio codec name in the lowercase canon, or the open escape for one this build’s roster does not carry.
- Autonomous
runtime - THE AUTONOMOUS PAIR WORD — what the
autonomousword seats atDeclared::Pair. - Awaiting
runtime - The receiving half, kept by whoever asked.
- Backpressure
runtime - WAIT FOR ROOM — the shipped
OverflowPolicy, and today’s behaviour as a type. - Barcode
Detection - A DECODED CODE, the standard it was read under, and where on the frame it was.
- Barcode
Detection Filter - The filter that guards a
BarcodeDetection<T>column: the payload, the standard, the confidence and the region. - Bare
Options runtime - THE BARE-SECTION PROBE: does
Ohave aDefaultfor a section with nooptionsto run at? - Batch
Door - THE BATCH DOOR — the type an emitted resolver looks for, and the one an application installs.
- Batch
Error - THE NEUTRAL CURRENCY a batch fails in — a refusal, the word it is recognised by, and
Clone. - BeI128
- An
i128stored as its order-preserving 16-byte big-endian blob, sign-flipped so the negative range sorts below the positive one. SeeBeU64for the layout contract the three share. - BeU64
- A
u64stored as its order-preserving 8-byte big-endian blob — SQLiteBLOB, PostgresBYTEA, MongoDB genericBinData. MySQL hasBIGINT UNSIGNED, so it bindsu64natively and never sees this type. - BeU128
- A
u128stored as its order-preserving 16-byte big-endian blob — no backend here has a 128-bit integer column. SeeBeU64for the layout contract the three share. - Binding
engine - ONE BOUND TOWER, as the member’s
tower(…)word wrote it. - Blob
Door - The DOOR a locate field takes from a request’s context — one per store a schema serves.
- Blob
Location - WHERE a blob is, in the shape a backend with nothing more to say elects.
- Block
runtime - The BLOCKING MODE — the
DrivenrowOperatorfills, and aResident’s default. - Blueprint
runtime - THE ARRANGEMENT, JOINED — declared facts in, a
Planout. - Bool
Marker - Read a type as a BOOLEAN — two values, so an ordering operator would name every row or none.
- Boolean
Filter - The boolean filter — equality and membership, and the one kind with NO type parameter:
boolis the only type it guards, so there is nothing for a parameter to range over. - Bounding
Box - AN AXIS-ALIGNED RECTANGLE — its top-left corner and its two extents, in whatever
Tthe declaration measures in. - Bounding
BoxFilter - FOUR STORED FACETS AND ONE DERIVED ONE, and no whole-box operator at all.
- BoxWriter
- The sink a full-text converter pushes SEGMENTS of text into.
- Bridged
runtime - THE TWO ENDS OF A BRIDGED ORIGIN — what the launch walk hands back once an origin is on its engine AND its feed is a graph edge.
- Budget
Spent engine - A WALK THAT DID NOT FINISH INSIDE ITS BUDGET — the named refusal, and never an empty answer.
- Buffered
runtime - THE BUFFERED PAIR WORD — what a declaration that wrote no
streamseats atDeclared::Pair. - Bytes
Filter - The VARIABLE-WIDTH bytes filter — generic over the column’s byte storage type
B(Vec<u8>, aBytesnewtype), mirroring polarsync’sByteaFilter<I>, and over the WIRE READINGIits operands cross under. Equality, ordering, membership, and byte-substringcontains/not_contains— and no affix operators, which a byte column has no use for. Bound-free struct; theAsRef<[u8]>belongs on the lowering impls.new()/Default+ theopt_accessor!getter and writers per slot. - Bytes
Marker - Read a type as a BYTE STRING — one opaque run of bytes, searched as bytes and never as characters.
- Cadence
runtime - One registered ringer and the interval it rings on — what
Sweeper::tickingtakes. - Calendar
runtime - ONE calendar expression, read, with the zone it is evaluated in.
- Calendar
Error runtime - Why a calendar expression could not be read.
- CatchUp
runtime - EVERY OWED TICK FIRES — the counter-case
Coalesceexists against, shipped so a deployment that needs it names a type rather than writing one. - Change
Intake runtime - The driver that turns a
AsyncChangesfeed into ordinary deliveries. - Channel
Graph runtime - A validated, immutable unit-DAG: its nodes/edges plus the topologically derived layers and any orphan nodes (unreachable from a source — reported, not rejected).
- Channels
runtime - What a deployment TUNED, node by node — the config layer of the channel precedence.
- Coalesce
runtime - ONE LOOK ANSWERS THEM ALL — the shipped
TickPolicy, and today’s behaviour as a type. - Column
- One stored COLUMN: its name, the type THIS database keeps it at, and whether it holds
NULL. - Column
Name - A column’s TWO names: the one its declaration wrote, and the one THIS DATABASE stores it under.
- Commands
runtime - THE CONTROL LINE, from the APP’s side — what says a command to one running source.
- Commit
runtime - What ONE
AsyncLands::landcall did: which of the items it was given reached the store, and — where some did not — why. - Composite
Marker - Read a type as a COMPOSITE — one value occupying SEVERAL columns of its holder’s row, so the questions are asked of its parts.
- Composite
Unique - ONE UNIQUE constraint over SEVERAL of a row’s declared entries — the composite
with_uniquesstates it cannot express. - Confidence
- A confidence or ratio in the closed unit interval
[0.0, 1.0], measured inS. - Confidence
Filter - The CONFIDENCE filter — six comparison operators over a threshold, and ONE input object for every width a confidence measures in.
- Confidence
Operand - THE WIDE DOOR — one confidence THRESHOLD as a client writes it, before any width has been chosen for it.
- Connected
- The per-call resources a store handle operates against: a borrow of the shared
Connection(the connection-manager a*Storeopened once and now hands to every op, so nothing reconnects per call) plus the per-callscope— owned here, being whatever the handle’sReadContext<'_>/WriteContext<'_>GAT resolved to (search knobs, or a borrowed&mut Transaction). - Contained
Operand - THE TWO-SHAPE OPERAND, and a newtype for
TimeRangeOperand’s reason one door over: a crossing is one row per type, so a shape serving a second door has to spell that door on a type of its own. - Context
runtime - ONE NODE’s window onto the world it runs in.
- Control
runtime - THE CONTROL LINE, from the SOURCE’s side: the typed commands an app says to a running origin.
- Count
- HOW MANY — a cardinality, and the currency every count in this framework is answered in.
- Counting
count(*)— HOW MANY ROWS the group holds, whatever they hold.- Creation
runtime - The CREATE walk over a checked deployment: resources, then slots, then nodes.
- Crossed
async-graphql - A value a wire face MADE, holding it until the resolver renders it — and rendering as
ToGraphqlOutputsays its type crosses. - Culled
runtime - WHAT ONE SWEEP COLLECTED — how many tables it reached and how many rows went.
- Curator
runtime - THE SEAT: what
Registry::curatingis handed, and all it ever does is queue. - Curator
Body runtime - THE BODY: what actually writes, and the only party that erases.
- Curator
Report runtime - HOW THE GENERATIONS SEAT HAS BEEN GETTING ON — three counts, read at any moment.
- Current
Row runtime - ONE ROW OF THE POINTER TABLE: which closure of which root is looking at which run, and when it started to.
- Current
Table runtime - THE TABLE ONE FAMILY’S POINTERS LIVE IN — its name, and the five column words every engine spells the same.
- Cursor
- A position in a written order: the ordering tuple of one row, and the signature of the order it was read under.
- Cycle
Error runtime - The payload of
ArrangeError::Cycle: a node on the detected cycle and its name. - Deadlines
runtime - THE DEADLINE SEAT: how long a silent caller waits at a door.
- Deferred
engine - The floor a query DEFERRED — what stands in the floor’s position while the number is still somebody else’s to supply.
- Delivery
runtime - One delivery: the payload, and the oneshot its consumer answers on.
- Detected
Language derive - One detection: which language a track was decided to be in, and how confident the detector was.
- Detected
Language Filter derive - The filter that guards a
DetectedLanguagecolumn: the whole IDENTITY axis flattened, and the CONFIDENCE nested beside it. - Detection
- A CLASSIFICATION — what something was decided to be, and how sure the decider was.
- Detection
Filter - The filter that guards a
Detectioncolumn: the WORD’s own filter, and the CONFIDENCE beside it. - Direct
Fanout Error runtime - The payload of
ArrangeError::DirectFanout: the offending producer, its name, and its out-edge count. - Disabled
Upstream Error runtime - The payload of
Refusal::DisabledUpstream: the edge and both of its ends by name. - Document
Segment - A FOUR-CORNERED REGION, with the detector’s confidence in it.
- Document
Segment Filter - The filter that guards a
DocumentSegment<T>column: the four corners, and the confidence. - Door
runtime - The SENDING half of a transient edge — the INVOKE DOOR.
- Doorbell
runtime - The listening half — held by the feed.
- Downstream
runtime - The downstream set of a node with ONE product — however many consumers subscribe to it.
- Drained
runtime - What one run of a resident did, from launch to shutdown.
- Drop
Newest runtime - REFUSE THE NEWEST — the shipped shedding
OverflowPolicyfor a sampling intake. - Drop
Oldest runtime - MAKE ROOM BY LOSING THE OLDEST — the shipped shedding
OverflowPolicyfor a live-value feed. - Dropping
Unbounded Error runtime - The payload of
Refusal::DroppingUnbounded: the node, its name, and WHICH of its upstreams resolved to an edge nothing bounds. - Duration
Filter async-graphqlorjiff - The duration filter — the same eight operators
ScalarFilterhas, overjiff::SignedDuration, and the one built-in kind whose EXISTENCE is a feature. - Duration
Marker - Read a type as a DURATION — an elapsed span, which carries a lexical form no number has.
- Duration
OutOf Range async-graphqlorjiff - A duration outside
i64nanoseconds, in either direction — seeDurationFilter::operand_nanos. - Edge
runtime - A declared edge
from → towith its fan-out kind. - Edge
Endpoint Error runtime - The payload of
ArrangeError::EdgeEndpointOutOfRange: the edge carrying the bad endpoint, that endpoint, and the declared node count. - EdgeId
runtime - An opaque handle to a declared edge (its index in declaration order).
- Edge
Table - One collection column’s SECOND TABLE, as this database creates it.
- Edge
Type Error runtime - An edge asked for under a type it does not carry.
- Embedding
- An embedding, at the ELEMENT TYPE and the WIDTH its model produces — and, where one is named, the SPACE it lives in. All three are carried in the type.
- Emitter
runtime - The EMISSION ORGAN handed to each
acceptcall: the typed buffer an operator states its outputs into. - Empty
Label - What a label refuses a value with — one sentence, at the four doors that mint one from the outside: a caller’s constructor, a stored column, a cursor a client handed back, and a wire operand.
- Enablement
runtime - Which nodes a deployment launches, as its options named them.
- Enrolled
runtime - One registered party’s OWN half: the announcement it watches, and the completion it fires.
- Enum
Filter - The enum filter — equality + membership only (no ordering, no substring). An enum column stores as, through the enum type’s own backend operand impl (text name or integer discriminant).
- Enum
Marker - Read a type as an ENUMERATION — a closed vocabulary, so membership is the whole question and there is no order to ask about.
- EqBests
engine dedup(eq)— accumulation through a list walked by field-wise equality.- EqJoin
engine - The join through a list walked by field-wise equality — quadratic in the number of DISTINCT ROOTS, and that is stated rather than hidden.
- EqSeen
engine dedup(eq)— membership through a list walked by field-wise equality.- Evictor
runtime - THE EVICTION HAND: takes the OLDEST message out of an edge so a newer one can take its place.
- Exchange
runtime - ONE DECLARED EXCHANGE, as the declaration wrote it.
- Expanded
engine - ONE QUESTION ON THE ROAD — what will be walked, and where it came from.
- Expansion
engine - THE EXPAND STEP’S SEAT — what a question road holds, and what an assembly mounts an expander into.
- Extracted
- A projection that reaches INTO a type, parameterised by which part is meant.
- F16
half - The THIRTEENTH width, and the only carrier here whose OPERAND is somebody else’s type —
which is why it alone rides a vocabulary feature. See the
halfrow in this crate’s manifest. A HALF-precision float on the wire — a JSON number, which a double holds one of exactly. - F32
- A single-precision float on the wire — a JSON number, which is what a double holds one of exactly.
- F64
- A double-precision float on the wire — a JSON number, which IS a double.
- F128
rust_decimal - The WIDEST float row, and the only carrier whose operand is a stand-in:
f128is the roster’s name andrust_decimal::Decimalis what holds the seat until Rust’s ownf128is stable. See therust_decimalrow in this crate’s manifest. The widest float row on the wire — DECIMAL TEXT, exact at every magnitude its operand holds. - Failure
runtime - A consumer’s failure, erased.
- FanAll
- ASK EVERY LANE — the explicit fallback, and the thing a fanned corpus mounts when it has nothing cleverer to say.
- FanStream
engine - ONE CELL OF A FAN’S GRID — which lane, which arm, what the cell is worth, and what it found.
- Feed
runtime - THE FEED: where a streaming body puts what it produces, one item at a time.
- Feed
Context runtime - WHAT A
FeedPolicyIS SHOWN when one delivery is about to be spawned. - Feeder
Absent Error runtime - The payload of
Refusal::FeederAbsent: the change-feed edge, and both of its ends by name. - Field
Name - A field’s name — an UNQUOTED identifier, and the one thing on the lowering path that becomes SQL TEXT rather than a bind.
- Fixed
runtime - THE SAME DEPTH EVERY TIME — the shipped
FeedPolicy, and a scalar wearing the seam’s shape. - Fixed
Bytes Filter - The FIXED-WIDTH bytes filter — exactly
Nbytes, over the same storage typeBand the same wire readingIits variable-width twin takes. - Fixed
U8Array - The FIXED-WIDTH byte vocabulary’s carrier — one type per WIDTH, and one scalar per width with it.
- Flags
Filter flags - The FLAGS filter — seven hard words over a bit set, and four sugar words that fold into four of them before anything lowers.
- Flags
Input flags - ONE OPERAND of a flags vocabulary, on its way in.
- Flags
Marker flags - Read a type as a FLAGS SET — a closed vocabulary of BITS, so the questions are set-theoretic and the stored value is the bit pattern behind them.
- Flags
View flags - One flags value on its way OUT — the OBJECT face, over every reading a bit set has.
- Flip
runtime - THE OTHER DURABLE ACT A MOVE EARNED — a re-run CLOSED, so point its closure at the run that closed.
- Floor
Spec engine - The per-member score floors a fused query carries, above what each declaration already states.
- Flow
runtime - A STEP’S FLOW — how many to take and how far to go: the shipped convention shape for
Serve::Options, OFFERED and never coerced. - Fold
Door engine - The DOOR an emitted set-similarity resolver reads its fold out of — one per (engine × election) a schema serves, and ABSENT wherever a deployment is content with the election’s own.
- Folded
engine - One set-similarity result: the score a
FoldSemanticsproduced, what each query vector’s own stream said about the entity, and the key. - Folded
Match async-graphqlandengine - ONE FOLDED hit on the wire, at either tier: the folded score, every query vector’s own sighting, and the NODE that matched — the ADDRESS at tier A, the whole upstream ENTITY at tier B.
- Folded
Query engine - A SET-SIMILARITY retrieve: the
mquery embeddings, and the minimum score a neighbour must reach. - Fulltext
Ask runtime - What a full-text
SlotLaneis asked: the per-call scope, the COLUMN SUBSET, the query string and HOW MANY. - Fulltext
Column - WHICH searchable field of a slot a call is about — the full-text ELECTION SELECTOR.
- Fulltext
Query engine - A full-text retrieve: the query text, and the minimum score a hit must reach to be returned.
- Fused
engine - One row of a fused answer: the framework’s score, the root it is about, and every member’s evidence for it.
- Fused
Score engine - What a fused retrieve ranks by: the sum of its members’ reciprocal-rank contributions.
- Generational
runtime - ONE TABLE OF A CLOSURE, AND THE TWO WORDS A SWEEP NEEDS OF IT — where the rows are, and how to find one root’s.
- Generations
Options runtime - WHERE THIS DEPLOYMENT KEEPS ITS POINTERS, AND HOW DEEP ITS HISTORY GOES — the
[generations]section. - Generations
Override runtime - THE LIVE DIAL: whichever knobs a request named, and no statement at all about the rest.
- Generations
Store Error runtime - WHAT A STORE COULD NOT DO — one refusal, carrying whatever the engine said underneath.
- Grant
runtime - ONE
writegrant, as the declaration wrote it — the PERMISSION half of a node’s declaration. - Grants
NoStore Error runtime - The payload of
Refusal::GrantsNoStore: who granted itself the write, from which clock, over what, and where that node is mounted. - Graph
Builder runtime - Builds a unit-DAG as data.
node/sourcedeclare typed nodes;edgerecords a type-checked edge;validate(see the graph module) freezes it into aChannelGraph. - Graphql
Name - A variant’s word on the WIRE — the member a GraphQL enum exposes.
- Harvest
runtime - What one
Outbound::harvestfound: the answers that arrived, each still holding the keys it spoke for. - Hash
Bests engine dedup(hash)— accumulation through aHashMap, the default.- Hash
Join engine - The join through a
HashMap— one hash and one bucket probe per contribution. - Hash
Seen engine dedup(hash)— membership through aHashSet, the default.- Held
engine - One entity’s SET in one column — the
mvalues it holds there, each wearing the ordinal that identifies it in every answer downstream. - Helm
runtime - THE WHEEL, AND EVERYTHING A HAND ON IT REACHES — one autonomous node with its three seats filled, waiting for an engine.
- HexBytes
- A byte string on the wire — lowercase hexadecimal, two characters per byte.
- Hint
runtime - The ringing half of a coalescing doorbell — held by whoever WRITES the store.
- Hyphenated
Uuid - A UUID on the wire — the canonical lowercase hyphenated text,
"018f3a2b-7c4d-7e1f-9a0b-1c2d3e4f5061". - I8
- A signed 8-bit integer on the wire — a JSON number, exact in both directions.
- I16
- A signed 16-bit integer on the wire — a JSON number, exact in both directions.
- I32
- A signed 32-bit integer on the wire — a JSON number, exact in both directions.
- I64
- A signed 64-bit integer on the wire — a JSON number inside the safe range, decimal text beyond it.
- I128
- A signed 128-bit integer on the wire — a JSON number inside the safe range, decimal text beyond it.
- Identity
- The state that changes nothing — every type projects to itself.
- Ignition
runtime - THE IGNITION WALK over a wired deployment: engines under the bodies, and the sources last.
- InFlight
runtime - One claim on an
AtMostOne, released when it drops. - Inbox
runtime - The receiving half — a node’s inbox.
- Index
Refusal - WHAT A SUBSCRIBING DECLARATION’S BODY REFUSES WITH — one error over the three seams a landing crosses.
- Inner
- The state that reads what a container HOLDS — the sub-state of
Extractedthis crate uses. - Input
Crossing - A witness that
Tcrosses into an INPUT position — the compile-level assertion, and nothing at runtime. - Inverted
Media Time Range mediatime - A pair of columns does not hold a range.
- Inverted
Time Range - Why two instants are not a range: the later one is EARLIER.
- Invoke
runtime - ONE invocation as the transient edge moves it: the input, and the oneshot the RESULT threads back on.
- Invokes
runtime - The RECEIVING half — a query node’s transient inbox.
- Item
runtime - One item as the transport moves it: the key the ack window releases by, and the declared struct.
- ItemId
runtime - One item’s identity ON THE TRANSPORT, minted by the node that sends it.
- Jiff
Civil Date Time async-graphqlorjiff - The
LocalDateTimescalar’s Rust carrier — a wire type and nothing else. - Jiff
Duration async-graphqlorjiff - The
Durationscalar’s Rust carrier — a wire type and nothing else. - Jiff
Zone Offset async-graphqlorjiff - The
UtcOffsetscalar’s Rust carrier — a wire type and nothing else. - Journal
Drain runtime - The draining end of a
JournalQueue— what aJournalWriterreads. - Journal
Queue runtime - The DIAGNOSTIC half’s bounded queue: a non-blocking push that drops the OLDEST when it is full.
- Journal
Tap runtime - The composition that turns a node’s observations into rows: a per-node PROJECTION and the arrangement’s QUEUE.
- Journal
Writer runtime - The DIAGNOSTIC half’s writer: it drains a
JournalQueuesomewhere else and writes what it finds. - Keeper
runtime - THE SEAT: what
Registry::installingis handed, and all it ever does is queue. - Keeper
Body runtime - THE BODY: what actually writes, and the only party that publishes.
- Keeper
Report runtime - HOW THE LEDGER HAS BEEN GETTING ON — three counts, read at any moment.
- Label
- A CLASSIFICATION’S WORD — what a detector, a classifier or a tagger says a thing IS.
- Lands
Nowhere Error runtime - The payload of
Refusal::LandsNowhere: the node that says it lands, and its name. - Lane
- ONE LANE, as the declaration that minted it wrote it: a key, and the tags it accepts beside it.
- Lane
Analyzers tantivy - THE PER-SLOT ANALYZER TABLE — this backend’s answer to
FulltextEngine::Options, one analyzer NAME per lane. - Lane
Collision - TWO LANES CLAIM ONE THING —
lane_collisions’ refusal. - LaneFan
- THE ROUTER’S SEAT — a roster, the router that chooses between its lanes, and the guardrails that stand between them.
- Lane
Ident - ONE LANE’S KEY — the opaque word a backend block wrote, carried through the neutral layer without being read.
- Lane
Mount runtime - A mounted lane HELD AS THE ACT OF BUILDING IT —
MountedLaneone step before it exists. - Language
derive - A primary language subtag, in the shortest spelling BCP 47 has for it:
de,zh,yue,und. - Language
Id derive - A whole language identity — what UTS-35 calls a unicode language id and what a track’s
metadata actually carries:
de,zh-Hans,en-US,sr-Cyrl-RS,en-US-x-lorem. - Language
IdFilter derive - The filter that guards a
LanguageIdcolumn: the whole IDENTITY, and each COMPONENT that has a column of its own. Holds DOMAIN values. - Language
IdOperand derive - A whole identity, on its way IN — the carrier the identity axis’s four operators cross on.
- Language
Tag - A LANGUAGE TAG, REDUCED TO WHAT A LANE CAN BE KEYED ON — a primary subtag and an optional script, with everything a lane does not partition on dropped.
- Layout
- ONE ARTIFACT FAMILY’s home — the bucket, directory or key prefix a declaration’s blobs go in.
- Lineage
runtime - The per-input refcount
Chainedjoins on. - List
Filter - The sequence filter — for an ORDERED collection column, generic over the element type
T.eq/necompare the whole collection element by element, so[1, 2]and[2, 1]are different operands;gt/gte/lt/ltecompare it lexicographically;has_elementis membership. - List
Marker - Read
Tas an ORDERED collection of elements read underVM— order and duplicates carry meaning, so[1, 2]and[2, 1]are different operands. - Local
FsBlob - The local-filesystem blob face — a STATELESS keyed handle holding ONLY its artifact-family slot.
It threads the
LocalFsStoreas its connection, soputpublishes under, andgetresolves against, the manager’s one root. - Local
FsStore - The local-filesystem connection-manager and the shared connection its handles thread: THE one
root, created once by
open. It IS theAsyncBlobEngine::Connectionof the handlesblobmints — a handle holds only its slot and reaches the root throughctx.connection(). - Local
Timestamp deriveandtime - A wall clock and the zone it was on, where the zone may be absent — the EXIF capture-time shape, as one value.
- Local
Timestamp Filter deriveandtime - The filter that guards a
LocalTimestampcolumn: a STRUCTURAL identity, a SEMANTIC one, a bound facet, and the components a capture time is made of. - Local
Timestamp Operand deriveandtime - A whole
LocalTimestampon its way IN as an operand — the exact pair, wall clock and zone together. - Located
Detection - A CLASSIFICATION AND ITS PLACE — what was found, how sure the finder was, and WHERE.
- Located
Detection Filter - The filter that guards a
LocatedDetection<T>column: the CLASSIFICATION axis flattened, and the GEOMETRY beside it. - Makes
Nothing runtime - THE NOOP BODY — the machine a target names when it has nothing to make.
- Mandatory
Options Error runtime - A launched node or ORIGIN whose section is BARE and whose options cannot be built out of nothing.
- Mandatory
Resource Options Error runtime - A demanded resource whose declared source produced no options, and whose options cannot be built out of nothing.
- Match
async-graphqlandengine - ONE HIT on the wire, at either tier: its score, its engine ordinal, and the NODE that matched — the ADDRESS at tier A, the whole upstream ENTITY at tier B.
- Max
engine maxⱼ bⱼ— the best single (query vector, set member) pair.- Media
Contained Operand mediatime - What a
containsoperand may be: one position, or a whole span./// Declared UNGATED, beside the type it carries, and the reason is the ungated-operand rule this house’s note states for its whole roster: a crossing says which FORM an operand takes and asks nothing about who parses that form. The binding’s half is the#[Scalar]ingraphql. - Media
Duration Bound mediatime - The DURATION facet: bounds on the span’s length, and no equality.
- Media
Instant Bound mediatime - A position on the timeline, on its way IN as a BOUND — every exact form, plus the three that name a position without naming a value.
- Media
Span Bound mediatime - A pair of positions, on its way IN:
{ start, end }or the exact"[100, 250) @ 1/90000". - Media
Span Duration Filter mediatime - The wire face is DECLARED, not written
- Media
Time Range mediatime - A half-open interval
[start, end), both endpoints in oneTimebase, wrappingmediatime::TimeRange. - Media
Time Range Filter mediatime - The filter that guards a
MediaTimeRangecolumn: the INTERVAL ALGEBRA, the span’s LENGTH, and the three components a row actually holds. - Media
Time Range Operand mediatime - A whole range, on its way IN as an IDENTITY operand — the exact encoding, and nothing that merely names a pair of positions.
- Media
Timestamp mediatime - A presentation timestamp — an integer PTS in units of its own
Timebase, wrappingmediatime::Timestamp. - Media
Timestamp Filter mediatime - The filter that guards a
MediaTimestampcolumn: an IDENTITY facet, a BOUND facet, and the two components a timestamp is made of. - Media
Timestamp Operand mediatime - A whole timestamp, on its way IN as an IDENTITY operand — the exact pair, and nothing that merely names a position.
- Member
engine - ONE DECLARED MEMBER, as the recipe wrote it.
- Memory
Aware runtime - AS DEEP AS THE MACHINE CAN AFFORD: the ceiling with headroom, the floor under pressure, and a straight line between.
- Missed
runtime - WHAT A MISSED TICK LOOKS LIKE from inside: which upstream, and how many of its intervals went by unfired.
- Missing
Resource Error runtime - A construction reached for a resource nothing built — the resource map’s one honest refusal.
- Mongo
Name - A variant’s word as MongoDB spells it, on
SqliteName’s terms. - Mongo
Retired mongodbandruntime - ONE ROOT FAMILY’S LEDGER, IN A MONGODB COLLECTION.
- Mongo
Time Range Comparison mongo TimeRangeFilter’s storage-side twin on MongoDB: the three interval words, and the two ends.- Mongo
Time Ranged Comparison mongo TimeRangedFilter’s storage-side twin on MongoDB: the stretch’s whole comparison, and the payload’s own beside it.- Mounted
runtime - THE THREE ENDS OF A MOUNTED ORIGIN — what the launch walk hands back once the origin is on its engine.
- Mysql
Name - A variant’s word as MySQL spells it, on
SqliteName’s terms. - Nanosecond
Overflow mediatime - An instant does not fit
i64nanoseconds. - Negative
Count - Why a stored column is not a cardinality — the read-path refusal a
Countcolumn makes, and the only value it has to make one about. - NetIp
Addr - An IP address of EITHER version on the wire — whichever version’s own canonical text.
- NetIpv4
Addr - An IPv4 address on the wire — the dotted quad,
"192.0.2.1". - NetIpv6
Addr - An IPv6 address on the wire — RFC 5952 canonical text,
"2001:db8::1". - NetSocket
Addr - An address and a port of EITHER version on the wire — whichever version’s own canonical text.
- NetSocket
Addr V4 - An IPv4 address and a port on the wire —
"192.0.2.1:443". - NetSocket
Addr V6 - An IPv6 address and a port on the wire —
"[2001:db8::1]:443", the address bracketed. - NoColumns
- THE UNUSED READER’S REFUSAL — a UNIT, because a phase that landed no column has exactly one thing to say about a read against it.
- NoDeadline
runtime - AS LONG AS IT TAKES — the shipped
DeadlinePolicy, and today’s behaviour as a type. - NoRetry
runtime - THE FRAMEWORK SCHEDULES NOTHING — the shipped
RetryPolicy, and today’s behaviour as a type. - Node
runtime - A declared node, erased of its operator type (the typed
NodeHandlecarries that). The read viewChannelGraphexposes. - Node
Handle runtime - A typed handle to a declared node. Carries
O(phantom) purely soGraphBuilder::edgecan compile-checkproducer::Output == consumer::Input. - NodeId
runtime - An opaque handle to a declared node (its index in declaration order).
- Node
Name runtime - A node’s declared name, as a type a message cannot be passed as.
- Node
Section runtime - A node’s own section of a deployment’s options: writing one is what launches the node, and what is under it is what the node is built with.
- Node
Wiring runtime - What a node declares beyond its place in the graph.
- NonZero
Column Error sqlx - Why a stored
0is not aNonZero*value — theNonZero*family’s own read-path refusal. - Noop
- Nothing here, as a type a schema can hold — the scalar an emission publishes where a seat is mandatory and its honest content is none.
- Norm
Coord - A NORMALIZED COORDINATE — one axis of a position in the unit square, in
[0.0, 1.0]. - Notified
runtime - A node’s out-edges when SOME of its consumers took the notify receipt.
- Nudge
runtime - The sweep half of an inbox: rings, never blocks, never carries data.
- Nullable
- A NULLABLE column’s filter:
F’s operators, plus the null test — which exists here and in no other filter type. - Nullable
Marker - Read
Tas a NULLABLE column whose value is read underVM—VM’s operators, plus the null test. - Occupancy
runtime - HOW FULL AN EDGE WAS when its policy was asked.
- One
- ONE embedding — the shape every election written before the set arrived has, and the one this family leaves entirely alone.
- Optional
Marker - Read
Tas whateverVMreads whatTholds as — theOptionis TRANSPARENT here rather than a state the filter carries. - Order
Fold - A signature BEING BUILT — the accumulator a RECURSIVE order walk carries down, one length-prefixed segment per hop.
- Order
Level - ONE level of the order a single wire term runs in: WHICH of the column type’s leaves this level
sorts by, as an ordinal into that type’s own
SEGMENTS. - Order
Levels - The LEVELS one term runs as —
OrderTerm::levels’s iterator. - Order
Mismatch - The payload of
CursorError::Order: the order the cursor was minted under, and the one it was replayed against. - Order
Signature - A fingerprint of the (columns, directions) sequence a cursor was minted under.
- Order
Term - One term of a WRITTEN order: which column, which way it runs, whether it can hold
NULL, what its subject is in this database, and the identity that survives a rename. - Orderings
async-graphql - An order as it arrived from a client: the terms it wrote, in the sequence it wrote them, each naming a subject no other term names.
- Outbound
runtime - A sender’s window over ONE edge.
- Outbox
runtime - The sending half of a bounded data edge.
- Output
Crossing - A witness that
Tcrosses into an output position — the compile-level assertion, and nothing at runtime. - Outside
TheInterval - What a confidence refuses a wire value with, and the whole of the interval’s enforcement at this crossing.
- Outside
TheUnit Interval - What a coordinate refuses a value with — one sentence, at the two doors that mint one from the outside: a stored column and a wire operand.
- Owed
runtime - What a consumer owes for ONE delivery.
- Owing
runtime - A member delivery’s obligation, SHARED by every group its items joined.
- Page
runtime - One page of a change feed — what a pull hands back.
- Page
Token engine - A CLAIM on a stretch of a kept ranking: which keeper is holding it, which snapshot, and how far in this client has read.
- Pairing
runtime - The by-key join buffer of ONE keyed group.
- Partial
Composite Error sqlx - A composite column whose VALUE columns disagree about being there.
- Party
runtime - One registered party, from the FRAMEWORK’s side: how to tell it to wind down, and how to learn that it has.
- Path
TooLong - The payload of
LocalFsBlobError::PathTooLong: the address that did not fit, its length, and the ceiling it passed. - Pattern
Column Error regexandsqlx - Why a stored pattern that no longer COMPILES is a refusal and not a panic — the pattern column’s own read-path refusal.
- Plan
runtime - A validated arrangement plus the wiring and options it is to run under.
- Point2
- A POSITION IN A PLANE — two components, in whatever
Tthe declaration measures in. - Point2
Filter - TWO COMPONENT FACETS, and no whole-point operator.
- Policies
runtime - THE ASSEMBLED SET: one policy per concern, chosen once and spent everywhere.
- Poll
Upstream runtime - WHICH poll upstream a tick came from — a position in the node’s
Schedule. - Postgres
Name - A variant’s word as PostgreSQL spells it, on
SqliteName’s terms. - Pressure
runtime - HOW SHORT OF MEMORY THE MACHINE IS, as the fraction of the way from comfortable to critical.
- Pulled
runtime - What one
ChangeIntake::drainpass did. - Pure
Leaf Error runtime - The payload of
Refusal::PureLeaf: the node that lands nothing, publishes to nobody and polls nothing, and its name. - Quad
- A QUADRILATERAL — four corners, in whatever
Tthe declaration measures in. - Quad
Filter - FOUR CORNER FACETS, each a whole
Point2Filter, and no whole-quad operator. - Quantified
Filter - The QUANTIFIED collection filter — two operators over a collection column, generic over the
element type
T:anyasks whether SOME element satisfies a whole element predicate, andcountasks about the collection’s LENGTH. There is no third. - Quantified
Marker - Read
Tas a collection whose ELEMENTS ARE ASKED ABOUT ONE AT A TIME and never as operands —QuantifiedFilter’s reading, whose whole vocabulary is some element satisfies this and this collection holds this many. - Query
Arm runtime - ONE node’s TRANSIENT arm: a SERVER, a transient inbox, and where its answers go.
- Query
Deadline runtime - A FIXED AMBIENT BUDGET on a query door —
take_within’s knob, said once for every silent caller. - Radians
- AN ANGLE, IN RADIANS — a
Tunderneath, and a different type so that a caller readingroll: Option<Radians<f32>>never has to ask what unit a bare number would have left silent. - Ranked
engine - One retrieved result: its score, its rank, and what was retrieved.
- Rate
mediatime - A frame or sample rate — the rational
num / denEVENTS PER SECOND a stream declares, wrappingmediatime::Rate. - Rate
Filter mediatime - The filter that guards a
Ratecolumn: the three facets a rational stored in two columns can honestly be asked about —TimebaseFilter’s shape, over the other reading. - Rate
Operand async-graphqlandmediatime - A whole rate, on its way IN — the carrier the value facet’s four operators cross on.
- Rayon
rayonandruntime - The
rayonword’s engine: rayon’s own global pool. - Reason
Name - A skip reason’s stable wire label — the string an operator’s own vocabulary is recognised by on the far side of an erased tap.
- Recorded
Positions runtime - Positions kept in memory.
- Recording
Tap runtime - A tap that keeps what it saw, for a test or a probe.
- RefFilter
- A
refCOLUMN’s filter: the column’s own operators, and — beside them, in the same object — the predicate over the row the reference points at. - Regex
Pattern regex - The COMPILED PATTERN’s carrier — the second here whose operand is somebody else’s type, and the
first whose crossing is a compile. See the
regexrow in this crate’s manifest. A regular expression on the wire — its PATTERN, verbatim,"^[a-z]+(?:-[0-9]+)?$". - Region
derive - A region subtag, in the registry’s own spelling:
DE,TW,419,ZZ. - Registries
runtime - EVERY ROOT FAMILY’S TABLE, held as one — the framework’s own runtime component.
- Registry
runtime - ONE ROOT FAMILY’S TABLE: every key it is holding something for, and this family’s own timing.
- Registry
Counts runtime - HOW MANY KEYS ONE FAMILY IS HOLDING, broken down by which of the four STORED states each is
in — see
Registry::counts. - Registry
Counts View async-graphql - HOW MANY KEYS ONE FAMILY HOLDS, broken down the way the brief’s own shape asks:
{ idle analyzing retiring retired }. - Registry
Driver runtime - A RUNNING REGISTRY DRIVER — dropping it stops the body and, on the thread road, waits for it.
- Registry
Entry async-graphql - ONE KEY, AS
recentHANDS IT OUT: its own text and where it stands. - Registry
Family async-graphql - ONE FAMILY’S FACE: what
registry(family:)hands back, every field answered through [crate::drive::DynRegistry] where the family has beenexposed, and the honest nothing everywhere it has not — see the module note. - Registry
Mutation Root async-graphql - THE MUTATION ROOT:
registryKnobs,retire,restore,reanalyze— four flat fields, each naming its ownfamily. See the module note for why they do not nest the way the query side does. - Registry
Options runtime - A deployment’s own timing for the root-key registry: the defaults every family reads, and whichever families this document wrote their own words for.
- Registry
Options View async-graphql - A FAMILY’S FIVE KNOBS, ON THE WIRE: what
registryKnobshands back — the resolved value after the fold, with no override table left to carry, exactly asRegistryOptions::for_familyhands one to a typed caller. - Registry
Override runtime - One family’s OWN words — every knob optional, and an absence reading whatever
RegistryOptions’s own defaults (or THIS document’s overridden defaults) say. - Registry
Query Root async-graphql - THE MOUNTABLE QUERY MEMBER: one field,
registry(family:), folded into<Root>Querybeside a graph’s own members byingraph-codegen’sgraph::query— or built into a schema directly, exactly asSqlDooris. - Repeated
Subject async-graphql - Two terms of one order naming one subject — what the decode refuses with.
- Reply
runtime - The sending half of ONE query’s reply oneshot.
- Resident
runtime - One node, resident for the process’s life.
- Resource
Catalog runtime - THE ROOT CATALOG: every resource a deployment declares, under its mount, from its one source.
- Resource
Demand runtime - ONE unit’s demand for a resource — what a
Shared<R>field says, as a plan records it. - Resource
Kinds runtime - THE KINDS ONE RESOURCE ANSWERS FOR — a SET, because a store may hold both.
- Resource
Name runtime - A resource’s name, as a type a message cannot be passed as.
- Resource
Source Error runtime - THE SINGLE-SOURCE LAW, refused: a resource was built through a door its declaration did not name.
- Resources
runtime - The shared resources a launch built, reachable by type.
- Responding
runtime - A RESPONDER, seated under the seam — what puts
ServesBELOWAnswersrather than beside it. - Retired
Mirror runtime - THE MIRROR: the single writer’s side, and the mint every reader comes from.
- Retired
Options runtime - WHERE THIS DEPLOYMENT KEEPS ITS RETIRED LEDGER — the
[retired]section. - Retired
Reader runtime - ONE READER’S OWN HANDLE onto the mirror — a wait-free membership test.
- Retired
Readers runtime - THE MINT FOR READERS — shareable, cloneable, and the only thing a worker needs to be handed.
- Retired
Row runtime - ONE ROW OF THE LEDGER: which key went out, when, on whose say-so, and whether anything was still in flight when it did.
- Retired
Store Error runtime - WHAT A LEDGER COULD NOT DO — one refusal, carrying whatever the engine said underneath.
- Retired
Table runtime - THE TABLE ONE FAMILY’S ROWS LIVE IN — its name, and the five column words every engine spells the same.
- Retries
runtime - THE RETRY SEAT: attached where
Station::is_settledalready answers whether an item is done. - Root
Projection runtime - The value an emitted root projection is written on — zero-sized, and see the module note for why.
- Rooted
engine - ONE member’s answer about ONE root: where that member put it, and what that member saw.
- Route
engine - ONE ROUTE of a fusing tier — the parent’s own facts about the edge, and the route’s package inside them.
- Routed
Probe - ONE DISPATCH — a lane, and the probe to ask it with.
- Router
Missing - A CORPUS WITH A CHOICE AND NOTHING TO MAKE IT WITH — guardrail ①’s refusal.
- RrfOptions
engine - RECIPROCAL RANK FUSION’s own parameters — one number, and it is optional.
- RunId
runtime - WHICH RUN A ROW WAS WRITTEN UNDER — the framework’s own stamp on a generational record, and the value the pointer points AT.
- Scalar
Filter - The scalar / orderable filter — every ordering + equality + membership operator.
Tis the field’s Rust type; a set slot lowers through that type’s own backend operand impl. - Scalar
Marker - Read a type as a NUMBER — one totally ordered value, which is what makes
gtand its neighbours mean something. - Schedule
runtime - A node’s poll entries and the clock each one keeps, in declaration order.
- Scope
runtime - WHICH CASCADE CLOSURE A POINTER IS FOR — the word that makes a flip cover one set of families rather than everything a root ever touched.
- Scored
- One search result: what matched, and the score it matched at.
- Script
Router - CUT BY WRITING SYSTEM — the shipped router, and the read side of the fan the write side already runs.
- Script
Run - ONE RUN — a maximal stretch of
textwritten in one script. - Script
Runs - The runs of one text, cut lazily —
script_runs’ own iterator. - Script
Subtag derive - An ISO 15924 script subtag, in the registry’s own Titlecase:
Latn,Hans,Hant,Zxxx. - Script
Weighted Fan - ASK EVERY LANE, AND LEAN ON THE ONES THE QUESTION IS WRITTEN IN — the recommended default.
- Search
Budget engine - THE PROTECTIVE NUMBERS ONE SEARCH NAMES — the framework’s own budget package, spoken by BOTH tiers that may name one.
- Seat
engine - ONE BROADCAST SEAT, as the recipe’s head declared it.
- Seats
Unfilled engine - WHAT A DECLARATION ASKED FOR AND AN ASSEMBLY DID NOT PROVIDE — the boot refusal, naming every gap at once.
- Segment
TooLong - The payload of
LocalFsBlobError::SegmentTooLong: which component was too long, what it rendered to, and the ceiling it passed. - Segments
- The path segments a key renders to — the sink a
KeySegmentswalk pushes into. - Served
runtime - What one run of a query arm did.
- Set
- A per-entity SET of embeddings — variable in length, EMPTY being legal.
- SetFilter
- The set filter — for an UNORDERED collection column, generic over the element type
T. Every operator here ignores order and multiplicity:eq/neare set equality,encloses/enclosed_byare superset / subset,overlapsis a non-empty intersection, andhas_elementis membership. - SetMarker
- Read
Tas an UNORDERED collection of elements read underVM— neither order nor duplicates carry meaning, so whole collection equality is mutual containment. - Settled
runtime - An
AckAS THE TRANSPORT CARRIES IT: the released set verbatim, the worker’s name, and the lifecycle erased. - Shadow
- One collection’s ORDER-PRESERVING COMPANION COLUMN — what
sortableadds to the row when this database keeps the collection in a table of its own. - Share
runtime - ONE member item’s share of its delivery’s obligation.
- Shared
runtime - A handle to a resource SEVERAL units hold at once — one construction, N clones.
- ShedKey
runtime - THE COMPLETE ITEM KEY of a shed item, as a tap sees it.
- Sheds
runtime - THE OVERFLOW SEAT: a full bounded edge, and what the deployment said to do about one.
- Shutdown
runtime - Every party that will be running when the launch returns.
- Shutdown
Signal runtime - THE STOP LINE, from the BODY’s side: the one thing the framework ever says to a running node.
- Side
Table - ONE upstream’s PROVENANCE table, on a node several independent upstreams feed.
- Sighting
engine - ONE MEMBER’S SIGHTING of a fused root — its own evidence, and the weighted term it contributed.
- Sightings
engine - ONE ENTITY’s per-query sightings, as the fold accumulates them — the accumulator’s VALUE, and a
type a caller of
set_scorednames and never builds. - Skip
runtime - One intentional refusal, as the operator states it: WHY, and — where the operator can say so — WHICH content it was about.
- Slot
Binding runtime - ONE CORPUS whose leg named NO resource — what the sole-default law is resolved for.
- Slot
Column - ONE COLUMN of an engine-backed slot: the name a declaration elected, and the DOOR of the column language its values cross by.
- Slot
Handle - An engine handle BRANDED with the SLOT it was opened for.
- Slot
Lane runtime - The framework’s own serving lane: one branded slot, answered through the engine’s own verb.
- Slot
Mismatch tantivy - The payload of
TantivyFulltextError::SlotMismatch: which slot the handle indexes into, and which slot theSlotWriterit was handed is the capability for. - Slot
Name - A validated SLOT name — WHICH index of a kind a record’s documents land in, and that resource’s durable name.
- Slot
Schema - ONE FULL-TEXT CORPUS, as a declaration describes it: its durable name, the columns it holds, and whether the engine KEEPS what it indexed.
- Slot
Spec - ONE VECTOR CORPUS, as a declaration describes it —
SlotSchema’s twin, one family over. - Slot
Writer tantivy - The write capability for ONE slot: that slot’s sole
IndexWritertogether with the schema fields to write through. - Smol
Bytes - A
smol_bytes::Bytescolumn’s bytes — lowercase hexadecimal, two characters per byte. - Snapshot
Keeper engine - A BOUNDED IN-MEMORY STORE of fused rankings, keyed by opaque page tokens and installed once by a deployment.
- Split
Origin Error runtime - The payload of
Refusal::SplitOrigin: the origin, and every launched consumer pulling at its one feed. - SqlBarcode
Detection Comparison sqlx BarcodeDetectionFilter’s storage-side twin — four comparisons, and the two text-shaped ones reached through two different kinds.- SqlBounding
BoxComparison sqlx BoundingBoxFilter’s storage-side twin — four comparisons over the columns a rectangle HOLDS, one over the column it is INDEXED by, and nothing of its own.- SqlDetected
Language Comparison deriveandsqlx DetectedLanguageFilter’s storage-side twin: the identity’s four columns, and the confidence.- SqlDetection
Comparison sqlx DetectionFilter’s storage-side twin — the label’s comparison and the confidence’s, and nothing of its own.- SqlDocument
Segment Comparison sqlx DocumentSegmentFilter’s storage-side twin — the quad’s whole comparison and the confidence’s.- SqlDoor
async-graphqlandsqlx - The DOOR a resolver takes from a request’s context — one per database a schema serves.
- SqlGather
engineandsqlx - The system of record, as a retrieve reaches it: one connection, one row type, one dialect.
- SqlGenerations
runtimeand (mysqlorpostgresorsqlite) - ONE CLOSURE’S POINTERS, ON ONE SQL DATABASE — and the tables its retention duty reaches.
- SqlLanguage
IdComparison deriveandsqlx LanguageIdFilter’s storage-side twin: the four columns an identity occupies, and the two whole-identity sets that cannot decompose onto them.- SqlLocal
Timestamp Comparison deriveandsqlxandtime LocalTimestampFilter’s storage-side twin: the derived instant column, the wall clock, the displacement, and the presence bit.- SqlLocated
Detection Comparison sqlx LocatedDetectionFilter’s storage-side twin — the classification’s whole comparison, and the box’s beside it.- SqlMedia
Time Range Comparison mediatimeandsqlx MediaTimeRangeFilter’s storage-side twin: the algebra over the derived endpoints, the length, the two declared counts, and the timebase citizen nested inside.- SqlMedia
Timestamp Comparison mediatimeandsqlx MediaTimestampFilter’s storage-side twin: the derived position column, the declared count, and the timebase citizen nested inside.- SqlPoint2
Comparison sqlx Point2Filter’s storage-side twin — the two components’ comparisons, and nothing of its own.- SqlPooled
Gather engineandsqlx - The system of record as a RESOLVER reaches it: one pool, one row type, one dialect — and the ROWS themselves, which is the one thing a wire face can cross.
- SqlQuad
Comparison sqlx QuadFilter’s storage-side twin — four CORNER comparisons, each a wholeSqlPoint2Comparison.- SqlRate
Comparison mediatimeandsqlx RateFilter’s storage-side twin: the two columns a reduced rate occupies, the whole-value memberships over the pair, and the affix questions over its rendering.- SqlRetired
runtimeand (mysqlorpostgresorsqlite) - ONE ROOT FAMILY’S LEDGER, ON ONE SQL DATABASE.
- SqlRows
async-graphqlandsqlx - The SHIPPED
AsyncBatchLoad:kids of one table, in one statement, through a read door. - SqlText
Detection Comparison sqlx TextDetectionFilter’s storage-side twin — the words’ comparison, the confidence’s, and the region’s.- SqlTime
Range Comparison sqlx TimeRangeFilter’s storage-side twin: the three interval words, and the two ends.- SqlTime
Ranged Comparison sqlx TimeRangedFilter’s storage-side twin: the stretch’s whole comparison, and the payload’s own beside it.- SqlTimebase
Comparison mediatimeandsqlx TimebaseFilter’s storage-side twin: the two columns a reduced timebase occupies, the whole-value memberships over the pair, and the affix questions over its rendering.- Sqlite
Feed runtimeandsqlite - The portable floor: a SQLite table with an ordered integer key, given a change feed.
- Sqlite
Name - A variant’s word as SQLite spells it — the value a column of the vocabulary holds there.
- Sqlite
Positions runtimeandsqlite - The SQLite-backed positions table — the floor’s durable half.
- Sqlite
Positions Error runtimeandsqlite - A
SqlitePositionsstatement failed. - Staging
runtime - The values a launch walk has BUILT and not yet handed on — the pre-ignition unwind’s own list.
- Stamp
runtime - The three readings a transition may need, taken as ONE argument.
- Steady
runtime - A PINNED READING — the probe a test asserts through, and the one a deployment with its own signal writes.
- Step
engine - ONE DECLARED STEP, as the declaration wrote it.
- Stopped
runtime - What a stopped world settled — and what it did not.
- Stopper
runtime - THE STOP LINE, from the FRAMEWORK’s side — what says wind down to one running source.
- Stream
Best engine - ONE QUERY VECTOR’S SIGHTING of an entity: the best score that vector found in the entity’s set, and where that vector’s own stream put it.
- Stream
Lane runtime - THE STREAM LANE: N warm instances of one stream-faced unit, the deliveries in flight over them, and the downstream set their outputs cross.
- Stream
Options runtime - THE TWO PER-NODE SEATS a stream-faced node carries, and the machine reading one of them decides on.
- Stream
Sighting async-graphqlandengine - ONE QUERY VECTOR’S SIGHTING on the wire: its own best score in the entity’s set, and where its own stream put the entity.
- Streamed
runtime - WHAT ONE STREAMED DELIVERY DID — the info its ack carries and a tap reads back.
- Streaming
runtime - THE STREAMING PAIR WORD — what the
streamword seats atDeclared::Pair. - Stretch
engine - One stretch of a kept ranking, and the claim on the next one.
- String
Marker - Read a type as TEXT — one string of characters, which is what makes the substring and affix questions mean something.
- Subject
Path - The SUBJECT one ordering term names: the path to a column, root-first, under the names no per-database rename can move.
- Subtitle
Codec mediaframe - What a subtitle track’s bytes are encoded with — an FFmpeg subtitle codec name in the lowercase canon, or the open escape for one this build’s roster does not carry.
- Sum
engine Σⱼ bⱼ— standard MaxSim / late-interaction, and the citizen a door falls back to.- Summing
sum(<column>)— the TOTAL of what the group’s rows hold.- Sweeper
runtime - The R-LESS sweep clock: one thread, ringing every registered
Ringson an interval. - Table
- ONE node’s storage in ONE database: the table, its columns, the columns an index seeks it by, the columns a UNIQUE index constrains, and the edge tables its collections hang off.
- Taken
Inbox Error runtime - A node’s receiving half, asked for twice.
- Tally
runtime - What a delivery’s items did — the per-item detail a batch ack carries in its info slot.
- Tantivy
Address tantivy - THIS ENGINE’S ADDRESS VOCABULARY — the canonical binary form a key’s columns seal into, and the form a hit’s stored address arrives in.
- Tantivy
Columns tantivy - THE READ PHASE —
FulltextEngine::ReadBufferforTantivyFulltext, and the cursor a key takes its columns back off. - Tantivy
Doc tantivy - ONE ENTRY under construction —
FulltextWrite::DocforTantivyFulltext. - Tantivy
Fulltext tantivy - The Tantivy full-text face — a STATELESS keyed handle holding ONLY its slot name: no index, no reader, no writer.
- Tantivy
Slot Maker runtimeandtantivy - THE FACTORY VISITOR — layer two’s machine for a tantivy-backed resource: shown one declared type at a time, it creates every corpus that type owns in this mount.
- Tantivy
Store tantivy - The Tantivy connection-manager and the shared connection its handles thread: ONE index root plus the lazily-opened per-slot index cache.
- Tantivy
Terms tantivy - THE WRITE PHASE —
FulltextEngine::WriteBufferforTantivyFulltext, and the accumulator a key reports its columns into. - Taps
runtime - Several taps as one — the composition the multi-destination ruling needs.
- Tasks
runtime - The
async(spawn)word’s shipped engine: the runtime the deployment already named. - Temporal
jiffandtime - A temporal value in the form a column holds it — the local type the jiff →
timecrossing needs in order to be spelled at all. - Term
Name - WHICH orderable column an ordering term names — the identity a per-database rename cannot move.
- Text
Detection - WORDS THAT WERE READ, and the region they were read from.
- Text
Detection Filter - The filter that guards a
TextDetection<T>column: the WORDS, the confidence, and the region. - Text
Filter - The text filter — generic over the column’s string storage type
S(String,SmolStr,Box<str>, …), mirroring polarsync’sStringFilter<I>(boundAsRef<str>, notDisplay: tighter, and it borrows the value rather than forcing ato_string), and over the WIRE READINGIits operands cross under. Equality, ordering, membership, and the substring / affix operators with their case-insensitive (_nocase) and negated (not_) variants — each of the twelve is its own slot, and a backend lowering reads them as (kind, negated, nocase) triples over one dialect leaf. Bound-free struct; theAsRef<str>belongs on the lowering impls. Constructed vianew()/Default+ theopt_accessor!writers, and read through its getters (a#[derive(Default)]would both spuriously addS: Defaultand duplicatenew()’s canonical empty value). - Thread
runtime - The
spawnword’s engine: ONE OS THREAD PER TICK. - Ticked
runtime - One tick as the inbox carries it: WHICH upstream rang, and the capacity-one cell that ring occupied.
- Ticker
runtime - One poll upstream’s ringer — the ASYNC engine’s half of the clock.
- Ticks
runtime - THE TICK SEAT: what one node’s clock does when it ran late.
- Time
Range - A HALF-OPEN stretch of the UTC timeline,
[start, end):startis in it andendis not. - Time
Range Filter - What guards a
TimeRangecolumn: the three INTERVAL words, and the two ENDS. - Time
Range Operand - The OPERAND, and it is a newtype for exactly
LanguageIdOperand’s reason: GraphQL keeps objects and input types in ONE namespace, andTimeRangeis an object. - Time
Ranged - A
Tand WHEN it was — the shape a timed analysis emits, with the timing held once and the payload left alone. - Time
Ranged Filter - What guards a
TimeRanged<T>column: the RANGE’s own filter, and the PAYLOAD’s own filter. - Timebase
mediatime - A media timebase — the rational
num / denthe stream itself declares, wrappingmediatime::Timebase. - Timebase
Filter mediatime - The filter that guards a
Timebasecolumn: three FACETS of one value, which is what a rational tag stored in two columns can honestly be asked about. - Timebase
Operand async-graphqlandmediatime - A whole timebase, on its way IN — the carrier the value facet’s four operators cross on.
- Timestamp
- An instant on the UTC timeline, to the NANOSECOND, from
-9999-01-02T01:59:59Zto9999-12-30T22:00:00.999999999Z. - Tower
Door engine - THE ASSEMBLED QUESTION ROAD a schema’s bound towers are walked over — one per tower a schema serves, and REQUIRED wherever a recipe bound one.
- Tracing
Tap runtimeandtracing - THE SHIPPED TAP: every observation, as a
tracingevent. - Track
runtime - WHOSE position: the node that is reading, and the source it is reading.
- TypedId
- An id AND WHAT IT ADDRESSES:
Iis the stored id,Ethe thing that id names. - U8
- An unsigned 8-bit integer on the wire — a JSON number, exact in both directions.
- U8Vector
- A
Vec<u8>column’s bytes — lowercase hexadecimal, two characters per byte. - U16
- An unsigned 16-bit integer on the wire — a JSON number, exact in both directions.
- U32
- An unsigned 32-bit integer on the wire — a JSON number, exact in both directions.
- U64
- An unsigned 64-bit integer on the wire — a JSON number inside the safe range, decimal text beyond it.
- U128
- An unsigned 128-bit integer on the wire — a JSON number inside the safe range, decimal text beyond it.
- Unacked
runtime - THE ACKED GIVE WAS REFUSED, and here is the item back.
- Unbound
Corpus runtime - ONE CORPUS a declaration owns whose leg named NO resource — the row a launch resolves by the SOLE-DEFAULT law.
- Unbound
Slot Error runtime - The payload of
Refusal::UnboundSlot: the corpus that named no resource, the KIND it needs, and every resource this deployment declared that could have held it. - Unbridged
Origin Error runtime - The payload of
Refusal::UnbridgedOrigin: the edge no bridge can open, and both of its ends by name. - Unbuilt
Target Error runtime - A TARGET A DECLARATION POINTS AT THAT THIS DEPLOYMENT NEVER BUILT — layer two’s own refusal, and the sentence that replaced a silent skip.
- Uncatalogued
Resource Error runtime - A resource built through the create walk that the ROOT CATALOG does not carry.
- Unchanneled
runtime - The shelf of a node that declares NO upstreams — the rack’s default, and the only shelf a document can write nothing into.
- Undeclared
Resource Error runtime - The payload of
Refusal::UndeclaredResource: the node that demanded, its name, and the resource nothing declared. - Unfed
runtime - THE ITEM WAS NOT TAKEN, and here it is back.
- Unfenced
Suffix - A row held a value its family’s own fence does not admit.
- Unknown
Analyzer tantivy - The payload of
TantivyFulltextError::UnknownAnalyzer: which lane named an analyzer, and what it named. - Unknown
Generations Engine runtime - A word that is not one of the three engines the framework builds.
- Unknown
Grant Error runtime - The payload of
Refusal::UnknownGrant: who granted itself the write, from which clock, and over what. - Unknown
Lane - NO LANE ANSWERS THIS TAG — the gate’s refusal, naming what it was handed and what it had.
- Unknown
Node Error runtime - The payload of
Refusal::UnknownNode: the name the options used. - Unknown
Retired Engine runtime - A word that is not one of the four engines the framework builds.
- Unknown
Upstream Error runtime - The payload of
Refusal::UnknownUpstream: who subscribed, and to what. - Unnameable
Family runtime - A family whose spelling cannot become a table name — see
RetiredTable::new. - Unnameable
Scope runtime - A word that cannot name a closure — see
Scope::new. - Unnameable
Table runtime - A word whose spelling cannot reach a statement — see
Generational::newandCurrentTable::new. - Unpoliced
runtime - The shelf of a node that selects NO policy — the rack’s default, and every node today.
- Unpolled
runtime - The absence of a poll arm, as a type.
- Unpressured
runtime - THE MACHINE NEVER RUNS SHORT — the shipped
MemoryProbe, and today’s behaviour as a type. - Unraised
Page async-graphql - A page whose nodes were raised elsewhere and did not all come back.
- Unrepresentable
Confidence - What one WIDTH refuses a wide-door operand with, and the only refusal a confidence crossing has.
- Unroutable
Lane - A PROBE NAMED A LANE THIS CORPUS DOES NOT HOLD — guardrail ②’s refusal.
- Unruntimed
runtime - The absence of an async runtime, as a type.
- Untorn
runtime - One enrolled teardown that did not say goodbye — the shutdown report’s un-torn class.
- Unwritten
runtime - A delivery’s write did not commit everything it staged.
- Unwritten
Artifact async-graphql - AN OBJECT THAT IS NOT THERE, at a position whose declaration signed for it.
- Upstream
runtime - ONE inbound edge, as the declaration wrote it.
- Upstream
Wiring runtime - What one inbound edge declares — the per-upstream words, mixable within one fan-in.
- Upstreams
runtime - THE INBOUND EDGES, AS A NODE THAT OWNS ITS LOOP HOLDS THEM — one receiving end apiece, in declaration order.
- Vanished
runtime - THE RUN ENDED WITHOUT ANSWERING — its body panicked, or its thread was killed under it.
- Vector
Ask runtime - What a vector
SlotLaneis asked: the per-call scope, and the coordinates. - Vector
Column - WHICH embedding of a slot a call is about — the ELECTION SELECTOR.
- Vector
Query engine - A vector retrieve: the query embedding, and the minimum score a neighbour must reach.
- Video
Codec mediaframe - What a video track’s bytes are encoded with — an FFmpeg video codec name in the lowercase canon, or the open escape for one this build’s roster does not carry.
- Walk
Budget engine - TIER TWO’s SEAT: the budget a launch named for one tower, and the clock that measures it.
- Wanted
runtime - WHICH of a node’s products have somewhere to go — the connection state, one bit per product in declaration order.
- Weighted
engine Σⱼ wⱼ·bⱼ— the sum with a weight per QUERY VECTOR, for a caller whose questions are not equally important.- Wired
runtime - A checked plan: what runs, and how.
- Wiring
runtime - THE WIRING WALK over a created deployment: edges, clocks, and the shutdown registry.
- Word
runtime - A DECLARED mode word, as a type — the bridge two macro expansions meet at.
- Worn
runtime - THE CELL a declaration’s two words name — what a launch’s every per-node line is addressed to.
- Written
runtime - What one
JournalWriterrun did. - Wrong
Byte Width - What a fixed-width byte column refuses a wire value with, and the only refusal among the framework’s own byte rows.
- Yielded
runtime - THE FEED LINE, from the FRAMEWORK’s side — where a source’s items are taken out.
- Zero
Operand - What a
NonZero*operand refuses a wire ZERO with — the INPUT direction’s half of the invariant, and the wire twin ofNonZeroColumnError.
Enums§
- AckMode
runtime - When a node releases its INPUT’s ack — the per-upstream opt-in.
- AckRefusal
runtime - WHY AN ACKED GIVE WAS REFUSED — the two facts, and the item is in the refusal either way.
- Answer
runtime - What a sender learns when it asks one outstanding delivery for its answer.
- Arrange
Error runtime - Why a
GraphBuilderfailedvalidate. Variants are declared invalidate’s check order. - Attached
runtime - What seating ONE out-edge in a downstream set came to.
- Audio
Codec Wire mediaframe - What a filter over
AudioCodecis NAMED, and the carrier its eight operators hold. - Barcode
Detection Leaf - The VALUE one of a decoded code’s seven levels compares.
- Barcode
Payload Kind - THE KIND OF THING a barcode’s decoded payload names — ten named kinds, plus an escape for a word this vocabulary does not name.
- Bounding
BoxLeaf - The VALUE one of a rectangle’s four levels compares — the per-leaf vocabulary this citizen publishes beside its sequence, and the type an emitted cursor’s slot is minted with for a column of this type.
- Bridge
engine - HOW A BROADCAST SEAT CROSSES into one arm’s question — the word the arm’s
sharedwas written with. - Builtin
- The framework’s own reading of a crossing — the default every filter’s carrier parameter takes, so that a spelling written before the axis existed means what it meant.
- Channel
Options runtime - WHAT an edge is opened as: bounded at a depth, or unbounded.
- Claimed
- WHAT TWO LANES CLAIMED — a word, or the catch-all role.
- Column
Door - WHICH DOOR of the column language one column went through — the KIND, named for the method that IS it, and as the ROW asked for it rather than as a default chain rewrote it.
- Column
Shape - What one FIELD of a row contributes to its table’s columns.
- Concern
runtime - WHICH policy advised — the four v1 concerns, as a report names them.
- Confidence
Operand Error - Why one wide-door operand was refused, and there are exactly two reasons.
- Conformance
Error - WHAT CONFORMANCE FOUND — one arm per way the round trip can fail, and each one names the party at fault.
- Contained
- What
containswas handed: one INSTANT, or a whole SPAN. - Cursor
Error - Why a cursor cannot be honoured.
- Custody
runtime - WHO owes a delivery’s answer: one token, or the tokens a JOIN composed.
- Driver
Engine runtime - WHICH ROAD a running driver took.
- Driver
Kind runtime - Which driver runs a node.
- Edge
Shape - The shape an edge table keeps a collection in — which decides whether its rows carry an ordinal, and therefore what a materialization can order by.
- Effect
runtime - What a node does with what it produces — the fact the pure-leaf refusal is decided on.
- Element
Columns - What ONE ELEMENT of a collection occupies in its edge table.
- Emission
runtime - One buffered output from an
acceptcall: a typed emit or an intentional skip. Typed inOut— no erasure is needed because an operator has exactly one output type. A processing failure is not an emission: it is theErrofOperator::accept, which the driver turns into aDeadLetteredfate. - Error
Code - The stable word one wire refusal is recognised by — the value of
extensions.code. - Expand
Origin engine - WHERE ONE QUESTION ON THE ROAD CAME FROM — the provenance an
Expandedcarries out of the expand step. - Fallibility
runtime - HOW ONE EXCHANGE FAILS, as its declaration said it does — the three-tier signature, as a fact.
- FanError
- HOW A FAN REFUSES — one arm per cause, carrying each whole.
- Fanout
Kind runtime - How a producer’s output edge reaches its consumer(s). Semantic, per-edge data — the runtime derives delivery from it.
- Fate
runtime - HOW A DELIVERY ENDED, where it ended without reaching a station.
- Feeder
runtime - WHOSE HAND fills the store a
Changesedge watches. - Fin
runtime - HOW A STREAMING LIFE ENDED — the
Okhalf of what arunanswers, at either of the two layers that have one. - Fulltext
Subset - WHICH of a slot’s searchable columns one
searchruns over — the read GRAIN, always passed. - Fusion
engine - The fusion strategy a fused retrieve runs.
- Fusion
Options engine - WHICH fold a tier runs, and the numbers that fold takes — the wire and configuration face of
Fusion. - Generations
Engine runtime - WHICH ENGINE A FAMILY’S CURRENT POINTERS RUN ON — the
generations(<engine>)word, as a value. - Grain
engine - The grain a retrieve’s dedup collapses at.
- Handover
runtime - WHAT ONE POLICY-GOVERNED HAND-OVER DID.
- Intake
Error runtime - Why a
ChangeIntakepass stopped. - KeyDecode
Error tantivy - A stored address failed to parse back into the values it was written from.
- Label
Wire - How a label crosses when the framework’s own text filter holds it — the reading that gives
TextFilter<Label, LabelWire>a face. - Language
IdColumn Error derive - Four columns do not hold a language identity, and this says why.
- Language
IdCrossing Error deriveandsqlx - A
LanguageIdFilterdid not reach the four columns, and this says which part of it did not. - Language
Wire derive - How this subtag crosses when the framework’s own ordering filter holds it — the reading that
gives
ScalarFilter<Language,LanguageWire>a face. - Launch
Error runtime - Why a launch did not happen — the validate walk’s WHOLE answer, or the create walk’s FIRST.
- Lifecycle
runtime - Where one item got to, as its consumer states it.
- Listen
runtime - How one inbound upstream feeds a node — the per-upstream word, mixable in one fan-in.
- Local
FsBlob Error - A local-filesystem blob failure.
- Local
Timestamp Leaf deriveandtime - The VALUE one of those four levels compares — the per-leaf vocabulary the citizen publishes beside its sequence, and the type an emitted cursor’s slot is minted with for a column of this type.
- Local
Timestamp Parts Error deriveandtime - Why a stored
(local, offset_seconds, offset_stated)triple is not a capture time. - Located
Detection Leaf - The VALUE one of a located finding’s six levels compares — the per-leaf vocabulary this citizen publishes beside its sequence.
- Many
Operands - The kind marker for a LIST OF OPERANDS — the
in/notInshape, crossing as a list of the element’s carrier. SeeOneOperandfor why the name is notOperands. - Media
Contained mediatime - What
containswas handed: one INSTANT, or a whole SPAN. - Media
Time Range Crossing Error mediatimeandsqlx - A
MediaTimeRangeFilterdid not reach its columns, and this says which part of it did not. - Media
Time Range Leaf mediatime - The VALUE one of those six levels compares — the per-leaf vocabulary this citizen publishes beside its sequence, and the type an emitted cursor’s slot is minted with for a column of this type.
- Media
Timestamp Crossing Error mediatimeandsqlx - A
MediaTimestampFilterdid not reach its columns, and this says which part of it did not. - Media
Timestamp Leaf mediatime - The VALUE one of those four levels compares — the per-leaf vocabulary the citizen publishes beside its sequence, and the type an emitted cursor’s slot is minted with for a column of this type.
- Nested
Filter - The kind marker for a NESTED FILTER — a slot holding a whole filter over a component of the
subject, crossing as that filter’s own input object. See
OneOperandfor why the name is notNested. - NoUtc
Position deriveandtime - Why a
LocalTimestamphas no UTC position. - Observation
runtime - EVERYTHING A TAP IS SHOWN: an item’s arrival at a station, and the framework’s own events beside it.
- OneOperand
- The kind marker for ONE OPERAND — a slot holding a single value of the subject’s own element type, crossing on that element’s carrier.
- Order
Direction - Which way one ordering term runs.
- Overflow
Decision runtime - WHAT TO DO ABOUT A FULL EDGE.
- OwnRead
Error engine - What an OWN READ reports: the engine refused, or the entity’s own stored vector did.
- Page
Argument async-graphql - One of the four pagination arguments a client may write.
- Page
Error async-graphql - Why these arguments describe no page.
- Page
Request async-graphql - The page a client’s arguments describe: which way it walks, how wide, and where it resumes.
- Page
Token Refusal engine - Why a page token cannot be honoured.
- Parse
Clock Error mediatime - A string does not name a clock position.
- Parse
Language Error derive - A string does not name a language subtag.
- Parse
Language IdError derive - A string does not name a language identity.
- Parse
Rate Error mediatime - A string does not name a
Rate. - Parse
Region Error derive - A string does not name a region subtag.
- Parse
Script Subtag Error derive - A string does not name a script subtag.
- Parse
Time Range Error - Why a string is not a stretch.
- Parse
Timebase Error mediatime - A string does not name a
Timebase. - Payload
runtime - What ONE delivery carries: a single item, or a batch of them.
- Payload
Iter runtime Payload’s owning iterator. Two arms rather than oneVecwalk, so the single case still allocates nothing.- Product
Seat Error runtime - A node’s OWN downstream set could not seat one of its declared out-edges.
- Query
Error runtime - Why a message this framework carried did not get where it was going.
- Rate
Column Error mediatime - A pair of columns does not hold a rate, and this says which invariant they broke.
- Rate
Crossing Error mediatimeandsqlx - A
RateFilterdid not reach the two columns, and this says which part of it did not. - Recurrence
runtime - How ONE poll entry recurs: on a fixed interval, or on a calendar.
- Refusal
runtime - ONE thing wrong with a deployment, as
Plan::validatefound it. - Refused
- Which leg of a two-legged fan refused, carrying that leg’s own error.
- Refused
Box - Why a unit box was refused — the three rules
BoundingBox::try_unitchecks, in the order it checks them. - Region
Wire derive - How this subtag crosses when the framework’s own ordering filter holds it — the reading that
gives
ScalarFilter<Region,RegionWire>a face. - Registry
Origin async-graphql - WHO RETIRES A KEY, ON THE WIRE — lowercase per the same law:
vanisheduser. - Registry
State async-graphql - ONE ROOT KEY’S STATE, ON THE WIRE —
RootStatewith every payload erased, because a unit enum is what a wire vocabulary this closed IS: five values, framework-owned, and no downstream crate has anything to add to where a key stands. - Related
Filter - A predicate over a REVERSE relation position — the rows whose own
refpoints back at this one — asked through the four quantifiers a collection is asked through, EXACTLY ONE at a time. - Resource
Kind runtime - A resource’s CITIZENSHIP: it is in the walk, so a plan can enumerate it and a demand can be checked against it.
- Resource
Source runtime - WHERE one resource’s options come from — the ONE source its declaration named.
- Retire
Origin runtime - WHO retired a key, and the whole of what the answer decides.
- Retired
Engine runtime - WHICH ENGINE A ROOT’S RETIRED LEDGER RUNS ON — the
retired(<engine>)word, as a value. - Retirement
runtime - THE DURABLE ACT A MOVE EARNED — named here, performed elsewhere.
- Retrieve
Error engine - Why a retrieve did not answer: the ENGINE refused, or the STORE did.
- Retry
Decision runtime - WHAT A FAILED ITEM EARNS.
- Root
Action runtime - WHAT MAY BE ASKED OF A ROOT KEY.
- Root
Advance runtime - WHAT ONE ASK DID.
- Root
State runtime - ONE ROOT KEY’S STATE.
- Rung
runtime - What a wait on a
Doorbellfound. - Script
Subtag Wire derive - How this subtag crosses when the framework’s own ordering filter holds it — the reading that
gives
ScalarFilter<ScriptSubtag,ScriptSubtagWire>a face. - Sent
async-graphql - The DELEGATION TRAIT a nullable column’s wire face is written over — the seam a downstream
filter joins
Nullable<F>through, since neither side can write the impl itself — and the SHORTHAND LAW’s own reading, which every filter face in every crate answers by asking it. - Skip
Reason runtime - Why a message was intentionally not emitted (a recorded gap, not an error).
- Sqlite
Feed Error runtimeandsqlite - Why a
SqliteFeedrefused. - Station
runtime - The station table on its own — what a watermark condition matches and what a tap counts.
- Std
- THE GRAPHQL STANDARD FIVE, as a reading a field NAMES — the constitution’s second law, and
the seat
Int,Float,String,BooleanandIDkeep now that they are not the default. - Subtitle
Codec Wire mediaframe - What a filter over
SubtitleCodecis NAMED, and the carrier its eight operators hold. - Swept
runtime - WHAT BECAME OF ONE TICK, as the seat answers it.
- Symbology
- THE BARCODE STANDARD a payload was encoded in — twenty-four named symbologies, plus an escape for a word this vocabulary does not name.
- Table
Columns - How a
TableSTATES its columns — the two roads a descriptor is written down. - Tantivy
Fulltext Error tantivy - A Tantivy full-text failure — of the manager’s open or writer path, or of a handle’s op.
- Term
Subject - What a term’s subject IS in the database the term was built for: one value in a column of the row, or a COLLECTION — and, where it is one, which of the two places this database keeps it.
- Terminal
runtime - The terminal table on its own — what a tap counts and what an account balances against.
- Text
Detection Leaf - The VALUE one of a reading’s six levels compares.
- Tick
Decision runtime - WHAT TO DO ABOUT MISSED TICKS.
- Timebase
Column Error mediatime - A pair of columns does not hold a timebase, and this says which invariant they broke.
- Timebase
Crossing Error mediatimeandsqlx - A
TimebaseFilterdid not reach the two columns, and this says which part of it did not. - Timestamp
Parts Error - Why a stored
(secs, nanos)pair is not an instant. - Tracing
Level runtime - The LEVEL a node’s spans open at — the closed vocabulary
tracing(level = …)writes. - Unfilled
Seat engine - ONE DECLARED WORD WHOSE SEAT IS EMPTY — which step, which word, and what the assembly owed it.
- Unreceipted
runtime - WHY A RECEIPT DID NOT COME BACK — the acked give’s refusal roster, and every arm is a different mistake.
- Unsettled
runtime - WHY A DELIVERY’S ANSWER NEVER CAME — the two terminal outcomes of a wait on one ack.
- Video
Codec Wire mediaframe - What a filter over
VideoCodecis NAMED, and the carrier its eight operators hold. - Wake
runtime - What woke a resident.
- Walk
- Which way a page runs through a written order.
- Writing
System - A WRITING SYSTEM, spelled the way ISO 15924 spells one.
Constants§
- CURRENT_
TABLE_ PREFIX runtime - The prefix every current-pointer table’s name carries — the framework’s own reserved stem.
- DEFAULT_
BATCH_ MAX_ ITEMS runtime - The batch item ceiling a document does not name — see
RegistryOptions::batch_max_items. - DEFAULT_
BATCH_ MAX_ WAIT runtime - The batch wait a document does not name — see
RegistryOptions::batch_max_wait. - DEFAULT_
DEBOUNCE runtime - The debounce window a document does not name — see
RegistryOptions::debounce. - DEFAULT_
FEED_ DEPTH runtime - THE MEASURED DEFAULT DEPTH: 256 items.
- DEFAULT_
IN_ FLIGHT runtime - HOW MANY DELIVERIES ONE STREAM-FACED NODE HOLDS AT ONCE, by default: one.
- DEFAULT_
KEEP runtime - HOW MANY GENERATIONS A CLOSURE KEEPS when a document says nothing — ONE, the current.
- DEFAULT_
RETIRE_ DRAIN runtime - The retiring drain ceiling a document does not name — see
RegistryOptions::retire_drain. - DEFAULT_
SETTLE runtime - The settle smoothing a document does not name — see
RegistryOptions::settle. - DEFAULT_
SNAPSHOT_ CAPACITY engine - HOW MANY SNAPSHOTS one keeper holds before the least recently read one goes.
- DEFAULT_
SNAPSHOT_ DEPTH engine - HOW DEEP a kept ranking goes — the shipped ceiling on one snapshot’s length.
- DEFAULT_
SNAPSHOT_ TTL engine - HOW LONG a snapshot outlives the ask that made it.
- MAX_
PATH_ LEN - The most bytes a WHOLE resolved blob address may occupy, the store’s root included —
LocalFsBlobError::PathTooLongrefuses past it. - MAX_
SEGMENT_ LEN - The most bytes ONE path component of a blob address may occupy —
LocalFsBlobError::SegmentTooLongrefuses past it. - RETIRED_
TABLE_ PREFIX runtime - The prefix every retired-ledger table’s name carries — the framework’s own reserved stem.
- RUN_
COLUMN runtime - THE RUN COLUMN every generational record wears — the framework’s own, on every replace-set family.
- UNDIVIDABLE
runtime - THE LABEL A REFUSED FAN-OUT WEARS — what a tap matches when a downstream set promised one output two seats and its payload makes one copy of itself: none.
Traits§
- Annotated
Question engine - A QUESTION THAT CARRIES AN ANNOTATION — the ⟂ stage’s one seat, written at the stage and READ everywhere after it.
- Answers
runtime - What a node does on its TRANSIENT arm —
Operator’s query-side twin. - Artifact
Data - This family’s bytes may be served INLINE — the
dataword, as a capability. - Artifact
Store - WHERE an artifact family’s objects live, and the verb a wire face spends on them.
- Artifact
Suffix - The SUFFIX one HYDRATED ROW renders — where the
extensionword’s six forms are resolved. - Assemble
sqlx - How a value is read back out of the columns it spans.
- Assembled
Tower engine - A TOWER WHOSE SEATS ARE FILLED — the gate a deployment’s assembly is read by, and the ONE call a resolver makes over it.
- Async
Answers runtime Answers’ ASYNCHRONOUS face — the same query role, for a responder that has an.awaitto spend.- Async
Autonomous Operator runtime AutonomousOperator’s ASYNCHRONOUS face — the same owned loop, for a body that has an.awaitto spend.- Async
Batch Load - THE NEUTRAL SEAM: these keys, in one ask.
- Async
Blob Engine - A blob store (local filesystem, S3, …), generic over the record
Rit stores: UNBOUNDED overR, with onlyget— whose signature projectsR::Key— carrying the method-levelwhere R: Transformer.puttakes a bare&R. - Async
Blob Store - Construction for a blob store — key-addressed under ONE connection-manager, partitioned by artifact-family slot.
- Async
Changes runtime - A store that publishes a change feed on
Db. - Async
Constructor runtime - A type a LAUNCH can build — the capability a node’s author implements by hand.
- Async
Fulltext Read - The full-text family’s READ half, answered through a FUTURE —
FulltextRead’s twin, at the same signature with the wrapper on. - Async
Fulltext Store - Construction for a full-text store — per-slot indices opened and cached behind ONE connection-manager.
- Async
Fulltext Write - The full-text family’s WRITE half, answered through a FUTURE —
FulltextWrite’s twin, at the same signature with the wrapper on. - Async
Fused Read engine - HOW a parent asks a member for its ranked keys.
- Async
Gather engine - The store side of a retrieve: a batch of keys, the caller’s filter, and the entities that survive both.
- Async
Initialize runtime - LAYER TWO’s AWAITED FACE —
Initialize’s twin, for a mount whose creates answer with a future. - Async
Lands runtime - A node’s own write — the socket a landing consumer’s durability comes through.
- Async
Locate - Resolve a blob’s ADDRESS without reading it — the wire-facing ref.
- Async
Operator runtime Operator’s ASYNCHRONOUS face — the same compute unit, for a body that has an.awaitto spend.- Async
Query Expander engine - THE CALL SEAT —
QueryExpander’s awaited face, and the oneExpansion::expandspends. - Async
Resource runtime - A type SEVERAL UNITS may hold at once — the capability contract, hand-implemented by the resource’s author.
- Async
Serves runtime Serves’ ASYNCHRONOUS face — the same read-path capability, for a lane whose answer has to be awaited.- Async
Source runtime Source’s AWAITED face — the same origin, for a life that has an.awaitto spend.- Async
Spawn runtime Spawn’s async twin: WHERE A DETACHED ASYNC TICK RUNS.- Async
Stream Operator runtime StreamOperator’s ASYNCHRONOUS face — the same per-delivery life, for a body that has an.awaitto spend.- Async
Teardown runtime - A value with something to SAY before the process leaves it — the opt-in goodbye.
- Async
Tick runtime - WHAT A MOUNTED CLOCK RUNS — the async citizen a
poll(…)entry names withhandler = "…". - Async
Type Visitor TypeVisitor’s AWAITED twin — the face a walk takes when the per-node work is I/O that cannot be postponed.- Async
Vector Read - The vector family’s READ half, answered through a FUTURE —
VectorRead’s twin, at the same signatures with the wrapper on. - Async
Vector Store - Construction for a vector store — per-slot tables opened and cached behind ONE connection-manager.
- Async
Vector Write - The vector family’s WRITE half, answered through a FUTURE —
VectorWrite’s twin, at the same signature with the wrapper on. - Attaches
runtime - THE CONSTRUCTION HALF OF
Sink— how a launch fills a downstream set whose products it cannot name. - Attributes
runtime - The per-node hook: what a record this node emitted descends from, and where an observation about that record goes.
- Autonomous
Operator runtime - A node whose WHOLE LIFE is one call: it owns the loop, selects across its own inbound edges in its own order, and publishes through its own downstream set until it is spent or told to stop.
- Batched
- THE ERASED CAPABILITY a
BatchDoorcarries: one key, answered. - Bests
engine - A KEYED ACCUMULATOR over the entities a set query has scored so far — the fold’s one moving part.
- Blob
Artifact - AN ARTIFACT FAMILY, seen from the declaration that SERVES it — the bridge two macro expansions cross when neither can read the other’s tokens.
- Blob
Engine - A blob store served on THIS THREAD —
AsyncBlobEngine’s blocking twin, and on a filesystem the face that holds the act rather than the one that wraps it. - Blob
Record - A blob-store entry: its byte payload and its file format.
- Blob
Source - WHERE an artifact family’s addresses are resolved — the seam an application answers with its own store.
- Blob
Store - Construction for a blob store whose OPENING is a blocking act —
AsyncBlobStore’s twin, and the narrowest of the three: it differs in exactly one verb. - Blob
Table - The ARTIFACT FAMILY a blob record’s objects land in — the blob side’s naming authority, and
FulltextTable’s sibling in every respect that matters. - Bool
Filter Marker - What guards a column whose type is read as a BOOLEAN.
- Bound
- ONE ROW OF THE MEMBER TABLE: an engine WORD a graph root bound, and the type it named.
- Bytes
Filter Marker - What guards a column whose type is read as a BYTE STRING.
- Bytes
Wire - What a BYTES filter’s operands cross the wire as, and the name that filter is published under — the third reading, over the byte vocabularies.
- Channel
Shelf runtime - WHAT A PER-NODE CHANNELS BLOCK CAN BE ASKED, whoever emitted it.
- Collection
Element - A type that may be ONE ELEMENT of a collection.
- Column
Eq - Whether two values of this column type are the same value.
- Column
Error - WHAT AN ENGINE’S ERROR MUST BE ABLE TO SAY — the obligation a row’s own refusals put on it.
- Column
Kind - What a field of this TYPE contributes to its row’s columns.
- Column
Reader - A KEY TAKING ITSELF BACK, one typed column at a time.
- Column
Writer - A KEY REPORTING ITSELF, one typed column at a time.
- Composite
Filter Marker - What guards a column whose type is read as a COMPOSITE.
- Confidence
Carrier - The widths a
Confidencemeasures in. - Confidence
Wire - A confidence at ONE WIDTH as the wire sees it — which roster scalar it is returned under, and how it reads a wide-door operand.
- Cursor
Codec - A byte form written by a TYPE OTHER THAN THE VALUE’S — the seat a household mounts its own cursor codec at.
- Cursor
Value - The bytes one cursor slot’s value crosses the opaque boundary as.
- Deadline
Policy runtime - A DOOR’S AMBIENT BUDGET: how long a question may take when its asker did not say.
- Declared
runtime - THE FACTS ONE NODE STATES ABOUT ITSELF — everything the launch walk needs and the root’s own declaration cannot see.
- Declared
Leaves - MY COLUMNS MEAN THE SEQUENCE THEY ARE DECLARED IN — the ONE WORD a composite that states no
ORDERwrites, and the key to theOrderLeavesrow below it. - Declared
Mutation runtime - WHAT ONE MUTATION NODE DECLARED — the facts its own expansion states, for the readers that cannot see its tokens.
- Declared
Origin runtime - WHAT ONE ORIGIN DECLARED — the facts a launch walk needs and a root’s own declaration cannot see.
- Declared
Resource runtime #[ingraph::resource]emitsimpl DeclaredResource for …, and the SUPERTRAIT is what makes the declaration assert the contract: a type declared without aAsyncResourceimpl isE0277AT THE DECLARATION rather than at the first unit that reached for it.- Declared
Search engine - WHAT ONE SEARCH RECIPE DECLARED — the facts its own expansion states, for the readers that cannot see its tokens.
- Declared
Tower engine - WHAT ONE TOWER DECLARED — the facts its own expansion states, for the readers that cannot see its tokens.
- Default
Marker - The marker a field’s type carries when the declaration names none.
- Default
Serve runtime - WHAT THIS SERVER IS CANONICALLY ASKED, AND WHAT IT CANONICALLY ANSWERS — the one-time line that makes a tower’s own words omissible.
- Default
VecMarker - What a
Vecof this ELEMENT type means when a declaration names no marker. - Delegates
Id - UNSAFE TO IMPLEMENT. The TRANSPARENCY ASSERTION:
Selfholds anIdand adds nothing a key can see, so every id duty may readdelegateINSTEAD ofSelf. - Describe
- What ONE node’s storage looks like in
Db— the per-type, per-TARGET self-description a walk hands to a visitor. - Dialect
Cursor - The byte form a value has AT ONE DIALECT — what a page-walk on
Dbactually spends. - Driven
runtime - WHAT A UNIT IS, in a mode
M: the three types both faces declare, said once so the driver can be written once. - Drives
runtime - THE DRIVING MATRIX: which of the two engines spends which of the two faces, and how.
- Duration
Filter Marker - What guards a column whose type is read as a DURATION.
- Elected
- ONE ELECTION of
T, as a TYPE — theVectorColumnabove lifted out of the value world. - Elects
One - The
embeddingLABEL’s claim, held over the MULTIPLICITY a field’s marker answers with. - Elects
Set - The
list(embedding)LABEL’s claim —ElectsOne’s twin, whose note states the whole of what this trait is for. - Embedding
Marker - A field an
embedding(<field>)election may name — ONE embedding, or a carrier holding a SET of them. - Embedding
Shape - ONE embedding’s own facts — the element type, the width and the space — as a projection rather than as a spelling.
- Emits
runtime - The Nth product a node emits, in declaration order — the projection a SUBSCRIPTION is spelled through.
- Enum
Filter Marker - What guards a column whose type is read as an ENUMERATION.
- Equals
Filter - The one filter an EXPANSION builds rather than receives: this kind’s empty filter with its equality operator set.
- Feed
Policy runtime - HOW DEEP TO CUT ONE DELIVERY’S FEED — judged at that delivery’s spawn.
- Field
- A KEY VALUE REPORTING ITSELF IN COLUMNS — engine-blind, written once, read by every engine.
- Filter
Slot - Which SHAPE one slot of a composed filter is, and whether it asks anything.
- Flags
Filter Marker flags - What guards a column whose type is read as a FLAGS SET.
- Flatten
Face async-graphql - The DELEGATION TRAIT a nullable column’s wire face is written over — the seam a downstream
filter joins
Nullable<F>through, since neither side can write the impl itself — and the SHORTHAND LAW’s own reading, which every filter face in every crate answers by asking it. - Fold
Semantics engine - HOW the per-query bests fold into one set score — the query-time contract of the multi-vector round.
- Fold
Visitor engine - WHAT AN EMITTED WIRE VOCABULARY HANDS ITS FOLD TO — the crossing from a closed set of words back to the open set of types.
- From
Graphql Order By - The infallible crossing: build a database’s level sequence from a completed wire order that needs no conversion.
- Fulltext
Engine - A full-text index (Tantivy, an FTS5 virtual table, a Postgres
tsvectorcolumn) — R-FREE. - Fulltext
Lane - ONE ENGINE’S WRITE LANE — how a party holding nothing but this engine opens a batch, builds the entries for it, publishes it, and throws it away.
- Fulltext
Mount - A resource a FULL-TEXT election reads through — the mount, mode-blind, minting one corpus at a time.
- Fulltext
Read - The full-text family’s READ half, answered SYNCHRONOUSLY —
search, and the lease it spends. - Fulltext
Record - A full-text entry: the document to index.
- Fulltext
Road - ONE FULL-TEXT SLOT’s document contract: the ROAD its elected field takes into the sink, and whether the engine KEEPS the original value beside what it indexed.
- Fulltext
Store - Construction for a full-text store whose OPENING is a blocking act —
AsyncFulltextStore’s twin, and the narrowest shape a store pair takes: it differs in exactly one verb. - Fulltext
Table - WHICH full-text slot a record’s documents land in — the record’s durable SLOT name.
- Fulltext
Write - The full-text family’s WRITE half, answered SYNCHRONOUSLY — the keyed replace, and the two seats only a write spends.
- Fusable
engine - WHAT a member contributes to a fused query: the options package it is configured with, and the question package it is asked with.
- Fused
Citizen async-graphqlandengine - HOW A SCHEMA ASKS ONE MEMBER FOR ITS RANKED KEYS — the wire twin of
AsyncFusedRead::keys, with the citizen lookup inside it. - Fused
Engine async-graphqlandengine - WHICH ENGINE A SCHEMA ASKS THIS MEMBER THROUGH.
- Generation
Ledger runtime - WHERE A CLOSED RUN’S OWN DURABLE ACT GOES — the flip seat,
RetiredLedger’s sibling. - Generations
Sql runtimeand (mysqlorpostgresorsqlite) - THE DIALECT FACTS A GENERATIONS STORE NEEDS — four words and three renderings, because five statements over five columns is all there is.
- Generations
Store runtime - THE ENGINE SEAM: where one closure’s current pointers live, and what collects what they supersede.
- Graphql
- What a non-
()Graphqlbinding answers: the entity’s wire face, in the two halves a schema has. - Graphql
Filter - “Is any operator set” — the one question every filter answers the same way on every backend, asked through a type parameter.
- Graphql
Input - The input half of a wire face — the types a client writes a query’s arguments in.
- Graphql
Output - The output half of a wire face — the types a client receives a result in.
- Group
runtime - A keyed group’s PARTIAL state: one slot per member, and what a full set becomes.
- Habitat
- A storage TARGET’s kind-level vocabulary: what a declared type’s home in it looks like.
- Habitats
runtime - LAYER TWO, on the DECLARATION — every home this declaration owns, in every target its legs point at, and every corpus of its whose leg pointed at nothing.
- Hydrates
- A record whose rows a HYDRATED read can be served from, and the database one is served out of.
- Id
- A type admissible as a key field — the sealed identity vocabulary.
- IdColumn
- HOW AN ID OVER THIS TYPE REACHES A COLUMN OF
Db— the per-inner dispatch#[derive(ingraph::Id)]’s three storage rows route through. - Identifiable
- What is reached by ONE id: the address itself, borrowed — and copied where the id’s type allows it.
- Implements
- The MEMBERSHIP evidence:
Memberis one ofInterface’s members. - Initialize
runtime - LAYER TWO’s BLOCKING FACE, on the RESOURCE — the factory visitor this mount’s homes are made by.
- Initializes
runtime - THE MODE-DISPATCHED DRIVER — what an emitted launch names once per (declaration × target), whichever face that target wears.
- Intake
runtime - WHERE a node’s input comes from — the capability its intake implements.
- Join
engine - Where each root already sits in the fold’s accumulator — the join’s one moving part.
- Joins
runtime - How a member of a keyed group states the key it JOINS ON.
- Journal
Row runtime - How a journal row is BUILT — the whole of what the framework says about the row’s shape.
- KeySegments
- How a key walks its fields into
Segments— the fs backend’s own key requirement. - Lands
runtime AsyncLands’ BLOCKING twin — the write socket a sync body reaches for.- Lane
Router - ONE QUESTION IN, ONE PROBE PER LANE OUT — the crossing a fanned corpus is asked through.
- Laned
Store - WHAT ONE LANE OF THIS SLOT IS ASKED WITH — the probe type a router wired to it must produce.
- Lanes
- WHAT PARTITIONS ONE SLOT HOLDS — the neutral layer’s whole knowledge of a fan.
- Ledger
runtime - A node’s OWN control store — where its completion rows land when it has no durable position to land them with.
- Lifecycle
Tap runtime - The OPEN observation seam: everything that happens to an item, offered to whoever asked.
- List
Filter Marker - What guards a column whose type is read as an ORDERED collection.
- Lived
runtime - ONE DOOR FOR TWO FACES: whatever a declaration’s
Modeselected — opened from its options, and driven to its ending on the calling thread. - Local
FsBlob Record - A record storable through this backend: its key walks into path segments.
- Locate
- Resolve a blob’s ADDRESS without reading it, on THIS THREAD —
AsyncLocate’s blocking twin. - Marker
- What a marker MARKS — the type it is an interpretation OF.
- Measure
- WHAT FILLS ONE MEASURE COLUMN — the contract a declared aggregate’s fold satisfies.
- Memory
Probe runtime - WHERE A MEMORY READING COMES FROM — the open seam under
MemoryAware. - Mount
runtime - WHAT ONE LINE OF A GRAPH ROOT’S LAUNCH DOES, at the cell the node’s own words selected.
- Multiplicity
- HOW MANY embeddings one election names — a CLOSED type-level vocabulary of two.
- Mutation
runtime - ONE EXCHANGE: what a single field of a mutation node IS — a request in, a response out, and a failure that may come back instead.
- Mutation
Node runtime - THE COMMAND FACE of a source: the node whose fields are the vocabulary an app can say to it.
- NoDefault
Options runtime - The arm taken where
O: Defaultdoes NOT hold — one autoref away fromBareOptions::resolve, which is what makes it the fallback rather than an ambiguity. - Nullable
Face async-graphql - The DELEGATION TRAIT a nullable column’s wire face is written over — the seam a downstream
filter joins
Nullable<F>through, since neither side can write the impl itself — and the SHORTHAND LAW’s own reading, which every filter face in every crate answers by asking it. - OneReference
- A
Related::Fieldswith exactly ONE member — what a reverse position’s shorthand requires. - Onward
runtime - Where an arm’s answer GOES: on to the next hop, or back to the caller.
- Operator
runtime - A compute unit: turns the messages it is DELIVERED into the ones it produces.
- Optional
- A field that may hold one value, handed out as
Option<&T>rather than&Option<T>— the shape a caller can use without a second step. - Order
Leaves - The VALUES this type’s order levels compare — the per-leaf vocabulary a citizen publishes
beside
ORDER, and the third of the three facts a composite states about itself. - Overflow
Policy runtime - A FULL BOUNDED EDGE: block, or shed.
- Policy
Shelf runtime - WHAT A PER-NODE POLICIES BLOCK IS, whoever emitted it.
- Position
Key runtime - A key a position map can hold — stated once, so the loop’s bound reads as one word.
- Positions
runtime - The CONTROL STORE: where a node got to, and the journal rows that must land with it.
- Product
Kind runtime - One node’s product vocabulary: a closed set of identities, ordered as the declaration wrote them.
- Products
runtime - A node’s product FAMILY: the emitted
<Node>Outenum, and the vocabulary naming its arms. - Quantified
Filter Marker - What guards a column whose type is read as a collection asked ONLY through quantifiers.
- Query
Expander engine - A QUESTION, WIDENED — the blocking face, and the ergonomic half of the pair.
- Radian
Math - The width
Radians::to_degreesandRadians::from_degreesneed —f32’s andf64’s ownto_degrees/to_radians, lifted into a trait because both are INHERENT methods on their widths and no trait incorenames either, so an unboundedTcannot spell them at all. See the module’s own note for the census that found no pre-existing bound to reuse instead. - Ranked
Stream engine - WHAT A FANNED TOWER’S TAIL ANSWERS, and the seat the mouth reads its two parameters off.
- Receipts
runtime - WHAT THIS MESSAGE’S RECEIPT IS — the type a consumer hands back for one item of it, declared once by the message that is GIVEN.
- Record
- What a non-
()Recordbinding answers, PER BACKEND: the shape a predicate over this row takes inB. - Reference
- ONE
reffield, as a type — a member ofRelated::Fields. - Related
- WHICH of
Self’s fields point atTarget— the one relation fact no projection can answer. - Repeated
- A field holding many values of one item type, handed out as a slice.
- Resource
Visitor runtime - A visitor applied once per resource a deployment declares — the RESOURCE half of the walk.
- Retired
Ledger runtime - WHERE A RETIREMENT’S OWN DURABLE ACT GOES — the seat.
- Retired
Sql runtimeand (mysqlorpostgresorsqlite) - THE DIALECT FACTS A LEDGER NEEDS — four, and no more, because four statements is all there is.
- Retired
Store runtime - THE ENGINE SEAM: where one root family’s retirement rows actually live.
- Retry
Policy runtime - WHAT A FAILED ITEM EARNS — attached at
Station::is_settled, which is where the runtime already asks whether an item is done. - Rings
runtime - Something a sweep can ring: a coalescing wake-up with no payload.
- RootKey
runtime - THE BOUND A ROOT FAMILY’S KEY MEETS, wearing a name.
- Runs
runtime - THE AUTONOMOUS ROW of the face table: what one node’s whole life IS, at each of the two faces.
- Scalar
Filter Marker - What guards a column whose type is read as a NUMBER.
- Scalar
Wire - What a SCALAR filter’s operands cross the wire as, and the name that filter is published under —
TextWire’s twin at the ORDERING family, with the same seat and the same law. - Score
Kind - THE SCORE CAPABILITY — what a
ConfidenceFilterguards, and the axis the confidence family widens along. - Search
Options Face async-graphqlandengine - THE ONE DEMAND A DRESSED RECIPE MAKES OF A BOUND TOWER’S REQUEST FACE — that it can be asked for through a schema.
- Search
Tower engine - WHAT A TOWER IS ASKED, WHAT IT ANSWERS, AND WHERE ITS STEPS LIVE.
- Searchable
- THE IDENTITY ROAD: a value that is ALREADY the document text.
- Seats
runtime - What a node’s LENDING does when one of its clocks comes due: SEAT the operator at that clock, and run the entry seated there.
- Seen
engine - A membership over the keys already admitted — the dedup stage’s one moving part.
- Segment
- How one
Idmember becomes one path segment. - Selects
runtime - Which mode a
Wordnames. Implemented for the two words and by nothing else — the vocabulary is closed because the axis has exactly two ends. - Serve
runtime - What a server IS, under either face — and the one seat its KNOBS sit in.
- Serves
runtime - Answer a question — the read path’s capability seam.
- SetFilter
Marker - What guards a column whose type is read as an UNORDERED collection.
- Shared
Question engine - WHAT ONE BROADCAST BECOMES, at a seat — the crossing a recipe’s
shared(…)seat takes to reach one member’s question. - Sink
runtime - WHERE a node’s outputs go: the capability its out-edges implement, one impl per product.
- Skip
Label runtime - An operator’s OWN skip vocabulary, made round-trippable across the erased tap boundary.
- Slot
- ONE SLOT of a declaration: an elected field, and the engine that holds it.
- Slot
Face async-graphql - The DELEGATION TRAIT a nullable column’s wire face is written over — the seam a downstream
filter joins
Nullable<F>through, since neither side can write the impl itself — and the SHORTHAND LAW’s own reading, which every filter face in every crate answers by asking it. - Socket
runtime - ONE OF A NODE’S OUT-EDGES, AS THE LAUNCH HOLDS IT — the erased seat a downstream set takes its sending half out of.
- Sole
Product runtime - A node that emits exactly ONE product — the audit an unselected subscription discharges.
- SortKey
- The ORDER-PRESERVING bytes one value of a collection element contributes.
- Source
runtime - AN ORIGIN, on the BLOCKING face — a scanning walk, a blocking socket loop, a directory watcher whose library calls block.
- Spawn
runtime - WHERE A DETACHED BLOCKING TICK RUNS: the open executor seam behind the
spawnandrayonwords. - SqlSource
async-graphqlandsqlx - WHERE a read runs — the seam an application answers with its own pool.
- State
- What
Selfprojects to under the stateS. - Stored
As - The word ONE dialect’s DDL declares this storage type with — one per LEAF COLUMN.
- Stream
Operator runtime - A compute unit whose ONE DELIVERY IS A WHOLE LIFE: it streams its outputs through a bounded
Feedas it produces them, for as long as that delivery lasts. - Streams
runtime - THE STREAMING ROW of the two-face table: what one delivery’s life IS, at each of the two faces.
- String
Filter Marker - What guards a column whose type is read as TEXT.
- Text
Wire - What a TEXT filter’s operands cross the wire as, and the name that filter is published under.
- Textual
Question engine - WHAT A TEXT-CLASS EXPANDER NEEDS OF A QUESTION, and the whole of it.
- Tick
runtime AsyncTick’s BLOCKING twin — what ablock,spawnorrayonentry’s mount implements.- Tick
Policy runtime - THE MISSED-TICK POSTURE: what a node does when its clock ran late.
- ToCrossed
Order By - The level sequence an emitted order SPENDS on one column, reached without naming a numbering — the map above refined to the two questions a lowering actually asks it.
- ToDatabase
Order By - An INTERPRETATION mapped to the LEVEL SEQUENCE one wire term over it sorts by, at one backend.
- ToError
Code - The code one typed refusal announces itself under.
- ToGraphql
Filter - An INTERPRETATION mapped to the filter types that guard a column read under it. Bound-free — a backend lowering capability is required only where a query is lowered.
- ToGraphql
Input - What ONE operand of this type crosses the wire as — the INPUT twin of
ToGraphqlOutput, and the bound the collection faces ask of their element. - ToGraphql
Output - What a wire face RETURNS a value as — keyed on the value’s own type, or on the MARKER that states a reading the type cannot state for itself.
- ToOrder
Leaves - An INTERPRETATION mapped to the VALUE one of its order LEVELS compares.
- ToSubject
Path - The subject an ordering TERM names — implemented by every emitted
<T>OrderBy. - Transformer
- An ENTITY’s set, bound to the entity type: the id it is REACHED by, on
Identifiablebelow, the full key and the ancestor half it is HANDED BACK under, and the row form it becomes. - TryFrom
Graphql Order By - The fallible crossing: build a database’s level sequence from a completed wire order, expanding each term.
- TryMap
Filter - A kind’s operand map, reached where the KIND ITSELF is a parameter.
- TryShared
Question engine - THE FALLIBLE TWIN of
SharedQuestion— the crossing ashared(try)arm demands, and the ONE face a door consumes. - Type
Visitor - A visitor applied once per node the graph declares.
- Vector
Engine - A vector index (Lance, pgvector, a
vec0virtual table) — R-FREE, exactly asFulltextEngineis, and for the same three reasons: an orphan wall an engine-specific key trait could not avoid, a method-levelwherean expansion could not satisfy, and an inference burden every call carried. - Vector
Mount - A resource a VECTOR election reads through —
FulltextMount’s twin, one family over. - Vector
Read - The vector family’s READ half, answered SYNCHRONOUSLY —
knnandget, and the lease both of them spend. - Vector
Record - A vector-index entry: its embedding.
- Vector
Store - Construction for a vector store whose OPENING is a blocking act —
AsyncVectorStore’s twin, and the narrowest shape a store pair takes: it differs in exactly one verb. - Vector
Write - The vector family’s WRITE half, answered SYNCHRONOUSLY — the keyed replace, and the two seats only a write spends.
- Walk
Clock engine - THE DEPLOYMENT’S OWN TIMER — what turns a number into a wall.
- Wire
Root async-graphqlandengine - WHAT A RECIPE’S ROOT IS ON THE WIRE — the address a client reads, and the row that address points at.
- Wire
Score async-graphql - A SCORE that can be rendered: it crosses through
ToGraphqlOutput, and the form it crosses to is one async-graphql can put on a wire.
Functions§
- ack_
channel runtime - One delivery’s oneshot.
- arm
runtime - ONE arm of a
select: park oninboxunless it has already hung up, wrapping what arrives. - artifact_
store async-graphql - The store an artifact family’s addresses resolve against, out of the request’s own context.
- asked
engine - The question ONE ROUTE is asked, by the ruled precedence: the route’s own > this tier’s > the parent’s.
- assembled
sqlx - The value a field named
fieldholds — the ONE spelling a decode writes per field, and the read half ofshape. - assembled_
flattened sqlx - The same field with its NAME dropped —
<db>(flatten), the read half offlattened. - blob_
address - Render a resolved blob path to its ADDRESS — the text component of a location.
- channel
runtime - A bounded data edge of
capacitymessages. - collection_
sort_ key elements’ order-preserving bytes — the value asortablecollection’s companion column holds.- control
runtime - Mint one source’s control line of
capacity: the app’sCommandsand the source’sControl. - current_
filter runtimeand (mysqlorpostgresorsqlite) - THE READ-PLAN’S OWN HALF: the predicate that holds a generational table to its current generation.
- derived
- A column the WRITE computes —
record(derived(column = "…", from = "…", type = "…")), the mirror image ofrecord(skip). - describes
- Whether
table’s columns are exactly whatcolumnsnames, in order — the audit a descriptor states against the row it describes. - distinct
- Whether the
atth FIELD ofshapesrenders its columns under names no other column of the row has already taken. - door
runtime - A transient edge of
capacityqueries. - doorbell
runtime - One doorbell: the ringing half and the listening half.
- drive_
awaited_ origin runtime - Drive an AWAITED origin to its ending, PINNED on the calling thread.
- drive_
origin runtime - Drive a BLOCKING origin to its ending on the calling thread —
Source::run, named. - elects_
a_ set - The
list(embedding)label’s audit —elects_one’s twin. - elects_
one - The
embeddinglabel’s audit, as a function an expansion takes the address of. - feed
runtime - Mint one source’s LOOSE feed line of
capacity: the source’sFeedand the framework’sYielded. - filled
engine - The FILL LOOP: ranked keys in, ranked entities out, one composed query per batch.
- flattened
- The same field with its NAME dropped —
<db>(flatten), which lays a composite’s columns out in the holder’s own namespace:num/denwhereshapegivestb_num/tb_den. - folded_
filled engine - The FILL LOOP AT THE SET GRAIN:
filledover aFoldedanswer instead of aRankedone. - folded_
matches async-graphqlandengine - A whole folded answer, crossed.
- fuse
engine - Fuse the members’ lists into one ranked answer.
- fuse_
fanned engine - THE FOLD AT THE MOUTH — a fan’s whole grid in, one ranked answer out.
- fuse_
weighted engine fusewith a WEIGHT on every member — the edge factRoute::weightcarries, spent.- has_
a_ wire_ face - The WIRE-FACE tie, as a bound an expansion instantiates: a member has one.
- ids_
are_ keys - THE FIVE BOUNDS AN ID OWES, as a bound an expansion instantiates: an id can be a KEY.
- implements
- The membership tie, as a bound an expansion instantiates:
Memberreally is one. - installed_
fold async-graphqlandengine - THE FOLD one emitted set resolver runs under, or
Nonewhere the deployment installed none. - installed_
keeper async-graphqlandengine - THE KEEPER A PAGED FIELD READS, or the line a deployment is missing.
- installed_
road async-graphqlandengine - THE ROAD ONE QUESTION WALKS — an exclusive set of steps minted for this read, beside the knobs the deployment named and the budget it may take.
- joins
- Whether
nameis whatpathjoins to — the comparison aconstaudit makes instead of building the joined string. - journal_
queue runtime - A queue of
capacityrows and the draining end of it. - keyed
engine - Read every FULL-TEXT hit’s ADDRESS back into
K— the emission’s half of the read, written once. - lane_
catch_ all_ repeats - THE COMPILE-TIME HALF OF
lane_collisions’ CATCH-ALL RULE — whether a lane BEFOREatalready declared it. - lane_
claim - THE WORD AT FLAT POSITION
at, AND THE LANE THAT CLAIMS IT — keys and aliases in declaration order, each lane’s key before its own aliases. - lane_
claim_ repeats - THE COMPILE-TIME HALF OF
lane_collisions’ WORD RULE — whether the word at flat positionatwas already claimed by an EARLIER position. - lane_
claims - HOW MANY WORDS A ROSTER CLAIMS — one per key and one per alias.
- lane_
collisions - TWO LANES CANNOT CLAIM ONE WORD — the roster’s own audit, public so a deployment may spend it where it likes.
- lane_
for - THE GATE — one tag in, one lane out, and it is the only road to a lane there is.
- leaf_
names - Whether
namesis exactly the columnssegmentsrenders, in order — the audit a FLAT restatement of a composite’s parts is held against. - leaf_
shape - The
leaf-th LEAF ofshapes, orNonewhere the tree has none at that index. - locate_
artifact async-graphql - THE WHOLE OF WHAT AN EMITTED LOCATE FIELD DOES — the door lookup, the suffix, and the address.
- locate_
signed_ artifact async-graphql - THE SIGNED WALK —
locate_artifact, and then the author’s own word spent on what came back. - matches
async-graphqlandengine - A whole ranked answer, crossed.
- one_
field_ points_ back - The reverse shorthand’s audit, as a bound an expansion instantiates:
Sourcepoints back atTargetthrough exactly one field. - open
runtime - A data edge opened at
spec— the door a RESOLVED declaration comes through. - owner_
best engine - ONE query vector’s
bⱼ: the engine’s hits for it, collapsed to the best score per OWNER. - owner_
best_ excluding engine owner_bestwith ONE OWNER ALREADY SEEN — the collapse a fuse-BY-EXAMPLE runs, where the example must not answer its own question.- participates
engine - Whether a route ENTERS its parent’s fold: it is walked, and it has a question to walk with.
- plain_
column sqlx - ONE column, fetched by name — the SCALAR answer, and the body every plain row shares.
- prepare
runtime - THE BOOT ROAD: the pointer table exists, and this is how many closures it is already pointing for.
- push_
collection_ sort_ key collection_sort_key, appending to a buffer a caller already holds.- push_
escaped - Append
bytesin the ESCAPED form a variable-width element takes: every0x00doubled up with0xFF, and a0x00 0x01terminator no body can spell. - ranked_
keys engine - The pipeline, in its ruled order: engine → floor → dedup → rank → tier A.
- ranked_
keys_ excluding engine - The walk above with ONE KEY ALREADY SEEN — the similar-by-example door’s self exclusion, and it is the DEDUP STAGE rather than a filter beside it.
- read_
artifact async-graphql - THE WHOLE OF WHAT AN EMITTED DATA FIELD DOES — the door lookup, the suffix, the read, and the encoding.
- read_
member - The next member out of
rest, advancing it past the bytes that member owned — orNonewhere the frame ends inside the length, inside the payload, or inside the member’s own reading. - read_
signed_ artifact async-graphql - THE SIGNED READ —
read_artifact, and then the author’s own word spent on what came back. - rebuild
runtime - THE BOOT ROAD: the ledger is the truth, so a starting deployment reads it and states what it says.
- refers_
through - Whether
columnsholdsfield— the reverse FULL form’s audit, in aconst. - refers_
to - The forward id equation, as a bound an expansion instantiates: a
reffield carries the target’s ID. - refused
async-graphql - The wire form of a typed refusal: its own sentence, and its code in
extensions. - refused_
address async-graphql - The wire form of a refusal raised by the ADDRESS crossing — an id a client wrote that this
record’s own
ToGraphqlInputrow will not read. - refused_
filter async-graphql - The wire form of a refusal raised by the FILTER crossing — an operand a client wrote that this record’s own crossing into the store’s comparison will not take.
- refused_
input async-graphql - The same, for a refusal raised while DECODING an argument.
- refused_
row async-graphql - The wire form of a refusal raised by the WIRE CROSSING — a stored row that will not become its output object.
- reply
runtime - One query’s reply oneshot.
- round_
trip_ fulltext - CONFORMANCE FOR A FULL-TEXT ENGINE —
round_trip_vector’s twin, and the same walk one seam over. - round_
trip_ vector - CONFORMANCE FOR A VECTOR ENGINE — one key, both legs.
- route_
depth engine - The DEPTH one route is fetched at: the ask, capped by the wall —
min(depth.unwrap_or(limit), declared_ceiling). - script_
runs - CUT
textINTO SCRIPT RUNS — the one implementation both sides of a fan call. - search_
slot async-graphqlandruntime - THE FULL-TEXT CORPUS one emitted resolver reads through — the branded handle, and the manager it reaches back through.
- sent
async-graphql - The DELEGATION TRAIT a nullable column’s wire face is written over — the seam a downstream
filter joins
Nullable<F>through, since neither side can write the impl itself — and the SHORTHAND LAW’s own reading, which every filter face in every crate answers by asking it. - set_
scored engine - THE FOLD:
mlists of per-query bests in, oneFoldedper ENTITY out, ranked and cut tolimit. - shape
- The shape a field named
fieldand typedTcontributes — the ONE spelling an emission writes per column. - shutdown_
signal runtime - Mint one source’s stop line: the framework’s
Stopperand the source’sShutdownSignal. - spans
- Whether a type’s word count matches the width its shape claims — the two
consts held against each other. - stored_
column - The ONE column of
columnsnamedfield— the name THIS DATABASE stores it under, read off a row’s own published shapes. - stores_
rows - The v1 MEMBERSHIP FENCE, as a bound an expansion instantiates: a member is a STORED record.
- subscribe
runtime - Declare an edge
upstream → downstream. - tightened_
budget engine - THE BUDGET A WIRE REQUEST RUNS UNDER: the ask, TIGHTENED by the deployment’s —
min(request, deployment), with an absent side unbounded. - value_
width - How many of the columns
shapesnames are part of the VALUE —widthcounting only the leavesColumnShape::holds_valueadmits. - vector_
addressed engine - Report
keyinto a FRESH buffer ofE’s own and seal it — the walk above run BACKWARDS, and the emission’s half of the by-key read. - vector_
keyed engine - Read every VECTOR hit’s ADDRESS back into
K—keyed’s twin, and the SAME walk one seam over. - vector_
slot async-graphqlandruntime - THE VECTOR CORPUS one emitted resolver reads through —
search_slot’s twin, one family over. - walk_
within engine - THE ENFORCEMENT POINT — one awaited walk, raced against the budget two tiers composed.
- width
- How many columns
shapesnames in total —ColumnShape::widthover a whole list. - write_
member - ONE value of several sharing a buffer, behind its own four-byte big-endian length.
Type Aliases§
- Autonomous
Body runtime - WHAT
Wiring::autonomousHANDS OVER FOR ONE AUTONOMOUS NODE: the wheel with its three seats filled, the far half of its stop line, and the shutdown enrolment. - Batch
Answer - What a batched answer arrives as — the one-key future a
BatchDoorhands back. - Boxed
Error runtime - An error whose type this crate cannot name.
- Cell
runtime - THE CELL
N’s OWN DECLARATION NAMES, as one word —Wornwith both seats read off the node. - Connection
async-graphql - One page of
N, resumed by the engine’s own keyset cursor. - Declared
Resident runtime - THE RESIDENT A DECLARED BUFFERED NODE IS WIRED INTO — every seat filled from the plan and from the node’s own facts, and nothing left for a caller to name but the lane.
- Died
runtime - What a refused OPENING and a death are both reported as — one currency, per
Source::Error, so the launch’s construction refusal and its taps name the same type. - Fulltext
Scope runtime - The per-call scope a full-text ask carries: the connection borrow — off the BASE — bundled with
whatever the READ FACE’s
ReadContextGAT resolved to. - Goodbye
runtime - A goodbye IN FLIGHT, driven where it was made.
- Hits
- A search’s whole answer: its hits, ordered as the engine ranked them.
- Installed
Road async-graphqlandengine - WHAT ONE LOOKUP HANDS BACK — the steps minted for this read, the knobs they run under, and the wall they run inside.
- Landing
runtime - THE FUTURE A STORE’S VERB HANDS BACK — one act, landing.
- Mount
Body runtime - What
Wiring::lane_mounthands over for one streaming node: the ACT of building its lane, and the shutdown enrolment that pairs with it. - Mounted
Lane runtime - EVERYTHING THE PARTY THAT DRIVES A MOUNTED LANE IS HANDED: the lane, the inbox its declared upstreams fill, and the shutdown enrolment.
- Node
Attribution runtime - THE PROJECTION A BUFFERED NODE ATTRIBUTES ITS OUTPUTS THROUGH — its own
Declared::Attributionseat, at the product its driven face states. - Node
Body runtime - What
Wiring::residenthands over for ONE node: the body that will run it, and the shutdown enrolment that pairs with it. - Ordered
runtime - What it is TOLD, the same way.
- Payload
Filter - The filter a payload of type
Tis guarded by, resolved the way the FRAMEWORK resolves one: throughT’s ownDefaultMarkerand that marker’sToGraphqlFilterrow. - Posted
runtime - A goodbye that TRAVELS — the one the settle seat carries back to the chain.
- Produced
runtime - What an origin of type
SPRODUCES, through the row its declaration named — the projection every door here spells, written once so a signature does not have to. - Receipt
Map runtime - THE PER-ITEM RECEIPTS ONE ACK CARRIES — absent unless a consumer actually stated one.
- Score
- A confidence measured in
f32, under the name this crate spent on it before the width was a parameter. - Selected
runtime - The mode a declared
SYNCnames — what a launch predicate is spelled through. - Settled
Parts runtime - The five halves of a
Settled, asinto_partshands them over: the released set, the worker’s name, the observation, a fate’s extra message, and the consumer’s own receipts. - Stream
Body runtime - What
Wiring::lanehands over for one STREAMING node: the lane that will drive it, and the shutdown enrolment that pairs with it. - Stream
Wires runtime - THE SET A STREAMING NODE PUBLISHES THROUGH — its own
Declared::Wiresseat, at the product its streaming face states. - Tuned
runtime - What OPENING an origin of type
Stakes, through the row its declaration named — its author’s ownSource::Options, and the type an emitted[<mount>]section holds. - Turning
runtime - THE FUTURE A STORE’S VERB HANDS BACK — one act, turning.
- Utf8
Bytes - The SLOT NAME’s transport type, re-exported because the per-slot factories already name it.
- Vector
Scope runtime FulltextScope’s twin on the vector face — the connection off the BASE and the lease off the READ FACE, exactly as above.
Attribute Macros§
- aggregate
derive - Declare an AGGREGATE — a record whose rows are a declared FOLD over one upstream’s rows, one row per group, recomputed WHOLE on every trigger.
- blob
derive - Declare an ARTIFACT FAMILY derived from another node’s messages — an operator holding one stored object per message it saw.
- entity
derive - Declare an ENTITY — an identity-bearing node with a wire face and NO rows.
- fields
derive - Declare a FIELD FRAGMENT — a group of fields several declarations hold, written once.
- flags
derive - Declare a FLAGS SET — a closed vocabulary of BITS a column holds a SUBSET of.
- fulltext
derive - Declare a FULL-TEXT INDEX over another node’s messages — an operator holding one document per message it saw, searchable by text.
- graph
derive - Declare a GRAPH ROOT — the struct whose fields are an application’s nodes.
- interface
derive - Declare an INTERFACE — a member set with a contract over it.
- journal
derive - Mount a JOURNAL — the canonical record of how far each content ROOT got through each node.
- mutation
derive - Declare a SOURCE’s COMMAND FACE — the vocabulary an application can say to one running origin.
- mutation_
error derive - Dress an application’s own failure type to RENDER — a declared exchange’s error, given a code and a sentence.
- operator
derive - Declare an OPERATOR — a graph node that subscribes, computes, emits, and owns NO storage.
- query_
error derive - [
mutation_error] for the READ path — the same skeleton, over an author’s own query failure. - record
derive - Declare a RECORD — an entity holding rows, in the databases its STORE WORDS name.
- resource
derive - Declare a SHAREABLE RESOURCE — a type several units may hold at once.
- search
derive - Declare a SEARCH RECIPE — the members one question is asked across, and the towers that turn it into what each of them can be asked with.
- source
derive - Declare an ORIGIN — and hold its
mutationword and itstype Mutationseat to each other. - tower
derive - Declare a QUESTION PIPELINE — the steps between what a person asked and what an index can be asked with.
- vector
derive - Declare an EMBEDDING INDEX over another node’s messages — an operator holding one document per message it saw, searchable by nearness.
Derive Macros§
- Comparison
derive - Give a HAND-WRITTEN struct the COMPARISON face — one predicate type per database it names, each field the comparison its column’s filter crosses into.
- Enum
derive - Equip a VOCABULARY — a unit-variant enum — with the WHOLE citizenship: the faces a column of it needs, and the face a schema needs.
- Filter
derive - Give a HAND-WRITTEN struct the FILTER face a record’s declaration gets — a predicate over its fields, each field its type’s filter.
- Id
derive - Equip an ID WRAPPER — a
#[repr(transparent)]type holding one value — with the whole register an address needs. - NewType
derive - Equip a NEWTYPE — a type this crate declares that wraps ONE value — with the faces it names.
- OrderBy
derive - Give a HAND-WRITTEN struct the ORDER-BY face — one term per field, each carrying the direction it runs in, plus the two questions every term answers.
- Union
derive - Equip a DECLARED UNION — an enum whose every variant carries one member type.