project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,201 +0,0 @@
-import path from "node:path";
-import { digestDesignAuthorityMembers, enforceDesignAuthorityTotalLimit, projectDesignAuthorityMembers, } from "./design-authority-digest.js";
-import { acquireDesignAuthorityManifest, acquireDesignAuthorityText, designAuthorityPathExists, } from "./design-authority-files.js";
-import { declaredDesignAuthorityFormat } from "./design-authority-format.js";
-import { designAuthorityManifestProjection, parseDesignAuthorityManifest, } from "./design-authority-manifest.js";
-import { analyzeDesignAuthorityLinks } from "./design-authority-links.js";
-import { designAuthorityRevision, projectDesignAuthorityTokens, } from "./design-authority-tokens.js";
-import { DESIGN_AUTHORITY_ENTRY_PATH, DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION, DESIGN_AUTHORITY_LIMITS, DESIGN_AUTHORITY_MANIFEST_PATH, } from "./design-authority-types.js";
-export async function inspectDesignAuthorityClosure(repositoryInput) {
-    const repository = path.resolve(repositoryInput);
-    const entryExists = await designAuthorityPathExists(path.join(repository, DESIGN_AUTHORITY_ENTRY_PATH));
-    const manifestExists = await designAuthorityPathExists(path.join(repository, DESIGN_AUTHORITY_MANIFEST_PATH));
-    if (!entryExists && manifestExists)
-        return emptyInspection("invalid", "bundle", [
-            {
-                severity: "error",
-                code: "bundle_entry_missing",
-                path: DESIGN_AUTHORITY_ENTRY_PATH,
-                detail: `${DESIGN_AUTHORITY_MANIFEST_PATH} exists without the canonical DESIGN.md entry`,
-            },
-        ]);
-    if (!entryExists)
-        return emptyInspection("missing", "missing", [
-            {
-                severity: "warning",
-                code: "design_authority_missing",
-                path: DESIGN_AUTHORITY_ENTRY_PATH,
-                detail: "DESIGN.md does not exist",
-            },
-        ]);
-    try {
-        const snapshot = await buildDesignAuthorityClosure(repository);
-        return {
-            schema_version: 1,
-            status: snapshot.diagnostics.some((item) => item.severity === "error")
-                ? "invalid"
-                : "valid",
-            ...snapshot,
-        };
-    }
-    catch (error) {
-        return emptyInspection("invalid", manifestExists ? "bundle" : await declaredModeHint(repository), [
-            {
-                severity: "error",
-                code: "design_authority_invalid",
-                detail: message(error),
-            },
-        ]);
-    }
-}
-export async function loadCurrentDesignAuthorityClosure(repository) {
-    const inspection = await inspectDesignAuthorityClosure(repository);
-    if (inspection.status !== "valid" || !inspection.identity)
-        throw new Error(`design_authority_invalid:${inspection.diagnostics
-            .map((item) => `${item.code}:${item.detail}`)
-            .join("|")}`);
-    if (inspection.mode === "missing")
-        throw new Error("design_authority_invalid:missing_mode");
-    return {
-        mode: inspection.mode,
-        identity: inspection.identity,
-        manifest: inspection.manifest,
-        claimed_closure_digest: inspection.claimed_closure_digest,
-        members: inspection.members,
-        member_paths: inspection.member_paths,
-        generated_tokens: inspection.generated_tokens,
-        diagnostics: inspection.diagnostics,
-    };
-}
-async function buildDesignAuthorityClosure(repository) {
-    const entry = await acquireDesignAuthorityText(repository, DESIGN_AUTHORITY_ENTRY_PATH, "design_authority_entry");
-    const declaredFormat = declaredDesignAuthorityFormat(entry.content);
-    const manifest = await acquireDesignAuthorityManifest(repository);
-    if (declaredFormat === "bundle-v1" && !manifest)
-        invalid("bundle_manifest_missing");
-    if (declaredFormat === null && manifest)
-        invalid("bundle_marker_missing");
-    const digestMembers = [
-        { ...entry, kind: "entry" },
-    ];
-    const markdownSources = [{ path: entry.path, content: entry.content }];
-    let parsedManifest = null;
-    let claimedDigest = null;
-    if (manifest) {
-        parsedManifest = parseDesignAuthorityManifest(manifest.content);
-        claimedDigest = parsedManifest.closure_digest;
-        if (parsedManifest.authority_files.length +
-            parsedManifest.generated_files.length +
-            2 >
-            DESIGN_AUTHORITY_LIMITS.max_members)
-            invalid("member_limit_exceeded");
-        for (const file of parsedManifest.authority_files) {
-            const acquired = await acquireDesignAuthorityText(repository, file.path, "design_authority_member");
-            digestMembers.push({ ...acquired, kind: "authority" });
-            markdownSources.push({ path: acquired.path, content: acquired.content });
-        }
-        for (const file of parsedManifest.generated_files)
-            digestMembers.push({
-                ...(await acquireDesignAuthorityText(repository, file.path, "design_authority_generated")),
-                kind: "generated",
-            });
-        const projection = designAuthorityManifestProjection(parsedManifest);
-        digestMembers.push({
-            path: DESIGN_AUTHORITY_MANIFEST_PATH,
-            content: projection,
-            raw: Buffer.from(projection),
-            normalized: Buffer.from(projection),
-            kind: "manifest",
-        });
-    }
-    enforceDesignAuthorityTotalLimit(digestMembers);
-    const generatedTokens = projectDesignAuthorityTokens(entry.content);
-    const diagnostics = [];
-    if (parsedManifest?.generated_files.length) {
-        const generated = digestMembers.find((member) => member.kind === "generated");
-        if (!generatedTokens.success)
-            diagnostics.push({
-                severity: "error",
-                code: "design_authority_token_projection_failed",
-                path: DESIGN_AUTHORITY_ENTRY_PATH,
-                detail: generatedTokens.error,
-            });
-        else if (!generated.raw.equals(Buffer.from(generatedTokens.content)))
-            diagnostics.push({
-                severity: "error",
-                code: "design_authority_generated_tokens_stale",
-                path: generated.path,
-                detail: "bytes differ from the deterministic DESIGN.md DTCG projection",
-            });
-    }
-    const declared = new Set(digestMembers.map((member) => member.path));
-    diagnostics.push(...(await analyzeDesignAuthorityLinks({
-        repository,
-        sources: markdownSources,
-        declared_paths: declared,
-    })));
-    const computedDigest = digestDesignAuthorityMembers(digestMembers);
-    if (claimedDigest && claimedDigest !== computedDigest)
-        diagnostics.push({
-            severity: "error",
-            code: "design_authority_closure_digest_mismatch",
-            path: DESIGN_AUTHORITY_MANIFEST_PATH,
-            detail: `claimed=${claimedDigest}; computed=${computedDigest}`,
-        });
-    const members = projectDesignAuthorityMembers(digestMembers);
-    return {
-        mode: parsedManifest ? "bundle" : "legacy",
-        identity: {
-            format_version: DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION,
-            entry_path: DESIGN_AUTHORITY_ENTRY_PATH,
-            manifest_path: parsedManifest ? DESIGN_AUTHORITY_MANIFEST_PATH : null,
-            closure_digest: computedDigest,
-            revision: designAuthorityRevision(entry.content),
-        },
-        manifest: parsedManifest,
-        claimed_closure_digest: claimedDigest,
-        members,
-        member_paths: members.map((member) => member.path),
-        generated_tokens: generatedTokens.success ? generatedTokens.content : null,
-        diagnostics: diagnostics.sort(compareDiagnostic),
-    };
-}
-function compareDiagnostic(left, right) {
-    const severity = Buffer.from(left.severity, "utf8").compare(Buffer.from(right.severity, "utf8"));
-    if (severity)
-        return severity;
-    return Buffer.from(`${left.path ?? ""}\0${left.code}\0${left.detail}`).compare(Buffer.from(`${right.path ?? ""}\0${right.code}\0${right.detail}`));
-}
-function emptyInspection(status, mode, diagnostics) {
-    return {
-        schema_version: 1,
-        status,
-        mode,
-        identity: null,
-        manifest: null,
-        claimed_closure_digest: null,
-        members: [],
-        member_paths: [],
-        generated_tokens: null,
-        diagnostics,
-    };
-}
-async function declaredModeHint(repository) {
-    try {
-        const entry = await acquireDesignAuthorityText(repository, DESIGN_AUTHORITY_ENTRY_PATH, "design_authority_entry");
-        return declaredDesignAuthorityFormat(entry.content) === "bundle-v1"
-            ? "bundle"
-            : "legacy";
-    }
-    catch (error) {
-        return /bundle_(?:marker|entry)/u.test(message(error))
-            ? "bundle"
-            : "legacy";
-    }
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function invalid(reason) {
-    throw new Error(`design_authority_invalid:${reason}`);
-}

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

@@ -1,10 +0,0 @@
-export type DeltaRow = Record<string, unknown>;
-export declare function deltaRow(value: unknown, label: string, required: string[], optional?: string[]): DeltaRow;
-export declare function deltaArray(value: unknown, label: string): unknown[];
-export declare function deltaText(value: unknown, label: string): string;
-export declare function deltaOneOf<const T extends readonly string[]>(value: unknown, allowed: T, label: string): T[number];
-export declare function deltaExact<T extends string | number>(value: unknown, expected: T, label: string): T;
-export declare function deltaStringSet(value: unknown, label: string, allowEmpty?: boolean): string[];
-export declare function deltaSourceRefSet(value: unknown, label: string, allowEmpty?: boolean): string[];
-export declare function deltaCompare(left: string, right: string): number;
-export declare function deltaInvalid(label: string, reason: string): never;

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

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

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

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

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

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

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

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

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

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

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

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