@stndrds/schema 1.0.0-alpha.264 → 1.0.0-alpha.266

package/dist/chunk-F6ATLCIR.mjs

@@ -0,0 +1,1214 @@
+import { SCHEMA_LIMITS, iconNameSchema } from './chunk-KDHDC7E6.mjs';
+import { ValidationError } from './chunk-POULKEJM.mjs';
+import { z } from 'zod';
+
+// src/types/system-attributes.ts
+var SYSTEM_ATTRIBUTE_I18N_KEYS = {
+  createdAt: "createdAt",
+  updatedAt: "updatedAt",
+  createdBy: "createdBy",
+  lastUpdatedBy: "lastUpdatedBy",
+  attachments: "attachments"
+};
+function getSystemAttributeI18nKey(name) {
+  return SYSTEM_ATTRIBUTE_I18N_KEYS[name];
+}
+var SYSTEM_ATTRIBUTES = {
+  createdAt: {
+    id: "system:createdAt",
+    name: "createdAt",
+    label: "Created time",
+    type: "date",
+    required: false,
+    system: true,
+    icon: "clock-circle",
+    description: "When this record was created"
+  },
+  updatedAt: {
+    id: "system:updatedAt",
+    name: "updatedAt",
+    label: "Last edited time",
+    type: "date",
+    required: false,
+    system: true,
+    icon: "clock-circle",
+    description: "When this record was last modified"
+  },
+  createdBy: {
+    id: "system:createdBy",
+    name: "createdBy",
+    label: "Created by",
+    type: "user",
+    required: false,
+    system: true,
+    multiple: false,
+    icon: "user",
+    description: "Actor who created this record"
+  },
+  lastUpdatedBy: {
+    id: "system:lastUpdatedBy",
+    name: "lastUpdatedBy",
+    label: "Last edited by",
+    type: "user",
+    required: false,
+    system: true,
+    multiple: false,
+    icon: "user",
+    description: "Actor who last modified this record"
+  },
+  /**
+   * System attribute for free-form document attachments.
+   * Hidden from forms, visible in Documents tab.
+   * Users can attach any document without template constraints.
+   */
+  attachments: {
+    id: "system:attachments",
+    name: "attachments",
+    label: "Attachments",
+    type: "document",
+    required: false,
+    system: true,
+    hidden: true,
+    // Hidden from regular form views
+    icon: "paperclip",
+    description: "Free-form document attachments"
+  }
+};
+function getSystemAttributeList() {
+  return Object.values(SYSTEM_ATTRIBUTES);
+}
+function isManagedSystemAttribute(attribute) {
+  return attribute.id?.startsWith("system:") ?? false;
+}
+
+// src/types/attribute-capabilities.ts
+var TEXT_OPERATORS = [
+  "is",
+  "is_not",
+  "contains",
+  "not_contains",
+  "starts_with",
+  "ends_with",
+  "is_empty",
+  "is_not_empty"
+];
+var NUMBER_OPERATORS = [
+  "is",
+  "is_not",
+  "less_than",
+  "greater_than",
+  "less_or_equal",
+  "greater_or_equal",
+  "is_empty",
+  "is_not_empty"
+];
+var CHECKBOX_OPERATORS = ["is"];
+var DATE_OPERATORS = [
+  "is",
+  "is_not",
+  "less_than",
+  "greater_than",
+  "less_or_equal",
+  "greater_or_equal",
+  "is_within",
+  "on_day_month",
+  "is_empty",
+  "is_not_empty"
+];
+var SELECT_OPERATORS = [
+  "is",
+  "is_not",
+  "any_of",
+  "none_of",
+  "is_empty",
+  "is_not_empty"
+];
+var MULTISELECT_OPERATORS = [
+  "any_of",
+  "none_of",
+  "is_empty",
+  "is_not_empty"
+];
+var REFERENCE_OPERATORS = [
+  "is",
+  "is_not",
+  "any_of",
+  "none_of",
+  "is_empty",
+  "is_not_empty"
+];
+var PRESENCE_OPERATORS = [
+  "is_empty",
+  "is_not_empty"
+];
+var FORMULA_OPERATORS = [
+  "is",
+  "is_not",
+  "less_than",
+  "greater_than",
+  "less_or_equal",
+  "greater_or_equal",
+  "contains",
+  "not_contains",
+  "is_empty",
+  "is_not_empty"
+];
+var ATTRIBUTE_FILTER_OPERATORS = {
+  text: TEXT_OPERATORS,
+  richtext: [],
+  number: NUMBER_OPERATORS,
+  checkbox: CHECKBOX_OPERATORS,
+  date: DATE_OPERATORS,
+  phone: ["is", "is_not", "contains", "not_contains", "starts_with", "is_empty", "is_not_empty"],
+  currency: NUMBER_OPERATORS,
+  status: SELECT_OPERATORS,
+  select: SELECT_OPERATORS,
+  multiselect: MULTISELECT_OPERATORS,
+  location: [],
+  user: REFERENCE_OPERATORS,
+  relation: REFERENCE_OPERATORS,
+  formula: FORMULA_OPERATORS,
+  document: PRESENCE_OPERATORS
+};
+var COMPUTED_TYPES = /* @__PURE__ */ new Set(["formula", "rollup"]);
+var EDGE_BACKED_TYPES = /* @__PURE__ */ new Set(["user", "relation", "document"]);
+var STATIC_DEFAULT_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "richtext",
+  "number",
+  "select",
+  "multiselect",
+  "status",
+  "date",
+  "phone",
+  "currency",
+  "location",
+  "user",
+  "relation",
+  "document"
+]);
+var PLACEHOLDER_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "number",
+  "date",
+  "phone",
+  "currency",
+  "select",
+  "multiselect"
+]);
+var SEARCHABLE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "phone",
+  "status",
+  "select",
+  "multiselect"
+]);
+var SORTABLE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "number",
+  "checkbox",
+  "date",
+  "phone",
+  "currency",
+  "status",
+  "select"
+]);
+function getAttributeCapabilities(attribute) {
+  const suppressed = Boolean(attribute.hidden || attribute.archived);
+  const active = !attribute.archived;
+  const computed = COMPUTED_TYPES.has(attribute.type);
+  const document = attribute.type === "document";
+  const edgeBacked = EDGE_BACKED_TYPES.has(attribute.type);
+  const cardinality = getAttributeCardinality(attribute);
+  const operators = suppressed ? [] : getRawFilterOperators(attribute);
+  const filterable = operators.length > 0 && !suppressed;
+  const searchable = !suppressed && SEARCHABLE_TYPES.has(attribute.type);
+  const sortable = !suppressed && SORTABLE_TYPES.has(attribute.type);
+  const groupable = !suppressed && isGroupableType(attribute.type);
+  const kanbanGroupable = !suppressed && attribute.type === "status";
+  const managed = isManagedSystemAttribute(attribute);
+  const readOnly = computed || document || managed;
+  const editable = !(suppressed || readOnly);
+  const required = isRequiredForbidden(attribute.type) ? "forbidden" : "allowed";
+  const defaultValue = getDefaultValueCapability(attribute.type);
+  const maxItems = supportsMaxItems(attribute);
+  const placeholder = PLACEHOLDER_TYPES.has(attribute.type);
+  const warningWhenDeprecated = Boolean(attribute.deprecated && !suppressed);
+  const editMode = resolveEditMode(attribute);
+  return {
+    lifecycle: {
+      active,
+      deprecated: Boolean(attribute.deprecated),
+      visibleInArchitect: true,
+      visibleInRuntime: !suppressed,
+      warningWhenDeprecated
+    },
+    storage: {
+      mode: computed ? "computed" : edgeBacked ? "edge" : "value",
+      cardinality,
+      edgeBacked,
+      preservesExistingValues: Boolean(attribute.archived),
+      qualifiedProperties: supportsQualifiedProperties(attribute.type),
+      polymorphic: getPolymorphicCapability(attribute),
+      maxItems
+    },
+    authoring: {
+      editable,
+      readOnly,
+      directEdit: editable && editMode === "inline",
+      required,
+      defaultValue,
+      placeholder,
+      maxItems
+    },
+    presentation: {
+      formField: !suppressed && isFormFieldType(attribute.type),
+      tableCell: !suppressed && isTableCellType(attribute.type),
+      defaultColumn: !suppressed && isDefaultColumnType(attribute.type),
+      compactDisplay: !suppressed,
+      popoverEditor: !suppressed && editMode === "popover",
+      placeholder,
+      warningWhenDeprecated
+    },
+    query: {
+      filterable,
+      searchable,
+      sortable,
+      groupable,
+      kanbanGroupable,
+      operators
+    },
+    agent: {
+      readable: !suppressed,
+      writable: editable && !document,
+      compactReadable: !suppressed,
+      contentReadable: !suppressed && isContentReadableType(attribute.type),
+      requiresDedicatedTool: document
+    },
+    exchange: {
+      importable: !suppressed,
+      exportable: !suppressed,
+      schemaExportable: true,
+      metadataExportable: false
+    }
+  };
+}
+function getAttributeFilterOperators(attribute) {
+  return getAttributeCapabilities(attribute).query.operators;
+}
+function isAttributeFilterable(attribute) {
+  return getAttributeCapabilities(attribute).query.filterable;
+}
+function isAttributeSearchable(attribute) {
+  return getAttributeCapabilities(attribute).query.searchable;
+}
+function isAttributeSortable(attribute) {
+  return getAttributeCapabilities(attribute).query.sortable;
+}
+function isAttributeGroupable(attribute) {
+  return getAttributeCapabilities(attribute).query.groupable;
+}
+function isAttributeKanbanGroupable(attribute) {
+  return getAttributeCapabilities(attribute).query.kanbanGroupable;
+}
+function getRollupFilterOperators(attr) {
+  const fn = attr.function;
+  if (fn === "earliest" || fn === "latest") {
+    return ATTRIBUTE_FILTER_OPERATORS.date;
+  }
+  if (fn === "original") {
+    const targetType = attr.targetAttributeType;
+    if (targetType && hasFilterOperatorEntry(targetType)) {
+      return ATTRIBUTE_FILTER_OPERATORS[targetType];
+    }
+    return ATTRIBUTE_FILTER_OPERATORS.number;
+  }
+  return ATTRIBUTE_FILTER_OPERATORS.number;
+}
+function getRawFilterOperators(attribute) {
+  if (attribute.type === "rollup") {
+    return getRollupFilterOperators(attribute);
+  }
+  return ATTRIBUTE_FILTER_OPERATORS[attribute.type] ?? [];
+}
+function getAttributeCardinality(attribute) {
+  if (attribute.type === "multiselect" || attribute.type === "document") return "many";
+  if (attribute.type === "user" && attribute.multiple === true) return "many";
+  if (attribute.type === "relation") return attribute.cardinality === "many" ? "many" : "one";
+  return "one";
+}
+function getPolymorphicCapability(attribute) {
+  if (attribute.type !== "relation") return "none";
+  const relation = attribute;
+  const targets = relation.targets ?? [];
+  if (targets.length === 1 && targets[0]?.object === "*") return "internal";
+  return targets.length > 1 ? "code-only" : "none";
+}
+function supportsMaxItems(attribute) {
+  if (attribute.type === "multiselect") return true;
+  if (attribute.type === "relation") return attribute.cardinality === "many";
+  return false;
+}
+function supportsQualifiedProperties(type) {
+  return type === "relation" || type === "document";
+}
+function isRequiredForbidden(type) {
+  return type === "checkbox" || type === "formula" || type === "rollup";
+}
+function getDefaultValueCapability(type) {
+  if (type === "checkbox") return "automatic";
+  if (type === "formula" || type === "rollup") return "forbidden";
+  if (STATIC_DEFAULT_TYPES.has(type)) return "static";
+  return "forbidden";
+}
+function isDefaultColumnType(type) {
+  return isTableCellType(type);
+}
+function isTableCellType(type) {
+  return type !== "richtext" && type !== "document";
+}
+function isFormFieldType(type) {
+  return type !== "richtext";
+}
+function resolveEditMode(attribute) {
+  switch (attribute.type) {
+    case "checkbox":
+      return "inline";
+    case "number":
+      return attribute.renderAs === "rating" ? "inline" : "default";
+    case "select":
+    case "multiselect":
+      return attribute.renderAs === "badges" ? "inline" : "popover";
+    case "status":
+    case "relation":
+    case "user":
+      return "popover";
+    default:
+      return "default";
+  }
+}
+function isGroupableType(type) {
+  return type === "status" || type === "currency";
+}
+function isContentReadableType(type) {
+  return type === "richtext" || type === "document";
+}
+function hasFilterOperatorEntry(type) {
+  return Object.prototype.hasOwnProperty.call(ATTRIBUTE_FILTER_OPERATORS, type);
+}
+
+// src/types/filters.ts
+var OPERATORS_BY_TYPE = ATTRIBUTE_FILTER_OPERATORS;
+var NO_VALUE_OPERATORS = ["is_empty", "is_not_empty"];
+function isNoValueOperator(operator) {
+  return NO_VALUE_OPERATORS.includes(operator);
+}
+function getRollupFilterOperators2(attr) {
+  return getRollupFilterOperators(attr);
+}
+
+// src/filters/dynamic-value.ts
+function isDynamicValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "dynamic" in value;
+}
+function currentActor() {
+  return { dynamic: "actor", ref: "current" };
+}
+function today() {
+  return { dynamic: "date", anchor: "today" };
+}
+function now() {
+  return { dynamic: "date", anchor: "now" };
+}
+
+// src/filters/normalize-operator.ts
+var SYNONYM_ALIASES = {
+  // equality
+  eq: "is",
+  equals: "is",
+  equal: "is",
+  "==": "is",
+  "=": "is",
+  neq: "is_not",
+  notEqual: "is_not",
+  isNot: "is_not",
+  "!=": "is_not",
+  "<>": "is_not",
+  // ordering
+  lt: "less_than",
+  "<": "less_than",
+  gt: "greater_than",
+  ">": "greater_than",
+  lte: "less_or_equal",
+  "<=": "less_or_equal",
+  gte: "greater_or_equal",
+  ">=": "greater_or_equal",
+  // set
+  in: "any_of",
+  isAnyOf: "any_of",
+  oneOf: "any_of",
+  notIn: "none_of",
+  not_in: "none_of",
+  isNoneOf: "none_of",
+  notOneOf: "none_of",
+  // text
+  startsWith: "starts_with",
+  beginsWith: "starts_with",
+  endsWith: "ends_with",
+  doesNotContain: "not_contains",
+  notContain: "not_contains",
+  // nullity
+  isEmpty: "is_empty",
+  isNotEmpty: "is_not_empty"
+};
+function normalizeOperator(rawOp) {
+  return SYNONYM_ALIASES[rawOp] ?? rawOp;
+}
+function normalizeFilterRule(rule) {
+  const normalized = normalizeOperator(rule.operator);
+  return normalized === rule.operator ? rule : { ...rule, operator: normalized };
+}
+
+// src/filters/relative-date.ts
+var MS_PER_DAY = 864e5;
+var RELATIVE_DATE_UNITS = /* @__PURE__ */ new Set(["days", "weeks", "months", "years"]);
+var RELATIVE_DATE_DIRECTIONS = /* @__PURE__ */ new Set(["past", "future"]);
+function isRelativeDateValue(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const rel = value;
+  return typeof rel.amount === "number" && Number.isFinite(rel.amount) && rel.amount > 0 && typeof rel.unit === "string" && RELATIVE_DATE_UNITS.has(rel.unit) && typeof rel.direction === "string" && RELATIVE_DATE_DIRECTIONS.has(rel.direction);
+}
+function utcDayStart(date) {
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+}
+function shiftUtcDay(dayStartMs, amount, unit) {
+  if (unit === "days") return dayStartMs + amount * MS_PER_DAY;
+  if (unit === "weeks") return dayStartMs + amount * 7 * MS_PER_DAY;
+  const from = new Date(dayStartMs);
+  const year = from.getUTCFullYear() + (unit === "years" ? amount : 0);
+  const month = from.getUTCMonth() + (unit === "months" ? amount : 0);
+  const lastDayOfTargetMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+  return Date.UTC(year, month, Math.min(from.getUTCDate(), lastDayOfTargetMonth));
+}
+function resolveIsWithinBounds(value, now2 = /* @__PURE__ */ new Date()) {
+  if (!isRelativeDateValue(value)) return null;
+  const todayStart = utcDayStart(now2);
+  const amount = Math.trunc(value.amount);
+  const bounds = value.direction === "past" ? {
+    startMs: shiftUtcDay(todayStart, -amount, value.unit),
+    endMs: todayStart + MS_PER_DAY
+  } : {
+    startMs: todayStart,
+    endMs: shiftUtcDay(todayStart, amount, value.unit) + MS_PER_DAY
+  };
+  if (!(Number.isFinite(bounds.startMs) && Number.isFinite(bounds.endMs))) return null;
+  return bounds;
+}
+function toUtcDayString(ms) {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+// src/filters/validation.ts
+var REFERENCE_TYPES = /* @__PURE__ */ new Set(["relation", "document", "user"]);
+var ID_LIKE_OPERATORS = [
+  "is",
+  "is_not",
+  "any_of",
+  "none_of",
+  "is_empty",
+  "is_not_empty"
+];
+var SYSTEM_FILTER_OPERATORS = {
+  // Identifier columns (uuid)
+  id: ID_LIKE_OPERATORS,
+  objectId: ID_LIKE_OPERATORS,
+  tenantId: ID_LIKE_OPERATORS,
+  // Free-form text columns share their counterpart's operator set
+  label: OPERATORS_BY_TYPE.text,
+  // Date columns
+  createdAt: OPERATORS_BY_TYPE.date,
+  updatedAt: OPERATORS_BY_TYPE.date,
+  deletedAt: OPERATORS_BY_TYPE.date,
+  // User columns (uuid → actor identity)
+  createdBy: OPERATORS_BY_TYPE.user,
+  lastUpdatedBy: OPERATORS_BY_TYPE.user
+};
+var SYSTEM_FILTER_ATTRIBUTE_TYPES = {
+  id: "text",
+  objectId: "text",
+  objectName: "text",
+  tenantId: "text",
+  label: "text",
+  createdAt: "date",
+  updatedAt: "date",
+  deletedAt: "date",
+  deletedBy: "user",
+  createdBy: "user",
+  lastUpdatedBy: "user",
+  visibility: "select",
+  ownedBy: "user"
+};
+var REMOVED_OPERATOR_REPLACEMENTS = {
+  before: '"less_than"',
+  after: '"greater_than"',
+  on_or_before: '"less_or_equal"',
+  on_or_after: '"greater_or_equal"',
+  is_checked: '"is" with value true',
+  is_not_checked: '"is" with value false',
+  day_month_eq: '"on_day_month"'
+};
+var SET_MEMBERSHIP_TYPES = new Set(
+  Object.entries(ATTRIBUTE_FILTER_OPERATORS).filter(([, ops]) => ops.includes("any_of") && !ops.includes("contains")).map(([type]) => type)
+);
+var SUBSTRING_TO_MEMBERSHIP = {
+  contains: "any_of",
+  not_contains: "none_of"
+};
+function resolveCanonicalOperator(rawOperator, effectiveType) {
+  const replacement = REMOVED_OPERATOR_REPLACEMENTS[rawOperator];
+  if (replacement) {
+    const m = `Unknown filter operator "${rawOperator}" \u2014 use ${replacement}`;
+    throw new ValidationError(m, [{ path: ["operator"], message: m }]);
+  }
+  const normalized = normalizeOperator(rawOperator);
+  const membership = SUBSTRING_TO_MEMBERSHIP[normalized];
+  if (membership && SET_MEMBERSHIP_TYPES.has(effectiveType)) {
+    const m = `Operator "${normalized}" is not valid for type "${effectiveType}" \u2014 use "${membership}"`;
+    throw new ValidationError(m, [{ path: ["operator"], message: m }]);
+  }
+  return normalized;
+}
+function assertOperatorForType(operator, type, context) {
+  const normalized = resolveCanonicalOperator(operator, type);
+  const ops = OPERATORS_BY_TYPE[type];
+  if (!ops?.includes(normalized)) {
+    const validList = ops?.length ? ops.join(", ") : "(no operators registered for this type)";
+    const summary = `Operator "${operator}" is not valid for ${context} type "${type}". Valid operators: ${validList}.`;
+    throw new ValidationError(summary, [
+      {
+        path: ["operator"],
+        message: summary
+      }
+    ]);
+  }
+  return normalized;
+}
+function assertRelativeDateValue(rule) {
+  if (rule.operator !== "is_within") return;
+  if (!isRelativeDateValue(rule.value)) {
+    const m = `Operator "is_within" requires a relative-date value { amount: positive number, unit: days|weeks|months|years, direction: past|future }`;
+    throw new ValidationError(m, [{ path: ["value"], message: m }]);
+  }
+}
+function assertDynamicValueForAttribute(rule, attrType) {
+  if (!isDynamicValue(rule.value)) return;
+  const v = rule.value;
+  if (v.dynamic === "actor" && attrType !== "user") {
+    const m = `actor token (@me) is only valid on user attributes, not "${attrType}"`;
+    throw new ValidationError(m, [{ path: ["value"], message: m }]);
+  }
+  if (v.dynamic === "date" && attrType !== "date") {
+    const m = `date token (@today/@now) is only valid on date attributes, not "${attrType}"`;
+    throw new ValidationError(m, [{ path: ["value"], message: m }]);
+  }
+}
+function collectQualifiedRuleIssues(rule, context) {
+  try {
+    validateQualifiedRule({ ...rule }, context);
+    return [];
+  } catch (error) {
+    if (!(error instanceof ValidationError)) throw error;
+    return error.errors.map((issue) => ({ ...issue, path: [...issue.path] }));
+  }
+}
+function validateQualifiedRule(rule, context) {
+  const rootAttr = context.attributes.find((a) => a.name === rule.attribute);
+  const systemOps = SYSTEM_FILTER_OPERATORS[rule.attribute];
+  if (!(rootAttr || systemOps)) {
+    throw new ValidationError(`Unknown attribute: ${rule.attribute}`, [
+      { path: ["attribute"], message: `Unknown attribute: ${rule.attribute}` }
+    ]);
+  }
+  if (rule.quantifier !== void 0 && !rule.property) {
+    const m = `quantifier is only valid on qualified edge rules (set "property")`;
+    throw new ValidationError(m, [{ path: ["quantifier"], message: m }]);
+  }
+  if (!rootAttr) {
+    if (rule.property) {
+      throw new ValidationError(`Cannot qualify system attribute "${rule.attribute}"`, [
+        { path: ["property"], message: `"${rule.attribute}" is a system column, not a reference` }
+      ]);
+    }
+    const effectiveType = SYSTEM_FILTER_ATTRIBUTE_TYPES[rule.attribute] ?? "text";
+    const normalizedOperator = resolveCanonicalOperator(rule.operator, effectiveType);
+    if (!systemOps.includes(normalizedOperator)) {
+      const summary = `Operator "${rule.operator}" is not valid for system attribute "${rule.attribute}". Valid operators: ${systemOps.join(", ")}.`;
+      throw new ValidationError(summary, [{ path: ["operator"], message: summary }]);
+    }
+    rule.operator = normalizedOperator;
+    assertRelativeDateValue(rule);
+    return;
+  }
+  if (!rule.property) {
+    assertDynamicValueForAttribute(rule, rootAttr.type);
+    const ops = getAttributeFilterOperators(rootAttr);
+    const normalizedOperator = resolveCanonicalOperator(rule.operator, rootAttr.type);
+    if (!ops.includes(normalizedOperator)) {
+      const validList = ops.length ? ops.join(", ") : "(not filterable)";
+      const summary = `Operator "${rule.operator}" is not valid for attribute "${rootAttr.name}". Valid operators: ${validList}.`;
+      throw new ValidationError(summary, [{ path: ["operator"], message: summary }]);
+    }
+    rule.operator = normalizedOperator;
+    assertRelativeDateValue(rule);
+    return;
+  }
+  if (!REFERENCE_TYPES.has(rootAttr.type)) {
+    throw new ValidationError(`Cannot qualify ${rootAttr.type} attribute "${rule.attribute}"`, [
+      { path: ["property"], message: `Attribute "${rule.attribute}" is not a reference type` }
+    ]);
+  }
+  const propSchema = rootAttr.properties;
+  if (!propSchema) {
+    throw new ValidationError(`Attribute "${rule.attribute}" has no qualifyWith schema`, [
+      { path: ["property"], message: `"${rule.attribute}" has no qualifyWith` }
+    ]);
+  }
+  const propDef = propSchema.definitions.find((p) => p.name === rule.property);
+  if (!propDef) {
+    throw new ValidationError(
+      `Property "${rule.property}" not defined on "${rule.attribute}".qualifyWith()`,
+      [{ path: ["property"], message: `Unknown property: ${rule.property}` }]
+    );
+  }
+  rule.operator = assertOperatorForType(rule.operator, propDef.type, "property");
+  assertRelativeDateValue(rule);
+}
+
+// src/types/objects.ts
+var RESOURCE_VISIBILITIES = ["workspace", "private"];
+var LIST_VIEW_TAB_VISIBILITIES = ["all", ...RESOURCE_VISIBILITIES];
+var SYSTEM_FIELD_NAMES = [
+  "id",
+  "createdAt",
+  "updatedAt",
+  "createdBy",
+  "lastUpdatedBy",
+  "visibility",
+  "ownedBy"
+];
+var RESERVED_ATTRIBUTE_NAMES = [
+  // System fields (auto-managed)
+  ...SYSTEM_FIELD_NAMES,
+  // Other ObjectRecord properties
+  "objectId",
+  "label",
+  "embeddingText",
+  "values",
+  "metadata",
+  "deletedAt",
+  "deletedBy",
+  "schemaVersion",
+  // Physical SQL alias; custom attributes may otherwise use snake_case names.
+  "owned_by"
+];
+var RESERVED_OBJECT_NAMES = ["skill"];
+
+// src/validators/view-config.schema.ts
+var createModeSchema = z.enum(["redirect", "inline", "peek"]);
+var nonEmptyStringArraySchema = z.array(z.string()).min(1);
+var columnsSchema = z.array(z.string()).max(SCHEMA_LIMITS.columnsPerTab);
+var sortRuleSchema = z.object({
+  attribute: z.string(),
+  direction: z.enum(["asc", "desc"])
+}).strict();
+var sortsSchema = z.array(sortRuleSchema).max(SCHEMA_LIMITS.sortsPerTab);
+var relativeDateValueSchema = z.object({
+  amount: z.number(),
+  unit: z.enum(["days", "weeks", "months", "years"]),
+  direction: z.enum(["past", "future"])
+}).strict();
+var currencyFilterValueSchema = z.object({
+  value: z.number().nullable(),
+  code: z.array(z.string()).optional()
+}).strict();
+var phoneFilterValueSchema = z.object({
+  phoneNumber: z.string().nullable(),
+  countryCode: z.string().optional()
+}).strict();
+var dynamicFilterValueSchema = z.discriminatedUnion("dynamic", [
+  z.object({
+    dynamic: z.literal("actor"),
+    ref: z.literal("current")
+  }).strict(),
+  z.object({
+    dynamic: z.literal("date"),
+    anchor: z.enum(["today", "now"])
+  }).strict()
+]);
+var filterValueSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.array(z.string()),
+  relativeDateValueSchema,
+  currencyFilterValueSchema,
+  phoneFilterValueSchema,
+  dynamicFilterValueSchema,
+  z.null()
+]);
+var filterOperatorSchema = z.enum(
+  [
+    "is",
+    "is_not",
+    "contains",
+    "not_contains",
+    "starts_with",
+    "ends_with",
+    "is_empty",
+    "is_not_empty",
+    "less_than",
+    "greater_than",
+    "less_or_equal",
+    "greater_or_equal",
+    "is_within",
+    "on_day_month",
+    "any_of",
+    "none_of"
+  ],
+  {
+    error: (issue) => {
+      const input = issue.input;
+      const replacement = typeof input === "string" ? REMOVED_OPERATOR_REPLACEMENTS[input] : void 0;
+      return replacement ? `Unknown filter operator "${input}" \u2014 use ${replacement}` : void 0;
+    }
+  }
+);
+var filterRuleSchema = z.object({
+  attribute: z.string(),
+  property: z.string().optional(),
+  quantifier: z.enum(["any", "none"]).optional(),
+  operator: filterOperatorSchema,
+  value: filterValueSchema
+}).strict();
+var filterRulesSchema = z.array(filterRuleSchema).max(SCHEMA_LIMITS.filterRulesPerTab);
+var filterStateSchema = z.object({
+  combinator: z.enum(["and", "or"]),
+  rules: filterRulesSchema
+}).strict();
+var filterGroupSchema = z.object({
+  id: z.string(),
+  combinator: z.enum(["and", "or"]),
+  rules: filterRulesSchema
+}).strict();
+function addDuplicateIdIssues(values, ctx, pathPrefix = []) {
+  const seen = /* @__PURE__ */ new Set();
+  values.forEach((value, index) => {
+    if (seen.has(value.id)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Duplicate id "${value.id}"`,
+        path: [...pathPrefix, index, "id"]
+      });
+    }
+    seen.add(value.id);
+  });
+}
+function addDuplicateNameIssues(values, ctx, pathPrefix = []) {
+  const seen = /* @__PURE__ */ new Set();
+  values.forEach((value, index) => {
+    if (seen.has(value.name)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Duplicate name "${value.name}"`,
+        path: [...pathPrefix, index, "name"]
+      });
+    }
+    seen.add(value.name);
+  });
+}
+var attributeGroupFieldSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+  attributes: nonEmptyStringArraySchema,
+  displayTemplate: z.string().optional()
+}).strict();
+var fieldPresentationShape = {
+  span: z.union([
+    z.literal(1),
+    z.literal(2),
+    z.literal(3),
+    z.literal(4),
+    z.literal(5),
+    z.literal(6),
+    z.literal(7),
+    z.literal(8),
+    z.literal(9),
+    z.literal(10),
+    z.literal(11),
+    z.literal(12)
+  ]).optional(),
+  label: z.string().optional(),
+  readOnly: z.boolean().optional()
+};
+var fieldSchema = z.object({
+  attribute: z.string().optional(),
+  attributeGroup: attributeGroupFieldSchema.optional(),
+  ...fieldPresentationShape
+}).strict().superRefine((field, ctx) => {
+  if (field.attribute === void 0 === (field.attributeGroup === void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "A field must define exactly one of attribute or attributeGroup"
+    });
+  }
+});
+var baseGroupShape = {
+  id: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+  collapsible: z.boolean().optional(),
+  collapsed: z.boolean().optional(),
+  order: z.number().optional()
+};
+var fieldGroupWriteSchema = z.object({
+  ...baseGroupShape,
+  type: z.literal("fields"),
+  fields: z.array(fieldSchema).max(SCHEMA_LIMITS.fieldsPerGroup)
+}).strict();
+var relationGroupSchema = z.object({
+  ...baseGroupShape,
+  type: z.literal("relation"),
+  attribute: z.string(),
+  columns: z.array(z.string()).max(SCHEMA_LIMITS.columnsPerTab).optional(),
+  readOnly: z.boolean().optional(),
+  allowCreate: z.boolean().optional()
+}).strict();
+var groupWriteSchema = z.discriminatedUnion("type", [fieldGroupWriteSchema, relationGroupSchema]);
+var baseTabShape = {
+  id: z.string(),
+  name: z.string(),
+  label: z.string(),
+  icon: iconNameSchema.optional(),
+  order: z.number().optional()
+};
+var formTabWriteSchema = z.object({
+  ...baseTabShape,
+  type: z.literal("form"),
+  groups: z.array(groupWriteSchema).min(1).max(SCHEMA_LIMITS.groupsPerFormTab),
+  formColumns: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional(),
+  density: z.enum(["compact", "comfortable", "spacious"]).optional()
+}).strict().superRefine((tab, ctx) => {
+  addDuplicateIdIssues(tab.groups, ctx, ["groups"]);
+  const totalFields = tab.groups.reduce(
+    (count, group) => count + (group.type === "fields" ? group.fields.length : 0),
+    0
+  );
+  if (totalFields > SCHEMA_LIMITS.fieldsPerFormTab) {
+    ctx.addIssue({
+      code: "too_big",
+      origin: "array",
+      maximum: SCHEMA_LIMITS.fieldsPerFormTab,
+      inclusive: true,
+      message: `A form tab can contain at most ${SCHEMA_LIMITS.fieldsPerFormTab} fields`,
+      path: ["groups"]
+    });
+  }
+  const seenAttributeGroupIds = /* @__PURE__ */ new Set();
+  tab.groups.forEach((group, groupIndex) => {
+    if (group.type !== "fields") return;
+    group.fields.forEach((field, fieldIndex) => {
+      if (field.attributeGroup === void 0) return;
+      const { id } = field.attributeGroup;
+      if (seenAttributeGroupIds.has(id)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Duplicate attribute group id "${id}"`,
+          path: ["groups", groupIndex, "fields", fieldIndex, "attributeGroup", "id"]
+        });
+      }
+      seenAttributeGroupIds.add(id);
+    });
+  });
+});
+var relationSourceSchema = z.object({
+  type: z.literal("relation"),
+  attribute: z.string()
+}).strict();
+var inverseSourceSchema = z.object({
+  type: z.literal("inverse"),
+  object: z.string(),
+  attribute: z.string()
+}).strict();
+var tableSourceSchema = z.discriminatedUnion("type", [
+  relationSourceSchema,
+  inverseSourceSchema
+]);
+var tableTabSchema = z.object({
+  ...baseTabShape,
+  type: z.literal("table"),
+  source: tableSourceSchema,
+  columns: columnsSchema,
+  allowCreate: z.boolean().optional(),
+  createMode: createModeSchema.optional(),
+  allowEdit: z.boolean().optional(),
+  allowDelete: z.boolean().optional(),
+  filters: filterStateSchema.optional(),
+  sorts: sortsSchema.optional()
+}).strict();
+var JSON_PROPS_MAX_DEPTH = 64;
+var JSON_PROPS_MAX_NODES = 1e4;
+function isPlainJsonObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function addJsonIssue(ctx, message, path = []) {
+  ctx.addIssue({ code: "custom", message, path });
+}
+function pushJsonArrayChildren(current, frame, stack, ctx) {
+  for (const key of Reflect.ownKeys(current)) {
+    if (key === "length") continue;
+    if (key === "__proto__") {
+      addJsonIssue(ctx, "The __proto__ key is not allowed in custom props", [...frame.path, key]);
+      continue;
+    }
+    if (typeof key === "symbol" || !/^(0|[1-9]\d*)$/.test(key)) {
+      addJsonIssue(ctx, "Arrays cannot contain non-index JSON properties", [...frame.path, key]);
+    }
+  }
+  for (let index = current.length - 1; index >= 0; index--) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, String(index));
+    const path = [...frame.path, index];
+    if (!(descriptor && "value" in descriptor)) {
+      addJsonIssue(ctx, "Sparse arrays are not valid JSON values", path);
+      continue;
+    }
+    stack.push({ kind: "enter", value: descriptor.value, path, depth: frame.depth + 1 });
+  }
+}
+function pushJsonObjectChildren(current, frame, stack, ctx) {
+  const keys = Reflect.ownKeys(current);
+  for (let index = keys.length - 1; index >= 0; index--) {
+    const key = keys[index];
+    const path = [...frame.path, key];
+    if (key === "__proto__") {
+      addJsonIssue(ctx, "The __proto__ key is not allowed in custom props", path);
+      continue;
+    }
+    if (typeof key === "symbol") {
+      addJsonIssue(ctx, "Symbol keys are not valid JSON keys", path);
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(current, key);
+    if (!(descriptor?.enumerable && "value" in descriptor)) {
+      addJsonIssue(ctx, "Custom props must contain enumerable data properties only", path);
+      continue;
+    }
+    stack.push({ kind: "enter", value: descriptor.value, path, depth: frame.depth + 1 });
+  }
+}
+function validateJsonProps(value, ctx) {
+  if (value === null || typeof value !== "object") {
+    addJsonIssue(ctx, "Expected a plain JSON object");
+    return;
+  }
+  try {
+    if (Array.isArray(value) || !isPlainJsonObject(value)) {
+      addJsonIssue(ctx, "Expected a plain JSON object");
+      return;
+    }
+  } catch {
+    addJsonIssue(ctx, "Custom props contain an object that cannot be safely inspected");
+    return;
+  }
+  const activeChain = /* @__PURE__ */ new WeakSet();
+  const stack = [{ kind: "enter", value, path: [], depth: 0 }];
+  let visitedNodes = 0;
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (!frame) break;
+    if (frame.kind === "exit") {
+      activeChain.delete(frame.value);
+      continue;
+    }
+    visitedNodes++;
+    if (visitedNodes > JSON_PROPS_MAX_NODES) {
+      addJsonIssue(
+        ctx,
+        `Custom props cannot exceed ${JSON_PROPS_MAX_NODES.toLocaleString("en-US")} total JSON nodes`,
+        frame.path
+      );
+      return;
+    }
+    if (frame.depth > JSON_PROPS_MAX_DEPTH) {
+      addJsonIssue(ctx, `Custom props cannot exceed depth ${JSON_PROPS_MAX_DEPTH}`, frame.path);
+      continue;
+    }
+    const current = frame.value;
+    if (current === null || typeof current === "string" || typeof current === "boolean" || typeof current === "number" && Number.isFinite(current)) {
+      continue;
+    }
+    if (typeof current !== "object") {
+      addJsonIssue(ctx, "Expected a JSON value", frame.path);
+      continue;
+    }
+    if (activeChain.has(current)) {
+      addJsonIssue(ctx, "Custom props cannot contain circular references", frame.path);
+      continue;
+    }
+    try {
+      if (Array.isArray(current)) {
+        activeChain.add(current);
+        stack.push({ kind: "exit", value: current });
+        pushJsonArrayChildren(current, frame, stack, ctx);
+        continue;
+      }
+      if (!isPlainJsonObject(current)) {
+        addJsonIssue(ctx, "Expected an array or plain JSON object", frame.path);
+        continue;
+      }
+      activeChain.add(current);
+      stack.push({ kind: "exit", value: current });
+      pushJsonObjectChildren(current, frame, stack, ctx);
+    } catch {
+      addJsonIssue(
+        ctx,
+        "Custom props contain an object that cannot be safely inspected",
+        frame.path
+      );
+    }
+  }
+}
+var jsonPropsSchema = z.unknown().superRefine(validateJsonProps).transform((value) => value);
+var customTabSchema = z.object({
+  ...baseTabShape,
+  type: z.literal("custom"),
+  component: z.string(),
+  props: jsonPropsSchema.optional()
+}).strict();
+var activityTabSchema = z.object({
+  ...baseTabShape,
+  type: z.literal("activity"),
+  limit: z.number().optional()
+}).strict();
+var richtextTabSchema = z.object({
+  ...baseTabShape,
+  type: z.literal("richtext"),
+  attribute: z.string(),
+  titleAttribute: z.string().optional()
+}).strict();
+var documentsTabSchema = z.object({
+  ...baseTabShape,
+  type: z.literal("documents"),
+  allowUpload: z.boolean().optional(),
+  allowRemove: z.boolean().optional(),
+  hideAttachments: z.boolean().optional()
+}).strict();
+var formsTabSchema = z.object({
+  ...baseTabShape,
+  type: z.literal("forms"),
+  objectName: z.string().optional()
+}).strict();
+var emailsTabSchema = z.object({
+  ...baseTabShape,
+  type: z.literal("emails"),
+  emailAttributeIds: z.array(z.string()).max(SCHEMA_LIMITS.emailAttributesPerTab)
+}).strict();
+var detailTabSchema = z.discriminatedUnion("type", [
+  formTabWriteSchema,
+  tableTabSchema,
+  customTabSchema,
+  activityTabSchema,
+  richtextTabSchema,
+  documentsTabSchema,
+  formsTabSchema,
+  emailsTabSchema
+]);
+var listTabCommonShape = {
+  id: z.string(),
+  label: z.string(),
+  icon: iconNameSchema.optional(),
+  default: z.boolean().optional(),
+  // Which records the tab scopes to. `"all"` is the default and means "impose
+  // no scope" — the mandatory viewer predicate alone decides, so the tab shows
+  // workspace records plus the viewer's own private ones. Defaulted rather than
+  // required so configs stored before the field existed still parse.
+  visibility: z.enum(LIST_VIEW_TAB_VISIBILITIES).default("all"),
+  columns: columnsSchema,
+  filters: filterGroupSchema.optional(),
+  sorts: sortsSchema.optional(),
+  readOnly: z.boolean().optional(),
+  createMode: createModeSchema.optional()
+};
+var listTableTabSchema = z.object({
+  ...listTabCommonShape,
+  layout: z.literal("table"),
+  columnSizing: z.record(z.string(), z.number()).optional()
+}).strict();
+var listKanbanTabSchema = z.object({
+  ...listTabCommonShape,
+  layout: z.literal("kanban"),
+  groupByAttribute: z.string(),
+  cardUserAttribute: z.string().optional(),
+  cardDateAttribute: z.string().optional(),
+  kanbanColumnOrder: z.array(z.string()).optional(),
+  kanbanColumnVisibility: z.record(z.string(), z.boolean()).optional(),
+  kanbanPinnedColumns: z.array(z.string()).optional()
+}).strict();
+var listViewTabSchema = z.discriminatedUnion("layout", [
+  listTableTabSchema,
+  listKanbanTabSchema
+]);
+var _listViewConfigSchema = z.object({
+  defaultFilters: filterGroupSchema.optional(),
+  tabs: z.array(listViewTabSchema).min(1).max(SCHEMA_LIMITS.tabsPerView)
+}).strict().superRefine((config, ctx) => {
+  addDuplicateIdIssues(config.tabs, ctx, ["tabs"]);
+  let hasDefault = false;
+  config.tabs.forEach((tab, index) => {
+    if (!tab.default) return;
+    if (hasDefault) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Only one list tab can be the default",
+        path: ["tabs", index, "default"]
+      });
+    }
+    hasDefault = true;
+  });
+});
+var _detailViewConfigSchema = z.object({
+  tabs: z.array(detailTabSchema).min(1).max(SCHEMA_LIMITS.tabsPerView),
+  sidePanel: z.object({
+    attributes: z.array(z.string()).max(SCHEMA_LIMITS.sidePanelAttributes),
+    width: z.number().optional()
+  }).strict().optional()
+}).strict().superRefine((config, ctx) => {
+  addDuplicateIdIssues(config.tabs, ctx, ["tabs"]);
+  addDuplicateNameIssues(config.tabs, ctx, ["tabs"]);
+});
+var listViewConfigSchema = _listViewConfigSchema;
+var detailViewConfigSchema = _detailViewConfigSchema;
+var viewTypeSchema = z.enum(["list", "detail"]);
+var viewConfigByTypeSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("list"),
+    config: listViewConfigSchema
+  }).strict(),
+  z.object({
+    type: z.literal("detail"),
+    config: detailViewConfigSchema
+  }).strict()
+]);
+function parseViewConfig(type, input) {
+  switch (type) {
+    case "list":
+      return listViewConfigSchema.parse(input);
+    case "detail":
+      return detailViewConfigSchema.parse(input);
+    default:
+      return viewConfigByTypeSchema.parse({ type, config: input }).config;
+  }
+}
+
+export { ATTRIBUTE_FILTER_OPERATORS, LIST_VIEW_TAB_VISIBILITIES, NO_VALUE_OPERATORS, OPERATORS_BY_TYPE, REMOVED_OPERATOR_REPLACEMENTS, RESERVED_ATTRIBUTE_NAMES, RESERVED_OBJECT_NAMES, RESOURCE_VISIBILITIES, SYNONYM_ALIASES, SYSTEM_ATTRIBUTES, SYSTEM_ATTRIBUTE_I18N_KEYS, SYSTEM_FIELD_NAMES, SYSTEM_FILTER_ATTRIBUTE_TYPES, collectQualifiedRuleIssues, currentActor, detailTabSchema, detailViewConfigSchema, getAttributeCapabilities, getAttributeFilterOperators, getRollupFilterOperators2 as getRollupFilterOperators, getSystemAttributeI18nKey, getSystemAttributeList, inverseSourceSchema, isAttributeFilterable, isAttributeGroupable, isAttributeKanbanGroupable, isAttributeSearchable, isAttributeSortable, isDynamicValue, isManagedSystemAttribute, isNoValueOperator, isRelativeDateValue, listViewConfigSchema, listViewTabSchema, normalizeFilterRule, normalizeOperator, now, parseViewConfig, relationSourceSchema, resolveIsWithinBounds, tableSourceSchema, toUtcDayString, today, validateQualifiedRule, viewConfigByTypeSchema, viewTypeSchema };