project-tiny-context-harness 0.8.12 → 0.8.13

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

@@ -0,0 +1,10 @@
+import { type DesignResourceAuthorityIdentity, type DesignResourceAuthoritySourceItem, type DesignResourceDecisionAuthority, type DesignResourceDelegation, type DesignResourceDelta, type DesignResourceRecoveryBase, type DesignResourceRecoveryBaseInput } from "./design-resource-recovery-types.js";
+export declare const DESIGN_RESOURCE_ORIGINS: readonly ["user-direct", "necessary-derived", "repository-evidence-backed", "provider-suggested"];
+export declare const DESIGN_RESOURCE_SEMANTIC_KINDS: readonly ["exact-visual", "product", "business", "permission", "data", "algorithm", "commercial", "safety-security", "technical"];
+export declare function parseRecoveryBaseInput(value: unknown, label: string): DesignResourceRecoveryBaseInput;
+export declare function parseRecoveryBase(value: unknown, label: string): DesignResourceRecoveryBase;
+export declare function parseDelegation(value: unknown, label: string): DesignResourceDelegation;
+export declare function parseAuthoritySourceItem(value: unknown, label: string): DesignResourceAuthoritySourceItem;
+export declare function parseDelta(value: unknown, label: string): DesignResourceDelta;
+export declare function parseAuthorityIdentity(value: unknown, label: string): DesignResourceAuthorityIdentity;
+export declare function parseDecisionAuthority(value: unknown, label: string): DesignResourceDecisionAuthority;

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

@@ -0,0 +1,184 @@
+import { arrayOf, digest, integer, object, oneOf, stringSet, text, unknownSemantics, } from "./design-resource-recovery-codec-primitives.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"]);
+    const kind = oneOf(first.kind, ["repository-file", "external-immutable", "not-applicable"], `${label}.kind`);
+    if (kind === "not-applicable") {
+        if ("locator" in first || "raw_byte_digest" in first)
+            throw new Error(`design_resource_recovery_invalid:${label}:not_applicable_identity_fields`);
+        return {
+            kind,
+            rationale: text(first.rationale, `${label}.rationale`),
+        };
+    }
+    if ("rationale" in first)
+        throw new Error(`design_resource_recovery_invalid:${label}:unexpected_rationale`);
+    return {
+        kind,
+        locator: text(first.locator, `${label}.locator`),
+        raw_byte_digest: digest(first.raw_byte_digest, `${label}.raw_byte_digest`),
+    };
+}
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,219 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,186 @@
+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}`);
+}