@xano/sdk 1.0.0

package/dist/chunk-HVRUQXGD.js

@@ -0,0 +1,1264 @@
+import {
+  brandDef
+} from "./chunk-ERVIASGL.js";
+import {
+  encodeTags,
+  registerKind
+} from "./chunk-4POWHT2K.js";
+import {
+  nearestKey
+} from "./chunk-WTPZRR4I.js";
+import {
+  DiagnosticError,
+  numberedList,
+  problemCount
+} from "./chunk-2EZ3ZJZZ.js";
+import {
+  isHostedFile
+} from "./chunk-XNCP4KYO.js";
+import {
+  annotate,
+  encodeStatement,
+  registerStatement
+} from "./chunk-YU4HSQW7.js";
+import {
+  COLUMN_CONTEXT,
+  COLUMN_NULLABLE_TYPES,
+  authoredFieldType,
+  encodeField,
+  isListColumn
+} from "./chunk-TTEIYD5P.js";
+import {
+  argsOrEmpty,
+  assertArg,
+  assertStatements,
+  describeEntry,
+  isTaggedArg
+} from "./chunk-CIMQZRRE.js";
+
+// src/util/known-keys.ts
+function assertKnownKeys(where, v, known) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return;
+  for (const key of Object.keys(v)) {
+    if (known.includes(key)) continue;
+    const near = nearestKey(key, known);
+    throw new Error(
+      `${where}: unknown key "${key}" \u2014 ${near ? `did you mean "${near}"? It` : "it"} would be dropped on emit; expected one of: ${known.join(", ")}.`
+    );
+  }
+}
+
+// src/statements/expression.ts
+var SUPPORTED_OPS = ["=", "!=", "===", "!==", ">", "<", ">=", "<="];
+var OP_ALIASES = { "==": "=" };
+function expr(left, op, right) {
+  const normalized = OP_ALIASES[op] ?? op;
+  if (!SUPPORTED_OPS.includes(normalized)) {
+    throw new Error(
+      `expr(): Unsupported conditional operator ${typeof op === "string" ? `"${op}"` : describeEntry(op)}. Supported: ${SUPPORTED_OPS.join(", ")} (also ==, a synonym for =)`
+    );
+  }
+  assertOperand("expr", "left", left);
+  assertOperand("expr", "right", right);
+  return { left, op: normalized, right };
+}
+function assertOperand(helper, side, v) {
+  if (isTaggedArg(v)) return;
+  throw new Error(
+    `${helper}(): the ${side} operand must be a value (\`c.*\`, \`ref()\`, \`inp()\`, \`col()\`, \u2026) \u2014 got ${describeEntry(v)}.`
+  );
+}
+var SEARCH_OPS = /* @__PURE__ */ new Set([
+  "=",
+  "==",
+  "!=",
+  "===",
+  "!==",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "in",
+  "not in",
+  "like",
+  "not like",
+  "ilike",
+  "not ilike",
+  "~",
+  "!~",
+  "between",
+  "not between",
+  "@>",
+  "contains",
+  "not contains",
+  "includes",
+  "not includes",
+  "overlaps",
+  "not overlaps",
+  "search"
+]);
+function isSearchOp(op) {
+  return typeof op === "string" && SEARCH_OPS.has(op);
+}
+function cmp(left, op, right, opts) {
+  if (!SEARCH_OPS.has(op)) {
+    throw new Error(
+      `cmp(): unsupported operator ${typeof op === "string" ? `"${op}"` : describeEntry(op)}. Supported: ${[...SEARCH_OPS].join(", ")}.`
+    );
+  }
+  assertOperand("cmp", "left", left);
+  assertOperand("cmp", "right", right);
+  return { left, op, right, ignoreEmpty: opts?.ignoreEmpty };
+}
+function assertChildren(helper, children) {
+  children.forEach((child, i) => {
+    if (typeof child === "object" && child !== null && !Array.isArray(child)) return;
+    if (isTaggedArg(child)) return;
+    throw new Error(
+      `${helper}(): argument ${i + 1} must be a condition (\`cmp()\`, \`expr()\`, \`and()\`/\`or()\`) \u2014 got ${describeEntry(child)}.`
+    );
+  });
+}
+function and(...children) {
+  assertChildren("and", children);
+  return { or: false, children };
+}
+function or(...children) {
+  assertChildren("or", children);
+  return { or: true, children };
+}
+function mixed(first, ...rest) {
+  if (rest.length === 0) {
+    throw new Error(
+      "mixed(): needs at least two terms \u2014 a single term has no join to mix. Pass the node on its own, or use and()/or() for a uniform container."
+    );
+  }
+  for (const term of rest) {
+    if (typeof term !== "object" || term === null || Array.isArray(term)) {
+      throw new Error(
+        `mixed(): every term after the first is exactly one of \`{ and: node }\` or \`{ or: node }\` \u2014 got ${describeEntry(term)}.`
+      );
+    }
+    const keys = Object.keys(term).filter((k) => term[k] !== void 0);
+    if (keys.length !== 1 || keys[0] !== "and" && keys[0] !== "or") {
+      throw new Error(
+        `mixed(): every term after the first is exactly one of \`{ and: node }\` or \`{ or: node }\` \u2014 got ${JSON.stringify(keys)}.`
+      );
+    }
+  }
+  return { mixed: [first, ...rest] };
+}
+function isValue(w) {
+  return typeof w === "object" && w !== null && !Array.isArray(w) && "tag" in w && "value" in w;
+}
+function isGroup(w) {
+  return typeof w === "object" && w !== null && !Array.isArray(w) && "children" in w;
+}
+function isMixed(w) {
+  return typeof w === "object" && w !== null && !Array.isArray(w) && "mixed" in w;
+}
+function containerTerms(node) {
+  if (isMixed(node)) {
+    return node.mixed.map(
+      (term, i) => i === 0 ? { or: false, node: term } : { or: "or" in term, node: "or" in term ? term.or : term.and }
+    );
+  }
+  return node.children.map((child, i) => ({ or: node.or && i > 0, node: child }));
+}
+function isCmpNode(w) {
+  return typeof w === "object" && w !== null && !Array.isArray(w) && "op" in w && "left" in w;
+}
+function toOperand(v) {
+  return { operand: v.value, tag: v.tag, filters: v.filters };
+}
+function toStatementNode(node, or2) {
+  const right = toOperand(node.right);
+  if (node.ignoreEmpty) right.ignore_empty = true;
+  return {
+    type: "statement",
+    or: or2,
+    group: { expression: [] },
+    statement: { op: node.op, left: toOperand(node.left), right }
+  };
+}
+function encodeContainer(children, joinOr) {
+  return encodeTerms(children.map((child, i) => ({ or: joinOr && i > 0, node: child })));
+}
+function encodeTerms(terms) {
+  return terms.map(({ or: or2, node }) => {
+    if (isGroup(node) || isMixed(node)) {
+      const group = {
+        type: "group",
+        or: or2,
+        group: { expression: encodeTerms(containerTerms(node)) }
+      };
+      return group;
+    }
+    return toStatementNode(node, or2);
+  });
+}
+var MAX_EXPRESSION_DEPTH = 128;
+function assertExpressionDepth(nodes) {
+  const stack = nodes.map((node) => ({ node, depth: 1 }));
+  while (stack.length > 0) {
+    const { node, depth } = stack.pop();
+    if (!isGroup(node) && !isMixed(node)) continue;
+    if (depth > MAX_EXPRESSION_DEPTH) {
+      throw new Error(
+        `condition: expression containers are nested ${depth} levels deep, past the supported limit of ${MAX_EXPRESSION_DEPTH}. Nesting costs quadratic bytes \u2014 every level re-wraps everything below it \u2014 so a deep chain exports megabytes and eventually cannot be walked at all. This is almost always a rule set folded one term at a time (\`rules.reduce((acc, r) => and(acc, r))\`); pass the terms as SIBLINGS of one container instead (\`and(...rules)\` \u2014 flat, linear, unlimited in count), or balance the tree so its depth is logarithmic. Mixing joins? Group each run: \`and(or(...anyOf), ...allOf)\`.`
+      );
+    }
+    for (const term of containerTerms(node)) stack.push({ node: term.node, depth: depth + 1 });
+  }
+}
+function encodeExpression(input) {
+  const nodes = Array.isArray(input) ? input : [input];
+  assertExpressionDepth(nodes);
+  const only = nodes.length === 1 ? nodes[0] : void 0;
+  if (only !== void 0 && isGroup(only) && only.or) {
+    return { expression: encodeContainer(only.children, true) };
+  }
+  if (only !== void 0 && isMixed(only)) {
+    return { expression: encodeTerms(containerTerms(only)) };
+  }
+  return { expression: encodeContainer(nodes, false) };
+}
+var RUNTIME_OPS = new Set(SUPPORTED_OPS);
+function isRuntimeConditionOp(op) {
+  return typeof op === "string" && (RUNTIME_OPS.has(op) || Object.hasOwn(OP_ALIASES, op));
+}
+var CONDITION_HINTS = {
+  in: "`cond.in(value, list)`",
+  "not in": "`cond.notIn(value, list)`",
+  contains: "`cond.contains(text, needle)`",
+  "not contains": "`cond.notContains(text, needle)`",
+  includes: "`cond.contains(text, needle)`",
+  like: "`cond.contains(text, needle)` (or `cond.startsWith`/`cond.endsWith`)",
+  ilike: "`cond.icontains(text, needle)`",
+  between: "`cond.between(value, lo, hi)`"
+};
+function assertRuntimeOps(node, surface) {
+  if (isGroup(node) || isMixed(node)) {
+    for (const term of containerTerms(node)) assertRuntimeOps(term.node, surface);
+    return;
+  }
+  if (!isCmpNode(node)) {
+    throw new Error(
+      `${surface}: a condition must be a comparison (\`expr(left, "=", right)\`, \`cond.*\`) or an and()/or() group \u2014 got ${describeEntry(node)}.` + (isValue(node) ? ` To test a value, compare it: \`expr(value, "=", c.bool(true))\`.` : "")
+    );
+  }
+  const op = node.op;
+  if (isRuntimeConditionOp(op)) return;
+  throw new Error(
+    `${surface}: operator "${op}" is a database-search operator and cannot be evaluated in a condition \u2014 the request fails at runtime with \`Invalid op: ${op}\`. A condition evaluates ${SUPPORTED_OPS.join(", ")} (and \`==\`). Keep "${op}" for a db.query/bulk/addon \`where\`, a table view filter, or a database trigger \`search\`. In a condition, reach for \`cond.*\`, which builds the filter-then-compare form that DOES run here \u2014 ${(Object.hasOwn(CONDITION_HINTS, op) ? CONDITION_HINTS[op] : void 0) ?? "`cond.in` / `contains` / `startsWith` / `endsWith` / `empty` / `between` / `isNull`"}.`
+  );
+}
+function encodeRuntimeCondition(input, surface) {
+  const nodes = Array.isArray(input) ? input : [input];
+  assertExpressionDepth(nodes);
+  for (const node of nodes) assertRuntimeOps(node, surface);
+  return encodeExpression(input);
+}
+function encodeComparison(when) {
+  return encodeExpression(when);
+}
+
+// src/statements/conditional.ts
+var CONDITIONAL = "mvp:conditional";
+var CONDITIONAL_ELIF = "mvp:conditional_elif";
+var ELIF_KEYS = /* @__PURE__ */ Object.keys({ when: 1, then: 1, disabled: 1, description: 1, mock: 1 });
+function conditionalElif(args, where = "then") {
+  args = argsOrEmpty(args);
+  assertKnownKeys(`Statement "s.conditional"${where === "then" ? "" : `: argument "${where.replace(/\.then$/, "")}"`}`, args, ELIF_KEYS);
+  const label = where === "then" ? "when" : where.replace(/\.then$/, ".when");
+  assertArg("s.conditional", label, args.when);
+  assertStatements("s.conditional", where, args.then);
+  const context = {
+    expr: encodeRuntimeCondition(args.when, "s.conditional elif `when`"),
+    if: { run: args.then.map(encodeStatement) }
+  };
+  return annotate({ name: CONDITIONAL_ELIF, context, input: [] }, args);
+}
+var CONDITIONAL_KEYS = /* @__PURE__ */ Object.keys({ when: 1, then: 1, elif: 1, else: 1, disabled: 1, description: 1, mock: 1 });
+function conditional(args) {
+  args = argsOrEmpty(args);
+  assertKnownKeys(`Statement "s.conditional"`, args, CONDITIONAL_KEYS);
+  assertArg("s.conditional", "when", args.when);
+  assertStatements("s.conditional", "then", args.then);
+  if (args.elif !== void 0 && args.elif !== null && !Array.isArray(args.elif)) {
+    throw new Error(
+      `Statement "s.conditional": argument "elif" must be an array of { when, then } branches \u2014 got ${describeEntry(args.elif)}.`
+    );
+  }
+  if (args.else !== void 0 && args.else !== null) assertStatements("s.conditional", "else", args.else);
+  const context = {
+    expr: encodeRuntimeCondition(args.when, "s.conditional `when`"),
+    if: { run: args.then.map(encodeStatement) },
+    elif: {
+      run: (args.elif ?? []).map((e, i) => {
+        if (e === null || typeof e !== "object") {
+          throw new Error(
+            `Statement "s.conditional": argument "elif[${i}]" must be a { when, then } branch \u2014 got ${describeEntry(e)}.`
+          );
+        }
+        return encodeStatement(conditionalElif(e, `elif[${i}].then`));
+      })
+    },
+    else: { run: (args.else ?? []).map(encodeStatement) }
+  };
+  return annotate({ name: CONDITIONAL, context, input: [] }, args);
+}
+registerStatement(CONDITIONAL, conditional);
+registerStatement(CONDITIONAL_ELIF, conditionalElif);
+
+// src/kinds/table.ts
+var SCALAR_FAMILY = {
+  bool: "bool",
+  int: "int",
+  epochms: "epochms",
+  decimal: "decimal",
+  text: "text",
+  uuid: "text",
+  email: "text",
+  password: "text",
+  enum: "enum"
+};
+function normalizeIndexType(type) {
+  return type === "unique" ? "btree|unique" : type;
+}
+var PRIORITY_OPS = ["A", "B", "C", "D"];
+var SEED_FILE = /* @__PURE__ */ Symbol.for("xanosdk.seed.file");
+function seedFile(path, base) {
+  return { [SEED_FILE]: { path, base: typeof base === "string" ? base : base.href } };
+}
+function isSeedFileSource(source) {
+  return typeof source === "object" && source !== null && SEED_FILE in source;
+}
+function toColumns(schema) {
+  if (Array.isArray(schema)) {
+    return schema.map((c) => {
+      if (!("options" in c) || c.options === null || typeof c.options !== "object") return c;
+      const { name, type, options } = c;
+      return { name, type, ...options };
+    });
+  }
+  return Object.entries(schema).map(([name, d]) => ({ name, type: d.type, ...d.options }));
+}
+function systemColumns(idType = "int") {
+  return [
+    // A uuid primary key persists NO `default` key — the engine stores it that
+    // way because the value is engine-generated. An `int` key and an ordinary
+    // (non-key) uuid column both carry `default: ""`, so this is specific to the
+    // uuid key. See {@link FieldOptions.noDefault}.
+    // `nullable` is pinned on both, not left to the per-type default: a uuid
+    // column is nullable by default (see COLUMN_NULLABLE_BY_DEFAULT), but a PRIMARY KEY
+    // never is, and every captured `id`/`created_at` stores `nullable: false`.
+    {
+      name: "id",
+      type: idType,
+      required: true,
+      nullable: false,
+      ...idType === "uuid" ? { noDefault: true } : {}
+    },
+    { name: "created_at", type: "epochms", default: "now", access: "private", nullable: false }
+  ];
+}
+function tableColumns(def) {
+  const cols = toColumns(def.schema);
+  if (def.system === false) return cols.map((col) => primaryKeyColumn(def.name, col));
+  const present = new Set(cols.map((col) => col.name));
+  const missing = systemColumns(def.idType).filter((sc) => !present.has(sc.name));
+  return [...missing, ...cols.map((col) => primaryKeyColumn(def.name, col))];
+}
+function primaryKeyColumn(table2, col) {
+  if (col.name !== "id") return col;
+  if (col.type !== "int" && col.type !== "uuid") {
+    throw new Error(
+      `${table2 === void 0 ? "" : `table "${table2}", `}column "id" (${authoredFieldType(col.type)}): \`id\` is the table's primary key, which is an int or a uuid \u2014 any other type fails the deploy. Declare \`id: f.int()\` or \`id: f.uuid()\`, or leave it out (\`idType: "uuid"\` picks a uuid key).`
+    );
+  }
+  return { ...col, ...systemColumns(col.type)[0] };
+}
+function systemIndexes(useXdo = false) {
+  return [
+    { type: "primary", fields: [{ name: "id" }] },
+    ...useXdo ? [{ type: "gin", fields: [{ name: "xdo", op: "jsonb_path_op" }] }] : [],
+    { type: "btree", fields: [{ name: "created_at", op: "desc" }] }
+  ];
+}
+function indexSignature(def) {
+  return `${normalizeIndexType(def.type)}|${def.fields.map((field) => field.name).join(",")}`;
+}
+function tableIndexes(def) {
+  const declared = def.index ?? [];
+  if (def.system === false) return declared;
+  const present = new Set(declared.map(indexSignature));
+  const missing = systemIndexes(def.useXdo).filter((idx) => !present.has(indexSignature(idx)));
+  return [...missing, ...declared];
+}
+var SYSTEM_COLUMN_NAMES = systemColumns().map((col) => col.name);
+function elideSystemIndexes(index, useXdo) {
+  const system = systemIndexes(useXdo);
+  const encoded = (list) => JSON.stringify(list.map(encodeIndex));
+  const target = encoded(index);
+  for (const subset of subsetsLargestFirst(system.length)) {
+    const pending = /* @__PURE__ */ new Map();
+    for (const position of subset) {
+      const signature = indexSignature(system[position]);
+      pending.set(signature, (pending.get(signature) ?? 0) + 1);
+    }
+    const kept = index.filter((entry) => {
+      const remaining = pending.get(indexSignature(entry)) ?? 0;
+      if (remaining === 0) return true;
+      pending.set(indexSignature(entry), remaining - 1);
+      return false;
+    });
+    if (kept.length === index.length) continue;
+    if (encoded(tableIndexes({ index: kept, useXdo })) === target) return kept;
+  }
+  return null;
+}
+function subsetsLargestFirst(n) {
+  const all = [];
+  for (let mask = 1; mask < 1 << n; mask += 1) {
+    const members = [];
+    for (let bit = 0; bit < n; bit += 1) if (mask & 1 << bit) members.push(bit);
+    all.push(members);
+  }
+  return all.sort((a, b) => b.length - a.length || a[0] - b[0]);
+}
+function encodeIndex(def) {
+  return {
+    name: def.name ?? "",
+    // A search index with no language fails the deploy (measured: SQL 42602);
+    // the engine's own default is english.
+    lang: def.lang || (normalizeIndexType(def.type) === "search" ? "english" : ""),
+    type: normalizeIndexType(def.type),
+    fields: def.fields.map((field) => ({ name: field.name, op: searchOp(def, field) })),
+    market_item: { id: 0, version: 0, guid: "" }
+  };
+}
+function searchOp(def, field) {
+  if (field.priority === void 0) return field.op ?? "";
+  if (field.op !== void 0) {
+    throw new Error(
+      `table index field "${field.name}": \`op\` and \`priority\` are two spellings of the same stored value (priority 1-4 is op "A"-"D"). Supplying both has no correct reading \u2014 drop one.`
+    );
+  }
+  if (normalizeIndexType(def.type) !== "search") {
+    throw new Error(
+      `table index field "${field.name}": \`priority\` is a SEARCH index's per-column weight, and this index is "${def.type}". On any other index the operator slot means something else entirely (sort direction, a pgvector distance op), so a priority written here would be stored as a letter the index does not understand. Use \`op\`.`
+    );
+  }
+  return PRIORITY_OPS[field.priority - 1];
+}
+function encodeView(def) {
+  return {
+    alias: def.alias ?? "",
+    hiddenCols: def.hide ?? [],
+    id: def.id,
+    name: def.name,
+    q: def.q ?? "",
+    expression: def.where ? encodeComparison(def.where).expression : [],
+    sort: (def.sort ?? []).map((s) => ({ name: s.name, order: s.order }))
+  };
+}
+function encodeColumn(def) {
+  const { name, type, ...options } = def;
+  return encodeField(name, type, options, COLUMN_CONTEXT);
+}
+function assertBmpColumnDefault(tableName, col) {
+  if (col.default === void 0) return;
+  for (const ch of String(col.default)) {
+    const cp = ch.codePointAt(0);
+    if (cp > 65535) {
+      const u = `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+      throw new Error(
+        `table "${tableName}", column "${col.name}": \`default\` contains a 4-byte character (${JSON.stringify(ch)}, ${u}). The engine mangles such characters into an invalid UTF-8 sequence in the column default, failing at deploy with Postgres 22021 (invalid byte sequence for encoding "UTF8"). Use a default within the Basic Multilingual Plane (accents, most CJK, and \u20AC are fine), or move the value onto an endpoint input (\`input.text({ default })\`), applied at runtime bind.`
+      );
+    }
+  }
+}
+function assertColumnDefaultQuote(tableName, col, useXdo) {
+  const family = Object.hasOwn(SCALAR_FAMILY, col.type) ? SCALAR_FAMILY[col.type] : void 0;
+  if (useXdo || isListColumn(col) || family !== "text" && family !== "enum") return;
+  if (typeof col.default !== "string" || !col.default.includes("'")) return;
+  throw new Error(
+    `table "${tableName}", column "${col.name}" (${authoredFieldType(col.type)}): \`default\` ${JSON.stringify(col.default)} contains an apostrophe, which a table that keeps its fields as columns cannot take in a default \u2014 the deploy fails with an SQL syntax error. Use a typographic apostrophe (\u2019), set the value at insert instead of as the default, or give the table \`useXdo: true\`.`
+  );
+}
+function assertIndexColumns(def) {
+  const known = tableColumns(def).map((col) => col.name);
+  const set = /* @__PURE__ */ new Set([...known, "xdo"]);
+  for (const index of def.index ?? []) {
+    for (const field of index.fields) {
+      if (set.has(field.name)) continue;
+      const column = field.name.slice(0, field.name.indexOf("."));
+      if (column !== "" && set.has(column)) continue;
+      const signature = `${normalizeIndexType(index.type)}(${index.fields.map((f) => f.name).join(", ")})`;
+      throw new Error(
+        `table "${def.name}", index "${signature}": unknown column "${field.name}" (not in table schema). Known columns: ${known.join(", ")}. An index over a column that does not exist exports cleanly and fails at deploy with an engine error that names neither.`
+      );
+    }
+  }
+}
+function assertIndexFieldTypes(def) {
+  const columns = new Map(tableColumns(def).map((col) => [col.name, col]));
+  for (const index of def.index ?? []) {
+    const type = normalizeIndexType(index.type);
+    const at = `table "${def.name}", index "${type}(${index.fields.map((f) => f.name).join(", ")})"`;
+    if ((type === "hash" || type === "vector") && index.fields.length !== 1) {
+      throw new Error(`${at}: a ${type} index covers exactly one column \u2014 the deploy fails on ${index.fields.length}. Declare one index per column.`);
+    }
+    const ops = INDEX_OPS[type];
+    const xdo = def.useXdo === true;
+    const plainIndex = type === "btree" || type === "btree|unique" || type === "hash";
+    for (const field of index.fields) {
+      const col = columns.get(field.name);
+      const column = col?.type;
+      const list = col !== void 0 && isListColumn(col);
+      const shown = column === void 0 ? "" : `${authoredFieldType(column)}${list ? " list" : ""}`;
+      if (column?.startsWith("blob") === true) {
+        throw new Error(`${at}: "${field.name}" is ${shown}, and a file column cannot be indexed \u2014 the deploy fails with "Complex schema is not supported.". Index a column that holds the value you match on.`);
+      }
+      if (xdo && plainIndex && column === "vector") {
+        throw new Error(`${at}: "${field.name}" is ${shown}, and on a \`useXdo: true\` table a ${type === "btree|unique" ? "unique" : type} index cannot cover a vector column \u2014 the deploy fails with an SQL syntax error. Use a vector index.`);
+      }
+      if (xdo && plainIndex && list && column !== void 0 && !XDO_LIST_INDEXABLE.has(column)) {
+        throw new Error(`${at}: "${field.name}" is ${shown}, and on a \`useXdo: true\` table a ${type === "btree|unique" ? "unique" : type} index over a list of anything but text or json deploys, then fails inserts with an SQL error. Drop the index, or keep the table's fields as columns (\`useXdo: false\`).`);
+      }
+      if (type === "vector" && column !== void 0 && column !== "vector") {
+        throw new Error(`${at}: "${field.name}" is ${shown}, and a vector index needs an \`f.vector(size)\` column \u2014 the deploy fails with "Malformed vector index".`);
+      }
+      if (type === "vector" && (field.op === void 0 || field.op === "")) {
+        throw new Error(`${at}: a vector index needs the distance \`op\` its queries use on "${field.name}" (${(INDEX_OPS.vector ?? []).map((o) => JSON.stringify(o)).join(", ")}) \u2014 the deploy fails with "Malformed vector index" without one.`);
+      }
+      if (type === "gist" && column !== void 0 && !column.startsWith("geo_")) {
+        throw new Error(`${at}: "${field.name}" is ${shown}, and a gist (spatial) index needs a geo column (\`f.geo.point()\`, \u2026) \u2014 the deploy fails on any other.`);
+      }
+      if (column === void 0 || field.name === "xdo") {
+      } else if (type === "gin" && (column !== "json" && column !== "obj" && !list || xdo && list)) {
+        throw new Error(
+          xdo && list ? `${at}: "${field.name}" is ${shown}, and on a \`useXdo: true\` table a gin index needs a json or object column \u2014 the deploy fails on a list. Keep the table's fields as columns (\`useXdo: false\`) to gin-index a list.` : `${at}: "${field.name}" is ${shown}, and a gin index needs a json, object or list column \u2014 the deploy fails on any other. Use a \`search\` index for text, or \`btree\`.`
+        );
+      } else if (type === "gin" && field.op !== void 0 && GIN_OPS[field.op] !== void 0 && !GIN_OPS[field.op](list)) {
+        throw new Error(`${at}: op ${JSON.stringify(field.op)} on "${field.name}" (${shown}) is for ${list ? "a json or object" : "a list"} column \u2014 the deploy fails. Use ${list ? '"array_ops"' : '"jsonb_ops" or "jsonb_path_ops"'}, or no op.`);
+      } else if (type === "search" && (list ? !(xdo && SEARCHABLE.has(column)) : !SEARCHABLE.has(column))) {
+        throw new Error(`${at}: "${field.name}" is ${shown}, and a search index needs a text, email, password or enum column \u2014 the deploy fails on any other.`);
+      } else if (type === "hash" && (column === "vector" || column.startsWith("geo_"))) {
+        throw new Error(`${at}: "${field.name}" is ${shown}, and a hash index cannot cover a ${column === "vector" ? "vector" : "geo"} column \u2014 the deploy fails. Use a ${column === "vector" ? "vector" : "gist"} index.`);
+      }
+      if (ops !== void 0 && field.op !== void 0 && field.op !== "" && !ops.includes(field.op)) {
+        throw new Error(`${at}: op ${JSON.stringify(field.op)} on "${field.name}" is not one a ${type} index takes (${ops.map((o) => JSON.stringify(o)).join(", ")}).`);
+      }
+    }
+  }
+}
+function calendarDate(text) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (m === null || m[1] === "0000") return false;
+  const day = /* @__PURE__ */ new Date(0);
+  day.setUTCFullYear(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+  return day.getUTCMonth() === Number(m[2]) - 1 && day.getUTCDate() === Number(m[3]);
+}
+var SEARCHABLE = /* @__PURE__ */ new Set(["text", "email", "password", "enum"]);
+var XDO_LIST_INDEXABLE = /* @__PURE__ */ new Set([...SEARCHABLE, "json"]);
+var INDEX_OPS = {
+  btree: ["asc", "desc"],
+  "btree|unique": ["asc", "desc"],
+  gin: ["jsonb_path_op", "jsonb_ops", "jsonb_path_ops", "array_ops"],
+  vector: ["vector_cosine_ops", "vector_ip_ops", "vector_l1_ops", "vector_l2_ops"]
+};
+var GIN_OPS = {
+  jsonb_ops: (list) => !list,
+  jsonb_path_ops: (list) => !list,
+  array_ops: (list) => list
+};
+function assertColumnDefaultFits(tableName, col, useXdo) {
+  const value = col.default;
+  if (value === void 0 || value === null || value === "" || typeof value === "object" || isListColumn(col)) return;
+  const text = String(value);
+  const shown = typeof value === "number" ? text : JSON.stringify(value);
+  const family = col.type === "date" ? "date" : Object.hasOwn(SCALAR_FAMILY, col.type) ? SCALAR_FAMILY[col.type] : void 0;
+  let want;
+  switch (family) {
+    case "int":
+      if (!/^-?\d+$/.test(text) || BigInt(text) > 2n ** 63n - 1n || BigInt(text) < -(2n ** 63n)) want = "a whole number (64-bit)";
+      break;
+    case "decimal":
+      if (typeof value === "boolean" || !/^\s*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?\s*$/.test(text)) want = "a number";
+      else if (!decimalDefaultInRange(text, useXdo)) {
+        throw new Error(
+          `table "${tableName}", column "${col.name}" (decimal): \`default\` ${shown} is out of range \u2014 ` + (useXdo ? "a JSON-storage table holds a decimal as a JSON number, and this one is past what a number can hold" : "a normalized table holds a decimal in 14 digits, 5 of them after the point, so it must stay below 1000000000 once rounded to 5 places") + ` \u2014 the table deploys, then every insert that leaves the column unset fails with an SQL error. Use a smaller default.`
+        );
+      }
+      break;
+    case "bool":
+      if (!/^(true|false|t|f|yes|no|on|off|1|0)$/i.test(text)) want = "true or false";
+      break;
+    case "epochms":
+      if (text !== "now" && !/^-?\d+$/.test(text)) {
+        const ms = /\d{4}-\d{2}-\d{2}/.test(text) ? Date.parse(text) : NaN;
+        want = `"now" (the insert time) or epoch milliseconds` + (Number.isFinite(ms) ? ` \u2014 ${JSON.stringify(text)} is \`default: ${ms}\`` : "");
+      }
+      break;
+    case "date":
+      if (text !== "now" && !calendarDate(text)) want = `"now" (the insert date) or a real calendar date ("2026-01-31")`;
+      break;
+  }
+  if (want === void 0) return;
+  const consequence = !useXdo ? "the database takes the default as written, so the table fails to deploy" : family === "date" ? "a JSON-storage table deploys, then every insert that leaves the column unset is refused or stores a rolled-over day" : "a JSON-storage table deploys, then every insert that leaves the column unset is refused";
+  throw new Error(
+    `table "${tableName}", column "${col.name}" (${authoredFieldType(col.type)}): \`default\` ${shown} does not fit \u2014 ${consequence}. Use ${want}.`
+  );
+}
+function decimalDefaultInRange(text, useXdo) {
+  if (useXdo) return Number.isFinite(Number(text));
+  const m = /^\s*[+-]?(\d*)\.?(\d*)(?:[eE]([+-]?\d+))?\s*$/.exec(text);
+  const digits = (m[1] + m[2]).replace(/^0+/, "");
+  if (digits === "") return true;
+  const shift = Number(m[3] ?? "0") - m[2].length + 6;
+  const limit = 999999999999995n;
+  if (shift >= 0) return digits.length + shift <= 15 && BigInt(digits) * 10n ** BigInt(shift) < limit;
+  if (-shift > digits.length) return true;
+  return BigInt(digits) < limit * 10n ** BigInt(-shift);
+}
+function assertOwnPrimaryKey(def) {
+  if (def.system !== false) return;
+  const hasId = tableColumns(def).some((col) => col.name === "id");
+  const hasPrimary = (def.index ?? []).some((index) => index.type === "primary" && index.fields.length === 1 && index.fields[0].name === "id");
+  if (hasId && hasPrimary) return;
+  const missing = [hasId ? void 0 : "an `id` column (`id: f.int()` or `id: f.uuid()`)", hasPrimary ? void 0 : '`{ type: "primary", fields: [{ name: "id" }] }` in `index`'].filter((m) => m !== void 0).join(" and ");
+  throw new Error(
+    `table "${def.name}": a \`system: false\` table still needs an \`id\` primary key \u2014 the deploy fails without it. Declare ${missing}, or drop \`system: false\` to have both added (with \`created_at\`).`
+  );
+}
+function encodeTable(def) {
+  if (!def.name) throw new Error("table: `name` is required.");
+  assertIndexShape(def);
+  for (const col of tableColumns(def)) {
+    assertBmpColumnDefault(def.name, col);
+    assertColumnDefaultFits(def.name, col, def.useXdo === true);
+    assertColumnDefaultQuote(def.name, col, def.useXdo === true);
+  }
+  assertIndexColumns(def);
+  assertIndexFieldTypes(def);
+  assertOwnPrimaryKey(def);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    docs: def.docs ?? "",
+    auth: def.auth ?? false,
+    install: def.install ?? false,
+    schema: tableColumns(def).map(encodeColumn),
+    index: tableIndexes(def).map(encodeIndex),
+    autocomplete: (def.autocomplete ?? []).map((name) => ({ name })),
+    external: def.external ?? { source: "", id: "" },
+    views: (def.views ?? []).map(encodeView),
+    tag: encodeTags(def.tags),
+    // A table has no `as` — it returns nothing (it's a datastore, not a stack
+    // statement); confirmed 0/16 live `mvp_dbo` rows carry one. (Older golden
+    // export fixtures store `as:<name>`, a stale generation — see normalize.ts.)
+    // `sql_name` is the engine's physical table name; persisted as "" (the
+    // engine derives the real name) — confirmed against live `mvp_dbo`.
+    sql_name: "",
+    use_xdo: def.useXdo ?? false,
+    market_item: { id: 0, version: 0, guid: "" }
+  };
+}
+var tableKind = {
+  name: "table",
+  payloadKey: "dbo",
+  encode: encodeTable
+};
+registerKind(tableKind);
+function table(def) {
+  if (def !== null && typeof def === "object") {
+    assertIndexShape(def);
+    assertColumnNames(def);
+  }
+  return brandDef(def, "table");
+}
+var COLUMN_NAME = /^(?![-@])(?![0-9]+$)(?![_-]+$)[A-Za-z0-9_:@!-]+(?<!-)$/;
+var COLUMN_NAME_BYTES = 63;
+var COLUMN_NAME_UNUSABLE = "table.column-name-unusable";
+function unusableColumnName(name) {
+  const bytes = new TextEncoder().encode(name).length;
+  if (bytes > COLUMN_NAME_BYTES && COLUMN_NAME.test(name)) {
+    return `is ${bytes} bytes and the database keeps only the first ${COLUMN_NAME_BYTES}, so it deploys but every read returns it empty`;
+  }
+  if (COLUMN_NAME.test(name)) return void 0;
+  if (/[^\x21-\x7e]|[.$]/.test(name) || name === "") return "cannot be deployed";
+  if (/^[A-Za-z0-9_:@!?-]+$/.test(name) && (name.includes("?") || /^[0-9]+$/.test(name) || /^[_-]+$/.test(name))) {
+    return "deploys, but every insert into the table fails (seed rows included)";
+  }
+  if (/^@[A-Za-z0-9_:@!-]*$/.test(name) && !name.endsWith("-")) return "deploys, but every filter on it fails";
+  return "is outside the column-name rule";
+}
+function unusableColumns(schema) {
+  const names = Array.isArray(schema) ? schema.map((c) => c !== null && typeof c === "object" ? c.name : void 0) : schema !== null && typeof schema === "object" ? Object.keys(schema) : [];
+  const out = [];
+  for (const name of names) {
+    if (typeof name !== "string") continue;
+    const why = unusableColumnName(name);
+    if (why !== void 0) out.push({ name, why });
+  }
+  return out;
+}
+function assertColumnNames(def) {
+  const schema = def.schema;
+  const names = Array.isArray(schema) ? schema.map((c) => c !== null && typeof c === "object" ? c.name : void 0) : schema !== null && typeof schema === "object" ? Object.keys(schema) : [];
+  const seen = /* @__PURE__ */ new Map();
+  const at = /* @__PURE__ */ new Map();
+  for (const [i, name2] of names.entries()) {
+    if (typeof name2 !== "string") continue;
+    if (at.has(name2)) {
+      throw new Error(
+        `table "${String(def.name)}": schema[${at.get(name2)}] and schema[${i}] are both named ${JSON.stringify(name2)} \u2014 the database keeps one column per name, so the table deploys with one of them. Rename or drop one.`
+      );
+    }
+    at.set(name2, i);
+    const head = new TextDecoder().decode(new TextEncoder().encode(name2).slice(0, COLUMN_NAME_BYTES));
+    const other = seen.get(head);
+    if (other !== void 0) {
+      throw new Error(
+        `table "${String(def.name)}": the column names ${JSON.stringify(other)} and ${JSON.stringify(name2)} share their first ${COLUMN_NAME_BYTES} bytes, which is all of a column name the database keeps \u2014 the deploy fails on a duplicate column. Shorten one of them.`
+      );
+    }
+    seen.set(head, name2);
+  }
+  if (def.diagnostics?.allow?.includes(COLUMN_NAME_UNUSABLE)) return;
+  const bad = unusableColumns(schema)[0];
+  if (bad === void 0) return;
+  const { name, why } = bad;
+  let fixed = name.trim().replace(/[^A-Za-z0-9_:@!-]+/g, "_").replace(/^[-@_]+|[-_]+$/g, "");
+  if (/^[0-9]+$/.test(fixed)) fixed = `col_${fixed}`;
+  if (new TextEncoder().encode(fixed).length > COLUMN_NAME_BYTES) fixed = fixed.slice(0, COLUMN_NAME_BYTES).replace(/[-_]+$/, "");
+  throw new Error(
+    `table "${String(def.name)}": the column name ${JSON.stringify(name)} ${why} \u2014 a column name is ASCII letters, digits, \`_\`, \`-\`, \`:\`, \`@\` and \`!\`, does not start or end with \`-\` or start with \`@\`, is not all digits or all \`_\`/\`-\`, and is at most ${COLUMN_NAME_BYTES} bytes.` + (fixed !== "" && fixed !== name && unusableColumnName(fixed) === void 0 ? ` Rename it, e.g. ${JSON.stringify(fixed)}.` : " Rename it.")
+  );
+}
+var INDEX_TYPES = /* @__PURE__ */ new Set(["primary", "btree", "hash", "gin", "gist", "search", "vector"]);
+function assertIndexShape(def) {
+  if (def.index === void 0) return;
+  const where = `table "${String(def.name)}"`;
+  if (!Array.isArray(def.index)) {
+    throw new Error(`${where}: \`index\` must be a list of { type, fields } entries \u2014 got ${typeof def.index}.`);
+  }
+  def.index.forEach((index, i) => {
+    const at = `${where}, index[${i}]`;
+    if (index === null || typeof index !== "object") throw new Error(`${at} must be a { type, fields } entry \u2014 got ${String(index)}.`);
+    if (typeof index.type !== "string") throw new Error(`${at}: \`type\` must be the index type ("btree", "unique", "search", \u2026).`);
+    const base = normalizeIndexType(index.type).split("|")[0];
+    if (!INDEX_TYPES.has(base)) {
+      const hint = base === "spatial" ? " A spatial index is `gist`." : base === "fulltext" || base === "text" ? " A full-text index is `search`." : "";
+      throw new Error(
+        `${at}: ${JSON.stringify(index.type)} is not an index type the engine builds \u2014 the deploy fails with "Invalid index type.", naming no table. Use one of ${[...INDEX_TYPES].filter((t) => t !== "primary").map((t) => `"${t}"`).join(", ")}, "unique".${hint}`
+      );
+    }
+    if (!Array.isArray(index.fields) || index.fields.length === 0) {
+      throw new Error(`${at}: \`fields\` must be a non-empty list of the indexed columns, e.g. \`fields: [{ name: "email" }]\`.`);
+    }
+    index.fields.forEach((field, j) => {
+      if (field === null || typeof field !== "object" || typeof field.name !== "string") {
+        throw new Error(
+          `${at}: fields[${j}] must be { name: "<column>" } \u2014 got ${JSON.stringify(field) ?? String(field)}.` + (typeof field === "string" ? ` Write \`{ name: ${JSON.stringify(field)} }\`.` : "")
+        );
+      }
+    });
+  });
+}
+
+// src/fields/email-address.ts
+function emailAddress(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && TRIMMED.includes(value[start])) start++;
+  while (end > start && TRIMMED.includes(value[end - 1])) end--;
+  const text = value.slice(start, end);
+  if (text === "") return true;
+  const bytes = String.fromCharCode(...new TextEncoder().encode(text));
+  return bytes.length <= 320 && EMAIL_ADDRESS.test(bytes);
+}
+var TRIMMED = " 	\n\r\0\v";
+var EMAIL_ADDRESS = (() => {
+  const atom = "[\\x21\\x23-\\x27\\x2A\\x2B\\x2D\\x2F-\\x39\\x3D\\x3F\\x5E-\\x7E]+";
+  const quoted = "\\x22(?:[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x21\\x23-\\x5B\\x5D-\\x7F]|\\x5C[\\x00-\\x7F])*\\x22";
+  const word = `(?:${atom}|${quoted})`;
+  const char = "(?:\\x22?\\x5C[\\x00-\\x7E]\\x22?|\\x22?[^\\x5C\\x22]\\x22?)";
+  const octet = "(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])";
+  const ipv4 = `${octet}(?:\\.${octet}){3}`;
+  const h = "[a-f0-9]{1,4}";
+  const domain = "(?!.*[^.]{64,})(?:(?:xn--)?[a-z0-9]+(?:-+[a-z0-9]+)*\\.){1,126}(?:[a-z][a-z0-9]*|xn--[a-z0-9]+)(?:-+[a-z0-9]+)*";
+  const v6 = `IPv6:(?:${h}(?::${h}){7}|(?!(?:.*[a-f0-9][:\\]]){7,})(?:${h}(?::${h}){0,5})?::(?:${h}(?::${h}){0,5})?)`;
+  const v6v4 = `(?:IPv6:(?:${h}(?::${h}){5}:|(?!(?:.*[a-f0-9]:){5,})(?:${h}(?::${h}){0,3})?::(?:${h}(?::${h}){0,3}:)?))?${ipv4}`;
+  return new RegExp(`^(?!${char}{255,})(?!${char}{65,}@)${word}(?:\\.${word})*@(?:${domain}|\\[(?:${v6}|${v6v4})\\])$`, "i");
+})();
+
+// src/workspace/seed-coerce.ts
+function coerceScalarValue(label, column, type, value, values, scalar) {
+  if (value === null) return null;
+  if (isHostedFile(value)) {
+    if (type.startsWith("blob")) return value;
+    throw new Error(
+      `${label}, column "${column}" (${authoredFieldType(type)}): hostedFile() goes in a file column (image, video, audio or attachment), not a ${authoredFieldType(type)} column. Fix the seed value or the column type.`
+    );
+  }
+  if (scalar !== void 0 && type === "uuid" && !(typeof value === "string" && UUID.test(value))) {
+    throw located(label, column, type, value, 'a uuid ("0b2d382e-dd81-4d56-a291-ecf899ca1d33")');
+  }
+  if (scalar !== void 0 && type === "email" && !(typeof value === "string" && emailAddress(value))) {
+    throw located(label, column, type, value, 'an email address ("ada@example.com")');
+  }
+  if (scalar !== void 0 && type === "vector") {
+    const size = scalar.vectorSize ?? 3;
+    if (!(Array.isArray(value) && value.length === size && value.every((n) => typeof n === "number" && Number.isFinite(n)))) {
+      throw located(label, column, type, value, `an array of exactly ${size} numbers (the column's size)`);
+    }
+    return value;
+  }
+  if (scalar !== void 0 && Object.hasOwn(GEO_TYPE, type)) {
+    const problem = geoProblem(GEO_TYPE[type], value);
+    if (problem !== void 0) throw located(label, column, type, value, problem);
+    return value;
+  }
+  if (scalar !== void 0 && type === "date") {
+    if (typeof value === "number" && Number.isFinite(value) || value instanceof Date && Number.isFinite(value.getTime())) {
+      return value;
+    }
+    if (typeof value === "string" && isCalendarDate(value)) return value;
+    throw located(label, column, type, value, 'a real calendar date ("2026-01-31"), or epoch milliseconds');
+  }
+  switch (Object.hasOwn(SCALAR_FAMILY, type) ? SCALAR_FAMILY[type] : void 0) {
+    case "int":
+      return wholeNumber(label, column, type, value);
+    case "decimal": {
+      let n;
+      if (typeof value === "number" && Number.isFinite(value)) n = value;
+      else if (typeof value === "bigint") n = Number(value);
+      else if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) n = Number(value);
+      if (n === void 0) throw located(label, column, type, value, "a number");
+      if (scalar?.useXdo === false && Math.abs(Math.round(n * 1e5) / 1e5) >= FIXED_DECIMAL_LIMIT) {
+        throw new SeedCellError(
+          (where, shown) => `${where}, column "${column}" (decimal): ${shown} is out of range \u2014 a decimal on a table without \`useXdo: true\` (its own, or the workspace's) holds under 1000000000 (9 digits left of the point), and the deploy fails on a larger one. Store it in an \`f.int\`, or give the table \`useXdo: true\`.`,
+          label,
+          value
+        );
+      }
+      return n;
+    }
+    case "epochms": {
+      if (typeof value === "number" && Number.isFinite(value)) return value;
+      if (value instanceof Date && Number.isFinite(value.getTime())) return value.getTime();
+      if (typeof value === "string") {
+        const ms = isoInstant(value);
+        if (ms !== void 0) return ms;
+      }
+      throw located(
+        label,
+        column,
+        type,
+        value,
+        'epoch ms, a Date, or ISO 8601 with Z or an offset ("2026-01-31T10:00:00Z"; a bare "2026-01-31" is midnight UTC) \u2014 a date-time without a zone reads differently per machine, so add Z or an offset'
+      );
+    }
+    case "bool": {
+      if (typeof value === "boolean") return value;
+      if (value === "true" || value === 1) return true;
+      if (value === "false" || value === 0) return false;
+      throw located(label, column, type, value, "a boolean");
+    }
+    case "text": {
+      if (typeof value === "string") return value;
+      throw located(label, column, type, value, "a string");
+    }
+    case "enum": {
+      if (!values || values.length === 0) return value;
+      if (values.includes(value)) return value;
+      if (typeof value === "number" && !Number.isFinite(value)) throw located(label, column, type, value, "one of its values");
+      const allowed = values.map((v) => JSON.stringify(v)).join(", ");
+      throw new SeedCellError(
+        (where, shown) => `${where}, column "${column}" (enum): ${shown} is not one of its declared values (${allowed}). Fix the seed value or add it to the column's enum.`,
+        label,
+        value
+      );
+    }
+    default:
+      assertJsonCarryable(label, column, type, value);
+      return value;
+  }
+}
+function assertJsonCarryable(label, column, type, value) {
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (node, path) => {
+    if (typeof node === "number") {
+      if (Number.isFinite(node)) return;
+      throw jsonRefusal(
+        label,
+        column,
+        type,
+        path,
+        `${node}, which is not a storable number`,
+        "JSON has no NaN or Infinity, so it would ship as `null` and the column would import empty"
+      );
+    }
+    if (typeof node === "bigint") {
+      throw jsonRefusal(
+        label,
+        column,
+        type,
+        path,
+        "a BigInt",
+        "JSON cannot carry one \u2014 convert it to a number or a string first"
+      );
+    }
+    if (typeof node === "function" || typeof node === "symbol") {
+      throw jsonRefusal(
+        label,
+        column,
+        type,
+        path,
+        `a ${typeof node}`,
+        "JSON drops it, so the key would vanish from the imported row"
+      );
+    }
+    if (node === null || typeof node !== "object") return;
+    if (seen.has(node)) {
+      throw jsonRefusal(
+        label,
+        column,
+        type,
+        path,
+        "a circular reference",
+        "JSON cannot carry one \u2014 the archive would fail to serialize"
+      );
+    }
+    seen.add(node);
+    if (Array.isArray(node)) {
+      node.forEach((el, i) => walk(el, `${path}[${i}]`));
+    } else {
+      for (const [key, member] of Object.entries(node)) walk(member, `${path}.${key}`);
+    }
+    seen.delete(node);
+  };
+  walk(value, `"${column}"`);
+}
+function jsonRefusal(label, column, type, path, got, why) {
+  return new Error(
+    `${label}, column "${column}" (${authoredFieldType(type)}): ${path} is ${got}. ${why}. Seed rows are carried to the engine as JSON \u2014 fix the value or the column type.`
+  );
+}
+function coerceColumnValue(label, col, value, useXdo) {
+  if (value === null) return null;
+  if (isListColumn(col)) {
+    if (!Array.isArray(value)) throw located(label, col.name, `${authoredFieldType(col.type)}[]`, value, "an array");
+    return value.map(
+      (el, j) => coerceScalarValue(label, `${col.name}[${j}]`, col.type, el, col.values)
+    );
+  }
+  return coerceScalarValue(label, col.name, col.type, value, col.values, { useXdo, vectorSize: col.vector?.size });
+}
+function unsafeIntRemedy(n) {
+  const reads = BigInt(n).toString();
+  return `a whole number within \xB19007199254740991 \u2014 past that a JS number cannot hold every whole number, so this one reads as ${reads}, which may not be the digits written; write the digits meant as a digit string or a BigInt \u2014 as it reads now, "${reads}" or ${reads}n \u2014 and in a seedFile quote it in the JSON`;
+}
+var INT64_MIN = -(2n ** 63n);
+var INT64_MAX = 2n ** 63n - 1n;
+function wholeNumber(label, column, type, value) {
+  let big;
+  if (typeof value === "bigint") big = value;
+  else if (typeof value === "string" && /^\s*[+-]?\d+\s*$/.test(value)) big = BigInt(value.trim());
+  else {
+    const n2 = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+    if (Number.isFinite(n2) && !Number.isInteger(n2)) {
+      throw located(label, column, type, value, "a whole number (an int column drops the fraction)");
+    }
+    if (Number.isInteger(n2)) {
+      if (!Number.isSafeInteger(n2) && Math.abs(n2) <= 2 ** 63) {
+        throw located(label, column, type, value, unsafeIntRemedy(n2));
+      }
+      big = BigInt(n2);
+    }
+  }
+  if (big === void 0) throw located(label, column, type, value, "a number");
+  if (big < INT64_MIN || big > INT64_MAX) {
+    throw located(label, column, type, value, "a whole number within int64 (\xB19223372036854775807)");
+  }
+  const n = Number(big);
+  return Number.isSafeInteger(n) ? n : big.toString();
+}
+function isoInstant(value) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?([Zz]|[+-]\d{2}(?::?\d{2})?))?$/.exec(value);
+  if (m === null) return void 0;
+  const [y, mo, d, h = 0, mi = 0, sec = 0] = [m[1], m[2], m[3], m[4], m[5], m[6]].map((v) => v === void 0 ? void 0 : Number(v));
+  if (!isCalendarDate(`${m[1]}-${m[2]}-${m[3]}`) || h > 23 || mi > 59 || sec > 59) return void 0;
+  let offset = 0;
+  const zone = /^([+-])(\d{2}):?(\d{2})?$/.exec(m[8] ?? "");
+  if (zone !== null) {
+    const [oh, om] = [Number(zone[2]), Number(zone[3] ?? 0)];
+    if (oh > 23 || om > 59) return void 0;
+    offset = (zone[1] === "-" ? -1 : 1) * (oh * 60 + om) * 6e4;
+  }
+  const at = new Date(Date.UTC(2e3, mo - 1, d, h, mi, sec, Number((m[7] ?? "").padEnd(3, "0").slice(0, 3))));
+  at.setUTCFullYear(y);
+  return at.getTime() - offset;
+}
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+  return UUID.test(value);
+}
+var GEO_TYPE = {
+  geo_point: "point",
+  geo_multipoint: "points",
+  geo_linestring: "path",
+  geo_multilinestring: "paths",
+  geo_polygon: "poly",
+  geo_multipolygon: "polys"
+};
+function geoProblem(name, value) {
+  if (typeof value === "string") return void 0;
+  const position = (p) => typeof p === "object" && p !== null && Number.isFinite(p.lng) && Number.isFinite(p.lat);
+  const positions = (d) => Array.isArray(d) && d.every(position);
+  const v = value;
+  const data = typeof v === "object" && v !== null && !Array.isArray(v) && v.type === name ? v.data : void 0;
+  const fits = name === "point" ? position(data) : name === "paths" || name === "polys" ? Array.isArray(data) && data.every(positions) : positions(data);
+  if (fits) return void 0;
+  const shape = name === "point" ? "{ lng, lat }" : name === "paths" || name === "polys" ? "[[{ lng, lat }, \u2026], \u2026]" : "[{ lng, lat }, \u2026]";
+  return `{ type: "${name}", data: ${shape} } (not GeoJSON)`;
+}
+var FIXED_DECIMAL_LIMIT = 1e9;
+function isCalendarDate(value) {
+  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[T ].*)?$/.exec(value);
+  if (m === null) return false;
+  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  const day = new Date(Date.UTC(y, mo - 1, d));
+  return mo >= 1 && mo <= 12 && day.getUTCMonth() === mo - 1 && day.getUTCDate() === d;
+}
+function located(label, column, type, value, expected) {
+  const got = value instanceof Date ? "Date" : Array.isArray(value) ? "array" : typeof value;
+  const nonFinite = typeof value === "number" && !Number.isFinite(value);
+  return new SeedCellError(
+    (where, shown) => `${where}, column "${column}" (${authoredFieldType(type)}): ` + (nonFinite ? `${String(value)} is not a storable number. ` : `expected ${expected}, got ${got} (${shown}). `) + `Fix the seed value or the column type.`,
+    label,
+    value
+  );
+}
+var SeedCellError = class extends Error {
+  constructor(render, where, value) {
+    super(render(where, shownValue(value)));
+    this.render = render;
+    this.value = value;
+  }
+  render;
+  value;
+};
+var SHOWN_MAX = 80;
+function shownValue(value) {
+  const json = typeof value === "bigint" ? `${value}n` : JSON.stringify(value) ?? String(value);
+  return json.length > SHOWN_MAX ? `${json.slice(0, SHOWN_MAX - 1)}\u2026` : json;
+}
+var GROUP_SAMPLE = 5;
+function groupRowProblems(tableName, problems) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const p of problems) {
+    const key = p.render("\0", "\0");
+    const list = groups.get(key);
+    if (list === void 0) groups.set(key, [p]);
+    else list.push(p);
+  }
+  return [...groups.values()].map((list) => {
+    const first = list[0];
+    if (list.length === 1) return first.render(`table "${tableName}", seed row ${first.row}`, shownValue(first.value));
+    const rows = list.slice(0, GROUP_SAMPLE).map((p) => p.row).join(", ") + (list.length > GROUP_SAMPLE ? ", \u2026" : "");
+    const distinct = [...new Set(list.map((p) => shownValue(p.value)))];
+    const shown = distinct.slice(0, GROUP_SAMPLE).join(", ") + (distinct.length > GROUP_SAMPLE ? `, \u2026 (${distinct.length} distinct)` : "");
+    return first.render(`table "${tableName}", ${list.length} seed rows (${rows})`, shown);
+  });
+}
+function coerceSeedRowValues(tableName, columns, rows, opts = {}) {
+  const colByName = new Map(columns.map((c) => [c.name, c]));
+  const mustSupply = columns.filter(mustSupplyInSeed);
+  const problems = [];
+  const out = rows.map((row, i) => {
+    const label = `table "${tableName}", seed row ${i}`;
+    const say = (render) => {
+      problems.push({ row: i, render });
+    };
+    const coerced = /* @__PURE__ */ Object.create(null);
+    if (row === null || typeof row !== "object" || Array.isArray(row)) {
+      const got = Array.isArray(row) ? "array" : typeof row;
+      say((where) => `${where}: expected a row object, got ${got}.`);
+      return coerced;
+    }
+    for (const [key, value] of Object.entries(row)) {
+      if (value === void 0) continue;
+      const col = colByName.get(key);
+      if (col === void 0) {
+        const known = columns.map((c) => c.name).join(", ");
+        problems.push({
+          row: i,
+          render: (where, shown) => `${where}: unknown column ${shown} (not in table schema). Known columns: ${known}.`,
+          value: key
+        });
+        continue;
+      }
+      if (value === null && !acceptsSeedNull(col)) {
+        say(
+          (where) => `${where}, column "${key}" (${authoredFieldType(col.type)}): null in a column that is not nullable. The engine does not store it as null \u2014 a date fails the deploy, int/decimal/timestamp store 0, text "", bool false. Give the column \`nullable: true\`, or the row a value.`
+        );
+        continue;
+      }
+      try {
+        coerced[key] = coerceColumnValue(label, col, value, opts.useXdo === true);
+      } catch (err) {
+        if (err instanceof SeedCellError) problems.push({ row: i, render: err.render, value: err.value });
+        else {
+          const message = err.message;
+          const rest = message.startsWith(label) ? message.slice(label.length) : null;
+          say((where) => rest === null ? message : where + rest);
+        }
+      }
+    }
+    const missing = mustSupply.filter((c) => row[c.name] === void 0).map((c) => `"${c.name}"`);
+    if (missing.length > 0) {
+      say(
+        (where) => `${where}: missing required column${missing.length === 1 ? "" : "s"} ${missing.join(", ")}. Supply ${missing.length === 1 ? "it" : "them"} on every row, or give the column a \`default\` (or \`nullable: true\`).`
+      );
+    }
+    return coerced;
+  });
+  problems.push(...partlySetDates(columns, rows));
+  if (problems.length > 0) throw seedError(groupRowProblems(tableName, problems), tableName);
+  return out;
+}
+function partlySetDates(columns, rows) {
+  const out = [];
+  for (const col of columns) {
+    if (col.type !== "date" || isListColumn(col) || acceptsSeedNull(col) || col.default !== void 0 || mustSupplyInSeed(col)) continue;
+    const isSet = (row) => row !== null && typeof row === "object" && row[col.name] !== void 0;
+    const set = rows.filter(isSet).length;
+    if (set === 0 || set === rows.length) continue;
+    rows.forEach((row, i) => {
+      if (isSet(row)) return;
+      out.push({
+        row: i,
+        render: (where) => `${where}: leaves out date column "${col.name}", which ${set} other seed row${set === 1 ? " sets" : "s set"} \u2014 the deploy fails on a date column set on some rows and not others. Set it on every row or none, or give the column a \`default\` or \`nullable: true\`.`
+      });
+    });
+  }
+  return out;
+}
+var NULLABLE_BY_DEFAULT = new Set(COLUMN_NULLABLE_TYPES);
+function acceptsSeedNull(col) {
+  if (col.type === "json" || isListColumn(col)) return true;
+  return col.nullable === true || col.nullable === void 0 && NULLABLE_BY_DEFAULT.has(col.type);
+}
+function mustSupplyInSeed(col) {
+  if (col.required !== true || col.default !== void 0) return false;
+  if (col.name === "id" || col.name === "created_at" || col.type === "json") return false;
+  return col.nullable === false || col.nullable === void 0 && !NULLABLE_BY_DEFAULT.has(col.type);
+}
+function seedError(problems, table2) {
+  const listed = problems.slice(0, SEED_PROBLEMS_LISTED);
+  const rest = problems.length - listed.length;
+  const details = listed.map((message) => ({ severity: "error", code: "seed.invalid", message }));
+  if (rest > 0) {
+    details.push({
+      severity: "error",
+      code: "seed.invalid",
+      message: `\u2026 and ${rest} more seed problem${rest === 1 ? "" : "s"}${table2 === void 0 ? "" : ` in table "${table2}"`}, not listed \u2014 fix these and export again to see them.`,
+      unlisted: rest
+    });
+  }
+  return seedFailure(details);
+}
+function seedFailure(details) {
+  const total = problemCount(details);
+  return new DiagnosticError(
+    details.length === 1 ? `xanosdk: ${details[0].message}` : `xanosdk: ${total} seed problems.
+${numberedList(details)}`,
+    details
+  );
+}
+var SEED_PROBLEMS_LISTED = 20;
+function assertSeedIds(tableName, columns, rows) {
+  const idType = columns.find((c) => c.name === "id")?.type;
+  if (idType !== "int" && idType !== "uuid") return false;
+  const withId = rows.filter((r) => r.id !== void 0).length;
+  if (withId === rows.length) return false;
+  if (withId !== 0) {
+    const fill = idType === "int" ? "auto-numbered 1..N" : "assigned a generated uuid";
+    throw new Error(
+      `table "${tableName}": ${withId} of ${rows.length} seed rows set \`id\` and the rest omit it. The engine preserves seed ids and won't auto-fill a missing one, so a mix collides on the primary key. Provide \`id\` for every seed row, or none (they'll be ${fill}).`
+    );
+  }
+  return true;
+}
+function assertSeedUnique(tableName, indexes, rows) {
+  for (const index of indexes) {
+    const type = normalizeIndexType(index.type);
+    if (type !== "primary" && !type.split("|").includes("unique")) continue;
+    const names = index.fields.map((f) => f.name);
+    if (names.length === 0 || names.some((n) => n.includes("."))) continue;
+    const seen = /* @__PURE__ */ new Map();
+    rows.forEach((row, i) => {
+      const values = names.map((n) => row[n]);
+      if (values.some((v) => v === null || v === void 0)) return;
+      const key = JSON.stringify(values);
+      const first = seen.get(key);
+      if (first === void 0) {
+        seen.set(key, i);
+        return;
+      }
+      const shown = names.length === 1 ? `${names[0]} = ${JSON.stringify(values[0])}` : `(${names.join(", ")}) = (${values.map((v) => JSON.stringify(v)).join(", ")})`;
+      throw new Error(
+        `table "${tableName}": seed rows ${first} and ${i} both have ${shown}, which the ${type === "primary" ? "primary key" : `unique index on (${names.join(", ")})`} allows once \u2014 the import fails on the duplicate. Make the values distinct, or drop one row.`
+      );
+    });
+  }
+}
+function isNonPublicColumn(col) {
+  return col.access === "internal" || col.sensitive === true || col.type === "password";
+}
+
+export {
+  assertKnownKeys,
+  expr,
+  isSearchOp,
+  cmp,
+  and,
+  or,
+  mixed,
+  isValue,
+  isGroup,
+  isMixed,
+  isCmpNode,
+  encodeExpression,
+  isRuntimeConditionOp,
+  encodeRuntimeCondition,
+  conditional,
+  SCALAR_FAMILY,
+  SEED_FILE,
+  seedFile,
+  isSeedFileSource,
+  tableColumns,
+  tableIndexes,
+  SYSTEM_COLUMN_NAMES,
+  elideSystemIndexes,
+  encodeIndex,
+  encodeView,
+  encodeColumn,
+  encodeTable,
+  tableKind,
+  table,
+  COLUMN_NAME_UNUSABLE,
+  unusableColumns,
+  emailAddress,
+  isUuid,
+  coerceSeedRowValues,
+  seedFailure,
+  assertSeedIds,
+  assertSeedUnique,
+  isNonPublicColumn
+};
+//# sourceMappingURL=chunk-HVRUQXGD.js.map