# Meridian handbook

- [Meridian](/): What Meridian is, what the engine-cms and engine-dmo bundles each include, how this handbook is organised and where to start.
- Getting started
  - [Getting started](/getting-started): The path from nothing to a running Meridian site on your machine, and which page answers each step.
  - [Install](/getting-started/install): What Meridian needs to run (the engine binary or container image, PostgreSQL 14 or later, and optional search and mail services) and how to check an installation.
  - [Your first project](/getting-started/first-project): Create a Meridian project with init or init --from, migrate and apply it to a database, seed it, serve it and sign in to the admin as the first staff user.
  - [Project layout](/getting-started/project-layout): Every directory and file a Meridian project can hold, what each is for, which bundle reads it, and which files you write and which the tooling writes.
  - [The development loop](/getting-started/development-loop): The commands for day-to-day work on a Meridian project (dev up, serve --dev, the dev authoring verbs, check, schema plan and apply, migrate, seed, describe, render, template tests, guide and docs serve), what each needs and what it exits with.
  - [Upgrading the engine](/getting-started/upgrading-the-engine): How to move a project to a new engine version, covering engine.version, the template contract and check --contract-report, migrations as an explicit deploy step, and the order to run things in.
- Concepts
  - [Concepts](/concepts): The ideas every Meridian project rests on (sites, locales, routes, documents and publishing, modules and bundles, stable ids, users and permissions) and how they fit together.
  - [Sites, locales and routes](/concepts/sites-locales-and-routes): How one Meridian install serves several sites in several locales, how locales are declared once and enabled per site, how routes give types URLs, and how a request finds its site, locale and document.
  - [Documents, revisions and publishing](/concepts/documents-revisions-and-publishing): How Meridian stores content as documents with a shared revision chain and one chain per locale, the per-locale workflow states, what publishing checks and does, scheduling, the trash, and revision retention.
  - [Modules and bundles](/concepts/modules-and-bundles): What the core platform provides, what each Meridian module adds and requires, which modules the engine-cms and engine-dmo bundles compile, and what happens when a project uses a module its binary lacks.
  - [Stable ids](/concepts/stable-ids): The id written beside every named element in Meridian configuration, who writes it, why a rename keeps all stored data, how renames and aliases work, and how to fix a missing, copied or wrong id.
  - [Users, roles and permissions](/concepts/users-roles-and-permissions): How staff users, groups, built-in and custom roles, and scoped grants control what each person may do in Meridian; how to create users and explain a decision; and how members of the public realm differ from staff.
- Content modelling
  - [Content modelling](/content-modelling): How a content type is declared in YAML under config/schema, with a complete worked example from an empty file to a rendered page.
  - [Content types](/content-modelling/types): Every key a type file takes (key, extends, label, ordering, template, singleton, variants, sites, groups, revisions and the rest), how to extend a core type, and the rules check enforces.
  - Fields
    - [Fields](/content-modelling/fields): The keys every field takes (name, type, label, required, index, translate, visible_when and the rest), field groups, and a table of all 23 field types with links to each type's page.
    - [Text and slug](/content-modelling/fields/text-and-slug): The text field (single or multi-line, length limits, pattern, email format) and the slug field (a per-locale URL segment generated from another field), with parameters, validation and template values.
    - [Numbers and money](/content-modelling/fields/numbers-and-money): The number field (min, max, step, integer, display unit) and the money field (a decimal amount with its ISO 4217 currency, fixed or chosen), with parameters, validation, stored shapes and template values.
    - [Boolean and select](/content-modelling/fields/boolean-and-select): The boolean field and the select field (one option or several from a declared list, each option with a stable id and per-locale label), with parameters, validation, stored values and what templates receive.
    - [Dates and times](/content-modelling/fields/dates-and-times): The date field (a calendar day), the datetime field (a wall-clock time in an IANA zone with its UTC instant) and the recurrence field (an event's repeating schedule and its occurrences), with parameters, stored shapes and template values.
    - [Places](/content-modelling/fields/places): The geo field (a point), the geo_shape field (an area boundary as GeoJSON) and the address field (a country-aware postal address), with parameters, validation, stored shapes and template values.
    - [Phone and opening hours](/content-modelling/fields/phone-and-opening-hours): The phone field (an E.164 number parsed in a region, with accepted number types) and the opening_hours field (a weekly pattern, seasons, exceptions and public holidays), with parameters, validation, stored shapes and template values.
    - [Asset](/content-modelling/fields/asset): The asset field (one or several media library files: images, documents, audio or library videos) with kinds, file and image constraints, per-use alt text, captions and framing, the stored shape and the image value templates receive.
    - [Link](/content-modelling/fields/link): The link field (one link or a list) to a document, asset, URL, email address, phone number, site or anchor, with kinds and their settings, editor attributes, rel, named styles, sub-fields, the stored shape and the link value templates receive.
    - [Video](/content-modelling/fields/video): The video field: a YouTube or Vimeo video, a media library video or an .mp4/.webm file on an allowed host, with poster, captions confirmation, title and transcript, rendered through a privacy facade.
    - [SEO](/content-modelling/fields/seo): The seo field: a per-locale search title and description and their social-sharing pair, with length warnings, the stored shape, and how head() uses it.
    - [Form](/content-modelling/fields/form): The form field: lets an editor place one of the site's declared form endpoints on a page, with the endpoints it may offer, the checks, and the form value templates render.
  - [Validation](/content-modelling/validation): When a document is checked (save and publish), required fields and required_in, visible_when and required_when, the expression language, cross-field validation rules with severity and timing, and the publish checks.
  - [Relations](/content-modelling/relations): The relation field: references from a document to other documents, tags, smart lists, assets, organisations or people, with targets, cardinality, tag filters, publish checks, stored shape, and how templates receive resolved entries.
  - [Blocks and rich text](/content-modelling/blocks-and-rich-text): Repeaters (a list of items with the same fields), blocks (a flexible page body of typed blocks, each with its own template), shared blocks, and Portable Text rich text with styles, lists, marks, link annotations and object blocks, and how each renders.
  - [Localisation](/content-modelling/localisation): How fields are translated: the translate modes (none, locale, language, group), the shared skeleton and per-locale leaves of repeaters, blocks, links and assets, structure per_locale, and field fallback on the public site.
  - [Schema changes](/content-modelling/schema-changes): How a change to the type files reaches the database: schema plan and schema apply, what is destructive and how to approve it, renames by id with aliases, removed fields kept under _orphaned, retyping and coercion, reprojection, and what apply refuses.
  - [Seeding and importing](/content-modelling/seeding-and-importing): Getting content into a project: seed sets (seed.yaml, documents per type and locale, assets, history and publishing states, references by seed key, verify, apply and reset), generated content, content create and update, and JSON export and import between environments.
- Templates
  - [Templates](/templates): How a request becomes a page, which template file renders each kind of page, how the template chain resolves names, and the commands that show what a template receives.
  - [The template language](/templates/language): The Pongo2 syntax Meridian templates use (printing, expressions, filters, keyword arguments, inheritance, includes, macros, loops, whitespace) and the escaping and security rules the engine enforces on every template.
  - [The page context](/templates/context): Exactly what each kind of page template receives (a document's entry and its common fields, an index page's items, pagination and facets, the search page's results, error pages, block and rich text templates) and how to print the real context of any URL.
  - [Globals](/templates/globals): The variables every public template can read (site, sites, locale, locales, page, request, now, today, settings, singletons, nav, csrf, assets, devMode) with every key each one holds.
  - [Querying content](/templates/queries): How a template fetches published documents with query() (where, tag, near, orderBy, limit, offset, exclude, organisation, onePer, with, and the terminal methods), nearby(), children(), ancestors(), smartList() and search(), with every rule, limit and error.
  - [Filters](/templates/filters): Every filter a Meridian template can use, grouped (text, locale-aware formatting of numbers, dates and money, rich text, URLs and encoding, lists, and the Pongo2 built-ins), with its argument, default, output and example.
  - [Tags](/templates/tags): Every tag a Meridian template can use (Pongo2's control flow, inheritance and include tags, and the engine's blocks, nav, component, slot, fragment, cache, announce, focus, patch, location and requireMember tags) with syntax, options and errors.
  - [Functions](/templates/functions): Every function a Meridian template can call (links and URLs, interface strings and locale helpers, content queries, head and structured data, feeds, forms and security, analytics, assets and images, embeds, sigmx, upstream sources, and the DMO functions) with arguments, keywords, return values and examples.
  - [Components](/templates/components): How to write, call and override a template component with a declared contract of props, slots and attributes that engine-dmo check enforces at every call site.
  - [Images](/templates/images): How to print responsive images from asset fields and theme files with img(), picture() and figure(), configure named transforms, breakpoints and art direction in config/images.yaml, and check what a page downloads.
  - [Links and URLs](/templates/links): How a template builds links with path(), url(), siteUrl() and localeUrl(), prints an entry's address, renders link and asset fields, and why every variable in href or src goes through the url filter.
  - [SEO and structured data](/templates/seo-and-structured-data): What head() and jsonld() print, how titles, descriptions, canonical URLs, hreflang, robots and Open Graph are decided, how to map a content type to schema.org, and how the sitemap and robots.txt are configured.
  - [Forms in templates](/templates/forms): How a template draws a form that posts to a declared endpoint (form field render(), enquiryForm(), subscribeForm() or hand-built markup), carries the CSRF token and abuse controls, and renders the success and error responses.
  - [Multisite templates](/templates/multisite): How several sites in one project share templates through an ordered chain of template roots, override a component, a block or a whole file for one site, extend their own name across the chain, and detect copies that have drifted.
  - [Frontend build](/templates/frontend-build): How stylesheets, scripts and static files reach a page through the assets helpers, with or without a Vite build, how the vite extension reads the build manifest and runs the dev server, and how to stay inside the content security policy with no inline script.
  - [Caching](/templates/caching): How the page cache and the cache tag for template fragments work, what a template does that makes a page or a block uncacheable, how cached output is invalidated on publish, and the configuration keys that bound it.
  - [Testing templates](/templates/testing): How to verify templates with engine-dmo check, the language server in your editor, describe template and describe route, render --json, and template tests in tests/templates/*.test.yaml with selector, JSON-LD and snapshot assertions.
- Features
  - [Features](/features): What the engine does for a website beyond content and templates, in both bundles, and which page explains each feature.
  - [Media library](/features/media): How uploads, alt text and captions per locale and per site, licence and rights records, duplicates, orphans and image derivatives work, with every media setting in engine.yaml.
  - [Search](/features/search): How to give a site a search page, connect Meilisearch, Elasticsearch or OpenSearch, what is indexed, the search.html template and search() function, browse mode without a backend, synonyms and the zero-result report.
  - [Navigation](/features/navigation): How menus work: navigation slots declared in site.yaml, navigation sets edited in the admin or seeded from files, the nav global and the nav tag in templates, and breadcrumbs, child pages and language switchers.
  - [Forms and submissions](/features/forms-and-submissions): How to build a contact or enquiry form with no code: declaring an endpoint in endpoints.yaml, its inputs, validation, spam protection and rate limits, the store and mail steps, retention, the drawn form, the response templates and the submissions inbox.
  - [Transactional mail](/features/mail): How to configure the mail driver (Postmark, Amazon SES, Resend, SMTP or the development log), per-site senders, the email templates the engine and your forms send, bounce and complaint webhooks, the suppression list and the mail commands.
  - [Newsletters](/features/newsletters): How the built-in newsletter works: capturing subscribers with double opt-in through a declared endpoint, topics and consent records, the confirmation and preference centre pages, composing and sending campaigns from live content, tracking, deliverability checks and the newsletter commands.
  - [Redirects and URLs](/features/redirects-and-urls): How addresses stay stable: slugs, the automatic redirects on a slug change, trash or move, redirect and 410 rules in routes.yaml, importing a CSV of redirects from an old site, the order rules are matched in, and how missing pages are recorded.
  - [Analytics](/features/analytics): What the built-in, cookieless analytics collects and how (server-side views, the beacon, tracked links, impressions), why it needs no consent banner, the template helpers, dashboards in analytics/dashboards.yaml, exports, retention and every analytics setting.
  - [AI assistance](/features/ai-assistance): How to connect your own AI provider (Azure OpenAI, OpenAI, Anthropic, Mistral or any OpenAI-compatible endpoint), which authoring tasks AI drafts and where, the review queue, budgets and the data boundary, prompt overrides, public disclosure and the ai commands.
  - [Accessibility](/features/accessibility): What the engine does for accessibility on public pages and what a template author must still do, the accessibility checks in engine-dmo check and engine-dmo a11y audit, the alt text policy, and the accessibility statement, issues register and conformance report the engine generates.
- Destination platform (engine-dmo)
  - [What engine-dmo adds](/dmo): The modules the DMO bundle compiles on top of the core content platform, what each one is for, how they depend on each other and which configuration files belong to them.
  - [Directory](/dmo/directory): The listing and area types engine-dmo adds, how to extend them, route and facet them, link a listing to the business behind it, and show places, maps, nearby results and enquiries in templates.
  - [Landing pages](/dmo/landing-pages): How to declare landing pages (a place crossed with a category, a category alone, or a calendar month) on a route, the threshold that makes one live, the generated and editor-written copy, the template and its landing context, and the redirects the engine keeps.
  - [CRM](/dmo/crm): Organisations, people and the links between them; custom fields on both; the timeline, tags and smart lists of organisations and people; broadcasts to member contacts; the CSV and XLSX import, merging, duplicates, trash and erasure; and every CRM command.
  - [Partners and the portal](/dmo/partners-and-portal): Membership tiers and memberships, what each tier may edit on a listing, partner roles and their permissions, the member portal's sign-in, invitations, reference screens and configuration, and the enquiry inbox businesses work from.
  - [Portal screens and actions](/dmo/portal-screens-and-actions): How to give one site its own portal path, routes and hidden screens, declare portal screens with scoped data and portal actions that write documents or custom fields, restyle the reference portal's templates, and build a portal of your own on the member API.
  - [Claims](/dmo/claims): How a business claims its organisation from the public site, how the claim is verified and scored from weighted signals, how staff review it, what approval does, every claims setting in engine.yaml and the claim commands.
  - [Promotions](/dmo/promotions): How to declare promotion slots on a site (across the site or per landing page), how members request them and staff approve them, how promoted() and promotionLabel() render paid placements with the label the law requires, and every slot setting, status and check.
  - [Member reports](/dmo/member-reports): What the member report tells a business about its listings, where members read it (portal, member API, PDF, monthly digest), how to configure the digest, the peer comparison and the improvement prompts, scheduled organisation reports for a board, and the report commands.
  - [Affiliates](/dmo/affiliates): How a site earns as an affiliate publisher: programmes with networks or direct deals, tracked links under /go/, the disclosure templates print, importing conversions by CSV, network connectors or a signed postback, the postback's signature and body, and the affiliate commands.
  - [Paid listings](/dmo/paid-listings): How to sell membership tiers and promotions: prices in config/paidlistings.yaml, Stripe Checkout or staff invoices, the portal's billing screen, the Stripe webhook, orders and their statuses, and how a paid order grants, renews, refunds and lapses a membership or a promotion.
  - [Multisite and networks](/dmo/multisite-networks): How several sites in one install share or separate partners: networks of sites that share organisations, people and portal accounts, what stays per site (tiers, slots, portals, landing pages), how staff are scoped to a network, and moving a site out with site export and retire.
- Extending
  - [Extending](/extending): The ways to add behaviour to a Meridian site without changing the engine: configuration and declared endpoints, templates and components, Go extensions loaded from engine.yaml, and experimental out-of-process plugins, with how to choose between them.
  - [Extensions](/extending/extensions): How to write a Meridian extension, a Go plugin built against github.com/wrux/meridian-extend that adds template globals and filters, HTTP routes, commands, an asset resolver and a dev server; every interface it offers, how to build it so the engine will load it, how to name it in engine.yaml, and every error the loader gives.
  - [First-party extensions](/extending/first-party-extensions): The extensions that ship beside the engine binary and load by name from engine.yaml (today the vite extension): what each adds, where its file lives in a release and in the container image, and how to turn it on.
  - [Project plugins (experimental)](/extending/plugins): How to give a declared endpoint logic YAML cannot express with a project plugin: an ordinary program the engine starts, supervises and calls over a Unix socket; plugins.yaml with every option, default and limit, the plugin step, writing one in Go with github.com/wrux/meridian-plugin, protocol version 0 on the wire, building, pinning and failure behaviour.
- Integrating
  - [Integrating](/integrating): How other systems reach a Meridian site: the read-only content API for headless frontends and builds, outbound webhooks, upstream data sources and scheduled feed imports, the content MCP for AI agents, the member API for a custom portal, and moving content in from WordPress or Sanity.
  - [Content API](/integrating/content-api): The read-only JSON content API at /api/content/v1: turning it on, publishable and secret keys and their capabilities, CORS, every operation and parameter, the document representation and each field type's delivered shape, queries with filters, facets and cursors, caching headers and cache tags, every error code, and the rate limits.
  - [Headless sites](/integrating/headless-sites): How to run a site's public pages from a frontend you build (Astro, Next.js, Nuxt or a static generator) on the content API: delivery.mode headless in site.yaml and what check enforces, the resolve loop, preview from the editor, revalidation webhooks and the change feed, forms, analytics collection, and static export.
  - [Webhooks](/integrating/webhooks): How Meridian tells other systems that something happened: webhooks.yaml with every option and limit, the content events and the endpoint webhook step, the request body and headers, verifying the HMAC signature, retries and backoff, the delivery log, and replaying a delivery.
  - [Sources and importers](/integrating/sources-and-importers): How to bring another service's data into a site without code: sources.yaml for cached, allowlisted upstream JSON read by templates and endpoints (with caching, failure modes and the circuit breaker), and importers.yaml for scheduled feed imports that create and update documents by external id, with every option, default and limit.
  - [Content MCP](/integrating/content-mcp): How to connect an AI agent (Claude or any Model Context Protocol client) to a Meridian site: turning the endpoint on, OAuth sign-in and the consent choices, the mcp configuration block, registering clients, personal access tokens and engine-dmo mcp call for scripts, engine-dmo mcp over stdio for local development, the tools, resources and prompts, limits, and what to tell a data protection officer.
  - [Member API](/integrating/member-api): How to build your own member portal (a single-page app or a headless site's account area) on the member API at /api/member/v1: what it requires, signing members in through the engine's sign-in screens, the same-origin session cookie and CSRF token, a worked request sequence, the form description, errors, rate limits and the OpenAPI contract.
  - [Migration](/integrating/migration): How to move an existing site into Meridian without losing content, media or search rankings: the engine's three imports (media manifests, content files with the HTML path, redirect CSVs) and their formats, the meridian-migrate toolkit for WordPress and Sanity exports, crawling the old site and matching its addresses, and a rehearsed cutover runbook.
- Deploying
  - [Deploying](/deploying): How a Meridian site runs in production, the parts of a deployment (engine, PostgreSQL, storage, optional search and mail), the deploy sequence, and which page covers each task.
  - [Configuration and secrets](/deploying/configuration-and-secrets): How one project runs in development, staging and production through engine.environment and environment variables, how ${VAR} interpolation and the secret rule work, and every rule production enforces.
  - [Container images](/deploying/container-images): The two published engine images (pure Go and -vips), their tags, what each contains, how to run one with your project mounted or baked into an image of your own, and the runtime constraints (non-root, no shell, read-only root).
  - [Single-node deployment](/deploying/single-node): A complete production deployment on one virtual machine with Docker Compose (Caddy for TLS, the engine, PostgreSQL and Meilisearch), with every file to copy, the first start, backups and the same setup under systemd without containers.
  - [Database and migrations](/deploying/database-and-migrations): What the engine needs from PostgreSQL, the connection pool settings, how engine migrations and schema apply run as deploy steps, what the engine refuses at boot, and how destructive schema changes are approved.
  - [Storage and media](/deploying/storage-and-media): Where uploaded originals and generated image derivatives are stored (a local or shared filesystem, or an S3-compatible bucket), how media is served and cached, putting a CDN in front, upload limits, and keeping derivatives in check.
  - [Backups and restore](/deploying/backups-and-restore): What a complete Meridian backup contains (the database, the media store, the project and the signing key), scripts to take one and restore it, the order that keeps them consistent, and exporting one site as a standalone install.
  - [Data protection duties](/deploying/data-protection): The data protection work that falls to whoever runs an install, answering a subject access request, generating the impact assessment, and turning on and verifying the audit log's hash chain, with what the chain cannot detect.
  - [Upgrades](/deploying/upgrades): The production procedure for moving an install to a new engine version (check in CI, back up, migrate, apply the schema, roll out, verify), how a rolling upgrade behaves across replicas, and how to roll back.
  - [Monitoring](/deploying/monitoring): How to watch a running Meridian install, covering the /health liveness and readiness endpoint, the Prometheus metrics listener and its series, OpenTelemetry traces and metrics, Sentry error reporting, the JSON logs, the job queue and scheduler commands, and the doctor support bundle.
  - [Scaling](/deploying/scaling): Running more than one engine replica behind a load balancer, covering what each replica does, the scheduler lease, shared storage, caches across replicas, background job workers, database connections and the page cache.
- Reference
  - [Reference](/reference): Where to find every command and flag, every configuration file and key, the template API for your project, environment variables, exit codes and error codes, and how to get the same from the binary.
  - CLI
    - [CLI](/reference/cli): Every engine-dmo and engine-cms command by purpose, the global flags, --json output (data or envelope), --quiet, how a command finds its project, and how to list the whole command tree as JSON.
    - [a11y](/reference/cli/a11y): engine-dmo a11y: Accessibility statements, the issues register and the conformance scaffold. Every subcommand, argument and flag.
    - [access](/reference/cli/access): engine-dmo access: The effective permission matrix. Every subcommand, argument and flag.
    - [affiliates](/reference/cli/affiliates): engine-dmo affiliates: Affiliate networks, conversion imports and postback secrets. Every subcommand, argument and flag.
    - [ai](/reference/cli/ai): engine-dmo ai: The AI provider, its budget, the review queue and the activity log. Every subcommand, argument and flag.
    - [analytics](/reference/cli/analytics): engine-dmo analytics: Rollups, recompute, retention and member reports. Every subcommand, argument and flag.
    - [api](/reference/cli/api): engine-dmo api: The content API: its contract, a site's project contract, and what it answers for a path. Every subcommand, argument and flag.
    - [assets](/reference/cli/assets): engine-dmo assets: The frontend build as the engine resolves it: the manifest a build reads. Every subcommand, argument and flag.
    - [audit](/reference/cli/audit): engine-dmo audit: The audit log's integrity: walk its hash chain and report every break. Every subcommand, argument and flag.
    - [broadcast](/reference/cli/broadcast): engine-dmo broadcast: The crm module's broadcasts: list, show, draft, test-send, schedule, send, cancel, report. Every subcommand, argument and flag.
    - [build](/reference/cli/build): engine-dmo build: Run the project's frontend build, then engine-dmo check. Every subcommand, argument and flag.
    - [check](/reference/cli/check): engine-dmo check: The CI gate: validate config, schema, templates and the deployment. Exit 3 on invalid configuration. Every subcommand, argument and flag.
    - [completion](/reference/cli/completion): engine-dmo completion: Generate the autocompletion script for the specified shell. Every subcommand, argument and flag.
    - [config](/reference/cli/config): engine-dmo config: Configuration tools. Every subcommand, argument and flag.
    - [content](/reference/cli/content): engine-dmo content: Content operations: list, get, create, update, trash, restore, hold, purge, clone, reproject, reindex, publish, structure, variant, prune-revisions, legal-hold. Every subcommand, argument and flag.
    - [crm](/reference/cli/crm): engine-dmo crm: The CRM from the command line: organisations, memberships, duplicate candidates, invitations and claims. Every subcommand, argument and flag.
    - [describe](/reference/cli/describe): engine-dmo describe: Describe the project, a content type, the field types, a route or a template, with ids, as text or --json. Every subcommand, argument and flag.
    - [dev](/reference/cli/dev): engine-dmo dev: Local development: the serve, check and apply loop, and the authoring verbs. Every subcommand, argument and flag.
    - [docs](/reference/cli/docs): engine-dmo docs: The template API of this project, and the skill that points an agent at the handbook. Every subcommand, argument and flag.
    - [doctor](/reference/cli/doctor): engine-dmo doctor: The support bundle: one pasteable text file. Every subcommand, argument and flag.
    - [dpia](/reference/cli/dpia): engine-dmo dpia: Write a data protection impact assessment with every technical fact filled from engine.yaml and the bundle. Every subcommand, argument and flag.
    - [export](/reference/cli/export): engine-dmo export: Export a site's content for a static build: the content API's answers, or the embed widgets' fragments. Every subcommand, argument and flag.
    - [guide](/reference/cli/guide): engine-dmo guide: Working guidance for this project, generated from its schema, routes and the engine's template contract. Every subcommand, argument and flag.
    - [health](/reference/cli/health): engine-dmo health: Liveness and readiness against a running server, for a load balancer or a deploy step. Every subcommand, argument and flag.
    - [init](/reference/cli/init): engine-dmo init: Start a new project directory: a bare starter, or a copy of a project with --from; the files it writes, the guidance for coding agents, and what is and is not available outside a Meridian checkout. Every subcommand, argument and flag.
    - [jobs](/reference/cli/jobs): engine-dmo jobs: The job queue: list what waits, fails and died, and retry dead jobs. Every subcommand, argument and flag.
    - [lists](/reference/cli/lists): engine-dmo lists: Smart lists: check every saved query, count one, or run one to a file. Every subcommand, argument and flag.
    - [locale](/reference/cli/locale): engine-dmo locale: Locales: list, coverage, what has drifted, rebuild the staleness table, add a locale's drafts. Every subcommand, argument and flag.
    - [lsp](/reference/cli/lsp): engine-dmo lsp: The template language server over stdio, for an editor: engine-dmo check's diagnostics as you type, completion, hover and go to definition. Development only. Every subcommand, argument and flag.
    - [mail](/reference/cli/mail): engine-dmo mail: Transactional mail: status, a real test send, the templates, and the suppression list. Every subcommand, argument and flag.
    - [mcp](/reference/cli/mcp): engine-dmo mcp: Serve the content MCP over standard input and output as a staff user, for a coding agent in development (refused in production). Every subcommand, argument and flag.
    - [media](/reference/cli/media): engine-dmo media: The media library: its size and alt text coverage, and the image pipeline's resolved transforms. Every subcommand, argument and flag.
    - [migrate](/reference/cli/migrate): engine-dmo migrate: Database migrations: forward only, applied as an explicit deploy step. Every subcommand, argument and flag.
    - [new](/reference/cli/new): engine-dmo new: Scaffold a type, a template, a component or a block. Every subcommand, argument and flag.
    - [newsletter](/reference/cli/newsletter): engine-dmo newsletter: The newsletter's subscribers, campaigns and deliverability. Every subcommand, argument and flag.
    - [plugin](/reference/cli/plugin): engine-dmo plugin: The project's plugins: build them. Every subcommand, argument and flag.
    - [portal](/reference/cli/portal): engine-dmo portal: The member portal. Every subcommand, argument and flag.
    - [redirects](/reference/cli/redirects): engine-dmo redirects: The redirect rules table: list, import a CSV with a dry run, roll an import back. Every subcommand, argument and flag.
    - [render](/reference/cli/render): engine-dmo render: Render a public page through the real pipeline, in process; --json adds errors, queries, assets, accessibility findings and the image report. Every subcommand, argument and flag.
    - [sar](/reference/cli/sar): engine-dmo sar: A subject access request bundle: everything the install holds about the person an email address belongs to, as one archive. Every subcommand, argument and flag.
    - [schedule](/reference/cli/schedule): engine-dmo schedule: The scheduled tasks: list them with their last success, and run one now. Every subcommand, argument and flag.
    - [schema](/reference/cli/schema): engine-dmo schema: Plan and apply configuration against the database. Every subcommand, argument and flag.
    - [search](/reference/cli/search): engine-dmo search: The search index and the query log. Every subcommand, argument and flag.
    - [seed](/reference/cli/seed): engine-dmo seed: Seed sets: validated content with history, assets and generated analytics. Every subcommand, argument and flag.
    - [serve](/reference/cli/serve): engine-dmo serve: start the server (public sites, admin, portal, APIs, jobs and scheduled tasks in one process), its boot sequence, what it refuses, and its flags.
    - [site](/reference/cli/site): engine-dmo site: A site leaving the install: export it as a standalone install, then retire it here. Every subcommand, argument and flag.
    - [tags](/reference/cli/tags): engine-dmo tags: The tag vocabulary: import the seed, review candidates, promote, merge and reject. Every subcommand, argument and flag.
    - [telemetry](/reference/cli/telemetry): engine-dmo telemetry: Telemetry export and error reporting: send a test event. Every subcommand, argument and flag.
    - [template](/reference/cli/template): engine-dmo template: The template contract's tooling: the generated API and template tests. Every subcommand, argument and flag.
    - [translate](/reference/cli/translate): engine-dmo translate: Translation jobs, the glossary and the memory. Every subcommand, argument and flag.
    - [user](/reference/cli/user): engine-dmo user: Staff users and groups. Every subcommand, argument and flag.
    - [version](/reference/cli/version): engine-dmo version: Version, bundle and modules, commit, build date, Go version, image variant and what it can encode, contract versions. Every subcommand, argument and flag.
    - [warm](/reference/cli/warm): engine-dmo warm: After a deploy: repair the search index, queue image derivatives and warm the page cache, with each page's time. Every subcommand, argument and flag.
    - [webhooks](/reference/cli/webhooks): engine-dmo webhooks: The outbound webhook delivery log: deliveries, replay. Every subcommand, argument and flag.
  - Configuration
    - [Configuration](/reference/configuration): Every configuration file a Meridian project can have, where it lives, what it holds and which page lists its keys, plus how files are loaded, checked, given ids and validated in an editor.
    - [engine.yaml](/reference/configuration/engine): Every key of config/engine.yaml for the server, database, migrations, schema, templates, public files, logging, caches, storage, jobs, telemetry, retention, audit and extensions, with type, default and meaning; other sections are on their own pages.
    - [engine.yaml: authentication and the MCP](/reference/configuration/engine-auth): Every key of engine.yaml's auth section (local staff accounts, OpenID Connect single sign-on, staff and member sessions, member sign-in) and its mcp section (the remote content MCP endpoint, its clients, tokens and limits), with type, default and meaning.
    - [engine.yaml: content, media and search](/reference/configuration/engine-content): Every key of engine.yaml's content, media, events, tags, approvals, endpoints, forms, search, maps, admin and notifications sections, with type, default and meaning.
    - [engine.yaml: mail and newsletter](/reference/configuration/engine-mail): Every key of engine.yaml's mail section (the transactional mail driver for SMTP, Postmark, Amazon SES or Resend, bounce webhooks, templates, suppression and broadcast sending) and its newsletter section, with type, default and meaning.
    - [engine.yaml: analytics and AI](/reference/configuration/engine-analytics-ai): Every key of engine.yaml's analytics section (cookieless ingest, bot filtering, retention, reporting time zone, PDF reports), its ai section (provider, models, data boundary, budget, features, disclosure) and its translation section, with type, default and meaning.
    - [engine.yaml: DMO modules](/reference/configuration/engine-dmo): Every key of engine.yaml's claims section (ownership claim methods, signal weights, auto-approval) and membership section (renewal reminders), with type, default and meaning, and where the portal settings live.
    - [locales.yaml and strings](/reference/configuration/locales): Every key of config/locales.yaml (the install's locales with their time zone, currency, fallbacks, direction, calendar and sorting) and of config/strings/<locale>.yaml.
    - [networks.yaml and memberships.yaml](/reference/configuration/networks-and-memberships): Every key of config/networks.yaml (sites sharing organisations, people and partner accounts) and config/memberships.yaml (the membership tiers, engine-dmo).
    - [site.yaml](/reference/configuration/site): Every key of config/sites/<key>/site.yaml: the site name, hosts, country, time zone, locales and URL strategy, navigation slots, template roots, SEO and robots, accessibility statement, widgets, headless delivery, assets, mail sender and outbound links.
    - [routes.yaml](/reference/configuration/routes): Every key of config/sites/<key>/routes.yaml: routes with their URI patterns per locale, index pages, nesting, pagination, facets, feeds, calendars and landing pages, the home page, configuration redirects and special pages.
    - [endpoints.yaml](/reference/configuration/endpoints): Every top-level key of config/sites/<key>/endpoints.yaml: declared endpoints with their path, methods, access, rate limit, spam controls, inputs, validation, steps and response.
    - [plugins.yaml](/reference/configuration/plugins): Every key of config/sites/<key>/plugins.yaml: the process plugins an endpoint step calls, with their command, pinned digest, environment, granted handlers and containment.
    - [promotions.yaml](/reference/configuration/promotions): Every key of config/sites/<key>/promotions.yaml (engine-dmo): paid promotion slots with their types, capacity, booking length, lead time, eligible tiers and prices, and the promoted label.
    - [images.yaml](/reference/configuration/images): Every key of config/images.yaml (breakpoints, image defaults and named transforms) and config/sites/<key>/images.yaml.
    - [Schema files](/reference/configuration/schema): Every key of a content type file (config/schema/<type>.yaml), of a field definition, and of the shared field groups (schema/_shared.yaml), shared blocks (blocks/_index.yaml) and CRM and enquiry custom field files that use the same field grammar.
    - [access/roles.yaml and grants.yaml](/reference/configuration/access): Every key of config/access/roles.yaml (staff roles and their permissions) and config/access/grants.yaml (roles granted to staff groups under a scope).
    - [Portal files](/reference/configuration/portal): Every key of config/portal/portal.yaml (the member portal's install defaults, member report rules and invitation timings), config/sites/<key>/portal.yaml (a site's portal, screens and actions) and config/portal/roles.yaml (partner roles), all engine-dmo.
    - [paidlistings.yaml](/reference/configuration/paidlistings): Every key of config/paidlistings.yaml (engine-dmo), the paid listings payment provider (Stripe or none) with its secrets, and each site's tier prices and how promotions are paid.
    - [analytics/reports.yaml and dashboards.yaml](/reference/configuration/analytics): Every key of config/analytics/reports.yaml (scheduled member and organisation reports) and config/analytics/dashboards.yaml (organisation dashboards and manually entered figures).
    - [accessibility.yaml](/reference/configuration/accessibility): Every key of config/accessibility.yaml, the known accessibility issues register the statement and conformance report read.
    - [AI prompt overrides](/reference/configuration/ai-prompts): Every key of an AI prompt override file in config/ai/prompts/<key>.yaml.
    - [Seed files](/reference/configuration/seed-files): Every key of config/search/synonyms.yaml, config/tags/vocabulary.yaml and config/tags/smartlists.yaml, the files commands import into the database, and of the seed/organisations and seed/people records.
  - [Template API](/reference/template-api): How to get the complete, generated template surface for your own project (every global, filter, tag, field type, your types and fields, routes and components) from engine-dmo template api, docs serve, describe and guide.
  - [Environment variables](/reference/environment-variables): Which environment variables the engine reads directly (very few), the conventional names a project's engine.yaml interpolates, the variables commands read secrets from, and the variables the engine sets for child processes.
  - [Exit codes](/reference/exit-codes): The five exit codes every engine-dmo and engine-cms command uses (0 success, 1 error, 2 pending or unconfirmed, 3 invalid configuration, 4 degraded), and which commands return 2 and 4 and why.
  - [Error codes](/reference/error-codes): Every stable MRD error code the engine reports, with its cause and its fix.
- For agents
  - [For agents](/agents): Start here if you are a coding agent building or changing a Meridian website. What Meridian is, the golden rules, how to read the rest of the handbook from the binary, and the change, check, render loop.
  - [Rules](/agents/rules): Every rule a coding agent must follow in a Meridian project, why it exists and exactly what breaks when it is ignored, covering configuration, ids, secrets, schema changes, content, templates, accessibility, generated files and production.
  - [Workflow: from a brief to a running site](/agents/workflow): The order of work for a coding agent turning a written brief into a working, accessible, deployable Meridian site, step by step, with the exact command for each step and how to verify it before moving on.
  - [Commands for agents](/agents/commands): The engine commands a coding agent uses to read, change and verify a Meridian project (describe, guide, docs, help --json, the dev verbs, check, schema plan and apply, render --json, a11y audit, content, seed and mcp), what each returns, what it needs and when to use it.
  - Recipes
    - [Recipes](/agents/recipes): Complete, checked examples of the tasks an agent meets most when building a Meridian site, from adding a content type to a DMO directory, a partner portal and an extension, each with the commands, the files and how to verify them.
    - [Add a content type](/agents/recipes/add-a-content-type): How an agent adds a custom content type to a Meridian project with dev type add and dev field add, what the generated schema file holds, and how to verify the type is applied and has an id for every field.
    - [Add a field](/agents/recipes/add-a-field): How an agent adds, labels, changes, renames and removes fields on custom and core Meridian types, including select options with labels, relations and boolean filters, with the commands, the YAML they write and the pitfalls of each verb.
    - [Add a route and its template](/agents/recipes/add-a-route): How an agent gives a content type addresses on a site with dev route add, writes the entry and index templates a route needs, and verifies them with describe route and render.
    - [Listing page with filters and pagination](/agents/recipes/listing-page): How an agent builds a type's index page in Meridian with route facets for filtering, a translated result count, cards and an accessible pager, and verifies the first, last and filtered pages with render.
    - [Navigation menu](/agents/recipes/navigation-menu): How an agent adds header and footer menus to a Meridian site with navigation slots in site.yaml, a seeded navigation set and the nav tag in the layout, marking the current page and hiding an empty menu.
    - [Responsive images](/agents/recipes/responsive-images): How an agent declares image transforms in config/images.yaml, prints asset fields with img(), picture() and figure() so every image has srcset, sizes, dimensions, alt text and its credit, seeds real photographs, and reads the image report from render.
    - [Enquiry form](/agents/recipes/enquiry-form): How an agent adds a contact form or a form about one listing to a Meridian site with dev endpoint add, writes the response, error and email templates the endpoint names, places the form on a page, and verifies it with check, render and a scripted post.
    - [Multilingual site](/agents/recipes/multilingual-site): How an agent adds a second locale to a Meridian site with dev locale add, gives routes per-locale paths, translates interface strings and labels, seeds translated documents, adds a language switcher and verifies hreflang and the translated pages.
    - [Search page](/agents/recipes/search-page): How an agent adds a search page to a Meridian site with the special search route and search.html, what browse mode returns without a search service, how to connect one, and how to verify the page renders and is accessible.
    - [DMO directory](/agents/recipes/dmo-directory): How an agent builds a destination directory on engine-dmo, extending the core listing and area types, loading the tag vocabulary, routing areas beside pages at /{slug}, filtering by place facets, printing structured data, seeding complete listings with hours, address and phone, and verifying it all.
    - [Partner portal](/agents/recipes/partner-portal): How an agent sets up the member portal on engine-dmo for partner businesses, declaring membership tiers, the member_editable rules that say what each tier may change, an extra portal screen, an organisation with a membership and an invitation, and how to verify each part.
    - [Landing pages](/agents/recipes/landing-pages): How an agent declares place-and-category landing pages on an engine-dmo listing route, what makes a page live, the optional landing template, and how to verify the configuration and the pages.
    - [Claims](/agents/recipes/claims): How an agent lets a business claim its listing on engine-dmo, seeding an organisation for each listing, writing the claim link that has no helper, reading the verification mail, and verifying the form from a script.
    - [Extension](/agents/recipes/extension): When an agent should write a Meridian extension (a Go plugin adding template filters, globals, routes or commands), the minimal filter extension, how it must be built to load, how to name it in engine.yaml and how to verify it.
  - [Troubleshooting](/agents/troubleshooting): The errors a coding agent meets in a Meridian project (from check, the dev verbs, schema plan and apply, seed, render, the accessibility audit and server start), what each message means and the exact fix, with the MRD error codes.
  - [Checklists](/agents/checklists): What done means for a coding agent handing a Meridian site back, as checklists with the command that proves each item, covering the project check, every route rendering, accessibility, content, SEO, performance, deploy configuration and secrets.
  - [The project skill and AGENTS.md](/agents/project-skill): The agent guidance files a Meridian project keeps (AGENTS.md, the meridian-project skill and the meridian skill), what writes and regenerates each, and the exact short section to paste into an AGENTS.md or skill a project already has.