@treeviz/familysearch-sdk 1.0.10

package/dist/index.cjs

@@ -0,0 +1,1689 @@
+'use strict';
+
+// src/client.ts
+var ENVIRONMENT_CONFIGS = {
+  production: {
+    identHost: "https://ident.familysearch.org",
+    platformHost: "https://api.familysearch.org"
+  },
+  beta: {
+    identHost: "https://identbeta.familysearch.org",
+    platformHost: "https://apibeta.familysearch.org"
+  },
+  integration: {
+    identHost: "https://identint.familysearch.org",
+    platformHost: "https://api-integ.familysearch.org"
+  }
+};
+var noopLogger = {
+  log: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var FamilySearchSDK = class {
+  constructor(config = {}) {
+    this.accessToken = null;
+    this.appKey = null;
+    this.environment = config.environment || "integration";
+    this.accessToken = config.accessToken || null;
+    this.appKey = config.appKey || null;
+    this.logger = config.logger || noopLogger;
+  }
+  /**
+   * Get the current environment
+   */
+  getEnvironment() {
+    return this.environment;
+  }
+  /**
+   * Set OAuth access token
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Clear access token
+   */
+  clearAccessToken() {
+    this.accessToken = null;
+  }
+  /**
+   * Check if SDK has a valid access token
+   */
+  hasAccessToken() {
+    return !!this.accessToken;
+  }
+  /**
+   * Get environment configuration
+   */
+  getConfig() {
+    return ENVIRONMENT_CONFIGS[this.environment];
+  }
+  /**
+   * Make authenticated API request
+   */
+  async request(url, options = {}) {
+    const config = this.getConfig();
+    const fullUrl = url.startsWith("http") ? url : `${config.platformHost}${url}`;
+    const headers = {
+      Accept: "application/json",
+      ...options.headers
+    };
+    const requiresAuth = fullUrl.includes("/platform/");
+    if (this.accessToken && requiresAuth) {
+      headers.Authorization = `Bearer ${this.accessToken}`;
+    }
+    if (this.appKey) {
+      headers["X-FS-App-Key"] = this.appKey;
+    }
+    this.logger.log(
+      `[FamilySearch SDK] ${options.method || "GET"} ${fullUrl}`
+    );
+    try {
+      const response = await fetch(fullUrl, {
+        ...options,
+        headers
+      });
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      let data;
+      const contentType = response.headers.get("content-type");
+      if (contentType && contentType.includes("application/json")) {
+        try {
+          data = await response.json();
+        } catch (error) {
+          this.logger.warn(
+            "[FamilySearch SDK] Failed to parse JSON response:",
+            error
+          );
+        }
+      }
+      const apiResponse = {
+        data,
+        statusCode: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders
+      };
+      if (!response.ok) {
+        const error = new Error(
+          `FamilySearch API error: ${response.status} ${response.statusText}`
+        );
+        error.statusCode = response.status;
+        error.response = apiResponse;
+        throw error;
+      }
+      return apiResponse;
+    } catch (error) {
+      this.logger.error("[FamilySearch SDK] Request failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(url, options = {}) {
+    return this.request(url, { ...options, method: "GET" });
+  }
+  /**
+   * POST request
+   */
+  async post(url, body, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    return this.request(url, {
+      ...options,
+      method: "POST",
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * PUT request
+   */
+  async put(url, body, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    return this.request(url, {
+      ...options,
+      method: "PUT",
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(url, options = {}) {
+    return this.request(url, { ...options, method: "DELETE" });
+  }
+  // ====================================
+  // User API
+  // ====================================
+  /**
+   * Get current authenticated user
+   */
+  async getCurrentUser() {
+    try {
+      const response = await this.get(
+        "/platform/users/current"
+      );
+      const user = response.data?.users?.[0];
+      return user || null;
+    } catch (error) {
+      this.logger.error(
+        "[FamilySearch SDK] Failed to get current user:",
+        error
+      );
+      return null;
+    }
+  }
+  // ====================================
+  // Tree/Pedigree API
+  // ====================================
+  /**
+   * Get person by ID
+   */
+  async getPerson(personId) {
+    try {
+      const response = await this.get(
+        `/platform/tree/persons/${personId}`
+      );
+      const person = response.data?.persons?.[0];
+      return person || null;
+    } catch (error) {
+      this.logger.error(
+        `[FamilySearch SDK] Failed to get person ${personId}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get person with full details including sources
+   */
+  async getPersonWithDetails(personId) {
+    try {
+      const response = await this.get(
+        `/platform/tree/persons/${personId}?sourceDescriptions=true`
+      );
+      return response.data || null;
+    } catch (error) {
+      this.logger.error(
+        `[FamilySearch SDK] Failed to get person details ${personId}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get notes for a person
+   */
+  async getPersonNotes(personId) {
+    try {
+      const response = await this.get(
+        `/platform/tree/persons/${personId}/notes`
+      );
+      return response.data || null;
+    } catch (error) {
+      this.logger.error(
+        `[FamilySearch SDK] Failed to get notes for ${personId}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get memories for a person
+   */
+  async getPersonMemories(personId) {
+    try {
+      const response = await this.get(
+        `/platform/tree/persons/${personId}/memories`
+      );
+      return response.data || null;
+    } catch (error) {
+      this.logger.error(
+        `[FamilySearch SDK] Failed to get memories for ${personId}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get couple relationship details
+   */
+  async getCoupleRelationship(relationshipId) {
+    try {
+      const response = await this.get(
+        `/platform/tree/couple-relationships/${relationshipId}`
+      );
+      return response.data || null;
+    } catch (error) {
+      this.logger.error(
+        `[FamilySearch SDK] Failed to get couple relationship ${relationshipId}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get child-and-parents relationship details
+   */
+  async getChildAndParentsRelationship(relationshipId) {
+    try {
+      const response = await this.get(
+        `/platform/tree/child-and-parents-relationships/${relationshipId}`
+      );
+      return response.data || null;
+    } catch (error) {
+      this.logger.error(
+        `[FamilySearch SDK] Failed to get child-and-parents relationship ${relationshipId}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get ancestry for a person
+   */
+  async getAncestry(personId, generations = 4) {
+    return this.get(
+      `/platform/tree/ancestry?person=${personId}&generations=${generations}`
+    );
+  }
+  /**
+   * Get descendancy for a person
+   */
+  async getDescendancy(personId, generations = 2) {
+    return this.get(
+      `/platform/tree/descendancy?person=${personId}&generations=${generations}`
+    );
+  }
+  /**
+   * Search for persons
+   */
+  async searchPersons(query, options = {}) {
+    const params = new URLSearchParams({
+      ...query,
+      ...options.start !== void 0 && {
+        start: options.start.toString()
+      },
+      ...options.count !== void 0 && {
+        count: options.count.toString()
+      }
+    });
+    return this.get(
+      `/platform/tree/search?${params.toString()}`
+    );
+  }
+  // ====================================
+  // Places API
+  // ====================================
+  /**
+   * Search for places
+   */
+  async searchPlaces(name, options = {}) {
+    try {
+      const params = new URLSearchParams({
+        name,
+        ...options.parentId && { parentId: options.parentId },
+        ...options.typeId && { typeId: options.typeId },
+        ...options.date && { date: options.date },
+        ...options.start !== void 0 && {
+          start: options.start.toString()
+        },
+        ...options.count !== void 0 && {
+          count: options.count.toString()
+        }
+      });
+      const response = await this.get(
+        `/platform/places/search?${params.toString()}`
+      );
+      return response.data || null;
+    } catch (error) {
+      this.logger.error(
+        "[FamilySearch SDK] Failed to search places:",
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Get place by ID
+   */
+  async getPlace(placeId) {
+    try {
+      const response = await this.get(
+        `/platform/places/${placeId}`
+      );
+      const place = response.data?.places?.[0];
+      return place || null;
+    } catch (error) {
+      this.logger.error(
+        `[FamilySearch SDK] Failed to get place ${placeId}:`,
+        error
+      );
+      return null;
+    }
+  }
+  // ====================================
+  // Import/Export API
+  // ====================================
+  /**
+   * Get GEDCOM export for a person and their ancestors
+   */
+  async exportGEDCOM(personId) {
+    try {
+      const response = await this.get(
+        `/platform/tree/persons/${personId}/gedcomx`,
+        {
+          headers: {
+            Accept: "application/x-gedcomx-v1+json"
+          }
+        }
+      );
+      return response.data || null;
+    } catch (error) {
+      this.logger.error(
+        "[FamilySearch SDK] Failed to export GEDCOM:",
+        error
+      );
+      return null;
+    }
+  }
+};
+var sdkInstance = null;
+function initFamilySearchSDK(config = {}) {
+  if (!sdkInstance) {
+    sdkInstance = new FamilySearchSDK(config);
+  } else {
+    if (config.accessToken !== void 0) {
+      sdkInstance.setAccessToken(config.accessToken);
+    }
+    if (config.environment !== void 0) {
+      sdkInstance = new FamilySearchSDK(config);
+    }
+  }
+  return sdkInstance;
+}
+function getFamilySearchSDK() {
+  if (!sdkInstance) {
+    sdkInstance = new FamilySearchSDK();
+  }
+  return sdkInstance;
+}
+function createFamilySearchSDK(config = {}) {
+  return new FamilySearchSDK(config);
+}
+function resetFamilySearchSDK() {
+  sdkInstance = null;
+}
+
+// src/auth/oauth.ts
+var OAUTH_ENDPOINTS = {
+  production: {
+    authorization: "https://ident.familysearch.org/cis-web/oauth2/v3/authorization",
+    token: "https://ident.familysearch.org/cis-web/oauth2/v3/token",
+    currentUser: "https://api.familysearch.org/platform/users/current"
+  },
+  beta: {
+    authorization: "https://identbeta.familysearch.org/cis-web/oauth2/v3/authorization",
+    token: "https://identbeta.familysearch.org/cis-web/oauth2/v3/token",
+    currentUser: "https://apibeta.familysearch.org/platform/users/current"
+  },
+  integration: {
+    authorization: "https://identint.familysearch.org/cis-web/oauth2/v3/authorization",
+    token: "https://identint.familysearch.org/cis-web/oauth2/v3/token",
+    currentUser: "https://api-integ.familysearch.org/platform/users/current"
+  }
+};
+function getOAuthEndpoints(environment = "integration") {
+  return OAUTH_ENDPOINTS[environment];
+}
+function generateOAuthState() {
+  const array = new Uint8Array(32);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function buildAuthorizationUrl(config, state, options = {}) {
+  const endpoints = getOAuthEndpoints(config.environment);
+  const url = new URL(endpoints.authorization);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", config.clientId);
+  url.searchParams.set("redirect_uri", config.redirectUri);
+  url.searchParams.set("state", state);
+  if (options.scopes && options.scopes.length > 0) {
+    url.searchParams.set("scope", options.scopes.join(" "));
+  }
+  if (options.prompt) {
+    url.searchParams.set("prompt", options.prompt);
+  }
+  return url.toString();
+}
+async function exchangeCodeForToken(code, config) {
+  const endpoints = getOAuthEndpoints(config.environment);
+  const response = await fetch(endpoints.token, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      client_id: config.clientId,
+      redirect_uri: config.redirectUri
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Failed to exchange code for token: ${error}`);
+  }
+  return response.json();
+}
+async function refreshAccessToken(refreshToken, config) {
+  const endpoints = getOAuthEndpoints(config.environment);
+  const response = await fetch(endpoints.token, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: config.clientId
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Failed to refresh token: ${error}`);
+  }
+  return response.json();
+}
+async function validateAccessToken(accessToken, environment = "integration") {
+  const endpoints = getOAuthEndpoints(environment);
+  try {
+    const response = await fetch(endpoints.currentUser, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json"
+      }
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function getUserInfo(accessToken, environment = "integration") {
+  const endpoints = getOAuthEndpoints(environment);
+  try {
+    const response = await fetch(endpoints.currentUser, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const fsUser = data.users?.[0];
+    if (!fsUser || !fsUser.id) {
+      return null;
+    }
+    return {
+      sub: fsUser.id,
+      name: fsUser.contactName || fsUser.displayName,
+      given_name: fsUser.givenName,
+      family_name: fsUser.familyName,
+      email: fsUser.email,
+      email_verified: fsUser.email ? true : false
+    };
+  } catch {
+    return null;
+  }
+}
+var OAUTH_STORAGE_KEYS = {
+  state: "fs_oauth_state",
+  linkMode: "fs_oauth_link_mode",
+  lang: "fs_oauth_lang",
+  parentUid: "fs_oauth_parent_uid"
+};
+function storeOAuthState(state, options = {}) {
+  if (typeof localStorage === "undefined") {
+    throw new Error(
+      "localStorage is not available. For server-side usage, implement custom state storage."
+    );
+  }
+  localStorage.setItem(OAUTH_STORAGE_KEYS.state, state);
+  if (options.isLinkMode) {
+    localStorage.setItem(OAUTH_STORAGE_KEYS.linkMode, "true");
+  } else {
+    localStorage.removeItem(OAUTH_STORAGE_KEYS.linkMode);
+  }
+  if (options.lang) {
+    localStorage.setItem(OAUTH_STORAGE_KEYS.lang, options.lang);
+  } else {
+    localStorage.removeItem(OAUTH_STORAGE_KEYS.lang);
+  }
+  if (options.parentUid) {
+    localStorage.setItem(OAUTH_STORAGE_KEYS.parentUid, options.parentUid);
+  } else {
+    localStorage.removeItem(OAUTH_STORAGE_KEYS.parentUid);
+  }
+}
+function validateOAuthState(state) {
+  if (typeof localStorage === "undefined") {
+    return { valid: false, isLinkMode: false };
+  }
+  const storedState = localStorage.getItem(OAUTH_STORAGE_KEYS.state);
+  const isLinkMode = localStorage.getItem(OAUTH_STORAGE_KEYS.linkMode) === "true";
+  const lang = localStorage.getItem(OAUTH_STORAGE_KEYS.lang) || void 0;
+  const parentUid = localStorage.getItem(OAUTH_STORAGE_KEYS.parentUid) || void 0;
+  localStorage.removeItem(OAUTH_STORAGE_KEYS.state);
+  localStorage.removeItem(OAUTH_STORAGE_KEYS.linkMode);
+  localStorage.removeItem(OAUTH_STORAGE_KEYS.lang);
+  localStorage.removeItem(OAUTH_STORAGE_KEYS.parentUid);
+  return {
+    valid: storedState === state,
+    isLinkMode,
+    lang,
+    parentUid
+  };
+}
+function openOAuthPopup(authUrl, options = {}) {
+  if (typeof window === "undefined") {
+    throw new Error("window is not available");
+  }
+  const width = options.width || 500;
+  const height = options.height || 600;
+  const windowName = options.windowName || "FamilySearch Login";
+  const left = window.screenX + (window.outerWidth - width) / 2;
+  const top = window.screenY + (window.outerHeight - height) / 2;
+  const popup = window.open(
+    authUrl,
+    windowName,
+    `width=${width},height=${height},left=${left},top=${top},toolbar=no,location=no,status=no,menubar=no,scrollbars=yes,resizable=yes`
+  );
+  if (popup) {
+    popup.focus();
+  }
+  return popup;
+}
+function parseCallbackParams(url = typeof window !== "undefined" ? window.location.href : "") {
+  const urlObj = new URL(url);
+  const params = urlObj.searchParams;
+  return {
+    code: params.get("code") || void 0,
+    state: params.get("state") || void 0,
+    error: params.get("error") || void 0,
+    error_description: params.get("error_description") || void 0
+  };
+}
+function getTokenStorageKey(userId, type) {
+  return `fs_token_${userId}_${type}`;
+}
+function storeTokens(userId, tokens) {
+  if (typeof sessionStorage === "undefined" || typeof localStorage === "undefined") {
+    throw new Error("Storage APIs are not available");
+  }
+  sessionStorage.setItem(
+    getTokenStorageKey(userId, "access"),
+    tokens.accessToken
+  );
+  if (tokens.expiresAt) {
+    sessionStorage.setItem(
+      getTokenStorageKey(userId, "expires"),
+      tokens.expiresAt.toString()
+    );
+  }
+  if (tokens.refreshToken) {
+    localStorage.setItem(
+      getTokenStorageKey(userId, "refresh"),
+      tokens.refreshToken
+    );
+  }
+  if (tokens.environment) {
+    localStorage.setItem(
+      getTokenStorageKey(userId, "environment"),
+      tokens.environment
+    );
+  }
+}
+function getStoredAccessToken(userId) {
+  if (typeof sessionStorage === "undefined") {
+    return null;
+  }
+  const token = sessionStorage.getItem(getTokenStorageKey(userId, "access"));
+  const expiresAt = sessionStorage.getItem(
+    getTokenStorageKey(userId, "expires")
+  );
+  if (!token) {
+    return null;
+  }
+  const EXPIRATION_BUFFER = 5 * 60 * 1e3;
+  if (expiresAt && Date.now() > parseInt(expiresAt) - EXPIRATION_BUFFER) {
+    return null;
+  }
+  return token;
+}
+function getStoredRefreshToken(userId) {
+  if (typeof localStorage === "undefined") {
+    return null;
+  }
+  return localStorage.getItem(getTokenStorageKey(userId, "refresh"));
+}
+function clearStoredTokens(userId) {
+  if (typeof sessionStorage !== "undefined") {
+    sessionStorage.removeItem(getTokenStorageKey(userId, "access"));
+    sessionStorage.removeItem(getTokenStorageKey(userId, "expires"));
+  }
+  if (typeof localStorage !== "undefined") {
+    localStorage.removeItem(getTokenStorageKey(userId, "refresh"));
+    localStorage.removeItem(getTokenStorageKey(userId, "environment"));
+  }
+}
+function clearAllTokens() {
+  if (typeof sessionStorage === "undefined" || typeof localStorage === "undefined") {
+    return;
+  }
+  const keysToRemove = [];
+  for (let i = 0; i < sessionStorage.length; i++) {
+    const key = sessionStorage.key(i);
+    if (key && key.startsWith("fs_token_")) {
+      keysToRemove.push(key);
+    }
+  }
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (key && key.startsWith("fs_token_")) {
+      keysToRemove.push(key);
+    }
+  }
+  keysToRemove.forEach((key) => {
+    sessionStorage.removeItem(key);
+    localStorage.removeItem(key);
+  });
+}
+
+// src/places/places.ts
+async function searchPlaces(sdk, query, options) {
+  const queryParts = [`name:"${query}"`];
+  if (options?.date) {
+    queryParts.push(`+date:${options.date}`);
+  }
+  if (options?.parentId) {
+    queryParts.push(`+parentId:${options.parentId}`);
+  }
+  const finalQuery = queryParts.join(" ");
+  const params = new URLSearchParams({
+    q: finalQuery,
+    ...options?.count && { count: options.count.toString() },
+    ...options?.start && { start: options.start.toString() }
+  });
+  const response = await sdk.get(
+    `/platform/places/search?${params.toString()}`
+  );
+  const data = response.data || {};
+  if (!data?.entries?.length) {
+    if (options?.date) {
+      const { date: _date, ...optionsWithoutDate } = options;
+      return searchPlaces(sdk, query, optionsWithoutDate);
+    }
+    return [];
+  }
+  return data.entries?.map((entry) => {
+    const place = entry.content?.gedcomx?.places?.[0];
+    return {
+      id: place?.id || entry.id,
+      title: entry.title,
+      fullyQualifiedName: entry.title,
+      names: place?.names,
+      standardized: place?.jurisdiction ? {
+        id: place.jurisdiction.id,
+        fullyQualifiedName: place.jurisdiction.name
+      } : void 0,
+      jurisdiction: place?.jurisdiction,
+      temporalDescription: place?.temporalDescription
+    };
+  }) || [];
+}
+async function getPlaceById(sdk, id) {
+  const response = await sdk.get(
+    `/platform/places/${id}`
+  );
+  return response.data?.places?.[0] || null;
+}
+async function getPlaceChildren(sdk, id, options) {
+  const params = new URLSearchParams({
+    ...options?.count && { count: options.count.toString() },
+    ...options?.start && { start: options.start.toString() }
+  });
+  const queryString = params.toString();
+  const url = `/platform/places/${id}/children${queryString ? `?${queryString}` : ""}`;
+  const response = await sdk.get(url);
+  const data = response.data || {};
+  return data.entries?.map((entry) => {
+    const place = entry.content?.gedcomx?.places?.[0];
+    return {
+      id: place?.id || entry.id,
+      title: entry.title,
+      fullyQualifiedName: entry.title,
+      names: place?.names,
+      jurisdiction: place?.jurisdiction
+    };
+  }) || [];
+}
+async function getPlaceDetails(sdk, id) {
+  const place = await getPlaceById(sdk, id);
+  if (!place) {
+    return null;
+  }
+  const primaryName = place.names?.find((n) => n.lang === "en")?.value || place.names?.[0]?.value || "";
+  const aliases = place.names?.filter((n) => n.value !== primaryName).map((n) => n.value || "").filter(Boolean) || [];
+  return {
+    id: place.id || id,
+    name: primaryName,
+    standardizedName: place.jurisdiction?.name,
+    aliases,
+    latitude: place.latitude,
+    longitude: place.longitude,
+    jurisdiction: place.jurisdiction?.name
+  };
+}
+
+// src/tree/pedigree.ts
+async function fetchPedigree(sdk, personId, options = {}) {
+  const {
+    generations = 4,
+    onProgress,
+    includeDetails = true,
+    includeNotes = true,
+    includeRelationshipDetails = true
+  } = options;
+  let targetPersonId = personId;
+  if (!targetPersonId) {
+    onProgress?.({
+      stage: "getting_current_user",
+      current: 0,
+      total: 1,
+      percent: 0
+    });
+    const currentUser = await sdk.getCurrentUser();
+    targetPersonId = currentUser?.personId || currentUser?.treeUserId || currentUser?.id;
+    if (!targetPersonId) {
+      throw new Error("Could not determine person ID for current user");
+    }
+  }
+  onProgress?.({
+    stage: "fetching_ancestry_structure",
+    current: 1,
+    total: 3,
+    percent: 10
+  });
+  const ancestryResponse = await sdk.getAncestry(targetPersonId, generations);
+  const ancestry = ancestryResponse.data;
+  if (!ancestry.persons || ancestry.persons.length === 0) {
+    throw new Error("No persons found in ancestry");
+  }
+  onProgress?.({
+    stage: "fetching_person_details",
+    current: 0,
+    total: ancestry.persons.length,
+    percent: 20
+  });
+  const personsWithDetails = [];
+  for (let i = 0; i < ancestry.persons.length; i++) {
+    const person = ancestry.persons[i];
+    onProgress?.({
+      stage: "fetching_person_details",
+      current: i + 1,
+      total: ancestry.persons.length,
+      percent: 20 + Math.floor((i + 1) / ancestry.persons.length * 45)
+    });
+    try {
+      const enhanced = { ...person };
+      if (includeDetails) {
+        enhanced.fullDetails = await sdk.getPersonWithDetails(
+          person.id
+        );
+      }
+      if (includeNotes) {
+        enhanced.notes = await sdk.getPersonNotes(
+          person.id
+        );
+      }
+      personsWithDetails.push(enhanced);
+    } catch {
+      personsWithDetails.push(person);
+    }
+  }
+  onProgress?.({
+    stage: "fetching_relationship_details",
+    current: 0,
+    total: ancestry.relationships?.length || 0,
+    percent: 65
+  });
+  const relationshipsWithDetails = [];
+  if (ancestry.relationships && includeRelationshipDetails) {
+    for (let i = 0; i < ancestry.relationships.length; i++) {
+      const rel = ancestry.relationships[i];
+      onProgress?.({
+        stage: "fetching_relationship_details",
+        current: i + 1,
+        total: ancestry.relationships.length,
+        percent: 65 + Math.floor((i + 1) / ancestry.relationships.length * 25)
+      });
+      try {
+        if (rel.type?.includes?.("Couple")) {
+          const relDetails = await sdk.getCoupleRelationship(rel.id);
+          relationshipsWithDetails.push({
+            ...rel,
+            details: relDetails
+          });
+        } else {
+          relationshipsWithDetails.push(rel);
+        }
+      } catch {
+        relationshipsWithDetails.push(rel);
+      }
+    }
+  } else if (ancestry.relationships) {
+    relationshipsWithDetails.push(...ancestry.relationships);
+  }
+  onProgress?.({
+    stage: "extracting_additional_relationships",
+    current: 0,
+    total: 1,
+    percent: 90
+  });
+  const allRelationships = [...relationshipsWithDetails];
+  const relationshipIds = new Set(relationshipsWithDetails.map((r) => r.id));
+  personsWithDetails.forEach((person) => {
+    const childAndParentsRels = person.fullDetails?.childAndParentsRelationships;
+    if (childAndParentsRels && Array.isArray(childAndParentsRels)) {
+      childAndParentsRels.forEach((rel) => {
+        if (!relationshipIds.has(rel.id)) {
+          relationshipIds.add(rel.id);
+          allRelationships.push({
+            id: rel.id,
+            type: "http://gedcomx.org/ParentChild",
+            person1: rel.parent1,
+            person2: rel.child,
+            parent2: rel.parent2
+          });
+        }
+      });
+    }
+    const relationships = person.fullDetails?.relationships;
+    if (relationships && Array.isArray(relationships)) {
+      relationships.forEach((rel) => {
+        if (rel.type?.includes?.("Couple") && !relationshipIds.has(rel.id)) {
+          relationshipIds.add(rel.id);
+          allRelationships.push({
+            id: rel.id,
+            type: rel.type,
+            person1: rel.person1,
+            person2: rel.person2,
+            facts: rel.facts
+          });
+        }
+      });
+    }
+  });
+  onProgress?.({
+    stage: "completing_data_fetch",
+    current: 1,
+    total: 1,
+    percent: 98
+  });
+  return {
+    persons: personsWithDetails,
+    relationships: allRelationships,
+    environment: sdk.getEnvironment()
+  };
+}
+async function getCurrentUser(sdk) {
+  return sdk.getCurrentUser();
+}
+async function getPersonWithDetails(sdk, personId) {
+  try {
+    const [details, notes] = await Promise.all([
+      sdk.getPersonWithDetails(personId),
+      sdk.getPersonNotes(personId)
+    ]);
+    if (!details) {
+      return null;
+    }
+    const fullDetails = details;
+    const personData = fullDetails?.persons?.[0];
+    if (!personData) {
+      return null;
+    }
+    return {
+      ...personData,
+      fullDetails,
+      notes
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchMultiplePersons(sdk, personIds) {
+  const pids = personIds.join(",");
+  const response = await sdk.get(`/platform/tree/persons?pids=${pids}`);
+  return response.data;
+}
+
+// src/utils/gedcom-converter.ts
+function transformFamilySearchUrl(url) {
+  if (!url.includes("/platform/tree/persons/")) {
+    return url;
+  }
+  const personId = url.match(/persons\/([^/?]+)/)?.[1];
+  if (!personId) {
+    return url;
+  }
+  let baseUrl = "https://www.familysearch.org";
+  if (url.includes("integration.familysearch.org") || url.includes("api-integ.familysearch.org")) {
+    baseUrl = "https://integration.familysearch.org";
+  } else if (url.includes("beta.familysearch.org") || url.includes("apibeta.familysearch.org")) {
+    baseUrl = "https://beta.familysearch.org";
+  }
+  return `${baseUrl}/tree/person/${personId}`;
+}
+function transformSourceUrl(url) {
+  if (!url) return url;
+  if (!url.includes("/platform/") && url.includes("ark:")) {
+    return url;
+  }
+  const arkMatch = url.match(/ark:\/[^/?]+\/[^/?]+/);
+  if (!arkMatch) {
+    return url;
+  }
+  const arkId = arkMatch[0];
+  let baseUrl = "https://www.familysearch.org";
+  if (url.includes("integration.familysearch.org") || url.includes("api-integ.familysearch.org")) {
+    baseUrl = "https://integration.familysearch.org";
+  } else if (url.includes("beta.familysearch.org") || url.includes("apibeta.familysearch.org")) {
+    baseUrl = "https://beta.familysearch.org";
+  }
+  return `${baseUrl}/${arkId}`;
+}
+function extractName(person) {
+  if (!person) return null;
+  if (person.names?.[0]?.nameForms?.[0]) {
+    const nameForm = person.names[0].nameForms[0];
+    const parts = nameForm.parts || [];
+    const given = parts.find((p) => p.type?.includes("Given"))?.value || "";
+    const surname = parts.find((p) => p.type?.includes("Surname"))?.value || "";
+    if (given || surname) {
+      return `${given} /${surname}/`.trim();
+    }
+    if (nameForm.fullText) {
+      return nameForm.fullText;
+    }
+  }
+  if (person.display?.name) {
+    return person.display.name;
+  }
+  return null;
+}
+function extractGender(person) {
+  if (!person) return null;
+  if (person.gender?.type?.includes("Male")) {
+    return "M";
+  } else if (person.gender?.type?.includes("Female")) {
+    return "F";
+  } else if (person.display?.gender === "Male") {
+    return "M";
+  } else if (person.display?.gender === "Female") {
+    return "F";
+  }
+  return null;
+}
+function extractFact(person, factType) {
+  if (!person) return null;
+  const result = {};
+  const factTypeUrl = `http://gedcomx.org/${factType === "BIRTH" ? "Birth" : "Death"}`;
+  const fact = person.facts?.find((f) => f.type === factTypeUrl);
+  if (fact) {
+    if (fact.date?.formal || fact.date?.original) {
+      result.date = (fact.date?.formal || fact.date?.original)?.replace(
+        /^(-|\+)/,
+        ""
+      );
+    }
+    if (fact.place?.original) {
+      result.place = fact.place.original;
+    }
+  }
+  if (factType === "BIRTH") {
+    result.date = result.date || person.display?.birthDate;
+    result.place = result.place || person.display?.birthPlace;
+  } else if (factType === "DEATH") {
+    result.date = result.date || person.display?.deathDate;
+    result.place = result.place || person.display?.deathPlace;
+  }
+  return result.date || result.place ? result : null;
+}
+function formatDateForGedcom(date) {
+  const months = [
+    "JAN",
+    "FEB",
+    "MAR",
+    "APR",
+    "MAY",
+    "JUN",
+    "JUL",
+    "AUG",
+    "SEP",
+    "OCT",
+    "NOV",
+    "DEC"
+  ];
+  const day = date.getDate();
+  const month = months[date.getMonth()];
+  const year = date.getFullYear();
+  return `${day} ${month} ${year}`;
+}
+function convertFactToGedcom(fact) {
+  const lines = [];
+  if (!fact.type) return lines;
+  const typeMap = {
+    "http://gedcomx.org/Burial": "BURI",
+    "http://gedcomx.org/Christening": "CHR",
+    "http://gedcomx.org/Baptism": "BAPM",
+    "http://gedcomx.org/Marriage": "MARR",
+    "http://gedcomx.org/Divorce": "DIV",
+    "http://gedcomx.org/Residence": "RESI",
+    "http://gedcomx.org/Occupation": "OCCU",
+    "http://gedcomx.org/Immigration": "IMMI",
+    "http://gedcomx.org/Emigration": "EMIG",
+    "http://gedcomx.org/Naturalization": "NATU",
+    "http://gedcomx.org/Census": "CENS"
+  };
+  const gedcomTag = typeMap[fact.type] || "EVEN";
+  if (gedcomTag === "OCCU" && fact.value) {
+    lines.push(`1 OCCU ${fact.value}`);
+  } else {
+    lines.push(`1 ${gedcomTag}`);
+  }
+  if (fact.links?.conclusion?.href) {
+    const webUrl = transformFamilySearchUrl(fact.links.conclusion.href);
+    lines.push(`2 _FS_LINK ${webUrl}`);
+  }
+  if (fact.date?.formal || fact.date?.original) {
+    lines.push(
+      `2 DATE ${(fact.date?.formal || fact.date?.original)?.replace(/^(-|\+)/, "")}`
+    );
+  }
+  if (fact.place?.original) {
+    lines.push(`2 PLAC ${fact.place.original}`);
+  }
+  if (fact.value && gedcomTag !== "OCCU") {
+    lines.push(`2 NOTE ${fact.value}`);
+  }
+  return lines;
+}
+function convertToGedcom(pedigreeData, options = {}) {
+  const {
+    treeName = "FamilySearch Import",
+    includeLinks = true,
+    includeNotes = true,
+    environment = "production"
+  } = options;
+  if (!pedigreeData || !pedigreeData.persons) {
+    throw new Error("Invalid FamilySearch data: no persons found");
+  }
+  const lines = [];
+  lines.push("0 HEAD");
+  lines.push("1 SOUR FamilySearch");
+  lines.push("2 VERS 1.0");
+  lines.push("2 NAME FamilySearch API");
+  lines.push("1 DEST ANY");
+  lines.push("1 DATE " + formatDateForGedcom(/* @__PURE__ */ new Date()));
+  lines.push("1 SUBM @SUBM1@");
+  lines.push("1 FILE " + treeName);
+  lines.push("1 GEDC");
+  lines.push("2 VERS 5.5");
+  lines.push("2 FORM LINEAGE-LINKED");
+  lines.push("1 CHAR UTF-8");
+  lines.push("0 @SUBM1@ SUBM");
+  const sourceMap = /* @__PURE__ */ new Map();
+  let sourceCounter = 1;
+  pedigreeData.persons.forEach((person) => {
+    const sourceDescriptions = person.fullDetails?.sourceDescriptions;
+    if (sourceDescriptions && Array.isArray(sourceDescriptions)) {
+      sourceDescriptions.forEach((source) => {
+        if (source.id && !sourceMap.has(source.id)) {
+          sourceMap.set(source.id, source);
+        }
+      });
+    }
+  });
+  sourceMap.forEach((source) => {
+    const sourceId = `@S${sourceCounter++}@`;
+    lines.push(`0 ${sourceId} SOUR`);
+    const title = source.titles?.[0]?.value || "FamilySearch Source";
+    lines.push(`1 TITL ${title}`);
+    if (source.citations?.[0]?.value) {
+      lines.push(`1 TEXT ${source.citations[0].value}`);
+    }
+    if (source.about) {
+      const webUrl = transformSourceUrl(source.about);
+      lines.push(`1 WWW ${webUrl}`);
+    }
+    if (source.resourceType) {
+      lines.push(`1 NOTE Resource Type: ${source.resourceType}`);
+    }
+  });
+  const personIdMap = /* @__PURE__ */ new Map();
+  pedigreeData.persons.forEach((person, index) => {
+    const gedcomId = `@I${index + 1}@`;
+    personIdMap.set(person.id, gedcomId);
+  });
+  const families = /* @__PURE__ */ new Map();
+  const childToParents = /* @__PURE__ */ new Map();
+  const allRelationships = [
+    ...pedigreeData.relationships || []
+  ];
+  pedigreeData.persons.forEach((person) => {
+    const personRelationships = person.fullDetails?.relationships;
+    if (personRelationships && Array.isArray(personRelationships)) {
+      personRelationships.forEach((rel) => {
+        const exists = allRelationships.some((r) => r.id === rel.id);
+        if (!exists) {
+          allRelationships.push(rel);
+        }
+      });
+    }
+    const childAndParentsRels = person.fullDetails?.childAndParentsRelationships;
+    if (childAndParentsRels && Array.isArray(childAndParentsRels)) {
+      childAndParentsRels.forEach((capRel) => {
+        if (capRel.parent1 && capRel.child) {
+          const rel = {
+            id: `${capRel.id}-p1`,
+            type: "http://gedcomx.org/ParentChild",
+            person1: { resourceId: capRel.parent1.resourceId },
+            person2: { resourceId: capRel.child.resourceId },
+            parent2: capRel.parent2 ? { resourceId: capRel.parent2.resourceId } : void 0
+          };
+          const exists = allRelationships.some(
+            (r) => r.id === rel.id
+          );
+          if (!exists) {
+            allRelationships.push(rel);
+          }
+        }
+        if (capRel.parent2 && capRel.child) {
+          const rel = {
+            id: `${capRel.id}-p2`,
+            type: "http://gedcomx.org/ParentChild",
+            person1: { resourceId: capRel.parent2.resourceId },
+            person2: { resourceId: capRel.child.resourceId },
+            parent2: capRel.parent1 ? { resourceId: capRel.parent1.resourceId } : void 0
+          };
+          const exists = allRelationships.some(
+            (r) => r.id === rel.id
+          );
+          if (!exists) {
+            allRelationships.push(rel);
+          }
+        }
+      });
+    }
+  });
+  const validPersonIds = new Set(pedigreeData.persons.map((p) => p.id));
+  allRelationships.forEach((rel) => {
+    if (rel.type?.includes("ParentChild")) {
+      const parentId = rel.person1?.resourceId;
+      const childId = rel.person2?.resourceId;
+      const parent2Id = rel.parent2?.resourceId;
+      if (!parentId || !childId) {
+        return;
+      }
+      if (!validPersonIds.has(childId)) {
+        return;
+      }
+      const validParents = [];
+      if (validPersonIds.has(parentId)) {
+        validParents.push(parentId);
+      }
+      if (parent2Id && validPersonIds.has(parent2Id)) {
+        validParents.push(parent2Id);
+      }
+      if (validParents.length > 0) {
+        if (!childToParents.has(childId)) {
+          childToParents.set(childId, []);
+        }
+        const parents = childToParents.get(childId);
+        validParents.forEach((parentId2) => {
+          if (!parents.includes(parentId2)) {
+            parents.push(parentId2);
+          }
+        });
+      }
+    } else if (rel.type?.includes("Couple")) {
+      const person1 = rel.person1?.resourceId;
+      const person2 = rel.person2?.resourceId;
+      if (!person1 || !person2) {
+        return;
+      }
+      if (validPersonIds.has(person1) && validPersonIds.has(person2)) {
+        const famKey = [person1, person2].sort().join("-");
+        if (!families.has(famKey)) {
+          families.set(famKey, {
+            spouses: /* @__PURE__ */ new Set([person1, person2]),
+            children: []
+          });
+        }
+      }
+    }
+  });
+  childToParents.forEach((parents, childId) => {
+    if (parents.length >= 2) {
+      const famKey = parents.slice(0, 2).sort().join("-");
+      if (!families.has(famKey)) {
+        families.set(famKey, {
+          spouses: new Set(parents.slice(0, 2)),
+          children: []
+        });
+      }
+      families.get(famKey).children.push(childId);
+    } else if (parents.length === 1) {
+      const famKey = `single-${parents[0]}`;
+      if (!families.has(famKey)) {
+        families.set(famKey, {
+          spouses: /* @__PURE__ */ new Set([parents[0]]),
+          children: []
+        });
+      }
+      families.get(famKey).children.push(childId);
+    }
+  });
+  const connectablePersons = /* @__PURE__ */ new Set();
+  if (options.ancestryPersonIds && options.ancestryPersonIds.size > 0) {
+    options.ancestryPersonIds.forEach((personId) => {
+      connectablePersons.add(personId);
+    });
+    families.forEach((family) => {
+      const spouses = Array.from(family.spouses);
+      if (spouses.some((spouseId) => connectablePersons.has(spouseId))) {
+        spouses.forEach((spouseId) => connectablePersons.add(spouseId));
+      }
+    });
+    let addedNewPersons = true;
+    while (addedNewPersons) {
+      addedNewPersons = false;
+      const beforeSize = connectablePersons.size;
+      childToParents.forEach((parents, childId) => {
+        if (parents.some((parentId) => connectablePersons.has(parentId))) {
+          if (!connectablePersons.has(childId)) {
+            connectablePersons.add(childId);
+            addedNewPersons = true;
+          }
+        }
+      });
+      families.forEach((family) => {
+        const spouses = Array.from(family.spouses);
+        const hasConnectableSpouse = spouses.some(
+          (spouseId) => connectablePersons.has(spouseId)
+        );
+        const hasConnectableChild = family.children.some(
+          (childId) => connectablePersons.has(childId)
+        );
+        if (hasConnectableSpouse || hasConnectableChild) {
+          spouses.forEach((spouseId) => {
+            if (!connectablePersons.has(spouseId)) {
+              connectablePersons.add(spouseId);
+              addedNewPersons = true;
+            }
+          });
+        }
+      });
+      const afterSize = connectablePersons.size;
+      if (afterSize > beforeSize) {
+        addedNewPersons = afterSize !== beforeSize;
+      }
+    }
+  } else {
+    childToParents.forEach((parents, childId) => {
+      connectablePersons.add(childId);
+      parents.forEach((parentId) => connectablePersons.add(parentId));
+    });
+  }
+  const allowOrphanFamilies = options.allowOrphanFamilies === true;
+  const orphanFamKeys = /* @__PURE__ */ new Set();
+  const personToFamKeys = /* @__PURE__ */ new Map();
+  families.forEach((family, key) => {
+    const spouseArray = Array.from(family.spouses);
+    const anyMemberConnectable = spouseArray.some((spouseId) => connectablePersons.has(spouseId)) || family.children.some((childId) => connectablePersons.has(childId));
+    const isOrphanFamily = !anyMemberConnectable;
+    if (isOrphanFamily) {
+      orphanFamKeys.add(key);
+    }
+    spouseArray.forEach((spouseId) => {
+      if (!personToFamKeys.has(spouseId))
+        personToFamKeys.set(spouseId, /* @__PURE__ */ new Set());
+      personToFamKeys.get(spouseId).add(key);
+    });
+    family.children.forEach((childId) => {
+      if (!personToFamKeys.has(childId))
+        personToFamKeys.set(childId, /* @__PURE__ */ new Set());
+      personToFamKeys.get(childId).add(key);
+    });
+  });
+  pedigreeData.persons.forEach((person) => {
+    const gedcomId = personIdMap.get(person.id);
+    if (!gedcomId) {
+      console.warn(
+        `[GEDCOM] Person ${person.id} not found in personIdMap`
+      );
+      return;
+    }
+    if (!allowOrphanFamilies) {
+      const famKeys = personToFamKeys.get(person.id);
+      if (famKeys && famKeys.size > 0 && Array.from(famKeys).every((key) => orphanFamKeys.has(key))) {
+        return;
+      }
+    }
+    lines.push(`0 ${gedcomId} INDI`);
+    if (person.id) {
+      lines.push(`1 _FS_ID ${person.id}`);
+    }
+    if (includeLinks) {
+      const personLink = person.links?.person?.href || person.identifiers?.["http://gedcomx.org/Persistent"]?.[0];
+      if (personLink) {
+        const webUrl = transformFamilySearchUrl(personLink);
+        lines.push(`1 _FS_LINK ${webUrl}`);
+      } else if (person.id) {
+        let baseUrl = "https://www.familysearch.org";
+        if (environment === "beta") {
+          baseUrl = "https://beta.familysearch.org";
+        } else if (environment === "integration") {
+          baseUrl = "https://integration.familysearch.org";
+        }
+        const webUrl = `${baseUrl}/tree/person/${person.id}`;
+        lines.push(`1 _FS_LINK ${webUrl}`);
+      }
+    }
+    const personData = person.fullDetails?.persons?.[0] || person;
+    const name = extractName(personData);
+    if (name) {
+      lines.push(`1 NAME ${name}`);
+    }
+    const gender = extractGender(personData);
+    if (gender) {
+      lines.push(`1 SEX ${gender}`);
+    }
+    const birth = extractFact(personData, "BIRTH");
+    if (birth) {
+      lines.push("1 BIRT");
+      if (birth.date) {
+        lines.push(`2 DATE ${birth.date}`);
+      }
+      if (birth.place) {
+        lines.push(`2 PLAC ${birth.place}`);
+      }
+    }
+    const death = extractFact(personData, "DEATH");
+    if (death) {
+      lines.push("1 DEAT");
+      if (death.date) {
+        lines.push(`2 DATE ${death.date}`);
+      }
+      if (death.place) {
+        lines.push(`2 PLAC ${death.place}`);
+      }
+    }
+    personData.facts?.forEach((fact) => {
+      if (fact.type && fact.type !== "http://gedcomx.org/Birth" && fact.type !== "http://gedcomx.org/Death") {
+        const factLines = convertFactToGedcom(fact);
+        factLines.forEach((line) => lines.push(line));
+      }
+    });
+    if (includeNotes && person.notes?.persons?.[0]?.notes) {
+      person.notes.persons[0].notes.forEach((note) => {
+        if (note.text) {
+          const noteText = note.text.replace(/\n/g, " ");
+          lines.push(`1 NOTE ${noteText}`);
+        }
+      });
+    }
+    const personSources = personData?.sources;
+    if (personSources && Array.isArray(personSources)) {
+      personSources.forEach((sourceRef) => {
+        const sourceId = sourceRef.descriptionId;
+        if (!sourceId) return;
+        const sourceIds = Array.from(sourceMap.keys());
+        const sourceIndex = sourceIds.indexOf(sourceId);
+        if (sourceIndex === -1) return;
+        const gedcomSourceId = `@S${sourceIndex + 1}@`;
+        lines.push(`1 SOUR ${gedcomSourceId}`);
+        if (sourceRef.qualifiers && Array.isArray(sourceRef.qualifiers)) {
+          sourceRef.qualifiers.forEach((qualifier) => {
+            if (qualifier.name && qualifier.value) {
+              lines.push(
+                `2 NOTE ${qualifier.name}: ${qualifier.value}`
+              );
+            }
+          });
+        }
+      });
+    }
+  });
+  let famIndex = 1;
+  const familyIdMap = /* @__PURE__ */ new Map();
+  families.forEach((family, key) => {
+    const spouseArray = Array.from(family.spouses);
+    const parentsInMap = spouseArray.filter((id) => personIdMap.has(id));
+    const hasNoParents = parentsInMap.length === 0;
+    const hasSingleParentNoChildren = parentsInMap.length === 1 && family.children.length === 0;
+    if (hasNoParents) {
+      if (family.children.length > 0) {
+        console.warn(
+          `[FS SDK GEDCOM] Skipping FAM for orphaned child(ren): ${family.children.length} child(ren) with 0 parents`
+        );
+      }
+      return;
+    }
+    if (hasSingleParentNoChildren) {
+      return;
+    }
+    const anyMemberConnectable = spouseArray.some((spouseId) => connectablePersons.has(spouseId)) || family.children.some((childId) => connectablePersons.has(childId));
+    const isOrphanFamily = !anyMemberConnectable;
+    if (isOrphanFamily && !allowOrphanFamilies) {
+      return;
+    }
+    const famId = `@F${famIndex++}@`;
+    familyIdMap.set(key, famId);
+    lines.push(`0 ${famId} FAM`);
+    if (isOrphanFamily && allowOrphanFamilies) {
+      lines.push(`1 _IS_ORPHAN_FAMILY Y`);
+    }
+    if (spouseArray.length === 2) {
+      const [person1, person2] = spouseArray;
+      const person1Data = pedigreeData.persons?.find(
+        (p) => p.id === person1
+      );
+      const person2Data = pedigreeData.persons?.find(
+        (p) => p.id === person2
+      );
+      const gender1 = extractGender(
+        person1Data?.fullDetails?.persons?.[0] || person1Data
+      );
+      const gender2 = extractGender(
+        person2Data?.fullDetails?.persons?.[0] || person2Data
+      );
+      const p1 = personIdMap.get(person1);
+      const p2 = personIdMap.get(person2);
+      if (gender1 === "M" || gender2 === "F") {
+        if (p1) lines.push(`1 HUSB ${p1}`);
+        if (p2) lines.push(`1 WIFE ${p2}`);
+      } else {
+        if (p2) lines.push(`1 HUSB ${p2}`);
+        if (p1) lines.push(`1 WIFE ${p1}`);
+      }
+      addMarriageFacts(lines, allRelationships, person1, person2);
+    } else if (spouseArray.length === 1) {
+      const parentData = pedigreeData.persons?.find(
+        (p) => p.id === spouseArray[0]
+      );
+      const gender = extractGender(
+        parentData?.fullDetails?.persons?.[0] || parentData
+      );
+      if (gender === "M") {
+        lines.push(`1 HUSB ${personIdMap.get(spouseArray[0])}`);
+      } else {
+        lines.push(`1 WIFE ${personIdMap.get(spouseArray[0])}`);
+      }
+    }
+    family.children.forEach((childId) => {
+      const childGedcomId = personIdMap.get(childId);
+      if (childGedcomId) {
+        lines.push(`1 CHIL ${childGedcomId}`);
+      }
+    });
+  });
+  childToParents.forEach((parents, childId) => {
+    const childGedcomId = personIdMap.get(childId);
+    if (!childGedcomId) return;
+    let famId;
+    if (parents.length >= 2) {
+      const famKey = parents.slice(0, 2).sort().join("-");
+      famId = familyIdMap.get(famKey);
+    } else if (parents.length === 1) {
+      const famKey = `single-${parents[0]}`;
+      famId = familyIdMap.get(famKey);
+    }
+    if (famId) {
+      const indiRecordIndex = lines.findIndex(
+        (line) => line === `0 ${childGedcomId} INDI`
+      );
+      if (indiRecordIndex !== -1) {
+        lines.splice(indiRecordIndex + 1, 0, `1 FAMC ${famId}`);
+      }
+    }
+  });
+  families.forEach((family, key) => {
+    const famId = familyIdMap.get(key);
+    if (!famId) return;
+    family.spouses.forEach((spouseId) => {
+      const spouseGedcomId = personIdMap.get(spouseId);
+      if (!spouseGedcomId) return;
+      const indiRecordIndex = lines.findIndex(
+        (line) => line === `0 ${spouseGedcomId} INDI`
+      );
+      if (indiRecordIndex !== -1) {
+        let insertIndex = indiRecordIndex + 1;
+        while (insertIndex < lines.length && lines[insertIndex].startsWith("1 FAMC")) {
+          insertIndex++;
+        }
+        lines.splice(insertIndex, 0, `1 FAMS ${famId}`);
+      }
+    });
+  });
+  const personsInFamilies = /* @__PURE__ */ new Set();
+  families.forEach((family) => {
+    family.spouses.forEach((id) => personsInFamilies.add(id));
+    family.children.forEach((id) => personsInFamilies.add(id));
+  });
+  lines.push("0 TRLR");
+  return lines.join("\n");
+}
+function addMarriageFacts(lines, relationships, person1, person2) {
+  const relKey = [person1, person2].sort().join("-");
+  const rel = relationships.find((r) => {
+    const a = r.person1?.resourceId || r.person1?.resource?.resourceId;
+    const b = r.person2?.resourceId || r.person2?.resource?.resourceId;
+    if (!a || !b) return false;
+    return [a, b].sort().join("-") === relKey;
+  });
+  if (!rel) return;
+  const marriageFacts = [];
+  if (rel.facts && Array.isArray(rel.facts)) {
+    rel.facts.forEach((f) => {
+      if (f.type?.includes("Marriage")) {
+        marriageFacts.push(f);
+      }
+    });
+  }
+  if (rel.details?.facts && Array.isArray(rel.details.facts)) {
+    marriageFacts.push(
+      ...rel.details.facts.filter((f) => f.type?.includes("Marriage"))
+    );
+  }
+  if (rel.details?.persons && Array.isArray(rel.details.persons)) {
+    rel.details.persons.forEach((p) => {
+      if (p.facts && Array.isArray(p.facts)) {
+        p.facts.forEach((f) => {
+          if (f.type?.includes("Marriage")) {
+            marriageFacts.push(f);
+          }
+        });
+      }
+    });
+  }
+  marriageFacts.forEach((mf) => {
+    const factLines = convertFactToGedcom(mf);
+    factLines.forEach((line) => lines.push(line));
+  });
+}
+var convertFamilySearchToGedcom = convertToGedcom;
+
+exports.ENVIRONMENT_CONFIGS = ENVIRONMENT_CONFIGS;
+exports.FamilySearchSDK = FamilySearchSDK;
+exports.OAUTH_ENDPOINTS = OAUTH_ENDPOINTS;
+exports.OAUTH_STORAGE_KEYS = OAUTH_STORAGE_KEYS;
+exports.buildAuthorizationUrl = buildAuthorizationUrl;
+exports.clearAllTokens = clearAllTokens;
+exports.clearStoredTokens = clearStoredTokens;
+exports.convertFamilySearchToGedcom = convertFamilySearchToGedcom;
+exports.convertToGedcom = convertToGedcom;
+exports.createFamilySearchSDK = createFamilySearchSDK;
+exports.exchangeCodeForToken = exchangeCodeForToken;
+exports.fetchMultiplePersons = fetchMultiplePersons;
+exports.fetchPedigree = fetchPedigree;
+exports.generateOAuthState = generateOAuthState;
+exports.getCurrentUser = getCurrentUser;
+exports.getFamilySearchSDK = getFamilySearchSDK;
+exports.getOAuthEndpoints = getOAuthEndpoints;
+exports.getPersonWithDetails = getPersonWithDetails;
+exports.getPlaceById = getPlaceById;
+exports.getPlaceChildren = getPlaceChildren;
+exports.getPlaceDetails = getPlaceDetails;
+exports.getStoredAccessToken = getStoredAccessToken;
+exports.getStoredRefreshToken = getStoredRefreshToken;
+exports.getTokenStorageKey = getTokenStorageKey;
+exports.getUserInfo = getUserInfo;
+exports.initFamilySearchSDK = initFamilySearchSDK;
+exports.openOAuthPopup = openOAuthPopup;
+exports.parseCallbackParams = parseCallbackParams;
+exports.refreshAccessToken = refreshAccessToken;
+exports.resetFamilySearchSDK = resetFamilySearchSDK;
+exports.searchPlaces = searchPlaces;
+exports.storeOAuthState = storeOAuthState;
+exports.storeTokens = storeTokens;
+exports.validateAccessToken = validateAccessToken;
+exports.validateOAuthState = validateOAuthState;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map