@sedrino/db-schema 0.1.1 → 0.1.2

package/dist/cli.js

@@ -0,0 +1,1904 @@
+#!/usr/bin/env bun
+
+// src/cli.ts
+import path2 from "path";
+import { env, exit } from "process";
+
+// src/utils.ts
+var SQLITE_EPOCH_MS_NOW = "CAST(strftime('%s','now') AS integer) * 1000 + CAST((strftime('%f','now') - strftime('%S','now')) * 1000 AS integer)";
+function sqliteEpochMsNowSql() {
+  return SQLITE_EPOCH_MS_NOW;
+}
+function toSnakeCase(value) {
+  return value.replace(/-/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1_$2").toLowerCase();
+}
+function toPascalCase(value) {
+  return value.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/\s+/).filter(Boolean).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
+}
+function toCamelCase(value) {
+  const pascal = toPascalCase(value);
+  return pascal.length > 0 ? `${pascal[0].toLowerCase()}${pascal.slice(1)}` : pascal;
+}
+function pluralize(value) {
+  if (value.endsWith("s")) return `${value}es`;
+  if (value.endsWith("y") && !/[aeiou]y$/i.test(value)) {
+    return `${value.slice(0, -1)}ies`;
+  }
+  return `${value}s`;
+}
+function singularize(value) {
+  if (value.endsWith("ies") && value.length > 3) {
+    return `${value.slice(0, -3)}y`;
+  }
+  if (value.endsWith("ses") && value.length > 3) {
+    return value.slice(0, -2);
+  }
+  if (value.endsWith("s") && !value.endsWith("ss") && value.length > 1) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function tableVariableName(tableName) {
+  return `table${toPascalCase(tableName)}`;
+}
+function defaultStorageForLogical(logical, column) {
+  switch (logical.kind) {
+    case "id":
+    case "string":
+    case "text":
+    case "enum":
+    case "json":
+      return { strategy: "sqlite.text", column };
+    case "boolean":
+    case "integer":
+      return { strategy: "sqlite.integer", column };
+    case "number":
+      return { strategy: "sqlite.real", column };
+    case "temporal.instant":
+      return { strategy: "sqlite.temporalInstantEpochMs", column };
+    case "temporal.plainDate":
+      return { strategy: "sqlite.temporalPlainDateText", column };
+  }
+}
+function validateLogicalAndStorageCompatibility(logical, storage) {
+  switch (storage.strategy) {
+    case "sqlite.temporalInstantEpochMs":
+      return logical.kind === "temporal.instant" ? null : "sqlite.temporalInstantEpochMs storage requires logical kind temporal.instant";
+    case "sqlite.temporalPlainDateText":
+      return logical.kind === "temporal.plainDate" ? null : "sqlite.temporalPlainDateText storage requires logical kind temporal.plainDate";
+    case "sqlite.integer":
+      return logical.kind === "boolean" || logical.kind === "integer" ? null : "sqlite.integer storage requires logical kind boolean or integer";
+    case "sqlite.real":
+      return logical.kind === "number" ? null : "sqlite.real storage requires logical kind number";
+    case "sqlite.text":
+      return logical.kind === "id" || logical.kind === "string" || logical.kind === "text" || logical.kind === "enum" || logical.kind === "json" ? null : "sqlite.text storage requires logical kind id, string, text, enum, or json";
+  }
+}
+function validateDefaultCompatibility(field, defaultValue) {
+  if (defaultValue.kind === "generatedId") {
+    return field.logical.kind === "id" ? null : "generatedId default requires logical kind id";
+  }
+  if (defaultValue.kind === "now") {
+    return field.logical.kind === "temporal.instant" ? null : "now default requires logical kind temporal.instant";
+  }
+  if (field.logical.kind === "boolean" && typeof defaultValue.value !== "boolean") {
+    return "boolean fields require boolean literal defaults";
+  }
+  if (field.logical.kind === "integer" && !Number.isInteger(defaultValue.value)) {
+    return "integer fields require integer literal defaults";
+  }
+  if (field.logical.kind === "number" && typeof defaultValue.value !== "number") {
+    return "number fields require numeric literal defaults";
+  }
+  return null;
+}
+function validateSchemaDocumentCompatibility(schema) {
+  const issues = [];
+  const tableNames = /* @__PURE__ */ new Set();
+  const indexNames = /* @__PURE__ */ new Set();
+  for (const table of schema.tables) {
+    if (tableNames.has(table.name)) {
+      issues.push({
+        path: `tables.${table.name}`,
+        message: `Duplicate table name ${table.name}`
+      });
+    }
+    tableNames.add(table.name);
+    const fieldNames = /* @__PURE__ */ new Set();
+    const columnNames = /* @__PURE__ */ new Set();
+    let primaryKeyCount = 0;
+    for (const field of table.fields) {
+      if (fieldNames.has(field.name)) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: `Duplicate field name ${field.name}`
+        });
+      }
+      fieldNames.add(field.name);
+      if (columnNames.has(field.storage.column)) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: `Duplicate column name ${field.storage.column}`
+        });
+      }
+      columnNames.add(field.storage.column);
+      if (field.primaryKey) primaryKeyCount += 1;
+      if (field.primaryKey && field.nullable) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: "Primary key fields cannot be nullable"
+        });
+      }
+      const storageIssue = validateLogicalAndStorageCompatibility(field.logical, field.storage);
+      if (storageIssue) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: storageIssue
+        });
+      }
+      if (field.default) {
+        const defaultIssue = validateDefaultCompatibility(field, field.default);
+        if (defaultIssue) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: defaultIssue
+          });
+        }
+      }
+      if (field.references && !tableNames.has(field.references.table)) {
+        const targetTableExists = schema.tables.some(
+          (candidate) => candidate.name === field.references.table
+        );
+        if (!targetTableExists) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: `Referenced table ${field.references.table} does not exist`
+          });
+        }
+      }
+      if (field.references) {
+        const targetTable = schema.tables.find(
+          (candidate) => candidate.name === field.references.table
+        );
+        const targetFieldExists = targetTable?.fields.some(
+          (candidate) => candidate.name === field.references.field
+        );
+        if (targetTable && !targetFieldExists) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: `Referenced field ${field.references.field} does not exist on table ${field.references.table}`
+          });
+        }
+      }
+    }
+    if (primaryKeyCount > 1) {
+      issues.push({
+        path: `tables.${table.name}`,
+        message: "Composite primary keys are not supported in v1"
+      });
+    }
+    for (const index of table.indexes) {
+      const indexName = index.name ?? `${table.name}_${index.fields.join("_")}_idx`;
+      if (indexNames.has(indexName)) {
+        issues.push({
+          path: `tables.${table.name}.indexes.${indexName}`,
+          message: `Duplicate index name ${indexName}`
+        });
+      }
+      indexNames.add(indexName);
+      for (const fieldName of index.fields) {
+        if (!fieldNames.has(fieldName)) {
+          issues.push({
+            path: `tables.${table.name}.indexes.${index.name ?? fieldName}`,
+            message: `Index references missing field ${fieldName}`
+          });
+        }
+      }
+    }
+    for (const unique of table.uniques) {
+      const uniqueName = unique.name ?? `${table.name}_${unique.fields.join("_")}_unique`;
+      if (indexNames.has(uniqueName)) {
+        issues.push({
+          path: `tables.${table.name}.uniques.${uniqueName}`,
+          message: `Duplicate index name ${uniqueName}`
+        });
+      }
+      indexNames.add(uniqueName);
+      for (const fieldName of unique.fields) {
+        if (!fieldNames.has(fieldName)) {
+          issues.push({
+            path: `tables.${table.name}.uniques.${unique.name ?? fieldName}`,
+            message: `Unique constraint references missing field ${fieldName}`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function stableStringify(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sortValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, innerValue]) => [key, sortValue(innerValue)]);
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+function createSchemaHash(schema) {
+  const text = stableStringify(schema);
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `schema_${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function cloneSchema(value) {
+  return structuredClone(value);
+}
+function renameStorageColumn(field, newFieldName) {
+  const next = cloneSchema(field);
+  const column = toSnakeCase(newFieldName);
+  next.name = newFieldName;
+  next.storage = { ...next.storage, column };
+  return next;
+}
+
+// src/drizzle.ts
+function compileSchemaToDrizzle(schema) {
+  const sqliteImports = /* @__PURE__ */ new Set(["sqliteTable"]);
+  const toolkitImports = /* @__PURE__ */ new Set();
+  let needsRelationsImport = false;
+  let needsUlid = false;
+  for (const table of schema.tables) {
+    for (const field of table.fields) {
+      switch (field.logical.kind) {
+        case "id":
+        case "string":
+        case "text":
+        case "enum":
+        case "json":
+          sqliteImports.add("text");
+          break;
+        case "boolean":
+        case "integer":
+          sqliteImports.add("integer");
+          break;
+        case "number":
+          sqliteImports.add("real");
+          break;
+        case "temporal.instant":
+          toolkitImports.add("temporalInstantEpochMs");
+          break;
+        case "temporal.plainDate":
+          toolkitImports.add("temporalPlainDateText");
+          break;
+      }
+      if (field.default?.kind === "generatedId") needsUlid = true;
+      if (field.default?.kind === "now") toolkitImports.add("epochMsNow");
+      if (field.references) needsRelationsImport = true;
+    }
+    if (table.indexes.length > 0) sqliteImports.add("index");
+    if (table.uniques.length > 0) sqliteImports.add("uniqueIndex");
+  }
+  const lines = [];
+  if (needsRelationsImport) {
+    lines.push(`import { defineRelations } from "drizzle-orm";`);
+  }
+  lines.push(
+    `import { ${Array.from(sqliteImports).sort().join(", ")} } from "drizzle-orm/sqlite-core";`
+  );
+  if (toolkitImports.size > 0) {
+    lines.push(
+      `import { ${Array.from(toolkitImports).sort().join(", ")} } from "@sedrino/toolkit/drizzle/sqlite";`
+    );
+  }
+  if (needsUlid) {
+    lines.push(`import { ulid } from "ulid";`);
+  }
+  lines.push("");
+  for (const table of schema.tables) {
+    lines.push(renderTable(table));
+    lines.push("");
+  }
+  const relationsSource = compileSchemaToDrizzleRelations(schema);
+  if (relationsSource) {
+    lines.push(relationsSource);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function compileSchemaToDrizzleRelations(schema) {
+  const directRelations = inferDirectRelations(schema);
+  const manyToManyRelations = inferManyToManyRelations(schema, directRelations.usedKeysByTable);
+  if (directRelations.relations.length === 0 && manyToManyRelations.length === 0) return "";
+  const schemaEntries = schema.tables.map((table) => `  ${tableSchemaKey(table.name)}: ${tableVariableName(table.name)},`).join("\n");
+  const tableBlocks = schema.tables.map((table) => {
+    const tableKey = tableSchemaKey(table.name);
+    const relationLines = directRelations.relations.filter(
+      (relation) => relation.sourceTable.name === table.name || relation.targetTable.name === table.name
+    ).flatMap((relation) => {
+      const lines = [];
+      if (relation.sourceTable.name === table.name) {
+        lines.push(`    ${relation.forwardKey}: ${renderOneRelation(relation)},`);
+      }
+      if (relation.targetTable.name === table.name && !relation.skipReverse) {
+        lines.push(`    ${relation.reverseKey}: ${renderReverseRelation(relation)},`);
+      }
+      return lines;
+    }).concat(
+      manyToManyRelations.filter((relation) => relation.leftTable.name === table.name || relation.rightTable.name === table.name).map(
+        (relation) => relation.leftTable.name === table.name ? `    ${relation.leftKey}: ${renderManyToManyRelation(relation, "left")},` : `    ${relation.rightKey}: ${renderManyToManyRelation(relation, "right")},`
+      )
+    );
+    if (relationLines.length === 0) return null;
+    return `  ${tableKey}: {
+${relationLines.join("\n")}
+  },`;
+  }).filter((block) => block !== null).join("\n");
+  return `export const relations = defineRelations({
+${schemaEntries}
+}, (r) => ({
+${tableBlocks}
+}));`;
+}
+function renderTable(table) {
+  const variableName = tableVariableName(table.name);
+  const fieldLines = table.fields.map((field) => `  ${field.name}: ${renderField(field)},`);
+  const tableConfig = renderTableConfig(table);
+  if (!tableConfig) {
+    return `export const ${variableName} = sqliteTable("${table.name}", {
+${fieldLines.join("\n")}
+});`;
+  }
+  return `export const ${variableName} = sqliteTable("${table.name}", {
+${fieldLines.join(
+    "\n"
+  )}
+}, (table) => [
+${tableConfig}
+]);`;
+}
+function renderTableConfig(table) {
+  const lines = [];
+  for (const index of table.indexes) {
+    lines.push(`  ${renderIndex(table.name, index)},`);
+  }
+  for (const unique of table.uniques) {
+    lines.push(`  ${renderUnique(table.name, unique)},`);
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function renderIndex(tableName, index) {
+  const name = index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
+  return `index("${name}").on(${index.fields.map((field) => `table.${field}`).join(", ")})`;
+}
+function renderUnique(tableName, unique) {
+  const name = unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
+  return `uniqueIndex("${name}").on(${unique.fields.map((field) => `table.${field}`).join(", ")})`;
+}
+function renderField(field) {
+  let expression = renderBaseColumn(field);
+  if (field.logical.kind === "json") {
+    expression += `.$type<${field.logical.tsType}>()`;
+  }
+  if (field.primaryKey) expression += ".primaryKey()";
+  if (!field.nullable) expression += ".notNull()";
+  if (field.unique && !field.primaryKey) expression += ".unique()";
+  const defaultExpression = renderDrizzleDefault(field.default);
+  if (defaultExpression) expression += `.default(${defaultExpression})`;
+  if (field.default?.kind === "generatedId") {
+    expression += `.$default(() => \`${field.default.prefix}-\${ulid()}\`)`;
+  }
+  if (field.references) {
+    const targetTable = tableVariableName(field.references.table);
+    const referenceParts = [`() => ${targetTable}.${field.references.field}`];
+    const options = [];
+    if (field.references.onDelete) options.push(`onDelete: "${field.references.onDelete}"`);
+    if (field.references.onUpdate) options.push(`onUpdate: "${field.references.onUpdate}"`);
+    if (options.length > 0) {
+      referenceParts.push(`{ ${options.join(", ")} }`);
+    }
+    expression += `.references(${referenceParts.join(", ")})`;
+  }
+  return expression;
+}
+function renderBaseColumn(field) {
+  switch (field.logical.kind) {
+    case "id":
+    case "string":
+    case "text":
+      return `text("${field.storage.column}")`;
+    case "enum":
+      return `text("${field.storage.column}", { enum: [${field.logical.values.map((value) => JSON.stringify(value)).join(", ")}] })`;
+    case "json":
+      return `text("${field.storage.column}", { mode: "json" })`;
+    case "boolean":
+      return `integer("${field.storage.column}", { mode: "boolean" })`;
+    case "integer":
+      return `integer("${field.storage.column}", { mode: "number" })`;
+    case "number":
+      return `real("${field.storage.column}")`;
+    case "temporal.instant":
+      return `temporalInstantEpochMs("${field.storage.column}")`;
+    case "temporal.plainDate":
+      return `temporalPlainDateText("${field.storage.column}")`;
+  }
+}
+function renderDrizzleDefault(defaultValue) {
+  if (!defaultValue) return null;
+  switch (defaultValue.kind) {
+    case "generatedId":
+      return null;
+    case "now":
+      return "epochMsNow()";
+    case "literal":
+      return JSON.stringify(defaultValue.value);
+  }
+}
+function inferDirectRelations(schema) {
+  const junctionTableNames = new Set(inferJunctionCandidates(schema).map((candidate) => candidate.junctionTable.name));
+  const raw = schema.tables.flatMap(
+    (sourceTable) => sourceTable.fields.filter((field) => field.references).map((field) => {
+      const targetTable = schema.tables.find((table) => table.name === field.references.table);
+      if (!targetTable) {
+        throw new Error(
+          `Cannot infer relation for ${sourceTable.name}.${field.name}; missing target table ${field.references.table}`
+        );
+      }
+      return {
+        sourceTable,
+        targetTable,
+        sourceField: field,
+        targetFieldName: field.references.field,
+        sourceTableKey: tableSchemaKey(sourceTable.name),
+        targetTableKey: tableSchemaKey(targetTable.name),
+        forwardBase: inferForwardRelationKey(field, targetTable),
+        reverseBase: tableSchemaKey(pluralize(sourceTable.name))
+      };
+    })
+  );
+  const duplicatePairCounts = /* @__PURE__ */ new Map();
+  for (const relation of raw) {
+    const key = `${relation.sourceTable.name}::${relation.targetTable.name}`;
+    duplicatePairCounts.set(key, (duplicatePairCounts.get(key) ?? 0) + 1);
+  }
+  const usedByTable = /* @__PURE__ */ new Map();
+  return {
+    relations: raw.map((relation) => {
+      const skipReverse = junctionTableNames.has(relation.sourceTable.name);
+      const pairKey = `${relation.sourceTable.name}::${relation.targetTable.name}`;
+      const needsAlias = (duplicatePairCounts.get(pairKey) ?? 0) > 1;
+      const alias = needsAlias ? relation.forwardBase : null;
+      const sourceUsed = ensureUsedSet(usedByTable, relation.sourceTable.name);
+      const targetUsed = ensureUsedSet(usedByTable, relation.targetTable.name);
+      const reverseKind = inferReverseKind(relation.sourceTable, relation.sourceField);
+      const forwardKey = ensureUniqueKey(
+        sourceUsed,
+        relation.forwardBase,
+        `${relation.forwardBase}${toPascalCase(relation.targetTable.name)}`
+      );
+      const reversePreferred = needsAlias ? `${relation.forwardBase}${toPascalCase(pluralize(relation.sourceTable.name))}` : relation.reverseBase;
+      const reverseFallback = `${relation.forwardBase}${toPascalCase(pluralize(relation.sourceTable.name))}`;
+      const reverseKey = skipReverse ? reversePreferred : ensureUniqueKey(targetUsed, reversePreferred, reverseFallback);
+      return {
+        sourceTable: relation.sourceTable,
+        targetTable: relation.targetTable,
+        sourceField: relation.sourceField,
+        targetFieldName: relation.targetFieldName,
+        sourceTableKey: relation.sourceTableKey,
+        targetTableKey: relation.targetTableKey,
+        forwardKey,
+        reverseKey,
+        alias,
+        reverseKind,
+        skipReverse
+      };
+    }),
+    usedKeysByTable: usedByTable
+  };
+}
+function inferManyToManyRelations(schema, usedByTable) {
+  const candidates = inferJunctionCandidates(schema);
+  const pairCounts = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const pairKey = createPairKey(candidate.leftTable.name, candidate.rightTable.name);
+    pairCounts.set(pairKey, (pairCounts.get(pairKey) ?? 0) + 1);
+  }
+  return candidates.map((candidate) => {
+    const pairKey = createPairKey(candidate.leftTable.name, candidate.rightTable.name);
+    const duplicatePair = (pairCounts.get(pairKey) ?? 0) > 1;
+    const selfRelation = candidate.leftTable.name === candidate.rightTable.name;
+    const alias = duplicatePair || selfRelation ? tableSchemaKey(candidate.junctionTable.name) : null;
+    const leftUsed = ensureUsedSet(usedByTable, candidate.leftTable.name);
+    const rightUsed = ensureUsedSet(usedByTable, candidate.rightTable.name);
+    const leftPreferred = inferManyToManyKey(candidate.rightTable, candidate.rightField, selfRelation);
+    const rightPreferred = inferManyToManyKey(candidate.leftTable, candidate.leftField, selfRelation);
+    const leftFallback = `${leftPreferred}${toPascalCase(candidate.junctionTable.name)}`;
+    const rightFallback = `${rightPreferred}${toPascalCase(candidate.junctionTable.name)}`;
+    return {
+      junctionTable: candidate.junctionTable,
+      leftTable: candidate.leftTable,
+      rightTable: candidate.rightTable,
+      leftField: candidate.leftField,
+      rightField: candidate.rightField,
+      leftTargetFieldName: candidate.leftField.references.field,
+      rightTargetFieldName: candidate.rightField.references.field,
+      junctionTableKey: tableSchemaKey(candidate.junctionTable.name),
+      leftTableKey: tableSchemaKey(candidate.leftTable.name),
+      rightTableKey: tableSchemaKey(candidate.rightTable.name),
+      leftKey: ensureUniqueKey(leftUsed, leftPreferred, leftFallback),
+      rightKey: ensureUniqueKey(rightUsed, rightPreferred, rightFallback),
+      alias
+    };
+  });
+}
+function inferJunctionCandidates(schema) {
+  return schema.tables.flatMap((junctionTable) => {
+    const referencedFields = junctionTable.fields.filter((field) => field.references);
+    if (referencedFields.length !== 2) return [];
+    if (junctionTable.fields.length !== 2) return [];
+    const compositeUnique = junctionTable.uniques.some(
+      (unique) => unique.fields.length === 2 && referencedFields.every((field) => unique.fields.includes(field.name))
+    );
+    if (!compositeUnique) return [];
+    const [leftField, rightField] = referencedFields;
+    const leftTable = schema.tables.find((table) => table.name === leftField.references.table);
+    const rightTable = schema.tables.find((table) => table.name === rightField.references.table);
+    if (!leftTable || !rightTable) return [];
+    return [
+      {
+        junctionTable,
+        leftField,
+        rightField,
+        leftTable,
+        rightTable
+      }
+    ];
+  });
+}
+function renderOneRelation(relation) {
+  const options = [
+    `from: r.${relation.sourceTableKey}.${relation.sourceField.name}`,
+    `to: r.${relation.targetTableKey}.${relation.targetFieldName}`
+  ];
+  if (relation.alias) {
+    options.push(`alias: "${relation.alias}"`);
+  }
+  return `r.one.${relation.targetTableKey}({ ${options.join(", ")} })`;
+}
+function renderReverseRelation(relation) {
+  const options = [
+    `from: r.${relation.targetTableKey}.${relation.targetFieldName}`,
+    `to: r.${relation.sourceTableKey}.${relation.sourceField.name}`
+  ];
+  if (relation.alias) {
+    options.push(`alias: "${relation.alias}"`);
+  }
+  return `r.${relation.reverseKind}.${relation.sourceTableKey}({ ${options.join(", ")} })`;
+}
+function renderManyToManyRelation(relation, side) {
+  const isLeft = side === "left";
+  const currentTableKey = isLeft ? relation.leftTableKey : relation.rightTableKey;
+  const currentTargetFieldName = isLeft ? relation.leftTargetFieldName : relation.rightTargetFieldName;
+  const currentJunctionFieldName = isLeft ? relation.leftField.name : relation.rightField.name;
+  const otherTableKey = isLeft ? relation.rightTableKey : relation.leftTableKey;
+  const otherTargetFieldName = isLeft ? relation.rightTargetFieldName : relation.leftTargetFieldName;
+  const otherJunctionFieldName = isLeft ? relation.rightField.name : relation.leftField.name;
+  const options = [
+    `from: r.${currentTableKey}.${currentTargetFieldName}.through(r.${relation.junctionTableKey}.${currentJunctionFieldName})`,
+    `to: r.${otherTableKey}.${otherTargetFieldName}.through(r.${relation.junctionTableKey}.${otherJunctionFieldName})`
+  ];
+  if (relation.alias) {
+    options.push(`alias: "${relation.alias}"`);
+  }
+  return `r.many.${otherTableKey}({ ${options.join(", ")} })`;
+}
+function inferForwardRelationKey(field, targetTable) {
+  const trimmed = field.name.replace(/Id$/, "").replace(/Ids$/, "").replace(/Ref$/, "");
+  const candidate = trimmed.length > 0 ? trimmed : tableSchemaKey(targetTable.name);
+  return toCamelCase(candidate);
+}
+function inferManyToManyKey(targetTable, targetField, selfRelation) {
+  if (!selfRelation) {
+    return tableSchemaKey(pluralize(singularize(targetTable.name)));
+  }
+  return tableSchemaKey(pluralize(inferForwardRelationKey(targetField, targetTable)));
+}
+function inferReverseKind(sourceTable, sourceField) {
+  if (sourceField.primaryKey || sourceField.unique) return "one";
+  const hasSingleFieldUnique = sourceTable.uniques.some(
+    (unique) => unique.fields.length === 1 && unique.fields[0] === sourceField.name
+  );
+  return hasSingleFieldUnique ? "one" : "many";
+}
+function ensureUsedSet(map, key) {
+  const existing = map.get(key);
+  if (existing) return existing;
+  const created = /* @__PURE__ */ new Set();
+  map.set(key, created);
+  return created;
+}
+function ensureUniqueKey(used, preferred, fallback) {
+  if (!used.has(preferred)) {
+    used.add(preferred);
+    return preferred;
+  }
+  if (!used.has(fallback)) {
+    used.add(fallback);
+    return fallback;
+  }
+  let counter = 2;
+  while (used.has(`${fallback}${counter}`)) {
+    counter += 1;
+  }
+  const candidate = `${fallback}${counter}`;
+  used.add(candidate);
+  return candidate;
+}
+function tableSchemaKey(tableName) {
+  return toCamelCase(tableName);
+}
+function createPairKey(left, right) {
+  return [left, right].sort((a, b) => a.localeCompare(b)).join("::");
+}
+
+// src/apply.ts
+import { createClient } from "@libsql/client";
+
+// src/types.ts
+import { z } from "zod";
+var foreignKeyActionSchema = z.enum([
+  "cascade",
+  "restrict",
+  "set null",
+  "set default",
+  "no action"
+]);
+var fieldReferenceSpecSchema = z.object({
+  table: z.string().min(1),
+  field: z.string().min(1),
+  onDelete: foreignKeyActionSchema.optional(),
+  onUpdate: foreignKeyActionSchema.optional()
+});
+var logicalTypeSpecSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("id"),
+    prefix: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal("string"),
+    format: z.enum(["email", "url", "slug"]).optional()
+  }),
+  z.object({
+    kind: z.literal("text")
+  }),
+  z.object({
+    kind: z.literal("boolean")
+  }),
+  z.object({
+    kind: z.literal("integer")
+  }),
+  z.object({
+    kind: z.literal("number")
+  }),
+  z.object({
+    kind: z.literal("enum"),
+    values: z.array(z.string()).min(1)
+  }),
+  z.object({
+    kind: z.literal("json"),
+    tsType: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal("temporal.instant")
+  }),
+  z.object({
+    kind: z.literal("temporal.plainDate")
+  })
+]);
+var storageSpecSchema = z.discriminatedUnion("strategy", [
+  z.object({
+    strategy: z.literal("sqlite.text"),
+    column: z.string().min(1)
+  }),
+  z.object({
+    strategy: z.literal("sqlite.integer"),
+    column: z.string().min(1)
+  }),
+  z.object({
+    strategy: z.literal("sqlite.real"),
+    column: z.string().min(1)
+  }),
+  z.object({
+    strategy: z.literal("sqlite.temporalInstantEpochMs"),
+    column: z.string().min(1)
+  }),
+  z.object({
+    strategy: z.literal("sqlite.temporalPlainDateText"),
+    column: z.string().min(1)
+  })
+]);
+var defaultSpecSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("literal"),
+    value: z.union([z.string(), z.number(), z.boolean(), z.null()])
+  }),
+  z.object({
+    kind: z.literal("now")
+  }),
+  z.object({
+    kind: z.literal("generatedId"),
+    prefix: z.string().min(1)
+  })
+]);
+var fieldSpecSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  logical: logicalTypeSpecSchema,
+  storage: storageSpecSchema,
+  nullable: z.boolean().default(true),
+  default: defaultSpecSchema.optional(),
+  primaryKey: z.boolean().default(false),
+  unique: z.boolean().default(false),
+  description: z.string().min(1).optional(),
+  references: fieldReferenceSpecSchema.optional()
+});
+var indexSpecSchema = z.object({
+  name: z.string().min(1).optional(),
+  fields: z.array(z.string().min(1)).min(1)
+});
+var uniqueSpecSchema = z.object({
+  name: z.string().min(1).optional(),
+  fields: z.array(z.string().min(1)).min(1)
+});
+var tableSpecSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().min(1).optional(),
+  fields: z.array(fieldSpecSchema).default([]),
+  indexes: z.array(indexSpecSchema).default([]),
+  uniques: z.array(uniqueSpecSchema).default([])
+});
+var schemaDocumentSchema = z.object({
+  version: z.literal(1),
+  dialect: z.literal("sqlite"),
+  schemaId: z.string().min(1),
+  tables: z.array(tableSpecSchema).default([])
+});
+
+// src/schema.ts
+function createEmptySchema(schemaId = "schema") {
+  return schemaDocumentSchema.parse({
+    version: 1,
+    dialect: "sqlite",
+    schemaId,
+    tables: []
+  });
+}
+function parseSchemaDocument(input) {
+  return schemaDocumentSchema.parse(input);
+}
+function validateSchemaDocument(input) {
+  const schema = parseSchemaDocument(input);
+  return {
+    schema,
+    issues: validateSchemaDocumentCompatibility(schema)
+  };
+}
+function assertValidSchemaDocument(input) {
+  const { schema, issues } = validateSchemaDocument(input);
+  if (issues.length > 0) {
+    throw new Error(
+      `Schema validation failed:
+${issues.map((issue) => `- ${issue.path}: ${issue.message}`).join("\n")}`
+    );
+  }
+  return schema;
+}
+function schemaHash(input) {
+  return createSchemaHash(input);
+}
+function findTable(schema, tableName) {
+  return schema.tables.find((table) => table.name === tableName) ?? null;
+}
+function findField(table, fieldName) {
+  return table.fields.find((field) => field.name === fieldName) ?? null;
+}
+
+// src/operations.ts
+function applyOperationsToSchema(schemaInput, operations) {
+  const schema = cloneSchema(schemaInput);
+  for (const operation of operations) {
+    applyOperationToSchemaMutating(schema, operation);
+  }
+  return assertValidSchemaDocument(schema);
+}
+function applyOperationToSchema(schemaInput, operation) {
+  const schema = cloneSchema(schemaInput);
+  applyOperationToSchemaMutating(schema, operation);
+  return assertValidSchemaDocument(schema);
+}
+function applyOperationToSchemaMutating(schema, operation) {
+  switch (operation.kind) {
+    case "createTable":
+      if (findTable(schema, operation.table.name)) {
+        throw new Error(`Table ${operation.table.name} already exists`);
+      }
+      schema.tables.push(cloneSchema(operation.table));
+      return;
+    case "dropTable": {
+      const referencedBy = schema.tables.flatMap(
+        (table) => table.fields.filter((field) => field.references?.table === operation.tableName).map((field) => `${table.name}.${field.name}`)
+      );
+      if (referencedBy.length > 0) {
+        throw new Error(
+          `Cannot drop table ${operation.tableName}; still referenced by ${referencedBy.join(", ")}`
+        );
+      }
+      const index = schema.tables.findIndex((table) => table.name === operation.tableName);
+      if (index < 0) throw new Error(`Table ${operation.tableName} does not exist`);
+      schema.tables.splice(index, 1);
+      return;
+    }
+    case "renameTable": {
+      const table = findTable(schema, operation.from);
+      if (!table) throw new Error(`Table ${operation.from} does not exist`);
+      if (findTable(schema, operation.to)) {
+        throw new Error(`Table ${operation.to} already exists`);
+      }
+      table.name = operation.to;
+      for (const candidateTable of schema.tables) {
+        for (const field of candidateTable.fields) {
+          if (field.references?.table === operation.from) {
+            field.references = {
+              ...field.references,
+              table: operation.to
+            };
+          }
+        }
+      }
+      return;
+    }
+    case "addField": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      if (findField(table, operation.field.name)) {
+        throw new Error(`Field ${operation.tableName}.${operation.field.name} already exists`);
+      }
+      table.fields.push(cloneSchema(operation.field));
+      return;
+    }
+    case "dropField": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const fieldIndex = table.fields.findIndex((field) => field.name === operation.fieldName);
+      if (fieldIndex < 0) {
+        throw new Error(`Field ${operation.tableName}.${operation.fieldName} does not exist`);
+      }
+      const referencedBy = schema.tables.flatMap(
+        (candidateTable) => candidateTable.fields.filter(
+          (field) => field.references?.table === operation.tableName && field.references.field === operation.fieldName
+        ).map((field) => `${candidateTable.name}.${field.name}`)
+      );
+      if (referencedBy.length > 0) {
+        throw new Error(
+          `Cannot drop field ${operation.tableName}.${operation.fieldName}; still referenced by ${referencedBy.join(", ")}`
+        );
+      }
+      table.fields.splice(fieldIndex, 1);
+      table.indexes = table.indexes.filter((index) => !index.fields.includes(operation.fieldName));
+      table.uniques = table.uniques.filter((unique) => !unique.fields.includes(operation.fieldName));
+      return;
+    }
+    case "renameField": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const field = findField(table, operation.from);
+      if (!field) throw new Error(`Field ${operation.tableName}.${operation.from} does not exist`);
+      if (findField(table, operation.to)) {
+        throw new Error(`Field ${operation.tableName}.${operation.to} already exists`);
+      }
+      const renamed = renameStorageColumn(field, operation.to);
+      const index = table.fields.findIndex((candidate) => candidate.id === field.id);
+      table.fields[index] = renamed;
+      table.indexes = renameFieldInIndexes(table.indexes, operation.from, operation.to);
+      table.uniques = renameFieldInUniques(table.uniques, operation.from, operation.to);
+      for (const candidateTable of schema.tables) {
+        for (const candidateField of candidateTable.fields) {
+          if (candidateField.references?.table === table.name && candidateField.references.field === operation.from) {
+            candidateField.references = {
+              ...candidateField.references,
+              field: operation.to
+            };
+          }
+        }
+      }
+      return;
+    }
+    case "alterField": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const field = findField(table, operation.fieldName);
+      if (!field) {
+        throw new Error(`Field ${operation.tableName}.${operation.fieldName} does not exist`);
+      }
+      const nextField = applyAlterFieldPatch(operation.tableName, field, operation.patch);
+      const fieldIndex = table.fields.findIndex((candidate) => candidate.id === field.id);
+      table.fields[fieldIndex] = nextField;
+      return;
+    }
+    case "addIndex": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      table.indexes.push(cloneSchema(operation.index));
+      return;
+    }
+    case "dropIndex": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const nextIndexes = table.indexes.filter(
+        (index) => resolveIndexName(table.name, index) !== operation.indexName
+      );
+      if (nextIndexes.length === table.indexes.length) {
+        throw new Error(`Index ${operation.indexName} does not exist on ${table.name}`);
+      }
+      table.indexes = nextIndexes;
+      return;
+    }
+    case "addUnique": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      table.uniques.push(cloneSchema(operation.unique));
+      return;
+    }
+    case "dropUnique": {
+      const table = findTable(schema, operation.tableName);
+      if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+      const nextUniques = table.uniques.filter(
+        (unique) => resolveUniqueName(table.name, unique) !== operation.uniqueName
+      );
+      if (nextUniques.length === table.uniques.length) {
+        throw new Error(`Unique ${operation.uniqueName} does not exist on ${table.name}`);
+      }
+      table.uniques = nextUniques;
+      return;
+    }
+  }
+}
+function applyAlterFieldPatch(tableName, field, patch) {
+  if (field.primaryKey) {
+    throw new Error(`Field ${tableName}.${field.name} is a primary key and cannot be altered in v1`);
+  }
+  if (patch.logical?.kind === "id") {
+    throw new Error(`Field ${tableName}.${field.name} cannot be altered into an id field in v1`);
+  }
+  const nextLogical = patch.logical ?? field.logical;
+  const nextColumn = patch.column ?? patch.storage?.column ?? field.storage.column;
+  const nextStorage = patch.storage ?? (patch.logical ? defaultStorageForLogical(nextLogical, nextColumn) : { ...field.storage, column: nextColumn });
+  const nextField = {
+    ...cloneSchema(field),
+    logical: cloneSchema(nextLogical),
+    storage: cloneSchema(nextStorage)
+  };
+  if (patch.nullable !== void 0) nextField.nullable = patch.nullable;
+  if (patch.default !== void 0) nextField.default = patch.default ?? void 0;
+  if (patch.unique !== void 0) nextField.unique = patch.unique;
+  if (patch.description !== void 0) nextField.description = patch.description ?? void 0;
+  if (patch.references !== void 0) nextField.references = patch.references ?? void 0;
+  const storageIssue = validateLogicalAndStorageCompatibility(nextField.logical, nextField.storage);
+  if (storageIssue) {
+    throw new Error(`Field ${tableName}.${field.name}: ${storageIssue}`);
+  }
+  if (nextField.default) {
+    const defaultIssue = validateDefaultCompatibility(nextField, nextField.default);
+    if (defaultIssue) {
+      throw new Error(`Field ${tableName}.${field.name}: ${defaultIssue}`);
+    }
+  }
+  return nextField;
+}
+function fieldStorageStrategyChanged(before, after) {
+  return before.storage.strategy !== after.storage.strategy;
+}
+function fieldNullabilityTightened(before, after) {
+  return before.nullable && !after.nullable;
+}
+function resolveIndexName(tableName, index) {
+  return index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
+}
+function resolveUniqueName(tableName, unique) {
+  return unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
+}
+function renameFieldInIndexes(indexes, from, to) {
+  return indexes.map((index) => ({
+    ...index,
+    fields: index.fields.map((field) => field === from ? to : field)
+  }));
+}
+function renameFieldInUniques(uniques, from, to) {
+  return uniques.map((unique) => ({
+    ...unique,
+    fields: unique.fields.map((field) => field === from ? to : field)
+  }));
+}
+
+// src/sqlite.ts
+function renderSqliteMigration(operations, options = {}) {
+  const statements = [];
+  const warnings = [];
+  let workingSchema = options.currentSchema ?? createEmptySchema();
+  let rebuildSequence = 0;
+  for (const operation of operations) {
+    const nextSchema = applyOperationToSchema(workingSchema, operation);
+    switch (operation.kind) {
+      case "createTable":
+        statements.push(renderCreateTableStatement(operation.table));
+        statements.push(...renderCreateIndexStatements(operation.table));
+        break;
+      case "dropTable":
+        statements.push(`DROP TABLE ${quoteIdentifier(operation.tableName)};`);
+        break;
+      case "renameTable":
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(operation.from)} RENAME TO ${quoteIdentifier(operation.to)};`
+        );
+        break;
+      case "renameField":
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(operation.tableName)} RENAME COLUMN ${quoteIdentifier(toSnakeCase(operation.from))} TO ${quoteIdentifier(toSnakeCase(operation.to))};`
+        );
+        break;
+      case "addIndex":
+        statements.push(renderCreateIndexStatement(operation.tableName, operation.index));
+        break;
+      case "dropIndex":
+        statements.push(`DROP INDEX ${quoteIdentifier(operation.indexName)};`);
+        break;
+      case "addUnique":
+        statements.push(renderCreateUniqueStatement(operation.tableName, operation.unique));
+        break;
+      case "dropUnique":
+        statements.push(`DROP INDEX ${quoteIdentifier(operation.uniqueName)};`);
+        break;
+      case "addField":
+      case "dropField":
+      case "alterField": {
+        const tableName = operation.tableName;
+        const beforeTable = findTable(workingSchema, tableName);
+        const afterTable = findTable(nextSchema, tableName);
+        if (!beforeTable || !afterTable) {
+          warnings.push(
+            `operation ${operation.kind} on ${tableName} could not be emitted because the table state was incomplete`
+          );
+          break;
+        }
+        const rebuild = renderTableRebuild({
+          beforeTable,
+          afterTable,
+          operation,
+          sequence: rebuildSequence
+        });
+        rebuildSequence += 1;
+        statements.push(...rebuild.statements);
+        warnings.push(...rebuild.warnings);
+        break;
+      }
+    }
+    workingSchema = nextSchema;
+  }
+  return {
+    statements,
+    warnings
+  };
+}
+function renderCreateTableStatement(table) {
+  const columnLines = table.fields.map((field) => `  ${renderColumnDefinition(field)}`);
+  return `CREATE TABLE ${quoteIdentifier(table.name)} (
+${columnLines.join(",\n")}
+);`;
+}
+function renderCreateIndexStatements(table) {
+  const statements = table.indexes.map(
+    (index) => renderCreateIndexStatement(table.name, index, table)
+  );
+  statements.push(
+    ...table.uniques.map((unique) => renderCreateUniqueStatement(table.name, unique, table))
+  );
+  return statements;
+}
+function renderCreateIndexStatement(tableName, index, table) {
+  const name = index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
+  return `CREATE INDEX ${quoteIdentifier(name)} ON ${quoteIdentifier(tableName)} (${index.fields.map((field) => quoteIdentifier(resolveColumnName(table, field))).join(", ")});`;
+}
+function renderCreateUniqueStatement(tableName, unique, table) {
+  const name = unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
+  return `CREATE UNIQUE INDEX ${quoteIdentifier(name)} ON ${quoteIdentifier(tableName)} (${unique.fields.map((field) => quoteIdentifier(resolveColumnName(table, field))).join(", ")});`;
+}
+function renderColumnDefinition(field) {
+  const parts = [quoteIdentifier(field.storage.column), renderSqlType(field.storage)];
+  if (field.primaryKey) parts.push("PRIMARY KEY");
+  if (!field.nullable) parts.push("NOT NULL");
+  if (field.unique && !field.primaryKey) parts.push("UNIQUE");
+  const defaultSql = renderSqlDefault(field.default, field);
+  if (defaultSql) parts.push(`DEFAULT ${defaultSql}`);
+  if (field.references) {
+    parts.push(
+      `REFERENCES ${quoteIdentifier(field.references.table)}(${quoteIdentifier(toSnakeCase(field.references.field))})`
+    );
+    if (field.references.onDelete)
+      parts.push(`ON DELETE ${field.references.onDelete.toUpperCase()}`);
+    if (field.references.onUpdate)
+      parts.push(`ON UPDATE ${field.references.onUpdate.toUpperCase()}`);
+  }
+  return parts.join(" ");
+}
+function renderSqlType(storage) {
+  switch (storage.strategy) {
+    case "sqlite.text":
+    case "sqlite.temporalPlainDateText":
+      return "TEXT";
+    case "sqlite.integer":
+    case "sqlite.temporalInstantEpochMs":
+      return "INTEGER";
+    case "sqlite.real":
+      return "REAL";
+  }
+}
+function renderSqlDefault(defaultValue, field) {
+  if (!defaultValue) return null;
+  switch (defaultValue.kind) {
+    case "generatedId":
+      return null;
+    case "now":
+      return `(${sqliteEpochMsNowSql()})`;
+    case "literal":
+      if (defaultValue.value === null) return "NULL";
+      if (typeof defaultValue.value === "string") {
+        return `'${defaultValue.value.replace(/'/g, "''")}'`;
+      }
+      if (typeof defaultValue.value === "boolean") {
+        return field.storage.strategy === "sqlite.integer" ? defaultValue.value ? "1" : "0" : defaultValue.value ? "TRUE" : "FALSE";
+      }
+      return `${defaultValue.value}`;
+  }
+}
+function resolveColumnName(table, fieldName) {
+  const field = table?.fields.find((candidate) => candidate.name === fieldName);
+  return field?.storage.column ?? toSnakeCase(fieldName);
+}
+function renderTableRebuild(args) {
+  const warnings = [];
+  const tempName = `__sedrino_rebuild_${args.afterTable.name}_${args.sequence}`;
+  const insertColumns = args.afterTable.fields.map((field) => quoteIdentifier(field.storage.column));
+  const selectExpressions = args.afterTable.fields.map(
+    (field) => renderRebuildSelectExpression({
+      beforeTable: args.beforeTable,
+      afterTable: args.afterTable,
+      operation: args.operation,
+      targetField: field,
+      warnings
+    })
+  );
+  const statements = [
+    "PRAGMA foreign_keys = OFF;",
+    `ALTER TABLE ${quoteIdentifier(args.beforeTable.name)} RENAME TO ${quoteIdentifier(tempName)};`,
+    renderCreateTableStatement(args.afterTable),
+    ...renderCreateIndexStatements(args.afterTable),
+    `INSERT INTO ${quoteIdentifier(args.afterTable.name)} (${insertColumns.join(", ")}) SELECT ${selectExpressions.join(", ")} FROM ${quoteIdentifier(tempName)};`,
+    `DROP TABLE ${quoteIdentifier(tempName)};`,
+    "PRAGMA foreign_keys = ON;"
+  ];
+  return {
+    statements,
+    warnings
+  };
+}
+function renderRebuildSelectExpression(args) {
+  const sourceField = args.beforeTable.fields.find((candidate) => candidate.id === args.targetField.id) ?? null;
+  if (!sourceField) {
+    if (args.operation.kind === "addField" && args.operation.field.id === args.targetField.id && args.operation.backfill) {
+      return `(${args.operation.backfill.sql}) AS ${quoteIdentifier(args.targetField.storage.column)}`;
+    }
+    const defaultSql = renderSqlDefault(args.targetField.default, args.targetField);
+    if (defaultSql) return `${defaultSql} AS ${quoteIdentifier(args.targetField.storage.column)}`;
+    if (args.targetField.nullable) {
+      return `NULL AS ${quoteIdentifier(args.targetField.storage.column)}`;
+    }
+    args.warnings.push(
+      `addField ${args.afterTable.name}.${args.targetField.name} is required with no default and cannot be backfilled safely`
+    );
+    return `NULL AS ${quoteIdentifier(args.targetField.storage.column)}`;
+  }
+  if (fieldStorageStrategyChanged(sourceField, args.targetField)) {
+    if (args.operation.kind === "alterField" && args.operation.transform && args.operation.fieldName === args.targetField.name) {
+      return `(${args.operation.transform.sql}) AS ${quoteIdentifier(args.targetField.storage.column)}`;
+    }
+    args.warnings.push(
+      `alterField ${args.afterTable.name}.${args.targetField.name} changes storage strategy from ${sourceField.storage.strategy} to ${args.targetField.storage.strategy}; explicit data transforms are not supported in v1`
+    );
+  }
+  let expression = quoteIdentifier(sourceField.storage.column);
+  if (args.operation.kind === "alterField" && args.operation.transform && args.operation.fieldName === args.targetField.name) {
+    expression = `(${args.operation.transform.sql})`;
+  }
+  if (fieldNullabilityTightened(sourceField, args.targetField) && !(args.operation.kind === "alterField" && args.operation.transform && args.operation.fieldName === args.targetField.name)) {
+    const defaultSql = renderSqlDefault(args.targetField.default, args.targetField);
+    if (defaultSql) {
+      expression = `COALESCE(${expression}, ${defaultSql})`;
+    } else {
+      args.warnings.push(
+        `alterField ${args.afterTable.name}.${args.targetField.name} makes a nullable field required without a default; existing NULL rows would fail during rebuild`
+      );
+    }
+  }
+  return `${expression} AS ${quoteIdentifier(args.targetField.storage.column)}`;
+}
+
+// src/planner.ts
+function planMigration(args) {
+  const currentSchema = args.currentSchema ? assertValidSchemaDocument(args.currentSchema) : createEmptySchema(args.migration.meta.id);
+  const operations = args.migration.buildOperations();
+  const nextSchema = applyOperationsToSchema(currentSchema, operations);
+  return {
+    migrationId: args.migration.meta.id,
+    migrationName: args.migration.meta.name,
+    fromSchemaHash: createSchemaHash(currentSchema),
+    toSchemaHash: createSchemaHash(nextSchema),
+    operations,
+    nextSchema,
+    sql: renderSqliteMigration(operations, { currentSchema })
+  };
+}
+function materializeSchema(args) {
+  let schema = args.baseSchema ? assertValidSchemaDocument(args.baseSchema) : createEmptySchema();
+  const plans = [];
+  for (const migration of args.migrations) {
+    const plan = planMigration({
+      currentSchema: schema,
+      migration
+    });
+    plans.push(plan);
+    schema = plan.nextSchema;
+  }
+  return {
+    schema,
+    plans
+  };
+}
+
+// src/apply.ts
+var MIGRATIONS_TABLE = "_sedrino_schema_migrations";
+var STATE_TABLE = "_sedrino_schema_state";
+function createLibsqlClient(options) {
+  return createClient({
+    url: options.url,
+    authToken: options.authToken,
+    concurrency: 0
+  });
+}
+async function applyMigrations(args) {
+  const client = args.client ?? createLibsqlClient(assertConnection(args.connection));
+  await ensureMetadataTables(client);
+  const appliedRows = await listAppliedMigrations(client);
+  const appliedIds = new Set(appliedRows.map((row) => row.migrationId));
+  const migrationMap = new Map(args.migrations.map((migration) => [migration.meta.id, migration]));
+  for (const applied of appliedRows) {
+    if (!migrationMap.has(applied.migrationId)) {
+      throw new Error(
+        `Database contains applied migration ${applied.migrationId}, but it is not present locally`
+      );
+    }
+  }
+  const appliedLocalMigrations = args.migrations.filter(
+    (migration) => appliedIds.has(migration.meta.id)
+  );
+  const expectedCurrent = materializeSchema({
+    baseSchema: args.baseSchema,
+    migrations: appliedLocalMigrations
+  }).schema;
+  const expectedHash = schemaHash(expectedCurrent);
+  const currentState = await getSchemaState(client);
+  if (currentState) {
+    if (currentState.schemaHash !== expectedHash) {
+      throw new Error(
+        `Schema drift detected. Database hash ${currentState.schemaHash} does not match expected local hash ${expectedHash}`
+      );
+    }
+  } else if (appliedRows.length > 0) {
+    throw new Error(
+      `Database has applied migrations recorded in ${MIGRATIONS_TABLE} but is missing ${STATE_TABLE}`
+    );
+  }
+  const pendingMigrations = args.migrations.filter(
+    (migration) => !appliedIds.has(migration.meta.id)
+  );
+  const appliedPlans = [];
+  let currentSchema = expectedCurrent;
+  for (const migration of pendingMigrations) {
+    const plan = planMigration({
+      currentSchema,
+      migration
+    });
+    if (plan.sql.warnings.length > 0) {
+      throw new Error(
+        `Migration ${plan.migrationId} cannot be applied safely:
+${plan.sql.warnings.map((warning) => `- ${warning}`).join("\n")}`
+      );
+    }
+    await executePlan(client, plan);
+    currentSchema = plan.nextSchema;
+    appliedPlans.push(plan);
+  }
+  return {
+    appliedPlans,
+    skippedMigrationIds: appliedLocalMigrations.map((migration) => migration.meta.id),
+    currentSchema,
+    currentSchemaHash: schemaHash(currentSchema)
+  };
+}
+async function listAppliedMigrations(client) {
+  const result = await client.execute(
+    `SELECT migration_id, migration_name, schema_hash, applied_at
+     FROM ${MIGRATIONS_TABLE}
+     ORDER BY applied_at ASC, migration_id ASC`
+  );
+  return result.rows.map((row) => ({
+    migrationId: getString(row.migration_id) ?? "",
+    migrationName: getString(row.migration_name) ?? "",
+    schemaHash: getString(row.schema_hash) ?? "",
+    appliedAt: getNumber(row.applied_at) ?? 0
+  }));
+}
+async function inspectMigrationStatus(args) {
+  const client = args.client ?? createLibsqlClient(assertConnection(args.connection));
+  const metadataTablesPresent = await hasMetadataTables(client);
+  const appliedRows = metadataTablesPresent ? await listAppliedMigrations(client) : [];
+  const appliedIds = new Set(appliedRows.map((row) => row.migrationId));
+  const localMigrationIds = args.migrations.map((migration) => migration.meta.id);
+  const pendingMigrationIds = localMigrationIds.filter((id) => !appliedIds.has(id));
+  const unexpectedDatabaseMigrationIds = appliedRows.map((row) => row.migrationId).filter((id) => !localMigrationIds.includes(id));
+  const appliedLocalMigrations = args.migrations.filter((migration) => appliedIds.has(migration.meta.id));
+  const expectedCurrent = materializeSchema({
+    baseSchema: args.baseSchema,
+    migrations: appliedLocalMigrations
+  }).schema;
+  const currentState = metadataTablesPresent ? await getSchemaState(client) : null;
+  const localSchemaHash = schemaHash(expectedCurrent);
+  const databaseSchemaHash = currentState?.schemaHash ?? null;
+  return {
+    localMigrationIds,
+    appliedMigrationIds: appliedRows.map((row) => row.migrationId),
+    pendingMigrationIds,
+    unexpectedDatabaseMigrationIds,
+    schemaHash: {
+      local: localSchemaHash,
+      database: databaseSchemaHash,
+      driftDetected: databaseSchemaHash !== null && databaseSchemaHash !== localSchemaHash
+    },
+    metadataTablesPresent
+  };
+}
+async function getSchemaState(client) {
+  const result = await client.execute(
+    `SELECT schema_hash, schema_json
+     FROM ${STATE_TABLE}
+     WHERE singleton_id = 1`
+  );
+  const row = result.rows[0];
+  if (!row) return null;
+  const schemaHashValue = getString(row.schema_hash);
+  const schemaJsonValue = getString(row.schema_json);
+  if (!schemaHashValue || !schemaJsonValue) return null;
+  return {
+    schemaHash: schemaHashValue,
+    schemaJson: schemaJsonValue
+  };
+}
+async function ensureMetadataTables(client) {
+  await client.batch(
+    [
+      "PRAGMA foreign_keys = ON",
+      `
+        CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+          migration_id TEXT PRIMARY KEY,
+          migration_name TEXT NOT NULL,
+          schema_hash TEXT NOT NULL,
+          applied_at INTEGER NOT NULL,
+          sql_statements_json TEXT NOT NULL
+        )
+      `,
+      `
+        CREATE TABLE IF NOT EXISTS ${STATE_TABLE} (
+          singleton_id INTEGER PRIMARY KEY CHECK (singleton_id = 1),
+          schema_hash TEXT NOT NULL,
+          schema_json TEXT NOT NULL,
+          updated_at INTEGER NOT NULL
+        )
+      `
+    ],
+    "write"
+  );
+}
+async function hasMetadataTables(client) {
+  const result = await client.execute({
+    sql: `SELECT name FROM sqlite_master
+          WHERE type = 'table' AND name IN (?, ?)`,
+    args: [MIGRATIONS_TABLE, STATE_TABLE]
+  });
+  const names = new Set(
+    result.rows.map((row) => getString(row.name)).filter((value) => value !== null)
+  );
+  return names.has(MIGRATIONS_TABLE) && names.has(STATE_TABLE);
+}
+async function executePlan(client, plan) {
+  const appliedAt = Date.now();
+  const statements = [
+    ...plan.sql.statements,
+    {
+      sql: `INSERT INTO ${MIGRATIONS_TABLE} (
+              migration_id,
+              migration_name,
+              schema_hash,
+              applied_at,
+              sql_statements_json
+            ) VALUES (?, ?, ?, ?, ?)`,
+      args: [
+        plan.migrationId,
+        plan.migrationName,
+        plan.toSchemaHash,
+        appliedAt,
+        JSON.stringify(plan.sql.statements)
+      ]
+    },
+    {
+      sql: `INSERT INTO ${STATE_TABLE} (
+              singleton_id,
+              schema_hash,
+              schema_json,
+              updated_at
+            ) VALUES (1, ?, ?, ?)
+            ON CONFLICT(singleton_id) DO UPDATE SET
+              schema_hash = excluded.schema_hash,
+              schema_json = excluded.schema_json,
+              updated_at = excluded.updated_at`,
+      args: [plan.toSchemaHash, JSON.stringify(plan.nextSchema), appliedAt]
+    }
+  ];
+  await client.batch(statements, "write");
+}
+function assertConnection(connection) {
+  if (!connection?.url) {
+    throw new Error("Missing database connection. Provide --url or pass a connection object.");
+  }
+  return connection;
+}
+function getString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function getNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+// src/project.ts
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+var MIGRATION_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".js", ".mjs"]);
+function resolveDbProjectLayout(dbDir = "db") {
+  const absoluteDbDir = path.resolve(dbDir);
+  return {
+    dbDir: absoluteDbDir,
+    migrationsDir: path.join(absoluteDbDir, "migrations"),
+    schemaDir: path.join(absoluteDbDir, "schema"),
+    snapshotPath: path.join(absoluteDbDir, "schema", "schema.snapshot.json"),
+    drizzlePath: path.join(absoluteDbDir, "schema", "schema.generated.ts")
+  };
+}
+async function loadMigrationDefinitionsFromDirectory(migrationsDir) {
+  const files = await readdir(migrationsDir, { withFileTypes: true });
+  const migrationFiles = files.filter((entry) => entry.isFile()).map((entry) => path.join(migrationsDir, entry.name)).filter((filePath) => MIGRATION_EXTENSIONS.has(path.extname(filePath))).sort((left, right) => path.basename(left).localeCompare(path.basename(right)));
+  const migrations = [];
+  for (const filePath of migrationFiles) {
+    const imported = await import(pathToFileURL(filePath).href);
+    const definition = imported.default;
+    if (!definition || !definition.meta || typeof definition.meta.id !== "string" || typeof definition.meta.name !== "string" || typeof definition.buildOperations !== "function") {
+      throw new Error(`Migration file ${filePath} does not export a valid default migration`);
+    }
+    migrations.push(definition);
+  }
+  return migrations;
+}
+async function materializeProjectMigrations(layout) {
+  const migrations = await loadMigrationDefinitionsFromDirectory(layout.migrationsDir);
+  assertUniqueMigrationIds(migrations);
+  const materialized = materializeSchema({ migrations });
+  return {
+    ...materialized,
+    migrations
+  };
+}
+async function createMigrationScaffold(layout, rawName, now = /* @__PURE__ */ new Date()) {
+  const slug = toKebabCase(rawName);
+  if (!slug) {
+    throw new Error("Migration name must contain at least one letter or number");
+  }
+  await mkdir(layout.migrationsDir, { recursive: true });
+  const datePrefix = formatMigrationDate(now);
+  const sequence = await nextMigrationSequence(layout.migrationsDir, datePrefix);
+  const sequenceText = String(sequence).padStart(3, "0");
+  const migrationId = `${datePrefix}-${sequenceText}-${slug}`;
+  const fileName = `${migrationId}.ts`;
+  const filePath = path.join(layout.migrationsDir, fileName);
+  const migrationName = humanizeMigrationName(slug);
+  const source = renderMigrationTemplate({
+    migrationId,
+    migrationName
+  });
+  await writeFile(filePath, source, { encoding: "utf8", flag: "wx" });
+  return {
+    filePath,
+    fileName,
+    migrationId,
+    migrationName
+  };
+}
+async function validateDbProject(layout) {
+  const materialized = await materializeProjectMigrations(layout);
+  const expectedSnapshot = `${JSON.stringify(materialized.schema, null, 2)}
+`;
+  const expectedDrizzle = compileSchemaToDrizzle(materialized.schema);
+  const warnings = materialized.plans.flatMap(
+    (plan) => plan.sql.warnings.map((warning) => `${plan.migrationId}: ${warning}`)
+  );
+  const [snapshotContents, drizzleContents] = await Promise.all([
+    readTextIfExists(layout.snapshotPath),
+    readTextIfExists(layout.drizzlePath)
+  ]);
+  return {
+    ...materialized,
+    warnings,
+    expectedSnapshot,
+    expectedDrizzle,
+    artifacts: {
+      snapshotExists: snapshotContents !== null,
+      drizzleExists: drizzleContents !== null,
+      snapshotUpToDate: snapshotContents === expectedSnapshot,
+      drizzleUpToDate: drizzleContents === expectedDrizzle
+    }
+  };
+}
+async function writeSchemaSnapshot(schema, snapshotPath) {
+  await mkdir(path.dirname(snapshotPath), { recursive: true });
+  await writeFile(snapshotPath, `${JSON.stringify(schema, null, 2)}
+`, "utf8");
+}
+async function writeDrizzleSchema(schema, drizzlePath) {
+  await mkdir(path.dirname(drizzlePath), { recursive: true });
+  await writeFile(drizzlePath, compileSchemaToDrizzle(schema), "utf8");
+}
+function assertUniqueMigrationIds(migrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const migration of migrations) {
+    if (seen.has(migration.meta.id)) {
+      throw new Error(`Duplicate migration id ${migration.meta.id}`);
+    }
+    seen.add(migration.meta.id);
+  }
+}
+async function readTextIfExists(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function nextMigrationSequence(migrationsDir, datePrefix) {
+  const files = await readdir(migrationsDir, { withFileTypes: true });
+  let maxSequence = 0;
+  for (const entry of files) {
+    if (!entry.isFile()) continue;
+    const match = entry.name.match(/^(\d{4}-\d{2}-\d{2})-(\d{3})(?:-[^.]+)?\.(?:ts|mts|js|mjs)$/);
+    if (!match) continue;
+    if (match[1] !== datePrefix) continue;
+    const parsed = Number(match[2]);
+    if (Number.isInteger(parsed) && parsed > maxSequence) {
+      maxSequence = parsed;
+    }
+  }
+  return maxSequence + 1;
+}
+function formatMigrationDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function toKebabCase(value) {
+  return value.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function humanizeMigrationName(slug) {
+  const parts = slug.split("-").filter(Boolean);
+  const first = parts[0];
+  if (!first) return "New migration";
+  const rest = parts.slice(1);
+  return [
+    `${first[0].toUpperCase()}${first.slice(1)}`,
+    ...rest
+  ].join(" ");
+}
+function renderMigrationTemplate(args) {
+  return `import { createMigration } from "@sedrino/db-schema";
+
+export default createMigration(
+  {
+    id: ${JSON.stringify(args.migrationId)},
+    name: ${JSON.stringify(args.migrationName)},
+  },
+  (m) => {
+    // TODO: define migration operations.
+  },
+);
+`;
+}
+
+// src/cli.ts
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const [group, command] = args.positionals;
+  if (!group || group === "help" || hasFlag(args, "help")) {
+    printHelp();
+    return;
+  }
+  switch (`${group} ${command ?? ""}`.trim()) {
+    case "migrate plan":
+      await handleMigratePlan(args);
+      return;
+    case "migrate create":
+      await handleMigrateCreate(args);
+      return;
+    case "migrate apply":
+      await handleMigrateApply(args);
+      return;
+    case "migrate validate":
+      await handleMigrateValidate(args);
+      return;
+    case "migrate status":
+      await handleMigrateStatus(args);
+      return;
+    case "schema print":
+      await handleSchemaPrint(args);
+      return;
+    case "schema drizzle":
+      await handleSchemaDrizzle(args);
+      return;
+    default:
+      throw new Error(`Unknown command: ${[group, command].filter(Boolean).join(" ")}`);
+  }
+}
+async function handleMigratePlan(args) {
+  const layout = resolveLayoutFromArgs(args);
+  const { schema, plans } = await materializeProjectMigrations(layout);
+  const snapshotPath = path2.resolve(getStringOption(args, "snapshot") ?? layout.snapshotPath);
+  const drizzleOutputPath = path2.resolve(getStringOption(args, "drizzle-out") ?? layout.drizzlePath);
+  await writeSchemaSnapshot(schema, snapshotPath);
+  await writeDrizzleSchema(schema, drizzleOutputPath);
+  const warnings = plans.flatMap(
+    (plan) => plan.sql.warnings.map((warning) => `${plan.migrationId}: ${warning}`)
+  );
+  const statementCount = plans.reduce((total, plan) => total + plan.sql.statements.length, 0);
+  console.log(`Planned ${plans.length} migration(s)`);
+  console.log(`Schema snapshot: ${snapshotPath}`);
+  console.log(`Drizzle output: ${drizzleOutputPath}`);
+  console.log(`SQL statements: ${statementCount}`);
+  console.log(`Schema hash: ${plans.at(-1)?.toSchemaHash ?? "schema_00000000"}`);
+  if (warnings.length > 0) {
+    console.log("");
+    console.log("Warnings:");
+    for (const warning of warnings) console.log(`- ${warning}`);
+  }
+  if (hasFlag(args, "sql")) {
+    console.log("");
+    for (const plan of plans) {
+      console.log(`# ${plan.migrationId} ${plan.migrationName}`);
+      for (const statement of plan.sql.statements) console.log(statement);
+      if (plan.sql.warnings.length > 0) {
+        for (const warning of plan.sql.warnings) console.log(`-- warning: ${warning}`);
+      }
+      console.log("");
+    }
+  }
+}
+async function handleMigrateCreate(args) {
+  const layout = resolveLayoutFromArgs(args);
+  const rawName = args.positionals.slice(2).join(" ").trim();
+  if (!rawName) {
+    throw new Error("Missing migration name. Usage: sedrino-db migrate create <name> [--dir db]");
+  }
+  const created = await createMigrationScaffold(layout, rawName);
+  console.log(`Created migration: ${created.filePath}`);
+  console.log(`Migration id: ${created.migrationId}`);
+  console.log(`Migration name: ${created.migrationName}`);
+}
+async function handleMigrateApply(args) {
+  const layout = resolveLayoutFromArgs(args);
+  const { migrations } = await materializeProjectMigrations(layout);
+  const url = getStringOption(args, "url") ?? env.LIBSQL_URL;
+  const authToken = getStringOption(args, "auth-token") ?? env.LIBSQL_AUTH_TOKEN;
+  if (!url) {
+    throw new Error("Missing database URL. Use --url or set LIBSQL_URL.");
+  }
+  const result = await applyMigrations({
+    client: createLibsqlClient({ url, authToken }),
+    migrations
+  });
+  await writeSchemaSnapshot(
+    result.currentSchema,
+    getStringOption(args, "snapshot") ?? layout.snapshotPath
+  );
+  await writeDrizzleSchema(
+    result.currentSchema,
+    getStringOption(args, "drizzle-out") ?? layout.drizzlePath
+  );
+  console.log(`Applied ${result.appliedPlans.length} migration(s)`);
+  console.log(`Skipped ${result.skippedMigrationIds.length} already-applied migration(s)`);
+  console.log(`Current schema hash: ${result.currentSchemaHash}`);
+  if (result.appliedPlans.length > 0) {
+    console.log("");
+    console.log("Applied:");
+    for (const plan of result.appliedPlans) {
+      console.log(`- ${plan.migrationId} (${plan.sql.statements.length} statement(s))`);
+    }
+  }
+}
+async function handleMigrateValidate(args) {
+  const layout = resolveLayoutFromArgs(args);
+  const result = await validateDbProject(layout);
+  console.log(`Validated ${result.migrations.length} migration(s)`);
+  console.log(`Schema hash: ${result.plans.at(-1)?.toSchemaHash ?? "schema_00000000"}`);
+  console.log(`Snapshot up to date: ${result.artifacts.snapshotUpToDate ? "yes" : "no"}`);
+  console.log(`Drizzle output up to date: ${result.artifacts.drizzleUpToDate ? "yes" : "no"}`);
+  if (result.warnings.length > 0) {
+    console.log("");
+    console.log("Warnings:");
+    for (const warning of result.warnings) console.log(`- ${warning}`);
+  }
+  const hasIssues = result.warnings.length > 0 || !result.artifacts.snapshotUpToDate || !result.artifacts.drizzleUpToDate;
+  if (hasIssues) {
+    exit(1);
+  }
+}
+async function handleMigrateStatus(args) {
+  const layout = resolveLayoutFromArgs(args);
+  const { migrations, plans } = await materializeProjectMigrations(layout);
+  console.log(`Local migrations: ${migrations.length}`);
+  console.log(`Local schema hash: ${plans.at(-1)?.toSchemaHash ?? "schema_00000000"}`);
+  const url = getStringOption(args, "url") ?? env.LIBSQL_URL;
+  const authToken = getStringOption(args, "auth-token") ?? env.LIBSQL_AUTH_TOKEN;
+  if (!url) {
+    return;
+  }
+  const status = await inspectMigrationStatus({
+    client: createLibsqlClient({ url, authToken }),
+    migrations,
+    baseSchema: void 0
+  });
+  console.log(`Metadata tables present: ${status.metadataTablesPresent ? "yes" : "no"}`);
+  console.log(`Applied in database: ${status.appliedMigrationIds.length}`);
+  console.log(`Pending locally: ${status.pendingMigrationIds.length}`);
+  console.log(`Unexpected in database: ${status.unexpectedDatabaseMigrationIds.length}`);
+  console.log(
+    `Database schema hash: ${status.schemaHash.database ?? (status.metadataTablesPresent ? "missing" : "none")}`
+  );
+  console.log(`Drift detected: ${status.schemaHash.driftDetected ? "yes" : "no"}`);
+  if (status.pendingMigrationIds.length > 0) {
+    console.log("");
+    console.log("Pending:");
+    for (const migrationId of status.pendingMigrationIds) console.log(`- ${migrationId}`);
+  }
+  if (status.unexpectedDatabaseMigrationIds.length > 0) {
+    console.log("");
+    console.log("Unexpected in database:");
+    for (const migrationId of status.unexpectedDatabaseMigrationIds) console.log(`- ${migrationId}`);
+  }
+  if (status.schemaHash.driftDetected || status.unexpectedDatabaseMigrationIds.length > 0) {
+    exit(1);
+  }
+}
+async function handleSchemaPrint(args) {
+  const layout = resolveLayoutFromArgs(args);
+  const { schema } = await materializeProjectMigrations(layout);
+  console.log(JSON.stringify(schema, null, 2));
+}
+async function handleSchemaDrizzle(args) {
+  const layout = resolveLayoutFromArgs(args);
+  const { schema } = await materializeProjectMigrations(layout);
+  const source = compileSchemaToDrizzle(schema);
+  const outputPath = getStringOption(args, "out");
+  if (outputPath) {
+    await writeDrizzleSchema(schema, path2.resolve(outputPath));
+    console.log(`Wrote Drizzle schema to ${path2.resolve(outputPath)}`);
+    return;
+  }
+  process.stdout.write(source);
+}
+function resolveLayoutFromArgs(args) {
+  return resolveDbProjectLayout(getStringOption(args, "dir") ?? "db");
+}
+function parseArgs(argv) {
+  const positionals = [];
+  const options = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (!value.startsWith("--")) {
+      positionals.push(value);
+      continue;
+    }
+    const withoutPrefix = value.slice(2);
+    const [rawKey, inlineValue] = withoutPrefix.split("=", 2);
+    const key = rawKey ?? "";
+    if (inlineValue !== void 0) {
+      options.set(key, inlineValue);
+      continue;
+    }
+    const next = argv[index + 1];
+    if (next && !next.startsWith("--")) {
+      options.set(key, next);
+      index += 1;
+      continue;
+    }
+    options.set(key, true);
+  }
+  return {
+    positionals,
+    options
+  };
+}
+function hasFlag(args, name) {
+  return args.options.get(name) === true;
+}
+function getStringOption(args, name) {
+  const value = args.options.get(name);
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function printHelp() {
+  console.log(`sedrino-db
+
+Usage:
+  sedrino-db migrate create <name> [--dir db]
+  sedrino-db migrate plan [--dir db] [--sql] [--snapshot path] [--drizzle-out path]
+  sedrino-db migrate apply --url <libsql-url> [--auth-token token] [--dir db]
+  sedrino-db migrate validate [--dir db]
+  sedrino-db migrate status [--dir db] [--url <libsql-url>] [--auth-token token]
+  sedrino-db schema print [--dir db]
+  sedrino-db schema drizzle [--dir db] [--out path]
+
+Defaults:
+  --dir defaults to ./db
+  schema snapshot defaults to ./db/schema/schema.snapshot.json
+  drizzle output defaults to ./db/schema/schema.generated.ts
+`);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  exit(1);
+});
+//# sourceMappingURL=cli.js.map