@c4a/context 0.6.18 → 0.7.0

package/indexerProjectedArtifactFanOutAudit.d.ts

@@ -0,0 +1,159 @@
+import { z } from "zod";
+export declare const INDEXER_PROJECTED_ARTIFACT_WARNING_THRESHOLD = 100;
+export declare const INDEXER_PROJECTED_ARTIFACT_REVISION_THRESHOLD = 300;
+declare const projectedArtifactDiagnosticSchema: z.ZodObject<{
+    projection_ref: z.ZodString;
+    projection_key: z.ZodString;
+    artifact_id: z.ZodEffects<z.ZodString, string, string>;
+    missing_requirements: z.ZodArray<z.ZodEnum<["logical-unit-owner", "bundle-variant", "evidence-justification"]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    artifact_id: string;
+    projection_ref: string;
+    projection_key: string;
+    missing_requirements: ("logical-unit-owner" | "bundle-variant" | "evidence-justification")[];
+}, {
+    artifact_id: string;
+    projection_ref: string;
+    projection_key: string;
+    missing_requirements: ("logical-unit-owner" | "bundle-variant" | "evidence-justification")[];
+}>;
+export declare const indexerProjectedArtifactFanOutAuditSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.projected-artifact-fan-out-audit/v1">;
+    partition_plan_hash: z.ZodString;
+    projected_artifact_plan_digest: z.ZodString;
+    artifact_bundle_set_digest: z.ZodString;
+    state: z.ZodEnum<["ready", "warning", "plan-revision-required"]>;
+    thresholds: z.ZodObject<{
+        warning_above: z.ZodLiteral<100>;
+        revision_above: z.ZodLiteral<300>;
+    }, "strict", z.ZodTypeAny, {
+        warning_above: 100;
+        revision_above: 300;
+    }, {
+        warning_above: 100;
+        revision_above: 300;
+    }>;
+    summary: z.ZodObject<{
+        projected_artifact_count: z.ZodNumber;
+        legally_assigned_artifact_count: z.ZodNumber;
+        unassigned_projected_artifact_count: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        projected_artifact_count: number;
+        legally_assigned_artifact_count: number;
+        unassigned_projected_artifact_count: number;
+    }, {
+        projected_artifact_count: number;
+        legally_assigned_artifact_count: number;
+        unassigned_projected_artifact_count: number;
+    }>;
+    unassigned_projection_refs_digest: z.ZodString;
+    diagnostic_sample: z.ZodArray<z.ZodObject<{
+        projection_ref: z.ZodString;
+        projection_key: z.ZodString;
+        artifact_id: z.ZodEffects<z.ZodString, string, string>;
+        missing_requirements: z.ZodArray<z.ZodEnum<["logical-unit-owner", "bundle-variant", "evidence-justification"]>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        artifact_id: string;
+        projection_ref: string;
+        projection_key: string;
+        missing_requirements: ("logical-unit-owner" | "bundle-variant" | "evidence-justification")[];
+    }, {
+        artifact_id: string;
+        projection_ref: string;
+        projection_key: string;
+        missing_requirements: ("logical-unit-owner" | "bundle-variant" | "evidence-justification")[];
+    }>, "many">;
+    diagnostic_sample_truncated: z.ZodBoolean;
+    candidate_materialization_allowed: z.ZodBoolean;
+    user_gate_required: z.ZodLiteral<false>;
+    profile_revision_ledger_consumed: z.ZodLiteral<false>;
+    outcome: z.ZodEnum<["projected-artifact-fan-out-current", "indexer-plan-revision-required"]>;
+    graph_outcome: z.ZodEnum<["completed", "partial"]>;
+} & {
+    audit_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.projected-artifact-fan-out-audit/v1";
+    thresholds: {
+        warning_above: 100;
+        revision_above: 300;
+    };
+    state: "warning" | "ready" | "plan-revision-required";
+    audit_digest: string;
+    partition_plan_hash: string;
+    outcome: "projected-artifact-fan-out-current" | "indexer-plan-revision-required";
+    user_gate_required: false;
+    profile_revision_ledger_consumed: false;
+    graph_outcome: "partial" | "completed";
+    summary: {
+        projected_artifact_count: number;
+        legally_assigned_artifact_count: number;
+        unassigned_projected_artifact_count: number;
+    };
+    projected_artifact_plan_digest: string;
+    artifact_bundle_set_digest: string;
+    unassigned_projection_refs_digest: string;
+    diagnostic_sample: {
+        artifact_id: string;
+        projection_ref: string;
+        projection_key: string;
+        missing_requirements: ("logical-unit-owner" | "bundle-variant" | "evidence-justification")[];
+    }[];
+    diagnostic_sample_truncated: boolean;
+    candidate_materialization_allowed: boolean;
+}, {
+    protocol: "context.indexer.projected-artifact-fan-out-audit/v1";
+    thresholds: {
+        warning_above: 100;
+        revision_above: 300;
+    };
+    state: "warning" | "ready" | "plan-revision-required";
+    audit_digest: string;
+    partition_plan_hash: string;
+    outcome: "projected-artifact-fan-out-current" | "indexer-plan-revision-required";
+    user_gate_required: false;
+    profile_revision_ledger_consumed: false;
+    graph_outcome: "partial" | "completed";
+    summary: {
+        projected_artifact_count: number;
+        legally_assigned_artifact_count: number;
+        unassigned_projected_artifact_count: number;
+    };
+    projected_artifact_plan_digest: string;
+    artifact_bundle_set_digest: string;
+    unassigned_projection_refs_digest: string;
+    diagnostic_sample: {
+        artifact_id: string;
+        projection_ref: string;
+        projection_key: string;
+        missing_requirements: ("logical-unit-owner" | "bundle-variant" | "evidence-justification")[];
+    }[];
+    diagnostic_sample_truncated: boolean;
+    candidate_materialization_allowed: boolean;
+}>;
+export type IndexerProjectedArtifactDiagnostic = z.infer<typeof projectedArtifactDiagnosticSchema>;
+export type IndexerProjectedArtifactFanOutAudit = z.infer<typeof indexerProjectedArtifactFanOutAuditSchema>;
+export declare function auditIndexerProjectedArtifactFanOut(input: {
+    partition_plan: unknown;
+    projected_artifact_plan: unknown;
+    artifact_bundles: readonly unknown[];
+    artifact_policy_eligibilities: readonly {
+        logical_unit_ref: string;
+        report: unknown;
+    }[];
+}): IndexerProjectedArtifactFanOutAudit;
+export declare function validateIndexerProjectedArtifactFanOutAudit(value: unknown): IndexerProjectedArtifactFanOutAudit;
+export declare function evaluateIndexerCandidateMaterialization(input: {
+    partition_plan: unknown;
+    projected_artifact_plan: unknown;
+    artifact_bundles: readonly unknown[];
+    artifact_policy_eligibilities: readonly {
+        logical_unit_ref: string;
+        report: unknown;
+    }[];
+}): {
+    audit: IndexerProjectedArtifactFanOutAudit;
+    can_materialize_candidate: boolean;
+    outcome: "projected-artifact-fan-out-current" | "indexer-plan-revision-required";
+    graph_outcome: "completed" | "partial";
+};
+export {};

package/indexerProjectedArtifactPlan.d.ts

@@ -0,0 +1,217 @@
+import { z } from "zod";
+declare const projectedArtifactOwnerSchema: z.ZodObject<{
+    kind: z.ZodEnum<["partition-group", "catalog-fallback"]>;
+    group_key: z.ZodString;
+    logical_unit_ref: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "catalog-fallback" | "partition-group";
+    logical_unit_ref: string;
+    group_key: string;
+}, {
+    kind: "catalog-fallback" | "partition-group";
+    logical_unit_ref: string;
+    group_key: string;
+}>;
+declare const projectedArtifactSchema: z.ZodObject<{
+    projection_ref: z.ZodString;
+    projection_key: z.ZodEffects<z.ZodString, string, string>;
+    artifact_id: z.ZodEffects<z.ZodString, string, string>;
+    artifact_kind: z.ZodEffects<z.ZodString, string, string>;
+    owner: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<["partition-group", "catalog-fallback"]>;
+        group_key: z.ZodString;
+        logical_unit_ref: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "catalog-fallback" | "partition-group";
+        logical_unit_ref: string;
+        group_key: string;
+    }, {
+        kind: "catalog-fallback" | "partition-group";
+        logical_unit_ref: string;
+        group_key: string;
+    }>>;
+    bundle_binding: z.ZodNullable<z.ZodObject<{
+        bundle_digest: z.ZodString;
+        artifact_policy_eligibility_digest: z.ZodString;
+        artifact_policy_variant: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        artifact_policy_variant: string;
+        bundle_digest: string;
+        artifact_policy_eligibility_digest: string;
+    }, {
+        artifact_policy_variant: string;
+        bundle_digest: string;
+        artifact_policy_eligibility_digest: string;
+    }>>;
+    evidence_justification_refs: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    artifact_kind: string;
+    artifact_id: string;
+    owner: {
+        kind: "catalog-fallback" | "partition-group";
+        logical_unit_ref: string;
+        group_key: string;
+    } | null;
+    projection_ref: string;
+    projection_key: string;
+    bundle_binding: {
+        artifact_policy_variant: string;
+        bundle_digest: string;
+        artifact_policy_eligibility_digest: string;
+    } | null;
+    evidence_justification_refs: string[];
+}, {
+    artifact_kind: string;
+    artifact_id: string;
+    owner: {
+        kind: "catalog-fallback" | "partition-group";
+        logical_unit_ref: string;
+        group_key: string;
+    } | null;
+    projection_ref: string;
+    projection_key: string;
+    bundle_binding: {
+        artifact_policy_variant: string;
+        bundle_digest: string;
+        artifact_policy_eligibility_digest: string;
+    } | null;
+    evidence_justification_refs: string[];
+}>;
+export declare const indexerProjectedArtifactPlanSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.projected-artifact-plan/v1">;
+    partition_workset_digest: z.ZodString;
+    partition_plan_hash: z.ZodString;
+    projected_artifacts: z.ZodArray<z.ZodObject<{
+        projection_ref: z.ZodString;
+        projection_key: z.ZodEffects<z.ZodString, string, string>;
+        artifact_id: z.ZodEffects<z.ZodString, string, string>;
+        artifact_kind: z.ZodEffects<z.ZodString, string, string>;
+        owner: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<["partition-group", "catalog-fallback"]>;
+            group_key: z.ZodString;
+            logical_unit_ref: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "catalog-fallback" | "partition-group";
+            logical_unit_ref: string;
+            group_key: string;
+        }, {
+            kind: "catalog-fallback" | "partition-group";
+            logical_unit_ref: string;
+            group_key: string;
+        }>>;
+        bundle_binding: z.ZodNullable<z.ZodObject<{
+            bundle_digest: z.ZodString;
+            artifact_policy_eligibility_digest: z.ZodString;
+            artifact_policy_variant: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            artifact_policy_variant: string;
+            bundle_digest: string;
+            artifact_policy_eligibility_digest: string;
+        }, {
+            artifact_policy_variant: string;
+            bundle_digest: string;
+            artifact_policy_eligibility_digest: string;
+        }>>;
+        evidence_justification_refs: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        artifact_kind: string;
+        artifact_id: string;
+        owner: {
+            kind: "catalog-fallback" | "partition-group";
+            logical_unit_ref: string;
+            group_key: string;
+        } | null;
+        projection_ref: string;
+        projection_key: string;
+        bundle_binding: {
+            artifact_policy_variant: string;
+            bundle_digest: string;
+            artifact_policy_eligibility_digest: string;
+        } | null;
+        evidence_justification_refs: string[];
+    }, {
+        artifact_kind: string;
+        artifact_id: string;
+        owner: {
+            kind: "catalog-fallback" | "partition-group";
+            logical_unit_ref: string;
+            group_key: string;
+        } | null;
+        projection_ref: string;
+        projection_key: string;
+        bundle_binding: {
+            artifact_policy_variant: string;
+            bundle_digest: string;
+            artifact_policy_eligibility_digest: string;
+        } | null;
+        evidence_justification_refs: string[];
+    }>, "many">;
+} & {
+    plan_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.projected-artifact-plan/v1";
+    partition_workset_digest: string;
+    partition_plan_hash: string;
+    plan_digest: string;
+    projected_artifacts: {
+        artifact_kind: string;
+        artifact_id: string;
+        owner: {
+            kind: "catalog-fallback" | "partition-group";
+            logical_unit_ref: string;
+            group_key: string;
+        } | null;
+        projection_ref: string;
+        projection_key: string;
+        bundle_binding: {
+            artifact_policy_variant: string;
+            bundle_digest: string;
+            artifact_policy_eligibility_digest: string;
+        } | null;
+        evidence_justification_refs: string[];
+    }[];
+}, {
+    protocol: "context.indexer.projected-artifact-plan/v1";
+    partition_workset_digest: string;
+    partition_plan_hash: string;
+    plan_digest: string;
+    projected_artifacts: {
+        artifact_kind: string;
+        artifact_id: string;
+        owner: {
+            kind: "catalog-fallback" | "partition-group";
+            logical_unit_ref: string;
+            group_key: string;
+        } | null;
+        projection_ref: string;
+        projection_key: string;
+        bundle_binding: {
+            artifact_policy_variant: string;
+            bundle_digest: string;
+            artifact_policy_eligibility_digest: string;
+        } | null;
+        evidence_justification_refs: string[];
+    }[];
+}>;
+export type IndexerProjectedArtifactOwner = z.infer<typeof projectedArtifactOwnerSchema>;
+export type IndexerProjectedArtifact = z.infer<typeof projectedArtifactSchema>;
+export type IndexerProjectedArtifactPlan = z.infer<typeof indexerProjectedArtifactPlanSchema>;
+export interface IndexerProjectedArtifactInput {
+    projection_key: string;
+    artifact_id: string;
+    artifact_kind: string;
+    owner?: IndexerProjectedArtifactOwner | null;
+    bundle_binding?: {
+        bundle_digest: string;
+        artifact_policy_eligibility_digest: string;
+        artifact_policy_variant: string;
+    } | null;
+    evidence_justification_refs?: readonly string[];
+}
+export declare function buildIndexerProjectedArtifactPlan(input: {
+    partition_workset_digest: string;
+    partition_plan_hash: string;
+    projected_artifacts: readonly IndexerProjectedArtifactInput[];
+}): IndexerProjectedArtifactPlan;
+export declare function validateIndexerProjectedArtifactPlan(value: unknown): IndexerProjectedArtifactPlan;
+export {};

package/indexerProtocolCommon.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const INDEXER_PROVIDER_MANIFEST_NAME = "context-indexer.yaml";
+export declare const DEFAULT_INDEXER_REGISTRY_PATH = "src/indexers.yaml";
+export declare const INDEXER_SEMANTIC_OPERATIONS: readonly ["main-index", "material-answer"];
+export type IndexerSemanticOperation = typeof INDEXER_SEMANTIC_OPERATIONS[number];
+export declare const INDEXER_COVERAGE_DOMAINS: readonly ["technical-structure", "public-contract", "business-semantics", "operations"];
+export type IndexerCoverageDomain = typeof INDEXER_COVERAGE_DOMAINS[number];
+export declare const INDEXER_EVIDENCE_KINDS: readonly ["code", "contract", "configuration", "documentation", "runbook", "decision-record", "test-result", "runtime-observation", "tool-snapshot"];
+export type IndexerEvidenceKind = typeof INDEXER_EVIDENCE_KINDS[number];
+export declare const INDEXER_LAYER_FRAGMENT_KINDS: readonly ["fact-enrichment", "template-variables", "derived-artifact-proposal"];
+export type IndexerLayerFragmentKind = typeof INDEXER_LAYER_FRAGMENT_KINDS[number];
+export declare const INDEXER_PROGRAM_CAPABILITIES: readonly ["source.read", "parser-facts.read", "indexer-result.write"];
+export type IndexerProgramCapability = typeof INDEXER_PROGRAM_CAPABILITIES[number];
+export declare const INDEXER_SUBJECT_DERIVATION_OPERATORS: readonly ["canonical-source-module-namespace", "canonical-service-namespace", "canonical-module-identity", "canonical-export-family"];
+export type IndexerSubjectDerivationOperator = typeof INDEXER_SUBJECT_DERIVATION_OPERATORS[number];
+export declare const INDEXER_SUBJECT_NORMALIZATIONS: readonly ["trim", "unicode-nfc", "preserve-case", "lowercase"];
+export type IndexerSubjectNormalization = typeof INDEXER_SUBJECT_NORMALIZATIONS[number];
+export declare const indexerDigestSchema: z.ZodString;
+export declare const indexerIdSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const indexerSnakeCaseIdSchema: z.ZodString;
+export declare const indexerSemverSchema: z.ZodString;
+export declare const indexerProtocolIdSchema: z.ZodString;
+export declare function isPortableIndexerPath(value: string): boolean;
+export declare const portableIndexerPathSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare function compareIndexerCanonicalText(left: string, right: string): number;
+export declare function canonicalIndexerJson(value: unknown): string;
+export declare function indexerProtocolDigest(value: unknown): string;
+export declare function formatIndexerSchemaIssues(issues: readonly z.ZodIssue[]): string;
+export declare function addDuplicateIssues(values: readonly string[], context: z.RefinementCtx, field: string): void;