@armoriq/policy-ir 0.1.0

package/dist/index.js

@@ -0,0 +1,1373 @@
+// src/ir.ts
+var SCHEMA_VERSION = "armor.policy.v2";
+function layerOfTarget(target) {
+  if ("org" in target) return "floor";
+  if ("group" in target) return "group";
+  if ("agent" in target) return "agent";
+  return "local";
+}
+
+// src/canonical.ts
+function canonicalJson(value) {
+  if (value === null || value === void 0) return "null";
+  switch (typeof value) {
+    case "number":
+      return canonicalNumber(value);
+    case "boolean":
+      return value ? "true" : "false";
+    case "string":
+      return escapeAscii(value);
+    case "object":
+      return Array.isArray(value) ? "[" + value.map(canonicalJson).join(",") + "]" : canonicalObject(value);
+    default:
+      throw new TypeError(`unsupported type in canonical JSON: ${typeof value}`);
+  }
+}
+function canonicalNumber(value) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError("non-finite number is not valid in canonical JSON");
+  }
+  return JSON.stringify(value);
+}
+function canonicalObject(obj) {
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+  return "{" + keys.map((k) => escapeAscii(k) + ":" + canonicalJson(obj[k])).join(",") + "}";
+}
+var SHORT_ESCAPES = {
+  8: "\\b",
+  9: "\\t",
+  10: "\\n",
+  12: "\\f",
+  13: "\\r",
+  34: '\\"',
+  92: "\\\\"
+};
+function escapeAscii(s) {
+  let out = '"';
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    const short = SHORT_ESCAPES[code];
+    if (short !== void 0) out += short;
+    else if (code < 32 || code > 126) out += "\\u" + code.toString(16).padStart(4, "0");
+    else out += s[i];
+  }
+  return out + '"';
+}
+
+// src/hash.ts
+import { createHash } from "crypto";
+var HASH_PREFIX = "sha256:";
+function sha256Canonical(value) {
+  return HASH_PREFIX + createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+}
+function policyHash(document) {
+  const { policyHash: _omitted, ...rest } = document;
+  return sha256Canonical(rest);
+}
+function verifyPolicyHash(document) {
+  return typeof document.policyHash === "string" && document.policyHash === policyHash(document);
+}
+
+// src/schema-hash.ts
+import { createHash as createHash2 } from "crypto";
+function schemaHash(inputSchema) {
+  if (inputSchema === null || inputSchema === void 0) return null;
+  const canonical = canonicalizeSchema(inputSchema, inputSchema, /* @__PURE__ */ new Set());
+  return "sha256:" + createHash2("sha256").update(canonicalJson(canonical), "utf8").digest("hex");
+}
+var SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependentSchemas"
+]);
+var DATA_KEYWORDS = /* @__PURE__ */ new Set(["enum", "const", "default", "examples"]);
+var ANNOTATION_KEYS = /* @__PURE__ */ new Set(["description", "title"]);
+function canonicalizeSchema(node, root, seen, isSchemaMap = false) {
+  if (Array.isArray(node)) return node.map((item) => canonicalizeSchema(item, root, seen));
+  if (node === null || typeof node !== "object") return node;
+  const obj = node;
+  if (isSchemaMap) return mapValues(obj, (v) => canonicalizeSchema(v, root, seen));
+  const ref = obj["$ref"];
+  if (typeof ref === "string" && ref.startsWith("#")) return canonicalizeRef(obj, ref, root, seen);
+  return canonicalizeKeywords(obj, root, seen);
+}
+function canonicalizeKeywords(obj, root, seen) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (ANNOTATION_KEYS.has(k)) continue;
+    out[k] = DATA_KEYWORDS.has(k) ? v : canonicalizeSchema(v, root, seen, SCHEMA_MAP_KEYWORDS.has(k));
+  }
+  return out;
+}
+function canonicalizeRef(obj, ref, root, seen) {
+  if (seen.has(ref)) return { $ref: ref };
+  const target = resolvePointer(root, ref);
+  if (target === void 0) return { $ref: ref };
+  const next = new Set(seen);
+  next.add(ref);
+  const resolved = canonicalizeSchema(target, root, next);
+  const { $ref: _ref, ...siblings } = obj;
+  if (Object.keys(siblings).length === 0) return resolved;
+  const base = isPlainObject(resolved) ? { ...resolved } : { $ref: ref };
+  return Object.assign(base, canonicalizeKeywords(siblings, root, next));
+}
+function resolvePointer(root, ref) {
+  if (ref === "#") return root;
+  if (!ref.startsWith("#/")) return void 0;
+  let node = root;
+  for (const rawSeg of ref.slice(2).split("/")) {
+    const seg = decodeURIComponent(rawSeg).replace(/~1/g, "/").replace(/~0/g, "~");
+    node = childOf(node, seg);
+    if (node === void 0) return void 0;
+  }
+  return node;
+}
+function childOf(node, seg) {
+  if (node === null || typeof node !== "object") return void 0;
+  return Array.isArray(node) ? node[Number(seg)] : node[seg];
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mapValues(obj, fn) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) out[k] = fn(v);
+  return out;
+}
+
+// src/evaluate/input.ts
+var VERDICT_RANK = { allow: 0, hold: 1, block: 2 };
+function stricter(a, b) {
+  return VERDICT_RANK[a] >= VERDICT_RANK[b] ? a : b;
+}
+
+// src/evaluate/glob.ts
+function globToRegExp(pattern) {
+  let source = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      const double = pattern[i + 1] === "*";
+      source += double ? ".*" : "[^/]*";
+      if (double) i++;
+    } else if (ch === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(ch);
+    }
+  }
+  return new RegExp(source + "$");
+}
+function matchGlob(pattern, value) {
+  return globToRegExp(pattern).test(value);
+}
+function isGlob(key) {
+  return key.includes("*") || key.includes("?");
+}
+function escapeRegExp(ch) {
+  return /[\\^$.|?*+()[\]{}]/.test(ch) ? "\\" + ch : ch;
+}
+
+// src/evaluate/conditions.ts
+function resolveField(input, field) {
+  const [root, ...rest] = field.split(".");
+  const base = root === "args" ? input.arguments : input.derived?.[root ?? ""];
+  return rest.reduce(childOf2, base);
+}
+function childOf2(node, key) {
+  if (node === null || typeof node !== "object") return void 0;
+  return node[key];
+}
+function conditionsHold(input, conditions) {
+  return conditions.every((c) => conditionHolds(input, c));
+}
+function conditionHolds(input, condition) {
+  const actual = resolveField(input, condition.field);
+  if (condition.op === "exists") return actual !== void 0 === (condition.value ?? true);
+  if (actual === void 0) return false;
+  return compare(condition.op, actual, condition.value);
+}
+var COMPARATORS = {
+  eq: (a, e) => a === e,
+  ne: (a, e) => a !== e,
+  gt: (a, e) => numeric(a, e, (x, y) => x > y),
+  gte: (a, e) => numeric(a, e, (x, y) => x >= y),
+  lt: (a, e) => numeric(a, e, (x, y) => x < y),
+  lte: (a, e) => numeric(a, e, (x, y) => x <= y),
+  in: (a, e) => Array.isArray(e) && e.includes(a),
+  notIn: (a, e) => Array.isArray(e) && !e.includes(a),
+  glob: (a, e) => strings(a, e, (x, y) => matchGlob(y, x)),
+  regex: (a, e) => strings(a, e, (x, y) => new RegExp(y).test(x)),
+  notRegex: (a, e) => strings(a, e, (x, y) => !new RegExp(y).test(x)),
+  startsWith: (a, e) => strings(a, e, (x, y) => x.startsWith(y))
+};
+function compare(op, actual, expected) {
+  return COMPARATORS[op](actual, expected);
+}
+function strings(a, e, test) {
+  return typeof a === "string" && typeof e === "string" && test(a, e);
+}
+function numeric(a, e, test) {
+  return typeof a === "number" && typeof e === "number" && test(a, e);
+}
+
+// src/evaluate/select.ts
+function selectRuleKey(statements, tool) {
+  let best = null;
+  for (const key of ruleKeysOf(statements)) {
+    if (!keyMatches(key, tool)) continue;
+    if (best === null || keyBeats(key, best)) best = key;
+  }
+  return best;
+}
+function ruleKeysOf(statements) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const s of statements) if ("tool" in s.match) keys.add(s.match.tool);
+  return keys;
+}
+function keyMatches(key, tool) {
+  return isGlob(key) ? matchGlob(key, tool) : key === tool;
+}
+function keyBeats(candidate, incumbent) {
+  const candidateGlob = isGlob(candidate);
+  const incumbentGlob = isGlob(incumbent);
+  if (candidateGlob !== incumbentGlob) return !candidateGlob;
+  return candidate.length > incumbent.length;
+}
+function variantsOf(statements, ruleKey) {
+  return statements.filter((s) => "tool" in s.match && s.match.tool === ruleKey).sort((a, b) => "tool" in a.match && "tool" in b.match ? a.match.order - b.match.order : 0);
+}
+function capabilityStatements(statements, tags) {
+  return statements.filter((s) => "capability" in s.match && tags.includes(s.match.capability));
+}
+
+// src/evaluate/layers.ts
+function isLive(expiresAt, timestamp) {
+  return expiresAt === "never" || Date.parse(expiresAt) > Date.parse(timestamp);
+}
+function liveStatements(doc, input) {
+  if (!isLive(doc.expiresAt, input.timestamp)) return [];
+  return doc.statements.filter((s) => isLive(s.expiresAt, input.timestamp));
+}
+function memberScope(statements, principal) {
+  if (!principal) return [];
+  const subjects = statements.map((s) => s.subject).filter((s) => s !== null);
+  const winner = strongestSubject(subjects, principal);
+  return winner ? statements.filter((s) => s.subject !== null && sameSubject(s.subject, winner)) : [];
+}
+function strongestSubject(subjects, principal) {
+  const byId = subjects.find((s) => "membershipId" in s && s.membershipId === principal.membershipId);
+  if (byId) return byId;
+  const email = principal.email?.toLowerCase();
+  const byEmail = subjects.find((s) => "email" in s && s.email.toLowerCase() === email);
+  if (byEmail) return byEmail;
+  const groups = principal.groups ?? [];
+  const byGroup = subjects.find((s) => "group" in s && groups.includes(s.group));
+  if (byGroup) return byGroup;
+  return subjects.find((s) => "product" in s && s.product === principal.product) ?? null;
+}
+function sameSubject(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function decideLayer(statements, input) {
+  const ruleDecision = decideRule(statements, input);
+  const capability = decideCapabilities(statements, input);
+  if (!ruleDecision) return capability;
+  if (!capability) return ruleDecision;
+  return stricter(capability.statement.effect, ruleDecision.statement.effect) === ruleDecision.statement.effect ? ruleDecision : capability;
+}
+function decideRule(statements, input) {
+  const key = selectRuleKey(statements, input.tool);
+  if (key === null) return null;
+  const winner = variantsOf(statements, key).find((v) => conditionsHold(input, v.conditions));
+  return winner ? { statement: winner, obligations: driftObligations(winner, input) } : null;
+}
+function decideCapabilities(statements, input) {
+  const matching = capabilityStatements(statements, input.capabilities ?? []).filter(
+    (s) => conditionsHold(input, s.conditions)
+  );
+  let best = null;
+  for (const s of matching) {
+    if (!best || stricter(s.effect, best.effect) === s.effect) best = s;
+  }
+  return best ? { statement: best, obligations: [] } : null;
+}
+function driftObligations(statement, input) {
+  if (input.schemaHash === void 0) return [];
+  const drifted = statement.conditions.map((c) => c.schemaBinding?.schemaHash ?? null).filter((bound) => bound !== null && bound !== input.schemaHash);
+  return drifted.map((bound) => ({
+    type: "schema_drift",
+    statementId: statement.id,
+    bound,
+    observed: input.schemaHash ?? null
+  }));
+}
+
+// src/evaluate/evaluate.ts
+function evaluate(input, bound) {
+  const floor2 = decideFloor(bound.floor, input);
+  if (floor2?.statement.effect === "block") return fromDecision(floor2, bound.floor, "floor");
+  const candidate = decideCandidate(input, bound);
+  const floorVerdict = floor2?.statement.effect ?? null;
+  if (floorVerdict && stricter(floorVerdict, candidate.verdict) !== candidate.verdict) {
+    return { ...fromDecision(floor2, bound.floor, "floor"), floorVerdict };
+  }
+  return { ...candidate, floorVerdict };
+}
+function decideFloor(doc, input) {
+  if (!doc) return null;
+  return decideLayer(liveStatements(doc, input).filter((s) => s.subject === null), input);
+}
+function decideCandidate(input, bound) {
+  for (const doc of [bound.agent, bound.group]) {
+    if (!doc) continue;
+    const statements = liveStatements(doc, input);
+    const member = decideLayer(memberScope(statements, input.member), input);
+    if (member) return fromDecision(member, doc, "member");
+    const own = decideLayer(statements.filter((s) => s.subject === null), input);
+    if (own) return fromDecision(own, doc, doc.layer);
+  }
+  return fromDefault(mostSpecific(bound));
+}
+function mostSpecific(bound) {
+  const doc = bound.agent ?? bound.group ?? bound.floor;
+  if (!doc) throw new Error("evaluate: no document is bound to the target");
+  return doc;
+}
+function fromDecision(decision, doc, layer) {
+  const { statement } = decision;
+  return {
+    verdict: statement.effect,
+    floorVerdict: null,
+    approval: statement.approval ?? null,
+    obligations: decision.obligations,
+    provenance: provenanceOf(statement, doc.policyId, layer)
+  };
+}
+function provenanceOf(statement, policyId, layer) {
+  return {
+    policyId,
+    statementId: statement.id,
+    ruleKey: statement.provenance.ruleKey,
+    variant: statement.provenance.variant,
+    layer
+  };
+}
+function fromDefault(doc) {
+  const verdict = doc.defaults.tools;
+  return {
+    verdict,
+    floorVerdict: null,
+    approval: null,
+    obligations: [],
+    provenance: { policyId: doc.policyId, statementId: null, ruleKey: "tools.default", variant: -1, layer: doc.layer }
+  };
+}
+
+// src/document/parse.ts
+import { parse as parseYamlText } from "yaml";
+
+// src/document/diagnostics.ts
+var Diagnostics = class {
+  items = [];
+  error(code, path, message) {
+    this.items.push({ code, severity: "error", path, message });
+  }
+  warning(code, path, message) {
+    this.items.push({ code, severity: "warning", path, message });
+  }
+  get hasErrors() {
+    return this.items.some((d) => d.severity === "error");
+  }
+};
+
+// src/document/grammar.ts
+var SOURCE_OPERATORS = [
+  "eq",
+  "neq",
+  "in",
+  "notIn",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "matches",
+  "notMatches",
+  "startsWith",
+  "glob",
+  "withinWorkspace",
+  "exists"
+];
+var VERDICTS = ["allow", "hold", "block"];
+var NEVER = "never";
+
+// src/document/reader.ts
+var Reader = class {
+  constructor(diag) {
+    this.diag = diag;
+  }
+  diag;
+  object(value, path, keys) {
+    if (!isPlainObject2(value)) {
+      this.diag.error("expected_object", path, `expected a mapping, got ${describe(value)}`);
+      return null;
+    }
+    for (const key of Object.keys(value)) {
+      if (!keys.includes(key)) this.diag.error("unknown_key", `${path}/${key}`, `unknown key "${key}"`);
+    }
+    return value;
+  }
+  /** A mapping whose keys are user-chosen (rule keys, member keys). */
+  map(value, path) {
+    if (isPlainObject2(value)) return value;
+    this.diag.error("expected_object", path, `expected a mapping, got ${describe(value)}`);
+    return null;
+  }
+  string(value, path) {
+    if (typeof value === "string" && value.length > 0) return value;
+    this.diag.error("expected_string", path, `expected a non-empty string, got ${describe(value)}`);
+    return null;
+  }
+  optionalString(value, path) {
+    return value === void 0 ? void 0 : this.string(value, path) ?? void 0;
+  }
+  boolean(value, path) {
+    if (value === void 0 || typeof value === "boolean") return value;
+    this.diag.error("expected_boolean", path, `expected true or false, got ${describe(value)}`);
+    return void 0;
+  }
+  number(value, path) {
+    if (value === void 0 || typeof value === "number" && Number.isFinite(value)) return value;
+    this.diag.error("expected_number", path, `expected a number, got ${describe(value)}`);
+    return void 0;
+  }
+  strings(value, path) {
+    if (value === void 0) return void 0;
+    if (Array.isArray(value) && value.every((v) => typeof v === "string")) return value;
+    this.diag.error("expected_string_list", path, `expected a list of strings, got ${describe(value)}`);
+    return void 0;
+  }
+  verdict(value, path) {
+    if (typeof value === "string" && VERDICTS.includes(value)) return value;
+    this.diag.error("expected_verdict", path, `expected allow, hold or block, got ${describe(value)}`);
+    return null;
+  }
+  optionalVerdict(value, path) {
+    return value === void 0 ? void 0 : this.verdict(value, path) ?? void 0;
+  }
+  /** `never` or ISO-8601; absent materializes to `never` (VC-7c, FR-22). */
+  expiresAt(value, path) {
+    if (value === void 0) return NEVER;
+    if (value instanceof Date) return value.toISOString();
+    if (value === NEVER) return NEVER;
+    if (typeof value === "string" && !Number.isNaN(Date.parse(value))) return new Date(value).toISOString();
+    this.diag.error("expected_expiry", path, `expected "never" or an ISO-8601 date-time, got ${describe(value)}`);
+    return NEVER;
+  }
+};
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "a list";
+  if (value instanceof Date) return "a date";
+  return typeof value === "object" ? "a mapping" : JSON.stringify(value);
+}
+
+// src/document/parse.ts
+function parseYaml(text) {
+  const diag = new Diagnostics();
+  let value;
+  try {
+    value = parseYamlText(text);
+  } catch (error) {
+    diag.error("yaml_syntax", "", error.message);
+    return { source: null, diagnostics: diag };
+  }
+  return parseValue(value, diag);
+}
+function parseDocument(value) {
+  return parseValue(value, new Diagnostics());
+}
+var ROOT_KEYS = ["apiVersion", "kind", "metadata", "target", "precedence", "spec"];
+var SPEC_KEYS = ["tools", "files", "network", "skills", "secrets", "members", "products", "capture", "approvalDefaults", "expiresAt"];
+var VARIANT_KEYS = ["action", "when", "approval", "reason", "controls", "expiresAt"];
+function parseValue(value, diag) {
+  const r = new Reader(diag);
+  const root = r.object(value, "", ROOT_KEYS);
+  if (!root) return { source: null, diagnostics: diag };
+  if (root.apiVersion !== "armor.io/v2") diag.error("unsupported_api_version", "/apiVersion", `expected armor.io/v2`);
+  if (root.kind !== "Policy") diag.error("unsupported_kind", "/kind", `expected Policy`);
+  const metadata = parseMetadata(r, root.metadata);
+  const target = parseTarget(r, diag, root.target);
+  const precedence = parsePrecedence(diag, root.precedence);
+  const spec = parseSpec(r, diag, root.spec);
+  if (diag.hasErrors || !metadata || !target || !spec) return { source: null, diagnostics: diag };
+  const source = { apiVersion: "armor.io/v2", kind: "Policy", metadata, target, spec };
+  if (precedence) source.precedence = precedence;
+  return { source, diagnostics: diag };
+}
+function parseMetadata(r, value) {
+  const m = r.object(value, "/metadata", ["name", "description", "orgId", "labels"]);
+  if (!m) return null;
+  const name = r.string(m.name, "/metadata/name");
+  if (!name) return null;
+  const out = { name };
+  const description = r.optionalString(m.description, "/metadata/description");
+  const orgId = r.optionalString(m.orgId, "/metadata/orgId");
+  if (description) out.description = description;
+  if (orgId) out.orgId = orgId;
+  if (m.labels !== void 0) out.labels = parseLabels(r, m.labels);
+  return out;
+}
+function parseLabels(r, value) {
+  const labels = r.map(value, "/metadata/labels") ?? {};
+  const out = {};
+  for (const [k, v] of Object.entries(labels)) {
+    const s = r.string(v, `/metadata/labels/${k}`);
+    if (s) out[k] = s;
+  }
+  return out;
+}
+var TARGET_FORMS = ["agent", "group", "org", "device"];
+function parseTarget(r, diag, value) {
+  const t = r.object(value, "/target", ["agent", "mcpServers", "group", "org", "device"]);
+  if (!t) return null;
+  const forms = TARGET_FORMS.filter((f) => t[f] !== void 0);
+  if (forms.length !== 1) {
+    diag.error("target_form", "/target", `exactly one of agent, group, org or device is required; got ${forms.length}`);
+    return null;
+  }
+  return targetOf(r, diag, t, forms[0]);
+}
+function targetOf(r, diag, t, form) {
+  if (form === "org" || form === "device") return fixedTarget(diag, t, form);
+  if (t.mcpServers !== void 0 && form !== "agent") diag.error("unknown_key", "/target/mcpServers", "mcpServers belongs to an agent target");
+  const id = r.string(t[form], `/target/${form}`);
+  if (!id) return null;
+  if (form === "group") return { group: id };
+  const servers = r.strings(t.mcpServers, "/target/mcpServers");
+  return servers ? { agent: id, mcpServers: servers } : { agent: id };
+}
+var FIXED_TARGETS = {
+  org: { value: "*", code: "target_org", message: 'the organization floor is written as org: "*"' },
+  device: { value: "local", code: "target_device", message: "the only device target is local" }
+};
+function fixedTarget(diag, t, form) {
+  const expected = FIXED_TARGETS[form];
+  if (t[form] === expected.value) return form === "org" ? { org: "*" } : { device: "local" };
+  diag.error(expected.code, `/target/${form}`, expected.message);
+  return null;
+}
+function parsePrecedence(diag, value) {
+  if (value === void 0 || value === "device-first" || value === "agent-first") return value;
+  diag.error("expected_precedence", "/precedence", "expected device-first or agent-first");
+  return void 0;
+}
+function parseSpec(r, diag, value) {
+  const s = r.object(value, "/spec", SPEC_KEYS);
+  if (!s) return null;
+  const tools = parseTools(r, diag, s.tools, "/spec/tools");
+  if (!tools) return null;
+  const spec = { tools, expiresAt: r.expiresAt(s.expiresAt, "/spec/expiresAt") };
+  assign(spec, "files", parseFiles(r, s.files));
+  assign(spec, "network", parseNetwork(r, s.network));
+  assign(spec, "skills", parseSkills(r, s.skills));
+  assign(spec, "secrets", parseSecrets(r, s.secrets));
+  assign(spec, "members", parseOverlays(r, diag, s.members, "/spec/members"));
+  assign(spec, "products", parseOverlays(r, diag, s.products, "/spec/products"));
+  assign(spec, "capture", parseCapture(r, s.capture));
+  assign(spec, "approvalDefaults", parseApproval(r, s.approvalDefaults, "/spec/approvalDefaults"));
+  return spec;
+}
+function assign(spec, key, value) {
+  if (value !== void 0) spec[key] = value;
+}
+function parseTools(r, diag, value, path) {
+  const t = r.object(value, path, ["default", "rules"]);
+  if (!t) return null;
+  const dflt = r.verdict(t.default, `${path}/default`);
+  if (!dflt) return null;
+  const rules = parseRules(r, diag, t.rules, `${path}/rules`);
+  return rules ? { default: dflt, rules } : { default: dflt };
+}
+function parseRules(r, diag, value, path) {
+  if (value === void 0) return void 0;
+  const map = r.map(value, path);
+  if (!map) return void 0;
+  const out = {};
+  for (const [key, rule] of Object.entries(map)) {
+    const parsed = parseRule(r, diag, rule, `${path}/${key}`);
+    if (parsed) out[key] = parsed;
+  }
+  return out;
+}
+function parseRule(r, diag, value, path) {
+  if (typeof value === "string") {
+    const v = r.verdict(value, path);
+    return v ? [{ action: v, expiresAt: "never" }] : null;
+  }
+  if (!Array.isArray(value)) {
+    diag.error("expected_rule", path, "expected a verdict or a list of variants");
+    return null;
+  }
+  const variants = value.map((v, i) => parseVariant(r, diag, v, `${path}/${i}`));
+  return variants.every((v) => v !== null) ? variants : null;
+}
+function parseVariant(r, diag, value, path) {
+  const v = r.object(value, path, VARIANT_KEYS);
+  if (!v) return null;
+  const action = r.verdict(v.action, `${path}/action`);
+  if (!action) return null;
+  const variant = { action, expiresAt: r.expiresAt(v.expiresAt, `${path}/expiresAt`) };
+  const when = parseWhen(r, diag, v.when, `${path}/when`);
+  const approval = parseApproval(r, v.approval, `${path}/approval`);
+  const reason = r.optionalString(v.reason, `${path}/reason`);
+  const controls = r.strings(v.controls, `${path}/controls`);
+  if (when) variant.when = when;
+  if (approval) variant.approval = approval;
+  if (reason) variant.reason = reason;
+  if (controls) variant.controls = controls;
+  return variant;
+}
+function parseWhen(r, diag, value, path) {
+  if (value === void 0) return void 0;
+  const map = r.map(value, path);
+  if (!map) return void 0;
+  const out = {};
+  for (const [field, spec] of Object.entries(map)) {
+    const cond = parseCondition(r, diag, spec, `${path}/${field}`);
+    if (cond) out[field] = cond;
+  }
+  return out;
+}
+function parseCondition(r, diag, value, path) {
+  const c = r.object(value, path, SOURCE_OPERATORS);
+  if (!c) return null;
+  const ops = Object.keys(c);
+  if (ops.length !== 1) {
+    diag.error("condition_operator", path, `exactly one operator is required; got ${ops.length}`);
+    return null;
+  }
+  return c;
+}
+function parseApproval(r, value, path) {
+  if (value === void 0) return void 0;
+  const a = r.object(value, path, ["approvers", "roles", "members", "anyMember"]);
+  if (!a) return void 0;
+  const approvers = r.number(a.approvers, `${path}/approvers`);
+  const out = { approvers: approvers ?? 1 };
+  const roles = r.strings(a.roles, `${path}/roles`);
+  const members = r.strings(a.members, `${path}/members`);
+  const anyMember = r.boolean(a.anyMember, `${path}/anyMember`);
+  if (roles) out.roles = roles;
+  if (members) out.members = members;
+  if (anyMember !== void 0) out.anyMember = anyMember;
+  return out;
+}
+function parseFiles(r, value) {
+  if (value === void 0) return void 0;
+  const f = r.object(value, "/spec/files", ["deny", "allowOutsideWorkspace"]);
+  if (!f) return void 0;
+  const out = {};
+  const deny = r.strings(f.deny, "/spec/files/deny");
+  const outside = r.boolean(f.allowOutsideWorkspace, "/spec/files/allowOutsideWorkspace");
+  if (deny) out.deny = deny;
+  if (outside !== void 0) out.allowOutsideWorkspace = outside;
+  return out;
+}
+function parseNetwork(r, value) {
+  if (value === void 0) return void 0;
+  const n = r.object(value, "/spec/network", ["default", "allow", "deny"]);
+  if (!n) return void 0;
+  const out = {};
+  const dflt = r.optionalVerdict(n.default, "/spec/network/default");
+  const allow = parseNetworkEntries(r, n.allow, "/spec/network/allow");
+  const deny = parseNetworkEntries(r, n.deny, "/spec/network/deny");
+  if (dflt) out.default = dflt;
+  if (allow) out.allow = allow;
+  if (deny) out.deny = deny;
+  return out;
+}
+function parseNetworkEntries(r, value, path) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    r.strings(value, path);
+    return void 0;
+  }
+  const out = [];
+  value.forEach((entry, i) => {
+    if (typeof entry === "string") return void out.push(entry);
+    const e = r.object(entry, `${path}/${i}`, ["host", "reason"]);
+    const host = e ? r.string(e.host, `${path}/${i}/host`) : null;
+    if (e && host) out.push(e.reason === void 0 ? { host } : { host, reason: String(e.reason) });
+  });
+  return out;
+}
+function parseSkills(r, value) {
+  if (value === void 0) return void 0;
+  const s = r.object(value, "/spec/skills", ["default", "hold", "block"]);
+  if (!s) return void 0;
+  const out = {};
+  const dflt = r.optionalVerdict(s.default, "/spec/skills/default");
+  const hold = r.strings(s.hold, "/spec/skills/hold");
+  const block = r.strings(s.block, "/spec/skills/block");
+  if (dflt) out.default = dflt;
+  if (hold) out.hold = hold;
+  if (block) out.block = block;
+  return out;
+}
+function parseSecrets(r, value) {
+  if (value === void 0) return void 0;
+  const s = r.object(value, "/spec/secrets", ["envBlocklist"]);
+  if (!s) return void 0;
+  const envBlocklist = r.strings(s.envBlocklist, "/spec/secrets/envBlocklist");
+  return envBlocklist ? { envBlocklist } : {};
+}
+function parseOverlays(r, diag, value, path) {
+  if (value === void 0) return void 0;
+  const map = r.map(value, path);
+  if (!map) return void 0;
+  const out = {};
+  for (const [key, overlay] of Object.entries(map)) {
+    const parsed = parseOverlay(r, diag, overlay, `${path}/${key}`);
+    if (parsed) out[key] = parsed;
+  }
+  return out;
+}
+function parseOverlay(r, diag, value, path) {
+  const o = r.object(value, path, ["tools", "expiresAt"]);
+  if (!o) return null;
+  const overlay = { expiresAt: r.expiresAt(o.expiresAt, `${path}/expiresAt`) };
+  if (o.tools === void 0) return overlay;
+  const t = r.object(o.tools, `${path}/tools`, ["default", "rules"]);
+  if (!t) return overlay;
+  const tools = {};
+  const dflt = r.optionalVerdict(t.default, `${path}/tools/default`);
+  const rules = parseRules(r, diag, t.rules, `${path}/tools/rules`);
+  if (dflt) tools.default = dflt;
+  if (rules) tools.rules = rules;
+  overlay.tools = tools;
+  return overlay;
+}
+function parseCapture(r, value) {
+  if (value === void 0) return void 0;
+  const c = r.object(value, "/spec/capture", ["arguments", "redact", "maxBytesPerCall", "sample"]);
+  if (!c) return void 0;
+  const out = {};
+  const args = r.boolean(c.arguments, "/spec/capture/arguments");
+  const redact = r.strings(c.redact, "/spec/capture/redact");
+  const max = r.number(c.maxBytesPerCall, "/spec/capture/maxBytesPerCall");
+  const sample = r.number(c.sample, "/spec/capture/sample");
+  if (args !== void 0) out.arguments = args;
+  if (redact) out.redact = redact;
+  if (max !== void 0) out.maxBytesPerCall = max;
+  if (sample !== void 0) out.sample = sample;
+  return out;
+}
+
+// src/document/validate.ts
+function validate(source) {
+  const diag = new Diagnostics();
+  const ctx = { diag, approvalDefaults: source.spec.approvalDefaults, base: source.spec.tools };
+  validateTargetSections(ctx, source);
+  if (source.spec.approvalDefaults) validateApproval(ctx, source.spec.approvalDefaults, "/spec/approvalDefaults", true);
+  validateRules(ctx, source.spec.tools.rules, "/spec/tools/rules");
+  validateOverlays(ctx, source.spec.members, "/spec/members");
+  validateOverlays(ctx, source.spec.products, "/spec/products");
+  validateCapture(ctx, source);
+  return diag;
+}
+function validateTargetSections(ctx, source) {
+  const local = "device" in source.target;
+  if (!local && source.spec.products) ctx.diag.error("local_only_section", "/spec/products", "products applies only under target device: local");
+  if (!local && source.precedence) ctx.diag.error("local_only_section", "/precedence", "precedence applies only under target device: local");
+  if (local && source.spec.members) ctx.diag.error("enterprise_only_section", "/spec/members", "members applies only to an enterprise target");
+  if (local && source.metadata.orgId) ctx.diag.error("enterprise_only_field", "/metadata/orgId", "a local policy carries no orgId");
+}
+function validateRules(ctx, rules, path) {
+  for (const [key, variants] of Object.entries(rules ?? {})) {
+    validateVariants(ctx, variants, `${path}/${key}`);
+  }
+}
+function validateVariants(ctx, variants, path) {
+  variants.forEach((variant, i) => {
+    const vpath = `${path}/${i}`;
+    if (i > 0 && isUnconditional(variants[i - 1])) {
+      ctx.diag.error("unreachable_variant", vpath, `variant ${i - 1} has no when, so this variant can never be reached`);
+    }
+    validateVariant(ctx, variant, vpath);
+  });
+}
+function isUnconditional(variant) {
+  return !variant.when || Object.keys(variant.when).length === 0;
+}
+function validateVariant(ctx, variant, path) {
+  if (variant.action === "hold") validateHoldApprover(ctx, variant, path);
+  for (const [field, spec] of Object.entries(variant.when ?? {})) validateCondition(ctx, spec, `${path}/when/${field}`);
+}
+function validateHoldApprover(ctx, variant, path) {
+  if (variant.approval) return void validateApproval(ctx, variant.approval, `${path}/approval`, true);
+  if (!ctx.approvalDefaults) {
+    ctx.diag.error("hold_without_approver", path, "a hold names an approval or the document sets approvalDefaults");
+  }
+}
+function validateApproval(ctx, approval, path, requireResolvable) {
+  if (!Number.isInteger(approval.approvers) || approval.approvers < 1) {
+    ctx.diag.error("approvers_count", `${path}/approvers`, "approvers is a whole number of at least 1");
+  }
+  if (requireResolvable && !namesAnApprover(approval)) {
+    ctx.diag.error("approval_unresolvable", path, "an approval names roles, members or anyMember: true");
+  }
+}
+function namesAnApprover(approval) {
+  return (approval.roles?.length ?? 0) > 0 || (approval.members?.length ?? 0) > 0 || approval.anyMember === true;
+}
+var OPERANDS = {
+  eq: [() => true, "any value"],
+  neq: [() => true, "any value"],
+  in: [Array.isArray, "a list"],
+  notIn: [Array.isArray, "a list"],
+  gt: [isNumber, "a number"],
+  gte: [isNumber, "a number"],
+  lt: [isNumber, "a number"],
+  lte: [isNumber, "a number"],
+  matches: [isRe2Pattern, "an RE2-compatible regular expression"],
+  notMatches: [isRe2Pattern, "an RE2-compatible regular expression"],
+  startsWith: [isString, "a string"],
+  glob: [isString, "a glob"],
+  withinWorkspace: [isBoolean, "true or false"],
+  exists: [isBoolean, "true or false"]
+};
+function validateCondition(ctx, spec, path) {
+  const [op, value] = Object.entries(spec)[0];
+  const [check, expected] = OPERANDS[op];
+  if (!check(value)) ctx.diag.error("condition_operand", `${path}/${op}`, `${op} takes ${expected}`);
+}
+function isNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function isString(v) {
+  return typeof v === "string";
+}
+function isBoolean(v) {
+  return typeof v === "boolean";
+}
+function isRe2Pattern(v) {
+  if (typeof v !== "string") return false;
+  if (/\\[1-9]|\(\?[=!<]/.test(v)) return false;
+  try {
+    new RegExp(v);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateOverlays(ctx, overlays2, path) {
+  for (const [key, overlay] of Object.entries(overlays2 ?? {})) {
+    const opath = `${path}/${key}`;
+    validateRules(ctx, overlay.tools?.rules, `${opath}/tools/rules`);
+    flagLoosening(ctx, overlay, opath);
+  }
+}
+function flagLoosening(ctx, overlay, path) {
+  const baseDefault = ctx.base.default;
+  if (overlay.tools?.default && looser(overlay.tools.default, baseDefault)) {
+    ctx.diag.warning("loosening_grant", `${path}/tools/default`, `default ${overlay.tools.default} is looser than the base default ${baseDefault}`);
+  }
+  for (const [key, variants] of Object.entries(overlay.tools?.rules ?? {})) {
+    const base = baseVerdictFor(ctx.base, key);
+    const loosest = variants.reduce((v, x) => looser(x.action, v) ? x.action : v, "block");
+    if (looser(loosest, base)) {
+      ctx.diag.warning("loosening_grant", `${path}/tools/rules/${key}`, `${key}: ${loosest} is looser than the base ${base}`);
+    }
+  }
+}
+function baseVerdictFor(base, key) {
+  const variants = base.rules?.[key];
+  if (!variants) return base.default;
+  return variants.reduce((v, x) => looser(v, x.action) ? x.action : v, "allow");
+}
+function looser(a, b) {
+  return VERDICT_RANK[a] < VERDICT_RANK[b];
+}
+function validateCapture(ctx, source) {
+  const c = source.spec.capture;
+  if (!c) return;
+  if (c.sample !== void 0 && (c.sample < 0 || c.sample > 1)) ctx.diag.error("capture_sample", "/spec/capture/sample", "sample is between 0 and 1");
+  if (c.maxBytesPerCall !== void 0 && (c.maxBytesPerCall < 0 || !Number.isInteger(c.maxBytesPerCall))) {
+    ctx.diag.error("capture_max_bytes", "/spec/capture/maxBytesPerCall", "maxBytesPerCall is a whole number of bytes");
+  }
+}
+
+// src/compile/port.ts
+var CAPABILITY_KEYS = /* @__PURE__ */ new Set([
+  "shell",
+  "file.read",
+  "file.write",
+  "file.delete",
+  "web.fetch",
+  "web.search",
+  "skill",
+  "subagent",
+  "destructive",
+  "files",
+  "network",
+  "skills",
+  "secrets"
+]);
+
+// src/compile/clamp.ts
+function resolveKey(key, inventory, diag, path) {
+  if (isGlob(key)) return { kind: "glob", tool: null };
+  const matches = inventory.filter((t) => t.name === key || t.qualifiedName === key);
+  if (matches.length === 0 && isCapabilityKey(key, inventory)) return { kind: "capability", tool: null };
+  if (matches.length > 1 && !matches.every((t) => t.owner.id === matches[0].owner.id)) {
+    diag.error("ambiguous_tool_key", path, `"${key}" exists on ${matches.length} owners; use the qualified mcp__<server>__${key} form`);
+    return { kind: "exact", tool: null };
+  }
+  return { kind: "exact", tool: bindExact(key, matches[0] ?? null, diag, path) };
+}
+function bindExact(key, tool, diag, path) {
+  if (!tool) {
+    diag.warning("unknown_tool_key", path, `"${key}" is not in the target's inventory; the rule compiles and binds nothing until the tool appears`);
+    return null;
+  }
+  if (!tool.declared) {
+    diag.warning("observed_only_tool", path, `"${key}" has only been observed, never declared; the rule compiles without a schema binding`);
+    return null;
+  }
+  return tool;
+}
+function isCapabilityKey(key, inventory) {
+  return CAPABILITY_KEYS.has(key) || inventory.some((t) => t.capabilities?.includes(key));
+}
+function checkGlobCollisions(keys, inventory, diag, path) {
+  const globs = keys.filter(isGlob);
+  for (const tool of inventory) {
+    const matching = globs.filter((g) => matchGlob(g, tool.name) || tool.qualifiedName !== void 0 && matchGlob(g, tool.qualifiedName));
+    const collision = sameLengthPair(matching);
+    if (collision) diag.error("ambiguous_glob", path, `"${collision[0]}" and "${collision[1]}" both match ${tool.name} with the same specificity`);
+  }
+}
+function sameLengthPair(globs) {
+  const byLength = /* @__PURE__ */ new Map();
+  for (const g of globs) {
+    const other = byLength.get(g.length);
+    if (other !== void 0) return [other, g];
+    byLength.set(g.length, g);
+  }
+  return null;
+}
+function checkArgumentKeys(fields, tool, diag, path) {
+  const properties = schemaProperties(tool.inputSchema);
+  if (!properties) return;
+  for (const field of fields) {
+    const [root, first] = field.split(".");
+    if (root === "args" && first !== void 0 && !properties.has(first)) {
+      diag.warning("unknown_argument", `${path}/${field}`, `"${first}" is not a declared argument of ${tool.name}`);
+    }
+  }
+}
+function schemaProperties(schema) {
+  if (schema === null || typeof schema !== "object") return null;
+  const props = schema.properties;
+  if (props === null || typeof props !== "object") return null;
+  return new Set(Object.keys(props));
+}
+
+// src/compile/lower-floors.ts
+function lowerFloors(spec, ctx) {
+  return [...lowerFiles(spec, ctx), ...lowerNetwork(spec, ctx), ...lowerSkills(spec, ctx), ...lowerSecrets(spec, ctx)];
+}
+function floor(capability, effect, conditions, order, ctx) {
+  return {
+    id: `st-${capability}-${effect}-${order}`,
+    subject: null,
+    match: { capability },
+    effect,
+    conditions,
+    expiresAt: "never",
+    provenance: { ruleKey: capability, variant: order, source: ctx.source, layer: ctx.layer }
+  };
+}
+function lowerFiles(spec, ctx) {
+  const out = (spec.files?.deny ?? []).map((glob, i) => floor("files", "block", [{ field: "path", op: "glob", value: glob }], i, ctx));
+  if (spec.files?.allowOutsideWorkspace === false) {
+    out.push(floor("files", "block", [{ field: "withinWorkspace", op: "eq", value: false }], out.length, ctx));
+  }
+  return out;
+}
+function hostOf(entry) {
+  return typeof entry === "string" ? entry : entry.host;
+}
+function lowerNetwork(spec, ctx) {
+  const n = spec.network;
+  if (!n) return [];
+  const deny = (n.deny ?? []).map((e, i) => floor("network", "block", [{ field: "host", op: "glob", value: hostOf(e) }], i, ctx));
+  const allow = (n.allow ?? []).map((e, i) => floor("network", "allow", [{ field: "host", op: "glob", value: hostOf(e) }], deny.length + i, ctx));
+  return [...deny, ...allow];
+}
+function lowerSkills(spec, ctx) {
+  const s = spec.skills;
+  if (!s) return [];
+  const hold = (s.hold ?? []).map((g, i) => floor("skills", "hold", [{ field: "skill", op: "glob", value: g }], i, ctx));
+  const block = (s.block ?? []).map((g, i) => floor("skills", "block", [{ field: "skill", op: "glob", value: g }], hold.length + i, ctx));
+  return [...hold, ...block];
+}
+function lowerSecrets(spec, ctx) {
+  const names = spec.secrets?.envBlocklist ?? [];
+  return names.length === 0 ? [] : [floor("secrets", "block", [{ field: "env", op: "in", value: names }], 0, ctx)];
+}
+
+// src/compile/lower-conditions.ts
+var OP_MAP = {
+  eq: "eq",
+  neq: "ne",
+  in: "in",
+  notIn: "notIn",
+  gt: "gt",
+  gte: "gte",
+  lt: "lt",
+  lte: "lte",
+  matches: "regex",
+  notMatches: "notRegex",
+  startsWith: "startsWith",
+  glob: "glob",
+  withinWorkspace: "eq",
+  exists: "exists"
+};
+function lowerConditions(when, schemaHash2) {
+  return Object.entries(when ?? {}).map(([field, spec]) => lowerCondition(field, spec, schemaHash2));
+}
+function lowerCondition(field, spec, schemaHash2) {
+  const [op, operand] = Object.entries(spec)[0];
+  const condition = {
+    field: op === "withinWorkspace" ? "withinWorkspace" : field,
+    op: OP_MAP[op],
+    value: operand
+  };
+  if (schemaHash2 !== void 0 && field.startsWith("args.")) condition.schemaBinding = { schemaHash: schemaHash2 };
+  return condition;
+}
+
+// src/compile/controls.ts
+var SOC2 = [
+  "CC1.1",
+  "CC1.2",
+  "CC1.3",
+  "CC1.4",
+  "CC1.5",
+  "CC2.1",
+  "CC2.2",
+  "CC2.3",
+  "CC3.1",
+  "CC3.2",
+  "CC3.3",
+  "CC3.4",
+  "CC4.1",
+  "CC4.2",
+  "CC5.1",
+  "CC5.2",
+  "CC5.3",
+  "CC6.1",
+  "CC6.2",
+  "CC6.3",
+  "CC6.4",
+  "CC6.5",
+  "CC6.6",
+  "CC6.7",
+  "CC6.8",
+  "CC7.1",
+  "CC7.2",
+  "CC7.3",
+  "CC7.4",
+  "CC7.5",
+  "CC8.1",
+  "CC9.1",
+  "CC9.2"
+].map((c) => `SOC2-${c}`);
+var HIPAA = [
+  "164.308(a)(1)",
+  "164.308(a)(3)",
+  "164.308(a)(4)",
+  "164.308(a)(5)",
+  "164.308(a)(6)",
+  "164.310(a)(1)",
+  "164.310(b)",
+  "164.310(c)",
+  "164.310(d)(1)",
+  "164.312(a)(1)",
+  "164.312(a)(2)(i)",
+  "164.312(a)(2)(iv)",
+  "164.312(b)",
+  "164.312(c)(1)",
+  "164.312(d)",
+  "164.312(e)(1)"
+].map((c) => `HIPAA-${c}`);
+var KNOWN_CONTROLS = /* @__PURE__ */ new Set([...SOC2, ...HIPAA]);
+
+// src/compile/lower-rules.ts
+function lowerRules(rules, ctx, path, subject, scopeExpiry) {
+  const out = [];
+  for (const [key, value] of Object.entries(rules ?? {})) {
+    out.push(...lowerRule(key, value, ctx, `${path}/${key}`, subject, scopeExpiry));
+  }
+  return out;
+}
+function lowerRule(key, variants, ctx, path, subject, scopeExpiry) {
+  const resolved = resolveKey(key, ctx.inventory, ctx.diag, path);
+  checkControls(variants, ctx.diag, path);
+  const fields = variants.flatMap((v) => Object.keys(v.when ?? {}));
+  if (resolved.tool) checkArgumentKeys(fields, resolved.tool, ctx.diag, path);
+  const schemaHash2 = resolved.kind === "exact" ? resolved.tool?.schemaHash ?? null : void 0;
+  return variants.map((variant, order) => ({
+    id: statementId(key, order, subject),
+    subject,
+    match: matchFor(key, resolved.kind, order),
+    effect: variant.action,
+    conditions: lowerConditions(variant.when, schemaHash2),
+    ...approvalFor(variant, ctx.approvalDefaults),
+    expiresAt: earliest(variant.expiresAt, scopeExpiry),
+    ...variant.controls ? { controls: variant.controls } : {},
+    provenance: { ruleKey: key, variant: order, source: ctx.source, layer: subject ? "member" : ctx.layer }
+  }));
+}
+function checkControls(variants, diag, path) {
+  variants.forEach((v, i) => {
+    for (const control of v.controls ?? []) {
+      if (!KNOWN_CONTROLS.has(control)) diag.warning("unknown_control", `${path}/${i}/controls`, `unknown control identifier "${control}"`);
+    }
+  });
+}
+function matchFor(key, kind, order) {
+  if (kind === "capability") return { capability: key };
+  const keyTier = kind;
+  return { tool: key, keyTier, order };
+}
+function approvalFor(variant, defaults) {
+  if (variant.action !== "hold") return {};
+  const approval = variant.approval ?? defaults;
+  return approval ? { approval } : {};
+}
+function earliest(a, b) {
+  if (a === "never") return b;
+  if (b === "never") return a;
+  return Date.parse(a) <= Date.parse(b) ? a : b;
+}
+function statementId(key, order, subject) {
+  const slug = key.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+  const who = subject ? "-" + subjectSlug(subject) : "";
+  return `st-${slug}${who}-${order}`;
+}
+function subjectSlug(subject) {
+  const value = Object.values(subject)[0];
+  return value.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+function subjectFor(key, kind) {
+  if (kind === "products") return { product: key };
+  if (key.includes("@")) return { email: key.toLowerCase() };
+  if (key.startsWith("team:")) return { group: key.slice("team:".length) };
+  return { membershipId: key };
+}
+function lowerOverlays(overlays2, kind, ctx, path) {
+  const out = [];
+  for (const [key, overlay] of Object.entries(overlays2 ?? {})) {
+    const subject = subjectFor(key, kind);
+    const opath = `${path}/${key}/tools`;
+    out.push(...lowerRules(overlay.tools?.rules, ctx, `${opath}/rules`, subject, overlay.expiresAt));
+    if (overlay.tools?.default) out.push(overlayDefault(overlay.tools.default, subject, overlay.expiresAt, ctx));
+  }
+  return out;
+}
+function overlayDefault(effect, subject, expiresAt, ctx) {
+  return {
+    id: statementId("*", 0, subject),
+    subject,
+    match: { tool: "*", keyTier: "glob", order: 0 },
+    effect,
+    conditions: [],
+    ...effect === "hold" && ctx.approvalDefaults ? { approval: ctx.approvalDefaults } : {},
+    expiresAt,
+    provenance: { ruleKey: "tools.default", variant: 0, source: ctx.source, layer: "member" }
+  };
+}
+
+// src/compile/report.ts
+var ENTERPRISE = {
+  tools: "enforced",
+  files: "argument-only",
+  network: "argument-only",
+  skills: "inert",
+  secrets: "inert"
+};
+var LOCAL = {
+  tools: "enforced",
+  files: "enforced",
+  network: "enforced",
+  skills: "enforced",
+  secrets: "enforced"
+};
+function enforceabilityReport(source, inventory) {
+  const table = "device" in source.target ? LOCAL : ENTERPRISE;
+  const sections = { tools: table.tools };
+  for (const section of ["files", "network", "skills", "secrets"]) {
+    if (source.spec[section]) sections[section] = table[section];
+  }
+  return { sections, notCoveredByCapabilityRules: uncovered(source, inventory) };
+}
+function uncovered(source, inventory) {
+  const capabilityKeys = Object.keys(source.spec.tools.rules ?? {}).filter((k) => CAPABILITY_KEYS.has(k) || inventory.some((t) => t.capabilities?.includes(k)));
+  if (capabilityKeys.length === 0) return [];
+  return inventory.filter((t) => !capabilityKeys.some((k) => t.capabilities?.includes(k))).map((t) => t.qualifiedName ?? t.name).sort();
+}
+
+// src/compile/compile.ts
+function compile(source, inventory, options) {
+  const diag = validate(source);
+  const report = enforceabilityReport(source, inventory);
+  if (diag.hasErrors) return { document: null, diagnostics: diag, report };
+  const layer = layerOfTarget(targetOf2(source.target));
+  const ctx = { inventory, diag, layer, approvalDefaults: source.spec.approvalDefaults, source: options.source ?? "yaml" };
+  checkGlobCollisions(Object.keys(source.spec.tools.rules ?? {}), inventory, diag, "/spec/tools/rules");
+  checkDeviceFirst(source, diag);
+  const statements = [
+    ...lowerRules(source.spec.tools.rules, ctx, "/spec/tools/rules", null, source.spec.expiresAt),
+    ...lowerFloors(source.spec, ctx),
+    ...lowerOverlays(source.spec.members, "members", ctx, "/spec/members"),
+    ...lowerOverlays(source.spec.products, "products", ctx, "/spec/products")
+  ];
+  if (diag.hasErrors) return { document: null, diagnostics: diag, report };
+  const document = {
+    schemaVersion: SCHEMA_VERSION,
+    policyId: options.policyId,
+    target: targetOf2(source.target, source),
+    layer,
+    defaults: defaultsOf(source),
+    capture: captureOf(source),
+    expiresAt: source.spec.expiresAt,
+    statements
+  };
+  document.policyHash = policyHash(document);
+  return { document, diagnostics: diag, report };
+}
+async function compileWithPort(source, port, options) {
+  return compile(source, await port.toolsForTarget(source.target), options);
+}
+function targetOf2(target, source) {
+  if ("device" in target) {
+    const products = Object.keys(source?.spec.products ?? {});
+    return products.length ? { device: "local", products } : { device: "local" };
+  }
+  return target;
+}
+function defaultsOf(source) {
+  return {
+    tools: source.spec.tools.default,
+    network: source.spec.network?.default ?? "block",
+    files: "allow",
+    skills: source.spec.skills?.default ?? "allow"
+  };
+}
+function captureOf(source) {
+  const c = source.spec.capture;
+  return {
+    arguments: c?.arguments ?? false,
+    redact: c?.redact ?? ["*token*", "*secret*", "authorization"],
+    maxBytesPerCall: c?.maxBytesPerCall ?? 16384,
+    sample: c?.sample ?? 1
+  };
+}
+function checkDeviceFirst(source, diag) {
+  if (!("device" in source.target) || source.precedence === "agent-first") return;
+  for (const [product, overlay] of Object.entries(source.spec.products ?? {})) {
+    for (const [key, variants] of Object.entries(overlay.tools?.rules ?? {})) {
+      if (loosensBase(variants, baseRankFor(source, key))) {
+        diag.error("device_first_loosening", `/spec/products/${product}/tools/rules/${key}`, `under device-first a product overlay may only tighten the base; set precedence: agent-first to allow this`);
+      }
+    }
+  }
+}
+function baseRankFor(source, key) {
+  const base = source.spec.tools.rules?.[key];
+  if (!Array.isArray(base)) return VERDICT_RANK[source.spec.tools.default];
+  return Math.min(...base.map((v) => VERDICT_RANK[v.action]));
+}
+function loosensBase(variants, baseRank) {
+  return variants.some((v) => VERDICT_RANK[v.action] < baseRank);
+}
+
+// src/compile/serialize.ts
+import { stringify } from "yaml";
+function serialize(source) {
+  const spec = { ...source.spec, tools: { ...source.spec.tools, rules: shorthand(source.spec.tools.rules) } };
+  if (spec.members) spec.members = overlays(spec.members);
+  if (spec.products) spec.products = overlays(spec.products);
+  const doc = {
+    apiVersion: source.apiVersion,
+    kind: source.kind,
+    metadata: source.metadata,
+    target: source.target
+  };
+  if (source.precedence) doc.precedence = source.precedence;
+  doc.spec = spec;
+  return stringify(doc, { lineWidth: 0, defaultStringType: "PLAIN", defaultKeyType: "PLAIN" });
+}
+function shorthand(rules) {
+  if (!rules) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(rules)) out[key] = scalarIfPlain(value);
+  return out;
+}
+function scalarIfPlain(variants) {
+  const only = variants.length === 1 ? variants[0] : null;
+  const plain = only && Object.keys(only).length === 2 && only.expiresAt === "never";
+  return plain ? only.action : variants;
+}
+function overlays(map) {
+  const out = {};
+  for (const [key, overlay] of Object.entries(map)) {
+    out[key] = overlay.tools?.rules ? { ...overlay, tools: { ...overlay.tools, rules: shorthand(overlay.tools.rules) } } : overlay;
+  }
+  return out;
+}
+export {
+  CAPABILITY_KEYS,
+  Diagnostics,
+  HASH_PREFIX,
+  KNOWN_CONTROLS,
+  NEVER,
+  SCHEMA_VERSION,
+  SOURCE_OPERATORS,
+  VERDICTS,
+  VERDICT_RANK,
+  canonicalJson,
+  checkArgumentKeys,
+  checkGlobCollisions,
+  compile,
+  compileWithPort,
+  conditionHolds,
+  conditionsHold,
+  enforceabilityReport,
+  evaluate,
+  globToRegExp,
+  isGlob,
+  layerOfTarget,
+  matchGlob,
+  parseDocument,
+  parseYaml,
+  policyHash,
+  resolveField,
+  resolveKey,
+  schemaHash,
+  selectRuleKey,
+  serialize,
+  sha256Canonical,
+  stricter,
+  validate,
+  verifyPolicyHash
+};
+//# sourceMappingURL=index.js.map