project-tiny-context-harness 0.8.17 → 0.11.0

package/dist/lib/design-authority-delta-codec-primitives.js

@@ -0,0 +1,58 @@
+import { normalizeRepositoryFile } from "./long-task-paths.js";
+export function deltaRow(value, label, required, optional = []) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        deltaInvalid(label, "object_required");
+    const result = value;
+    const allowed = new Set([...required, ...optional]);
+    for (const key of Object.keys(result))
+        if (!allowed.has(key))
+            deltaInvalid(label, `unknown_field:${key}`);
+    for (const key of required)
+        if (!Object.hasOwn(result, key))
+            deltaInvalid(label, `missing_field:${key}`);
+    return result;
+}
+export function deltaArray(value, label) {
+    if (!Array.isArray(value))
+        deltaInvalid(label, "array_required");
+    return value;
+}
+export function deltaText(value, label) {
+    if (typeof value !== "string" || !value.trim() || /[\0\r\n\t]/u.test(value))
+        deltaInvalid(label, "non_empty_single_line_string_required");
+    return value;
+}
+export function deltaOneOf(value, allowed, label) {
+    const result = deltaText(value, label);
+    if (!allowed.includes(result))
+        deltaInvalid(label, `unsupported:${result}`);
+    return result;
+}
+export function deltaExact(value, expected, label) {
+    if (value !== expected)
+        deltaInvalid(label, `expected:${String(expected)}`);
+    return expected;
+}
+export function deltaStringSet(value, label, allowEmpty = false) {
+    const values = deltaArray(value, label).map((item, index) => deltaText(item, `${label}[${index}]`));
+    if (!allowEmpty && !values.length)
+        deltaInvalid(label, "non_empty_array_required");
+    if (new Set(values).size !== values.length)
+        deltaInvalid(label, "duplicate_value");
+    return values.sort(deltaCompare);
+}
+export function deltaSourceRefSet(value, label, allowEmpty = false) {
+    return deltaStringSet(value, label, allowEmpty).map((item) => {
+        const [file, anchor, ...extra] = item.split("#");
+        if (!file || extra.length || (anchor !== undefined && !anchor))
+            deltaInvalid(label, `invalid_source_ref:${item}`);
+        const normalized = normalizeRepositoryFile(file, label);
+        return anchor === undefined ? normalized : `${normalized}#${anchor}`;
+    });
+}
+export function deltaCompare(left, right) {
+    return Buffer.from(left).compare(Buffer.from(right));
+}
+export function deltaInvalid(label, reason) {
+    throw new Error(`design_authority_delta_invalid:${label}:${reason}`);
+}

package/dist/lib/design-authority-delta-codec.d.ts

@@ -0,0 +1,2 @@
+import { type DesignAuthorityDeltaAssessmentV1 } from "./design-authority-delta-types.js";
+export declare function parseDesignAuthorityDeltaAssessment(content: string): DesignAuthorityDeltaAssessmentV1;

package/dist/lib/design-authority-delta-codec.js

@@ -0,0 +1,193 @@
+import { DESIGN_AUTHORITY_DELTA_ASSESSMENTS, DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA, } from "./design-authority-delta-types.js";
+import { DESIGN_AUTHORITY_ENTRY_PATH, DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION, DESIGN_AUTHORITY_MANIFEST_PATH, isDesignAuthorityDigest, } from "./design-authority-types.js";
+import { normalizeRepositoryFile } from "./long-task-paths.js";
+import { parseStrictYaml } from "./strict-codec.js";
+import { deltaArray as array, deltaCompare as compare, deltaExact as exact, deltaInvalid as invalid, deltaOneOf as oneOf, deltaRow as row, deltaSourceRefSet as sourceRefSet, deltaStringSet as stringSet, deltaText as text, } from "./design-authority-delta-codec-primitives.js";
+export function parseDesignAuthorityDeltaAssessment(content) {
+    let decoded;
+    try {
+        JSON.parse(content);
+        decoded = parseStrictYaml(content);
+    }
+    catch (error) {
+        invalid("assessment", `json:${message(error)}`);
+    }
+    const common = row(decoded, "assessment", ["schema_version", "assessment", "based_on"], [
+        "evidence",
+        "observed_variances",
+        "scope",
+        "reason",
+        "affected_rules",
+        "durability",
+        "precedent",
+        "required_owner",
+        "proposed_changes",
+        "supporting_resources",
+        "representative_scenarios",
+    ]);
+    exact(common.schema_version, DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA, "assessment.schema_version");
+    const assessment = oneOf(common.assessment, DESIGN_AUTHORITY_DELTA_ASSESSMENTS, "assessment.assessment");
+    if (assessment === "consistent_with_current_authority")
+        return parseConsistent(decoded);
+    if (assessment === "task_local_variance")
+        return parseVariance(decoded);
+    return parseCandidate(decoded);
+}
+function parseConsistent(value) {
+    const input = row(value, "assessment", [
+        "schema_version",
+        "assessment",
+        "based_on",
+        "evidence",
+        "observed_variances",
+    ]);
+    const evidence = parseEvidence(input.evidence);
+    if (evidence.tokens.length +
+        evidence.components.length +
+        evidence.rules.length ===
+        0)
+        invalid("assessment.evidence", "at_least_one_reference_required");
+    const variances = array(input.observed_variances, "assessment.observed_variances");
+    if (variances.length)
+        invalid("assessment.observed_variances", "must_be_empty_for_consistent");
+    return {
+        schema_version: DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA,
+        assessment: "consistent_with_current_authority",
+        based_on: parseIdentity(input.based_on, "assessment.based_on"),
+        evidence,
+        observed_variances: [],
+    };
+}
+function parseVariance(value) {
+    const base = row(value, "assessment", [
+        "schema_version",
+        "assessment",
+        "based_on",
+        "scope",
+        "reason",
+        "affected_rules",
+        "durability",
+    ], ["precedent", "required_owner"]);
+    const durability = oneOf(base.durability, ["task_only", "cross_task_candidate"], "assessment.durability");
+    const common = {
+        schema_version: DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA,
+        assessment: "task_local_variance",
+        based_on: parseIdentity(base.based_on, "assessment.based_on"),
+        scope: stringSet(base.scope, "assessment.scope"),
+        reason: text(base.reason, "assessment.reason"),
+        affected_rules: sourceRefSet(base.affected_rules, "assessment.affected_rules"),
+    };
+    if (durability === "task_only") {
+        exact(base.precedent, "forbidden", "assessment.precedent");
+        if (base.required_owner !== undefined)
+            invalid("assessment.required_owner", "forbidden_for_task_only");
+        return {
+            ...common,
+            durability,
+            precedent: "forbidden",
+        };
+    }
+    if (base.precedent !== undefined)
+        invalid("assessment.precedent", "forbidden_for_cross_task_candidate");
+    return {
+        ...common,
+        durability,
+        required_owner: parseScreenContractOwner(base.required_owner),
+    };
+}
+function parseCandidate(value) {
+    const input = row(value, "assessment", [
+        "schema_version",
+        "assessment",
+        "based_on",
+        "proposed_changes",
+        "supporting_resources",
+        "representative_scenarios",
+    ]);
+    const proposedChanges = parseChanges(input.proposed_changes);
+    if (Object.values(proposedChanges).reduce((total, changes) => total + changes.length, 0) === 0)
+        invalid("assessment.proposed_changes", "at_least_one_change_required");
+    return {
+        schema_version: DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA,
+        assessment: "authority_delta_candidate",
+        based_on: parseIdentity(input.based_on, "assessment.based_on"),
+        proposed_changes: proposedChanges,
+        supporting_resources: sourceRefSet(input.supporting_resources, "assessment.supporting_resources", true),
+        representative_scenarios: stringSet(input.representative_scenarios, "assessment.representative_scenarios"),
+    };
+}
+function parseEvidence(value) {
+    const input = row(value, "assessment.evidence", [
+        "tokens",
+        "components",
+        "rules",
+    ]);
+    return {
+        tokens: stringSet(input.tokens, "assessment.evidence.tokens", true),
+        components: stringSet(input.components, "assessment.evidence.components", true),
+        rules: sourceRefSet(input.rules, "assessment.evidence.rules", true),
+    };
+}
+function parseChanges(value) {
+    const input = row(value, "assessment.proposed_changes", [
+        "tokens",
+        "components",
+        "patterns",
+        "motion",
+        "platforms",
+    ]);
+    return Object.fromEntries(Object.entries(input).map(([kind, changes]) => [
+        kind,
+        changeSet(changes, `assessment.proposed_changes.${kind}`),
+    ]));
+}
+function changeSet(value, label) {
+    const changes = array(value, label).map((item, index) => {
+        const local = `${label}[${index}]`;
+        const input = row(item, local, ["key", "proposal", "rationale"]);
+        return {
+            key: text(input.key, `${local}.key`),
+            proposal: text(input.proposal, `${local}.proposal`),
+            rationale: text(input.rationale, `${local}.rationale`),
+        };
+    });
+    if (new Set(changes.map((change) => change.key)).size !== changes.length)
+        invalid(label, "duplicate_key");
+    return changes.sort((left, right) => compare(left.key, right.key));
+}
+function parseIdentity(value, label) {
+    const input = row(value, label, [
+        "format_version",
+        "entry_path",
+        "manifest_path",
+        "closure_digest",
+        "revision",
+    ]);
+    exact(input.format_version, DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION, `${label}.format_version`);
+    exact(input.entry_path, DESIGN_AUTHORITY_ENTRY_PATH, `${label}.entry_path`);
+    if (input.manifest_path !== null &&
+        input.manifest_path !== DESIGN_AUTHORITY_MANIFEST_PATH)
+        invalid(`${label}.manifest_path`, "unsupported_manifest_path");
+    if (!isDesignAuthorityDigest(input.closure_digest))
+        invalid(`${label}.closure_digest`, "sha256_identity_required");
+    if (input.revision !== null)
+        text(input.revision, `${label}.revision`);
+    return {
+        format_version: DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION,
+        entry_path: DESIGN_AUTHORITY_ENTRY_PATH,
+        manifest_path: input.manifest_path,
+        closure_digest: input.closure_digest,
+        revision: input.revision,
+    };
+}
+function parseScreenContractOwner(value) {
+    const input = row(value, "assessment.required_owner", ["type", "path"]);
+    exact(input.type, "screen_contract", "assessment.required_owner.type");
+    const ownerPath = normalizeRepositoryFile(text(input.path, "assessment.required_owner.path"), "assessment.required_owner.path");
+    if (!ownerPath.startsWith("project_context/") || !ownerPath.endsWith(".md"))
+        invalid("assessment.required_owner.path", "screen_contract_must_be_project_context_markdown");
+    return { type: "screen_contract", path: ownerPath };
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/design-authority-delta-types.d.ts

@@ -0,0 +1,65 @@
+import type { DesignAuthorityIdentityV1 } from "./design-authority-types.js";
+export declare const DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA: "design-authority-delta-assessment-v1";
+export declare const DESIGN_AUTHORITY_DELTA_ASSESSMENTS: readonly ["consistent_with_current_authority", "task_local_variance", "authority_delta_candidate"];
+export type DesignAuthorityDeltaAssessmentKind = (typeof DESIGN_AUTHORITY_DELTA_ASSESSMENTS)[number];
+export interface DesignAuthorityDeltaEvidenceV1 {
+    tokens: string[];
+    components: string[];
+    rules: string[];
+}
+export interface DesignAuthorityDeltaChangeV1 {
+    key: string;
+    proposal: string;
+    rationale: string;
+}
+export interface DesignAuthorityDeltaChangesV1 {
+    tokens: DesignAuthorityDeltaChangeV1[];
+    components: DesignAuthorityDeltaChangeV1[];
+    patterns: DesignAuthorityDeltaChangeV1[];
+    motion: DesignAuthorityDeltaChangeV1[];
+    platforms: DesignAuthorityDeltaChangeV1[];
+}
+interface DesignAuthorityDeltaAssessmentBaseV1 {
+    schema_version: typeof DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA;
+    assessment: DesignAuthorityDeltaAssessmentKind;
+    based_on: DesignAuthorityIdentityV1;
+}
+export interface DesignAuthorityConsistentAssessmentV1 extends DesignAuthorityDeltaAssessmentBaseV1 {
+    assessment: "consistent_with_current_authority";
+    evidence: DesignAuthorityDeltaEvidenceV1;
+    observed_variances: [];
+}
+export interface DesignAuthorityTaskOnlyVarianceV1 extends DesignAuthorityDeltaAssessmentBaseV1 {
+    assessment: "task_local_variance";
+    scope: string[];
+    reason: string;
+    affected_rules: string[];
+    durability: "task_only";
+    precedent: "forbidden";
+}
+export interface DesignAuthorityCrossTaskVarianceV1 extends DesignAuthorityDeltaAssessmentBaseV1 {
+    assessment: "task_local_variance";
+    scope: string[];
+    reason: string;
+    affected_rules: string[];
+    durability: "cross_task_candidate";
+    required_owner: {
+        type: "screen_contract";
+        path: string;
+    };
+}
+export interface DesignAuthorityDeltaCandidateV1 extends DesignAuthorityDeltaAssessmentBaseV1 {
+    assessment: "authority_delta_candidate";
+    proposed_changes: DesignAuthorityDeltaChangesV1;
+    supporting_resources: string[];
+    representative_scenarios: string[];
+}
+export type DesignAuthorityDeltaAssessmentV1 = DesignAuthorityConsistentAssessmentV1 | DesignAuthorityTaskOnlyVarianceV1 | DesignAuthorityCrossTaskVarianceV1 | DesignAuthorityDeltaCandidateV1;
+export interface DesignAuthorityDeltaValidationV1 {
+    schema_version: typeof DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA;
+    assessment: DesignAuthorityDeltaAssessmentKind;
+    authority_identity: DesignAuthorityIdentityV1;
+    authority_current: true;
+    write_performed: false;
+}
+export {};

package/dist/lib/design-authority-delta-types.js

@@ -0,0 +1,6 @@
+export const DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA = "design-authority-delta-assessment-v1";
+export const DESIGN_AUTHORITY_DELTA_ASSESSMENTS = [
+    "consistent_with_current_authority",
+    "task_local_variance",
+    "authority_delta_candidate",
+];

package/dist/lib/design-authority-delta-validation.d.ts

@@ -0,0 +1,2 @@
+import { type DesignAuthorityDeltaAssessmentV1, type DesignAuthorityDeltaValidationV1 } from "./design-authority-delta-types.js";
+export declare function validateDesignAuthorityDeltaAssessmentCurrent(repository: string, assessment: DesignAuthorityDeltaAssessmentV1): Promise<DesignAuthorityDeltaValidationV1>;

package/dist/lib/design-authority-delta-validation.js

@@ -0,0 +1,16 @@
+import { loadCurrentDesignAuthorityClosure } from "./design-authority-closure.js";
+import { DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA, } from "./design-authority-delta-types.js";
+import { canonicalValueJson } from "./strict-codec.js";
+export async function validateDesignAuthorityDeltaAssessmentCurrent(repository, assessment) {
+    const current = await loadCurrentDesignAuthorityClosure(repository);
+    if (canonicalValueJson(assessment.based_on) !==
+        canonicalValueJson(current.identity))
+        throw new Error(`design_authority_delta_invalid:assessment.based_on:identity_mismatch:${assessment.based_on.closure_digest}:${current.identity.closure_digest}`);
+    return {
+        schema_version: DESIGN_AUTHORITY_DELTA_ASSESSMENT_SCHEMA,
+        assessment: assessment.assessment,
+        authority_identity: current.identity,
+        authority_current: true,
+        write_performed: false,
+    };
+}

package/dist/lib/design-authority-digest.d.ts

@@ -0,0 +1,8 @@
+import type { AcquiredDesignAuthorityText } from "./design-authority-files.js";
+import { type DesignAuthorityClosureMember } from "./design-authority-types.js";
+export interface DesignAuthorityDigestMember extends AcquiredDesignAuthorityText {
+    kind: DesignAuthorityClosureMember["kind"];
+}
+export declare function digestDesignAuthorityMembers(members: DesignAuthorityDigestMember[]): string;
+export declare function projectDesignAuthorityMembers(members: DesignAuthorityDigestMember[]): DesignAuthorityClosureMember[];
+export declare function enforceDesignAuthorityTotalLimit(members: DesignAuthorityDigestMember[]): void;

package/dist/lib/design-authority-digest.js

@@ -0,0 +1,36 @@
+import { createHash } from "node:crypto";
+import { DESIGN_AUTHORITY_LIMITS, } from "./design-authority-types.js";
+export function digestDesignAuthorityMembers(members) {
+    const hash = createHash("sha256");
+    for (const member of sortDesignAuthorityMembers(members)) {
+        const pathBytes = Buffer.from(member.path, "utf8");
+        hash.update(uint64(pathBytes.length));
+        hash.update(pathBytes);
+        hash.update(uint64(member.normalized.length));
+        hash.update(member.normalized);
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+export function projectDesignAuthorityMembers(members) {
+    return sortDesignAuthorityMembers(members).map((member) => ({
+        path: member.path,
+        kind: member.kind,
+        content_sha256: `sha256:${createHash("sha256")
+            .update(member.normalized)
+            .digest("hex")}`,
+        normalized_bytes: member.normalized.length,
+    }));
+}
+export function enforceDesignAuthorityTotalLimit(members) {
+    const total = members.reduce((sum, member) => sum + member.normalized.length, 0);
+    if (total > DESIGN_AUTHORITY_LIMITS.max_total_bytes)
+        throw new Error(`design_authority_invalid:total_limit_exceeded:${total}`);
+}
+function sortDesignAuthorityMembers(members) {
+    return [...members].sort((left, right) => Buffer.from(left.path).compare(Buffer.from(right.path)));
+}
+function uint64(value) {
+    const result = Buffer.alloc(8);
+    result.writeBigUInt64BE(BigInt(value));
+    return result;
+}

package/dist/lib/design-authority-files.d.ts

@@ -0,0 +1,9 @@
+export interface AcquiredDesignAuthorityText {
+    path: string;
+    content: string;
+    normalized: Buffer;
+    raw: Buffer;
+}
+export declare function acquireDesignAuthorityManifest(repository: string): Promise<AcquiredDesignAuthorityText | null>;
+export declare function acquireDesignAuthorityText(repository: string, relative: string, label: string): Promise<AcquiredDesignAuthorityText>;
+export declare function designAuthorityPathExists(target: string): Promise<boolean>;

package/dist/lib/design-authority-files.js

@@ -0,0 +1,62 @@
+import { lstat, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { assertProtectedRepositoryDirectory, assertProtectedRepositoryFile, } from "./repository-path-safety.js";
+import { DESIGN_AUTHORITY_LIMITS, DESIGN_AUTHORITY_MANIFEST_PATH, } from "./design-authority-types.js";
+export async function acquireDesignAuthorityManifest(repository) {
+    const directory = path.join(repository, "design_system");
+    if (!(await designAuthorityPathExists(directory)))
+        return null;
+    await assertProtectedRepositoryDirectory(repository, directory, "design_authority_directory");
+    const manifest = path.join(repository, DESIGN_AUTHORITY_MANIFEST_PATH);
+    if (!(await designAuthorityPathExists(manifest)))
+        return null;
+    return acquireDesignAuthorityText(repository, DESIGN_AUTHORITY_MANIFEST_PATH, "design_authority_manifest");
+}
+export async function acquireDesignAuthorityText(repository, relative, label) {
+    const absolute = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...relative.split("/")), label);
+    await assertExactDesignAuthorityPath(repository, relative, label);
+    const bytes = await readFile(absolute);
+    if (bytes.length > DESIGN_AUTHORITY_LIMITS.max_file_bytes)
+        invalid(`file_limit_exceeded:${relative}:${bytes.length}`);
+    if (bytes.subarray(0, 3).equals(Buffer.from([0xef, 0xbb, 0xbf])))
+        invalid(`utf8_bom_not_allowed:${relative}`);
+    let content;
+    try {
+        content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        invalid(`invalid_utf8:${relative}`);
+    }
+    return {
+        path: relative,
+        content,
+        normalized: Buffer.from(content.replace(/\r\n?/gu, "\n"), "utf8"),
+        raw: bytes,
+    };
+}
+async function assertExactDesignAuthorityPath(repository, relative, label) {
+    let parent = path.resolve(repository);
+    for (const segment of relative.split("/")) {
+        const entries = await readdir(parent);
+        if (!entries.includes(segment))
+            invalid(`${label}_path_case_mismatch:${relative}`);
+        parent = path.join(parent, segment);
+    }
+}
+export async function designAuthorityPathExists(target) {
+    try {
+        await lstat(target);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function invalid(reason) {
+    throw new Error(`design_authority_invalid:${reason}`);
+}

package/dist/lib/design-authority-format.d.ts

@@ -0,0 +1,2 @@
+export type DesignAuthorityDeclaredFormat = "bundle-v1" | null;
+export declare function declaredDesignAuthorityFormat(content: string): DesignAuthorityDeclaredFormat;

package/dist/lib/design-authority-format.js

@@ -0,0 +1,93 @@
+import { DESIGN_AUTHORITY_BUNDLE_MARKER } from "./design-authority-types.js";
+import { parseStrictYaml } from "./strict-codec.js";
+const DESIGN_AUTHORITY_FORMAT_NAMESPACE = "ty-context-design-authority-format";
+const WHOLE_LINE_HTML_COMMENT = /^\s*<!--([\s\S]*?)-->\s*$/u;
+export function declaredDesignAuthorityFormat(content) {
+    const lines = content.replace(/\r\n?/gu, "\n").split("\n");
+    const frontmatter = markdownFrontmatter(lines);
+    const markers = machineMarkerLines(lines, frontmatter.body_start, frontmatter.unclosed);
+    const noncanonical = markers.find((entry) => entry.line !== DESIGN_AUTHORITY_BUNDLE_MARKER);
+    if (noncanonical)
+        invalidNoncanonicalMarker(noncanonical);
+    if (markers.length === 0)
+        return null;
+    const bodyStart = frontmatter.body_start;
+    if (frontmatter.unclosed)
+        invalid(`bundle_marker_noncanonical:line=${markers[0].index + 1}:frontmatter_unclosed`);
+    if (frontmatter.source !== null)
+        try {
+            parseStrictYaml(frontmatter.source);
+        }
+        catch (error) {
+            invalid(`bundle_marker_noncanonical:line=${markers[0].index + 1}:frontmatter_invalid:${message(error)}`);
+        }
+    if (markers.length > 1)
+        invalid("bundle_marker_duplicate");
+    const firstBodyLine = lines.findIndex((line, index) => index >= bodyStart && line.trim().length > 0);
+    if (firstBodyLine !== markers[0].index)
+        invalid(`bundle_marker_misplaced:line=${markers[0].index + 1}`);
+    return "bundle-v1";
+}
+function markdownFrontmatter(lines) {
+    if (lines[0] !== "---")
+        return { body_start: 0, source: null, unclosed: false };
+    for (let index = 1; index < lines.length; index += 1)
+        if (lines[index] === "---")
+            return {
+                body_start: index + 1,
+                source: lines.slice(1, index).join("\n"),
+                unclosed: false,
+            };
+    return { body_start: 1, source: null, unclosed: true };
+}
+function machineMarkerLines(lines, bodyStart, frontmatterUnclosed) {
+    const result = [];
+    let fence = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (frontmatterUnclosed || index < bodyStart) {
+            if (isReservedFormatComment(line))
+                result.push({ index, line });
+            continue;
+        }
+        const fenceLine = /^\s*(`{3,}|~{3,})(.*)$/u.exec(line);
+        if (fence) {
+            if (fenceLine &&
+                fence.marker === fenceLine[1][0] &&
+                fenceLine[1].length >= fence.width &&
+                fenceLine[2].trim().length === 0)
+                fence = null;
+            continue;
+        }
+        if (fenceLine) {
+            fence = {
+                marker: fenceLine[1][0],
+                width: fenceLine[1].length,
+            };
+            continue;
+        }
+        if (isReservedFormatComment(line))
+            result.push({ index, line });
+    }
+    return result;
+}
+function isReservedFormatComment(line) {
+    const comment = WHOLE_LINE_HTML_COMMENT.exec(line);
+    return Boolean(comment &&
+        comment[1].toLowerCase().includes(DESIGN_AUTHORITY_FORMAT_NAMESPACE));
+}
+function invalidNoncanonicalMarker(entry) {
+    invalid(`bundle_marker_noncanonical:line=${entry.index + 1}:expected=${JSON.stringify(DESIGN_AUTHORITY_BUNDLE_MARKER)}:actual=${diagnosticLine(entry.line)}`);
+}
+function diagnosticLine(line) {
+    const limit = 256;
+    return JSON.stringify(line.length <= limit
+        ? line
+        : `${line.slice(0, limit)}…(${line.length} chars)`);
+}
+function invalid(reason) {
+    throw new Error(`design_authority_invalid:${reason}`);
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/design-authority-links.d.ts

@@ -0,0 +1,10 @@
+import { type DesignAuthorityDiagnostic } from "./design-authority-types.js";
+export interface DesignAuthorityMarkdownSource {
+    path: string;
+    content: string;
+}
+export declare function analyzeDesignAuthorityLinks(input: {
+    repository: string;
+    sources: DesignAuthorityMarkdownSource[];
+    declared_paths: ReadonlySet<string>;
+}): Promise<DesignAuthorityDiagnostic[]>;