fullstackgtm 0.10.0

package/src/demo.ts

@@ -0,0 +1,200 @@
+import type {
+  CanonicalAccount,
+  CanonicalActivity,
+  CanonicalContact,
+  CanonicalDeal,
+  CanonicalGtmSnapshot,
+  CanonicalUser,
+} from "./types.ts";
+
+export type DemoSnapshotOptions = {
+  /** PRNG seed; the same seed always produces the same snapshot. */
+  seed?: number;
+  /** Anchor date (YYYY-MM-DD) all relative dates derive from. */
+  today?: string;
+  accounts?: number;
+  deals?: number;
+};
+
+const FIRST_NAMES = [
+  "Ava", "Marcus", "Priya", "Diego", "Sofia", "Jordan",
+  "Mei", "Tomás", "Nia", "Ethan", "Lena", "Omar",
+];
+const LAST_NAMES = [
+  "Calloway", "Reyes", "Iyer", "Novak", "Bennett", "Okafor",
+  "Lindqvist", "Moreau", "Tanaka", "Whitfield", "Drummond", "Vargas",
+];
+const COMPANY_HEADS = [
+  "Halcyon", "Northwind", "Cobalt", "Ridgeline", "Lumen", "Vantage",
+  "Harbor", "Atlas", "Crestline", "Meridian", "Bluff", "Juniper",
+  "Granite", "Summit", "Beacon",
+];
+const COMPANY_TAILS = [
+  "Analytics", "Logistics", "Biotech", "Robotics", "Software",
+  "Manufacturing", "Health", "Financial", "Media", "Systems",
+  "Foods", "Energy", "Labs", "Dynamics",
+];
+const INDUSTRIES = [
+  "SaaS", "Logistics", "Healthcare", "Manufacturing", "Financial Services",
+  "Media", "Energy", "Retail",
+];
+const OPEN_STAGES = ["discovery", "qualification", "proposal", "negotiation"];
+const DEAL_LABELS = [
+  "Platform Subscription", "Enterprise Rollout", "Pilot Expansion",
+  "Renewal", "Multi-Year Agreement", "Team Upgrade", "Add-On Seats",
+];
+
+/** Deterministic PRNG (mulberry32) so demo data is stable across runs. */
+function mulberry32(seed: number) {
+  let state = seed >>> 0;
+  return () => {
+    state = (state + 0x6d2b79f5) >>> 0;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function shiftDate(today: string, days: number): string {
+  const base = Date.parse(`${today}T00:00:00Z`);
+  return new Date(base + days * 86_400_000).toISOString().slice(0, 10);
+}
+
+/**
+ * Generate a realistic, deliberately messy mid-market CRM snapshot.
+ *
+ * The mess is injected at fixed indices so audits over a given seed produce
+ * stable, testable findings, while the PRNG varies names, amounts, and dates:
+ * - every 8th account is an orphan (no contacts, no deals)
+ * - every 9th deal references a departed owner that no longer exists
+ * - every 11th deal lost its account association
+ * - open deals carry a realistic spread of past close dates and stale activity
+ */
+export function generateDemoSnapshot(options: DemoSnapshotOptions = {}): CanonicalGtmSnapshot {
+  const seed = options.seed ?? 7;
+  const today = options.today ?? "2026-06-09";
+  const accountCount = options.accounts ?? 56;
+  const dealCount = options.deals ?? 80;
+  const random = mulberry32(seed);
+  const pick = <T,>(items: T[]) => items[Math.floor(random() * items.length)];
+  const between = (min: number, max: number) => min + Math.floor(random() * (max - min + 1));
+
+  const users: CanonicalUser[] = FIRST_NAMES.map((firstName, index) => ({
+    id: `user_${String(index + 1).padStart(2, "0")}`,
+    provider: "mock",
+    crmId: `${9000 + index}`,
+    name: `${firstName} ${LAST_NAMES[index]}`,
+    email: `${firstName.toLowerCase()}.${LAST_NAMES[index].toLowerCase()}@example.com`,
+    title: index === 0 ? "VP Sales" : index === 1 ? "Sales Manager" : "Account Executive",
+    active: index < 10,
+  }));
+  const activeReps = users.slice(2, 10);
+
+  const accounts: CanonicalAccount[] = [];
+  for (let index = 0; index < accountCount; index += 1) {
+    const name = `${COMPANY_HEADS[index % COMPANY_HEADS.length]} ${pick(COMPANY_TAILS)}`;
+    accounts.push({
+      id: `acct_${String(index + 1).padStart(3, "0")}`,
+      provider: "mock",
+      crmId: `${10_000 + index}`,
+      name,
+      domain: `${name.toLowerCase().replace(/[^a-z]/g, "")}.com`,
+      industry: pick(INDUSTRIES),
+      ownerId: random() < 0.85 ? pick(activeReps).id : undefined,
+      employeeCount: between(40, 4000),
+      annualRevenue: between(2, 400) * 1_000_000,
+      lastSyncAt: shiftDate(today, -between(0, 3)),
+    });
+  }
+  const orphanAccountIds = new Set(
+    accounts.filter((_, index) => index % 8 === 0).map((account) => account.id),
+  );
+  const linkableAccounts = accounts.filter((account) => !orphanAccountIds.has(account.id));
+
+  const contacts: CanonicalContact[] = [];
+  for (const account of linkableAccounts) {
+    const count = between(1, 3);
+    for (let index = 0; index < count; index += 1) {
+      const firstName = pick(FIRST_NAMES);
+      const lastName = pick(LAST_NAMES);
+      contacts.push({
+        id: `contact_${String(contacts.length + 1).padStart(3, "0")}`,
+        provider: "mock",
+        crmId: `${20_000 + contacts.length}`,
+        accountId: account.id,
+        firstName,
+        lastName,
+        email: `${firstName.toLowerCase()}@${account.domain}`,
+        title: pick(["CTO", "VP Operations", "Head of RevOps", "Director of IT", "CFO"]),
+        ownerId: account.ownerId,
+        lastSyncAt: account.lastSyncAt,
+      });
+    }
+  }
+
+  const deals: CanonicalDeal[] = [];
+  const activities: CanonicalActivity[] = [];
+  for (let index = 0; index < dealCount; index += 1) {
+    const account = linkableAccounts[index % linkableAccounts.length];
+    const departedOwner = index % 9 === 0;
+    const unlinked = index % 11 === 0;
+    const stageRoll = random();
+    const stage =
+      stageRoll < 0.7 ? pick(OPEN_STAGES) : stageRoll < 0.88 ? "closedwon" : "closedlost";
+    const isWon = stage === "closedwon";
+    const isClosed = isWon || stage === "closedlost";
+    const closeDate = isClosed
+      ? shiftDate(today, -between(5, 120))
+      : shiftDate(today, between(-60, 150));
+    const daysSinceActivity = isClosed ? between(5, 60) : between(0, 75);
+    const lastActivityAt = shiftDate(today, -daysSinceActivity);
+
+    const deal: CanonicalDeal = {
+      id: `deal_${String(index + 1).padStart(3, "0")}`,
+      provider: "mock",
+      crmId: `${30_000 + index}`,
+      accountId: unlinked ? undefined : account.id,
+      ownerId: departedOwner ? `user_departed_${index % 2}` : (account.ownerId ?? pick(activeReps).id),
+      name: `${account.name} — ${pick(DEAL_LABELS)}`,
+      amount: between(8, 480) * 500,
+      currency: "USD",
+      stage,
+      closeDate,
+      forecastCategory: isWon ? "closed_won" : isClosed ? "closed_lost" : "pipeline",
+      probability: isClosed ? (isWon ? 1 : 0) : between(10, 80) / 100,
+      isClosed,
+      isWon,
+      lastActivityAt,
+      lastSyncAt: shiftDate(today, -between(0, 2)),
+    };
+    deals.push(deal);
+
+    const activityCount = Math.max(1, 3 - Math.floor(daysSinceActivity / 25));
+    for (let activityIndex = 0; activityIndex < activityCount; activityIndex += 1) {
+      activities.push({
+        id: `activity_${String(activities.length + 1).padStart(4, "0")}`,
+        provider: "mock",
+        dealId: deal.id,
+        accountId: deal.accountId,
+        ownerId: deal.ownerId,
+        type: pick(["call", "email", "meeting"] as const),
+        occurredAt: shiftDate(today, -(daysSinceActivity + activityIndex * between(3, 12))),
+        subject: pick([
+          "Discovery call", "Pricing discussion", "Security review",
+          "Champion sync", "Procurement follow-up", "Executive alignment",
+        ]),
+      });
+    }
+  }
+
+  return {
+    generatedAt: `${today}T00:00:00.000Z`,
+    provider: "mock",
+    users,
+    accounts,
+    contacts,
+    deals,
+    activities,
+  };
+}

package/src/diff.ts

@@ -0,0 +1,158 @@
+import type { AuditFinding, CanonicalGtmSnapshot, PatchPlan } from "./types.ts";
+
+/**
+ * Snapshot and audit drift. Record ids and finding ids are stable across
+ * runs, so two snapshots (or two plans) can be compared directly: what
+ * appeared, what disappeared, what changed — and whether hygiene regressed.
+ */
+
+// Fields that change on every sync without semantic meaning.
+const IGNORED_FIELDS = new Set(["raw", "lastSyncAt", "identities"]);
+
+export type FieldChange = { field: string; before: unknown; after: unknown };
+
+export type RecordChange = { id: string; label: string; changes: FieldChange[] };
+
+export type CollectionDiff = {
+  added: Array<{ id: string; label: string }>;
+  removed: Array<{ id: string; label: string }>;
+  changed: RecordChange[];
+};
+
+export type SnapshotDiff = {
+  before: { provider: string; generatedAt: string };
+  after: { provider: string; generatedAt: string };
+  users: CollectionDiff;
+  accounts: CollectionDiff;
+  contacts: CollectionDiff;
+  deals: CollectionDiff;
+  activities: CollectionDiff;
+};
+
+type AnyRecord = { id: string; name?: string; email?: string };
+
+function labelOf(record: AnyRecord): string {
+  return record.name ?? record.email ?? record.id;
+}
+
+function diffCollection(before: AnyRecord[], after: AnyRecord[]): CollectionDiff {
+  const beforeById = new Map(before.map((record) => [record.id, record]));
+  const afterById = new Map(after.map((record) => [record.id, record]));
+
+  const added = after
+    .filter((record) => !beforeById.has(record.id))
+    .map((record) => ({ id: record.id, label: labelOf(record) }));
+  const removed = before
+    .filter((record) => !afterById.has(record.id))
+    .map((record) => ({ id: record.id, label: labelOf(record) }));
+
+  const changed: RecordChange[] = [];
+  for (const record of after) {
+    const previous = beforeById.get(record.id);
+    if (!previous) continue;
+    const fields = new Set([...Object.keys(previous), ...Object.keys(record)]);
+    const changes: FieldChange[] = [];
+    for (const field of fields) {
+      if (IGNORED_FIELDS.has(field)) continue;
+      const beforeValue = (previous as Record<string, unknown>)[field];
+      const afterValue = (record as Record<string, unknown>)[field];
+      if (JSON.stringify(beforeValue) !== JSON.stringify(afterValue)) {
+        changes.push({ field, before: beforeValue ?? null, after: afterValue ?? null });
+      }
+    }
+    if (changes.length > 0) {
+      changed.push({ id: record.id, label: labelOf(record), changes });
+    }
+  }
+
+  return { added, removed, changed };
+}
+
+export function diffSnapshots(
+  before: CanonicalGtmSnapshot,
+  after: CanonicalGtmSnapshot,
+): SnapshotDiff {
+  return {
+    before: { provider: before.provider, generatedAt: before.generatedAt },
+    after: { provider: after.provider, generatedAt: after.generatedAt },
+    users: diffCollection(before.users, after.users),
+    accounts: diffCollection(before.accounts, after.accounts),
+    contacts: diffCollection(before.contacts, after.contacts),
+    deals: diffCollection(before.deals, after.deals),
+    activities: diffCollection(before.activities, after.activities),
+  };
+}
+
+export type FindingsDrift = {
+  newFindings: AuditFinding[];
+  resolvedFindings: AuditFinding[];
+  persistingCount: number;
+};
+
+/** Hygiene drift between two plans, keyed on stable finding ids. */
+export function diffFindings(before: PatchPlan, after: PatchPlan): FindingsDrift {
+  const beforeIds = new Set(before.findings.map((finding) => finding.id));
+  const afterIds = new Set(after.findings.map((finding) => finding.id));
+  return {
+    newFindings: after.findings.filter((finding) => !beforeIds.has(finding.id)),
+    resolvedFindings: before.findings.filter((finding) => !afterIds.has(finding.id)),
+    persistingCount: after.findings.filter((finding) => beforeIds.has(finding.id)).length,
+  };
+}
+
+export function diffToMarkdown(diff: SnapshotDiff, drift?: FindingsDrift): string {
+  const lines = [
+    "# Snapshot diff",
+    "",
+    `Before: ${diff.before.provider} @ ${diff.before.generatedAt}`,
+    `After: ${diff.after.provider} @ ${diff.after.generatedAt}`,
+    "",
+    "| Collection | Added | Removed | Changed |",
+    "| --- | --- | --- | --- |",
+  ];
+  for (const collection of ["users", "accounts", "contacts", "deals", "activities"] as const) {
+    const entry = diff[collection];
+    lines.push(
+      `| ${collection} | ${entry.added.length} | ${entry.removed.length} | ${entry.changed.length} |`,
+    );
+  }
+
+  for (const collection of ["users", "accounts", "contacts", "deals", "activities"] as const) {
+    const entry = diff[collection];
+    if (entry.added.length + entry.removed.length + entry.changed.length === 0) continue;
+    lines.push("", `## ${collection}`, "");
+    for (const record of entry.added) lines.push(`- added ${record.label} (${record.id})`);
+    for (const record of entry.removed) lines.push(`- removed ${record.label} (${record.id})`);
+    for (const record of entry.changed) {
+      lines.push(
+        `- changed ${record.label} (${record.id}): ${record.changes
+          .map((change) => `${change.field} ${formatValue(change.before)} → ${formatValue(change.after)}`)
+          .join("; ")}`,
+      );
+    }
+  }
+
+  if (drift) {
+    lines.push(
+      "",
+      "## Hygiene drift",
+      "",
+      `New findings: ${drift.newFindings.length}`,
+      `Resolved findings: ${drift.resolvedFindings.length}`,
+      `Persisting findings: ${drift.persistingCount}`,
+    );
+    for (const finding of drift.newFindings) {
+      lines.push(`- NEW [${finding.ruleId}] ${finding.summary}`);
+    }
+    for (const finding of drift.resolvedFindings) {
+      lines.push(`- resolved [${finding.ruleId}] ${finding.summary}`);
+    }
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function formatValue(value: unknown) {
+  if (value === undefined || value === null || value === "") return "∅";
+  return typeof value === "string" ? value : JSON.stringify(value);
+}

package/src/format.ts

@@ -0,0 +1,162 @@
+import type { PatchPlan, PatchPlanRun } from "./types.ts";
+
+export function patchPlanToMarkdown(plan: PatchPlan) {
+  const lines = [
+    `# ${plan.title}`,
+    "",
+    `Status: ${plan.status}`,
+    `Dry run: ${plan.dryRun ? "yes" : "no"}`,
+    `Summary: ${plan.summary}`,
+    "",
+  ];
+
+  if (plan.findings.length > 0) {
+    const byRule = new Map<string, { count: number; severity: string }>();
+    for (const finding of plan.findings) {
+      const entry = byRule.get(finding.ruleId) ?? { count: 0, severity: finding.severity };
+      entry.count += 1;
+      byRule.set(finding.ruleId, entry);
+    }
+    lines.push("## Findings by Rule", "", "| Rule | Findings | Severity |", "| --- | --- | --- |");
+    byRule.forEach((entry, ruleId) => {
+      lines.push(`| ${ruleId} | ${entry.count} | ${entry.severity} |`);
+    });
+    lines.push("");
+  }
+
+  lines.push("## Findings", "");
+
+  const findings = plan.pipelineFindings ?? [];
+  if (findings.length > 0) {
+    for (const finding of findings) {
+      lines.push(
+        `- **${finding.title}** (${finding.severity}, ${finding.status})`,
+        `  - Finding: ${finding.type}`,
+        `  - Object: ${finding.objectType}/${finding.objectId}`,
+        `  - Summary: ${finding.summary}`,
+        `  - Recommendation: ${finding.recommendation}`,
+        `  - Evidence refs: ${formatRefs(finding.evidenceIds)}`,
+        `  - Current CRM value: ${formatValue(finding.currentCrmValue)}`,
+        `  - Proposed value: ${formatValue(finding.proposedValue)}`,
+        `  - Source freshness: ${formatFreshness(finding.freshness)}`,
+        `  - Patch eligible: ${finding.patchEligibility.eligible ? "yes" : "no"} (${finding.patchEligibility.reason})`,
+      );
+    }
+    const pipelineFindingIds = new Set(findings.map((finding) => finding.id));
+    const otherFindings = plan.findings.filter((finding) => !pipelineFindingIds.has(finding.id));
+    if (otherFindings.length > 0) {
+      lines.push("", "### Other Findings", "");
+      for (const finding of otherFindings) {
+        lines.push(
+          `- **${finding.title}** (${finding.severity})`,
+          `  - Object: ${finding.objectType}/${finding.objectId}`,
+          `  - Rule: ${finding.ruleId}`,
+          `  - Summary: ${finding.summary}`,
+          `  - Recommendation: ${finding.recommendation}`,
+        );
+      }
+    }
+  } else if (plan.findings.length === 0) {
+    lines.push("No findings.");
+  } else {
+    for (const finding of plan.findings) {
+      lines.push(
+        `- **${finding.title}** (${finding.severity})`,
+        `  - Object: ${finding.objectType}/${finding.objectId}`,
+        `  - Rule: ${finding.ruleId}`,
+        `  - Summary: ${finding.summary}`,
+        `  - Recommendation: ${finding.recommendation}`,
+      );
+    }
+  }
+
+  if (plan.evidence && plan.evidence.length > 0) {
+    lines.push("", "## Evidence", "");
+    for (const evidence of plan.evidence) {
+      lines.push(
+        `- **${evidence.id}** ${evidence.sourceSystem}:${evidence.sourceObjectType}/${evidence.sourceObjectId}`,
+        `  - Object: ${evidence.objectType ?? "unknown"}/${evidence.objectId ?? "unknown"}`,
+        `  - Text: ${evidence.text}`,
+        `  - Freshness: ${evidence.freshness ? formatFreshness(evidence.freshness) : "unknown"}`,
+      );
+    }
+  }
+
+  lines.push("", "## Proposed Patch Operations", "");
+  if (plan.operations.length === 0) {
+    lines.push("No patch operations proposed.");
+  } else {
+    for (const operation of plan.operations) {
+      lines.push(
+        `- **${operation.operation}** ${operation.objectType}/${operation.objectId}`,
+        `  - ID: ${operation.id}`,
+        `  - Field/action: ${operation.field ?? operation.operation}`,
+        `  - Findings: ${formatRefs(operation.findingIds)}`,
+        `  - Evidence refs: ${formatRefs(operation.evidenceIds)}`,
+        `  - Before: ${formatValue(operation.beforeValue)}`,
+        `  - After: ${formatValue(operation.afterValue)}`,
+        `  - Reason: ${operation.reason}`,
+        `  - Source rule/policy: ${operation.sourceRuleOrPolicy ?? "unspecified"}`,
+        `  - Risk: ${operation.riskLevel}`,
+        `  - Approval required: ${operation.approvalRequired ? "yes" : "no"}`,
+        `  - Rollback: ${operation.rollback ?? "restore prior value if apply is rejected or verification fails"}`,
+        `  - Verification: ${formatVerification(operation.verification)}`,
+      );
+    }
+  }
+
+  lines.push(
+    "",
+    "> This prototype is dry-run only. Real CRM writes must require explicit human approval before connector adapters apply any operation.",
+  );
+  return `${lines.join("\n")}\n`;
+}
+
+export function formatPatchPlanRun(run: PatchPlanRun) {
+  const lines = [
+    `# Patch plan run`,
+    "",
+    `Plan: ${run.planId}`,
+    `Provider: ${run.provider}`,
+    `Status: ${run.status}`,
+    `Started: ${run.startedAt}`,
+    `Finished: ${run.finishedAt}`,
+    "",
+    "## Operation Results",
+    "",
+  ];
+  if (run.results.length === 0) {
+    lines.push("No operations were attempted.");
+  } else {
+    for (const result of run.results) {
+      lines.push(
+        `- **${result.status}** ${result.operationId}${result.detail ? ` — ${result.detail}` : ""}`,
+      );
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+function formatValue(value: unknown) {
+  if (value === undefined || value === null || value === "") return "unset";
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+
+function formatRefs(refs: string[] | undefined) {
+  return refs && refs.length > 0 ? refs.join(", ") : "none";
+}
+
+function formatFreshness(freshness: NonNullable<PatchPlan["pipelineFindings"]>[number]["freshness"]) {
+  const age = freshness.ageDays === undefined ? "age unknown" : `${freshness.ageDays}d old`;
+  const source = freshness.sourceUpdatedAt ? `source ${freshness.sourceUpdatedAt}` : "source date unknown";
+  return `${freshness.state}, ${age}, ${source}, checked ${freshness.checkedAt}`;
+}
+
+function formatVerification(verification: NonNullable<PatchPlan["operations"]>[number]["verification"]) {
+  if (!verification) return "not started";
+  const observed = verification.observedValue === undefined
+    ? ""
+    : `, observed ${formatValue(verification.observedValue)}`;
+  return `${verification.status}${observed}${verification.auditText ? ` (${verification.auditText})` : ""}`;
+}

package/src/index.ts

@@ -0,0 +1,129 @@
+export { auditSnapshot, defaultPolicy } from "./audit.ts";
+export {
+  CONFIG_FILE_NAME,
+  loadConfig,
+  mergePolicy,
+  resolveConfiguredRules,
+  type FullstackgtmConfig,
+  type LoadedConfig,
+} from "./config.ts";
+export { applyPatchPlan, type ApplyPatchPlanOptions } from "./connector.ts";
+export { createHubspotConnector, type HubspotConnectorOptions } from "./connectors/hubspot.ts";
+export {
+  DEFAULT_LOOPBACK_PORT,
+  DEFAULT_OAUTH_SCOPES,
+  exchangeHubspotCode,
+  refreshHubspotToken,
+  runHubspotLoopbackLogin,
+  validateHubspotToken,
+  type HubspotTokenSet,
+  type LoopbackLoginOptions,
+} from "./connectors/hubspotAuth.ts";
+export {
+  createSalesforceConnector,
+  type SalesforceConnection,
+  type SalesforceConnectorOptions,
+} from "./connectors/salesforce.ts";
+export {
+  pollSalesforceDeviceLogin,
+  refreshSalesforceToken,
+  startSalesforceDeviceLogin,
+  validateSalesforceToken,
+  type SalesforceDeviceAuthorization,
+  type SalesforceTokenSet,
+} from "./connectors/salesforceAuth.ts";
+export { createStripeConnector, type StripeConnectorOptions } from "./connectors/stripe.ts";
+export {
+  credentialsDir,
+  credentialsPath,
+  deleteCredential,
+  getCredential,
+  resolveHubspotAccessToken,
+  resolveHubspotConnection,
+  storeCredential,
+  type HubspotConnection,
+  type StoredCredential,
+} from "./credentials.ts";
+export { generateDemoSnapshot, type DemoSnapshotOptions } from "./demo.ts";
+export {
+  diffFindings,
+  diffSnapshots,
+  diffToMarkdown,
+  type CollectionDiff,
+  type FieldChange,
+  type FindingsDrift,
+  type RecordChange,
+  type SnapshotDiff,
+} from "./diff.ts";
+export {
+  mergeSnapshots,
+  type MergeConflict,
+  type MergeMatch,
+  type MergeReport,
+  type MergeSuggestion,
+} from "./merge.ts";
+export { createFilePlanStore, type PlanStore, type StoredPlan } from "./planStore.ts";
+export { formatPatchPlanRun, patchPlanToMarkdown } from "./format.ts";
+export {
+  HUBSPOT_DEFAULT_FIELD_MAPPINGS,
+  SALESFORCE_DEFAULT_FIELD_MAPPINGS,
+  mappedField,
+  mappedFields,
+  normalizeFieldMappings,
+  readMappedValue,
+  type CrmObjectType,
+  type FieldMappings,
+} from "./mappings.ts";
+export {
+  accountSingleSourceRule,
+  activeDealAccountWithoutContactsRule,
+  auditFindingId,
+  buildSnapshotIndex,
+  builtinAuditRules,
+  closingSoonInactiveRule,
+  duplicateAccountDomainRule,
+  duplicateContactEmailRule,
+  missingDealAccountRule,
+  missingDealAmountRule,
+  missingDealOwnerRule,
+  orphanAccountRule,
+  pastCloseDateRule,
+  patchOperationId,
+  requiresHumanInput,
+  staleDealRule,
+} from "./rules.ts";
+export { sampleSnapshot } from "./sampleData.ts";
+export type {
+  ApprovalStatus,
+  AuditFinding,
+  AuditFindingSeverity,
+  CanonicalAccount,
+  CanonicalActivity,
+  CanonicalContact,
+  CanonicalDeal,
+  CanonicalGtmSnapshot,
+  CanonicalUser,
+  CrmProvider,
+  GtmAuditRule,
+  GtmConnector,
+  GtmEvidence,
+  GtmEvidenceSourceSystem,
+  GtmObjectType,
+  GtmPolicy,
+  GtmRuleContext,
+  GtmRuleResult,
+  GtmSnapshotIndex,
+  PatchOperation,
+  PatchOperationResult,
+  PatchOperationType,
+  PatchPlan,
+  PatchPlanRun,
+  PatchPlanRunStatus,
+  PatchVerification,
+  PipelineFinding,
+  PipelineFindingStatus,
+  PipelineFindingType,
+  ProviderIdentity,
+  RiskLevel,
+  SourceFreshness,
+} from "./types.ts";