project-tiny-context-harness 0.8.11 → 0.8.13

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

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

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

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

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

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

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

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

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

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

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