@designtools/manifest 0.0.0-stage → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,577 @@
+import ts from 'typescript';
+
+/**
+ * The manifest schema: what `designtools-manifest build` writes to
+ * `<system>/manifest/`: components.json, tokens.json, rules.json,
+ * patterns.json, taxonomy.json and assets.json.
+ *
+ * This file has no imports on purpose. @designtools/blocks carries a byte-identical
+ * copy, so a project's docs read the manifest through the same types the tool
+ * wrote it with, and a test in this repo fails if the two drift.
+ *
+ * Every path is relative to the project root, with forward slashes. Arrays keep
+ * source order where order means something (variant axes, fixture states, token
+ * ramps); everything else is sorted, so a diff of the files shows only real changes.
+ */
+declare const MANIFEST_SCHEMA = "designtools.manifest/1";
+/** What every manifest file opens with. */
+interface ManifestFile {
+    /** `@designtools/manifest@<version>`, so `check` can tell a tool upgrade from an edit. */
+    generator: string;
+    schema: string;
+}
+/** components.json */
+interface ComponentsManifest extends ManifestFile {
+    /** The system folder the components were read from. */
+    system: string;
+    /** Sorted by name, then source. */
+    components: ComponentEntry[];
+}
+interface ComponentEntry {
+    /** The export name, or `@name` when the JSDoc gives one. */
+    name: string;
+    /** The exported identifier to import. Equals `name` unless `@name` renamed it. */
+    export: string;
+    /** The file that exports it. */
+    source: string;
+    /**
+     * The module specifier an app imports it by, through the tsconfig path alias
+     * that reaches the system folder (`@ds/button/button`). Absent when no alias does,
+     * in which case `source` is the only honest answer.
+     */
+    import?: string;
+    /** The component's JSDoc, or its variant config's when the component has none. */
+    description?: string;
+    /** `@category`. Blocks group components without one under "Components". */
+    category?: string;
+    /** `@status`, or `deprecated` from `@deprecated`. Absent until someone decides it. */
+    status?: Status;
+    /** Why it has that status: the `@deprecated` reason, or text after `@status`. */
+    statusNote?: string;
+    /** `@use`, `@avoid`, `@instead`: when to reach for it, when not, and what instead. */
+    usage?: Usage;
+    /** `@example` snippets in the JSDoc, each one JSX. */
+    snippets?: string[];
+    /** `@see`, each one a link or a component name. */
+    see?: string[];
+    /** `@primitive`: the primitive it wraps, as a link or a package path. */
+    primitive?: string;
+    /** `@aria`: the ARIA pattern it follows, usually a link. */
+    aria?: string;
+    /** `@role` and `@keyboard`: what assistive technology meets, and the keys it answers. */
+    a11y?: {
+        role?: string;
+        keyboard?: string[];
+    };
+    /** `@replaces`: raw elements this component stands in for, which the adherence report counts. */
+    replaces?: string[];
+    /**
+     * What it also accepts beyond its own props: an intrinsic element (`"span"`)
+     * or a wrapped primitive (`"@base-ui/react/select:Root"`).
+     */
+    inherits?: string[];
+    /** Its own props, and those of a primitive it wraps. Inherited DOM props are left out. */
+    props: Record<string, PropEntry>;
+    /** Absent when it has no variants by any route. */
+    variants?: VariantsEntry;
+    /** Every `data-slot` it renders, sorted. */
+    slots: string[];
+    /** Absent when the component has no examples file. */
+    examples?: ExamplesEntry;
+}
+type Status = "stable" | "emerging" | "deprecated";
+interface Usage {
+    use?: string;
+    avoid?: string;
+    /** Components, or other things, to use instead. */
+    instead?: string[];
+}
+interface PropEntry {
+    /** The type as written or resolved, e.g. `string`, `"sm" | "md"`, `(v: string) => void`. */
+    type: string;
+    /** Present when the type is a union of literals: each value, unquoted. */
+    values?: string[];
+    required: boolean;
+    /** The default, as source text, when the component destructures one. */
+    default?: string;
+    description?: string;
+    deprecated?: string;
+    /** The package that declares it, when it comes from a wrapped primitive rather than the project. */
+    from?: string;
+}
+interface VariantsEntry {
+    /** Where the axes came from: a `tv()` or `cva()` config, or the props' literal union types. */
+    from: "tv" | "cva" | "props";
+    /** The config's variable name. Absent when `from` is `"props"`. */
+    config?: string;
+    /** Source order. */
+    axes: VariantAxis[];
+    /** Conditions only, without their classes, in source order. */
+    compound?: Record<string, string | string[]>[];
+    /** A `tv()` config's named parts, in source order. */
+    parts?: string[];
+}
+interface VariantAxis {
+    name: string;
+    /** Source order. */
+    options: VariantOption[];
+    default?: string;
+}
+interface VariantOption {
+    name: string;
+    description?: string;
+}
+/**
+ * A co-located `*.examples.tsx`: `canonical` is the one to copy, `do*` and
+ * `dont*` render as pairs in order, anything else is a further example.
+ */
+interface ExamplesEntry {
+    source: string;
+    canonical?: ExampleRef;
+    do: ExampleRef[];
+    dont: ExampleRef[];
+    other: ExampleRef[];
+}
+interface ExampleRef {
+    /** The export name. */
+    name: string;
+    /** Its JSDoc: why to do it, or why not. */
+    description?: string;
+    /** The JSX it returns, as written, for agents and code views. */
+    code?: string;
+}
+/** tokens.json */
+interface TokensManifest extends ManifestFile {
+    /** The stylesheets read, in the order given. */
+    sources: string[];
+    /** Source order: file by file, declaration by declaration. */
+    tokens: TokenEntry[];
+}
+type TokenTier = "color" | "font" | "font-weight" | "text" | "leading" | "tracking" | "spacing" | "size" | "radius" | "shadow" | "ease" | "duration" | "motion" | "breakpoint" | "container" | "other";
+interface TokenEntry {
+    /** The custom property, with its dashes: `--color-primary-500`. */
+    name: string;
+    tier: TokenTier;
+    /**
+     * The value in each context it is declared in. `default` is `@theme` or `:root`;
+     * `light` and `dark` are the mode blocks; a `p3:` prefix marks the
+     * `@media (color-gamut: p3)` layer. Any other selector is kept as written.
+     */
+    values: Record<string, string>;
+    /** The comment above it, or above the run of declarations it belongs to. */
+    description?: string;
+    /** The stylesheet that first declares it. */
+    source: string;
+    /** Later stylesheets whose declaration replaced a value, in the order read: an override layer. */
+    overriddenIn?: string[];
+}
+/** rules.json: brand and interface rules in one format. */
+interface RulesManifest extends ManifestFile {
+    /** Sorted by id. */
+    rules: RuleEntry[];
+}
+interface RuleEntry {
+    /** The file name without `.rule.json`, used as its anchor: `touch-target`. */
+    id: string;
+    kind: "brand" | "interface";
+    title: string;
+    /** The rule, in one or two sentences, for people first. */
+    statement: string;
+    /** Why it exists. */
+    rationale?: string;
+    /** The measurable line, e.g. `44 × 44 CSS px`. */
+    threshold?: string;
+    /** Components, elements, assets or pages it governs. */
+    appliesTo?: string[];
+    exceptions?: string[];
+    /** Tokens it rests on, e.g. `--size-2xl`. */
+    tokens?: string[];
+    /**
+     * Confirmed with the client, an assumption still to confirm, or measured: generated from the
+     * tokens (where a colour can be text), a fact that changes when they do, not a decision.
+     */
+    status: "confirmed" | "assumption" | "measured";
+    /** How it is proved: a test, a lint rule, an audit, or a person. */
+    check?: {
+        kind: "test" | "lint" | "audit" | "manual";
+        ref?: string;
+        description?: string;
+    };
+    source: string;
+}
+/** patterns.json: the product's recurring screen compositions. */
+interface PatternsManifest extends ManifestFile {
+    /** Sorted by name. */
+    patterns: PatternEntry[];
+}
+interface PatternEntry {
+    /** From the file name: `checkout` for `checkout.pattern.tsx`. */
+    id: string;
+    name: string;
+    description?: string;
+    status?: Status;
+    /** The system components it imports, by name, sorted. */
+    components: string[];
+    /** Each named export is a composition, in source order. */
+    examples: ExampleRef[];
+    source: string;
+}
+/** taxonomy.json: one vocabulary, with the wrong forms to avoid. */
+interface TaxonomyManifest extends ManifestFile {
+    /** Sorted by name. */
+    terms: TermEntry[];
+}
+interface TermEntry {
+    /** The canonical form. */
+    name: string;
+    kind: "component" | "variant" | "token" | "pattern" | "rule" | "product";
+    /** Known wrong forms: `error` for `destructive`, `Modal` for `Dialog`, "log in" for "sign in". */
+    wrong?: string[];
+    note?: string;
+    /** Where it is defined: a component's source, a token's name, a rule's id. */
+    ref?: string;
+}
+/** assets.json: logos, icons and imagery, with how to use them. */
+interface AssetsManifest extends ManifestFile {
+    /** Sorted by file. */
+    assets: AssetEntry[];
+}
+interface AssetEntry {
+    file: string;
+    kind: "logo" | "icon" | "image" | "other";
+    name: string;
+    usage?: string;
+    /** e.g. `24px tall` */
+    minSize?: string;
+    /** e.g. `the height of the wordmark's x` or a length */
+    clearSpace?: string;
+    /** Surfaces it may sit on, as semantic colour names: `canvas`, `primary`. */
+    surfaces?: string[];
+    alt?: string;
+    /** Intrinsic size, read from an SVG's viewBox or a PNG's header. */
+    width?: number;
+    height?: number;
+}
+
+/**
+ * Components: every exported React component under the system folder.
+ *
+ * Props come from react-docgen-typescript, which resolves types through the
+ * checker, run once over a single program for every file (the LloydsDirect
+ * docgen built a program per file, which is where its time went). Everything
+ * else (variants, data-slots, JSDoc, examples) is read from the syntax tree,
+ * because it is written as data in the source and needs no type resolution.
+ */
+
+interface Warning {
+    file: string;
+    line?: number;
+    message: string;
+}
+interface ComponentsOptions {
+    /** Project root; every path in the output is relative to it. */
+    root: string;
+    /** The system folder, relative to root. */
+    system: string;
+    /** tsconfig.json to resolve imports and path aliases with, relative to root. Found from root when absent. */
+    tsconfig?: string;
+    /** Folder the manifest is written to, relative to root; skipped when scanning. */
+    out?: string;
+}
+declare function listComponentFiles(root: string, system: string, out?: string): string[];
+declare function readComponents(options: ComponentsOptions, warn: (w: Warning) => void): ComponentEntry[];
+
+/**
+ * Build the manifest in memory: each file's path and exact contents. The
+ * CLI writes them (build), compares them with what is on disk (check), or
+ * compares them with a git ref (diff); nothing here touches the disk but to read.
+ */
+
+declare const GENERATOR_NAME = "@designtools/manifest";
+declare const VERSION: string;
+declare const GENERATOR: string;
+interface ManifestConfig {
+    /** Project root. Every other path is relative to it. */
+    root: string;
+    /** The design system folder, e.g. `src/ds`. */
+    system: string;
+    /** Token stylesheets, in the order they are imported. */
+    tokens: string[];
+    /** tsconfig.json for resolving imports. Found from root when absent. */
+    tsconfig?: string;
+    /** Where the manifest goes. Defaults to `<system>/manifest`, so it moves with the system. */
+    out?: string;
+    /** Folder of `*.rule.json` files. Defaults to `<system>/rules`. */
+    rules?: string;
+    /** The curated synonyms and wrong forms. Defaults to `<system>/taxonomy.json`. */
+    taxonomy?: string;
+    /** Brand assets, with an `assets.json` saying how to use them. Defaults to `<system>/brand`. */
+    brand?: string;
+    /** Where the docs are served, for the agent pointer file, e.g. `/design/system`. */
+    docs?: string;
+    /**
+     * The usage file `@designtools/tokens --usage` writes: every colour on every background with a
+     * verdict. Its failures become measured usage rules in rules.json.
+     */
+    usage?: string;
+    /** The agent file the pointer section goes in, when the default choice is wrong for the project. */
+    agents?: string;
+    /**
+     * More places for prose-check to read, beside the agent files, `.claude/`, `docs/`
+     * and the system folder: files of any kind, or folders, whose markdown and
+     * `*content.ts(x)` files (the docs site's editorial copy) are read.
+     */
+    prose?: string[];
+}
+interface BuiltManifest {
+    components: ComponentsManifest;
+    tokens: TokensManifest;
+    rules: RulesManifest;
+    patterns: PatternsManifest;
+    taxonomy: TaxonomyManifest;
+    assets: AssetsManifest;
+    /** Relative path → exact file contents. */
+    files: Record<string, string>;
+    warnings: Warning[];
+}
+declare function outDir(config: ManifestConfig): string;
+declare function buildManifest(config: ManifestConfig): BuiltManifest;
+/**
+ * JSON with every object's keys sorted and arrays left in their order, two-space
+ * indented, with a final newline. Arrays carry the orders that mean something
+ * (axes, states, ramps), so sorting them would lose information; sorting keys
+ * means two runs, or two machines, write the same bytes.
+ */
+declare function serialise(value: unknown): string;
+
+/**
+ * Configuration: `designtools.json` at the project root, overridden by flags.
+ *
+ *   { "manifest": { "system": "src/ds", "tokens": ["app/styles/tokens.css", "app/styles/scale.css"] } }
+ *
+ * One file for every @designtools tool, so a project records its system folder once.
+ */
+
+declare const CONFIG_FILE = "designtools.json";
+interface ConfigFlags {
+    root?: string;
+    system?: string;
+    tokens?: string[];
+    tsconfig?: string;
+    out?: string;
+}
+declare function loadConfig(flags: ConfigFlags): ManifestConfig;
+
+/**
+ * Classify every change between two manifests, so a person only has to look at
+ * the breaking ones:
+ *
+ *   breaking  something a caller relies on is gone or now required
+ *   additive  something new that nothing could depend on yet
+ *   visual    a value changed; visual regression decides whether it matters
+ *   docs      a description, category, example or deprecation changed
+ *
+ * Components are matched by their path inside the system folder and their
+ * export name, so moving the whole system up a tier is not a change.
+ */
+
+type ChangeClass = "breaking" | "additive" | "visual" | "docs";
+declare const CHANGE_CLASSES: ChangeClass[];
+interface Change {
+    class: ChangeClass;
+    /** The component or token the change belongs to. */
+    subject: string;
+    message: string;
+}
+interface ManifestPair {
+    components?: ComponentsManifest;
+    tokens?: TokensManifest;
+    rules?: RulesManifest;
+    patterns?: PatternsManifest;
+    taxonomy?: TaxonomyManifest;
+    assets?: AssetsManifest;
+}
+declare function diffManifests(before: ManifestPair, after: ManifestPair): Change[];
+/** A markdown report, ready to post on a pull request. */
+declare function formatReport(changes: Change[], base: string): string;
+
+/**
+ * JSDoc, read from the comment text rather than through the type checker, so a
+ * tag means the same thing on a component, a variant config and a fixture.
+ *
+ * The recognised tags are the ones the LloydsDirect design system used in
+ * practice. Anything else is reported, because a misspelt tag (`@primative`
+ * turned up three times there) otherwise vanishes without a trace.
+ */
+
+interface JSDocTag {
+    name: string;
+    text: string;
+}
+interface JSDoc {
+    description: string;
+    tags: JSDocTag[];
+    /** 1-based line of the comment, for warnings. */
+    line: number;
+}
+/** Tags the manifest reads. */
+declare const MANIFEST_TAGS: Set<string>;
+/** Parse the text of a `/** … *\/` comment into a description and its tags. */
+declare function parseJSDoc(comment: string): Omit<JSDoc, "line">;
+
+/**
+ * Examples files: each named export renders the real components. The manifest
+ * records each export's name, its JSDoc (why), and the JSX it returns as written,
+ * so a docs page can show the code and an agent can copy the canonical one. It
+ * never runs them.
+ */
+
+interface ExampleFile {
+    sf: ts.SourceFile;
+    /** The file's own JSDoc: the first comment, when a statement other than an import follows it. */
+    doc?: JSDoc;
+    exports: ExampleRef[];
+}
+declare function readExampleFile(path: string, source: string, warn: (w: Warning) => void, owner?: string): ExampleFile;
+/** `canonical`, then `do*` and `dont*` in order, then anything else. */
+declare function classifyExamples(source: string, exports: ExampleRef[]): ExamplesEntry;
+
+/**
+ * Tokens: every custom property in the project's token stylesheets.
+ *
+ * A project commits CSS, not a token JSON: @designtools/tokens writes the colour
+ * tiers with their light, dark and P3 blocks, and the scale (space, type, radius,
+ * shadow, motion) is authored by hand beside it. Both are read the same way, so
+ * there is one reader and no second token format to keep in step.
+ *
+ * The comment above a declaration, or above the run of declarations it starts,
+ * is that token's description: the scale's comments already say why each value
+ * is what it is. A comment on the same line after a declaration describes that
+ * declaration (`--size-xl: 3rem; /* 48px controls *\/`), and does not start a run.
+ */
+
+declare function readTokens(root: string, sources: string[], warn: (w: Warning) => void): TokenEntry[];
+declare function tierOf(name: string, values: Record<string, string>): TokenTier;
+
+/**
+ * The guidance a system carries beyond its components and tokens: rules,
+ * patterns, the taxonomy and brand assets. Each is authored by people in a
+ * small file beside the code; the manifest gathers them into one shape, and
+ * fills in what can be read rather than written (a pattern's components, an
+ * image's size, the canonical names).
+ */
+
+/** One `<id>.rule.json` per rule, brand and interface alike. */
+declare function readRules(root: string, dir: string, warn: (w: Warning) => void): RuleEntry[];
+/**
+ * `<id>.pattern.tsx` anywhere in the system folder: the file's JSDoc names and
+ * describes it, its imports say which components it composes, and each named
+ * export is a composition.
+ */
+declare function readPatterns(root: string, system: string, components: ComponentEntry[], compiler: ts.CompilerOptions, warn: (w: Warning) => void, skip?: string): PatternEntry[];
+/**
+ * One vocabulary. The canonical names come from everything the manifest reads;
+ * the curated `taxonomy.json` adds their wrong forms, and product terms the
+ * code does not name.
+ */
+declare function buildTaxonomy(root: string, curatedPath: string, inputs: {
+    components: ComponentEntry[];
+    tokens: TokenEntry[];
+    patterns: PatternEntry[];
+    rules: RuleEntry[];
+}, warn: (w: Warning) => void): TermEntry[];
+/**
+ * Brand assets from one folder. `assets.json` in it says how to use each file;
+ * files it does not mention are listed too, with a warning, so nothing in the
+ * folder goes unseen. The order is the author's (the wordmark first, because it
+ * is the default), then anything unlisted by file name.
+ */
+declare function readAssets(root: string, brandDir: string, warn: (w: Warning) => void): AssetEntry[];
+
+/**
+ * The agent pointer file: a generated section of CLAUDE.md or AGENTS.md that
+ * sends agents to the manifest, the rules and the design language. It never
+ * lists components, tokens or variants: a list written into prose is a second
+ * copy that drifts, and prose-check flags one.
+ */
+
+declare const AGENTS_START = "<!-- designtools:start \u00B7 generated by designtools-manifest agents; edit outside these markers -->";
+declare const AGENTS_END = "<!-- designtools:end -->";
+/**
+ * The file the pointer goes in: the flag, then `manifest.agents` in designtools.json,
+ * then AGENTS.md when CLAUDE.md imports it (`@AGENTS.md`, as `next dev` writes it), so
+ * every agent reads the section and Claude still reaches it through the import; else
+ * CLAUDE.md if the project has one, else AGENTS.md.
+ */
+declare function agentsFile(root: string, given?: string, configured?: string): string;
+declare function agentsSection(config: ManifestConfig & {
+    docs?: string;
+}): string;
+/** The file with the section replaced, or appended when it has none. */
+declare function withAgentsSection(existing: string | undefined, section: string): string;
+interface Provenance {
+    /** `name@version` of the project, from its package.json. */
+    version: string;
+    /** Short commit hash, with `-dirty` when the tree has uncommitted changes. */
+    commit: string;
+    /** `Generated from acme-web@1.4.0 at 3f2a9c1` */
+    line: string;
+}
+/**
+ * Where a generated page comes from, for its header: the project's version and
+ * the commit it was built at. CI variables win over git, which a deploy may not have.
+ */
+declare function provenance(root: string): Provenance;
+
+/**
+ * prose-check: the system's names in agent files and docs prose, checked
+ * against the manifest. It warns; it never fails. Three things are flagged:
+ *
+ *   a component tag (`<Modal>`) the system does not have
+ *   a wrong form from the taxonomy (`Modal` for `Dialog`, "log in" for "sign in")
+ *   a restated list: a paragraph or list naming several components or tokens,
+ *   which is a second copy of the manifest that will drift
+ *
+ * A page that names wrong forms on purpose (a voice page: "never the customer")
+ * says so: `prose-check-ignore` on a line skips it, `prose-check-ignore-next-line`
+ * skips the one after, and `prose-check-ignore-start` … `prose-check-ignore-end`
+ * skip everything between, in whatever comment syntax the file uses.
+ */
+
+interface ProseFinding {
+    file: string;
+    line: number;
+    message: string;
+}
+interface ProseInputs {
+    components: ComponentEntry[];
+    patterns: PatternEntry[];
+    tokens: TokenEntry[];
+    terms: TermEntry[];
+}
+declare function defaultProseFiles(root: string, system: string, extra?: string[]): string[];
+declare function checkProse(root: string, files: string[], inputs: ProseInputs): ProseFinding[];
+
+/**
+ * Variant configs, read by parsing the `tv()` or `cva()` call. The config is
+ * already data (axes, options, defaults, compound conditions), so nothing is
+ * inferred from types.
+ *
+ * tailwind-variants is the suite default; class-variance-authority has the same
+ * shape for everything read here. Either may be imported under another name.
+ */
+
+interface VariantConfig {
+    /** The variable it is assigned to. */
+    name: string;
+    kind: "tv" | "cva";
+    entry: VariantsEntry;
+    /** `tv({ extend: base })`: the config this one builds on, merged in by whoever resolves names. */
+    extendsName?: string;
+    doc?: JSDoc;
+    description?: string;
+}
+/** Every `const x = tv({...})` / `cva(base, {...})` at any depth, in source order. */
+declare function findVariantConfigs(sf: ts.SourceFile): VariantConfig[];
+
+export { AGENTS_END, AGENTS_START, type AssetEntry, type AssetsManifest, type BuiltManifest, CHANGE_CLASSES, CONFIG_FILE, type Change, type ChangeClass, type ComponentEntry, type ComponentsManifest, type ComponentsOptions, type ConfigFlags, type ExampleRef, type ExamplesEntry, GENERATOR, GENERATOR_NAME, MANIFEST_SCHEMA, MANIFEST_TAGS, type ManifestConfig, type ManifestPair, type PatternEntry, type PatternsManifest, type PropEntry, type ProseFinding, type ProseInputs, type Provenance, type RuleEntry, type RulesManifest, type Status, type TaxonomyManifest, type TermEntry, type TokenEntry, type TokenTier, type TokensManifest, type Usage, VERSION, type VariantAxis, type VariantOption, type VariantsEntry, type Warning, agentsFile, agentsSection, buildManifest, buildTaxonomy, checkProse, classifyExamples, defaultProseFiles, diffManifests, findVariantConfigs, formatReport, listComponentFiles, loadConfig, outDir, parseJSDoc, provenance, readAssets, readComponents, readExampleFile, readPatterns, readRules, readTokens, serialise, tierOf, withAgentsSection };

package/dist/index.js

@@ -0,0 +1,70 @@
+import {
+  AGENTS_END,
+  AGENTS_START,
+  CHANGE_CLASSES,
+  CONFIG_FILE,
+  GENERATOR,
+  GENERATOR_NAME,
+  MANIFEST_SCHEMA,
+  MANIFEST_TAGS,
+  VERSION,
+  agentsFile,
+  agentsSection,
+  buildManifest,
+  buildTaxonomy,
+  checkProse,
+  classifyExamples,
+  defaultProseFiles,
+  diffManifests,
+  findVariantConfigs,
+  formatReport,
+  listComponentFiles,
+  loadConfig,
+  outDir,
+  parseJSDoc,
+  provenance,
+  readAssets,
+  readComponents,
+  readExampleFile,
+  readPatterns,
+  readRules,
+  readTokens,
+  serialise,
+  tierOf,
+  withAgentsSection
+} from "./chunk-PQGMDEUF.js";
+export {
+  AGENTS_END,
+  AGENTS_START,
+  CHANGE_CLASSES,
+  CONFIG_FILE,
+  GENERATOR,
+  GENERATOR_NAME,
+  MANIFEST_SCHEMA,
+  MANIFEST_TAGS,
+  VERSION,
+  agentsFile,
+  agentsSection,
+  buildManifest,
+  buildTaxonomy,
+  checkProse,
+  classifyExamples,
+  defaultProseFiles,
+  diffManifests,
+  findVariantConfigs,
+  formatReport,
+  listComponentFiles,
+  loadConfig,
+  outDir,
+  parseJSDoc,
+  provenance,
+  readAssets,
+  readComponents,
+  readExampleFile,
+  readPatterns,
+  readRules,
+  readTokens,
+  serialise,
+  tierOf,
+  withAgentsSection
+};