project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,155 +0,0 @@
-import { DESIGN_RESOURCE_PATCH_SCHEMA } from "./design-resource-recovery-schema.js";
-import { arrayOf, digest, integer, literal, multilineText, object, oneOf, optionalArrayOf, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
-const ENCODINGS = ["utf8", "utf8-bom", "utf16le", "utf16be"];
-export function parseProviderReferences(value, label) {
-    const row = object(value, label, ["project", "run", "resources"]);
-    return {
-        project: parseProviderIdentity(row.project, `${label}.project`),
-        run: parseProviderIdentity(row.run, `${label}.run`),
-        resources: optionalArrayOf(row.resources, `${label}.resources`, parseProviderResourceIdentity),
-    };
-}
-export function parsePatch(value, label) {
-    const row = object(value, label, ["schema_version", "operations"]);
-    literal(row.schema_version, DESIGN_RESOURCE_PATCH_SCHEMA, `${label}.schema_version`);
-    return {
-        schema_version: DESIGN_RESOURCE_PATCH_SCHEMA,
-        operations: arrayOf(row.operations, `${label}.operations`, (item, itemLabel) => {
-            const operation = object(item, itemLabel, [
-                "operation_id",
-                "operation",
-                "target_key",
-                "delta_id",
-                "before_text",
-                "after_text",
-                "before_text_sha256",
-                "after_text_sha256",
-                "source_span",
-                "semantic_binding",
-                "expected_occurrences",
-            ]);
-            literal(operation.expected_occurrences, 1, `${itemLabel}.expected_occurrences`);
-            return {
-                operation_id: text(operation.operation_id, `${itemLabel}.operation_id`),
-                operation: oneOf(operation.operation, ["add", "replace", "remove"], `${itemLabel}.operation`),
-                target_key: text(operation.target_key, `${itemLabel}.target_key`),
-                delta_id: text(operation.delta_id, `${itemLabel}.delta_id`),
-                before_text: multilineText(operation.before_text, `${itemLabel}.before_text`),
-                after_text: multilineText(operation.after_text, `${itemLabel}.after_text`, { allowEmpty: true }),
-                before_text_sha256: digest(operation.before_text_sha256, `${itemLabel}.before_text_sha256`),
-                after_text_sha256: digest(operation.after_text_sha256, `${itemLabel}.after_text_sha256`),
-                source_span: parsePatchSourceSpan(operation.source_span, `${itemLabel}.source_span`),
-                semantic_binding: parsePatchSemanticBinding(operation.semantic_binding, `${itemLabel}.semantic_binding`),
-                expected_occurrences: 1,
-            };
-        }),
-    };
-}
-function parsePatchSourceSpan(value, label) {
-    const row = object(value, label, [
-        "coordinate_system",
-        "start_offset",
-        "end_offset",
-        "before_text_sha256",
-    ]);
-    literal(row.coordinate_system, "utf16-code-unit-v1", `${label}.coordinate_system`);
-    return {
-        coordinate_system: "utf16-code-unit-v1",
-        start_offset: integer(row.start_offset, `${label}.start_offset`),
-        end_offset: integer(row.end_offset, `${label}.end_offset`),
-        before_text_sha256: digest(row.before_text_sha256, `${label}.before_text_sha256`),
-    };
-}
-function parsePatchSemanticBinding(value, label) {
-    const row = object(value, label, [
-        "delta_id",
-        "target_key",
-        "before_semantics_sha256",
-        "after_semantics_sha256",
-        "before_text_projection",
-        "after_text_projection",
-    ]);
-    return {
-        delta_id: text(row.delta_id, `${label}.delta_id`),
-        target_key: text(row.target_key, `${label}.target_key`),
-        before_semantics_sha256: digest(row.before_semantics_sha256, `${label}.before_semantics_sha256`),
-        after_semantics_sha256: digest(row.after_semantics_sha256, `${label}.after_semantics_sha256`),
-        before_text_projection: parseTextProjection(row.before_text_projection, `${label}.before_text_projection`),
-        after_text_projection: parseTextProjection(row.after_text_projection, `${label}.after_text_projection`),
-    };
-}
-function parseTextProjection(value, label) {
-    if (value === null)
-        return null;
-    const row = object(value, label, [
-        "semantic_path",
-        "start_offset",
-        "end_offset",
-    ]);
-    return {
-        semantic_path: arrayOf(row.semantic_path, `${label}.semantic_path`, (item, itemLabel) => text(item, itemLabel), { allowEmpty: true }),
-        start_offset: integer(row.start_offset, `${label}.start_offset`),
-        end_offset: integer(row.end_offset, `${label}.end_offset`),
-    };
-}
-export function parseWritebackInput(value, label, complete) {
-    const fields = [
-        "target_locator",
-        "pre_write_raw_byte_digest",
-        "patch",
-        "patch_identity",
-        "expected_post_write_raw_byte_digest",
-        "resource_identities",
-        "proposal_written_delta_ids",
-    ];
-    if (complete)
-        fields.push("target_encoding", "target_eol_policy");
-    const row = object(value, label, fields);
-    const base = {
-        target_locator: text(row.target_locator, `${label}.target_locator`),
-        pre_write_raw_byte_digest: digest(row.pre_write_raw_byte_digest, `${label}.pre_write_raw_byte_digest`),
-        patch: parsePatch(row.patch, `${label}.patch`),
-        patch_identity: digest(row.patch_identity, `${label}.patch_identity`),
-        expected_post_write_raw_byte_digest: digest(row.expected_post_write_raw_byte_digest, `${label}.expected_post_write_raw_byte_digest`),
-        resource_identities: optionalArrayOf(row.resource_identities, `${label}.resource_identities`, parseResourceDigestIdentity),
-        proposal_written_delta_ids: stringSet(row.proposal_written_delta_ids, `${label}.proposal_written_delta_ids`, { allowEmpty: true }),
-    };
-    if (!complete)
-        return base;
-    return {
-        ...base,
-        target_encoding: oneOf(row.target_encoding, ENCODINGS, `${label}.target_encoding`),
-        target_eol_policy: oneOf(row.target_eol_policy, ["none", "lf", "crlf", "cr"], `${label}.target_eol_policy`),
-    };
-}
-function parseProviderIdentity(value, label) {
-    const row = object(value, label, ["key", "locator", "immutable_identity"]);
-    return {
-        key: text(row.key, `${label}.key`),
-        locator: text(row.locator, `${label}.locator`),
-        immutable_identity: text(row.immutable_identity, `${label}.immutable_identity`),
-    };
-}
-function parseProviderResourceIdentity(value, label) {
-    const row = object(value, label, [
-        "key",
-        "locator",
-        "immutable_identity",
-        "raw_byte_digest",
-    ]);
-    return {
-        ...parseProviderIdentity({
-            key: row.key,
-            locator: row.locator,
-            immutable_identity: row.immutable_identity,
-        }, label),
-        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
-    };
-}
-function parseResourceDigestIdentity(value, label) {
-    const row = object(value, label, ["key", "raw_byte_digest"]);
-    return {
-        key: text(row.key, `${label}.key`),
-        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
-    };
-}

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

@@ -1,44 +0,0 @@
-import { type DesignResourceRecoveryCheckpoint, type DesignResourceRecoveryCreateInput, type DesignResourceReplayProjection } from "./design-resource-recovery-types.js";
-import type { DesignResourceReconciliationResult } from "./design-resource-reconciliation-types.js";
-export interface DesignResourceRecoveryInspection {
-    status: "recoverable";
-    checkpoint_path: string;
-    checkpoint_raw_byte_digest: string;
-    replay: DesignResourceReplayProjection;
-    writeback: {
-        configured: false;
-    } | {
-        configured: true;
-        state: "unapplied" | "applied" | "conflict";
-        current_raw_byte_digest: string;
-        pre_write_raw_byte_digest: string;
-        expected_post_write_raw_byte_digest: string;
-    };
-}
-export declare function createDesignResourceRecoveryCheckpoint(repository: string, input: DesignResourceRecoveryCreateInput): Promise<{
-    status: "created" | "already-current";
-    checkpoint_path: string;
-    checkpoint_raw_byte_digest: string;
-}>;
-export declare function updateDesignResourceRecoveryCheckpoint(repository: string, input: DesignResourceRecoveryCreateInput, expectedCurrentDigest: string): Promise<{
-    status: "updated" | "already-current";
-    checkpoint_path: string;
-    checkpoint_raw_byte_digest: string;
-}>;
-export declare function inspectDesignResourceRecovery(repository: string, sessionId: string): Promise<DesignResourceRecoveryInspection>;
-export declare function previewDesignResourceRecoveryWriteback(repository: string, sessionId: string): Promise<DesignResourceRecoveryInspection & {
-    patch: DesignResourceRecoveryCheckpoint["writeback"];
-}>;
-export declare function applyDesignResourceRecoveryWriteback(repository: string, sessionId: string, auditLocator: string): Promise<{
-    status: "writeback-applied" | "writeback-idempotent" | "external-resource-revalidation-pending" | "blocked";
-    write_transaction: boolean;
-    idempotent_replay: boolean;
-    reconciliation: DesignResourceReconciliationResult;
-    target_raw_byte_digest: string;
-}>;
-export declare function reconcileDesignResourceRecovery(repository: string, sessionId: string, auditLocator: string): Promise<{
-    status: "reconciliation-balanced" | "external-resource-revalidation-pending" | "blocked";
-    write_transaction: false;
-    reconciliation: DesignResourceReconciliationResult;
-}>;
-export { removeDesignResourceRecoveryCheckpoint } from "./design-resource-recovery-cleanup.js";

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

@@ -1,216 +0,0 @@
-import { createRecoveryCheckpointFile, deriveDigestCasState, atomicCasWrite, readRecoveryCheckpointFile, readRecoveryRepositoryFile, updateRecoveryCheckpointFile, } from "./design-resource-recovery-files.js";
-import { loadCurrentDesignResourceRecoveryCheckpoint, validateDesignResourceRepositoryAuthority, } from "./design-resource-recovery-current.js";
-import { encodeDesignResourceRecoveryCheckpoint, parseDesignResourceRecoveryCheckpoint, } from "./design-resource-recovery-codec.js";
-import { parseDesignResourceReconciliationAudit } from "./design-resource-reconciliation-codec.js";
-import { reconcileDesignResourceWriteback } from "./design-resource-reconciliation.js";
-import { activeAcceptedDesignResourceDeltas, createDesignResourceReplayProjection, validateDesignResourceRecoverySemantics, } from "./design-resource-recovery-replay.js";
-import { applyDesignResourceExactPatch, decodeDesignResourceText, verifyDesignResourceExactPatchReadback, verifyDesignResourceSupersededTextReadback, } from "./design-resource-recovery-text.js";
-import { validateDesignResourceAuthoritySourceItems } from "./design-resource-recovery-source-authority.js";
-import { validateReconciliationDownstreamOwners, validateSelectedResourceRepositoryBindings, } from "./design-resource-recovery-repository-bindings.js";
-import { DESIGN_RESOURCE_RECOVERY_SCHEMA } from "./design-resource-recovery-schema.js";
-import { sha256Hex } from "./strict-codec.js";
-export async function createDesignResourceRecoveryCheckpoint(repository, input) {
-    const { encoded } = await prepareDesignResourceRecoveryCheckpoint(repository, input);
-    const written = await createRecoveryCheckpointFile(repository, input.session_id, Buffer.from(encoded, "utf8"));
-    return {
-        status: written.changed ? "created" : "already-current",
-        checkpoint_path: written.path,
-        checkpoint_raw_byte_digest: written.raw_byte_digest,
-    };
-}
-export async function updateDesignResourceRecoveryCheckpoint(repository, input, expectedCurrentDigest) {
-    const current = await readRecoveryCheckpointFile(repository, input.session_id);
-    assertDigest("checkpoint_update", current.raw_byte_digest, expectedCurrentDigest);
-    const currentCheckpoint = parseDesignResourceRecoveryCheckpoint(current.bytes.toString("utf8"));
-    if (currentCheckpoint.session_id !== input.session_id)
-        throw new Error("design_resource_recovery_invalid:update_session_identity_mismatch");
-    validateDesignResourceRecoverySemantics(currentCheckpoint);
-    const { encoded } = await prepareDesignResourceRecoveryCheckpoint(repository, input);
-    const written = await updateRecoveryCheckpointFile(repository, input.session_id, Buffer.from(encoded, "utf8"), expectedCurrentDigest);
-    const readback = await readRecoveryCheckpointFile(repository, input.session_id);
-    assertDigest("checkpoint_update_readback", readback.raw_byte_digest, written.raw_byte_digest);
-    const parsed = parseDesignResourceRecoveryCheckpoint(readback.bytes.toString("utf8"));
-    validateDesignResourceRecoverySemantics(parsed);
-    return {
-        status: written.changed ? "updated" : "already-current",
-        checkpoint_path: written.path,
-        checkpoint_raw_byte_digest: written.raw_byte_digest,
-    };
-}
-async function prepareDesignResourceRecoveryCheckpoint(repository, input) {
-    validateDesignResourceRecoverySemantics(input);
-    const baseSnapshot = await readRecoveryRepositoryFile(repository, input.base.locator, "design_resource_recovery_base");
-    assertDigest("base", baseSnapshot.raw_byte_digest, input.base.raw_byte_digest);
-    const baseText = decodeDesignResourceText(baseSnapshot.bytes);
-    await validateDesignResourceRepositoryAuthority(repository, input.design_authority);
-    await validateDesignResourceAuthoritySourceItems(repository, input);
-    await validateSelectedResourceRepositoryBindings(repository, input);
-    let writeback;
-    if (input.writeback) {
-        const target = await readRecoveryRepositoryFile(repository, input.writeback.target_locator, "design_resource_recovery_writeback_target");
-        assertDigest("writeback_pre", target.raw_byte_digest, input.writeback.pre_write_raw_byte_digest);
-        const patched = applyDesignResourceExactPatch(target.bytes, input.writeback.patch);
-        assertDigest("writeback_expected_post", sha256Hex(patched.bytes), input.writeback.expected_post_write_raw_byte_digest);
-        verifyDesignResourceSupersededTextReadback(patched.bytes, input.writeback.patch, supersedingDeltaIds(input));
-        writeback = {
-            ...input.writeback,
-            target_encoding: patched.encoding,
-            target_eol_policy: patched.eol_policy,
-        };
-    }
-    const { schema_version: _inputSchema, base: _inputBase, writeback: _inputWriteback, ...common } = input;
-    const checkpoint = {
-        ...common,
-        schema_version: DESIGN_RESOURCE_RECOVERY_SCHEMA,
-        owner: "ty-context-design-resource-recovery",
-        base: {
-            ...input.base,
-            encoding: baseText.encoding,
-            eol_policy: baseText.eol_policy,
-        },
-        ...(writeback ? { writeback } : {}),
-    };
-    validateDesignResourceRecoverySemantics(checkpoint);
-    const encoded = encodeDesignResourceRecoveryCheckpoint(checkpoint);
-    const roundTrip = parseDesignResourceRecoveryCheckpoint(encoded);
-    validateDesignResourceRecoverySemantics(roundTrip);
-    return {
-        checkpoint: roundTrip,
-        encoded,
-    };
-}
-export async function inspectDesignResourceRecovery(repository, sessionId) {
-    const loaded = await loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId);
-    const writeback = loaded.checkpoint.writeback;
-    if (!writeback)
-        return {
-            status: "recoverable",
-            checkpoint_path: loaded.path,
-            checkpoint_raw_byte_digest: loaded.digest,
-            replay: createDesignResourceReplayProjection(loaded.checkpoint),
-            writeback: { configured: false },
-        };
-    const target = await readRecoveryRepositoryFile(repository, writeback.target_locator, "design_resource_recovery_writeback_target");
-    return {
-        status: "recoverable",
-        checkpoint_path: loaded.path,
-        checkpoint_raw_byte_digest: loaded.digest,
-        replay: createDesignResourceReplayProjection(loaded.checkpoint),
-        writeback: {
-            configured: true,
-            state: deriveDigestCasState(target.raw_byte_digest, writeback.pre_write_raw_byte_digest, writeback.expected_post_write_raw_byte_digest),
-            current_raw_byte_digest: target.raw_byte_digest,
-            pre_write_raw_byte_digest: writeback.pre_write_raw_byte_digest,
-            expected_post_write_raw_byte_digest: writeback.expected_post_write_raw_byte_digest,
-        },
-    };
-}
-export async function previewDesignResourceRecoveryWriteback(repository, sessionId) {
-    const inspection = await inspectDesignResourceRecovery(repository, sessionId);
-    const checkpoint = (await loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId)).checkpoint;
-    if (!checkpoint.writeback)
-        throw new Error("design_resource_recovery_invalid:writeback_not_configured");
-    return { ...inspection, patch: checkpoint.writeback };
-}
-export async function applyDesignResourceRecoveryWriteback(repository, sessionId, auditLocator) {
-    const { checkpoint } = await loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId);
-    const writeback = checkpoint.writeback;
-    if (!writeback)
-        throw new Error("design_resource_recovery_invalid:writeback_not_configured");
-    const auditSnapshot = await readRecoveryRepositoryFile(repository, auditLocator, "design_resource_recovery_fresh_audit");
-    const audit = parseDesignResourceReconciliationAudit(auditSnapshot.bytes.toString("utf8"));
-    const preReconciliation = reconcileDesignResourceWriteback(checkpoint, audit);
-    let externalRevalidationRequired = false;
-    if (preReconciliation.status === "reconciliation-balanced") {
-        try {
-            externalRevalidationRequired = (await validateReconciliationDownstreamOwners(repository, checkpoint)).external_revalidation_required;
-        }
-        catch (error) {
-            preReconciliation.status = "blocked";
-            preReconciliation.findings.push(error instanceof Error ? error.message : String(error));
-        }
-    }
-    const target = await readRecoveryRepositoryFile(repository, writeback.target_locator, "design_resource_recovery_writeback_target");
-    const state = deriveDigestCasState(target.raw_byte_digest, writeback.pre_write_raw_byte_digest, writeback.expected_post_write_raw_byte_digest);
-    if (state === "conflict")
-        throw new Error("design_resource_recovery_invalid:writeback_cas_conflict");
-    if (preReconciliation.status === "blocked")
-        return {
-            status: "blocked",
-            write_transaction: false,
-            idempotent_replay: state === "applied",
-            reconciliation: preReconciliation,
-            target_raw_byte_digest: target.raw_byte_digest,
-        };
-    let wrote = false;
-    if (state === "unapplied") {
-        const patched = applyDesignResourceExactPatch(target.bytes, writeback.patch, writeback.target_encoding, writeback.target_eol_policy);
-        assertDigest("writeback_expected_post", sha256Hex(patched.bytes), writeback.expected_post_write_raw_byte_digest);
-        await atomicCasWrite(repository, writeback.target_locator, patched.bytes, writeback.pre_write_raw_byte_digest, target.mode);
-        wrote = true;
-    }
-    const post = await readRecoveryRepositoryFile(repository, writeback.target_locator, "design_resource_recovery_writeback_readback");
-    assertDigest("writeback_post_readback", post.raw_byte_digest, writeback.expected_post_write_raw_byte_digest);
-    verifyDesignResourceExactPatchReadback(post.bytes, writeback.patch);
-    verifyDesignResourceSupersededTextReadback(post.bytes, writeback.patch, supersedingDeltaIds(checkpoint));
-    const reconciliation = reconcileDesignResourceWriteback(checkpoint, audit);
-    if (reconciliation.status === "reconciliation-balanced") {
-        try {
-            externalRevalidationRequired = (await validateReconciliationDownstreamOwners(repository, checkpoint)).external_revalidation_required;
-        }
-        catch (error) {
-            reconciliation.status = "blocked";
-            reconciliation.findings.push(error instanceof Error ? error.message : String(error));
-            reconciliation.findings.sort();
-        }
-    }
-    return {
-        status: reconciliation.status === "blocked"
-            ? "blocked"
-            : externalRevalidationRequired
-                ? "external-resource-revalidation-pending"
-                : wrote
-                    ? "writeback-applied"
-                    : "writeback-idempotent",
-        write_transaction: wrote,
-        idempotent_replay: !wrote,
-        reconciliation,
-        target_raw_byte_digest: post.raw_byte_digest,
-    };
-}
-export async function reconcileDesignResourceRecovery(repository, sessionId, auditLocator) {
-    const { checkpoint } = await loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId, { validateSelectedResources: false });
-    if (checkpoint.writeback)
-        throw new Error("design_resource_recovery_invalid:read_only_reconcile_requires_no_writeback");
-    const auditSnapshot = await readRecoveryRepositoryFile(repository, auditLocator, "design_resource_recovery_fresh_audit");
-    const audit = parseDesignResourceReconciliationAudit(auditSnapshot.bytes.toString("utf8"));
-    const reconciliation = reconcileDesignResourceWriteback(checkpoint, audit);
-    if (reconciliation.status === "blocked")
-        return { status: "blocked", write_transaction: false, reconciliation };
-    try {
-        const current = await validateReconciliationDownstreamOwners(repository, checkpoint);
-        return {
-            status: current.external_revalidation_required
-                ? "external-resource-revalidation-pending"
-                : "reconciliation-balanced",
-            write_transaction: false,
-            reconciliation,
-        };
-    }
-    catch (error) {
-        reconciliation.status = "blocked";
-        reconciliation.findings.push(error instanceof Error ? error.message : String(error));
-        reconciliation.findings.sort();
-        return { status: "blocked", write_transaction: false, reconciliation };
-    }
-}
-export { removeDesignResourceRecoveryCheckpoint } from "./design-resource-recovery-cleanup.js";
-function assertDigest(label, actual, expected) {
-    if (actual !== expected)
-        throw new Error(`design_resource_recovery_invalid:${label}_digest_mismatch:${expected}:${actual}`);
-}
-function supersedingDeltaIds(state) {
-    return new Set(activeAcceptedDesignResourceDeltas(state.deltas)
-        .filter((delta) => delta.supersedes.length > 0)
-        .map((delta) => delta.delta_id));
-}

package/dist/lib/design-resource-symbolic-applicability-authority.d.ts

@@ -1,7 +0,0 @@
-import type { SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
-export declare function validateSymbolicApplicabilityAuthorityRefs(row: {
-    census_refs: string[];
-    source_item_refs: string[];
-    basis_refs: string[];
-    rationale: string;
-}, indexes: SymbolicManifestIndexes, artifactRefs: ReadonlySet<string>, label: string): void;

package/dist/lib/design-resource-symbolic-applicability-authority.js

@@ -1,19 +0,0 @@
-import { isKnownSymbolicApplicabilityPolicyRef } from "./design-resource-symbolic-applicability-policy.js";
-import { invalid, requireKnownRefs, unique, } from "./design-resource-symbolic-validation-support.js";
-export function validateSymbolicApplicabilityAuthorityRefs(row, indexes, artifactRefs, label) {
-    if (!row.census_refs.length ||
-        !row.source_item_refs.length ||
-        !row.basis_refs.length ||
-        !row.rationale.trim())
-        invalid("v2_applicability_authority_incomplete", label);
-    unique(row.census_refs, `v2_applicability_census_duplicate:${label}`);
-    unique(row.source_item_refs, `v2_applicability_source_item_duplicate:${label}`);
-    unique(row.basis_refs, `v2_applicability_basis_duplicate:${label}`);
-    requireKnownRefs(row.census_refs, indexes.census, "v2_applicability_census_unknown");
-    requireKnownRefs(row.source_item_refs, indexes.sourceItems, "v2_applicability_source_item_unknown");
-    for (const basisRef of row.basis_refs)
-        if (!isKnownSymbolicApplicabilityPolicyRef(basisRef) &&
-            !indexes.census.has(basisRef) &&
-            !artifactRefs.has(basisRef))
-            invalid("v2_applicability_basis_authority_unknown", `${label}:${basisRef}`);
-}

package/dist/lib/design-resource-symbolic-applicability-policy.d.ts

@@ -1,12 +0,0 @@
-import type { DesignResourceInspectorCensusEntryV1 } from "./design-resource-fact-manifest-model.js";
-import type { DesignResourceHandoffSubjectV1 } from "./design-resource-handoff-types.js";
-export declare const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_POLICY_VERSION: "package-subject-capability-algebra-v1";
-export interface DerivedSymbolicStandardApplicabilityV1 {
-    property_refs: string[];
-    policy_basis_refs: string[];
-}
-export declare function symbolicApplicabilitySubjectPolicyRef(kind: string): string;
-export declare function symbolicApplicabilityCensusPolicyRef(kind: string): string;
-export declare const SYMBOLIC_APPLICABILITY_POPULATION_POLICY_REF: "package-policy.subject-population.v1";
-export declare function deriveRequiredSymbolicStandardApplicability(subject: DesignResourceHandoffSubjectV1, census: ReadonlyMap<string, DesignResourceInspectorCensusEntryV1>): DerivedSymbolicStandardApplicabilityV1;
-export declare function isKnownSymbolicApplicabilityPolicyRef(value: string): boolean;

package/dist/lib/design-resource-symbolic-applicability-policy.js

@@ -1,79 +0,0 @@
-import { DESIGN_RESOURCE_STANDARD_PROPERTIES } from "./design-resource-fact-manifest-catalog.js";
-import { compareText } from "./design-resource-symbolic-validation-support.js";
-export const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_POLICY_VERSION = "package-subject-capability-algebra-v1";
-const BASE_VISUAL_PROPERTIES = ["geometry.width", "color.background"];
-const SUBJECT_FAMILIES = {
-    surface: [],
-    flow: ["navigation"],
-    region: [],
-    overlay: ["interaction", "accessibility"],
-    system_ui: ["system", "accessibility"],
-    component_family: [],
-    component_instance: [],
-    control: ["interaction", "accessibility"],
-    anatomy_part: [],
-    slot: [],
-    primitive: [],
-    text: ["typography", "content"],
-    icon: ["icon", "asset", "accessibility"],
-    media: ["media", "asset", "accessibility"],
-    asset: ["asset"],
-    relation: ["relation"],
-};
-const CENSUS_FAMILIES = {
-    asset_reference: ["asset"],
-    relation: ["relation"],
-    dynamic_population: ["content"],
-    interaction_phase: ["interaction"],
-};
-const propertyRefsByFamily = new Map();
-for (const property of DESIGN_RESOURCE_STANDARD_PROPERTIES) {
-    const values = propertyRefsByFamily.get(property.family) ?? [];
-    values.push(property.key);
-    propertyRefsByFamily.set(property.family, values);
-}
-export function symbolicApplicabilitySubjectPolicyRef(kind) {
-    return `package-policy.subject-kind.${kind}.v1`;
-}
-export function symbolicApplicabilityCensusPolicyRef(kind) {
-    return `package-policy.census-kind.${kind.replaceAll("_", "-")}.v1`;
-}
-export const SYMBOLIC_APPLICABILITY_POPULATION_POLICY_REF = "package-policy.subject-population.v1";
-export function deriveRequiredSymbolicStandardApplicability(subject, census) {
-    const properties = new Set();
-    const policyBasis = new Set();
-    for (const propertyRef of BASE_VISUAL_PROPERTIES)
-        properties.add(propertyRef);
-    addFamilies(properties, SUBJECT_FAMILIES[subject.kind] ?? []);
-    policyBasis.add(symbolicApplicabilitySubjectPolicyRef(subject.kind));
-    for (const censusRef of subject.census_refs) {
-        const kind = census.get(censusRef)?.kind;
-        if (!kind)
-            continue;
-        const families = CENSUS_FAMILIES[kind] ?? [];
-        if (!families.length)
-            continue;
-        addFamilies(properties, families);
-        policyBasis.add(symbolicApplicabilityCensusPolicyRef(kind));
-    }
-    if (subject.population_ref !== null) {
-        addFamilies(properties, ["content"]);
-        policyBasis.add(SYMBOLIC_APPLICABILITY_POPULATION_POLICY_REF);
-    }
-    return {
-        property_refs: [...properties].sort(compareText),
-        policy_basis_refs: [...policyBasis].sort(compareText),
-    };
-}
-export function isKnownSymbolicApplicabilityPolicyRef(value) {
-    if (value === SYMBOLIC_APPLICABILITY_POPULATION_POLICY_REF)
-        return true;
-    if (Object.keys(SUBJECT_FAMILIES).some((kind) => value === symbolicApplicabilitySubjectPolicyRef(kind)))
-        return true;
-    return Object.keys(CENSUS_FAMILIES).some((kind) => value === symbolicApplicabilityCensusPolicyRef(kind));
-}
-function addFamilies(properties, families) {
-    for (const family of families)
-        for (const propertyRef of propertyRefsByFamily.get(family) ?? [])
-            properties.add(propertyRef);
-}

package/dist/lib/design-resource-symbolic-applicability-profiles.d.ts

@@ -1,8 +0,0 @@
-export declare const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILE_CATALOG: "package-subject-property-applicability-v1";
-export interface DesignResourceSymbolicApplicabilityProfileV1 {
-    key: string;
-    property_refs: readonly string[];
-}
-export declare const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILES: readonly DesignResourceSymbolicApplicabilityProfileV1[];
-export declare function symbolicPropertyProfileKey(propertyRef: string): string;
-export declare function resolveSymbolicApplicabilityProfiles(profileRefs: readonly string[], label: string): Set<string>;

package/dist/lib/design-resource-symbolic-applicability-profiles.js

@@ -1,55 +0,0 @@
-import { DESIGN_RESOURCE_STANDARD_PROPERTIES, DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS, } from "./design-resource-fact-manifest-catalog.js";
-import { DESIGN_RESOURCE_INSPECTOR_CAPABILITIES, DESIGN_RESOURCE_PROPERTY_FAMILIES, } from "./design-resource-fact-manifest-types.js";
-import { compareText, invalid, } from "./design-resource-symbolic-validation-support.js";
-export const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILE_CATALOG = "package-subject-property-applicability-v1";
-const profiles = buildProfiles();
-export const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILES = Object.freeze(profiles);
-const profileByKey = new Map(profiles.map((profile) => [profile.key, profile]));
-export function symbolicPropertyProfileKey(propertyRef) {
-    return `profile.property.${propertyRef}`;
-}
-export function resolveSymbolicApplicabilityProfiles(profileRefs, label) {
-    const propertyRefs = new Set();
-    for (const profileRef of profileRefs) {
-        const profile = profileByKey.get(profileRef);
-        if (!profile)
-            invalid("v2_applicability_profile_unknown", `${label}:${profileRef}`);
-        for (const propertyRef of profile.property_refs)
-            propertyRefs.add(propertyRef);
-    }
-    return propertyRefs;
-}
-function buildProfiles() {
-    const result = [
-        {
-            key: "profile.all-standard",
-            property_refs: [...DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS],
-        },
-    ];
-    for (const property of DESIGN_RESOURCE_STANDARD_PROPERTIES)
-        result.push({
-            key: symbolicPropertyProfileKey(property.key),
-            property_refs: [property.key],
-        });
-    for (const family of DESIGN_RESOURCE_PROPERTY_FAMILIES)
-        result.push({
-            key: `profile.family.${family}`,
-            property_refs: DESIGN_RESOURCE_STANDARD_PROPERTIES.filter((property) => property.family === family).map((property) => property.key),
-        });
-    for (const capability of DESIGN_RESOURCE_INSPECTOR_CAPABILITIES)
-        result.push({
-            key: `profile.capability.${capability}`,
-            property_refs: DESIGN_RESOURCE_STANDARD_PROPERTIES.filter((property) => property.inspector_capability_refs.includes(capability)).map((property) => property.key),
-        });
-    result.sort((left, right) => compareText(left.key, right.key));
-    if (new Set(result.map((profile) => profile.key)).size !== result.length)
-        invalid("v2_applicability_profile_catalog_duplicate", "");
-    const covered = new Set(result.flatMap((profile) => profile.property_refs));
-    if (covered.size !== DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS.length ||
-        DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS.some((key) => !covered.has(key)))
-        invalid("v2_applicability_profile_catalog_incomplete", "");
-    return result.map((profile) => Object.freeze({
-        ...profile,
-        property_refs: Object.freeze([...profile.property_refs].sort(compareText)),
-    }));
-}

package/dist/lib/design-resource-symbolic-applicability-shape.d.ts

@@ -1,2 +0,0 @@
-import type { DesignResourceSymbolicStructuralApplicabilityV2 } from "./design-resource-symbolic-fact-types.js";
-export declare function parseSymbolicStructuralApplicability(value: unknown, label: string): DesignResourceSymbolicStructuralApplicabilityV2;