@c4a/context 0.6.18 → 0.7.0

package/indexerQuestionAuthority.d.ts

@@ -0,0 +1,419 @@
+import { z } from "zod";
+export declare const indexerRequirementQuestionBindingSchema: z.ZodObject<{
+    ref: z.ZodString;
+    authority: z.ZodObject<{
+        kind: z.ZodEnum<["cli-base-contract", "verified-contract-overlay"]>;
+        ref: z.ZodString;
+        digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "cli-base-contract" | "verified-contract-overlay";
+        ref: string;
+        digest: string;
+    }, {
+        kind: "cli-base-contract" | "verified-contract-overlay";
+        ref: string;
+        digest: string;
+    }>;
+    contract_version: z.ZodNumber;
+    contract_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    ref: string;
+    authority: {
+        kind: "cli-base-contract" | "verified-contract-overlay";
+        ref: string;
+        digest: string;
+    };
+    contract_version: number;
+    contract_digest: string;
+}, {
+    ref: string;
+    authority: {
+        kind: "cli-base-contract" | "verified-contract-overlay";
+        ref: string;
+        digest: string;
+    };
+    contract_version: number;
+    contract_digest: string;
+}>;
+export declare const indexerQuestionEvidenceContractSchema: z.ZodEffects<z.ZodObject<{
+    accepted_kinds: z.ZodArray<z.ZodEnum<["code", "contract", "configuration", "documentation", "runbook", "decision-record", "test-result", "runtime-observation", "tool-snapshot"]>, "many">;
+    minimum_items: z.ZodNumber;
+    minimum_distinct_sources: z.ZodNumber;
+    provenance_constraints: z.ZodOptional<z.ZodObject<{
+        protocol: z.ZodLiteral<"context.indexer.selector/v1">;
+        expression: z.ZodType<import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression, z.ZodTypeDef, import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression>;
+    }, "strict", z.ZodTypeAny, {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    }, {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+    minimum_items: number;
+    minimum_distinct_sources: number;
+    provenance_constraints?: {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    } | undefined;
+}, {
+    accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+    minimum_items: number;
+    minimum_distinct_sources: number;
+    provenance_constraints?: {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    } | undefined;
+}>, {
+    accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+    minimum_items: number;
+    minimum_distinct_sources: number;
+    provenance_constraints?: {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    } | undefined;
+}, {
+    accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+    minimum_items: number;
+    minimum_distinct_sources: number;
+    provenance_constraints?: {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    } | undefined;
+}>;
+export declare const indexerResolvedMaterialQuestionSchema: z.ZodObject<{
+    ref: z.ZodString;
+    authority: z.ZodObject<{
+        kind: z.ZodEnum<["cli-base-contract", "verified-contract-overlay"]>;
+        ref: z.ZodString;
+        digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "cli-base-contract" | "verified-contract-overlay";
+        ref: string;
+        digest: string;
+    }, {
+        kind: "cli-base-contract" | "verified-contract-overlay";
+        ref: string;
+        digest: string;
+    }>;
+    contract_version: z.ZodNumber;
+    contract_digest: z.ZodString;
+    semantic: z.ZodEffects<z.ZodString, string, string>;
+    coverage_domain: z.ZodEffects<z.ZodString, string, string>;
+    target_domain_ref: z.ZodEffects<z.ZodString, string, string>;
+    target_selector: z.ZodObject<{
+        protocol: z.ZodLiteral<"context.indexer.selector/v1">;
+        expression: z.ZodType<import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression, z.ZodTypeDef, import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression>;
+    }, "strict", z.ZodTypeAny, {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    }, {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    }>;
+    evidence_contract: z.ZodEffects<z.ZodObject<{
+        accepted_kinds: z.ZodArray<z.ZodEnum<["code", "contract", "configuration", "documentation", "runbook", "decision-record", "test-result", "runtime-observation", "tool-snapshot"]>, "many">;
+        minimum_items: z.ZodNumber;
+        minimum_distinct_sources: z.ZodNumber;
+        provenance_constraints: z.ZodOptional<z.ZodObject<{
+            protocol: z.ZodLiteral<"context.indexer.selector/v1">;
+            expression: z.ZodType<import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression, z.ZodTypeDef, import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression>;
+        }, "strict", z.ZodTypeAny, {
+            protocol: "context.indexer.selector/v1";
+            expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+        }, {
+            protocol: "context.indexer.selector/v1";
+            expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+        minimum_items: number;
+        minimum_distinct_sources: number;
+        provenance_constraints?: {
+            protocol: "context.indexer.selector/v1";
+            expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+        } | undefined;
+    }, {
+        accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+        minimum_items: number;
+        minimum_distinct_sources: number;
+        provenance_constraints?: {
+            protocol: "context.indexer.selector/v1";
+            expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+        } | undefined;
+    }>, {
+        accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+        minimum_items: number;
+        minimum_distinct_sources: number;
+        provenance_constraints?: {
+            protocol: "context.indexer.selector/v1";
+            expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+        } | undefined;
+    }, {
+        accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+        minimum_items: number;
+        minimum_distinct_sources: number;
+        provenance_constraints?: {
+            protocol: "context.indexer.selector/v1";
+            expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+        } | undefined;
+    }>;
+    allowed_exclusion_reason_codes: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    ref: string;
+    authority: {
+        kind: "cli-base-contract" | "verified-contract-overlay";
+        ref: string;
+        digest: string;
+    };
+    contract_version: number;
+    contract_digest: string;
+    semantic: string;
+    coverage_domain: string;
+    target_domain_ref: string;
+    target_selector: {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    };
+    evidence_contract: {
+        accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+        minimum_items: number;
+        minimum_distinct_sources: number;
+        provenance_constraints?: {
+            protocol: "context.indexer.selector/v1";
+            expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+        } | undefined;
+    };
+    allowed_exclusion_reason_codes?: string[] | undefined;
+}, {
+    ref: string;
+    authority: {
+        kind: "cli-base-contract" | "verified-contract-overlay";
+        ref: string;
+        digest: string;
+    };
+    contract_version: number;
+    contract_digest: string;
+    semantic: string;
+    coverage_domain: string;
+    target_domain_ref: string;
+    target_selector: {
+        protocol: "context.indexer.selector/v1";
+        expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+    };
+    evidence_contract: {
+        accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+        minimum_items: number;
+        minimum_distinct_sources: number;
+        provenance_constraints?: {
+            protocol: "context.indexer.selector/v1";
+            expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+        } | undefined;
+    };
+    allowed_exclusion_reason_codes?: string[] | undefined;
+}>;
+export type IndexerRequirementQuestionBinding = z.infer<typeof indexerRequirementQuestionBindingSchema>;
+export type IndexerResolvedMaterialQuestion = z.infer<typeof indexerResolvedMaterialQuestionSchema>;
+export type IndexerQuestionEvidenceContract = z.infer<typeof indexerQuestionEvidenceContractSchema>;
+export declare function indexerResolvedMaterialQuestionDigest(question: Omit<IndexerResolvedMaterialQuestion, "contract_digest">): string;
+export declare function validateIndexerResolvedMaterialQuestion(input: {
+    binding: unknown;
+    resolved_question: unknown;
+    allowed_selector_fact_paths: ReadonlySet<string>;
+    coverage_domain_state: "required" | "optional" | "out-of-scope";
+}): IndexerResolvedMaterialQuestion;
+declare const questionTargetInventoryItemSchema: z.ZodObject<{
+    target_ref: z.ZodString;
+    target_domain_ref: z.ZodEffects<z.ZodString, string, string>;
+    requirement_ref: z.ZodString;
+    owner_cell_ref: z.ZodString;
+    source_ref: z.ZodString;
+    module_ref: z.ZodNullable<z.ZodString>;
+    subject_key: z.ZodObject<{
+        protocol: z.ZodLiteral<"context.subject-key/v1">;
+        namespace: z.ZodEffects<z.ZodString, string, string>;
+        kind: z.ZodEffects<z.ZodString, string, string>;
+        local_key: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: string;
+        protocol: "context.subject-key/v1";
+        namespace: string;
+        local_key: string;
+    }, {
+        kind: string;
+        protocol: "context.subject-key/v1";
+        namespace: string;
+        local_key: string;
+    }>;
+    node_ref: z.ZodString;
+    canonical_fact_slice_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    source_ref: string;
+    requirement_ref: string;
+    target_ref: string;
+    module_ref: string | null;
+    target_domain_ref: string;
+    subject_key: {
+        kind: string;
+        protocol: "context.subject-key/v1";
+        namespace: string;
+        local_key: string;
+    };
+    node_ref: string;
+    owner_cell_ref: string;
+    canonical_fact_slice_digest: string;
+}, {
+    source_ref: string;
+    requirement_ref: string;
+    target_ref: string;
+    module_ref: string | null;
+    target_domain_ref: string;
+    subject_key: {
+        kind: string;
+        protocol: "context.subject-key/v1";
+        namespace: string;
+        local_key: string;
+    };
+    node_ref: string;
+    owner_cell_ref: string;
+    canonical_fact_slice_digest: string;
+}>;
+export declare const indexerQuestionTargetInventorySchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.question-target-inventory/v1">;
+    inventory_digest: z.ZodString;
+    requirement_set_digest: z.ZodString;
+    profile_contract_digests: z.ZodArray<z.ZodString, "many">;
+    source_inventory_digests: z.ZodArray<z.ZodString, "many">;
+    items: z.ZodArray<z.ZodObject<{
+        target_ref: z.ZodString;
+        target_domain_ref: z.ZodEffects<z.ZodString, string, string>;
+        requirement_ref: z.ZodString;
+        owner_cell_ref: z.ZodString;
+        source_ref: z.ZodString;
+        module_ref: z.ZodNullable<z.ZodString>;
+        subject_key: z.ZodObject<{
+            protocol: z.ZodLiteral<"context.subject-key/v1">;
+            namespace: z.ZodEffects<z.ZodString, string, string>;
+            kind: z.ZodEffects<z.ZodString, string, string>;
+            local_key: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: string;
+            protocol: "context.subject-key/v1";
+            namespace: string;
+            local_key: string;
+        }, {
+            kind: string;
+            protocol: "context.subject-key/v1";
+            namespace: string;
+            local_key: string;
+        }>;
+        node_ref: z.ZodString;
+        canonical_fact_slice_digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        source_ref: string;
+        requirement_ref: string;
+        target_ref: string;
+        module_ref: string | null;
+        target_domain_ref: string;
+        subject_key: {
+            kind: string;
+            protocol: "context.subject-key/v1";
+            namespace: string;
+            local_key: string;
+        };
+        node_ref: string;
+        owner_cell_ref: string;
+        canonical_fact_slice_digest: string;
+    }, {
+        source_ref: string;
+        requirement_ref: string;
+        target_ref: string;
+        module_ref: string | null;
+        target_domain_ref: string;
+        subject_key: {
+            kind: string;
+            protocol: "context.subject-key/v1";
+            namespace: string;
+            local_key: string;
+        };
+        node_ref: string;
+        owner_cell_ref: string;
+        canonical_fact_slice_digest: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.question-target-inventory/v1";
+    inventory_digest: string;
+    requirement_set_digest: string;
+    items: {
+        source_ref: string;
+        requirement_ref: string;
+        target_ref: string;
+        module_ref: string | null;
+        target_domain_ref: string;
+        subject_key: {
+            kind: string;
+            protocol: "context.subject-key/v1";
+            namespace: string;
+            local_key: string;
+        };
+        node_ref: string;
+        owner_cell_ref: string;
+        canonical_fact_slice_digest: string;
+    }[];
+    profile_contract_digests: string[];
+    source_inventory_digests: string[];
+}, {
+    protocol: "context.indexer.question-target-inventory/v1";
+    inventory_digest: string;
+    requirement_set_digest: string;
+    items: {
+        source_ref: string;
+        requirement_ref: string;
+        target_ref: string;
+        module_ref: string | null;
+        target_domain_ref: string;
+        subject_key: {
+            kind: string;
+            protocol: "context.subject-key/v1";
+            namespace: string;
+            local_key: string;
+        };
+        node_ref: string;
+        owner_cell_ref: string;
+        canonical_fact_slice_digest: string;
+    }[];
+    profile_contract_digests: string[];
+    source_inventory_digests: string[];
+}>;
+export type IndexerQuestionTargetInventoryItem = z.infer<typeof questionTargetInventoryItemSchema>;
+export type IndexerQuestionTargetInventory = z.infer<typeof indexerQuestionTargetInventorySchema>;
+export declare function indexerQuestionSubjectTargetRef(input: {
+    target_domain_ref: string;
+    owner_cell_ref: string;
+    subject_key: unknown;
+}): string;
+export declare function indexerQuestionTargetItemDigest(item: IndexerQuestionTargetInventoryItem): string;
+export declare function indexerQuestionTargetInventoryDigest(value: Omit<IndexerQuestionTargetInventory, "inventory_digest">): string;
+export declare function buildIndexerQuestionTargetInventory(input: {
+    requirement_set_digest: string;
+    profile_contract_digests: readonly string[];
+    source_inventory_digests: readonly string[];
+    items: readonly Omit<IndexerQuestionTargetInventoryItem, "target_ref" | "node_ref">[];
+}): IndexerQuestionTargetInventory;
+export declare function validateIndexerQuestionTargetInventory(value: unknown): IndexerQuestionTargetInventory;
+export declare function indexerMaterialQuestionKey(input: {
+    owner_cell_ref: string;
+    question_contract_digest: string;
+    question_subject_target_ref: string;
+}): string;
+export declare function indexerQuestionTargetSetDigest(questionKeys: readonly string[]): string;
+export declare function indexerQuestionSetDigest(questions: readonly IndexerResolvedMaterialQuestion[]): string;
+export declare function indexerQuestionRevisionDigest(input: {
+    question_contract_digest: string;
+    question_key: string;
+    owner_cell_digest: string;
+    question_target_item_digest: string;
+    answer_landing_dependency_digest?: string;
+}): string;
+export {};

package/indexerReaderTargetInventory.d.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+export declare const INDEXER_READER_TARGET_AUTHORITATIVE_OBSERVATIONS: readonly ["declaration", "public-export", "contract-declaration", "runtime-registration", "approved-subject", "partition-subject"];
+export declare const INDEXER_READER_TARGET_REFERENCE_OBSERVATIONS: readonly ["symbol-reference", "import-alias", "re-export-alias", "internal-helper-reference", "lightweight-evidence"];
+export declare const INDEXER_READER_TARGET_OBSERVATION_KINDS: readonly ["declaration", "public-export", "contract-declaration", "runtime-registration", "approved-subject", "partition-subject", "symbol-reference", "import-alias", "re-export-alias", "internal-helper-reference", "lightweight-evidence"];
+declare const readerTargetIdentityObservationSchema: z.ZodObject<{
+    observation_ref: z.ZodString;
+    canonical_identity_ref: z.ZodString;
+    observation_kind: z.ZodEnum<["declaration", "public-export", "contract-declaration", "runtime-registration", "approved-subject", "partition-subject", "symbol-reference", "import-alias", "re-export-alias", "internal-helper-reference", "lightweight-evidence"]>;
+    source_ref: z.ZodString;
+    module_ref: z.ZodNullable<z.ZodString>;
+    content_digest: z.ZodString;
+    evidence_refs: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    source_ref: string;
+    evidence_refs: string[];
+    module_ref: string | null;
+    content_digest: string;
+    observation_ref: string;
+    canonical_identity_ref: string;
+    observation_kind: "lightweight-evidence" | "declaration" | "public-export" | "contract-declaration" | "runtime-registration" | "approved-subject" | "partition-subject" | "symbol-reference" | "import-alias" | "re-export-alias" | "internal-helper-reference";
+}, {
+    source_ref: string;
+    evidence_refs: string[];
+    module_ref: string | null;
+    content_digest: string;
+    observation_ref: string;
+    canonical_identity_ref: string;
+    observation_kind: "lightweight-evidence" | "declaration" | "public-export" | "contract-declaration" | "runtime-registration" | "approved-subject" | "partition-subject" | "symbol-reference" | "import-alias" | "re-export-alias" | "internal-helper-reference";
+}>;
+export declare const indexerReaderTargetFactInventorySchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.reader-target-fact-inventory/v1">;
+    source_scope_digest: z.ZodString;
+    observations: z.ZodArray<z.ZodObject<{
+        observation_ref: z.ZodString;
+        canonical_identity_ref: z.ZodString;
+        observation_kind: z.ZodEnum<["declaration", "public-export", "contract-declaration", "runtime-registration", "approved-subject", "partition-subject", "symbol-reference", "import-alias", "re-export-alias", "internal-helper-reference", "lightweight-evidence"]>;
+        source_ref: z.ZodString;
+        module_ref: z.ZodNullable<z.ZodString>;
+        content_digest: z.ZodString;
+        evidence_refs: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        source_ref: string;
+        evidence_refs: string[];
+        module_ref: string | null;
+        content_digest: string;
+        observation_ref: string;
+        canonical_identity_ref: string;
+        observation_kind: "lightweight-evidence" | "declaration" | "public-export" | "contract-declaration" | "runtime-registration" | "approved-subject" | "partition-subject" | "symbol-reference" | "import-alias" | "re-export-alias" | "internal-helper-reference";
+    }, {
+        source_ref: string;
+        evidence_refs: string[];
+        module_ref: string | null;
+        content_digest: string;
+        observation_ref: string;
+        canonical_identity_ref: string;
+        observation_kind: "lightweight-evidence" | "declaration" | "public-export" | "contract-declaration" | "runtime-registration" | "approved-subject" | "partition-subject" | "symbol-reference" | "import-alias" | "re-export-alias" | "internal-helper-reference";
+    }>, "many">;
+    inventory_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.reader-target-fact-inventory/v1";
+    inventory_digest: string;
+    source_scope_digest: string;
+    observations: {
+        source_ref: string;
+        evidence_refs: string[];
+        module_ref: string | null;
+        content_digest: string;
+        observation_ref: string;
+        canonical_identity_ref: string;
+        observation_kind: "lightweight-evidence" | "declaration" | "public-export" | "contract-declaration" | "runtime-registration" | "approved-subject" | "partition-subject" | "symbol-reference" | "import-alias" | "re-export-alias" | "internal-helper-reference";
+    }[];
+}, {
+    protocol: "context.indexer.reader-target-fact-inventory/v1";
+    inventory_digest: string;
+    source_scope_digest: string;
+    observations: {
+        source_ref: string;
+        evidence_refs: string[];
+        module_ref: string | null;
+        content_digest: string;
+        observation_ref: string;
+        canonical_identity_ref: string;
+        observation_kind: "lightweight-evidence" | "declaration" | "public-export" | "contract-declaration" | "runtime-registration" | "approved-subject" | "partition-subject" | "symbol-reference" | "import-alias" | "re-export-alias" | "internal-helper-reference";
+    }[];
+}>;
+export declare const indexerReaderTargetProjectionSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.reader-target-projection/v1">;
+    artifact_set_digest: z.ZodString;
+    targets: z.ZodArray<z.ZodObject<{
+        reader_target_ref: z.ZodString;
+        canonical_identity_ref: z.ZodString;
+        target_kind: z.ZodEffects<z.ZodString, string, string>;
+        landing_refs: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        canonical_identity_ref: string;
+        reader_target_ref: string;
+        target_kind: string;
+        landing_refs: string[];
+    }, {
+        canonical_identity_ref: string;
+        reader_target_ref: string;
+        target_kind: string;
+        landing_refs: string[];
+    }>, "many">;
+    projection_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.reader-target-projection/v1";
+    targets: {
+        canonical_identity_ref: string;
+        reader_target_ref: string;
+        target_kind: string;
+        landing_refs: string[];
+    }[];
+    projection_digest: string;
+    artifact_set_digest: string;
+}, {
+    protocol: "context.indexer.reader-target-projection/v1";
+    targets: {
+        canonical_identity_ref: string;
+        reader_target_ref: string;
+        target_kind: string;
+        landing_refs: string[];
+    }[];
+    projection_digest: string;
+    artifact_set_digest: string;
+}>;
+export type IndexerReaderTargetObservation = z.infer<typeof readerTargetIdentityObservationSchema>;
+export type IndexerReaderTargetFactInventory = z.infer<typeof indexerReaderTargetFactInventorySchema>;
+export type IndexerReaderTargetProjection = z.infer<typeof indexerReaderTargetProjectionSchema>;
+export interface IndexerReaderTargetObservationInput {
+    canonical_identity_ref: string;
+    observation_kind: typeof INDEXER_READER_TARGET_OBSERVATION_KINDS[number];
+    source_ref: string;
+    module_ref: string | null;
+    content_digest: string;
+    evidence_refs: readonly string[];
+}
+export interface IndexerReaderTargetProjectionInput {
+    canonical_identity_ref: string;
+    target_kind: string;
+    landing_refs: readonly string[];
+}
+export declare function indexerReaderTargetRef(canonicalIdentityRef: string): string;
+export declare function indexerReaderTargetObservationRef(input: Omit<IndexerReaderTargetObservation, "observation_ref" | "evidence_refs">): string;
+export declare function indexerReaderTargetFactInventoryDigest(value: Omit<IndexerReaderTargetFactInventory, "inventory_digest">): string;
+export declare function buildIndexerReaderTargetFactInventory(input: {
+    source_scope_digest: string;
+    observations: readonly IndexerReaderTargetObservationInput[];
+}): IndexerReaderTargetFactInventory;
+export declare function validateIndexerReaderTargetFactInventory(input: {
+    value: unknown;
+    expected_source_scope_digest?: string;
+    known_evidence_refs?: readonly string[];
+}): IndexerReaderTargetFactInventory;
+export declare function indexerReaderTargetProjectionDigest(value: Omit<IndexerReaderTargetProjection, "projection_digest">): string;
+export declare function buildIndexerReaderTargetProjection(input: {
+    artifact_set_digest: string;
+    targets: readonly IndexerReaderTargetProjectionInput[];
+}): IndexerReaderTargetProjection;
+export declare function validateIndexerReaderTargetProjection(valueInput: unknown): IndexerReaderTargetProjection;
+export {};

package/indexerReferenceOnlyAudit.d.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+export declare const indexerReferenceOnlyReaderTargetAuditSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.reference-only-reader-target-audit/v1">;
+    fact_inventory_digest: z.ZodString;
+    target_projection_digest: z.ZodString;
+    target_count: z.ZodNumber;
+    authoritative_target_count: z.ZodNumber;
+    reference_only_target_count: z.ZodNumber;
+    unsubstantiated_target_count: z.ZodNumber;
+    authoritative_target_refs: z.ZodArray<z.ZodString, "many">;
+    reference_only_target_refs: z.ZodArray<z.ZodString, "many">;
+    unsubstantiated_target_refs: z.ZodArray<z.ZodString, "many">;
+    metric: z.ZodObject<{
+        metric_id: z.ZodLiteral<"reference-only-reader-targets">;
+        unit: z.ZodLiteral<"count">;
+        actual: z.ZodNumber;
+        denominator: z.ZodNumber;
+        target_refs: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        target_refs: string[];
+        denominator: number;
+        unit: "count";
+        metric_id: "reference-only-reader-targets";
+        actual: number;
+    }, {
+        target_refs: string[];
+        denominator: number;
+        unit: "count";
+        metric_id: "reference-only-reader-targets";
+        actual: number;
+    }>;
+    pass: z.ZodBoolean;
+    audit_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.reference-only-reader-target-audit/v1";
+    audit_digest: string;
+    pass: boolean;
+    fact_inventory_digest: string;
+    target_projection_digest: string;
+    target_count: number;
+    authoritative_target_count: number;
+    reference_only_target_count: number;
+    unsubstantiated_target_count: number;
+    authoritative_target_refs: string[];
+    reference_only_target_refs: string[];
+    unsubstantiated_target_refs: string[];
+    metric: {
+        target_refs: string[];
+        denominator: number;
+        unit: "count";
+        metric_id: "reference-only-reader-targets";
+        actual: number;
+    };
+}, {
+    protocol: "context.indexer.reference-only-reader-target-audit/v1";
+    audit_digest: string;
+    pass: boolean;
+    fact_inventory_digest: string;
+    target_projection_digest: string;
+    target_count: number;
+    authoritative_target_count: number;
+    reference_only_target_count: number;
+    unsubstantiated_target_count: number;
+    authoritative_target_refs: string[];
+    reference_only_target_refs: string[];
+    unsubstantiated_target_refs: string[];
+    metric: {
+        target_refs: string[];
+        denominator: number;
+        unit: "count";
+        metric_id: "reference-only-reader-targets";
+        actual: number;
+    };
+}>;
+export type IndexerReferenceOnlyReaderTargetAudit = z.infer<typeof indexerReferenceOnlyReaderTargetAuditSchema>;
+export declare function indexerReferenceOnlyReaderTargetAuditDigest(value: Omit<IndexerReferenceOnlyReaderTargetAudit, "audit_digest">): string;
+export declare function buildIndexerReferenceOnlyReaderTargetAudit(input: {
+    fact_inventory: unknown;
+    target_projection: unknown;
+}): IndexerReferenceOnlyReaderTargetAudit;
+export declare function validateIndexerReferenceOnlyReaderTargetAudit(input: {
+    value: unknown;
+    fact_inventory: unknown;
+    target_projection: unknown;
+}): IndexerReferenceOnlyReaderTargetAudit;
+export declare function assertNoReferenceOnlyReaderTargets(input: {
+    value: unknown;
+    fact_inventory: unknown;
+    target_projection: unknown;
+}): IndexerReferenceOnlyReaderTargetAudit;