@fleox-agent-crm/agentcrm 0.0.0-stage → 0.3.0

package/dist/agent/chunks/schema-7-4-qtSS.mjs

@@ -0,0 +1,203 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+const NEUTRALS = ["zinc", "slate", "stone", "gray", "neutral"];
+const RADII = ["none", "sm", "md", "lg", "xl"];
+const DENSITIES = ["compact", "comfortable"];
+const SIDEBAR_STYLES = ["default", "dark", "accent"];
+const COLOR_MODES = ["system", "light", "dark"];
+const CONTRASTS = ["normal", "high"];
+const BUTTON_STYLES = ["neutral", "accent"];
+const APPEARANCE_DOC_ID = "appearance";
+const MAX_IMAGE_BYTES = 200 * 1024;
+const MAX_CUSTOM_CSS = 50 * 1024;
+const DEFAULT_ACCENT = "#3366ff";
+const HEX_RE = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+function isHexColor(value) {
+  return typeof value === "string" && HEX_RE.test(value.trim());
+}
+function normalizeHex(value) {
+  const m = HEX_RE.exec(value.trim());
+  if (!m) throw new Error(`"${value}" is not a hex color (#rrggbb).`);
+  let h = m[1].toLowerCase();
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  return `#${h}`;
+}
+function hexToRgb(hex) {
+  const h = normalizeHex(hex).slice(1);
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+function rgbToHex([r, g, b]) {
+  const c = (v) => Math.round(Math.min(255, Math.max(0, v))).toString(16).padStart(2, "0");
+  return `#${c(r)}${c(g)}${c(b)}`;
+}
+function mixHex(a, b, t) {
+  const x = hexToRgb(a);
+  const y = hexToRgb(b);
+  return rgbToHex([0, 1, 2].map((i) => x[i] + (y[i] - x[i]) * t));
+}
+const FALLBACK = 'ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif';
+const SYSTEM_FONT_STACK = `Inter, ${FALLBACK}`;
+function google(id, name) {
+  return { id, label: name, family: `"${name}", ${FALLBACK}`, google: name };
+}
+const FONTS = [
+  { id: "system", label: "System (default)", family: SYSTEM_FONT_STACK },
+  google("inter", "Inter"),
+  google("geist", "Geist"),
+  google("roboto", "Roboto"),
+  google("open-sans", "Open Sans"),
+  google("lato", "Lato"),
+  google("source-sans-3", "Source Sans 3"),
+  google("ibm-plex-sans", "IBM Plex Sans"),
+  google("dm-sans", "DM Sans"),
+  google("manrope", "Manrope"),
+  google("work-sans", "Work Sans"),
+  google("plus-jakarta-sans", "Plus Jakarta Sans"),
+  google("figtree", "Figtree"),
+  google("outfit", "Outfit"),
+  google("nunito-sans", "Nunito Sans"),
+  google("poppins", "Poppins"),
+  google("space-grotesk", "Space Grotesk")
+];
+const DEFAULT_APPEARANCE = {
+  preset: "default",
+  accent: DEFAULT_ACCENT,
+  neutral: "zinc",
+  radius: "md",
+  density: "comfortable",
+  font: "system",
+  sidebar: "default",
+  defaultMode: "system",
+  contrast: "normal",
+  buttons: "neutral"
+};
+const APPEARANCE_KEYS = ["preset", "accent", "neutral", "radius", "density", "font", "sidebar", "defaultMode", "contrast", "buttons", "logo", "favicon", "customCss", "themeId"];
+const ENUMS = {
+  neutral: NEUTRALS,
+  radius: RADII,
+  density: DENSITIES,
+  sidebar: SIDEBAR_STYLES,
+  defaultMode: COLOR_MODES,
+  contrast: CONTRASTS,
+  buttons: BUTTON_STYLES
+};
+const IMAGE_RE = /^data:image\/(png|jpeg|gif|webp|svg\+xml|x-icon|vnd\.microsoft\.icon);base64,[A-Za-z0-9+/]+=*$/;
+const ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+function dataUrlBytes(url) {
+  const b64 = url.slice(url.indexOf(",") + 1);
+  const pad = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0;
+  return Math.floor(b64.length * 3 / 4) - pad;
+}
+function validateImageDataUrl(value, label = "image") {
+  if (typeof value !== "string" || !IMAGE_RE.test(value)) return `The ${label} must be a base64 image data URL (PNG, JPEG, GIF, WebP, SVG or ICO).`;
+  const bytes = dataUrlBytes(value);
+  if (bytes > MAX_IMAGE_BYTES) return `The ${label} is ${Math.round(bytes / 1024)} KB — the limit is ${MAX_IMAGE_BYTES / 1024} KB.`;
+  return null;
+}
+function validateAppearancePatch(patch) {
+  const errors = [];
+  const value = {};
+  if (!patch || typeof patch !== "object" || Array.isArray(patch)) return { value, errors: ["The appearance patch must be an object."] };
+  for (const [key, raw] of Object.entries(patch)) {
+    if (!APPEARANCE_KEYS.includes(key)) {
+      errors.push(`Unknown appearance key "${key}". Keys: ${APPEARANCE_KEYS.join(", ")}.`);
+      continue;
+    }
+    const k = key;
+    if (raw === null || raw === void 0) {
+      value[k] = void 0;
+      continue;
+    }
+    const allowed = ENUMS[k];
+    if (allowed) {
+      if (typeof raw !== "string" || !allowed.includes(raw)) errors.push(`${k} must be one of ${allowed.join(", ")}.`);
+      else value[k] = raw;
+      continue;
+    }
+    switch (k) {
+      case "accent":
+        if (!isHexColor(raw)) errors.push("accent must be a hex color like #3366ff.");
+        else value.accent = normalizeHex(raw);
+        break;
+      case "font":
+        if (typeof raw !== "string" || !FONTS.some((f) => f.id === raw)) errors.push(`font must be one of ${FONTS.map((f) => f.id).join(", ")}.`);
+        else value.font = raw;
+        break;
+      case "preset":
+        if (typeof raw !== "string" || !ID_RE.test(raw)) errors.push("preset must be a preset id.");
+        else value.preset = raw;
+        break;
+      case "themeId":
+        if (typeof raw !== "string" || !ID_RE.test(raw)) errors.push("themeId must be an extension id.");
+        else value.themeId = raw;
+        break;
+      case "logo":
+      case "favicon": {
+        if (raw === "") {
+          value[k] = void 0;
+          break;
+        }
+        const err = validateImageDataUrl(raw, k);
+        if (err) errors.push(err);
+        else value[k] = raw;
+        break;
+      }
+      case "customCss": {
+        if (typeof raw !== "string") errors.push("customCss must be a string.");
+        else if (new TextEncoder().encode(raw).length > MAX_CUSTOM_CSS) errors.push(`customCss is larger than ${MAX_CUSTOM_CSS / 1024} KB.`);
+        else if (/<\/?style|<script/i.test(raw)) errors.push("customCss must be plain CSS (no <style> / <script> tags).");
+        else value.customCss = raw.trim() ? raw : void 0;
+        break;
+      }
+    }
+  }
+  return { value, errors };
+}
+function resolveAppearance(stored, theme) {
+  const clean = (o) => {
+    if (!o) return {};
+    const { value } = validateAppearancePatch(Object.fromEntries(Object.entries(o).filter(([k, v]) => APPEARANCE_KEYS.includes(k) && v !== void 0 && v !== null)));
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+  };
+  const themeValues = clean(theme?.appearance);
+  delete themeValues.themeId;
+  delete themeValues.logo;
+  delete themeValues.favicon;
+  return { ...DEFAULT_APPEARANCE, ...themeValues, ...clean(stored) };
+}
+function stripPatchNulls(patch) {
+  return Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== null && v !== void 0));
+}
+const schema = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  APPEARANCE_KEYS,
+  DEFAULT_APPEARANCE,
+  dataUrlBytes,
+  resolveAppearance,
+  stripPatchNulls,
+  validateAppearancePatch,
+  validateImageDataUrl
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  APPEARANCE_DOC_ID as A,
+  BUTTON_STYLES as B,
+  CONTRASTS as C,
+  DEFAULT_ACCENT as D,
+  FONTS as F,
+  NEUTRALS as N,
+  RADII as R,
+  SIDEBAR_STYLES as S,
+  DEFAULT_APPEARANCE as a,
+  validateImageDataUrl as b,
+  APPEARANCE_KEYS as c,
+  COLOR_MODES as d,
+  DENSITIES as e,
+  mixHex as m,
+  resolveAppearance as r,
+  schema as s,
+  validateAppearancePatch as v
+};

package/dist/agent/chunks/schema-DlHt2PxI.mjs

@@ -0,0 +1,367 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { c as camelId } from "./utils-DmI8FtXP.mjs";
+import { colorAt, canConvertType, isEmptyFieldValue, convertValue } from "./fields-B0bitgmr.mjs";
+import { s as slugId } from "./ids-CvnmrMJX.mjs";
+import { d as defaultViewFor } from "./standardObjects-CheqfDqa.mjs";
+import { e as FIELD_TYPES } from "../agentcrm.mjs";
+import { assertCan, OpsError } from "./context-CxFfqS4D.mjs";
+import { hardDeleteMutations } from "./records-DoqiT9xR.mjs";
+import { requireObject, objectsOf, pipelinesOf, recordsOf, asDoc, viewsOf, thaw } from "./store-5gqRSKXg.mjs";
+import "node:util";
+import "node:fs";
+import "node:path";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./query-C5nJB_3C.mjs";
+import "./relations-B9TynBmA.mjs";
+function listObjects(ctx) {
+  assertCan(ctx, "records.read");
+  return objectsOf(ctx.store);
+}
+function getObject(ctx, id) {
+  assertCan(ctx, "records.read");
+  return requireObject(ctx.store, id);
+}
+function describeSchema(ctx, objectId) {
+  assertCan(ctx, "records.read");
+  const objects = objectId ? [requireObject(ctx.store, objectId)] : objectsOf(ctx.store);
+  return objects.map((o) => ({
+    id: o.id,
+    label: o.labelPlural,
+    singular: o.labelSingular,
+    labelField: o.labelField,
+    ...o.imageField ? { imageField: o.imageField } : {},
+    standard: o.standard,
+    count: recordsOf(ctx.store, o.id).length,
+    fields: o.fields.map((f) => ({
+      id: f.id,
+      label: f.label,
+      type: f.type,
+      ...f.required ? { required: true } : {},
+      ...f.unique ? { unique: true } : {},
+      ...f.system ? { system: true } : {},
+      ...f.hidden ? { hidden: true } : {},
+      ...f.options ? { options: f.options.map((x) => ({ id: x.id, label: x.label })) } : {},
+      ...f.relation ? { relation: f.relation } : {},
+      ...f.currency ? { currency: f.currency } : {}
+    })),
+    pipelines: pipelinesOf(ctx.store, o.id).map((p) => ({ id: p.id, name: p.name, stages: p.stages.map((s) => ({ id: s.id, label: s.label, kind: s.kind, probability: s.probability })) }))
+  }));
+}
+function saveObject(ctx, object) {
+  return { op: "set", collection: "objects", doc: asDoc({ ...object, updatedAt: ctx.now() }) };
+}
+async function createObject(ctx, input) {
+  assertCan(ctx, "schema.write");
+  const singular = input.labelSingular?.trim();
+  const plural = input.labelPlural?.trim() || (singular ? `${singular}s` : "");
+  if (!singular) throw new OpsError("validation", "An object needs a name.");
+  const taken = objectsOf(ctx.store).map((o) => o.id);
+  const id = input.id ? input.id : slugId(plural, taken);
+  if (!/^[a-z][a-z0-9-]{1,40}$/.test(id)) throw new OpsError("validation", `Invalid object id "${id}" (lower-case letters, digits, dashes).`);
+  if (taken.includes(id)) throw new OpsError("conflict", `Object "${id}" already exists.`);
+  const now = ctx.now();
+  let object = {
+    id,
+    labelSingular: singular,
+    labelPlural: plural,
+    icon: input.icon ?? "Box",
+    color: input.color ?? colorAt(taken.length + 3),
+    standard: false,
+    labelField: "name",
+    fields: [{ id: "name", label: "Name", type: "text", required: true, system: true }],
+    createdAt: now,
+    updatedAt: now
+  };
+  for (const f of input.fields ?? []) object = { ...object, fields: [...object.fields, buildField(ctx, object, f)] };
+  const view = defaultViewFor(object);
+  await ctx.store.write(
+    [
+      { op: "set", collection: "objects", doc: asDoc(object) },
+      ...ctx.store.get("views", view.id) ? [] : [{ op: "set", collection: "views", doc: asDoc(view) }]
+    ],
+    { message: `Create object ${plural}` }
+  );
+  return requireObject(ctx.store, id);
+}
+async function updateObject(ctx, id, patch) {
+  assertCan(ctx, "schema.write");
+  const object = thaw(requireObject(ctx.store, id));
+  if (patch.labelSingular !== void 0) object.labelSingular = patch.labelSingular.trim() || object.labelSingular;
+  if (patch.labelPlural !== void 0) object.labelPlural = patch.labelPlural.trim() || object.labelPlural;
+  if (patch.icon !== void 0) object.icon = patch.icon;
+  if (patch.color !== void 0) object.color = patch.color;
+  if (patch.labelField !== void 0) {
+    const f = object.fields.find((x) => x.id === patch.labelField);
+    if (!f || !["text", "email", "url", "phone"].includes(f.type)) throw new OpsError("validation", `"${patch.labelField}" can't be the label field (needs a text field).`);
+    object.labelField = patch.labelField;
+  }
+  if (patch.imageField !== void 0) {
+    if (patch.imageField === null || patch.imageField === "") delete object.imageField;
+    else {
+      const f = object.fields.find((x) => x.id === patch.imageField);
+      if (!f || f.type !== "image") throw new OpsError("validation", `"${patch.imageField}" can't be the image field (needs an image field).`);
+      object.imageField = patch.imageField;
+    }
+  }
+  await ctx.store.write([saveObject(ctx, object)], { message: `Update object ${object.labelPlural}` });
+  return requireObject(ctx.store, id);
+}
+async function deleteObject(ctx, id) {
+  assertCan(ctx, "schema.write");
+  const object = requireObject(ctx.store, id);
+  if (object.standard) throw new OpsError("invalid", `${object.labelPlural} is a standard object and can't be deleted.`);
+  if (pipelinesOf(ctx.store, id).length) throw new OpsError("invalid", `Delete the pipelines of ${object.labelPlural} first.`);
+  const records = recordsOf(ctx.store, id, { includeDeleted: true });
+  const mutations = [{ op: "delete", collection: "objects", id }, ...hardDeleteMutations(ctx, records.map((r) => r.id))];
+  for (const v of viewsOf(ctx.store, id)) mutations.push({ op: "delete", collection: "views", id: v.id });
+  for (const other of objectsOf(ctx.store)) {
+    if (other.id === id) continue;
+    const kept = other.fields.filter((f) => !(f.type === "relation" && f.relation?.object === id));
+    if (kept.length !== other.fields.length) {
+      mutations.push(saveObject(ctx, { ...other, fields: kept }));
+      for (const f of other.fields.filter((x) => !kept.includes(x))) mutations.push(...clearFieldValues(ctx, other.id, f.id));
+    }
+  }
+  await ctx.store.write(dedupeMutations(mutations), { message: `Delete object ${object.labelPlural}` });
+  return { id, records: records.length };
+}
+function dedupeMutations(mutations) {
+  const deleted = new Set(mutations.filter((m) => m.op === "delete").map((m) => `${m.collection}/${m.id}`));
+  return mutations.filter((m) => m.op === "delete" || !deleted.has(`${m.collection}/${m.op === "set" ? m.doc.id : m.id}`));
+}
+function buildOptions(input, existing = []) {
+  const out = [];
+  (input ?? []).forEach((o, i) => {
+    const label = (typeof o === "string" ? o : o.label ?? "").trim();
+    if (!label) return;
+    const wanted = typeof o === "string" ? void 0 : o.id;
+    const prev = existing.find((e) => e.id === wanted) ?? existing.find((e) => e.label.toLowerCase() === label.toLowerCase());
+    const id = prev?.id ?? (wanted && !out.some((x) => x.id === wanted) ? wanted : slugId(label, out.map((x) => x.id)));
+    out.push({ id, label, color: (typeof o === "string" ? void 0 : o.color) ?? prev?.color ?? colorAt(i) });
+  });
+  return out;
+}
+function buildField(ctx, object, input) {
+  const label = input.label?.trim();
+  if (!label) throw new OpsError("validation", "A field needs a label.");
+  if (!FIELD_TYPES.includes(input.type)) throw new OpsError("validation", `Unknown field type "${input.type}". Types: ${FIELD_TYPES.join(", ")}.`);
+  const taken = new Set(object.fields.map((f) => f.id));
+  let id = input.id ?? camelId(label);
+  if (!id) id = "field";
+  if (!/^[a-zA-Z][a-zA-Z0-9_]{0,40}$/.test(id)) throw new OpsError("validation", `Invalid field id "${id}".`);
+  if (input.id && taken.has(id)) throw new OpsError("conflict", `Field "${id}" already exists on ${object.labelPlural}.`);
+  if (["id", "object", "ownerId", "createdAt", "updatedAt", "createdBy", "updatedBy", "deletedAt"].includes(id)) id = `${id}Field`;
+  for (let i = 2; taken.has(id); i++) id = `${camelId(label) || "field"}${i}`;
+  const field = { id, label, type: input.type };
+  if (input.description) field.description = input.description;
+  if (input.required) field.required = true;
+  if (input.unique) field.unique = true;
+  if (input.hidden) field.hidden = true;
+  if (input.type === "select" || input.type === "multiSelect") field.options = buildOptions(input.options);
+  if (input.type === "currency") field.currency = (input.currency ?? "USD").toUpperCase();
+  if (input.type === "relation") {
+    const rel = input.relation;
+    if (!rel?.object) throw new OpsError("validation", "A relation field needs a target object.");
+    requireObject(ctx.store, rel.object);
+    field.relation = { object: rel.object, cardinality: rel.cardinality === "many" ? "many" : "one", ...rel.inverseField ? { inverseField: rel.inverseField } : {} };
+  }
+  if (input.defaultValue !== void 0) field.defaultValue = input.defaultValue;
+  return field;
+}
+async function createField(ctx, objectId, input) {
+  assertCan(ctx, "schema.write");
+  const object = requireObject(ctx.store, objectId);
+  const field = buildField(ctx, object, input);
+  const imageField = object.imageField ?? (field.type === "image" ? field.id : void 0);
+  await ctx.store.write([saveObject(ctx, { ...object, ...imageField ? { imageField } : {}, fields: [...object.fields, field] })], { message: `Add field ${field.label}` });
+  return field;
+}
+function requireField(object, fieldId) {
+  const f = object.fields.find((x) => x.id === fieldId);
+  if (!f) throw new OpsError("notFound", `Field "${fieldId}" not found on ${object.labelPlural}.`);
+  return f;
+}
+function isPipelineManaged(ctx, objectId, fieldId) {
+  const pipelines = pipelinesOf(ctx.store, objectId);
+  return pipelines.some((p) => p.stageField === fieldId) || fieldId === "pipeline" && pipelines.length > 0;
+}
+async function updateField(ctx, objectId, fieldId, patch) {
+  assertCan(ctx, "schema.write");
+  const object = requireObject(ctx.store, objectId);
+  const before = requireField(object, fieldId);
+  let field = thaw(before);
+  if (patch.label !== void 0) {
+    if (!patch.label.trim()) throw new OpsError("validation", "A field needs a label.");
+    field.label = patch.label.trim();
+  }
+  if (patch.description !== void 0) field.description = patch.description || void 0;
+  if (patch.required !== void 0) field.required = patch.required || void 0;
+  if (patch.unique !== void 0) field.unique = patch.unique || void 0;
+  if (patch.hidden !== void 0) {
+    if (patch.hidden && fieldId === object.labelField) throw new OpsError("invalid", "The label field can't be hidden.");
+    field.hidden = patch.hidden || void 0;
+  }
+  if (patch.currency !== void 0) field.currency = patch.currency.toUpperCase();
+  if (patch.defaultValue !== void 0) field.defaultValue = patch.defaultValue;
+  const mutations = [];
+  let converted;
+  let cleared;
+  if (patch.type !== void 0 && patch.type !== before.type) {
+    if (before.system || isPipelineManaged(ctx, objectId, fieldId)) throw new OpsError("invalid", `${before.label} is a system field: its type can't change.`);
+    if (!FIELD_TYPES.includes(patch.type)) throw new OpsError("validation", `Unknown field type "${patch.type}".`);
+    if (!canConvertType(before.type, patch.type)) throw new OpsError("invalid", `Can't convert ${before.type} to ${patch.type}.`);
+    field = { ...field, type: patch.type };
+    if (patch.type === "select" || patch.type === "multiSelect") {
+      if (!patch.options && !field.options?.length) {
+        const values = /* @__PURE__ */ new Set();
+        for (const r of recordsOf(ctx.store, objectId, { includeDeleted: true })) {
+          const v = r.fields[fieldId];
+          for (const x of Array.isArray(v) ? v : [v]) if (x !== void 0 && x !== null && String(x).trim()) values.add(before.type === "select" || before.type === "multiSelect" ? before.options?.find((o) => o.id === x)?.label ?? String(x) : String(x).trim());
+        }
+        field.options = buildOptions([...values].slice(0, 200));
+      }
+    } else {
+      delete field.options;
+    }
+    if (patch.type === "currency") field.currency = field.currency ?? "USD";
+    if (patch.type !== "relation") delete field.relation;
+    converted = 0;
+    cleared = 0;
+    const migrateTo = patch.options ? { ...field, options: buildOptions(patch.options, field.options) } : field;
+    for (const r of recordsOf(ctx.store, objectId, { includeDeleted: true })) {
+      const v = r.fields[fieldId];
+      if (isEmptyFieldValue(before, v)) continue;
+      const next = convertValue(before, migrateTo, v);
+      if (next === void 0) cleared++;
+      else converted++;
+      mutations.push({ op: "patch", collection: "records", id: r.id, fields: { [`fields.${fieldId}`]: next } });
+    }
+  }
+  if (patch.options !== void 0) {
+    if (isPipelineManaged(ctx, objectId, fieldId)) throw new OpsError("invalid", `${before.label} options mirror the pipelines — edit the pipeline stages instead.`);
+    if (field.type !== "select" && field.type !== "multiSelect") throw new OpsError("invalid", `${field.label} has no options.`);
+    const nextOptions = buildOptions(patch.options, before.options);
+    const kept = new Set(nextOptions.map((o) => o.id));
+    if (before.type === field.type) {
+      for (const r of recordsOf(ctx.store, objectId, { includeDeleted: true })) {
+        const v = r.fields[fieldId];
+        if (field.type === "select" && typeof v === "string" && !kept.has(v)) mutations.push({ op: "patch", collection: "records", id: r.id, fields: { [`fields.${fieldId}`]: void 0 } });
+        if (field.type === "multiSelect" && Array.isArray(v) && v.some((x) => !kept.has(x))) {
+          const rest = v.filter((x) => kept.has(x));
+          mutations.push({ op: "patch", collection: "records", id: r.id, fields: { [`fields.${fieldId}`]: rest.length ? rest : void 0 } });
+        }
+      }
+    }
+    field.options = nextOptions;
+  }
+  const fields = object.fields.map((f) => f.id === fieldId ? field : f);
+  const nextObject = { ...object, fields };
+  if (object.imageField === fieldId && field.type !== "image") delete nextObject.imageField;
+  mutations.unshift(saveObject(ctx, nextObject));
+  await ctx.store.write(mutations, { message: `Update field ${field.label}` });
+  return { field: requireField(requireObject(ctx.store, objectId), fieldId), ...converted !== void 0 ? { converted, cleared } : {} };
+}
+function changeFieldType(ctx, objectId, fieldId, type, options) {
+  return updateField(ctx, objectId, fieldId, { type, ...options ? { options } : {} });
+}
+function clearFieldValues(ctx, objectId, fieldId) {
+  return recordsOf(ctx.store, objectId, { includeDeleted: true }).filter((r) => r.fields[fieldId] !== void 0).map((r) => ({ op: "patch", collection: "records", id: r.id, fields: { [`fields.${fieldId}`]: void 0 } }));
+}
+async function deleteField(ctx, objectId, fieldId) {
+  assertCan(ctx, "schema.write");
+  const object = requireObject(ctx.store, objectId);
+  const field = requireField(object, fieldId);
+  if (field.system) throw new OpsError("invalid", `${field.label} is a system field and can't be deleted.`);
+  if (field.standard) throw new OpsError("invalid", `${field.label} is a standard field: hide it instead of deleting it.`);
+  if (fieldId === object.labelField) throw new OpsError("invalid", "The label field can't be deleted.");
+  if (isPipelineManaged(ctx, objectId, fieldId)) throw new OpsError("invalid", `${field.label} holds pipeline stages.`);
+  const clears = clearFieldValues(ctx, objectId, fieldId);
+  const rest = { ...object, fields: object.fields.filter((f) => f.id !== fieldId) };
+  if (rest.imageField === fieldId) delete rest.imageField;
+  const mutations = [saveObject(ctx, rest), ...clears];
+  for (const v of viewsOf(ctx.store, objectId)) {
+    const usesField = v.columns.includes(fieldId) || v.filters.some((f) => f.field === fieldId) || v.sorts.some((s) => s.field === fieldId) || v.groupBy === fieldId;
+    if (!usesField) continue;
+    mutations.push({
+      op: "patch",
+      collection: "views",
+      id: v.id,
+      fields: {
+        columns: v.columns.filter((c) => c !== fieldId),
+        filters: v.filters.filter((f) => f.field !== fieldId),
+        sorts: v.sorts.filter((s) => s.field !== fieldId),
+        groupBy: v.groupBy === fieldId ? void 0 : v.groupBy
+      }
+    });
+  }
+  await ctx.store.write(mutations, { message: `Delete field ${field.label}` });
+  return { id: fieldId, cleared: clears.length };
+}
+async function reorderFields(ctx, objectId, order) {
+  assertCan(ctx, "schema.write");
+  const object = requireObject(ctx.store, objectId);
+  const pos = new Map(order.map((id, i) => [id, i]));
+  const fields = [...object.fields].sort((a, b) => (pos.get(a.id) ?? 1e6 + object.fields.indexOf(a)) - (pos.get(b.id) ?? 1e6 + object.fields.indexOf(b)));
+  await ctx.store.write([saveObject(ctx, { ...object, fields })], { message: "Reorder fields" });
+  return requireObject(ctx.store, objectId);
+}
+async function addOption(ctx, objectId, fieldId, option) {
+  const field = requireField(requireObject(ctx.store, objectId), fieldId);
+  const res = await updateField(ctx, objectId, fieldId, { options: [...field.options ?? [], option] });
+  return res.field.options[res.field.options.length - 1];
+}
+async function updateOption(ctx, objectId, fieldId, optionId, patch) {
+  const field = requireField(requireObject(ctx.store, objectId), fieldId);
+  if (!field.options?.some((o) => o.id === optionId)) throw new OpsError("notFound", `Option "${optionId}" not found on ${field.label}.`);
+  const res = await updateField(ctx, objectId, fieldId, { options: field.options.map((o) => o.id === optionId ? { ...o, ...patch } : o) });
+  return res.field.options.find((o) => o.id === optionId);
+}
+async function removeOption(ctx, objectId, fieldId, optionId, opts = {}) {
+  assertCan(ctx, "schema.write");
+  const object = requireObject(ctx.store, objectId);
+  const field = requireField(object, fieldId);
+  if (isPipelineManaged(ctx, objectId, fieldId)) throw new OpsError("invalid", `${field.label} options mirror the pipelines — edit the pipeline stages instead.`);
+  if (!field.options?.some((o) => o.id === optionId)) throw new OpsError("notFound", `Option "${optionId}" not found on ${field.label}.`);
+  if (opts.replaceWith && !field.options.some((o) => o.id === opts.replaceWith && o.id !== optionId)) throw new OpsError("validation", `Unknown replacement option "${opts.replaceWith}".`);
+  const mutations = [saveObject(ctx, { ...object, fields: object.fields.map((f) => f.id === fieldId ? { ...f, options: f.options.filter((o) => o.id !== optionId) } : f) })];
+  let moved = 0;
+  for (const r of recordsOf(ctx.store, objectId, { includeDeleted: true })) {
+    const v = r.fields[fieldId];
+    if (field.type === "select" && v === optionId) {
+      moved++;
+      mutations.push({ op: "patch", collection: "records", id: r.id, fields: { [`fields.${fieldId}`]: opts.replaceWith } });
+    } else if (field.type === "multiSelect" && Array.isArray(v) && v.includes(optionId)) {
+      moved++;
+      const next = [...new Set(v.map((x) => x === optionId ? opts.replaceWith : x).filter(Boolean))];
+      mutations.push({ op: "patch", collection: "records", id: r.id, fields: { [`fields.${fieldId}`]: next.length ? next : void 0 } });
+    }
+  }
+  await ctx.store.write(mutations, { message: `Remove option from ${field.label}` });
+  return { moved };
+}
+export {
+  addOption,
+  changeFieldType,
+  createField,
+  createObject,
+  deleteField,
+  deleteObject,
+  describeSchema,
+  getObject,
+  listObjects,
+  removeOption,
+  reorderFields,
+  updateField,
+  updateObject,
+  updateOption
+};