lurqrun 0.1.6 → 0.1.7

package/dist/policy-3P6BGRDN.js

@@ -0,0 +1,115 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  validateSelectionPolicy
+} from "./chunk-LBFGSSF2.js";
+import {
+  describeRules,
+  diffPolicies
+} from "./chunk-PSX3GIAN.js";
+import {
+  getPolicy,
+  getPolicyDecisions,
+  getPolicyHistory,
+  putPolicy
+} from "./chunk-4ZYCIMY4.js";
+import {
+  resolveApiKey
+} from "./chunk-Y5GI7RL3.js";
+import "./chunk-GPTKSNR6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/policy.ts
+init_esm_shims();
+import { readFileSync, writeFileSync } from "fs";
+async function runPolicyPull(file, opts) {
+  const text = `${JSON.stringify(await getPolicy(opts), null, 2)}
+`;
+  if (!file) {
+    process.stdout.write(text);
+    return;
+  }
+  writeFileSync(file, text);
+  console.log(`wrote ${file}`);
+}
+function readPolicyFile(file) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(file, "utf8"));
+  } catch (err) {
+    console.error(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  const result = validateSelectionPolicy(raw);
+  if ("error" in result) {
+    console.error(`${file}: ${result.error}`);
+    return null;
+  }
+  return result.policy;
+}
+function indent(lines, empty) {
+  return lines.length ? lines.map((line) => `  ${line}`).join("\n") : `  ${empty}`;
+}
+async function runPolicyPush(file, opts) {
+  const policy = readPolicyFile(file);
+  if (!policy) {
+    process.exitCode = 1;
+    return;
+  }
+  if (opts.check) {
+    console.log(`${file} is a valid policy.`);
+    if (!resolveApiKey(opts.apiKey)) {
+      console.log(indent(describeRules(policy), "no rules enforced."));
+      return;
+    }
+    console.log("pushing it would change:");
+    console.log(indent(diffPolicies(await getPolicy(opts), policy), "nothing."));
+    return;
+  }
+  const { previous } = await putPolicy(policy, opts);
+  console.log("policy replaced.");
+  console.log(
+    previous ? indent(diffPolicies(previous, policy), "no rule changes.") : indent(describeRules(policy), "no rules enforced.")
+  );
+}
+async function runPolicyHistory(opts) {
+  const changes = await getPolicyHistory(opts);
+  if (opts.json) {
+    console.log(JSON.stringify(changes, null, 2));
+    return;
+  }
+  if (!changes.length) {
+    console.log("no policy changes recorded yet.");
+    return;
+  }
+  for (const change of changes) {
+    console.log(`${change.at.slice(0, 16).replace("T", " ")} UTC  ${change.actor}`);
+    console.log(indent(change.changes, "saved with no rule changes."));
+  }
+}
+async function runPolicyLog(opts) {
+  const days = opts.days === void 0 ? 30 : Number(opts.days);
+  const decisions = await getPolicyDecisions(days, opts);
+  if (opts.json) {
+    console.log(JSON.stringify(decisions, null, 2));
+    return;
+  }
+  if (!decisions.length) {
+    console.log(`nothing refused or warned about in the last ${days} days.`);
+    return;
+  }
+  const width = Math.max(...decisions.map((d) => d.packageName.length));
+  for (const d of decisions) {
+    console.log(
+      `${d.packageName.padEnd(width)}  ${d.action.padEnd(7)}  ${d.rule.padEnd(10)}  ${String(d.count).padStart(4)}x  last ${d.lastDay}`
+    );
+  }
+}
+export {
+  readPolicyFile,
+  runPolicyHistory,
+  runPolicyLog,
+  runPolicyPull,
+  runPolicyPush
+};

package/dist/references-6N7VEPHT.js

@@ -0,0 +1,14 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  SURFACE_CLAIM_KINDS,
+  isRootSpecifier,
+  packageOfSpecifier,
+  scanReferences
+} from "./chunk-ST2X2GYN.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  SURFACE_CLAIM_KINDS,
+  isRootSpecifier,
+  packageOfSpecifier,
+  scanReferences
+};

package/dist/release-4U4ABNSJ.js

@@ -0,0 +1,128 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  diffSurfaces
+} from "./chunk-SHCEBP3J.js";
+import {
+  readManifest
+} from "./chunk-ELGCAM7P.js";
+import {
+  fetchAndExtract
+} from "./chunk-BV32UNLL.js";
+import "./chunk-AHBP533R.js";
+import "./chunk-SJOVFF7B.js";
+import {
+  require_semver
+} from "./chunk-3GHJR7XR.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/surface/release.ts
+init_esm_shims();
+var import_semver = __toESM(require_semver(), 1);
+var RANK = { patch: 0, minor: 1, major: 2 };
+function declaredBump(from, to) {
+  if (!import_semver.default.gt(to, from)) return null;
+  if (import_semver.default.major(to) !== import_semver.default.major(from)) return "major";
+  if (import_semver.default.minor(to) !== import_semver.default.minor(from)) return "minor";
+  return "patch";
+}
+function covers(declared, required, baselineMajor) {
+  if (baselineMajor === 0 && required === "major") return RANK[declared] >= RANK.minor;
+  return RANK[declared] >= RANK[required];
+}
+function releaseVerdict(publishedVersion, localVersion, diff) {
+  const required = diff.removed.length || diff.arityChanged.length || diff.typeOnlyRemoved.length ? "major" : diff.added.length ? "minor" : "patch";
+  const declared = declaredBump(publishedVersion, localVersion);
+  const verdict = declared !== null && covers(declared, required, import_semver.default.major(publishedVersion)) ? "ok" : "understated";
+  return { declared, required, verdict };
+}
+var inconclusive = (base, reason) => ({
+  ...base,
+  declared: null,
+  required: "patch",
+  verdict: "inconclusive",
+  removed: [],
+  arityChanged: [],
+  typeOnlyRemoved: [],
+  added: [],
+  inconclusive: reason
+});
+async function checkRelease(dir, opts = {}) {
+  const manifest = readManifest(dir);
+  const name = manifest?.name;
+  const base = {
+    package: name ?? dir,
+    publishedVersion: null,
+    localVersion: manifest?.version ?? null
+  };
+  if (!name) return inconclusive(base, `no readable package.json in ${dir}`);
+  if (!manifest.version) return inconclusive(base, "package.json has no version field");
+  const { extractSurface } = await import("./extract-NKGKLIVT.js");
+  const local = extractSurface(dir, { manifest });
+  if (local.undeclaredReason) {
+    return inconclusive(base, `${local.undeclaredReason} \u2014 build the package first`);
+  }
+  const published = await fetchAndExtract(name, opts.against ?? "latest", {
+    fetchImpl: opts.fetchImpl
+  });
+  if (!published) {
+    return inconclusive(base, `${name} has no published version to compare against`);
+  }
+  const withVersion = { ...base, publishedVersion: published.resolvedVersion };
+  const diff = diffSurfaces(published.surface, local);
+  if (diff.inconclusive) return inconclusive(withVersion, diff.inconclusive);
+  return {
+    ...withVersion,
+    ...releaseVerdict(published.resolvedVersion, manifest.version, diff),
+    removed: diff.removed.map((s) => s.path),
+    arityChanged: diff.arityChanged,
+    typeOnlyRemoved: diff.typeOnlyRemoved.map((s) => s.path),
+    added: diff.added.map((s) => s.path)
+  };
+}
+var LIST_CAP = 12;
+var list = (label, items) => {
+  if (!items.length) return [];
+  const shown = items.slice(0, LIST_CAP);
+  const more = items.length - shown.length;
+  return [
+    `  ${label} (${items.length}):`,
+    ...shown.map((s) => `    \xB7 ${s}`),
+    ...more > 0 ? [`    \u2026 ${more} more`] : []
+  ];
+};
+function formatReleaseCheck(c) {
+  const out = [`lurq, release check \u2014 ${c.package}`, ""];
+  if (c.verdict === "inconclusive") {
+    out.push(`INCONCLUSIVE  ${c.inconclusive}`, "", "No verdict. This is not a pass.");
+    return out.join("\n");
+  }
+  const from = c.publishedVersion ?? "?";
+  const to = c.localVersion ?? "?";
+  out.push(
+    c.verdict === "ok" ? c.declared === c.required ? `OK          ${from} \u2192 ${to} is a ${c.declared}, which is what this API change needs.` : `OK          ${from} \u2192 ${to} is a ${c.declared}; this API change only needed a ${c.required}.` : c.declared === null ? `UNDERSTATED  ${to} is not ahead of the published ${from}.` : `UNDERSTATED  ${from} \u2192 ${to} is tagged ${c.declared}, but this API change is a ${c.required}.`,
+    ""
+  );
+  out.push(...list("Removed exports", c.removed));
+  if (c.arityChanged.length) {
+    out.push(`  Parameter count changed (${c.arityChanged.length}):`);
+    for (const a of c.arityChanged.slice(0, LIST_CAP)) {
+      out.push(`    \xB7 ${a.path}  ${a.from} \u2192 ${a.to}`);
+    }
+  }
+  out.push(...list("Removed types (breaks tsc, not node)", c.typeOnlyRemoved));
+  out.push(...list("Added exports", c.added));
+  if (!c.removed.length && !c.arityChanged.length && !c.typeOnlyRemoved.length && !c.added.length) {
+    out.push("  No change to the exported surface.");
+  }
+  return out.join("\n");
+}
+export {
+  checkRelease,
+  formatReleaseCheck,
+  releaseVerdict
+};

package/dist/remote-YGCXYI4V.js

@@ -0,0 +1,32 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  MissingKeyError,
+  RemoteError,
+  apiKey,
+  callTool,
+  endpoint,
+  fetchUpgradePlan,
+  getPolicy,
+  getPolicyDecisions,
+  getPolicyHistory,
+  putPolicy,
+  reportUpgradeRuns,
+  uploadMcpScan
+} from "./chunk-4ZYCIMY4.js";
+import "./chunk-Y5GI7RL3.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  MissingKeyError,
+  RemoteError,
+  apiKey,
+  callTool,
+  endpoint,
+  fetchUpgradePlan,
+  getPolicy,
+  getPolicyDecisions,
+  getPolicyHistory,
+  putPolicy,
+  reportUpgradeRuns,
+  uploadMcpScan
+};

package/dist/reportRuns-CKQQYLY4.js

@@ -0,0 +1,64 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/reportRuns.ts
+init_esm_shims();
+var MAX_RUNS = 100;
+function findingRefs(finding) {
+  return [
+    ...finding.symbolsRemoved.flatMap((s) => s.refs),
+    ...finding.arityChanged.flatMap((a) => a.refs),
+    ...finding.typeErrors ?? [],
+    ...(finding.entriesRemoved ?? []).flatMap((e) => e.refs),
+    ...finding.moduleFormat?.broken ?? [],
+    ...finding.moduleFormat?.olderNode ?? []
+  ];
+}
+function buildRunReports(report, targets, ctx) {
+  const versions = new Map(targets.map((t) => [t.package, t]));
+  const base = (pkg) => {
+    const target = versions.get(pkg);
+    return {
+      repoFullName: ctx.repoFullName,
+      packageName: pkg,
+      fromVersion: target?.fromVersion ?? "",
+      toVersion: target?.toVersion ?? "",
+      status: "checked",
+      runUrl: ctx.runUrl
+    };
+  };
+  const rows = [];
+  for (const finding of report.breaking) {
+    const refs = findingRefs(finding);
+    rows.push({
+      ...base(finding.package),
+      // The finding carries its own versions; prefer them over the target map.
+      fromVersion: finding.fromVersion,
+      toVersion: finding.toVersion,
+      severity: finding.severity,
+      symbolsAffected: [
+        ...finding.symbolsRemoved.map((s) => s.symbol),
+        ...finding.arityChanged.map((a) => a.symbol),
+        ...(finding.entriesRemoved ?? []).map((e) => e.specifier)
+      ],
+      callSites: refs.length,
+      callSiteFiles: [...new Set(refs.map((r) => r.file))]
+    });
+  }
+  for (const pkg of report.ok) rows.push({ ...base(pkg), severity: "ok" });
+  for (const u of report.unverified) rows.push({ ...base(u.package), severity: "unverified" });
+  return rows.filter((r) => r.fromVersion && r.toVersion).slice(0, MAX_RUNS);
+}
+function runContextFromEnv(env = process.env) {
+  const repoFullName = env.GITHUB_REPOSITORY?.trim();
+  if (!repoFullName) return null;
+  const server = env.GITHUB_SERVER_URL?.trim() || "https://github.com";
+  const runId = env.GITHUB_RUN_ID?.trim();
+  return { repoFullName, runUrl: runId ? `${server}/${repoFullName}/actions/runs/${runId}` : "" };
+}
+export {
+  buildRunReports,
+  runContextFromEnv
+};

package/dist/sandbox-MEZLAODF.js

@@ -0,0 +1,39 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  getSandbox
+} from "./chunk-I2JUKN6Z.js";
+import "./chunk-C6GLE626.js";
+import "./chunk-GE37NVLN.js";
+import {
+  storeVerificationRun
+} from "./chunk-6L3U7DZ5.js";
+import "./chunk-LYMPYETA.js";
+import "./chunk-GRJXQBQZ.js";
+import "./chunk-WHX2ZFCG.js";
+import "./chunk-GPTKSNR6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/pipeline/sandbox.ts
+init_esm_shims();
+async function verifyPackageInSandbox(db, pkg, version, opts = {}) {
+  const result = await (await getSandbox()).verify(pkg, version, opts);
+  await storeVerificationRun(db, {
+    packageName: pkg,
+    version: version ?? "latest",
+    driver: result.driver,
+    moduleSystem: result.moduleSystem,
+    installed: result.installed,
+    imported: result.imported,
+    ranScripts: result.ranScripts,
+    durationMs: result.durationMs,
+    error: result.error,
+    ranAt: /* @__PURE__ */ new Date()
+  }).catch(() => {
+  });
+  return result;
+}
+export {
+  verifyPackageInSandbox
+};

package/dist/server-KFUD5X57.js

@@ -0,0 +1,55 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  SERVE_NEEDS_DATABASE,
+  buildMcpServer,
+  exactVersion,
+  npmName,
+  startMcpServer
+} from "./chunk-CUP36ND3.js";
+import "./chunk-IQ4SDKKY.js";
+import "./chunk-XBIDMHSK.js";
+import "./chunk-L6N4JFW2.js";
+import "./chunk-3N3Q3DSW.js";
+import "./chunk-DB2VF5UD.js";
+import "./chunk-6AAEVQ7I.js";
+import "./chunk-LEGPB7DO.js";
+import "./chunk-Q5VPF4WI.js";
+import "./chunk-VL2E5T2A.js";
+import "./chunk-6EQ3ARXA.js";
+import "./chunk-SHCEBP3J.js";
+import "./chunk-LO35HLQZ.js";
+import "./chunk-4F7ZESPO.js";
+import "./chunk-BULZAX2U.js";
+import "./chunk-QSL6QN5X.js";
+import "./chunk-M6NYEXCW.js";
+import "./chunk-6L3U7DZ5.js";
+import "./chunk-J5FZYN4A.js";
+import "./chunk-PSX3GIAN.js";
+import "./chunk-FW6BD2NO.js";
+import "./chunk-BUALU27S.js";
+import "./chunk-LRD4GBYE.js";
+import "./chunk-BCANRN5B.js";
+import "./chunk-2VMOWSRY.js";
+import "./chunk-4ESO33J6.js";
+import "./chunk-CW5HJ3LX.js";
+import "./chunk-AHBP533R.js";
+import "./chunk-SJOVFF7B.js";
+import "./chunk-HWBBVLOT.js";
+import "./chunk-NH5I4KHH.js";
+import "./chunk-VLRHFMGJ.js";
+import "./chunk-WQ23REYT.js";
+import "./chunk-LYMPYETA.js";
+import "./chunk-3GHJR7XR.js";
+import "./chunk-GRJXQBQZ.js";
+import "./chunk-WHX2ZFCG.js";
+import "./chunk-LUAKDHLZ.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  SERVE_NEEDS_DATABASE,
+  buildMcpServer,
+  exactVersion,
+  npmName,
+  startMcpServer
+};

package/dist/surface-V62GE554.js

@@ -0,0 +1,141 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  formatError
+} from "./chunk-MHUEVBVO.js";
+import {
+  bumpSurfaceAttempt,
+  dropSurfaceQueue,
+  enqueuePreviousSurface,
+  enqueueSurface,
+  getPackagesMissingGraphSurface,
+  getPendingSurfaces,
+  isExtractionCached,
+  storeSurface,
+  surfaceRef
+} from "./chunk-LO35HLQZ.js";
+import {
+  fetchAndExtract
+} from "./chunk-BV32UNLL.js";
+import {
+  getPackagesWithSurface
+} from "./chunk-M6NYEXCW.js";
+import "./chunk-AHBP533R.js";
+import "./chunk-SJOVFF7B.js";
+import {
+  getPackageVersions
+} from "./chunk-NH5I4KHH.js";
+import "./chunk-VLRHFMGJ.js";
+import "./chunk-LYMPYETA.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/pipeline/surface.ts
+init_esm_shims();
+var VERSION_LOOKBACK = 50;
+var EXTRACTOR_VERSION = "2";
+var MAX_ATTEMPTS = 3;
+async function extractAndStore(db, pkg, version) {
+  const fetched = await fetchAndExtract(pkg, version);
+  if (!fetched) return { outcome: "missing", version: null };
+  const resolved = fetched.resolvedVersion;
+  const ref = surfaceRef(pkg, resolved);
+  if (await isExtractionCached(db, ref, fetched.artifactHash, EXTRACTOR_VERSION))
+    return { outcome: "cached", version: resolved };
+  const res = await storeSurface(db, fetched.surface, {
+    artifactHash: fetched.artifactHash,
+    extractorVersion: EXTRACTOR_VERSION
+  });
+  return {
+    outcome: res.verdict === "undeclared" ? "undeclared" : "stored",
+    version: resolved
+  };
+}
+async function drainSurfaceQueue(db, opts = {}) {
+  const pending = await getPendingSurfaces(db, opts.limit ?? 10);
+  const s = {
+    drained: 0,
+    stored: 0,
+    cached: 0,
+    undeclared: 0,
+    failed: 0,
+    backfilled: 0
+  };
+  for (const item of pending) {
+    s.drained++;
+    try {
+      const { outcome, version } = await extractAndStore(db, item.packageName, item.version);
+      if (outcome === "stored") s.stored++;
+      else if (outcome === "cached") s.cached++;
+      else if (outcome === "undeclared") s.undeclared++;
+      if (version && (outcome === "stored" || outcome === "cached")) {
+        await enqueuePreviousSurface(
+          db,
+          item.packageName,
+          version,
+          await getPackageVersions(db, item.packageName, VERSION_LOOKBACK)
+        ).then(
+          (queued) => {
+            if (queued) s.backfilled++;
+          },
+          (err) => logger.warn(
+            { pkg: item.packageName, version, err: formatError(err) },
+            "surface: previous-version backfill could not be queued"
+          )
+        );
+      }
+      await dropSurfaceQueue(db, item.id);
+    } catch (err) {
+      s.failed++;
+      if (item.attempts + 1 >= MAX_ATTEMPTS) await dropSurfaceQueue(db, item.id);
+      else await bumpSurfaceAttempt(db, item.id);
+      logger.warn(
+        { spec: item.specKey, attempts: item.attempts + 1, err: formatError(err) },
+        "surface extraction failed"
+      );
+    }
+  }
+  return s;
+}
+async function backfillSurfaces(db, opts = {}) {
+  const limit = opts.limit ?? 500;
+  const s = { scanned: 0, queuedLatest: 0, queuedPrevious: 0 };
+  const missing = await getPackagesMissingGraphSurface(db, limit, { byDownloads: opts.byDownloads });
+  for (const row of missing) {
+    s.scanned++;
+    await enqueueSurface(db, row.name, row.version).then(
+      () => {
+        s.queuedLatest++;
+      },
+      (err) => logger.warn({ pkg: row.name, err: formatError(err) }, "backfill: could not queue latest")
+    );
+  }
+  const withSurface = await getPackagesWithSurface(db, limit);
+  for (const row of withSurface) {
+    s.scanned++;
+    await enqueuePreviousSurface(
+      db,
+      row.name,
+      row.version,
+      await getPackageVersions(db, row.name, VERSION_LOOKBACK)
+    ).then(
+      (queued) => {
+        if (queued) s.queuedPrevious++;
+      },
+      (err) => logger.warn(
+        { pkg: row.name, err: formatError(err) },
+        "backfill: could not queue predecessor"
+      )
+    );
+  }
+  return s;
+}
+export {
+  backfillSurfaces,
+  drainSurfaceQueue,
+  extractAndStore
+};

package/dist/surface-YL6O67W3.js

@@ -0,0 +1,36 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  bumpSurfaceAttempt,
+  dropSurfaceQueue,
+  enqueuePreviousSurface,
+  enqueueSurface,
+  getMcpServerNames,
+  getPackagesMissingGraphSurface,
+  getPendingSurfaces,
+  hasStoredSurface,
+  isExtractionCached,
+  mcpSurfaceRef,
+  previousVersion,
+  specKey,
+  storeSurface,
+  surfaceRef
+} from "./chunk-LO35HLQZ.js";
+import "./chunk-LYMPYETA.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  bumpSurfaceAttempt,
+  dropSurfaceQueue,
+  enqueuePreviousSurface,
+  enqueueSurface,
+  getMcpServerNames,
+  getPackagesMissingGraphSurface,
+  getPendingSurfaces,
+  hasStoredSurface,
+  isExtractionCached,
+  mcpSurfaceRef,
+  previousVersion,
+  specKey,
+  storeSurface,
+  surfaceRef
+};

package/dist/surfaceHandlers-X2IZKA3E.js

@@ -0,0 +1,20 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  handleDiffSurface,
+  handleResolveSurface,
+  loadStored,
+  rowsToSurface
+} from "./chunk-DB2VF5UD.js";
+import "./chunk-SHCEBP3J.js";
+import "./chunk-LO35HLQZ.js";
+import "./chunk-HWBBVLOT.js";
+import "./chunk-LYMPYETA.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  handleDiffSurface,
+  handleResolveSurface,
+  loadStored,
+  rowsToSurface
+};