@mesh-tech/mesh-cli 0.20.2 → 0.20.4

package/dist/src/docs/cli-reference.js

@@ -1,31 +1,7 @@
-/**
- * Generate the `mesh` CLI reference from the commander tree.
- *
- * This is the load-bearing half of "self-documenting": the reference is not a
- * hand-maintained table that drifts from the code, it is a projection of the
- * same `Command` objects the CLI parses. Add a flag and the docs grow it; the
- * `--check` mode in `mesh docs` fails CI when the two diverge.
- *
- * Pure by construction — `extractCliReference` and `renderCliReferenceMarkdown`
- * do no I/O, so they are directly unit-testable.
- */
 import os from "node:os";
 function currentMachinePaths() {
     return { homeDir: os.homedir(), tmpDir: os.tmpdir() };
 }
-/**
- * Collapse machine-specific absolute paths to the symbols a reader recognizes.
- *
- * Some option defaults are computed at registration time from the environment —
- * `mesh install-shim --dir` defaults to `path.join(os.homedir(), ".local/bin")`.
- * Rendered literally, the generated reference embeds whoever ran the generator
- * (`/Users/dmb/.local/bin` vs `/home/runner/.local/bin`), which makes the
- * artifact machine-dependent and the `--check` gate pass only on one laptop —
- * exactly how this was caught, by CI failing a locally-green gate.
- *
- * Substituting `~` fixes determinism and is also what the reader wants to see.
- * Longest prefix first, since tmpdir can live under home on macOS.
- */
 export function normalizeMachinePaths(value, paths) {
     const candidates = [
         { prefix: paths.tmpDir, symbol: "$TMPDIR" },
@@ -42,14 +18,6 @@ export function normalizeMachinePaths(value, paths) {
     }
     return value;
 }
-/**
- * Render a default value the way a reader would type it, not the way
- * `JSON.stringify` would: bare for strings so `docs/docs.config.json` doesn't
- * arrive wrapped in quotes, JSON for everything structured.
- *
- * `paths` is injectable so the normalization above is testable without
- * depending on the machine running the test.
- */
 export function formatDefault(value, paths = currentMachinePaths()) {
     if (value === undefined || value === null)
         return undefined;
@@ -59,7 +27,6 @@ export function formatDefault(value, paths = currentMachinePaths()) {
         return String(value);
     return normalizeMachinePaths(JSON.stringify(value), paths);
 }
-/** Slugify a command path into a stable anchor: `mesh hub dev` → `mesh-hub-dev`. */
 export function slugifyCommandPath(path) {
     return path
         .trim()
@@ -86,12 +53,6 @@ function extractOptions(command) {
         return ref;
     });
 }
-/**
- * Positional-argument usage for a command.
- *
- * `Command.usage()` returns the whole `[options] <arg>` string; we want only
- * the positional part, since options are documented in their own table.
- */
 function extractArgs(command) {
     const internals = command;
     const declared = internals.registeredArguments ?? internals._args ?? [];
@@ -106,16 +67,6 @@ function extractArgs(command) {
     })
         .join(" ");
 }
-/**
- * Commands the reference must not publish.
- *
- * Two kinds. Commander auto-registers a `help` subcommand on every group, which
- * documents commander rather than Mesh. And commands declared
- * `{ hidden: true }` are internal re-entry points the CLI spawns for itself
- * (`mesh dev __token-server`, `mesh vpn tunnel __run`) — `hidden` is already
- * this repo's signal for "keep out of `--help`", and the docs honor the same
- * signal rather than inventing a second one.
- */
 function isUndocumented(command) {
     const internals = command;
     return internals._name === "help" || internals._hidden === true;
@@ -138,13 +89,6 @@ function extractCommand(command, parentPath, depth) {
             .map((child) => extractCommand(child, path, depth + 1)),
     };
 }
-/**
- * Project a commander program into a serializable reference tree.
- *
- * The root program's `--version` option is excluded: its value is the CLI
- * version, which would make the generated output differ on every release and
- * turn the `--check` gate into noise.
- */
 export function extractCliReference(program) {
     const internals = program;
     const rootName = internals._name ?? "mesh";
@@ -157,7 +101,6 @@ export function extractCliReference(program) {
             .map((child) => extractCommand(child, rootName, 1)),
     };
 }
-/** Depth-first walk over every command in the tree, parents before children. */
 export function flattenCommands(reference) {
     const flat = [];
     const visit = (command) => {
@@ -167,15 +110,6 @@ export function flattenCommands(reference) {
     reference.commands.forEach(visit);
     return flat;
 }
-/**
- * Escape the characters that would break a markdown table cell.
- *
- * Backslash first, then pipe — the reverse order is subtly wrong. A description
- * containing a literal `\|` would have its pipe escaped to `\\|`, which markdown
- * reads as "escaped backslash, then a live cell delimiter", splitting the row.
- * Escaping the backslash first makes it `\\\|`: one literal backslash, one
- * escaped pipe.
- */
 function cell(text) {
     return text
         .replace(/\\/g, "\\\\")
@@ -201,8 +135,6 @@ function renderOptionsTable(options) {
     return lines;
 }
 function renderCommand(command) {
-    // Cap heading depth at h4 — deeper nesting produces headings no navigation
-    // renders, and Mesh's tree is at most `mesh <group> <cmd> <sub>`.
     const heading = "#".repeat(Math.min(command.depth + 1, 4));
     const usage = [command.path, command.options.length > 0 ? "[options]" : "", command.args]
         .filter(Boolean)
@@ -218,13 +150,6 @@ function renderCommand(command) {
     command.subcommands.forEach((child) => lines.push(...renderCommand(child)));
     return lines;
 }
-/**
- * Render the reference as markdown.
- *
- * The output carries a generated-file banner naming the command that rebuilds
- * it, because the failure mode for generated docs is someone hand-editing the
- * artifact and losing the change on the next build.
- */
 export function renderCliReferenceMarkdown(reference) {
     const lines = [
         "<!--",
@@ -250,7 +175,5 @@ export function renderCliReferenceMarkdown(reference) {
     }
     lines.push("");
     reference.commands.forEach((command) => lines.push(...renderCommand(command)));
-    // Collapse the blank-line runs that per-section rendering leaves behind.
     return `${lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}\n`;
 }
-//# sourceMappingURL=cli-reference.js.map

package/dist/src/docs/discover.d.ts

@@ -1,60 +1,20 @@
-/**
- * Doc-root discovery.
- *
- * The one rule of the portal: **a directory publishes its markdown if, and
- * only if, it contains a `docs.json`.** This module finds those directories,
- * validates their declarations, and walks them for publishable pages —
- * skipping any path with a reserved segment (at any depth) and any `README.md`
- * (a README is the directory's GitHub face, not portal content; a root that
- * wants one published names it in `include[]`, the escape hatch).
- *
- * Discovery is purely about *which files* publish. Reading their content —
- * titles, front-matter, links — is assembly's job (`assemble.ts`).
- */
 import type { DocsJson } from "./schema.js";
-/** A validated doc root. */
 export interface DocRoot {
-    /** Repo-relative directory holding the docs.json, posix separators. */
     dir: string;
     config: DocsJson;
-    /** Route prefix — `config.slug` or the slugified title. "" means site root. */
     slug: string;
 }
-/** One publishable markdown file. */
 export interface DiscoveredPage {
-    /** Repo-relative source path, posix separators. */
     source: string;
-    /** The root that claimed it. */
     root: DocRoot;
-    /**
-     * Route path inside the section, no leading slash — e.g.
-     * `primitives/service`. "" for the section's own index page.
-     */
     routePath: string;
-    /** True when the page came from `include[]` rather than the tree walk. */
     included: boolean;
 }
 export interface Discovery {
     roots: DocRoot[];
     pages: DiscoveredPage[];
-    /** Every structural problem found, human-readable. Non-empty fails --check. */
     errors: string[];
 }
-/**
- * The route a page gets inside its section: the path relative to the root,
- * each segment slugified, the `.md` dropped, and a trailing `index` collapsed
- * so a directory's index page serves at the directory's route.
- */
 export declare function routePathFor(relPath: string): string;
-/**
- * Find every doc root under `repoRoot`, validate it, and collect its pages.
- *
- * The walk looks for `docs.json` files anywhere in the repo (excluding the
- * ROOT_WALK_SKIP directories), so a package opts in by adding one file and
- * nothing else. Roots are sorted by (order, title); pages within a root are
- * sorted by route path so assembly is deterministic.
- */
 export declare function discoverDocRoots(repoRoot: string): Discovery;
-/** What exists at `candidate`, or null. Link resolution needs the file/dir split for blob-vs-tree URLs. */
 export declare function pathKind(candidate: string): "file" | "dir" | null;
-//# sourceMappingURL=discover.d.ts.map

package/dist/src/docs/discover.js

@@ -1,25 +1,6 @@
-/**
- * Doc-root discovery.
- *
- * The one rule of the portal: **a directory publishes its markdown if, and
- * only if, it contains a `docs.json`.** This module finds those directories,
- * validates their declarations, and walks them for publishable pages —
- * skipping any path with a reserved segment (at any depth) and any `README.md`
- * (a README is the directory's GitHub face, not portal content; a root that
- * wants one published names it in `include[]`, the escape hatch).
- *
- * Discovery is purely about *which files* publish. Reading their content —
- * titles, front-matter, links — is assembly's job (`assemble.ts`).
- */
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { docsJsonSchema, hasReservedSegment, slugify } from "./schema.js";
-/**
- * Directories the walk never descends into while LOOKING FOR roots. This list
- * is about walk performance and sanity (`.git`, build output), and is
- * deliberately separate from the reserved list, which is about publish
- * safety. `node_modules` is on both: it is huge, and it must never publish.
- */
 const ROOT_WALK_SKIP = new Set([
     ".git",
     "node_modules",
@@ -33,21 +14,13 @@ const ROOT_WALK_SKIP = new Set([
     ".vercel",
     ".wrangler",
 ]);
-/**
- * The route a page gets inside its section: the path relative to the root,
- * each segment slugified, the `.md` dropped, and a trailing `index` collapsed
- * so a directory's index page serves at the directory's route.
- */
 export function routePathFor(relPath) {
     const withoutExt = relPath.replace(/\.md$/i, "");
     const parts = withoutExt.split("/").map(slugify);
-    // A trailing `index` segment collapses: the file serves at its directory's
-    // route (a root-level index.md is the section's own landing page).
     if (parts[parts.length - 1] === "index")
         parts.pop();
     return parts.join("/");
 }
-/** Recursively collect `*.md` files under `dir`, skipping reserved segments. */
 function walkMarkdown(absDir, relDir, errors, rootDir) {
     const out = [];
     let entries;
@@ -60,9 +33,6 @@ function walkMarkdown(absDir, relDir, errors, rootDir) {
     for (const entry of entries) {
         const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
         if (hasReservedSegment(entry.name)) {
-            // Reserved names are silently skipped in the walk — exclusion here is
-            // the normal case, not an error. The gate separately asserts that
-            // nothing reserved ever reaches the OUTPUT (fail-closed).
             continue;
         }
         const abs = path.join(absDir, entry.name);
@@ -72,29 +42,18 @@ function walkMarkdown(absDir, relDir, errors, rootDir) {
             out.push(...walkMarkdown(abs, rel, errors, rootDir));
         }
         else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-            // A README is the directory's GitHub face — it does not publish via the
-            // walk. The include[] escape hatch is how a README becomes a page.
             if (entry.name.toLowerCase() === "readme.md")
                 continue;
             out.push(rel);
         }
         else if (entry.isFile() &&
             entry.name === "docs.json" &&
-            relDir !== "" // the root's own docs.json is the declaration, not content
-        ) {
+            relDir !== "") {
             errors.push(`nested doc root: ${rootDir}/.../${rel} — a docs.json inside another doc root is ambiguous; give it its own sibling root or remove it`);
         }
     }
     return out;
 }
-/**
- * Find every doc root under `repoRoot`, validate it, and collect its pages.
- *
- * The walk looks for `docs.json` files anywhere in the repo (excluding the
- * ROOT_WALK_SKIP directories), so a package opts in by adding one file and
- * nothing else. Roots are sorted by (order, title); pages within a root are
- * sorted by route path so assembly is deterministic.
- */
 export function discoverDocRoots(repoRoot) {
     const errors = [];
     const roots = [];
@@ -110,20 +69,13 @@ export function discoverDocRoots(repoRoot) {
         if (hasDocsJson) {
             const rel = relDir || ".";
             if (insideReserved || (relDir && hasReservedSegment(relDir))) {
-                // Fail-closed: a root under a reserved directory is the "mistake one"
-                // half of the leak scenario. Refusing it here means even a deliberate
-                // docs.json in docs/plans/ publishes nothing.
                 errors.push(`doc root ${rel}/ is under a reserved segment — it publishes nothing. Move the content out of the reserved directory instead.`);
             }
             else {
                 const root = loadRoot(absDir, rel, errors);
-                // An invalid declaration publishes NOTHING — assembling pages under a
-                // guessed title/slug could put content at routes nobody reviewed.
                 if (root)
                     roots.push(root);
             }
-            // Never look for further roots inside a claimed root — a nested
-            // docs.json is reported by the page walk instead (ambiguous ownership).
             return;
         }
         for (const entry of entries) {
@@ -131,9 +83,6 @@ export function discoverDocRoots(repoRoot) {
                 continue;
             if (ROOT_WALK_SKIP.has(entry.name))
                 continue;
-            // Dot-directories are tooling, not content — ALL of them, so a
-            // .pi/docs.json is skipped here exactly like a .claude one. The page
-            // walk does the same, so a root found there could never publish anyway.
             if (entry.name.startsWith("."))
                 continue;
             const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
@@ -171,20 +120,16 @@ export function discoverDocRoots(repoRoot) {
                 continue;
             }
             if (pages.some((p) => p.source === normalized))
-                continue; // walked already
+                continue;
             const stem = path.posix.basename(normalized).replace(/\.md$/i, "");
             pages.push({
                 source: normalized,
                 root,
-                // An included README is the section's index page — "a package README
-                // is its natural overview page". Anything else routes by its stem.
                 routePath: stem.toLowerCase() === "readme" ? "" : slugify(stem),
                 included: true,
             });
         }
     }
-    // Route collisions are authoring mistakes two files cannot both survive —
-    // catch them at discovery so the failure names both sources.
     const seenRoutes = new Map();
     for (const page of pages) {
         const route = [page.root.slug, page.routePath].filter(Boolean).join("/");
@@ -198,7 +143,6 @@ export function discoverDocRoots(repoRoot) {
         a.config.title.localeCompare(b.config.title));
     return { roots, pages, errors };
 }
-/** Parse and validate one root's docs.json. Returns null (and records why) when invalid — an invalid declaration publishes nothing. */
 function loadRoot(absDir, relDir, errors) {
     const configPath = path.join(absDir, "docs.json");
     let raw;
@@ -220,7 +164,6 @@ function loadRoot(absDir, relDir, errors) {
     const slug = config.slug ?? slugify(config.title);
     return { dir: relDir, config, slug };
 }
-/** What exists at `candidate`, or null. Link resolution needs the file/dir split for blob-vs-tree URLs. */
 export function pathKind(candidate) {
     try {
         const stat = statSync(candidate);
@@ -230,4 +173,3 @@ export function pathKind(candidate) {
         return null;
     }
 }
-//# sourceMappingURL=discover.js.map

package/dist/src/docs/portal.d.ts

@@ -1,58 +1,20 @@
-/**
- * `mesh docs portal` — assemble the developer portal from the repo's
- * docs.json-discovered markdown and hand it to the renderer (Zudoku) to build
- * or serve.
- *
- * Modes:
- *
- *   mesh docs portal                 assemble → `zudoku build` → apps/docs/dist
- *   mesh docs portal --serve         assemble → `zudoku dev` (local preview)
- *   mesh docs portal --assemble-only assemble and stop (content/, config,
- *                                    manifests) — what CI runs before `build`
- *   mesh docs portal --check         the CI gate: assemble to a scratch dir and
- *                                    fail on any of the four assertions below
- *
- * The four --check assertions, any of which exits non-zero:
- *   1. a docs.json fails schema validation (or any other discovery error)
- *   2. an assembled output path contains a reserved segment (fail-closed —
- *      internal material must never be publishable)
- *   3. an internal link resolves to nothing
- *   4. the committed CLI reference is stale (the command tree drifted)
- *
- * Assembly always writes `publish-manifest.json` — every source path that
- * made it into the site — which CI uploads as an artifact; on PRs
- * `--diff-base <ref>` also prints the added/removed published paths into the
- * GitHub job summary.
- */
 import type { AssembleResult } from "./assemble.js";
-/** The Zudoku app package directory, relative to the repo root. */
 export declare const DOCS_APP_DIR = "apps/docs";
 export interface PortalRunResult {
     assembled: AssembleResult;
     errors: string[];
 }
-/**
- * Run discovery + assembly. Shared by every mode; the scratch-dir variant is
- * what --check uses so the gate never depends on (or dirties) apps/docs.
- */
 export declare function runAssemble(args: {
     repoRoot: string;
     outDir: string;
     configOut?: string;
     writeFiles?: boolean;
 }): PortalRunResult;
-/** Print the assembly report: counts, external-link note, broken-link list. */
 export declare function reportAssembly(result: PortalRunResult): void;
-/**
- * The --check gate. Returns the failure list (empty = pass). Also writes the
- * job-summary publish-set diff when --diff-base names a ref and
- * GITHUB_STEP_SUMMARY is writable.
- */
 export declare function checkPortal(args: {
     repoRoot: string;
     diffBase?: string | undefined;
     printManifest?: boolean;
-    /** Stable path to write publish-manifest.json to (CI uploads it as an artifact). */
     manifestOut?: string | undefined;
     checkCliReference: () => Promise<string | null>;
 }): Promise<string[]>;
@@ -66,14 +28,8 @@ export interface PortalCommandOptions {
     diffBase?: string | undefined;
     manifestOut?: string | undefined;
 }
-/**
- * The command body. Kept free of commander types so the test suite can drive
- * it directly; `commands/docs.ts` is a thin flag adapter.
- */
 export declare function runPortalCommand(opts: PortalCommandOptions, deps: {
     repoRoot: string;
     checkCliReference: () => Promise<string | null>;
 }): Promise<void>;
-/** Re-exported so commands/docs.ts can wire the CLI-reference staleness check. */
 export declare function cliReferenceStaleness(repoRoot: string): Promise<string | null>;
-//# sourceMappingURL=portal.d.ts.map

package/dist/src/docs/portal.js

@@ -1,29 +1,3 @@
-/**
- * `mesh docs portal` — assemble the developer portal from the repo's
- * docs.json-discovered markdown and hand it to the renderer (Zudoku) to build
- * or serve.
- *
- * Modes:
- *
- *   mesh docs portal                 assemble → `zudoku build` → apps/docs/dist
- *   mesh docs portal --serve         assemble → `zudoku dev` (local preview)
- *   mesh docs portal --assemble-only assemble and stop (content/, config,
- *                                    manifests) — what CI runs before `build`
- *   mesh docs portal --check         the CI gate: assemble to a scratch dir and
- *                                    fail on any of the four assertions below
- *
- * The four --check assertions, any of which exits non-zero:
- *   1. a docs.json fails schema validation (or any other discovery error)
- *   2. an assembled output path contains a reserved segment (fail-closed —
- *      internal material must never be publishable)
- *   3. an internal link resolves to nothing
- *   4. the committed CLI reference is stale (the command tree drifted)
- *
- * Assembly always writes `publish-manifest.json` — every source path that
- * made it into the site — which CI uploads as an artifact; on PRs
- * `--diff-base <ref>` also prints the added/removed published paths into the
- * GitHub job summary.
- */
 import { spawn } from "node:child_process";
 import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
@@ -31,7 +5,6 @@ import path from "node:path";
 import { logError, logInfo, logSuccess, logWarn } from "../utils/log.js";
 import { assemblePortal, currentBaseline, currentCommit, diffPublishSets, publishSetAtRef, renderPublishSetSummary, renderVersionJson, renderZudokuConfig, } from "./assemble.js";
 import { discoverDocRoots } from "./discover.js";
-/** The Zudoku app package directory, relative to the repo root. */
 export const DOCS_APP_DIR = "apps/docs";
 const CONTENT_DIR = "content";
 const GENERATED_CONFIG = "zudoku.config.ts";
@@ -40,10 +13,6 @@ const VERSION_JSON_DIR = "public";
 const VERSION_JSON = "version.json";
 const SITE_TITLE = "Mesh Developer Portal";
 const SITE_DESCRIPTION = "Build and run financial-services apps on Mesh Platform with the mesh developer CLI.";
-/**
- * Run discovery + assembly. Shared by every mode; the scratch-dir variant is
- * what --check uses so the gate never depends on (or dirties) apps/docs.
- */
 export function runAssemble(args) {
     const discovery = discoverDocRoots(args.repoRoot);
     const assembled = assemblePortal({
@@ -55,10 +24,6 @@ export function runAssemble(args) {
     });
     const errors = [...discovery.errors];
     if (args.writeFiles !== false) {
-        // The manifest lands BESIDE the content dir for a real assemble
-        // (apps/docs/publish-manifest.json — gitignored derived state) and INSIDE
-        // the scratch dir for a --check run, so concurrent checks never share a
-        // file and nothing is written loose to the tmpdir root.
         const manifestPath = args.outDir.includes(tmpdir())
             ? path.join(args.outDir, PUBLISH_MANIFEST)
             : path.join(args.outDir, "..", PUBLISH_MANIFEST);
@@ -82,7 +47,6 @@ export function runAssemble(args) {
     }
     return { assembled, errors };
 }
-/** Print the assembly report: counts, external-link note, broken-link list. */
 export function reportAssembly(result) {
     const { assembled } = result;
     logSuccess(`Assembled ${assembled.pages.length} pages from ${new Set(assembled.pages.map((p) => p.sectionTitle)).size} sections → ${assembled.outDir}`);
@@ -97,11 +61,6 @@ export function reportAssembly(result) {
         }
     }
 }
-/**
- * The --check gate. Returns the failure list (empty = pass). Also writes the
- * job-summary publish-set diff when --diff-base names a ref and
- * GITHUB_STEP_SUMMARY is writable.
- */
 export async function checkPortal(args) {
     const scratch = mkdtempSync(path.join(tmpdir(), "mesh-docs-check-"));
     const result = runAssemble({ repoRoot: args.repoRoot, outDir: scratch });
@@ -128,7 +87,6 @@ export async function checkPortal(args) {
     }
     return failures;
 }
-/** Diff the publish set against a git ref; print + append to the GH job summary. */
 function writePublishSetSummary(repoRoot, diffBase, manifest) {
     let diff = null;
     try {
@@ -150,7 +108,6 @@ function writePublishSetSummary(repoRoot, diffBase, manifest) {
         }
     }
 }
-/** Spawn the renderer. Returns its exit code. */
 function runZudoku(args) {
     const cliArgs = args.mode === "dev"
         ? ["dev", "--port", String(args.port ?? 3000)]
@@ -166,10 +123,6 @@ function runZudoku(args) {
         child.on("close", (code) => resolve(code ?? 1));
     });
 }
-/**
- * The command body. Kept free of commander types so the test suite can drive
- * it directly; `commands/docs.ts` is a thin flag adapter.
- */
 export async function runPortalCommand(opts, deps) {
     const { repoRoot } = deps;
     if (opts.check) {
@@ -226,7 +179,6 @@ export async function runPortalCommand(opts, deps) {
         logSuccess(`Portal built → ${path.join(path.relative(repoRoot, appDir), "dist")}`);
     }
 }
-/** Re-exported so commands/docs.ts can wire the CLI-reference staleness check. */
 export async function cliReferenceStaleness(repoRoot) {
     const [{ createProgram }, { extractCliReference, renderCliReferenceMarkdown },] = await Promise.all([
         import("../program.js"),
@@ -239,4 +191,3 @@ export async function cliReferenceStaleness(repoRoot) {
         return null;
     return `${existing === null ? "CLI reference is missing" : "CLI reference is stale"}: docs/portal/generated/cli-reference.md — the commander tree changed; regenerate and commit with \`pnpm exec mesh docs cli-reference\``;
 }
-//# sourceMappingURL=portal.js.map

package/dist/src/docs/registry-docs.d.ts

@@ -1,43 +1,14 @@
-/**
- * The docs-as-registry-artifact client.
- *
- * The release job publishes the built portal as `@mesh-tech/docs` in the
- * fixed lockstep group, so the docs version IS the @mesh-tech/* baseline
- * version it describes. The audience is exactly "people who can install the
- * packages": the CodeArtifact registry is Zitadel-role-gated (see
- * `mesh registry login`), so no public hosting is required for the docs to
- * reach precisely the authorized set.
- *
- * This module reads the user's existing `~/.npmrc` CodeArtifact token (the
- * one `mesh registry login` writes), lists published docs versions, and
- * fetches + caches a version's tarball. It never talks to AWS directly.
- */
 export declare const DOCS_PACKAGE = "@mesh-tech/docs";
 export interface DocsRegistryAuth {
     endpoint: string;
     token: string;
 }
-/** The CodeArtifact token + endpoint from `mesh registry login`'s ~/.npmrc line. */
 export declare function readDocsRegistryAuth(npmrcPath?: string): DocsRegistryAuth | null;
-/** x.y.z numeric compare (release versions carry no prerelease suffixes). */
 export declare function compareVersions(a: string, b: string): number;
 export interface DocsVersionList {
     versions: string[];
     latest: string | undefined;
 }
-/**
- * Every published docs version, oldest → newest, plus the registry's
- * `latest` dist-tag. Throws with the login remediation when the registry
- * rejects the token — an expired token is the common case (12h TTL).
- */
 export declare function listDocsVersions(auth: DocsRegistryAuth, fetchImpl?: typeof fetch): Promise<DocsVersionList>;
-/** Where fetched docs versions live: `~/.cache/mesh/docs/<version>/`. */
 export declare function docsCacheRoot(): string;
-/**
- * Fetch and extract a docs version into the cache; returns the directory
- * containing the site's `dist/`. Cache hit = the directory already has a
- * `dist/index.html`. Partial downloads extract to a temp sibling and rename,
- * so an interrupted fetch never leaves a half-written "good" cache entry.
- */
 export declare function fetchDocsArtifact(auth: DocsRegistryAuth, version: string, cacheRoot?: string, fetchImpl?: typeof fetch): Promise<string>;
-//# sourceMappingURL=registry-docs.d.ts.map