@vorionsys/shared-constants 1.0.0

package/dist/chunk-F2R6HBF5.js

@@ -0,0 +1,253 @@
+import {
+  TrustTier
+} from "./chunk-PHL3CB53.js";
+
+// 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;
+}
+
+export {
+  RATE_LIMITS,
+  getRateLimits,
+  getMinTierForLimits,
+  wouldExceedLimit,
+  formatRateLimit,
+  TIER_QUOTAS,
+  getQuota,
+  isUnlimited
+};

package/dist/chunk-IKLCEYZT.js

@@ -0,0 +1,142 @@
+// 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
+};
+
+export {
+  VORION_DOMAINS,
+  DOMAIN_ALIASES,
+  AGENTANCHOR_DOMAINS,
+  COGNIGATE_DOMAINS,
+  API_ENDPOINTS,
+  VORION_EMAILS,
+  AGENTANCHOR_EMAILS,
+  GITHUB,
+  NPM_PACKAGES,
+  ALL_DOMAINS
+};

package/dist/chunk-JZJPDGG7.js

@@ -0,0 +1,215 @@
+// 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);
+}
+
+export {
+  CapabilityCategory,
+  CAPABILITIES,
+  getCapabilitiesForTier,
+  getCapability,
+  isCapabilityAvailable,
+  getCapabilityMinTier,
+  getCapabilitiesByCategory,
+  getAllCapabilityCodes
+};