@schemic/core 0.1.0-alpha.0

package/lib/index.js

@@ -0,0 +1,794 @@
+import {
+  array,
+  connectionEntry,
+  isConnectionEntry,
+  literal,
+  nullable,
+  option,
+  record,
+  scalar,
+  union
+} from "./chunk-C4D6JWSE.js";
+import {
+  KindRegistry,
+  buildKindDiff,
+  driverNames,
+  emitKinds,
+  getDriver,
+  introspectKinds,
+  lowerSchema,
+  orderObjects,
+  planKinds,
+  registerDriver,
+  snapshotKinds,
+  snapshotObjects
+} from "./chunk-T23RNU7G.js";
+
+// src/cli-kit/config.ts
+import { existsSync, statSync } from "fs";
+import { dirname, resolve } from "path";
+import { createJiti } from "jiti";
+var CONFIG_NAMES = [
+  "schemic.config.ts",
+  "schemic.config.mjs",
+  "schemic.config.js"
+];
+var DEFAULT_MIGRATIONS = "./database/migrations";
+function schemaIsFilePath(path) {
+  if (existsSync(path)) return statSync(path).isFile();
+  return /\.[mc]?[jt]s$/.test(path);
+}
+function loadDotEnv(dir) {
+  const proc = process;
+  if (typeof proc.loadEnvFile !== "function") return;
+  for (const name of [".env.local", ".env"]) {
+    const file = resolve(dir, name);
+    if (!existsSync(file)) continue;
+    try {
+      proc.loadEnvFile(file);
+    } catch {
+    }
+  }
+}
+function makeJiti() {
+  return createJiti(import.meta.url, {
+    interopDefault: true,
+    fsCache: false,
+    moduleCache: false
+  });
+}
+async function loadProject(opts) {
+  const cwd = opts?.cwd ?? process.cwd();
+  const path = opts?.config ? resolve(cwd, opts.config) : CONFIG_NAMES.map((n) => resolve(cwd, n)).find((p) => existsSync(p));
+  if (!path || !existsSync(path)) {
+    throw new Error("No schemic.config.ts found \u2014 run `schemic init` first.");
+  }
+  const root = dirname(path);
+  loadDotEnv(root);
+  const loaded = await makeJiti().import(path);
+  const config = loaded.default ?? loaded;
+  if (!config?.connections || Object.keys(config.connections).length === 0) {
+    throw new Error(`Invalid config at ${path}: expected a "connections" map.`);
+  }
+  return { config, root };
+}
+function resolveConnectionConfig(config, connection, conn, driver, root) {
+  const { schema, migrations, key, ...params } = conn;
+  const schemaPath = resolve(root, schema);
+  const migrationsDir = resolve(root, migrations ?? DEFAULT_MIGRATIONS);
+  return {
+    connection: key ? `${connection}:${key}` : connection,
+    driver,
+    root,
+    schemaPath,
+    schemaIsFile: schemaIsFilePath(schemaPath),
+    migrationsDir,
+    metaDir: resolve(migrationsDir, "meta"),
+    migrationsTable: config.migrationsTable ?? "_migrations",
+    params,
+    seed: config.seed
+  };
+}
+async function loadConfig(opts) {
+  const { config, root } = await loadProject(opts);
+  const names = Object.keys(config.connections);
+  const name = config.defaultConnection ?? (names.length === 1 ? names[0] : "default");
+  const entry = config.connections[name];
+  if (!entry) {
+    throw new Error(
+      `No connection named "${name}". Set "defaultConnection" or pass --connection. Known: ${names.join(", ")}.`
+    );
+  }
+  const ctx = { connections: {}, args: {}, env: process.env };
+  const resolved = await entry.resolve(ctx);
+  if (resolved.length !== 1) {
+    throw new Error(
+      `Connection "${name}" resolved to ${resolved.length} connections (a collection); pass --connection ${name}:<key>.`
+    );
+  }
+  return resolveConnectionConfig(config, name, resolved[0], entry.driver, root);
+}
+
+// src/cli-kit/style.ts
+var colorEnabled = () => Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+var paint = (code, s) => colorEnabled() ? `\x1B[${code}m${s}\x1B[0m` : s;
+var style = {
+  green: (s) => paint(32, s),
+  red: (s) => paint(31, s),
+  yellow: (s) => paint(33, s),
+  cyan: (s) => paint(36, s),
+  dim: (s) => paint(90, s),
+  bold: (s) => paint(1, s)
+};
+var ok = (s) => `${style.green("\u2713")} ${s}`;
+var fail = (s) => `${style.red("\u2717")} ${s}`;
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+// src/cli-kit/diff.ts
+function isEmptyDiff(diff) {
+  return diff.up.length === 0;
+}
+function tokenDiff(before, after) {
+  const a = before.split(" ");
+  const b = after.split(" ");
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => new Array(n + 1).fill(0)
+  );
+  for (let i2 = m - 1; i2 >= 0; i2--) {
+    for (let j2 = n - 1; j2 >= 0; j2--) {
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const colored = colorEnabled();
+  const del = (t) => colored ? style.red(t) : `[-${t}-]`;
+  const ins = (t) => colored ? style.green(t) : `{+${t}+}`;
+  const eq = (t) => colored ? style.dim(t) : t;
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    if (a[i] === b[j]) {
+      out.push(eq(a[i]));
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      out.push(del(a[i++]));
+    } else {
+      out.push(ins(b[j++]));
+    }
+  }
+  while (i < m) out.push(del(a[i++]));
+  while (j < n) out.push(ins(b[j++]));
+  return out.join(" ");
+}
+function renderItem(it, inline = false) {
+  if (it.op === "add") return style.green(`  + ${it.ddl}`);
+  if (it.op === "remove") return style.red(`  - ${it.ddl}`);
+  if (inline) return `    ${tokenDiff(it.before, it.after)}`;
+  return `${style.red(`  - ${it.before}`)}
+${style.green(`  + ${it.after}`)}`;
+}
+function groupByFile(items) {
+  const order = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const it of items) {
+    const key = it.file ?? `\0${it.table}`;
+    let group = byKey.get(key);
+    if (!group) {
+      group = [];
+      byKey.set(key, group);
+      order.push(key);
+    }
+    group.push(it);
+  }
+  return order.map((key) => {
+    const group = byKey.get(key) ?? [];
+    return {
+      header: group.find((i) => i.file)?.file ?? group[0].table,
+      items: group
+    };
+  });
+}
+function formatItems(items, inline = false) {
+  return groupByFile(items).map(
+    (g) => [
+      style.bold(g.header),
+      ...g.items.map((it) => renderItem(it, inline))
+    ].join("\n")
+  ).join("\n\n");
+}
+function formatPatch(diff) {
+  const items = diff.items ?? [];
+  if (!items.length) return "";
+  const out = [];
+  for (const { header, items: group } of groupByFile(items)) {
+    const lines = [];
+    let dels = 0;
+    let adds = 0;
+    for (const it of group) {
+      if (it.op === "add") {
+        lines.push(`+${it.ddl}`);
+        adds++;
+      } else if (it.op === "remove") {
+        lines.push(`-${it.old}`);
+        dels++;
+      } else {
+        lines.push(`-${it.before}`, `+${it.after}`);
+        dels++;
+        adds++;
+      }
+    }
+    out.push(
+      `diff --git a/${header} b/${header}`,
+      `--- a/${header}`,
+      `+++ b/${header}`,
+      `@@ -${dels ? 1 : 0},${dels} +${adds ? 1 : 0},${adds} @@`,
+      ...lines
+    );
+  }
+  return `${out.join("\n")}
+`;
+}
+function formatFull(diff, inline = false) {
+  const byKey = new Map((diff.items ?? []).map((it) => [it.key, it]));
+  const out = [];
+  let prev;
+  for (const f of diff.full ?? []) {
+    if (prev !== void 0 && f.table !== prev) out.push("");
+    const it = byKey.get(f.key);
+    if (it?.op === "change") out.push(renderItem(it, inline));
+    else if (it?.op === "add") out.push(style.green(`  + ${f.ddl}`));
+    else out.push(style.dim(`    ${f.ddl}`));
+    prev = f.table;
+  }
+  const removed = (diff.items ?? []).filter((it) => it.op === "remove");
+  if (removed.length) {
+    out.push("");
+    for (const it of removed) out.push(renderItem(it, inline));
+  }
+  return out.join("\n");
+}
+function formatDiff(diff, opts = {}) {
+  if (!diff.up.length) return "No changes.";
+  let out = opts.full ? formatFull(diff, opts.inline) : formatItems(diff.items ?? [], opts.inline);
+  if (opts.down) {
+    out += `
+
+${style.dim("  rollback (down):")}
+${diff.down.map((s) => style.dim(`  ${s}`)).join("\n")}`;
+  }
+  return out;
+}
+function summarizeKinds(registry, items) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const it of items) counts.set(it.kind, (counts.get(it.kind) ?? 0) + 1);
+  const parts = [];
+  for (const [kind, n] of counts) {
+    const d = registry.display(kind);
+    parts.push(`${n} ${n === 1 ? d.label : d.plural}`);
+  }
+  return parts.join(", ");
+}
+
+// src/cli-kit/filter.ts
+function cat(v, defaultOn) {
+  if (v === void 0) return { on: defaultOn };
+  if (v === false) return { on: false };
+  if (v === true) return { on: true };
+  const names = new Set(
+    v.split(",").map((s) => s.trim()).filter(Boolean)
+  );
+  return names.size ? { on: true, names } : { on: true };
+}
+function parseFilter(o) {
+  return {
+    tables: cat(o.tables, true),
+    functions: cat(o.functions, true),
+    events: cat(o.events, true),
+    access: cat(o.access, false)
+    // DEFINE ACCESS is explicit everywhere — see module note.
+  };
+}
+function kindFlags(cmd) {
+  return cmd.option("--tables [names]", "only these tables (comma-separated)").option("--no-tables", "exclude all tables").option("--functions [names]", "only these functions").option("--no-functions", "exclude all functions").option("--events [names]", "only these events").option("--no-events", "exclude all events").option(
+    "--access [names]",
+    "include access (off by default; key not pulled)"
+  ).option("--no-access", "exclude all access (the default)");
+}
+var inCat = (c, name) => c.on && (!c.names || c.names.has(name));
+var objKey = (o) => `${o.kind}:${o.name}`;
+function category(kind) {
+  if (kind === "function") return "functions";
+  if (kind === "access") return "access";
+  return "tables";
+}
+function passesFilter(registry, o, f) {
+  const owner = registry.engine(o.kind)?.owner?.(o);
+  if (owner) {
+    if (!inCat(f.tables, owner.name)) return false;
+    return o.kind === "event" ? inCat(f.events, o.name) : true;
+  }
+  return inCat(f[category(o.kind)], o.name);
+}
+function filterKinds(registry, objects, f) {
+  return objects.filter((o) => passesFilter(registry, o, f));
+}
+function mergeStored(registry, prev, next, f) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const o of snapshotObjects(prev.schema))
+    if (!passesFilter(registry, o, f)) merged.set(objKey(o), o);
+  for (const o of snapshotObjects(next.schema))
+    if (passesFilter(registry, o, f)) merged.set(objKey(o), o);
+  return {
+    version: 3,
+    driver: next.driver,
+    schema: snapshotKinds([...merged.values()]),
+    files: { ...prev.files ?? {}, ...next.files ?? {} }
+  };
+}
+function intersectKinds(registry, disk, live, f) {
+  const liveKeys = new Set(live.map(objKey));
+  return disk.filter(
+    (o) => liveKeys.has(objKey(o)) && passesFilter(registry, o, f)
+  );
+}
+
+// src/cli-kit/merge.ts
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+import { generateCode, parseModule } from "magicast";
+function applyPull(plan) {
+  const touched = [];
+  for (const f of plan.files) {
+    if (f.action === "unchanged") continue;
+    if (f.action === "delete") {
+      rmSync(f.abs, { force: true });
+    } else {
+      mkdirSync(dirname2(f.abs), { recursive: true });
+      writeFileSync(f.abs, f.after);
+    }
+    touched.push(f.rel);
+  }
+  return touched;
+}
+var asMod = (mod) => mod;
+function exportConstName(node) {
+  if (node.type !== "ExportNamedDeclaration") return null;
+  if (node.declaration?.type !== "VariableDeclaration") return null;
+  return node.declaration.declarations?.[0]?.id?.name ?? null;
+}
+function exportConstInit(node) {
+  return node.declaration?.declarations?.[0]?.init ?? null;
+}
+function defineCall(init) {
+  let n = init;
+  while (n) {
+    if (n.type === "CallExpression") {
+      if (n.callee?.type === "Identifier" && /^define/.test(n.callee.name ?? ""))
+        return n;
+      n = n.callee?.type === "MemberExpression" ? n.callee.object ?? null : n.callee ?? null;
+    } else if (n.type === "MemberExpression") {
+      n = n.object ?? null;
+    } else break;
+  }
+  return null;
+}
+function fieldsObject(init) {
+  const call = defineCall(init);
+  if (!call) return null;
+  let obj = call.arguments?.[1] ?? null;
+  if (obj?.type === "ArrowFunctionExpression") obj = obj.body ?? null;
+  return obj?.type === "ObjectExpression" ? obj : null;
+}
+function propKey(p) {
+  return p.key?.name ?? p.key?.value;
+}
+function hasLeadingComment(node) {
+  return Boolean(node.comments?.some((c) => c.leading));
+}
+function parseImportLine(line) {
+  const m = /import\s*\{([^}]*)\}\s*from\s*["']([^"']+)["']/.exec(line);
+  if (!m) return null;
+  return {
+    from: m[2],
+    names: m[1].split(",").map((s) => s.trim()).filter(Boolean)
+  };
+}
+function mergeUnits(existingSrc, units, opts) {
+  const mod = parseModule(existingSrc);
+  const body = asMod(mod).$ast.body;
+  const existing = /* @__PURE__ */ new Map();
+  for (const node of body) {
+    const name = exportConstName(node);
+    if (name) existing.set(name, node);
+  }
+  const localOnly = { fields: [], objects: [] };
+  const desiredNames = new Set(units.map((u) => u.exportName));
+  for (const unit of units) {
+    const unitBody = asMod(parseModule(unit.code)).$ast.body;
+    const desiredNode = unitBody.find(
+      (n) => exportConstName(n) === unit.exportName
+    );
+    if (!desiredNode) continue;
+    const prior = existing.get(unit.exportName);
+    if (prior) {
+      if (unit.kind === "table") {
+        const priorObj = fieldsObject(exportConstInit(prior));
+        const desiredObj = fieldsObject(exportConstInit(desiredNode));
+        if (priorObj?.properties && desiredObj?.properties) {
+          const desiredKeys = new Set(desiredObj.properties.map(propKey));
+          const localFields = priorObj.properties.filter(
+            (p) => !desiredKeys.has(propKey(p))
+          );
+          if (localFields.length) {
+            localOnly.fields.push({
+              exportName: unit.exportName,
+              fields: localFields.map((p) => propKey(p) ?? "?")
+            });
+            if (opts.keepLocalFields)
+              for (const p of localFields) desiredObj.properties.push(p);
+          }
+        }
+      }
+      if (!hasLeadingComment(desiredNode))
+        desiredNode.comments = prior.comments;
+      body[body.indexOf(prior)] = desiredNode;
+    } else {
+      body.push(desiredNode);
+    }
+    addImports(mod, unit.imports);
+  }
+  for (const [name, node] of existing) {
+    if (desiredNames.has(name)) continue;
+    localOnly.objects.push(name);
+    if (!opts.keepLocalObjects) body.splice(body.indexOf(node), 1);
+  }
+  return { content: ensureTrailingNewline(generateCode(mod).code), localOnly };
+}
+function addImports(mod, lines) {
+  const imports = asMod(mod).imports;
+  for (const line of lines) {
+    const parsed = parseImportLine(line);
+    if (!parsed) continue;
+    for (const name of parsed.names)
+      imports.$add({ from: parsed.from, imported: name, local: name });
+  }
+}
+function ensureTrailingNewline(s) {
+  return s.endsWith("\n") ? s : `${s}
+`;
+}
+var splitLines = (s) => s === "" ? [] : s.replace(/\n$/, "").split("\n");
+function lineOps(before, after) {
+  const a = splitLines(before);
+  const b = splitLines(after);
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => new Array(n + 1).fill(0)
+  );
+  for (let i2 = m - 1; i2 >= 0; i2--)
+    for (let j2 = n - 1; j2 >= 0; j2--)
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    if (a[i] === b[j]) {
+      ops.push({ tag: " ", line: a[i] });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ tag: "-", line: a[i++] });
+    } else {
+      ops.push({ tag: "+", line: b[j++] });
+    }
+  }
+  while (i < m) ops.push({ tag: "-", line: a[i++] });
+  while (j < n) ops.push({ tag: "+", line: b[j++] });
+  return ops;
+}
+function lineDiff(before, after) {
+  const ops = lineOps(before, after);
+  const CONTEXT = 2;
+  const keep = new Array(ops.length).fill(false);
+  ops.forEach((op, idx) => {
+    if (op.tag === " ") return;
+    for (let k = Math.max(0, idx - CONTEXT); k <= Math.min(ops.length - 1, idx + CONTEXT); k++)
+      keep[k] = true;
+  });
+  const out = [];
+  let gap = false;
+  ops.forEach((op, idx) => {
+    if (!keep[idx]) {
+      if (!gap) out.push(style.dim("  \u2026"));
+      gap = true;
+      return;
+    }
+    gap = false;
+    if (op.tag === " ") out.push(style.dim(`  ${op.line}`));
+    else if (op.tag === "-") out.push(style.red(`- ${op.line}`));
+    else out.push(style.green(`+ ${op.line}`));
+  });
+  return out.join("\n");
+}
+function unifiedDiff(before, after, label) {
+  const ops = lineOps(before, after);
+  if (!ops.some((o) => o.tag !== " ")) return "";
+  const oldLen = ops.filter((o) => o.tag !== "+").length;
+  const newLen = ops.filter((o) => o.tag !== "-").length;
+  const body = ops.map(
+    (o) => o.tag === " " ? ` ${o.line}` : `${o.tag}${o.line}`
+  );
+  return `${[
+    `diff --git a/${label} b/${label}`,
+    `--- a/${label}`,
+    `+++ b/${label}`,
+    `@@ -1,${oldLen} +1,${newLen} @@`,
+    ...body
+  ].join("\n")}
+`;
+}
+function actionLabel(action) {
+  if (action === "create") return colorEnabled() ? style.green("new") : "new";
+  if (action === "update")
+    return colorEnabled() ? style.yellow("update") : "update";
+  if (action === "delete")
+    return colorEnabled() ? style.red("delete") : "delete";
+  return style.dim("unchanged");
+}
+
+// src/cli-kit/meta.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join } from "path";
+var SNAPSHOT_FILE = "_snapshot.json";
+var DEFAULT_MIGRATION_EXT = ".surql";
+function emptyStored() {
+  return {
+    version: 3,
+    driver: "surrealdb",
+    schema: { kinds: {} },
+    files: {}
+  };
+}
+var EMPTY_STORED = emptyStored();
+function readSnapshot(metaDir) {
+  const path = join(metaDir, SNAPSHOT_FILE);
+  if (!existsSync2(path)) return emptyStored();
+  const raw = JSON.parse(readFileSync(path, "utf8"));
+  if (raw.version === 3 && raw.driver && raw.schema)
+    return { files: {}, ...raw };
+  return emptyStored();
+}
+function writeSnapshot(metaDir, snapshot) {
+  mkdirSync2(metaDir, { recursive: true });
+  writeFileSync2(
+    join(metaDir, SNAPSHOT_FILE),
+    `${JSON.stringify(snapshot, null, 2)}
+`
+  );
+}
+function listMigrations(migrationsDir, ext = DEFAULT_MIGRATION_EXT) {
+  if (!existsSync2(migrationsDir)) return [];
+  return readdirSync(migrationsDir).filter((f) => f.endsWith(ext)).sort().map((file) => ({ tag: file.slice(0, -ext.length), file }));
+}
+function timestamp(date) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${date.getUTCFullYear()}` + p(date.getUTCMonth() + 1) + p(date.getUTCDate()) + p(date.getUTCHours()) + p(date.getUTCMinutes()) + p(date.getUTCSeconds());
+}
+function checksum(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function slug(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "migration";
+}
+
+// src/cli-kit/pager.ts
+import { execFileSync, spawn } from "child_process";
+function gitConfig(key) {
+  try {
+    const v = execFileSync("git", ["config", "--get", key], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return v || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolvePager() {
+  return gitConfig("pager.diff") || gitConfig("core.pager") || process.env.GIT_PAGER || process.env.PAGER || void 0;
+}
+function pipeThroughPager(pager, text) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn("sh", ["-c", pager], {
+      stdio: ["pipe", "inherit", "inherit"]
+    });
+    child.once("error", reject);
+    child.once("close", () => resolve2());
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(text);
+  });
+}
+
+// src/cli-kit/schema.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
+function isTableDef(v) {
+  if (!v || typeof v !== "object") return false;
+  const t = v;
+  return typeof t.name === "string" && typeof t.fields === "object" && t.fields !== null && typeof t.config === "object" && t.config !== null && typeof t.record === "function";
+}
+function isStandaloneDef(v) {
+  if (!v || typeof v !== "object") return false;
+  const d = v;
+  return (d.kind === "event" || d.kind === "function" || d.kind === "access") && typeof d.name === "string";
+}
+function tsFiles(dir) {
+  const out = [];
+  for (const entry of readdirSync2(dir).sort()) {
+    const p = join2(dir, entry);
+    if (statSync2(p).isDirectory()) out.push(...tsFiles(p));
+    else if (/\.(ts|mts|js|mjs)$/.test(entry) && !entry.endsWith(".d.ts"))
+      out.push(p);
+  }
+  return out;
+}
+function schemaFiles(path) {
+  return statSync2(path).isFile() ? [path] : tsFiles(path);
+}
+async function* tablesIn(jiti, file) {
+  const mod = await jiti.import(file);
+  for (const value of Object.values(mod)) if (isTableDef(value)) yield value;
+}
+async function loadDefs(schemaPath) {
+  if (!existsSync3(schemaPath)) {
+    throw new Error(`Schema path not found: ${schemaPath}`);
+  }
+  const jiti = makeJiti();
+  const tables = /* @__PURE__ */ new Map();
+  const defs = [];
+  const fileOf = /* @__PURE__ */ new Map();
+  for (const file of schemaFiles(schemaPath)) {
+    const mod = await jiti.import(file);
+    for (const value of Object.values(mod)) {
+      if (isTableDef(value)) {
+        tables.set(value.name, value);
+        fileOf.set(value, file);
+      } else if (isStandaloneDef(value)) {
+        defs.push(value);
+        fileOf.set(value, file);
+      }
+    }
+  }
+  const rank = (t) => t.config.relation ? 1 : 0;
+  const sorted = [...tables.values()].sort(
+    (a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name)
+  );
+  return { tables: sorted, defs, fileOf };
+}
+async function loadSchemas(schemaPath) {
+  return (await loadDefs(schemaPath)).tables;
+}
+async function scanLocalEntities(schemaPath) {
+  if (!existsSync3(schemaPath)) return /* @__PURE__ */ new Map();
+  const jiti = makeJiti();
+  const out = /* @__PURE__ */ new Map();
+  for (const file of schemaFiles(schemaPath)) {
+    const exports = Object.entries(
+      await jiti.import(file)
+    );
+    const entities = [];
+    for (const [exportName, value] of exports) {
+      if (isTableDef(value))
+        entities.push({ exportName, name: value.name, kind: "table" });
+      else if (isStandaloneDef(value) && (value.kind === "function" || value.kind === "access"))
+        entities.push({ exportName, name: value.name, kind: "def" });
+    }
+    if (entities.length)
+      out.set(file, {
+        entities,
+        pureSchema: entities.length === exports.length
+      });
+  }
+  return out;
+}
+async function existingTables(schemaPath) {
+  if (!existsSync3(schemaPath)) return /* @__PURE__ */ new Map();
+  const jiti = makeJiti();
+  const out = /* @__PURE__ */ new Map();
+  for (const file of schemaFiles(schemaPath)) {
+    for await (const t of tablesIn(jiti, file)) out.set(t.name, file);
+  }
+  return out;
+}
+async function duplicateTables(schemaPath) {
+  if (!existsSync3(schemaPath)) return /* @__PURE__ */ new Map();
+  const jiti = makeJiti();
+  const seen = /* @__PURE__ */ new Map();
+  for (const file of schemaFiles(schemaPath)) {
+    for await (const t of tablesIn(jiti, file)) {
+      const files = seen.get(t.name);
+      if (files) files.push(file);
+      else seen.set(t.name, [file]);
+    }
+  }
+  return new Map([...seen].filter(([, files]) => files.length > 1));
+}
+export {
+  EMPTY_STORED,
+  KindRegistry,
+  actionLabel,
+  applyPull,
+  array,
+  buildKindDiff,
+  checksum,
+  colorEnabled,
+  connectionEntry,
+  driverNames,
+  duplicateTables,
+  emitKinds,
+  existingTables,
+  fail,
+  filterKinds,
+  formatDiff,
+  formatItems,
+  formatPatch,
+  getDriver,
+  inCat,
+  intersectKinds,
+  introspectKinds,
+  isConnectionEntry,
+  isEmptyDiff,
+  kindFlags,
+  lineDiff,
+  listMigrations,
+  literal,
+  loadConfig,
+  loadDefs,
+  loadProject,
+  loadSchemas,
+  lowerSchema,
+  makeJiti,
+  mergeStored,
+  mergeUnits,
+  nullable,
+  ok,
+  option,
+  orderObjects,
+  parseFilter,
+  passesFilter,
+  pipeThroughPager,
+  planKinds,
+  plural,
+  readSnapshot,
+  record,
+  registerDriver,
+  resolveConnectionConfig,
+  resolvePager,
+  scalar,
+  scanLocalEntities,
+  slug,
+  snapshotKinds,
+  snapshotObjects,
+  style,
+  summarizeKinds,
+  timestamp,
+  tokenDiff,
+  unifiedDiff,
+  union,
+  writeSnapshot
+};
+//# sourceMappingURL=index.js.map