js-bao 0.4.0 → 0.4.1

package/dist/codegen-v2.cjs

@@ -0,0 +1,1766 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/models/StringSet.ts
+var init_StringSet = __esm({
+  "src/models/StringSet.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/documentTypes.ts
+var init_documentTypes = __esm({
+  "src/types/documentTypes.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/queryTypes.ts
+var init_queryTypes = __esm({
+  "src/types/queryTypes.ts"() {
+    "use strict";
+  }
+});
+
+// src/query/CursorManager.ts
+var init_CursorManager = __esm({
+  "src/query/CursorManager.ts"() {
+    "use strict";
+    init_queryTypes();
+  }
+});
+
+// src/utils/sql.ts
+var init_sql = __esm({
+  "src/utils/sql.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/patterns.ts
+var init_patterns = __esm({
+  "src/utils/patterns.ts"() {
+    "use strict";
+  }
+});
+
+// src/query/DocumentQueryTranslator.ts
+var init_DocumentQueryTranslator = __esm({
+  "src/query/DocumentQueryTranslator.ts"() {
+    "use strict";
+    init_queryTypes();
+    init_CursorManager();
+    init_sql();
+    init_patterns();
+  }
+});
+
+// src/models/metaSync.ts
+function registerFunctionDefault(fn, name) {
+  KNOWN_FUNCTION_DEFAULTS.set(fn, name);
+}
+var Y, KNOWN_FUNCTION_DEFAULTS;
+var init_metaSync = __esm({
+  "src/models/metaSync.ts"() {
+    "use strict";
+    Y = __toESM(require("yjs"), 1);
+    KNOWN_FUNCTION_DEFAULTS = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/models/BaseModel.ts
+function generateULID() {
+  return (0, import_ulid.ulid)();
+}
+var Y2, import_ulid;
+var init_BaseModel = __esm({
+  "src/models/BaseModel.ts"() {
+    "use strict";
+    Y2 = __toESM(require("yjs"), 1);
+    import_ulid = require("ulid");
+    init_StringSet();
+    init_documentTypes();
+    init_DocumentQueryTranslator();
+    init_CursorManager();
+    init_sql();
+    init_metaSync();
+    registerFunctionDefault(generateULID, "generate_ulid");
+  }
+});
+
+// src/models/relationshipManager.ts
+var init_relationshipManager = __esm({
+  "src/models/relationshipManager.ts"() {
+    "use strict";
+    init_BaseModel();
+  }
+});
+
+// src/models/ModelRegistry.ts
+var init_ModelRegistry = __esm({
+  "src/models/ModelRegistry.ts"() {
+    "use strict";
+    init_BaseModel();
+    init_relationshipManager();
+  }
+});
+
+// src/cli/codegen-v2.ts
+var import_commander = require("commander");
+var path3 = __toESM(require("path"), 1);
+
+// src/cli/v2/generator.ts
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+
+// src/models/tomlLoader.ts
+var import_smol_toml = require("smol-toml");
+
+// src/models/schema.ts
+init_BaseModel();
+init_ModelRegistry();
+function defineModelSchema(input) {
+  const { name, fields } = input;
+  const options = {
+    name,
+    className: input.options?.className,
+    uniqueConstraints: input.options?.uniqueConstraints ? [...input.options.uniqueConstraints] : void 0,
+    relationships: input.options?.relationships
+  };
+  const schema = {
+    name,
+    fields,
+    options,
+    runtimeShape: void 0,
+    buildRuntimeShape(modelClass) {
+      if (schema.runtimeShape && schema.runtimeShape.class === modelClass) {
+        return schema.runtimeShape;
+      }
+      const fieldsMap = /* @__PURE__ */ new Map();
+      for (const [fieldName, fieldOptions] of Object.entries(fields)) {
+        fieldsMap.set(fieldName, { ...fieldOptions });
+      }
+      const resolvedUniqueConstraints = resolveUniqueConstraints(
+        name,
+        fieldsMap,
+        options.uniqueConstraints
+      );
+      schema.runtimeShape = {
+        class: modelClass,
+        options,
+        fields: fieldsMap,
+        resolvedUniqueConstraints
+      };
+      return schema.runtimeShape;
+    }
+  };
+  return schema;
+}
+function resolveUniqueConstraints(modelName, fields, customConstraints) {
+  const resolved = [];
+  for (const [fieldName, options] of fields.entries()) {
+    if (options.unique) {
+      resolved.push({
+        name: `${modelName}_${fieldName}_unique`,
+        fields: [fieldName]
+      });
+    }
+  }
+  if (customConstraints) {
+    for (const constraint of customConstraints) {
+      const missingField = constraint.fields.find(
+        (field) => !fields.has(field)
+      );
+      if (missingField) {
+        console.warn(
+          `[defineModelSchema] Unique constraint "${constraint.name}" for model "${modelName}" references unknown field "${missingField}". Skipping.`
+        );
+        continue;
+      }
+      if (resolved.some((item) => item.name === constraint.name)) {
+        console.warn(
+          `[defineModelSchema] Duplicate unique constraint name "${constraint.name}" in model "${modelName}".`
+        );
+      }
+      resolved.push({
+        name: constraint.name,
+        fields: [...constraint.fields]
+      });
+    }
+  }
+  return resolved;
+}
+
+// src/models/tomlLoader.ts
+var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "id",
+  "stringset"
+]);
+var KNOWN_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "indexed",
+  "unique",
+  "required",
+  "auto_assign",
+  "max_length",
+  "max_count",
+  "default"
+]);
+var KNOWN_MODEL_KEYS = /* @__PURE__ */ new Set([
+  "fields",
+  "relationships",
+  "unique_constraints",
+  "class_name"
+]);
+var KNOWN_RELATIONSHIP_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "model",
+  "related_id_field",
+  "join_model",
+  "join_model_local_field",
+  "join_model_related_field",
+  "order_by_field",
+  "order_direction",
+  "join_model_order_by_field",
+  "join_model_order_direction"
+]);
+var KNOWN_UNIQUE_CONSTRAINT_KEYS = /* @__PURE__ */ new Set(["name", "fields"]);
+function checkUnknownKeys(raw, known, context, strict) {
+  if (!strict) return;
+  for (const key of Object.keys(raw)) {
+    if (!known.has(key)) {
+      throw new Error(
+        `${context}: unknown key "${key}". Allowed: ${[...known].join(", ")}`
+      );
+    }
+  }
+}
+function parseFieldOptions(raw, context, strict) {
+  if (!raw.type || !VALID_FIELD_TYPES.has(raw.type)) {
+    throw new Error(
+      `Invalid field type "${raw.type}". Must be one of: ${[...VALID_FIELD_TYPES].join(", ")}`
+    );
+  }
+  checkUnknownKeys(raw, KNOWN_FIELD_KEYS, context, strict);
+  const opts = { type: raw.type };
+  if (raw.indexed === true) opts.indexed = true;
+  if (raw.unique === true) opts.unique = true;
+  if (raw.required === true) opts.required = true;
+  if (raw.auto_assign === true) opts.autoAssign = true;
+  if (raw.max_length !== void 0) opts.maxLength = raw.max_length;
+  if (raw.max_count !== void 0) opts.maxCount = raw.max_count;
+  if (raw.default !== void 0) opts.default = raw.default;
+  return opts;
+}
+function requireField(raw, field, context) {
+  if (!raw[field]) {
+    throw new Error(`Relationship ${context}: missing required field "${field}"`);
+  }
+}
+function parseRelationship(raw, context, strict) {
+  const type = raw.type;
+  checkUnknownKeys(raw, KNOWN_RELATIONSHIP_KEYS, context, strict);
+  if (type === "refersTo") {
+    requireField(raw, "model", "refersTo");
+    requireField(raw, "related_id_field", "refersTo");
+    return {
+      type: "refersTo",
+      model: raw.model,
+      relatedIdField: raw.related_id_field
+    };
+  }
+  if (type === "hasMany") {
+    requireField(raw, "model", "hasMany");
+    requireField(raw, "related_id_field", "hasMany");
+    const rel = {
+      type: "hasMany",
+      model: raw.model,
+      relatedIdField: raw.related_id_field
+    };
+    if (raw.order_by_field) rel.orderByField = raw.order_by_field;
+    if (raw.order_direction) rel.orderDirection = raw.order_direction;
+    return rel;
+  }
+  if (type === "hasManyThrough") {
+    requireField(raw, "model", "hasManyThrough");
+    requireField(raw, "join_model", "hasManyThrough");
+    requireField(raw, "join_model_local_field", "hasManyThrough");
+    requireField(raw, "join_model_related_field", "hasManyThrough");
+    const rel = {
+      type: "hasManyThrough",
+      model: raw.model,
+      joinModel: raw.join_model,
+      joinModelLocalField: raw.join_model_local_field,
+      joinModelRelatedField: raw.join_model_related_field
+    };
+    if (raw.join_model_order_by_field)
+      rel.joinModelOrderByField = raw.join_model_order_by_field;
+    if (raw.join_model_order_direction)
+      rel.joinModelOrderDirection = raw.join_model_order_direction;
+    return rel;
+  }
+  throw new Error(`Unknown relationship type: ${type}`);
+}
+function loadSchemaFromTomlString(tomlString, options = {}) {
+  const strict = options.strict !== false;
+  const parsed = (0, import_smol_toml.parse)(tomlString);
+  const models = parsed.models;
+  if (!models || typeof models !== "object") {
+    throw new Error("TOML schema must have a [models] section");
+  }
+  const schemas = [];
+  for (const [modelName, modelDef] of Object.entries(models)) {
+    checkUnknownKeys(
+      modelDef,
+      KNOWN_MODEL_KEYS,
+      `[models.${modelName}]`,
+      strict
+    );
+    const fields = {};
+    if (modelDef.fields) {
+      for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+        fields[fieldName] = parseFieldOptions(
+          fieldDef,
+          `[models.${modelName}.fields.${fieldName}]`,
+          strict
+        );
+      }
+    }
+    let relationships;
+    if (modelDef.relationships) {
+      relationships = {};
+      for (const [relName, relDef] of Object.entries(
+        modelDef.relationships
+      )) {
+        relationships[relName] = parseRelationship(
+          relDef,
+          `[models.${modelName}.relationships.${relName}]`,
+          strict
+        );
+      }
+    }
+    let uniqueConstraints;
+    if (modelDef.unique_constraints) {
+      uniqueConstraints = [];
+      for (const raw of modelDef.unique_constraints) {
+        checkUnknownKeys(
+          raw,
+          KNOWN_UNIQUE_CONSTRAINT_KEYS,
+          `[[models.${modelName}.unique_constraints]]`,
+          strict
+        );
+        uniqueConstraints.push({
+          name: raw.name,
+          fields: [...raw.fields]
+        });
+      }
+    }
+    const className = typeof modelDef.class_name === "string" ? modelDef.class_name : void 0;
+    schemas.push(
+      defineModelSchema({
+        name: modelName,
+        fields,
+        options: {
+          className,
+          uniqueConstraints,
+          relationships
+        }
+      })
+    );
+  }
+  return schemas;
+}
+
+// src/cli/v2/pluralization.ts
+function singularizeToPascalCase(snakePlural) {
+  if (!snakePlural || snakePlural.length === 0) return null;
+  const parts = snakePlural.split("_");
+  if (parts.some((p) => p.length === 0)) return null;
+  const last = parts[parts.length - 1];
+  const singularizedLast = singularizeWord(last);
+  if (singularizedLast === null) return null;
+  parts[parts.length - 1] = singularizedLast;
+  return parts.map(pascalSegment).join("");
+}
+function singularizeWord(word) {
+  if (!word) return null;
+  if (!endsWithS(word)) return null;
+  if (word.endsWith("ies") && word.length > 3) {
+    return word.slice(0, -3) + "y";
+  }
+  if (word.endsWith("xes") && word.length > 3) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("ses") && word.length > 3) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("shes") && word.length > 4) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("ches") && word.length > 4) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && word.length > 1) {
+    return word.slice(0, -1);
+  }
+  return null;
+}
+function pascalSegment(segment) {
+  if (!segment) return segment;
+  return segment.charAt(0).toUpperCase() + segment.slice(1);
+}
+function endsWithS(word) {
+  return word.endsWith("s");
+}
+function resolveClassName(modelName, classNameOverride) {
+  if (classNameOverride && classNameOverride.length > 0) {
+    return classNameOverride;
+  }
+  const singular = singularizeToPascalCase(modelName);
+  if (singular === null) {
+    throw new Error(
+      `Cannot derive a class name from TOML model "${modelName}". Add an explicit "class_name" override under [models.${modelName}], e.g. class_name = "MyClass".`
+    );
+  }
+  return singular;
+}
+
+// src/cli/v2/fingerprint.ts
+var import_crypto = require("crypto");
+function fingerprintToml(tomlContent) {
+  return (0, import_crypto.createHash)("sha256").update(tomlContent, "utf-8").digest("hex").slice(0, 16);
+}
+
+// src/cli/v2/tsTypes.ts
+function tsTypeForFieldType(fieldType) {
+  switch (fieldType) {
+    case "string":
+    case "id":
+    case "date":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "stringset":
+      return "StringSet";
+    default: {
+      const _exhaustive = fieldType;
+      throw new Error(`Unknown TOML field type: ${_exhaustive}`);
+    }
+  }
+}
+
+// src/cli/v2/templates.ts
+var HEADER_BANNER = "// AUTO-GENERATED FROM models.toml \u2014 DO NOT EDIT.";
+var REGEN_INSTRUCTION = "// Run `npx js-bao-codegen-v2` to regenerate.";
+function renderModelFile(input) {
+  const {
+    className,
+    modelName,
+    fingerprint,
+    fields,
+    relationships,
+    classNamesByModelName
+  } = input;
+  const usesStringSet = Object.values(fields).some(
+    (opts) => opts.type === "stringset"
+  );
+  const rels = relationships ? Object.entries(relationships) : [];
+  const usesPagination = rels.some(
+    ([, cfg]) => cfg.type === "hasMany" || cfg.type === "hasManyThrough"
+  );
+  const targetClassNames = /* @__PURE__ */ new Set();
+  for (const [, cfg] of rels) {
+    const targetName = classNamesByModelName[cfg.model];
+    if (!targetName) {
+      throw new Error(
+        `Relationship in [models.${modelName}] references model "${cfg.model}" which is not present in models.toml. Cross-TOML references are not supported.`
+      );
+    }
+    if (targetName !== className) {
+      targetClassNames.add(targetName);
+    }
+  }
+  const lines = [];
+  lines.push(HEADER_BANNER);
+  lines.push(REGEN_INSTRUCTION);
+  lines.push(`// fingerprint: ${fingerprint}`);
+  lines.push("");
+  const jsBaoTypeImports = ["BaseModel"];
+  if (usesStringSet) jsBaoTypeImports.push("StringSet");
+  if (usesPagination) {
+    jsBaoTypeImports.push("PaginationOptions", "PaginatedResult");
+  }
+  lines.push(
+    `import type { ${jsBaoTypeImports.join(", ")} } from "js-bao";`
+  );
+  lines.push(`import { BaseModel as BaseModelImpl } from "js-bao";`);
+  const sortedTargets = [...targetClassNames].sort();
+  for (const target of sortedTargets) {
+    lines.push(`import type { ${target} } from "./${target}.generated";`);
+  }
+  lines.push("");
+  lines.push(`export interface ${className}Attrs {`);
+  for (const [fieldName, opts] of Object.entries(fields)) {
+    const tsType = tsTypeForFieldType(opts.type);
+    const optional = opts.required === true ? "" : "?";
+    lines.push(`  ${fieldName}${optional}: ${tsType};`);
+  }
+  lines.push(`}`);
+  lines.push("");
+  lines.push(`export interface ${className} extends ${className}Attrs, BaseModel {`);
+  const seenCompanionTargets = /* @__PURE__ */ new Map();
+  for (const [relName, cfg] of rels) {
+    const targetClass = classNamesByModelName[cfg.model];
+    if (cfg.type === "refersTo") {
+      lines.push(`  ${relName}(): Promise<${targetClass} | null>;`);
+    } else if (cfg.type === "hasMany") {
+      lines.push(
+        `  ${relName}(options?: PaginationOptions): Promise<PaginatedResult<${targetClass}>>;`
+      );
+    } else if (cfg.type === "hasManyThrough") {
+      const priorRel = seenCompanionTargets.get(targetClass);
+      if (priorRel !== void 0) {
+        throw new Error(
+          `Generator-time collision: model [models.${modelName}] has two hasManyThrough relationships ("${priorRel}" and "${relName}") both targeting class "${targetClass}", which would produce duplicate add${targetClass}/remove${targetClass} methods. Rename one of the relationships or split into different target models.`
+        );
+      }
+      seenCompanionTargets.set(targetClass, relName);
+      lines.push(
+        `  ${relName}(options?: PaginationOptions): Promise<PaginatedResult<${targetClass}>>;`
+      );
+      lines.push(`  add${targetClass}(target: ${targetClass} | string): Promise<void>;`);
+      lines.push(`  remove${targetClass}(target: ${targetClass} | string): Promise<void>;`);
+    }
+  }
+  lines.push(`}`);
+  lines.push("");
+  lines.push(`export class ${className} extends BaseModelImpl {}`);
+  lines.push("");
+  lines.push(
+    `export const ${className}_modelName: "${escapeStringLiteral(modelName)}" = ${JSON.stringify(modelName)};`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function renderBarrel(input) {
+  const { fingerprint, tomlFilename, entries } = input;
+  const lines = [];
+  lines.push(HEADER_BANNER);
+  lines.push(REGEN_INSTRUCTION);
+  lines.push(`// fingerprint: ${fingerprint}`);
+  lines.push("//");
+  lines.push(
+    "// Importing this barrel registers every model with js-bao as a side"
+  );
+  lines.push(
+    "// effect (via `attachAndRegisterModel`). Apps should import models from"
+  );
+  lines.push(
+    "// this barrel rather than the per-model `*.generated` files so"
+  );
+  lines.push("// registration runs exactly once.");
+  lines.push("");
+  lines.push(`import type { BaseModel } from "js-bao";`);
+  lines.push(
+    `import { attachAndRegisterModel, loadSchemaFromTomlString } from "js-bao";`
+  );
+  lines.push(`import modelsToml from "./${tomlFilename}?raw";`);
+  for (const { className } of entries) {
+    lines.push(`import { ${className} } from "./${className}.generated";`);
+  }
+  lines.push("");
+  for (const { className } of entries) {
+    lines.push(`export { ${className} } from "./${className}.generated";`);
+  }
+  lines.push("");
+  lines.push(`const _modelPairs: ReadonlyArray<{`);
+  lines.push(`  modelName: string;`);
+  lines.push(`  class: typeof BaseModel;`);
+  lines.push(`}> = [`);
+  for (const { modelName, className } of entries) {
+    lines.push(
+      `  { modelName: ${JSON.stringify(modelName)}, class: ${className} },`
+    );
+  }
+  lines.push(`];`);
+  lines.push("");
+  lines.push(`const _schemasByName = Object.fromEntries(`);
+  lines.push(`  loadSchemaFromTomlString(modelsToml).map((s) => [s.name, s])`);
+  lines.push(`);`);
+  lines.push("");
+  lines.push(`for (const { modelName, class: ModelClass } of _modelPairs) {`);
+  lines.push(`  const schema = _schemasByName[modelName];`);
+  lines.push(`  if (!schema) {`);
+  lines.push(`    throw new Error(`);
+  lines.push(
+    '      `Generated model ${ModelClass.name} expected TOML schema "${modelName}" \u2014 did models.toml change without re-running codegen?`'
+  );
+  lines.push(`    );`);
+  lines.push(`  }`);
+  lines.push(`  attachAndRegisterModel(ModelClass, schema);`);
+  lines.push(`}`);
+  lines.push("");
+  lines.push(`const _knownModelNames = new Set(_modelPairs.map((p) => p.modelName));`);
+  lines.push(`for (const schemaName of Object.keys(_schemasByName)) {`);
+  lines.push(`  if (!_knownModelNames.has(schemaName)) {`);
+  lines.push(`    throw new Error(`);
+  lines.push(
+    '      `TOML model "${schemaName}" has no generated class. Run \\`npx js-bao-codegen-v2\\` to regenerate.`'
+  );
+  lines.push(`    );`);
+  lines.push(`  }`);
+  lines.push(`}`);
+  lines.push("");
+  lines.push(`export const allModels: unknown[] = _modelPairs.map((m) => m.class);`);
+  lines.push("");
+  return lines.join("\n");
+}
+function escapeStringLiteral(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+// src/cli/v2/generator.ts
+var GENERATED_FILE_SUFFIX = ".generated.ts";
+var BARREL_FILENAME = "index.ts";
+async function generate(options) {
+  const inputAbs = path.resolve(options.inputTomlPath);
+  const outAbs = path.resolve(options.outputDir);
+  const tomlContent = await import_fs.promises.readFile(inputAbs, "utf-8");
+  const fingerprint = fingerprintToml(tomlContent);
+  const loaderOpts = { strict: options.strict !== false };
+  const schemas = loadSchemaFromTomlString(tomlContent, loaderOpts);
+  if (schemas.length === 0) {
+    throw new Error(
+      `models.toml at ${inputAbs} has no [models.*] sections \u2014 nothing to generate.`
+    );
+  }
+  const classNamesByModelName = {};
+  const seenClassNames = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const className = resolveClassName(schema.name, schema.options.className);
+    if (seenClassNames.has(className)) {
+      const otherModel = seenClassNames.get(className);
+      throw new Error(
+        `Class name collision: TOML models "${otherModel}" and "${schema.name}" both produce class "${className}". Add a "class_name" override to one of them.`
+      );
+    }
+    seenClassNames.set(className, schema.name);
+    classNamesByModelName[schema.name] = className;
+  }
+  const entries = schemas.map((s) => ({
+    modelName: s.name,
+    className: classNamesByModelName[s.name]
+  })).sort((a, b) => a.className.localeCompare(b.className));
+  const tomlFilename = path.basename(inputAbs);
+  const filesToWrite = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const className = classNamesByModelName[schema.name];
+    const filePath = path.join(outAbs, `${className}${GENERATED_FILE_SUFFIX}`);
+    filesToWrite.set(
+      filePath,
+      renderModelFile({
+        className,
+        modelName: schema.name,
+        fingerprint,
+        fields: extractFields(schema),
+        relationships: schema.options.relationships,
+        classNamesByModelName
+      })
+    );
+  }
+  const barrelPath = path.join(outAbs, BARREL_FILENAME);
+  filesToWrite.set(
+    barrelPath,
+    renderBarrel({
+      fingerprint,
+      tomlFilename,
+      entries
+    })
+  );
+  if (options.check === true) {
+    return await runCheck(outAbs, filesToWrite);
+  }
+  await import_fs.promises.mkdir(outAbs, { recursive: true });
+  const deletedFiles = await cleanupGeneratedOutputs(outAbs, filesToWrite);
+  const writtenFiles = [];
+  for (const [filePath, content] of filesToWrite) {
+    await import_fs.promises.writeFile(filePath, content, "utf-8");
+    writtenFiles.push(filePath);
+  }
+  writtenFiles.sort();
+  deletedFiles.sort();
+  return { writtenFiles, deletedFiles, mismatches: [] };
+}
+function extractFields(schema) {
+  return schema.fields;
+}
+async function runCheck(outAbs, filesToWrite) {
+  const mismatches = [];
+  for (const [filePath, expected] of filesToWrite) {
+    let actual;
+    try {
+      actual = await import_fs.promises.readFile(filePath, "utf-8");
+    } catch (err) {
+      if (err && err.code === "ENOENT") {
+        actual = null;
+      } else {
+        throw err;
+      }
+    }
+    if (actual === null) {
+      mismatches.push({ filePath, reason: "missing" });
+    } else if (actual !== expected) {
+      mismatches.push({ filePath, reason: "differs" });
+    }
+  }
+  if (await dirExists(outAbs)) {
+    const onDisk = await listOwnedGeneratedFiles(outAbs);
+    const expectedPaths = new Set(filesToWrite.keys());
+    for (const filePath of onDisk) {
+      if (!expectedPaths.has(filePath)) {
+        mismatches.push({ filePath, reason: "stale" });
+      }
+    }
+  }
+  return {
+    writtenFiles: [...filesToWrite.keys()].sort(),
+    deletedFiles: [],
+    mismatches
+  };
+}
+async function cleanupGeneratedOutputs(outDir, filesToWrite) {
+  const onDisk = await listOwnedGeneratedFiles(outDir);
+  const expectedPaths = new Set(filesToWrite.keys());
+  const deleted = [];
+  for (const filePath of onDisk) {
+    if (!expectedPaths.has(filePath)) {
+      await import_fs.promises.unlink(filePath);
+      deleted.push(filePath);
+    }
+  }
+  return deleted;
+}
+async function listOwnedGeneratedFiles(outDir) {
+  if (!await dirExists(outDir)) return [];
+  const entries = await import_fs.promises.readdir(outDir, { withFileTypes: true });
+  const owned = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (entry.name.endsWith(GENERATED_FILE_SUFFIX) || entry.name === BARREL_FILENAME) {
+      owned.push(path.join(outDir, entry.name));
+    }
+  }
+  return owned;
+}
+async function dirExists(dir) {
+  try {
+    const stat = await import_fs.promises.stat(dir);
+    return stat.isDirectory();
+  } catch (err) {
+    if (err && err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+
+// src/cli/v2/migrate.ts
+var path2 = __toESM(require("path"), 1);
+var import_fs2 = require("fs");
+var ts = __toESM(require("typescript"), 1);
+
+// src/cli/v2/toml-writer.ts
+var CAMEL_TO_SNAKE = {
+  autoAssign: "auto_assign",
+  maxLength: "max_length",
+  maxCount: "max_count",
+  relatedIdField: "related_id_field",
+  joinModel: "join_model",
+  joinModelLocalField: "join_model_local_field",
+  joinModelRelatedField: "join_model_related_field",
+  joinModelOrderByField: "join_model_order_by_field",
+  joinModelOrderDirection: "join_model_order_direction",
+  orderByField: "order_by_field",
+  orderDirection: "order_direction"
+};
+function toSnake(key) {
+  return CAMEL_TO_SNAKE[key] ?? key;
+}
+function tomlValue(v) {
+  if (typeof v === "string") {
+    return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+  }
+  if (typeof v === "number" || typeof v === "boolean") {
+    return String(v);
+  }
+  throw new Error(
+    `tomlValue: unsupported value kind ${typeof v} (${JSON.stringify(v)})`
+  );
+}
+function renderModelsToml(models) {
+  const lines = [];
+  let first = true;
+  for (const model of models) {
+    if (!first) lines.push("", "");
+    first = false;
+    lines.push(`[models.${model.name}]`);
+    if (model.className !== void 0) {
+      lines.push(`class_name = ${tomlValue(model.className)}`);
+    }
+    for (const [fieldName, opts] of Object.entries(model.fields)) {
+      lines.push("");
+      lines.push(`[models.${model.name}.fields.${fieldName}]`);
+      lines.push(`type = ${tomlValue(opts.type)}`);
+      if (opts.autoAssign === true) lines.push("auto_assign = true");
+      if (opts.indexed === true) lines.push("indexed = true");
+      if (opts.unique === true) lines.push("unique = true");
+      if (opts.required === true) lines.push("required = true");
+      if (opts.maxLength !== void 0) lines.push(`max_length = ${opts.maxLength}`);
+      if (opts.maxCount !== void 0) lines.push(`max_count = ${opts.maxCount}`);
+      if (opts.default !== void 0) {
+        lines.push(`default = ${tomlValue(opts.default)}`);
+      }
+    }
+    if (model.relationships) {
+      for (const [relName, cfg] of Object.entries(model.relationships)) {
+        lines.push("");
+        lines.push(`[models.${model.name}.relationships.${relName}]`);
+        for (const [k, v] of Object.entries(cfg)) {
+          if (v === void 0) continue;
+          lines.push(`${toSnake(k)} = ${tomlValue(v)}`);
+        }
+      }
+    }
+    if (model.uniqueConstraints) {
+      for (const c of model.uniqueConstraints) {
+        lines.push("");
+        lines.push(`[[models.${model.name}.unique_constraints]]`);
+        lines.push(`name = ${tomlValue(c.name)}`);
+        lines.push(
+          `fields = [${c.fields.map((f) => tomlValue(f)).join(", ")}]`
+        );
+      }
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/cli/v2/migrate.ts
+async function migrate(options) {
+  const inputAbs = path2.resolve(options.inputDir);
+  const outputAbs = path2.resolve(options.outputDir);
+  let inputStat;
+  try {
+    inputStat = await import_fs2.promises.stat(inputAbs);
+  } catch {
+    throw new Error(`Input directory does not exist: ${inputAbs}`);
+  }
+  if (!inputStat.isDirectory()) {
+    throw new Error(`Input path is not a directory: ${inputAbs}`);
+  }
+  const tomlPath = path2.join(outputAbs, "models.toml");
+  const reportJsonPath = path2.join(outputAbs, "migration-report.json");
+  const reportMdPath = path2.join(outputAbs, "migration-report.md");
+  if (!options.dryRun) {
+    if (await fileExists(tomlPath)) {
+      if (!options.force) {
+        throw new Error(
+          `models.toml already exists at ${tomlPath}; refusing to overwrite. Pass --force to overwrite, or remove the file first.`
+        );
+      }
+    }
+  }
+  const sourceFiles = await findV1SourceFiles(inputAbs);
+  const extracted = parseV1SourceFiles(sourceFiles);
+  if (extracted.length === 0) {
+    throw new Error(
+      `No v1 models found in ${inputAbs}. migrate scans for files containing \`defineModelSchema(...)\`; make sure the input dir points at v1 model sources.`
+    );
+  }
+  const tomlContent = renderTomlFromExtracted(extracted);
+  const report = buildReport(extracted, inputAbs);
+  const reportMd = renderReportMarkdown(report, inputAbs);
+  const reportJsonStr = JSON.stringify(report, null, 2) + "\n";
+  if (options.dryRun === true) {
+    return {
+      tomlPath,
+      reportJsonPath,
+      reportMdPath,
+      dryRun: true,
+      tomlContent,
+      reportJson: report,
+      reportMd
+    };
+  }
+  await import_fs2.promises.mkdir(outputAbs, { recursive: true });
+  await import_fs2.promises.writeFile(tomlPath, tomlContent, "utf-8");
+  await import_fs2.promises.writeFile(reportJsonPath, reportJsonStr, "utf-8");
+  await import_fs2.promises.writeFile(reportMdPath, reportMd, "utf-8");
+  return {
+    tomlPath,
+    reportJsonPath,
+    reportMdPath,
+    dryRun: false,
+    tomlContent,
+    reportJson: report,
+    reportMd
+  };
+}
+async function findV1SourceFiles(dir) {
+  const out = [];
+  const walk = async (current) => {
+    const entries = await import_fs2.promises.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules") continue;
+        if (entry.name === "generated") continue;
+        if (entry.name === "__tests__") continue;
+        await walk(full);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".ts")) continue;
+      if (entry.name.endsWith(".d.ts")) continue;
+      if (entry.name.endsWith(".generated.ts")) continue;
+      if (entry.name.endsWith(".test.ts")) continue;
+      if (entry.name.endsWith(".spec.ts")) continue;
+      out.push(full);
+    }
+  };
+  await walk(dir);
+  out.sort();
+  return out;
+}
+function parseV1SourceFiles(files) {
+  const out = [];
+  for (const file of files) {
+    const text = readFileSyncSafe(file);
+    if (text === null) continue;
+    if (!text.includes("defineModelSchema")) continue;
+    const sf = ts.createSourceFile(
+      file,
+      text,
+      ts.ScriptTarget.ES2020,
+      /* setParentNodes */
+      true,
+      ts.ScriptKind.TS
+    );
+    const schemas = collectSchemas(sf);
+    if (schemas.length === 0) continue;
+    const classByExtendsBaseModel = collectBaseModelClasses(sf);
+    for (const schema of schemas) {
+      const klass = classByExtendsBaseModel.length === 1 ? classByExtendsBaseModel[0] : classByExtendsBaseModel.find(
+        (c) => schemaIdentifierProbablyMatches(c, schema.identifier)
+      ) ?? null;
+      const className = klass?.name?.text ?? deriveFallbackClassName(schema.modelName);
+      out.push({
+        modelName: schema.modelName,
+        className,
+        sourceFile: file,
+        fields: schema.fields,
+        relationships: schema.relationships,
+        uniqueConstraints: schema.uniqueConstraints,
+        functionDefaults: schema.functionDefaults,
+        classCustomContent: klass ? extractCustomClassContent(klass, file) : []
+      });
+    }
+  }
+  out.sort((a, b) => a.modelName.localeCompare(b.modelName));
+  return out;
+}
+function readFileSyncSafe(file) {
+  try {
+    return (0, import_fs2.readFileSync)(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function collectSchemas(sf) {
+  const out = [];
+  const visit = (node) => {
+    if (ts.isVariableStatement(node) && node.declarationList.declarations.length > 0) {
+      for (const decl of node.declarationList.declarations) {
+        if (decl.initializer && ts.isCallExpression(decl.initializer) && ts.isIdentifier(decl.initializer.expression) && decl.initializer.expression.text === "defineModelSchema" && decl.initializer.arguments.length > 0 && ts.isIdentifier(decl.name)) {
+          const arg = decl.initializer.arguments[0];
+          if (ts.isObjectLiteralExpression(arg)) {
+            const parsed = parseDefineModelSchemaArg(arg, sf);
+            if (parsed) {
+              out.push({ identifier: decl.name.text, ...parsed });
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return out;
+}
+function parseDefineModelSchemaArg(obj, sf) {
+  let modelName = null;
+  let fields = {};
+  let relationships;
+  let uniqueConstraints;
+  const functionDefaults = [];
+  for (const property of obj.properties) {
+    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name))
+      continue;
+    const name = property.name.text;
+    if (name === "name" && ts.isStringLiteral(property.initializer)) {
+      modelName = property.initializer.text;
+    } else if (name === "fields" && ts.isObjectLiteralExpression(property.initializer)) {
+      const parsed = parseFields(property.initializer, sf);
+      fields = parsed.fields;
+      functionDefaults.push(...parsed.functionDefaults);
+    } else if (name === "options" && ts.isObjectLiteralExpression(property.initializer)) {
+      for (const opt of property.initializer.properties) {
+        if (!ts.isPropertyAssignment(opt) || !ts.isIdentifier(opt.name))
+          continue;
+        const optName = opt.name.text;
+        if (optName === "relationships" && ts.isObjectLiteralExpression(opt.initializer)) {
+          relationships = parseRelationships(opt.initializer);
+        } else if (optName === "uniqueConstraints" && ts.isArrayLiteralExpression(opt.initializer)) {
+          uniqueConstraints = parseUniqueConstraints(opt.initializer);
+        }
+      }
+    }
+  }
+  if (!modelName) return null;
+  for (const fd of functionDefaults) {
+    const opts = fields[fd.field];
+    if (opts && opts.type === "id") {
+      fd.severity = "info";
+      opts.autoAssign = true;
+    } else {
+      fd.severity = "warn";
+    }
+  }
+  return { modelName, fields, relationships, uniqueConstraints, functionDefaults };
+}
+function parseFields(obj, sf) {
+  const fields = {};
+  const functionDefaults = [];
+  for (const property of obj.properties) {
+    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name))
+      continue;
+    const fieldName = property.name.text;
+    if (!ts.isObjectLiteralExpression(property.initializer)) continue;
+    const opts = { type: "string" };
+    for (const fp of property.initializer.properties) {
+      if (!ts.isPropertyAssignment(fp) || !ts.isIdentifier(fp.name)) continue;
+      const optName = fp.name.text;
+      const value = parsePropertyValue(fp.initializer);
+      switch (optName) {
+        case "type":
+          if (typeof value === "string") opts.type = value;
+          break;
+        case "indexed":
+          if (typeof value === "boolean") opts.indexed = value;
+          break;
+        case "unique":
+          if (typeof value === "boolean") opts.unique = value;
+          break;
+        case "required":
+          if (typeof value === "boolean") opts.required = value;
+          break;
+        case "autoAssign":
+          if (typeof value === "boolean") opts.autoAssign = value;
+          break;
+        case "maxLength":
+          if (typeof value === "number") opts.maxLength = value;
+          break;
+        case "maxCount":
+          if (typeof value === "number") opts.maxCount = value;
+          break;
+        case "default": {
+          if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            opts.default = value;
+          } else if (isFunctionLikeInitializer(fp.initializer)) {
+            const lc = sf.getLineAndCharacterOfPosition(fp.getStart(sf));
+            functionDefaults.push({
+              field: fieldName,
+              line: lc.line + 1,
+              snippet: snippetOf(fp.initializer.getText(sf)),
+              severity: "warn"
+              // re-classified later if id+autoAssign
+            });
+          }
+          break;
+        }
+      }
+    }
+    fields[fieldName] = opts;
+  }
+  return { fields, functionDefaults };
+}
+function isFunctionLikeInitializer(node) {
+  if (ts.isArrowFunction(node)) return true;
+  if (ts.isFunctionExpression(node)) return true;
+  if (ts.isIdentifier(node)) return true;
+  if (ts.isCallExpression(node)) return true;
+  return false;
+}
+function parsePropertyValue(node) {
+  if (ts.isStringLiteral(node)) return node.text;
+  if (ts.isNumericLiteral(node)) return parseFloat(node.text);
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+  if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) {
+    return -parseFloat(node.operand.text);
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    return node.elements.map((el) => parsePropertyValue(el));
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+        obj[prop.name.text] = parsePropertyValue(prop.initializer);
+      }
+    }
+    return obj;
+  }
+  return void 0;
+}
+function parseRelationships(obj) {
+  const out = {};
+  for (const property of obj.properties) {
+    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name))
+      continue;
+    const relName = property.name.text;
+    let inner = null;
+    if (ts.isObjectLiteralExpression(property.initializer)) {
+      inner = property.initializer;
+    } else if (ts.isAsExpression(property.initializer) && ts.isObjectLiteralExpression(property.initializer.expression)) {
+      inner = property.initializer.expression;
+    }
+    if (!inner) continue;
+    const cfg = parseRelationshipConfig(inner);
+    if (cfg) out[relName] = cfg;
+  }
+  return out;
+}
+function parseRelationshipConfig(obj) {
+  const raw = {};
+  for (const property of obj.properties) {
+    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name))
+      continue;
+    if (ts.isStringLiteral(property.initializer)) {
+      raw[property.name.text] = property.initializer.text;
+    }
+  }
+  if (!raw.type || !raw.model) return null;
+  if (raw.type === "refersTo") {
+    if (!raw.relatedIdField) return null;
+    const cfg = {
+      type: "refersTo",
+      model: raw.model,
+      relatedIdField: raw.relatedIdField
+    };
+    return cfg;
+  }
+  if (raw.type === "hasMany") {
+    if (!raw.relatedIdField) return null;
+    const cfg = {
+      type: "hasMany",
+      model: raw.model,
+      relatedIdField: raw.relatedIdField
+    };
+    if (raw.orderByField) cfg.orderByField = raw.orderByField;
+    if (raw.orderDirection) cfg.orderDirection = raw.orderDirection;
+    return cfg;
+  }
+  if (raw.type === "hasManyThrough") {
+    if (!raw.joinModel || !raw.joinModelLocalField || !raw.joinModelRelatedField)
+      return null;
+    const cfg = {
+      type: "hasManyThrough",
+      model: raw.model,
+      joinModel: raw.joinModel,
+      joinModelLocalField: raw.joinModelLocalField,
+      joinModelRelatedField: raw.joinModelRelatedField
+    };
+    if (raw.joinModelOrderByField)
+      cfg.joinModelOrderByField = raw.joinModelOrderByField;
+    if (raw.joinModelOrderDirection)
+      cfg.joinModelOrderDirection = raw.joinModelOrderDirection;
+    return cfg;
+  }
+  return null;
+}
+function parseUniqueConstraints(arr) {
+  const out = [];
+  for (const el of arr.elements) {
+    if (!ts.isObjectLiteralExpression(el)) continue;
+    let name = null;
+    let fields = null;
+    for (const property of el.properties) {
+      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name))
+        continue;
+      if (property.name.text === "name" && ts.isStringLiteral(property.initializer)) {
+        name = property.initializer.text;
+      } else if (property.name.text === "fields" && ts.isArrayLiteralExpression(property.initializer)) {
+        const items = [];
+        for (const item of property.initializer.elements) {
+          if (ts.isStringLiteral(item)) items.push(item.text);
+        }
+        fields = items;
+      }
+    }
+    if (name && fields) out.push({ name, fields });
+  }
+  return out;
+}
+function collectBaseModelClasses(sf) {
+  const out = [];
+  const visit = (node) => {
+    if (ts.isClassDeclaration(node) && classExtendsBaseModel(node)) {
+      out.push(node);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return out;
+}
+function classExtendsBaseModel(node) {
+  if (!node.heritageClauses) return false;
+  for (const heritage of node.heritageClauses) {
+    if (heritage.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+    for (const t of heritage.types) {
+      if (ts.isIdentifier(t.expression) && t.expression.text === "BaseModel")
+        return true;
+    }
+  }
+  return false;
+}
+function schemaIdentifierProbablyMatches(klass, schemaIdentifier) {
+  if (!klass.name) return false;
+  const want = klass.name.text;
+  const stripped = schemaIdentifier.replace(/Schema$/, "");
+  return stripped.localeCompare(want, void 0, { sensitivity: "accent" }) === 0;
+}
+function extractCustomClassContent(klass, file) {
+  const sf = klass.getSourceFile();
+  const out = [];
+  for (const member of klass.members) {
+    let kind = null;
+    let name = "<anonymous>";
+    if (ts.isMethodDeclaration(member)) {
+      kind = hasStaticModifier(member) ? "static-method" : "instance-method";
+      if (member.name && ts.isIdentifier(member.name)) name = member.name.text;
+    } else if (ts.isGetAccessor(member)) {
+      kind = "getter";
+      if (member.name && ts.isIdentifier(member.name)) name = member.name.text;
+    } else if (ts.isSetAccessor(member)) {
+      kind = "setter";
+      if (member.name && ts.isIdentifier(member.name)) name = member.name.text;
+    } else if (ts.isPropertyDeclaration(member)) {
+      kind = "property";
+      if (member.name && ts.isIdentifier(member.name)) name = member.name.text;
+    } else if (ts.isConstructorDeclaration(member)) {
+      if (member.body && member.body.statements.length > 0) {
+        kind = "ctor-override";
+        name = "constructor";
+      }
+    }
+    if (kind === null) continue;
+    const lc = sf.getLineAndCharacterOfPosition(member.getStart(sf));
+    out.push({
+      kind,
+      name,
+      file,
+      line: lc.line + 1,
+      snippet: snippetOf(member.getText(sf))
+    });
+  }
+  return out;
+}
+function hasStaticModifier(node) {
+  const mods = ts.getModifiers(node) ?? [];
+  return mods.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+}
+function snippetOf(text) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return collapsed.length > 120 ? collapsed.slice(0, 117) + "..." : collapsed;
+}
+function deriveFallbackClassName(modelName) {
+  const parts = modelName.split(/_+/).filter(Boolean);
+  return parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function renderTomlFromExtracted(extracted) {
+  const models = extracted.slice().sort((a, b) => a.modelName.localeCompare(b.modelName)).map((e) => {
+    const computedDefault = singularizeToPascalCase(e.modelName);
+    const className = e.className && e.className !== computedDefault ? e.className : void 0;
+    return {
+      name: e.modelName,
+      className,
+      fields: e.fields,
+      relationships: e.relationships,
+      uniqueConstraints: e.uniqueConstraints
+    };
+  });
+  return renderModelsToml(models);
+}
+function buildReport(extracted, inputAbs) {
+  const models = extracted.map((e) => {
+    const customContent = [
+      ...e.classCustomContent,
+      ...e.functionDefaults.map((fd) => ({
+        kind: "function-default",
+        name: fd.field,
+        file: e.sourceFile,
+        line: fd.line,
+        snippet: fd.snippet,
+        severity: fd.severity
+      }))
+    ];
+    const hasNonInfoCustom = customContent.some(
+      (c) => c.kind !== "function-default" || c.severity !== "info"
+    );
+    return {
+      modelName: e.modelName,
+      className: e.className,
+      sourceFile: e.sourceFile,
+      classification: hasNonInfoCustom ? "needs-manual-migration" : "safe-to-delete",
+      customContent
+    };
+  });
+  const summary = {
+    safeToDelete: models.filter((m) => m.classification === "safe-to-delete").length,
+    needsManualMigration: models.filter(
+      (m) => m.classification === "needs-manual-migration"
+    ).length,
+    functionDefaults: models.reduce(
+      (acc, m) => acc + m.customContent.filter((c) => c.kind === "function-default").length,
+      0
+    )
+  };
+  const v1GeneratedFiles = listLikelyV1OutputFiles(inputAbs);
+  return {
+    summary,
+    models,
+    v1GeneratedFiles
+  };
+}
+function listLikelyV1OutputFiles(inputAbs) {
+  const out = [];
+  const candidates = [
+    path2.join(inputAbs, "generated", "relationships.ts"),
+    path2.join(inputAbs, "generated", "relationships.d.ts"),
+    path2.join(inputAbs, "generated", "index.ts")
+  ];
+  for (const c of candidates) {
+    try {
+      if ((0, import_fs2.statSync)(c).isFile()) out.push(c);
+    } catch {
+    }
+  }
+  const genDir = path2.join(inputAbs, "generated");
+  try {
+    const entries = (0, import_fs2.readdirSync)(genDir);
+    for (const e of entries) {
+      if (e.endsWith(".relationships.d.ts")) {
+        out.push(path2.join(genDir, e));
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function renderReportMarkdown(report, inputAbs) {
+  const lines = [];
+  lines.push("# Migration Report");
+  lines.push("");
+  lines.push(`Input directory: \`${inputAbs}\``);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`- safe-to-delete: ${report.summary.safeToDelete}`);
+  lines.push(`- needs-manual-migration: ${report.summary.needsManualMigration}`);
+  lines.push(`- function-defaults: ${report.summary.functionDefaults}`);
+  lines.push("");
+  if (report.v1GeneratedFiles.length > 0) {
+    lines.push("## v1-generated files (informational; not deleted)");
+    lines.push("");
+    for (const f of report.v1GeneratedFiles) {
+      lines.push(`- \`${f}\``);
+    }
+    lines.push("");
+  }
+  lines.push("## Models");
+  lines.push("");
+  for (const m of report.models) {
+    lines.push(`### ${m.className} (\`${m.modelName}\`) \u2014 ${m.classification}`);
+    lines.push("");
+    lines.push(`Source: \`${m.sourceFile}\``);
+    lines.push("");
+    if (m.customContent.length > 0) {
+      lines.push("Custom content:");
+      lines.push("");
+      for (const c of m.customContent) {
+        const sev = c.severity ? ` (${c.severity})` : "";
+        lines.push(`- \`${c.kind}\` \`${c.name}\`${sev} at line ${c.line}`);
+        if (c.snippet) lines.push(`  - \`${c.snippet}\``);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+async function fileExists(p) {
+  try {
+    const stat = await import_fs2.promises.stat(p);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/utils/Logger.ts
+var Logger2 = class _Logger {
+  static isVerbose = false;
+  static setVerbose(verbose) {
+    _Logger.isVerbose = verbose;
+  }
+  static log(message, prefix) {
+    const fullMessage = prefix ? `[${prefix}] ${message}` : message;
+    console.log(fullMessage);
+  }
+  static verbose(message, prefix) {
+    if (_Logger.isVerbose) {
+      const fullMessage = prefix ? `[${prefix}] ${message}` : message;
+      console.log(fullMessage);
+    }
+  }
+  static warn(message, prefix) {
+    const fullMessage = prefix ? `[${prefix}] ${message}` : message;
+    console.warn(fullMessage);
+  }
+  static error(message, prefix) {
+    const fullMessage = prefix ? `[${prefix}] ${message}` : message;
+    console.error(fullMessage);
+  }
+};
+
+// package.json
+var package_default = {
+  name: "js-bao",
+  version: "0.4.1",
+  description: "A library providing data modeling capabilities which support live updates and queries.",
+  types: "dist/index.d.ts",
+  type: "module",
+  files: [
+    "dist"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      node: {
+        import: "./dist/node.js",
+        require: "./dist/node.cjs"
+      },
+      browser: {
+        import: "./dist/browser.js",
+        require: "./dist/browser.cjs"
+      },
+      default: {
+        import: "./dist/index.js",
+        require: "./dist/index.cjs"
+      }
+    },
+    "./node": {
+      types: "./dist/node.d.ts",
+      import: "./dist/node.js",
+      require: "./dist/node.cjs"
+    },
+    "./browser": {
+      types: "./dist/browser.d.ts",
+      import: "./dist/browser.js",
+      require: "./dist/browser.cjs"
+    },
+    "./cloudflare": {
+      types: "./dist/cloudflare.d.ts",
+      import: "./dist/cloudflare.js",
+      require: "./dist/cloudflare.cjs"
+    },
+    "./cloudflare/do": {
+      types: "./dist/cloudflare-do.d.ts",
+      import: "./dist/cloudflare-do.js",
+      require: "./dist/cloudflare-do.cjs"
+    },
+    "./client": {
+      types: "./dist/client.d.ts",
+      import: "./dist/client.js",
+      require: "./dist/client.cjs"
+    }
+  },
+  bin: {
+    "js-bao-codegen": "./dist/codegen.cjs",
+    "jsbao-codegen": "./dist/codegen.cjs",
+    "js-bao-codegen-v2": "./dist/codegen-v2.cjs",
+    "jsbao-codegen-v2": "./dist/codegen-v2.cjs"
+  },
+  scripts: {
+    build: "pnpm build:cli && pnpm build:cli-v2 && pnpm codegen && rm -f dist/index.* dist/node.* dist/browser.* dist/cloudflare.* dist/cloudflare-do.* dist/client.* && pnpm build:main",
+    "build:main": "pnpm build:browser && pnpm build:node && pnpm build:universal && pnpm build:cloudflare && pnpm build:cloudflare-do && pnpm build:client",
+    "build:browser": "tsup src/browser.ts --format esm,cjs --dts --platform browser --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --external fs --no-splitting",
+    "build:node": "tsup src/node.ts --format esm,cjs --dts --platform node --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --no-splitting",
+    "build:universal": "tsup src/index.ts --format esm,cjs --dts --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --no-splitting",
+    "build:cloudflare": "tsup src/cloudflare.ts --format esm,cjs --dts --platform browser --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --external fs --no-splitting",
+    "build:cloudflare-do": "tsup src/cloudflare-do.ts --format esm,cjs --dts --platform neutral --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --external fs --no-splitting",
+    "build:client": "tsup src/client.ts --format esm,cjs --dts --platform browser --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --external fs --no-splitting",
+    "build:cli": "tsup src/cli/codegen.ts --format cjs --dts --platform node --target node18 --external commander --external typescript --external fs --external path --external util --no-splitting",
+    "build:cli-v2": "tsup src/cli/codegen-v2.ts --format cjs --dts --platform node --target node18 --external commander --external typescript --external fs --external path --external util --no-splitting",
+    dev: 'pnpm build:cli && concurrently "pnpm codegen:watch" "pnpm dev:main"',
+    "dev:main": 'concurrently "pnpm build:browser:dev --watch" "pnpm build:node:dev --watch" "pnpm build:universal:dev --watch"',
+    "dev:simple": "pnpm build:cli && pnpm codegen && pnpm build:main --watch",
+    "build:browser:dev": "tsup src/browser.ts --format esm,cjs --dts --sourcemap --platform browser --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --external fs",
+    "build:node:dev": "tsup src/node.ts --format esm,cjs --dts --sourcemap --platform node --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs",
+    "build:universal:dev": "tsup src/index.ts --format esm,cjs --dts --sourcemap --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs",
+    codegen: "./dist/codegen.cjs --config js-bao.config.cjs || echo 'Codegen skipped (likely in consumer project)'",
+    "codegen:watch": "./dist/codegen.cjs --config js-bao.config.cjs --watch",
+    "codegen:consumer": `node -e "require('child_process').spawn('./node_modules/.bin/js-bao-codegen', process.argv.slice(2), {stdio: 'inherit'})"`,
+    "publish:alpha": "node scripts/publish.js --tag alpha",
+    "publish:stable": "node scripts/publish.js",
+    test: 'echo "Error: no test specified" && exit 1',
+    prepare: "pnpm build",
+    prepublishOnly: "pnpm build"
+  },
+  dependencies: {
+    "async-mutex": "^0.5.0",
+    "smol-toml": "^1.3.1",
+    "sql.js": "^1.13.0",
+    ulid: "^3.0.0"
+  },
+  devDependencies: {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^20.17.51",
+    "@types/sql.js": "^1.4.9",
+    commander: "^11.0.0",
+    concurrently: "^9.1.2",
+    tsup: "^8.0.2",
+    tsx: "^4.19.4",
+    typescript: "^5.4.5",
+    yjs: "^13.6.18"
+  },
+  peerDependencies: {
+    yjs: "^13.6.18"
+  },
+  optionalDependencies: {
+    "better-sqlite3": "^12.6.2"
+  },
+  keywords: [
+    "yjs",
+    "crdt",
+    "orm",
+    "sqljs",
+    "database",
+    "reactivedb",
+    "nodejs",
+    "browser",
+    "sqlite",
+    "cloudflare",
+    "durable-objects",
+    "workers"
+  ],
+  author: "Primitive LLC",
+  license: "UNLICENSED"
+};
+
+// src/cli/codegen-v2.ts
+var CodegenV2CLI = class {
+  program;
+  constructor() {
+    this.program = new import_commander.Command();
+    this.setupCommands();
+  }
+  setupCommands() {
+    this.program.name("js-bao-codegen-v2").description(
+      "Generate typed model classes + auto-registration barrel from a models.toml"
+    ).version(package_default.version ?? "unknown");
+    this.program.command("generate", { isDefault: true }).description(
+      "Generate typed model classes + auto-registration barrel from models.toml"
+    ).requiredOption("-i, --input <file>", "Path to models.toml").requiredOption(
+      "-o, --output <dir>",
+      "Output directory for *.generated.ts and index.ts"
+    ).option(
+      "--check",
+      "Exit non-zero if generated output would change (CI-friendly)",
+      false
+    ).option(
+      "--no-strict",
+      "Do not fail on unknown TOML keys (legacy behavior)"
+    ).option("-v, --verbose", "Show detailed logging information", false).action(async (options) => {
+      await this.run(options);
+    });
+    this.program.command("migrate").description(
+      "Scan a v1 codegen app and produce a models.toml + migration report"
+    ).requiredOption(
+      "-i, --input <dir>",
+      "Directory containing v1 model .ts source files"
+    ).requiredOption(
+      "-o, --output <dir>",
+      "Directory where models.toml and migration-report.{json,md} are written"
+    ).option(
+      "--dry-run",
+      "Print planned outputs without writing to disk",
+      false
+    ).option(
+      "--force",
+      "Overwrite an existing models.toml in the output directory",
+      false
+    ).option("-v, --verbose", "Show detailed logging information", false).action(async (options) => {
+      await this.runMigrate(options);
+    });
+  }
+  async run(options) {
+    Logger2.setVerbose(options.verbose);
+    Logger2.log(
+      `js-bao-codegen-v2 v${package_default.version ?? "unknown"}`,
+      "js-bao-codegen-v2"
+    );
+    const inputAbs = path3.resolve(options.input);
+    const outputAbs = path3.resolve(options.output);
+    Logger2.verbose(`Input:  ${inputAbs}`, "js-bao-codegen-v2");
+    Logger2.verbose(`Output: ${outputAbs}`, "js-bao-codegen-v2");
+    let result;
+    try {
+      result = await generate({
+        inputTomlPath: inputAbs,
+        outputDir: outputAbs,
+        check: options.check,
+        // commander turns `--no-strict` into `strict: false`; otherwise
+        // `options.strict` is `true` by default (its negation-flag
+        // behavior — see the option declaration above).
+        strict: options.strict !== false
+      });
+    } catch (err) {
+      Logger2.error(String(err instanceof Error ? err.message : err), "js-bao-codegen-v2");
+      process.exit(1);
+      return;
+    }
+    if (options.check) {
+      if (result.mismatches.length > 0) {
+        Logger2.error(
+          `Check failed: ${result.mismatches.length} file(s) out of date.`,
+          "js-bao-codegen-v2"
+        );
+        for (const m of result.mismatches) {
+          Logger2.error(`  ${m.reason}: ${path3.relative(process.cwd(), m.filePath)}`, "js-bao-codegen-v2");
+        }
+        Logger2.error(
+          "Run `npx js-bao-codegen-v2 --input <toml> --output <dir>` to regenerate.",
+          "js-bao-codegen-v2"
+        );
+        process.exit(1);
+        return;
+      }
+      Logger2.log(
+        `Check passed: ${result.writtenFiles.length} file(s) up to date.`,
+        "js-bao-codegen-v2"
+      );
+      return;
+    }
+    for (const f of result.deletedFiles) {
+      Logger2.verbose(`deleted ${path3.relative(process.cwd(), f)}`, "js-bao-codegen-v2");
+    }
+    for (const f of result.writtenFiles) {
+      Logger2.verbose(`wrote   ${path3.relative(process.cwd(), f)}`, "js-bao-codegen-v2");
+    }
+    Logger2.log(
+      `Generated ${result.writtenFiles.length} file(s)` + (result.deletedFiles.length > 0 ? `, deleted ${result.deletedFiles.length} stale file(s).` : "."),
+      "js-bao-codegen-v2"
+    );
+  }
+  async runMigrate(options) {
+    Logger2.setVerbose(options.verbose);
+    Logger2.log(
+      `js-bao-codegen-v2 migrate v${package_default.version ?? "unknown"}`,
+      "js-bao-codegen-v2"
+    );
+    const inputAbs = path3.resolve(options.input);
+    const outputAbs = path3.resolve(options.output);
+    Logger2.verbose(`Input:  ${inputAbs}`, "js-bao-codegen-v2");
+    Logger2.verbose(`Output: ${outputAbs}`, "js-bao-codegen-v2");
+    if (options.dryRun) Logger2.log("(dry-run; no files will be written)", "js-bao-codegen-v2");
+    let result;
+    try {
+      result = await migrate({
+        inputDir: inputAbs,
+        outputDir: outputAbs,
+        dryRun: options.dryRun === true,
+        force: options.force === true
+      });
+    } catch (err) {
+      Logger2.error(
+        String(err instanceof Error ? err.message : err),
+        "js-bao-codegen-v2"
+      );
+      process.exit(1);
+      return;
+    }
+    if (result.dryRun) {
+      Logger2.log("--- planned models.toml ---", "js-bao-codegen-v2");
+      Logger2.log(result.tomlContent, "js-bao-codegen-v2");
+      Logger2.log("--- planned migration report (Markdown) ---", "js-bao-codegen-v2");
+      Logger2.log(result.reportMd, "js-bao-codegen-v2");
+      return;
+    }
+    Logger2.log(
+      `Wrote ${path3.relative(process.cwd(), result.tomlPath)}`,
+      "js-bao-codegen-v2"
+    );
+    Logger2.log(
+      `Wrote ${path3.relative(process.cwd(), result.reportJsonPath)}`,
+      "js-bao-codegen-v2"
+    );
+    Logger2.log(
+      `Wrote ${path3.relative(process.cwd(), result.reportMdPath)}`,
+      "js-bao-codegen-v2"
+    );
+    Logger2.log(
+      `Summary: ${result.reportJson.summary.safeToDelete} safe-to-delete, ${result.reportJson.summary.needsManualMigration} needs-manual-migration, ${result.reportJson.summary.functionDefaults} function-default(s) flagged.`,
+      "js-bao-codegen-v2"
+    );
+  }
+  execute() {
+    this.program.parseAsync(process.argv).catch((err) => {
+      Logger2.error(String(err), "js-bao-codegen-v2");
+      process.exit(1);
+    });
+  }
+};
+var cli = new CodegenV2CLI();
+cli.execute();