Enum Doc 

pub enum Doc {
    Json(JsonAdapter),
    Csv(CsvAdapter),
    Xml(XmlAdapter),
    Html(HtmlAdapter),
    Text(TextModel),
    Sqlite(SqliteAdapter),
    Fs(FsAdapter),
    FsDeep(ComposeAdapter<FsAdapter>),
    Git(GitAdapter),
    Archive(ComposeAdapter<ArchiveAdapter>),
    ArchiveRaw(ArchiveAdapter),
    Xlsx(XlsxAdapter),
    Syntax(TreeSitterAdapter),
    Code(CodeModel),
    Mount(MountAdapter),
    Boxed(Dyn, Box<dyn Fn(NodeId) -> String>),
}

A materialized source: one variant per adapter family. JSON-model formats (json/yaml/toml) render node results as pointers, the rest as locators.

Variants

Json(JsonAdapter)

Csv(CsvAdapter)

Xml(XmlAdapter)

Html(HtmlAdapter)

Text(TextModel)

Sqlite(SqliteAdapter)

Fs(FsAdapter)

FsDeep(ComposeAdapter<FsAdapter>)

Git(GitAdapter)

Archive(ComposeAdapter<ArchiveAdapter>)

ArchiveRaw(ArchiveAdapter)

An archive held opaque (no_graft): the member tree with leaves as plain entries — the tar -t view.

Xlsx(XlsxAdapter)

Syntax(TreeSitterAdapter)

Code(CodeModel)

Mount(MountAdapter)

Boxed(Dyn, Box<dyn Fn(NodeId) -> String>)

Any adapter behind the object-safe trait, with its locator renderer — the carrier for scheme targets opened through qua’s dispatch (gcl:, kafka:, neo4j://, …).

Implementations

impl Doc

pub fn parse(input: &str, format: &str) -> Result<Doc>

Parse a text document by format name — the wasm entry point, and the text tail of the native open. Formats: json, yaml, toml, csv, tsv, xml, html, markdown, jsonl/ndjson, kaiv/daiv.

pub fn export( &self, query: &str, now: (i64, u32), allow_shell: bool, kind: &str, ) -> Result<String>

Run query and render its results as exportable markup: md/markdown, html, or txt/text. Node results render structurally through the text vocabulary — sections back to headings, lists to lists — and kinds outside it degrade to prose paragraphs; value results render as lines.

pub fn run_modeled( &self, query: &str, now: (i64, u32), allow_shell: bool, model: &Model, ) -> Result<QueryResult>

Run against a --model-enriched view of this source: the derived containers, references, and edges the model declares, over this Doc’s base. now binds now() for the base and its constructor queries alike.

pub fn render_modeled(&self, node: NodeId, model: &Model) -> String

Render a node from a model-enriched run: /container/value for derived nodes, the base’s own renderer otherwise.

pub fn run( &self, query: &str, now: (i64, u32), allow_shell: bool, ) -> Result<QueryResult>

pub fn render(&self, node: NodeId) -> String

Render a node result as its source-appropriate locator.

pub fn sqlite_bytes(bytes: &[u8]) -> Result<Doc>

Open a SQLite database from its file bytes — a .db that never touched a filesystem (the browser’s uploaded files).

pub fn mount_docs(parts: Vec<(String, Doc)>) -> Result<Doc>

Mount already-built documents as named children of one root — the general wasm-safe mount, for callers that assembled their Docs from text or bytes rather than paths.

pub fn attach_url(&mut self, url: &str)

Declare a source’s own URL on its adapter — today the html DOM reading, whose relative hrefs join against it for the acquisition arrow (::href--> across documents). Other formats ignore it (their cross-references carry no URL yet).

pub fn url_roots(&self, urls: &[(String, String)]) -> HashMap<String, NodeId>

The reference targets for this doc: external-reference identifier (its declared URL) → the root the arrow lands on, for every mounted source that declared one. urls is (mount name, url); on a single-source (path-bare) doc the one root answers.

pub fn mount_texts(parts: &[(String, String, String)]) -> Result<Doc>

Mount several already-parsed text documents as named children of one root — Doc::mount_docs over Doc::parse, for callers that hold text (the browser playground’s paste boxes). parts is (name, format, text).

impl Doc

pub fn open(path: &Path, opts: &Options) -> Result<Doc>

Open one path as a local source. Directories are filesystem trees (--graft grafts parseable leaves); git:PATH opens a repository; binary kinds (SQLite, spreadsheets, archives) and source files dispatch by extension/magic; everything else is a text document parsed by extension or content sniff.

pub fn mount(paths: &[PathBuf], opts: &Options) -> Result<Doc>

Open several sources as named children of one root (file stem = mount name), so a single query — including a <=> join — spans them all.

pub fn mount_specs(specs: &[MountSpec], opts: &Options) -> Result<Doc>

Doc::mount with optional explicit mount names (NAME=TARGET); an unnamed spec mounts under its file stem.