@lunora/do 1.0.0-alpha.44 → 1.0.0-alpha.46

package/dist/packem_shared/DEFAULT_MAX_RELATION_KEYS-BEan1CRD.mjs

@@ -1,211 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { distinctValues } from './applyOnDelete-BXSq3S70.mjs';
-
-const RELATION_EXISTS_KEY = "__relationExists";
-
-const RELATION_OPERATOR_META = {
-  every: { kind: "many", negateChild: true, negated: true },
-  is: { kind: "one", negated: false },
-  isNot: { kind: "one", negated: true, nullDisjunct: true },
-  none: { kind: "many", negated: true },
-  some: { kind: "many", negated: false }
-};
-const RELATION_OPERATORS = new Set(Object.keys(RELATION_OPERATOR_META));
-const joinColumns = (relation) => relation.kind === "one" ? { clause: relation.field, project: relation.references } : { clause: relation.references, project: relation.field };
-const DEFAULT_MAX_RELATION_KEYS = 5e3;
-const KEY_OVERFLOW = /* @__PURE__ */ Symbol("relation-key-overflow");
-const branchesOf = (value) => Array.isArray(value) ? value.map((branch) => branch ?? {}) : [];
-const combineAnd = (clauses) => {
-  if (clauses.length === 1) {
-    const [only] = clauses;
-    return only ?? {};
-  }
-  return clauses.length === 0 ? {} : { AND: clauses };
-};
-const isRelationPredicate = (value) => {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const keys = Object.keys(value);
-  return keys.length > 0 && keys.every((key) => RELATION_OPERATORS.has(key));
-};
-const containsRelationPredicate = (where, schema, tableName) => {
-  const relationMap = schema.tables[tableName]?.relationMap ?? {};
-  return Object.keys(where).some((key) => {
-    const value = where[key];
-    if (key === "AND" || key === "OR") {
-      return branchesOf(value).some((branch) => containsRelationPredicate(branch, schema, tableName));
-    }
-    if (key === "NOT") {
-      return containsRelationPredicate(value ?? {}, schema, tableName);
-    }
-    return Boolean(relationMap[key]) && isRelationPredicate(value);
-  });
-};
-const assertFlatPredicate = (where, schema, tableName, op) => {
-  if (where && containsRelationPredicate(where, schema, tableName)) {
-    throw new LunoraError("INTERNAL", `relation-crossing predicates are not supported in ${op}() — use them in findMany/findFirst or an RLS read policy`);
-  }
-};
-const projectChildKeys = async (relation, childWhere, projectField, context, escalatable) => {
-  const resolvedChildWhere = await resolveForTable(childWhere, relation.table, context);
-  const { page } = await context.fetcher(relation.table, {
-    baseWhere: context.relationBaseWhere?.(relation.table),
-    relationBaseWhere: context.relationBaseWhere,
-    where: resolvedChildWhere
-  });
-  const keys = distinctValues(page, projectField);
-  if (keys.length > context.maxRelationKeys) {
-    if (escalatable) {
-      return KEY_OVERFLOW;
-    }
-    throw new LunoraError(
-      "INTERNAL",
-      `relation predicate on "${relation.table}" matched ${String(keys.length)} rows, exceeding the ${String(context.maxRelationKeys)}-key limit; narrow the predicate (a same-shard EXISTS push-down lifts this cap)`
-    );
-  }
-  return keys;
-};
-const compileOperator = async (operator, relation, childWhere, context, escalatable) => {
-  const meta = RELATION_OPERATOR_META[operator];
-  if (!meta) {
-    throw new LunoraError("INTERNAL", `unknown relation operator "${operator}"`);
-  }
-  const { clause, project } = joinColumns(relation);
-  const keys = await projectChildKeys(relation, meta.negateChild ? { NOT: childWhere } : childWhere, project, context, escalatable);
-  if (keys === KEY_OVERFLOW) {
-    return KEY_OVERFLOW;
-  }
-  if (!meta.negated) {
-    return { [clause]: { in: keys } };
-  }
-  if (meta.nullDisjunct) {
-    return { OR: [{ [clause]: { notIn: keys } }, { [clause]: { isNull: true } }] };
-  }
-  return { [clause]: { notIn: keys } };
-};
-const buildExistsMarker = async (operator, relation, childWhere, parentTable, context) => {
-  const meta = RELATION_OPERATOR_META[operator];
-  if (!meta) {
-    throw new LunoraError("INTERNAL", `unknown relation operator "${operator}"`);
-  }
-  const base = context.relationBaseWhere?.(relation.table);
-  const predicatePart = meta.negateChild ? { NOT: childWhere } : childWhere;
-  const merged = base ? { AND: [base, predicatePart] } : predicatePart;
-  const resolvedChild = await resolveForTable(merged, relation.table, context);
-  const marker = { childWhere: resolvedChild, negated: meta.negated, parentTable, relation };
-  return { [RELATION_EXISTS_KEY]: marker };
-};
-const assertCardinality = (operator, name, relation) => {
-  const meta = RELATION_OPERATOR_META[operator];
-  if (meta && meta.kind !== relation.kind) {
-    throw new LunoraError("INTERNAL", `relation operator "${operator}" requires a to-${meta.kind} relation, but "${name}" is to-${relation.kind}`);
-  }
-};
-const resolveRelationNode = async (name, relation, predicate, parentTable, context) => {
-  const clauses = [];
-  for (const operator of Object.keys(predicate)) {
-    assertCardinality(operator, name, relation);
-    const childWhere = predicate[operator] ?? {};
-    const pushable = context.canPushExists?.(relation) ?? false;
-    if (pushable && context.existsPushMode === "always") {
-      clauses.push(await buildExistsMarker(operator, relation, childWhere, parentTable, context));
-      continue;
-    }
-    const semijoin = await compileOperator(operator, relation, childWhere, context, pushable);
-    if (semijoin === KEY_OVERFLOW) {
-      clauses.push(await buildExistsMarker(operator, relation, childWhere, parentTable, context));
-    } else {
-      clauses.push(semijoin);
-    }
-  }
-  return combineAnd(clauses);
-};
-const resolveKey = async (key, value, tableName, context) => {
-  if (key === "AND" || key === "OR") {
-    const resolved = [];
-    for (const branch of branchesOf(value)) {
-      resolved.push(await resolveForTable(branch, tableName, context));
-    }
-    return { [key]: resolved };
-  }
-  if (key === "NOT") {
-    return { NOT: await resolveForTable(value ?? {}, tableName, context) };
-  }
-  const relation = context.schema.tables[tableName]?.relationMap?.[key];
-  if (relation && isRelationPredicate(value)) {
-    return resolveRelationNode(key, relation, value, tableName, context);
-  }
-  return { [key]: value };
-};
-const resolveForTable = async (where, tableName, context) => {
-  const clauses = [];
-  for (const key of Object.keys(where)) {
-    clauses.push(await resolveKey(key, where[key], tableName, context));
-  }
-  return combineAnd(clauses);
-};
-const resolveRelationPredicates = async (where, options) => {
-  if (!where || !containsRelationPredicate(where, options.schema, options.tableName)) {
-    return where;
-  }
-  return resolveForTable(where, options.tableName, {
-    canPushExists: options.canPushExists,
-    existsPushMode: options.existsPushMode ?? "auto",
-    fetcher: options.fetcher,
-    maxRelationKeys: options.maxRelationKeys ?? DEFAULT_MAX_RELATION_KEYS,
-    relationBaseWhere: options.relationBaseWhere,
-    schema: options.schema
-  });
-};
-const firstShardedHit = (branches, schema, tableName) => {
-  for (const branch of branches) {
-    const hit = findShardedRelationTarget(branch, schema, tableName);
-    if (hit) {
-      return hit;
-    }
-  }
-  return void 0;
-};
-const inspectKey = (key, value, schema, tableName) => {
-  if (key === "AND" || key === "OR") {
-    return firstShardedHit(branchesOf(value), schema, tableName);
-  }
-  if (key === "NOT") {
-    return firstShardedHit([value ?? {}], schema, tableName);
-  }
-  const relation = schema.tables[tableName]?.relationMap?.[key];
-  if (!relation || !isRelationPredicate(value)) {
-    return void 0;
-  }
-  if (schema.tables[relation.table]?.shardMode?.kind === "shardBy") {
-    return { relation: key, target: relation.table };
-  }
-  return firstShardedHit(Object.values(value), schema, relation.table);
-};
-const findShardedRelationTarget = (where, schema, tableName) => {
-  for (const key of Object.keys(where)) {
-    const hit = inspectKey(key, where[key], schema, tableName);
-    if (hit) {
-      return hit;
-    }
-  }
-  return void 0;
-};
-const assertShapeShardable = (effectiveWhere, schema, table) => {
-  if (!effectiveWhere) {
-    return;
-  }
-  const offending = findShardedRelationTarget(effectiveWhere, schema, table);
-  if (!offending) {
-    return;
-  }
-  throw Object.assign(
-    new Error(
-      `shape on "${table}" joins the sharded table "${offending.target}" via relation "${offending.relation}" — a live shape cannot replicate rows that live in another shard's Durable Object. Fix it by (a) denormalizing the joined columns into "${table}", or (b) moving "${offending.target}" to .global() so it is served through the latency-tiered D1 shape tier.`
-    ),
-    { code: "SHAPE_CROSS_SHARD_JOIN", name: "LunoraError", status: 400 }
-  );
-};
-
-export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates };

package/dist/packem_shared/FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs

@@ -1,248 +0,0 @@
-const FUNCTION_METRICS_TABLE = "__lunora_metrics";
-const FUNCTION_METRICS_BUCKETS_TABLE = "__lunora_metrics_buckets";
-const FUNCTION_METRICS_SCANS_TABLE = "__lunora_metrics_scans";
-const FUNCTION_METRICS_INDEX_TABLE = "__lunora_metrics_index";
-const FUNCTION_METRICS_BUCKET_MS = 6e4;
-const FUNCTION_METRICS_BUCKET_RETENTION = 1440;
-const FUNCTION_METRICS_MAX_PATHS = 5e3;
-const FUNCTION_METRICS_READ_LIMIT = 1e3;
-const runSql = (sql, query, ...params) => {
-  const runner = sql.exec;
-  return runner.call(sql, query, ...params);
-};
-const bucketFloor = (ts) => Math.floor(ts / FUNCTION_METRICS_BUCKET_MS) * FUNCTION_METRICS_BUCKET_MS;
-const dedupeIndexHits = (hits) => {
-  const seen = /* @__PURE__ */ new Map();
-  for (const hit of hits) {
-    seen.set(`${hit.table}\0${hit.index}`, { index: hit.index, table: hit.table });
-  }
-  return [...seen.values()];
-};
-const ensureFunctionMetricsTables = (sql) => {
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_TABLE}" (
-            path TEXT PRIMARY KEY,
-            calls INTEGER NOT NULL DEFAULT 0,
-            errors INTEGER NOT NULL DEFAULT 0,
-            conflicts INTEGER NOT NULL DEFAULT 0,
-            scans INTEGER NOT NULL DEFAULT 0,
-            total_duration_ms REAL NOT NULL DEFAULT 0,
-            min_duration_ms REAL,
-            max_duration_ms REAL NOT NULL DEFAULT 0,
-            last_called_at REAL NOT NULL DEFAULT 0,
-            last_error_at REAL,
-            last_error_message TEXT
-        )`
-  );
-  for (const column of ["scans", "conflicts"]) {
-    try {
-      runSql(sql, `ALTER TABLE "${FUNCTION_METRICS_TABLE}" ADD COLUMN ${column} INTEGER NOT NULL DEFAULT 0`);
-    } catch {
-    }
-  }
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_BUCKETS_TABLE}" (
-            path TEXT NOT NULL,
-            bucket_ms INTEGER NOT NULL,
-            calls INTEGER NOT NULL DEFAULT 0,
-            errors INTEGER NOT NULL DEFAULT 0,
-            PRIMARY KEY (path, bucket_ms)
-        )`
-  );
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_SCANS_TABLE}" (
-            path TEXT NOT NULL,
-            table_name TEXT NOT NULL,
-            scans INTEGER NOT NULL DEFAULT 0,
-            PRIMARY KEY (path, table_name)
-        )`
-  );
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_INDEX_TABLE}" (
-            table_name TEXT NOT NULL,
-            index_name TEXT NOT NULL,
-            reads INTEGER NOT NULL DEFAULT 0,
-            PRIMARY KEY (table_name, index_name)
-        )`
-  );
-};
-const recordFunctionMetric = (sql, input) => {
-  ensureFunctionMetricsTables(sql);
-  const pathCountRow = runSql(sql, `SELECT COUNT(*) AS n FROM "${FUNCTION_METRICS_TABLE}"`).one();
-  if (pathCountRow.n >= FUNCTION_METRICS_MAX_PATHS) {
-    const tracked = runSql(sql, `SELECT COUNT(*) AS c FROM "${FUNCTION_METRICS_TABLE}" WHERE path = ?`, input.path).one();
-    if (tracked.c === 0) {
-      return;
-    }
-  }
-  const scannedTables = input.scannedTables ? [...new Set(input.scannedTables)] : [];
-  const scanCount = scannedTables.length;
-  const indexHits = dedupeIndexHits(input.indexHits ?? []);
-  const errorCount = input.errored ? 1 : 0;
-  const conflictCount = input.conflicted ? 1 : 0;
-  const lastErrorAt = input.errored ? input.ts : null;
-  const lastErrorMessage = input.errored ? input.errorMessage ?? null : null;
-  runSql(
-    sql,
-    `INSERT INTO "${FUNCTION_METRICS_TABLE}"
-            (path, calls, errors, conflicts, scans, total_duration_ms, min_duration_ms, max_duration_ms, last_called_at, last_error_at, last_error_message)
-         VALUES (?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(path) DO UPDATE SET
-            calls = calls + 1,
-            errors = errors + excluded.errors,
-            conflicts = conflicts + excluded.conflicts,
-            scans = scans + excluded.scans,
-            total_duration_ms = total_duration_ms + excluded.total_duration_ms,
-            min_duration_ms = MIN(COALESCE(min_duration_ms, excluded.min_duration_ms), excluded.min_duration_ms),
-            max_duration_ms = MAX(max_duration_ms, excluded.max_duration_ms),
-            last_called_at = excluded.last_called_at,
-            last_error_at = CASE WHEN excluded.last_error_at IS NULL THEN last_error_at ELSE excluded.last_error_at END,
-            last_error_message = CASE WHEN excluded.last_error_at IS NULL THEN last_error_message ELSE excluded.last_error_message END`,
-    input.path,
-    errorCount,
-    conflictCount,
-    scanCount,
-    input.durationMs,
-    input.durationMs,
-    input.durationMs,
-    input.ts,
-    lastErrorAt,
-    lastErrorMessage
-  );
-  const bucket = bucketFloor(input.ts);
-  runSql(
-    sql,
-    `INSERT INTO "${FUNCTION_METRICS_BUCKETS_TABLE}" (path, bucket_ms, calls, errors)
-         VALUES (?, ?, 1, ?)
-         ON CONFLICT(path, bucket_ms) DO UPDATE SET
-            calls = calls + 1,
-            errors = errors + excluded.errors`,
-    input.path,
-    bucket,
-    errorCount
-  );
-  runSql(
-    sql,
-    `DELETE FROM "${FUNCTION_METRICS_BUCKETS_TABLE}"
-         WHERE path = ?
-           AND bucket_ms <= (
-            SELECT MAX(bucket_ms) - ? FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" WHERE path = ?
-           )`,
-    input.path,
-    FUNCTION_METRICS_BUCKET_RETENTION * FUNCTION_METRICS_BUCKET_MS,
-    input.path
-  );
-  for (const table of scannedTables) {
-    runSql(
-      sql,
-      `INSERT INTO "${FUNCTION_METRICS_SCANS_TABLE}" (path, table_name, scans)
-             VALUES (?, ?, 1)
-             ON CONFLICT(path, table_name) DO UPDATE SET
-                scans = scans + 1`,
-      input.path,
-      table
-    );
-  }
-  for (const hit of indexHits) {
-    runSql(
-      sql,
-      `INSERT INTO "${FUNCTION_METRICS_INDEX_TABLE}" (table_name, index_name, reads)
-             VALUES (?, ?, 1)
-             ON CONFLICT(table_name, index_name) DO UPDATE SET
-                reads = reads + 1`,
-      hit.table,
-      hit.index
-    );
-  }
-};
-const readFunctionMetricScans = (sql) => {
-  ensureFunctionMetricsTables(sql);
-  const rows = runSql(
-    sql,
-    // Bounded read: cap the materialized rows so a bloated attribution table
-    // can't blow up DO memory. Highest-scan rows lead so the dominant
-    // attributions survive the cut.
-    `SELECT path, table_name, scans FROM "${FUNCTION_METRICS_SCANS_TABLE}" ORDER BY scans DESC, path ASC, table_name ASC LIMIT ${String(FUNCTION_METRICS_READ_LIMIT)}`
-  ).toArray();
-  const byPath = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const list = byPath.get(row.path);
-    const entry = { scans: row.scans, table: row.table_name };
-    if (list === void 0) {
-      byPath.set(row.path, [entry]);
-    } else {
-      list.push(entry);
-    }
-  }
-  return byPath;
-};
-const readFunctionMetricIndexHits = (sql) => {
-  ensureFunctionMetricsTables(sql);
-  const rows = runSql(
-    sql,
-    `SELECT table_name, index_name, reads FROM "${FUNCTION_METRICS_INDEX_TABLE}" ORDER BY table_name ASC, index_name ASC`
-  ).toArray();
-  return rows.map((row) => {
-    return { index: row.index_name, reads: row.reads, table: row.table_name };
-  });
-};
-const mergeScanAttribution = (into, scanned) => {
-  for (const table of scanned) {
-    const entry = into.find((attribution) => attribution.table === table);
-    if (entry === void 0) {
-      into.push({ scans: 1, table });
-    } else {
-      entry.scans += 1;
-    }
-  }
-  into.sort((a, b) => b.scans - a.scans || a.table.localeCompare(b.table));
-  return into;
-};
-const readFunctionMetrics = (sql) => {
-  ensureFunctionMetricsTables(sql);
-  const scansByPath = readFunctionMetricScans(sql);
-  const rows = runSql(sql, `SELECT * FROM "${FUNCTION_METRICS_TABLE}" ORDER BY last_called_at DESC LIMIT ${String(FUNCTION_METRICS_READ_LIMIT)}`).toArray();
-  return rows.map((row) => {
-    return {
-      calls: row.calls,
-      conflicts: row.conflicts,
-      errors: row.errors,
-      lastCalledAt: row.last_called_at,
-      lastErrorAt: row.last_error_at,
-      lastErrorMessage: row.last_error_message,
-      maxDurationMs: row.max_duration_ms,
-      path: row.path,
-      scannedTables: scansByPath.get(row.path) ?? [],
-      scans: row.scans,
-      totalDurationMs: row.total_duration_ms
-    };
-  });
-};
-const readFunctionMetricBuckets = (sql, path) => {
-  ensureFunctionMetricsTables(sql);
-  const rows = path === void 0 ? runSql(
-    sql,
-    `SELECT path, bucket_ms, calls, errors FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" ORDER BY bucket_ms ASC, path ASC`
-  ).toArray() : runSql(
-    sql,
-    `SELECT path, bucket_ms, calls, errors FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" WHERE path = ? ORDER BY bucket_ms ASC`,
-    path
-  ).toArray();
-  return rows.map((row) => {
-    return { bucketMs: row.bucket_ms, calls: row.calls, errors: row.errors, path: row.path };
-  });
-};
-const readFunctionMetricsTotals = (sql) => {
-  ensureFunctionMetricsTables(sql);
-  const row = runSql(
-    sql,
-    `SELECT SUM(calls) AS requests, SUM(errors) AS errors FROM "${FUNCTION_METRICS_TABLE}"`
-  ).one();
-  return { errors: row.errors ?? 0, requests: row.requests ?? 0 };
-};
-
-export { FUNCTION_METRICS_BUCKETS_TABLE, FUNCTION_METRICS_BUCKET_MS, FUNCTION_METRICS_BUCKET_RETENTION, FUNCTION_METRICS_INDEX_TABLE, FUNCTION_METRICS_MAX_PATHS, FUNCTION_METRICS_READ_LIMIT, FUNCTION_METRICS_SCANS_TABLE, FUNCTION_METRICS_TABLE, ensureFunctionMetricsTables, mergeScanAttribution, readFunctionMetricBuckets, readFunctionMetricIndexHits, readFunctionMetricScans, readFunctionMetrics, readFunctionMetricsTotals, recordFunctionMetric };

package/dist/packem_shared/GEO_DEFAULT_PRECISION-BWnsNmpP.mjs

@@ -1,114 +0,0 @@
-const BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz";
-const GEO_DEFAULT_PRECISION = 9;
-const EARTH_RADIUS_METERS = 63710088e-1;
-const CELL_WIDTH_METERS = [Number.POSITIVE_INFINITY, 5009400, 1252300, 156500, 39100, 4900, 1200, 152.9, 38.2, 4.77, 1.19, 0.149, 0.037];
-const clampPrecision = (precision) => Math.min(Math.max(Math.trunc(precision), 1), 12);
-const encodeGeohash = (point, precision) => {
-  const chars = clampPrecision(precision);
-  let latMin = -90;
-  let latMax = 90;
-  let lngMin = -180;
-  let lngMax = 180;
-  let hash = "";
-  let bit = 0;
-  let index = 0;
-  let even = true;
-  while (hash.length < chars) {
-    if (even) {
-      const mid = (lngMin + lngMax) / 2;
-      if (point.lng >= mid) {
-        index = index * 2 + 1;
-        lngMin = mid;
-      } else {
-        index *= 2;
-        lngMax = mid;
-      }
-    } else {
-      const mid = (latMin + latMax) / 2;
-      if (point.lat >= mid) {
-        index = index * 2 + 1;
-        latMin = mid;
-      } else {
-        index *= 2;
-        latMax = mid;
-      }
-    }
-    even = !even;
-    if (bit < 4) {
-      bit += 1;
-    } else {
-      hash += BASE32[index] ?? "0";
-      bit = 0;
-      index = 0;
-    }
-  }
-  return hash;
-};
-const haversineMeters = (a, b) => {
-  const toRadians = (degrees) => degrees * Math.PI / 180;
-  const dLat = toRadians(b.lat - a.lat);
-  const dLng = toRadians(b.lng - a.lng);
-  const lat1 = toRadians(a.lat);
-  const lat2 = toRadians(b.lat);
-  const h = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
-  return 2 * EARTH_RADIUS_METERS * Math.asin(Math.min(1, Math.sqrt(h)));
-};
-const precisionForRadius = (radiusMeters) => {
-  for (let length = CELL_WIDTH_METERS.length - 1; length >= 1; length -= 1) {
-    const width = CELL_WIDTH_METERS[length];
-    if (width !== void 0 && width >= radiusMeters) {
-      return length;
-    }
-  }
-  return 1;
-};
-const NEIGHBOURS = {
-  east: ["bc01fg45238967deuvhjyznpkmstqrwx", "bc01fg45238967deuvhjyznpkmstqrwx"],
-  north: ["p0r21436x8zb9dcf5h7kjnmqesgutwvy", "bc01fg45238967deuvhjyznpkmstqrwx"],
-  south: ["14365h7k9dcfesgujnmqp0r2twvyx8zb", "238967debc01fg45kmstqrwxuvhjyznp"],
-  west: ["238967debc01fg45kmstqrwxuvhjyznp", "238967debc01fg45kmstqrwxuvhjyznp"]
-};
-const BORDERS = {
-  east: ["bcfguvyz", "prxz"],
-  north: ["prxz", "bcfguvyz"],
-  south: ["028b", "0145hjnp"],
-  west: ["0145hjnp", "028b"]
-};
-const adjacent = (hash, direction) => {
-  const lower = hash.toLowerCase();
-  const lastChar = lower.at(-1) ?? "";
-  let base = lower.slice(0, -1);
-  const type = lower.length % 2 === 0 ? 0 : 1;
-  if (BORDERS[direction][type].includes(lastChar) && base !== "") {
-    base = adjacent(base, direction);
-  }
-  return base + (BASE32[NEIGHBOURS[direction][type].indexOf(lastChar)] ?? "");
-};
-const coveringGeohashes = (center, radiusMeters) => {
-  const precision = precisionForRadius(Math.max(radiusMeters, 1));
-  const origin = encodeGeohash(center, precision);
-  const north = adjacent(origin, "north");
-  const south = adjacent(origin, "south");
-  const cells = [
-    origin,
-    north,
-    south,
-    adjacent(origin, "east"),
-    adjacent(origin, "west"),
-    adjacent(north, "east"),
-    adjacent(north, "west"),
-    adjacent(south, "east"),
-    adjacent(south, "west")
-  ];
-  return [...new Set(cells)];
-};
-const pointInBoundingBox = (point, box) => point.lat >= box.sw.lat && point.lat <= box.ne.lat && point.lng >= box.sw.lng && point.lng <= box.ne.lng;
-const boundingBoxCenter = (box) => {
-  return { lat: (box.sw.lat + box.ne.lat) / 2, lng: (box.sw.lng + box.ne.lng) / 2 };
-};
-const boundingBoxGeohashes = (box) => {
-  const center = boundingBoxCenter(box);
-  return coveringGeohashes(center, Math.max(haversineMeters(center, box.ne), 1));
-};
-
-export { GEO_DEFAULT_PRECISION, boundingBoxCenter, boundingBoxGeohashes, coveringGeohashes, encodeGeohash, haversineMeters, pointInBoundingBox };

package/dist/packem_shared/LogBuffer-B_Ezju_N.mjs

@@ -1,37 +0,0 @@
-const DEFAULT_CAPACITY = 500;
-class LogBuffer {
-  /** Backing store, kept in insertion order (oldest first). */
-  buffer = [];
-  capacity;
-  constructor(capacity = DEFAULT_CAPACITY) {
-    this.capacity = capacity > 0 ? Math.trunc(capacity) : DEFAULT_CAPACITY;
-  }
-  /** Number of entries currently buffered. */
-  get size() {
-    return this.buffer.length;
-  }
-  /** Drop every buffered entry. */
-  clear() {
-    this.buffer.length = 0;
-  }
-  /**
-   * Snapshot of the buffered entries, **newest first** so the panel renders
-   * the most recent activity at the top without re-sorting. Returns a fresh
-   * array each call; the caller may mutate it freely.
-   */
-  entries() {
-    return this.buffer.toReversed();
-  }
-  /**
-   * Append an entry, evicting the oldest when at capacity so the buffer never
-   * grows past its bound.
-   */
-  push(entry) {
-    this.buffer.push(entry);
-    if (this.buffer.length > this.capacity) {
-      this.buffer.shift();
-    }
-  }
-}
-
-export { LogBuffer };