@stndrds/schema 1.0.0-alpha.294 → 1.0.0-alpha.296

package/dist/chunk-4KMUATDG.js

@@ -1,609 +0,0 @@
-'use strict';
-
-// 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",
-  SCHEMA_PLAN_NOT_FOUND: "SCHEMA_PLAN_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` means "you lack permission", and only that (#2681).
-  FORBIDDEN: "SCHEMA_FORBIDDEN",
-  ACCESS_DENIED: "SCHEMA_ACCESS_DENIED",
-  // Refusals that are NOT permission denials (#2681)
-  //
-  // `FORBIDDEN`'s message is redacted to a neutral sentence (#2675), which is
-  // honest only while the code means one thing. It did not: a workspace
-  // invariant (the last owner), a state gate (a disarmed reflex), an
-  // immutability refusal (system forms) and a missing actor context each told
-  // a caller who holds every permission that they lack one, sending them to an
-  // administrator with nothing to grant. So a refusal a permission grant would
-  // NOT lift takes one of the codes below — plus `SYSTEM_ENTITY_IMMUTABLE`,
-  // which already existed — and keeps the explanatory message that names its
-  // remedy. Every one answers 403, exactly as it did while miscoded: the
-  // ruling changed the semantics, not a single HTTP status.
-  //
-  // A fifth site was seen and deliberately left alone: `ApiKeyService`'s
-  // missing-actor refusal answers 400 `VALIDATION_FAILED`, and moving it here
-  // would change a public HTTP status — which the ruling forbids. It stays at
-  // its 400 pending a ruling of its own.
-  /**
-   * A workspace RULE refuses the write — the last owner cannot be removed.
-   *
-   * Not `INVARIANT_VIOLATION`, despite the name: that one is an internal
-   * "should never happen" assertion, a bug signal nobody outside the codebase
-   * can act on. This is the opposite — a rule the caller can act on, reached
-   * by a request that was entirely well-formed, whose message tells them how.
-   */
-  WORKSPACE_INVARIANT: "SCHEMA_WORKSPACE_INVARIANT",
-  /** The resource's own state refuses the operation — a disarmed reflex run. */
-  STATE_GATE: "SCHEMA_STATE_GATE",
-  /** The operation needs an actor and the request carried none. */
-  ACTOR_CONTEXT_REQUIRED: "SCHEMA_ACTOR_CONTEXT_REQUIRED",
-  // Connectors
-  CONNECTOR_AUTH_FAILED: "SCHEMA_CONNECTOR_AUTH_FAILED",
-  CONNECTOR_INVALID_STATE: "SCHEMA_CONNECTOR_INVALID_STATE",
-  /**
-   * The provider issued tokens and the flow failed AFTER that — resolving the
-   * connected address. Distinct from CONNECTOR_AUTH_FAILED because the user is
-   * left holding a real grant: consent happened, and it may still be live on the
-   * provider side even though no connection row exists here.
-   */
-  CONNECTOR_GRANT_ORPHANED: "SCHEMA_CONNECTOR_GRANT_ORPHANED",
-  // 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: "SCHEMA_DUPLICATE",
-  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",
-  // --------------------------------------------------------------------------
-  // Platform-wide codes (runtime). This enum is the single registry of every
-  // error type across the stack; domain error classes live in their module but
-  // draw their `code` from here. Never throw a raw `Error` — pick a code below.
-  // --------------------------------------------------------------------------
-  // Configuration / wiring — a required runtime dependency is not configured
-  CONFIGURATION_REQUIRED: "CONFIGURATION_REQUIRED",
-  SEARCH_ADAPTER_REQUIRED: "SEARCH_ADAPTER_REQUIRED",
-  // Background jobs — one or more cron schedules could not be armed at boot
-  CRON_REGISTRATION_FAILED: "CRON_REGISTRATION_FAILED",
-  // Search backend — a search read call failed at the transport level
-  // (non-API transport error: JSON.parse on a non-JSON body, network failure)
-  SEARCH_BACKEND_FAILED: "SEARCH_BACKEND_FAILED",
-  // Invariants — internal "should never happen" assertions (programmer error)
-  INVARIANT_VIOLATION: "INVARIANT_VIOLATION",
-  // Tenant / context
-  TENANT_CONTEXT_MISSING: "TENANT_CONTEXT_MISSING",
-  FEATURE_FLAGS_CONTEXT: "FEATURE_FLAGS_CONTEXT",
-  // Realtime delivery — stable codes shared by runtime and transport adapters
-  REALTIME_RATE_LIMITED: "REALTIME_RATE_LIMITED",
-  REALTIME_DELIVERY_FAILED: "REALTIME_DELIVERY_FAILED",
-  REALTIME_SUBSCRIPTION_FAILED: "REALTIME_SUBSCRIPTION_FAILED",
-  // Agents
-  AGENT_UNKNOWN: "AGENT_UNKNOWN",
-  AGENT_DEPTH_EXCEEDED: "AGENT_DEPTH_EXCEEDED",
-  AGENT_COST_LIMIT_EXCEEDED: "AGENT_COST_LIMIT_EXCEEDED",
-  AGENT_TREE_COST_LIMIT_EXCEEDED: "AGENT_TREE_COST_LIMIT_EXCEEDED",
-  AGENT_SESSION_NOT_FOUND: "AGENT_SESSION_NOT_FOUND",
-  AGENT_DEFINITION_NOT_FOUND: "AGENT_DEFINITION_NOT_FOUND",
-  AGENT_RUN_CONFIG: "AGENT_RUN_CONFIG",
-  AGENT_STREAMING: "AGENT_STREAMING",
-  AGENT_MISSING_ACTOR: "AGENT_MISSING_ACTOR",
-  AGENT_INVALID_STATE: "AGENT_INVALID_STATE",
-  AGENT_COMPACTION_IMPOSSIBLE: "AGENT_COMPACTION_IMPOSSIBLE",
-  AGENT_COMPACTION_TIMEOUT: "AGENT_COMPACTION_TIMEOUT",
-  AGENT_LEASE_HELD: "AGENT_LEASE_HELD",
-  AGENT_WORK_MODE_REQUIRED: "AGENT_WORK_MODE_REQUIRED",
-  AGENT_MESSAGE_NOT_FOUND: "AGENT_MESSAGE_NOT_FOUND",
-  AGENT_MESSAGE_NOT_EDITABLE: "AGENT_MESSAGE_NOT_EDITABLE",
-  // Remote devices
-  DEVICE_NOT_FOUND: "DEVICE_NOT_FOUND",
-  DEVICE_OFFLINE: "DEVICE_OFFLINE",
-  // AI / LLM
-  AI_UNKNOWN: "AI_UNKNOWN",
-  AI_USAGE_LIMIT_EXCEEDED: "AI_USAGE_LIMIT_EXCEEDED",
-  AI_INVALID_USAGE: "AI_INVALID_USAGE",
-  AI_INVALID_MODEL: "AI_INVALID_MODEL",
-  AI_INVALID_MODEL_INPUT: "AI_INVALID_MODEL_INPUT",
-  AI_REPOSITORY_ERROR: "AI_REPOSITORY_ERROR",
-  AI_GENERATION_FAILED: "AI_GENERATION_FAILED",
-  // Documents — attach/detach and file operations
-  DOCUMENT_MIME_NOT_ACCEPTED: "DOCUMENT_MIME_NOT_ACCEPTED",
-  DOCUMENT_MULTIPLE_NOT_ALLOWED: "DOCUMENT_MULTIPLE_NOT_ALLOWED",
-  DOCUMENT_NOT_FOUND_FOR_OPERATION: "DOCUMENT_NOT_FOUND_FOR_OPERATION",
-  DOCUMENT_STORAGE_FAILED: "DOCUMENT_STORAGE_FAILED",
-  DOCUMENT_SIZE_EXCEEDED: "DOCUMENT_SIZE_EXCEEDED",
-  DOCUMENT_OCR_FAILED: "DOCUMENT_OCR_FAILED",
-  DOCUMENT_BLOB_EMPTY: "DOCUMENT_BLOB_EMPTY",
-  DOCUMENT_FILE_TOO_LARGE: "DOCUMENT_FILE_TOO_LARGE",
-  DOCUMENT_FILE_NOT_FOUND: "DOCUMENT_FILE_NOT_FOUND",
-  DOCUMENT_FILE_ALREADY_PACKED: "DOCUMENT_FILE_ALREADY_PACKED",
-  // Documents — agent placement guards (record/drive targeting from tools)
-  DOCUMENT_RECORD_NOT_FOUND: "DOCUMENT_RECORD_NOT_FOUND",
-  DOCUMENT_RECORD_OBJECT_MISMATCH: "DOCUMENT_RECORD_OBJECT_MISMATCH",
-  DOCUMENT_FOLDER_SERVICE_UNAVAILABLE: "DOCUMENT_FOLDER_SERVICE_UNAVAILABLE",
-  DOCUMENT_FOLDER_PATH_NOT_FOUND: "DOCUMENT_FOLDER_PATH_NOT_FOUND",
-  // Email image proxy — token/fetch failures surfaced through the proxy route
-  // Email provider sync — transport failures from Gmail / Microsoft Graph
-  EMAIL_PROVIDER_API_FAILED: "EMAIL_PROVIDER_API_FAILED",
-  EMAIL_BATCH_ITEM_FAILED: "EMAIL_BATCH_ITEM_FAILED",
-  // Calendar provider sync — transport failures from Google Calendar / Microsoft Graph
-  CALENDAR_PROVIDER_API_FAILED: "CALENDAR_PROVIDER_API_FAILED",
-  // Reflexes — agent-authored deterministic automations
-  REFLEX_INVALID_TRANSITION: "REFLEX_INVALID_TRANSITION",
-  REFLEX_INVALID_TOKEN: "REFLEX_INVALID_TOKEN",
-  REFLEX_CAPABILITY_DENIED: "REFLEX_CAPABILITY_DENIED",
-  REFLEX_GATEWAY_UNAVAILABLE: "REFLEX_GATEWAY_UNAVAILABLE",
-  REFLEX_BUNDLE_FAILED: "REFLEX_BUNDLE_FAILED",
-  REFLEX_EGRESS_DENIED: "REFLEX_EGRESS_DENIED",
-  REFLEX_PROTOCOL_VIOLATION: "REFLEX_PROTOCOL_VIOLATION",
-  REFLEX_RUN_FAILED: "REFLEX_RUN_FAILED",
-  REFLEX_RUN_TIMEOUT: "REFLEX_RUN_TIMEOUT",
-  REFLEX_DEPENDENCY_DRIFT: "REFLEX_DEPENDENCY_DRIFT",
-  REFLEX_NOT_READY: "REFLEX_NOT_READY",
-  REFLEX_INVARIANT_VIOLATION: "REFLEX_INVARIANT_VIOLATION",
-  /** The embeddings feature is enabled but no Gateway credential is configured. */
-  EMBEDDING_MODEL_UNAVAILABLE: "EMBEDDING_MODEL_UNAVAILABLE",
-  /** The provider returned vectors whose length differs from the configured dimensions. */
-  EMBEDDING_DIMENSION_MISMATCH: "EMBEDDING_DIMENSION_MISMATCH"
-};
-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, message = `${resourceType} with id "${resourceId}" not found`) {
-    super(message, code, {
-      resourceType,
-      resourceId
-    });
-    /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
-    this._tag = "NotFoundError";
-    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 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 });
-    /** Literal discriminator for `Effect.catchTag`; a widened `string` breaks narrowing. */
-    this._tag = "ValidationError";
-    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) => {
-      const named = op;
-      return named.name ? `- ${op.type} "${named.name}"` : `- ${op.type}`;
-    }).join("\n");
-    super(
-      `Destructive schema operations detected (data will be lost):
-${summary}
-
-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.`,
-      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, message) {
-    const code = resourceType === "object" ? SchemaErrorCode.DUPLICATE_OBJECT : resourceType === "attribute" ? SchemaErrorCode.DUPLICATE_ATTRIBUTE : SchemaErrorCode.DUPLICATE;
-    const autoMessage = `${resourceType.charAt(0).toUpperCase()}${resourceType.slice(1)} "${resourceName}" already exists`;
-    super(message ?? autoMessage, 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}${cause ? ` (${cause})` : ""}`, code, {
-      operation,
-      entity,
-      cause
-    });
-    this.name = "RepositoryError";
-    this.operation = operation;
-    this.entity = entity;
-    this.cause = cause;
-  }
-};
-var SearchBackendError = class extends SchemaError {
-  constructor(scope, cause) {
-    super(`Search backend unavailable for ${scope}`, SchemaErrorCode.SEARCH_BACKEND_FAILED, {
-      scope,
-      cause
-    });
-    this.name = "SearchBackendError";
-    this.scope = scope;
-    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;
-}
-
-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.SchemaPlanNotFoundError = SchemaPlanNotFoundError;
-exports.SearchBackendError = SearchBackendError;
-exports.StorageError = StorageError;
-exports.SyncCascadeError = SyncCascadeError;
-exports.SyncConflictError = SyncConflictError;
-exports.SyncError = SyncError;
-exports.SystemEntityImmutableError = SystemEntityImmutableError;
-exports.ValidationError = ValidationError;
-exports.isAttributeInUseError = isAttributeInUseError;
-exports.isNotFoundError = isNotFoundError;
-exports.isObjectReferencedError = isObjectReferencedError;
-exports.isProtectedResourceError = isProtectedResourceError;
-exports.isRecordReferencedError = isRecordReferencedError;
-exports.isSchemaError = isSchemaError;
-exports.isValidationError = isValidationError;

package/dist/chunk-5WATIVCA.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var chunkYKWSHBT5_js = require('./chunk-YKWSHBT5.js');
-var zod = require('zod');
-
-function createCheckboxValidator(_attr, _messages = chunkYKWSHBT5_js.DEFAULT_VALIDATION_MESSAGES) {
-  return zod.z.boolean();
-}
-
-exports.createCheckboxValidator = createCheckboxValidator;

package/dist/chunk-ACKMC6FL.js

@@ -1,17 +0,0 @@
-'use strict';
-
-var chunkYKWSHBT5_js = require('./chunk-YKWSHBT5.js');
-var zod = require('zod');
-
-function createCurrencyValidator(attr, messages = chunkYKWSHBT5_js.DEFAULT_VALIDATION_MESSAGES) {
-  const valueSchema = attr.allowNegative ? zod.z.number() : zod.z.number().min(0);
-  return zod.z.object(
-    {
-      code: zod.z.string().length(3),
-      value: valueSchema
-    },
-    { message: messages.invalidCurrency(attr) }
-  );
-}
-
-exports.createCurrencyValidator = createCurrencyValidator;

package/dist/chunk-AYVHMVKQ.mjs

@@ -1,15 +0,0 @@
-import { DEFAULT_VALIDATION_MESSAGES } from './chunk-HRQEZUAA.mjs';
-import { z } from 'zod';
-
-function createCurrencyValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const valueSchema = attr.allowNegative ? z.number() : z.number().min(0);
-  return z.object(
-    {
-      code: z.string().length(3),
-      value: valueSchema
-    },
-    { message: messages.invalidCurrency(attr) }
-  );
-}
-
-export { createCurrencyValidator };