@hollware/core 0.0.1 → 0.1.0

package/dist/index.d.mts

@@ -1,3 +1,2032 @@
+import * as z from "zod";
+import { MarkdownDocument } from "comark";
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/markdown/types.d.ts
+/**
+ * The shapes of the Markdown pipeline: Markdown in, the Comark document and what the contracts
+ * need out (ADR-001, ADR-020). The Markdown is the source of truth; everything here is derived
+ * from it and can be derived again by `reparse`.
+ */
+/**
+ * The Comark document of a revision, as Hollware stores it and hands it to sites: a site renders
+ * it with the Comark renderer of its framework, without parsing anything.
+ */
+type EntryDocument = MarkdownDocument;
+interface Heading {
+  readonly depth: 1 | 2 | 3 | 4 | 5 | 6;
+  readonly text: string;
+  /** Hollware's own heading id, which keeps letters outside ASCII (ADR-020). */
+  readonly id: string;
+  readonly line?: number;
+}
+/** The entry an internal link names. */
+interface LinkTarget {
+  readonly collection: string;
+  readonly locale: string;
+  readonly slug: string;
+}
+/**
+ * A link of the body, by where it points:
+ * - `internal`: a path that matches a route of a collection of the site, so it names an entry;
+ * - `site`: any other path of the site, such as `/about/`;
+ * - `anchor`: `#section`, within the same entry;
+ * - `external`: an `http:`, `https:` or `mailto:` URL.
+ *
+ * A URL with any other scheme, such as `javascript:`, is no link: it is reported in `disallowed`.
+ */
+interface LinkRef {
+  readonly href: string;
+  readonly kind: 'internal' | 'site' | 'anchor' | 'external';
+  /** For an `internal` link, the entry it names. */
+  readonly target?: LinkTarget;
+  readonly line?: number;
+}
+interface ImageRef {
+  readonly src: string;
+  /** The alternative text; `''` when it is missing or empty, which Comark does not tell apart. */
+  readonly alt: string;
+  readonly line?: number;
+}
+/** A component the body uses, with the props it was given. */
+interface ComponentUse {
+  readonly name: string;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly line?: number;
+}
+/**
+ * Something the pipeline did not let through: the parser leaves a marker in its place, and the
+ * content-safety contracts report it (ADR-020). Nothing is dropped silently.
+ */
+interface DisallowedMarker {
+  readonly kind: 'raw-html' | 'unknown-component' | 'disallowed-attribute' | 'unsafe-url';
+  /** The tag, component, attribute or URL. */
+  readonly name: string;
+  readonly line?: number;
+}
+/** What the pipeline finds in the body, for the contracts and the derived columns. */
+interface ExtractedContent {
+  readonly headings: readonly Heading[];
+  readonly links: readonly LinkRef[];
+  readonly images: readonly ImageRef[];
+  readonly components: readonly ComponentUse[];
+  /** The words of the body, which `word_count` stores. */
+  readonly words: number;
+  readonly disallowed: readonly DisallowedMarker[];
+}
+/** A Markdown file the pipeline could parse. */
+interface ProcessedMarkdown {
+  /** The frontmatter as YAML gave it, before the collection's schema looked at it. */
+  readonly frontmatter: Readonly<Record<string, unknown>>;
+  readonly document: EntryDocument;
+  readonly extracted: ExtractedContent;
+  /** The version of Comark that parsed it, stored as `comark_version`. */
+  readonly comarkVersion: string;
+  /**
+   * The version of Hollware's pipeline settings (plugins, allowlists, heading ids), stored as
+   * `pipeline_version`. It changes whenever the same Markdown would give another document.
+   */
+  readonly pipelineVersion: string;
+}
+interface ProcessMarkdownOptions {
+  /** The components the collection allows; the pipeline marks any other. */
+  readonly components: readonly string[];
+  /** The largest file accepted, in UTF-8 bytes. */
+  readonly maxMarkdownBytes: number;
+  /** The routes of the site's collections, by collection and then by locale, to find internal links. */
+  readonly routes: Readonly<Record<string, Readonly<Record<string, string>>>>;
+}
+/**
+ * The pipeline's answer. A file it cannot store, because it is too large or its frontmatter or
+ * syntax does not parse, comes back as violations (`size-limit`, `frontmatter-syntax`,
+ * `comark-parse`), which make the write `refused`.
+ */
+type ProcessResult = {
+  readonly ok: true;
+  readonly value: ProcessedMarkdown;
+} | {
+  readonly ok: false;
+  readonly violations: readonly Violation[];
+};
+/** Processes a Markdown file. It answers for any string and never throws. */
+type ProcessMarkdown = (markdown: string, options: ProcessMarkdownOptions) => Promise<ProcessResult>;
+/** Renders a stored document to HTML that holds no raw HTML. */
+type RenderHtml = (document: EntryDocument) => Promise<string>;
+//#endregion
+//#region src/contracts/types.d.ts
+/**
+ * The shapes of the contracts (ADR-004): what a contract looks at, what it reports, and the
+ * verdict of a revision. Contract errors never block a draft; they block publishing.
+ */
+type Severity = 'error' | 'warning';
+/**
+ * When contracts run. `write`: on every `create_draft` and `update_draft`. `publish`: on
+ * `validate` and `publish`, where the rules that depend on other entries (links, translation
+ * pairs) are checked against the site as it is at that moment.
+ */
+type Phase = 'write' | 'publish';
+/** One problem a contract found. */
+interface Violation {
+  /** The id of the contract: `schema`, `translation-pair`, `seo-title-length`… */
+  readonly contract: string;
+  readonly severity: Severity;
+  /**
+   * A JSON Pointer into the entry seen as `{ frontmatter, body }`: `/frontmatter/description`,
+   * or `/body` for the Markdown body (with `line`).
+   */
+  readonly path: string;
+  /** What is wrong, for the agent. */
+  readonly message: string;
+  /** What to change so that the problem goes away, for the agent. Never empty. */
+  readonly fix: string;
+  /** The line of the Markdown file, from 1, when the problem has one. */
+  readonly line?: number;
+}
+/** The result of running the contracts of a collection on one revision. */
+interface Verdict {
+  /** No errors; warnings do not count. */
+  readonly ok: boolean;
+  readonly phase: Phase;
+  readonly errors: readonly Violation[];
+  readonly warnings: readonly Violation[];
+  /**
+   * A hash of what the revision was checked against: the collection's schema, its components
+   * and the ids, severities and phases of its contracts. A stored verdict says which rules it
+   * answered to.
+   */
+  readonly contractsHash: string;
+}
+/** A warning the caller acknowledged to publish, as `publish` takes and `publications` records. */
+interface AcknowledgedWarning {
+  readonly contract: string;
+  readonly path: string;
+}
+/** An entry of the site, by its natural key. */
+interface EntryRef {
+  readonly collection: string;
+  readonly locale: string;
+  readonly slug: string;
+}
+/** What a lookup tells about an entry. */
+interface EntryFacts {
+  readonly id: string;
+  readonly status: 'draft' | 'scheduled' | 'published';
+  readonly translationGroup: string | null;
+}
+/**
+ * How contracts read the other entries of the same site. The server implements it on D1, in
+ * chunks that stay under D1's 100 bound parameters per statement.
+ */
+interface EntryLookup {
+  /** The entry for each ref, in the order of `refs`; `null` where there is none. */
+  lookupMany(refs: readonly EntryRef[]): Promise<readonly (EntryFacts | null)[]>;
+  /** Every entry of a translation group of a collection, one per locale. */
+  translations(collection: string, translationGroup: string): Promise<readonly (EntryRef & EntryFacts)[]>;
+}
+/** What a contract looks at. */
+interface ContractContext<Frontmatter = Record<string, unknown>> {
+  readonly site: string;
+  readonly collection: string;
+  readonly locale: string;
+  readonly slug: string;
+  /** The entry's id, or `null` while the entry is being created. */
+  readonly entryId: string | null;
+  readonly phase: Phase;
+  /**
+   * The frontmatter as the collection's schema returned it. A contract runs only when the
+   * schema accepted the frontmatter; otherwise the schema's own violations stand alone.
+   */
+  readonly frontmatter: Frontmatter;
+  /** What the Markdown pipeline made of the file. */
+  readonly markdown: ProcessedMarkdown;
+  /** The other entries of the site. */
+  readonly entries: EntryLookup;
+}
+/** A problem a contract reports; Hollware adds the contract's id and severity. */
+interface ContractFinding {
+  readonly path: string;
+  readonly message: string;
+  readonly fix: string;
+  readonly line?: number;
+}
+/** A rule with an id, a severity and a fix for every problem it finds (ADR-004). */
+interface Contract<Frontmatter = Record<string, unknown>> {
+  /** Lowercase words joined by hyphens, unique within the collection: `seo-title-length`. */
+  readonly id: string;
+  readonly severity: Severity;
+  /** The phases it runs in; both when absent. A rule that reads other entries runs on `publish`. */
+  readonly phases?: readonly Phase[];
+  /** What the rule asks for, as `describe_site` shows it to agents. */
+  readonly description: string;
+  /** The problems it finds; an empty list passes. */
+  check(context: ContractContext<Frontmatter>): readonly ContractFinding[] | Promise<readonly ContractFinding[]>;
+}
+//#endregion
+//#region src/config/types.d.ts
+/**
+ * The shapes of `hollware.config.ts`. The config holds the sites of the deployment, and each site
+ * its collections; `describe_site` shows all of it to agents.
+ */
+/**
+ * A schema Hollware can validate with and show to agents: a Standard Schema that also converts to
+ * JSON Schema. Zod 4.2 or later is one; any other library that implements both works too.
+ */
+type DescribedSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
+/** What a schema returns once it accepts a value. */
+type SchemaOutput<Schema extends DescribedSchema> = StandardSchemaV1.InferOutput<Schema>;
+/** A component an entry may use in its body, such as `::callout{type="tip"}`. */
+interface ComponentDefinition {
+  /** Validates the props. It should reject unknown keys (ADR-020). */
+  readonly props: DescribedSchema;
+  /** What the component is for, as `describe_site` shows it. */
+  readonly description?: string;
+  /** An example of its use in Markdown, as `describe_site` shows it. */
+  readonly example?: string;
+}
+/**
+ * A kind of entry of a site: a blog, docs pages, talks. It is generic over its schema, so that
+ * its contracts see the frontmatter the schema returns.
+ */
+interface CollectionDefinition<Schema extends DescribedSchema = DescribedSchema> {
+  /** The frontmatter every entry must have; `describe_site` shows it as JSON Schema. */
+  readonly schema: Schema;
+  /**
+   * The public path of an entry in each locale of the site, with `:slug`:
+   * `{ es: '/blog/:slug/', en: '/en/blog/:slug/' }`. Links that match one are internal links.
+   */
+  readonly routes: Readonly<Record<string, string>>;
+  /**
+   * Translations: the frontmatter field that holds the key the translations of an entry share.
+   * Without it, the entries of the collection have no translations.
+   */
+  readonly translations?: {
+    readonly groupBy: string;
+  };
+  /** The frontmatter field that holds the entry's tags, an array of strings. */
+  readonly tags?: string;
+  /**
+   * The frontmatter field, an ISO 8601 date, that orders the published entries in listings,
+   * newest first. Without it, they follow the date of their first publication.
+   */
+  readonly sortBy?: string;
+  /** The components the body may use. Any other component is an error (ADR-020). */
+  readonly components?: Readonly<Record<string, ComponentDefinition>>;
+  /**
+   * Rules of the collection. The schema, the components, content safety and the size limit are
+   * checked anyway.
+   */
+  readonly contracts?: readonly Contract<SchemaOutput<Schema>>[];
+  /** The largest Markdown file accepted, in UTF-8 bytes. 512 KiB when absent. */
+  readonly maxMarkdownBytes?: number;
+  /** Guidance for whoever writes in this collection, in Markdown. */
+  readonly styleGuide?: string;
+}
+/** A site of the deployment. */
+interface SiteDefinition {
+  /** Its locales, such as `['es', 'en']`. */
+  readonly locales: readonly [string, ...string[]];
+  readonly defaultLocale: string;
+  readonly collections: Readonly<Record<string, CollectionDefinition>>;
+  /** Guidance for whoever writes anywhere in the site, in Markdown. */
+  readonly styleGuide?: string;
+}
+/** What `hollware.config.ts` exports. */
+interface HollwareConfig {
+  /**
+   * The sites, by key. The key is the site's id in the database, so it never changes once
+   * content exists. v0.1 serves exactly one site per deployment.
+   */
+  readonly sites: Readonly<Record<string, SiteDefinition>>;
+}
+/** A collection once the config is resolved: checked, with every default filled in. */
+interface ResolvedCollection {
+  readonly name: string;
+  readonly schema: DescribedSchema;
+  readonly routes: Readonly<Record<string, string>>;
+  readonly translationGroupField: string | null;
+  readonly tagsField: string | null;
+  readonly sortByField: string | null;
+  readonly components: ReadonlyMap<string, ComponentDefinition>;
+  /** The contracts of the collection; the built-in ones run besides them. */
+  readonly contracts: readonly Contract<unknown>[];
+  readonly maxMarkdownBytes: number;
+  readonly styleGuide: string | null;
+}
+/** A site once the config is resolved. */
+interface ResolvedSite {
+  readonly key: string;
+  readonly locales: readonly string[];
+  readonly defaultLocale: string;
+  readonly styleGuide: string | null;
+  readonly collections: ReadonlyMap<string, ResolvedCollection>;
+}
+/** The config once resolved, at the start of the Worker. v0.1 holds exactly one site. */
+interface ResolvedConfig {
+  readonly sites: ReadonlyMap<string, ResolvedSite>;
+}
+/**
+ * Checks a config and fills in its defaults. It throws one error that lists every problem, each
+ * with its fix, so that a broken config stops the Worker at startup with an actionable message.
+ */
+type ResolveConfig = (config: HollwareConfig) => ResolvedConfig;
+//#endregion
+//#region src/config/define.d.ts
+/**
+ * The `define*` helpers only give the config its types: the frontmatter type of a collection
+ * flows from its schema into its contracts. Validating the config is the job of the config
+ * module, when the Worker starts.
+ */
+/** Declares the config of a deployment: what `hollware.config.ts` exports. */
+export declare function defineConfig(config: HollwareConfig): HollwareConfig;
+/** Declares a collection. Its contracts see the frontmatter that its schema returns. */
+export declare function defineCollection<const Schema extends DescribedSchema>(collection: CollectionDefinition<Schema>): CollectionDefinition<Schema>;
+/** Declares a component that entries may use in their body. */
+export declare function defineComponent(component: ComponentDefinition): ComponentDefinition;
+/**
+ * Declares a contract shared by several collections, with the frontmatter type it reads given
+ * explicitly: `defineContract<{ title: string }>({ … })`. Inside `defineCollection`, write a
+ * contract as a plain object instead: its `check` gets the frontmatter type of the schema there,
+ * which a generic call inside the array would lose.
+ */
+export declare function defineContract<Frontmatter = Record<string, unknown>>(contract: Contract<Frontmatter>): Contract<Frontmatter>;
+//#endregion
+//#region src/config/config-error.d.ts
+/** One thing wrong with the config, found by `resolveConfig`. */
+interface ConfigProblem {
+  /** Where it is, from the root of the config: `sites.playground.collections.blog.routes`. */
+  readonly path: string;
+  /** What is wrong, as a sentence without its final period. */
+  readonly message: string;
+  /** What to change, as a sentence with its final period. */
+  readonly fix: string;
+}
+/**
+ * The error `resolveConfig` throws: every problem of the config at once, so that a broken
+ * `hollware.config.ts` stops the Worker at startup with a message that says what to change. The
+ * message has one line per problem, `<path>: <message>. <fix>`, and `problems` holds them as data.
+ */
+export declare class ConfigError extends Error {
+  readonly name = "ConfigError";
+  readonly problems: readonly ConfigProblem[];
+  constructor(problems: readonly ConfigProblem[]);
+}
+//#endregion
+//#region src/config/constants.d.ts
+/** The largest Markdown file a collection accepts when its config does not say, 512 KiB. */
+export declare const DEFAULT_MAX_MARKDOWN_BYTES = 524288;
+/**
+ * The largest `maxMarkdownBytes` a collection may set, 768 KiB. A revision row holds the Markdown,
+ * the frontmatter and the Comark document, which is about 1.3 times the Markdown, so a row is
+ * about 2.3 times the file, and the store refuses rows over 1.9 MB: a file over about 800 KB could
+ * never be saved. 768 KiB keeps a margin.
+ */
+export declare const MAX_MARKDOWN_BYTES_CEILING = 786432;
+declare namespace schemas_d_exports {
+  export { acknowledgedWarning, collectionDescription, collectionName, componentDescription, conflict, contractDescription, document, entry, entryId, entryStatus, entrySummary, format, locale, markdown, phase, publication, revisionId, severity, siteDescription, slug, verdict, version, violation };
+}
+/**
+ * The pieces the operation schemas share. Their descriptions become the JSON Schema that agents
+ * read over MCP, so they are written for the agent.
+ */
+declare const collectionName: z.ZodString;
+declare const locale: z.ZodString;
+declare const slug: z.ZodString;
+declare const entryId: z.ZodString;
+declare const revisionId: z.ZodString;
+declare const version: z.ZodNumber;
+declare const markdown: z.ZodString;
+declare const entryStatus: z.ZodEnum<{
+  draft: "draft";
+  published: "published";
+  scheduled: "scheduled";
+}>;
+declare const severity: z.ZodEnum<{
+  error: "error";
+  warning: "warning";
+}>;
+declare const phase: z.ZodEnum<{
+  publish: "publish";
+  write: "write";
+}>;
+declare const violation: z.ZodObject<{
+  contract: z.ZodString;
+  severity: z.ZodEnum<{
+    error: "error";
+    warning: "warning";
+  }>;
+  path: z.ZodString;
+  message: z.ZodString;
+  fix: z.ZodString;
+  line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const verdict: z.ZodObject<{
+  ok: z.ZodBoolean;
+  phase: z.ZodEnum<{
+    publish: "publish";
+    write: "write";
+  }>;
+  errors: z.ZodArray<z.ZodObject<{
+    contract: z.ZodString;
+    severity: z.ZodEnum<{
+      error: "error";
+      warning: "warning";
+    }>;
+    path: z.ZodString;
+    message: z.ZodString;
+    fix: z.ZodString;
+    line: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  warnings: z.ZodArray<z.ZodObject<{
+    contract: z.ZodString;
+    severity: z.ZodEnum<{
+      error: "error";
+      warning: "warning";
+    }>;
+    path: z.ZodString;
+    message: z.ZodString;
+    fix: z.ZodString;
+    line: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  contractsHash: z.ZodString;
+}, z.core.$strip>;
+declare const acknowledgedWarning: z.ZodObject<{
+  contract: z.ZodString;
+  path: z.ZodString;
+}, z.core.$strip>;
+declare const entrySummary: z.ZodObject<{
+  id: z.ZodString;
+  collection: z.ZodString;
+  locale: z.ZodString;
+  slug: z.ZodString;
+  translationGroup: z.ZodNullable<z.ZodString>;
+  status: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    scheduled: "scheduled";
+  }>;
+  version: z.ZodNumber;
+  frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  tags: z.ZodArray<z.ZodString>;
+  hasUnpublishedChanges: z.ZodBoolean;
+  publishedAt: z.ZodNullable<z.ZodString>;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+declare const publication: z.ZodObject<{
+  revision: z.ZodString;
+  verdict: z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>;
+  acknowledged: z.ZodArray<z.ZodObject<{
+    contract: z.ZodString;
+    path: z.ZodString;
+  }, z.core.$strip>>;
+  at: z.ZodString;
+}, z.core.$strip>;
+/** The Comark document of a revision: what a site's renderer takes. */
+declare const document: z.ZodObject<{
+  nodes: z.ZodArray<z.ZodUnknown>;
+  frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  meta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+declare const entry: z.ZodObject<{
+  id: z.ZodString;
+  collection: z.ZodString;
+  locale: z.ZodString;
+  slug: z.ZodString;
+  translationGroup: z.ZodNullable<z.ZodString>;
+  status: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    scheduled: "scheduled";
+  }>;
+  version: z.ZodNumber;
+  frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  tags: z.ZodArray<z.ZodString>;
+  hasUnpublishedChanges: z.ZodBoolean;
+  publishedAt: z.ZodNullable<z.ZodString>;
+  updatedAt: z.ZodString;
+  revision: z.ZodString;
+  verdict: z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>;
+  lastPublication: z.ZodNullable<z.ZodObject<{
+    revision: z.ZodString;
+    verdict: z.ZodObject<{
+      ok: z.ZodBoolean;
+      phase: z.ZodEnum<{
+        publish: "publish";
+        write: "write";
+      }>;
+      errors: z.ZodArray<z.ZodObject<{
+        contract: z.ZodString;
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        fix: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+      warnings: z.ZodArray<z.ZodObject<{
+        contract: z.ZodString;
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        fix: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+      contractsHash: z.ZodString;
+    }, z.core.$strip>;
+    acknowledged: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      path: z.ZodString;
+    }, z.core.$strip>>;
+    at: z.ZodString;
+  }, z.core.$strip>>;
+  markdown: z.ZodOptional<z.ZodString>;
+  document: z.ZodOptional<z.ZodObject<{
+    nodes: z.ZodArray<z.ZodUnknown>;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    meta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  }, z.core.$strip>>;
+  html: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const conflict: z.ZodObject<{
+  currentVersion: z.ZodNumber;
+  headRevision: z.ZodString;
+}, z.core.$strip>;
+declare const format: z.ZodEnum<{
+  document: "document";
+  html: "html";
+  markdown: "markdown";
+}>;
+declare const componentDescription: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodNullable<z.ZodString>;
+  example: z.ZodNullable<z.ZodString>;
+  props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+declare const contractDescription: z.ZodObject<{
+  id: z.ZodString;
+  severity: z.ZodEnum<{
+    error: "error";
+    warning: "warning";
+  }>;
+  phases: z.ZodArray<z.ZodEnum<{
+    publish: "publish";
+    write: "write";
+  }>>;
+  description: z.ZodString;
+}, z.core.$strip>;
+declare const collectionDescription: z.ZodObject<{
+  name: z.ZodString;
+  schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  routes: z.ZodRecord<z.ZodString, z.ZodString>;
+  translationGroupField: z.ZodNullable<z.ZodString>;
+  tagsField: z.ZodNullable<z.ZodString>;
+  sortByField: z.ZodNullable<z.ZodString>;
+  components: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    example: z.ZodNullable<z.ZodString>;
+    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  }, z.core.$strip>>;
+  contracts: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodEnum<{
+      error: "error";
+      warning: "warning";
+    }>;
+    phases: z.ZodArray<z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>>;
+    description: z.ZodString;
+  }, z.core.$strip>>;
+  maxMarkdownBytes: z.ZodNumber;
+  styleGuide: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const siteDescription: z.ZodObject<{
+  key: z.ZodString;
+  locales: z.ZodArray<z.ZodString>;
+  defaultLocale: z.ZodString;
+  styleGuide: z.ZodNullable<z.ZodString>;
+  collections: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    translationGroupField: z.ZodNullable<z.ZodString>;
+    tagsField: z.ZodNullable<z.ZodString>;
+    sortByField: z.ZodNullable<z.ZodString>;
+    components: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      description: z.ZodNullable<z.ZodString>;
+      example: z.ZodNullable<z.ZodString>;
+      props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    contracts: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      phases: z.ZodArray<z.ZodEnum<{
+        publish: "publish";
+        write: "write";
+      }>>;
+      description: z.ZodString;
+    }, z.core.$strip>>;
+    maxMarkdownBytes: z.ZodNumber;
+    styleGuide: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+//#endregion
+//#region src/contracts/description.d.ts
+/** What `describe_site` shows of a contract. */
+type ContractDescription = z.output<typeof contractDescription>;
+/** A contract as `describe_site` shows it to agents. */
+export declare function describeContract(contract: Pick<Contract<unknown>, 'id' | 'severity' | 'phases' | 'description'>): ContractDescription;
+//#endregion
+//#region src/contracts/builtin.d.ts
+/**
+ * Every id Hollware's own contracts use. The config module reserves them: a contract of a site
+ * cannot take one, except through `contracts.*`, which makes the opt-in ones.
+ *
+ * - Always on, run by `runContracts`: `schema`, `components` and the four content-safety
+ *   contracts, `raw-html`, `unknown-component`, `disallowed-attribute` and `unsafe-url`.
+ * - Opt-in, listed in a collection's `contracts`: `translation-pair`, `internal-links-resolve`
+ *   and `images-have-alt`.
+ * - Always on, found before the contracts run: `size-limit` (made by the pipeline for
+ *   `maxMarkdownBytes` and by the store for the row, with `sizeLimitViolation`),
+ *   `frontmatter-syntax` and `comark-parse` (made by the pipeline), and `unique-slug` and
+ *   `unique-translation` (made when the store finds the slug or the translation group taken). A
+ *   write with one of them is `refused`, so no verdict is made for it: they are
+ *   `REFUSAL_CONTRACT_IDS`.
+ */
+export declare const BUILT_IN_CONTRACT_IDS: readonly ['schema', 'components', 'raw-html', 'unknown-component', 'disallowed-attribute', 'unsafe-url', 'translation-pair', 'internal-links-resolve', 'images-have-alt', 'size-limit', 'frontmatter-syntax', 'comark-parse', 'unique-slug', 'unique-translation'];
+type BuiltInContractId = (typeof BUILT_IN_CONTRACT_IDS)[number];
+/**
+ * The ids of the violations that make a write `refused` instead of saving it: a file that cannot
+ * be stored, because it is over a size limit, its frontmatter is not YAML or its Markdown does not
+ * parse, or whose slug or translation group another entry holds. Every other violation is saved with the draft and only blocks publishing (ADR-004,
+ * ADR-020). Plain strings, so that a violation's `contract` can be looked up in the list.
+ */
+export declare const REFUSAL_CONTRACT_IDS: readonly string[];
+/**
+ * The always-on contracts as `describe_site` shows them, in `BUILT_IN_CONTRACT_IDS` order. The
+ * opt-in ones are not here: a collection that uses one lists it in its own `contracts`.
+ */
+export declare function describeBuiltInContracts(): ContractDescription[];
+//#endregion
+//#region src/contracts/opt-in.d.ts
+/**
+ * The built-in contracts a collection opts into by listing them in its `contracts`, and the
+ * factory for its own: `contracts.translationPair()`, `contracts.internalLinksResolve()`,
+ * `contracts.imagesHaveAlt()` and `contracts.custom({ … })`.
+ */
+interface BuiltInOptions {
+  /** `error` unless given: an error blocks publishing, a warning has to be acknowledged. */
+  readonly severity?: Severity;
+}
+/**
+ * Every locale of the site has an entry in the translation group of this one. It reads the group
+ * from the frontmatter field the collection names in `translations.groupBy`, and counts an entry
+ * in any status, so the pair can be published one after the other. Checked when publishing, and
+ * skipped when the collection has no translations.
+ */
+declare function translationPair(options?: BuiltInOptions): Contract<unknown>;
+/**
+ * Every link to another entry of the site points at an entry that is published, or at the entry
+ * itself. All the targets are looked up in one call to `lookupMany`, and none when the body has no
+ * link to another entry. Checked when publishing.
+ */
+declare function internalLinksResolve(options?: BuiltInOptions): Contract<unknown>;
+/** Every image has alt text. An alt of only spaces counts as none. Checked on every write. */
+declare function imagesHaveAlt(options?: BuiltInOptions): Contract<unknown>;
+/** A text that may depend on the entry: `The title has ${frontmatter.title.length} characters.` */
+type ContractText<Frontmatter> = string | ((context: ContractContext<Frontmatter>) => string);
+interface CustomContractOptions<Frontmatter> {
+  /** Lowercase words joined by hyphens, unique within the collection: `seo-title-length`. */
+  readonly id: string;
+  readonly severity: Severity;
+  /** What the rule asks for, as `describe_site` shows it to agents. */
+  readonly description: string;
+  /** The phases it runs in; both when absent. */
+  readonly phases?: readonly Phase[];
+  /** Whether the entry follows the rule: `true` passes, `false` reports the problem. */
+  check(context: ContractContext<Frontmatter>): boolean | Promise<boolean>;
+  /** What is wrong, for the agent. */
+  readonly message: ContractText<Frontmatter>;
+  /** What to change so that the problem goes away, for the agent. Never empty. */
+  readonly fix: ContractText<Frontmatter>;
+  /** A JSON Pointer into `{ frontmatter, body }`: `/frontmatter/title`. The whole entry (`''`) when absent. */
+  readonly path?: string;
+}
+/**
+ * A contract of a site made of a yes or no question and the words to say when the answer is no.
+ * One finding at most: a rule that reports several problems, or the line they are on, is a plain
+ * `Contract` object, which can return as many findings as it wants.
+ *
+ * Inside `defineCollection`, TypeScript cannot infer the frontmatter type of a call like this one
+ * (it can for a plain object): give it, as in `contracts.custom<{ title: string }>({ … })`.
+ */
+declare function custom<Frontmatter = Record<string, unknown>>(options: CustomContractOptions<Frontmatter>): Contract<Frontmatter>;
+export declare const contracts: {
+  readonly custom: typeof custom;
+  readonly imagesHaveAlt: typeof imagesHaveAlt;
+  readonly internalLinksResolve: typeof internalLinksResolve;
+  readonly translationPair: typeof translationPair;
+};
+//#endregion
+//#region src/contracts/registry.d.ts
+/**
+ * Whether a contract was made by Hollware: the always-on ones and what the factories of
+ * `contracts` return. A site's own contract with the id of a built-in one is not.
+ */
+export declare function isBuiltInContract(contract: Contract<unknown>): boolean;
+//#endregion
+//#region src/contracts/run.d.ts
+interface RunContractsInput {
+  readonly site: ResolvedSite;
+  readonly collection: ResolvedCollection;
+  readonly locale: string;
+  readonly slug: string;
+  /** The entry's id, or `null` while the entry is being created. */
+  readonly entryId: string | null;
+  /**
+   * `write` runs the contracts that are declared for it. `publish` (for `validate` and `publish`)
+   * runs every contract, so that its verdict lists everything that blocks publishing.
+   */
+  readonly phase: Phase;
+  readonly markdown: ProcessedMarkdown;
+  /** The other entries of the site, for the contracts that look at them. */
+  readonly entries: EntryLookup;
+}
+/**
+ * Runs the contracts of a collection on one revision (ADR-004).
+ *
+ * The `schema` contract goes first. The collection's own contracts, which read the frontmatter,
+ * run only when it passed, and get what the schema returned; the built-in ones that do not need
+ * it run anyway, so that one verdict lists as much as it can; the context of those has no
+ * frontmatter (`undefined`) when the schema refused it. A contract that throws does not break
+ * the run: it becomes an error of that contract.
+ *
+ * The violations come in a fixed order: the built-in contracts in their own order, then the
+ * collection's in the order of its config, and the findings of each one by line and then by path.
+ */
+export declare function runContracts(input: RunContractsInput): Promise<Verdict>;
+//#endregion
+//#region src/contracts/size.d.ts
+/**
+ * The `size-limit` violation of the row that D1 holds, which the store checks against
+ * `MAX_ROW_BYTES`. It points at the entry as a whole (the empty JSON Pointer), because what
+ * counts is everything stored with it. The Markdown pipeline words its own `size-limit` for
+ * `maxMarkdownBytes`, which names the file and the collection's limit.
+ *
+ * `bytes` is the size in UTF-8 bytes and `limit` the largest size accepted. Call it when `bytes`
+ * is over `limit`.
+ */
+export declare function sizeLimitViolation(bytes: number, limit: number): Violation;
+//#endregion
+//#region src/contracts/unique.d.ts
+/**
+ * The violations of a write that the store refuses because another entry of the same collection
+ * and locale holds what has to be unique there: the slug, or the translation group. `holder` is
+ * the id of that entry. Like `sizeLimitViolation`, they make the write `refused`, and every such
+ * refusal reads the same.
+ */
+/** Another entry of the collection and locale has the slug. The slug is no field of the file. */
+export declare function uniqueSlugViolation(holder: string): Violation;
+/** Another entry of the collection and locale belongs to the translation group in `field`. */
+export declare function uniqueTranslationViolation(holder: string, field: string): Violation;
+//#endregion
+//#region src/config/describe.d.ts
+/** A site as `describe_site` shows it to agents: the `site` of the operation's output. */
+type SiteDescription = z.output<typeof siteDescription>;
+/**
+ * What an agent reads before it writes: for each collection, the JSON Schema of the frontmatter
+ * (draft 2020-12, as the schema accepts it) and of each component's props, the routes, the
+ * fields (the translation group, the tags and the sorting field), the contracts and the style
+ * guides. `builtInContracts` are described before the collection's own ones.
+ *
+ * Converting the schemas costs about 1.4 ms for a realistic site, so the description is made once
+ * per site and per array of built-in contracts (pass the same array every time), and every call
+ * after that returns the same object, which is frozen because it is shared by every request of
+ * the isolate. Collections, components and contracts come in the order of the config.
+ */
+export declare function describeResolvedSite(site: ResolvedSite, options?: {
+  readonly builtInContracts?: readonly ContractDescription[];
+}): SiteDescription;
+//#endregion
+//#region src/config/resolve.d.ts
+/**
+ * Checks the config of the deployment and fills in its defaults, or throws a `ConfigError` with
+ * every problem it found, so that a broken `hollware.config.ts` stops the Worker at startup with
+ * a message that says what to change. v0.1 serves exactly one site per deployment.
+ *
+ * The parameter is `unknown` because the config comes from user code that may be plain
+ * JavaScript; a `HollwareConfig` is accepted as is, so this is a `ResolveConfig`. Notes on the
+ * rules:
+ *
+ * - A site key is lowercase letters and digits joined by single hyphens, from 1 to 64 characters
+ *   (`isSiteKey`, the rule of the CLI). A collection name and a component name are lowercase
+ *   letters, digits and hyphens, starting with a letter, at most 63 characters. A contract id is
+ *   lowercase words joined by single hyphens, and the id of a built-in contract
+ *   (`BUILT_IN_CONTRACT_IDS`) is taken only by a contract that Hollware made (`isBuiltInContract`:
+ *   `contracts.translationPair()` and the like), once.
+ * - Each locale is a language tag with an optional script and region (`es`, `pt-BR`,
+ *   `zh-Hant-TW`). Routes are checked against the locales only when the locales are valid.
+ * - A route has `:slug` once. Two routes of the site are the same pattern when they differ at
+ *   most by a trailing slash; patterns that overlap without being equal are not detected.
+ * - `translations.groupBy`, `tags` and `sortBy` name properties of the frontmatter's JSON Schema
+ *   (as agents see it, so `$ref`s are followed). `groupBy` is a string, `tags` an array of
+ *   strings and `sortBy` a string with the `date` or `date-time` format: a plain string does not
+ *   prove that the listing sorts by time. None may be nullable, and each may be optional.
+ * - Collections, components and contracts keep the order of the config; each collection's routes
+ *   come out in the order of the site's locales.
+ */
+export declare function resolveConfig(config: unknown): ResolvedConfig;
+//#endregion
+//#region src/config/site-key.d.ts
+/**
+ * The key of a site, which is the id of its row in the database: lowercase letters and digits
+ * joined by single hyphens (`blog`, `docs-2`, `acme-eu`), from 1 to `SITE_KEY_MAX_LENGTH`
+ * characters. It is the rule of the CLI, which can import it, so that a key the CLI writes is a
+ * key the config accepts.
+ */
+export declare const SITE_KEY_PATTERN: RegExp;
+/** The longest a site key can be. */
+export declare const SITE_KEY_MAX_LENGTH = 64;
+/** Whether a value is a site key: a string that fits `SITE_KEY_PATTERN` and is not too long. */
+export declare function isSiteKey(value: unknown): value is string;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * The errors of an operation that are none of its outcomes: the caller asked for something it
+ * cannot have, or the server could not answer. Conflicts, missing entries and blocked publishes
+ * are outcomes, not errors (`operations/specs.ts`).
+ */
+export declare const ERROR_CODES: readonly [
+/** The input breaks a rule the input schema cannot express. */
+'invalid_input',
+/** The input names a collection the site does not have. */
+'unknown_collection',
+/** The input names a locale the site does not have. */
+'unknown_locale',
+/** The token lacks a scope the operation requires; the message names every missing scope. */
+'insufficient_scope',
+/** The answer would exceed the output cap. Hollware never truncates content. */
+'output_too_large',
+/** The operation ran out of time. */
+'timeout',
+/** Anything else. The message says nothing about the cause, which goes to the log. */
+'internal'];
+type ErrorCode = (typeof ERROR_CODES)[number];
+/**
+ * An error that the caller sees: a code, a message for the agent and a fix it can act on. The
+ * cause, when there is one, is for the log only and never reaches the caller.
+ */
+export declare class HollwareError extends Error {
+  readonly name = "HollwareError";
+  readonly code: ErrorCode;
+  readonly fix: string;
+  constructor(code: ErrorCode, message: string, fix: string, options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/ids.d.ts
+/**
+ * Identifiers: a prefix that names the kind of thing, an underscore, and a ULID (48 bits of
+ * time in milliseconds, then 80 random bits, in Crockford's base 32), so that ids of one kind
+ * sort by creation time. For example `ent_01JAB3XQ8ZK4M6N2P5R7S9T0VW`.
+ */
+/** The kinds of ids and their prefixes. A new kind adds its prefix here. */
+export declare const ID_PREFIXES: {
+  readonly entry: 'ent';
+  readonly publication: 'pub';
+  readonly revision: 'rev';
+  readonly revisionTag: 'tag';
+  readonly token: 'tok';
+  readonly user: 'usr';
+};
+type IdPrefix = (typeof ID_PREFIXES)[keyof typeof ID_PREFIXES];
+/**
+ * A ULID for the given time and 10 random bytes. Both default to now and to fresh randomness
+ * from `crypto.getRandomValues`; tests pass their own.
+ */
+export declare function ulid(time?: number, random?: Uint8Array): string;
+/** A new id of the given kind: `newId('ent')` → `ent_01JAB…`. */
+export declare function newId(prefix: IdPrefix): string;
+/** Whether a string is an id of the given kind. */
+export declare function isId(prefix: IdPrefix, value: string): boolean;
+//#endregion
+//#region src/markdown/process.d.ts
+/**
+ * Processes a Markdown file for a collection (ADR-001, ADR-020): the frontmatter and the body
+ * are parsed once and the contracts get what they need from the result. It answers for any
+ * string and never throws: a file it cannot store comes back as violations.
+ */
+export declare const processMarkdown: ProcessMarkdown;
+//#endregion
+//#region src/markdown/render.d.ts
+/**
+ * Renders a stored document to HTML with `@comark/html`. `@comark/html` is imported when the
+ * first document is rendered, so that an isolate that never renders never loads it.
+ */
+export declare const renderHtml: RenderHtml;
+//#endregion
+//#region src/markdown/versions.d.ts
+/**
+ * The version of Comark that parses the Markdown, which every revision stores as `comark_version`.
+ * Comark exports no version at runtime, so this constant is the one place that names it, and
+ * `tests/markdown/versions.test.ts` binds it to the package that is installed.
+ */
+export declare const COMARK_VERSION = "0.7.0";
+/**
+ * The version of Hollware's own pipeline settings: the plugins, the allowlists, the heading ids,
+ * the markers and the line numbers (ADR-020). Bump it whenever the same Markdown would give another
+ * document or other extracted data, so that `reparse` knows which revisions to rebuild.
+ * `tests/markdown/versions.test.ts` pins the output for the shared fixtures, so a change that
+ * forgets the bump fails there.
+ */
+export declare const PIPELINE_VERSION = "1";
+//#endregion
+//#region src/scopes.d.ts
+/**
+ * The scopes a token carries. An operation asks for scopes, never for a role: what a token may
+ * do is its own scopes intersected with those of its user's role (ADR-019).
+ */
+export declare const SCOPES: readonly ['content:read', 'content:write', 'content:publish', 'schema:admin'];
+type Scope = (typeof SCOPES)[number];
+/** Whether a string is one of the scopes. */
+export declare function isScope(value: string): value is Scope;
+//#endregion
+//#region src/operations/types.d.ts
+/**
+ * The shape of an operation spec (ADR-017): its name, its input and output schemas, the scopes
+ * it requires, its effect and its outcomes. A spec holds no handler and no MCP, HTTP or
+ * Cloudflare vocabulary; the adapters of `packages/server` derive their protocol from it.
+ */
+/**
+ * What an operation does to the content. The MCP hints, the HTTP method and whether an answer
+ * may be cached derive from it:
+ * - `read` changes nothing;
+ * - `edit` changes an entry that exists;
+ * - `write` creates content or makes it public;
+ * - `destructive` takes content away from the public.
+ */
+type Effect = 'read' | 'edit' | 'write' | 'destructive';
+/** How the surfaces treat an outcome. */
+interface OutcomeInfo {
+  /** Whether the outcome is an error for the caller: `isError` over MCP, a 4xx over HTTP. */
+  readonly isError: boolean;
+}
+/** The outcomes an output schema allows: the values of its `outcome` field. */
+type OutcomeOf<Output extends z.ZodType> = z.output<Output> extends {
+  outcome: infer Outcome extends string;
+} ? Outcome : never;
+interface OperationSpec<Name extends string = string, Input extends z.ZodType = z.ZodType, Output extends z.ZodType = z.ZodType> {
+  /** The tool name over MCP, in snake case: `create_draft`. */
+  readonly name: Name;
+  /** A short human title. */
+  readonly title: string;
+  /** What the operation does and when to use it, written for the agent. */
+  readonly description: string;
+  /** An object schema; adapters reject input that does not match. */
+  readonly input: Input;
+  /** An object schema with an `outcome` field (MCP needs an object at the root). */
+  readonly output: Output;
+  /** Every scope the caller needs. */
+  readonly scopes: readonly Scope[];
+  readonly effect: Effect;
+  /** Every outcome of the output, and whether it is an error for the caller. */
+  readonly outcomes: Readonly<Record<OutcomeOf<Output>, OutcomeInfo>>;
+}
+/** Declares an operation spec, keeping the literal types of its name and schemas. */
+export declare function defineOperation<const Name extends string, Input extends z.ZodType, Output extends z.ZodType>(spec: OperationSpec<Name, Input, Output>): OperationSpec<Name, Input, Output>;
+//#endregion
+//#region src/operations/specs.d.ts
+/**
+ * The operations of v0.1, specified once (ADR-017). The outcomes and the effect of each one are
+ * the table of the v0.1 plan; `tests/operations.test.ts` holds it literally. Inputs are strict
+ * objects, so a misspelled field is an error instead of being ignored.
+ */
+export declare const describeSite: OperationSpec<"describe_site", z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    ok: "ok";
+  }>;
+  site: z.ZodObject<{
+    key: z.ZodString;
+    locales: z.ZodArray<z.ZodString>;
+    defaultLocale: z.ZodString;
+    styleGuide: z.ZodNullable<z.ZodString>;
+    collections: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      routes: z.ZodRecord<z.ZodString, z.ZodString>;
+      translationGroupField: z.ZodNullable<z.ZodString>;
+      tagsField: z.ZodNullable<z.ZodString>;
+      sortByField: z.ZodNullable<z.ZodString>;
+      components: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        example: z.ZodNullable<z.ZodString>;
+        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      }, z.core.$strip>>;
+      contracts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+        }>;
+        phases: z.ZodArray<z.ZodEnum<{
+          publish: "publish";
+          write: "write";
+        }>>;
+        description: z.ZodString;
+      }, z.core.$strip>>;
+      maxMarkdownBytes: z.ZodNumber;
+      styleGuide: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>>;
+export declare const listEntries: OperationSpec<"list_entries", z.ZodObject<{
+  collection: z.ZodString;
+  locale: z.ZodOptional<z.ZodString>;
+  tag: z.ZodOptional<z.ZodString>;
+  status: z.ZodOptional<z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    scheduled: "scheduled";
+  }>>;
+  limit: z.ZodDefault<z.ZodNumber>;
+  cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    ok: "ok";
+  }>;
+  entries: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>>;
+export declare const getEntry: OperationSpec<"get_entry", z.ZodObject<{
+  collection: z.ZodString;
+  locale: z.ZodString;
+  slug: z.ZodString;
+  formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+    document: "document";
+    html: "html";
+    markdown: "markdown";
+  }>>>;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    not_found: "not_found";
+    ok: "ok";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+    revision: z.ZodString;
+    verdict: z.ZodObject<{
+      ok: z.ZodBoolean;
+      phase: z.ZodEnum<{
+        publish: "publish";
+        write: "write";
+      }>;
+      errors: z.ZodArray<z.ZodObject<{
+        contract: z.ZodString;
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        fix: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+      warnings: z.ZodArray<z.ZodObject<{
+        contract: z.ZodString;
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        fix: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+      contractsHash: z.ZodString;
+    }, z.core.$strip>;
+    lastPublication: z.ZodNullable<z.ZodObject<{
+      revision: z.ZodString;
+      verdict: z.ZodObject<{
+        ok: z.ZodBoolean;
+        phase: z.ZodEnum<{
+          publish: "publish";
+          write: "write";
+        }>;
+        errors: z.ZodArray<z.ZodObject<{
+          contract: z.ZodString;
+          severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+          }>;
+          path: z.ZodString;
+          message: z.ZodString;
+          fix: z.ZodString;
+          line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        warnings: z.ZodArray<z.ZodObject<{
+          contract: z.ZodString;
+          severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+          }>;
+          path: z.ZodString;
+          message: z.ZodString;
+          fix: z.ZodString;
+          line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        contractsHash: z.ZodString;
+      }, z.core.$strip>;
+      acknowledged: z.ZodArray<z.ZodObject<{
+        contract: z.ZodString;
+        path: z.ZodString;
+      }, z.core.$strip>>;
+      at: z.ZodString;
+    }, z.core.$strip>>;
+    markdown: z.ZodOptional<z.ZodString>;
+    document: z.ZodOptional<z.ZodObject<{
+      nodes: z.ZodArray<z.ZodUnknown>;
+      frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      meta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    html: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare const getTranslations: OperationSpec<"get_translations", z.ZodObject<{
+  collection: z.ZodString;
+  translationGroup: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    not_found: "not_found";
+    ok: "ok";
+  }>;
+  entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strip>>;
+export declare const createDraft: OperationSpec<"create_draft", z.ZodObject<{
+  collection: z.ZodString;
+  locale: z.ZodString;
+  slug: z.ZodString;
+  markdown: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    refused: "refused";
+    saved: "saved";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  verdict: z.ZodOptional<z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare const updateDraft: OperationSpec<"update_draft", z.ZodObject<{
+  id: z.ZodString;
+  version: z.ZodNumber;
+  markdown: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    conflict: "conflict";
+    not_found: "not_found";
+    refused: "refused";
+    saved: "saved";
+    unchanged: "unchanged";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  verdict: z.ZodOptional<z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>>;
+  conflict: z.ZodOptional<z.ZodObject<{
+    currentVersion: z.ZodNumber;
+    headRevision: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare const validate: OperationSpec<"validate", z.ZodObject<{
+  collection: z.ZodString;
+  locale: z.ZodString;
+  slug: z.ZodString;
+  markdown: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    ok: "ok";
+  }>;
+  verdict: z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>>;
+export declare const publish: OperationSpec<"publish", z.ZodObject<{
+  id: z.ZodString;
+  version: z.ZodNumber;
+  acknowledgeWarnings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    contract: z.ZodString;
+    path: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    blocked: "blocked";
+    conflict: "conflict";
+    needs_acknowledgement: "needs_acknowledgement";
+    not_found: "not_found";
+    published: "published";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  verdict: z.ZodOptional<z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>>;
+  conflict: z.ZodOptional<z.ZodObject<{
+    currentVersion: z.ZodNumber;
+    headRevision: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare const unpublish: OperationSpec<"unpublish", z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    not_found: "not_found";
+    unpublished: "unpublished";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+/** Every operation of v0.1, sorted by name: the order of `tools/list`. */
+export declare const OPERATIONS: readonly [OperationSpec<"create_draft", z.ZodObject<{
+  collection: z.ZodString;
+  locale: z.ZodString;
+  slug: z.ZodString;
+  markdown: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    refused: "refused";
+    saved: "saved";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  verdict: z.ZodOptional<z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>, OperationSpec<"describe_site", z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    ok: "ok";
+  }>;
+  site: z.ZodObject<{
+    key: z.ZodString;
+    locales: z.ZodArray<z.ZodString>;
+    defaultLocale: z.ZodString;
+    styleGuide: z.ZodNullable<z.ZodString>;
+    collections: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      routes: z.ZodRecord<z.ZodString, z.ZodString>;
+      translationGroupField: z.ZodNullable<z.ZodString>;
+      tagsField: z.ZodNullable<z.ZodString>;
+      sortByField: z.ZodNullable<z.ZodString>;
+      components: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        example: z.ZodNullable<z.ZodString>;
+        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      }, z.core.$strip>>;
+      contracts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+        }>;
+        phases: z.ZodArray<z.ZodEnum<{
+          publish: "publish";
+          write: "write";
+        }>>;
+        description: z.ZodString;
+      }, z.core.$strip>>;
+      maxMarkdownBytes: z.ZodNumber;
+      styleGuide: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>>, OperationSpec<"get_entry", z.ZodObject<{
+  collection: z.ZodString;
+  locale: z.ZodString;
+  slug: z.ZodString;
+  formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+    document: "document";
+    html: "html";
+    markdown: "markdown";
+  }>>>;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    not_found: "not_found";
+    ok: "ok";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+    revision: z.ZodString;
+    verdict: z.ZodObject<{
+      ok: z.ZodBoolean;
+      phase: z.ZodEnum<{
+        publish: "publish";
+        write: "write";
+      }>;
+      errors: z.ZodArray<z.ZodObject<{
+        contract: z.ZodString;
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        fix: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+      warnings: z.ZodArray<z.ZodObject<{
+        contract: z.ZodString;
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        fix: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+      contractsHash: z.ZodString;
+    }, z.core.$strip>;
+    lastPublication: z.ZodNullable<z.ZodObject<{
+      revision: z.ZodString;
+      verdict: z.ZodObject<{
+        ok: z.ZodBoolean;
+        phase: z.ZodEnum<{
+          publish: "publish";
+          write: "write";
+        }>;
+        errors: z.ZodArray<z.ZodObject<{
+          contract: z.ZodString;
+          severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+          }>;
+          path: z.ZodString;
+          message: z.ZodString;
+          fix: z.ZodString;
+          line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        warnings: z.ZodArray<z.ZodObject<{
+          contract: z.ZodString;
+          severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+          }>;
+          path: z.ZodString;
+          message: z.ZodString;
+          fix: z.ZodString;
+          line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        contractsHash: z.ZodString;
+      }, z.core.$strip>;
+      acknowledged: z.ZodArray<z.ZodObject<{
+        contract: z.ZodString;
+        path: z.ZodString;
+      }, z.core.$strip>>;
+      at: z.ZodString;
+    }, z.core.$strip>>;
+    markdown: z.ZodOptional<z.ZodString>;
+    document: z.ZodOptional<z.ZodObject<{
+      nodes: z.ZodArray<z.ZodUnknown>;
+      frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      meta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    html: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>>, OperationSpec<"get_translations", z.ZodObject<{
+  collection: z.ZodString;
+  translationGroup: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    not_found: "not_found";
+    ok: "ok";
+  }>;
+  entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strip>>, OperationSpec<"list_entries", z.ZodObject<{
+  collection: z.ZodString;
+  locale: z.ZodOptional<z.ZodString>;
+  tag: z.ZodOptional<z.ZodString>;
+  status: z.ZodOptional<z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    scheduled: "scheduled";
+  }>>;
+  limit: z.ZodDefault<z.ZodNumber>;
+  cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    ok: "ok";
+  }>;
+  entries: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>>, OperationSpec<"publish", z.ZodObject<{
+  id: z.ZodString;
+  version: z.ZodNumber;
+  acknowledgeWarnings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    contract: z.ZodString;
+    path: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    blocked: "blocked";
+    conflict: "conflict";
+    needs_acknowledgement: "needs_acknowledgement";
+    not_found: "not_found";
+    published: "published";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  verdict: z.ZodOptional<z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>>;
+  conflict: z.ZodOptional<z.ZodObject<{
+    currentVersion: z.ZodNumber;
+    headRevision: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>, OperationSpec<"unpublish", z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    not_found: "not_found";
+    unpublished: "unpublished";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>, OperationSpec<"update_draft", z.ZodObject<{
+  id: z.ZodString;
+  version: z.ZodNumber;
+  markdown: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    conflict: "conflict";
+    not_found: "not_found";
+    refused: "refused";
+    saved: "saved";
+    unchanged: "unchanged";
+  }>;
+  entry: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    locale: z.ZodString;
+    slug: z.ZodString;
+    translationGroup: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      draft: "draft";
+      published: "published";
+      scheduled: "scheduled";
+    }>;
+    version: z.ZodNumber;
+    frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tags: z.ZodArray<z.ZodString>;
+    hasUnpublishedChanges: z.ZodBoolean;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  verdict: z.ZodOptional<z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>>;
+  conflict: z.ZodOptional<z.ZodObject<{
+    currentVersion: z.ZodNumber;
+    headRevision: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>, OperationSpec<"validate", z.ZodObject<{
+  collection: z.ZodString;
+  locale: z.ZodString;
+  slug: z.ZodString;
+  markdown: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  outcome: z.ZodEnum<{
+    ok: "ok";
+  }>;
+  verdict: z.ZodObject<{
+    ok: z.ZodBoolean;
+    phase: z.ZodEnum<{
+      publish: "publish";
+      write: "write";
+    }>;
+    errors: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+      contract: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+      }>;
+      path: z.ZodString;
+      message: z.ZodString;
+      fix: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contractsHash: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>>];
+type Operation = (typeof OPERATIONS)[number];
+type OperationName = Operation['name'];
+/** The spec of an operation, by its name. */
+type OperationByName<Name extends OperationName> = Extract<Operation, {
+  name: Name;
+}>;
+//#endregion
+//#region src/tokens.d.ts
+/**
+ * Personal tokens (ADR-019): `hw_pat_` and 52 characters of lowercase Crockford base 32, which
+ * carry 260 random bits. The CLI makes a token and prints it once. The server never stores it:
+ * it keeps the SHA-256 of the whole token, in hex, and finds a presented token by that hash. The
+ * row of a token has an id of its own (`tok_…`, see `ids.ts`), its scopes and its expiry.
+ */
+export declare const PERSONAL_TOKEN_PREFIX = "hw_pat_";
+/** Days until a new personal token expires, unless whoever creates it asks for another expiry. */
+export declare const PERSONAL_TOKEN_TTL_DAYS = 90;
+/**
+ * A new personal token. Each of the 52 random bytes gives one character (its low 5 bits, which
+ * are uniform because 256 is a multiple of 32). `random` defaults to `crypto.getRandomValues`;
+ * tests pass their own bytes.
+ */
+export declare function generatePersonalToken(random?: Uint8Array): string;
+/** Whether a string has the shape of a personal token. It says nothing about whether one exists. */
+export declare function isPersonalToken(value: string): boolean;
+/** The SHA-256 of a token, in lowercase hex: what the `tokens` table stores and looks up. */
+export declare function hashPersonalToken(token: string): Promise<string>;
+//#endregion
 //#region src/index.d.ts
 export declare const name = "@hollware/core";
-//#endregion
+//#endregion
+export { type AcknowledgedWarning, type BuiltInContractId, type BuiltInOptions, type CollectionDefinition, type ComponentDefinition, type ComponentUse, type ConfigProblem, type Contract, type ContractContext, type ContractDescription, type ContractFinding, type ContractText, type CustomContractOptions, type DescribedSchema, type DisallowedMarker, type Effect, type EntryDocument, type EntryFacts, type EntryLookup, type EntryRef, type ErrorCode, type ExtractedContent, type Heading, type HollwareConfig, type IdPrefix, type ImageRef, type LinkRef, type LinkTarget, type Operation, type OperationByName, type OperationName, type OperationSpec, type OutcomeInfo, type OutcomeOf, type Phase, type ProcessMarkdown, type ProcessMarkdownOptions, type ProcessResult, type ProcessedMarkdown, type RenderHtml, type ResolveConfig, type ResolvedCollection, type ResolvedConfig, type ResolvedSite, type RunContractsInput, type SchemaOutput, type Scope, type Severity, type SiteDefinition, type SiteDescription, type Verdict, type Violation, schemas_d_exports as schemas };