gh-inari 0.2.0 → 0.5.2

package/dist/semantic-template.js

@@ -0,0 +1,1151 @@
+import { lstat, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { stringify as stringifyYaml } from "yaml";
+import { assertCanonicalContract, } from "./contract/ir.js";
+import { compileIssueFormYaml } from "./contract/issue-form.js";
+import { parsePullRequestTemplate, renderPullRequestTemplate } from "./pull-request-template.js";
+export const SEMANTIC_TEMPLATE_VERSION = 1;
+export const SEMANTIC_TEMPLATE_DIRECTORY = ".github/inari";
+export const SEMANTIC_ISSUE_DIRECTORY = ".github/inari/issues";
+export const SEMANTIC_PULL_REQUEST_FILE = ".github/inari/pull-request.json";
+export const GENERATED_TEMPLATE_NOTICE = "Generated by gh-inari from .github/inari; do not edit.";
+export class SemanticTemplateError extends Error {
+    code;
+    path;
+    violations;
+    constructor(violations, options) {
+        const first = violations[0];
+        if (first === undefined)
+            throw new Error("Semantic template errors require at least one violation.");
+        super(violations.map((violation) => `${violation.path}: ${violation.message}`).join("\n"), options);
+        this.name = "SemanticTemplateError";
+        this.code = first.code;
+        this.path = first.path;
+        this.violations = violations;
+    }
+    toJSON() {
+        return { code: this.code, path: this.path, message: this.message, violations: this.violations };
+    }
+}
+const ISSUE_NATIVE_DIRECTORY = ".github/ISSUE_TEMPLATE";
+const PR_NATIVE_DEFAULT = ".github/PULL_REQUEST_TEMPLATE.md";
+const PR_NATIVE_DIRECTORY = ".github/PULL_REQUEST_TEMPLATE";
+const JSON_EXTENSION = ".json";
+/** Find semantic contracts without reading their contents. */
+export async function discoverSemanticTemplates(repositoryRoot = process.cwd()) {
+    const root = resolveRoot(repositoryRoot);
+    const identities = [];
+    const issues = path.join(root, SEMANTIC_ISSUE_DIRECTORY);
+    if (await optionalDirectory(issues)) {
+        const entries = await readdir(issues, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name, "en-US"))) {
+            if (!entry.isFile() || path.extname(entry.name).toLocaleLowerCase("en-US") !== JSON_EXTENSION)
+                continue;
+            const id = path.basename(entry.name, path.extname(entry.name));
+            identities.push({
+                id,
+                kind: "issue",
+                name: id,
+                sourcePath: toRepositoryPath(root, path.join(issues, entry.name)),
+                generatedPath: toRepositoryPath(root, path.join(root, ISSUE_NATIVE_DIRECTORY, `${id}.yml`)),
+            });
+        }
+    }
+    const pullRequest = path.join(root, SEMANTIC_PULL_REQUEST_FILE);
+    if (await optionalFile(pullRequest)) {
+        identities.push({
+            id: "pull-request",
+            kind: "pull_request",
+            name: "Pull request",
+            sourcePath: toRepositoryPath(root, pullRequest),
+            generatedPath: toRepositoryPath(root, path.join(root, PR_NATIVE_DEFAULT)),
+        });
+    }
+    const pullRequests = path.join(root, SEMANTIC_TEMPLATE_DIRECTORY, "pull-requests");
+    if (await optionalDirectory(pullRequests)) {
+        const entries = await readdir(pullRequests, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name, "en-US"))) {
+            if (!entry.isFile() || path.extname(entry.name).toLocaleLowerCase("en-US") !== JSON_EXTENSION)
+                continue;
+            const id = path.basename(entry.name, path.extname(entry.name));
+            identities.push({
+                id,
+                kind: "pull_request",
+                name: id,
+                sourcePath: toRepositoryPath(root, path.join(pullRequests, entry.name)),
+                generatedPath: toRepositoryPath(root, path.join(root, PR_NATIVE_DIRECTORY, `${id}.md`)),
+            });
+        }
+    }
+    return identities;
+}
+/** Synchronous counterpart used by bounded governance and tooling callers. */
+export function discoverSemanticTemplatesSync(repositoryRoot = process.cwd()) {
+    const root = resolveRoot(repositoryRoot);
+    const identities = [];
+    const issues = path.join(root, SEMANTIC_ISSUE_DIRECTORY);
+    if (optionalDirectorySync(issues)) {
+        for (const entry of readdirSync(issues, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name, "en-US"))) {
+            if (!entry.isFile() || path.extname(entry.name).toLocaleLowerCase("en-US") !== JSON_EXTENSION)
+                continue;
+            const id = path.basename(entry.name, path.extname(entry.name));
+            identities.push({
+                id,
+                kind: "issue",
+                name: id,
+                sourcePath: toRepositoryPath(root, path.join(issues, entry.name)),
+                generatedPath: toRepositoryPath(root, path.join(root, ISSUE_NATIVE_DIRECTORY, `${id}.yml`)),
+            });
+        }
+    }
+    const pullRequest = path.join(root, SEMANTIC_PULL_REQUEST_FILE);
+    if (optionalFileSync(pullRequest)) {
+        identities.push({
+            id: "pull-request",
+            kind: "pull_request",
+            name: "Pull request",
+            sourcePath: toRepositoryPath(root, pullRequest),
+            generatedPath: toRepositoryPath(root, path.join(root, PR_NATIVE_DEFAULT)),
+        });
+    }
+    const pullRequests = path.join(root, SEMANTIC_TEMPLATE_DIRECTORY, "pull-requests");
+    if (optionalDirectorySync(pullRequests)) {
+        for (const entry of readdirSync(pullRequests, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name, "en-US"))) {
+            if (!entry.isFile() || path.extname(entry.name).toLocaleLowerCase("en-US") !== JSON_EXTENSION)
+                continue;
+            const id = path.basename(entry.name, path.extname(entry.name));
+            identities.push({
+                id,
+                kind: "pull_request",
+                name: id,
+                sourcePath: toRepositoryPath(root, path.join(pullRequests, entry.name)),
+                generatedPath: toRepositoryPath(root, path.join(root, PR_NATIVE_DIRECTORY, `${id}.md`)),
+            });
+        }
+    }
+    return identities;
+}
+export async function readSemanticTemplate(repositoryRoot, identity) {
+    const root = resolveRoot(repositoryRoot);
+    const sourcePath = safeRepositoryPath(root, identity.sourcePath);
+    let serialized;
+    try {
+        serialized = await readFile(sourcePath, "utf8");
+    }
+    catch (cause) {
+        throw new SemanticTemplateError([
+            {
+                code: "SEMANTIC_TEMPLATE_SOURCE_ERROR",
+                path: identity.sourcePath,
+                message: `Cannot read semantic source "${identity.sourcePath}".`,
+            },
+        ], { cause });
+    }
+    return { ...identity, source: parseSemanticTemplate(serialized, identity.sourcePath) };
+}
+export function readSemanticTemplateSync(repositoryRoot, identity) {
+    const root = resolveRoot(repositoryRoot);
+    const sourcePath = safeRepositoryPath(root, identity.sourcePath);
+    try {
+        return { ...identity, source: parseSemanticTemplate(readFileSync(sourcePath, "utf8"), identity.sourcePath) };
+    }
+    catch (cause) {
+        if (cause instanceof SemanticTemplateError)
+            throw cause;
+        throw new SemanticTemplateError([
+            {
+                code: "SEMANTIC_TEMPLATE_SOURCE_ERROR",
+                path: identity.sourcePath,
+                message: `Cannot read semantic source "${identity.sourcePath}".`,
+            },
+        ], { cause });
+    }
+}
+export function parseSemanticTemplate(serialized, sourcePath = "$") {
+    let value;
+    try {
+        value = JSON.parse(serialized);
+    }
+    catch (cause) {
+        throw new SemanticTemplateError([
+            {
+                code: "SEMANTIC_TEMPLATE_INVALID_JSON",
+                path: sourcePath,
+                message: "Semantic source must contain valid JSON.",
+            },
+        ], { cause });
+    }
+    return normalizeSemanticTemplate(value, sourcePath);
+}
+export function normalizeSemanticTemplate(value, sourcePath = "$") {
+    const violations = [];
+    if (!isRecord(value)) {
+        throw new SemanticTemplateError([
+            { code: "SEMANTIC_TEMPLATE_INVALID_ROOT", path: sourcePath, message: "Semantic source must be a JSON object." },
+        ]);
+    }
+    assertKeys(value, [
+        "version",
+        "kind",
+        "artifactKind",
+        "id",
+        "name",
+        "description",
+        "title",
+        "labels",
+        "sections",
+        "fields",
+        "template",
+        "metadata",
+    ], sourcePath, violations);
+    const template = isRecord(value.template) ? value.template : undefined;
+    const metadata = isRecord(value.metadata) ? value.metadata : undefined;
+    if (value.template !== undefined && template === undefined)
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", `${sourcePath}.template`, "template must be an object.");
+    if (value.metadata !== undefined && metadata === undefined)
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", `${sourcePath}.metadata`, "metadata must be an object.");
+    if (template !== undefined)
+        assertKeys(template, ["kind", "artifactKind", "id", "name", "description", "title", "labels", "sections", "fields"], `${sourcePath}.template`, violations);
+    if (metadata !== undefined)
+        assertKeys(metadata, ["description", "title", "labels"], `${sourcePath}.metadata`, violations);
+    const version = value.version ?? template?.version;
+    if (version !== SEMANTIC_TEMPLATE_VERSION)
+        addViolation(violations, "SEMANTIC_TEMPLATE_UNSUPPORTED_VERSION", `${sourcePath}.version`, `Only semantic template version ${SEMANTIC_TEMPLATE_VERSION} is supported.`);
+    const rawKind = value.kind ?? value.artifactKind ?? template?.kind ?? template?.artifactKind;
+    const kind = rawKind === "pr" ? "pull_request" : rawKind;
+    if (kind !== "issue" && kind !== "pull_request")
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", `${sourcePath}.kind`, "kind must be issue or pull_request.");
+    const id = stringValue(value.id ?? template?.id, `${sourcePath}.id`, violations);
+    const name = stringValue(value.name ?? template?.name, `${sourcePath}.name`, violations);
+    const description = optionalString(value.description ?? metadata?.description ?? template?.description, `${sourcePath}.description`, violations);
+    const title = optionalString(value.title ?? metadata?.title ?? template?.title, `${sourcePath}.title`, violations);
+    const labels = optionalStringList(value.labels ?? metadata?.labels ?? template?.labels, `${sourcePath}.labels`, violations);
+    const rawSections = value.sections ?? value.fields ?? template?.sections ?? template?.fields;
+    if (!Array.isArray(rawSections) || rawSections.length === 0)
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", `${sourcePath}.sections`, "sections must be a non-empty array.");
+    const sections = Array.isArray(rawSections)
+        ? rawSections.map((section, index) => normalizeSection(section, `${sourcePath}.sections[${index}]`, violations))
+        : [];
+    const ids = new Set();
+    for (const [index, section] of sections.entries()) {
+        if (section !== undefined && ids.has(section.id))
+            addViolation(violations, "SEMANTIC_TEMPLATE_AMBIGUOUS", `${sourcePath}.sections[${index}].id`, `Duplicate section id "${section.id}".`);
+        if (section !== undefined)
+            ids.add(section.id);
+    }
+    if (kind === "issue" && (description === undefined || description.length === 0))
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", `${sourcePath}.description`, "Issue templates require a non-empty description.");
+    if (violations.length > 0)
+        throw new SemanticTemplateError(violations);
+    return {
+        version: SEMANTIC_TEMPLATE_VERSION,
+        kind: kind,
+        id: id,
+        name: name,
+        ...(description === undefined ? {} : { description }),
+        ...(title === undefined ? {} : { title }),
+        ...(labels === undefined ? {} : { labels }),
+        sections: sections,
+    };
+}
+export async function compileSemanticTemplate(repositoryRoot, document) {
+    return compileSemanticTemplateSource(document.source, document.generatedPath);
+}
+export function compileSemanticTemplateSync(repositoryRoot, document) {
+    return compileSemanticTemplateSource(document.source, document.generatedPath);
+}
+/** Compile an already trusted semantic source without consulting the filesystem. */
+export function compileSemanticTemplateSource(source, generatedPath) {
+    const native = renderSemanticNative(source, generatedPath);
+    const identity = {
+        id: source.id,
+        kind: source.kind,
+        name: source.name,
+        sourcePath: "<memory>",
+        generatedPath,
+        source,
+    };
+    const contract = compileNativeProjection(native, identity);
+    return applySemanticIdentityAndConstraints(contract, source);
+}
+/** Render one semantic contract to the committed native GitHub projection. */
+export function renderSemanticNative(source, generatedPath) {
+    if (source.kind === "issue")
+        return renderIssueNative(source);
+    const provisional = renderPullRequestProvisional(source);
+    const identity = {
+        id: source.id,
+        type: "pull-request",
+        kind: "pull-request",
+        name: source.name,
+        path: generatedPath,
+    };
+    const parsed = parsePullRequestTemplate(provisional, identity);
+    const rebound = applySemanticIdentityAndConstraints(parsed, source);
+    return `<!-- ${GENERATED_TEMPLATE_NOTICE} -->\n\n${renderPullRequestTemplate(rebound)}`;
+}
+export function renderSemanticCompactSchema(contract) {
+    assertCanonicalContract(contract);
+    const properties = {};
+    const required = [];
+    for (const section of contract.sections) {
+        for (const field of section.fields) {
+            const constraints = contract.supplementalConstraints.fields.find((entry) => entry.fieldId === field.id);
+            const entry = { id: field.id, label: field.label, type: field.type };
+            if (field.description !== undefined)
+                entry.description = field.description;
+            const hasDefault = field.defaultValue !== undefined || field.nativeMetadata.defaultValue !== undefined;
+            const isRequired = (constraints?.required ?? field.required === "required") && !hasDefault;
+            if (isRequired)
+                required.push(field.id);
+            if (field.type === "enum")
+                entry.choices = field.options.map((option) => option.value);
+            if (field.type === "array")
+                entry.choices = field.items.options?.map((option) => option.value) ?? [];
+            if (field.type === "checklist")
+                entry.choices = field.items.map((item) => ({ id: item.id, label: item.label, required: item.required }));
+            for (const key of ["minLength", "maxLength", "pattern", "minItems", "maxItems"]) {
+                const value = constraints?.[key] ?? field.constraints?.[key];
+                if (value !== undefined)
+                    entry[key] = value;
+            }
+            properties[field.id] = entry;
+        }
+    }
+    return { version: SEMANTIC_TEMPLATE_VERSION, kind: contract.artifactKind, fields: properties, required };
+}
+export async function syncSemanticTemplates(repositoryRoot = process.cwd(), check = false) {
+    const root = resolveRoot(repositoryRoot);
+    const identities = await discoverSemanticTemplates(root);
+    const generated = new Map();
+    for (const identity of identities) {
+        const document = await readSemanticTemplate(root, identity);
+        generated.set(identity.generatedPath, renderSemanticNative(document.source, identity.generatedPath));
+    }
+    const drift = [];
+    const written = [];
+    for (const [relativePath, content] of generated) {
+        const absolutePath = safeRepositoryPath(root, relativePath);
+        let current;
+        try {
+            current = await readFile(absolutePath, "utf8");
+        }
+        catch {
+            current = undefined;
+        }
+        if (current !== content) {
+            drift.push(relativePath);
+            if (!check) {
+                await mkdir(path.dirname(absolutePath), { recursive: true });
+                await writeRepositoryFile(absolutePath, content);
+                written.push(relativePath);
+            }
+        }
+    }
+    const staleGenerated = await findStaleGeneratedFiles(root, generated);
+    if (!check) {
+        for (const relativePath of staleGenerated) {
+            const absolutePath = safeRepositoryPath(root, relativePath);
+            const current = await readFile(absolutePath, "utf8");
+            await writeRepositoryFile(absolutePath, current);
+        }
+    }
+    return {
+        check,
+        changed: drift.length > 0 || staleGenerated.length > 0,
+        written,
+        drift,
+        staleGenerated,
+        generated: [...generated.keys()],
+    };
+}
+export async function importNativeTemplate(repositoryRoot, nativePath, destinationPath) {
+    const root = resolveRoot(repositoryRoot);
+    const sourcePath = safeRepositoryPath(root, nativePath);
+    const content = await readFile(sourcePath, "utf8");
+    const relative = toRepositoryPath(root, sourcePath);
+    const kind = relative.includes("ISSUE_TEMPLATE/") ? "issue" : "pull_request";
+    const base = path.basename(relative, path.extname(relative));
+    const identity = {
+        id: base,
+        type: kind === "issue" ? "issue-form" : "pull-request",
+        kind: kind === "issue" ? "issue" : "pull-request",
+        name: base,
+        path: relative,
+    };
+    const contract = kind === "issue"
+        ? compileIssueFormYaml(stripGeneratedNotice(content), identity)
+        : parsePullRequestTemplate(stripGeneratedNotice(content), identity);
+    const source = semanticSourceFromContract(contract);
+    const outputPath = destinationPath ?? defaultImportPath(root, source, base);
+    const absoluteOutput = safeRepositoryPath(root, outputPath);
+    await mkdir(path.dirname(absoluteOutput), { recursive: true });
+    await writeRepositoryFile(absoluteOutput, `${JSON.stringify(source, null, 2)}\n`);
+    const writtenPath = toRepositoryPath(root, absoluteOutput);
+    const warning = destinationPath === undefined ? undefined : discoverableWarning(source.kind, writtenPath);
+    return warning === undefined ? { path: writtenPath, source } : { path: writtenPath, source, warning };
+}
+function discoverableWarning(kind, writtenPath) {
+    const discoverable = kind === "issue"
+        ? writtenPath.startsWith(`${SEMANTIC_ISSUE_DIRECTORY}/`) && writtenPath.endsWith(JSON_EXTENSION)
+        : writtenPath === SEMANTIC_PULL_REQUEST_FILE ||
+            (writtenPath.startsWith(`${SEMANTIC_TEMPLATE_DIRECTORY}/pull-requests/`) &&
+                writtenPath.endsWith(JSON_EXTENSION));
+    if (discoverable)
+        return undefined;
+    return (`wrote ${writtenPath}, but no semantic template will be discovered there; ` +
+        `expected ${SEMANTIC_ISSUE_DIRECTORY}/<id>.json, ${SEMANTIC_PULL_REQUEST_FILE}, ` +
+        `or ${SEMANTIC_TEMPLATE_DIRECTORY}/pull-requests/<id>.json`);
+}
+export function semanticSourceFromContract(contractInput) {
+    assertCanonicalContract(contractInput);
+    const sections = [];
+    for (const section of contractInput.sections) {
+        if (section.kind === "documentation") {
+            sections.push({
+                id: section.id,
+                kind: "documentation",
+                content: section.content ?? "",
+                ...(section.title === undefined ? {} : { label: section.title }),
+                ...headingMetadata(section),
+            });
+            continue;
+        }
+        const field = section.fields[0];
+        if (field === undefined)
+            continue;
+        sections.push({
+            id: field.id,
+            kind: "input",
+            type: field.type,
+            label: field.label,
+            ...(field.description === undefined ? {} : { description: field.description }),
+            ...(field.required === "unknown" ? {} : { required: field.required === "required" }),
+            ...(field.nativeMetadata.elementType === "input" || field.nativeMetadata.elementType === "textarea"
+                ? { element: field.nativeMetadata.elementType }
+                : {}),
+            ...(field.nativeMetadata.placeholder === undefined ? {} : { placeholder: field.nativeMetadata.placeholder }),
+            ...(field.nativeMetadata.render === undefined ? {} : { render: field.nativeMetadata.render }),
+            ...(field.type === "string" || field.type === "enum"
+                ? field.defaultValue === undefined
+                    ? {}
+                    : { defaultValue: field.defaultValue }
+                : {}),
+            ...(field.type === "array"
+                ? {
+                    multiple: field.selection === "multi_select",
+                    options: field.items.options?.map((option) => ({
+                        id: option.value,
+                        label: option.label,
+                        ...(option.description === undefined ? {} : { description: option.description }),
+                    })),
+                }
+                : {}),
+            ...(field.type === "enum"
+                ? {
+                    options: field.options.map((option) => ({
+                        id: option.value,
+                        label: option.label,
+                        ...(option.description === undefined ? {} : { description: option.description }),
+                    })),
+                }
+                : {}),
+            ...(field.type === "checklist"
+                ? { options: field.items.map((item) => ({ id: item.id, label: item.label, required: item.required })) }
+                : {}),
+            ...headingMetadata(section),
+        });
+    }
+    const result = {
+        version: SEMANTIC_TEMPLATE_VERSION,
+        kind: contractInput.artifactKind,
+        id: contractInput.templateIdentity.id,
+        name: contractInput.templateIdentity.name,
+        ...(contractInput.nativeMetadata.description === undefined
+            ? {}
+            : { description: contractInput.nativeMetadata.description }),
+        ...(contractInput.nativeMetadata.title === undefined ? {} : { title: contractInput.nativeMetadata.title }),
+        ...(contractInput.nativeMetadata.labels === undefined ? {} : { labels: contractInput.nativeMetadata.labels }),
+        sections,
+    };
+    return normalizeSemanticTemplate(result);
+}
+export function selectSemanticTemplate(identities, kind, selector) {
+    const candidates = identities.filter((identity) => identity.kind === kind);
+    const matches = candidates.filter((identity) => semanticSelectorMatches(identity, selector));
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length === 0)
+        throw new SemanticTemplateError([
+            {
+                code: "SEMANTIC_TEMPLATE_INVALID_VALUE",
+                path: "$.template",
+                message: "No semantic template matches the requested selector.",
+            },
+        ]);
+    throw new SemanticTemplateError([
+        {
+            code: "SEMANTIC_TEMPLATE_AMBIGUOUS",
+            path: "$.template",
+            message: "The semantic template selector matches multiple contracts.",
+        },
+    ]);
+}
+export function semanticTemplateGeneratedPath(kind, id) {
+    return kind === "issue"
+        ? `${ISSUE_NATIVE_DIRECTORY}/${id}.yml`
+        : id === "pull-request"
+            ? PR_NATIVE_DEFAULT
+            : `${PR_NATIVE_DIRECTORY}/${id}.md`;
+}
+function compileNativeProjection(native, document) {
+    if (document.source.kind === "issue") {
+        const identity = {
+            id: document.source.id,
+            name: document.source.name,
+            path: document.generatedPath,
+            type: "issue-form",
+            kind: "issue",
+        };
+        return compileIssueFormYaml(native, identity);
+    }
+    const identity = {
+        id: document.source.id,
+        type: "pull-request",
+        kind: "pull-request",
+        name: document.source.name,
+        path: document.generatedPath,
+    };
+    return parsePullRequestTemplate(native, identity);
+}
+function renderIssueNative(source) {
+    const body = source.sections.map((section) => {
+        if (section.kind === "documentation")
+            return { type: "markdown", attributes: { value: section.content ?? "" } };
+        const type = issueElementType(section);
+        const attributes = { label: section.label ?? section.id };
+        if (section.description !== undefined)
+            attributes.description = section.description;
+        if (section.placeholder !== undefined)
+            attributes.placeholder = section.placeholder;
+        if (section.defaultValue !== undefined && (type === "input" || type === "textarea"))
+            attributes.value = section.defaultValue;
+        if (type === "textarea" && section.render !== undefined)
+            attributes.render = section.render;
+        if (type === "dropdown") {
+            attributes.options = (section.options ?? []).map((option) => option.label);
+            if (section.multiple === true)
+                attributes.multiple = true;
+            const defaultValue = Array.isArray(section.defaultValue) ? section.defaultValue[0] : section.defaultValue;
+            const index = defaultValue === undefined
+                ? undefined
+                : (section.options ?? []).findIndex((option) => option.value === defaultValue || option.id === defaultValue || option.label === defaultValue);
+            if (index !== undefined && index >= 0)
+                attributes.default = index;
+        }
+        if (type === "checkboxes")
+            attributes.options = (section.options ?? []).map((option) => ({
+                label: option.label,
+                ...(option.required === undefined ? {} : { required: option.required }),
+            }));
+        return {
+            type,
+            id: section.id,
+            attributes,
+            ...(section.required === undefined ? {} : { validations: { required: section.required } }),
+        };
+    });
+    const native = {
+        name: source.name,
+        ...(source.description === undefined ? {} : { description: source.description }),
+        ...(source.title === undefined ? {} : { title: source.title }),
+        ...(source.labels === undefined ? {} : { labels: source.labels }),
+        body,
+    };
+    return `# ${GENERATED_TEMPLATE_NOTICE}\n${stringifyYaml(native, { lineWidth: 0 })}`;
+}
+function renderPullRequestProvisional(source) {
+    const blocks = source.sections.map((section) => {
+        if (section.kind === "documentation") {
+            const content = section.content ?? "";
+            return section.headingLevel === undefined
+                ? content
+                : `${"#".repeat(section.headingLevel)} ${section.label ?? section.id}\n\n${content}`;
+        }
+        const headingLevel = section.headingLevel ?? 2;
+        const heading = `${"#".repeat(headingLevel)} ${section.label ?? section.id}`;
+        if (section.type === "checklist") {
+            const placeholder = section.placeholder === undefined ? [] : [section.placeholder];
+            const items = (section.options ?? []).map((option) => `- [ ] ${option.label}`);
+            return [heading, ...placeholder, items.join("\n")].filter((entry) => entry.length > 0).join("\n\n");
+        }
+        return [heading, section.placeholder ?? ""].join("\n\n");
+    });
+    return `${blocks.join("\n\n")}\n`;
+}
+function applySemanticIdentityAndConstraints(contractInput, source) {
+    const sections = [];
+    let sourceIndex = 0;
+    for (const section of contractInput.sections) {
+        const sourceSection = source.sections[sourceIndex];
+        if (sourceSection === undefined) {
+            sections.push(section);
+            continue;
+        }
+        sourceIndex += 1;
+        if (sourceSection.kind === "documentation") {
+            sections.push({
+                ...section,
+                id: sourceSection.id,
+                ...(sourceSection.label === undefined ? {} : { title: sourceSection.label }),
+                nativeMetadata: { ...section.nativeMetadata, sourceId: sourceSection.id },
+            });
+            continue;
+        }
+        const field = section.fields[0];
+        if (field === undefined) {
+            sections.push(section);
+            continue;
+        }
+        const reboundField = rebindField(field, sourceSection);
+        sections.push({
+            ...section,
+            id: sourceSection.id,
+            ...(sourceSection.label === undefined ? {} : { title: sourceSection.label }),
+            nativeMetadata: { ...section.nativeMetadata, sourceId: sourceSection.id },
+            fields: [reboundField],
+        });
+    }
+    const sourceConstraints = source.sections
+        .filter((section) => section.kind === "input")
+        .flatMap((section) => {
+        const constraints = { fieldId: section.id };
+        for (const key of ["required", "minLength", "maxLength", "pattern", "minItems", "maxItems"]) {
+            if (section[key] !== undefined)
+                constraints[key] = section[key];
+        }
+        return Object.keys(constraints).length === 1 ? [] : [constraints];
+    });
+    const sourceFieldIds = new Set(source.sections.filter((section) => section.kind === "input").map((section) => section.id));
+    const existing = contractInput.supplementalConstraints.fields.filter((entry) => !sourceFieldIds.has(entry.fieldId));
+    const supplemental = [...existing, ...sourceConstraints];
+    const rebound = {
+        ...contractInput,
+        templateIdentity: { ...contractInput.templateIdentity, id: source.id, name: source.name },
+        nativeMetadata: {
+            ...contractInput.nativeMetadata,
+            ...(source.description === undefined ? {} : { description: source.description }),
+            ...(source.title === undefined ? {} : { title: source.title }),
+            ...(source.labels === undefined ? {} : { labels: source.labels }),
+        },
+        sections,
+        supplementalConstraints: { fields: supplemental },
+    };
+    try {
+        assertCanonicalContract(rebound);
+    }
+    catch (cause) {
+        throw new SemanticTemplateError([
+            {
+                code: "SEMANTIC_TEMPLATE_INVALID_VALUE",
+                path: "$",
+                message: cause instanceof Error ? cause.message : "Semantic source did not compile to a valid canonical contract.",
+            },
+        ], { cause });
+    }
+    return rebound;
+}
+function rebindField(field, source) {
+    const nativeMetadata = { ...field.nativeMetadata, sourceId: source.id };
+    if (field.type === "checklist") {
+        const options = source.options ?? [];
+        const items = field.items.map((item, index) => {
+            const option = options[index];
+            return option === undefined
+                ? item
+                : {
+                    ...item,
+                    id: option.id ?? option.value ?? checklistIdentifier(option.label, index),
+                    label: option.label,
+                    required: option.required ?? item.required,
+                };
+        });
+        return {
+            ...field,
+            id: source.id,
+            ...(source.label === undefined ? {} : { label: source.label }),
+            ...(source.description === undefined ? {} : { description: source.description }),
+            nativeMetadata: {
+                ...nativeMetadata,
+                options: items.map((item) => ({ value: item.id, label: item.label, required: item.required })),
+            },
+            items,
+        };
+    }
+    if (field.type === "enum") {
+        const options = field.options.map((option, index) => {
+            const sourceOption = source.options?.[index];
+            return sourceOption === undefined
+                ? option
+                : {
+                    ...option,
+                    value: sourceOption.value ?? sourceOption.id ?? sourceOption.label,
+                    label: sourceOption.label,
+                    ...(sourceOption.description === undefined ? {} : { description: sourceOption.description }),
+                };
+        });
+        return {
+            ...field,
+            id: source.id,
+            ...(source.label === undefined ? {} : { label: source.label }),
+            ...(source.description === undefined ? {} : { description: source.description }),
+            nativeMetadata: {
+                ...nativeMetadata,
+                options: options.map((option) => ({
+                    value: option.value,
+                    label: option.label,
+                    ...(option.description === undefined ? {} : { description: option.description }),
+                })),
+            },
+            options,
+        };
+    }
+    if (field.type === "array") {
+        const options = field.items.options?.map((option, index) => {
+            const sourceOption = source.options?.[index];
+            return sourceOption === undefined
+                ? option
+                : {
+                    ...option,
+                    value: sourceOption.value ?? sourceOption.id ?? sourceOption.label,
+                    label: sourceOption.label,
+                    ...(sourceOption.description === undefined ? {} : { description: sourceOption.description }),
+                };
+        });
+        return {
+            ...field,
+            id: source.id,
+            ...(source.label === undefined ? {} : { label: source.label }),
+            ...(source.description === undefined ? {} : { description: source.description }),
+            nativeMetadata,
+            items: { ...field.items, ...(options === undefined ? {} : { options }) },
+        };
+    }
+    return {
+        ...field,
+        id: source.id,
+        ...(source.label === undefined ? {} : { label: source.label }),
+        ...(source.description === undefined ? {} : { description: source.description }),
+        nativeMetadata,
+    };
+}
+function semanticSourceFromField(field, section) {
+    return {
+        id: field.id,
+        kind: "input",
+        type: field.type,
+        label: field.label,
+        ...(field.description === undefined ? {} : { description: field.description }),
+        ...(field.required === "unknown" ? {} : { required: field.required === "required" }),
+        ...(field.nativeMetadata.placeholder === undefined ? {} : { placeholder: field.nativeMetadata.placeholder }),
+        ...(field.nativeMetadata.render === undefined ? {} : { render: field.nativeMetadata.render }),
+        ...(field.type === "checklist"
+            ? { options: field.items.map((item) => ({ id: item.id, label: item.label, required: item.required })) }
+            : {}),
+        ...(field.type === "enum"
+            ? {
+                options: field.options.map((option) => ({
+                    id: option.value,
+                    label: option.label,
+                    ...(option.description === undefined ? {} : { description: option.description }),
+                })),
+            }
+            : {}),
+        ...(field.type === "array"
+            ? {
+                multiple: field.selection === "multi_select",
+                options: field.items.options?.map((option) => ({ id: option.value, label: option.label })),
+            }
+            : {}),
+        ...headingMetadata(section),
+    };
+}
+function semanticSourceFromContractLegacy(contract) {
+    const sections = [];
+    for (const section of contract.sections) {
+        const field = section.fields[0];
+        if (section.kind === "documentation")
+            sections.push({
+                id: section.id,
+                kind: "documentation",
+                content: section.content ?? "",
+                ...headingMetadata(section),
+            });
+        else if (field !== undefined)
+            sections.push(semanticSourceFromField(field, section));
+    }
+    return {
+        version: SEMANTIC_TEMPLATE_VERSION,
+        kind: contract.artifactKind,
+        id: contract.templateIdentity.id,
+        name: contract.templateIdentity.name,
+        ...(contract.nativeMetadata.description === undefined ? {} : { description: contract.nativeMetadata.description }),
+        ...(contract.nativeMetadata.title === undefined ? {} : { title: contract.nativeMetadata.title }),
+        ...(contract.nativeMetadata.labels === undefined ? {} : { labels: contract.nativeMetadata.labels }),
+        sections,
+    };
+}
+function issueElementType(section) {
+    if (section.element !== undefined)
+        return section.element;
+    if (section.type === "enum" || section.type === "array")
+        return "dropdown";
+    if (section.type === "checklist")
+        return "checkboxes";
+    return "textarea";
+}
+function defaultImportPath(root, source, base) {
+    return source.kind === "issue"
+        ? toRepositoryPath(root, path.join(root, SEMANTIC_ISSUE_DIRECTORY, `${base}.json`))
+        : toRepositoryPath(root, path.join(root, SEMANTIC_TEMPLATE_DIRECTORY, "pull-request.json"));
+}
+function headingMetadata(section) {
+    return {
+        ...(section.title === undefined ? {} : { label: section.title }),
+        ...(section.render.headingLevel === undefined ? {} : { headingLevel: section.render.headingLevel }),
+    };
+}
+function findStaleGeneratedFiles(root, generated) {
+    return findGeneratedFiles(root).then((files) => files.filter((file) => !generated.has(file)));
+}
+async function findGeneratedFiles(root) {
+    const files = [];
+    for (const directory of [ISSUE_NATIVE_DIRECTORY, PR_NATIVE_DIRECTORY]) {
+        const absolute = path.join(root, directory);
+        if (!(await optionalDirectory(absolute)))
+            continue;
+        const entries = await readdir(absolute, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const relative = toRepositoryPath(root, path.join(absolute, entry.name));
+            const content = await readFile(path.join(absolute, entry.name), "utf8");
+            if (content.includes(GENERATED_TEMPLATE_NOTICE))
+                files.push(relative);
+        }
+    }
+    const defaultPr = path.join(root, PR_NATIVE_DEFAULT);
+    if (await optionalFile(defaultPr)) {
+        const relative = toRepositoryPath(root, defaultPr);
+        const content = await readFile(defaultPr, "utf8");
+        if (content.includes(GENERATED_TEMPLATE_NOTICE))
+            files.push(relative);
+    }
+    return [...new Set(files)].sort();
+}
+function semanticSelectorMatches(identity, selector) {
+    if (selector === undefined)
+        return true;
+    const defaultPullRequestName = identity.kind === "pull_request" && identity.generatedPath === PR_NATIVE_DEFAULT ? "default" : undefined;
+    if (typeof selector === "string")
+        return (selector === identity.id ||
+            selector === identity.sourcePath ||
+            selector === identity.generatedPath ||
+            selector.toLocaleLowerCase("en-US") === identity.name.toLocaleLowerCase("en-US") ||
+            selector.toLocaleLowerCase("en-US") === defaultPullRequestName);
+    return ((selector.id === undefined || selector.id === identity.id) &&
+        (selector.path === undefined ||
+            selector.path === identity.sourcePath ||
+            selector.path === identity.generatedPath) &&
+        (selector.name === undefined ||
+            selector.name.toLocaleLowerCase("en-US") === identity.name.toLocaleLowerCase("en-US") ||
+            selector.name.toLocaleLowerCase("en-US") === defaultPullRequestName));
+}
+function normalizeSection(value, pathPrefix, violations) {
+    if (!isRecord(value)) {
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "Sections must be objects.");
+        return undefined;
+    }
+    assertKeys(value, [
+        "id",
+        "kind",
+        "type",
+        "label",
+        "title",
+        "description",
+        "content",
+        "required",
+        "element",
+        "placeholder",
+        "default",
+        "defaultValue",
+        "render",
+        "language",
+        "multiple",
+        "options",
+        "items",
+        "minLength",
+        "maxLength",
+        "pattern",
+        "minItems",
+        "maxItems",
+        "headingLevel",
+    ], pathPrefix, violations);
+    const id = stringValue(value.id, `${pathPrefix}.id`, violations);
+    const rawType = typeof value.type === "string" ? value.type : undefined;
+    const kind = value.kind === "documentation" || rawType === "markdown" || rawType === "documentation" ? "documentation" : "input";
+    const type = normalizeInputType(rawType, `${pathPrefix}.type`, violations, kind);
+    const label = optionalString(value.label ?? value.title, `${pathPrefix}.label`, violations);
+    const description = optionalString(value.description, `${pathPrefix}.description`, violations);
+    const content = optionalString(value.content, `${pathPrefix}.content`, violations);
+    if (kind === "documentation" && content === undefined)
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", `${pathPrefix}.content`, "Documentation sections require content.");
+    if (kind === "input" && label === undefined)
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", `${pathPrefix}.label`, "Input sections require a label.");
+    const required = optionalBoolean(value.required, `${pathPrefix}.required`, violations);
+    const element = optionalElement(value.element, `${pathPrefix}.element`, violations);
+    const placeholder = optionalString(value.placeholder, `${pathPrefix}.placeholder`, violations);
+    const defaultValue = value.defaultValue ?? value.default;
+    const normalizedDefault = normalizeDefault(defaultValue, `${pathPrefix}.defaultValue`, violations);
+    const render = optionalString(value.render ?? value.language, `${pathPrefix}.render`, violations);
+    const multiple = optionalBoolean(value.multiple, `${pathPrefix}.multiple`, violations);
+    const rawOptions = value.options ?? value.items;
+    const options = normalizeOptions(rawOptions, `${pathPrefix}.options`, violations);
+    const minLength = optionalInteger(value.minLength, `${pathPrefix}.minLength`, violations);
+    const maxLength = optionalInteger(value.maxLength, `${pathPrefix}.maxLength`, violations);
+    const pattern = optionalString(value.pattern, `${pathPrefix}.pattern`, violations);
+    const minItems = optionalInteger(value.minItems, `${pathPrefix}.minItems`, violations);
+    const maxItems = optionalInteger(value.maxItems, `${pathPrefix}.maxItems`, violations);
+    const headingLevel = optionalInteger(value.headingLevel, `${pathPrefix}.headingLevel`, violations);
+    if (headingLevel !== undefined && (headingLevel < 1 || headingLevel > 6))
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", `${pathPrefix}.headingLevel`, "headingLevel must be between 1 and 6.");
+    if (minLength !== undefined && maxLength !== undefined && minLength > maxLength)
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "minLength cannot exceed maxLength.");
+    if (minItems !== undefined && maxItems !== undefined && minItems > maxItems)
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "minItems cannot exceed maxItems.");
+    if (id === undefined)
+        return undefined;
+    return {
+        id,
+        kind,
+        ...(type === undefined ? {} : { type }),
+        ...(label === undefined ? {} : { label }),
+        ...(description === undefined ? {} : { description }),
+        ...(content === undefined ? {} : { content }),
+        ...(required === undefined ? {} : { required }),
+        ...(element === undefined ? {} : { element }),
+        ...(placeholder === undefined ? {} : { placeholder }),
+        ...(normalizedDefault === undefined ? {} : { defaultValue: normalizedDefault }),
+        ...(render === undefined ? {} : { render }),
+        ...(multiple === undefined ? {} : { multiple }),
+        ...(options === undefined ? {} : { options }),
+        ...(minLength === undefined ? {} : { minLength }),
+        ...(maxLength === undefined ? {} : { maxLength }),
+        ...(pattern === undefined ? {} : { pattern }),
+        ...(minItems === undefined ? {} : { minItems }),
+        ...(maxItems === undefined ? {} : { maxItems }),
+        ...(headingLevel === undefined ? {} : { headingLevel }),
+    };
+}
+function normalizeInputType(value, pathPrefix, violations, kind) {
+    if (kind === "documentation")
+        return undefined;
+    if (value === undefined || value === "string" || value === "input" || value === "textarea")
+        return "string";
+    if (value === "enum" || value === "select" || value === "dropdown")
+        return "enum";
+    if (value === "array" || value === "multi_select" || value === "multi-select")
+        return "array";
+    if (value === "checklist" || value === "checkboxes")
+        return "checklist";
+    addViolation(violations, "SEMANTIC_TEMPLATE_UNSUPPORTED_FIELD", pathPrefix, `Unsupported semantic field type "${value}".`);
+    return undefined;
+}
+function normalizeOptions(value, pathPrefix, violations) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "options must be an array.");
+        return undefined;
+    }
+    return value.map((entry, index) => {
+        const optionPath = `${pathPrefix}[${index}]`;
+        if (typeof entry === "string")
+            return { label: entry, value: entry, id: entry };
+        if (!isRecord(entry)) {
+            addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", optionPath, "Options must be strings or objects.");
+            return { label: `option-${index + 1}` };
+        }
+        assertKeys(entry, ["id", "value", "label", "description", "required"], optionPath, violations);
+        const label = stringValue(entry.label ?? entry.value ?? entry.id, `${optionPath}.label`, violations) ?? `option-${index + 1}`;
+        const id = optionalString(entry.id, `${optionPath}.id`, violations);
+        const valueText = optionalString(entry.value, `${optionPath}.value`, violations);
+        const description = optionalString(entry.description, `${optionPath}.description`, violations);
+        const required = optionalBoolean(entry.required, `${optionPath}.required`, violations);
+        return {
+            label,
+            ...(id === undefined ? {} : { id }),
+            ...(valueText === undefined ? {} : { value: valueText }),
+            ...(description === undefined ? {} : { description }),
+            ...(required === undefined ? {} : { required }),
+        };
+    });
+}
+function normalizeDefault(value, pathPrefix, violations) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string"))
+        return value;
+    addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "defaultValue must be a string or string array.");
+    return undefined;
+}
+function semanticTypeOf(field) {
+    return field.type ?? "string";
+}
+function rebindSemanticFieldIds(source, contract) {
+    return applySemanticIdentityAndConstraints(contract, source);
+}
+function stripGeneratedNotice(content) {
+    return content.replace(`# ${GENERATED_TEMPLATE_NOTICE}\n`, "").replace(`<!-- ${GENERATED_TEMPLATE_NOTICE} -->\n`, "");
+}
+function checklistIdentifier(label, index) {
+    const normalized = label
+        .normalize("NFKD")
+        .replace(/[\\u0300-\\u036f]/gu, "")
+        .replace(/[^A-Za-z0-9_-]+/gu, "-")
+        .replace(/^-+|-+$/gu, "");
+    if (normalized.length === 0)
+        return `item-${index + 1}`;
+    return /^[A-Za-z]/u.test(normalized) ? normalized : `item-${normalized}`;
+}
+function assertKeys(record, allowed, pathPrefix, violations) {
+    const allowedSet = new Set(allowed);
+    for (const key of Object.keys(record).sort())
+        if (!allowedSet.has(key))
+            addViolation(violations, "SEMANTIC_TEMPLATE_UNKNOWN_PROPERTY", `${pathPrefix}.${key}`, `Unknown semantic template property "${key}".`);
+}
+function stringValue(value, pathPrefix, violations) {
+    if (typeof value === "string" && value.trim().length > 0)
+        return value;
+    addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "Value must be a non-empty string.");
+    return undefined;
+}
+function optionalString(value, pathPrefix, violations) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "Value must be a string.");
+    return undefined;
+}
+function optionalStringList(value, pathPrefix, violations) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry.trim().length > 0))
+        return value;
+    addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "Value must be an array of non-empty strings.");
+    return undefined;
+}
+function optionalBoolean(value, pathPrefix, violations) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "boolean")
+        return value;
+    addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "Value must be boolean.");
+    return undefined;
+}
+function optionalElement(value, pathPrefix, violations) {
+    if (value === undefined)
+        return undefined;
+    if (value === "input" || value === "textarea" || value === "dropdown" || value === "checkboxes")
+        return value;
+    addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "element is not a supported native Issue Form element.");
+    return undefined;
+}
+function optionalInteger(value, pathPrefix, violations) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
+        return value;
+    addViolation(violations, "SEMANTIC_TEMPLATE_INVALID_VALUE", pathPrefix, "Value must be a non-negative safe integer.");
+    return undefined;
+}
+function addViolation(violations, code, pathPrefix, message) {
+    violations.push({ code, path: pathPrefix, message });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveRoot(repositoryRoot) {
+    return path.resolve(typeof repositoryRoot === "string" ? repositoryRoot : fileURLToPath(repositoryRoot));
+}
+function toRepositoryPath(root, absolutePath) {
+    return path.relative(root, absolutePath).split(path.sep).join("/");
+}
+function safeRepositoryPath(root, relativePath) {
+    const absolute = path.resolve(root, relativePath);
+    const relative = path.relative(root, absolute);
+    if (relative.length === 0 || relative.startsWith("..") || path.isAbsolute(relative))
+        throw new SemanticTemplateError([
+            {
+                code: "SEMANTIC_TEMPLATE_INVALID_VALUE",
+                path: relativePath,
+                message: "Repository path must remain inside the repository root.",
+            },
+        ]);
+    return absolute;
+}
+async function writeRepositoryFile(absolutePath, content) {
+    try {
+        if ((await lstat(absolutePath)).isSymbolicLink())
+            throw new SemanticTemplateError([
+                {
+                    code: "SEMANTIC_TEMPLATE_INVALID_VALUE",
+                    path: absolutePath,
+                    message: "Refusing to write through a symbolic link.",
+                },
+            ]);
+    }
+    catch (cause) {
+        if (cause instanceof SemanticTemplateError)
+            throw cause;
+    }
+    await writeFile(absolutePath, content, "utf8");
+}
+async function optionalDirectory(directory) {
+    try {
+        return (await stat(directory)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function optionalFile(file) {
+    try {
+        return (await stat(file)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function optionalDirectorySync(directory) {
+    try {
+        return statSync(directory).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function optionalFileSync(file) {
+    try {
+        return statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=semantic-template.js.map