@gmickel/gno 1.28.0 → 1.29.0

package/src/core/destination-classifier.ts

@@ -0,0 +1,402 @@
+/** Conservative, redacted classification for network and bind destinations. */
+
+// node:net provides the platform IP parser; Bun has no equivalent address parser.
+import { isIP } from "node:net";
+
+import type { EgressDestinationZone } from "./egress-policy";
+
+export const DESTINATION_ADDRESS_CLASSES = [
+  "loopback",
+  "private",
+  "tailscale",
+  "public",
+  "unknown",
+] as const;
+export type DestinationAddressClass =
+  (typeof DESTINATION_ADDRESS_CLASSES)[number];
+
+export const DESTINATION_CLASSIFICATION_REASONS = [
+  "LOCAL_PROCESS",
+  "LOOPBACK_ADDRESS",
+  "PRIVATE_ADDRESS",
+  "TAILSCALE_ADDRESS",
+  "PUBLIC_ADDRESS",
+  "UNPROVEN_REMOTE",
+  "MIXED_DNS_ANSWERS",
+  "REMOTE_PROVIDER",
+  "WILDCARD_BIND",
+] as const;
+export type DestinationClassificationReason =
+  (typeof DESTINATION_CLASSIFICATION_REASONS)[number];
+
+export interface DestinationClassificationAudit {
+  readonly source: "local_process" | "bind" | "literal" | "dns" | "provider";
+  readonly hostnameKind: "none" | "ip_literal" | "dns_name";
+  readonly addressCount: number;
+  readonly addressClasses: readonly DestinationAddressClass[];
+  readonly mixed: boolean;
+}
+
+export interface DestinationClassification {
+  readonly zone: EgressDestinationZone;
+  readonly addressClass: DestinationAddressClass;
+  readonly reason: DestinationClassificationReason;
+  readonly audit: DestinationClassificationAudit;
+}
+
+export interface DestinationClassifierInput {
+  kind?: "network" | "bind" | "local_process";
+  hostname?: string;
+  addresses?: readonly string[];
+  remoteProvider?: boolean;
+}
+
+const ADDRESS_CLASS_ORDER = new Map<DestinationAddressClass, number>(
+  DESTINATION_ADDRESS_CLASSES.map((value, index) => [value, index])
+);
+
+function stripAddressDecoration(address: string): string {
+  const unwrapped =
+    address.startsWith("[") && address.endsWith("]")
+      ? address.slice(1, -1)
+      : address;
+  return unwrapped.split("%", 1)[0]?.toLowerCase() ?? "";
+}
+
+function parseIpv4(address: string): readonly number[] | null {
+  const octets = address.split(".");
+  if (
+    octets.length !== 4 ||
+    octets.some(
+      (octet) => !/^(?:0|[1-9]\d{0,2})$/u.test(octet) || Number(octet) > 255
+    )
+  ) {
+    return null;
+  }
+  return octets.map(Number);
+}
+
+function parseIpv6(address: string): readonly number[] | null {
+  let normalized = stripAddressDecoration(address);
+  if (isIP(normalized) !== 6) return null;
+
+  if (normalized.includes(".")) {
+    const separator = normalized.lastIndexOf(":");
+    const ipv4 = parseIpv4(normalized.slice(separator + 1));
+    if (!ipv4) return null;
+    const high = ((ipv4[0] ?? 0) << 8) | (ipv4[1] ?? 0);
+    const low = ((ipv4[2] ?? 0) << 8) | (ipv4[3] ?? 0);
+    normalized = `${normalized.slice(0, separator)}:${high.toString(
+      16
+    )}:${low.toString(16)}`;
+  }
+
+  const halves = normalized.split("::");
+  if (halves.length > 2) return null;
+  const left = halves[0] ? halves[0].split(":") : [];
+  const right = halves[1] ? halves[1].split(":") : [];
+  const missing = 8 - left.length - right.length;
+  if (
+    (halves.length === 1 && missing !== 0) ||
+    (halves.length === 2 && missing < 1)
+  ) {
+    return null;
+  }
+  const groups = [
+    ...left,
+    ...Array.from({ length: missing }, () => "0"),
+    ...right,
+  ];
+  if (
+    groups.length !== 8 ||
+    groups.some((group) => !/^[\da-f]{1,4}$/u.test(group))
+  ) {
+    return null;
+  }
+  return groups.map((group) => Number.parseInt(group, 16));
+}
+
+interface Ipv4SpecialPrefix {
+  readonly address: readonly [number, number, number, number];
+  readonly prefixLength: number;
+  readonly addressClass: Exclude<DestinationAddressClass, "public">;
+}
+
+// IANA IPv4 Special-Purpose Address Space, refreshed 2025-10-09. GNO
+// conservatively keeps every registered block out of provider-public proof.
+const IPV4_SPECIAL_PREFIXES = [
+  { address: [0, 0, 0, 0], prefixLength: 8, addressClass: "unknown" },
+  { address: [10, 0, 0, 0], prefixLength: 8, addressClass: "private" },
+  { address: [100, 64, 0, 0], prefixLength: 10, addressClass: "unknown" },
+  { address: [127, 0, 0, 0], prefixLength: 8, addressClass: "loopback" },
+  { address: [169, 254, 0, 0], prefixLength: 16, addressClass: "unknown" },
+  { address: [172, 16, 0, 0], prefixLength: 12, addressClass: "private" },
+  { address: [192, 0, 0, 0], prefixLength: 24, addressClass: "unknown" },
+  { address: [192, 0, 2, 0], prefixLength: 24, addressClass: "unknown" },
+  { address: [192, 31, 196, 0], prefixLength: 24, addressClass: "unknown" },
+  { address: [192, 52, 193, 0], prefixLength: 24, addressClass: "unknown" },
+  { address: [192, 88, 99, 0], prefixLength: 24, addressClass: "unknown" },
+  { address: [192, 168, 0, 0], prefixLength: 16, addressClass: "private" },
+  { address: [192, 175, 48, 0], prefixLength: 24, addressClass: "unknown" },
+  { address: [198, 18, 0, 0], prefixLength: 15, addressClass: "unknown" },
+  { address: [198, 51, 100, 0], prefixLength: 24, addressClass: "unknown" },
+  { address: [203, 0, 113, 0], prefixLength: 24, addressClass: "unknown" },
+  { address: [224, 0, 0, 0], prefixLength: 3, addressClass: "unknown" },
+] as const satisfies readonly Ipv4SpecialPrefix[];
+
+function ipv4Integer(octets: readonly number[]): number {
+  return (
+    ((((octets[0] ?? 0) << 24) >>> 0) |
+      ((octets[1] ?? 0) << 16) |
+      ((octets[2] ?? 0) << 8) |
+      (octets[3] ?? 0)) >>>
+    0
+  );
+}
+
+function matchesIpv4Prefix(
+  octets: readonly number[],
+  prefix: Ipv4SpecialPrefix
+): boolean {
+  const mask =
+    prefix.prefixLength === 0
+      ? 0
+      : (0xffffffff << (32 - prefix.prefixLength)) >>> 0;
+  return (
+    (ipv4Integer(octets) & mask) >>> 0 ===
+    (ipv4Integer(prefix.address) & mask) >>> 0
+  );
+}
+
+function classifyIpv4(octets: readonly number[]): DestinationAddressClass {
+  for (const prefix of IPV4_SPECIAL_PREFIXES) {
+    if (matchesIpv4Prefix(octets, prefix)) return prefix.addressClass;
+  }
+  return "public";
+}
+
+interface Ipv6Prefix {
+  readonly groups: readonly number[];
+  readonly prefixLength: number;
+}
+
+// IANA IPv6 Special-Purpose Address Space, refreshed 2025-10-09. Mapped IPv4
+// and the globally reachable NAT64 WKP are handled separately by target
+// semantics; every prefix below remains ineligible for provider-public proof.
+const IPV6_SPECIAL_PREFIXES = [
+  { groups: [0x0100], prefixLength: 64 },
+  { groups: [0x0100, 0, 0, 1], prefixLength: 64 },
+  { groups: [0x2001], prefixLength: 23 },
+  { groups: [0x2001, 0x0db8], prefixLength: 32 },
+  { groups: [0x2002], prefixLength: 16 },
+  { groups: [0x2620, 0x004f, 0x8000], prefixLength: 48 },
+  { groups: [0x3fff], prefixLength: 20 },
+  { groups: [0x5f00], prefixLength: 16 },
+] as const satisfies readonly Ipv6Prefix[];
+
+function matchesIpv6Prefix(
+  groups: readonly number[],
+  prefix: Ipv6Prefix
+): boolean {
+  const fullGroups = Math.floor(prefix.prefixLength / 16);
+  for (let index = 0; index < fullGroups; index += 1) {
+    if ((groups[index] ?? 0) !== (prefix.groups[index] ?? 0)) return false;
+  }
+  const remainingBits = prefix.prefixLength % 16;
+  if (remainingBits === 0) return true;
+  const mask = (0xffff << (16 - remainingBits)) & 0xffff;
+  return (
+    ((groups[fullGroups] ?? 0) & mask) ===
+    ((prefix.groups[fullGroups] ?? 0) & mask)
+  );
+}
+
+function embeddedIpv4Class(
+  groups: readonly number[],
+  highGroupIndex: number
+): DestinationAddressClass {
+  const high = groups[highGroupIndex] ?? 0;
+  const low = groups[highGroupIndex + 1] ?? 0;
+  return classifyIpv4([high >> 8, high & 0xff, low >> 8, low & 0xff]);
+}
+
+function classifyIpv6(groups: readonly number[]): DestinationAddressClass {
+  const [first = -1, second = -1, third = -1] = groups;
+  const isLoopback =
+    groups.slice(0, 7).every((group) => group === 0) && groups[7] === 1;
+  if (isLoopback) return "loopback";
+  const isUnspecified = groups.every((group) => group === 0);
+  if (isUnspecified || (first & 0xff00) === 0xff00) return "unknown";
+  const isMappedIpv4 =
+    groups.slice(0, 5).every((group) => group === 0) && groups[5] === 0xffff;
+  if (isMappedIpv4) {
+    return embeddedIpv4Class(groups, 6);
+  }
+  const isCompatibleIpv4 = groups.slice(0, 6).every((group) => group === 0);
+  if (isCompatibleIpv4) return "unknown";
+  const isPublicNat64 =
+    first === 0x0064 &&
+    second === 0xff9b &&
+    groups.slice(2, 6).every((group) => group === 0);
+  if (isPublicNat64) {
+    return embeddedIpv4Class(groups, 6) === "public" ? "public" : "unknown";
+  }
+  const isLocalNat64 =
+    first === 0x0064 && second === 0xff9b && third === 0x0001;
+  if (isLocalNat64 || first === 0x2002) return "unknown";
+  if (first === 0xfd7a && second === 0x115c && third === 0xa1e0) {
+    return "tailscale";
+  }
+  const isAwsInstanceMetadata =
+    first === 0xfd00 &&
+    second === 0x0ec2 &&
+    groups.slice(2, 7).every((group) => group === 0) &&
+    groups[7] === 0x0254;
+  if (isAwsInstanceMetadata) return "unknown";
+  if ((first & 0xfe00) === 0xfc00 || (first & 0xffc0) === 0xfe80) {
+    return "private";
+  }
+  if (
+    IPV6_SPECIAL_PREFIXES.some((prefix) => matchesIpv6Prefix(groups, prefix))
+  ) {
+    return "unknown";
+  }
+  return matchesIpv6Prefix(groups, {
+    groups: [0x2000],
+    prefixLength: 3,
+  })
+    ? "public"
+    : "unknown";
+}
+
+export function classifyNetworkAddress(
+  address: string
+): DestinationAddressClass {
+  const normalized = stripAddressDecoration(address);
+  const family = isIP(normalized);
+  if (family === 4) {
+    const octets = parseIpv4(normalized);
+    return octets ? classifyIpv4(octets) : "unknown";
+  }
+  if (family === 6) {
+    const groups = parseIpv6(normalized);
+    return groups ? classifyIpv6(groups) : "unknown";
+  }
+  return "unknown";
+}
+
+export function isNetworkAddress(address: string): boolean {
+  return isIP(stripAddressDecoration(address)) !== 0;
+}
+
+function auditFor(
+  source: DestinationClassificationAudit["source"],
+  hostnameKind: DestinationClassificationAudit["hostnameKind"],
+  addressClasses: readonly DestinationAddressClass[],
+  addressCount: number
+): DestinationClassificationAudit {
+  const uniqueClasses = [...new Set(addressClasses)].sort(
+    (left, right) =>
+      (ADDRESS_CLASS_ORDER.get(left) ?? 0) -
+      (ADDRESS_CLASS_ORDER.get(right) ?? 0)
+  );
+  return {
+    source,
+    hostnameKind,
+    addressCount,
+    addressClasses: uniqueClasses,
+    mixed: uniqueClasses.length > 1,
+  };
+}
+
+function classification(
+  zone: EgressDestinationZone,
+  addressClass: DestinationAddressClass,
+  reason: DestinationClassificationReason,
+  audit: DestinationClassificationAudit
+): DestinationClassification {
+  return { zone, addressClass, reason, audit };
+}
+
+function classifyAddressSet(
+  classes: readonly DestinationAddressClass[],
+  audit: DestinationClassificationAudit
+): DestinationClassification {
+  if (classes.length === 0 || classes.includes("unknown")) {
+    return classification("remote", "unknown", "UNPROVEN_REMOTE", audit);
+  }
+  if (classes.every((value) => value === "loopback")) {
+    return classification("loopback", "loopback", "LOOPBACK_ADDRESS", audit);
+  }
+  if (
+    classes.every((value) => value === "private") ||
+    classes.every((value) => value === "tailscale")
+  ) {
+    const addressClass = classes[0] ?? "private";
+    return classification(
+      "lan",
+      addressClass,
+      addressClass === "tailscale" ? "TAILSCALE_ADDRESS" : "PRIVATE_ADDRESS",
+      audit
+    );
+  }
+  if (classes.every((value) => value === "public")) {
+    return classification("remote", "public", "PUBLIC_ADDRESS", audit);
+  }
+  return classification("remote", "unknown", "MIXED_DNS_ANSWERS", audit);
+}
+
+/**
+ * Classify only explicit addresses or supplied DNS answers. Names alone never
+ * prove loopback/LAN membership, and provider identity never relaxes a zone.
+ */
+export function classifyDestination(
+  input: DestinationClassifierInput
+): DestinationClassification {
+  if (input.kind === "local_process") {
+    return classification(
+      "local_process",
+      "loopback",
+      "LOCAL_PROCESS",
+      auditFor("local_process", "none", [], 0)
+    );
+  }
+
+  const hostname = stripAddressDecoration(input.hostname ?? "");
+  const hostnameIsIp = isIP(hostname) !== 0;
+  const hostnameKind = hostnameIsIp
+    ? "ip_literal"
+    : hostname
+      ? "dns_name"
+      : "none";
+  const source =
+    input.kind === "bind"
+      ? "bind"
+      : input.remoteProvider
+        ? "provider"
+        : hostnameIsIp
+          ? "literal"
+          : "dns";
+  const addresses = hostnameIsIp
+    ? [hostname]
+    : input.addresses && input.addresses.length > 0
+      ? input.addresses
+      : [];
+  const classes = addresses.map(classifyNetworkAddress);
+  const audit = auditFor(source, hostnameKind, classes, addresses.length);
+
+  if (input.kind === "bind" && (hostname === "0.0.0.0" || hostname === "::")) {
+    return classification("remote", "unknown", "WILDCARD_BIND", audit);
+  }
+  const addressSet = classifyAddressSet(classes, audit);
+  if (input.remoteProvider && addressSet.addressClass === "public") {
+    return classification("remote", "public", "REMOTE_PROVIDER", audit);
+  }
+  return addressSet;
+}
+
+export function classifyBindDestination(
+  host: string
+): DestinationClassification {
+  return classifyDestination({ kind: "bind", hostname: host });
+}

package/src/core/egress-audit.ts

@@ -0,0 +1,239 @@
+/** Bounded local management service for content-free egress receipts. */
+
+import type {
+  EgressAuditDeleteResult as StoredEgressAuditDeleteResult,
+  EgressAuditPage,
+  EgressAuditPurgeResult,
+  EgressAuditRetentionPolicy,
+  EgressAuditRetentionResult,
+  StorePort,
+  StoreResult,
+} from "../store/types";
+import type { EgressContentClass, EgressDecision } from "./egress-policy";
+import type { EgressLineage } from "./egress-provenance";
+
+import { canonicalTraceJson } from "../store/retrieval-trace-codec";
+import { err, ok } from "../store/types";
+import { defaultEgressPolicyPort } from "./egress-policy";
+import { egressLineageSchema } from "./egress-provenance";
+
+const CURSOR_PREFIX = "gno-egress-audit-v1.";
+const DEFAULT_RETENTION: EgressAuditRetentionPolicy = {
+  maxAgeDays: 30,
+  maxReceipts: 10_000,
+  maxBytes: 4 * 1024 * 1024,
+};
+
+const encodeCursor = (cursor: {
+  createdAtMs: number;
+  auditId: string;
+}): string =>
+  `${CURSOR_PREFIX}${new TextEncoder()
+    .encode(canonicalTraceJson(cursor))
+    .toBase64({ alphabet: "base64url", omitPadding: true })}`;
+
+const decodeCursor = (
+  cursor: string | undefined
+): StoreResult<{ createdAtMs: number; auditId: string } | undefined> => {
+  if (cursor === undefined) return ok(undefined);
+  if (!cursor.startsWith(CURSOR_PREFIX)) {
+    return err("INVALID_INPUT", "Invalid egress audit cursor");
+  }
+  try {
+    const decoded = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(
+        Uint8Array.fromBase64(cursor.slice(CURSOR_PREFIX.length), {
+          alphabet: "base64url",
+        })
+      )
+    ) as Record<string, unknown>;
+    if (
+      Object.keys(decoded).sort().join(",") !== "auditId,createdAtMs" ||
+      typeof decoded.auditId !== "string" ||
+      decoded.auditId.length < 1 ||
+      decoded.auditId.length > 128 ||
+      !Number.isSafeInteger(decoded.createdAtMs) ||
+      (decoded.createdAtMs as number) < 0
+    ) {
+      throw new TypeError("Invalid egress audit cursor");
+    }
+    return ok({
+      createdAtMs: decoded.createdAtMs as number,
+      auditId: decoded.auditId,
+    });
+  } catch {
+    return err("INVALID_INPUT", "Invalid egress audit cursor");
+  }
+};
+
+export interface EgressAuditListResult extends Omit<
+  EgressAuditPage,
+  "nextCursor"
+> {
+  schemaVersion: "1.0";
+  nextCursor: string | null;
+}
+
+export interface EgressAuditStatusResult {
+  schemaVersion: "1.0";
+  retention: EgressAuditRetentionPolicy;
+  receipts: number;
+  bytes: number;
+  oldestCreatedAtMs: number | null;
+  newestCreatedAtMs: number | null;
+}
+
+export interface EgressAuditShowResult {
+  schemaVersion: "1.0";
+  receipt: EgressAuditPage["receipts"][number];
+}
+
+export type EgressAuditDeleteResult = StoredEgressAuditDeleteResult & {
+  schemaVersion: "1.0";
+};
+
+export type EgressAuditPurgeManagementResult = EgressAuditPurgeResult & {
+  schemaVersion: "1.0";
+};
+
+export class EgressAuditService {
+  private readonly clock: () => number;
+  private readonly idFactory: () => string;
+
+  constructor(
+    private readonly store: StorePort,
+    deps: { clock?: () => number; idFactory?: () => string } = {}
+  ) {
+    this.clock = deps.clock ?? Date.now;
+    this.idFactory = deps.idFactory ?? (() => crypto.randomUUID());
+  }
+
+  async record(input: {
+    decision: EgressDecision;
+    lineage: EgressLineage;
+    contentClass: EgressContentClass;
+    retention?: EgressAuditRetentionPolicy;
+  }): Promise<StoreResult<"inserted" | "duplicate">> {
+    const lineage = egressLineageSchema.safeParse(input.lineage);
+    const audit = input.decision.audit;
+    if (
+      !lineage.success ||
+      audit.action === "unknown" ||
+      audit.destinationZone === "unknown" ||
+      audit.contentClass !== input.contentClass ||
+      typeof audit.callerAuthenticated !== "boolean" ||
+      typeof audit.callerOperationAuthorized !== "boolean"
+    ) {
+      return err("INVALID_INPUT", "Invalid egress audit decision metadata");
+    }
+    const expected = defaultEgressPolicyPort.evaluate({
+      collections: lineage.data.sources,
+      action: audit.action,
+      destination: { zone: audit.destinationZone },
+      caller: {
+        authenticated: audit.callerAuthenticated,
+        operationAuthorized: audit.callerOperationAuthorized,
+      },
+      contentClass: input.contentClass,
+    });
+    if (
+      canonicalTraceJson(expected) !== canonicalTraceJson(input.decision) ||
+      audit.collectionCount !== lineage.data.sources.length ||
+      canonicalTraceJson(audit.collections) !==
+        canonicalTraceJson(
+          lineage.data.sources.map(({ collection }) => collection)
+        ) ||
+      audit.effectivePolicy !== lineage.data.effectivePolicy
+    ) {
+      return err(
+        "INVALID_INPUT",
+        "Egress audit decision does not match its policy lineage"
+      );
+    }
+    const retention = input.retention ?? DEFAULT_RETENTION;
+    if (!this.store.appendEgressAuditReceiptWithRetention) {
+      return err(
+        "CONSTRAINT_VIOLATION",
+        "Store cannot atomically persist bounded egress audits"
+      );
+    }
+    const nowMs = this.clock();
+    return this.store.appendEgressAuditReceiptWithRetention(
+      {
+        auditId: this.idFactory(),
+        decision: input.decision.allowed ? "allow" : "deny",
+        action: audit.action,
+        destinationZone: audit.destinationZone,
+        contentClass: input.contentClass,
+        effectivePolicy: lineage.data.effectivePolicy,
+        reasonCode: input.decision.reason,
+        lineageDigest: lineage.data.digest,
+        createdAtMs: nowMs,
+        expiresAtMs: nowMs + retention.maxAgeDays * 86_400_000,
+      },
+      retention,
+      nowMs
+    );
+  }
+
+  async list(
+    input: {
+      limit?: number;
+      cursor?: string;
+    } = {}
+  ): Promise<StoreResult<EgressAuditListResult>> {
+    const cursor = decodeCursor(input.cursor);
+    if (!cursor.ok) return cursor;
+    const page = await this.store.listEgressAuditReceipts(
+      input.limit ?? 100,
+      cursor.value
+    );
+    if (!page.ok) return page;
+    return ok({
+      schemaVersion: "1.0",
+      receipts: page.value.receipts,
+      nextCursor: page.value.nextCursor
+        ? encodeCursor(page.value.nextCursor)
+        : null,
+    });
+  }
+
+  async show(auditId: string): Promise<StoreResult<EgressAuditShowResult>> {
+    const receipt = await this.store.getEgressAuditReceipt(auditId);
+    if (!receipt.ok) return receipt;
+    return receipt.value
+      ? ok({ schemaVersion: "1.0", receipt: receipt.value })
+      : err("NOT_FOUND", "Egress audit receipt not found");
+  }
+
+  async status(): Promise<StoreResult<EgressAuditStatusResult>> {
+    const status = await this.store.getEgressAuditStatus();
+    return status.ok
+      ? ok({
+          schemaVersion: "1.0",
+          retention: { ...DEFAULT_RETENTION },
+          ...status.value,
+        })
+      : status;
+  }
+
+  async delete(auditId: string): Promise<StoreResult<EgressAuditDeleteResult>> {
+    const deleted = await this.store.deleteEgressAuditReceipt(auditId);
+    if (!deleted.ok) return deleted;
+    return deleted.value.deleted === 0
+      ? err("NOT_FOUND", "Egress audit receipt not found")
+      : ok({ schemaVersion: "1.0" as const, ...deleted.value });
+  }
+
+  enforceRetention(
+    policy: EgressAuditRetentionPolicy,
+    nowMs = this.clock()
+  ): Promise<StoreResult<EgressAuditRetentionResult>> {
+    return this.store.enforceEgressAuditRetention(policy, nowMs);
+  }
+
+  async purge(): Promise<StoreResult<EgressAuditPurgeManagementResult>> {
+    const purged = await this.store.purgeEgressAuditReceipts();
+    return purged.ok ? ok({ schemaVersion: "1.0", ...purged.value }) : purged;
+  }
+}

package/src/core/egress-authorization.ts

@@ -0,0 +1,50 @@
+/** Shared current-policy authorization boundary for derived artifacts. */
+
+import type { Collection } from "../config/types";
+import type { StorePort, StoreResult } from "../store/types";
+import type {
+  EgressAction,
+  EgressCallerContext,
+  EgressContentClass,
+  EgressDestinationZone,
+} from "./egress-policy";
+import type { EgressLineage } from "./egress-provenance";
+
+import { err, ok } from "../store/types";
+import { currentEgressSources } from "./collection-egress-policy-service";
+import { EgressAuditService } from "./egress-audit";
+import { evaluateEgressPolicy } from "./egress-policy";
+import { resolveEgressLineage } from "./egress-provenance";
+
+export const authorizeCurrentEgress = async (input: {
+  store: StorePort;
+  config: { collections: readonly Collection[] };
+  lineage: EgressLineage;
+  action: EgressAction;
+  destinationZone: EgressDestinationZone;
+  caller: EgressCallerContext;
+  contentClass: EgressContentClass;
+}): Promise<StoreResult<EgressLineage>> => {
+  const currentLineage = resolveEgressLineage(
+    currentEgressSources(
+      input.config,
+      input.lineage.sources.map(({ collection }) => collection)
+    )
+  );
+  const decision = evaluateEgressPolicy({
+    collections: currentLineage.sources,
+    action: input.action,
+    destination: { zone: input.destinationZone },
+    caller: input.caller,
+    contentClass: input.contentClass,
+  });
+  const recorded = await new EgressAuditService(input.store).record({
+    decision,
+    lineage: currentLineage,
+    contentClass: input.contentClass,
+  });
+  if (!recorded.ok) return recorded;
+  return decision.allowed
+    ? ok(currentLineage)
+    : err("EGRESS_DENIED", "Operation blocked by collection egress policy");
+};