@quillmark/quiver 0.1.1 → 0.3.0

package/dist/built-loader.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Built-quiver loader — browser-safe at module level.
+ * Internal; not exported from index.ts.
+ *
+ * Exposes:
+ *   - BuiltTransport interface (implemented by HttpTransport)
+ *   - loadBuiltQuiver(transport) → Quiver
+ *
+ * NO static node: imports — this module is safe to load in browser contexts.
+ */
+import { Quiver } from "./quiver.js";
+/**
+ * Transport abstraction: fetch raw bytes by relative path within the packed
+ * artifact. Sole implementation is HttpTransport (browser + Node).
+ */
+export interface BuiltTransport {
+    fetchBytes(relativePath: string): Promise<Uint8Array>;
+}
+/**
+ * Load a build-output quiver via the given transport.
+ *
+ * 1. Fetches Quiver.json (pointer) and parses it.
+ * 2. Fetches the manifest file it points to and validates it.
+ * 3. Builds a catalog from manifest entries (versions sorted descending).
+ * 4. Returns a Quiver instance backed by a BuiltLoader.
+ */
+export declare function loadBuiltQuiver(transport: BuiltTransport): Promise<Quiver>;

package/dist/built-loader.js

@@ -0,0 +1,232 @@
+/**
+ * Built-quiver loader — browser-safe at module level.
+ * Internal; not exported from index.ts.
+ *
+ * Exposes:
+ *   - BuiltTransport interface (implemented by HttpTransport)
+ *   - loadBuiltQuiver(transport) → Quiver
+ *
+ * NO static node: imports — this module is safe to load in browser contexts.
+ */
+import { QuiverError } from "./errors.js";
+import { unpackFiles } from "./bundle.js";
+import { isCanonicalSemver, compareSemver } from "./semver.js";
+import { Quiver } from "./quiver.js";
+// ─── Path validation ──────────────────────────────────────────────────────────
+const MANIFEST_FILENAME_RE = /^manifest\.[0-9a-f]+\.json$/;
+const BUNDLE_FILENAME_RE = /^[A-Za-z0-9_.-]+@[0-9]+\.[0-9]+\.[0-9]+\.[0-9a-f]+\.zip$/;
+const FONT_HASH_RE = /^[0-9a-f]{32}$/;
+function validateManifestFileName(name) {
+    if (!MANIFEST_FILENAME_RE.test(name)) {
+        throw new QuiverError("quiver_invalid", `Pointer manifest filename is invalid: "${name}"`);
+    }
+}
+function validateBundleFileName(bundle, context) {
+    if (!BUNDLE_FILENAME_RE.test(bundle)) {
+        throw new QuiverError("quiver_invalid", `${context}: bundle filename is invalid: "${bundle}"`);
+    }
+}
+function validateFontHash(hash, context) {
+    if (!FONT_HASH_RE.test(hash)) {
+        throw new QuiverError("quiver_invalid", `${context}: font hash is invalid: "${hash}"`);
+    }
+}
+// ─── BuiltLoader implementation ─────────────────────────────────────────────
+class BuiltLoader {
+    transport;
+    index;
+    /** Font byte cache: hash → in-flight or resolved Promise. */
+    fontCache = new Map();
+    constructor(transport, 
+    /** Index map from "name@version" to its manifest entry. */
+    index) {
+        this.transport = transport;
+        this.index = index;
+    }
+    async loadTree(name, version) {
+        const entry = this.index.get(`${name}@${version}`);
+        // If entry is missing, the outer Quiver.loadTree gate already validated
+        // that this name/version is in the catalog; trust that gate and fall
+        // through. The transport will surface a transport_error naturally.
+        // (Defensive: this should not be reachable in normal operation.)
+        if (!entry) {
+            throw new QuiverError("transport_error", `Quill "${name}@${version}" not found in built-quiver manifest`, { version, ref: `${name}@${version}` });
+        }
+        // 1. Fetch + unpack bundle zip.
+        const zipBytes = await this.transport.fetchBytes(entry.bundle);
+        const files = unpackFiles(zipBytes);
+        // 2. Rehydrate fonts from store (coalesced).
+        const fontEntries = Object.entries(entry.fonts);
+        await Promise.all(fontEntries.map(async ([path, hash]) => {
+            files[path] = await this.fetchFont(hash);
+        }));
+        // 3. Convert to Map.
+        return new Map(Object.entries(files));
+    }
+    /**
+     * Fetch a font by hash from store/<hash>, coalescing concurrent requests for
+     * the same hash into a single fetch. On error, removes the cache entry so
+     * callers can retry.
+     */
+    fetchFont(hash) {
+        let promise = this.fontCache.get(hash);
+        if (!promise) {
+            promise = this.transport
+                .fetchBytes(`store/${hash}`)
+                .catch((err) => {
+                this.fontCache.delete(hash);
+                throw err;
+            });
+            this.fontCache.set(hash, promise);
+        }
+        return promise;
+    }
+}
+// ─── Pointer + manifest validation helpers ────────────────────────────────────
+function assertNoUnknownKeys(obj, allowed, context) {
+    for (const key of Object.keys(obj)) {
+        if (!allowed.includes(key)) {
+            throw new QuiverError("quiver_invalid", `${context}: unknown field "${key}"`);
+        }
+    }
+}
+function parsePointer(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new QuiverError("quiver_invalid", "Quiver.json contains invalid JSON");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new QuiverError("quiver_invalid", "Quiver.json must be a JSON object");
+    }
+    const obj = parsed;
+    assertNoUnknownKeys(obj, ["manifest"], "Quiver.json");
+    if (typeof obj["manifest"] !== "string" || obj["manifest"].length === 0) {
+        throw new QuiverError("quiver_invalid", 'Quiver.json must have a non-empty string "manifest" field');
+    }
+    return obj["manifest"];
+}
+function parseManifest(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new QuiverError("quiver_invalid", "Manifest file contains invalid JSON");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new QuiverError("quiver_invalid", "Manifest must be a JSON object");
+    }
+    const obj = parsed;
+    assertNoUnknownKeys(obj, ["version", "name", "quills"], "manifest");
+    if (obj["version"] !== 1) {
+        throw new QuiverError("quiver_invalid", `Manifest version must be 1, got ${String(obj["version"])}`);
+    }
+    if (typeof obj["name"] !== "string" || obj["name"].length === 0) {
+        throw new QuiverError("quiver_invalid", 'Manifest must have a non-empty string "name" field');
+    }
+    if (!Array.isArray(obj["quills"])) {
+        throw new QuiverError("quiver_invalid", 'Manifest must have a "quills" array');
+    }
+    const quills = [];
+    for (let i = 0; i < obj["quills"].length; i++) {
+        const entry = obj["quills"][i];
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            throw new QuiverError("quiver_invalid", `manifest.quills[${i}] must be an object`);
+        }
+        const e = entry;
+        assertNoUnknownKeys(e, ["name", "version", "bundle", "fonts"], `manifest.quills[${i}]`);
+        if (typeof e["name"] !== "string" || e["name"].length === 0) {
+            throw new QuiverError("quiver_invalid", `manifest.quills[${i}].name must be a non-empty string`);
+        }
+        if (typeof e["version"] !== "string" ||
+            !isCanonicalSemver(e["version"])) {
+            throw new QuiverError("quiver_invalid", `manifest.quills[${i}].version must be canonical semver (x.y.z), got "${String(e["version"])}"`);
+        }
+        if (typeof e["bundle"] !== "string" ||
+            e["bundle"].length === 0) {
+            throw new QuiverError("quiver_invalid", `manifest.quills[${i}].bundle must be a non-empty string`);
+        }
+        validateBundleFileName(e["bundle"], `manifest.quills[${i}].bundle`);
+        if (typeof e["fonts"] !== "object" ||
+            e["fonts"] === null ||
+            Array.isArray(e["fonts"])) {
+            throw new QuiverError("quiver_invalid", `manifest.quills[${i}].fonts must be an object`);
+        }
+        const fonts = e["fonts"];
+        for (const [k, v] of Object.entries(fonts)) {
+            if (typeof v !== "string") {
+                throw new QuiverError("quiver_invalid", `manifest.quills[${i}].fonts["${k}"] must be a string`);
+            }
+            validateFontHash(v, `manifest.quills[${i}].fonts["${k}"]`);
+        }
+        quills.push({
+            name: e["name"],
+            version: e["version"],
+            bundle: e["bundle"],
+            fonts: fonts,
+        });
+    }
+    return {
+        version: 1,
+        name: obj["name"],
+        quills,
+    };
+}
+// ─── Main entry point ─────────────────────────────────────────────────────────
+/**
+ * Load a build-output quiver via the given transport.
+ *
+ * 1. Fetches Quiver.json (pointer) and parses it.
+ * 2. Fetches the manifest file it points to and validates it.
+ * 3. Builds a catalog from manifest entries (versions sorted descending).
+ * 4. Returns a Quiver instance backed by a BuiltLoader.
+ */
+export async function loadBuiltQuiver(transport) {
+    // 1. Fetch and parse pointer.
+    let pointerBytes;
+    try {
+        pointerBytes = await transport.fetchBytes("Quiver.json");
+    }
+    catch (err) {
+        if (err instanceof QuiverError)
+            throw err;
+        throw new QuiverError("transport_error", `Failed to fetch Quiver.json: ${err.message}`, { cause: err });
+    }
+    const manifestFileName = parsePointer(new TextDecoder().decode(pointerBytes));
+    validateManifestFileName(manifestFileName);
+    // 2. Fetch and parse manifest.
+    let manifestBytes;
+    try {
+        manifestBytes = await transport.fetchBytes(manifestFileName);
+    }
+    catch (err) {
+        if (err instanceof QuiverError)
+            throw err;
+        throw new QuiverError("transport_error", `Failed to fetch manifest "${manifestFileName}": ${err.message}`, { cause: err });
+    }
+    const manifest = parseManifest(new TextDecoder().decode(manifestBytes));
+    // 3. Build catalog: name → versions sorted descending.
+    //    Also build index map: "name@version" → entry (with duplicate detection).
+    const catalogRaw = new Map();
+    const index = new Map();
+    for (const entry of manifest.quills) {
+        const key = `${entry.name}@${entry.version}`;
+        if (index.has(key)) {
+            throw new QuiverError("quiver_invalid", `Duplicate quill entry in manifest: "${key}"`);
+        }
+        index.set(key, entry);
+        const versions = catalogRaw.get(entry.name) ?? [];
+        versions.push(entry.version);
+        catalogRaw.set(entry.name, versions);
+    }
+    for (const [, versions] of catalogRaw) {
+        versions.sort((a, b) => compareSemver(b, a));
+    }
+    // 4. Build loader.
+    const loader = new BuiltLoader(transport, index);
+    // 5. Return Quiver via internal factory.
+    return Quiver._fromLoader(manifest.name, catalogRaw, loader);
+}

package/dist/bundle.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Zip utilities — browser-safe (uses fflate only).
+ */
+/**
+ * Pack a flat file map into a deterministic zip.
+ * Keys are sorted before zipping so insertion order doesn't affect output.
+ */
+export declare function packFiles(files: Record<string, Uint8Array>): Uint8Array;
+/**
+ * Unpack a zip into a flat file map.
+ * Returns { path: Uint8Array } for every file entry in the archive.
+ */
+export declare function unpackFiles(data: Uint8Array): Record<string, Uint8Array>;

package/dist/bundle.js

@@ -0,0 +1,33 @@
+/**
+ * Zip utilities — browser-safe (uses fflate only).
+ */
+import { zipSync, unzipSync } from "fflate";
+/**
+ * Fixed epoch mtime for deterministic zip output.
+ * All entries get this timestamp so byte-identical inputs → byte-identical zips.
+ */
+const ZIP_EPOCH = new Date(Date.UTC(1980, 0, 1));
+/**
+ * Pack a flat file map into a deterministic zip.
+ * Keys are sorted before zipping so insertion order doesn't affect output.
+ */
+export function packFiles(files) {
+    const sorted = Object.keys(files).sort();
+    const input = {};
+    for (const key of sorted) {
+        input[key] = [files[key], { mtime: ZIP_EPOCH }];
+    }
+    return zipSync(input, { level: 6 });
+}
+/**
+ * Unpack a zip into a flat file map.
+ * Returns { path: Uint8Array } for every file entry in the archive.
+ */
+export function unpackFiles(data) {
+    const raw = unzipSync(data);
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        result[key] = value;
+    }
+    return result;
+}

package/dist/engine-types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Minimal structural types matching @quillmark/wasm >=0.57.0 (verified against 0.59.0-rc.2).
+ *
+ * Shape:
+ *   class Quillmark { quill(tree: Map<string, Uint8Array>): Quill }
+ *   class Quill     { render(doc, opts?): RenderResult; open(doc): RenderSession }
+ *
+ * Note: as of 0.59.0-rc.2 the first arg to render/open is a `Document` instance
+ * (from `Document.fromMarkdown(...)`), not the old `ParsedDocument` interface.
+ * Quiver keeps the arg typed as `unknown` so consumers of either shape (and
+ * test doubles) satisfy the contract structurally.
+ *
+ * These types are INTERNAL — never re-exported from index.ts. They exist so
+ * registry.ts never imports from @quillmark/wasm directly and so test doubles
+ * can satisfy the contract without pulling the real WASM module.
+ *
+ * Call-site note: Quiver never invokes `render` or `open` itself; consumers do
+ * after `getQuill()`. The loose `unknown` parameter typing is intentional.
+ */
+export interface QuillmarkLike {
+    quill(tree: Map<string, Uint8Array>): QuillLike;
+}
+export interface QuillLike {
+    render(doc: unknown, opts?: unknown): unknown;
+    open?: (doc: unknown) => unknown;
+}

package/dist/engine-types.js

@@ -0,0 +1,20 @@
+/**
+ * Minimal structural types matching @quillmark/wasm >=0.57.0 (verified against 0.59.0-rc.2).
+ *
+ * Shape:
+ *   class Quillmark { quill(tree: Map<string, Uint8Array>): Quill }
+ *   class Quill     { render(doc, opts?): RenderResult; open(doc): RenderSession }
+ *
+ * Note: as of 0.59.0-rc.2 the first arg to render/open is a `Document` instance
+ * (from `Document.fromMarkdown(...)`), not the old `ParsedDocument` interface.
+ * Quiver keeps the arg typed as `unknown` so consumers of either shape (and
+ * test doubles) satisfy the contract structurally.
+ *
+ * These types are INTERNAL — never re-exported from index.ts. They exist so
+ * registry.ts never imports from @quillmark/wasm directly and so test doubles
+ * can satisfy the contract without pulling the real WASM module.
+ *
+ * Call-site note: Quiver never invokes `render` or `open` itself; consumers do
+ * after `getQuill()`. The loose `unknown` parameter typing is intentional.
+ */
+export {};

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+export type QuiverErrorCode = "invalid_ref" | "quill_not_found" | "quiver_invalid" | "transport_error" | "quiver_collision";
+export declare class QuiverError extends Error {
+    readonly code: QuiverErrorCode;
+    /** Offending ref string, when available. */
+    readonly ref?: string;
+    /** Offending version, when available. */
+    readonly version?: string;
+    /** Quiver `name` from Quiver.yaml, when available. */
+    readonly quiverName?: string;
+    constructor(code: QuiverErrorCode, message: string, options?: {
+        ref?: string;
+        version?: string;
+        quiverName?: string;
+        cause?: unknown;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,17 @@
+export class QuiverError extends Error {
+    code;
+    /** Offending ref string, when available. */
+    ref;
+    /** Offending version, when available. */
+    version;
+    /** Quiver `name` from Quiver.yaml, when available. */
+    quiverName;
+    constructor(code, message, options) {
+        super(message, { cause: options?.cause });
+        this.name = "QuiverError";
+        this.code = code;
+        this.ref = options?.ref;
+        this.version = options?.version;
+        this.quiverName = options?.quiverName;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { QuiverError } from "./errors.js";
+export type { QuiverErrorCode } from "./errors.js";
+export { Quiver } from "./quiver.js";
+export { QuiverRegistry } from "./registry.js";
+export type { BuildOptions } from "./build.js";
+export type { QuillmarkLike, QuillLike } from "./engine-types.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+// Main browser-safe entrypoint.
+export { QuiverError } from "./errors.js";
+export { Quiver } from "./quiver.js";
+export { QuiverRegistry } from "./registry.js";

package/dist/node.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist/node.js

@@ -0,0 +1,5 @@
+// Node-only entrypoint.
+// Re-export everything from the main browser-safe entrypoint.
+// Node-only factories (fromPackage, fromDir, build) are methods on
+// Quiver itself — no additional exports are needed here.
+export * from "./index.js";

package/dist/quiver-yaml.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Internal parser/validator for Quiver.yaml files.
+ *
+ * Uses the `yaml` npm package for robust YAML parsing. Quiver.yaml has a
+ * simple two-field schema (name, description), but using a proper YAML parser
+ * ensures correct handling of quoting, escaping, and multi-line strings.
+ */
+export interface QuiverMeta {
+    name: string;
+    description?: string;
+}
+/**
+ * Parses and validates Quiver.yaml contents.
+ *
+ * Throws `QuiverError('quiver_invalid')` on:
+ *   - YAML parse failure
+ *   - Missing or non-string `name`
+ *   - `name` fails charset validation [A-Za-z0-9_-]+
+ *   - Unknown fields (strict)
+ *   - `description` present but not a string
+ */
+export declare function parseQuiverYaml(raw: string | Uint8Array): QuiverMeta;

package/dist/quiver-yaml.js

@@ -0,0 +1,63 @@
+/**
+ * Internal parser/validator for Quiver.yaml files.
+ *
+ * Uses the `yaml` npm package for robust YAML parsing. Quiver.yaml has a
+ * simple two-field schema (name, description), but using a proper YAML parser
+ * ensures correct handling of quoting, escaping, and multi-line strings.
+ */
+import { parse as parseYaml } from "yaml";
+import { QuiverError } from "./errors.js";
+const NAME_RE = /^[A-Za-z0-9_-]+$/;
+const KNOWN_FIELDS = new Set(["name", "description"]);
+/**
+ * Parses and validates Quiver.yaml contents.
+ *
+ * Throws `QuiverError('quiver_invalid')` on:
+ *   - YAML parse failure
+ *   - Missing or non-string `name`
+ *   - `name` fails charset validation [A-Za-z0-9_-]+
+ *   - Unknown fields (strict)
+ *   - `description` present but not a string
+ */
+export function parseQuiverYaml(raw) {
+    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+    let parsed;
+    try {
+        parsed = parseYaml(text);
+    }
+    catch (err) {
+        throw new QuiverError("quiver_invalid", `Quiver.yaml: YAML parse failure — ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new QuiverError("quiver_invalid", `Quiver.yaml: expected a mapping at the top level, got ${Array.isArray(parsed) ? "array" : String(parsed)}`);
+    }
+    const doc = parsed;
+    // Check for unknown fields (strict mode)
+    for (const key of Object.keys(doc)) {
+        if (!KNOWN_FIELDS.has(key)) {
+            throw new QuiverError("quiver_invalid", `Quiver.yaml: unknown field "${key}" — only "name" and "description" are valid in V1`);
+        }
+    }
+    // Validate `name`
+    if (!("name" in doc)) {
+        throw new QuiverError("quiver_invalid", `Quiver.yaml: required field "name" is missing`);
+    }
+    if (typeof doc["name"] !== "string") {
+        throw new QuiverError("quiver_invalid", `Quiver.yaml: "name" must be a string, got ${typeof doc["name"]}`);
+    }
+    const name = doc["name"];
+    if (!NAME_RE.test(name)) {
+        throw new QuiverError("quiver_invalid", `Quiver.yaml: "name" value "${name}" contains invalid characters — only [A-Za-z0-9_-] are allowed`);
+    }
+    // Validate optional `description`
+    if ("description" in doc && doc["description"] !== undefined) {
+        if (typeof doc["description"] !== "string") {
+            throw new QuiverError("quiver_invalid", `Quiver.yaml: "description" must be a string if present, got ${typeof doc["description"]}`);
+        }
+    }
+    const meta = { name };
+    if (typeof doc["description"] === "string") {
+        meta.description = doc["description"];
+    }
+    return meta;
+}

package/dist/quiver.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Quiver — primary runtime abstraction for a collection of quills.
+ *
+ * Polymorphism via composition: internally stores a pluggable loader
+ * (either source-backed or build-output-backed).
+ */
+import type { BuildOptions } from "./build.js";
+/** @internal Internal loader strategy: source or build output. */
+export interface QuiverLoader {
+    loadTree(name: string, version: string): Promise<Map<string, Uint8Array>>;
+}
+export declare class Quiver {
+    #private;
+    readonly name: string;
+    /**
+     * Private constructor — use static factory methods.
+     * TS prevents external `new Quiver(...)` at compile time.
+     * Static methods inside can still call it.
+     */
+    private constructor();
+    /** @internal Used by loadBuiltQuiver. Not part of the public API. */
+    static _fromLoader(name: string, catalog: Map<string, string[]>, loader: QuiverLoader): Quiver;
+    /**
+     * Node-only factory. Resolves an npm specifier against `node_modules` and
+     * loads the source layout at the package root.
+     *
+     * The resolved package must have `Quiver.yaml` at its root.
+     *
+     * Throws `transport_error` on resolution/I/O failure, `quiver_invalid`
+     * on schema violations.
+     */
+    static fromPackage(specifier: string): Promise<Quiver>;
+    /**
+     * Node-only factory. Reads a Source Quiver from a local directory containing
+     * `Quiver.yaml` and `quills/<name>/<version>/Quill.yaml` entries.
+     *
+     * Also accepts `import.meta.url`-style `file://` URLs as a convenience for
+     * tests; the URL's parent directory is used as the source root.
+     *
+     * Throws `quiver_invalid` on schema violations, `transport_error` on I/O failure.
+     */
+    static fromDir(pathOrFileUrl: string): Promise<Quiver>;
+    /**
+     * Browser-safe factory. Loads build output from an HTTP/HTTPS URL.
+     *
+     * Origin-relative URLs (e.g. `/quivers/foo/`) are accepted in browser
+     * environments. `file://` URLs are rejected — local build output is
+     * not loadable in V1; serve over HTTP or use `fromPackage`/`fromDir`
+     * against the source.
+     *
+     * Throws `transport_error` on network/HTTP failure, `quiver_invalid`
+     * on format errors.
+     */
+    static fromBuilt(url: string): Promise<Quiver>;
+    /** Returns all known quill names, sorted lexicographically. */
+    quillNames(): string[];
+    /**
+     * Returns all canonical versions for a given quill name, sorted descending.
+     * Returns an empty array if the quill name is not in the catalog.
+     */
+    versionsOf(name: string): string[];
+    /**
+     * Node-only tooling. Reads the Source Quiver at sourceDir, validates it,
+     * and writes the runtime build artifact to outDir.
+     *
+     * Uses dynamic import of `./build.js` so that this module stays
+     * browser-safe at evaluation time.
+     *
+     * Throws `quiver_invalid` on source validation failures,
+     * `transport_error` on I/O failures.
+     */
+    static build(sourceDir: string, outDir: string, opts?: BuildOptions): Promise<void>;
+    /**
+     * Lazily loads the file tree for a specific quill version.
+     *
+     * Returns `Map<string, Uint8Array>` suitable for `engine.quill(tree)`.
+     * Does NOT cache the result — caching is the registry's concern.
+     *
+     * Throws `transport_error` if name/version not in catalog or I/O fails.
+     */
+    loadTree(name: string, version: string): Promise<Map<string, Uint8Array>>;
+}