@peac/policy-kit 0.10.9 → 0.10.10

package/dist/index.mjs

@@ -0,0 +1,1270 @@
+import { z, ZodError } from 'zod';
+import { SubjectTypeSchema, ControlDecisionSchema, ControlLicensingModeSchema, ControlPurposeSchema } from '@peac/schema';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+
+// src/types.ts
+var POLICY_VERSION = "peac-policy/0.1";
+var SubjectMatcherSchema = z.object({
+  /** Match by subject type(s) - single type or array */
+  type: z.union([SubjectTypeSchema, z.array(SubjectTypeSchema)]).optional(),
+  /** Match by label(s) - subject must have ALL specified labels */
+  labels: z.array(z.string().min(1)).optional(),
+  /** Match by subject ID pattern (exact match or prefix with *) */
+  id: z.string().min(1).optional()
+}).strict();
+var PolicyRuleSchema = z.object({
+  /** Rule name (for debugging/auditing) */
+  name: z.string().min(1),
+  /** Subject matcher (omit for any subject) */
+  subject: SubjectMatcherSchema.optional(),
+  /** Purpose(s) this rule applies to - single purpose or array */
+  purpose: z.union([ControlPurposeSchema, z.array(ControlPurposeSchema)]).optional(),
+  /** Licensing mode(s) this rule applies to */
+  licensing_mode: z.union([ControlLicensingModeSchema, z.array(ControlLicensingModeSchema)]).optional(),
+  /** Decision if rule matches */
+  decision: ControlDecisionSchema,
+  /** Reason for decision (for audit trail) */
+  reason: z.string().optional()
+}).strict();
+var PolicyDefaultsSchema = z.object({
+  /** Default decision when no rule matches */
+  decision: ControlDecisionSchema,
+  /** Default reason for audit trail */
+  reason: z.string().optional()
+}).strict();
+var PolicyDocumentSchema = z.object({
+  /** Policy format version */
+  version: z.literal(POLICY_VERSION),
+  /** Policy name/description (optional) */
+  name: z.string().optional(),
+  /** Default decision (required) */
+  defaults: PolicyDefaultsSchema,
+  /** Rules evaluated in order (first match wins) */
+  rules: z.array(PolicyRuleSchema)
+}).strict();
+var RateLimitConfigSchema = z.object({
+  /** Maximum requests allowed in the window */
+  limit: z.number().int().positive(),
+  /** Window size in seconds (e.g., 3600 for 1 hour) */
+  window_seconds: z.number().int().positive(),
+  /** Optional burst allowance above the limit */
+  burst: z.number().int().nonnegative().optional(),
+  /** How to partition rate limits (default: per-agent) */
+  partition: z.union([z.enum(["agent", "ip", "account"]), z.string().min(1)]).optional()
+}).strict();
+function parseRateLimit(input) {
+  const match = input.match(/^(\d+)\/(second|minute|hour|day)$/i);
+  if (!match) {
+    throw new Error(
+      `Invalid rate limit format: "${input}". Expected format: "100/hour", "1000/day", etc.`
+    );
+  }
+  const limit = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  const windowMap = {
+    second: 1,
+    minute: 60,
+    hour: 3600,
+    day: 86400
+  };
+  return {
+    limit,
+    window_seconds: windowMap[unit]
+  };
+}
+function formatRateLimit(config) {
+  const { limit, window_seconds } = config;
+  if (window_seconds === 1) return `${limit}/second`;
+  if (window_seconds === 60) return `${limit}/minute`;
+  if (window_seconds === 3600) return `${limit}/hour`;
+  if (window_seconds === 86400) return `${limit}/day`;
+  return `${limit}/${window_seconds}s`;
+}
+var DecisionRequirementsSchema = z.object({
+  /** Require a valid PEAC receipt */
+  receipt: z.boolean().optional()
+  // Extensible: add more requirements as needed
+  // attestation?: boolean;
+  // kyc?: boolean;
+}).strict();
+var ProfileParameterSchema = z.object({
+  /** Human-readable description */
+  description: z.string().min(1),
+  /** Whether this parameter is required */
+  required: z.boolean().optional(),
+  /** Default value if not provided */
+  default: z.union([z.string(), z.number(), z.boolean()]).optional(),
+  /** Example value for documentation */
+  example: z.string().optional(),
+  /** Validation type for the parameter */
+  validate: z.enum(["email", "url", "rate_limit"]).optional()
+}).strict();
+var ProfileDefinitionSchema = z.object({
+  /** Unique profile identifier (e.g., 'news-media') */
+  id: z.string().min(1).regex(/^[a-z][a-z0-9-]*$/),
+  /** Human-readable profile name */
+  name: z.string().min(1),
+  /** Multi-line description of the profile */
+  description: z.string().min(1),
+  /** Base policy document */
+  policy: PolicyDocumentSchema,
+  /** Configurable parameters */
+  parameters: z.record(z.string(), ProfileParameterSchema),
+  /** Default values for profile instances */
+  defaults: z.object({
+    /** Default requirements for 'review' decisions */
+    requirements: DecisionRequirementsSchema.optional(),
+    /** Default rate limit */
+    rate_limit: RateLimitConfigSchema.optional()
+  }).strict().optional()
+}).strict();
+var PolicyConstraintsSchema = z.object({
+  /** Rate limit configuration */
+  rate_limit: z.object({
+    /** Window size in seconds */
+    window_s: z.number().int().positive(),
+    /** Maximum requests allowed in the window */
+    max: z.number().int().positive(),
+    /** Retry-After header value in seconds (optional) */
+    retry_after_s: z.number().int().positive().optional()
+  }).strict().optional(),
+  /** Budget constraints */
+  budget: z.object({
+    /** Maximum tokens allowed */
+    max_tokens: z.number().int().positive().optional(),
+    /** Maximum requests allowed */
+    max_requests: z.number().int().positive().optional()
+  }).strict().optional()
+}).strict();
+var EnforcementProfileSchema = z.object({
+  /** Profile identifier */
+  id: z.enum(["strict", "balanced", "open"]),
+  /** Human-readable name */
+  name: z.string().min(1),
+  /** Description of when to use this profile */
+  description: z.string().min(1),
+  /** Decision for requests with no purpose declared (missing header) */
+  undeclared_decision: z.enum(["allow", "deny", "review"]),
+  /** Decision for requests with unknown purpose tokens */
+  unknown_decision: z.enum(["allow", "deny", "review"]),
+  /** Purpose reason to record when undeclared/unknown is processed */
+  purpose_reason: z.enum([
+    "allowed",
+    "constrained",
+    "denied",
+    "downgraded",
+    "undeclared_default",
+    "unknown_preserved"
+  ]),
+  /** Default constraints to apply for 'review' decisions */
+  default_constraints: PolicyConstraintsSchema.optional(),
+  /** Whether receipts are required for allowed requests */
+  receipts: z.enum(["required", "optional", "omit"])
+}).strict();
+var PolicyLoadError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "PolicyLoadError";
+  }
+};
+var PolicyValidationError = class extends PolicyLoadError {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "PolicyValidationError";
+  }
+};
+function parsePolicy(content, format) {
+  let parsed;
+  try {
+    if (format === "json") {
+      parsed = JSON.parse(content);
+    } else if (format === "yaml") {
+      parsed = yaml.parse(content);
+    } else {
+      try {
+        parsed = JSON.parse(content);
+      } catch {
+        parsed = yaml.parse(content);
+      }
+    }
+  } catch (err) {
+    throw new PolicyLoadError(
+      `Failed to parse policy: ${err instanceof Error ? err.message : String(err)}`,
+      err instanceof Error ? err : void 0
+    );
+  }
+  return validatePolicy(parsed);
+}
+function validatePolicy(obj) {
+  try {
+    return PolicyDocumentSchema.parse(obj);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      const issues = err.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      throw new PolicyValidationError(`Policy validation failed: ${issues}`, err.issues);
+    }
+    throw new PolicyLoadError(
+      `Policy validation failed: ${err instanceof Error ? err.message : String(err)}`,
+      err instanceof Error ? err : void 0
+    );
+  }
+}
+function loadPolicy(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  let format;
+  if (ext === ".json") {
+    format = "json";
+  } else if (ext === ".yaml" || ext === ".yml") {
+    format = "yaml";
+  }
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    throw new PolicyLoadError(
+      `Failed to read policy file: ${err instanceof Error ? err.message : String(err)}`,
+      err instanceof Error ? err : void 0
+    );
+  }
+  return parsePolicy(content, format);
+}
+function policyFileExists(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createExamplePolicy() {
+  return {
+    version: POLICY_VERSION,
+    name: "Example Policy",
+    defaults: {
+      decision: "deny",
+      reason: "No matching rule found"
+    },
+    rules: [
+      {
+        name: "allow-subscribed-crawl",
+        subject: {
+          type: "human",
+          labels: ["subscribed"]
+        },
+        purpose: "crawl",
+        licensing_mode: "subscription",
+        decision: "allow",
+        reason: "Subscribed users can crawl"
+      },
+      {
+        name: "allow-verified-agents-inference",
+        subject: {
+          type: "agent",
+          labels: ["verified"]
+        },
+        purpose: ["inference", "ai_input"],
+        licensing_mode: "pay_per_inference",
+        decision: "allow",
+        reason: "Verified agents can run inference with payment"
+      },
+      {
+        name: "review-org-train",
+        subject: {
+          type: "org"
+        },
+        purpose: "train",
+        decision: "review",
+        reason: "Training requests from organizations require review"
+      }
+    ]
+  };
+}
+function serializePolicyYaml(policy) {
+  return yaml.stringify(policy, {
+    lineWidth: 100,
+    defaultKeyType: "PLAIN",
+    defaultStringType: "QUOTE_DOUBLE"
+  });
+}
+function serializePolicyJson(policy, pretty = true) {
+  return JSON.stringify(policy, null, pretty ? 2 : void 0);
+}
+
+// src/evaluate.ts
+function matchesSingleOrArray(value, pattern) {
+  if (pattern === void 0) {
+    return true;
+  }
+  if (value === void 0) {
+    return false;
+  }
+  if (Array.isArray(pattern)) {
+    return pattern.includes(value);
+  }
+  return value === pattern;
+}
+function matchesIdPattern(id, pattern) {
+  if (pattern === void 0) {
+    return true;
+  }
+  if (id === void 0) {
+    return false;
+  }
+  if (pattern.endsWith("*")) {
+    const prefix = pattern.slice(0, -1);
+    return id.startsWith(prefix);
+  }
+  return id === pattern;
+}
+function hasAllLabels(subjectLabels, requiredLabels) {
+  if (requiredLabels === void 0 || requiredLabels.length === 0) {
+    return true;
+  }
+  if (subjectLabels === void 0 || subjectLabels.length === 0) {
+    return false;
+  }
+  return requiredLabels.every((label) => subjectLabels.includes(label));
+}
+function matchesSubject(subject, matcher) {
+  if (matcher === void 0) {
+    return true;
+  }
+  if (!matchesSingleOrArray(subject?.type, matcher.type)) {
+    return false;
+  }
+  if (!hasAllLabels(subject?.labels, matcher.labels)) {
+    return false;
+  }
+  if (!matchesIdPattern(subject?.id, matcher.id)) {
+    return false;
+  }
+  return true;
+}
+function ruleMatches(rule, context) {
+  if (!matchesSubject(context.subject, rule.subject)) {
+    return false;
+  }
+  if (!matchesSingleOrArray(context.purpose, rule.purpose)) {
+    return false;
+  }
+  if (!matchesSingleOrArray(context.licensing_mode, rule.licensing_mode)) {
+    return false;
+  }
+  return true;
+}
+function evaluate(policy, context) {
+  for (const rule of policy.rules) {
+    if (ruleMatches(rule, context)) {
+      return {
+        decision: rule.decision,
+        matched_rule: rule.name,
+        reason: rule.reason,
+        is_default: false
+      };
+    }
+  }
+  return {
+    decision: policy.defaults.decision,
+    reason: policy.defaults.reason,
+    is_default: true
+  };
+}
+function explainMatches(policy, context) {
+  const matches = [];
+  for (const rule of policy.rules) {
+    if (ruleMatches(rule, context)) {
+      matches.push(rule.name);
+    }
+  }
+  if (matches.length === 0) {
+    matches.push("[default]");
+  }
+  return matches;
+}
+function findEffectiveRule(policy, context) {
+  for (const rule of policy.rules) {
+    if (ruleMatches(rule, context)) {
+      return rule;
+    }
+  }
+  return void 0;
+}
+function isAllowed(policy, context) {
+  const result = evaluate(policy, context);
+  return result.decision === "allow";
+}
+function isDenied(policy, context) {
+  const result = evaluate(policy, context);
+  return result.decision === "deny";
+}
+function requiresReview(policy, context) {
+  const result = evaluate(policy, context);
+  return result.decision === "review";
+}
+function evaluateBatch(policy, contexts) {
+  return contexts.map((context) => evaluate(policy, context));
+}
+
+// src/compiler.ts
+var PEAC_PROTOCOL_VERSION = "0.9";
+function compilePeacTxt(policy, options = {}) {
+  const lines = [];
+  const { includeComments = true, peacVersion = PEAC_PROTOCOL_VERSION } = options;
+  if (includeComments) {
+    lines.push("# PEAC Policy Discovery File");
+    lines.push(`# Generated from: ${policy.name || "peac-policy.yaml"}`);
+    lines.push("#");
+    lines.push("# Serve at: /.well-known/peac.txt");
+    lines.push("# See: https://www.peacprotocol.org");
+    lines.push("");
+  }
+  lines.push(`version: ${peacVersion}`);
+  const usage = policy.defaults.decision === "allow" ? "open" : "conditional";
+  lines.push(`usage: ${usage}`);
+  lines.push("");
+  const purposes = extractPurposes(policy);
+  if (purposes.length > 0) {
+    lines.push(`purposes: [${purposes.join(", ")}]`);
+  }
+  if (options.attribution && options.attribution !== "none") {
+    lines.push(`attribution: ${options.attribution}`);
+  }
+  const receiptsDefault = usage === "conditional" ? "required" : "optional";
+  const receiptsValue = options.receipts ?? receiptsDefault;
+  if (receiptsValue !== "omit") {
+    lines.push(`receipts: ${receiptsValue}`);
+  }
+  if (options.rateLimit) {
+    lines.push(`rate_limit: ${options.rateLimit}`);
+  }
+  if (options.negotiateUrl) {
+    lines.push(`negotiate: ${options.negotiateUrl}`);
+  }
+  if (options.contact) {
+    lines.push(`contact: ${options.contact}`);
+  }
+  if (policy.rules.length > 0 && includeComments) {
+    lines.push("");
+    lines.push("# Policy rules (first-match-wins, author order preserved):");
+    lines.push(`# Source: ${policy.name || "peac-policy.yaml"} (${policy.rules.length} rules)`);
+    for (const rule of policy.rules) {
+      lines.push(`#   ${rule.name}: ${rule.decision}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function compileRobotsSnippet(policy, options = {}) {
+  const lines = [];
+  const { includeComments = true } = options;
+  const aiCrawlers = [
+    "Anthropic-AI",
+    "CCBot",
+    "ChatGPT-User",
+    "Claude-Web",
+    "Cohere-AI",
+    "GPTBot",
+    "Google-Extended",
+    "Meta-ExternalAgent",
+    "Meta-ExternalFetcher",
+    "PerplexityBot",
+    "anthropic-ai",
+    "cohere-ai"
+  ];
+  if (includeComments) {
+    lines.push("# AI Crawler Directives");
+    lines.push(`# Generated from PEAC policy: ${policy.name || "peac-policy.yaml"}`);
+    lines.push("#");
+    lines.push("# SNIPPET - Review before adding to your robots.txt");
+    lines.push(`# Default policy: ${policy.defaults.decision}`);
+    lines.push("");
+  }
+  const isDefaultAllow = policy.defaults.decision === "allow";
+  for (const crawler of aiCrawlers) {
+    lines.push(`User-agent: ${crawler}`);
+    if (isDefaultAllow) {
+      lines.push("Allow: /");
+    } else {
+      lines.push("Disallow: /");
+      if (includeComments) {
+        lines.push("# Requires PEAC receipt for access");
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function compileAiprefTemplates(policy, options = {}) {
+  const templates = [];
+  const { peacVersion = PEAC_PROTOCOL_VERSION } = options;
+  const usage = policy.defaults.decision === "allow" ? "open" : "conditional";
+  templates.push({
+    header: "PEAC-Policy",
+    value: `version=${peacVersion}; usage=${usage}; rules=${policy.rules.length}`,
+    description: "Debug/compatibility header - see peac.txt for authoritative policy"
+  });
+  if (policy.defaults.decision === "deny") {
+    templates.push({
+      header: "X-Robots-Tag",
+      value: "noai, noimageai",
+      description: "Compatibility header: signal no AI training (default deny policy)"
+    });
+  }
+  templates.push({
+    header: "# Compatibility Note",
+    value: "See /.well-known/peac.txt for authoritative policy",
+    description: "These headers are for compatibility only. AIPREF-style X-AI-* headers are not generated to avoid contradictions with conditional rules."
+  });
+  return templates;
+}
+function renderPolicyMarkdown(policy, options = {}) {
+  const lines = [];
+  lines.push(`# ${policy.name || "AI Access Policy"}`);
+  lines.push("");
+  lines.push(`> Generated from PEAC policy (${policy.version})`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`- **Default Decision:** ${policy.defaults.decision}`);
+  if (policy.defaults.reason) {
+    lines.push(`- **Default Reason:** ${policy.defaults.reason}`);
+  }
+  lines.push(`- **Total Rules:** ${policy.rules.length}`);
+  lines.push("");
+  if (options.contact) {
+    lines.push(`For questions about this policy, contact: ${options.contact}`);
+    lines.push("");
+  }
+  lines.push("## How This Policy Works");
+  lines.push("");
+  lines.push(
+    "This policy uses **first-match-wins** semantics (like firewall rules). When an AI agent requests access:"
+  );
+  lines.push("");
+  lines.push("1. Rules are evaluated in order");
+  lines.push("2. The first matching rule determines the decision");
+  lines.push("3. If no rule matches, the default decision applies");
+  lines.push("");
+  if (policy.rules.length > 0) {
+    lines.push("## Rules");
+    lines.push("");
+    lines.push("> Rules are evaluated in order. The first matching rule wins.");
+    lines.push("");
+    for (const rule of policy.rules) {
+      lines.push(`### ${rule.name}`);
+      lines.push("");
+      lines.push(`- **Decision:** ${rule.decision}`);
+      if (rule.reason) {
+        lines.push(`- **Reason:** ${rule.reason}`);
+      }
+      if (rule.subject) {
+        const subjectParts = [];
+        if (rule.subject.type) {
+          const types = Array.isArray(rule.subject.type) ? rule.subject.type.join(", ") : rule.subject.type;
+          subjectParts.push(`type: ${types}`);
+        }
+        if (rule.subject.labels) {
+          subjectParts.push(`labels: ${rule.subject.labels.join(", ")}`);
+        }
+        if (rule.subject.id) {
+          subjectParts.push(`id: ${rule.subject.id}`);
+        }
+        if (subjectParts.length > 0) {
+          lines.push(`- **Subject:** ${subjectParts.join("; ")}`);
+        }
+      }
+      if (rule.purpose) {
+        const purposes = Array.isArray(rule.purpose) ? rule.purpose.join(", ") : rule.purpose;
+        lines.push(`- **Purpose:** ${purposes}`);
+      }
+      if (rule.licensing_mode) {
+        const modes = Array.isArray(rule.licensing_mode) ? rule.licensing_mode.join(", ") : rule.licensing_mode;
+        lines.push(`- **Licensing Mode:** ${modes}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(
+    "*This policy is enforced via the PEAC Protocol. See [peacprotocol.org](https://www.peacprotocol.org) for more information.*"
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function extractPurposes(policy) {
+  const purposes = /* @__PURE__ */ new Set();
+  for (const rule of policy.rules) {
+    if (rule.purpose) {
+      if (Array.isArray(rule.purpose)) {
+        for (const p of rule.purpose) {
+          purposes.add(p);
+        }
+      } else {
+        purposes.add(rule.purpose);
+      }
+    }
+  }
+  return Array.from(purposes).sort();
+}
+
+// src/generated/profiles.ts
+var PROFILE_IDS = ["api-provider", "news-media", "open-source", "saas-docs"];
+var PROFILES = {
+  "api-provider": {
+    defaults: {
+      rate_limit: {
+        limit: 200,
+        window_seconds: 3600
+      },
+      requirements: {
+        receipt: true
+      }
+    },
+    description: "Policy profile for API providers and developer platforms.\nAllows search indexing for API discoverability.\nBlocks training to protect API design and documentation IP.\nRequires receipts for inference to enable usage tracking.\n",
+    id: "api-provider",
+    name: "API Provider",
+    parameters: {
+      contact: {
+        description: "Developer relations or API support email",
+        example: "api-support@example.com",
+        required: true,
+        validate: "email"
+      },
+      negotiate_url: {
+        description: "URL for API access negotiation",
+        required: false,
+        validate: "url"
+      },
+      rate_limit: {
+        default: "200/hour",
+        description: "Rate limit for API documentation access",
+        validate: "rate_limit"
+      }
+    },
+    policy: {
+      defaults: {
+        decision: "deny",
+        reason: "Default deny - explicit permission required"
+      },
+      name: "API Provider Policy",
+      rules: [
+        {
+          decision: "allow",
+          name: "allow-discovery",
+          purpose: ["crawl", "index", "search", "ai_index"],
+          reason: "Allow API discovery and search indexing"
+        },
+        {
+          decision: "deny",
+          name: "block-training",
+          purpose: "train",
+          reason: "API documentation training requires license"
+        },
+        {
+          decision: "review",
+          name: "inference-with-receipt",
+          purpose: ["inference", "ai_input"],
+          reason: "Inference requires valid PEAC receipt for tracking"
+        }
+      ],
+      version: "peac-policy/0.1"
+    }
+  },
+  "news-media": {
+    defaults: {
+      rate_limit: {
+        limit: 100,
+        window_seconds: 3600
+      },
+      requirements: {
+        receipt: true
+      }
+    },
+    description: "Policy profile for news and media publishers.\nAllows search engine indexing while blocking unauthorized AI training.\nInference access requires a valid PEAC receipt.\n",
+    id: "news-media",
+    name: "News Media Publisher",
+    parameters: {
+      contact: {
+        description: "Contact email for licensing inquiries",
+        example: "licensing@example.com",
+        required: true,
+        validate: "email"
+      },
+      negotiate_url: {
+        description: "URL for license negotiation",
+        required: false,
+        validate: "url"
+      },
+      rate_limit: {
+        default: "100/hour",
+        description: "Rate limit for allowed purposes",
+        validate: "rate_limit"
+      }
+    },
+    policy: {
+      defaults: {
+        decision: "deny",
+        reason: "Default deny - explicit permission required"
+      },
+      name: "News Media Policy",
+      rules: [
+        {
+          decision: "allow",
+          name: "allow-search-indexing",
+          purpose: ["crawl", "index", "search", "ai_index"],
+          reason: "Allow discovery and search engine indexing"
+        },
+        {
+          decision: "deny",
+          name: "block-training",
+          purpose: "train",
+          reason: "Training requires explicit licensing agreement"
+        },
+        {
+          decision: "review",
+          name: "inference-needs-receipt",
+          purpose: ["inference", "ai_input"],
+          reason: "Inference access requires valid PEAC receipt"
+        }
+      ],
+      version: "peac-policy/0.1"
+    }
+  },
+  "open-source": {
+    defaults: {
+      rate_limit: {
+        limit: 1e3,
+        window_seconds: 3600
+      }
+    },
+    description: "Policy profile for open source projects.\nFully open access including AI training.\nEncourages broad AI ecosystem adoption.\nReceipts are optional for attribution tracking.\n",
+    id: "open-source",
+    name: "Open Source Project",
+    parameters: {
+      attribution: {
+        default: "optional",
+        description: "Attribution requirement",
+        example: "required"
+      },
+      contact: {
+        description: "Project contact or maintainer email",
+        example: "maintainer@example.com",
+        required: false,
+        validate: "email"
+      }
+    },
+    policy: {
+      defaults: {
+        decision: "allow",
+        reason: "Open source - all access permitted"
+      },
+      name: "Open Source Policy",
+      rules: [],
+      version: "peac-policy/0.1"
+    }
+  },
+  "saas-docs": {
+    defaults: {
+      rate_limit: {
+        limit: 500,
+        window_seconds: 3600
+      }
+    },
+    description: "Policy profile for SaaS documentation sites.\nOpen access for search and inference to improve discoverability.\nTraining blocked to protect proprietary documentation.\nReceipts are optional to encourage AI agent adoption.\n",
+    id: "saas-docs",
+    name: "SaaS Documentation",
+    parameters: {
+      contact: {
+        description: "Contact email for questions",
+        example: "docs@example.com",
+        required: false,
+        validate: "email"
+      },
+      rate_limit: {
+        default: "500/hour",
+        description: "Rate limit for access",
+        validate: "rate_limit"
+      }
+    },
+    policy: {
+      defaults: {
+        decision: "allow",
+        reason: "Open by default for documentation"
+      },
+      name: "SaaS Documentation Policy",
+      rules: [
+        {
+          decision: "deny",
+          name: "block-training",
+          purpose: "train",
+          reason: "Proprietary documentation - training requires license"
+        }
+      ],
+      version: "peac-policy/0.1"
+    }
+  }
+};
+
+// src/profiles.ts
+var ProfileError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ProfileError";
+  }
+};
+function listProfiles() {
+  return [...PROFILE_IDS];
+}
+function hasProfile(id) {
+  return PROFILE_IDS.includes(id);
+}
+function loadProfile(id) {
+  const profile = PROFILES[id];
+  if (!profile) {
+    throw new ProfileError(`Profile not found: ${id}`, "PROFILE_NOT_FOUND");
+  }
+  return profile;
+}
+function getProfile(id) {
+  if (!hasProfile(id)) {
+    return void 0;
+  }
+  return PROFILES[id];
+}
+function validateProfileParams(profile, params) {
+  const def = typeof profile === "string" ? loadProfile(profile) : profile;
+  const errors = [];
+  const warnings = [];
+  const paramDefs = def.parameters || {};
+  const providedKeys = new Set(Object.keys(params));
+  for (const [key, paramDef] of Object.entries(paramDefs)) {
+    if (paramDef.required && !providedKeys.has(key)) {
+      errors.push({
+        parameter: key,
+        message: `Required parameter missing: ${key}`,
+        code: "MISSING_REQUIRED"
+      });
+    }
+  }
+  for (const [key, value] of Object.entries(params)) {
+    const paramDef = paramDefs[key];
+    if (!paramDef) {
+      errors.push({
+        parameter: key,
+        message: `Unknown parameter: ${key}`,
+        code: "UNKNOWN_PARAMETER"
+      });
+      continue;
+    }
+    if (value === void 0 || value === null) {
+      if (paramDef.required) {
+        errors.push({
+          parameter: key,
+          message: `Required parameter is null/undefined: ${key}`,
+          code: "MISSING_REQUIRED"
+        });
+      }
+      continue;
+    }
+    const strValue = String(value);
+    const validationError = validateParameterValue(key, strValue, paramDef);
+    if (validationError) {
+      errors.push(validationError);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateParameterValue(key, value, paramDef) {
+  if (!paramDef.validate) {
+    return null;
+  }
+  switch (paramDef.validate) {
+    case "email": {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(value)) {
+        return {
+          parameter: key,
+          message: `Invalid email format: ${value}`,
+          code: "INVALID_FORMAT"
+        };
+      }
+      break;
+    }
+    case "url": {
+      try {
+        new URL(value);
+      } catch {
+        return {
+          parameter: key,
+          message: `Invalid URL format: ${value}`,
+          code: "INVALID_FORMAT"
+        };
+      }
+      break;
+    }
+    case "rate_limit": {
+      try {
+        parseRateLimit(value);
+      } catch {
+        const parsed = RateLimitConfigSchema.safeParse(value);
+        if (!parsed.success) {
+          return {
+            parameter: key,
+            message: `Invalid rate limit format: ${value}. Expected format: "100/hour" or RateLimitConfig object`,
+            code: "INVALID_FORMAT"
+          };
+        }
+      }
+      break;
+    }
+  }
+  return null;
+}
+function customizeProfile(profile, params = {}) {
+  const def = typeof profile === "string" ? loadProfile(profile) : profile;
+  const validation = validateProfileParams(def, params);
+  if (!validation.valid) {
+    const errorMessages = validation.errors.map((e) => `${e.parameter}: ${e.message}`).join(", ");
+    throw new ProfileError(`Parameter validation failed: ${errorMessages}`, "VALIDATION_FAILED");
+  }
+  const appliedParams = {};
+  for (const [key, paramDef] of Object.entries(def.parameters || {})) {
+    if (key in params && params[key] !== void 0 && params[key] !== null) {
+      appliedParams[key] = params[key];
+    } else if (paramDef.default !== void 0) {
+      appliedParams[key] = paramDef.default;
+    }
+  }
+  const policy = JSON.parse(JSON.stringify(def.policy));
+  const appliedDefaults = {};
+  if (def.defaults?.requirements) {
+    appliedDefaults.requirements = { ...def.defaults.requirements };
+  }
+  if (def.defaults?.rate_limit) {
+    appliedDefaults.rate_limit = { ...def.defaults.rate_limit };
+  }
+  if (appliedParams.rate_limit) {
+    const rateLimitValue = appliedParams.rate_limit;
+    if (typeof rateLimitValue === "string") {
+      try {
+        appliedDefaults.rate_limit = parseRateLimit(rateLimitValue);
+      } catch {
+      }
+    }
+  }
+  return {
+    policy,
+    appliedDefaults,
+    parameters: appliedParams
+  };
+}
+function getAllProfiles() {
+  return PROFILE_IDS.map((id) => PROFILES[id]);
+}
+function getProfileSummary(profile) {
+  const def = typeof profile === "string" ? loadProfile(profile) : profile;
+  const requiredParams = [];
+  const optionalParams = [];
+  for (const [key, paramDef] of Object.entries(def.parameters || {})) {
+    if (paramDef.required) {
+      requiredParams.push(key);
+    } else {
+      optionalParams.push(key);
+    }
+  }
+  return {
+    id: def.id,
+    name: def.name,
+    description: def.description,
+    defaultDecision: def.policy.defaults.decision,
+    ruleCount: def.policy.rules?.length || 0,
+    requiresReceipt: def.defaults?.requirements?.receipt ?? false,
+    requiredParams: requiredParams.sort(),
+    optionalParams: optionalParams.sort()
+  };
+}
+
+// src/enforce.ts
+function enforceDecision(decision, context = {}) {
+  switch (decision) {
+    case "allow":
+      return {
+        allowed: true,
+        statusCode: 200,
+        reason: "Access allowed by policy",
+        challenge: false,
+        decision
+      };
+    case "deny":
+      return {
+        allowed: false,
+        statusCode: 403,
+        reason: "Access denied by policy",
+        challenge: false,
+        decision
+      };
+    case "review": {
+      if (context.receiptVerified === true) {
+        return {
+          allowed: true,
+          statusCode: 200,
+          reason: "Access allowed - receipt verified",
+          challenge: false,
+          decision
+        };
+      }
+      return {
+        allowed: false,
+        statusCode: 402,
+        reason: "Access requires verification - present valid receipt",
+        challenge: true,
+        decision
+      };
+    }
+    default: {
+      const _exhaustive = decision;
+      return {
+        allowed: false,
+        statusCode: 403,
+        reason: `Unknown decision: ${_exhaustive}`,
+        challenge: false,
+        decision
+      };
+    }
+  }
+}
+function requiresChallenge(result) {
+  return result.challenge;
+}
+function getChallengeHeader(result) {
+  if (!result.challenge) {
+    return void 0;
+  }
+  return 'PEAC realm="receipt", error="receipt_required"';
+}
+function enforceForHttp(decision, context = {}) {
+  const result = enforceDecision(decision, context);
+  const headers = {};
+  if (result.challenge) {
+    const challengeHeader = getChallengeHeader(result);
+    if (challengeHeader) {
+      headers["WWW-Authenticate"] = challengeHeader;
+    }
+  }
+  return {
+    status: result.statusCode,
+    headers,
+    allowed: result.allowed,
+    reason: result.reason
+  };
+}
+function enforcePurposeDecision(decision, context) {
+  if (context.explicitUndeclared) {
+    return {
+      allowed: false,
+      statusCode: 400,
+      reason: '"undeclared" is not a valid purpose token - it is internal-only',
+      decision
+    };
+  }
+  if (!context.purposeValid) {
+    const tokenList = context.invalidTokens?.join(", ") || "unknown";
+    return {
+      allowed: false,
+      statusCode: 400,
+      reason: `Invalid purpose token(s): ${tokenList}`,
+      decision
+    };
+  }
+  switch (decision) {
+    case "allow":
+      return {
+        allowed: true,
+        statusCode: 200,
+        reason: "Purpose allowed by policy",
+        decision
+      };
+    case "deny":
+      return {
+        allowed: false,
+        statusCode: 403,
+        reason: "Purpose denied by policy",
+        decision
+      };
+    case "review":
+      return {
+        allowed: false,
+        statusCode: 403,
+        reason: "Purpose requires review - treated as denied for purpose enforcement",
+        decision
+      };
+    default: {
+      const _exhaustive = decision;
+      return {
+        allowed: false,
+        statusCode: 403,
+        reason: `Unknown decision: ${_exhaustive}`,
+        decision
+      };
+    }
+  }
+}
+function getPurposeDecisionStatusCode(decision, purposeValid) {
+  if (!purposeValid) {
+    return 400;
+  }
+  switch (decision) {
+    case "allow":
+      return 200;
+    case "deny":
+    case "review":
+      return 403;
+    default:
+      return 403;
+  }
+}
+
+// src/enforcement-profiles.ts
+var STRICT_PROFILE = {
+  id: "strict",
+  name: "Strict",
+  description: "Deny undeclared purposes. Use for regulated data, private APIs, or compliance-critical resources.",
+  undeclared_decision: "deny",
+  unknown_decision: "deny",
+  purpose_reason: "denied",
+  receipts: "required"
+};
+var BALANCED_PROFILE = {
+  id: "balanced",
+  name: "Balanced",
+  description: "Review undeclared purposes with rate limits. Default for general web publishers.",
+  undeclared_decision: "review",
+  unknown_decision: "review",
+  purpose_reason: "undeclared_default",
+  default_constraints: {
+    rate_limit: {
+      window_s: 3600,
+      // 1 hour
+      max: 100,
+      retry_after_s: 60
+    }
+  },
+  receipts: "optional"
+};
+var OPEN_PROFILE = {
+  id: "open",
+  name: "Open",
+  description: "Allow undeclared purposes with recording. Use for public content and research data.",
+  undeclared_decision: "allow",
+  unknown_decision: "allow",
+  purpose_reason: "allowed",
+  receipts: "optional"
+};
+var ENFORCEMENT_PROFILES = {
+  strict: STRICT_PROFILE,
+  balanced: BALANCED_PROFILE,
+  open: OPEN_PROFILE
+};
+var DEFAULT_ENFORCEMENT_PROFILE = "balanced";
+var ENFORCEMENT_PROFILE_IDS = [
+  "strict",
+  "balanced",
+  "open"
+];
+function getEnforcementProfile(id) {
+  const profile = ENFORCEMENT_PROFILES[id];
+  if (!profile) {
+    throw new Error(`Invalid enforcement profile ID: ${id}`);
+  }
+  return profile;
+}
+function isEnforcementProfileId(id) {
+  return ENFORCEMENT_PROFILE_IDS.includes(id);
+}
+function getDefaultEnforcementProfile() {
+  return ENFORCEMENT_PROFILES[DEFAULT_ENFORCEMENT_PROFILE];
+}
+var CANONICAL_PURPOSES = /* @__PURE__ */ new Set(["train", "search", "user_action", "inference", "index"]);
+var LEGACY_PURPOSE_MAP = {
+  crawl: "index",
+  ai_input: "inference",
+  ai_index: "index"
+};
+function isCanonicalPurpose(token) {
+  return CANONICAL_PURPOSES.has(token);
+}
+function isLegacyPurpose(token) {
+  return token in LEGACY_PURPOSE_MAP;
+}
+function evaluatePurpose(declaredPurposes, profileId = DEFAULT_ENFORCEMENT_PROFILE) {
+  const profile = getEnforcementProfile(profileId);
+  if (declaredPurposes.length === 0) {
+    return {
+      decision: profile.undeclared_decision,
+      purpose_reason: "undeclared_default",
+      constraints: profile.undeclared_decision === "review" ? profile.default_constraints : void 0,
+      purpose_declared: false,
+      has_unknown_tokens: false,
+      unknown_tokens: [],
+      profile_id: profileId
+    };
+  }
+  const canonicalTokens = [];
+  const legacyTokens = [];
+  const unknownTokens = [];
+  for (const token of declaredPurposes) {
+    if (isCanonicalPurpose(token)) {
+      canonicalTokens.push(token);
+    } else if (isLegacyPurpose(token)) {
+      legacyTokens.push(token);
+    } else {
+      unknownTokens.push(token);
+    }
+  }
+  if (unknownTokens.length > 0 && canonicalTokens.length === 0 && legacyTokens.length === 0) {
+    return {
+      decision: profile.unknown_decision,
+      purpose_reason: "unknown_preserved",
+      constraints: profile.unknown_decision === "review" ? profile.default_constraints : void 0,
+      purpose_declared: true,
+      has_unknown_tokens: true,
+      unknown_tokens: unknownTokens,
+      profile_id: profileId
+    };
+  }
+  const enforcedPurpose = canonicalTokens[0] ?? LEGACY_PURPOSE_MAP[legacyTokens[0]];
+  return {
+    decision: "allow",
+    purpose_enforced: enforcedPurpose,
+    purpose_reason: unknownTokens.length > 0 ? "unknown_preserved" : "allowed",
+    purpose_declared: true,
+    has_unknown_tokens: unknownTokens.length > 0,
+    unknown_tokens: unknownTokens,
+    profile_id: profileId
+  };
+}
+function getPurposeStatusCode(result) {
+  switch (result.decision) {
+    case "allow":
+      return 200;
+    case "review":
+    case "deny":
+      return 403;
+  }
+}
+function getRetryAfter(constraints) {
+  return constraints?.rate_limit?.retry_after_s;
+}
+
+export { BALANCED_PROFILE, DEFAULT_ENFORCEMENT_PROFILE, DecisionRequirementsSchema, ENFORCEMENT_PROFILES, ENFORCEMENT_PROFILE_IDS, EnforcementProfileSchema, OPEN_PROFILE, PEAC_PROTOCOL_VERSION, POLICY_VERSION, PROFILES, PROFILE_IDS, PolicyConstraintsSchema, PolicyDefaultsSchema, PolicyDocumentSchema, PolicyLoadError, PolicyRuleSchema, PolicyValidationError, ProfileDefinitionSchema, ProfileError, ProfileParameterSchema, RateLimitConfigSchema, STRICT_PROFILE, SubjectMatcherSchema, compileAiprefTemplates, compilePeacTxt, compileRobotsSnippet, createExamplePolicy, customizeProfile, enforceDecision, enforceForHttp, enforcePurposeDecision, evaluate, evaluateBatch, evaluatePurpose, explainMatches, findEffectiveRule, formatRateLimit, getAllProfiles, getChallengeHeader, getDefaultEnforcementProfile, getEnforcementProfile, getProfile, getProfileSummary, getPurposeDecisionStatusCode, getPurposeStatusCode, getRetryAfter, hasProfile, isAllowed, isDenied, isEnforcementProfileId, listProfiles, loadPolicy, loadProfile, parsePolicy, parseRateLimit, policyFileExists, renderPolicyMarkdown, requiresChallenge, requiresReview, serializePolicyJson, serializePolicyYaml, validatePolicy, validateProfileParams };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map