Crate thread_engine 

Loom — the embeddable engine for the Thread

Loom is to the Thread what a rendering engine (Chromium) is to a browser (Chrome): the reusable, renderer-agnostic core that any Thread browser can build on. Infinite is the reference browser — winit + wgpu + egui — but it holds no monopoly: everything a browser needs to reach, parse, and stay present in worlds lives here, behind a rendering seam, so a second browser (a different renderer, a different UI, an embedded view) can be built without re-implementing the network core.

What Loom owns (all renderer-agnostic):

• resolver — Locator → world manifest (“DNS”): registry → the host’s own .well-known/thread → local file. This is what lets anyone host a world on their domain with zero contact.
• navigator — veilwalking: the renderer-agnostic navigation state machine (which world is active, when to step through a veil, what’s in focus), driving a renderer through the navigator::WorldLoader seam.
• engine — Loom, the one-call facade that owns your loader and reduces a whole browser to new + open + update each frame.
• [walk] — scripted walks: drive the engine through a recorded path over a corpus (headless) and report where it landed — the engine as its own oracle.
• bookmarks — kept places (a personal constellation), persisted as one human-readable JSON file.
• home — the home-space (thread://home): a local world the traveler owns, seeded on first launch, where bookmarks materialize as veils and build mode persists blocks.
• mesh — Tier-1 serverless P2P presence: a transport-agnostic mesh coordinator so small worlds are shared with no relay at all.
• codex — canonical-meaning lookups against the live Codex.
• commerce — server-authoritative purchases (commerce.buy → the Thread’s purchase endpoint) and entitlement reads, Passport-bearer signed.
• passport — the traveler’s held identity (token + fetched descriptor), presented on presence join and portal handoff, never persisted by hosts.
• directory — the worlds directory (discovery / jump-to).
• web — the in-world reader for the old 2D web (transclusion), so visitors never have to leave the Thread.
• presence — the presence relay client (WebSocket), feeding traveler::PresenceState.

What Loom deliberately does not own: windowing, the GPU, meshes, the HUD. Those belong to the browser. The world runtime (physics, chunks, player, camera, actors) lives in the host application, and the world format in infinite_manifest; Loom re-exports both so an embedder depends on one crate.

Re-exports

pub use traveler::Instance;

pub use traveler::PoseSample;

pub use traveler::PresenceState;

pub use traveler::TravelerPose;

pub use assets::AssetSource;

pub use behavior::Action;

pub use behavior::ActionList;

pub use behavior::Behavior;

pub use behavior::InteractEvent;

pub use bookmarks::Bookmark;

pub use bookmarks::Bookmarks;

pub use codex::CodexClient;

pub use commerce::CommerceClient;

pub use directory::Directory;

pub use engine::Loom;

pub use mesh::MeshCoordinator;

pub use mesh::MeshEvent;

pub use mesh::MeshPose;

pub use mesh::MeshTransport;

pub use mesh::Signal;

pub use navigator::Focus;

pub use navigator::Navigator;

pub use navigator::WorldLoader;

pub use passport::Passport;

pub use presence::PresenceClient;

pub use resolver::fetch_world;

pub use resolver::TravelResult;

pub use walk::walk;

pub use walk::Script;

pub use walk::Step;

pub use walk::WalkOutcome;

pub use web::WebReader;

pub use glam;

pub use infinite_avatar;

pub use infinite_manifest;

Modules

assets

Asset resolution — turn a World Manifest asset URI into a readable local file, fetching remote ones into an on-disk cache.

behavior

Behavior ABI — the sandboxed interactivity layer (behavior-abi-v0.1).

behavior_weft

Weft behaviors — the Thread’s native code, running beside the WASM floor (weft-v0.1 · behavior-abi-v0.1).

bookmarks

Bookmarks — a traveler’s personal constellation.

codex

In-world Codex reader — the “inspect” side of the Thread.

commerce

In-world commerce — the “buy” side of the Thread.

directory

The worlds directory — a “jump anywhere” list of places on the Thread.

engine

The one-call embedder facade: Loom.

home

The home-space — the browser’s about:home, except it’s a world you own.

host

The embedded room host — a browser hosting a place itself.

mesh

Tier 1 presence — the serverless P2P mesh (presence-topology-v0.1 §3).

navigator

Veilwalking — the navigation state machine of the Thread, renderer-agnostic.

passport

The traveler’s Passport — one portable identity across the Thread.

presence

Presence relay client — the live transport for shared worlds.

recents

Recents — the threads a traveler last walked.

resolver

Locator resolution — the Thread’s “DNS”, network-first with a local fallback.

traveler

Travelers — the people sharing a world, and where they are now.

walk

Scripted walks — the engine as its own conformance oracle.

web

In-world web reader — the old web, inside the Thread.