@usefragments/core 1.11.0 → 2.0.0

package/src/feature-plan/digest.ts

@@ -1,217 +0,0 @@
-import { canonicalPreimage, compareCanonicalStrings, sha256Hex } from "../contract/hash.js";
-import { featureRevisionIdFromDigest, type DigestHex } from "../domain-ids.js";
-import {
-  AGENT_FEATURE_CONTEXT_MAX_BYTES_V1,
-  agentFeatureContextV1Schema as structuralAgentFeatureContextV1Schema,
-  approvedFeatureManifestInputV1Schema,
-  approvedFeatureManifestV1Schema,
-  featureProposalInputV1Schema,
-  featureProposalV1Schema,
-  type AgentFeatureContextV1,
-  type ApprovedFeatureManifestInputV1,
-  type ApprovedFeatureManifestV1,
-  type FeatureProposalInputV1,
-  type FeatureProposalV1,
-} from "./types.js";
-
-const sortedUnique = (values: readonly string[]): string[] => [...new Set(values)].sort();
-
-function normalizeEvidenceRefs<T extends { evidenceRefIds: string[] }>(row: T): T {
-  return { ...row, evidenceRefIds: sortedUnique(row.evidenceRefIds) };
-}
-
-function normalizeCommon<
-  T extends {
-    placement: FeatureProposalInputV1["placement"];
-    componentUses: FeatureProposalInputV1["componentUses"];
-    tokenUses: FeatureProposalInputV1["tokenUses"];
-    patternUses: FeatureProposalInputV1["patternUses"];
-    layout: FeatureProposalInputV1["layout"];
-    responsive: FeatureProposalInputV1["responsive"];
-    scenarios: FeatureProposalInputV1["scenarios"];
-    gaps: FeatureProposalInputV1["gaps"];
-    acceptance: FeatureProposalInputV1["acceptance"];
-    evidenceRefs: FeatureProposalInputV1["evidenceRefs"];
-  },
->(value: T): T {
-  return {
-    ...value,
-    placement: normalizeEvidenceRefs(value.placement),
-    componentUses: value.componentUses
-      .map(normalizeEvidenceRefs)
-      .sort((left, right) => compareCanonicalStrings(left.useId, right.useId)),
-    tokenUses: value.tokenUses
-      .map(normalizeEvidenceRefs)
-      .sort((left, right) => compareCanonicalStrings(left.useId, right.useId)),
-    patternUses: value.patternUses
-      .map(normalizeEvidenceRefs)
-      .sort((left, right) => compareCanonicalStrings(left.useId, right.useId)),
-    layout: {
-      concerns: value.layout.concerns
-        .map(normalizeEvidenceRefs)
-        .sort((left, right) => compareCanonicalStrings(left.concern, right.concern)),
-    },
-    responsive: value.responsive
-      .map(normalizeEvidenceRefs)
-      .sort((left, right) => compareCanonicalStrings(left.decisionId, right.decisionId)),
-    scenarios: value.scenarios
-      .map((scenario) => ({ ...scenario, acceptanceIds: sortedUnique(scenario.acceptanceIds) }))
-      .sort((left, right) => compareCanonicalStrings(left.scenarioId, right.scenarioId)),
-    gaps: value.gaps
-      .map(normalizeEvidenceRefs)
-      .sort((left, right) => compareCanonicalStrings(left.gapId, right.gapId)),
-    acceptance: value.acceptance
-      .map(normalizeEvidenceRefs)
-      .sort((left, right) => compareCanonicalStrings(left.acceptanceId, right.acceptanceId)),
-    evidenceRefs: [...value.evidenceRefs].sort((left, right) =>
-      compareCanonicalStrings(left.evidenceId, right.evidenceId)
-    ),
-  };
-}
-
-export function normalizeFeatureProposalInputV1(
-  value: FeatureProposalInputV1
-): FeatureProposalInputV1 {
-  const parsed = featureProposalInputV1Schema.parse(value);
-  return normalizeCommon({
-    ...parsed,
-    questions: parsed.questions
-      .map((question) => ({ ...normalizeEvidenceRefs(question), options: [...question.options] }))
-      .sort((left, right) => compareCanonicalStrings(left.decisionId, right.decisionId)),
-  }) as FeatureProposalInputV1;
-}
-
-function proposalProjection(proposal: FeatureProposalInputV1): Record<string, unknown> {
-  return {
-    schema: "feature-revision.v1",
-    kind: proposal.kind,
-    planId: proposal.planId,
-    parentRevisionDigest: proposal.parentRevisionDigest,
-    pins: proposal.pins,
-    placement: proposal.placement,
-    componentUses: proposal.componentUses,
-    tokenUses: proposal.tokenUses,
-    patternUses: proposal.patternUses,
-    layout: proposal.layout,
-    responsive: proposal.responsive,
-    scenarios: proposal.scenarios,
-    gaps: proposal.gaps,
-    acceptance: proposal.acceptance,
-    questions: proposal.questions,
-    evidenceRefs: proposal.evidenceRefs,
-  };
-}
-
-export function featureProposalRevisionDigestV1(value: FeatureProposalInputV1): DigestHex {
-  const proposal = normalizeFeatureProposalInputV1(value);
-  return sha256Hex(canonicalPreimage(proposalProjection(proposal)));
-}
-
-export function buildFeatureProposalV1(value: FeatureProposalInputV1): FeatureProposalV1 {
-  const proposal = normalizeFeatureProposalInputV1(value);
-  const revisionDigest = sha256Hex(canonicalPreimage(proposalProjection(proposal)));
-  return featureProposalV1Schema.parse({
-    ...proposal,
-    revisionId: featureRevisionIdFromDigest(revisionDigest),
-    revisionDigest,
-  }) as FeatureProposalV1;
-}
-
-export function parseFeatureProposalV1(value: unknown): FeatureProposalV1 {
-  const parsed = featureProposalV1Schema.parse(value);
-  const { revisionId, revisionDigest, ...input } = parsed;
-  const rebuilt = buildFeatureProposalV1(input as FeatureProposalInputV1);
-  if (revisionId !== rebuilt.revisionId || revisionDigest !== rebuilt.revisionDigest) {
-    throw new TypeError("Feature proposal derived identity does not match its semantic projection");
-  }
-  return rebuilt;
-}
-
-export function normalizeApprovedFeatureManifestInputV1(
-  value: ApprovedFeatureManifestInputV1
-): ApprovedFeatureManifestInputV1 {
-  const parsed = approvedFeatureManifestInputV1Schema.parse(value);
-  return normalizeCommon({
-    ...parsed,
-    decisions: [...parsed.decisions].sort((left, right) =>
-      compareCanonicalStrings(left.decisionId, right.decisionId)
-    ),
-    approval: { ...parsed.approval },
-    validatedGrounding: { ...parsed.validatedGrounding },
-  }) as ApprovedFeatureManifestInputV1;
-}
-
-function manifestProjection(manifest: ApprovedFeatureManifestInputV1): Record<string, unknown> {
-  return {
-    schema: "feature-revision.v1",
-    kind: manifest.kind,
-    planId: manifest.planId,
-    parentRevisionDigest: manifest.parentRevisionDigest,
-    proposalRevisionDigest: manifest.proposalRevisionDigest,
-    pins: manifest.pins,
-    validatedGrounding: manifest.validatedGrounding,
-    placement: manifest.placement,
-    componentUses: manifest.componentUses,
-    tokenUses: manifest.tokenUses,
-    patternUses: manifest.patternUses,
-    layout: manifest.layout,
-    responsive: manifest.responsive,
-    scenarios: manifest.scenarios,
-    gaps: manifest.gaps,
-    acceptance: manifest.acceptance,
-    evidenceRefs: manifest.evidenceRefs,
-    decisions: manifest.decisions,
-    approval: {
-      approverUserId: manifest.approval.approverUserId,
-      decisionDigest: manifest.approval.decisionDigest,
-      expiresAt: manifest.approval.expiresAt,
-    },
-  };
-}
-
-export function approvedFeatureManifestRevisionDigestV1(
-  value: ApprovedFeatureManifestInputV1
-): DigestHex {
-  const manifest = normalizeApprovedFeatureManifestInputV1(value);
-  return sha256Hex(canonicalPreimage(manifestProjection(manifest)));
-}
-
-export function buildApprovedFeatureManifestV1(
-  value: ApprovedFeatureManifestInputV1
-): ApprovedFeatureManifestV1 {
-  const manifest = normalizeApprovedFeatureManifestInputV1(value);
-  const revisionDigest = sha256Hex(canonicalPreimage(manifestProjection(manifest)));
-  return approvedFeatureManifestV1Schema.parse({
-    ...manifest,
-    revisionId: featureRevisionIdFromDigest(revisionDigest),
-    revisionDigest,
-  }) as ApprovedFeatureManifestV1;
-}
-
-export function parseApprovedFeatureManifestV1(value: unknown): ApprovedFeatureManifestV1 {
-  const parsed = approvedFeatureManifestV1Schema.parse(value);
-  const { revisionId, revisionDigest, ...input } = parsed;
-  const rebuilt = buildApprovedFeatureManifestV1(input as ApprovedFeatureManifestInputV1);
-  if (revisionId !== rebuilt.revisionId || revisionDigest !== rebuilt.revisionDigest) {
-    throw new TypeError(
-      "Approved manifest derived identity does not match its semantic projection"
-    );
-  }
-  return rebuilt;
-}
-
-export const agentFeatureContextV1Schema = structuralAgentFeatureContextV1Schema.superRefine(
-  (value, context) => {
-    const bytes = new TextEncoder().encode(canonicalPreimage(value)).byteLength;
-    if (bytes > AGENT_FEATURE_CONTEXT_MAX_BYTES_V1) {
-      context.addIssue({
-        code: "custom",
-        message: `Agent feature context exceeds ${AGENT_FEATURE_CONTEXT_MAX_BYTES_V1} UTF-8 bytes`,
-      });
-    }
-  }
-);
-
-export function parseAgentFeatureContextV1(value: unknown): AgentFeatureContextV1 {
-  return agentFeatureContextV1Schema.parse(value) as AgentFeatureContextV1;
-}