@hraness/peopleblade 0.1.1 → 0.1.2

package/dist/cloud-sync-client.js

@@ -0,0 +1,1827 @@
+// @bun
+// src/local/cloud-sync-client.ts
+import { Effect as Effect3 } from "effect";
+
+// src/lib/contracts.ts
+import { createHash } from "crypto";
+import { z } from "zod";
+var enrichmentPolicyVersion = "identity-bound-claims-v15";
+var enrichmentPriorityPolicyVersion = "enrichment-value-v9";
+var exactProfileTitleOnlyEvidenceExcerpt = "Title-only result for the exact stored public profile URL; no page text was returned.";
+var sourceLabelSchema = z.enum([
+  "apple",
+  "beeper",
+  "gmail",
+  "google",
+  "imessage",
+  "instagram",
+  "linkedin",
+  "substack",
+  "telegram",
+  "whatsapp",
+  "x"
+]);
+var boundedText = (maximum) => z.string().trim().min(1).max(maximum);
+var nullableText = (maximum) => boundedText(maximum).nullable();
+var httpUrlSchema = z.url().max(4096).refine((value) => {
+  try {
+    const protocol = new URL(value).protocol;
+    return protocol === "https:" || protocol === "http:";
+  } catch {
+    return false;
+  }
+}, "URL must use HTTP or HTTPS");
+function isCanonicalBirthday(value) {
+  const match = /^(?:(\d{4})-|--)(\d{2})-(\d{2})$/u.exec(value);
+  if (match === null)
+    return false;
+  const year = match[1] === undefined ? 2000 : Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (year < 1 || year > 9999 || month < 1 || month > 12 || day < 1)
+    return false;
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return day <= days[month - 1];
+}
+var birthdaySchema = z.string().refine(isCanonicalBirthday, "Birthday must be a real canonical YYYY-MM-DD or --MM-DD date").nullable();
+var cloudEmailSchema = z.email().max(1024);
+var identityAnchorsSchema = z.discriminatedUnion("state", [
+  z.object({
+    state: z.literal("available"),
+    emails: z.array(cloudEmailSchema).max(100),
+    phones: z.array(boundedText(256)).max(100),
+    profileUrls: z.array(httpUrlSchema).max(100)
+  }).strict(),
+  z.object({ state: z.literal("unavailable") }).strict()
+]);
+var automaticEnrichmentSelectionSchema = z.object({
+  version: z.literal(1),
+  state: z.enum(["eligible", "blocked"])
+}).strict();
+var unavailableAutomaticEnrichmentSelectionSchema = z.object({
+  version: z.literal(0),
+  state: z.literal("unavailable")
+}).strict();
+var legacyEnrichmentInputSchema = z.object({
+  displayName: boundedText(1024),
+  emails: z.array(cloudEmailSchema).max(100),
+  phones: z.array(boundedText(256)).max(100),
+  organization: nullableText(1024),
+  title: nullableText(1024),
+  sources: z.array(sourceLabelSchema).max(16),
+  providerHandles: z.record(boundedText(128), boundedText(2048)).refine((value) => Object.keys(value).length <= 50, "providerHandles contains too many entries")
+}).strict();
+var enrichmentInputSchema = legacyEnrichmentInputSchema.extend({
+  enrichmentInputVersion: z.literal(2),
+  identityAnchors: identityAnchorsSchema
+}).strict();
+function enrichmentInputSha256(value) {
+  return sha256(canonicalJson(enrichmentInputSchema.parse({
+    displayName: value.displayName,
+    emails: value.emails,
+    phones: value.phones,
+    organization: value.organization,
+    title: value.title,
+    sources: value.sources,
+    providerHandles: value.providerHandles,
+    enrichmentInputVersion: value.enrichmentInputVersion,
+    identityAnchors: value.identityAnchors
+  })));
+}
+function legacyEnrichmentInputSha256(value) {
+  return sha256(canonicalJson(legacyEnrichmentInputSchema.parse({
+    displayName: value.displayName,
+    emails: value.emails,
+    phones: value.phones,
+    organization: value.organization,
+    title: value.title,
+    sources: value.sources,
+    providerHandles: value.providerHandles
+  })));
+}
+var legacyV1CloudContactSchema = z.object({
+  id: z.string().regex(/^[a-f0-9]{64}$/u),
+  localPersonId: z.string().regex(/^[1-9][0-9]{0,18}$/u),
+  displayName: boundedText(1024),
+  emails: z.array(cloudEmailSchema).max(100),
+  phones: z.array(boundedText(256)).max(100),
+  organization: nullableText(1024),
+  title: nullableText(1024),
+  birthday: birthdaySchema,
+  sources: z.array(sourceLabelSchema).max(16),
+  providerHandles: z.record(boundedText(128), boundedText(2048)).refine((value) => Object.keys(value).length <= 50, "providerHandles contains too many entries"),
+  interactionCount: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  reciprocal: z.boolean(),
+  firstInteractionAt: z.iso.datetime({ offset: true }).nullable(),
+  lastInteractionAt: z.iso.datetime({ offset: true }).nullable(),
+  updatedAt: z.iso.datetime({ offset: true }),
+  metadataSha256: z.string().regex(/^[a-f0-9]{64}$/u),
+  enrichmentInputSha256: z.string().regex(/^[a-f0-9]{64}$/u)
+}).strict();
+var legacyV0CloudContactSchema = legacyV1CloudContactSchema.omit({ enrichmentInputSha256: true }).strict();
+var legacyV2CloudContactSchema = legacyV1CloudContactSchema.extend({
+  enrichmentInputVersion: z.literal(2),
+  identityAnchors: identityAnchorsSchema
+}).strict().superRefine((contact, context) => {
+  if (contact.identityAnchors.state !== "available") {
+    context.addIssue({
+      code: "custom",
+      path: ["identityAnchors", "state"],
+      message: "Current sync contacts require available identity anchors"
+    });
+    return;
+  }
+  const emails = new Set(contact.emails);
+  const phones = new Set(contact.phones);
+  contact.identityAnchors.emails.forEach((email, index) => {
+    if (!emails.has(email))
+      context.addIssue({
+        code: "custom",
+        path: ["identityAnchors", "emails", index],
+        message: "Identity email anchor must also be an observed email"
+      });
+  });
+  contact.identityAnchors.phones.forEach((phone, index) => {
+    if (!phones.has(phone))
+      context.addIssue({
+        code: "custom",
+        path: ["identityAnchors", "phones", index],
+        message: "Identity phone anchor must also be an observed phone"
+      });
+  });
+});
+var cloudContactSchema = legacyV1CloudContactSchema.extend({
+  enrichmentInputVersion: z.literal(2),
+  identityAnchors: identityAnchorsSchema,
+  automaticEnrichmentSelection: automaticEnrichmentSelectionSchema
+}).strict().superRefine((contact, context) => {
+  if (contact.identityAnchors.state !== "available") {
+    context.addIssue({
+      code: "custom",
+      path: ["identityAnchors", "state"],
+      message: "Current sync contacts require available identity anchors"
+    });
+    return;
+  }
+  const emails = new Set(contact.emails);
+  const phones = new Set(contact.phones);
+  contact.identityAnchors.emails.forEach((email, index) => {
+    if (!emails.has(email))
+      context.addIssue({
+        code: "custom",
+        path: ["identityAnchors", "emails", index],
+        message: "Identity email anchor must also be an observed email"
+      });
+  });
+  contact.identityAnchors.phones.forEach((phone, index) => {
+    if (!phones.has(phone))
+      context.addIssue({
+        code: "custom",
+        path: ["identityAnchors", "phones", index],
+        message: "Identity phone anchor must also be an observed phone"
+      });
+  });
+});
+var quarantinedCloudContactSchema = legacyV1CloudContactSchema.extend({
+  enrichmentInputVersion: z.literal(2),
+  identityAnchors: z.object({ state: z.literal("unavailable") }).strict(),
+  automaticEnrichmentSelection: unavailableAutomaticEnrichmentSelectionSchema
+}).strict();
+var selectionQuarantinedCloudContactSchema = legacyV1CloudContactSchema.extend({
+  enrichmentInputVersion: z.literal(2),
+  identityAnchors: identityAnchorsSchema,
+  automaticEnrichmentSelection: unavailableAutomaticEnrichmentSelectionSchema
+}).strict().superRefine((contact, context) => {
+  if (contact.identityAnchors.state !== "available") {
+    context.addIssue({
+      code: "custom",
+      path: ["identityAnchors", "state"],
+      message: "Current sync contacts require available identity anchors"
+    });
+    return;
+  }
+  const emails = new Set(contact.emails);
+  const phones = new Set(contact.phones);
+  contact.identityAnchors.emails.forEach((email, index) => {
+    if (!emails.has(email))
+      context.addIssue({
+        code: "custom",
+        path: ["identityAnchors", "emails", index],
+        message: "Identity email anchor must also be an observed email"
+      });
+  });
+  contact.identityAnchors.phones.forEach((phone, index) => {
+    if (!phones.has(phone))
+      context.addIssue({
+        code: "custom",
+        path: ["identityAnchors", "phones", index],
+        message: "Identity phone anchor must also be an observed phone"
+      });
+  });
+});
+var syncStartSchema = z.object({
+  contactCount: z.number().int().min(0).max(1e6),
+  databaseFingerprint: z.string().regex(/^[a-f0-9]{64}$/u),
+  schemaVersion: z.number().int().min(1).max(1000),
+  resumeVersion: z.literal(1).optional()
+}).strict();
+var syncPageSchema = z.object({
+  snapshotId: z.uuid(),
+  ordinal: z.number().int().min(0).max(1e5),
+  contacts: z.array(cloudContactSchema).min(1).max(200)
+}).strict();
+function syncContactInputVersion(contact) {
+  if ("enrichmentInputVersion" in contact && contact.enrichmentInputVersion === 2)
+    return 2;
+  return "enrichmentInputSha256" in contact && typeof contact.enrichmentInputSha256 === "string" ? 1 : 0;
+}
+function syncSelectionVersion(contact) {
+  return "automaticEnrichmentSelection" in contact ? 1 : 0;
+}
+var serverSyncPageInputSchema = z.object({
+  snapshotId: z.uuid(),
+  ordinal: z.number().int().min(0).max(1e5),
+  contacts: z.array(z.union([
+    cloudContactSchema,
+    legacyV2CloudContactSchema,
+    legacyV1CloudContactSchema,
+    legacyV0CloudContactSchema
+  ])).min(1).max(200)
+}).strict().superRefine((input, context) => {
+  const coordinateVersions = new Set(input.contacts.map((contact) => `${syncContactInputVersion(contact)}:${syncSelectionVersion(contact)}`));
+  if (coordinateVersions.size !== 1) {
+    context.addIssue({
+      code: "custom",
+      path: ["contacts"],
+      message: "Sync page contacts must use one projection version."
+    });
+  }
+  input.contacts.forEach((contact, index) => {
+    const version = syncContactInputVersion(contact);
+    if (version === 0)
+      return;
+    const expected = version === 2 ? enrichmentInputSha256(contact) : legacyEnrichmentInputSha256(contact);
+    const actual = "enrichmentInputSha256" in contact ? contact.enrichmentInputSha256 : null;
+    if (actual !== expected)
+      context.addIssue({
+        code: "custom",
+        path: ["contacts", index, "enrichmentInputSha256"],
+        message: `Sync contact enrichment input hash is invalid for version ${version}`
+      });
+  });
+});
+var serverSyncPageSchema = serverSyncPageInputSchema.transform((input) => {
+  const inputVersion = syncContactInputVersion(input.contacts[0]);
+  const selectionVersion = syncSelectionVersion(input.contacts[0]);
+  return {
+    snapshotId: input.snapshotId,
+    ordinal: input.ordinal,
+    inputVersion,
+    selectionVersion,
+    legacyPayloadSha256: inputVersion === 2 && selectionVersion === 1 ? null : sha256(canonicalJson(input.contacts)),
+    contacts: input.contacts.map((contact) => {
+      if (inputVersion === 2 && selectionVersion === 1)
+        return cloudContactSchema.parse(contact);
+      if (inputVersion === 2)
+        return selectionQuarantinedCloudContactSchema.parse({
+          ...contact,
+          automaticEnrichmentSelection: { version: 0, state: "unavailable" }
+        });
+      const upgraded = {
+        ...contact,
+        enrichmentInputVersion: 2,
+        identityAnchors: { state: "unavailable" },
+        automaticEnrichmentSelection: { version: 0, state: "unavailable" }
+      };
+      return quarantinedCloudContactSchema.parse({
+        ...upgraded,
+        enrichmentInputSha256: enrichmentInputSha256(upgraded)
+      });
+    })
+  };
+});
+var syncFinishSchema = z.object({
+  snapshotId: z.uuid(),
+  pages: z.number().int().min(0).max(1e5),
+  contactCount: z.number().int().min(0).max(1e6)
+}).strict();
+var cliEnrichmentContactSchema = z.object({
+  localPersonId: z.string().regex(/^[1-9][0-9]{0,18}$/u),
+  enrichmentInputVersion: z.literal(2),
+  enrichmentInputSha256: z.string().regex(/^[a-f0-9]{64}$/u)
+}).strict();
+var legacyV1CliEnrichmentContactSchema = z.object({
+  localPersonId: z.string().regex(/^[1-9][0-9]{0,18}$/u),
+  enrichmentInputSha256: z.string().regex(/^[a-f0-9]{64}$/u)
+}).strict();
+var legacyV0CliEnrichmentContactSchema = z.object({
+  localPersonId: z.string().regex(/^[1-9][0-9]{0,18}$/u),
+  metadataSha256: z.string().regex(/^[a-f0-9]{64}$/u)
+}).strict();
+var serverCliEnrichmentContactSchema = z.union([
+  cliEnrichmentContactSchema,
+  legacyV1CliEnrichmentContactSchema,
+  legacyV0CliEnrichmentContactSchema
+]);
+function cliEnrichmentInputVersion(contact) {
+  if ("enrichmentInputVersion" in contact)
+    return 2;
+  return "enrichmentInputSha256" in contact ? 1 : 0;
+}
+var serverCliEnrichmentContactsSchema = z.array(serverCliEnrichmentContactSchema).min(1).max(100).refine((contacts) => new Set(contacts.map(cliEnrichmentInputVersion)).size === 1, "A CLI enrichment request must use one hash-coordinate version.");
+var cliEnrichmentPreviewSchema = z.object({
+  contacts: z.array(cliEnrichmentContactSchema).min(1).max(100)
+}).strict();
+var cliPrioritizedEnrichmentPreviewSchema = z.object({
+  requestedCount: z.number().int().min(1).max(100),
+  priorityPolicyVersion: z.literal(enrichmentPriorityPolicyVersion)
+}).strict();
+var serverCliEnrichmentPreviewSchema = z.object({
+  contacts: serverCliEnrichmentContactsSchema
+}).strict();
+var cliEnrichmentConfirmationTokenSchema = z.string().regex(/^[A-Za-z0-9_-]{43}$/u);
+var cliEnrichmentStartSchema = z.object({
+  previewId: z.uuid(),
+  confirmationToken: cliEnrichmentConfirmationTokenSchema,
+  contacts: z.array(cliEnrichmentContactSchema).min(1).max(100)
+}).strict();
+var serverCliEnrichmentStartSchema = z.object({
+  previewId: z.uuid(),
+  confirmationToken: cliEnrichmentConfirmationTokenSchema,
+  contacts: serverCliEnrichmentContactsSchema
+}).strict();
+var cliEnrichmentStatusSchema = z.object({
+  jobId: z.uuid()
+}).strict();
+var cliEnrichmentRevalidationSchema = z.object({
+  limit: z.number().int().min(1).max(100)
+}).strict();
+var cliEnrichmentRevalidationResponseSchema = z.object({
+  processed: z.number().int().min(0).max(100),
+  accepted: z.number().int().min(0).max(100),
+  rejected: z.number().int().min(0).max(100),
+  hasMore: z.boolean(),
+  targetPolicyVersion: z.literal(enrichmentPolicyVersion),
+  validationProfileSha256: z.string().regex(/^[a-f0-9]{64}$/u)
+}).strict().superRefine((value, context) => {
+  if (value.accepted + value.rejected !== value.processed) {
+    context.addIssue({
+      code: "custom",
+      message: "Accepted and rejected counts must equal the processed count.",
+      path: ["processed"]
+    });
+  }
+});
+var deviceStartSchema = z.object({
+  deviceName: boundedText(128),
+  tokenSha256: z.string().regex(/^[a-f0-9]{64}$/u)
+}).strict();
+var deviceCodeSchema = z.string().regex(/^[A-Za-z0-9_-]{64}$/u);
+var deviceStatusSchema = z.object({
+  deviceCode: deviceCodeSchema
+}).strict();
+var cloudDeviceIdSchema = z.uuid();
+var cloudDevicesRequestSchema = z.object({}).strict();
+var cloudDeviceRevokeRequestSchema = z.object({
+  deviceId: cloudDeviceIdSchema
+}).strict();
+var cloudDeviceSchema = z.object({
+  id: cloudDeviceIdSchema,
+  name: boundedText(128),
+  createdAt: z.iso.datetime({ offset: true }),
+  lastSeenAt: z.iso.datetime({ offset: true }),
+  revokedAt: z.iso.datetime({ offset: true }).nullable(),
+  current: z.boolean()
+}).strict();
+var cloudDevicesResponseSchema = z.object({
+  devices: z.array(cloudDeviceSchema).max(200)
+}).strict();
+var cloudDeviceRevokeResponseSchema = z.object({
+  deviceId: cloudDeviceIdSchema,
+  revokedAt: z.iso.datetime({ offset: true })
+}).strict();
+var enrichmentClaimSchema = z.object({
+  field: z.enum(["headline", "organization", "role", "location", "website", "publicEmail"]),
+  evidenceIndexes: z.array(z.number().int().min(0).max(4)).min(1).max(5)
+}).strict();
+var enrichmentOutputSchema = z.object({
+  identityMatch: z.enum(["confirmed", "possible", "insufficient"]),
+  identityEvidenceIndexes: z.array(z.number().int().min(0).max(4)).max(5),
+  confidence: z.number().int().min(0).max(100),
+  headline: nullableText(1024),
+  organization: nullableText(1024),
+  role: nullableText(1024),
+  location: nullableText(1024),
+  website: httpUrlSchema.nullable(),
+  publicEmail: z.email().max(1024).nullable(),
+  publicEmailEvidenceIndex: z.number().int().min(0).max(4).nullable(),
+  notes: z.string().trim().max(2000),
+  claims: z.array(enrichmentClaimSchema).max(24)
+}).strict();
+var enrichmentEvidenceReferenceSchema = z.object({
+  url: httpUrlSchema,
+  title: boundedText(1024),
+  excerpt: boundedText(4000),
+  kind: z.enum(["public_page", "provider_attestation"]).optional()
+}).strict();
+var enrichmentIdentitySubjectSchema = enrichmentInputSchema.pick({
+  displayName: true,
+  emails: true,
+  phones: true,
+  identityAnchors: true,
+  organization: true,
+  title: true,
+  providerHandles: true
+}).superRefine((subject, context) => {
+  if (subject.identityAnchors.state !== "available")
+    return;
+  const emails = new Set(subject.emails);
+  const phones = new Set(subject.phones);
+  subject.identityAnchors.emails.forEach((email, index) => {
+    if (!emails.has(email))
+      context.addIssue({
+        code: "custom",
+        path: ["identityAnchors", "emails", index],
+        message: "Identity email anchor must also be an observed email"
+      });
+  });
+  subject.identityAnchors.phones.forEach((phone, index) => {
+    if (!phones.has(phone))
+      context.addIssue({
+        code: "custom",
+        path: ["identityAnchors", "phones", index],
+        message: "Identity phone anchor must also be an observed phone"
+      });
+  });
+});
+var enrichmentEvidenceRecordSchema = enrichmentEvidenceReferenceSchema.extend({
+  sourceId: boundedText(2048)
+}).strict();
+var publicEvidenceSchema = enrichmentEvidenceReferenceSchema.omit({ kind: true }).strict();
+var manualResearchSchema = enrichmentOutputSchema.extend({
+  evidence: z.array(publicEvidenceSchema).max(5)
+}).strict();
+function normalizedEvidenceText(value) {
+  return value.normalize("NFKC").toLocaleLowerCase("en-US").replaceAll(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+var LATIN_IDENTITY_FOLDABLE_MARKS = new Set([
+  ..."\u0300\u0301\u0302\u0303\u0304\u0306\u0307\u0308\u0309\u030A\u030B\u030C\u030F\u0311\u031B" + "\u0323\u0324\u0325\u0326\u0327\u0328\u032D\u032E\u0330\u0331"
+]);
+var HISTORICAL_PROFESSIONAL_MARKERS = new Set([
+  "alum",
+  "alumni",
+  "ceased",
+  "departed",
+  "down",
+  "emeritus",
+  "ended",
+  "ex",
+  "exited",
+  "former",
+  "formerly",
+  "left",
+  "past",
+  "previous",
+  "previously",
+  "quit",
+  "resigned",
+  "retired",
+  "sold",
+  "stepped",
+  "switched",
+  "until",
+  "was",
+  "were"
+]);
+var CURRENT_PROFESSIONAL_MARKERS = new Set([
+  "are",
+  "current",
+  "currently",
+  "is",
+  "now",
+  "present",
+  "presently",
+  "serves",
+  "works"
+]);
+var RESIDENCE_LOCATION_MARKERS = new Set([
+  "base",
+  "based",
+  "home",
+  "lives",
+  "located",
+  "location",
+  "residence",
+  "resident",
+  "resides"
+]);
+var EVENT_LOCATION_MARKERS = new Set([
+  "conference",
+  "conferences",
+  "event",
+  "events",
+  "keynote",
+  "keynotes",
+  "meetup",
+  "meetups",
+  "panel",
+  "panels",
+  "presented",
+  "presenting",
+  "presentation",
+  "speaker",
+  "speakers",
+  "speaking",
+  "spoke",
+  "summit",
+  "summits",
+  "talk",
+  "talks",
+  "workshop",
+  "workshops"
+]);
+var NON_PERSON_LOCATION_MARKERS = new Set([
+  "branch",
+  "branches",
+  "business",
+  "businesses",
+  "company",
+  "companies",
+  "employer",
+  "headquarters",
+  "hq",
+  "office",
+  "offices",
+  "organization",
+  "organisations",
+  "organizations",
+  "startup",
+  "startups",
+  "team",
+  "teams",
+  "venue",
+  "venues"
+]);
+var HISTORICAL_LOCATION_MARKERS = new Set([
+  "ex",
+  "former",
+  "formerly",
+  "once",
+  "past",
+  "previous",
+  "previously",
+  "used",
+  "was",
+  "were"
+]);
+var LOCATION_COPULA_AND_MODIFIERS = new Set([
+  "are",
+  "current",
+  "currently",
+  "is",
+  "now",
+  "presently"
+]);
+var PERSON_LOCATION_PRONOUNS = new Set(["he", "she", "they"]);
+var LOCATION_RELATION_GLUE = new Set(["at", "for", "in", "is", "of", "to"]);
+var LOCATION_SUPERSESSION_MARKERS = new Set([
+  "departed",
+  "left",
+  "moved",
+  "relocated",
+  "relocating",
+  "vacated"
+]);
+var PROFESSIONAL_EVENT_MARKERS = new Set([
+  "attended",
+  "attending",
+  "conference",
+  "dinner",
+  "event",
+  "game",
+  "guest",
+  "hosted",
+  "interviewed",
+  "keynote",
+  "lunch",
+  "meet",
+  "meeting",
+  "met",
+  "panel",
+  "presented",
+  "presenting",
+  "speaker",
+  "speaking",
+  "spoke",
+  "summit",
+  "talk",
+  "venue",
+  "visited",
+  "visiting",
+  "webinar",
+  "workshop"
+]);
+var NON_EMPLOYMENT_RELATION_MARKERS = new Set([
+  "candidate",
+  "client",
+  "competitor",
+  "critic",
+  "criticized",
+  "customer",
+  "grant",
+  "grantee",
+  "invested",
+  "investor",
+  "invests",
+  "received",
+  "sponsor",
+  "sponsored",
+  "vendor"
+]);
+var SIMPLE_AFFILIATION_GLUE = new Set([
+  "a",
+  "an",
+  "as",
+  "at",
+  "current",
+  "currently",
+  "is",
+  "the"
+]);
+var PROFESSIONAL_ROLE_MARKERS = new Set([
+  "chief",
+  "cofounder",
+  "director",
+  "employee",
+  "founder",
+  "lead",
+  "leader",
+  "member",
+  "owner",
+  "partner",
+  "president",
+  "principal"
+]);
+var PROFESSIONAL_RELATION_BOUNDARIES = new Set(["and", "but", "then", "while"]);
+var PROFESSIONAL_RELATION_MODIFIERS = new Set(["current", "currently", "now", "presently"]);
+var ORGANIZATION_SUFFIX_DISQUALIFIERS = new Set([
+  "alum",
+  "alumni",
+  "candidate",
+  "client",
+  "competitor",
+  "critic",
+  "customer",
+  "guest",
+  "investee",
+  "investor",
+  "sponsor",
+  "vendor"
+]);
+var ROLE_SUFFIX_DISQUALIFIERS = new Set([
+  "alum",
+  "alumni",
+  "aspirant",
+  "candidate",
+  "emeritus",
+  "impersonator",
+  "nominee",
+  "pretender"
+]);
+var PROFESSIONAL_SUBJECT_PRONOUNS = new Set(["he", "her", "his", "she", "their", "they"]);
+var CURRENT_PROFESSIONAL_CLAUSE_MARKERS = new Set([
+  "appointed",
+  "are",
+  "employed",
+  "founded",
+  "is",
+  "joined",
+  "leads",
+  "named",
+  "owns",
+  "serves",
+  "serving",
+  "works",
+  "working"
+]);
+var ROLE_EMAIL_LOCAL_PARTS = new Set([
+  "abuse",
+  "accounts",
+  "admin",
+  "admissions",
+  "assistant",
+  "billing",
+  "careers",
+  "community",
+  "connect",
+  "contact",
+  "contactus",
+  "customerservice",
+  "events",
+  "finance",
+  "general",
+  "hello",
+  "help",
+  "hr",
+  "info",
+  "inquiries",
+  "investors",
+  "jobs",
+  "legal",
+  "mail",
+  "marketing",
+  "media",
+  "newsletter",
+  "noreply",
+  "office",
+  "operations",
+  "ops",
+  "partners",
+  "postmaster",
+  "press",
+  "privacy",
+  "reception",
+  "sales",
+  "security",
+  "support",
+  "team",
+  "webmaster"
+]);
+var PROFILE_IDENTITY_LINK_NEGATIONS = new Set([
+  "aint",
+  "alleged",
+  "allegedly",
+  "arent",
+  "cannot",
+  "cant",
+  "couldnt",
+  "criticized",
+  "denied",
+  "denies",
+  "different",
+  "disassociated",
+  "disavowed",
+  "disavows",
+  "disclaimed",
+  "disclaims",
+  "didnt",
+  "doesnt",
+  "dont",
+  "fake",
+  "fan",
+  "fraudulent",
+  "hadnt",
+  "hasnt",
+  "havent",
+  "impersonator",
+  "incorrect",
+  "isnt",
+  "lacked",
+  "lacking",
+  "lacks",
+  "mirror",
+  "misattributed",
+  "mistaken",
+  "neither",
+  "never",
+  "no",
+  "nor",
+  "not",
+  "parody",
+  "purported",
+  "satire",
+  "shant",
+  "shouldnt",
+  "supposed",
+  "unaffiliated",
+  "unassociated",
+  "unconnected",
+  "unofficial",
+  "unrelated",
+  "wasnt",
+  "werent",
+  "without",
+  "wont",
+  "wouldnt",
+  "wrong",
+  "zero"
+]);
+var PROFILE_IDENTITY_NEGATED_AUXILIARY_STEMS = new Set([
+  "ain",
+  "aren",
+  "can",
+  "couldn",
+  "didn",
+  "doesn",
+  "don",
+  "hadn",
+  "hasn",
+  "haven",
+  "isn",
+  "mightn",
+  "mustn",
+  "needn",
+  "shan",
+  "shouldn",
+  "wasn",
+  "weren",
+  "won",
+  "wouldn"
+]);
+var PROFILE_IDENTITY_CURRENT_PREFIX_TOKENS = new Set([
+  "a",
+  "an",
+  "current",
+  "currently",
+  "now",
+  "present",
+  "presently",
+  "the"
+]);
+var PROFILE_IDENTITY_PROFESSIONAL_ROLE_TOKENS = new Set([
+  "advisor",
+  "analyst",
+  "architect",
+  "attorney",
+  "ceo",
+  "cfo",
+  "chief",
+  "cofounder",
+  "consultant",
+  "cto",
+  "designer",
+  "developer",
+  "director",
+  "employee",
+  "engineer",
+  "executive",
+  "founder",
+  "investor",
+  "lead",
+  "leader",
+  "manager",
+  "member",
+  "officer",
+  "owner",
+  "partner",
+  "president",
+  "principal",
+  "professor",
+  "researcher",
+  "scientist"
+]);
+var PROFILE_IDENTITY_EMPLOYMENT_CONTINUATION_STARTS = new Set([
+  "appointed",
+  "employed",
+  "founded",
+  "joined",
+  "leads",
+  "named",
+  "owns",
+  "serves",
+  "serving",
+  "works",
+  "working"
+]);
+var PROFILE_IDENTITY_LOCATION_CONTINUATION_STARTS = new Set([
+  "base",
+  "based",
+  "lives",
+  "located",
+  "location",
+  "residence",
+  "resident",
+  "resides"
+]);
+var PROFILE_IDENTITY_SUBJECT_CONTINUATION_DISQUALIFIERS = new Set([
+  "another",
+  "association",
+  "belongs",
+  "by",
+  "client",
+  "colleague",
+  "connection",
+  "created",
+  "discussed",
+  "else",
+  "follows",
+  "impersonator",
+  "mentioned",
+  "owned",
+  "recommends",
+  "redirected",
+  "redirects",
+  "someone",
+  "used",
+  "uses"
+]);
+var WEBSITE_ATTRIBUTION_NEGATIONS = new Set([
+  "criticized",
+  "denied",
+  "fake",
+  "fraudulent",
+  "impersonator",
+  "not",
+  "unofficial",
+  "unrelated"
+]);
+var TIER_ONE_ROLE_NOUNS = new Set([
+  "accountant",
+  "administrator",
+  "adviser",
+  "advisor",
+  "analyst",
+  "architect",
+  "artist",
+  "associate",
+  "attorney",
+  "author",
+  "builder",
+  "chair",
+  "chairman",
+  "chairperson",
+  "chief",
+  "clinician",
+  "coach",
+  "commissioner",
+  "consultant",
+  "controller",
+  "coordinator",
+  "counsel",
+  "creator",
+  "cto",
+  "ceo",
+  "cfo",
+  "cio",
+  "cmo",
+  "coo",
+  "dean",
+  "designer",
+  "developer",
+  "director",
+  "editor",
+  "engineer",
+  "entrepreneur",
+  "evangelist",
+  "executive",
+  "fellow",
+  "founder",
+  "head",
+  "investor",
+  "lead",
+  "leader",
+  "lecturer",
+  "manager",
+  "member",
+  "officer",
+  "operator",
+  "owner",
+  "partner",
+  "physician",
+  "president",
+  "principal",
+  "producer",
+  "professor",
+  "recruiter",
+  "researcher",
+  "scientist",
+  "specialist",
+  "strategist",
+  "supervisor",
+  "svp",
+  "trustee",
+  "vp"
+]);
+var TIER_ONE_ROLE_WORDS = new Set([
+  ...TIER_ONE_ROLE_NOUNS,
+  "acquisition",
+  "ai",
+  "artificial",
+  "assistant",
+  "banking",
+  "board",
+  "business",
+  "clinical",
+  "commercial",
+  "community",
+  "co",
+  "creative",
+  "customer",
+  "data",
+  "design",
+  "development",
+  "digital",
+  "engineering",
+  "executive",
+  "finance",
+  "financial",
+  "founding",
+  "fractional",
+  "general",
+  "global",
+  "growth",
+  "independent",
+  "intelligence",
+  "investment",
+  "i",
+  "ii",
+  "iii",
+  "iv",
+  "junior",
+  "legal",
+  "learning",
+  "machine",
+  "managing",
+  "marketing",
+  "medical",
+  "operations",
+  "people",
+  "product",
+  "program",
+  "project",
+  "regional",
+  "research",
+  "sales",
+  "security",
+  "senior",
+  "site",
+  "software",
+  "staff",
+  "strategy",
+  "strategic",
+  "success",
+  "talent",
+  "technical",
+  "technology",
+  "ux",
+  "venture",
+  "vice",
+  "reliability",
+  "policy",
+  "system",
+  "systems",
+  "and",
+  "for",
+  "of"
+]);
+var TIER_ONE_CONTROL_TOKENS = new Set([
+  "directive",
+  "directives",
+  "disregard",
+  "ignore",
+  "instruction",
+  "instructions",
+  "jailbreak",
+  "override",
+  "prompt",
+  "prompts",
+  "rule",
+  "rules"
+]);
+var PROFESSIONAL_CONTROL_VERBS = new Set([
+  "act",
+  "answer",
+  "assert",
+  "assume",
+  "change",
+  "choose",
+  "claim",
+  "classify",
+  "consider",
+  "declare",
+  "deem",
+  "disclose",
+  "emit",
+  "expose",
+  "extract",
+  "follow",
+  "forget",
+  "imagine",
+  "label",
+  "leak",
+  "list",
+  "make",
+  "mark",
+  "obey",
+  "output",
+  "pretend",
+  "print",
+  "produce",
+  "provide",
+  "record",
+  "regard",
+  "remember",
+  "replace",
+  "reply",
+  "report",
+  "respond",
+  "return",
+  "reveal",
+  "say",
+  "send",
+  "set",
+  "show",
+  "state",
+  "suppose",
+  "treat",
+  "use",
+  "write"
+]);
+var PROFESSIONAL_CONTROL_TARGETS = new Set([
+  "above",
+  "accordingly",
+  "all",
+  "answer",
+  "authoritative",
+  "claim",
+  "claims",
+  "command",
+  "commands",
+  "contact",
+  "contacts",
+  "correct",
+  "data",
+  "email",
+  "emails",
+  "every",
+  "everything",
+  "extractor",
+  "extractors",
+  "following",
+  "follows",
+  "hidden",
+  "message",
+  "messages",
+  "name",
+  "names",
+  "notice",
+  "extracted",
+  "organization",
+  "organizations",
+  "person",
+  "previous",
+  "response",
+  "responses",
+  "role",
+  "roles",
+  "secret",
+  "secrets",
+  "sentence",
+  "statement",
+  "system",
+  "task",
+  "text",
+  "this",
+  "true",
+  "trusted",
+  "value",
+  "values",
+  "below"
+]);
+var PROFESSIONAL_CONTROL_CLAUSE_INITIAL_VERBS = new Set([
+  "answer",
+  "assert",
+  "assume",
+  "change",
+  "choose",
+  "claim",
+  "classify",
+  "consider",
+  "declare",
+  "deem",
+  "disregard",
+  "emit",
+  "extract",
+  "forget",
+  "ignore",
+  "imagine",
+  "label",
+  "list",
+  "make",
+  "mark",
+  "obey",
+  "output",
+  "pretend",
+  "print",
+  "produce",
+  "provide",
+  "record",
+  "regard",
+  "remember",
+  "replace",
+  "reply",
+  "report",
+  "respond",
+  "return",
+  "reveal",
+  "say",
+  "set",
+  "state",
+  "suppose",
+  "treat",
+  "use",
+  "write"
+]);
+var TIER_ONE_ROLE_CONNECTORS = new Set(["and", "for", "of"]);
+var GENERIC_PROFESSIONAL_DEPARTURE_TARGETS = new Set([
+  "a",
+  "an",
+  "business",
+  "company",
+  "employer",
+  "employment",
+  "firm",
+  "her",
+  "his",
+  "its",
+  "job",
+  "organization",
+  "position",
+  "role",
+  "startup",
+  "team",
+  "that",
+  "the",
+  "their",
+  "this"
+]);
+var IDENTITY_GRADE_CONTENT_FREE_TEXT = new Set([
+  "directory listing",
+  "identity confirmation",
+  "identity verified",
+  "known contact",
+  "known identity",
+  "no additional structured facts",
+  "no structured facts",
+  "profile",
+  "profile page",
+  "professional profile",
+  "public directory listing",
+  "public profile",
+  "public professional profile",
+  "verified",
+  "verified contact",
+  "verified identity",
+  "verified profile",
+  normalizedEvidenceText(exactProfileTitleOnlyEvidenceExcerpt)
+]);
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+// src/local/cloud-configuration.ts
+import { z as z3 } from "zod";
+
+// src/local/config.ts
+import { closeSync, constants, existsSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { z as z2 } from "zod";
+
+// src/local/paths.ts
+import { homedir, hostname, platform } from "os";
+import { join } from "path";
+function peoplebladeDirectory() {
+  if (platform() === "darwin")
+    return join(homedir(), "Library", "Application Support", "PeopleBlade");
+  if (platform() === "win32")
+    return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "PeopleBlade");
+  return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "peopleblade");
+}
+function peoplebladeConfigPath() {
+  return join(peoplebladeDirectory(), "config.json");
+}
+
+// src/local/config.ts
+var configSchema = z2.object({
+  cloud: z2.object({
+    baseUrl: z2.url().max(2048),
+    deviceId: z2.uuid(),
+    token: z2.string().min(20).max(512)
+  }).strict().nullable()
+}).strict();
+function readLocalConfig() {
+  const path = peoplebladeConfigPath();
+  if (!existsSync(path))
+    return { cloud: null };
+  return configSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+}
+
+// src/local/cloud-configuration.ts
+var cloudConfigurationSchema = z3.object({
+  baseUrl: z3.url().max(2048),
+  deviceId: z3.uuid(),
+  token: z3.string().min(20).max(512)
+}).strict();
+function cloudConfiguration(override) {
+  const config = override ?? readLocalConfig().cloud;
+  if (config === null)
+    throw new Error("Run `peopleblade cloud signin` first.");
+  return cloudConfigurationSchema.parse(config);
+}
+
+// src/local/contact-read-model.ts
+var canonicalInteractionRollupCtesSql = `
+  canonical_interaction_inputs AS (
+    SELECT member.canonical_person_id AS person_id,
+      metric.provider,
+      CASE WHEN metric.provider = 'beeper'
+        THEN coalesce(metric_realm.service, metric.provider) ELSE metric.provider END AS logical_service,
+      CASE WHEN metric.provider = 'beeper'
+        THEN 'beeper' ELSE 'direct' END AS source_lane,
+      metric.interaction_count,
+      metric.reciprocal,
+      metric.first_interaction_at,
+      metric.last_interaction_at
+    FROM interaction_metrics metric
+    JOIN person_identity_components member ON member.person_id = metric.person_id
+    LEFT JOIN source_realms metric_realm
+      ON metric_realm.authority = metric.provider AND metric_realm.account_key = metric.account_key
+    WHERE (metric_realm.id IS NULL OR metric_realm.active = 1)
+      AND (
+        NOT EXISTS (
+          SELECT 1
+          FROM provider_resources observed_resource
+          WHERE observed_resource.provider = metric.provider
+            AND observed_resource.account_key = metric.account_key
+            AND observed_resource.person_id = metric.person_id
+        )
+        OR EXISTS (
+          SELECT 1
+          FROM provider_resources active_resource
+          LEFT JOIN source_realms active_realm ON active_realm.id = active_resource.source_realm_id
+          WHERE active_resource.provider = metric.provider
+            AND active_resource.account_key = metric.account_key
+            AND active_resource.person_id = metric.person_id
+            AND active_resource.active = 1
+            AND (active_realm.id IS NULL OR active_realm.active = 1)
+        )
+      )
+  ),
+  canonical_interaction_lanes AS (
+    SELECT person_id, logical_service, source_lane,
+      sum(interaction_count) AS interaction_count,
+      max(reciprocal) AS reciprocal,
+      min(first_interaction_at) AS first_interaction_at,
+      max(last_interaction_at) AS last_interaction_at
+    FROM canonical_interaction_inputs
+    GROUP BY person_id, logical_service, source_lane
+  ),
+  canonical_interaction_services AS (
+    SELECT person_id, logical_service,
+      max(interaction_count) AS interaction_count,
+      max(reciprocal) AS reciprocal,
+      min(first_interaction_at) AS first_interaction_at,
+      max(last_interaction_at) AS last_interaction_at
+    FROM canonical_interaction_lanes
+    GROUP BY person_id, logical_service
+  ),
+  canonical_interaction_rollup AS (
+    SELECT person_id,
+      sum(interaction_count) AS interaction_count,
+      max(reciprocal) AS reciprocal,
+      min(first_interaction_at) AS first_interaction_at,
+      max(last_interaction_at) AS last_interaction_at
+    FROM canonical_interaction_services
+    GROUP BY person_id
+  )
+`;
+
+// src/local/provider-handles.ts
+import { createHmac } from "crypto";
+import { z as z4 } from "zod";
+var sha256Schema = z4.string().regex(/^[a-f0-9]{64}$/u);
+var providerHandleCandidateSchema = z4.object({
+  provider: z4.string().min(1).max(64),
+  service: z4.string().min(1).max(64).nullable(),
+  realmExternalIdSha256: sha256Schema.nullable(),
+  bindingAuthSha256: sha256Schema.nullable(),
+  handle: z4.string().min(1)
+}).strict();
+function localDatabaseInstanceId(database) {
+  const row = database.query("SELECT instance_id FROM local_state WHERE singleton = 1").get();
+  if (row === null || !/^[a-f0-9]{64}$/u.test(row.instance_id)) {
+    throw new Error("PeopleBlade local database identity is missing.");
+  }
+  return row.instance_id;
+}
+function providerHandleKey(candidate, databaseInstanceId) {
+  if (candidate.provider !== "beeper")
+    return candidate.provider;
+  if (candidate.service === null || candidate.realmExternalIdSha256 === null || candidate.bindingAuthSha256 === null)
+    throw new Error("Beeper provider handle is missing its bound source realm.");
+  const realmDiscriminator = createHmac("sha256", databaseInstanceId).update(canonicalJson([
+    "peopleblade-beeper-provider-handle-realm-v1",
+    candidate.bindingAuthSha256,
+    candidate.realmExternalIdSha256
+  ])).digest("hex").slice(0, 48);
+  return `beeper:${candidate.service}:${realmDiscriminator}`;
+}
+function parseProviderHandleCandidates(value, databaseInstanceId) {
+  const localSalt = sha256Schema.parse(databaseInstanceId);
+  const parsed = JSON.parse(value);
+  const candidates = z4.array(providerHandleCandidateSchema).max(50).parse(parsed);
+  const handles = {};
+  for (const candidate of candidates) {
+    const key = providerHandleKey(candidate, localSalt);
+    if (Object.hasOwn(handles, key)) {
+      throw new Error("Local provider handles contain a stable-key collision.");
+    }
+    handles[key] = candidate.handle;
+  }
+  return handles;
+}
+
+// src/local/projection.ts
+function parseStringArray(value) {
+  const parsed = JSON.parse(value);
+  if (!Array.isArray(parsed) || !parsed.every((item) => typeof item === "string"))
+    throw new Error("Invalid local contact array.");
+  return parsed;
+}
+function iso(value) {
+  if (value === null)
+    return null;
+  const parsed = new Date(value.includes("T") ? value : `${value.replace(" ", "T")}Z`);
+  return Number.isNaN(parsed.valueOf()) ? null : parsed.toISOString();
+}
+function localDatabaseFingerprint(database) {
+  return localDatabaseInstanceId(database);
+}
+function localSchemaVersion(database) {
+  const row = database.query("SELECT count(*) AS count FROM schema_migrations").get();
+  if (row === null || !Number.isSafeInteger(row.count) || row.count < 1)
+    throw new Error("PeopleBlade schema is not initialized.");
+  return row.count;
+}
+function projectCloudContacts(database) {
+  const rows = database.query(`
+    WITH
+    ${canonicalInteractionRollupCtesSql},
+    person_rollup AS (
+      SELECT member.canonical_person_id AS person_id,
+        CASE WHEN count(DISTINCT person.birthday) = 1 THEN min(person.birthday) ELSE NULL END AS birthday,
+        max(person.do_not_contact) AS do_not_contact,
+        max(person.updated_at) AS updated_at
+      FROM person_identity_components member
+      JOIN people person ON person.id = member.person_id
+      GROUP BY member.canonical_person_id
+    ),
+    deduplicated_methods AS (
+      SELECT member.canonical_person_id AS person_id, method.kind, method.normalized_value,
+        max(method.is_primary) AS primary_rank, min(method.id) AS first_id,
+        min(CASE WHEN method.identity_eligible = 1 AND method.confidence = 'exact'
+          AND (method.provider_resource_id IS NULL OR (
+            resource.active = 1 AND (realm.id IS NULL OR realm.active = 1)
+          ))
+          THEN method.id END) AS identity_anchor_id
+      FROM contact_methods method
+      JOIN person_identity_components member ON member.person_id = method.person_id
+      LEFT JOIN provider_resources resource ON resource.id = method.provider_resource_id
+      LEFT JOIN source_realms realm ON realm.id = resource.source_realm_id
+      WHERE method.active = 1 AND method.kind IN ('email', 'phone')
+      GROUP BY member.canonical_person_id, method.kind, method.normalized_value
+    ),
+    ordered_methods AS (
+      SELECT item.person_id, item.kind, method.value,
+        item.identity_anchor_id IS NOT NULL AS identity_anchor
+      FROM deduplicated_methods item
+      JOIN contact_methods method ON method.id = coalesce(item.identity_anchor_id, item.first_id)
+      ORDER BY item.person_id, item.kind, item.identity_anchor_id IS NOT NULL DESC,
+        item.primary_rank DESC, item.first_id
+    ),
+    email_rollup AS (
+      SELECT person_id, json_group_array(value) AS emails_json
+      FROM ordered_methods WHERE kind = 'email' GROUP BY person_id
+    ),
+    phone_rollup AS (
+      SELECT person_id, json_group_array(value) AS phones_json
+      FROM ordered_methods WHERE kind = 'phone' GROUP BY person_id
+    ),
+    identity_email_rollup AS (
+      SELECT person_id, json_group_array(value) AS identity_emails_json
+      FROM ordered_methods WHERE kind = 'email' AND identity_anchor GROUP BY person_id
+    ),
+    identity_phone_rollup AS (
+      SELECT person_id, json_group_array(value) AS identity_phones_json
+      FROM ordered_methods WHERE kind = 'phone' AND identity_anchor GROUP BY person_id
+    ),
+    identity_profile_url_rollup AS (
+      SELECT person_id, json_group_array(profile_url) AS identity_profile_urls_json
+      FROM (
+        SELECT member.canonical_person_id AS person_id,
+          trim(resource.profile_url) AS profile_url, min(resource.id) AS first_id
+        FROM provider_resources resource
+        JOIN person_identity_components member ON member.person_id = resource.person_id
+        LEFT JOIN source_realms realm ON realm.id = resource.source_realm_id
+        WHERE resource.active = 1 AND resource.profile_url_identity_eligible = 1
+          AND resource.profile_url IS NOT NULL AND trim(resource.profile_url) <> ''
+          AND (realm.id IS NULL OR realm.active = 1)
+        GROUP BY member.canonical_person_id, trim(resource.profile_url)
+        ORDER BY member.canonical_person_id, first_id
+      )
+      GROUP BY person_id
+    ),
+    resource_eligibility AS (
+      SELECT member.canonical_person_id AS person_id,
+        max(resource.active) AS has_active_resource
+      FROM provider_resources resource
+      JOIN person_identity_components member ON member.person_id = resource.person_id
+      GROUP BY member.canonical_person_id
+    ),
+    source_values AS (
+      SELECT member.canonical_person_id AS person_id, resource.provider
+      FROM provider_resources resource
+      JOIN person_identity_components member ON member.person_id = resource.person_id
+      WHERE resource.active = 1
+      UNION
+      SELECT metric.person_id, metric.provider
+      FROM canonical_interaction_inputs metric
+    ),
+    source_rollup AS (
+      SELECT person_id, json_group_array(provider) AS sources_json
+      FROM (SELECT person_id, provider FROM source_values ORDER BY person_id, provider)
+      GROUP BY person_id
+    ),
+    handle_choices AS (
+      SELECT person_id, provider, service, realm_external_id_sha256,
+        binding_auth_sha256, resource_id
+      FROM (
+        SELECT member.canonical_person_id AS person_id,
+          resource.provider,
+          CASE WHEN resource.provider='beeper' THEN realm.service ELSE NULL END AS service,
+          CASE WHEN resource.provider='beeper' THEN realm.external_id_sha256 ELSE NULL END AS realm_external_id_sha256,
+          CASE WHEN resource.provider='beeper' THEN incarnation.auth_sha256 ELSE NULL END AS binding_auth_sha256,
+          resource.id AS resource_id,
+          row_number() OVER (
+            PARTITION BY member.canonical_person_id, resource.provider,
+              CASE WHEN resource.provider='beeper' THEN resource.source_realm_id ELSE NULL END
+            ORDER BY CASE
+              WHEN resource.profile_url IS NOT NULL AND trim(resource.profile_url) <> '' THEN 0
+              WHEN resource.username IS NOT NULL AND trim(resource.username) <> '' THEN 1
+              ELSE 2
+            END, resource.id
+          ) AS preference_rank
+        FROM provider_resources resource
+        JOIN person_identity_components member ON member.person_id = resource.person_id
+        LEFT JOIN source_realms realm ON realm.id = resource.source_realm_id
+        LEFT JOIN source_bindings binding ON binding.id = realm.source_binding_id
+        LEFT JOIN current_source_binding_incarnations incarnation ON incarnation.source_binding_id = binding.id
+        WHERE resource.active = 1 AND (realm.id IS NULL OR realm.active = 1)
+      )
+      WHERE preference_rank = 1
+    ),
+    handle_rollup AS (
+      SELECT person_id, json_group_array(json_object(
+        'provider', provider,
+        'service', service,
+        'realmExternalIdSha256', realm_external_id_sha256,
+        'bindingAuthSha256', binding_auth_sha256,
+        'handle', handle
+      )) AS handles_json
+      FROM (
+        SELECT choice.person_id, choice.provider, choice.service,
+          choice.realm_external_id_sha256, choice.binding_auth_sha256,
+          CASE
+            WHEN resource.profile_url IS NOT NULL AND trim(resource.profile_url) <> '' THEN resource.profile_url
+            WHEN resource.username IS NOT NULL AND trim(resource.username) <> '' THEN resource.username
+            ELSE resource.resource_id
+          END AS handle
+        FROM handle_choices choice
+        JOIN provider_resources resource ON resource.id = choice.resource_id
+        ORDER BY choice.person_id, choice.provider, choice.service,
+          choice.realm_external_id_sha256
+      )
+      GROUP BY person_id
+    )
+    SELECT p.id, p.display_name, p.organization, p.title,
+      person_rollup.birthday,
+      coalesce(person_rollup.do_not_contact, p.do_not_contact) AS do_not_contact,
+      coalesce(person_rollup.updated_at, p.updated_at) AS updated_at,
+      coalesce(canonical_interaction_rollup.interaction_count, 0) AS interaction_count,
+      coalesce(canonical_interaction_rollup.reciprocal, 0) AS reciprocal,
+      canonical_interaction_rollup.first_interaction_at,
+      canonical_interaction_rollup.last_interaction_at,
+      coalesce(email_rollup.emails_json, '[]') AS emails_json,
+      coalesce(phone_rollup.phones_json, '[]') AS phones_json,
+      coalesce(identity_email_rollup.identity_emails_json, '[]') AS identity_emails_json,
+      coalesce(identity_phone_rollup.identity_phones_json, '[]') AS identity_phones_json,
+      coalesce(identity_profile_url_rollup.identity_profile_urls_json, '[]') AS identity_profile_urls_json,
+      coalesce(source_rollup.sources_json, '[]') AS sources_json,
+      coalesce(handle_rollup.handles_json, '[]') AS handles_json
+    FROM people p
+    JOIN person_identity_components root ON root.person_id = p.id AND root.canonical_person_id = p.id
+    LEFT JOIN person_rollup ON person_rollup.person_id = p.id
+    LEFT JOIN canonical_interaction_rollup ON canonical_interaction_rollup.person_id = p.id
+    LEFT JOIN email_rollup ON email_rollup.person_id = p.id
+    LEFT JOIN phone_rollup ON phone_rollup.person_id = p.id
+    LEFT JOIN identity_email_rollup ON identity_email_rollup.person_id = p.id
+    LEFT JOIN identity_phone_rollup ON identity_phone_rollup.person_id = p.id
+    LEFT JOIN identity_profile_url_rollup ON identity_profile_url_rollup.person_id = p.id
+    LEFT JOIN source_rollup ON source_rollup.person_id = p.id
+    LEFT JOIN handle_rollup ON handle_rollup.person_id = p.id
+    LEFT JOIN resource_eligibility ON resource_eligibility.person_id = p.id
+    WHERE resource_eligibility.person_id IS NULL
+      OR resource_eligibility.has_active_resource = 1
+      OR canonical_interaction_rollup.person_id IS NOT NULL
+    ORDER BY p.id
+  `).all();
+  const instance = localDatabaseFingerprint(database);
+  return rows.map((row) => {
+    const sources = sourceLabelSchema.array().parse(parseStringArray(row.sources_json).filter((source) => sourceLabelSchema.safeParse(source).success));
+    const data = {
+      id: sha256(`peopleblade\x00${instance}\x00${row.id}`),
+      localPersonId: String(row.id),
+      displayName: row.display_name ?? "Unnamed contact",
+      emails: parseStringArray(row.emails_json).filter((email) => cloudEmailSchema.safeParse(email).success).slice(0, 100),
+      phones: parseStringArray(row.phones_json).slice(0, 100),
+      organization: row.organization,
+      title: row.title,
+      birthday: row.birthday,
+      sources,
+      providerHandles: parseProviderHandleCandidates(row.handles_json, instance),
+      enrichmentInputVersion: 2,
+      identityAnchors: {
+        state: "available",
+        emails: parseStringArray(row.identity_emails_json).filter((email) => cloudEmailSchema.safeParse(email).success).slice(0, 100),
+        phones: parseStringArray(row.identity_phones_json).slice(0, 100),
+        profileUrls: parseStringArray(row.identity_profile_urls_json).filter((url) => httpUrlSchema.safeParse(url).success).slice(0, 100)
+      },
+      automaticEnrichmentSelection: {
+        version: 1,
+        state: row.do_not_contact === 1 ? "blocked" : "eligible"
+      },
+      interactionCount: row.interaction_count,
+      reciprocal: row.reciprocal === 1,
+      firstInteractionAt: iso(row.first_interaction_at),
+      lastInteractionAt: iso(row.last_interaction_at),
+      updatedAt: iso(row.updated_at) ?? new Date(0).toISOString()
+    };
+    return cloudContactSchema.parse({
+      ...data,
+      metadataSha256: sha256(canonicalJson(data)),
+      enrichmentInputSha256: enrichmentInputSha256(data)
+    });
+  });
+}
+
+// src/local/cloud-sync-runtime.ts
+import {
+  Cause,
+  Exit,
+  Layer,
+  ManagedRuntime,
+  Option
+} from "effect";
+
+// src/local/cloud-sync-program.ts
+import { Effect as Effect2 } from "effect";
+
+// src/local/cloud-sync-service.ts
+import { Context, Data, Effect } from "effect";
+import { z as z5 } from "zod";
+
+class CloudSyncError extends Data.TaggedError("CloudSyncError") {
+}
+var syncValue = (operation, read) => Effect.try({ try: read, catch: (cause) => new CloudSyncError({ operation, cause }) });
+var syncStartResponse = z5.object({
+  snapshotId: z5.uuid(),
+  resumed: z5.boolean(),
+  uploadedContacts: z5.number().int().min(0).max(1e6),
+  uploadedPages: z5.number().int().min(0).max(1e5),
+  uploadedPageContactCounts: z5.array(z5.number().int().min(1).max(200)).max(1e5)
+}).strict().superRefine((value, context) => {
+  if (value.uploadedPageContactCounts.length !== value.uploadedPages)
+    context.addIssue({
+      code: "custom",
+      path: ["uploadedPageContactCounts"],
+      message: "Uploaded sync-page manifest length does not match its page count"
+    });
+  const contactCount = value.uploadedPageContactCounts.reduce((sum, count) => sum + count, 0);
+  if (contactCount !== value.uploadedContacts)
+    context.addIssue({
+      code: "custom",
+      path: ["uploadedContacts"],
+      message: "Uploaded sync-page manifest does not match its contact count"
+    });
+  if (!value.resumed && (value.uploadedContacts !== 0 || value.uploadedPages !== 0))
+    context.addIssue({
+      code: "custom",
+      path: ["resumed"],
+      message: "A fresh sync snapshot cannot report uploaded progress"
+    });
+});
+
+class CloudSync extends Context.Tag("peopleblade/local/CloudSync/v1")() {
+}
+
+// src/local/cloud-sync-program.ts
+var syncCloudProgram = Effect2.gen(function* () {
+  const ports = yield* CloudSync;
+  const prepared = yield* ports.prepare;
+  const { contacts, pageSize } = prepared;
+  const started = yield* ports.start(prepared.start);
+  if (started.uploadedContacts > contacts.length)
+    return yield* Effect2.fail(new CloudSyncError({
+      operation: "resume",
+      cause: new Error("Cloud sync resume progress exceeds the current local projection.")
+    }));
+  let pages = 0;
+  let offset = 0;
+  for (const priorPageContacts of started.uploadedPageContactCounts) {
+    const replayContacts = contacts.slice(offset, offset + priorPageContacts);
+    if (replayContacts.length !== priorPageContacts)
+      return yield* Effect2.fail(new CloudSyncError({
+        operation: "resume",
+        cause: new Error("Cloud sync resume manifest exceeds the current local projection.")
+      }));
+    const input = yield* syncValue("page", () => syncPageSchema.parse({ snapshotId: started.snapshotId, ordinal: pages, contacts: replayContacts }));
+    yield* ports.page(input);
+    pages += 1;
+    offset += priorPageContacts;
+  }
+  if (offset !== started.uploadedContacts || pages !== started.uploadedPages)
+    return yield* Effect2.fail(new CloudSyncError({
+      operation: "resume",
+      cause: new Error("Cloud sync resume manifest did not reproduce its reported progress.")
+    }));
+  for (;offset < contacts.length; offset += pageSize) {
+    const input = yield* syncValue("page", () => syncPageSchema.parse({ snapshotId: started.snapshotId, ordinal: pages, contacts: contacts.slice(offset, offset + pageSize) }));
+    yield* ports.page(input);
+    pages += 1;
+  }
+  const finish = yield* syncValue("finish", () => syncFinishSchema.parse({ snapshotId: started.snapshotId, pages, contactCount: contacts.length }));
+  yield* ports.finish(finish);
+  yield* ports.commit(started.snapshotId);
+  return { snapshotId: started.snapshotId, contacts: contacts.length, pages, resumed: started.resumed, replayedPages: started.uploadedPages };
+});
+
+// src/local/cloud-sync-runtime.ts
+async function runCloudSync(ports, signal) {
+  const runtime = ManagedRuntime.make(Layer.succeed(CloudSync, ports));
+  try {
+    const exit = await runtime.runPromiseExit(syncCloudProgram, { signal });
+    if (Exit.isSuccess(exit))
+      return exit.value;
+    const failure = Cause.failureOption(exit.cause);
+    if (Option.isSome(failure) && failure.value instanceof CloudSyncError)
+      throw failure.value.cause;
+    throw Cause.squash(exit.cause);
+  } finally {
+    await runtime.dispose();
+  }
+}
+
+// src/local/cloud-sync-client.ts
+var SYNC_PAGE_TIMEOUT_MS = 240000;
+function cloudSyncPorts(database, options, postJson) {
+  let config;
+  const request = (operation, path, input, timeoutMs) => Effect3.suspend(() => {
+    const current = config;
+    if (current === undefined)
+      return Effect3.die(new Error("Cloud sync transport used before preparation."));
+    return Effect3.tryPromise({
+      try: (signal) => postJson(options.fetcher ?? fetch, `${current.baseUrl}${path}`, input, current.token, timeoutMs, signal),
+      catch: (cause) => new CloudSyncError({ operation, cause })
+    });
+  });
+  return {
+    prepare: syncValue("projection", () => {
+      config = cloudConfiguration(options.configuration);
+      const contacts = projectCloudContacts(database);
+      return {
+        contacts,
+        pageSize: Math.max(1, Math.min(200, options.pageSize ?? 200)),
+        start: syncStartSchema.parse({
+          contactCount: contacts.length,
+          databaseFingerprint: localDatabaseFingerprint(database),
+          schemaVersion: localSchemaVersion(database),
+          resumeVersion: 1
+        })
+      };
+    }),
+    start: (input) => request("start", "/api/cli/sync/start", input, 285000).pipe(Effect3.flatMap((value) => syncValue("start", () => syncStartResponse.parse(value)))),
+    page: (input) => request("page", "/api/cli/sync/page", input, SYNC_PAGE_TIMEOUT_MS).pipe(Effect3.asVoid),
+    finish: (input) => request("finish", "/api/cli/sync/finish", input).pipe(Effect3.asVoid),
+    commit: (snapshotId) => syncValue("local-commit", () => {
+      if (config === undefined)
+        throw new Error("Cloud sync commit used before preparation.");
+      database.query(`INSERT INTO cloud_sync_state(singleton,base_url,device_id,last_snapshot_id,last_synced_at)
+        VALUES (1,?,?,?,CURRENT_TIMESTAMP)
+        ON CONFLICT(singleton) DO UPDATE SET base_url=excluded.base_url, device_id=excluded.device_id,
+          last_snapshot_id=excluded.last_snapshot_id, last_synced_at=excluded.last_synced_at`).run(config.baseUrl, config.deviceId, snapshotId);
+    })
+  };
+}
+function startCloudSync(database, options, transport) {
+  return runCloudSync(cloudSyncPorts(database, options, transport), options.signal);
+}
+export {
+  startCloudSync
+};