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).

Markdown enters through the bound door: Quill::parse conforms the document against the quill that will render it.

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

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

let doc = quill.parse("~~~\n$quill: my_quill\n$kind: main\ntitle: Hello\n~~~\n\n# Hello World").unwrap().document;
let result = engine.render(&quill, &doc, &RenderOptions::default().with_output_format(OutputFormat::Pdf)).unwrap();

Or no Markdown at all: a blank canvas and the schema-bound writer.

use quillmark::{quill_from_path, Document};

let quill = quill_from_path("path/to/quill").unwrap();
let mut doc = Document::new("my_quill".parse().unwrap());

let mut writer = quill.writer(&mut doc);
writer.set("title", "Hello").unwrap();

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.

CardReader

A single composable card bound to its CardSchema, from TypedReader::card. Same get / body_markdown verbs as TypedReader, reading the card at its bound index.

CardSchema

Schema definition for a card kind (composable content blocks)

ChangeBundle

One committed field edit: a text delta and the three op channels, applied in field order (delta → islands → lines → marks) by Content::apply_field_change. Default is the identity bundle, so a caller names only the channels it uses: ChangeBundle { delta, ..Default::default() }.

ChangeSet

What a committed LiveSession::update changed.

Content

The canonical content model, the pre-built value the document mutators accept, and the canonical-form token every content read answers in. One content field as a content: the text plus the structure that rides on it.

ContentHit

A resolved point → content position: the schema field a click landed in and the USV offset into that field’s Content. The forward position_at direction, paired with locate (content position → caret rect).

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.

FieldSchema

Schema definition for a template field. default: answers both the value axis and the obligation one (must_fill); SCHEMAS.md §“Value and obligation: one declaration” is the rule.

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 update. Reads between edits see a stable document (update is transactional, swapping the compile only on success) so immutability is an invariant between commits, not a type.

Location

Normalized

The canonical content model, the pre-built value the document mutators accept, and the canonical-form token every content read answers in. A Content that Content::normalize has run on: the precondition both projections carry. Minted only by Content::into_normalized, which the codecs decode through; a mutation that does not re-establish the invariant takes into_content and mints again.

Parsed

The record of one load: the Document and any non-fatal warnings. Returned by both Document::parse and the bound Quill::parse, whose warnings also carry the conform::* ones. Warnings live here and only here: Document is the value, Parsed the load event.

Quill

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

QuillConfig

Top-level configuration for a Quillmark project

QuillIgnore

QuillReference

Complete reference to a Quill template with name and version selector.

QuillValue

Unified value type: JSON-shaped data beside the paths of the nodes tagged !must_fill.

Quillmark

A backend registry and render dispatcher: the sole home of backend-dependent surface, resolving a Quill’s declared backend at render time. Quill loading needs no engine — see Quill::from_tree or quill_from_path.

RenderError

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

RenderOptions

Internal rendering options.

RenderResult

RenderedRegion

One schema field placement’s extent on a rendered page.

TypedReader

A Document bound to its QuillConfig for typed reads. Construct with Quill::reader. Reads target the main card; use card for a composable card. The read twin of TypedWriter.

TypedWriter

A Document bound to its QuillConfig for typed writes. Construct with Quill::writer. Writes target the main card; use card for a composable card.

Enums

BoundParseError

The failure of the bound door (Quill::parse): the markdown did not parse, or it parsed under a $quill this quill does not answer to. Nothing conforms under the wrong schema, so the mismatch is an error and not a warning; to_diagnostics flattens either half for a consumer that only routes on codes.

EditError

Errors returned by document and card mutators.

FieldType

A field’s declared type:. Each type’s meaning and grammar is the SCHEMAS.md §“Quill.yaml DSL” table.

FileTreeNode

A node in a quill bundle’s file tree. Out-of-crate callers build these; Quill::from_tree takes one. Symlinks are refused at the loader rather than modelled here.

HitGranularity

How precisely a ContentHit::pos resolved. Never sub-cluster.

ImportError

Carried by EditError::Import, so nameable from here. Import errors: just the nesting guard.

OutputFormat

ParseError

PathSegment

One step of a path into a value tree: an object key or an array index. The canonical path-segment type for the whole crate, covering nested-comment and nested-fill paths alike.

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. A variant carries enough for Display to render the uniform message ERROR.md § “Validation message contract” describes.

Traits

Backend

Backend trait for rendering different output formats.

Functions

quill_from_path

Load a quill from a filesystem directory, skipping what QuillIgnore excludes.

tree_from_path

Walk a filesystem path into an in-memory FileTreeNode, for a caller that wants to edit the tree before Quill::from_tree reads it. Skips what QuillIgnore excludes.