@vorionsys/shared-constants 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1762 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACTIVE_THEME: () => ACTIVE_THEME,
+  AGENTANCHOR_DOMAINS: () => AGENTANCHOR_DOMAINS,
+  AGENTANCHOR_EMAILS: () => AGENTANCHOR_EMAILS,
+  AGENTANCHOR_PRODUCTS: () => AGENTANCHOR_PRODUCTS,
+  ALL_DOMAINS: () => ALL_DOMAINS,
+  ALL_PRODUCTS: () => ALL_PRODUCTS,
+  ALL_TIERS: () => ALL_TIERS,
+  API_ENDPOINTS: () => API_ENDPOINTS,
+  API_VERSIONS: () => API_VERSIONS,
+  AUTH_ERRORS: () => AUTH_ERRORS,
+  BASIS_CURRENT_VERSION: () => BASIS_CURRENT_VERSION,
+  BASIS_SPEC_VERSION: () => BASIS_SPEC_VERSION,
+  BASIS_VERSIONS: () => BASIS_VERSIONS,
+  CAPABILITIES: () => CAPABILITIES,
+  CAR_SPEC_CURRENT_VERSION: () => CAR_SPEC_CURRENT_VERSION,
+  CAR_SPEC_VERSIONS: () => CAR_SPEC_VERSIONS,
+  COGNIGATE_CURRENT_VERSION: () => COGNIGATE_CURRENT_VERSION,
+  COGNIGATE_DEFAULT_VERSION: () => COGNIGATE_DEFAULT_VERSION,
+  COGNIGATE_DOMAINS: () => COGNIGATE_DOMAINS,
+  COGNIGATE_VERSIONS: () => COGNIGATE_VERSIONS,
+  CapabilityCategory: () => CapabilityCategory,
+  DOMAIN_ALIASES: () => DOMAIN_ALIASES,
+  ERROR_CODES: () => ERROR_CODES,
+  EXTERNAL_ERRORS: () => EXTERNAL_ERRORS,
+  ErrorCategory: () => ErrorCategory,
+  GITHUB: () => GITHUB,
+  LAST_UPDATED: () => LAST_UPDATED,
+  LOGIC_API_VERSIONS: () => LOGIC_API_VERSIONS,
+  LOGIC_CURRENT_VERSION: () => LOGIC_CURRENT_VERSION,
+  NOT_FOUND_ERRORS: () => NOT_FOUND_ERRORS,
+  NPM_PACKAGES: () => NPM_PACKAGES,
+  ProductCategory: () => ProductCategory,
+  ProductStatus: () => ProductStatus,
+  RATE_LIMITS: () => RATE_LIMITS,
+  RATE_LIMIT_ERRORS: () => RATE_LIMIT_ERRORS,
+  SERVER_ERRORS: () => SERVER_ERRORS,
+  THEMES: () => THEMES,
+  TIER_QUOTAS: () => TIER_QUOTAS,
+  TIER_THRESHOLDS: () => TIER_THRESHOLDS,
+  TRUST_API_VERSIONS: () => TRUST_API_VERSIONS,
+  TRUST_CURRENT_VERSION: () => TRUST_CURRENT_VERSION,
+  TRUST_ERRORS: () => TRUST_ERRORS,
+  TrustTier: () => TrustTier,
+  VALIDATION_ERRORS: () => VALIDATION_ERRORS,
+  VERSION: () => VERSION,
+  VERSION_HEADERS: () => VERSION_HEADERS,
+  VORION_DOMAINS: () => VORION_DOMAINS,
+  VORION_EMAILS: () => VORION_EMAILS,
+  VORION_PRODUCTS: () => VORION_PRODUCTS,
+  VersionStatus: () => VersionStatus,
+  buildApiUrl: () => buildApiUrl,
+  createErrorResponse: () => createErrorResponse,
+  formatErrorMessage: () => formatErrorMessage,
+  formatRateLimit: () => formatRateLimit,
+  getActiveTheme: () => getActiveTheme,
+  getAllCapabilityCodes: () => getAllCapabilityCodes,
+  getAllThemeIds: () => getAllThemeIds,
+  getCapabilitiesByCategory: () => getCapabilitiesByCategory,
+  getCapabilitiesForTier: () => getCapabilitiesForTier,
+  getCapability: () => getCapability,
+  getCapabilityMinTier: () => getCapabilityMinTier,
+  getCurrentVersion: () => getCurrentVersion,
+  getErrorByCode: () => getErrorByCode,
+  getErrorsByCategory: () => getErrorsByCategory,
+  getMinTierForLimits: () => getMinTierForLimits,
+  getProduct: () => getProduct,
+  getProductsByCategory: () => getProductsByCategory,
+  getProductsByOrganization: () => getProductsByOrganization,
+  getProductsByStatus: () => getProductsByStatus,
+  getQuota: () => getQuota,
+  getRateLimits: () => getRateLimits,
+  getRetryableErrors: () => getRetryableErrors,
+  getStableVersions: () => getStableVersions,
+  getTierCode: () => getTierCode,
+  getTierColor: () => getTierColor,
+  getTierMaxScore: () => getTierMaxScore,
+  getTierMinScore: () => getTierMinScore,
+  getTierName: () => getTierName,
+  getTierThreshold: () => getTierThreshold,
+  getVersionDefinition: () => getVersionDefinition,
+  isCapabilityAvailable: () => isCapabilityAvailable,
+  isUnlimited: () => isUnlimited,
+  isVersionDeprecated: () => isVersionDeprecated,
+  isVersionSupported: () => isVersionSupported,
+  meetsTierRequirement: () => meetsTierRequirement,
+  parseTier: () => parseTier,
+  scoreToTier: () => scoreToTier,
+  themeToCssVars: () => themeToCssVars,
+  wouldExceedLimit: () => wouldExceedLimit
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/tiers.ts
+var TrustTier = /* @__PURE__ */ ((TrustTier2) => {
+  TrustTier2[TrustTier2["T0_SANDBOX"] = 0] = "T0_SANDBOX";
+  TrustTier2[TrustTier2["T1_OBSERVED"] = 1] = "T1_OBSERVED";
+  TrustTier2[TrustTier2["T2_PROVISIONAL"] = 2] = "T2_PROVISIONAL";
+  TrustTier2[TrustTier2["T3_MONITORED"] = 3] = "T3_MONITORED";
+  TrustTier2[TrustTier2["T4_STANDARD"] = 4] = "T4_STANDARD";
+  TrustTier2[TrustTier2["T5_TRUSTED"] = 5] = "T5_TRUSTED";
+  TrustTier2[TrustTier2["T6_CERTIFIED"] = 6] = "T6_CERTIFIED";
+  TrustTier2[TrustTier2["T7_AUTONOMOUS"] = 7] = "T7_AUTONOMOUS";
+  return TrustTier2;
+})(TrustTier || {});
+var TIER_THRESHOLDS = {
+  [0 /* T0_SANDBOX */]: {
+    min: 0,
+    max: 199,
+    name: "Sandbox",
+    description: "Isolated, no external access, observation only",
+    color: "#78716c",
+    textColor: "#ffffff"
+  },
+  [1 /* T1_OBSERVED */]: {
+    min: 200,
+    max: 349,
+    name: "Observed",
+    description: "Read-only, sandboxed execution, monitored",
+    color: "#ef4444",
+    textColor: "#ffffff"
+  },
+  [2 /* T2_PROVISIONAL */]: {
+    min: 350,
+    max: 500,
+    name: "Provisional",
+    description: "Basic operations, heavy supervision",
+    color: "#f97316",
+    textColor: "#ffffff"
+  },
+  [3 /* T3_MONITORED */]: {
+    min: 501,
+    max: 649,
+    name: "Monitored",
+    description: "Standard operations with continuous monitoring",
+    color: "#eab308",
+    textColor: "#000000"
+  },
+  [4 /* T4_STANDARD */]: {
+    min: 650,
+    max: 799,
+    name: "Standard",
+    description: "External API access, policy-governed",
+    color: "#22c55e",
+    textColor: "#ffffff"
+  },
+  [5 /* T5_TRUSTED */]: {
+    min: 800,
+    max: 875,
+    name: "Trusted",
+    description: "Cross-agent communication, delegated tasks",
+    color: "#3b82f6",
+    textColor: "#ffffff"
+  },
+  [6 /* T6_CERTIFIED */]: {
+    min: 876,
+    max: 950,
+    name: "Certified",
+    description: "Admin tasks, agent spawning, minimal oversight",
+    color: "#8b5cf6",
+    textColor: "#ffffff"
+  },
+  [7 /* T7_AUTONOMOUS */]: {
+    min: 951,
+    max: 1e3,
+    name: "Autonomous",
+    description: "Full autonomy, self-governance, strategic only",
+    color: "#06b6d4",
+    textColor: "#ffffff"
+  }
+};
+function scoreToTier(score) {
+  if (score < 0 || score > 1e3) {
+    throw new Error(`Trust score must be between 0 and 1000, got ${score}`);
+  }
+  if (score >= 951) return 7 /* T7_AUTONOMOUS */;
+  if (score >= 876) return 6 /* T6_CERTIFIED */;
+  if (score >= 800) return 5 /* T5_TRUSTED */;
+  if (score >= 650) return 4 /* T4_STANDARD */;
+  if (score >= 501) return 3 /* T3_MONITORED */;
+  if (score >= 350) return 2 /* T2_PROVISIONAL */;
+  if (score >= 200) return 1 /* T1_OBSERVED */;
+  return 0 /* T0_SANDBOX */;
+}
+function getTierThreshold(tier) {
+  return TIER_THRESHOLDS[tier];
+}
+function getTierName(tier) {
+  return TIER_THRESHOLDS[tier].name;
+}
+function getTierColor(tier) {
+  return TIER_THRESHOLDS[tier].color;
+}
+function getTierMinScore(tier) {
+  return TIER_THRESHOLDS[tier].min;
+}
+function getTierMaxScore(tier) {
+  return TIER_THRESHOLDS[tier].max;
+}
+function meetsTierRequirement(score, minTier) {
+  const actualTier = scoreToTier(score);
+  return actualTier >= minTier;
+}
+function getTierCode(tier) {
+  return `T${tier}`;
+}
+function parseTier(input) {
+  const normalized = input.toUpperCase().trim();
+  const tMatch = normalized.match(/^T?(\d)$/);
+  if (tMatch) {
+    const num = parseInt(tMatch[1], 10);
+    if (num >= 0 && num <= 7) {
+      return num;
+    }
+  }
+  const nameMap = {
+    SANDBOX: 0 /* T0_SANDBOX */,
+    OBSERVED: 1 /* T1_OBSERVED */,
+    PROVISIONAL: 2 /* T2_PROVISIONAL */,
+    MONITORED: 3 /* T3_MONITORED */,
+    STANDARD: 4 /* T4_STANDARD */,
+    TRUSTED: 5 /* T5_TRUSTED */,
+    CERTIFIED: 6 /* T6_CERTIFIED */,
+    AUTONOMOUS: 7 /* T7_AUTONOMOUS */
+  };
+  return nameMap[normalized] ?? null;
+}
+var ALL_TIERS = [
+  0 /* T0_SANDBOX */,
+  1 /* T1_OBSERVED */,
+  2 /* T2_PROVISIONAL */,
+  3 /* T3_MONITORED */,
+  4 /* T4_STANDARD */,
+  5 /* T5_TRUSTED */,
+  6 /* T6_CERTIFIED */,
+  7 /* T7_AUTONOMOUS */
+];
+
+// src/domains.ts
+var VORION_DOMAINS = {
+  /** Main Vorion organization site */
+  main: "https://vorion.org",
+  /** BASIS specification and documentation */
+  basis: "https://basis.vorion.org",
+  /** CAR ID specification */
+  carId: "https://carid.vorion.org",
+  /** ATSF (Agent Trust & Safety Framework) */
+  atsf: "https://atsf.vorion.org",
+  /** Learning and educational resources (primary) */
+  learn: "https://learn.vorion.org",
+  /** Kaizen - Interactive AI Learning Experience (mirrors learn) */
+  kaizen: "https://kaizen.vorion.org",
+  /** Technical documentation */
+  docs: "https://docs.vorion.org",
+  /** Community forum */
+  community: "https://community.vorion.org"
+};
+var DOMAIN_ALIASES = {
+  "kaizen.vorion.org": "learn.vorion.org"
+};
+var AGENTANCHOR_DOMAINS = {
+  /** Main Agent Anchor AI site */
+  main: "https://agentanchorai.com",
+  /** Agent Anchor Trust - Trust verification and certification */
+  trust: "https://trust.agentanchorai.com",
+  /** Agent Anchor Logic - Policy engine and governance logic */
+  logic: "https://logic.agentanchorai.com",
+  /** Status page */
+  status: "https://status.agentanchorai.com"
+};
+var COGNIGATE_DOMAINS = {
+  /** Cognigate main site and documentation */
+  main: "https://cognigate.dev",
+  /** Cognigate API documentation */
+  docs: "https://cognigate.dev/docs"
+};
+var API_ENDPOINTS = {
+  /** Cognigate Production API */
+  cognigate: {
+    production: "https://cognigate.dev/v1",
+    staging: "https://staging.cognigate.dev/v1"
+  },
+  /** Agent Anchor AI Production API */
+  agentAnchor: {
+    production: "https://api.agentanchorai.com/v1",
+    staging: "https://staging-api.agentanchorai.com/v1",
+    sandbox: "https://sandbox.agentanchorai.com/v1"
+  },
+  /** Trust API */
+  trust: {
+    production: "https://trust.agentanchorai.com/v1",
+    staging: "https://staging.trust.agentanchorai.com/v1"
+  },
+  /** Logic/Policy API */
+  logic: {
+    production: "https://logic.agentanchorai.com/v1",
+    staging: "https://staging.logic.agentanchorai.com/v1"
+  }
+};
+var VORION_EMAILS = {
+  /** General inquiries */
+  info: "info@vorion.org",
+  /** Security reports */
+  security: "security@vorion.org",
+  /** Legal inquiries */
+  legal: "legal@vorion.org",
+  /** Community and contributions */
+  community: "community@vorion.org",
+  /** Contributing */
+  contribute: "contribute@vorion.org"
+};
+var AGENTANCHOR_EMAILS = {
+  /** General support */
+  support: "support@agentanchorai.com",
+  /** Sales inquiries */
+  sales: "sales@agentanchorai.com",
+  /** Partner program */
+  partners: "partners@agentanchorai.com",
+  /** API support */
+  apiSupport: "api-support@agentanchorai.com",
+  /** Enterprise inquiries */
+  enterprise: "enterprise@agentanchorai.com",
+  /** Compliance */
+  compliance: "compliance@agentanchorai.com",
+  /** Team */
+  team: "team@agentanchorai.com"
+};
+var GITHUB = {
+  /** Vorion organization */
+  vorion: {
+    org: "https://github.com/voriongit",
+    mainRepo: "https://github.com/voriongit/vorion"
+  },
+  /** Agent Anchor AI (if separate) */
+  agentAnchor: {
+    org: "https://github.com/agentanchorai"
+  }
+};
+var NPM_PACKAGES = {
+  /** Open source packages (@vorionsys) */
+  vorion: {
+    basis: "@vorionsys/basis",
+    contracts: "@vorionsys/contracts",
+    carSpec: "@vorionsys/car-spec",
+    atsfCore: "@vorionsys/atsf-core",
+    cognigate: "@vorionsys/cognigate",
+    sharedConstants: "@vorionsys/shared-constants"
+  },
+  /** Commercial packages (@agentanchor) */
+  agentAnchor: {
+    sdk: "@agentanchor/sdk",
+    trust: "@agentanchor/trust",
+    logic: "@agentanchor/logic"
+  }
+};
+var ALL_DOMAINS = {
+  vorion: VORION_DOMAINS,
+  agentAnchor: AGENTANCHOR_DOMAINS,
+  cognigate: COGNIGATE_DOMAINS,
+  api: API_ENDPOINTS,
+  emails: {
+    vorion: VORION_EMAILS,
+    agentAnchor: AGENTANCHOR_EMAILS
+  },
+  github: GITHUB,
+  npm: NPM_PACKAGES
+};
+
+// src/capabilities.ts
+var CapabilityCategory = /* @__PURE__ */ ((CapabilityCategory2) => {
+  CapabilityCategory2["DATA_ACCESS"] = "data_access";
+  CapabilityCategory2["API_ACCESS"] = "api_access";
+  CapabilityCategory2["CODE_EXECUTION"] = "code_execution";
+  CapabilityCategory2["AGENT_INTERACTION"] = "agent_interaction";
+  CapabilityCategory2["RESOURCE_MANAGEMENT"] = "resource_management";
+  CapabilityCategory2["GOVERNANCE"] = "governance";
+  CapabilityCategory2["ADMIN"] = "admin";
+  return CapabilityCategory2;
+})(CapabilityCategory || {});
+var CAPABILITIES = [
+  // T0 - Sandbox
+  {
+    code: "CAP-READ-PUBLIC",
+    name: "Read Public Data",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Access publicly available data",
+    unlockTier: 0 /* T0_SANDBOX */
+  },
+  {
+    code: "CAP-GENERATE-TEXT",
+    name: "Generate Text",
+    category: "code_execution" /* CODE_EXECUTION */,
+    description: "Generate text responses",
+    unlockTier: 0 /* T0_SANDBOX */
+  },
+  // T1 - Observed
+  {
+    code: "CAP-READ-INTERNAL",
+    name: "Read Internal Data",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Access internal data within allowed scopes",
+    unlockTier: 1 /* T1_OBSERVED */,
+    constraints: ["Read-only", "Logged"]
+  },
+  {
+    code: "CAP-INTERNAL-API",
+    name: "Internal API Access",
+    category: "api_access" /* API_ACCESS */,
+    description: "Make read-only internal API calls",
+    unlockTier: 1 /* T1_OBSERVED */,
+    constraints: ["GET only", "Rate limited"]
+  },
+  // T2 - Provisional
+  {
+    code: "CAP-FILE-WRITE",
+    name: "Write Files",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Write to approved directories",
+    unlockTier: 2 /* T2_PROVISIONAL */,
+    constraints: ["Approved dirs only", "Size limited"]
+  },
+  {
+    code: "CAP-DB-READ",
+    name: "Database Read",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Read from approved database tables",
+    unlockTier: 2 /* T2_PROVISIONAL */,
+    constraints: ["Approved tables", "Query timeout"]
+  },
+  {
+    code: "CAP-EXTERNAL-API-READ",
+    name: "External API Read",
+    category: "api_access" /* API_ACCESS */,
+    description: "Make GET requests to approved external APIs",
+    unlockTier: 2 /* T2_PROVISIONAL */,
+    constraints: ["GET only", "Approved endpoints"]
+  },
+  // T3 - Monitored
+  {
+    code: "CAP-DB-WRITE",
+    name: "Database Write",
+    category: "data_access" /* DATA_ACCESS */,
+    description: "Write to approved database tables",
+    unlockTier: 3 /* T3_MONITORED */,
+    constraints: ["Approved tables", "Transaction limits"]
+  },
+  {
+    code: "CAP-EXTERNAL-API-FULL",
+    name: "External API Full Access",
+    category: "api_access" /* API_ACCESS */,
+    description: "Full REST operations on approved external APIs",
+    unlockTier: 3 /* T3_MONITORED */,
+    constraints: ["Approved endpoints", "Rate limited"]
+  },
+  {
+    code: "CAP-CODE-SANDBOX",
+    name: "Sandboxed Code Execution",
+    category: "code_execution" /* CODE_EXECUTION */,
+    description: "Execute code in isolated sandbox",
+    unlockTier: 3 /* T3_MONITORED */,
+    constraints: ["Sandboxed", "Time limited", "No network"]
+  },
+  // T4 - Standard
+  {
+    code: "CAP-AGENT-COMMUNICATE",
+    name: "Agent Communication",
+    category: "agent_interaction" /* AGENT_INTERACTION */,
+    description: "Send and receive messages to/from other agents",
+    unlockTier: 4 /* T4_STANDARD */,
+    constraints: ["Approved agents", "Message limits"]
+  },
+  {
+    code: "CAP-WORKFLOW-MULTI",
+    name: "Multi-Step Workflow",
+    category: "code_execution" /* CODE_EXECUTION */,
+    description: "Orchestrate multi-step workflows",
+    unlockTier: 4 /* T4_STANDARD */,
+    constraints: ["Approved patterns", "Checkpoints required"]
+  },
+  {
+    code: "CAP-ESCALATE-HUMAN",
+    name: "Human Escalation",
+    category: "governance" /* GOVERNANCE */,
+    description: "Initiate escalation to human reviewers",
+    unlockTier: 4 /* T4_STANDARD */
+  },
+  // T5 - Trusted
+  {
+    code: "CAP-AGENT-DELEGATE",
+    name: "Task Delegation",
+    category: "agent_interaction" /* AGENT_INTERACTION */,
+    description: "Delegate tasks to other agents",
+    unlockTier: 5 /* T5_TRUSTED */,
+    constraints: ["Trust verified agents"]
+  },
+  {
+    code: "CAP-RESOURCE-PROVISION",
+    name: "Resource Provisioning",
+    category: "resource_management" /* RESOURCE_MANAGEMENT */,
+    description: "Provision computational resources",
+    unlockTier: 5 /* T5_TRUSTED */,
+    constraints: ["Budget limits", "Approval required"]
+  },
+  // T6 - Certified
+  {
+    code: "CAP-AGENT-SPAWN",
+    name: "Spawn Agents",
+    category: "agent_interaction" /* AGENT_INTERACTION */,
+    description: "Create new agent instances",
+    unlockTier: 6 /* T6_CERTIFIED */,
+    constraints: ["Template required", "Quota limited"]
+  },
+  {
+    code: "CAP-INFRA-MANAGE",
+    name: "Infrastructure Management",
+    category: "resource_management" /* RESOURCE_MANAGEMENT */,
+    description: "Manage infrastructure resources",
+    unlockTier: 6 /* T6_CERTIFIED */,
+    constraints: ["Approved resources"]
+  },
+  {
+    code: "CAP-POLICY-CREATE",
+    name: "Policy Creation",
+    category: "governance" /* GOVERNANCE */,
+    description: "Create governance policies",
+    unlockTier: 6 /* T6_CERTIFIED */,
+    constraints: ["Review required"]
+  },
+  // T7 - Autonomous
+  {
+    code: "CAP-FULL-ADMIN",
+    name: "Full Administration",
+    category: "admin" /* ADMIN */,
+    description: "Full administrative access",
+    unlockTier: 7 /* T7_AUTONOMOUS */
+  },
+  {
+    code: "CAP-SELF-MODIFY",
+    name: "Self-Modification",
+    category: "code_execution" /* CODE_EXECUTION */,
+    description: "Modify own configuration and behavior",
+    unlockTier: 7 /* T7_AUTONOMOUS */,
+    constraints: ["Ethical bounds", "Audit logged"]
+  },
+  {
+    code: "CAP-STRATEGIC-DECISION",
+    name: "Strategic Decisions",
+    category: "governance" /* GOVERNANCE */,
+    description: "Make strategic organizational decisions",
+    unlockTier: 7 /* T7_AUTONOMOUS */,
+    constraints: ["Human oversight available"]
+  }
+];
+function getCapabilitiesForTier(tier) {
+  return CAPABILITIES.filter((cap) => cap.unlockTier <= tier);
+}
+function getCapability(code) {
+  return CAPABILITIES.find((cap) => cap.code === code);
+}
+function isCapabilityAvailable(code, tier) {
+  const cap = getCapability(code);
+  return cap !== void 0 && cap.unlockTier <= tier;
+}
+function getCapabilityMinTier(code) {
+  return getCapability(code)?.unlockTier;
+}
+function getCapabilitiesByCategory(category) {
+  return CAPABILITIES.filter((cap) => cap.category === category);
+}
+function getAllCapabilityCodes() {
+  return CAPABILITIES.map((cap) => cap.code);
+}
+
+// src/products.ts
+var ProductCategory = /* @__PURE__ */ ((ProductCategory2) => {
+  ProductCategory2["OPEN_SOURCE"] = "open_source";
+  ProductCategory2["COMMERCIAL"] = "commercial";
+  ProductCategory2["DEVELOPER_TOOLS"] = "developer_tools";
+  ProductCategory2["EDUCATION"] = "education";
+  return ProductCategory2;
+})(ProductCategory || {});
+var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
+  ProductStatus2["DEVELOPMENT"] = "development";
+  ProductStatus2["ALPHA"] = "alpha";
+  ProductStatus2["BETA"] = "beta";
+  ProductStatus2["GA"] = "ga";
+  ProductStatus2["DEPRECATED"] = "deprecated";
+  ProductStatus2["EOL"] = "eol";
+  return ProductStatus2;
+})(ProductStatus || {});
+var VORION_PRODUCTS = {
+  basis: {
+    id: "basis",
+    name: "BASIS",
+    description: "Blockchain Agent Safety & Identity Standard - Open framework for AI agent governance",
+    category: "open_source" /* OPEN_SOURCE */,
+    status: "ga" /* GA */,
+    url: "https://basis.vorion.org",
+    docsUrl: "https://basis.vorion.org/docs",
+    repoUrl: "https://github.com/voriongit/vorion/tree/master/packages/basis",
+    npmPackage: "@vorionsys/basis",
+    organization: "vorion",
+    version: "1.0.0"
+  },
+  carId: {
+    id: "car-id",
+    name: "CAR ID",
+    description: "Categorical Agent Registry - Universal agent identification system",
+    category: "open_source" /* OPEN_SOURCE */,
+    status: "ga" /* GA */,
+    url: "https://carid.vorion.org",
+    docsUrl: "https://carid.vorion.org/docs",
+    repoUrl: "https://github.com/voriongit/vorion/tree/master/packages/car-spec",
+    npmPackage: "@vorionsys/car-spec",
+    organization: "vorion",
+    version: "1.0.0"
+  },
+  atsf: {
+    id: "atsf",
+    name: "ATSF",
+    description: "Agent Trust & Safety Framework - Comprehensive safety evaluation system",
+    category: "open_source" /* OPEN_SOURCE */,
+    status: "beta" /* BETA */,
+    url: "https://atsf.vorion.org",
+    docsUrl: "https://atsf.vorion.org/docs",
+    repoUrl: "https://github.com/voriongit/vorion/tree/master/packages/atsf-core",
+    npmPackage: "@vorionsys/atsf-core",
+    organization: "vorion",
+    version: "0.9.0"
+  },
+  kaizen: {
+    id: "kaizen",
+    name: "Kaizen",
+    description: "Interactive AI Learning Experience - Educational platform for agentic AI",
+    category: "education" /* EDUCATION */,
+    status: "beta" /* BETA */,
+    url: "https://learn.vorion.org",
+    docsUrl: "https://learn.vorion.org/docs",
+    repoUrl: "https://github.com/voriongit/vorion/tree/master/kaizen",
+    organization: "vorion"
+  },
+  kaizenStudio: {
+    id: "kaizen-studio",
+    name: "Kaizen Studio",
+    description: "Interactive AI learning studio - hands-on agentic AI experiments",
+    category: "education" /* EDUCATION */,
+    status: "beta" /* BETA */,
+    url: "https://kaizen.vorion.org",
+    repoUrl: "https://github.com/voriongit/vorion/tree/master/kaizen",
+    organization: "vorion"
+  },
+  proofPlane: {
+    id: "proof-plane",
+    name: "Proof Plane",
+    description: "Cryptographic proof layer for agent attestations and verifiable execution",
+    category: "open_source" /* OPEN_SOURCE */,
+    status: "beta" /* BETA */,
+    url: "https://vorion.org/proof-plane",
+    repoUrl: "https://github.com/voriongit/vorion/tree/master/packages/proof-plane",
+    npmPackage: "@vorionsys/proof-plane",
+    organization: "vorion",
+    version: "0.5.0"
+  },
+  contracts: {
+    id: "contracts",
+    name: "Vorion Contracts",
+    description: "Smart contracts for on-chain agent governance and attestations",
+    category: "open_source" /* OPEN_SOURCE */,
+    status: "beta" /* BETA */,
+    url: "https://vorion.org/contracts",
+    repoUrl: "https://github.com/voriongit/vorion/tree/master/packages/contracts",
+    npmPackage: "@vorionsys/contracts",
+    organization: "vorion"
+  }
+};
+var AGENTANCHOR_PRODUCTS = {
+  cognigate: {
+    id: "cognigate",
+    name: "Cognigate",
+    description: "AI Governance API - Reference implementation of BASIS runtime",
+    category: "commercial" /* COMMERCIAL */,
+    status: "ga" /* GA */,
+    url: "https://cognigate.dev",
+    docsUrl: "https://cognigate.dev/docs",
+    npmPackage: "@vorionsys/cognigate",
+    organization: "agentanchor",
+    version: "1.0.0"
+  },
+  trust: {
+    id: "trust",
+    name: "Agent Anchor Trust",
+    description: "Trust verification and certification platform for AI agents",
+    category: "commercial" /* COMMERCIAL */,
+    status: "ga" /* GA */,
+    url: "https://trust.agentanchorai.com",
+    docsUrl: "https://trust.agentanchorai.com/docs",
+    organization: "agentanchor"
+  },
+  logic: {
+    id: "logic",
+    name: "Agent Anchor Logic",
+    description: "Policy engine and governance logic for enterprise AI",
+    category: "commercial" /* COMMERCIAL */,
+    status: "beta" /* BETA */,
+    url: "https://logic.agentanchorai.com",
+    docsUrl: "https://logic.agentanchorai.com/docs",
+    organization: "agentanchor"
+  },
+  platform: {
+    id: "platform",
+    name: "Agent Anchor Platform",
+    description: "Enterprise AI governance dashboard and management console",
+    category: "commercial" /* COMMERCIAL */,
+    status: "ga" /* GA */,
+    url: "https://agentanchorai.com",
+    docsUrl: "https://agentanchorai.com/docs",
+    organization: "agentanchor"
+  }
+};
+var ALL_PRODUCTS = {
+  vorion: VORION_PRODUCTS,
+  agentAnchor: AGENTANCHOR_PRODUCTS
+};
+function getProduct(productId) {
+  return VORION_PRODUCTS[productId] || AGENTANCHOR_PRODUCTS[productId];
+}
+function getProductsByCategory(category) {
+  const allProducts = [...Object.values(VORION_PRODUCTS), ...Object.values(AGENTANCHOR_PRODUCTS)];
+  return allProducts.filter((p) => p.category === category);
+}
+function getProductsByStatus(status) {
+  const allProducts = [...Object.values(VORION_PRODUCTS), ...Object.values(AGENTANCHOR_PRODUCTS)];
+  return allProducts.filter((p) => p.status === status);
+}
+function getProductsByOrganization(org) {
+  return org === "vorion" ? Object.values(VORION_PRODUCTS) : Object.values(AGENTANCHOR_PRODUCTS);
+}
+
+// src/rate-limits.ts
+var RATE_LIMITS = {
+  [0 /* T0_SANDBOX */]: {
+    requestsPerSecond: 1,
+    requestsPerMinute: 10,
+    requestsPerHour: 100,
+    requestsPerDay: 500,
+    burstLimit: 2,
+    maxPayloadBytes: 1024 * 10,
+    // 10 KB
+    maxResponseBytes: 1024 * 100,
+    // 100 KB
+    connectionTimeoutMs: 5e3,
+    requestTimeoutMs: 1e4
+  },
+  [1 /* T1_OBSERVED */]: {
+    requestsPerSecond: 2,
+    requestsPerMinute: 30,
+    requestsPerHour: 500,
+    requestsPerDay: 2e3,
+    burstLimit: 5,
+    maxPayloadBytes: 1024 * 50,
+    // 50 KB
+    maxResponseBytes: 1024 * 500,
+    // 500 KB
+    connectionTimeoutMs: 5e3,
+    requestTimeoutMs: 15e3
+  },
+  [2 /* T2_PROVISIONAL */]: {
+    requestsPerSecond: 5,
+    requestsPerMinute: 100,
+    requestsPerHour: 2e3,
+    requestsPerDay: 1e4,
+    burstLimit: 10,
+    maxPayloadBytes: 1024 * 100,
+    // 100 KB
+    maxResponseBytes: 1024 * 1024,
+    // 1 MB
+    connectionTimeoutMs: 1e4,
+    requestTimeoutMs: 3e4
+  },
+  [3 /* T3_MONITORED */]: {
+    requestsPerSecond: 10,
+    requestsPerMinute: 300,
+    requestsPerHour: 5e3,
+    requestsPerDay: 5e4,
+    burstLimit: 20,
+    maxPayloadBytes: 1024 * 500,
+    // 500 KB
+    maxResponseBytes: 1024 * 1024 * 5,
+    // 5 MB
+    connectionTimeoutMs: 1e4,
+    requestTimeoutMs: 6e4
+  },
+  [4 /* T4_STANDARD */]: {
+    requestsPerSecond: 20,
+    requestsPerMinute: 600,
+    requestsPerHour: 1e4,
+    requestsPerDay: 1e5,
+    burstLimit: 50,
+    maxPayloadBytes: 1024 * 1024,
+    // 1 MB
+    maxResponseBytes: 1024 * 1024 * 10,
+    // 10 MB
+    connectionTimeoutMs: 15e3,
+    requestTimeoutMs: 12e4
+  },
+  [5 /* T5_TRUSTED */]: {
+    requestsPerSecond: 50,
+    requestsPerMinute: 1500,
+    requestsPerHour: 3e4,
+    requestsPerDay: 3e5,
+    burstLimit: 100,
+    maxPayloadBytes: 1024 * 1024 * 5,
+    // 5 MB
+    maxResponseBytes: 1024 * 1024 * 50,
+    // 50 MB
+    connectionTimeoutMs: 3e4,
+    requestTimeoutMs: 3e5
+  },
+  [6 /* T6_CERTIFIED */]: {
+    requestsPerSecond: 100,
+    requestsPerMinute: 3e3,
+    requestsPerHour: 1e5,
+    requestsPerDay: 1e6,
+    burstLimit: 200,
+    maxPayloadBytes: 1024 * 1024 * 10,
+    // 10 MB
+    maxResponseBytes: 1024 * 1024 * 100,
+    // 100 MB
+    connectionTimeoutMs: 6e4,
+    requestTimeoutMs: 6e5
+  },
+  [7 /* T7_AUTONOMOUS */]: {
+    requestsPerSecond: 500,
+    requestsPerMinute: 1e4,
+    requestsPerHour: 5e5,
+    requestsPerDay: 5e6,
+    burstLimit: 500,
+    maxPayloadBytes: 1024 * 1024 * 50,
+    // 50 MB
+    maxResponseBytes: 1024 * 1024 * 500,
+    // 500 MB
+    connectionTimeoutMs: 12e4,
+    requestTimeoutMs: 12e5
+  }
+};
+function getRateLimits(tier) {
+  return RATE_LIMITS[tier];
+}
+function getMinTierForLimits(config) {
+  const tiers = Object.values(TrustTier).filter((t) => typeof t === "number");
+  for (const tier of tiers) {
+    const limits = RATE_LIMITS[tier];
+    if ((config.requestsPerSecond === void 0 || limits.requestsPerSecond >= config.requestsPerSecond) && (config.requestsPerMinute === void 0 || limits.requestsPerMinute >= config.requestsPerMinute) && (config.requestsPerHour === void 0 || limits.requestsPerHour >= config.requestsPerHour) && (config.requestsPerDay === void 0 || limits.requestsPerDay >= config.requestsPerDay)) {
+      return tier;
+    }
+  }
+  return 7 /* T7_AUTONOMOUS */;
+}
+function wouldExceedLimit(tier, window, currentCount) {
+  const limits = RATE_LIMITS[tier];
+  switch (window) {
+    case "second":
+      return currentCount >= limits.requestsPerSecond;
+    case "minute":
+      return currentCount >= limits.requestsPerMinute;
+    case "hour":
+      return currentCount >= limits.requestsPerHour;
+    case "day":
+      return currentCount >= limits.requestsPerDay;
+  }
+}
+function formatRateLimit(tier) {
+  const limits = RATE_LIMITS[tier];
+  return `${limits.requestsPerSecond}/s, ${limits.requestsPerMinute}/min, ${limits.requestsPerHour}/hr`;
+}
+var TIER_QUOTAS = {
+  [0 /* T0_SANDBOX */]: {
+    monthlyApiCalls: 1e3,
+    monthlyComputeUnits: 100,
+    monthlyStorageBytes: 1024 * 1024 * 10,
+    // 10 MB
+    monthlyBandwidthBytes: 1024 * 1024 * 100,
+    // 100 MB
+    maxAgents: 1,
+    maxWebhooks: 1,
+    maxTeamMembers: 1
+  },
+  [1 /* T1_OBSERVED */]: {
+    monthlyApiCalls: 1e4,
+    monthlyComputeUnits: 1e3,
+    monthlyStorageBytes: 1024 * 1024 * 100,
+    // 100 MB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024,
+    // 1 GB
+    maxAgents: 5,
+    maxWebhooks: 5,
+    maxTeamMembers: 3
+  },
+  [2 /* T2_PROVISIONAL */]: {
+    monthlyApiCalls: 5e4,
+    monthlyComputeUnits: 5e3,
+    monthlyStorageBytes: 1024 * 1024 * 500,
+    // 500 MB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 5,
+    // 5 GB
+    maxAgents: 10,
+    maxWebhooks: 10,
+    maxTeamMembers: 5
+  },
+  [3 /* T3_MONITORED */]: {
+    monthlyApiCalls: 25e4,
+    monthlyComputeUnits: 25e3,
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 2,
+    // 2 GB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 25,
+    // 25 GB
+    maxAgents: 50,
+    maxWebhooks: 25,
+    maxTeamMembers: 10
+  },
+  [4 /* T4_STANDARD */]: {
+    monthlyApiCalls: 1e6,
+    monthlyComputeUnits: 1e5,
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 10,
+    // 10 GB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 100,
+    // 100 GB
+    maxAgents: 200,
+    maxWebhooks: 50,
+    maxTeamMembers: 25
+  },
+  [5 /* T5_TRUSTED */]: {
+    monthlyApiCalls: 5e6,
+    monthlyComputeUnits: 5e5,
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 50,
+    // 50 GB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 500,
+    // 500 GB
+    maxAgents: 1e3,
+    maxWebhooks: 100,
+    maxTeamMembers: 50
+  },
+  [6 /* T6_CERTIFIED */]: {
+    monthlyApiCalls: 25e6,
+    monthlyComputeUnits: 25e5,
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 250,
+    // 250 GB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 2500,
+    // 2.5 TB
+    maxAgents: 5e3,
+    maxWebhooks: 250,
+    maxTeamMembers: 100
+  },
+  [7 /* T7_AUTONOMOUS */]: {
+    monthlyApiCalls: -1,
+    // Unlimited
+    monthlyComputeUnits: -1,
+    // Unlimited
+    monthlyStorageBytes: 1024 * 1024 * 1024 * 1024,
+    // 1 TB
+    monthlyBandwidthBytes: 1024 * 1024 * 1024 * 1e4,
+    // 10 TB
+    maxAgents: -1,
+    // Unlimited
+    maxWebhooks: -1,
+    // Unlimited
+    maxTeamMembers: -1
+    // Unlimited
+  }
+};
+function getQuota(tier) {
+  return TIER_QUOTAS[tier];
+}
+function isUnlimited(value) {
+  return value === -1;
+}
+
+// src/error-codes.ts
+var ErrorCategory = /* @__PURE__ */ ((ErrorCategory2) => {
+  ErrorCategory2["AUTH"] = "auth";
+  ErrorCategory2["VALIDATION"] = "validation";
+  ErrorCategory2["RATE_LIMIT"] = "rate_limit";
+  ErrorCategory2["NOT_FOUND"] = "not_found";
+  ErrorCategory2["TRUST"] = "trust";
+  ErrorCategory2["SERVER"] = "server";
+  ErrorCategory2["EXTERNAL"] = "external";
+  ErrorCategory2["CONFIG"] = "config";
+  return ErrorCategory2;
+})(ErrorCategory || {});
+var AUTH_ERRORS = {
+  MISSING_API_KEY: {
+    code: "E1001",
+    httpStatus: 401,
+    category: "auth" /* AUTH */,
+    message: "API key is missing. Include it in the Authorization header.",
+    retryable: false,
+    docsUrl: "https://cognigate.dev/docs/authentication"
+  },
+  INVALID_API_KEY: {
+    code: "E1002",
+    httpStatus: 401,
+    category: "auth" /* AUTH */,
+    message: "API key is invalid or has been revoked.",
+    retryable: false,
+    docsUrl: "https://cognigate.dev/docs/authentication"
+  },
+  EXPIRED_API_KEY: {
+    code: "E1003",
+    httpStatus: 401,
+    category: "auth" /* AUTH */,
+    message: "API key has expired. Generate a new key.",
+    retryable: false,
+    docsUrl: "https://cognigate.dev/docs/authentication"
+  },
+  INSUFFICIENT_PERMISSIONS: {
+    code: "E1004",
+    httpStatus: 403,
+    category: "auth" /* AUTH */,
+    message: "Insufficient permissions for this operation.",
+    retryable: false
+  },
+  AGENT_NOT_AUTHORIZED: {
+    code: "E1005",
+    httpStatus: 403,
+    category: "auth" /* AUTH */,
+    message: "Agent is not authorized for this action.",
+    retryable: false
+  },
+  TOKEN_EXPIRED: {
+    code: "E1006",
+    httpStatus: 401,
+    category: "auth" /* AUTH */,
+    message: "Authentication token has expired.",
+    retryable: false
+  },
+  MFA_REQUIRED: {
+    code: "E1007",
+    httpStatus: 403,
+    category: "auth" /* AUTH */,
+    message: "Multi-factor authentication is required for this operation.",
+    retryable: false
+  }
+};
+var VALIDATION_ERRORS = {
+  INVALID_REQUEST: {
+    code: "E2001",
+    httpStatus: 400,
+    category: "validation" /* VALIDATION */,
+    message: "Request body is invalid or malformed.",
+    retryable: false
+  },
+  MISSING_REQUIRED_FIELD: {
+    code: "E2002",
+    httpStatus: 400,
+    category: "validation" /* VALIDATION */,
+    message: "Required field is missing: {field}",
+    retryable: false
+  },
+  INVALID_FIELD_TYPE: {
+    code: "E2003",
+    httpStatus: 400,
+    category: "validation" /* VALIDATION */,
+    message: "Field {field} has invalid type. Expected {expected}.",
+    retryable: false
+  },
+  INVALID_FIELD_VALUE: {
+    code: "E2004",
+    httpStatus: 400,
+    category: "validation" /* VALIDATION */,
+    message: "Field {field} has invalid value.",
+    retryable: false
+  },
+  PAYLOAD_TOO_LARGE: {
+    code: "E2005",
+    httpStatus: 413,
+    category: "validation" /* VALIDATION */,
+    message: "Request payload exceeds maximum size of {maxSize}.",
+    retryable: false
+  },
+  INVALID_JSON: {
+    code: "E2006",
+    httpStatus: 400,
+    category: "validation" /* VALIDATION */,
+    message: "Request body is not valid JSON.",
+    retryable: false
+  },
+  INVALID_CAR_ID: {
+    code: "E2007",
+    httpStatus: 400,
+    category: "validation" /* VALIDATION */,
+    message: "Invalid CAR ID format. Expected: car:domain/category/name:version",
+    retryable: false,
+    docsUrl: "https://carid.vorion.org/format"
+  },
+  INVALID_TRUST_SCORE: {
+    code: "E2008",
+    httpStatus: 400,
+    category: "validation" /* VALIDATION */,
+    message: "Trust score must be between 0 and 1000.",
+    retryable: false
+  }
+};
+var RATE_LIMIT_ERRORS = {
+  RATE_LIMIT_EXCEEDED: {
+    code: "E3001",
+    httpStatus: 429,
+    category: "rate_limit" /* RATE_LIMIT */,
+    message: "Rate limit exceeded. Retry after {retryAfter} seconds.",
+    retryable: true
+  },
+  QUOTA_EXCEEDED: {
+    code: "E3002",
+    httpStatus: 429,
+    category: "rate_limit" /* RATE_LIMIT */,
+    message: "Monthly quota exceeded. Upgrade your tier or wait for reset.",
+    retryable: false
+  },
+  CONCURRENT_LIMIT: {
+    code: "E3003",
+    httpStatus: 429,
+    category: "rate_limit" /* RATE_LIMIT */,
+    message: "Too many concurrent requests. Max burst: {burstLimit}.",
+    retryable: true
+  },
+  DAILY_LIMIT_EXCEEDED: {
+    code: "E3004",
+    httpStatus: 429,
+    category: "rate_limit" /* RATE_LIMIT */,
+    message: "Daily request limit exceeded. Resets at midnight UTC.",
+    retryable: true
+  }
+};
+var NOT_FOUND_ERRORS = {
+  RESOURCE_NOT_FOUND: {
+    code: "E4001",
+    httpStatus: 404,
+    category: "not_found" /* NOT_FOUND */,
+    message: "Resource not found: {resourceType}/{resourceId}",
+    retryable: false
+  },
+  AGENT_NOT_FOUND: {
+    code: "E4002",
+    httpStatus: 404,
+    category: "not_found" /* NOT_FOUND */,
+    message: "Agent not found: {agentId}",
+    retryable: false
+  },
+  PROOF_NOT_FOUND: {
+    code: "E4003",
+    httpStatus: 404,
+    category: "not_found" /* NOT_FOUND */,
+    message: "Proof not found: {proofId}",
+    retryable: false
+  },
+  ENDPOINT_NOT_FOUND: {
+    code: "E4004",
+    httpStatus: 404,
+    category: "not_found" /* NOT_FOUND */,
+    message: "API endpoint not found.",
+    retryable: false
+  },
+  ATTESTATION_NOT_FOUND: {
+    code: "E4005",
+    httpStatus: 404,
+    category: "not_found" /* NOT_FOUND */,
+    message: "Attestation not found: {attestationId}",
+    retryable: false
+  }
+};
+var TRUST_ERRORS = {
+  TRUST_TIER_INSUFFICIENT: {
+    code: "E5001",
+    httpStatus: 403,
+    category: "trust" /* TRUST */,
+    message: "Trust tier {currentTier} insufficient. Required: {requiredTier}.",
+    retryable: false,
+    docsUrl: "https://basis.vorion.org/tiers"
+  },
+  CAPABILITY_NOT_AVAILABLE: {
+    code: "E5002",
+    httpStatus: 403,
+    category: "trust" /* TRUST */,
+    message: "Capability {capability} not available at tier {tier}.",
+    retryable: false,
+    docsUrl: "https://cognigate.dev/docs/capabilities"
+  },
+  GOVERNANCE_DENIED: {
+    code: "E5003",
+    httpStatus: 403,
+    category: "trust" /* TRUST */,
+    message: "Action denied by governance policy: {reason}.",
+    retryable: false
+  },
+  AGENT_SUSPENDED: {
+    code: "E5004",
+    httpStatus: 403,
+    category: "trust" /* TRUST */,
+    message: "Agent is suspended. Contact support for reinstatement.",
+    retryable: false
+  },
+  PROOF_VERIFICATION_FAILED: {
+    code: "E5005",
+    httpStatus: 400,
+    category: "trust" /* TRUST */,
+    message: "Proof verification failed: {reason}.",
+    retryable: false
+  },
+  ATTESTATION_INVALID: {
+    code: "E5006",
+    httpStatus: 400,
+    category: "trust" /* TRUST */,
+    message: "Attestation is invalid or has expired.",
+    retryable: false
+  },
+  ESCALATION_REQUIRED: {
+    code: "E5007",
+    httpStatus: 403,
+    category: "trust" /* TRUST */,
+    message: "Action requires human approval. Escalation ID: {escalationId}.",
+    retryable: false
+  }
+};
+var SERVER_ERRORS = {
+  INTERNAL_ERROR: {
+    code: "E6001",
+    httpStatus: 500,
+    category: "server" /* SERVER */,
+    message: "An internal error occurred. Please try again later.",
+    retryable: true
+  },
+  SERVICE_UNAVAILABLE: {
+    code: "E6002",
+    httpStatus: 503,
+    category: "server" /* SERVER */,
+    message: "Service is temporarily unavailable. Please try again later.",
+    retryable: true
+  },
+  DATABASE_ERROR: {
+    code: "E6003",
+    httpStatus: 500,
+    category: "server" /* SERVER */,
+    message: "Database operation failed. Please try again later.",
+    retryable: true
+  },
+  MAINTENANCE_MODE: {
+    code: "E6004",
+    httpStatus: 503,
+    category: "server" /* SERVER */,
+    message: "Service is under maintenance. Expected completion: {eta}.",
+    retryable: true
+  }
+};
+var EXTERNAL_ERRORS = {
+  BLOCKCHAIN_ERROR: {
+    code: "E7001",
+    httpStatus: 502,
+    category: "external" /* EXTERNAL */,
+    message: "Blockchain network error. Please try again later.",
+    retryable: true
+  },
+  UPSTREAM_TIMEOUT: {
+    code: "E7002",
+    httpStatus: 504,
+    category: "external" /* EXTERNAL */,
+    message: "Upstream service timed out.",
+    retryable: true
+  },
+  EXTERNAL_SERVICE_ERROR: {
+    code: "E7003",
+    httpStatus: 502,
+    category: "external" /* EXTERNAL */,
+    message: "External service error: {service}.",
+    retryable: true
+  }
+};
+var ERROR_CODES = {
+  ...AUTH_ERRORS,
+  ...VALIDATION_ERRORS,
+  ...RATE_LIMIT_ERRORS,
+  ...NOT_FOUND_ERRORS,
+  ...TRUST_ERRORS,
+  ...SERVER_ERRORS,
+  ...EXTERNAL_ERRORS
+};
+function getErrorByCode(code) {
+  return Object.values(ERROR_CODES).find((e) => e.code === code);
+}
+function getErrorsByCategory(category) {
+  return Object.values(ERROR_CODES).filter((e) => e.category === category);
+}
+function getRetryableErrors() {
+  return Object.values(ERROR_CODES).filter((e) => e.retryable);
+}
+function formatErrorMessage(error, params) {
+  let message = error.message;
+  for (const [key, value] of Object.entries(params)) {
+    message = message.replace(`{${key}}`, String(value));
+  }
+  return message;
+}
+function createErrorResponse(error, params, requestId) {
+  return {
+    error: {
+      code: error.code,
+      message: params ? formatErrorMessage(error, params) : error.message,
+      category: error.category,
+      retryable: error.retryable,
+      ...error.docsUrl && { docsUrl: error.docsUrl },
+      ...requestId && { requestId }
+    },
+    status: error.httpStatus
+  };
+}
+
+// src/api-versions.ts
+var VersionStatus = /* @__PURE__ */ ((VersionStatus2) => {
+  VersionStatus2["DEVELOPMENT"] = "development";
+  VersionStatus2["PREVIEW"] = "preview";
+  VersionStatus2["STABLE"] = "stable";
+  VersionStatus2["DEPRECATED"] = "deprecated";
+  VersionStatus2["RETIRED"] = "retired";
+  return VersionStatus2;
+})(VersionStatus || {});
+var COGNIGATE_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "stable" /* STABLE */,
+    changelogUrl: "https://cognigate.dev/changelog/v1"
+  }
+};
+var COGNIGATE_CURRENT_VERSION = "v1";
+var COGNIGATE_DEFAULT_VERSION = "v1";
+var TRUST_API_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "stable" /* STABLE */,
+    changelogUrl: "https://trust.agentanchorai.com/changelog/v1"
+  }
+};
+var TRUST_CURRENT_VERSION = "v1";
+var LOGIC_API_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "preview" /* PREVIEW */,
+    changelogUrl: "https://logic.agentanchorai.com/changelog/v1"
+  }
+};
+var LOGIC_CURRENT_VERSION = "v1";
+var BASIS_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "stable" /* STABLE */,
+    changelogUrl: "https://basis.vorion.org/changelog"
+  }
+};
+var BASIS_CURRENT_VERSION = "v1";
+var BASIS_SPEC_VERSION = "1.0.0";
+var CAR_SPEC_VERSIONS = {
+  v1: {
+    version: "v1",
+    fullVersion: "1.0.0",
+    releaseDate: "2026-02-01",
+    status: "stable" /* STABLE */,
+    changelogUrl: "https://carid.vorion.org/changelog"
+  }
+};
+var CAR_SPEC_CURRENT_VERSION = "v1";
+var API_VERSIONS = {
+  cognigate: COGNIGATE_VERSIONS,
+  trust: TRUST_API_VERSIONS,
+  logic: LOGIC_API_VERSIONS,
+  basis: BASIS_VERSIONS,
+  carSpec: CAR_SPEC_VERSIONS
+};
+function getCurrentVersion(service) {
+  switch (service) {
+    case "cognigate":
+      return COGNIGATE_CURRENT_VERSION;
+    case "trust":
+      return TRUST_CURRENT_VERSION;
+    case "logic":
+      return LOGIC_CURRENT_VERSION;
+    case "basis":
+      return BASIS_CURRENT_VERSION;
+    case "carSpec":
+      return CAR_SPEC_CURRENT_VERSION;
+  }
+}
+function getVersionDefinition(service, version) {
+  return API_VERSIONS[service][version];
+}
+function isVersionSupported(service, version) {
+  const def = getVersionDefinition(service, version);
+  if (!def) return false;
+  return def.status !== "retired" /* RETIRED */;
+}
+function isVersionDeprecated(service, version) {
+  const def = getVersionDefinition(service, version);
+  if (!def) return false;
+  return def.status === "deprecated" /* DEPRECATED */;
+}
+function getStableVersions(service) {
+  return Object.values(API_VERSIONS[service]).filter(
+    (v) => v.status === "stable" /* STABLE */
+  );
+}
+function buildApiUrl(baseUrl, version, path) {
+  const cleanBase = baseUrl.replace(/\/$/, "");
+  const cleanPath = path.replace(/^\//, "");
+  return `${cleanBase}/${version}/${cleanPath}`;
+}
+var VERSION_HEADERS = {
+  /** Header to request specific API version */
+  REQUEST_VERSION: "X-API-Version",
+  /** Header indicating actual API version used */
+  RESPONSE_VERSION: "X-API-Version",
+  /** Header warning about deprecation */
+  DEPRECATION_WARNING: "X-Deprecation-Warning",
+  /** Header with sunset date */
+  SUNSET: "Sunset"
+};
+
+// src/themes.ts
+var ACTIVE_THEME = "midnight_cyan";
+var THEMES = {
+  // ═══════════════════════════════════════════════════════════════
+  // OPTION 1: MIDNIGHT CYAN — Current look, standardized
+  // ═══════════════════════════════════════════════════════════════
+  midnight_cyan: {
+    name: "Midnight Cyan",
+    description: "Developer-native. Terminal-adjacent. The current look, unified.",
+    bgPrimary: "#0a0a0f",
+    bgSurface: "#111118",
+    bgInput: "#0d0d14",
+    bgNav: "#111118",
+    bgCode: "#0d0d14",
+    accent: "#06b6d4",
+    accentHover: "#22d3ee",
+    accentMuted: "rgba(6, 182, 212, 0.1)",
+    accentSubtle: "rgba(6, 182, 212, 0.03)",
+    textPrimary: "#e0e0e6",
+    textHeading: "#ffffff",
+    textSecondary: "#888888",
+    textTertiary: "#666666",
+    border: "#1e1e2e",
+    borderInput: "#2a2a3a",
+    borderHover: "rgba(6, 182, 212, 0.4)",
+    borderDivider: "rgba(255, 255, 255, 0.05)",
+    gradientFrom: "#06b6d4",
+    gradientTo: "#2dd4bf",
+    scrollTrack: "#0a0a0f",
+    scrollThumb: "#333340",
+    scrollThumbHover: "#06b6d4",
+    selectionBg: "rgba(6, 182, 212, 0.3)",
+    success: "#22c55e",
+    error: "#ef4444",
+    warning: "#f97316",
+    info: "#3b82f6",
+    layerBasis: "#fbbf24",
+    layerIntent: "#60a5fa",
+    layerEnforce: "#818cf8",
+    layerProof: "#34d399",
+    fontFamily: "'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    fontImport: "Inter",
+    cardBlur: false,
+    buttonText: "#000000"
+  },
+  // ═══════════════════════════════════════════════════════════════
+  // OPTION 2: INDIGO AUTHORITY — Governance-forward, institutional
+  // ═══════════════════════════════════════════════════════════════
+  indigo_authority: {
+    name: "Indigo Authority",
+    description: "Institutional. Authoritative. Governance-forward.",
+    bgPrimary: "#07070d",
+    bgSurface: "#12121f",
+    bgInput: "#0c0c18",
+    bgNav: "#12121f",
+    bgCode: "#0c0c18",
+    accent: "#818cf8",
+    accentHover: "#a5b4fc",
+    accentMuted: "rgba(129, 140, 248, 0.1)",
+    accentSubtle: "rgba(129, 140, 248, 0.03)",
+    textPrimary: "#dcdce6",
+    textHeading: "#ffffff",
+    textSecondary: "#8888a0",
+    textTertiary: "#666680",
+    border: "#1e1e30",
+    borderInput: "#2a2a40",
+    borderHover: "rgba(129, 140, 248, 0.4)",
+    borderDivider: "rgba(255, 255, 255, 0.05)",
+    gradientFrom: "#818cf8",
+    gradientTo: "#c084fc",
+    scrollTrack: "#07070d",
+    scrollThumb: "#2a2a40",
+    scrollThumbHover: "#818cf8",
+    selectionBg: "rgba(129, 140, 248, 0.3)",
+    success: "#22c55e",
+    error: "#ef4444",
+    warning: "#f97316",
+    info: "#3b82f6",
+    layerBasis: "#fbbf24",
+    layerIntent: "#60a5fa",
+    layerEnforce: "#818cf8",
+    layerProof: "#34d399",
+    fontFamily: "'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    fontImport: "Inter",
+    cardBlur: false,
+    buttonText: "#000000"
+  },
+  // ═══════════════════════════════════════════════════════════════
+  // OPTION 3: OBSIDIAN AMBER — Warm, premium, "gold standard"
+  // ═══════════════════════════════════════════════════════════════
+  obsidian_amber: {
+    name: "Obsidian Amber",
+    description: "Premium. Warm. The gold standard of AI governance.",
+    bgPrimary: "#0a0a08",
+    bgSurface: "#141410",
+    bgInput: "#0d0d0a",
+    bgNav: "#141410",
+    bgCode: "#0d0d0a",
+    accent: "#f59e0b",
+    accentHover: "#fbbf24",
+    accentMuted: "rgba(245, 158, 11, 0.1)",
+    accentSubtle: "rgba(245, 158, 11, 0.03)",
+    textPrimary: "#e6e0d6",
+    textHeading: "#ffffff",
+    textSecondary: "#8a8478",
+    textTertiary: "#666058",
+    border: "#2a2820",
+    borderInput: "#3a3830",
+    borderHover: "rgba(245, 158, 11, 0.4)",
+    borderDivider: "rgba(255, 255, 255, 0.05)",
+    gradientFrom: "#f59e0b",
+    gradientTo: "#f97316",
+    scrollTrack: "#0a0a08",
+    scrollThumb: "#3a3830",
+    scrollThumbHover: "#f59e0b",
+    selectionBg: "rgba(245, 158, 11, 0.3)",
+    success: "#22c55e",
+    error: "#ef4444",
+    warning: "#f97316",
+    info: "#3b82f6",
+    layerBasis: "#fbbf24",
+    layerIntent: "#60a5fa",
+    layerEnforce: "#818cf8",
+    layerProof: "#34d399",
+    fontFamily: "'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    fontImport: "Inter",
+    cardBlur: false,
+    buttonText: "#000000"
+  },
+  // ═══════════════════════════════════════════════════════════════
+  // OPTION 4: ARCTIC GLASS — Modern SaaS, frosted glass
+  // ═══════════════════════════════════════════════════════════════
+  arctic_glass: {
+    name: "Arctic Glass",
+    description: "Modern SaaS. Clean. Frosted glass depth.",
+    bgPrimary: "#0c0c14",
+    bgSurface: "rgba(255, 255, 255, 0.04)",
+    bgInput: "rgba(0, 0, 0, 0.3)",
+    bgNav: "rgba(12, 12, 20, 0.8)",
+    bgCode: "rgba(0, 0, 0, 0.3)",
+    accent: "#38bdf8",
+    accentHover: "#7dd3fc",
+    accentMuted: "rgba(56, 189, 248, 0.1)",
+    accentSubtle: "rgba(56, 189, 248, 0.03)",
+    textPrimary: "#e2e8f0",
+    textHeading: "#f8fafc",
+    textSecondary: "#94a3b8",
+    textTertiary: "#64748b",
+    border: "rgba(255, 255, 255, 0.08)",
+    borderInput: "rgba(255, 255, 255, 0.12)",
+    borderHover: "rgba(56, 189, 248, 0.4)",
+    borderDivider: "rgba(255, 255, 255, 0.05)",
+    gradientFrom: "#38bdf8",
+    gradientTo: "#06b6d4",
+    scrollTrack: "#0c0c14",
+    scrollThumb: "rgba(255, 255, 255, 0.1)",
+    scrollThumbHover: "#38bdf8",
+    selectionBg: "rgba(56, 189, 248, 0.3)",
+    success: "#22c55e",
+    error: "#ef4444",
+    warning: "#f97316",
+    info: "#3b82f6",
+    layerBasis: "#fbbf24",
+    layerIntent: "#60a5fa",
+    layerEnforce: "#818cf8",
+    layerProof: "#34d399",
+    fontFamily: "'Geist', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    fontImport: "Geist",
+    cardBlur: true,
+    buttonText: "#000000"
+  }
+};
+function getActiveTheme() {
+  return THEMES[ACTIVE_THEME];
+}
+function getAllThemeIds() {
+  return Object.keys(THEMES);
+}
+function themeToCssVars(themeId = ACTIVE_THEME) {
+  const t = THEMES[themeId];
+  return `
+    --bg-primary: ${t.bgPrimary};
+    --bg-surface: ${t.bgSurface};
+    --bg-input: ${t.bgInput};
+    --bg-nav: ${t.bgNav};
+    --bg-code: ${t.bgCode};
+    --accent: ${t.accent};
+    --accent-hover: ${t.accentHover};
+    --accent-muted: ${t.accentMuted};
+    --accent-subtle: ${t.accentSubtle};
+    --text-primary: ${t.textPrimary};
+    --text-heading: ${t.textHeading};
+    --text-secondary: ${t.textSecondary};
+    --text-tertiary: ${t.textTertiary};
+    --border: ${t.border};
+    --border-input: ${t.borderInput};
+    --border-hover: ${t.borderHover};
+    --border-divider: ${t.borderDivider};
+    --gradient-from: ${t.gradientFrom};
+    --gradient-to: ${t.gradientTo};
+    --scroll-track: ${t.scrollTrack};
+    --scroll-thumb: ${t.scrollThumb};
+    --scroll-thumb-hover: ${t.scrollThumbHover};
+    --selection-bg: ${t.selectionBg};
+    --success: ${t.success};
+    --error: ${t.error};
+    --warning: ${t.warning};
+    --info: ${t.info};
+    --layer-basis: ${t.layerBasis};
+    --layer-intent: ${t.layerIntent};
+    --layer-enforce: ${t.layerEnforce};
+    --layer-proof: ${t.layerProof};
+    --btn-text: ${t.buttonText};
+  `.trim();
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+var LAST_UPDATED = "2026-02-04";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTIVE_THEME,
+  AGENTANCHOR_DOMAINS,
+  AGENTANCHOR_EMAILS,
+  AGENTANCHOR_PRODUCTS,
+  ALL_DOMAINS,
+  ALL_PRODUCTS,
+  ALL_TIERS,
+  API_ENDPOINTS,
+  API_VERSIONS,
+  AUTH_ERRORS,
+  BASIS_CURRENT_VERSION,
+  BASIS_SPEC_VERSION,
+  BASIS_VERSIONS,
+  CAPABILITIES,
+  CAR_SPEC_CURRENT_VERSION,
+  CAR_SPEC_VERSIONS,
+  COGNIGATE_CURRENT_VERSION,
+  COGNIGATE_DEFAULT_VERSION,
+  COGNIGATE_DOMAINS,
+  COGNIGATE_VERSIONS,
+  CapabilityCategory,
+  DOMAIN_ALIASES,
+  ERROR_CODES,
+  EXTERNAL_ERRORS,
+  ErrorCategory,
+  GITHUB,
+  LAST_UPDATED,
+  LOGIC_API_VERSIONS,
+  LOGIC_CURRENT_VERSION,
+  NOT_FOUND_ERRORS,
+  NPM_PACKAGES,
+  ProductCategory,
+  ProductStatus,
+  RATE_LIMITS,
+  RATE_LIMIT_ERRORS,
+  SERVER_ERRORS,
+  THEMES,
+  TIER_QUOTAS,
+  TIER_THRESHOLDS,
+  TRUST_API_VERSIONS,
+  TRUST_CURRENT_VERSION,
+  TRUST_ERRORS,
+  TrustTier,
+  VALIDATION_ERRORS,
+  VERSION,
+  VERSION_HEADERS,
+  VORION_DOMAINS,
+  VORION_EMAILS,
+  VORION_PRODUCTS,
+  VersionStatus,
+  buildApiUrl,
+  createErrorResponse,
+  formatErrorMessage,
+  formatRateLimit,
+  getActiveTheme,
+  getAllCapabilityCodes,
+  getAllThemeIds,
+  getCapabilitiesByCategory,
+  getCapabilitiesForTier,
+  getCapability,
+  getCapabilityMinTier,
+  getCurrentVersion,
+  getErrorByCode,
+  getErrorsByCategory,
+  getMinTierForLimits,
+  getProduct,
+  getProductsByCategory,
+  getProductsByOrganization,
+  getProductsByStatus,
+  getQuota,
+  getRateLimits,
+  getRetryableErrors,
+  getStableVersions,
+  getTierCode,
+  getTierColor,
+  getTierMaxScore,
+  getTierMinScore,
+  getTierName,
+  getTierThreshold,
+  getVersionDefinition,
+  isCapabilityAvailable,
+  isUnlimited,
+  isVersionDeprecated,
+  isVersionSupported,
+  meetsTierRequirement,
+  parseTier,
+  scoreToTier,
+  themeToCssVars,
+  wouldExceedLimit
+});