Package-level declarations
Types
An opaque admission gate over warp's free (CoordinationKind.Free) execution path.
A handle returned by AdmissionControl.admit for an admitted task. WarpNode calls settle exactly once when the task completes, so an enforcement adapter can release or charge whatever it reserved at admission time.
Lazy-bobbin exchange over a Seam.
The content address of a bobbin — a warp kernel stored in the local Creel.
A manifest entry: a content-addressed bobbin plus optional variant provenance.
Selects how WarpNode claims the tasks it owns on the consistent-hash ring.
A minimal local runtime that ties a Draft pipeline to a converging IncrementalResult.
A task that requires coordination — it is not safe to apply without a consensus round-trip. This is the escalation path: tasks that are non-idempotent, require strict exactly-once delivery, or whose correctness depends on a globally-agreed ordering must be placed here.
A task or contribution that is safe to apply without coordination — it lives in a join-semilattice, so concurrent applications from any number of peers converge to the same result regardless of order, duplication, or delivery gaps.
Tags each task in the warp queue as either coordination-free or coordinated.
The local rack of loaded bobbins — a content-addressed store keyed by BobbinHash.
One node in a Draft dependency DAG — a DraftStage plus its predecessor edges.
One step in a Draft dataflow graph.
A guest-controlled window [ptr, ptr + len) of WASM linear memory, decoded from a packed warp_run result by unpackWarpResult.
A converging result backed by a join-semilattice — the observation side of monotone (convergent) query execution in :kuilt-warp.
An opaque fair-share lane tag carried on a TaskDescriptor.
A batch of op registrations, installable into an OpRegistry as one unit.
Optimization level of a compiled bobbin variant. Higher wins when several variants exist for the same Target. The spike's fake compiler produced a single level; the durable VariantKey address carries the level so a real optimizer (WasmOptimizer) can publish variants at distinct efforts for the same source.
The identity optimizer: returns bytes unchanged at every level — the OptLevel.O0 (passthrough) semantics.
A snapshot of the current peer roster that feeds the TaskRing.
The unit of work that travels across the fabric — the task-descriptor envelope.
The address of a compiled bobbin variant: which source kernel it was built from, for which Target, at which OptLevel. Recorded as the variantOf provenance on a BobbinMeta so a peer can discover "the compiled-for-my-target version of source S".
The all-or-nothing capability bundle that enables lazy bobbin fetch-and-run.
Ties the warp foundation together over a real Seam.
A CRDT-mergeable statistics map: per-source cardinality sketches gathered as HyperLogLog instances, so they converge when gossiped on the same anti-entropy as the rest of the warp state.
Base class for all WASM-runtime failures.
Thrown by an Op returned from WasmRuntime.load when the WASM module traps or raises an unhandled exception at runtime, or exceeds the sandbox's execution-time budget (WasmSandboxConfig.executionTimeout).
Thrown by WasmRuntime.load when a WASM module cannot be loaded into the sandbox.
Injectable contract for a wasm→wasm optimizer — the transform a compiler node runs on a raw kernel before publishing the result as a gossiped variant.
Injectable contract for a sandboxed WASM execution environment.
Configuration for the sandboxed WASM execution environment.
Functions
The bounds-checked warp-ABI result decode: unpackWarpResult + requireInBounds + one read of the validated window.
Compute the join (least upper bound) of all values in contributions.
Compute the join (least upper bound) of all values in contributions, or null if the list is empty.
Lift a raw Quilted value into the coordination-free path.
Apply transform to this value's state, producing a new CoordinationFree with the transformed state. The caller is responsible for ensuring transform is itself monotone — i.e. that the output lattice's join is preserved under the mapping.
Builds an OpRegistry populated by registrars, installed in the given order.
Validates a guest-controlled window [ptr, ptr + len) against the live linear-memory size, in Long space so no operand can have sign-wrapped.
Returns a Flow of the current peer set derived from Seam.peers, suitable for passing to WarpNode as its rosterFlow.
Returns a Flow of voter PeerIds derived from this RaftNode's current us.tractat.kuilt.raft.ClusterConfig, suitable for passing to WarpNode as its rosterFlow.
Unpacks a warp_run result — (resPtr << 32) | (resLen & 0xFFFF_FFFF) — into its unsigned pointer/length words.
Return a copy of this descriptor requiring affinity at its execution site — the producer-side eligibility tagging step, the sibling of TaskDescriptor.inLane(...). Everything else (op, args, trace, pin, lane) is preserved, so eligibility composes with a lane. This is the shipped .where { } surface: build a TaskDescriptor, tag it with where, and enqueue it on a WarpNode. Placement then hashes over the eligible subset.
Pair this value with other into a LatticeProduct, combining both states into a single coordination-free snapshot.