@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/src/body/amend.js

@@ -0,0 +1,289 @@
+import { decodeVerificationDeclarations, VerificationDocumentError } from "./verification.js";
+import { parseToAST } from "../markdown/parse.js";
+import { directChildren, indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent } from "../markdown/query.js";
+import { decodeRegion, RegionDocumentError } from "./region.js";
+import { contractSectionName, RESERVED_SECTIONS } from "./shape.js";
+import { renderAmendedContractBody } from "./render.js";
+function refusal(message) {
+    throw new TypeError(message);
+}
+function nonblank(document, node) {
+    return rawSlice(document, node.span).trim().length > 0;
+}
+function sections(document) {
+    return indexedHeadings(indexDocument(document), { level: 2 })
+        .filter((node) => node.type === "section");
+}
+function operationSections(document) {
+    if (document.frontmatter !== undefined)
+        refusal("amend operations may not contain frontmatter");
+    if (indexedHeadings(indexDocument(document), { level: 1 }).length > 0)
+        refusal("amend operations may contain H2 sections only");
+    if (document.children.some((node) => node.type !== "section" && nonblank(document, node))) {
+        refusal("amend operations contain bytes outside H2 sections");
+    }
+    return sections(document).map((section) => {
+        const match = /^(Add|Update|Replace|Append|Remove):[ ]+(.+)$/.exec(section.title.trim());
+        if (!match)
+            refusal(`invalid amend operation heading: ${section.title}`);
+        return { kind: match[1], target: match[2].trim(), section };
+    });
+}
+function prose(document, section, label) {
+    const value = sectionContent(document, section);
+    if (value.trim().length === 0)
+        refusal(`${label} operation body must be nonblank`);
+    return value;
+}
+function region(document, section) {
+    try {
+        return decodeRegion(document, section);
+    }
+    catch (error) {
+        if (error instanceof RegionDocumentError)
+            refusal(error.message);
+        throw error;
+    }
+}
+function criteria(document, section) {
+    const headings = directChildren(section, "heading").filter((heading) => heading.level === 3);
+    if (headings.length === 0)
+        refusal("Criteria operation must contain one or more H3 entries");
+    const before = rawSlice(document, { start: section.contentStart, end: headings[0].span.start });
+    if (before.trim().length > 0)
+        refusal("Criteria operation may contain only H3 entries");
+    const seen = new Set();
+    return headings.map((heading, index) => {
+        const title = heading.text.trim();
+        const key = normalizeTitle(title);
+        if (title.length === 0 || seen.has(key))
+            refusal("criteria operation contains duplicate or empty titles");
+        seen.add(key);
+        const body = rawSlice(document, { start: heading.span.end, end: headings[index + 1]?.span.start ?? section.span.end });
+        if (body.trim().length === 0)
+            refusal(`criterion '${title}' operation body is empty`);
+        return { title, body };
+    });
+}
+function verification(document, section) {
+    try {
+        return decodeVerificationDeclarations(document, section);
+    }
+    catch (error) {
+        if (error instanceof VerificationDocumentError)
+            refusal(error.message);
+        throw error;
+    }
+}
+function cloneBody(body) {
+    const criteria = body.criteria.map((criterion) => ({ ...criterion }));
+    const extensions = body.extensions.map((extension) => ({ ...extension }));
+    const criterionIndexes = new Map();
+    criteria.forEach((criterion, index) => {
+        const key = normalizeTitle(criterion.title);
+        if (!criterionIndexes.has(key))
+            criterionIndexes.set(key, index);
+    });
+    const extensionIndexes = new Map();
+    extensions.forEach((extension, index) => {
+        const key = normalizeTitle(extension.title);
+        if (!extensionIndexes.has(key))
+            extensionIndexes.set(key, index);
+    });
+    return {
+        title: body.title,
+        context: body.context,
+        objective: body.objective,
+        design: body.design,
+        region: [...body.region],
+        criteria,
+        verification: body.verification.map((declaration) => ({ ...declaration })),
+        extensions,
+        criterionIndexes,
+        extensionIndexes,
+    };
+}
+function completeBody(body) {
+    return {
+        title: body.title,
+        context: body.context,
+        objective: body.objective,
+        design: body.design,
+        region: body.region,
+        criteria: body.criteria.filter((criterion) => criterion !== undefined),
+        verification: body.verification,
+        extensions: body.extensions.filter((extension) => extension !== undefined),
+    };
+}
+function extensionIndex(body, target) {
+    const index = body.extensionIndexes.get(normalizeTitle(target));
+    return index !== undefined && body.extensions[index]?.title === target ? index : -1;
+}
+function criterionIndex(body, target) {
+    const key = normalizeTitle(target);
+    return body.criterionIndexes.get(key) ?? -1;
+}
+function appendText(current, addition) {
+    return `${current.trimEnd()}\n\n${addition.trim()}\n`;
+}
+function requireEmpty(document, section) {
+    if (sectionContent(document, section).trim().length > 0)
+        refusal("Remove operation must not have a body");
+}
+function alteredText(body, target, value) {
+    body[target] = value;
+}
+function applyRemove(body, operation, document) {
+    requireEmpty(document, operation.section);
+    if (operation.target.startsWith("Criterion ")) {
+        const title = operation.target.slice("Criterion ".length);
+        const index = criterionIndex(body, title);
+        if (index < 0)
+            refusal(`unknown criterion '${title}'`);
+        body.criteria[index] = undefined;
+        body.criterionIndexes.delete(normalizeTitle(title));
+        return;
+    }
+    const index = extensionIndex(body, operation.target);
+    if (index < 0)
+        refusal(`unknown extension '${operation.target}'`);
+    body.extensions[index] = undefined;
+    body.extensionIndexes.delete(normalizeTitle(operation.target));
+}
+function applyUpdate(body, operation, document) {
+    if (operation.target.startsWith("Criterion ")) {
+        const title = operation.target.slice("Criterion ".length);
+        const index = criterionIndex(body, title);
+        if (index < 0)
+            refusal(`unknown criterion '${title}'`);
+        const criterion = body.criteria[index];
+        body.criteria[index] = { ...criterion, body: prose(document, operation.section, "criterion") };
+        return;
+    }
+    const index = extensionIndex(body, operation.target);
+    if (index < 0)
+        refusal(`unknown extension '${operation.target}'`);
+    const extension = body.extensions[index];
+    body.extensions[index] = { ...extension, content: prose(document, operation.section, "extension") };
+}
+function addedCriteria(body, operation, document) {
+    const added = criteria(document, operation.section);
+    if (added.some((candidate) => criterionIndex(body, candidate.title) >= 0)) {
+        refusal(`${operation.kind} Criteria targets an existing criterion`);
+    }
+    for (const criterion of added) {
+        const index = body.criteria.length;
+        body.criteria.push(criterion);
+        body.criterionIndexes.set(normalizeTitle(criterion.title), index);
+    }
+}
+function applyAdd(body, operation, document) {
+    const target = contractSectionName(operation.target);
+    if (target === "criteria") {
+        addedCriteria(body, operation, document);
+        return;
+    }
+    if (target !== null)
+        refusal(`Add does not support ${operation.target}`);
+    const normalized = normalizeTitle(operation.target);
+    if (RESERVED_SECTIONS.has(normalized))
+        refusal(`${normalized} is not a contract Markdown section`);
+    if (body.extensionIndexes.has(normalized))
+        refusal(`extension already exists '${operation.target}'`);
+    const index = body.extensions.length;
+    body.extensions.push({ title: operation.target, content: prose(document, operation.section, "extension") });
+    body.extensionIndexes.set(normalized, index);
+}
+function applyAppend(body, operation, document) {
+    const target = contractSectionName(operation.target);
+    if (target === "criteria") {
+        addedCriteria(body, operation, document);
+        return;
+    }
+    if (target === "context" || target === "objective" || target === "design") {
+        alteredText(body, target, appendText(body[target], prose(document, operation.section, operation.target)));
+        return;
+    }
+    if (target !== null)
+        refusal(`Append does not support ${operation.target}`);
+    const index = extensionIndex(body, operation.target);
+    if (index < 0)
+        refusal(`unknown extension '${operation.target}'`);
+    const extension = body.extensions[index];
+    body.extensions[index] = { ...extension, content: appendText(extension.content, prose(document, operation.section, "extension")) };
+}
+function applyReplace(body, operation, document) {
+    const target = contractSectionName(operation.target);
+    if (target === "verification") {
+        body.verification = verification(document, operation.section);
+        return;
+    }
+    if (target === "context" || target === "objective" || target === "design") {
+        alteredText(body, target, prose(document, operation.section, operation.target));
+        return;
+    }
+    if (target === "region") {
+        body.region = region(document, operation.section);
+        return;
+    }
+    if (target === "criteria") {
+        const replacement = criteria(document, operation.section);
+        body.criteria = [...replacement];
+        body.criterionIndexes = new Map(replacement.map((criterion, index) => [normalizeTitle(criterion.title), index]));
+        return;
+    }
+    if (target !== null)
+        refusal(`Replace does not support ${operation.target}`);
+    const index = extensionIndex(body, operation.target);
+    if (index < 0)
+        refusal(`unknown extension '${operation.target}'`);
+    const extension = body.extensions[index];
+    body.extensions[index] = { ...extension, content: prose(document, operation.section, "extension") };
+}
+function applyOperation(body, operation, document) {
+    switch (operation.kind) {
+        case "Add":
+            applyAdd(body, operation, document);
+            return;
+        case "Update":
+            applyUpdate(body, operation, document);
+            return;
+        case "Replace":
+            applyReplace(body, operation, document);
+            return;
+        case "Append":
+            applyAppend(body, operation, document);
+            return;
+        case "Remove":
+            applyRemove(body, operation, document);
+            return;
+    }
+}
+function operationKey(operation) {
+    const target = operation.target.startsWith("Criterion ")
+        ? `Criterion ${normalizeTitle(operation.target.slice("Criterion ".length))}`
+        : operation.target;
+    return `${operation.kind}:${target}`;
+}
+function apply(source, current) {
+    const document = parseToAST(source);
+    const operations = operationSections(document);
+    if (operations.length === 0)
+        refusal("amend requires at least one H2 operation");
+    const seen = new Set();
+    const changed = new Set();
+    const body = cloneBody(current);
+    for (const operation of operations) {
+        const key = operationKey(operation);
+        if (seen.has(key))
+            refusal(`duplicate amend operation '${key}'`);
+        seen.add(key);
+        changed.add(normalizeTitle(operation.target.startsWith("Criterion ") ? "Criteria" : operation.target));
+        applyOperation(body, operation, document);
+    }
+    return { body: completeBody(body), changed };
+}
+export function applyAmendDocument(source, current) {
+    const result = apply(source, current);
+    return renderAmendedContractBody(current.document.bytes, result.body, result.changed);
+}

package/build/src/body/arc.d.ts

@@ -0,0 +1,2 @@
+import type { ArcData } from "../core/facts/types.js";
+export declare function decodeArcDocument(source: string): Readonly<Omit<ArcData, "seq">>;

package/build/src/body/arc.js

@@ -0,0 +1,54 @@
+import { parseToAST } from "../markdown/parse.js";
+import { indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
+function refusal(message) {
+    throw new TypeError(message);
+}
+function nonblankRaw(document, node) {
+    return rawSlice(document, node.span).trim().length > 0;
+}
+function topLevelSections(document) {
+    return indexedHeadings(indexDocument(document), { level: 2 })
+        .filter((node) => node.type === "section");
+}
+function requiredProse(document, sections, name) {
+    const section = sections.get(name);
+    if (section === undefined)
+        refusal(`arc document is missing ## ${name[0].toUpperCase()}${name.slice(1)}`);
+    const value = sectionContent(document, section);
+    if (value.trim().length === 0)
+        refusal(`arc section '${section.title}' is empty`);
+    return value;
+}
+export function decodeArcDocument(source) {
+    const document = parseToAST(source);
+    if (document.frontmatter !== undefined)
+        refusal("arc document may not contain frontmatter");
+    const titles = indexedHeadings(indexDocument(document), { level: 1 })
+        .filter((node) => node.type === "section");
+    if (titles.length !== 1)
+        refusal("arc document requires exactly one H1 title");
+    const title = titles[0];
+    if (title.title.trim().length === 0)
+        refusal("arc title must be nonblank");
+    if (title.children.some((node) => nonblankRaw(document, node))) {
+        refusal("arc title may not contain content before the first H2 section");
+    }
+    const stray = document.children.filter((node) => node.type !== "section" && nonblankRaw(document, node));
+    if (stray.length > 0)
+        refusal("arc document contains content outside an H1 or H2 section");
+    const sections = new Map();
+    for (const section of topLevelSections(document)) {
+        const name = normalizeTitle(section.title);
+        if (sections.has(name))
+            refusal(`duplicate arc section '${section.title}'`);
+        if (name !== "objective" && name !== "brief") {
+            refusal(`arc document does not allow ## ${section.title}`);
+        }
+        sections.set(name, section);
+    }
+    return {
+        title: title.title,
+        objective: requiredProse(document, sections, "objective"),
+        brief: requiredProse(document, sections, "brief"),
+    };
+}

package/build/src/body/decode.d.ts

@@ -0,0 +1,4 @@
+import type { DecodedContractDocument } from "./types.js";
+import type { VerificationDefinition } from "../verification/declaration.js";
+export declare function decodeContractDocument(source: string): DecodedContractDocument;
+export declare function verificationDefinition(document: DecodedContractDocument): VerificationDefinition | null;

package/build/src/body/decode.js

@@ -0,0 +1,146 @@
+import { mintDocumentKey, mintDocumentSegmentKey } from "./keys.js";
+import { parseToAST } from "../markdown/parse.js";
+import { directChildren, indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
+import { CONTRACT_SECTIONS, RESERVED_SECTIONS } from "./shape.js";
+import { decodeRegion, RegionDocumentError } from "./region.js";
+import { decodeVerificationDeclarations, VerificationDocumentError } from "./verification.js";
+function refusal(message) {
+    throw new TypeError(message);
+}
+function nonblankRaw(document, node) {
+    return rawSlice(document, node.span).trim().length > 0;
+}
+function topLevelSections(document) {
+    return indexedHeadings(indexDocument(document), { level: 2 })
+        .filter((node) => node.type === "section");
+}
+function indexedSections(document) {
+    const sections = new Map();
+    for (const section of topLevelSections(document)) {
+        const title = normalizeTitle(section.title);
+        if (sections.has(title))
+            refusal(`duplicate contract section '${section.title}'`);
+        sections.set(title, section);
+    }
+    return sections;
+}
+function requireSections(sections) {
+    for (const [name, spec] of Object.entries(CONTRACT_SECTIONS)) {
+        if (spec.required && !sections.has(name))
+            refusal(`contract document is missing ## ${spec.title}`);
+    }
+}
+function requiredSection(sections, name) {
+    return sections.get(name);
+}
+function prose(document, section) {
+    const value = sectionContent(document, section);
+    if (value.trim().length === 0)
+        refusal(`contract section '${section.title}' is empty`);
+    return value;
+}
+function region(document, section) {
+    try {
+        return decodeRegion(document, section);
+    }
+    catch (error) {
+        if (error instanceof RegionDocumentError)
+            refusal(error.message);
+        throw error;
+    }
+}
+function criteria(document, section) {
+    const headings = directChildren(section, "heading").filter((heading) => heading.level === 3);
+    if (headings.length === 0)
+        refusal("Criteria must contain one or more H3 entries");
+    const before = rawSlice(document, { start: section.contentStart, end: headings[0].span.start });
+    if (before.trim().length > 0)
+        refusal("Criteria may contain only H3 entries");
+    const seen = new Set();
+    return headings.map((heading, index) => {
+        const title = heading.text.trim();
+        const key = normalizeTitle(title);
+        if (seen.has(key))
+            refusal(`duplicate criterion '${title}'`);
+        seen.add(key);
+        const body = rawSlice(document, {
+            start: heading.span.end,
+            end: headings[index + 1]?.span.start ?? section.span.end,
+        });
+        if (body.trim().length === 0)
+            refusal(`criterion '${title}' is empty`);
+        return { title, body };
+    });
+}
+function rejectUnownedBytes(document, title) {
+    if (title.children.some((node) => nonblankRaw(document, node))) {
+        refusal("contract title may not contain content before the first H2 section");
+    }
+    const stray = document.children.filter((node) => node.type !== "section" && nonblankRaw(document, node));
+    if (stray.length > 0)
+        refusal("contract document contains content outside an H1 or H2 section");
+}
+function verification(document, section) {
+    try {
+        return decodeVerificationDeclarations(document, section);
+    }
+    catch (error) {
+        if (error instanceof VerificationDocumentError)
+            refusal(error.message);
+        throw error;
+    }
+}
+export function decodeContractDocument(source) {
+    const document = parseToAST(source);
+    if (document.frontmatter !== undefined)
+        refusal("contract document may not contain frontmatter");
+    const titles = indexedHeadings(indexDocument(document), { level: 1 })
+        .filter((node) => node.type === "section");
+    if (titles.length !== 1)
+        refusal("contract document requires exactly one H1 title");
+    const title = titles[0];
+    rejectUnownedBytes(document, title);
+    const sections = indexedSections(document);
+    requireSections(sections);
+    for (const name of RESERVED_SECTIONS) {
+        if (sections.has(name))
+            refusal(`${name} is not a contract Markdown section`);
+    }
+    const extensions = [...sections.entries()]
+        .filter(([name]) => !Object.hasOwn(CONTRACT_SECTIONS, name))
+        .map(([, section]) => {
+        const content = sectionContent(document, section);
+        if (content.trim().length === 0)
+            refusal(`extension '${section.title}' is empty`);
+        return { title: section.title, content };
+    });
+    const verificationSection = sections.get("verification");
+    const body = {
+        title: title.title,
+        context: prose(document, requiredSection(sections, "context")),
+        objective: prose(document, requiredSection(sections, "objective")),
+        design: prose(document, requiredSection(sections, "design")),
+        region: region(document, requiredSection(sections, "region")),
+        criteria: criteria(document, requiredSection(sections, "criteria")),
+        verification: verificationSection === undefined ? [] : verification(document, verificationSection),
+        extensions,
+    };
+    const sectionNodes = topLevelSections(document);
+    const segments = sectionNodes.map((section) => mintDocumentSegmentKey(document.source, section.span));
+    return {
+        ...body,
+        document: { bytes: source, key: mintDocumentKey(source) },
+        segments,
+        verificationSegment: verificationSection === undefined
+            ? null
+            : mintDocumentSegmentKey(document.source, verificationSection.span),
+    };
+}
+export function verificationDefinition(document) {
+    if (document.verificationSegment === null)
+        return null;
+    return {
+        segment: document.verificationSegment,
+        declarations: document.verification,
+    };
+}

package/build/src/body/keys.d.ts

@@ -0,0 +1,4 @@
+import { type DocumentKey, type DocumentSegmentKey } from "../core/facts/types.js";
+import type { SourceSpan } from "../markdown/types.js";
+export declare function mintDocumentKey(source: string): DocumentKey;
+export declare function mintDocumentSegmentKey(source: string, span: SourceSpan): DocumentSegmentKey;

package/build/src/body/keys.js

@@ -0,0 +1,11 @@
+import { createHash } from "node:crypto";
+import { documentKey, documentSegmentKey } from "../core/facts/types.js";
+function digest(value) {
+    return createHash("sha256").update(Buffer.from(value, "utf8")).digest("hex");
+}
+export function mintDocumentKey(source) {
+    return documentKey(`document:sha256:${digest(source)}`);
+}
+export function mintDocumentSegmentKey(source, span) {
+    return documentSegmentKey(`segment:sha256:${digest(source.slice(span.start, span.end))}`);
+}

package/build/src/body/region.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentNode, SectionNode } from "../markdown/types.js";
+export declare class RegionDocumentError extends Error {
+    constructor(message: string);
+}
+export declare function decodeRegion(document: DocumentNode, section: SectionNode): readonly string[];
+export declare function regionsOverlap(mine: readonly string[], theirs: readonly string[]): readonly [string, string][];

package/build/src/body/region.js

@@ -0,0 +1,139 @@
+import { directChildren, rawSlice } from "../markdown/query.js";
+export class RegionDocumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RegionDocumentError";
+    }
+}
+function refusal(message) {
+    throw new RegionDocumentError(message);
+}
+function nonblank(document, node) {
+    return rawSlice(document, node.span).trim().length > 0;
+}
+function compileSegment(segment, pattern) {
+    if (segment === "**")
+        return { kind: "deep" };
+    if (segment.includes("**")) {
+        refusal(`Region pattern '${pattern}' may use ** only as a complete segment`);
+    }
+    return { kind: "segment", characters: Array.from(segment) };
+}
+function compileRegionPattern(pattern) {
+    if (pattern.length === 0)
+        refusal("Region path patterns must be nonblank");
+    if (/[\r\n]/.test(pattern))
+        refusal(`Region pattern '${pattern}' must occupy one line`);
+    if (/[!\[\]{}]/.test(pattern))
+        refusal(`Region pattern '${pattern}' contains a forbidden glob form`);
+    if (pattern.startsWith("/"))
+        refusal(`Region pattern '${pattern}' must be repository-relative`);
+    if (pattern.endsWith("/"))
+        refusal(`Region pattern '${pattern}' may not end with /`);
+    if (pattern.includes(".."))
+        refusal(`Region pattern '${pattern}' may not contain ..`);
+    const segments = pattern.split("/");
+    if (segments.some((segment) => segment.length === 0)) {
+        refusal(`Region pattern '${pattern}' may not contain an empty segment`);
+    }
+    return { source: pattern, segments: segments.map((segment) => compileSegment(segment, pattern)) };
+}
+function segmentTransition(characters, index) {
+    const character = characters[index];
+    if (character === undefined)
+        return null;
+    if (character === "*")
+        return { next: index, character: null };
+    if (character === "?")
+        return { next: index + 1, character: null };
+    return { next: index + 1, character };
+}
+function compatible(left, right) {
+    return left.character === null || right.character === null || left.character === right.character;
+}
+function segmentsOverlap(left, right) {
+    const queue = [[0, 0, false]];
+    const visited = new Set();
+    let cursor = 0;
+    while (cursor < queue.length) {
+        const [leftIndex, rightIndex, consumed] = queue[cursor++];
+        const key = `${leftIndex}:${rightIndex}:${consumed}`;
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        if (leftIndex === left.length && rightIndex === right.length && consumed)
+            return true;
+        if (left[leftIndex] === "*")
+            queue.push([leftIndex + 1, rightIndex, consumed]);
+        if (right[rightIndex] === "*")
+            queue.push([leftIndex, rightIndex + 1, consumed]);
+        const leftTransition = segmentTransition(left, leftIndex);
+        const rightTransition = segmentTransition(right, rightIndex);
+        if (leftTransition !== null && rightTransition !== null && compatible(leftTransition, rightTransition)) {
+            queue.push([leftTransition.next, rightTransition.next, true]);
+        }
+    }
+    return false;
+}
+function patternsOverlap(left, right) {
+    const queue = [[0, 0]];
+    const visited = new Set();
+    let cursor = 0;
+    while (cursor < queue.length) {
+        const [leftIndex, rightIndex] = queue[cursor++];
+        const key = `${leftIndex}:${rightIndex}`;
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        if (leftIndex === left.length && rightIndex === right.length)
+            return true;
+        const leftSegment = left[leftIndex];
+        const rightSegment = right[rightIndex];
+        if (leftSegment?.kind === "deep")
+            queue.push([leftIndex + 1, rightIndex]);
+        if (rightSegment?.kind === "deep")
+            queue.push([leftIndex, rightIndex + 1]);
+        if (leftSegment === undefined || rightSegment === undefined)
+            continue;
+        if (leftSegment.kind === "deep") {
+            queue.push([leftIndex, rightSegment.kind === "deep" ? rightIndex : rightIndex + 1]);
+            continue;
+        }
+        if (rightSegment.kind === "deep") {
+            queue.push([leftIndex + 1, rightIndex]);
+            continue;
+        }
+        if (segmentsOverlap(leftSegment.characters, rightSegment.characters)) {
+            queue.push([leftIndex + 1, rightIndex + 1]);
+        }
+    }
+    return false;
+}
+export function decodeRegion(document, section) {
+    const blocks = directChildren(section, "code_block");
+    if (blocks.length !== 1 || !blocks[0].closed || blocks[0].info.length > 0) {
+        refusal("Region must contain one closed fence without an info string");
+    }
+    const other = section.children.filter((node) => node !== blocks[0] && nonblank(document, node));
+    if (other.length > 0)
+        refusal("Region may contain only its fenced declaration");
+    const patterns = blocks[0].lines.slice(1, -1).filter((line) => line.trim().length > 0);
+    if (patterns.length === 0)
+        refusal("Region must declare at least one path pattern");
+    for (const pattern of patterns)
+        compileRegionPattern(pattern);
+    return patterns;
+}
+export function regionsOverlap(mine, theirs) {
+    const myPatterns = mine.map((pattern) => compileRegionPattern(pattern));
+    const theirPatterns = theirs.map((pattern) => compileRegionPattern(pattern));
+    const overlaps = [];
+    for (const myPattern of myPatterns) {
+        for (const theirPattern of theirPatterns) {
+            if (patternsOverlap(myPattern.segments, theirPattern.segments)) {
+                overlaps.push([myPattern.source, theirPattern.source]);
+            }
+        }
+    }
+    return overlaps;
+}

package/build/src/body/render.d.ts

@@ -0,0 +1,4 @@
+import type { ArcData } from "../core/facts/types.js";
+import type { ContractBody } from "./types.js";
+export declare function renderContractBody(body: ContractBody, currentArc?: ArcData): string;
+export declare function renderAmendedContractBody(currentSource: string, body: ContractBody, changedSections: ReadonlySet<string>): string;