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

package/dist/{chunk-ZBQEMIAV.js → chunk-FDIAOFHS.js}

@@ -10,6 +10,7 @@ var SchemaErrorCode = {
   RECORD_NOT_FOUND: "SCHEMA_RECORD_NOT_FOUND",
   ROLE_NOT_FOUND: "SCHEMA_ROLE_NOT_FOUND",
   MEMORY_NOT_FOUND: "SCHEMA_MEMORY_NOT_FOUND",
+  SCHEMA_PLAN_NOT_FOUND: "SCHEMA_PLAN_NOT_FOUND",
   // Validation
   VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED",
   INVALID_ATTRIBUTE_NAME: "SCHEMA_INVALID_ATTRIBUTE_NAME",
@@ -180,6 +181,12 @@ var RecordNotFoundError = class extends NotFoundError {
     this.name = "RecordNotFoundError";
   }
 };
+var SchemaPlanNotFoundError = class extends NotFoundError {
+  constructor(planId) {
+    super("Schema plan", planId, SchemaErrorCode.SCHEMA_PLAN_NOT_FOUND);
+    this.name = "SchemaPlanNotFoundError";
+  }
+};
 var ValidationError = class _ValidationError extends SchemaError {
   constructor(message, errors) {
     super(message, SchemaErrorCode.VALIDATION_FAILED, { errors });
@@ -280,19 +287,14 @@ var OrphanSystemAttributeError = class extends SchemaError {
 var DestructiveSyncNotAllowedError = class extends SchemaError {
   constructor(operations) {
     const summary = operations.map((op) => {
-      if (op.type === "remove_attribute") {
-        return `- remove_attribute "${op.objectName ?? "?"}.${op.name}"`;
-      }
-      if (op.type === "remove_object") {
-        return "- remove_object";
-      }
-      return `- ${op.type}`;
+      const named = op;
+      return named.name ? `- ${op.type} "${named.name}"` : `- ${op.type}`;
     }).join("\n");
     super(
       `Destructive schema operations detected (data will be lost):
 ${summary}
 
-To allow Standards to apply these automatically, set the environment variable:
+These are applied only under an explicit opt-in; without it boot demotes the object to runtime and keeps its rows. To let Standards apply them automatically, set the environment variable:
   STANDARDS_ALLOW_DESTRUCTIVE_SYNC=1
 
 Otherwise, revert your code changes or back up the data first.`,
@@ -531,6 +533,7 @@ exports.RepositoryError = RepositoryError;
 exports.RoleNotFoundError = RoleNotFoundError;
 exports.SchemaError = SchemaError;
 exports.SchemaErrorCode = SchemaErrorCode;
+exports.SchemaPlanNotFoundError = SchemaPlanNotFoundError;
 exports.SearchBackendError = SearchBackendError;
 exports.StorageError = StorageError;
 exports.SyncCascadeError = SyncCascadeError;

package/dist/{chunk-UXCJ3NI4.mjs → chunk-KDHDC7E6.mjs}

@@ -1,6 +1,6 @@
+import { ValidationError } from './chunk-POULKEJM.mjs';
 import { z } from 'zod';
-
-// src/validation/config/schemas.ts
+import { ICONS, COLORS } from '@stndrds/constants';
 
 // src/computed/parser.ts
 var ComputedFormulaParseError = class extends Error {
@@ -306,6 +306,39 @@ function getOperatorPrecedence(operator) {
   }
 }
 
+// src/validation/limits.ts
+var SCHEMA_LIMITS = {
+  attributesPerObject: 300,
+  tabsPerView: 24,
+  groupsPerFormTab: 12,
+  fieldsPerGroup: 60,
+  fieldsPerFormTab: 150,
+  columnsPerTab: 50,
+  optionsPerAttribute: 200,
+  sidePanelAttributes: 100,
+  filterRulesPerTab: 50,
+  sortsPerTab: 20,
+  emailAttributesPerTab: 30,
+  objectsPerPlan: 20,
+  mutationsPerPlan: 500,
+  planBytes: 512 * 1024,
+  historyDefault: 20,
+  historyMax: 50,
+  iconQueries: 5,
+  iconResults: 20
+};
+var COLOR_IDS = Object.keys(COLORS);
+var ICON_NAMES = new Set(ICONS);
+var colorIdSchema = z.enum(COLOR_IDS);
+var iconNameSchema = z.string().superRefine((value, ctx) => {
+  if (!ICON_NAMES.has(value)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Invalid icon name"
+    });
+  }
+}).transform((value) => value);
+
 // src/validation/config/schemas.ts
 var baseConfigSchema = z.object({
   placeholder: z.string().optional(),
@@ -318,14 +351,25 @@ var baseConfigSchema = z.object({
   deprecated: z.boolean().optional(),
   metadata: z.record(z.string(), z.unknown()).optional()
 });
-var optionSchema = z.object({
+var optionBaseSchema = z.object({
   value: z.string().min(1),
   label: z.string().min(1),
-  color: z.string().optional(),
   description: z.string().optional(),
-  group: z.enum(["idle", "in_progress", "finished"]).optional(),
   inverse: z.string().optional(),
   archived: z.boolean().optional()
+});
+var statusGroupSchema = z.enum(["idle", "in_progress", "finished"]);
+var selectOptionWriteSchema = optionBaseSchema.extend({
+  color: colorIdSchema
+}).strict();
+var multiselectOptionWriteSchema = selectOptionWriteSchema;
+var statusOptionWriteSchema = optionBaseSchema.extend({
+  color: colorIdSchema,
+  group: statusGroupSchema
+}).strict();
+var optionSchema = optionBaseSchema.extend({
+  color: z.string().optional(),
+  group: statusGroupSchema.optional()
 }).strict();
 var optionsArraySchema = z.array(optionSchema).min(1).refine(
   (options) => {
@@ -334,6 +378,18 @@ var optionsArraySchema = z.array(optionSchema).min(1).refine(
   },
   { message: "Duplicate option values are not allowed" }
 );
+function writeOptionsArraySchema(option) {
+  return z.array(option).min(1).max(SCHEMA_LIMITS.optionsPerAttribute).refine(
+    (options) => {
+      const values = options.map((candidate) => candidate.value);
+      return new Set(values).size === values.length;
+    },
+    { message: "Duplicate option values are not allowed" }
+  );
+}
+var selectOptionsWriteSchema = writeOptionsArraySchema(selectOptionWriteSchema);
+var multiselectOptionsWriteSchema = writeOptionsArraySchema(multiselectOptionWriteSchema);
+var statusOptionsWriteSchema = writeOptionsArraySchema(statusOptionWriteSchema);
 var relationTargetSchema = z.object({
   object: z.string().min(1),
   displayTemplate: z.string().optional(),
@@ -369,7 +425,10 @@ var checkboxConfigSchema = baseConfigSchema;
 var dateConfigSchema = baseConfigSchema.extend({
   dateFormat: z.enum(["short", "long", "full", "relative"]).optional(),
   minDate: z.string().optional(),
-  maxDate: z.string().optional()
+  maxDate: z.string().optional(),
+  includeTime: z.boolean().optional(),
+  endDate: z.boolean().optional(),
+  timeFormat: z.enum(["12h", "24h"]).optional()
 });
 var phoneConfigSchema = baseConfigSchema.extend({
   defaultCountryCode: z.string().length(3).optional()
@@ -388,10 +447,12 @@ var locationConfigSchema = baseConfigSchema.extend({
   allowedCountries: z.array(z.string().length(3)).optional()
 });
 var selectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
+  options: optionsArraySchema,
+  renderAs: z.literal("badges").optional()
 });
 var multiselectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
+  options: optionsArraySchema,
+  renderAs: z.literal("badges").optional()
 });
 var userConfigSchema = baseConfigSchema.extend({
   types: z.array(z.enum(["user", "agent"])).min(1).optional(),
@@ -492,5 +553,85 @@ function parseAttributeConfig(type, config) {
   const schema = getAttributeConfigSchema(type);
   return schema.strip().parse(config);
 }
+function getAttributeConfigWriteSchema(type) {
+  const schema = getAttributeConfigSchema(type).extend({
+    icon: iconNameSchema.optional()
+  });
+  switch (type) {
+    case "select":
+      return schema.extend({ options: selectOptionsWriteSchema });
+    case "multiselect":
+      return schema.extend({ options: multiselectOptionsWriteSchema });
+    case "status":
+      return schema.extend({ options: statusOptionsWriteSchema });
+    default:
+      return schema;
+  }
+}
+function validationErrorFromIssues(issues) {
+  return ValidationError.fromZodErrors(
+    issues.map((issue) => ({
+      path: issue.path.map((segment) => typeof segment === "symbol" ? String(segment) : segment),
+      message: issue.message
+    }))
+  );
+}
+function parseWriteSchema(type, input) {
+  const result = getAttributeConfigWriteSchema(type).strip().safeParse(input);
+  if (!result.success) {
+    throw validationErrorFromIssues(result.error.issues);
+  }
+  return result.data;
+}
+function parseAttributeConfigForCreate(type, input) {
+  return parseWriteSchema(type, input);
+}
+function validatePatchedIcon(patch) {
+  if (!Object.prototype.hasOwnProperty.call(patch, "icon")) {
+    return;
+  }
+  const result = iconNameSchema.optional().safeParse(patch.icon);
+  if (!result.success) {
+    throw ValidationError.fromZodErrors(
+      result.error.issues.map((issue) => ({
+        path: [
+          "icon",
+          ...issue.path.map((segment) => typeof segment === "symbol" ? String(segment) : segment)
+        ],
+        message: issue.message
+      }))
+    );
+  }
+}
+function isSelectLike(type) {
+  return type === "select" || type === "multiselect" || type === "status";
+}
+function parseAttributeConfigForUpdate(stored, patch) {
+  const ownsOptions = Object.prototype.hasOwnProperty.call(patch, "options");
+  const ownsIcon = Object.prototype.hasOwnProperty.call(patch, "icon");
+  const input = { ...stored, ...patch };
+  validatePatchedIcon(patch);
+  if (ownsOptions) {
+    const { icon: storedIcon, ...inputWithoutStoredIcon } = input;
+    const parsed2 = parseWriteSchema(stored.type, ownsIcon ? input : inputWithoutStoredIcon);
+    if (!ownsIcon && storedIcon !== void 0) {
+      parsed2.icon = storedIcon;
+    }
+    return parsed2;
+  }
+  const storedOptions = stored.options;
+  if (isSelectLike(stored.type)) {
+    input.options = [{ value: "__legacy__", label: "__legacy__" }];
+  }
+  const result = getAttributeConfigSchema(stored.type).strip().safeParse(input);
+  if (!result.success) {
+    throw validationErrorFromIssues(result.error.issues);
+  }
+  const parsed = result.data;
+  if (isSelectLike(stored.type)) {
+    parsed.options = storedOptions;
+  }
+  return parsed;
+}
 
-export { ComputedFormulaParseError, attributeConfigSchemas, getAttributeConfigSchema, parseAttributeConfig, parseComputedFormula };
+export { ComputedFormulaParseError, SCHEMA_LIMITS, attributeConfigSchemas, colorIdSchema, getAttributeConfigSchema, iconNameSchema, multiselectOptionWriteSchema, parseAttributeConfig, parseAttributeConfigForCreate, parseAttributeConfigForUpdate, parseComputedFormula, selectOptionWriteSchema, statusGroupSchema, statusOptionWriteSchema };

package/dist/{chunk-U36ZIBEM.mjs → chunk-O73ROMWQ.mjs}

@@ -1,6 +1,17 @@
 import { DEFAULT_VALIDATION_MESSAGES } from './chunk-HRQEZUAA.mjs';
 import { z } from 'zod';
 
+// src/lib/text-format.ts
+var TEXT_FORMAT_PATTERNS = {
+  email: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
+  url: "^https?:\\/\\/[\\w\\-]+(\\.[\\w\\-]+)+[/#?]?.*$",
+  slug: "^[a-z0-9]+(?:-[a-z0-9]+)*$"
+};
+function resolveTextPattern(attr) {
+  if (attr.pattern) return attr.pattern;
+  return attr.format ? TEXT_FORMAT_PATTERNS[attr.format] : void 0;
+}
+
 // src/lib/lru-cache.ts
 var LRUCache = class {
   constructor(capacity) {
@@ -64,13 +75,11 @@ function createTextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
   if (attr.maxLength !== void 0) {
     schema = schema.max(attr.maxLength, messages.maxLength(attr, attr.maxLength));
   }
-  if (attr.pattern) {
-    schema = schema.regex(
-      getCachedRegex(textRegexCache, attr.pattern),
-      messages.invalidPattern(attr)
-    );
+  const pattern = resolveTextPattern(attr);
+  if (pattern) {
+    schema = schema.regex(getCachedRegex(textRegexCache, pattern), messages.invalidPattern(attr));
   }
   return schema;
 }
 
-export { createTextValidator };
+export { TEXT_FORMAT_PATTERNS, createTextValidator, resolveTextPattern };

package/dist/{chunk-QIWADKYA.mjs → chunk-POULKEJM.mjs}

@@ -8,6 +8,7 @@ var SchemaErrorCode = {
   RECORD_NOT_FOUND: "SCHEMA_RECORD_NOT_FOUND",
   ROLE_NOT_FOUND: "SCHEMA_ROLE_NOT_FOUND",
   MEMORY_NOT_FOUND: "SCHEMA_MEMORY_NOT_FOUND",
+  SCHEMA_PLAN_NOT_FOUND: "SCHEMA_PLAN_NOT_FOUND",
   // Validation
   VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED",
   INVALID_ATTRIBUTE_NAME: "SCHEMA_INVALID_ATTRIBUTE_NAME",
@@ -178,6 +179,12 @@ var RecordNotFoundError = class extends NotFoundError {
     this.name = "RecordNotFoundError";
   }
 };
+var SchemaPlanNotFoundError = class extends NotFoundError {
+  constructor(planId) {
+    super("Schema plan", planId, SchemaErrorCode.SCHEMA_PLAN_NOT_FOUND);
+    this.name = "SchemaPlanNotFoundError";
+  }
+};
 var ValidationError = class _ValidationError extends SchemaError {
   constructor(message, errors) {
     super(message, SchemaErrorCode.VALIDATION_FAILED, { errors });
@@ -278,19 +285,14 @@ var OrphanSystemAttributeError = class extends SchemaError {
 var DestructiveSyncNotAllowedError = class extends SchemaError {
   constructor(operations) {
     const summary = operations.map((op) => {
-      if (op.type === "remove_attribute") {
-        return `- remove_attribute "${op.objectName ?? "?"}.${op.name}"`;
-      }
-      if (op.type === "remove_object") {
-        return "- remove_object";
-      }
-      return `- ${op.type}`;
+      const named = op;
+      return named.name ? `- ${op.type} "${named.name}"` : `- ${op.type}`;
     }).join("\n");
     super(
       `Destructive schema operations detected (data will be lost):
 ${summary}
 
-To allow Standards to apply these automatically, set the environment variable:
+These are applied only under an explicit opt-in; without it boot demotes the object to runtime and keeps its rows. To let Standards apply them automatically, set the environment variable:
   STANDARDS_ALLOW_DESTRUCTIVE_SYNC=1
 
 Otherwise, revert your code changes or back up the data first.`,
@@ -506,4 +508,4 @@ function isObjectReferencedError(error) {
   return error instanceof ObjectReferencedError;
 }
 
-export { AccessDeniedError, AttributeInUseError, AttributeNotFoundError, ChangeTypeNotSupportedError, ConcurrentModificationError, DestructiveSyncNotAllowedError, DuplicateError, ForbiddenError, MemoryNotFoundError, MigrationTimeoutError, NotFoundError, NotImplementedError, ObjectNotFoundError, ObjectReferencedError, OrphanSystemAttributeError, ProtectedResourceError, ProtectedRoleError, RecordNotFoundError, RecordReferencedError, RepositoryError, RoleNotFoundError, SchemaError, SchemaErrorCode, SearchBackendError, StorageError, SyncCascadeError, SyncConflictError, SyncError, SystemEntityImmutableError, ValidationError, isAttributeInUseError, isNotFoundError, isObjectReferencedError, isProtectedResourceError, isRecordReferencedError, isSchemaError, isValidationError };
+export { AccessDeniedError, AttributeInUseError, AttributeNotFoundError, ChangeTypeNotSupportedError, ConcurrentModificationError, DestructiveSyncNotAllowedError, DuplicateError, ForbiddenError, MemoryNotFoundError, MigrationTimeoutError, NotFoundError, NotImplementedError, ObjectNotFoundError, ObjectReferencedError, OrphanSystemAttributeError, ProtectedResourceError, ProtectedRoleError, RecordNotFoundError, RecordReferencedError, RepositoryError, RoleNotFoundError, SchemaError, SchemaErrorCode, SchemaPlanNotFoundError, SearchBackendError, StorageError, SyncCascadeError, SyncConflictError, SyncError, SystemEntityImmutableError, ValidationError, isAttributeInUseError, isNotFoundError, isObjectReferencedError, isProtectedResourceError, isRecordReferencedError, isSchemaError, isValidationError };

package/dist/{chunk-EBGRZUIH.js → chunk-Q4SZAMJT.js}

@@ -8,6 +8,9 @@ var libphonenumberJs = require('libphonenumber-js');
 function digitsOnly(input) {
   return input.replace(/\D/g, "");
 }
+function normalizeCountrylessPhoneNumber(phoneNumber) {
+  return digitsOnly(phoneNumber);
+}
 function getIso2(iso3) {
   const country = constants.getCountryByIso3(iso3);
   return country?.iso2;
@@ -65,3 +68,5 @@ function createPhoneValidator(attr, messages = chunkYKWSHBT5_js.DEFAULT_VALIDATI
 
 exports.createPhoneValidator = createPhoneValidator;
 exports.formatPhoneForDisplay = formatPhoneForDisplay;
+exports.normalizeCountrylessPhoneNumber = normalizeCountrylessPhoneNumber;
+exports.normalizePhoneNumber = normalizePhoneNumber;

package/dist/{chunk-NGGU6BSN.mjs → chunk-QMLO7V5E.mjs}

@@ -1,16 +1,16 @@
-import { createCheckboxValidator } from './chunk-OSSGN43B.mjs';
-import { createDateValidator } from './chunk-Q44QKLN4.mjs';
-import { createNumberValidator } from './chunk-UANQJ2GH.mjs';
-import { createTextValidator } from './chunk-U36ZIBEM.mjs';
 import { createRichtextValidator } from './chunk-QVLQPW3O.mjs';
 import { createMultiselectValidator, createSelectValidator, createStatusValidator } from './chunk-ZDQ5AP26.mjs';
 import { createUserValidator } from './chunk-LV3FEUKU.mjs';
 import { createFormulaValidator } from './chunk-UXAHLSWC.mjs';
 import { createRollupValidator } from './chunk-NS63SPNN.mjs';
-import { ValidationError } from './chunk-QIWADKYA.mjs';
+import { createCheckboxValidator } from './chunk-OSSGN43B.mjs';
+import { createDateValidator } from './chunk-Q44QKLN4.mjs';
+import { createNumberValidator } from './chunk-UANQJ2GH.mjs';
+import { createTextValidator } from './chunk-O73ROMWQ.mjs';
+import { ValidationError } from './chunk-POULKEJM.mjs';
 import { createCurrencyValidator } from './chunk-AYVHMVKQ.mjs';
 import { createLocationValidator } from './chunk-YUFTHPOE.mjs';
-import { createPhoneValidator } from './chunk-JUKLL5RJ.mjs';
+import { createPhoneValidator } from './chunk-R5LAJCBU.mjs';
 import { createRelationValidator } from './chunk-GO6LQADH.mjs';
 import { DEFAULT_VALIDATION_MESSAGES, formatZodErrors } from './chunk-HRQEZUAA.mjs';
 import { z } from 'zod';

package/dist/{chunk-L4U5QEQL.js → chunk-QN2N3IJZ.js}

@@ -1,8 +1,8 @@
 'use strict';
 
+var chunkFDIAOFHS_js = require('./chunk-FDIAOFHS.js');
 var zod = require('zod');
-
-// src/validation/config/schemas.ts
+var constants = require('@stndrds/constants');
 
 // src/computed/parser.ts
 var ComputedFormulaParseError = class extends Error {
@@ -308,6 +308,39 @@ function getOperatorPrecedence(operator) {
   }
 }
 
+// src/validation/limits.ts
+var SCHEMA_LIMITS = {
+  attributesPerObject: 300,
+  tabsPerView: 24,
+  groupsPerFormTab: 12,
+  fieldsPerGroup: 60,
+  fieldsPerFormTab: 150,
+  columnsPerTab: 50,
+  optionsPerAttribute: 200,
+  sidePanelAttributes: 100,
+  filterRulesPerTab: 50,
+  sortsPerTab: 20,
+  emailAttributesPerTab: 30,
+  objectsPerPlan: 20,
+  mutationsPerPlan: 500,
+  planBytes: 512 * 1024,
+  historyDefault: 20,
+  historyMax: 50,
+  iconQueries: 5,
+  iconResults: 20
+};
+var COLOR_IDS = Object.keys(constants.COLORS);
+var ICON_NAMES = new Set(constants.ICONS);
+var colorIdSchema = zod.z.enum(COLOR_IDS);
+var iconNameSchema = zod.z.string().superRefine((value, ctx) => {
+  if (!ICON_NAMES.has(value)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Invalid icon name"
+    });
+  }
+}).transform((value) => value);
+
 // src/validation/config/schemas.ts
 var baseConfigSchema = zod.z.object({
   placeholder: zod.z.string().optional(),
@@ -320,14 +353,25 @@ var baseConfigSchema = zod.z.object({
   deprecated: zod.z.boolean().optional(),
   metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
-var optionSchema = zod.z.object({
+var optionBaseSchema = zod.z.object({
   value: zod.z.string().min(1),
   label: zod.z.string().min(1),
-  color: zod.z.string().optional(),
   description: zod.z.string().optional(),
-  group: zod.z.enum(["idle", "in_progress", "finished"]).optional(),
   inverse: zod.z.string().optional(),
   archived: zod.z.boolean().optional()
+});
+var statusGroupSchema = zod.z.enum(["idle", "in_progress", "finished"]);
+var selectOptionWriteSchema = optionBaseSchema.extend({
+  color: colorIdSchema
+}).strict();
+var multiselectOptionWriteSchema = selectOptionWriteSchema;
+var statusOptionWriteSchema = optionBaseSchema.extend({
+  color: colorIdSchema,
+  group: statusGroupSchema
+}).strict();
+var optionSchema = optionBaseSchema.extend({
+  color: zod.z.string().optional(),
+  group: statusGroupSchema.optional()
 }).strict();
 var optionsArraySchema = zod.z.array(optionSchema).min(1).refine(
   (options) => {
@@ -336,6 +380,18 @@ var optionsArraySchema = zod.z.array(optionSchema).min(1).refine(
   },
   { message: "Duplicate option values are not allowed" }
 );
+function writeOptionsArraySchema(option) {
+  return zod.z.array(option).min(1).max(SCHEMA_LIMITS.optionsPerAttribute).refine(
+    (options) => {
+      const values = options.map((candidate) => candidate.value);
+      return new Set(values).size === values.length;
+    },
+    { message: "Duplicate option values are not allowed" }
+  );
+}
+var selectOptionsWriteSchema = writeOptionsArraySchema(selectOptionWriteSchema);
+var multiselectOptionsWriteSchema = writeOptionsArraySchema(multiselectOptionWriteSchema);
+var statusOptionsWriteSchema = writeOptionsArraySchema(statusOptionWriteSchema);
 var relationTargetSchema = zod.z.object({
   object: zod.z.string().min(1),
   displayTemplate: zod.z.string().optional(),
@@ -371,7 +427,10 @@ var checkboxConfigSchema = baseConfigSchema;
 var dateConfigSchema = baseConfigSchema.extend({
   dateFormat: zod.z.enum(["short", "long", "full", "relative"]).optional(),
   minDate: zod.z.string().optional(),
-  maxDate: zod.z.string().optional()
+  maxDate: zod.z.string().optional(),
+  includeTime: zod.z.boolean().optional(),
+  endDate: zod.z.boolean().optional(),
+  timeFormat: zod.z.enum(["12h", "24h"]).optional()
 });
 var phoneConfigSchema = baseConfigSchema.extend({
   defaultCountryCode: zod.z.string().length(3).optional()
@@ -390,10 +449,12 @@ var locationConfigSchema = baseConfigSchema.extend({
   allowedCountries: zod.z.array(zod.z.string().length(3)).optional()
 });
 var selectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
+  options: optionsArraySchema,
+  renderAs: zod.z.literal("badges").optional()
 });
 var multiselectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
+  options: optionsArraySchema,
+  renderAs: zod.z.literal("badges").optional()
 });
 var userConfigSchema = baseConfigSchema.extend({
   types: zod.z.array(zod.z.enum(["user", "agent"])).min(1).optional(),
@@ -494,9 +555,98 @@ function parseAttributeConfig(type, config) {
   const schema = getAttributeConfigSchema(type);
   return schema.strip().parse(config);
 }
+function getAttributeConfigWriteSchema(type) {
+  const schema = getAttributeConfigSchema(type).extend({
+    icon: iconNameSchema.optional()
+  });
+  switch (type) {
+    case "select":
+      return schema.extend({ options: selectOptionsWriteSchema });
+    case "multiselect":
+      return schema.extend({ options: multiselectOptionsWriteSchema });
+    case "status":
+      return schema.extend({ options: statusOptionsWriteSchema });
+    default:
+      return schema;
+  }
+}
+function validationErrorFromIssues(issues) {
+  return chunkFDIAOFHS_js.ValidationError.fromZodErrors(
+    issues.map((issue) => ({
+      path: issue.path.map((segment) => typeof segment === "symbol" ? String(segment) : segment),
+      message: issue.message
+    }))
+  );
+}
+function parseWriteSchema(type, input) {
+  const result = getAttributeConfigWriteSchema(type).strip().safeParse(input);
+  if (!result.success) {
+    throw validationErrorFromIssues(result.error.issues);
+  }
+  return result.data;
+}
+function parseAttributeConfigForCreate(type, input) {
+  return parseWriteSchema(type, input);
+}
+function validatePatchedIcon(patch) {
+  if (!Object.prototype.hasOwnProperty.call(patch, "icon")) {
+    return;
+  }
+  const result = iconNameSchema.optional().safeParse(patch.icon);
+  if (!result.success) {
+    throw chunkFDIAOFHS_js.ValidationError.fromZodErrors(
+      result.error.issues.map((issue) => ({
+        path: [
+          "icon",
+          ...issue.path.map((segment) => typeof segment === "symbol" ? String(segment) : segment)
+        ],
+        message: issue.message
+      }))
+    );
+  }
+}
+function isSelectLike(type) {
+  return type === "select" || type === "multiselect" || type === "status";
+}
+function parseAttributeConfigForUpdate(stored, patch) {
+  const ownsOptions = Object.prototype.hasOwnProperty.call(patch, "options");
+  const ownsIcon = Object.prototype.hasOwnProperty.call(patch, "icon");
+  const input = { ...stored, ...patch };
+  validatePatchedIcon(patch);
+  if (ownsOptions) {
+    const { icon: storedIcon, ...inputWithoutStoredIcon } = input;
+    const parsed2 = parseWriteSchema(stored.type, ownsIcon ? input : inputWithoutStoredIcon);
+    if (!ownsIcon && storedIcon !== void 0) {
+      parsed2.icon = storedIcon;
+    }
+    return parsed2;
+  }
+  const storedOptions = stored.options;
+  if (isSelectLike(stored.type)) {
+    input.options = [{ value: "__legacy__", label: "__legacy__" }];
+  }
+  const result = getAttributeConfigSchema(stored.type).strip().safeParse(input);
+  if (!result.success) {
+    throw validationErrorFromIssues(result.error.issues);
+  }
+  const parsed = result.data;
+  if (isSelectLike(stored.type)) {
+    parsed.options = storedOptions;
+  }
+  return parsed;
+}
 
 exports.ComputedFormulaParseError = ComputedFormulaParseError;
+exports.SCHEMA_LIMITS = SCHEMA_LIMITS;
 exports.attributeConfigSchemas = attributeConfigSchemas;
+exports.colorIdSchema = colorIdSchema;
 exports.getAttributeConfigSchema = getAttributeConfigSchema;
+exports.iconNameSchema = iconNameSchema;
+exports.multiselectOptionWriteSchema = multiselectOptionWriteSchema;
 exports.parseAttributeConfig = parseAttributeConfig;
+exports.parseAttributeConfigForCreate = parseAttributeConfigForCreate;
+exports.parseAttributeConfigForUpdate = parseAttributeConfigForUpdate;
 exports.parseComputedFormula = parseComputedFormula;
+exports.selectOptionWriteSchema = selectOptionWriteSchema;
+exports.statusGroupSchema = statusGroupSchema;
+exports.statusOptionWriteSchema = statusOptionWriteSchema;

package/dist/{chunk-JUKLL5RJ.mjs → chunk-R5LAJCBU.mjs}

@@ -1,11 +1,14 @@
 import { DEFAULT_VALIDATION_MESSAGES } from './chunk-HRQEZUAA.mjs';
-import { getCountryByIso3, isValidIso3, stripTrunkPrefix } from '@stndrds/constants';
+import { getCountryByIso3, stripTrunkPrefix, isValidIso3 } from '@stndrds/constants';
 import { z } from 'zod';
 import { parsePhoneNumberFromString } from 'libphonenumber-js';
 
 function digitsOnly(input) {
   return input.replace(/\D/g, "");
 }
+function normalizeCountrylessPhoneNumber(phoneNumber) {
+  return digitsOnly(phoneNumber);
+}
 function getIso2(iso3) {
   const country = getCountryByIso3(iso3);
   return country?.iso2;
@@ -61,4 +64,4 @@ function createPhoneValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
   }));
 }
 
-export { createPhoneValidator, formatPhoneForDisplay };
+export { createPhoneValidator, formatPhoneForDisplay, normalizeCountrylessPhoneNumber, normalizePhoneNumber };