@stndrds/schema 1.0.0-alpha.188 → 1.0.0-alpha.189

package/dist/chunk-FQ2ZYOVS.js

@@ -0,0 +1,688 @@
+'use strict';
+
+var chunkMAKSIK3P_js = require('./chunk-MAKSIK3P.js');
+var chunkJ5HRK3WD_js = require('./chunk-J5HRK3WD.js');
+var chunkTKN73433_js = require('./chunk-TKN73433.js');
+var chunkD7WFIGXW_js = require('./chunk-D7WFIGXW.js');
+var chunk3JINFUN3_js = require('./chunk-3JINFUN3.js');
+var chunkQWZHR2OO_js = require('./chunk-QWZHR2OO.js');
+var chunkEZHMVZQ4_js = require('./chunk-EZHMVZQ4.js');
+var chunkVXOTYFEW_js = require('./chunk-VXOTYFEW.js');
+var chunkOAQWRMTP_js = require('./chunk-OAQWRMTP.js');
+var chunkACQ3TUFK_js = require('./chunk-ACQ3TUFK.js');
+var chunkDC7YYE3U_js = require('./chunk-DC7YYE3U.js');
+var chunkROAZLZA2_js = require('./chunk-ROAZLZA2.js');
+var chunkCCB4OY2O_js = require('./chunk-CCB4OY2O.js');
+var chunk7A3Y6O32_js = require('./chunk-7A3Y6O32.js');
+var chunkP2BE2A2G_js = require('./chunk-P2BE2A2G.js');
+var chunkT225DB55_js = require('./chunk-T225DB55.js');
+var zod = require('zod');
+
+function isEmptyValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (value instanceof Date) return false;
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return Object.values(value).every(
+      (v) => v === null || v === void 0 || typeof v === "string" && v.trim() === ""
+    );
+  }
+  return false;
+}
+function withEmptyToNull(validator) {
+  return zod.z.preprocess((val) => isEmptyValue(val) ? null : val, validator.nullish());
+}
+
+// src/validation/object/attribute-factory.ts
+function createAttributeValidator(attr, messages = chunkT225DB55_js.DEFAULT_VALIDATION_MESSAGES) {
+  switch (attr.type) {
+    case "text":
+      return chunk3JINFUN3_js.createTextValidator(attr, messages);
+    case "textarea":
+      return chunk3JINFUN3_js.createTextAreaValidator(attr, messages);
+    case "richtext":
+      return chunkQWZHR2OO_js.createRichtextValidator(attr, messages);
+    case "number":
+      return chunkTKN73433_js.createNumberValidator(attr, messages);
+    case "checkbox":
+      return chunkMAKSIK3P_js.createCheckboxValidator(attr, messages);
+    case "date":
+      return chunkJ5HRK3WD_js.createDateValidator(attr, messages);
+    case "phone":
+      return chunk7A3Y6O32_js.createPhoneValidator(attr, messages);
+    case "currency":
+      return chunkDC7YYE3U_js.createCurrencyValidator(attr, messages);
+    case "status":
+      return chunkEZHMVZQ4_js.createStatusValidator(attr, messages);
+    case "location":
+      return chunkCCB4OY2O_js.createLocationValidator(attr, messages);
+    case "select":
+      return chunkEZHMVZQ4_js.createSelectValidator(attr, messages);
+    case "multiselect":
+      return chunkEZHMVZQ4_js.createMultiselectValidator(attr, messages);
+    case "file":
+      return chunkROAZLZA2_js.createFileValidator(attr, messages);
+    case "user":
+      return chunkVXOTYFEW_js.createUserValidator(attr, messages);
+    case "relation":
+      return chunkP2BE2A2G_js.createRelationValidator(attr, messages);
+    case "rating":
+      return chunkD7WFIGXW_js.createRatingValidator(attr, messages);
+    case "formula":
+      return chunkOAQWRMTP_js.createFormulaValidator(attr, messages);
+    case "rollup":
+      return chunkACQ3TUFK_js.createRollupValidator(attr, messages);
+    default:
+      return zod.z.unknown();
+  }
+}
+function createFormAttributeValidator(attr, messages = chunkT225DB55_js.DEFAULT_VALIDATION_MESSAGES) {
+  const validator = createAttributeValidator(attr, messages);
+  if (!attr.required) {
+    return withEmptyToNull(validator);
+  }
+  return validator;
+}
+var objectValidatorCache = /* @__PURE__ */ new WeakMap();
+var draftValidatorCache = /* @__PURE__ */ new WeakMap();
+function createObjectValidator(objectDef) {
+  const cached = objectValidatorCache.get(objectDef);
+  if (cached) return cached;
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    const validator = createAttributeValidator(attr);
+    shape[attr.name] = attr.required ? validator : withEmptyToNull(validator);
+  }
+  const schema = zod.z.object(shape).passthrough();
+  objectValidatorCache.set(objectDef, schema);
+  return schema;
+}
+function createDraftValidator(objectDef) {
+  const cached = draftValidatorCache.get(objectDef);
+  if (cached) return cached;
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    const validator = createAttributeValidator(attr);
+    shape[attr.name] = withEmptyToNull(validator);
+  }
+  const schema = zod.z.object(shape).passthrough();
+  draftValidatorCache.set(objectDef, schema);
+  return schema;
+}
+
+// src/exceptions.ts
+var SchemaErrorCode = {
+  // Generic
+  UNKNOWN: "SCHEMA_UNKNOWN_ERROR",
+  // Not Found
+  OBJECT_NOT_FOUND: "SCHEMA_OBJECT_NOT_FOUND",
+  ATTRIBUTE_NOT_FOUND: "SCHEMA_ATTRIBUTE_NOT_FOUND",
+  RECORD_NOT_FOUND: "SCHEMA_RECORD_NOT_FOUND",
+  ROLE_NOT_FOUND: "SCHEMA_ROLE_NOT_FOUND",
+  MEMORY_NOT_FOUND: "SCHEMA_MEMORY_NOT_FOUND",
+  // Validation
+  VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED",
+  INVALID_ATTRIBUTE_NAME: "SCHEMA_INVALID_ATTRIBUTE_NAME",
+  INVALID_OBJECT_NAME: "SCHEMA_INVALID_OBJECT_NAME",
+  // Protected Resources
+  PROTECTED_OBJECT: "SCHEMA_PROTECTED_OBJECT",
+  PROTECTED_ATTRIBUTE: "SCHEMA_PROTECTED_ATTRIBUTE",
+  PROTECTED_VIEW: "SCHEMA_PROTECTED_VIEW",
+  PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE",
+  // Permissions
+  FORBIDDEN: "SCHEMA_FORBIDDEN",
+  ACCESS_DENIED: "SCHEMA_ACCESS_DENIED",
+  // Sync
+  SYNC_FAILED: "SCHEMA_SYNC_FAILED",
+  SYNC_CONFLICT: "SCHEMA_SYNC_CONFLICT",
+  SYNC_CASCADE: "SCHEMA_SYNC_CASCADE",
+  ORPHAN_SYSTEM_ATTRIBUTE: "SCHEMA_ORPHAN_SYSTEM_ATTRIBUTE",
+  // System Entity Immutability
+  SYSTEM_ENTITY_IMMUTABLE: "SCHEMA_SYSTEM_ENTITY_IMMUTABLE",
+  // L2 — migration system simplification (2026-05-17)
+  DESTRUCTIVE_NOT_ALLOWED: "SCHEMA_DESTRUCTIVE_NOT_ALLOWED",
+  MIGRATION_TIMEOUT: "SCHEMA_MIGRATION_TIMEOUT",
+  CHANGE_TYPE_NOT_SUPPORTED: "SCHEMA_CHANGE_TYPE_NOT_SUPPORTED",
+  // Duplicates
+  DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT",
+  DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE",
+  // Concurrency
+  CONFLICT: "SCHEMA_CONFLICT",
+  // Storage
+  STORAGE_UPLOAD_FAILED: "SCHEMA_STORAGE_UPLOAD_FAILED",
+  STORAGE_DOWNLOAD_FAILED: "SCHEMA_STORAGE_DOWNLOAD_FAILED",
+  STORAGE_DELETE_FAILED: "SCHEMA_STORAGE_DELETE_FAILED",
+  STORAGE_URL_FAILED: "SCHEMA_STORAGE_URL_FAILED",
+  // Repository Operations
+  REPOSITORY_CREATE_FAILED: "SCHEMA_REPOSITORY_CREATE_FAILED",
+  REPOSITORY_UPDATE_FAILED: "SCHEMA_REPOSITORY_UPDATE_FAILED",
+  REPOSITORY_DELETE_FAILED: "SCHEMA_REPOSITORY_DELETE_FAILED",
+  REPOSITORY_QUERY_FAILED: "SCHEMA_REPOSITORY_QUERY_FAILED",
+  // Not Implemented
+  NOT_IMPLEMENTED: "SCHEMA_NOT_IMPLEMENTED",
+  // Timeout
+  TIMEOUT: "SCHEMA_TIMEOUT",
+  // Schema Integrity
+  RECORD_REFERENCED: "SCHEMA_RECORD_REFERENCED",
+  ATTRIBUTE_IN_USE: "SCHEMA_ATTRIBUTE_IN_USE",
+  OBJECT_REFERENCED: "SCHEMA_OBJECT_REFERENCED"
+};
+var SchemaError = class extends Error {
+  constructor(message, code = SchemaErrorCode.UNKNOWN, details) {
+    super(message);
+    this.name = "SchemaError";
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+var NotFoundError = class extends SchemaError {
+  constructor(resourceType, resourceId, code = SchemaErrorCode.RECORD_NOT_FOUND) {
+    super(`${resourceType} with id "${resourceId}" not found`, code, {
+      resourceType,
+      resourceId
+    });
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var ObjectNotFoundError = class extends NotFoundError {
+  constructor(objectId) {
+    super("Object", objectId, SchemaErrorCode.OBJECT_NOT_FOUND);
+    this.name = "ObjectNotFoundError";
+  }
+};
+var AttributeNotFoundError = class extends NotFoundError {
+  constructor(attributeId) {
+    super("Attribute", attributeId, SchemaErrorCode.ATTRIBUTE_NOT_FOUND);
+    this.name = "AttributeNotFoundError";
+  }
+};
+var RecordNotFoundError = class extends NotFoundError {
+  constructor(recordId) {
+    super("Record", recordId, SchemaErrorCode.RECORD_NOT_FOUND);
+    this.name = "RecordNotFoundError";
+  }
+};
+var ValidationError = class _ValidationError extends SchemaError {
+  constructor(message, errors) {
+    super(message, SchemaErrorCode.VALIDATION_FAILED, { errors });
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+  /**
+   * Create a validation error from Zod-style errors
+   */
+  static fromZodErrors(errors) {
+    const details = errors.map((err) => ({
+      path: err.path.map(String),
+      message: err.message
+    }));
+    const message = `Validation failed: ${details.map((d) => `${d.path.join(".")}: ${d.message}`).join(", ")}`;
+    return new _ValidationError(message, details);
+  }
+};
+var ProtectedResourceError = class extends SchemaError {
+  constructor(resourceType, resourceName, operation) {
+    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : resourceType === "view" ? SchemaErrorCode.PROTECTED_VIEW : SchemaErrorCode.PROTECTED_ATTRIBUTE;
+    super(`Cannot ${operation} system ${resourceType} "${resourceName}"`, code, {
+      resourceType,
+      resourceName,
+      operation
+    });
+    this.name = "ProtectedResourceError";
+    this.resourceType = resourceType;
+    this.resourceName = resourceName;
+    this.operation = operation;
+  }
+};
+var SyncError = class extends SchemaError {
+  constructor(objectName, message, cause) {
+    super(`Failed to sync object "${objectName}": ${message}`, SchemaErrorCode.SYNC_FAILED, {
+      objectName,
+      cause: cause?.message
+    });
+    this.name = "SyncError";
+    this.objectName = objectName;
+    this.cause = cause;
+  }
+};
+var SystemEntityImmutableError = class extends SchemaError {
+  constructor(entityType, entityName) {
+    super(
+      `Cannot mutate system ${entityType} "${entityName}". System entities are declared in code and immutable at runtime.`,
+      SchemaErrorCode.SYSTEM_ENTITY_IMMUTABLE,
+      { entityType, entityName }
+    );
+    this.name = "SystemEntityImmutableError";
+    this.entityType = entityType;
+    this.entityName = entityName;
+  }
+};
+var SyncConflictError = class extends SchemaError {
+  constructor(params) {
+    const target = params.attributeName ? `"${params.objectName}.${params.attributeName}"` : `"${params.objectName}"`;
+    super(
+      `Cannot promote runtime entity ${target}: ${params.reason}. Resolve via: (1) relax the code constraint, (2) migrate runtime values manually, or (3) rename the code declaration.`,
+      SchemaErrorCode.SYNC_CONFLICT,
+      {
+        objectName: params.objectName,
+        attributeName: params.attributeName,
+        reason: params.reason
+      }
+    );
+    this.name = "SyncConflictError";
+    this.objectName = params.objectName;
+    this.attributeName = params.attributeName;
+    this.reason = params.reason;
+  }
+};
+var SyncCascadeError = class extends SchemaError {
+  constructor(objectName, conflictingAttributes) {
+    super(
+      `Cannot demote object "${objectName}": attributes ${conflictingAttributes.join(", ")} are still declared in code. Remove them from code first, or restore the object.`,
+      SchemaErrorCode.SYNC_CASCADE,
+      { objectName, conflictingAttributes }
+    );
+    this.name = "SyncCascadeError";
+    this.objectName = objectName;
+    this.conflictingAttributes = conflictingAttributes;
+  }
+};
+var OrphanSystemAttributeError = class extends SchemaError {
+  constructor(objectName, attributeName) {
+    super(
+      `Attribute "${objectName}.${attributeName}" is system:true but its object parent is system:false. This is an invariant violation.`,
+      SchemaErrorCode.ORPHAN_SYSTEM_ATTRIBUTE,
+      { objectName, attributeName }
+    );
+    this.name = "OrphanSystemAttributeError";
+    this.objectName = objectName;
+    this.attributeName = attributeName;
+  }
+};
+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}`;
+    }).join("\n");
+    super(
+      `Destructive schema operations detected (data will be lost):
+${summary}
+
+To allow Standards to apply these automatically, set the environment variable:
+  STANDARDS_ALLOW_DESTRUCTIVE_SYNC=1
+
+Otherwise, revert your code changes or back up the data first.`,
+      SchemaErrorCode.DESTRUCTIVE_NOT_ALLOWED,
+      { operations }
+    );
+    this.name = "DestructiveSyncNotAllowedError";
+    this.operations = operations;
+  }
+};
+var MigrationTimeoutError = class extends SchemaError {
+  constructor(objectName, migrated, total, maxDurationMs) {
+    super(
+      `Migration for "${objectName}" exceeded the maximum duration (${maxDurationMs}ms). Migrated ${migrated}/${total} records before timeout. Increase STANDARDS_MIGRATION_MAX_DURATION_MS or split the migration into smaller batches.`,
+      SchemaErrorCode.MIGRATION_TIMEOUT,
+      { objectName, migrated, total, maxDurationMs }
+    );
+    this.name = "MigrationTimeoutError";
+    this.objectName = objectName;
+    this.migrated = migrated;
+    this.total = total;
+    this.maxDurationMs = maxDurationMs;
+  }
+};
+var ChangeTypeNotSupportedError = class extends SchemaError {
+  constructor(objectName, attributeName) {
+    super(
+      `Cannot change type of attribute "${objectName}.${attributeName}" via runtime API. Declare a migration in your schema code:
+  object("${objectName}").migration(N, (m) =>
+    m.changeType("${attributeName}", from, to, { transform: (v) => ... })
+  )`,
+      SchemaErrorCode.CHANGE_TYPE_NOT_SUPPORTED,
+      { objectName, attributeName }
+    );
+    this.name = "ChangeTypeNotSupportedError";
+    this.objectName = objectName;
+    this.attributeName = attributeName;
+  }
+};
+var DuplicateError = class extends SchemaError {
+  constructor(resourceType, resourceName) {
+    const code = resourceType === "object" ? SchemaErrorCode.DUPLICATE_OBJECT : SchemaErrorCode.DUPLICATE_ATTRIBUTE;
+    super(
+      `${resourceType === "object" ? "Object" : "Attribute"} "${resourceName}" already exists`,
+      code,
+      { resourceType, resourceName }
+    );
+    this.name = "DuplicateError";
+    this.resourceType = resourceType;
+    this.resourceName = resourceName;
+  }
+};
+function isSchemaError(error) {
+  return error instanceof SchemaError;
+}
+function isNotFoundError(error) {
+  return error instanceof NotFoundError;
+}
+function isValidationError(error) {
+  return error instanceof ValidationError;
+}
+function isProtectedResourceError(error) {
+  return error instanceof ProtectedResourceError;
+}
+var ForbiddenError = class extends SchemaError {
+  constructor(objectName, action, userId) {
+    super(`No ${action} permission on object "${objectName}"`, SchemaErrorCode.FORBIDDEN, {
+      objectName,
+      action,
+      userId
+    });
+    this.name = "ForbiddenError";
+    this.objectName = objectName;
+    this.action = action;
+    this.userId = userId;
+  }
+};
+var ProtectedRoleError = class extends SchemaError {
+  constructor(roleName, operation) {
+    super(`Cannot ${operation} system role "${roleName}"`, SchemaErrorCode.PROTECTED_ROLE, {
+      roleName,
+      operation
+    });
+    this.name = "ProtectedRoleError";
+    this.roleName = roleName;
+    this.operation = operation;
+  }
+};
+var RoleNotFoundError = class extends NotFoundError {
+  constructor(roleId) {
+    super("Role", roleId, SchemaErrorCode.ROLE_NOT_FOUND);
+    this.name = "RoleNotFoundError";
+  }
+};
+var ConcurrentModificationError = class extends SchemaError {
+  constructor(recordId) {
+    super(
+      `Record ${recordId} was modified by another request. Please refresh and try again.`,
+      SchemaErrorCode.CONFLICT,
+      { recordId }
+    );
+  }
+};
+var StorageError = class extends SchemaError {
+  constructor(operation, message, path, cause) {
+    const code = operation === "upload" ? SchemaErrorCode.STORAGE_UPLOAD_FAILED : operation === "download" ? SchemaErrorCode.STORAGE_DOWNLOAD_FAILED : operation === "delete" ? SchemaErrorCode.STORAGE_DELETE_FAILED : SchemaErrorCode.STORAGE_URL_FAILED;
+    super(`Storage ${operation} failed: ${message}`, code, {
+      operation,
+      path,
+      cause
+    });
+    this.name = "StorageError";
+    this.operation = operation;
+    this.path = path;
+    this.cause = cause;
+  }
+};
+var AccessDeniedError = class extends SchemaError {
+  constructor(resource, reason) {
+    super(reason ?? `Access denied to resource: ${resource}`, SchemaErrorCode.ACCESS_DENIED, {
+      resource,
+      reason
+    });
+    this.name = "AccessDeniedError";
+    this.resource = resource;
+    this.reason = reason;
+  }
+};
+var RepositoryError = class extends SchemaError {
+  constructor(operation, entity, message, cause) {
+    const code = operation === "create" ? SchemaErrorCode.REPOSITORY_CREATE_FAILED : operation === "update" ? SchemaErrorCode.REPOSITORY_UPDATE_FAILED : operation === "delete" ? SchemaErrorCode.REPOSITORY_DELETE_FAILED : SchemaErrorCode.REPOSITORY_QUERY_FAILED;
+    super(`Failed to ${operation} ${entity}: ${message}`, code, {
+      operation,
+      entity,
+      cause
+    });
+    this.name = "RepositoryError";
+    this.operation = operation;
+    this.entity = entity;
+    this.cause = cause;
+  }
+};
+var NotImplementedError = class extends SchemaError {
+  constructor(feature, milestone) {
+    const message = milestone ? `${feature}: not implemented (${milestone})` : `${feature}: not implemented`;
+    super(message, SchemaErrorCode.NOT_IMPLEMENTED, {
+      feature,
+      milestone
+    });
+    this.name = "NotImplementedError";
+    this.feature = feature;
+    this.milestone = milestone;
+  }
+};
+var MemoryNotFoundError = class extends NotFoundError {
+  constructor(memoryId) {
+    super("Memory", memoryId, SchemaErrorCode.MEMORY_NOT_FOUND);
+    this.name = "MemoryNotFoundError";
+  }
+};
+var RecordReferencedError = class extends SchemaError {
+  constructor(recordId, references) {
+    const total = references.reduce((sum, r) => sum + r.count, 0);
+    super(
+      `Cannot delete record: referenced by ${total} record${total > 1 ? "s" : ""}`,
+      SchemaErrorCode.RECORD_REFERENCED,
+      { recordId, references }
+    );
+    this.name = "RecordReferencedError";
+    this.recordId = recordId;
+    this.references = references;
+  }
+};
+var AttributeInUseError = class extends SchemaError {
+  constructor(attributeName, usage) {
+    super(
+      `Cannot delete attribute "${attributeName}": used in ${usage}`,
+      SchemaErrorCode.ATTRIBUTE_IN_USE,
+      { attributeName, usage }
+    );
+    this.name = "AttributeInUseError";
+    this.attributeName = attributeName;
+    this.usage = usage;
+  }
+};
+var ObjectReferencedError = class extends SchemaError {
+  constructor(objectName, referencingObjects) {
+    super(
+      `Cannot delete object "${objectName}": target of relations in ${referencingObjects.join(", ")}`,
+      SchemaErrorCode.OBJECT_REFERENCED,
+      { objectName, referencingObjects }
+    );
+    this.name = "ObjectReferencedError";
+    this.objectName = objectName;
+    this.referencingObjects = referencingObjects;
+  }
+};
+function isRecordReferencedError(error) {
+  return error instanceof RecordReferencedError;
+}
+function isAttributeInUseError(error) {
+  return error instanceof AttributeInUseError;
+}
+function isObjectReferencedError(error) {
+  return error instanceof ObjectReferencedError;
+}
+
+// src/validation/object/helpers.ts
+function validateAttribute(attr, value) {
+  const validator = createAttributeValidator(attr);
+  if (!attr.required && (value === void 0 || value === null)) {
+    return { success: true, data: { [attr.name]: value } };
+  }
+  const result = validator.safeParse(value);
+  if (result.success) {
+    return {
+      success: true,
+      data: { [attr.name]: result.data }
+    };
+  }
+  return {
+    success: false,
+    errors: chunkT225DB55_js.formatZodErrors(result.error).map((err) => ({
+      path: [attr.name, ...err.path],
+      message: err.message
+    }))
+  };
+}
+function validateObject(objectDef, data) {
+  const validator = createObjectValidator(objectDef);
+  const result = validator.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: chunkT225DB55_js.formatZodErrors(result.error)
+  };
+}
+function validateObjectOrThrow(objectDef, data) {
+  const result = validateObject(objectDef, data);
+  if (!result.success) {
+    const errors = result.errors ?? [];
+    const detail = errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
+    throw new ValidationError(
+      `Validation failed for ${objectDef.label}:
+${detail}`,
+      errors.map((err) => ({ path: err.path, message: err.message }))
+    );
+  }
+  return result.data;
+}
+function validateDraft(objectDef, data) {
+  const validator = createDraftValidator(objectDef);
+  const result = validator.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: chunkT225DB55_js.formatZodErrors(result.error)
+  };
+}
+function validateDraftOrThrow(objectDef, data) {
+  const result = validateDraft(objectDef, data);
+  if (!result.success) {
+    const errors = result.errors ?? [];
+    const detail = errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
+    throw new ValidationError(
+      `Draft validation failed for ${objectDef.label}:
+${detail}`,
+      errors.map((err) => ({ path: err.path, message: err.message }))
+    );
+  }
+  return result.data;
+}
+function isValuePresent(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return false;
+  }
+  return true;
+}
+function getMissingRequiredAttributes(objectDef, data) {
+  const missing = [];
+  for (const attr of objectDef.attributes) {
+    if (attr.required && !isValuePresent(data[attr.name])) {
+      missing.push(attr);
+    }
+  }
+  return missing;
+}
+function isRecordComplete(objectDef, data) {
+  const missing = getMissingRequiredAttributes(objectDef, data);
+  if (missing.length > 0) {
+    return false;
+  }
+  const validation = validateObject(objectDef, data);
+  return validation.success;
+}
+function computeRecordStatus(objectDef, data) {
+  return isRecordComplete(objectDef, data) ? "complete" : "draft";
+}
+
+exports.AccessDeniedError = AccessDeniedError;
+exports.AttributeInUseError = AttributeInUseError;
+exports.AttributeNotFoundError = AttributeNotFoundError;
+exports.ChangeTypeNotSupportedError = ChangeTypeNotSupportedError;
+exports.ConcurrentModificationError = ConcurrentModificationError;
+exports.DestructiveSyncNotAllowedError = DestructiveSyncNotAllowedError;
+exports.DuplicateError = DuplicateError;
+exports.ForbiddenError = ForbiddenError;
+exports.MemoryNotFoundError = MemoryNotFoundError;
+exports.MigrationTimeoutError = MigrationTimeoutError;
+exports.NotFoundError = NotFoundError;
+exports.NotImplementedError = NotImplementedError;
+exports.ObjectNotFoundError = ObjectNotFoundError;
+exports.ObjectReferencedError = ObjectReferencedError;
+exports.OrphanSystemAttributeError = OrphanSystemAttributeError;
+exports.ProtectedResourceError = ProtectedResourceError;
+exports.ProtectedRoleError = ProtectedRoleError;
+exports.RecordNotFoundError = RecordNotFoundError;
+exports.RecordReferencedError = RecordReferencedError;
+exports.RepositoryError = RepositoryError;
+exports.RoleNotFoundError = RoleNotFoundError;
+exports.SchemaError = SchemaError;
+exports.SchemaErrorCode = SchemaErrorCode;
+exports.StorageError = StorageError;
+exports.SyncCascadeError = SyncCascadeError;
+exports.SyncConflictError = SyncConflictError;
+exports.SyncError = SyncError;
+exports.SystemEntityImmutableError = SystemEntityImmutableError;
+exports.ValidationError = ValidationError;
+exports.computeRecordStatus = computeRecordStatus;
+exports.createAttributeValidator = createAttributeValidator;
+exports.createDraftValidator = createDraftValidator;
+exports.createFormAttributeValidator = createFormAttributeValidator;
+exports.createObjectValidator = createObjectValidator;
+exports.getMissingRequiredAttributes = getMissingRequiredAttributes;
+exports.isAttributeInUseError = isAttributeInUseError;
+exports.isNotFoundError = isNotFoundError;
+exports.isObjectReferencedError = isObjectReferencedError;
+exports.isProtectedResourceError = isProtectedResourceError;
+exports.isRecordComplete = isRecordComplete;
+exports.isRecordReferencedError = isRecordReferencedError;
+exports.isSchemaError = isSchemaError;
+exports.isValidationError = isValidationError;
+exports.validateAttribute = validateAttribute;
+exports.validateDraft = validateDraft;
+exports.validateDraftOrThrow = validateDraftOrThrow;
+exports.validateObject = validateObject;
+exports.validateObjectOrThrow = validateObjectOrThrow;