Crate quillmark 

Quillmark

Quillmark is a schema-driven document engine that turns Markdown with card-yaml metadata blocks into a fully typeset document (PDF, SVG, PNG).

use quillmark::{quill_from_path, Document, OutputFormat, Quillmark, RenderOptions};

let quill = quill_from_path("path/to/quill").unwrap();
let engine = Quillmark::new();

let parsed = Document::parse("~~~\n$quill: my_quill\n$kind: main\ntitle: Hello\n~~~\n\n# Hello World").unwrap().document;
let result = engine.render(&quill, &parsed, &RenderOptions {
    output_format: Some(OutputFormat::Pdf),
    ..Default::default()
}).unwrap();

Re-exports

pub use orchestration::Quillmark;

Modules

orchestration

Orchestration

Structs

Artifact

An artifact produced by rendering.

Card

A single card-yaml block (root or composable). body is the content (Content) form of the prose after the closing fence — the empty content when none follows; check card.body().is_blank(). Markdown is a projection: Card::body_markdown re-emits it.

CardSchema

Schema definition for a card kind (composable content blocks)

ChangeSet

What a committed LiveSession::apply changed.

Content

One content field as a content: the text plus the structure that rides on it.

Delta

A per-field edit against a base content. Ops apply left-to-right, consuming base positions; Retain/Delete advance the base cursor, Insert adds new text. USV throughout.

Diagnostic

Structured diagnostic information.

Document

A fully-parsed Quillmark document. Serde routes through StoredDocument; for the plate wire shape see Document::to_plate_json.

FieldSchema

Schema definition for a template field.

LiveSession

Opaque, backend-backed live render session: a persistent compiler that serves reads (render, paint seams, regions) from its current compile and takes edits via apply. Reads between edits see a stable document — apply is transactional, swapping the compile only on success — so immutability is an invariant between commits, not a type.

Location

Parsed

The record of one parse: the Document and any non-fatal warnings. Returned by Document::parse, the single parse entry. Warnings live here and only here — Document is the value (equality, the storage DTO, and mutators all exclude warnings); Parsed is the parse event. A caller that wants only the document writes Document::parse(md)?.document.

Quill

Portable, validated quill data: the file bundle, parsed config, and metadata of an authored quill, tagged with its declared backend id.

QuillConfig

Top-level configuration for a Quillmark project

QuillIgnore

Simple gitignore-style pattern matcher for .quillignore

RenderError

Main error type for rendering operations: a non-empty collection of Diagnostics.

RenderOptions

Internal rendering options.

RenderResult

Enums

FieldType

Field type hint enum for type-safe field type definitions.

FileTreeNode

A node in the file tree structure

OutputFormat

Output formats supported by backends.

ParseError

Severity

Fatality is this two-value ladder and nothing else: Error blocks the stage that emits it, Warning never does. There is no lint-level configuration and no warning-to-error promotion; an informational aside is a Diagnostic::hint, not a severity.

ValidationError

Validation error with a structured field path.

Traits

Backend

Backend trait for rendering different output formats.

Functions

quill_from_path

Load a quill from a filesystem directory. Honours a root .quillignore, else a default ignore set. (The fs walk lives here; core stays fs-agnostic.)

quill_from_path_with_warnings

quill_from_path, keeping the config’s advisory diagnostics rather than dropping them — the door for a caller that reports them (quillmark validate -v).

tree_from_path

Walk a filesystem path into an in-memory FileTreeNode — the tree half of quill_from_path, for a caller that wants to edit the tree before Quill::from_tree reads it.