mcp-scraper 0.88.2 → 0.89.0

package/dist/chunk-K3Z5AQYE.js

@@ -1,683 +0,0 @@
-import {
-  csvRecords
-} from "./chunk-RJ7JVYKU.js";
-import {
-  getDb
-} from "./chunk-YXNDOQXN.js";
-
-// src/api/location-data-repository.ts
-import { createHash, randomUUID } from "crypto";
-var HOSTED_ZIP_DATASET_KIND = "us_zip_groups";
-var HOSTED_CENSUS_DATASET_PREFIX = "us_census_places";
-var MIN_NATIONWIDE_ZIP_COUNT = 25e3;
-var REQUIRED_LOCATION_STATE_CODES = [
-  "AL",
-  "AK",
-  "AZ",
-  "AR",
-  "CA",
-  "CO",
-  "CT",
-  "DE",
-  "DC",
-  "FL",
-  "GA",
-  "HI",
-  "ID",
-  "IL",
-  "IN",
-  "IA",
-  "KS",
-  "KY",
-  "LA",
-  "ME",
-  "MD",
-  "MA",
-  "MI",
-  "MN",
-  "MS",
-  "MO",
-  "MT",
-  "NE",
-  "NV",
-  "NH",
-  "NJ",
-  "NM",
-  "NY",
-  "NC",
-  "ND",
-  "OH",
-  "OK",
-  "OR",
-  "PA",
-  "RI",
-  "SC",
-  "SD",
-  "TN",
-  "TX",
-  "UT",
-  "VT",
-  "VA",
-  "WA",
-  "WV",
-  "WI",
-  "WY"
-];
-var STATE_FIPS_BY_ABBR = {
-  AL: "01",
-  AK: "02",
-  AZ: "04",
-  AR: "05",
-  CA: "06",
-  CO: "08",
-  CT: "09",
-  DE: "10",
-  DC: "11",
-  FL: "12",
-  GA: "13",
-  HI: "15",
-  ID: "16",
-  IL: "17",
-  IN: "18",
-  IA: "19",
-  KS: "20",
-  KY: "21",
-  LA: "22",
-  ME: "23",
-  MD: "24",
-  MA: "25",
-  MI: "26",
-  MN: "27",
-  MS: "28",
-  MO: "29",
-  MT: "30",
-  NE: "31",
-  NV: "32",
-  NH: "33",
-  NJ: "34",
-  NM: "35",
-  NY: "36",
-  NC: "37",
-  ND: "38",
-  OH: "39",
-  OK: "40",
-  OR: "41",
-  PA: "42",
-  RI: "44",
-  SC: "45",
-  SD: "46",
-  TN: "47",
-  TX: "48",
-  UT: "49",
-  VT: "50",
-  VA: "51",
-  WA: "53",
-  WV: "54",
-  WI: "55",
-  WY: "56"
-};
-var REQUIRED_LOCATION_STATE_SET = new Set(REQUIRED_LOCATION_STATE_CODES);
-var IMPORT_BATCH_SIZE = 200;
-var MAX_SOURCE_URL_LENGTH = 2e3;
-var schemaDb = null;
-var schemaPromise = null;
-function normalizeHostedCityKey(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-}
-function stringArray(value) {
-  if (value == null) return [];
-  try {
-    const parsed = JSON.parse(String(value));
-    return Array.isArray(parsed) ? parsed.map(String) : [];
-  } catch {
-    return [];
-  }
-}
-function rowToDataset(row) {
-  return {
-    id: String(row.id),
-    kind: String(row.dataset_kind),
-    sourceUrl: row.source_url == null ? null : String(row.source_url),
-    sha256: String(row.sha256),
-    rowCount: Number(row.row_count ?? 0),
-    groupCount: Number(row.group_count ?? 0),
-    stateCount: Number(row.state_count ?? 0),
-    sourceRowCount: Number(row.source_row_count ?? row.row_count ?? 0),
-    rejectedRowCount: Number(row.rejected_row_count ?? 0),
-    zipCount: Number(row.zip_count ?? 0),
-    coveredStates: stringArray(row.covered_states_json),
-    coverageComplete: Number(row.coverage_complete ?? 0) === 1,
-    status: String(row.status),
-    createdAt: String(row.created_at),
-    completedAt: row.completed_at == null ? null : String(row.completed_at),
-    error: row.error == null ? null : String(row.error)
-  };
-}
-function censusDatasetKind(state) {
-  return `${HOSTED_CENSUS_DATASET_PREFIX}:${state}`;
-}
-function normalizedSourceUrl(value) {
-  const trimmed = value?.trim();
-  if (!trimmed) return null;
-  if (trimmed.length > MAX_SOURCE_URL_LENGTH) throw new Error(`sourceUrl must be ${MAX_SOURCE_URL_LENGTH} characters or fewer`);
-  let parsed;
-  try {
-    parsed = new URL(trimmed);
-  } catch {
-    throw new Error("sourceUrl must be a valid URL");
-  }
-  parsed.username = "";
-  parsed.password = "";
-  parsed.search = "";
-  parsed.hash = "";
-  return parsed.toString();
-}
-function normalizedZip(value) {
-  const digits = value.trim();
-  if (!/^\d{1,5}$/.test(digits)) return null;
-  return digits.padStart(5, "0");
-}
-function normalizedState(value) {
-  const state = value.trim().toUpperCase();
-  return REQUIRED_LOCATION_STATE_SET.has(state) ? state : null;
-}
-function csvColumn(record, names) {
-  for (const name of names) {
-    const value = record[name];
-    if (value !== void 0) return value;
-  }
-  return "";
-}
-function numberOrNull(value) {
-  if (value === void 0 || value.trim() === "") return null;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed >= 0 ? Math.trunc(parsed) : null;
-}
-function displayCityFromCensus(name) {
-  if (/^Nashville-Davidson metropolitan government/i.test(name)) return "Nashville";
-  return name.replace(/\s+(city|town|village|municipality|borough)$/i, "").trim();
-}
-function parseHostedCensusPlacesCsv(csv, expectedStateFips) {
-  const records = csvRecords(csv.replace(/^\uFEFF/, ""));
-  if (records.length === 0) throw new Error("Census place CSV contains no data rows.");
-  const headers = new Set(Object.keys(records[0] ?? {}).map((header) => header.trim()));
-  const required = ["SUMLEV", "STATE", "NAME", "POPESTIMATE2020", "POPESTIMATE2021", "POPESTIMATE2022", "POPESTIMATE2023", "POPESTIMATE2024", "POPESTIMATE2025"];
-  const missing = required.filter((header) => !headers.has(header));
-  if (missing.length > 0) throw new Error(`Census place CSV is missing required columns: ${missing.join(", ")}.`);
-  const placeRecords = records.filter((record) => record.SUMLEV?.trim() === "162");
-  if (expectedStateFips) {
-    const expected = expectedStateFips.padStart(2, "0");
-    const mismatched = placeRecords.filter((record) => record.STATE?.trim().padStart(2, "0") !== expected);
-    if (mismatched.length > 0) {
-      const received = [...new Set(mismatched.map((record) => record.STATE?.trim() || "(blank)"))].slice(0, 5);
-      throw new Error(`Census place CSV STATE does not match requested FIPS ${expected}; received ${received.join(", ")}.`);
-    }
-  }
-  const candidates = placeRecords.map((record) => {
-    const censusName = record.NAME?.trim() ?? "";
-    if (!censusName) return null;
-    const city = displayCityFromCensus(censusName);
-    const cityKey = normalizeHostedCityKey(city);
-    if (!cityKey) return null;
-    const populations = {
-      2020: numberOrNull(record.POPESTIMATE2020),
-      2021: numberOrNull(record.POPESTIMATE2021),
-      2022: numberOrNull(record.POPESTIMATE2022),
-      2023: numberOrNull(record.POPESTIMATE2023),
-      2024: numberOrNull(record.POPESTIMATE2024),
-      2025: numberOrNull(record.POPESTIMATE2025)
-    };
-    if (Object.values(populations).every((value) => value === null)) return null;
-    return {
-      city,
-      cityKey,
-      censusName,
-      estimatesBase2020: numberOrNull(record.ESTIMATESBASE2020),
-      populations
-    };
-  }).filter((place) => place !== null);
-  const placesByCityKey = /* @__PURE__ */ new Map();
-  const populationRank = (place) => place.populations[2025] ?? place.populations[2024] ?? place.populations[2023] ?? place.populations[2022] ?? place.populations[2021] ?? place.populations[2020] ?? place.estimatesBase2020 ?? -1;
-  for (const candidate of candidates) {
-    const current = placesByCityKey.get(candidate.cityKey);
-    if (!current || populationRank(candidate) > populationRank(current) || populationRank(candidate) === populationRank(current) && candidate.censusName.localeCompare(current.censusName) < 0) {
-      placesByCityKey.set(candidate.cityKey, candidate);
-    }
-  }
-  const places = [...placesByCityKey.values()].sort((a, b) => a.city.localeCompare(b.city));
-  if (places.length === 0) throw new Error("Census place CSV did not contain any valid place population rows.");
-  return { sourceRowCount: records.length, places };
-}
-function parseHostedZipGroupsCsv(csv) {
-  const records = csvRecords(csv.replace(/^\uFEFF/, ""));
-  if (records.length === 0) throw new Error("Location ZIP CSV contains no data rows.");
-  const first = records[0] ?? {};
-  const headers = new Set(Object.keys(first).map((header) => header.trim().toLowerCase()));
-  const hasState = ["state_abbr", "state", "state_id"].some((header) => headers.has(header));
-  const hasCity = ["city", "primary_city"].some((header) => headers.has(header));
-  const hasZip = ["zipcode", "zip", "zip_code"].some((header) => headers.has(header));
-  if (!hasState || !hasCity || !hasZip) {
-    throw new Error("Location ZIP CSV must include state_abbr/state, city, and zipcode/zip columns.");
-  }
-  const grouped = /* @__PURE__ */ new Map();
-  let rowCount = 0;
-  let rejectedRowCount = 0;
-  const states = /* @__PURE__ */ new Set();
-  const uniqueZips = /* @__PURE__ */ new Set();
-  for (const rawRecord of records) {
-    const record = Object.fromEntries(Object.entries(rawRecord).map(([key2, value]) => [key2.trim().toLowerCase(), value]));
-    const state = normalizedState(csvColumn(record, ["state_abbr", "state", "state_id"]));
-    const city = csvColumn(record, ["city", "primary_city"]).trim();
-    const zip = normalizedZip(csvColumn(record, ["zipcode", "zip", "zip_code"]));
-    const county = csvColumn(record, ["county", "county_name"]).trim();
-    if (!state || !REQUIRED_LOCATION_STATE_SET.has(state) || !city || !zip) {
-      rejectedRowCount += 1;
-      continue;
-    }
-    const cityKey = normalizeHostedCityKey(city);
-    if (!cityKey) {
-      rejectedRowCount += 1;
-      continue;
-    }
-    const key = `${state}\0${cityKey}`;
-    let group = grouped.get(key);
-    if (!group) {
-      group = { city, cityKey, state, zips: /* @__PURE__ */ new Set(), counties: /* @__PURE__ */ new Set() };
-      grouped.set(key, group);
-    }
-    group.zips.add(zip);
-    if (county) group.counties.add(county);
-    states.add(state);
-    uniqueZips.add(zip);
-    rowCount += 1;
-  }
-  if (grouped.size === 0) throw new Error("Location ZIP CSV did not contain any valid US city/ZIP rows.");
-  return {
-    sourceRowCount: records.length,
-    rowCount,
-    rejectedRowCount,
-    zipCount: uniqueZips.size,
-    stateCount: states.size,
-    coveredStates: [...states].sort(),
-    groups: [...grouped.values()].map((group) => ({
-      city: group.city,
-      cityKey: group.cityKey,
-      state: group.state,
-      zips: [...group.zips].sort(),
-      counties: [...group.counties].sort()
-    })).sort((a, b) => a.state.localeCompare(b.state) || a.city.localeCompare(b.city))
-  };
-}
-function assertNationwideZipCoverage(parsed) {
-  const covered = new Set(parsed.coveredStates);
-  const missingStates = REQUIRED_LOCATION_STATE_CODES.filter((state) => !covered.has(state));
-  const errors = [];
-  if (missingStates.length > 0) errors.push(`missing required states: ${missingStates.join(", ")}`);
-  if (parsed.zipCount < MIN_NATIONWIDE_ZIP_COUNT) {
-    errors.push(`only ${parsed.zipCount} unique ZIPs; at least ${MIN_NATIONWIDE_ZIP_COUNT} are required`);
-  }
-  if (errors.length > 0) {
-    throw new Error(`Location ZIP snapshot is not nationwide and was not activated (${errors.join("; ")}; ${parsed.rejectedRowCount} rejected rows).`);
-  }
-}
-async function ensureHostedLocationDataSchema() {
-  const db = getDb();
-  if (schemaDb !== db) {
-    schemaDb = db;
-    schemaPromise = null;
-  }
-  if (!schemaPromise) {
-    schemaPromise = (async () => {
-      await db.execute(`
-        CREATE TABLE IF NOT EXISTS location_data_imports (
-          id           TEXT PRIMARY KEY,
-          dataset_kind TEXT NOT NULL,
-          source_url   TEXT,
-          sha256       TEXT NOT NULL,
-          row_count    INTEGER NOT NULL DEFAULT 0,
-          group_count  INTEGER NOT NULL DEFAULT 0,
-          state_count  INTEGER NOT NULL DEFAULT 0,
-          source_row_count   INTEGER NOT NULL DEFAULT 0,
-          rejected_row_count INTEGER NOT NULL DEFAULT 0,
-          zip_count          INTEGER NOT NULL DEFAULT 0,
-          covered_states_json TEXT NOT NULL DEFAULT '[]',
-          coverage_complete  INTEGER NOT NULL DEFAULT 0,
-          status       TEXT NOT NULL,
-          error        TEXT,
-          created_at   TEXT NOT NULL DEFAULT (datetime('now')),
-          completed_at TEXT
-        )
-      `);
-      const importColumns = new Set((await db.execute(`PRAGMA table_info(location_data_imports)`)).rows.map((row) => String(row.name)));
-      const missingImportColumns = [
-        ["source_row_count", `INTEGER NOT NULL DEFAULT 0`],
-        ["rejected_row_count", `INTEGER NOT NULL DEFAULT 0`],
-        ["zip_count", `INTEGER NOT NULL DEFAULT 0`],
-        ["covered_states_json", `TEXT NOT NULL DEFAULT '[]'`],
-        ["coverage_complete", `INTEGER NOT NULL DEFAULT 0`]
-      ];
-      for (const [column, definition] of missingImportColumns) {
-        if (!importColumns.has(column)) await db.execute(`ALTER TABLE location_data_imports ADD COLUMN ${column} ${definition}`);
-      }
-      await db.execute(`CREATE INDEX IF NOT EXISTS location_data_imports_kind_created ON location_data_imports(dataset_kind, created_at DESC)`);
-      await db.execute(`
-        CREATE TABLE IF NOT EXISTS location_zip_groups (
-          import_id     TEXT NOT NULL REFERENCES location_data_imports(id) ON DELETE CASCADE,
-          state_abbr    TEXT NOT NULL,
-          city_key      TEXT NOT NULL,
-          city          TEXT NOT NULL,
-          zips_json     TEXT NOT NULL,
-          counties_json TEXT NOT NULL,
-          PRIMARY KEY(import_id, state_abbr, city_key)
-        )
-      `);
-      await db.execute(`CREATE INDEX IF NOT EXISTS location_zip_groups_state ON location_zip_groups(import_id, state_abbr, city_key)`);
-      await db.execute(`
-        CREATE TABLE IF NOT EXISTS location_census_places (
-          import_id           TEXT NOT NULL REFERENCES location_data_imports(id) ON DELETE CASCADE,
-          state_abbr          TEXT NOT NULL,
-          city_key            TEXT NOT NULL,
-          city                TEXT NOT NULL,
-          census_name         TEXT NOT NULL,
-          estimates_base_2020 INTEGER,
-          population_2020     INTEGER,
-          population_2021     INTEGER,
-          population_2022     INTEGER,
-          population_2023     INTEGER,
-          population_2024     INTEGER,
-          population_2025     INTEGER,
-          PRIMARY KEY(import_id, state_abbr, city_key)
-        )
-      `);
-      await db.execute(`CREATE INDEX IF NOT EXISTS location_census_places_state ON location_census_places(import_id, state_abbr, city_key)`);
-      await db.execute(`
-        CREATE TABLE IF NOT EXISTS location_data_active (
-          dataset_kind TEXT PRIMARY KEY,
-          import_id    TEXT NOT NULL REFERENCES location_data_imports(id),
-          activated_at TEXT NOT NULL DEFAULT (datetime('now'))
-        )
-      `);
-    })().catch((error) => {
-      schemaPromise = null;
-      throw error;
-    });
-  }
-  await schemaPromise;
-}
-async function getActiveHostedDataset(kind) {
-  await ensureHostedLocationDataSchema();
-  const result = await getDb().execute({
-    sql: `
-      SELECT i.*
-      FROM location_data_active a
-      JOIN location_data_imports i ON i.id = a.import_id
-      WHERE a.dataset_kind = ? AND i.status = 'ready'
-      LIMIT 1
-    `,
-    args: [kind]
-  });
-  const row = result.rows[0];
-  return row ? rowToDataset(row) : null;
-}
-async function getActiveHostedLocationDataset() {
-  return getActiveHostedDataset(HOSTED_ZIP_DATASET_KIND);
-}
-async function listActiveHostedLocationDatasets() {
-  await ensureHostedLocationDataSchema();
-  const result = await getDb().execute(`
-    SELECT i.*
-    FROM location_data_active a
-    JOIN location_data_imports i ON i.id = a.import_id
-    WHERE i.status = 'ready'
-    ORDER BY i.dataset_kind ASC
-  `);
-  return result.rows.map((row) => rowToDataset(row));
-}
-async function getHostedZipGroups(stateInput) {
-  const state = normalizedState(stateInput);
-  if (!state) throw new Error("state must be a two-letter US state abbreviation");
-  const dataset = await getActiveHostedLocationDataset();
-  if (!dataset) return { dataset: null, groups: /* @__PURE__ */ new Map() };
-  const result = await getDb().execute({
-    sql: `
-      SELECT city, city_key, state_abbr, zips_json, counties_json
-      FROM location_zip_groups
-      WHERE import_id = ? AND state_abbr = ?
-      ORDER BY city COLLATE NOCASE ASC
-    `,
-    args: [dataset.id, state]
-  });
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of result.rows) {
-    const cityKey = String(row.city_key);
-    groups.set(cityKey, {
-      city: String(row.city),
-      cityKey,
-      state: String(row.state_abbr),
-      zips: JSON.parse(String(row.zips_json)),
-      counties: JSON.parse(String(row.counties_json))
-    });
-  }
-  return { dataset, groups };
-}
-async function importHostedZipGroupsCsv(input) {
-  await ensureHostedLocationDataSchema();
-  const sourceUrl = normalizedSourceUrl(input.sourceUrl);
-  const sha256 = createHash("sha256").update(input.csv).digest("hex");
-  const active = await getActiveHostedLocationDataset();
-  if (active?.sha256 === sha256) return { dataset: active, duplicate: true };
-  const parsed = parseHostedZipGroupsCsv(input.csv);
-  assertNationwideZipCoverage(parsed);
-  const id = `loc_${randomUUID().replaceAll("-", "")}`;
-  const db = getDb();
-  await db.execute({
-    sql: `
-      INSERT INTO location_data_imports (
-        id, dataset_kind, source_url, sha256, row_count, group_count, state_count,
-        source_row_count, rejected_row_count, zip_count, covered_states_json, coverage_complete, status
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 'loading')
-    `,
-    args: [
-      id,
-      HOSTED_ZIP_DATASET_KIND,
-      sourceUrl,
-      sha256,
-      parsed.rowCount,
-      parsed.groups.length,
-      parsed.stateCount,
-      parsed.sourceRowCount,
-      parsed.rejectedRowCount,
-      parsed.zipCount,
-      JSON.stringify(parsed.coveredStates)
-    ]
-  });
-  try {
-    for (let offset = 0; offset < parsed.groups.length; offset += IMPORT_BATCH_SIZE) {
-      const batch = parsed.groups.slice(offset, offset + IMPORT_BATCH_SIZE).map((group) => ({
-        sql: `
-          INSERT INTO location_zip_groups (
-            import_id, state_abbr, city_key, city, zips_json, counties_json
-          ) VALUES (?, ?, ?, ?, ?, ?)
-        `,
-        args: [id, group.state, group.cityKey, group.city, JSON.stringify(group.zips), JSON.stringify(group.counties)]
-      }));
-      await db.batch(batch, "write");
-    }
-    await db.batch([
-      {
-        sql: `UPDATE location_data_imports SET status = 'ready', completed_at = datetime('now'), error = NULL WHERE id = ? AND status = 'loading'`,
-        args: [id]
-      },
-      {
-        sql: `
-          INSERT INTO location_data_active (dataset_kind, import_id, activated_at)
-          VALUES (?, ?, datetime('now'))
-          ON CONFLICT(dataset_kind) DO UPDATE SET import_id = excluded.import_id, activated_at = excluded.activated_at
-        `,
-        args: [HOSTED_ZIP_DATASET_KIND, id]
-      }
-    ], "write");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    await db.execute({
-      sql: `UPDATE location_data_imports SET status = 'failed', error = ?, completed_at = datetime('now') WHERE id = ?`,
-      args: [message.slice(0, 1e3), id]
-    }).catch(() => void 0);
-    throw error;
-  }
-  const result = await db.execute({ sql: "SELECT * FROM location_data_imports WHERE id = ? LIMIT 1", args: [id] });
-  const row = result.rows[0];
-  if (!row) throw new Error("Hosted location import completed without a durable metadata row.");
-  return { dataset: rowToDataset(row), duplicate: false };
-}
-async function importHostedCensusPlacesCsv(input) {
-  await ensureHostedLocationDataSchema();
-  const state = normalizedState(input.state);
-  if (!state) throw new Error("state must be a two-letter US state abbreviation");
-  const kind = censusDatasetKind(state);
-  const sourceUrl = normalizedSourceUrl(input.sourceUrl);
-  const sha256 = createHash("sha256").update(input.csv).digest("hex");
-  const active = await getActiveHostedDataset(kind);
-  if (active?.sha256 === sha256) return { dataset: active, duplicate: true };
-  const stateFips = STATE_FIPS_BY_ABBR[state];
-  const parsed = parseHostedCensusPlacesCsv(input.csv, stateFips);
-  const id = `loc_${randomUUID().replaceAll("-", "")}`;
-  const db = getDb();
-  await db.execute({
-    sql: `
-      INSERT INTO location_data_imports (
-        id, dataset_kind, source_url, sha256, row_count, group_count, state_count,
-        source_row_count, rejected_row_count, zip_count, covered_states_json, coverage_complete, status
-      ) VALUES (?, ?, ?, ?, ?, ?, 1, ?, 0, 0, ?, 1, 'loading')
-    `,
-    args: [id, kind, sourceUrl, sha256, parsed.places.length, parsed.places.length, parsed.sourceRowCount, JSON.stringify([state])]
-  });
-  try {
-    for (let offset = 0; offset < parsed.places.length; offset += IMPORT_BATCH_SIZE) {
-      const batch = parsed.places.slice(offset, offset + IMPORT_BATCH_SIZE).map((place) => ({
-        sql: `
-          INSERT INTO location_census_places (
-            import_id, state_abbr, city_key, city, census_name, estimates_base_2020,
-            population_2020, population_2021, population_2022, population_2023,
-            population_2024, population_2025
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `,
-        args: [
-          id,
-          state,
-          place.cityKey,
-          place.city,
-          place.censusName,
-          place.estimatesBase2020,
-          place.populations[2020],
-          place.populations[2021],
-          place.populations[2022],
-          place.populations[2023],
-          place.populations[2024],
-          place.populations[2025]
-        ]
-      }));
-      await db.batch(batch, "write");
-    }
-    await db.batch([
-      {
-        sql: `UPDATE location_data_imports SET status = 'ready', completed_at = datetime('now'), error = NULL WHERE id = ? AND status = 'loading'`,
-        args: [id]
-      },
-      {
-        sql: `
-          INSERT INTO location_data_active (dataset_kind, import_id, activated_at)
-          VALUES (?, ?, datetime('now'))
-          ON CONFLICT(dataset_kind) DO UPDATE SET import_id = excluded.import_id, activated_at = excluded.activated_at
-        `,
-        args: [kind, id]
-      }
-    ], "write");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    await db.execute({
-      sql: `UPDATE location_data_imports SET status = 'failed', error = ?, completed_at = datetime('now') WHERE id = ?`,
-      args: [message.slice(0, 1e3), id]
-    }).catch(() => void 0);
-    throw error;
-  }
-  const result = await db.execute({ sql: "SELECT * FROM location_data_imports WHERE id = ? LIMIT 1", args: [id] });
-  const row = result.rows[0];
-  if (!row) throw new Error("Hosted Census import completed without a durable metadata row.");
-  return { dataset: rowToDataset(row), duplicate: false };
-}
-async function queryHostedLocationMarkets(input) {
-  const state = normalizedState(input.state);
-  if (!state) throw new Error("state must be a two-letter US state abbreviation");
-  if (!Number.isSafeInteger(input.minPopulation) || input.minPopulation < 0) throw new Error("minPopulation must be a non-negative integer");
-  if (!Number.isSafeInteger(input.maxResults) || input.maxResults < 1 || input.maxResults > 100) throw new Error("maxResults must be between 1 and 100");
-  const populationDataset = await getActiveHostedDataset(censusDatasetKind(state));
-  const needsZipDataset = input.includeZipGroups || Boolean(input.zip);
-  const zipLookup = needsZipDataset ? await getHostedZipGroups(state) : { dataset: null, groups: /* @__PURE__ */ new Map() };
-  if (!populationDataset) {
-    return { markets: [], populationDataset: null, zipDataset: zipLookup.dataset, warnings: [] };
-  }
-  const result = await getDb().execute({
-    sql: `
-      SELECT *
-      FROM location_census_places
-      WHERE import_id = ? AND state_abbr = ?
-      ORDER BY city COLLATE NOCASE ASC
-    `,
-    args: [populationDataset.id, state]
-  });
-  const cityQuery = normalizeHostedCityKey(input.cityQuery ?? "");
-  const zip = input.zip?.trim();
-  const populationColumn = `population_${input.populationYear}`;
-  const markets = result.rows.map((row) => {
-    const populationValue = row[populationColumn];
-    if (populationValue == null) return null;
-    const population = Number(populationValue);
-    if (!Number.isSafeInteger(population) || population < input.minPopulation) return null;
-    const city = String(row.city);
-    const normalizedKey = String(row.city_key);
-    if (cityQuery && !normalizedKey.includes(cityQuery)) return null;
-    const zipGroup = zipLookup.groups.get(normalizedKey);
-    const zips = zipGroup?.zips ?? [];
-    if (zip && !zips.includes(zip)) return null;
-    return {
-      city,
-      state,
-      location: `${city}, ${state}`,
-      cityKey: `${city}|${state}`,
-      censusName: String(row.census_name),
-      population,
-      populationYear: input.populationYear,
-      estimatesBase2020: row.estimates_base_2020 == null ? null : Number(row.estimates_base_2020),
-      zips: input.includeZipGroups ? zips : [],
-      counties: input.includeZipGroups ? zipGroup?.counties ?? [] : []
-    };
-  }).filter((market) => market !== null).sort((a, b) => b.population - a.population || a.city.localeCompare(b.city)).slice(0, input.maxResults);
-  const warnings = [];
-  if (input.includeZipGroups && zipLookup.dataset && markets.some((market) => market.zips.length === 0)) {
-    warnings.push("Some hosted Census places did not match the hosted ZIP city groups.");
-  }
-  return {
-    markets,
-    populationDataset,
-    zipDataset: zipLookup.dataset,
-    warnings
-  };
-}
-
-export {
-  HOSTED_ZIP_DATASET_KIND,
-  HOSTED_CENSUS_DATASET_PREFIX,
-  MIN_NATIONWIDE_ZIP_COUNT,
-  REQUIRED_LOCATION_STATE_CODES,
-  parseHostedCensusPlacesCsv,
-  parseHostedZipGroupsCsv,
-  ensureHostedLocationDataSchema,
-  getActiveHostedDataset,
-  getActiveHostedLocationDataset,
-  listActiveHostedLocationDatasets,
-  getHostedZipGroups,
-  importHostedZipGroupsCsv,
-  importHostedCensusPlacesCsv,
-  queryHostedLocationMarkets
-};

package/dist/chunk-K45K75OF.js

@@ -1,6 +0,0 @@
-// src/version.ts
-var PACKAGE_VERSION = "0.88.2";
-
-export {
-  PACKAGE_VERSION
-};