gh-inari 0.1.0 → 0.2.0

package/README.md

@@ -22,6 +22,16 @@ To register the installed package as a GitHub CLI extension, pass its package di
 gh inari --help
 ```
 
+A clean checkout is also a supported extension source:
+
+```bash
+gh extension install yohn-jp/gh-inari
+gh inari --help
+```
+
+The repository launcher uses the committed build and installs its production
+dependencies on first use when GitHub CLI installs directly from the repository.
+
 Inari uses the current `gh` authentication and repository context. It does not maintain a second credential store. Use `--repository owner/name` when the target repository is not the current checkout.
 
 ## Commands
@@ -40,6 +50,8 @@ gh inari issue validate <number> --template <template> --json
 gh inari pr validate <number> --template <template> --json
 gh inari issue explain <number> --template <template> --json
 gh inari pr explain <number> --template <template> --json
+gh inari issue get <number> [--template <template>] --json
+gh inari pr get <number> [--template <template>] --json
 ```
 
 `--from -` reads JSON from stdin. Create input uses an envelope when mutation metadata is needed:
@@ -56,9 +68,20 @@ The `fields` object is the semantic input contract shown by `schema`. Issue crea
 
 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`.
 
+`issue get` and `pr get` are canonical-only v1 reads. They resolve the target
+repository's default-branch governance, select the supported native template,
+parse the existing artifact with the same parser and semantic validator as
+`validate`/`explain`, and emit only canonical `fields` plus minimal artifact
+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
+deterministically; multiple structural matches fail closed. Native template
+boilerplate and raw Markdown are intentionally absent from successful output.
+
 ## Source of truth and supported semantics
 
-`.github/ISSUE_TEMPLATE/**` and `.github/PULL_REQUEST_TEMPLATE*` remain the structural source of truth. Inari discovers and compiles those files; it does not replace them with a proprietary body schema. Supported Issue Form nodes are `input`, `textarea`, single- and multi-select `dropdown`, `checkboxes`, and `markdown`. Browser-only or ambiguous behavior, such as uploads or unsupported textarea rendering modes, fails closed.
+`.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.
 
 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:
 
@@ -77,15 +100,27 @@ sections:
       requireComplete: false
 ```
 
-References must match native section identities (`id`/`sourceId`); stale, unknown, or ambiguous references fail closed. No overlay rule means no inferred requirement.
+One repository policy file can bind several native PR templates with `templates`; every entry in a multi-template policy must identify one template by stable `id`, `path`, or unique `name`:
 
-Issue Form top-level `labels` are preserved as create defaults. Top-level `assignees`, `projects`, and `type`, upload fields, and textarea code-block rendering are explicitly unsupported in v1 and fail closed rather than being approximated.
+```yaml
+version: 1
+templates:
+  - template: default
+    sections: []
+  - template:
+      path: .github/PULL_REQUEST_TEMPLATE/release.md
+    sections: []
+```
+
+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.
 
 ## Scope
 
 Inari owns repository-governed GitHub mutations: it reads repository-native governance, exposes it as machine-readable contracts, validates structured input against that governance, renders the canonical artifact, and performs the corresponding `gh` operation — or rejects it with actionable feedback.
 
-Inari is not a general GitHub CLI wrapper. Generic read/query operations such as `pr view`, `issue view`, diff/search summarization, or token-efficient GitHub inspection are out of scope.
+Inari is not a general GitHub CLI wrapper. Generic read/query operations such as `pr view`, `issue view`, diff/search summarization, or token-efficient GitHub inspection remain out of scope; `get` only reconstructs artifacts that match the repository-governed canonical contract.
 
 ## Safety and existing artifacts
 
@@ -96,7 +131,9 @@ resolve template -> compile contract -> validate semantic JSON
 -> render canonical Markdown -> construct validated-rendered artifact -> call gh
 ```
 
-Schema, validate, and render never call a remote mutation. Invalid, ambiguous, unparseable, or unsupported pre-flight state cannot reach the mutation adapter. Existing Issue and PR validation fetches the artifact through the typed `gh` adapter, reconstructs semantic values, and calls the same compiler-owned validator. Diagnostics distinguish valid artifacts, ordinary semantic violations, wrong-template bodies, and unparseable structure.
+`prepareIssueArtifact` and `preparePullRequestArtifact` are the trusted preparation boundary for library callers. Each reparses the exact rendered body with the same compiled contract, revalidates the reconstructed values, and compares them deterministically with the validated/materialized source values before producing an opaque, frozen capability carrying the target repository/ref provenance. The public `phase: "validated-rendered"` string is informational; a caller-created or spread object is rejected by the mutation adapter, and there is no public marker helper.
+
+Schema, validate, and render never call a remote mutation. Invalid, ambiguous, unparseable, or unsupported pre-flight state cannot reach the mutation adapter. Existing Issue and PR validation fetches the artifact through the typed `gh` adapter, reconstructs semantic values, and calls the same compiler-owned validator. Diagnostics distinguish valid artifacts, ordinary semantic violations, wrong-template bodies, and unparseable structure. Renderer/parser drift fails with the typed `ARTIFACT_ROUND_TRIP_INVALID` preparation error.
 
 The public compiler, contract, validation, rendering, and adapter boundaries are library APIs. Future Actions or App adapters can use them without invoking or scraping CLI output.
 

package/dist/artifact.d.ts

@@ -1,4 +1,5 @@
 import { type SemanticValidationResult, type SemanticViolation } from "./contract/validation.js";
+import { type CanonicalContract } from "./contract/ir.js";
 import { type ValidatedRenderedIssueArtifact, type ValidatedRenderedPullRequestArtifact } from "./github/types.js";
 export interface ArtifactInputMetadata {
     readonly title?: string;
@@ -13,12 +14,32 @@ export interface ArtifactInputDocument {
     readonly fields: Readonly<Record<string, unknown>>;
     readonly metadata: ArtifactInputMetadata;
 }
+export interface ArtifactMetadataViolation {
+    readonly code: "INPUT_METADATA_INVALID";
+    readonly path: string;
+    readonly message: string;
+}
 export type ArtifactInputErrorCode = "INPUT_DOCUMENT_INVALID" | "INPUT_METADATA_INVALID";
 export declare class ArtifactInputError extends Error {
     readonly code: ArtifactInputErrorCode;
     readonly path: string;
     constructor(code: ArtifactInputErrorCode, message: string, path?: string);
 }
+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;
+}
+/** Stable failures raised before a mutation-capable artifact is created. */
+export declare class ArtifactPreparationError extends Error {
+    readonly code: ArtifactPreparationErrorCode;
+    readonly diagnostics: readonly ArtifactRoundTripDiagnostic[];
+    constructor(code: ArtifactPreparationErrorCode, message: string, diagnostics?: readonly ArtifactRoundTripDiagnostic[]);
+}
 export interface PreparedIssueArtifact {
     readonly input: ArtifactInputDocument;
     readonly validation: SemanticValidationResult;
@@ -29,8 +50,8 @@ export interface PreparedPullRequestArtifact {
     readonly validation: SemanticValidationResult;
     readonly artifact: ValidatedRenderedPullRequestArtifact;
 }
-export type ExistingArtifactClassification = "valid" | "semantic" | "wrong-template" | "unparseable";
-export type ExistingArtifactDiagnosticCode = "EXISTING_WRONG_TEMPLATE" | "EXISTING_UNPARSEABLE" | "EXISTING_EXTRA_CONTENT" | "EXISTING_UNKNOWN_CHECKLIST_ITEM";
+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";
 export interface ExistingArtifactDiagnostic {
     readonly code: ExistingArtifactDiagnosticCode;
     readonly path: string;
@@ -75,6 +96,28 @@ export declare function parseExistingIssueArtifact(contractInput: unknown, body:
 export declare function parseExistingPullRequestArtifact(contractInput: unknown, body: string | null | undefined): ExistingArtifactParseResult;
 export declare function validateExistingIssueArtifact(contractInput: unknown, body: string | null | undefined): ExistingArtifactValidationResult;
 export declare function validateExistingPullRequestArtifact(contractInput: unknown, body: string | null | undefined): ExistingArtifactValidationResult;
+export interface ExistingArtifactCandidate {
+    readonly contract: CanonicalContract;
+    readonly result: ExistingArtifactValidationResult;
+}
+export interface ExistingArtifactSelection {
+    readonly contract?: CanonicalContract;
+    readonly result: ExistingArtifactValidationResult;
+}
+export interface ExistingArtifactProjection {
+    readonly valid: boolean;
+    readonly projection: "canonical" | "unavailable";
+    readonly classification: ExistingArtifactClassification;
+    readonly fields?: Readonly<Record<string, unknown>>;
+    readonly diagnostics: readonly ExistingArtifactDiagnostic[];
+    readonly violations: readonly ExistingArtifactDiagnostic[] | readonly SemanticViolation[];
+}
+/** Project only validated semantic values; invalid artifacts never expose parsed fields. */
+export declare function projectExistingArtifact(result: ExistingArtifactValidationResult): ExistingArtifactProjection;
+/** Select a uniquely parsed governed artifact, failing closed on ambiguity. */
+export declare function selectExistingArtifactCandidate(candidates: readonly ExistingArtifactCandidate[]): ExistingArtifactSelection;
+/** Validate the same required string metadata enforced by mutation preparation. */
+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>;
 /** Escape only Markdown constructs that could change the canonical section structure. */

package/dist/artifact.js

@@ -1,6 +1,6 @@
 import { SemanticValidationError, validateSemanticInput, } from "./contract/validation.js";
-import { assertCanonicalContract } from "./contract/ir.js";
-import { markValidatedRenderedIssueArtifact, markValidatedRenderedPullRequestArtifact, } from "./github/types.js";
+import { assertCanonicalContract, } from "./contract/ir.js";
+import { createValidatedRenderedIssueArtifact, createValidatedRenderedPullRequestArtifact, } from "./github/capability.js";
 export class ArtifactInputError extends Error {
     code;
     path;
@@ -11,6 +11,18 @@ export class ArtifactInputError extends Error {
         this.path = path;
     }
 }
+/** Stable failures raised before a mutation-capable artifact is created. */
+export class ArtifactPreparationError extends Error {
+    code;
+    diagnostics;
+    constructor(code, message, diagnostics = []) {
+        super(message);
+        this.name = "ArtifactPreparationError";
+        this.code = code;
+        this.diagnostics = diagnostics;
+    }
+}
+const GITHUB_NO_RESPONSE = "_No response_";
 /** Parse the documented JSON input envelope while keeping field semantics adapter-independent. */
 export function parseArtifactInputDocument(input) {
     if (!isRecord(input))
@@ -59,15 +71,19 @@ export function prepareIssueArtifact(contractInput, input) {
     assertCanonicalContract(contractInput);
     if (contractInput.artifactKind !== "issue")
         throw new ArtifactInputError("INPUT_DOCUMENT_INVALID", "An Issue contract is required.");
+    requireTrustedProvenance(contractInput);
     const validation = validateSemanticInput(contractInput, input.fields);
     if (!validation.valid)
         throw new SemanticValidationError(validation.violations);
-    const title = requiredMetadataString(input.metadata.title, "title");
-    const labels = input.metadata.labels ?? contractInput.nativeMetadata.labels;
-    const artifact = markValidatedRenderedIssueArtifact({
+    const title = requiredMetadataString(input.metadata.title ?? contractInput.nativeMetadata.title, "title");
+    const labels = mergeIssueLabels(contractInput.nativeMetadata.labels, input.metadata.labels);
+    const body = renderIssueBody(contractInput, validation.values);
+    verifyRenderedRoundTrip(contractInput, validation.values, body, "issue");
+    const artifact = createValidatedRenderedIssueArtifact({
         kind: "issue",
         title,
-        body: renderIssueBody(contractInput, validation.values),
+        body,
+        provenance: contractInput.provenance,
         ...(labels === undefined ? {} : { labels }),
         ...(input.metadata.assignees === undefined ? {} : { assignees: input.metadata.assignees }),
     });
@@ -78,16 +94,20 @@ export function preparePullRequestArtifact(contractInput, input) {
     if (contractInput.artifactKind !== "pull_request") {
         throw new ArtifactInputError("INPUT_DOCUMENT_INVALID", "A pull request contract is required.");
     }
+    requireTrustedProvenance(contractInput);
     const validation = validateSemanticInput(contractInput, input.fields);
     if (!validation.valid)
         throw new SemanticValidationError(validation.violations);
     const title = requiredMetadataString(input.metadata.title, "title");
     const head = requiredMetadataString(input.metadata.head, "head");
     const base = requiredMetadataString(input.metadata.base, "base");
-    const artifact = markValidatedRenderedPullRequestArtifact({
+    const body = renderPullRequestBody(contractInput, validation.values);
+    verifyRenderedRoundTrip(contractInput, validation.values, body, "pull_request");
+    const artifact = createValidatedRenderedPullRequestArtifact({
         kind: "pull_request",
         title,
-        body: renderPullRequestBody(contractInput, validation.values),
+        body,
+        provenance: contractInput.provenance,
         head,
         base,
         ...(input.metadata.draft === undefined ? {} : { draft: input.metadata.draft }),
@@ -120,6 +140,67 @@ export function validateExistingPullRequestArtifact(contractInput, body) {
     const parse = parseExistingPullRequestArtifact(contractInput, body);
     return validateParsedArtifact(contractInput, parse);
 }
+/** Project only validated semantic values; invalid artifacts never expose parsed fields. */
+export function projectExistingArtifact(result) {
+    return {
+        valid: result.valid,
+        projection: result.valid ? "canonical" : "unavailable",
+        classification: result.classification,
+        ...(result.valid ? { fields: result.parse.values } : {}),
+        diagnostics: result.parse.diagnostics,
+        violations: result.violations,
+    };
+}
+/** Select a uniquely parsed governed artifact, failing closed on ambiguity. */
+export function selectExistingArtifactCandidate(candidates) {
+    const parsed = candidates.filter((candidate) => candidate.result.parse.parsed);
+    if (parsed.length === 1) {
+        const selected = parsed[0];
+        return selected;
+    }
+    if (parsed.length > 1) {
+        const paths = parsed.map((candidate) => candidate.contract.templateIdentity.path).sort(compareStrings);
+        const diagnostic = {
+            code: "EXISTING_AMBIGUOUS_TEMPLATE",
+            path: "$.template",
+            message: `Artifact structure matches multiple repository-native templates: ${paths.join(", ")}.`,
+        };
+        return {
+            result: {
+                valid: false,
+                classification: "ambiguous",
+                parse: { parsed: false, values: {}, diagnostics: [diagnostic] },
+                violations: [diagnostic],
+            },
+        };
+    }
+    const diagnostics = candidates.flatMap((candidate) => candidate.result.parse.diagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        path: `${candidate.contract.templateIdentity.path}${diagnostic.path}`,
+        message: `[${candidate.contract.templateIdentity.path}] ${diagnostic.message}`,
+    })));
+    const classification = candidates.some((candidate) => candidate.result.parse.diagnostics.some((diagnostic) => diagnostic.code === "EXISTING_WRONG_TEMPLATE"))
+        ? "wrong-template"
+        : "unparseable";
+    return {
+        result: {
+            valid: false,
+            classification,
+            parse: { parsed: false, values: {}, diagnostics },
+            violations: diagnostics,
+        },
+    };
+}
+/** Validate the same required string metadata enforced by mutation preparation. */
+export function validateRequiredMetadataString(value, key) {
+    if (typeof value === "string" && value.trim().length > 0)
+        return undefined;
+    return {
+        code: "INPUT_METADATA_INVALID",
+        path: `$.${key}`,
+        message: `${key} must be a non-empty string.`,
+    };
+}
 export async function validateExistingIssueFromAdapter(reader, contract, issueNumber) {
     const issue = await reader.getIssue(issueNumber);
     return { number: issueNumber, url: issue.url, result: validateExistingIssueArtifact(contract, issue.body) };
@@ -147,14 +228,89 @@ function validateParsedArtifact(contract, parse) {
         violations: semantic.violations,
     };
 }
+function requireTrustedProvenance(contract) {
+    if (contract.provenance === undefined) {
+        throw new ArtifactPreparationError("ARTIFACT_PROVENANCE_MISSING", "Mutation preparation requires a contract bound to trusted repository governance.", [
+            {
+                code: "ROUND_TRIP_PARSE",
+                path: "$.provenance",
+                message: "The compiled contract has no trusted repository/ref provenance.",
+            },
+        ]);
+    }
+}
+function verifyRenderedRoundTrip(contract, expectedValues, body, kind) {
+    const parsed = kind === "issue" ? parseExistingIssueArtifact(contract, body) : parseExistingPullRequestArtifact(contract, body);
+    if (!parsed.parsed) {
+        throw new ArtifactPreparationError("ARTIFACT_ROUND_TRIP_INVALID", `Rendered ${kind} artifact did not reparse under the compiled contract.`, parsed.diagnostics.map((diagnostic) => ({
+            code: "ROUND_TRIP_PARSE",
+            path: diagnostic.path,
+            message: diagnostic.message,
+        })));
+    }
+    const reconstructed = validateSemanticInput(contract, parsed.values);
+    if (!reconstructed.valid) {
+        throw new ArtifactPreparationError("ARTIFACT_ROUND_TRIP_INVALID", `Rendered ${kind} artifact failed semantic validation after reparsing.`, reconstructed.violations.map((violation) => ({
+            code: "ROUND_TRIP_SEMANTIC",
+            path: violation.path,
+            message: violation.message,
+        })));
+    }
+    const mismatches = compareMaterializedValues(expectedValues, reconstructed.values);
+    if (mismatches.length > 0) {
+        throw new ArtifactPreparationError("ARTIFACT_ROUND_TRIP_INVALID", `Rendered ${kind} artifact did not preserve its validated semantic values.`, mismatches);
+    }
+}
+function compareMaterializedValues(expected, actual) {
+    const keys = [...new Set([...Object.keys(expected), ...Object.keys(actual)])].sort(compareStrings);
+    const diagnostics = [];
+    for (const key of keys) {
+        const expectedPresent = Object.prototype.hasOwnProperty.call(expected, key);
+        const actualPresent = Object.prototype.hasOwnProperty.call(actual, key);
+        const path = `$.${key}`;
+        if (!expectedPresent || !actualPresent) {
+            diagnostics.push({
+                code: "ROUND_TRIP_MISMATCH",
+                path,
+                message: "Rendered artifact changed whether a semantic field was materialized.",
+                ...(expectedPresent ? { expected: expected[key] } : {}),
+                ...(actualPresent ? { actual: actual[key] } : {}),
+            });
+            continue;
+        }
+        if (stableValue(expected[key]) !== stableValue(actual[key])) {
+            diagnostics.push({
+                code: "ROUND_TRIP_MISMATCH",
+                path,
+                message: "Rendered artifact changed a materialized semantic value.",
+                expected: expected[key],
+                actual: actual[key],
+            });
+        }
+    }
+    return diagnostics;
+}
+function stableValue(value) {
+    if (value === undefined)
+        return "undefined";
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? String(value);
+    if (Array.isArray(value))
+        return `[${value.map((entry) => stableValue(entry)).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort(compareStrings)
+        .map((key) => `${JSON.stringify(key)}:${stableValue(record[key])}`)
+        .join(",")}}`;
+}
 function renderIssueBody(contract, values) {
     const blocks = [];
     for (let sectionIndex = 0; sectionIndex < contract.sections.length; sectionIndex += 1) {
         const section = contract.sections[sectionIndex];
         if (section.kind === "documentation") {
-            const content = trimBlankLines(section.content ?? "");
-            if (content !== undefined)
-                blocks.push(content);
+            // GitHub renders Issue Form markdown in the form only; it is not part of
+            // the submitted Issue body. The content remains in the contract for
+            // schema/explain and native-source traceability.
             continue;
         }
         const title = section.title ?? section.fields[0]?.label;
@@ -197,13 +353,24 @@ function renderDocumentation(section, content) {
 }
 function renderFieldValue(field, value, kind) {
     if (field.type === "string" || field.type === "enum") {
-        if (typeof value === "string")
-            return escapeMarkdownValue(value);
-        return kind === "pull_request" ? (field.nativeMetadata.placeholder ?? "") : "";
+        if (typeof value === "string" && (kind !== "issue" || value.trim().length > 0)) {
+            return field.nativeMetadata.render === undefined
+                ? escapeMarkdownValue(value)
+                : renderCodeBlock(value, field.nativeMetadata.render);
+        }
+        if (kind === "pull_request")
+            return field.nativeMetadata.placeholder ?? "";
+        return field.nativeMetadata.render === undefined
+            ? GITHUB_NO_RESPONSE
+            : renderCodeBlock("", field.nativeMetadata.render);
     }
     if (field.type === "array") {
         if (!Array.isArray(value))
-            return "";
+            return kind === "issue" ? GITHUB_NO_RESPONSE : "";
+        if (value.length === 0)
+            return kind === "issue" ? GITHUB_NO_RESPONSE : "";
+        if (field.nativeMetadata.multiple === true)
+            return value.map((entry) => escapeMarkdownValue(String(entry))).join(", ");
         return value.map((entry) => `- ${escapeMarkdownValue(String(entry))}`).join("\n");
     }
     const selected = new Set(Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : []);
@@ -222,7 +389,9 @@ function parseRenderedBody(contract, body, issueHeadingLevel, stripComments) {
         while (lines[cursor] !== undefined && lines[cursor]?.trim().length === 0)
             cursor += 1;
         if (section.kind === "documentation") {
-            const expected = trimBlankLines(section.content ?? "");
+            if (issueHeadingLevel !== undefined)
+                continue;
+            const expected = trimBlankLines(stripComments ? removeHtmlComments(section.content ?? "") : (section.content ?? ""));
             if (expected !== undefined) {
                 const expectedLines = expected.split("\n");
                 if (!sameLines(lines.slice(cursor, cursor + expectedLines.length), expectedLines)) {
@@ -255,11 +424,29 @@ function parseRenderedBody(contract, body, issueHeadingLevel, stripComments) {
         }
         cursor += 1;
         const contentStart = cursor;
-        while (cursor < lines.length && !isHeading(lines[cursor] ?? ""))
+        const nextIssueHeading = issueHeadingLevel === undefined ? undefined : findNextIssueHeading(contract, sectionIndex);
+        let openFence;
+        while (cursor < lines.length) {
+            const line = lines[cursor] ?? "";
+            const fenceMatch = /^(`{3,})/u.exec(line);
+            if (openFence === undefined) {
+                if (nextIssueHeading === undefined
+                    ? issueHeadingLevel === undefined && isHeading(line)
+                    : line.trim() === nextIssueHeading)
+                    break;
+                if (fenceMatch !== null)
+                    openFence = fenceMatch[1];
+            }
+            else if (fenceMatch !== null && fenceMatch[1] === openFence) {
+                openFence = undefined;
+            }
             cursor += 1;
+        }
         let fieldEnd = cursor;
         const nextSection = contract.sections[sectionIndex + 1];
-        const nextDocumentation = nextSection?.kind === "documentation" ? trimBlankLines(nextSection.content ?? "") : undefined;
+        const nextDocumentation = issueHeadingLevel === undefined && nextSection?.kind === "documentation"
+            ? trimBlankLines(nextSection.content ?? "")
+            : undefined;
         if (nextDocumentation !== undefined) {
             const documentationLines = nextDocumentation.split("\n");
             const rawCandidate = lines.slice(contentStart, fieldEnd);
@@ -296,8 +483,15 @@ function parseRenderedBody(contract, body, issueHeadingLevel, stripComments) {
 function parseFieldLines(field, lines, path, stripComments) {
     const diagnostics = [];
     const filtered = stripComments ? lines.filter((line) => line.trim().length > 0) : lines;
+    if (filtered.length === 1 && filtered[0]?.trim() === GITHUB_NO_RESPONSE) {
+        // GitHub uses the same marker for an empty optional selection. Preserve
+        // the materialized empty array so prepared artifacts remain reversible.
+        return { value: field.type === "array" ? [] : undefined, diagnostics };
+    }
     if (field.type === "string" || field.type === "enum") {
-        const value = trimBlankLines(unescapeMarkdownValue(filtered.join("\n")));
+        const value = field.nativeMetadata.render === undefined
+            ? trimBlankLines(unescapeMarkdownValue(filtered.join("\n")))
+            : parseRenderedCodeBlock(filtered, field.nativeMetadata.render, path, diagnostics);
         const placeholder = stripComments
             ? removeHtmlComments(field.nativeMetadata.placeholder ?? "")
             : (field.nativeMetadata.placeholder ?? "");
@@ -306,6 +500,18 @@ function parseFieldLines(field, lines, path, stripComments) {
         return { value, diagnostics };
     }
     if (field.type === "array") {
+        if (field.nativeMetadata.multiple === true) {
+            const value = trimBlankLines(unescapeMarkdownValue(filtered.join("\n")));
+            if (value === undefined)
+                return { value: undefined, diagnostics };
+            const values = value
+                .split(",")
+                .map((entry) => entry.trim())
+                .filter((entry) => entry.length > 0);
+            if (values.length === 0)
+                return { value: undefined, diagnostics };
+            return { value: values, diagnostics };
+        }
         const values = filtered
             .map((line) => {
             const value = /^[-+*][ \t]+(.+)$/u.exec(line)?.[1]?.trim();
@@ -359,6 +565,55 @@ function removeRenderedPlaceholder(lines, placeholder) {
         ? lines.slice(placeholderLines.length)
         : lines;
 }
+function findNextIssueHeading(contract, sectionIndex) {
+    for (let index = sectionIndex + 1; index < contract.sections.length; index += 1) {
+        const section = contract.sections[index];
+        if (section.kind !== "input")
+            continue;
+        const title = section.title ?? section.fields[0]?.label;
+        if (title !== undefined)
+            return `### ${escapeHeading(title)}`;
+    }
+    return undefined;
+}
+function parseRenderedCodeBlock(lines, language, path, diagnostics) {
+    const opening = /^(`{3,})(.*)$/u.exec(lines[0] ?? "");
+    if (opening === null || opening[2] !== language || lines.length < 2) {
+        diagnostics.push({
+            code: "EXISTING_UNPARSEABLE",
+            path,
+            message: `Rendered textarea values must use a fenced ${language} code block.`,
+        });
+        return undefined;
+    }
+    const fence = opening[1];
+    if (lines.at(-1) !== fence) {
+        diagnostics.push({
+            code: "EXISTING_UNPARSEABLE",
+            path,
+            message: "Rendered textarea code blocks must have a matching closing fence.",
+        });
+        return undefined;
+    }
+    const value = lines.slice(1, -1).join("\n");
+    return value.length === 0 ? undefined : value;
+}
+function renderCodeBlock(value, language) {
+    const normalized = normalizeSource(value);
+    const longestFence = Math.max(0, ...Array.from(normalized.matchAll(/`+/gu), (match) => match[0]?.length ?? 0));
+    const fence = "`".repeat(Math.max(3, longestFence + 1));
+    return `${fence}${language}\n${normalized}\n${fence}`;
+}
+function mergeIssueLabels(nativeLabels, callerLabels) {
+    if (nativeLabels === undefined && callerLabels === undefined)
+        return undefined;
+    const labels = [];
+    for (const label of [...(nativeLabels ?? []), ...(callerLabels ?? [])]) {
+        if (!labels.includes(label))
+            labels.push(label);
+    }
+    return labels;
+}
 function parseMetadata(input) {
     const metadata = {};
     if (input.title !== undefined)
@@ -381,8 +636,9 @@ function parseMetadata(input) {
     return metadata;
 }
 function requiredMetadataString(value, key) {
-    if (typeof value !== "string" || value.trim().length === 0)
-        throw new ArtifactInputError("INPUT_METADATA_INVALID", `${key} must be a non-empty string.`, `$.${key}`);
+    const violation = validateRequiredMetadataString(value, key);
+    if (violation !== undefined)
+        throw new ArtifactInputError(violation.code, violation.message, violation.path);
     return value;
 }
 function stringArray(value, key) {
@@ -469,4 +725,7 @@ function sameLines(actual, expected) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
 //# sourceMappingURL=artifact.js.map