project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/design-resource-recovery-shape.js

@@ -1,241 +0,0 @@
-import { arrayOf, digest, integer, literal, object, oneOf, stringSet, text, unknownSemantics, } from "./design-resource-recovery-codec-primitives.js";
-import { DESIGN_AUTHORITY_ENTRY_PATH, DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION, DESIGN_AUTHORITY_MANIFEST_PATH, isDesignAuthorityDigest, } from "./design-authority-types.js";
-export const DESIGN_RESOURCE_ORIGINS = [
-    "user-direct",
-    "necessary-derived",
-    "repository-evidence-backed",
-    "provider-suggested",
-];
-const STATUSES = ["accepted", "rejected", "unresolved"];
-const OPERATIONS = ["add", "replace", "remove", "preserve"];
-const ENCODINGS = ["utf8", "utf8-bom", "utf16le", "utf16be"];
-const EOLS = ["none", "lf", "crlf", "cr", "mixed"];
-export const DESIGN_RESOURCE_SEMANTIC_KINDS = [
-    "exact-visual",
-    "product",
-    "business",
-    "permission",
-    "data",
-    "algorithm",
-    "commercial",
-    "safety-security",
-    "technical",
-];
-const SOURCE_ITEM_KINDS = [
-    "outcome_result",
-    "requirement",
-    "control",
-    "acceptance",
-    "technical_obligation",
-    "non_completing",
-    "non_goal",
-    "forbidden_shortcut",
-    "risk_fact",
-    "external_confirmation",
-    "decision",
-];
-export function parseRecoveryBaseInput(value, label) {
-    const row = object(value, label, [
-        "locator",
-        "raw_byte_digest",
-        "materialization",
-        "scope_ceiling",
-        "in_scope_keys",
-        "explicitly_excluded_keys",
-    ]);
-    const materialization = object(row.materialization, `${label}.materialization`, ["kind"], ["authorization_ref"]);
-    const kind = oneOf(materialization.kind, ["repository-source", "authorized-recovery-snapshot"], `${label}.materialization.kind`);
-    const normalizedMaterialization = kind === "repository-source"
-        ? { kind }
-        : {
-            kind,
-            authorization_ref: text(materialization.authorization_ref, `${label}.materialization.authorization_ref`),
-        };
-    if (kind === "repository-source" && "authorization_ref" in materialization)
-        throw new Error(`design_resource_recovery_invalid:${label}.materialization:unexpected_authorization_ref`);
-    return {
-        locator: text(row.locator, `${label}.locator`),
-        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
-        materialization: normalizedMaterialization,
-        scope_ceiling: text(row.scope_ceiling, `${label}.scope_ceiling`),
-        in_scope_keys: stringSet(row.in_scope_keys, `${label}.in_scope_keys`),
-        explicitly_excluded_keys: stringSet(row.explicitly_excluded_keys, `${label}.explicitly_excluded_keys`, { allowEmpty: true }),
-    };
-}
-export function parseRecoveryBase(value, label) {
-    const row = object(value, label, [
-        "locator",
-        "raw_byte_digest",
-        "materialization",
-        "scope_ceiling",
-        "in_scope_keys",
-        "explicitly_excluded_keys",
-        "encoding",
-        "eol_policy",
-    ]);
-    const base = parseRecoveryBaseInput(Object.fromEntries(Object.entries(row).filter(([key]) => key !== "encoding" && key !== "eol_policy")), label);
-    return {
-        ...base,
-        encoding: oneOf(row.encoding, ENCODINGS, `${label}.encoding`),
-        eol_policy: oneOf(row.eol_policy, EOLS, `${label}.eol_policy`),
-    };
-}
-export function parseDelegation(value, label) {
-    const row = object(value, label, [
-        "key",
-        "source_ref",
-        "allowed_origins",
-        "allowed_target_keys",
-        "allowed_semantic_kinds",
-    ]);
-    return {
-        key: text(row.key, `${label}.key`),
-        source_ref: text(row.source_ref, `${label}.source_ref`),
-        allowed_origins: arrayOf(row.allowed_origins, `${label}.allowed_origins`, (item, itemLabel) => oneOf(item, DESIGN_RESOURCE_ORIGINS, itemLabel)),
-        allowed_target_keys: stringSet(row.allowed_target_keys, `${label}.allowed_target_keys`),
-        allowed_semantic_kinds: stringSet(row.allowed_semantic_kinds, `${label}.allowed_semantic_kinds`).map((value, index) => oneOf(value, DESIGN_RESOURCE_SEMANTIC_KINDS, `${label}.allowed_semantic_kinds[${index}]`)),
-    };
-}
-export function parseAuthoritySourceItem(value, label) {
-    const row = object(value, label, [
-        "source_ref",
-        "locator",
-        "raw_byte_digest",
-        "source_item_key",
-        "source_item_kind",
-        "source_item_text_sha256",
-    ]);
-    return {
-        source_ref: text(row.source_ref, `${label}.source_ref`),
-        locator: text(row.locator, `${label}.locator`),
-        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
-        source_item_key: text(row.source_item_key, `${label}.source_item_key`),
-        source_item_kind: oneOf(row.source_item_kind, SOURCE_ITEM_KINDS, `${label}.source_item_kind`),
-        source_item_text_sha256: digest(row.source_item_text_sha256, `${label}.source_item_text_sha256`),
-    };
-}
-export function parseDelta(value, label) {
-    const row = object(value, label, [
-        "delta_id",
-        "sequence",
-        "supersedes",
-        "proposes_replacement_of",
-        "operation",
-        "semantic_kind",
-        "target_keys",
-        "before_semantics",
-        "after_semantics",
-        "origin",
-        "decision_authority",
-        "evidence_refs",
-        "source_refs",
-        "explicitly_unchanged_keys",
-        "status",
-    ]);
-    return {
-        delta_id: text(row.delta_id, `${label}.delta_id`),
-        sequence: integer(row.sequence, `${label}.sequence`, 1),
-        supersedes: stringSet(row.supersedes, `${label}.supersedes`, {
-            allowEmpty: true,
-        }),
-        proposes_replacement_of: stringSet(row.proposes_replacement_of, `${label}.proposes_replacement_of`, { allowEmpty: true }),
-        operation: oneOf(row.operation, OPERATIONS, `${label}.operation`),
-        semantic_kind: oneOf(row.semantic_kind, DESIGN_RESOURCE_SEMANTIC_KINDS, `${label}.semantic_kind`),
-        target_keys: stringSet(row.target_keys, `${label}.target_keys`),
-        before_semantics: unknownSemantics(row, "before_semantics", label),
-        after_semantics: unknownSemantics(row, "after_semantics", label),
-        origin: oneOf(row.origin, DESIGN_RESOURCE_ORIGINS, `${label}.origin`),
-        decision_authority: parseDecisionAuthority(row.decision_authority, `${label}.decision_authority`),
-        evidence_refs: stringSet(row.evidence_refs, `${label}.evidence_refs`, {
-            allowEmpty: true,
-        }),
-        source_refs: stringSet(row.source_refs, `${label}.source_refs`, {
-            allowEmpty: true,
-        }),
-        explicitly_unchanged_keys: stringSet(row.explicitly_unchanged_keys, `${label}.explicitly_unchanged_keys`, { allowEmpty: true }),
-        status: oneOf(row.status, STATUSES, `${label}.status`),
-    };
-}
-export function parseAuthorityIdentity(value, label) {
-    const first = object(value, label, ["kind"], [
-        "locator",
-        "raw_byte_digest",
-        "rationale",
-        "format_version",
-        "entry_path",
-        "manifest_path",
-        "closure_digest",
-        "revision",
-    ]);
-    const kind = oneOf(first.kind, [
-        "repository-closure",
-        "repository-file",
-        "external-immutable",
-        "not-applicable",
-    ], `${label}.kind`);
-    if (kind === "repository-closure") {
-        rejectFields(first, label, ["locator", "raw_byte_digest", "rationale"]);
-        literal(first.format_version, DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION, `${label}.format_version`);
-        literal(first.entry_path, DESIGN_AUTHORITY_ENTRY_PATH, `${label}.entry_path`);
-        const manifestPath = parseNullableManifestPath(first.manifest_path, `${label}.manifest_path`);
-        if (!isDesignAuthorityDigest(first.closure_digest))
-            throw new Error(`design_resource_recovery_invalid:${label}.closure_digest:sha256_required`);
-        const revision = first.revision === null
-            ? null
-            : text(first.revision, `${label}.revision`);
-        return {
-            kind,
-            format_version: DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION,
-            entry_path: DESIGN_AUTHORITY_ENTRY_PATH,
-            manifest_path: manifestPath,
-            closure_digest: first.closure_digest,
-            revision,
-        };
-    }
-    if (kind === "not-applicable") {
-        rejectFields(first, label, [
-            "locator",
-            "raw_byte_digest",
-            "format_version",
-            "entry_path",
-            "manifest_path",
-            "closure_digest",
-            "revision",
-        ]);
-        return {
-            kind,
-            rationale: text(first.rationale, `${label}.rationale`),
-        };
-    }
-    rejectFields(first, label, [
-        "rationale",
-        "format_version",
-        "entry_path",
-        "manifest_path",
-        "closure_digest",
-        "revision",
-    ]);
-    return {
-        kind,
-        locator: text(first.locator, `${label}.locator`),
-        raw_byte_digest: digest(first.raw_byte_digest, `${label}.raw_byte_digest`),
-    };
-}
-function parseNullableManifestPath(value, label) {
-    if (value === null)
-        return null;
-    return literal(value, DESIGN_AUTHORITY_MANIFEST_PATH, label);
-}
-function rejectFields(row, label, fields) {
-    for (const field of fields)
-        if (Object.hasOwn(row, field))
-            throw new Error(`design_resource_recovery_invalid:${label}:unexpected_field:${field}`);
-}
-export function parseDecisionAuthority(value, label) {
-    const result = text(value, label);
-    if (result === "explicit-user" || result === "none")
-        return result;
-    if (/^delegated:[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(result))
-        return result;
-    throw new Error(`design_resource_recovery_invalid:${label}:invalid_authority`);
-}

package/dist/lib/design-resource-recovery-source-authority.d.ts

@@ -1,5 +0,0 @@
-import type { DesignResourceAuthorityProjection, DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput } from "./design-resource-recovery-types.js";
-type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
-export declare function validateDesignResourceAuthoritySourceItems(repository: string, state: RecoveryState): Promise<void>;
-export declare function parseAuthorityProjections(sourcePath: string, itemKey: string, normalizedText: string): DesignResourceAuthorityProjection[];
-export {};

package/dist/lib/design-resource-recovery-source-authority.js

@@ -1,219 +0,0 @@
-import { decodeDesignResourceText } from "./design-resource-recovery-text.js";
-import { readRecoveryRepositoryFile } from "./design-resource-recovery-files.js";
-import { parseSourceDocument } from "./long-task-source-item-parser.js";
-import { arrayOf, digest, literal, object, oneOf, parseStrictJsonObject, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
-import { DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA } from "./design-resource-recovery-schema.js";
-import { DESIGN_RESOURCE_ORIGINS, DESIGN_RESOURCE_SEMANTIC_KINDS, } from "./design-resource-recovery-shape.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-import { isDesignResourceAuthoritativeMeaningSourceKind } from "./design-resource-recovery-authority-policy.js";
-export async function validateDesignResourceAuthoritySourceItems(repository, state) {
-    const byLocator = new Map();
-    const bySourceRef = new Map();
-    for (const declared of state.authority_sources) {
-        let loaded = byLocator.get(declared.locator);
-        if (!loaded) {
-            loaded = await loadAuthoritySourceDocument(repository, declared.locator);
-            byLocator.set(declared.locator, loaded);
-        }
-        if (loaded.rawByteDigest !== declared.raw_byte_digest)
-            invalid(`authority_source_raw_digest_mismatch:${declared.source_ref}:${declared.raw_byte_digest}:${loaded.rawByteDigest}`);
-        const item = loaded.items.get(declared.source_item_key);
-        if (!item)
-            invalid(`authority_source_item_missing:${declared.source_ref}:${declared.source_item_key}`);
-        if (item.kind !== declared.source_item_kind)
-            invalid(`authority_source_item_kind_mismatch:${declared.source_ref}:${declared.source_item_kind}:${item.kind}`);
-        if (item.text_sha256 !== declared.source_item_text_sha256)
-            invalid(`authority_source_item_digest_mismatch:${declared.source_ref}:${declared.source_item_text_sha256}:${item.text_sha256}`);
-        bySourceRef.set(declared.source_ref, {
-            kind: item.kind,
-            projections: item.projections,
-        });
-    }
-    validateDelegationProjections(state, bySourceRef);
-    validateAcceptedDeltaProjections(state, bySourceRef);
-}
-function validateDelegationProjections(state, sources) {
-    for (const delegation of state.delegations) {
-        const source = sources.get(delegation.source_ref);
-        if (!source)
-            invalid(`delegation_source_ref_unresolved:${delegation.key}`);
-        if (source.kind !== "decision")
-            invalid(`delegation_source_not_decision:${delegation.key}`);
-        const matching = source.projections.filter((projection) => projection.mode === "delegation" &&
-            projection.delegation_key === delegation.key);
-        if (matching.length !== 1)
-            invalid(`delegation_projection_count:${delegation.key}:${matching.length}`);
-        const projection = matching[0];
-        if (projection.mode !== "delegation")
-            throw new Error("unreachable");
-        assertExactSet(projection.allowed_target_keys, delegation.allowed_target_keys, `delegation_projection_targets:${delegation.key}`);
-        assertExactSet(projection.allowed_semantic_kinds, delegation.allowed_semantic_kinds, `delegation_projection_semantic_kinds:${delegation.key}`);
-        assertExactSet(projection.allowed_origins, delegation.allowed_origins, `delegation_projection_origins:${delegation.key}`);
-    }
-}
-function validateAcceptedDeltaProjections(state, sources) {
-    const delegations = new Map(state.delegations.map((item) => [item.key, item]));
-    for (const delta of state.deltas) {
-        if (delta.status !== "accepted")
-            continue;
-        const sourceRows = delta.source_refs.map((sourceRef) => {
-            const source = sources.get(sourceRef);
-            if (!source)
-                invalid(`delta_source_ref_unresolved:${delta.delta_id}:${sourceRef}`);
-            return { sourceRef, ...source };
-        });
-        const meaningDigest = sha256Hex(canonicalValueJson(delta.after_semantics));
-        const matchingMeaning = sourceRows.filter(({ projections }) => projections.some((projection) => projection.mode === "explicit-user" &&
-            projection.meaning_sha256 === meaningDigest &&
-            projection.semantic_kinds.includes(delta.semantic_kind) &&
-            projection.allowed_origins.includes(delta.origin) &&
-            sameStringSet(projection.target_keys, delta.target_keys)));
-        if (delta.decision_authority === "explicit-user") {
-            const decisions = matchingMeaning.filter(({ kind }) => kind === "decision");
-            if (!decisions.length)
-                invalid(`explicit_user_projection_required:${delta.delta_id}`);
-        }
-        if (delta.decision_authority.startsWith("delegated:")) {
-            const key = delta.decision_authority.slice("delegated:".length);
-            const delegation = delegations.get(key);
-            if (!delegation)
-                invalid(`delegation_not_found:${delta.delta_id}:${key}`);
-            const source = sourceRows.find((item) => item.sourceRef === delegation.source_ref);
-            if (!source?.projections.some((projection) => projection.mode === "delegation" &&
-                projection.delegation_key === key &&
-                projection.allowed_origins.includes(delta.origin) &&
-                projection.allowed_semantic_kinds.includes(delta.semantic_kind) &&
-                delta.target_keys.every((target) => projection.allowed_target_keys.includes(target))))
-                invalid(`delegation_projection_mismatch:${delta.delta_id}:${key}`);
-        }
-        const delegatedExactVisual = delta.semantic_kind === "exact-visual" &&
-            delta.decision_authority.startsWith("delegated:");
-        const delegatedNonvisual = delta.semantic_kind !== "exact-visual" &&
-            delta.decision_authority.startsWith("delegated:");
-        if (delegatedNonvisual) {
-            const key = delta.decision_authority.slice("delegated:".length);
-            const delegation = delegations.get(key);
-            const independent = matchingMeaning.filter(({ sourceRef, kind }) => sourceRef !== delegation?.source_ref &&
-                isDesignResourceAuthoritativeMeaningSourceKind(kind));
-            if (!independent.length)
-                invalid(`delegated_nonvisual_meaning_projection_required:${delta.delta_id}`);
-        }
-        else if (!delegatedExactVisual && !matchingMeaning.length)
-            invalid(`accepted_meaning_projection_required:${delta.delta_id}`);
-    }
-}
-async function loadAuthoritySourceDocument(repository, locator) {
-    const snapshot = await readRecoveryRepositoryFile(repository, locator, "design_resource_recovery_authority_source");
-    const decoded = decodeDesignResourceText(snapshot.bytes);
-    try {
-        const parsed = parseSourceDocument(snapshot.relative, decoded.text);
-        return {
-            rawByteDigest: snapshot.raw_byte_digest,
-            items: new Map(parsed.items.map((item) => [
-                item.key,
-                {
-                    kind: item.kind,
-                    text_sha256: item.text_sha256,
-                    projections: parseAuthorityProjections(snapshot.relative, item.key, item.normalized_text),
-                },
-            ])),
-        };
-    }
-    catch (error) {
-        invalid(`authority_source_parse_failed:${snapshot.relative}:${error.message}`);
-    }
-}
-export function parseAuthorityProjections(sourcePath, itemKey, normalizedText) {
-    const projections = [];
-    for (const [index, line] of normalizedText.split("\n").entries()) {
-        if (!line.includes(DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA))
-            continue;
-        const match = /^<!-- ty-dra-authority-v1 (\{.*\}) -->$/u.exec(line);
-        if (!match)
-            invalid(`authority_projection_marker_invalid:${sourcePath}:${itemKey}:${index + 1}`);
-        projections.push(parseAuthorityProjection(match[1], `${sourcePath}:${itemKey}:${index + 1}`));
-    }
-    const identities = projections.map(projectionIdentity);
-    if (new Set(identities).size !== identities.length)
-        invalid(`authority_projection_duplicate:${sourcePath}:${itemKey}`);
-    return projections;
-}
-function parseAuthorityProjection(content, label) {
-    const parsed = parseStrictJsonObject(content, `authority_projection:${label}`);
-    const header = object(parsed, `authority_projection:${label}`, ["schema_version", "mode"], [
-        "target_keys",
-        "semantic_kinds",
-        "allowed_origins",
-        "meaning_sha256",
-        "delegation_key",
-        "allowed_target_keys",
-        "allowed_semantic_kinds",
-    ]);
-    literal(header.schema_version, DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA, `authority_projection:${label}.schema_version`);
-    const mode = oneOf(header.mode, ["explicit-user", "delegation"], `authority_projection:${label}.mode`);
-    if (mode === "explicit-user") {
-        const row = object(parsed, `authority_projection:${label}`, [
-            "schema_version",
-            "mode",
-            "target_keys",
-            "semantic_kinds",
-            "allowed_origins",
-            "meaning_sha256",
-        ]);
-        return {
-            schema_version: DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA,
-            mode,
-            target_keys: stringSet(row.target_keys, `authority_projection:${label}.target_keys`),
-            semantic_kinds: enumSet(row.semantic_kinds, DESIGN_RESOURCE_SEMANTIC_KINDS, `authority_projection:${label}.semantic_kinds`),
-            allowed_origins: enumSet(row.allowed_origins, DESIGN_RESOURCE_ORIGINS, `authority_projection:${label}.allowed_origins`),
-            meaning_sha256: digest(row.meaning_sha256, `authority_projection:${label}.meaning_sha256`),
-        };
-    }
-    const row = object(parsed, `authority_projection:${label}`, [
-        "schema_version",
-        "mode",
-        "delegation_key",
-        "allowed_target_keys",
-        "allowed_semantic_kinds",
-        "allowed_origins",
-    ]);
-    const delegationKey = text(row.delegation_key, `authority_projection:${label}.delegation_key`);
-    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(delegationKey))
-        invalid(`authority_projection_delegation_key_invalid:${label}`);
-    return {
-        schema_version: DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA,
-        mode,
-        delegation_key: delegationKey,
-        allowed_target_keys: stringSet(row.allowed_target_keys, `authority_projection:${label}.allowed_target_keys`),
-        allowed_semantic_kinds: enumSet(row.allowed_semantic_kinds, DESIGN_RESOURCE_SEMANTIC_KINDS, `authority_projection:${label}.allowed_semantic_kinds`),
-        allowed_origins: enumSet(row.allowed_origins, DESIGN_RESOURCE_ORIGINS, `authority_projection:${label}.allowed_origins`),
-    };
-}
-function enumSet(value, allowed, label) {
-    const result = arrayOf(value, label, (item, itemLabel) => oneOf(item, allowed, itemLabel));
-    if (new Set(result).size !== result.length)
-        invalid(`authority_projection_duplicate_value:${label}`);
-    return result.sort(compareText);
-}
-function projectionIdentity(projection) {
-    return canonicalValueJson(projection);
-}
-function assertExactSet(actual, expected, label) {
-    const left = [...actual].sort(compareText);
-    const right = [...expected].sort(compareText);
-    if (left.length !== right.length ||
-        left.some((value, index) => value !== right[index]))
-        invalid(label);
-}
-function sameStringSet(left, right) {
-    const first = [...left].sort(compareText);
-    const second = [...right].sort(compareText);
-    return (first.length === second.length &&
-        first.every((value, index) => value === second[index]));
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function invalid(reason) {
-    throw new Error(`design_resource_recovery_invalid:${reason}`);
-}

package/dist/lib/design-resource-recovery-text.d.ts

@@ -1,17 +0,0 @@
-import type { DesignResourceEolPolicy, DesignResourceTextEncoding } from "./design-resource-recovery-types.js";
-import type { DesignResourceExactPatch } from "./design-resource-recovery-patch-types.js";
-export interface DesignResourceDecodedText {
-    text: string;
-    encoding: DesignResourceTextEncoding;
-    eol_policy: DesignResourceEolPolicy;
-}
-export declare function decodeDesignResourceText(bytes: Uint8Array): DesignResourceDecodedText;
-export declare function encodeDesignResourceText(text: string, encoding: DesignResourceTextEncoding): Buffer;
-export declare function applyDesignResourceExactPatch(bytes: Uint8Array, patch: DesignResourceExactPatch, expectedEncoding?: DesignResourceTextEncoding, expectedEol?: Exclude<DesignResourceEolPolicy, "mixed">): {
-    bytes: Buffer;
-    encoding: DesignResourceTextEncoding;
-    eol_policy: Exclude<DesignResourceEolPolicy, "mixed">;
-};
-export declare function verifyDesignResourceExactPatchReadback(bytes: Uint8Array, patch: DesignResourceExactPatch): void;
-export declare function verifyDesignResourceSupersededTextReadback(bytes: Uint8Array, patch: DesignResourceExactPatch, supersedingDeltaIds: ReadonlySet<string>): void;
-export declare function detectEolPolicy(text: string): DesignResourceEolPolicy;

package/dist/lib/design-resource-recovery-text.js

@@ -1,186 +0,0 @@
-import { sha256Hex } from "./strict-codec.js";
-export function decodeDesignResourceText(bytes) {
-    let encoding;
-    let body;
-    if (startsWith(bytes, [0xef, 0xbb, 0xbf])) {
-        encoding = "utf8-bom";
-        body = bytes.subarray(3);
-    }
-    else if (startsWith(bytes, [0xff, 0xfe])) {
-        encoding = "utf16le";
-        body = bytes.subarray(2);
-    }
-    else if (startsWith(bytes, [0xfe, 0xff])) {
-        encoding = "utf16be";
-        body = swapUtf16(bytes.subarray(2));
-    }
-    else {
-        encoding = "utf8";
-        body = bytes;
-    }
-    if ((encoding === "utf16le" || encoding === "utf16be") && body.length % 2)
-        invalid("odd_utf16_byte_length");
-    let text;
-    try {
-        text = new TextDecoder(encoding === "utf16le" || encoding === "utf16be" ? "utf-16le" : "utf-8", { fatal: true }).decode(body);
-    }
-    catch {
-        invalid(`invalid_${encoding}`);
-    }
-    if (text.includes("\0"))
-        invalid("nul_character_not_allowed");
-    return { text, encoding, eol_policy: detectEolPolicy(text) };
-}
-export function encodeDesignResourceText(text, encoding) {
-    if (text.includes("\0"))
-        invalid("nul_character_not_allowed");
-    if (encoding === "utf8")
-        return Buffer.from(text, "utf8");
-    if (encoding === "utf8-bom")
-        return Buffer.concat([Buffer.from([0xef, 0xbb, 0xbf]), Buffer.from(text)]);
-    const littleEndian = Buffer.from(text, "utf16le");
-    if (encoding === "utf16le")
-        return Buffer.concat([Buffer.from([0xff, 0xfe]), littleEndian]);
-    return Buffer.concat([
-        Buffer.from([0xfe, 0xff]),
-        Buffer.from(swapUtf16(littleEndian)),
-    ]);
-}
-export function applyDesignResourceExactPatch(bytes, patch, expectedEncoding, expectedEol) {
-    const decoded = decodeDesignResourceText(bytes);
-    if (decoded.eol_policy === "mixed")
-        invalid("mixed_eol_writeback_unsupported");
-    if (expectedEncoding && decoded.encoding !== expectedEncoding)
-        invalid(`encoding_changed:${expectedEncoding}:${decoded.encoding}`);
-    if (expectedEol && decoded.eol_policy !== expectedEol)
-        invalid(`eol_changed:${expectedEol}:${decoded.eol_policy}`);
-    const operations = resolveOriginalSourceSpans(decoded.text, patch);
-    let text = decoded.text;
-    for (const operation of [...operations].reverse()) {
-        const { start_offset: start, end_offset: end } = operation.source_span;
-        text = `${text.slice(0, start)}${operation.after_text}${text.slice(end)}`;
-    }
-    assertPatchFinalIntervals(text, patch);
-    assertPatchAfterTextOccurrences(text, patch);
-    const postEol = detectEolPolicy(text);
-    if (postEol !== decoded.eol_policy)
-        invalid(`patch_changes_eol_policy:${decoded.eol_policy}:${postEol}`);
-    return {
-        bytes: encodeDesignResourceText(text, decoded.encoding),
-        encoding: decoded.encoding,
-        eol_policy: decoded.eol_policy,
-    };
-}
-export function verifyDesignResourceExactPatchReadback(bytes, patch) {
-    const decoded = decodeDesignResourceText(bytes);
-    assertPatchFinalIntervals(decoded.text, patch);
-    assertPatchAfterTextOccurrences(decoded.text, patch);
-}
-export function verifyDesignResourceSupersededTextReadback(bytes, patch, supersedingDeltaIds) {
-    const text = decodeDesignResourceText(bytes).text;
-    for (const operation of patch.operations) {
-        if (!supersedingDeltaIds.has(operation.delta_id))
-            continue;
-        const count = occurrenceCount(text, operation.before_text);
-        if (count !== 0)
-            invalid(`superseded_before_text_leakage:${operation.operation_id}:${count}`);
-    }
-}
-export function detectEolPolicy(text) {
-    const withoutCrLf = text.replace(/\r\n/gu, "");
-    const kinds = [
-        text.includes("\r\n") ? "crlf" : null,
-        withoutCrLf.includes("\n") ? "lf" : null,
-        withoutCrLf.includes("\r") ? "cr" : null,
-    ].filter((value) => value !== null);
-    if (!kinds.length)
-        return "none";
-    return kinds.length === 1 ? kinds[0] : "mixed";
-}
-function occurrenceCount(value, search) {
-    if (!search)
-        invalid("patch_before_text_empty");
-    let count = 0;
-    let offset = 0;
-    while (true) {
-        const found = value.indexOf(search, offset);
-        if (found < 0)
-            return count;
-        count += 1;
-        offset = found + search.length;
-    }
-}
-function resolveOriginalSourceSpans(text, patch) {
-    const operations = [...patch.operations].sort((left, right) => left.source_span.start_offset - right.source_span.start_offset ||
-        left.source_span.end_offset - right.source_span.end_offset ||
-        left.operation_id.localeCompare(right.operation_id));
-    let previous;
-    for (const operation of operations) {
-        const span = operation.source_span;
-        if (span.coordinate_system !== "utf16-code-unit-v1" ||
-            span.start_offset < 0 ||
-            span.end_offset <= span.start_offset ||
-            span.end_offset > text.length ||
-            span.end_offset - span.start_offset !== operation.before_text.length)
-            invalid(`patch_source_span_range:${operation.operation_id}`);
-        const actual = text.slice(span.start_offset, span.end_offset);
-        if (actual !== operation.before_text ||
-            sha256Hex(actual) !== span.before_text_sha256 ||
-            span.before_text_sha256 !== operation.before_text_sha256)
-            invalid(`patch_source_span_preimage:${operation.operation_id}`);
-        if ((operation.operation === "remove" ||
-            (operation.operation === "add" &&
-                operation.after_text.startsWith("<!-- ty-dra-proposal-scalar-v1 "))) &&
-            span.start_offset > 0 &&
-            !["\n", "\r"].includes(text[span.start_offset - 1]))
-            invalid(`patch_carrier_line_boundary:${operation.operation_id}`);
-        const count = occurrenceCount(text, operation.before_text);
-        if (count !== operation.expected_occurrences)
-            invalid(`patch_occurrence_mismatch:${operation.operation_id}:${operation.expected_occurrences}:${count}`);
-        if (previous && span.start_offset < previous.source_span.end_offset)
-            invalid(`patch_source_span_overlap:${previous.operation_id}:${operation.operation_id}`);
-        previous = operation;
-    }
-    return operations;
-}
-function assertPatchFinalIntervals(text, patch) {
-    const operations = [...patch.operations].sort((left, right) => left.source_span.start_offset - right.source_span.start_offset ||
-        left.source_span.end_offset - right.source_span.end_offset ||
-        left.operation_id.localeCompare(right.operation_id));
-    let offsetDelta = 0;
-    for (const operation of operations) {
-        const start = operation.source_span.start_offset + offsetDelta;
-        const end = start + operation.after_text.length;
-        if (start < 0 ||
-            end > text.length ||
-            text.slice(start, end) !== operation.after_text)
-            invalid(`patch_readback_output_span:${operation.operation_id}`);
-        offsetDelta +=
-            operation.after_text.length -
-                (operation.source_span.end_offset - operation.source_span.start_offset);
-    }
-}
-function assertPatchAfterTextOccurrences(text, patch) {
-    for (const operation of patch.operations) {
-        const remove = operation.operation === "remove";
-        const count = occurrenceCount(text, remove ? operation.before_text : operation.after_text);
-        const expected = remove ? 0 : operation.expected_occurrences;
-        if (count !== expected)
-            invalid(`${remove ? "patch_remove_before_still_present" : "patch_after_occurrence_mismatch"}:${operation.operation_id}:${expected}:${count}`);
-    }
-}
-function startsWith(bytes, prefix) {
-    return prefix.every((value, index) => bytes[index] === value);
-}
-function swapUtf16(bytes) {
-    const result = Uint8Array.from(bytes);
-    for (let index = 0; index < result.length; index += 2) {
-        const first = result[index];
-        result[index] = result[index + 1];
-        result[index + 1] = first;
-    }
-    return result;
-}
-function invalid(reason) {
-    throw new Error(`design_resource_recovery_invalid:text:${reason}`);
-}