TypedMark Typed Markdown note systems
Essentials

Quick Reference

Audience: collection authors and tool authors looking up an existing rule.

See also:

This page is non-normative. It maps terms and tasks to the sections that govern them.

Glossary#

Term Meaning Defined in
Collection A rooted set of Markdown notes plus governing artifacts Foundations
Core Profile The minimal authoring profile for a conforming typed collection Foundations
Governed artifact typedmark.md, a note-type schema, a property set, an automation rule, a saved view, a template, or history.md — Markdown files with governed frontmatter or body surfaces Foundations
Note type A named structural class notes are associated with Foundations
Managed note A note associated with exactly one concrete note type and governed by its schema Managed Notes and Properties
Untyped note A note outside Core managed-note validation; explicit extensions can govern other surfaces Foundations
Asset A non-Markdown content file Foundations
Property set A named reusable bundle of frontmatter, relationships, and headings Collection Model
Effective note-type schema The result of composing a concrete schema, its abstract ancestors, and property sets Note Type Schemas
Field definition The typed contract for one frontmatter property Field Definition Reference
Field conversion A directional, typed conversion from one field definition to another Field compatibility and conversion
Canonical materialization Explicit normalization of declared effective values; ordinary edits preserve sparse storage Managed Notes and Properties
Relationship instance A resolved note-to-note link counted against declared targets Relationships, Headings, and Templates
System A collection that declares version and scaffold, making it publishable and composable Systems, Composition, and Evolution
Composition Building one self-contained collection from ordered source systems Systems, Composition, and Evolution
Marketplace catalog The marketplace.json index of known systems Systems, Composition, and Evolution
Vocabulary A named, reusable value set referenced by allowed_values_from Collection Model
Automation rule A declarative event or schedule trigger with an ordered, atomic action list Collection Model
Propagation Deterministic multi-wave automation execution that commits only at a valid fixed point Managed Notes and Properties
Portable query A plain-JSON, read-only descriptor for filtering managed notes and projecting deterministic result rows Portable Queries
Dataset A governed reusable query with stable row identity and a common projected column contract across note types Datasets
Saved view A governed presentation over an embedded portable query or referenced dataset, using a table, list, cards, board, tree, calendar, or timeline layout Saved Views
Template region Marker-delimited static Markdown with a per-note baseline receipt for portable three-way drift detection Template Drift Tracking
Content expansion Marker-delimited plain Markdown derived from a declared source, with automatic, manual, once, and ejectable modes Content Expansion

How do I…#

I want to… Use Defined in
start with the smallest conforming setup Core configuration and one concrete schema Getting Started
require a concrete effective value nullable: false Effective values
require a field only in some states conditions with require / require_null Conditional constraints
restrict a field to fixed values allowed_values, or allowed_values_from with a vocabulary Field Definition Reference
make link fields point at real notes validate_exists: true Field Definition Reference
restrict which note types a link targets targets on the link field Field Definition Reference
ask for priority and effort when creating a task inputs: [priority, effort] Creation Inputs
auto-fill creation dates or ids Core generated: now or uuid; other generators use Authoring Field Definition Reference
stop a value from changing immutable: true Field Definition Reference
keep a value unique unique: true (per type) or unique: collection Field Definition Reference
say "every meeting belongs to a project" relationship_kind: belongs_to field + relationship cardinality Relationships
keep related_tasks and related_projects in step inverse on both fields (one-sided links are inverse_mismatch warnings) Relationship Model
list a project's tasks or a task's prerequisites relationship_kind: contains or depends_on (no cycles) Relationship Model
file notes by date, quarter, or week {field:format} over a stored/effective date field Storage rules
store a periodic note's year, quarter, month, or week from its date from_date: {field: date, part: GGGG} Expressions
link a periodic note to its week or month note from_date or computed name + self_field expansion Expressions
keep companion notes beside their parent (Projects/Launch/Decisions.md) {project:folder}/{project:name} over a single note-link field Storage rules
add a required name suffix note_name_suffix.pattern Storage rules
store a note in a folder of its own, such as Projects/Launch/Launch (Project).md note_folder: optional (or required) in storage Storage rules
accept names with or without a decorative suffix, titled without it note_name_suffix: {pattern: " (Permanent)", optional: true} Storage rules
let authors choose note names, optionally by shape omit note_name_pattern; add note_name_regex, e.g. "^[a-z0-9]+(?:[.-][a-z0-9]+)*$" for net.proto.bgp Storage rules
map notes to types by tag or folder note_type_mappings with kind: tag or kind: folder Note-type mappings
require tags collection-wide or by note type mandatory_tags in the collection or schema Mandatory tags
say which status values mean done states on the status field, e.g. completed: {done: true, outcome: success} Field Definition Reference
turn a note into another type without losing data re-typing with a typedmark-preserved block Note Re-typing
rename or move a note without breaking links, or edit without reformatting a writer claiming the Edits and Renames contract Edits and Renames
stamp the date work becomes done set_field with value_from: trigger_date and only_if_empty: true Automation rules
react when work becomes done trigger.changed.status.to_state: {done: true} or when: {status: {state: {done: true}}} Automation rules
archive notes some time after they finish a daily schedule with when: {status: {state: {done: true}}, completed_on: {older_than: P30D}} and archive_note Automation rules
remove a value so the field falls back to its default unset_field Automation rules
act only when a field is empty or past a threshold when: {due: {empty: true}} or when: {progress: {greater_than: 50}} Automation rules
target notes whose field is empty, or above or below a bound when: {lent_to: {empty: true}}, when: {copies: {greater_than: 1}} Automation rules
react to note changes or a schedule an automation artifact under <metadata_directory>/automations/ Automation rules
let automation changes trigger further rules safely propagation mode with automation_defaults.max_propagation_waves Dependency propagation
select, filter, sort, group, or limit managed notes portably a portable query descriptor with where, select, order_by, group_by, and limit Portable Queries
reuse one multi-type result in several presentations a dataset artifact under <metadata_directory>/datasets/ and saved views that reference it Datasets
save and share a table, list, cards, board, tree, calendar, or timeline view a saved-view artifact under <metadata_directory>/views/ Saved Views
split a board into swimlanes (per project, area, or type) presentation.board.lanes.column Saved Views
move cards between columns and order them by hand presentation.board.writable: true and rank: manual_order Saved Views
show tasks under their parent tasks and projects (work breakdown) layout: tree with tree.parent (a link or a list of links), context: ancestors, writable: true Saved Views
see tasks on their scheduled and due days, or as spans on a plan layout: calendar with calendar.dates, or layout: timeline with start/end Saved Views
list the open checklist items of many notes a query with rows: items and an item predicate on checked Task Items
list the checklist items that mention a project rows: items with {kind: item, property: links, operator: contains_any, value: [Projects/Launch.md]} Task Items
roll estimates and progress up a work breakdown tree.rollups with sum and weighted_mean (weight, done_value) Saved Views
show only this project's tasks with one shared dataset a relationship predicate with context_note: true Portable Queries
build a readable Markdown dashboard from datasets or saved views one or more dataset- or view-backed content expansions in an ordinary note Content Expansion
detect and reconcile static template changes without overwriting note edits typedmark:template-region markers plus template_regions baseline receipts Template Drift Tracking
keep a Markdown region synchronized with a field, relationship, or query result a typedmark:expansion marker with mode: auto or manual Content Expansion
share fields across many note types property sets and default_property_sets Collection Model
combine differently typed fields safely field compatibility and conversion rules Field compatibility and conversion
replace old folder-scoped structure explicitly authored concrete types and mappings Collection Model
tolerate unknown fields on one type only per-type unknown_field severity Note Type Schemas
require exactly one Home note count: {min: 1, max: 1} and fixed storage Counts
explain sections and route quick captures heading entries {text, description} and headings.capture_h2 Heading rules
enforce the H1 matches the title headings.require_h1_title: true Heading rules
soft-delete or archive a note core fields deleted / archived Core-defined fields
give a note alternative link names core field aliases Core-defined fields
publish my setup for others declare version and scaffold; list it in a marketplace Systems
let an agent repair a finding safely a result's fix action Validation Reports
give an agent a note type's resolved fields and where they come from a typedmark:effective-schema export Effective Schema Export
validate artifacts in my editor or CI the published JSON Schemas schema/