@autonoma-ai/sdk 0.2.1-canary.bbfed39 → 0.2.2

package/dist/index.js

@@ -44,101 +44,6 @@ function hmac(data, secret) {
   return createHmac2("sha256", secret).update(data).digest("base64url");
 }
 
-// src/tree.ts
-var RESERVED_KEYS = /* @__PURE__ */ new Set(["_alias", "_ref"]);
-function resolveTree(create, schema) {
-  const relationByParentField = /* @__PURE__ */ new Map();
-  for (const rel of schema.relations) {
-    relationByParentField.set(`${rel.parentModel}.${rel.parentField}`, rel);
-  }
-  const fkOnParent = /* @__PURE__ */ new Set();
-  for (const rel of schema.relations) {
-    const edge = schema.edges.find(
-      (e) => e.localField === rel.childField && (e.from === rel.parentModel || e.from === rel.childModel)
-    );
-    if (edge && edge.from === rel.parentModel) {
-      fkOnParent.add(`${rel.parentModel}.${rel.parentField}`);
-    }
-  }
-  const aliases = /* @__PURE__ */ new Map();
-  const ops = [];
-  const deferredUpdates = [];
-  let tempCounter = 0;
-  function makeTempId(model) {
-    return `__temp_${model}_${tempCounter++}`;
-  }
-  function walkNode(modelName, node, parentTempId, parentRelation, parentFkOnParent) {
-    const fields = {};
-    const preChildren = [];
-    const postChildren = [];
-    const alias = node._alias;
-    const tempId = makeTempId(modelName);
-    for (const [key, value] of Object.entries(node)) {
-      if (RESERVED_KEYS.has(key)) continue;
-      const exactKey = `${modelName}.${key}`;
-      const prefixedKey = `${modelName}.${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-      let relation = relationByParentField.get(exactKey) ?? relationByParentField.get(prefixedKey) ?? void 0;
-      let matchedKey = relationByParentField.has(exactKey) ? exactKey : prefixedKey;
-      if (!relation) {
-        for (const [relKey, rel] of relationByParentField) {
-          if (relKey.startsWith(`${modelName}.`) && rel.childModel.toLowerCase() === key.toLowerCase()) {
-            relation = rel;
-            matchedKey = relKey;
-            break;
-          }
-        }
-      }
-      if (relation) {
-        const isOnParent = fkOnParent.has(matchedKey);
-        if (isOnParent) {
-          preChildren.push({ relation, value, fkOnParent: true });
-        } else {
-          postChildren.push({ relation, value, fkOnParent: false });
-        }
-        continue;
-      }
-      if (value && typeof value === "object" && "_ref" in value) {
-        const refAlias = value._ref;
-        const refTempId = aliases.get(refAlias);
-        if (!refTempId) {
-          deferredUpdates.push({ targetTempId: tempId, model: modelName, field: key, refAlias });
-          continue;
-        }
-        fields[key] = refTempId;
-        continue;
-      }
-      fields[key] = value;
-    }
-    if (parentRelation && parentTempId && !parentFkOnParent) {
-      fields[parentRelation.childField] = parentTempId;
-    }
-    for (const { relation, value } of preChildren) {
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          const childTempId = walkNode(relation.childModel, item, tempId, relation, true);
-          fields[relation.childField] = childTempId;
-        }
-      }
-    }
-    ops.push({ model: modelName, fields, tempId, batch: false });
-    if (alias) aliases.set(alias, tempId);
-    for (const { relation, value } of postChildren) {
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          walkNode(relation.childModel, item, tempId, relation, false);
-        }
-      }
-    }
-    return tempId;
-  }
-  for (const [modelName, nodes] of Object.entries(create)) {
-    for (const node of nodes) {
-      walkNode(modelName, node, null, null, false);
-    }
-  }
-  return { ops, deferredUpdates, aliases };
-}
-
 // src/errors.ts
 var AutonomaError = class extends Error {
   constructor(message, code, status) {
@@ -177,9 +82,9 @@ var Errors = {
       403
     );
   },
-  productionBlocked() {
+  productionBlocked(detail) {
     return new AutonomaError(
-      "Environment factory is disabled in production",
+      `Environment factory is disabled in production${detail != null ? `. ${detail}` : ""}`,
       "PRODUCTION_BLOCKED",
       404
     );
@@ -193,649 +98,355 @@ var Errors = {
   }
 };
 
-// src/generated/sql-queries.ts
-var POSTGRES_COLUMNS = `SELECT
-  table_name,
-  column_name,
-  data_type,
-  udt_name,
-  is_nullable,
-  column_default
-FROM information_schema.columns
-WHERE table_schema = '{{schema}}'
-ORDER BY table_name, ordinal_position`;
-var POSTGRES_ENUMS = `SELECT t.typname AS enum_name, e.enumlabel AS enum_value
-FROM pg_type t
-JOIN pg_enum e ON t.oid = e.enumtypid
-JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-ORDER BY t.typname, e.enumsortorder`;
-var POSTGRES_FOREIGN_KEYS = `SELECT
-  kcu.table_name AS from_table,
-  kcu.column_name AS from_column,
-  ccu.table_name AS to_table,
-  ccu.column_name AS to_column,
-  c.is_nullable
-FROM information_schema.table_constraints tc
-JOIN information_schema.key_column_usage kcu
-  ON tc.constraint_name = kcu.constraint_name
-  AND tc.table_schema = kcu.table_schema
-JOIN information_schema.constraint_column_usage ccu
-  ON tc.constraint_name = ccu.constraint_name
-  AND tc.table_schema = ccu.table_schema
-LEFT JOIN information_schema.columns c
-  ON c.table_schema = kcu.table_schema
-  AND c.table_name = kcu.table_name
-  AND c.column_name = kcu.column_name
-WHERE tc.constraint_type = 'FOREIGN KEY'
-  AND tc.table_schema = '{{schema}}'
-ORDER BY kcu.table_name, kcu.ordinal_position`;
-var POSTGRES_PRIMARY_KEYS = `SELECT
-  tc.table_name,
-  kcu.column_name
-FROM information_schema.table_constraints tc
-JOIN information_schema.key_column_usage kcu
-  ON tc.constraint_name = kcu.constraint_name
-  AND tc.table_schema = kcu.table_schema
-WHERE tc.constraint_type = 'PRIMARY KEY'
-  AND tc.table_schema = '{{schema}}'
-ORDER BY tc.table_name, kcu.ordinal_position`;
-var POSTGRES_TABLES = `SELECT table_name
-FROM information_schema.tables
-WHERE table_schema = '{{schema}}'
-  AND table_type = 'BASE TABLE'
-ORDER BY table_name`;
-var MYSQL_COLUMNS = `SELECT
-  table_name,
-  column_name,
-  data_type,
-  column_type AS udt_name,
-  is_nullable,
-  column_default
-FROM information_schema.columns
-WHERE table_schema = '{{schema}}'
-ORDER BY table_name, ordinal_position`;
-var MYSQL_ENUMS = `SELECT NULL AS enum_name, NULL AS enum_value FROM DUAL WHERE 1 = 0`;
-var MYSQL_FOREIGN_KEYS = `SELECT
-  kcu.table_name AS from_table,
-  kcu.column_name AS from_column,
-  kcu.referenced_table_name AS to_table,
-  kcu.referenced_column_name AS to_column,
-  c.is_nullable
-FROM information_schema.key_column_usage kcu
-JOIN information_schema.columns c
-  ON c.table_schema = kcu.table_schema
-  AND c.table_name = kcu.table_name
-  AND c.column_name = kcu.column_name
-WHERE kcu.referenced_table_name IS NOT NULL
-  AND kcu.table_schema = '{{schema}}'
-ORDER BY kcu.table_name, kcu.ordinal_position`;
-var MYSQL_PRIMARY_KEYS = `SELECT
-  tc.table_name,
-  kcu.column_name
-FROM information_schema.table_constraints tc
-JOIN information_schema.key_column_usage kcu
-  ON tc.constraint_name = kcu.constraint_name
-  AND tc.table_schema = kcu.table_schema
-  AND tc.table_name = kcu.table_name
-WHERE tc.constraint_type = 'PRIMARY KEY'
-  AND tc.table_schema = '{{schema}}'
-ORDER BY tc.table_name, kcu.ordinal_position`;
-var MYSQL_TABLES = `SELECT table_name
-FROM information_schema.tables
-WHERE table_schema = '{{schema}}'
-  AND table_type = 'BASE TABLE'
-ORDER BY table_name`;
-
-// src/dialect.ts
-var replaceSchema = (template, schema) => template.replace("{{schema}}", schema);
-var postgres = {
-  name: "postgres",
-  param: (i) => `$${i}`,
-  quoteId: (name) => `"${name}"`,
-  supportsReturning: true,
-  tablesSQL: (schema) => replaceSchema(POSTGRES_TABLES, schema),
-  columnsSQL: (schema) => replaceSchema(POSTGRES_COLUMNS, schema),
-  primaryKeysSQL: (schema) => replaceSchema(POSTGRES_PRIMARY_KEYS, schema),
-  foreignKeysSQL: (schema) => replaceSchema(POSTGRES_FOREIGN_KEYS, schema),
-  enumsSQL: () => POSTGRES_ENUMS
-};
-var mysql = {
-  name: "mysql",
-  param: () => "?",
-  quoteId: (name) => `\`${name}\``,
-  supportsReturning: false,
-  tablesSQL: (schema) => replaceSchema(MYSQL_TABLES, schema),
-  columnsSQL: (schema) => replaceSchema(MYSQL_COLUMNS, schema),
-  primaryKeysSQL: (schema) => replaceSchema(MYSQL_PRIMARY_KEYS, schema),
-  foreignKeysSQL: (schema) => replaceSchema(MYSQL_FOREIGN_KEYS, schema),
-  enumsSQL: () => MYSQL_ENUMS
-};
-function getDialect(name = "postgres") {
-  switch (name) {
-    case "postgres":
-      return postgres;
-    case "mysql":
-      return mysql;
-    default:
-      throw new Error(`Dialect "${name}" is not yet supported. Currently only "postgres" and "mysql" are available.`);
-  }
-}
-
-// src/introspect.ts
-async function introspectDatabase(executor, dialect, config) {
-  const dbSchema = config.schema ?? (dialect.name === "mysql" ? void 0 : "public");
-  if (!dbSchema) {
-    throw new Error("MySQL requires a schema (database name). Pass it via config.schema or HandlerConfig.dbSchema.");
-  }
-  const excludeSet = new Set(config.excludeTables ?? ["_prisma_migrations"]);
-  const [tableRows, columnRows, pkRows, fkRows, enumRows] = await Promise.all([
-    executor.query(dialect.tablesSQL(dbSchema)).then(normalizeKeys),
-    executor.query(dialect.columnsSQL(dbSchema)).then(normalizeKeys),
-    executor.query(dialect.primaryKeysSQL(dbSchema)).then(normalizeKeys),
-    executor.query(dialect.foreignKeysSQL(dbSchema)).then(normalizeKeys),
-    executor.query(dialect.enumsSQL(dbSchema)).then(normalizeKeys)
-  ]);
-  const enumValues = /* @__PURE__ */ new Map();
-  for (const row of enumRows) {
-    if (!row.enum_name) continue;
-    if (!enumValues.has(row.enum_name)) enumValues.set(row.enum_name, []);
-    enumValues.get(row.enum_name).push(row.enum_value);
-  }
-  if (dialect.name === "mysql") {
-    for (const col of columnRows) {
-      const parsed = parseMySQLEnum(col.udt_name);
-      if (parsed) {
-        const enumKey = `${col.table_name}.${col.column_name}`;
-        enumValues.set(enumKey, parsed);
-      }
-    }
-  }
-  const pksByTable = /* @__PURE__ */ new Map();
-  for (const row of pkRows) {
-    if (!pksByTable.has(row.table_name)) pksByTable.set(row.table_name, /* @__PURE__ */ new Set());
-    pksByTable.get(row.table_name).add(row.column_name);
-  }
-  const userMap = config.tableNameMap ?? {};
-  const tableMap = /* @__PURE__ */ new Map();
-  const reverseTableMap = /* @__PURE__ */ new Map();
-  for (const [model, dbTable] of Object.entries(userMap)) {
-    tableMap.set(model, dbTable);
-    reverseTableMap.set(dbTable, model);
-  }
-  const dbTables = tableRows.map((r) => r.table_name).filter((t) => !excludeSet.has(t));
-  for (const dbTable of dbTables) {
-    if (reverseTableMap.has(dbTable)) continue;
-    const modelName = snakeToPascal(dbTable);
-    tableMap.set(modelName, dbTable);
-    reverseTableMap.set(dbTable, modelName);
-  }
-  const models = [];
-  const columnMaps = /* @__PURE__ */ new Map();
-  const enumTypeMaps = /* @__PURE__ */ new Map();
-  const columnsByTable = /* @__PURE__ */ new Map();
-  for (const row of columnRows) {
-    if (!columnsByTable.has(row.table_name)) columnsByTable.set(row.table_name, []);
-    columnsByTable.get(row.table_name).push(row);
-  }
-  for (const [modelName, dbTable] of tableMap) {
-    const cols = columnsByTable.get(dbTable) ?? [];
-    const pks = pksByTable.get(dbTable) ?? /* @__PURE__ */ new Set();
-    const colMap = /* @__PURE__ */ new Map();
-    const fields = [];
-    for (const col of cols) {
-      const fieldName = snakeToCamel(col.column_name);
-      colMap.set(fieldName, col.column_name);
-      let enumVals;
-      if (dialect.name === "mysql") {
-        enumVals = enumValues.get(`${col.table_name}.${col.column_name}`);
-      } else {
-        enumVals = enumValues.get(col.udt_name);
-      }
-      const type = enumVals ? `enum(${enumVals.join(",")})` : mapDataType(col.data_type, col.udt_name, dialect.name);
-      if (dialect.name === "postgres") {
-        if (enumVals) {
-          if (!enumTypeMaps.has(modelName)) enumTypeMaps.set(modelName, /* @__PURE__ */ new Map());
-          enumTypeMaps.get(modelName).set(fieldName, col.udt_name);
-        } else if (col.data_type === "jsonb" || col.udt_name === "jsonb" || col.data_type === "json" || col.udt_name === "json") {
-          if (!enumTypeMaps.has(modelName)) enumTypeMaps.set(modelName, /* @__PURE__ */ new Map());
-          const jsonType = col.data_type === "json" || col.udt_name === "json" ? "json" : "jsonb";
-          enumTypeMaps.get(modelName).set(fieldName, jsonType);
-        } else if (col.data_type.includes("timestamp") || col.udt_name === "timestamptz" || col.udt_name === "timestamp") {
-          if (!enumTypeMaps.has(modelName)) enumTypeMaps.set(modelName, /* @__PURE__ */ new Map());
-          enumTypeMaps.get(modelName).set(fieldName, col.udt_name);
-        }
-      }
-      fields.push({
-        name: fieldName,
-        type,
-        isRequired: col.is_nullable === "NO",
-        isId: pks.has(col.column_name),
-        hasDefault: col.column_default !== null
-      });
+// src/payload-topo.ts
+var RESERVED_KEYS = /* @__PURE__ */ new Set(["_alias", "_ref"]);
+function collectRefs(value, out) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    const ref = obj._ref;
+    if (typeof ref === "string") {
+      out.push(ref);
+      return;
     }
-    columnMaps.set(modelName, colMap);
-    models.push({ name: modelName, tableName: dbTable, fields });
+    for (const v of Object.values(obj)) collectRefs(v, out);
+    return;
   }
-  const edges = [];
-  for (const fk of fkRows) {
-    const fromModel = reverseTableMap.get(fk.from_table);
-    const toModel = reverseTableMap.get(fk.to_table);
-    if (!fromModel || !toModel) continue;
-    const fromColMap = columnMaps.get(fromModel);
-    const toColMap = columnMaps.get(toModel);
-    const localField = fromColMap ? reverseGet(fromColMap, fk.from_column) ?? fk.from_column : fk.from_column;
-    const foreignField = toColMap ? reverseGet(toColMap, fk.to_column) ?? fk.to_column : fk.to_column;
-    edges.push({
-      from: fromModel,
-      to: toModel,
-      localField,
-      foreignField,
-      nullable: fk.is_nullable === "YES"
-    });
+  if (Array.isArray(value)) {
+    for (const v of value) collectRefs(v, out);
   }
-  const relations = [];
-  for (const edge of edges) {
-    const fromDbTable = tableMap.get(edge.from);
-    const fromColMap = columnMaps.get(edge.from) ?? /* @__PURE__ */ new Map();
-    const fkDbCol = fromColMap.get(edge.localField) ?? edge.localField;
-    const fromPks = pksByTable.get(fromDbTable);
-    const isOneToOne = fromPks !== void 0 && fromPks.size === 1 && fromPks.has(fkDbCol);
-    relations.push({
-      parentModel: edge.to,
-      childModel: edge.from,
-      parentField: isOneToOne ? lowerFirst(edge.from) : pluralCamelCase(edge.from),
-      childField: edge.localField
-    });
-    relations.push({
-      parentModel: edge.from,
-      childModel: edge.to,
-      parentField: lowerFirst(edge.to),
-      childField: edge.localField
-    });
-  }
-  return {
-    schema: { models, edges, relations, scopeField: config.scopeField },
-    tableMap,
-    columnMaps,
-    enumTypeMaps
-  };
-}
-function snakeToPascal(str) {
-  return str.split("_").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-}
-function snakeToCamel(str) {
-  const pascal = snakeToPascal(str);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
-}
-function parseMySQLEnum(columnType) {
-  if (!columnType) return null;
-  const match = columnType.match(/^enum\((.+)\)$/i);
-  if (!match) return null;
-  return match[1].split(",").map((v) => v.trim().replace(/^'|'$/g, ""));
-}
-function mapDataType(dataType, udtName, dialectName) {
-  const dt = dataType.toLowerCase();
-  if (dialectName === "mysql" && dt === "tinyint" && udtName.toLowerCase().startsWith("tinyint(1)")) return "Boolean";
-  if (dt === "integer" || dt === "smallint" || dt === "bigint" || dt === "int" || dt === "mediumint" || dt === "tinyint") return "Int";
-  if (dt === "numeric" || dt === "real" || dt === "double precision" || dt === "float" || dt === "double" || dt === "decimal") return "Float";
-  if (dt === "boolean" || dt === "tinyint(1)") return "Boolean";
-  if (dt === "text" || dt === "character varying" || dt === "character" || dt === "varchar" || dt === "char" || dt === "mediumtext" || dt === "longtext" || dt === "tinytext") return "String";
-  if (dt === "timestamp with time zone" || dt === "timestamp without time zone" || dt === "date" || dt === "time" || dt === "datetime" || dt === "timestamp") return "DateTime";
-  if (dt === "json" || dt === "jsonb") return "Json";
-  if (dt === "uuid") return "String";
-  if (dt === "bytea" || dt === "blob" || dt === "mediumblob" || dt === "longblob" || dt === "tinyblob" || dt === "binary" || dt === "varbinary") return "Bytes";
-  if (dt === "user-defined" && dialectName === "postgres") return udtName;
-  if (dt === "enum" || dt === "set") return udtName;
-  return dataType;
-}
-function lowerFirst(str) {
-  return str.charAt(0).toLowerCase() + str.slice(1);
-}
-function pluralCamelCase(modelName) {
-  const camel = lowerFirst(modelName);
-  return pluralize(camel);
-}
-function pluralize(str) {
-  if (str.endsWith("s") || str.endsWith("x") || str.endsWith("z") || str.endsWith("ch") || str.endsWith("sh")) {
-    return str + "es";
-  }
-  if (str.endsWith("y") && str.length > 1 && !isVowel(str.charAt(str.length - 2))) {
-    return str.slice(0, -1) + "ies";
-  }
-  return str + "s";
-}
-function isVowel(ch) {
-  return "aeiou".includes(ch.toLowerCase());
 }
-function normalizeKeys(rows) {
-  return rows.map((row) => {
-    if (!row || typeof row !== "object") return row;
-    const normalized = {};
-    for (const [key, val] of Object.entries(row)) {
-      normalized[key.toLowerCase()] = val;
+function resolveRefs(value, aliasToTempId) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    const ref = obj._ref;
+    if (typeof ref === "string") {
+      const real = aliasToTempId[ref];
+      return real !== void 0 ? real : value;
     }
-    return normalized;
-  });
-}
-function reverseGet(map, dbName) {
-  for (const [key, val] of map) {
-    if (val === dbName) return key;
-  }
-  return null;
-}
-
-// src/create.ts
-import { randomUUID } from "crypto";
-async function createEntities(executor, dialect, tableMap, columnMaps, spec, _context, enumTypeMaps = /* @__PURE__ */ new Map(), schemaModels = []) {
-  const results = {};
-  for (const [model, entitySpec] of Object.entries(spec)) {
-    const dbTable = tableMap.get(model);
-    if (!dbTable) throw new Error(`Unknown model "${model}". Not found in database tables.`);
-    const colMap = columnMaps.get(model) ?? /* @__PURE__ */ new Map();
-    const enumTypeMap = enumTypeMaps.get(model) ?? /* @__PURE__ */ new Map();
-    const modelInfo = schemaModels.find((m) => m.name === model);
-    const idFields = modelInfo?.fields.filter((f) => f.isId) ?? [];
-    const pkField = idFields.find((f) => f.name.toLowerCase() === "id") ?? idFields[0];
-    const pkFieldName = pkField?.name ?? "id";
-    const pkFieldType = pkField?.type ?? "String";
-    if (entitySpec.batch && entitySpec.fields.length > 0) {
-      results[model] = await insertBatch(executor, dialect, dbTable, colMap, enumTypeMap, entitySpec.fields, pkFieldName, pkFieldType);
-    } else {
-      const created = [];
-      for (const fields of entitySpec.fields) {
-        const [record] = await insertOne(executor, dialect, dbTable, colMap, enumTypeMap, fields, pkFieldName, pkFieldType);
-        if (record) created.push(record);
-      }
-      results[model] = created;
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[k] = resolveRefs(v, aliasToTempId);
     }
+    return out;
   }
-  return results;
-}
-async function updateEntity(executor, dialect, tableMap, columnMaps, model, id, fields, enumTypeMaps = /* @__PURE__ */ new Map(), pkFieldName = "id") {
-  const dbTable = tableMap.get(model);
-  if (!dbTable) throw new Error(`Unknown model "${model}" for update.`);
-  const colMap = columnMaps.get(model) ?? /* @__PURE__ */ new Map();
-  const enumTypeMap = enumTypeMaps.get(model) ?? /* @__PURE__ */ new Map();
-  const setClauses = [];
-  const params = [];
-  let paramIdx = 1;
-  for (const [fieldName, value] of Object.entries(fields)) {
-    const dbCol = colMap.get(fieldName) ?? fieldName;
-    setClauses.push(`${dialect.quoteId(dbCol)} = ${castParam(dialect, paramIdx, enumTypeMap, fieldName)}`);
-    params.push(serializeValue(value, dialect));
-    paramIdx++;
-  }
-  const idCol = colMap.get(pkFieldName) ?? pkFieldName;
-  params.push(id);
-  const sql = `UPDATE ${dialect.quoteId(dbTable)} SET ${setClauses.join(", ")} WHERE ${dialect.quoteId(idCol)} = ${dialect.param(paramIdx)}`;
-  await executor.query(sql, params);
-}
-async function insertOne(executor, dialect, dbTable, colMap, enumTypeMap, fields, pkFieldName = "id", pkFieldType = "String") {
-  if (pkFieldName && fields[pkFieldName] === void 0 && pkFieldType === "String") {
-    fields = { ...fields, [pkFieldName]: randomUUID() };
-  }
-  const entries = Object.entries(fields);
-  if (entries.length === 0) {
-    const sql = `INSERT INTO ${dialect.quoteId(dbTable)} DEFAULT VALUES RETURNING *`;
-    return mapRowsBack(await executor.query(sql), colMap);
-  }
-  const dbCols = [];
-  const params = [];
-  const placeholders = [];
-  let paramIdx = 1;
-  for (const [fieldName, value] of entries) {
-    const dbCol = colMap.get(fieldName) ?? fieldName;
-    dbCols.push(dialect.quoteId(dbCol));
-    placeholders.push(castParam(dialect, paramIdx, enumTypeMap, fieldName));
-    params.push(serializeValue(value, dialect));
-    paramIdx++;
-  }
-  const colList = dbCols.join(", ");
-  const valList = placeholders.join(", ");
-  if (dialect.supportsReturning) {
-    const sql = `INSERT INTO ${dialect.quoteId(dbTable)} (${colList}) VALUES (${valList}) RETURNING *`;
-    return mapRowsBack(await executor.query(sql, params), colMap);
+  if (Array.isArray(value)) {
+    return value.map((v) => resolveRefs(v, aliasToTempId));
   }
-  await executor.query(
-    `INSERT INTO ${dialect.quoteId(dbTable)} (${colList}) VALUES (${valList})`,
-    params
-  );
-  const idCol = colMap.get(pkFieldName) ?? pkFieldName;
-  const id = fields[pkFieldName];
-  return mapRowsBack(
-    await executor.query(
-      `SELECT * FROM ${dialect.quoteId(dbTable)} WHERE ${dialect.quoteId(idCol)} = ${dialect.param(1)}`,
-      [id]
-    ),
-    colMap
-  );
+  return value;
 }
-async function insertBatch(executor, dialect, dbTable, colMap, enumTypeMap, fieldsArr, pkFieldName = "id", pkFieldType = "String") {
-  if (fieldsArr.length === 0) return [];
-  if (pkFieldName && pkFieldType === "String") {
-    fieldsArr = fieldsArr.map((fields) => {
-      if (fields[pkFieldName] === void 0) {
-        return { ...fields, [pkFieldName]: randomUUID() };
+function resolvePayloadTree(create) {
+  if (!create || typeof create !== "object" || Array.isArray(create)) {
+    throw Errors.invalidBody("`create` must be an object keyed by model name");
+  }
+  const rawEntries = [];
+  let counter = 0;
+  const aliases = {};
+  const aliasOwnerModel = {};
+  for (const [model, entities] of Object.entries(create)) {
+    if (!Array.isArray(entities)) {
+      throw Errors.invalidBody(
+        `\`create.${model}\` must be a list of entity objects, got ${typeof entities}`
+      );
+    }
+    for (const entity of entities) {
+      if (!entity || typeof entity !== "object" || Array.isArray(entity)) {
+        throw Errors.invalidBody(
+          `\`create.${model}\` entries must be objects, got ${Array.isArray(entity) ? "array" : typeof entity}`
+        );
       }
-      return fields;
-    });
-  }
-  const fieldNameSet = /* @__PURE__ */ new Set();
-  for (const fields of fieldsArr) {
-    for (const key of Object.keys(fields)) {
-      fieldNameSet.add(key);
+      const tempId = `__temp_${model}_${counter++}`;
+      const obj = entity;
+      const aliasRaw = obj._alias;
+      let alias = null;
+      if (typeof aliasRaw === "string") {
+        if (aliases[aliasRaw] !== void 0) {
+          throw Errors.invalidBody(`duplicate _alias "${aliasRaw}"`);
+        }
+        aliases[aliasRaw] = tempId;
+        aliasOwnerModel[aliasRaw] = model;
+        alias = aliasRaw;
+      } else if (aliasRaw !== void 0 && aliasRaw !== null) {
+        throw Errors.invalidBody('"_alias" must be a string');
+      }
+      rawEntries.push({ model, tempId, entity: obj, alias });
     }
   }
-  const fieldNames = [...fieldNameSet].sort();
-  if (fieldNames.length === 0) {
-    const allResults2 = [];
-    for (const fields of fieldsArr) {
-      const [record] = await insertOne(executor, dialect, dbTable, colMap, enumTypeMap, fields);
-      if (record) allResults2.push(record);
+  const depsByTempId = {};
+  const fieldsByTempId = {};
+  const modelByTempId = {};
+  for (const { model, tempId, entity } of rawEntries) {
+    const deps = [];
+    const cleaned = {};
+    for (const [key, value] of Object.entries(entity)) {
+      if (RESERVED_KEYS.has(key)) continue;
+      collectRefs(value, deps);
+      cleaned[key] = resolveRefs(value, aliases);
+    }
+    const unknowns = deps.filter((a) => aliases[a] === void 0);
+    if (unknowns.length > 0) {
+      const sorted = Array.from(new Set(unknowns)).sort();
+      throw Errors.invalidBody(
+        `\`create.${model}\` references unknown alias(es): ${sorted.join(", ")}`
+      );
     }
-    return allResults2;
-  }
-  const dbCols = fieldNames.map((f) => dialect.quoteId(colMap.get(f) ?? f));
-  const colList = dbCols.join(", ");
-  const MAX_PARAMS = 32e3;
-  const chunkSize = Math.max(1, Math.floor(MAX_PARAMS / fieldNames.length));
-  const allResults = [];
-  for (let offset = 0; offset < fieldsArr.length; offset += chunkSize) {
-    const chunk = fieldsArr.slice(offset, offset + chunkSize);
-    const params = [];
-    const valueTuples = [];
-    let paramIdx = 1;
-    for (const fields of chunk) {
-      const placeholders = [];
-      for (const fieldName of fieldNames) {
-        placeholders.push(castParam(dialect, paramIdx, enumTypeMap, fieldName));
-        params.push(serializeValue(fields[fieldName], dialect));
-        paramIdx++;
+    depsByTempId[tempId] = deps;
+    fieldsByTempId[tempId] = cleaned;
+    modelByTempId[tempId] = model;
+  }
+  const inDegree = {};
+  for (const { tempId } of rawEntries) inDegree[tempId] = 0;
+  const edges = {};
+  for (const [tempId, deps] of Object.entries(depsByTempId)) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const depAlias of deps) {
+      const depTempId = aliases[depAlias];
+      if (depTempId === tempId || seen.has(depTempId)) continue;
+      seen.add(depTempId);
+      (edges[depTempId] ??= []).push(tempId);
+      inDegree[tempId] = (inDegree[tempId] ?? 0) + 1;
+    }
+  }
+  const payloadOrder = {};
+  rawEntries.forEach((e, i) => {
+    payloadOrder[e.tempId] = i;
+  });
+  const ready = Object.keys(inDegree).filter((t) => inDegree[t] === 0).sort((a, b) => payloadOrder[a] - payloadOrder[b]);
+  const sortedTempIds = [];
+  while (ready.length > 0) {
+    const tid = ready.shift();
+    sortedTempIds.push(tid);
+    for (const next of edges[tid] ?? []) {
+      inDegree[next] = (inDegree[next] ?? 0) - 1;
+      if (inDegree[next] === 0) ready.push(next);
+    }
+    ready.sort((a, b) => payloadOrder[a] - payloadOrder[b]);
+  }
+  if (sortedTempIds.length !== rawEntries.length) {
+    const cycle = Object.entries(inDegree).filter(([, deg]) => deg > 0).map(([tid]) => tid).sort((a, b) => payloadOrder[a] - payloadOrder[b]);
+    const cycleModels = cycle.map((t) => modelByTempId[t]).join(", ");
+    throw Errors.invalidBody(`cycle detected in _alias/_ref graph: ${cycleModels}`);
+  }
+  const aliasDependencies = {};
+  for (const [alias, tempId] of Object.entries(aliases)) {
+    aliasDependencies[alias] = [...depsByTempId[tempId] ?? []];
+  }
+  const ops = sortedTempIds.map((tid) => ({
+    model: modelByTempId[tid],
+    fields: fieldsByTempId[tid],
+    tempId: tid
+  }));
+  return { ops, aliases, aliasOwnerModel, aliasDependencies };
+}
+function computeTeardownOrder(refs, aliasDependencies, aliasOwnerModel) {
+  const models = Object.keys(refs);
+  if (!aliasDependencies || !aliasOwnerModel || Object.keys(aliasDependencies).length === 0) {
+    return [...models].reverse();
+  }
+  const modelDeps = {};
+  for (const m of models) modelDeps[m] = /* @__PURE__ */ new Set();
+  for (const [alias, deps] of Object.entries(aliasDependencies)) {
+    const owner = aliasOwnerModel[alias];
+    if (!owner || !(owner in modelDeps)) continue;
+    for (const depAlias of deps) {
+      const depModel = aliasOwnerModel[depAlias];
+      if (!depModel || depModel === owner) continue;
+      if (depModel in modelDeps) {
+        modelDeps[owner].add(depModel);
       }
-      valueTuples.push(`(${placeholders.join(", ")})`);
-    }
-    const valList = valueTuples.join(", ");
-    if (dialect.supportsReturning) {
-      const sql = `INSERT INTO ${dialect.quoteId(dbTable)} (${colList}) VALUES ${valList} RETURNING *`;
-      allResults.push(...mapRowsBack(await executor.query(sql, params), colMap));
-    } else {
-      await executor.query(
-        `INSERT INTO ${dialect.quoteId(dbTable)} (${colList}) VALUES ${valList}`,
-        params
-      );
     }
   }
-  return allResults;
-}
-function mapRowsBack(rows, colMap) {
-  if (colMap.size === 0) return rows;
-  const reverse = /* @__PURE__ */ new Map();
-  for (const [fieldName, dbCol] of colMap) {
-    reverse.set(dbCol, fieldName);
-  }
-  return rows.map((row) => {
-    const mapped = {};
-    for (const [key, value] of Object.entries(row)) {
-      const fieldName = reverse.get(key) ?? key;
-      mapped[fieldName] = value;
+  const inDegree = {};
+  for (const m of models) inDegree[m] = 0;
+  const adj = {};
+  for (const [owner, deps] of Object.entries(modelDeps)) {
+    for (const depModel of deps) {
+      ;
+      (adj[depModel] ??= []).push(owner);
+      inDegree[owner] = (inDegree[owner] ?? 0) + 1;
     }
-    return mapped;
-  });
-}
-function castParam(dialect, paramIdx, enumTypeMap, fieldName) {
-  const placeholder = dialect.param(paramIdx);
-  if (dialect.name === "postgres") {
-    const enumType = enumTypeMap.get(fieldName);
-    if (enumType) return `${placeholder}::${dialect.quoteId(enumType)}`;
   }
-  return placeholder;
-}
-var MYSQL_DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
-function serializeValue(value, dialect) {
-  if (value === null || value === void 0) return null;
-  if (typeof value === "object" && !(value instanceof Date)) {
-    if (Array.isArray(value)) return value;
-    return JSON.stringify(value);
-  }
-  if (typeof value === "string" && dialect.name === "mysql") {
-    if (MYSQL_DATETIME_RE.test(value)) {
-      return value.replace("T", " ").replace("Z", "").replace(/\.\d+$/, "");
+  const payloadOrder = {};
+  models.forEach((m, i) => {
+    payloadOrder[m] = i;
+  });
+  const ready = models.filter((m) => inDegree[m] === 0).sort((a, b) => payloadOrder[a] - payloadOrder[b]);
+  const upOrder = [];
+  while (ready.length > 0) {
+    const m = ready.shift();
+    upOrder.push(m);
+    for (const next of adj[m] ?? []) {
+      inDegree[next] = (inDegree[next] ?? 0) - 1;
+      if (inDegree[next] === 0) ready.push(next);
     }
+    ready.sort((a, b) => payloadOrder[a] - payloadOrder[b]);
   }
-  return value;
+  if (upOrder.length !== models.length) {
+    return [...models].reverse();
+  }
+  return [...upOrder].reverse();
 }
 
-// src/teardown.ts
-function computeTeardownOrder(schema) {
-  let scopeRootModel = null;
-  for (const edge of schema.edges) {
-    if (edge.localField.toLowerCase() === schema.scopeField.toLowerCase() && edge.to !== edge.from) {
-      scopeRootModel = edge.to;
-      break;
-    }
+// src/schema.ts
+function fieldTypeFromZod(schema) {
+  return classifyZod(unwrap(schema));
+}
+function getDef(schema) {
+  const def = schema._def;
+  return def && typeof def === "object" ? def : {};
+}
+function unwrap(schema) {
+  let current = schema;
+  for (let i = 0; i < 16; i++) {
+    const def = getDef(current);
+    const wrapped = wrappedSchemaFrom(def);
+    if (!wrapped) return current;
+    current = wrapped;
+  }
+  return current;
+}
+function wrappedSchemaFrom(def) {
+  const candidate = def.innerType ?? def.schema;
+  if (!candidate) return null;
+  const tn = def.typeName;
+  if (tn === "ZodOptional" || tn === "ZodNullable" || tn === "ZodDefault" || tn === "ZodCatch" || tn === "ZodBranded" || tn === "ZodReadonly" || tn === "ZodEffects" || tn === "ZodPipeline" || tn === "ZodLazy" || // Zod v4 uses `type` instead of `typeName`.
+  def.type === "optional" || def.type === "nullable" || def.type === "default" || def.type === "catch" || def.type === "readonly" || def.type === "pipe" || def.type === "lazy") {
+    return candidate;
   }
-  const scopeFieldByModel = /* @__PURE__ */ new Map();
-  if (scopeRootModel) {
-    for (const edge of schema.edges) {
-      if (edge.to === scopeRootModel && edge.from !== scopeRootModel) {
-        scopeFieldByModel.set(edge.from, edge.localField);
+  return null;
+}
+function classifyZod(schema) {
+  const def = getDef(schema);
+  const name = (def.typeName ?? def.type ?? "").toString();
+  if (name === "ZodString" || name === "string") return "string";
+  if (name === "ZodNumber" || name === "number") {
+    return "number";
+  }
+  if (name === "ZodBigInt" || name === "bigint") return "integer";
+  if (name === "ZodBoolean" || name === "boolean") return "boolean";
+  if (name === "ZodDate" || name === "date") return "timestamp";
+  if (name === "ZodEnum" || name === "enum") return "string";
+  if (name === "ZodNativeEnum" || name === "nativeEnum") return "string";
+  if (name === "ZodLiteral" || name === "literal") return "string";
+  if (name === "ZodArray" || name === "array" || name === "ZodObject" || name === "object" || name === "ZodRecord" || name === "record" || name === "ZodTuple" || name === "tuple" || name === "ZodMap" || name === "map" || name === "ZodSet" || name === "set" || name === "ZodAny" || name === "any" || name === "ZodUnknown" || name === "unknown") {
+    return "json";
+  }
+  return "string";
+}
+function isOptional(schema) {
+  const def = getDef(schema);
+  const tn = def.typeName ?? def.type;
+  if (tn === "ZodOptional" || tn === "optional") return true;
+  if (tn === "ZodDefault" || tn === "default") return true;
+  if (tn === "ZodNullable" || tn === "nullable") {
+    return false;
+  }
+  const inner = wrappedSchemaFrom(def);
+  if (inner) return isOptional(inner);
+  return false;
+}
+function hasDefault(schema) {
+  const def = getDef(schema);
+  const tn = def.typeName ?? def.type;
+  if (tn === "ZodDefault" || tn === "default") return true;
+  const inner = wrappedSchemaFrom(def);
+  if (inner) return hasDefault(inner);
+  return false;
+}
+function camelToSnake(name) {
+  let out = "";
+  for (let i = 0; i < name.length; i++) {
+    const ch = name.charAt(i);
+    if (ch >= "A" && ch <= "Z" && i > 0) {
+      const prev = name.charAt(i - 1);
+      if (!(prev >= "A" && prev <= "Z")) {
+        out += "_";
       }
     }
+    out += ch.toLowerCase();
   }
-  const modelNames = schema.models.map((m) => m.name);
-  const { sorted, cycles } = topoSort(modelNames, schema.edges);
-  const components = [];
-  const nodeToComp = /* @__PURE__ */ new Map();
-  for (const cycle of cycles) {
-    const idx = components.length;
-    components.push(cycle);
-    for (const node of cycle) nodeToComp.set(node, idx);
-  }
-  for (const node of sorted) {
-    nodeToComp.set(node, components.length);
-    components.push([node]);
-  }
-  const condAdj = /* @__PURE__ */ new Map();
-  const condInDeg = /* @__PURE__ */ new Map();
-  for (let i = 0; i < components.length; i++) {
-    condAdj.set(i, /* @__PURE__ */ new Set());
-    condInDeg.set(i, 0);
-  }
-  for (const edge of schema.edges) {
-    if (edge.from === edge.to) continue;
-    const fc = nodeToComp.get(edge.from);
-    const tc = nodeToComp.get(edge.to);
-    if (fc !== void 0 && tc !== void 0 && fc !== tc && !condAdj.get(tc).has(fc)) {
-      condAdj.get(tc).add(fc);
-      condInDeg.set(fc, (condInDeg.get(fc) ?? 0) + 1);
-    }
-  }
-  const condQueue = [];
-  for (const [idx, deg] of condInDeg) {
-    if (deg === 0) condQueue.push(idx);
-  }
-  const condOrder = [];
-  while (condQueue.length > 0) {
-    condQueue.sort();
-    const idx = condQueue.shift();
-    condOrder.push(idx);
-    for (const neighbor of condAdj.get(idx)) {
-      const nd = (condInDeg.get(neighbor) ?? 1) - 1;
-      condInDeg.set(neighbor, nd);
-      if (nd === 0) condQueue.push(neighbor);
+  return out;
+}
+function objectShape(schema) {
+  const def = getDef(schema);
+  const tn = def.typeName ?? def.type;
+  if (tn !== "ZodObject" && tn !== "object") return null;
+  const shape = def.shape;
+  if (typeof shape === "function") {
+    try {
+      const evaluated = shape();
+      if (evaluated && typeof evaluated === "object") return evaluated;
+    } catch {
+      return null;
     }
   }
-  const order = [];
-  for (const compIdx of [...condOrder].reverse()) {
-    for (const model of components[compIdx]) {
-      if (model !== scopeRootModel) {
-        order.push(model);
-      }
-    }
+  if (shape && typeof shape === "object") {
+    return shape;
   }
-  return { order, scopeRootModel, cycles, scopeFieldByModel };
+  return null;
 }
-async function teardown(executor, dialect, tableMap, columnMaps, schema, scopeValue, refs, skipModels) {
-  const { order, scopeRootModel, cycles, scopeFieldByModel } = computeTeardownOrder(schema);
-  await executor.transaction(async (tx) => {
-    for (const cycle of cycles) {
-      const edge = findDeferrableEdge(cycle, schema.edges);
-      if (!edge) continue;
-      const scopeFK = scopeFieldByModel.get(edge.from);
-      if (!scopeFK) continue;
-      const dbTable2 = tableMap.get(edge.from);
-      if (!dbTable2) continue;
-      const colMap2 = columnMaps.get(edge.from) ?? /* @__PURE__ */ new Map();
-      const dbFKCol = colMap2.get(edge.localField) ?? edge.localField;
-      const dbScopeCol = colMap2.get(scopeFK) ?? scopeFK;
-      await tx.query(
-        `UPDATE ${dialect.quoteId(dbTable2)} SET ${dialect.quoteId(dbFKCol)} = NULL WHERE ${dialect.quoteId(dbScopeCol)} = ${dialect.param(1)}`,
-        [scopeValue]
-      );
-    }
-    for (const model of order) {
-      if (skipModels?.has(model)) continue;
-      await deleteModel(tx, dialect, tableMap, columnMaps, model, scopeValue, scopeFieldByModel, refs, schema);
-    }
-    if (!scopeRootModel || skipModels?.has(scopeRootModel)) return;
-    const dbTable = tableMap.get(scopeRootModel);
-    if (!dbTable) return;
-    const colMap = columnMaps.get(scopeRootModel) ?? /* @__PURE__ */ new Map();
-    const rootModelInfo = schema.models.find((m) => m.name === scopeRootModel);
-    const rootIdFields = rootModelInfo?.fields.filter((f) => f.isId) ?? [];
-    const rootPkFieldName = (rootIdFields.find((f) => f.name.toLowerCase() === "id") ?? rootIdFields[0])?.name ?? "id";
-    const idCol = colMap.get(rootPkFieldName) ?? rootPkFieldName;
-    await tx.query(
-      `DELETE FROM ${dialect.quoteId(dbTable)} WHERE ${dialect.quoteId(idCol)} = ${dialect.param(1)}`,
-      [scopeValue]
-    );
-  });
+function modelToFields(inputSchema) {
+  const fields = [
+    { name: "id", type: "string", isRequired: false, isId: true, hasDefault: true }
+  ];
+  const shape = objectShape(unwrap(inputSchema));
+  if (!shape) return fields;
+  for (const [name, value] of Object.entries(shape)) {
+    const optional = isOptional(value);
+    const defaulted = hasDefault(value);
+    fields.push({
+      name,
+      type: fieldTypeFromZod(value),
+      isRequired: !optional && !defaulted,
+      isId: false,
+      hasDefault: defaulted
+    });
+  }
+  return fields;
 }
-async function deleteModel(tx, dialect, tableMap, columnMaps, model, scopeValue, scopeFieldByModel, refs, schema) {
-  const dbTable = tableMap.get(model);
-  if (!dbTable) return;
-  const colMap = columnMaps.get(model) ?? /* @__PURE__ */ new Map();
-  const modelInfo = schema.models.find((m) => m.name === model);
-  const idFields = modelInfo?.fields.filter((f) => f.isId) ?? [];
-  const pkFieldName = (idFields.find((f) => f.name.toLowerCase() === "id") ?? idFields[0])?.name ?? "id";
-  const scopeFK = scopeFieldByModel.get(model);
-  if (scopeFK) {
-    const dbCol = colMap.get(scopeFK) ?? scopeFK;
-    await tx.query(
-      `DELETE FROM ${dialect.quoteId(dbTable)} WHERE ${dialect.quoteId(dbCol)} = ${dialect.param(1)}`,
-      [scopeValue]
-    );
-  } else if (refs?.[model]) {
-    const ids = refs[model].map((r) => r[pkFieldName]).filter((id) => id != null);
-    if (ids.length > 0) {
-      const idCol = colMap.get(pkFieldName) ?? pkFieldName;
-      const placeholders = ids.map((_, i) => dialect.param(i + 1)).join(", ");
-      await tx.query(
-        `DELETE FROM ${dialect.quoteId(dbTable)} WHERE ${dialect.quoteId(idCol)} IN (${placeholders})`,
-        ids
+function buildSchemaFromFactories(factories, scopeField) {
+  const models = [];
+  for (const [entity, factory] of Object.entries(factories)) {
+    if (!factory.inputSchema) {
+      throw new Error(
+        `Factory "${entity}" has no inputSchema. Every factory must declare a Zod schema in defineFactory({ ..., inputSchema }).`
       );
     }
+    models.push({
+      name: entity,
+      tableName: camelToSnake(entity),
+      fields: modelToFields(factory.inputSchema)
+    });
   }
+  return { models, edges: [], relations: [], scopeField };
+}
+function schemaToWire(schema) {
+  return {
+    models: schema.models.map((m) => ({
+      name: m.name,
+      tableName: m.tableName,
+      fields: m.fields.map((f) => ({
+        name: f.name,
+        type: f.type,
+        isRequired: f.isRequired,
+        isId: f.isId,
+        hasDefault: f.hasDefault
+      }))
+    })),
+    edges: schema.edges.map((e) => ({
+      from: e.from,
+      to: e.to,
+      localField: e.localField,
+      foreignField: e.foreignField,
+      nullable: e.nullable
+    })),
+    relations: schema.relations.map((r) => ({
+      parentModel: r.parentModel,
+      childModel: r.childModel,
+      parentField: r.parentField,
+      childField: r.childField
+    })),
+    scopeField: schema.scopeField
+  };
 }
 
 // src/handler.ts
@@ -852,10 +463,15 @@ function resolveTokens(value, testRunId, index) {
         const parts = cycle[1].split(",").map((p) => p.trim().replace(/^['"]|['"]$/g, ""));
         return parts.length ? parts[index % parts.length] : "";
       }
-      throw new AutonomaError(`Unresolved token: {{${token}}}`, "UNRESOLVED_TOKEN", 400);
+      throw new AutonomaError(
+        `Unresolved token: {{${token}}}`,
+        "UNRESOLVED_TOKEN",
+        400
+      );
     });
   }
-  if (Array.isArray(value)) return value.map((v) => resolveTokens(v, testRunId, index));
+  if (Array.isArray(value))
+    return value.map((v) => resolveTokens(v, testRunId, index));
   if (value && typeof value === "object") {
     const out = {};
     for (const [k, v] of Object.entries(value)) {
@@ -865,21 +481,7 @@ function resolveTokens(value, testRunId, index) {
   }
   return value;
 }
-var introspectionCache = /* @__PURE__ */ new WeakMap();
-async function getIntrospection(config) {
-  let cached = introspectionCache.get(config);
-  if (cached) return cached;
-  const dialect = getDialect(config.dialect);
-  cached = await introspectDatabase(config.executor, dialect, {
-    scopeField: config.scopeField,
-    schema: config.dbSchema,
-    tableNameMap: config.tableNameMap,
-    excludeTables: config.excludeTables
-  });
-  introspectionCache.set(config, cached);
-  return cached;
-}
-var PROTOCOL_VERSION = "1.0";
+var PROTOCOL_VERSION = true ? "1.0" : "1.0";
 function buildSdkMeta(config) {
   return {
     version: PROTOCOL_VERSION,
@@ -900,7 +502,9 @@ async function handleRequest(config, req) {
       );
     }
     if (!config.allowProduction && process.env.NODE_ENV === "production") {
-      throw Errors.productionBlocked();
+      throw Errors.productionBlocked(
+        "allowProduction not set and NODE_ENV === 'production'. if you want to change this, set allowProduction explicitly."
+      );
     }
     const signature = req.headers["x-signature"] ?? req.headers["X-Signature"] ?? "";
     if (!verifySignature(req.body, signature, config.sharedSecret)) {
@@ -913,7 +517,10 @@ async function handleRequest(config, req) {
       throw Errors.invalidBody("invalid JSON");
     }
     const action = body.action;
-    if (!action) throw Errors.invalidBody("missing action");
+    if (!action)
+      throw Errors.invalidBody(
+        'missing action. expected one of "discover", "up" or "down"'
+      );
     switch (action) {
       case "discover":
         return await handleDiscover(config);
@@ -926,134 +533,96 @@ async function handleRequest(config, req) {
     }
   } catch (err) {
     if (err instanceof AutonomaError) {
-      return { status: err.status, body: { error: err.message, code: err.code } };
+      return {
+        status: err.status,
+        body: { error: err.message, code: err.code }
+      };
     }
     const message = err instanceof Error ? err.message : "Internal error";
     return { status: 500, body: { error: message, code: "INTERNAL_ERROR" } };
   }
 }
 async function handleDiscover(config) {
-  const { schema } = await getIntrospection(config);
-  return { status: 200, body: { ...buildSdkMeta(config), schema } };
+  const schema = buildSchemaFromFactories(
+    config.factories ?? {},
+    config.scopeField
+  );
+  return {
+    status: 200,
+    body: { ...buildSdkMeta(config), schema: schemaToWire(schema) }
+  };
 }
 async function handleUp(config, body) {
   const create = body.create;
   if (!create) throw Errors.invalidBody('missing "create" in request body');
-  const testRunId = body.testRunId ?? crypto.randomUUID();
-  const { schema, tableMap, columnMaps, enumTypeMaps } = await getIntrospection(config);
-  const dialect = getDialect(config.dialect);
-  const tree = resolveTree(create, schema);
+  const testRunId = body.testRunId ?? randomUUID();
+  const factories = config.factories ?? {};
+  if (Object.keys(factories).length === 0) {
+    throw Errors.invalidBody(
+      "no factories registered \u2014 every model in `create` must have a factory."
+    );
+  }
+  const tree = resolvePayloadTree(create);
   const refs = {};
   const idMap = /* @__PURE__ */ new Map();
-  await config.executor.transaction(async (tx) => {
-    let i = 0;
-    while (i < tree.ops.length) {
-      const op = tree.ops[i];
-      const model = op.model;
-      const batch = [op];
-      while (i + 1 < tree.ops.length && tree.ops[i + 1].model === model && tree.ops[i + 1].batch === op.batch) {
-        i++;
-        batch.push(tree.ops[i]);
-      }
-      const modelInfo = schema.models.find((m) => m.name === model);
-      const idFields = modelInfo?.fields.filter((f) => f.isId) ?? [];
-      const pkField = idFields.find((f) => f.name.toLowerCase() === "id") ?? idFields[0];
-      const pkFieldName = pkField?.name ?? "id";
-      const resolvedFields = batch.map((b, batchIndex) => {
-        const fields = resolveTokens({ ...b.fields }, testRunId, batchIndex);
-        for (const [key, value] of Object.entries(fields)) {
-          if (typeof value === "string" && value.startsWith("__temp_")) {
-            const realId = idMap.get(value);
-            if (realId) fields[key] = realId;
-          }
-        }
-        const scopeEdge = schema.edges.find(
-          (e) => e.from === model && e.localField.replace(/_/g, "").toLowerCase() === schema.scopeField.replace(/_/g, "").toLowerCase() && e.from !== e.to
-        );
-        if (scopeEdge && !(scopeEdge.localField in fields)) {
-          const scopeVal = detectScopeValue(refs, schema.scopeField);
-          if (scopeVal) fields[scopeEdge.localField] = scopeVal;
-        }
-        if (modelInfo) {
-          for (const field of modelInfo.fields) {
-            if (field.isRequired && !field.hasDefault && !field.isId && !(field.name in fields)) {
-              if (field.type === "DateTime") {
-                fields[field.name] = /* @__PURE__ */ new Date();
-              }
-            }
-          }
-        }
-        return fields;
-      });
-      let records;
-      const factory = config.factories?.[model];
-      if (factory) {
-        records = [];
-        for (const fields of resolvedFields) {
-          const factoryCtx = {
-            refs,
-            executor: tx,
-            scenarioName: testRunId,
-            testRunId
-          };
-          const record = await factory.create(fields, factoryCtx);
-          if (record[pkFieldName] == null) {
-            throw new AutonomaError(
-              `Factory for "${model}" must return a record with "${pkFieldName}"`,
-              "FACTORY_MISSING_PK",
-              500
-            );
-          }
-          records.push(record);
-        }
-      } else {
-        const spec = {
-          [model]: { count: resolvedFields.length, fields: resolvedFields, batch: op.batch }
-        };
-        const context = { testRunId, refs };
-        const created = await createEntities(tx, dialect, tableMap, columnMaps, spec, context, enumTypeMaps, schema.models);
-        records = created[model] ?? [];
-      }
-      if (!refs[model]) refs[model] = [];
-      refs[model].push(...records);
-      for (let j = 0; j < batch.length; j++) {
-        const record = records[j];
-        if (record) {
-          const recordId = record[pkFieldName];
-          if (recordId != null) {
-            idMap.set(batch[j].tempId, recordId);
-          }
-        }
-      }
-      i++;
+  const modelIndex = {};
+  for (const op of tree.ops) {
+    const model = op.model;
+    const factory = factories[model];
+    if (!factory) {
+      throw Errors.invalidBody(
+        `no factory registered for model "${model}". Register one with \`defineFactory(...)\` and add it to HandlerConfig.factories.`
+      );
     }
-    for (const deferred of tree.deferredUpdates) {
-      const realTargetId = idMap.get(deferred.targetTempId);
-      const refTempId = tree.aliases.get(deferred.refAlias);
-      const realRefId = refTempId ? idMap.get(refTempId) : void 0;
-      if (!realTargetId || !realRefId) {
-        throw new Error(
-          `_ref "${deferred.refAlias}" could not be resolved. Ensure the referenced node has _alias defined in the scenario.`
-        );
-      }
-      const deferredModelInfo = schema.models.find((m) => m.name === deferred.model);
-      const deferredIdFields = deferredModelInfo?.fields.filter((f) => f.isId) ?? [];
-      const deferredPkFieldName = (deferredIdFields.find((f) => f.name.toLowerCase() === "id") ?? deferredIdFields[0])?.name ?? "id";
-      await updateEntity(tx, dialect, tableMap, columnMaps, deferred.model, String(realTargetId), { [deferred.field]: realRefId }, enumTypeMaps, deferredPkFieldName);
+    const idx = modelIndex[model] ?? 0;
+    modelIndex[model] = idx + 1;
+    const tokenResolved = resolveTokens(op.fields, testRunId, idx);
+    const swapped = swapTempIds(tokenResolved, idMap);
+    const parsed = factory.inputSchema.safeParse(swapped);
+    if (!parsed.success) {
+      const formatted = parsed.error.issues.map(
+        (i) => `${i.path.join(".") || "<root>"}: ${i.message}`
+      ).join("; ");
+      throw new AutonomaError(
+        `Invalid input for "${model}": ${formatted}`,
+        "INTERNAL_ERROR",
+        500
+      );
     }
-  });
-  const scopeValue = detectScopeValue(refs, schema.scopeField) ?? testRunId;
-  const firstUser = findFirstUser(refs);
-  let auth = await config.auth(firstUser, { scopeValue, refs });
+    const ctx = { refs, scenarioName: testRunId, testRunId };
+    const recordRaw = await factory.create(parsed.data, ctx);
+    const record = normaliseRecord(recordRaw);
+    if (!record || record.id == null) {
+      throw new AutonomaError(
+        `Factory for "${model}" must return a record with "id"`,
+        "FACTORY_MISSING_PK",
+        500
+      );
+    }
+    (refs[model] ??= []).push(record);
+    idMap.set(op.tempId, record.id);
+  }
+  const authUser = findFirstUser(refs);
+  const scopeValue = detectScopeValue(refs, config.scopeField) ?? testRunId;
+  let auth = await config.auth(authUser, { scopeValue, refs });
   if (config.afterUp) {
     const hookCtx = { scenarioName: scopeValue, refs };
     auth = await config.afterUp(hookCtx, auth);
   }
   const refsToken = signRefs(
-    { refs, testRunId: scopeValue, environment: "" },
+    {
+      refs,
+      testRunId: scopeValue,
+      environment: "",
+      aliasDependencies: tree.aliasDependencies,
+      aliasOwnerModel: tree.aliasOwnerModel
+    },
     config.signingSecret
   );
-  return { status: 200, body: { ...buildSdkMeta(config), auth, refs, refsToken } };
+  return {
+    status: 200,
+    body: { ...buildSdkMeta(config), auth, refs, refsToken }
+  };
 }
 async function handleDown(config, body) {
   const refsToken = body.refsToken;
@@ -1065,40 +634,61 @@ async function handleDown(config, body) {
     const message = err instanceof Error ? err.message : "invalid token";
     throw Errors.invalidRefsToken(message);
   }
-  const { schema, tableMap, columnMaps } = await getIntrospection(config);
-  const dialect = getDialect(config.dialect);
+  const refs = payload.refs ?? {};
+  const testRunId = payload.testRunId ?? "";
   if (config.beforeDown) {
-    const hookCtx = { scenarioName: payload.testRunId, refs: payload.refs ?? {} };
+    const hookCtx = { scenarioName: testRunId, refs };
     await config.beforeDown(hookCtx);
   }
-  const factoryTeardownModels = /* @__PURE__ */ new Set();
-  if (config.factories) {
-    for (const [model, factory] of Object.entries(config.factories)) {
-      if (factory.teardown) {
-        factoryTeardownModels.add(model);
+  const factories = config.factories ?? {};
+  const teardownOrder = computeTeardownOrder(
+    refs,
+    payload.aliasDependencies,
+    payload.aliasOwnerModel
+  );
+  for (const model of teardownOrder) {
+    const factory = factories[model];
+    if (!factory || !factory.teardown) continue;
+    const records = refs[model] ?? [];
+    const ctx = { refs, scenarioName: testRunId, testRunId };
+    for (const record of [...records].reverse()) {
+      let teardownInput = record;
+      if (factory.refSchema) {
+        const parsed = factory.refSchema.safeParse(record);
+        if (!parsed.success) {
+          const formatted = parsed.error.issues.map(
+            (i) => `${i.path.join(".") || "<root>"}: ${i.message}`
+          ).join("; ");
+          throw new AutonomaError(
+            `Invalid teardown record for "${model}": ${formatted}`,
+            "INTERNAL_ERROR",
+            500
+          );
+        }
+        teardownInput = parsed.data;
       }
+      await factory.teardown(teardownInput, ctx);
     }
   }
-  if (factoryTeardownModels.size > 0) {
-    const { order, scopeRootModel } = computeTeardownOrder(schema);
-    const fullOrder = scopeRootModel ? [...order, scopeRootModel] : order;
-    const refs = payload.refs ?? {};
-    for (const model of [...fullOrder].reverse()) {
-      if (!factoryTeardownModels.has(model)) continue;
-      const records = refs[model] ?? [];
-      const factoryCtx = {
-        refs,
-        executor: config.executor,
-        scenarioName: payload.testRunId,
-        testRunId: payload.testRunId
-      };
-      for (const record of [...records].reverse()) {
-        await config.factories[model].teardown(record, factoryCtx);
-      }
+  return { status: 200, body: { ...buildSdkMeta(config), ok: true } };
+}
+function swapTempIds(value, idMap) {
+  if (typeof value === "string" && value.startsWith("__temp_")) {
+    return idMap.get(value) ?? value;
+  }
+  if (Array.isArray(value)) return value.map((v) => swapTempIds(v, idMap));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = swapTempIds(v, idMap);
     }
+    return out;
   }
-  await teardown(config.executor, dialect, tableMap, columnMaps, schema, payload.testRunId, payload.refs, factoryTeardownModels);
-  return { status: 200, body: { ...buildSdkMeta(config), ok: true } };
+  return value;
+}
+function normaliseRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
 }
 function findFirstUser(refs) {
   for (const [model, records] of Object.entries(refs)) {
@@ -1122,6 +712,12 @@ function detectScopeValue(refs, scopeField) {
   }
   return null;
 }
+function randomUUID() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `run-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
 
 // src/fingerprint.ts
 import { createHash } from "crypto";
@@ -1143,17 +739,14 @@ function sortReplacer(_key, value) {
 }
 
 // src/check.ts
-async function checkScenario(executor, scenario, options) {
+async function checkScenario(factories, scenario, options) {
   const sharedSecret = options?.sharedSecret ?? "autonoma-check-shared";
   const signingSecret = options?.signingSecret ?? "autonoma-check-signing";
   const config = {
-    executor,
     scopeField: options?.scopeField ?? "organizationId",
-    dialect: options?.dialect,
-    dbSchema: options?.dbSchema,
-    tableNameMap: options?.tableNameMap,
     sharedSecret,
     signingSecret,
+    factories,
     auth: options?.auth ?? (async () => ({ headers: { Authorization: "Bearer check-token" } }))
   };
   const upBody = JSON.stringify({ action: "up", create: scenario.create });
@@ -1169,7 +762,7 @@ async function checkScenario(executor, scenario, options) {
     return {
       valid: false,
       phase: "up",
-      errors: [{ phase: "up", message: errorMsg, fix: suggestFix(errorMsg) }],
+      errors: [{ phase: "up", message: errorMsg }],
       timing: { upMs, downMs: 0 }
     };
   }
@@ -1193,27 +786,13 @@ async function checkScenario(executor, scenario, options) {
   }
   return { valid: true, phase: "ok", errors: [], timing: { upMs, downMs } };
 }
-async function checkAllScenarios(executor, scenarios, options) {
+async function checkAllScenarios(factories, scenarios, options) {
   const results = [];
   for (const scenario of scenarios) {
-    results.push(await checkScenario(executor, scenario, options));
+    results.push(await checkScenario(factories, scenario, options));
   }
   return results;
 }
-function suggestFix(errorMsg) {
-  if (errorMsg.includes("Unique constraint failed") || errorMsg.includes("unique constraint")) {
-    const match = errorMsg.match(/fields: \(`(.+?)`\)/) ?? errorMsg.match(/constraint "(.+?)"/);
-    if (match) return `Unique constraint on (${match[1]}). Ensure field values are unique across instances.`;
-    return "Unique constraint violation. Make field values unique across instances.";
-  }
-  if (errorMsg.includes("Foreign key constraint") || errorMsg.includes("foreign key")) {
-    return "A referenced record does not exist. Check that parent entities are nested correctly.";
-  }
-  if (errorMsg.includes("null value in column") || errorMsg.includes("must not be null")) {
-    return "A required field is null. Add it to the node with a value.";
-  }
-  return "";
-}
 
 // src/factory.ts
 function defineFactory(definition) {
@@ -1223,24 +802,39 @@ function defineFactory(definition) {
   if (definition.teardown !== void 0 && typeof definition.teardown !== "function") {
     throw new Error('Factory "teardown" must be a function if provided');
   }
+  if (!definition.inputSchema || !isZodSchema(definition.inputSchema)) {
+    throw new Error(
+      'Factory "inputSchema" must be a Zod schema (e.g. z.object({...})). Discover relies on it to describe the model to the dashboard.'
+    );
+  }
+  if (definition.refSchema !== void 0 && !isZodSchema(definition.refSchema)) {
+    throw new Error('Factory "refSchema" must be a Zod schema if provided');
+  }
   return definition;
 }
+function isZodSchema(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.parse === "function" && typeof candidate.safeParse === "function";
+}
 export {
+  AutonomaError,
+  Errors,
   PROTOCOL_VERSION,
+  buildSchemaFromFactories,
   checkAllScenarios,
   checkScenario,
   computeTeardownOrder,
-  createEntities,
   defineFactory,
+  fieldTypeFromZod,
   findDeferrableEdge,
   fingerprint,
-  getDialect,
   handleRequest,
-  introspectDatabase,
-  resolveTree,
+  resolvePayloadTree,
+  resolveTokens,
+  schemaToWire,
   signBody,
   signRefs,
-  teardown,
   topoSort,
   verifyRefs,
   verifySignature