Start building a capability chain from this subject.

Returns an iterator over all `(name, field)` pairs.

* DID identifier for the underlying database.

Execute this query, returning a stream of claims.

Execute the fork against a provider. The provider (typically the Operator) builds protocol-specific authorization and delegates to the site provider.

Build a test operator and return both the operator and the profile.

Create a test repository using the given operator and profile.

Inserts a cell into this collection, keyed by its name.

Inserts a named field into the schema.

Parse a command string into a Command. # Errors Returns an error if the command string is not valid: - Missing leading slash - Has trailing slash (e

Push a delegation onto the chain (closer to invoker). Its issuer must match the current chain's audience.

Start a transaction on this branch. Use `.assert()` and `.retract()` to accumulate changes, then `.commit().perform(&env)` to apply them.

Opens a batch of in-place edits over this tree. The returned [`TransientTree`] holds the tree's spine in transient form; apply [`insert`](TransientTr

Serializes the edited tree bottom-up into `delta` and returns it as a [`PersistentTree`], carrying the node cache forward. The root is empty (`NULL_BL

Execute the push operation. Push is fast-forward only: - `Ok(Some(revision))` — pushed; upstream now at `revision`. - `Ok(None)` — nothing to push (

Bind a term to a [`Binding::Present`] value. For named variables, stores the value in the bindings map; checks consistency if already bound: - existi

Execute against an operator.

Creates a new delta that contains a copy of this delta's contents.

Returns the [`Blake3Hash`] of this buffer's contents, computing it if necessary.

Build a scope from an effect capability, projecting through Attenuate. Unlike `Scope::from`, this projects effect fields through their [`Attenuate`](

Open the branch, creating it if it doesn't exist.

Execute against the environment.

Returns the branch name of this upstream.

Drains all entries from this delta and returns them as an iterator.

Stores bytes under their content hash, verifying the hash matches.

Returns a name unique within this process, formed as `{prefix}-{ts}-{seq}`. Uses a high-resolution timestamp combined with a process-local counter so

Inserts a key-value pair into the cache.

The catalog (archive index) scoped to this branch's subject.

Returns the handle for this space's memory directory.

Creates an equality constraint between this term and another term. This method creates a `Constraint::Equality` that enforces equality between the tw

Assert a claim into this transaction.

Phase two: advance the branch cells — the head to the merged revision and the sync-base marker to the merged upstream tree. Instant (no network): jus

Create a deterministic test signer from a seed.

Returns the number of fields in the schema.

Create a command to publish a new value to this cell. The CAS precondition is the cache's *current* version at perform time: "overwrite whatever the

Wrap this match into a single-element `Selection` stream.

Generate a new random Ed25519 signer. This is useful for creating space signers in tests.

Get the 'is' (value) parameter.

Serializes this node body to bytes. Returns the serializer's [`AlignedVec`] directly so the alignment that in-place archive access depends on is pres

Begin building a `Coalesce` constraint. Returns a builder that completes when `.is(output)` is called. # Example ```no_run # use dialog_query::Term;

Waits for all queued tasks to complete. Returns `Ok(())` if all tasks completed successfully, or the first error encountered. After `join` returns, t

Returns the hash as a byte slice.

Returns the number of entries currently in this delta.

Get a branch reference for the given name. Call `.open()` or `.load()` on the returned reference.

Resolve a path segment under this space's root.

Execute the query, returning a stream of results. Resolves the operator's identity via [`Identify`], builds the query overlay (caller changes + auto-

Returns a reference to this concept's attributes (required and optional alike). Use [`AttributeDescriptor::is_optional`] to tell them apart.

Import a keypair from seed bytes with the specified extractability.

Begin building a dynamic attribute expression for this attribute and the given entity. Chain with [`.is()`](DynamicAttributeBuilder::is) to complete t

Execute this query, returning a stream of claims.

Extract the contained [`Value`], returning [`EvaluationError::Absent`] if this binding is `Absent`. Use this when the caller cannot tolerate absence,

Deletes a key, mutating the transient tree in place. A missing key is a no-op.

Look up the binding for a term. For named variables, returns the binding (Present or Absent). For constants, returns `Present(value)`. Returns [`Eval

Get a reference to the storage

Get a reference to the compiled tree

Archive capability for this branch's subject.

Get the [`ValueDataType`] that corresponds to this variant of [`Value`]

Look up the inferred type for a variable by name.

Adds a key-value pair to this delta.

Execute the pull operation: [`prepare`](Self::prepare) the merge, then [`commit`](PreparedPull::commit) it. The one-shot form. To hold an exclusive l

Get the audience of the last delegation in the chain (closest to invoker). This is the operator/invoker DID. Since the chain is guaranteed non-empty,

Iterate over `(name, inferred kind)` pairs.

Execute this invocation against a provider.

Produce an ordered execution plan ([`Conjunction`]) for the given scope. Repeatedly selects the cheapest feasible premise until all premises have bee

Get the command from the invocation.

Get the entity of this claim

Builds a tree from this descriptor using the provided storage. Returns a `TreeSpec` containing the built tree and node specifications for asserting r

Look up the multiplicity of an element, defaulting to 0 in cases for as-yet untracked elements.

Open a query over this branch. Returns a [`QueryLayer`] rooted at the branch. Use [`with`](QueryLayer::with) to fold in a [`Statement`]'s changes, [`