@hasna/contacts 0.8.1 → 0.9.1

package/dist/browser/native.js

@@ -0,0 +1,822 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/browser/native.ts
+import { createRequire } from "module";
+
+// src/sdk/index.ts
+import { resolveCredential as resolveCredential2 } from "@hasna/contracts/client";
+
+// src/cloud/http-storage.ts
+import {
+  ClientTransportConfigurationError,
+  createHasnaHttpTransport,
+  resolveCredential,
+  resolveClientTransport as resolveSharedClientTransport
+} from "@hasna/contracts/client";
+
+// src/cloud/client-config.ts
+import { createHash } from "crypto";
+import { readFileSync, statSync } from "fs";
+import { clientTransportEnvKeys, credentialDiskSourceList, toV1BaseUrl } from "@hasna/contracts/client";
+function invalid() {
+  throw new Error("CONTACTS_CLIENT_CONFIG_INVALID: blank, conflicting, or unstable client configuration; no request was sent.");
+}
+function checkAliases(values) {
+  const keys = clientTransportEnvKeys("contacts");
+  for (const group of [keys.apiUrlKeys, keys.apiKeyKeys]) {
+    const defined = group.filter((key) => values[key] !== undefined);
+    const normalized = defined.map((key) => {
+      const value = values[key].trim();
+      if (!value)
+        invalid();
+      if (group === keys.apiUrlKeys) {
+        try {
+          return toV1BaseUrl(value);
+        } catch {
+          invalid();
+        }
+      }
+      return value;
+    });
+    if (new Set(normalized).size > 1)
+      invalid();
+  }
+}
+function checkDiskAliases(text) {
+  const values = {};
+  const wanted = new Set(Object.values(clientTransportEnvKeys("contacts")).flat());
+  for (const line of text.split(/\r?\n/)) {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/.exec(line);
+    if (!match || !wanted.has(match[1]))
+      continue;
+    let value = match[2].trim();
+    if (value.startsWith('"') || value.startsWith("'")) {
+      if (value.length < 2 || value.at(-1) !== value[0])
+        invalid();
+      value = value.slice(1, -1);
+    }
+    if (values[match[1]] !== undefined && values[match[1]] !== value)
+      invalid();
+    values[match[1]] = value;
+  }
+  checkAliases(values);
+}
+function clientConfigurationStamp(env) {
+  checkAliases(env);
+  const digest = createHash("sha256");
+  digest.update(JSON.stringify(Object.entries(env).sort(([a], [b]) => a.localeCompare(b))));
+  const profile = env.HASNA_PROFILE?.trim();
+  if (profile && !/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(profile))
+    invalid();
+  const paths = [
+    ...credentialDiskSourceList("contacts", env),
+    ...profile ? credentialDiskSourceList("contacts", env, profile) : []
+  ];
+  for (const { path } of paths) {
+    digest.update(path);
+    try {
+      const before = statSync(path, { bigint: true });
+      if (!before.isFile() || before.size > 65536n)
+        invalid();
+      const contents = readFileSync(path);
+      const after = statSync(path, { bigint: true });
+      const identity = (s) => `${s.dev}:${s.ino}:${s.size}:${s.mtimeNs}:${s.ctimeNs}`;
+      if (identity(before) !== identity(after))
+        invalid();
+      checkDiskAliases(contents.toString("utf8"));
+      digest.update(identity(after)).update(contents);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        invalid();
+      digest.update("absent");
+    }
+  }
+  return digest.digest("hex");
+}
+function assertConfigurationUnchanged(env, expected) {
+  if (clientConfigurationStamp(env) !== expected)
+    invalid();
+}
+
+// src/cloud/resolver-inputs.ts
+import {
+  clientTransportEnvKeys as clientTransportEnvKeys2,
+  credentialOverrideEnvKey,
+  credentialPointerEnvKey,
+  CREDENTIAL_PROFILE_ENV_KEY
+} from "@hasna/contracts/client";
+var CONTRACTS_AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
+function isAmbientContactsEnv(env) {
+  if (typeof process !== "undefined" && env === process.env)
+    return true;
+  return env[CONTRACTS_AMBIENT_ENVIRONMENT] === true;
+}
+function contactsResolverCredentials(env, credentials = {}) {
+  const keychain = { ...credentials.keychain };
+  if (keychain.enabled === undefined && keychain.run === undefined) {
+    keychain.enabled = isAmbientContactsEnv(env);
+  }
+  return { ...credentials, keychain };
+}
+
+// src/cloud/http-storage.ts
+var RETIRED_CLIENT_SELECTOR_KEYS = [
+  "HASNA_CONTACTS_STORAGE_MODE",
+  "CONTACTS_STORAGE_MODE",
+  "HASNA_CONTACTS_MODE",
+  "CONTACTS_MODE",
+  "HASNA_CONTACTS_DB_PATH",
+  "CONTACTS_DB_PATH",
+  "HASNA_CONTACTS_DATABASE_URL",
+  "CONTACTS_DATABASE_URL"
+];
+function configuredKeys(env, keys) {
+  return keys.filter((key) => env[key] !== undefined && env[key].trim().length > 0);
+}
+function assertNoRetiredClientSelectors(env) {
+  const found = configuredKeys(env, RETIRED_CLIENT_SELECTOR_KEYS);
+  if (found.length === 0)
+    return;
+  throw new ContactsClientConfigurationError("RETIRED_CONTACTS_CLIENT_SELECTOR", `Contacts clients use only HASNA_CONTACTS_API_URL plus an API key resolved by @hasna/contracts. ` + `Remove retired client selector${found.length === 1 ? "" : "s"}: ${found.join(", ")}. ` + "PostgreSQL configuration belongs only on contacts-serve; local SQLite is available only through the explicit legacy migration command.");
+}
+function assertHttpsBaseUrl(baseUrl) {
+  const url = new URL(baseUrl);
+  if (url.protocol !== "https:") {
+    throw new ContactsClientConfigurationError("CONTACTS_API_HTTPS_REQUIRED", "HASNA_CONTACTS_API_URL must use HTTPS. Plain HTTP and local-store fallback are disabled for contacts clients.");
+  }
+}
+
+class ContactsClientConfigurationError extends Error {
+  code;
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "ContactsClientConfigurationError";
+  }
+}
+function unconfiguredResolution(issue, resolution, warning = null) {
+  return {
+    transport: "unconfigured",
+    baseUrl: null,
+    apiUrlSource: resolution?.apiUrlSource ?? null,
+    apiKeyPresent: resolution?.apiKeyPresent ?? false,
+    apiKeySource: resolution?.apiKeySource ?? null,
+    apiKeyTier: resolution?.apiKeyTier ?? null,
+    configured: false,
+    misconfigured: true,
+    issue,
+    warning
+  };
+}
+function resolveContactsClientTransport(name, env = process.env, credentials = {}) {
+  if (name !== "contacts") {
+    throw new ContactsClientConfigurationError("CONTACTS_CLIENT_NAME_INVALID", "This resolver only accepts the contacts app slug.");
+  }
+  assertNoRetiredClientSelectors(env);
+  const stamp = clientConfigurationStamp(env);
+  let resolution;
+  try {
+    resolution = resolveSharedClientTransport(name, env, {
+      credentials: contactsResolverCredentials(env, credentials)
+    });
+  } catch (error) {
+    assertConfigurationUnchanged(env, stamp);
+    if (error instanceof ClientTransportConfigurationError) {
+      return unconfiguredResolution(error.message, null);
+    }
+    throw error;
+  }
+  assertConfigurationUnchanged(env, stamp);
+  try {
+    assertHttpsBaseUrl(resolution.baseUrl);
+  } catch (error) {
+    return {
+      ...unconfiguredResolution(error instanceof Error ? error.message : String(error), resolution),
+      apiKeyPresent: resolution.apiKeyPresent
+    };
+  }
+  return {
+    transport: "https",
+    baseUrl: resolution.baseUrl,
+    apiUrlSource: resolution.apiUrlSource,
+    apiKeyPresent: resolution.apiKeyPresent,
+    apiKeySource: resolution.apiKeySource,
+    apiKeyTier: resolution.apiKeyTier,
+    configured: true,
+    misconfigured: false,
+    issue: null,
+    warning: resolution.warning
+  };
+}
+
+// src/sdk/v1.generated.ts
+class ApiError extends Error {
+  status;
+  body;
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+}
+
+class ContactsV1Client {
+  baseUrl;
+  apiKey;
+  fetchImpl;
+  baseHeaders;
+  constructor(options) {
+    if (!options.baseUrl)
+      throw new Error("ContactsV1Client requires a baseUrl.");
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.baseHeaders = options.headers ?? {};
+  }
+  async request(method, path, opts) {
+    const url = new URL(this.baseUrl + path);
+    if (opts.query) {
+      for (const [key, value] of Object.entries(opts.query)) {
+        if (value !== undefined && value !== null)
+          url.searchParams.set(key, String(value));
+      }
+    }
+    const headers = { Accept: "application/json", ...this.baseHeaders, ...opts.init?.headers };
+    if (this.apiKey)
+      headers["x-api-key"] = this.apiKey;
+    let payload;
+    if (opts.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      payload = JSON.stringify(opts.body);
+    }
+    const response = await this.fetchImpl(url.toString(), { ...opts.init, method, headers, body: payload });
+    const text = await response.text();
+    const data = text ? (() => {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    })() : undefined;
+    if (!response.ok) {
+      throw new ApiError(response.status, `${method} ${path} failed: ${response.status}`, data);
+    }
+    return data;
+  }
+  async listCompanies(query, init) {
+    return this.request("GET", `/v1/companies`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async createCompany(body, init) {
+    return this.request("POST", `/v1/companies`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async getCompany(id, init) {
+    return this.request("GET", `/v1/companies/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async deleteCompany(id, init) {
+    return this.request("DELETE", `/v1/companies/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async updateCompany(id, body, init) {
+    return this.request("PATCH", `/v1/companies/${encodeURIComponent(String(id))}`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async listContacts(query, init) {
+    return this.request("GET", `/v1/contacts`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async createContact(body, init) {
+    return this.request("POST", `/v1/contacts`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async getContactProjectIds(contactId, init) {
+    return this.request("GET", `/v1/contacts/${encodeURIComponent(String(contactId))}/projects`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async setContactProjects(contactId, body, init) {
+    return this.request("PUT", `/v1/contacts/${encodeURIComponent(String(contactId))}/projects`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async linkContactToProject(contactId, projectId, init) {
+    return this.request("PUT", `/v1/contacts/${encodeURIComponent(String(contactId))}/projects/${encodeURIComponent(String(projectId))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async unlinkContactFromProject(contactId, projectId, init) {
+    return this.request("DELETE", `/v1/contacts/${encodeURIComponent(String(contactId))}/projects/${encodeURIComponent(String(projectId))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async addTagToContact(contactId, tagId, init) {
+    return this.request("PUT", `/v1/contacts/${encodeURIComponent(String(contactId))}/tags/${encodeURIComponent(String(tagId))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async removeTagFromContact(contactId, tagId, init) {
+    return this.request("DELETE", `/v1/contacts/${encodeURIComponent(String(contactId))}/tags/${encodeURIComponent(String(tagId))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async getContact(id, init) {
+    return this.request("GET", `/v1/contacts/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async deleteContact(id, init) {
+    return this.request("DELETE", `/v1/contacts/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async updateContact(id, body, init) {
+    return this.request("PATCH", `/v1/contacts/${encodeURIComponent(String(id))}`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async listContactProjectMemberships(projectId, query, init) {
+    return this.request("GET", `/v1/projects/${encodeURIComponent(String(projectId))}/contact-memberships`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async readContactProjectMembership(projectId, contactId, init) {
+    return this.request("GET", `/v1/projects/${encodeURIComponent(String(projectId))}/contact-memberships/${encodeURIComponent(String(contactId))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async attachContactProjectMembership(projectId, contactId, body, init) {
+    return this.request("POST", `/v1/projects/${encodeURIComponent(String(projectId))}/contact-memberships/${encodeURIComponent(String(contactId))}/attach`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async detachContactProjectMembership(projectId, contactId, body, init) {
+    return this.request("POST", `/v1/projects/${encodeURIComponent(String(projectId))}/contact-memberships/${encodeURIComponent(String(contactId))}/detach`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async listContactIdsByProject(projectId, init) {
+    return this.request("GET", `/v1/projects/${encodeURIComponent(String(projectId))}/contacts`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async getStats(init) {
+    return this.request("GET", `/v1/stats`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async listTags(query, init) {
+    return this.request("GET", `/v1/tags`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async createTag(body, init) {
+    return this.request("POST", `/v1/tags`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async getTag(id, init) {
+    return this.request("GET", `/v1/tags/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async deleteTag(id, init) {
+    return this.request("DELETE", `/v1/tags/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async updateTag(id, body, init) {
+    return this.request("PATCH", `/v1/tags/${encodeURIComponent(String(id))}`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+}
+
+// src/sdk/index.ts
+function validateBaseUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error("ContactsV1Client baseUrl must be an absolute HTTPS URL.");
+  }
+  if (url.protocol !== "https:")
+    throw new Error("ContactsV1Client baseUrl must use HTTPS.");
+  if (url.username || url.password)
+    throw new Error("ContactsV1Client baseUrl must not contain credentials.");
+  if (url.search || url.hash)
+    throw new Error("ContactsV1Client baseUrl must not contain a query or fragment.");
+  url.pathname = url.pathname.replace(/\/+$/, "").replace(/\/v1$/, "");
+  return url.toString().replace(/\/+$/, "");
+}
+function validateApiKey(apiKey) {
+  const key = (apiKey ?? "").trim();
+  if (!key)
+    throw new Error("ContactsV1Client requires an API key.");
+  if (/[^\t\x20-\x7e]/.test(key)) {
+    throw new Error("ContactsV1Client API key contains bytes that are invalid in an HTTP header.");
+  }
+  return key;
+}
+
+class ContactsV1Client2 extends ContactsV1Client {
+  constructor(options) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    super({
+      ...options,
+      baseUrl: validateBaseUrl(options.baseUrl),
+      apiKey: validateApiKey(options.apiKey),
+      fetch: (input, init) => fetchImpl(input, { ...init, redirect: "manual" })
+    });
+  }
+}
+var CONTACTS_APP_NAME = "contacts";
+function contactsSdkAuthorityPinMessage() {
+  return "an explicit baseUrl requires an explicit apiKey. The SDK never attaches a credential that " + "resolved for a different authority: pass `apiKey` explicitly, or omit `baseUrl` and let the " + "@hasna/contracts chain resolve both halves together.";
+}
+var SDK_HOSTED_ONLY = "The contacts SDK is hosted-only and never falls back to local data.";
+function resolveSdkCredential(env, chainOptions) {
+  const credential = resolveCredential2(CONTACTS_APP_NAME, env, chainOptions);
+  if (!credential) {
+    const diagnosis = resolveContactsClientTransport(CONTACTS_APP_NAME, env, chainOptions);
+    throw new ContactsClientConfigurationError("CONTACTS_API_NOT_CONFIGURED", `${diagnosis.issue ?? "No contacts credential resolved."} ${SDK_HOSTED_ONLY}`);
+  }
+  if (credential.tier === "pointer") {
+    throw new ContactsClientConfigurationError("CONTACTS_CREDENTIAL_POINTER_UNSUPPORTED", `The contacts SDK resolves credentials synchronously and cannot complete the secrets-vault pointer ` + `${credential.source} per request. Use a literal tier instead: an explicit apiKey, the Keychain item ` + `hasna.credentials.${CONTACTS_APP_NAME}.api-key, ~/.hasna/${CONTACTS_APP_NAME}/config/credentials, ` + `or HASNA_CONTACTS_API_KEY.`);
+  }
+  return credential.apiKey;
+}
+function createContactsClient(options = {}) {
+  const { baseUrl, apiKey, env, profile, keychain, ...clientOptions } = options;
+  if (baseUrl !== undefined) {
+    if (!apiKey)
+      throw new ContactsClientConfigurationError("CONTACTS_CREDENTIAL_PINNED", contactsSdkAuthorityPinMessage());
+    return new ContactsV1Client2({ ...clientOptions, baseUrl, apiKey });
+  }
+  const envObject = env ?? (typeof process !== "undefined" ? process.env : {});
+  const requested = {
+    ...apiKey !== undefined ? { apiKey } : {},
+    ...profile !== undefined ? { profile } : {},
+    ...keychain !== undefined ? { keychain } : {}
+  };
+  const chainOptions = contactsResolverCredentials(envObject, requested);
+  const initialKey = resolveSdkCredential(envObject, chainOptions);
+  const resolution = resolveContactsClientTransport(CONTACTS_APP_NAME, envObject, { ...chainOptions, apiKey: initialKey });
+  if (!resolution.configured || !resolution.baseUrl) {
+    throw new ContactsClientConfigurationError("CONTACTS_API_NOT_CONFIGURED", `${resolution.issue ?? "The contacts API client is not configured."} ${SDK_HOSTED_ONLY}`);
+  }
+  const pinnedBaseUrl = resolution.baseUrl;
+  const baseFetch = clientOptions.fetch ?? globalThis.fetch;
+  const chainFetch = async (input, init) => {
+    const snapshot = { ...envObject };
+    const freshKey = resolveSdkCredential(snapshot, chainOptions);
+    const current = resolveContactsClientTransport(CONTACTS_APP_NAME, snapshot, { ...chainOptions, apiKey: freshKey });
+    if (!current.configured || current.baseUrl !== pinnedBaseUrl) {
+      throw new ContactsClientConfigurationError("CONTACTS_AUTHORITY_CHANGED", "Client authority changed or disappeared; construct a new client before sending data.");
+    }
+    const headers = new Headers(init?.headers);
+    headers.set("x-api-key", freshKey);
+    return baseFetch(input, { ...init, headers });
+  };
+  return new ContactsV1Client2({ ...clientOptions, baseUrl: pinnedBaseUrl, apiKey: initialKey, fetch: chainFetch });
+}
+
+// src/browser/identity.ts
+var EXTENSION_ID = "ceegpmbcoiomonopbhpifdalooccfgjj";
+
+// src/browser/protocol.ts
+class BrowserError extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "BrowserError";
+  }
+}
+function safeError(error) {
+  return error instanceof BrowserError ? error.code : "CONTACTS_UNAVAILABLE";
+}
+
+class NativeProtocol {
+  handlers;
+  buffer = Buffer.alloc(0);
+  queued = 0;
+  chain = Promise.resolve();
+  constructor(handlers) {
+    this.handlers = handlers;
+  }
+  accept(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    if (this.buffer.length > 1048576)
+      return this.handlers.fail();
+    while (this.buffer.length >= 4) {
+      const length = this.buffer.readUInt32LE(0);
+      if (!length || length > 65536)
+        return this.handlers.fail();
+      if (this.buffer.length < 4 + length)
+        break;
+      let message;
+      try {
+        message = JSON.parse(this.buffer.subarray(4, 4 + length).toString());
+      } catch {
+        return this.handlers.fail();
+      }
+      this.buffer = this.buffer.subarray(4 + length);
+      if (!message || typeof message.id !== "string" || !/^[0-9a-f-]{36}$/.test(message.id))
+        return this.handlers.fail();
+      if (++this.queued > 32)
+        return this.handlers.fail();
+      this.chain = this.chain.then(async () => {
+        try {
+          const result = await this.handlers.handle(message);
+          this.handlers.send({ id: message.id, ok: true, result });
+        } catch (e) {
+          this.handlers.send({ id: message.id, ok: false, error: safeError(e) });
+        } finally {
+          this.queued--;
+        }
+      });
+    }
+  }
+  async idle() {
+    await this.chain;
+  }
+}
+function encodeFrame(value) {
+  const body = Buffer.from(JSON.stringify(value));
+  if (body.length > 512000)
+    throw new BrowserError("RESPONSE_TOO_LARGE");
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(body.length);
+  return Buffer.concat([header, body]);
+}
+
+// src/browser/values.ts
+function rec(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text(value, max = 200) {
+  return typeof value === "string" && value.length <= max ? value.trim() : "";
+}
+function list(value) {
+  return Array.isArray(value) ? value.map(rec).filter((x) => x !== null) : [];
+}
+function primary(items) {
+  return items.find((x) => x.is_primary === true) ?? items[0] ?? null;
+}
+function contactId(value) {
+  if (typeof value !== "string" || !/^[a-zA-Z0-9_-]{1,128}$/.test(value))
+    throw new BrowserError("CONTACT_NOT_FOUND");
+  return value;
+}
+function searchQuery(value) {
+  if (value === undefined || value === null)
+    return "";
+  if (typeof value !== "string")
+    throw new BrowserError("INVALID_QUERY");
+  return value.trim().slice(0, 200);
+}
+var REGION_NAMES = (() => {
+  try {
+    return new Intl.DisplayNames(["en"], { type: "region" });
+  } catch {
+    return null;
+  }
+})();
+var REGION_CODES = "AD AE AF AG AI AL AM AO AQ AR AS AT AU AW AX AZ BA BB BD BE BF BG BH BI BJ BL BM BN BO BQ BR BS BT BV BW BY BZ CA CC CD CF CG CH CI CK CL CM CN CO CR CU CV CW CX CY CZ DE DJ DK DM DO DZ EC EE EG EH ER ES ET FI FJ FK FM FO FR GA GB GD GE GF GG GH GI GL GM GN GP GQ GR GS GT GU GW GY HK HM HN HR HT HU ID IE IL IM IN IO IQ IR IS IT JE JM JO JP KE KG KH KI KM KN KP KR KW KY KZ LA LB LC LI LK LR LS LT LU LV LY MA MC MD ME MF MG MH MK ML MM MN MO MP MQ MR MS MT MU MV MW MX MY MZ NA NC NE NF NG NI NL NO NP NR NU NZ OM PA PE PF PG PH PK PL PM PN PR PS PT PW PY QA RE RO RS RU RW SA SB SC SD SE SG SH SI SJ SK SL SM SN SO SR SS ST SV SX SY SZ TC TD TF TG TH TJ TK TL TM TN TO TR TT TV TW TZ UA UG UM US UY UZ VA VC VE VG VI VN VU WF WS YE YT ZA ZM ZW".split(" ");
+var ALIAS_NAMES = {
+  usa: "US",
+  unitedstates: "US",
+  unitedstatesofamerica: "US",
+  uk: "GB",
+  unitedkingdom: "GB",
+  greatbritain: "GB",
+  england: "GB",
+  romania: "RO",
+  germany: "DE",
+  france: "FR",
+  spain: "ES",
+  italy: "IT",
+  netherlands: "NL",
+  thenetherlands: "NL"
+};
+function countryCode(value) {
+  const raw = value.trim();
+  if (!raw)
+    return "";
+  if (/^[A-Za-z]{2}$/.test(raw))
+    return raw.toUpperCase();
+  const norm = raw.toLowerCase().replace(/[^a-z]/g, "");
+  if (ALIAS_NAMES[norm])
+    return ALIAS_NAMES[norm];
+  if (REGION_NAMES) {
+    for (const code of REGION_CODES) {
+      let name;
+      try {
+        name = REGION_NAMES.of(code);
+      } catch {
+        name = undefined;
+      }
+      if (name && name.toLowerCase().replace(/[^a-z]/g, "") === norm)
+        return code;
+    }
+  }
+  return raw;
+}
+function contactSummary(contact) {
+  const c = rec(contact);
+  if (!c || typeof c.id !== "string")
+    return null;
+  const email = primary(list(c.emails));
+  const company = rec(c.company);
+  const name = text(c.display_name) || [text(c.first_name), text(c.last_name)].filter(Boolean).join(" ") || text(c.nickname) || "Unnamed contact";
+  return { id: c.id, name, company: text(company?.name, 120), email: text(email?.address, 254) };
+}
+function contactValues(contact) {
+  const c = rec(contact);
+  if (!c)
+    throw new BrowserError("CONTACT_NOT_FOUND");
+  const out = {};
+  const set = (key, value, max = 200) => {
+    const v = text(value, max);
+    if (v)
+      out[key] = v;
+  };
+  const first = text(c.first_name);
+  const last = text(c.last_name);
+  set("given-name", first);
+  set("family-name", last);
+  set("name", text(c.display_name) || [first, last].filter(Boolean).join(" "));
+  set("nickname", c.nickname);
+  set("organization", rec(c.company)?.name, 120);
+  set("organization-title", c.job_title, 120);
+  set("url", c.website, 2048);
+  const email = primary(list(c.emails));
+  set("email", email?.address, 254);
+  const phone = primary(list(c.phones));
+  if (phone) {
+    const number = text(phone.number, 40);
+    const code = text(phone.country_code, 6);
+    if (number)
+      out.tel = code && !number.startsWith("+") ? `${code.startsWith("+") ? code : `+${code}`} ${number}`.trim() : number;
+  }
+  const address = primary(list(c.addresses));
+  if (address) {
+    const street = text(address.street, 300);
+    if (street) {
+      const lines = street.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+      out["street-address"] = lines.join(`
+`);
+      out["address-line1"] = lines[0] ?? street;
+      if (lines[1])
+        out["address-line2"] = lines.slice(1).join(", ");
+    }
+    set("address-level2", address.city, 120);
+    set("address-level1", address.state, 120);
+    set("postal-code", address.zip, 40);
+    const country = text(address.country, 120);
+    if (country)
+      out.country = countryCode(country);
+  }
+  const birthday = text(c.birthday, 40);
+  if (/^\d{4}-\d{2}-\d{2}/.test(birthday))
+    out.bday = birthday.slice(0, 10);
+  return out;
+}
+
+// src/browser/native.ts
+var version = (() => {
+  try {
+    return createRequire(import.meta.url)("../../package.json").version;
+  } catch {
+    return "unknown";
+  }
+})();
+if (process.argv[2] !== `chrome-extension://${EXTENSION_ID}/` || process.stdout.isTTY)
+  process.exit(1);
+var client = null;
+var configured = null;
+function api() {
+  if (client)
+    return client;
+  if (configured)
+    throw new BrowserError(configured);
+  try {
+    client = createContactsClient();
+    return client;
+  } catch (error) {
+    configured = error instanceof ContactsClientConfigurationError ? "CONTACTS_NOT_CONFIGURED" : "CONTACTS_UNAVAILABLE";
+    throw new BrowserError(configured);
+  }
+}
+var browserId;
+function send(value) {
+  process.stdout.write(encodeFrame(value));
+}
+process.stdin.on("end", () => process.exit(0));
+process.stdin.on("error", () => process.exit(1));
+process.stdout.on("error", () => process.exit(1));
+async function handle(message) {
+  if (message.op === "hello") {
+    if (typeof message.browserId !== "string" || !/^[0-9a-f-]{36}$/.test(message.browserId))
+      throw new BrowserError("INVALID_BROWSER_ID");
+    browserId = message.browserId;
+    return { browserId, version };
+  }
+  if (!browserId)
+    throw new BrowserError("HELLO_REQUIRED");
+  if (message.op === "status")
+    return { browserId, version, configured: configured === null };
+  if (message.op === "search") {
+    const query = searchQuery(message.query);
+    const response = query ? await api().listContacts({ q: query, limit: 20 }) : await api().listContacts({ limit: 20, ...{ order_by: "updated_at", order_dir: "desc" } });
+    const contacts = Array.isArray(response?.contacts) ? response.contacts : [];
+    return contacts.map(contactSummary).filter((x) => x !== null);
+  }
+  if (message.op === "resolve") {
+    const id = contactId(message.contactId);
+    let response = null;
+    try {
+      response = await api().getContact(id);
+    } catch (error) {
+      if (error instanceof BrowserError)
+        throw error;
+      if (error?.status === 404)
+        throw new BrowserError("CONTACT_NOT_FOUND");
+      throw new BrowserError("CONTACTS_UNAVAILABLE");
+    }
+    const contact = response?.contact ?? response;
+    if (!contact || contact.id !== id)
+      throw new BrowserError("CONTACT_NOT_FOUND");
+    return contactValues(contact);
+  }
+  throw new BrowserError("UNKNOWN_OPERATION");
+}
+var protocol = new NativeProtocol({ handle, send, fail: () => process.exit(1) });
+process.stdin.on("data", (chunk) => {
+  protocol.accept(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+});