gh-inari 0.7.0 → 0.9.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "inari",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Governed GitHub Issue/PR/template workflows via the inari CLI. Prefer inari over raw gh for operations it owns; use inari skill for operational playbooks.",
   "skills": "skills/inari"
 }

package/README.md

@@ -129,6 +129,16 @@ marketplace registration and installation via Codex plugin commands to
 activate the skill; standard `npm install` alone does not automatically
 surface the plugin to Codex-aware agents.
 
+To discover and install it from this repository's marketplace:
+
+```bash
+codex plugin marketplace add .
+```
+
+In Codex, run `/plugins`, select the `gh-inari` marketplace, and install
+`inari`. Start a new Codex session after installation so the bundled Skill
+is available.
+
 The Skill is deliberately thin: it identifies governed GitHub Issue/PR/
 template workflows as Inari-owned and routes agents to `inari skill` /
 `inari skill <scenario>` for the actual operational playbooks, and to
@@ -156,8 +166,8 @@ inari issue get <number> [--template <template>] --json
 inari pr get <number> [--template <template>] --json
 inari issue check <number> [--template <template>]
 inari pr check <number> [--template <template>]
-inari issue edit <number> --from patch.json [--dry-run]
-inari pr edit <number> --from patch.json [--dry-run]
+inari issue edit <number> [--from patch.json] [--field name=value] [--title title] [--dry-run]
+inari pr edit <number> [--from patch.json] [--field name=value] [--title title] [--base branch] [--maintainer-can-modify] [--dry-run]
 inari issue normalize <number> [--dry-run]
 inari pr normalize <number> [--dry-run]
 inari issue sync <number> --from desired.json [--dry-run]
@@ -174,7 +184,14 @@ inari pr sync <number> --from desired.json [--dry-run]
 }
 ```
 
-The `fields` object is the semantic input contract shown by `schema`. Issue creation also accepts `assignees`; pull request creation accepts `head`, `base`, `draft`, and `maintainerCanModify`. `--title`, `--head`, and `--base` override envelope metadata.
+The `fields` object is the semantic input contract shown by `schema`; the same schema output exposes the separate required create metadata schema. Issue creation also accepts `assignees`; pull request creation accepts `head`, `base`, `draft`, and `maintainerCanModify`. Caller-supplied `title` metadata is required for both create commands, and `--title`, `--head`, and `--base` override envelope metadata. Existing `edit` commands use the remote artifact as their patch base: `--title` is supported for Issues and pull requests, while pull requests also support `--base` and `--maintainer-can-modify`; `--draft` is rejected for edit because pull-request PATCH does not accept it. Omitted values are preserved and unsupported or immutable metadata is rejected.
+
+`pr sync --from` accepts a complete pull-request desired-state envelope. Use
+`inari pr sync --help` for the top-level contract, or
+`inari pr schema <template> --json` for its machine-readable `syncInput.schema`
+and a valid `syncInput.minimalExample`.
+`issue sync --from` overlays supplied semantic fields and metadata onto the
+current artifact, preserving values omitted from the input.
 
 Schema and validation output is JSON. `--json` makes render and create output JSON as well. Validation failures return exit status `2`; usage errors return `1`; GitHub/transport failures return `3`. Error objects contain stable `code`, `path` where applicable, and ordered `violations`.
 
@@ -185,25 +202,33 @@ parse the existing artifact with the same parser and semantic validator as
 metadata. Successful reads report `projection: "canonical"`; wrong-template,
 unparseable, ambiguous, and semantically invalid artifacts report structured
 diagnostics with `projection: "unavailable"` and never return guessed fields.
-When `--template` is omitted, all supported candidates are evaluated
+When `--template` is omitted, Inari first looks for the bounded invisible
+template identity marker every rendered artifact now carries. A valid marker
+resolves the contract directly; an unknown, stale, or wrong-kind marker fails
+closed with a diagnostic instead of guessing another template. Artifacts
+without a marker fall back to evaluating all supported candidates
 deterministically; multiple structural matches fail closed. Native template
 boilerplate and raw Markdown are intentionally absent from successful output.
 
 Existing artifact remediation uses one semantic pipeline for both Issues and
 pull requests. `check` is read-only and classifies an artifact as
 `valid-current`, `non-canonical`, `semantically-invalid`, `unsupported`, or
-`ambiguous`. `edit` applies only an explicit semantic patch from JSON; it never
-accepts raw Markdown as the mutation contract. `normalize` re-renders a
+`ambiguous`. `edit` applies an explicit semantic/metadata patch from JSON or
+direct CLI options; it never accepts raw Markdown as the mutation contract. `normalize` re-renders a
 parseable, semantically valid artifact and fails closed when preservation is
-not proven. `sync` treats its input as the complete desired semantic state and
-reconciles the canonical projection deterministically. A successful no-op is
+not proven. `issue sync` overlays its input onto the current canonical state,
+while `pr sync` treats its input as the complete desired semantic state; both
+reconcile the canonical projection deterministically. A successful no-op is
 reported explicitly, and `--dry-run` returns a bounded semantic/rendered diff
-without calling a GitHub mutation.
+plus the validated resulting fields, metadata, and canonical body without
+calling a GitHub mutation.
 
 ## Source of truth and supported semantics
 
 `.github/ISSUE_TEMPLATE/**` remains the Issue source of truth. For pull requests, Inari discovers GitHub's supported repository locations: `pull_request_template` files under the repository root, `docs/`, or `.github/`, plus `PULL_REQUEST_TEMPLATE/` directories under each location. Native PR template filenames and the `.md`/`.txt` extensions supported by Inari are matched case-insensitively. Other PR-template extension surfaces are intentionally unsupported in v1 and fail closed. Inari discovers and compiles those files; it does not replace them with a proprietary body schema. Supported Issue Form nodes are `input`, `textarea` (including native `render` code fences), single- and multi-select `dropdown`, `checkboxes`, and `markdown`. Browser-only or ambiguous behavior, such as uploads or unsupported textarea rendering modes, fails closed. Markdown nodes are retained for contract/schema explainability but never emitted into an Issue body.
 
+Issue dependencies are a separate, template-independent semantic object. Structured Issue envelopes may provide `dependencies.blockedBy` and `dependencies.blocks`; each reference is the canonical `{ "repositoryHost": "github.com", "repositoryId": "<decimal REST repository database id>", "repository": "owner/name", "number": N }` identity. `repositoryHost` plus `repositoryId` is authoritative: the host/install boundary prevents IDs from different GH_HOST/GHES installations colliding. Within one host, rename/transfer preserves the repository identity tuple and changes only the optional locator; cross-host migration is a different identity. The GitHub adapter obtains this decimal ID from the REST repository endpoint through `gh api`, including for repository overrides through a read-only identity lookup; a context that cannot obtain it does not synthesize one from owner/name. Inari sorts and validates these references (including duplicate, self, malformed, and contradictory declarations) before rendering. Non-empty dependencies are preserved in a bounded reserved body marker and projected back as normalized JSON; ordinary Markdown and GitHub-native dependency metadata are never inferred as semantic input. GitHub-native dependency state is not currently mutated by Inari, so there is no competing authority or implicit drift reconciliation.
+
 Native PR Markdown expresses structure but not policy. A small versioned overlay may add constraints unavailable in Markdown without changing section order or content. The supported v1 form is:
 
 ```yaml
@@ -235,7 +260,7 @@ templates:
 
 Template and section bindings are deterministic. Stale, unknown, or ambiguous template/section references fail closed. `linkedIssue: true` means that the field contains a GitHub closing reference: `close`, `closes`, `closed`, `fix`, `fixes`, `fixed`, `resolve`, `resolves`, or `resolved`, followed by `#ISSUE-NUMBER` or `OWNER/REPOSITORY#ISSUE-NUMBER`, with an optional colon and case-insensitive keyword. This validates syntax only; GitHub applies automatic linking/closure only under its own contextual rules, including the target default branch.
 
-Issue Form top-level `title` is the exact default title used when the caller omits a title; an explicit caller title replaces it without inferred prefix concatenation. Top-level `labels` are repository-governed defaults and are always retained; caller-supplied labels are appended in order with duplicates removed. Top-level `assignees`, `projects`, and `type`, and upload fields remain unsupported and fail closed rather than being approximated.
+Issue Form top-level `title` is a fixed native prefix for create validation, but it does not satisfy the caller's required title metadata by itself. An explicit caller title is used as supplied without inferred prefix concatenation or automatic generation. Top-level `labels` are repository-governed defaults and are always retained; caller-supplied labels are appended in order with duplicates removed. Top-level `assignees`, `projects`, and `type`, and upload fields remain unsupported and fail closed rather than being approximated.
 
 ## Scope
 

package/dist/artifact.d.ts

@@ -1,5 +1,7 @@
-import { type SemanticValidationResult, type SemanticViolation } from "./contract/validation.js";
-import { type CanonicalContract } from "./contract/ir.js";
+import { type PartialSemanticValidationResult, type PartialSemanticRepairResult, type SemanticValidationResult, type SemanticViolation } from "./contract/validation.js";
+import { type ArtifactDiagnostic, type ArtifactDiagnosticReport } from "./diagnostics.js";
+import { type ArtifactKind, type CanonicalContract } from "./contract/ir.js";
+import { type IssueDependencies, type IssueReference } from "./contract/issue-reference.js";
 import { type ValidatedRenderedIssueArtifact, type ValidatedRenderedPullRequestArtifact } from "./github/types.js";
 export interface ArtifactInputMetadata {
     readonly title?: string;
@@ -13,31 +15,66 @@ export interface ArtifactInputMetadata {
 export interface ArtifactInputDocument {
     readonly fields: Readonly<Record<string, unknown>>;
     readonly metadata: ArtifactInputMetadata;
+    /** Generic Issue relationships, independent of template-specific fields. */
+    readonly dependencies?: IssueDependencies;
+}
+/**
+ * A representation-independent candidate entering the canonical contract.
+ * Adapters may decode JSON, native Markdown, an existing GitHub body, or
+ * internal field input, but they never validate or materialize contract
+ * semantics themselves.
+ */
+export type ArtifactCandidateSource = "json" | "markdown" | "existing" | "fields";
+export interface ArtifactCandidate {
+    readonly fields: unknown;
+    readonly metadata: ArtifactInputMetadata;
+    readonly source: ArtifactCandidateSource;
+    readonly dependencies?: IssueDependencies;
+}
+export interface ArtifactCandidateAdapterResult {
+    readonly parsed: boolean;
+    readonly candidate?: ArtifactCandidate;
+    readonly diagnostics: readonly ExistingArtifactDiagnostic[];
+}
+/** Result of the one candidate -> selected contract -> canonical JSON boundary. */
+export interface CanonicalArtifactLoadResult {
+    readonly valid: boolean;
+    readonly complete: boolean;
+    /** Canonical contract-shaped semantic JSON. Never contains rejected fields. */
+    readonly canonical: Readonly<Record<string, unknown>>;
+    /** Explicit alias for callers that name the output canonical JSON. */
+    readonly canonicalJson: Readonly<Record<string, unknown>>;
+    /** Backward-compatible semantic value name used by renderer callers. */
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly candidate: ArtifactCandidate;
+    readonly acceptedFields: readonly string[];
+    readonly missingFields: PartialSemanticValidationResult["missingFields"];
+    readonly invalidFields: PartialSemanticValidationResult["invalidFields"];
+    readonly diagnostics: ArtifactDiagnosticReport;
+    readonly violations: readonly SemanticViolation[];
+    readonly dependencies?: IssueDependencies;
 }
 export interface ArtifactMetadataViolation {
     readonly code: "INPUT_METADATA_INVALID";
     readonly path: string;
     readonly message: string;
 }
-export type ArtifactInputErrorCode = "INPUT_DOCUMENT_INVALID" | "INPUT_METADATA_INVALID";
+export type ArtifactInputErrorCode = "INPUT_DOCUMENT_INVALID" | "INPUT_METADATA_INVALID" | "INPUT_DEPENDENCIES_INVALID";
 export declare class ArtifactInputError extends Error {
     readonly code: ArtifactInputErrorCode;
     readonly path: string;
-    constructor(code: ArtifactInputErrorCode, message: string, path?: string);
+    readonly details?: unknown;
+    constructor(code: ArtifactInputErrorCode, message: string, path?: string, details?: unknown);
 }
 export type ArtifactPreparationErrorCode = "ARTIFACT_PROVENANCE_MISSING" | "ARTIFACT_ROUND_TRIP_INVALID";
-export type ArtifactRoundTripDiagnosticCode = "ROUND_TRIP_PARSE" | "ROUND_TRIP_SEMANTIC" | "ROUND_TRIP_MISMATCH";
-export interface ArtifactRoundTripDiagnostic {
-    readonly code: ArtifactRoundTripDiagnosticCode;
-    readonly path: string;
-    readonly message: string;
-    readonly expected?: unknown;
-    readonly actual?: unknown;
-}
+/** @deprecated Round-trip diagnostics use the shared #118 diagnostic contract. */
+export type ArtifactRoundTripDiagnostic = ArtifactDiagnostic;
+/** @deprecated Use ArtifactDiagnosticCode/ArtifactDiagnosticDetailCode. */
+export type ArtifactRoundTripDiagnosticCode = ArtifactDiagnostic["code"];
 /** Stable failures raised before a mutation-capable artifact is created. */
 export declare class ArtifactPreparationError extends Error {
     readonly code: ArtifactPreparationErrorCode;
-    readonly diagnostics: readonly ArtifactRoundTripDiagnostic[];
+    readonly diagnostics: readonly ArtifactDiagnostic[];
     constructor(code: ArtifactPreparationErrorCode, message: string, diagnostics?: readonly ArtifactRoundTripDiagnostic[]);
 }
 export interface PreparedIssueArtifact {
@@ -51,7 +88,7 @@ export interface PreparedPullRequestArtifact {
     readonly artifact: ValidatedRenderedPullRequestArtifact;
 }
 export type ExistingArtifactClassification = "valid" | "semantic" | "wrong-template" | "unparseable" | "ambiguous";
-export type ExistingArtifactDiagnosticCode = "EXISTING_WRONG_TEMPLATE" | "EXISTING_UNPARSEABLE" | "EXISTING_EXTRA_CONTENT" | "EXISTING_UNKNOWN_CHECKLIST_ITEM" | "EXISTING_AMBIGUOUS_TEMPLATE" | "EXISTING_NON_CANONICAL" | "EXISTING_TEMPLATE_COMPILE_FAILED";
+export type ExistingArtifactDiagnosticCode = "EXISTING_WRONG_TEMPLATE" | "EXISTING_UNPARSEABLE" | "EXISTING_EXTRA_CONTENT" | "EXISTING_UNKNOWN_CHECKLIST_ITEM" | "EXISTING_AMBIGUOUS_TEMPLATE" | "EXISTING_NON_CANONICAL" | "EXISTING_TEMPLATE_COMPILE_FAILED" | "EXISTING_TEMPLATE_MARKER_INVALID";
 export interface ExistingArtifactDiagnostic {
     readonly code: ExistingArtifactDiagnosticCode;
     readonly path: string;
@@ -60,6 +97,19 @@ export interface ExistingArtifactDiagnostic {
 export interface ExistingArtifactParseResult {
     readonly parsed: boolean;
     readonly values: Readonly<Record<string, unknown>>;
+    readonly dependencies?: IssueDependencies;
+    /** Raw dependency declaration retained for the semantic validation boundary. */
+    readonly dependencyInput?: unknown;
+    readonly diagnostics: readonly ExistingArtifactDiagnostic[];
+}
+/**
+ * Semantic values recovered from an artifact that did not pass the strict
+ * structural parser. Values are extracted only from unambiguous contract
+ * sections and are still subject to the canonical semantic loader before use.
+ */
+export interface RecoverableArtifactValues {
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly dependencies?: IssueDependencies;
     readonly diagnostics: readonly ExistingArtifactDiagnostic[];
 }
 export interface ExistingArtifactValidationResult {
@@ -74,6 +124,8 @@ export interface ExistingIssueReader {
     getIssue(issueNumber: number): Promise<{
         readonly body: string | null;
         readonly url: string;
+        readonly repositoryId?: string;
+        readonly repositoryHost?: string;
     }>;
 }
 export interface ExistingPullRequestReader {
@@ -82,6 +134,51 @@ export interface ExistingPullRequestReader {
         readonly url: string;
     }>;
 }
+/**
+ * Bounded invisible template identity marker embedded in newly rendered
+ * artifacts. It is the primary template-selection signal for governed
+ * read/repair/validation; legacy artifacts without a marker (or with one
+ * that cannot be trusted) fall back to deterministic structural matching.
+ * The marker is metadata only: it never substitutes for the authoritative
+ * repository governance/provenance that resolves the actual contract.
+ */
+export declare const TEMPLATE_IDENTITY_MARKER_VERSION: "1";
+export declare const ISSUE_DEPENDENCY_MARKER_VERSION: "1";
+export interface TemplateIdentityMarker {
+    readonly version: string;
+    readonly kind: ArtifactKind;
+    readonly path: string;
+}
+export type TemplateIdentityMarkerStatus = "absent" | "valid" | "malformed" | "unsupported-version";
+export interface TemplateIdentityMarkerExtraction {
+    readonly status: TemplateIdentityMarkerStatus;
+    readonly marker?: TemplateIdentityMarker;
+    /** Body with a recognized trailing marker line removed; unchanged when none is present. */
+    readonly body: string;
+}
+export type IssueDependencyMarkerStatus = "absent" | "valid" | "malformed" | "unsupported-version";
+export interface IssueDependencyMarkerExtraction {
+    readonly status: IssueDependencyMarkerStatus;
+    readonly dependencies?: IssueDependencies;
+    /** Body with a recognized trailing dependency marker removed. */
+    readonly body: string;
+}
+/**
+ * Read only the reserved trailing dependency marker emitted by Inari.  No
+ * ordinary Markdown is interpreted as a relationship declaration.
+ */
+export declare function extractIssueDependencyMarker(body: string): IssueDependencyMarkerExtraction;
+/**
+ * Recognize and remove a trailing template identity marker line without
+ * applying semantic parsing. Only a line starting with the exact reserved
+ * marker prefix is treated as a marker attempt at all; ordinary trailing
+ * HTML comments (e.g. PR template scaffolding) are left untouched here and
+ * handled by the existing comment-stripping path. Once the reserved prefix
+ * is detected, the line is never silently ignored as "absent" again: an
+ * oversized, truncated, or otherwise broken marker attempt fails closed as
+ * "malformed" instead of falling through to structural matching.
+ */
+export declare function extractTemplateIdentityMarker(body: string): TemplateIdentityMarkerExtraction;
 export interface FetchedExistingArtifact {
     readonly number: number;
     readonly url: string;
@@ -89,6 +186,41 @@ export interface FetchedExistingArtifact {
 }
 /** Parse the documented JSON input envelope while keeping field semantics adapter-independent. */
 export declare function parseArtifactInputDocument(input: unknown): ArtifactInputDocument;
+/** Adapt a parsed JSON envelope without granting it canonical status. */
+export declare function adaptJsonArtifactCandidate(input: unknown): ArtifactCandidate;
+/** Adapt internal structured fields to the same candidate shape as JSON. */
+export declare function adaptFieldArtifactCandidate(fields: unknown, metadata?: ArtifactInputMetadata): ArtifactCandidate;
+/** Alias used by command adapters that call this input the CLI field path. */
+export declare const adaptCliFieldCandidate: typeof adaptFieldArtifactCandidate;
+/** Generic adapter spelling for callers that already hold structured fields. */
+export declare const adaptArtifactCandidate: typeof adaptFieldArtifactCandidate;
+/** Adapt an existing native artifact body through the repository parser. */
+export declare function adaptMarkdownArtifactCandidate(contractInput: unknown, body: string | null | undefined): ArtifactCandidateAdapterResult;
+/** Existing GitHub bodies use the same native Markdown adapter by design. */
+export declare function adaptExistingArtifactCandidate(contractInput: unknown, body: string | null | undefined): ArtifactCandidateAdapterResult;
+/**
+ * Reload a candidate against the selected canonical contract.  Complete input
+ * takes the normal one-pass validator (and therefore may materialize contract
+ * defaults); incomplete/invalid input uses the bounded partial contract and
+ * exposes only accepted semantic values.
+ */
+export declare function loadCanonicalArtifact(contractInput: unknown, candidateInput: unknown): CanonicalArtifactLoadResult;
+/** Explicitly named alias for callers that pass a candidate object. */
+export declare const loadCanonicalCandidate: typeof loadCanonicalArtifact;
+/** Load a JSON representation through the canonical contract boundary. */
+export declare function loadCanonicalJsonArtifact(contractInput: unknown, input: unknown): CanonicalArtifactLoadResult;
+/** Load native Markdown through the same parser and canonical contract. */
+export declare function loadCanonicalMarkdownArtifact(contractInput: unknown, body: string | null | undefined): CanonicalArtifactLoadResult;
+/** Existing-body spelling retained so read/repair callers share one boundary. */
+export declare function loadCanonicalExistingArtifact(contractInput: unknown, body: string | null | undefined): CanonicalArtifactLoadResult;
+/** Classify an artifact input envelope without applying semantic defaults. */
+export declare function validatePartialArtifactInput(contractInput: unknown, input: unknown): PartialSemanticValidationResult;
+/** Terminology alias for callers that treat validation as classification. */
+export declare const classifyPartialArtifactInput: typeof validatePartialArtifactInput;
+/** Merge only a targeted field patch into a prior stateless partial result. */
+export declare function repairPartialArtifactInput(contractInput: unknown, previous: unknown, patch?: unknown): PartialSemanticRepairResult;
+/** Terminology alias for callers that describe targeted repair as a merge. */
+export declare const mergePartialArtifactInput: typeof repairPartialArtifactInput;
 export declare function renderIssueArtifact(contractInput: unknown, input: unknown): string;
 export declare function renderPullRequestArtifact(contractInput: unknown, input: unknown): string;
 /** Construct the only values accepted by the GitHub mutation adapter. */
@@ -96,7 +228,15 @@ export declare function prepareIssueArtifact(contractInput: unknown, input: Arti
 export declare function preparePullRequestArtifact(contractInput: unknown, input: ArtifactInputDocument): PreparedPullRequestArtifact;
 export declare function parseExistingIssueArtifact(contractInput: unknown, body: string | null | undefined): ExistingArtifactParseResult;
 export declare function parseExistingPullRequestArtifact(contractInput: unknown, body: string | null | undefined): ExistingArtifactParseResult;
-export declare function validateExistingIssueArtifact(contractInput: unknown, body: string | null | undefined): ExistingArtifactValidationResult;
+/**
+ * Recover field values from a malformed or wrong-template body without
+ * weakening the strict existing-artifact parser. The section boundaries and
+ * field decoding are the same parser primitives used by strict parsing; only
+ * the order/complete-structure requirement is relaxed for an explicitly
+ * selected repair target.
+ */
+export declare function recoverExistingArtifactValues(contractInput: unknown, body: string | null | undefined): RecoverableArtifactValues;
+export declare function validateExistingIssueArtifact(contractInput: unknown, body: string | null | undefined, subject?: IssueReference): ExistingArtifactValidationResult;
 export declare function validateExistingPullRequestArtifact(contractInput: unknown, body: string | null | undefined): ExistingArtifactValidationResult;
 export interface ExistingArtifactCandidate {
     readonly contract: CanonicalContract;
@@ -111,6 +251,7 @@ export interface ExistingArtifactProjection {
     readonly projection: "canonical" | "unavailable";
     readonly classification: ExistingArtifactClassification;
     readonly fields?: Readonly<Record<string, unknown>>;
+    readonly dependencies?: IssueDependencies;
     readonly diagnostics: readonly ExistingArtifactDiagnostic[];
     readonly violations?: readonly SemanticViolation[];
     readonly attemptedTemplates?: readonly string[];
@@ -123,6 +264,8 @@ export declare function selectExistingArtifactCandidate(candidates: readonly Exi
 export declare function validateRequiredMetadataString(value: unknown, key: string): ArtifactMetadataViolation | undefined;
 export declare function validateExistingIssueFromAdapter(reader: ExistingIssueReader, contract: unknown, issueNumber: number): Promise<FetchedExistingArtifact>;
 export declare function validateExistingPullRequestFromAdapter(reader: ExistingPullRequestReader, contract: unknown, pullRequestNumber: number): Promise<FetchedExistingArtifact>;
+/** @internal Validate the canonical Issue metadata handoff before mutation. */
+export declare function verifyIssueMetadataRoundTrip(expected: Readonly<Record<string, unknown>>, artifact: ValidatedRenderedIssueArtifact): void;
 /** Escape only Markdown constructs that could change the canonical section structure. */
 export declare function escapeMarkdownValue(value: string): string;
 export declare function removeHtmlComments(value: string): string;