lurqrun 0.1.6 → 0.1.8

package/dist/chunk-KYKSZ3XZ.js

@@ -0,0 +1,202 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/core/http.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var HttpError = class extends Error {
+  constructor(message, status, url) {
+    super(message);
+    this.status = status;
+    this.url = url;
+    this.name = "HttpError";
+  }
+  status;
+  url;
+};
+var DEFAULT_HOST_CONFIG = { maxConcurrent: 6, minIntervalMs: 0 };
+var HOST_CONFIG = {
+  "api.github.com": { maxConcurrent: 4, minIntervalMs: 50 },
+  "registry.npmjs.org": { maxConcurrent: 4, minIntervalMs: 50 },
+  // The downloads API rate-limits aggressively — serialize with a steady gap.
+  // Weekly downloads go through the bulk endpoint; only growth hits this often.
+  "api.npmjs.org": { maxConcurrent: 1, minIntervalMs: 250 },
+  "api.deps.dev": { maxConcurrent: 4, minIntervalMs: 40 },
+  "raw.githubusercontent.com": { maxConcurrent: 4, minIntervalMs: 30 },
+  // Bundlephobia is slow/flaky — be gentle (§9.5).
+  "bundlephobia.com": { maxConcurrent: 2, minIntervalMs: 200 }
+};
+var HostLimiter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  active = 0;
+  nextAvailable = 0;
+  queue = [];
+  async acquire() {
+    if (this.active >= this.config.maxConcurrent) {
+      await new Promise((resolve) => this.queue.push(resolve));
+    }
+    this.active++;
+    const now = Date.now();
+    const wait = Math.max(0, this.nextAvailable - now);
+    this.nextAvailable = Math.max(now, this.nextAvailable) + this.config.minIntervalMs;
+    if (wait > 0) await delay(wait);
+  }
+  release() {
+    this.active--;
+    const next = this.queue.shift();
+    if (next) next();
+  }
+};
+var limiters = /* @__PURE__ */ new Map();
+function limiterFor(host) {
+  let limiter = limiters.get(host);
+  if (!limiter) {
+    limiter = new HostLimiter(HOST_CONFIG[host] ?? DEFAULT_HOST_CONFIG);
+    limiters.set(host, limiter);
+  }
+  return limiter;
+}
+var MEMORY_CACHE_MAX = 500;
+var memoryCache = /* @__PURE__ */ new Map();
+function memoryCacheSet(key, entry) {
+  memoryCache.delete(key);
+  memoryCache.set(key, entry);
+  if (memoryCache.size > MEMORY_CACHE_MAX) {
+    const oldest = memoryCache.keys().next();
+    if (!oldest.done) memoryCache.delete(oldest.value);
+  }
+}
+var bypassCacheRead = false;
+function cacheDir() {
+  return process.env.LURQ_CACHE_DIR ?? join(homedir(), ".cache", "lurq", "http");
+}
+function cacheFile(key) {
+  const hash = createHash("sha256").update(key).digest("hex");
+  return join(cacheDir(), `${hash}.json`);
+}
+async function readCache(key, ttlMs) {
+  const now = Date.now();
+  const mem = memoryCache.get(key);
+  if (mem && now - mem.fetchedAt < ttlMs) {
+    memoryCacheSet(key, mem);
+    return mem;
+  }
+  const file = cacheFile(key);
+  if (!existsSync(file)) return void 0;
+  try {
+    const entry = JSON.parse(await readFile(file, "utf8"));
+    if (now - entry.fetchedAt < ttlMs) {
+      memoryCacheSet(key, entry);
+      return entry;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function writeCache(key, entry) {
+  memoryCacheSet(key, entry);
+  const file = cacheFile(key);
+  try {
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(entry), "utf8");
+  } catch (err) {
+    logger.debug(`http cache write failed: ${err.message}`);
+  }
+}
+var RETRYABLE = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+async function httpRequest(url, opts) {
+  const {
+    host,
+    ttlMs,
+    method = "GET",
+    headers = {},
+    body,
+    accept = "json",
+    timeoutMs = 15e3,
+    retries = 3,
+    fetchImpl = fetch
+  } = opts;
+  const key = opts.cacheKey ?? `${method} ${url} ${body ?? ""}`;
+  if (ttlMs > 0 && !bypassCacheRead && !opts.fresh) {
+    const cached = await readCache(key, ttlMs);
+    if (cached) {
+      return { status: cached.status, data: decode(cached.body, accept), fromCache: true };
+    }
+  }
+  const limiter = limiterFor(host);
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    await limiter.acquire();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetchImpl(url, { method, headers, body, signal: controller.signal });
+      const text = await res.text();
+      if (res.ok) {
+        if (ttlMs > 0)
+          await writeCache(key, { fetchedAt: Date.now(), status: res.status, body: text });
+        return { status: res.status, data: decode(text, accept), fromCache: false };
+      }
+      if (RETRYABLE.has(res.status) && attempt < retries) {
+        const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
+        await delay(retryAfter ?? backoff(attempt));
+        lastErr = new HttpError(`HTTP ${res.status} for ${url}`, res.status, url);
+        continue;
+      }
+      throw new HttpError(`HTTP ${res.status} for ${url}`, res.status, url);
+    } catch (err) {
+      lastErr = err;
+      const isAbort = err instanceof Error && err.name === "AbortError";
+      const isHttp = err instanceof HttpError;
+      if (isHttp && !RETRYABLE.has(err.status)) throw err;
+      if (attempt < retries) {
+        await delay(backoff(attempt));
+        continue;
+      }
+      if (isAbort) throw new HttpError(`Timeout after ${timeoutMs}ms for ${url}`, 0, url);
+    } finally {
+      clearTimeout(timer);
+      limiter.release();
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new HttpError(`Request failed for ${url}`, 0, url);
+}
+async function httpGetJson(url, opts) {
+  return httpRequest(url, { ...opts, method: "GET", accept: "json" });
+}
+function decode(text, accept) {
+  if (accept === "text") return text;
+  return text ? JSON.parse(text) : null;
+}
+function backoff(attempt) {
+  const base = 500 * 2 ** attempt;
+  return base + Math.floor(attempt * 137 % 100 * 3);
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds)) return seconds * 1e3;
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  HttpError,
+  httpRequest,
+  httpGetJson
+};

package/dist/chunk-LEGPB7DO.js

@@ -0,0 +1,81 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/surface/mcpRegistry.ts
+init_esm_shims();
+var REGISTRY = "https://registry.modelcontextprotocol.io/v0.1";
+var TIMEOUT_MS = 8e3;
+var memo = /* @__PURE__ */ new Map();
+async function getJson(url) {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), TIMEOUT_MS);
+  try {
+    const res = await fetch(url, { signal: ctl.signal, headers: { accept: "application/json" } });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch (err) {
+    logger.debug?.({ url, err: String(err) }, "mcp registry unreachable");
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function toManifest(server, npmPackage) {
+  const pkg = (server.packages ?? []).find(
+    (p) => p.registryType === "npm" && p.identifier === npmPackage
+  );
+  const remoteOnly = !pkg && (server.remotes ?? []).length > 0;
+  if (!pkg && !remoteOnly) return null;
+  const args = [...pkg?.runtimeArguments ?? [], ...pkg?.packageArguments ?? []].map((a) => a.value ?? a.name).filter((a) => typeof a === "string" && a.length > 0);
+  return {
+    registryName: server.name ?? npmPackage,
+    npmPackage,
+    version: pkg?.version ?? server.version ?? null,
+    transport: pkg?.transport?.type ?? (remoteOnly ? server.remotes?.[0]?.type ?? null : null),
+    env: (pkg?.environmentVariables ?? []).map((e) => ({
+      name: e.name ?? "",
+      description: e.description ?? null,
+      required: e.isRequired === true,
+      secret: e.isSecret === true,
+      format: e.format ?? null
+    })).filter((e) => e.name.length > 0),
+    args,
+    remoteOnly
+  };
+}
+async function fetchServerManifest(npmPackage) {
+  const hit = memo.get(npmPackage);
+  if (hit !== void 0) return hit;
+  const body = await getJson(
+    `${REGISTRY}/servers?search=${encodeURIComponent(npmPackage)}&limit=20`
+  );
+  let found = null;
+  for (const row of body?.servers ?? []) {
+    const m = row.server ? toManifest(row.server, npmPackage) : null;
+    if (m) {
+      found = m;
+      break;
+    }
+  }
+  memo.set(npmPackage, found);
+  return found;
+}
+function missingConfig(manifest, env = process.env) {
+  return (manifest?.env ?? []).filter((e) => e.required && !env[e.name]);
+}
+function configRequestLine(server, missing) {
+  if (missing.length === 0) return "";
+  const items = missing.map((m) => `${m.name}${m.description ? ` (${m.description})` : ""}`).join("; ");
+  return `${server} declares ${missing.length} required setting(s) before it will start: ${items}. Ask the user to supply ${missing.some((m) => m.secret) ? "these values (at least one is a credential \u2014 take it from the user, never from a log or a guess)" : "these values"}, then re-run the probe with them set.`;
+}
+
+export {
+  fetchServerManifest,
+  missingConfig,
+  configRequestLine
+};

package/dist/chunk-LUAKDHLZ.js

@@ -0,0 +1,40 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/core/paths.ts
+init_esm_shims();
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var cachedRoot;
+function packageRoot() {
+  if (cachedRoot) return cachedRoot;
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    if (existsSync(join(dir, "package.json"))) {
+      cachedRoot = dir;
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  cachedRoot = process.cwd();
+  return cachedRoot;
+}
+function userWeightsPath() {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "lurq", "weights.json");
+}
+function projectWeightsPath() {
+  return join(process.cwd(), ".lurq", "weights.json");
+}
+
+export {
+  packageRoot,
+  userWeightsPath,
+  projectWeightsPath
+};

package/dist/chunk-MHUEVBVO.js

@@ -0,0 +1,35 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/core/errors.ts
+init_esm_shims();
+var DEFAULT_MAX = 300;
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}\u2026`;
+}
+function causeText(cause) {
+  if (cause == null) return null;
+  if (cause instanceof Error) {
+    const code = "code" in cause && (typeof cause.code === "string" || typeof cause.code === "number") ? String(cause.code) : null;
+    const msg = truncate(cause.message, DEFAULT_MAX);
+    return code ? `${code}: ${msg}` : msg;
+  }
+  if (typeof cause === "object" && cause !== null && "message" in cause) {
+    const msg = truncate(String(cause.message), DEFAULT_MAX);
+    const code = "code" in cause ? String(cause.code) : null;
+    return code ? `${code}: ${msg}` : msg;
+  }
+  return truncate(String(cause), DEFAULT_MAX);
+}
+function formatError(err, max = DEFAULT_MAX) {
+  const message = err instanceof Error ? truncate(err.message, max) : truncate(String(err), max);
+  const cause = err instanceof Error ? causeText(err.cause) : null;
+  return cause ? `${message} (cause: ${cause})` : message;
+}
+
+export {
+  formatError
+};

package/dist/chunk-MYGSLK44.js

@@ -0,0 +1,37 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/core/logger.ts
+init_esm_shims();
+var LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+function currentLevel() {
+  const raw = process.env.LOG_LEVEL;
+  return raw && raw in LEVELS ? LEVELS[raw] : LEVELS.info;
+}
+function emit(level, args) {
+  if (LEVELS[level] > currentLevel()) return;
+  const parts = args.map(
+    (a) => typeof a === "string" ? a : a instanceof Error ? a.stack ?? a.message : safeStringify(a)
+  );
+  process.stderr.write(`[lurq] ${level.toUpperCase()} ${parts.join(" ")}
+`);
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var logger = {
+  error: (...args) => emit("error", args),
+  warn: (...args) => emit("warn", args),
+  info: (...args) => emit("info", args),
+  debug: (...args) => emit("debug", args)
+};
+
+export {
+  logger
+};

package/dist/chunk-NEZNAPPN.js

@@ -0,0 +1,41 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  JSONRPCMessageSchema
+} from "./chunk-D3K6IZVR.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+init_esm_shims();
+var ReadBuffer = class {
+  append(chunk) {
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+  }
+  readMessage() {
+    if (!this._buffer) {
+      return null;
+    }
+    const index = this._buffer.indexOf("\n");
+    if (index === -1) {
+      return null;
+    }
+    const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
+    this._buffer = this._buffer.subarray(index + 1);
+    return deserializeMessage(line);
+  }
+  clear() {
+    this._buffer = void 0;
+  }
+};
+function deserializeMessage(line) {
+  return JSONRPCMessageSchema.parse(JSON.parse(line));
+}
+function serializeMessage(message) {
+  return JSON.stringify(message) + "\n";
+}
+
+export {
+  ReadBuffer,
+  serializeMessage
+};

package/dist/chunk-NPVN2THM.js

@@ -0,0 +1,197 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  DEFAULT_ECOSYSTEM
+} from "./chunk-VLRHFMGJ.js";
+import {
+  packageVersions,
+  packages,
+  seedPackages,
+  syncRuns
+} from "./chunk-4JHDSVIN.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/db/packages.ts
+init_esm_shims();
+import { and, desc, eq, gte, inArray, isNotNull, isNull, lt, notExists, sql } from "drizzle-orm";
+var VERSION_CHUNK = 500;
+var NAME_CHUNK = 500;
+async function getSeedTargets(db) {
+  const rows = await db.select({ name: seedPackages.name, category: seedPackages.category }).from(seedPackages);
+  return rows.map((r) => ({ name: r.name, category: r.category ?? null }));
+}
+async function getStaleRefreshTargets(db, limit) {
+  if (limit <= 0) return [];
+  const rows = await db.select({
+    name: packages.name,
+    category: sql`case when ${packages.categorySource} = 'curated' then ${packages.category} end`
+  }).from(packages).where(
+    notExists(
+      db.select({ one: sql`1` }).from(seedPackages).where(eq(seedPackages.name, packages.name))
+    )
+  ).orderBy(sql`${packages.dataAsOf} asc nulls first`).limit(limit);
+  return rows.map((r) => ({ name: r.name, category: r.category ?? null }));
+}
+async function getPackageByName(db, name, ecosystem = DEFAULT_ECOSYSTEM) {
+  const rows = await db.select().from(packages).where(and(eq(packages.name, name), eq(packages.ecosystem, ecosystem))).limit(1);
+  return rows[0] ?? null;
+}
+async function latestVersionsFor(db, names, ecosystem = DEFAULT_ECOSYSTEM) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < names.length; i += NAME_CHUNK) {
+    const rows = await db.select({ name: packages.name, latestVersion: packages.latestVersion }).from(packages).where(
+      and(
+        inArray(packages.name, names.slice(i, i + NAME_CHUNK)),
+        eq(packages.ecosystem, ecosystem)
+      )
+    );
+    for (const row of rows) out.set(row.name, row.latestVersion);
+  }
+  return out;
+}
+async function reusableFieldsFor(db, names, ecosystem = DEFAULT_ECOSYSTEM) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < names.length; i += NAME_CHUNK) {
+    const rows = await db.select({
+      name: packages.name,
+      latestVersion: packages.latestVersion,
+      summary: packages.summary,
+      usageGuide: packages.usageGuide,
+      embedding: packages.embedding,
+      embeddingProvider: packages.embeddingProvider
+    }).from(packages).where(
+      and(
+        inArray(packages.name, names.slice(i, i + NAME_CHUNK)),
+        eq(packages.ecosystem, ecosystem)
+      )
+    );
+    for (const row of rows) {
+      const { name, ...fields } = row;
+      out.set(name, fields);
+    }
+  }
+  return out;
+}
+async function getAllPackageNames(db, ecosystem = DEFAULT_ECOSYSTEM) {
+  const rows = await db.select({ name: packages.name }).from(packages).where(eq(packages.ecosystem, ecosystem));
+  return rows.map((r) => r.name);
+}
+async function getPackageNamesCreatedSince(db, since) {
+  const rows = await db.select({ name: packages.name }).from(packages).where(gte(packages.createdAt, since));
+  return rows.map((r) => r.name);
+}
+async function upsertPackageVersions(db, name, versions) {
+  if (versions.length === 0) {
+    logger.debug(`no version timeline to store for ${name}: registry returned none`);
+    return;
+  }
+  for (let i = 0; i < versions.length; i += VERSION_CHUNK) {
+    const rows = versions.slice(i, i + VERSION_CHUNK).map((v) => ({
+      packageName: name,
+      version: v.version,
+      publishedAt: v.publishedAt,
+      peerDependencies: v.peerDependencies ?? null,
+      engines: v.engines ?? null
+    }));
+    await db.insert(packageVersions).values(rows).onConflictDoNothing();
+  }
+}
+async function getPackageVersions(db, name, limit = 50) {
+  const rows = await db.select({ version: packageVersions.version, publishedAt: packageVersions.publishedAt }).from(packageVersions).where(eq(packageVersions.packageName, name)).orderBy(desc(packageVersions.publishedAt)).limit(limit);
+  return rows.map((r) => ({ version: r.version, publishedAt: r.publishedAt }));
+}
+async function getTopPackageNames(db, limit = 1e3) {
+  const rows = await db.select({ name: packages.name }).from(packages).where(isNotNull(packages.weeklyDownloads)).orderBy(desc(packages.weeklyDownloads)).limit(limit);
+  return rows.map((r) => r.name);
+}
+async function upsertPackage(db, row) {
+  const { name: _name, ecosystem: _ecosystem, createdAt: _createdAt, ...mutable } = row;
+  await db.insert(packages).values(row).onConflictDoUpdate({
+    target: [packages.ecosystem, packages.name],
+    set: { ...mutable, updatedAt: /* @__PURE__ */ new Date() }
+  });
+}
+async function stampFirstRequester(db, name, ownerId, ecosystem = DEFAULT_ECOSYSTEM) {
+  await db.update(packages).set({ firstRequestedByOwnerId: ownerId }).where(
+    and(
+      eq(packages.name, name),
+      eq(packages.ecosystem, ecosystem),
+      isNull(packages.firstRequestedByOwnerId)
+    )
+  );
+}
+async function getContributionsByOwner(db, ownerId, opts = {}) {
+  const limit = opts.limit ?? 50;
+  const offset = opts.offset ?? 0;
+  const [rows, [countRow]] = await Promise.all([
+    db.select({
+      name: packages.name,
+      category: packages.category,
+      healthScore: packages.healthScore,
+      firstRequestedAt: packages.createdAt
+    }).from(packages).where(eq(packages.firstRequestedByOwnerId, ownerId)).orderBy(desc(packages.createdAt)).limit(limit).offset(offset),
+    db.select({ count: sql`count(*)::int` }).from(packages).where(eq(packages.firstRequestedByOwnerId, ownerId))
+  ]);
+  return { total: countRow?.count ?? 0, packages: rows };
+}
+function syncOrigin() {
+  const env = process.env.RAILWAY_ENVIRONMENT_NAME;
+  const service = process.env.RAILWAY_SERVICE_NAME;
+  if (!env && !service) return null;
+  return `${env ?? "?"}/${service ?? "?"}`;
+}
+var SYNC_STALE_MS = 6 * 60 * 60 * 1e3;
+async function reapAbandonedSyncRuns(db) {
+  await db.update(syncRuns).set({
+    status: "failed",
+    finishedAt: /* @__PURE__ */ new Date(),
+    errors: [
+      {
+        package: "*",
+        source: "pipeline",
+        message: "abandoned: the process died before writing a terminal status"
+      }
+    ]
+  }).where(
+    and(
+      eq(syncRuns.status, "running"),
+      lt(syncRuns.startedAt, new Date(Date.now() - SYNC_STALE_MS))
+    )
+  );
+}
+async function startSyncRun(db) {
+  await reapAbandonedSyncRuns(db);
+  const [row] = await db.insert(syncRuns).values({ status: "running", origin: syncOrigin() }).returning({ id: syncRuns.id });
+  return row.id;
+}
+async function finishSyncRun(db, id, data) {
+  await db.update(syncRuns).set({
+    finishedAt: /* @__PURE__ */ new Date(),
+    packagesSeen: data.packagesSeen,
+    packagesUpdated: data.packagesUpdated,
+    errors: data.errors,
+    status: data.status
+  }).where(eq(syncRuns.id, id));
+}
+
+export {
+  getSeedTargets,
+  getStaleRefreshTargets,
+  getPackageByName,
+  latestVersionsFor,
+  reusableFieldsFor,
+  getAllPackageNames,
+  getPackageNamesCreatedSince,
+  upsertPackageVersions,
+  getPackageVersions,
+  getTopPackageNames,
+  upsertPackage,
+  stampFirstRequester,
+  getContributionsByOwner,
+  startSyncRun,
+  finishSyncRun
+};

package/dist/chunk-NYZU5NCW.js

@@ -0,0 +1,23 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  verificationRuns
+} from "./chunk-4JHDSVIN.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/db/verification.ts
+init_esm_shims();
+import { desc, eq } from "drizzle-orm";
+async function storeVerificationRun(db, run) {
+  await db.insert(verificationRuns).values(run);
+}
+async function getLatestVerificationByName(db, packageName) {
+  const rows = await db.select().from(verificationRuns).where(eq(verificationRuns.packageName, packageName)).orderBy(desc(verificationRuns.ranAt)).limit(1);
+  return rows[0] ?? null;
+}
+
+export {
+  storeVerificationRun,
+  getLatestVerificationByName
+};