@smthrs/kernel 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/GrantStore.js

@@ -0,0 +1,857 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var GrantStore_exports = {};
+__export(GrantStore_exports, {
+  GrantStore: () => GrantStore,
+  canonicalEnvelopePatterns: () => canonicalEnvelopePatterns,
+  emptyPolicy: () => emptyPolicy,
+  envelopeSignature: () => envelopeSignature,
+  isValidEnvelopePattern: () => isValidEnvelopePattern,
+  isValidGrantPattern: () => isValidGrantPattern,
+  layer: () => layer,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeNoop: () => makeNoop,
+  maximumCapabilityResourceLength: () => maximumCapabilityResourceLength,
+  maximumEnvelopePatterns: () => maximumEnvelopePatterns,
+  maximumEventBytes: () => maximumEventBytes,
+  maximumIdentityLength: () => maximumIdentityLength,
+  maximumMetadataBytes: () => maximumMetadataBytes,
+  maximumMetadataDepth: () => maximumMetadataDepth,
+  maximumMetadataMembers: () => maximumMetadataMembers,
+  maximumPendingRequests: () => maximumPendingRequests,
+  maximumPersistMillis: () => maximumPersistMillis,
+  maximumRules: () => maximumRules
+});
+module.exports = __toCommonJS(GrantStore_exports);
+var import_Capability = require("@smthrs/capability/Capability");
+var import_Permission = require("@smthrs/capability/Permission");
+var import_Sha256 = require("@smthrs/crypto/Sha256");
+var import_effect = require("effect");
+var import_CapabilitySet = require("./CapabilitySet.js");
+var import_GrantEvent = require("./GrantEvent.js");
+var import_Workspace = require("./Workspace.js");
+const emptyPolicy = import_CapabilitySet.current.pipe(
+  import_effect.Effect.map((ceiling) => Object.freeze({ groups: Object.freeze([]), ceiling }))
+);
+class GrantStore extends import_effect.Context.Service()("@smthrs/kernel/GrantStore") {
+}
+const maximumRules = 1024;
+const maximumEnvelopePatterns = 256;
+const maximumPendingRequests = 1024;
+const maximumMetadataDepth = 16;
+const maximumMetadataMembers = 1024;
+const maximumMetadataBytes = 64 * 1024;
+const maximumEventBytes = 256 * 1024;
+const maximumPersistMillis = 3e4;
+const maximumIdentityLength = 4096;
+const maximumCapabilityResourceLength = import_Capability.maxResourceLength;
+const encoder = new TextEncoder();
+const isWellFormed = (value) => {
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) return false;
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) {
+      return false;
+    }
+  }
+  return true;
+};
+const invalid = (message) => new import_Permission.GrantStoreError({ code: "invalid_resolution", message });
+const immutableFields = (value, fields) => {
+  for (const field of fields) {
+    Object.defineProperty(value, field, {
+      value: value[field],
+      enumerable: true,
+      writable: false,
+      configurable: false
+    });
+  }
+  return value;
+};
+const snapshotCapability = (capability) => immutableFields(
+  new import_Capability.Capability({ action: capability.action, resource: capability.resource }),
+  ["action", "resource"]
+);
+const snapshotPattern = (pattern) => immutableFields(
+  new import_Capability.CapabilityPattern({ action: pattern.action, resource: pattern.resource }),
+  ["action", "resource"]
+);
+const snapshotRule = (rule) => immutableFields(
+  new import_Permission.Rule({ effect: rule.effect, pattern: snapshotPattern(rule.pattern) }),
+  ["effect", "pattern"]
+);
+const snapshotFailure = (what, cause) => cause instanceof import_Permission.GrantStoreError ? cause : invalid(`${what} is invalid`);
+const attemptSnapshot = (what, evaluate2) => import_effect.Effect.try({
+  try: evaluate2,
+  catch: (cause) => snapshotFailure(what, cause)
+});
+const metadataSnapshot = (input) => {
+  let members = 0;
+  const active = /* @__PURE__ */ new WeakSet();
+  const visit = (value, depth) => {
+    if (depth > maximumMetadataDepth) throw invalid(`metadata exceeds depth ${maximumMetadataDepth}`);
+    if (value === null || typeof value === "boolean") return value;
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) throw invalid("metadata contains a non-finite number");
+      return value;
+    }
+    if (typeof value === "string") {
+      if (!isWellFormed(value)) throw invalid("metadata contains ill-formed text");
+      if (value.length > maximumMetadataBytes) throw invalid(`metadata exceeds ${maximumMetadataBytes} bytes`);
+      return value;
+    }
+    if (typeof value !== "object" || value === null) throw invalid("metadata must be JSON data");
+    if (active.has(value)) throw invalid("metadata must not contain cycles");
+    active.add(value);
+    try {
+      if (Array.isArray(value)) {
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        const snapshot3 = [];
+        for (let index = 0; index < value.length; index += 1) {
+          members += 1;
+          if (members > maximumMetadataMembers) {
+            throw invalid(`metadata exceeds ${maximumMetadataMembers} members`);
+          }
+          const descriptor = descriptors[String(index)];
+          if (descriptor === void 0 || !("value" in descriptor)) {
+            throw invalid("metadata arrays must be dense data");
+          }
+          snapshot3.push(visit(descriptor.value, depth + 1));
+        }
+        return Object.freeze(snapshot3);
+      }
+      const prototype = Object.getPrototypeOf(value);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw invalid("metadata objects must be plain records");
+      }
+      const snapshot2 = /* @__PURE__ */ Object.create(null);
+      for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        if (!descriptor.enumerable) continue;
+        members += 1;
+        if (members > maximumMetadataMembers) {
+          throw invalid(`metadata exceeds ${maximumMetadataMembers} members`);
+        }
+        if (!isWellFormed(key) || !("value" in descriptor)) {
+          throw invalid("metadata members must be well-formed data properties");
+        }
+        if (descriptor.value !== void 0) snapshot2[key] = visit(descriptor.value, depth + 1);
+      }
+      return Object.freeze(snapshot2);
+    } finally {
+      active.delete(value);
+    }
+  };
+  const snapshot = visit(input, 0);
+  if (Array.isArray(snapshot) || snapshot === null || typeof snapshot !== "object") {
+    throw invalid("metadata must be a record");
+  }
+  const encoded = JSON.stringify(snapshot);
+  if (encoder.encode(encoded).byteLength > maximumMetadataBytes) {
+    throw invalid(`metadata exceeds ${maximumMetadataBytes} bytes`);
+  }
+  return snapshot;
+};
+const validIdentity = (value) => value === void 0 || typeof value === "string" && value.length > 0 && value.length <= maximumIdentityLength && isWellFormed(value) && !value.includes("\0");
+const prepareEnvelope = (input, expectedPlanDigest, workspaceRoot) => attemptSnapshot("grant envelope", () => {
+  if (!Array.isArray(input.patterns)) throw invalid("patterns must be an array");
+  if (input.patterns.length > maximumEnvelopePatterns) {
+    throw invalid(`patterns exceed ${maximumEnvelopePatterns} entries`);
+  }
+  const patterns = canonicalEnvelopePatterns(input.patterns);
+  if (patterns.length === 0) {
+    return { planDigest: expectedPlanDigest ?? "", scope: "run", patterns };
+  }
+  const scope = input.scope ?? "run";
+  if (!isEnvelopeScope(scope)) throw invalid("scope must be run or remembered");
+  if (expectedPlanDigest === void 0) throw invalid("grant envelope requires a configured planDigest");
+  if (!validIdentity(input.planDigest)) throw invalid("planDigest is empty, malformed, or too long");
+  if (input.planDigest !== expectedPlanDigest) throw invalid("planDigest mismatch");
+  for (let index = 0; index < patterns.length; index += 1) {
+    if (!isValidEnvelopePattern(patterns[index], workspaceRoot)) {
+      throw invalid(`patterns[${index}] is outside the workspace envelope`);
+    }
+  }
+  return { planDigest: input.planDigest, scope, patterns };
+});
+const exactPattern = (capability) => new import_Capability.CapabilityPattern({
+  action: capability.action,
+  resource: capability.resource
+});
+const hasResourceWildcard = (resource) => resource.includes("*") || resource.includes("?");
+const isResolution = (value) => value === "once" || value === "run" || value === "remembered" || value === "deny";
+const isEnvelopeScope = (value) => value === "run" || value === "remembered";
+const canonicalEnvelopePatterns = (patterns) => {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const input of patterns) {
+    const pattern = snapshotPattern(input);
+    const identity = (0, import_Capability.format)(pattern);
+    if (!byIdentity.has(identity)) {
+      byIdentity.set(identity, pattern);
+    }
+  }
+  return Object.freeze([...byIdentity.keys()].sort().map((identity) => byIdentity.get(identity)));
+};
+const envelopeEncoding = (planDigest, scope, patterns) => JSON.stringify({ planDigest, scope, patterns: canonicalEnvelopePatterns(patterns).map(import_Capability.format) });
+const envelopeSignature = (planDigest, scope, patterns) => `sha256:${(0, import_Sha256.digestSync)(envelopeEncoding(planDigest, scope, patterns))}`;
+const decodeLegacySignature = import_effect.Schema.decodeUnknownResult(
+  import_effect.Schema.fromJsonString(import_effect.Schema.Struct({
+    planDigest: import_effect.Schema.String,
+    scope: import_effect.Schema.Literals(["run", "remembered"]),
+    patterns: import_effect.Schema.Array(import_effect.Schema.String).check(import_effect.Schema.isMaxLength(maximumEnvelopePatterns))
+  })),
+  { onExcessProperty: "error" }
+);
+const normalizeEnvelopeSignature = (value) => {
+  if (!value.startsWith("{")) return value;
+  if (value.length > maximumEventBytes || encoder.encode(value).byteLength > maximumEventBytes) return value;
+  const decoded = decodeLegacySignature(value);
+  if (decoded._tag === "Failure" || !validIdentity(decoded.success.planDigest)) return value;
+  const { planDigest, scope, patterns } = decoded.success;
+  const parsed = import_effect.Option.all(patterns.map(import_Capability.parsePattern));
+  if (import_effect.Option.isNone(parsed) || envelopeEncoding(planDigest, scope, parsed.value) !== value) return value;
+  return envelopeSignature(planDigest, scope, parsed.value);
+};
+const isValidGrantPattern = (pattern, capability, tier, workspaceRoot) => {
+  if (pattern.action !== capability.action || !(0, import_Capability.matches)(pattern, capability)) {
+    return false;
+  }
+  if (hasResourceWildcard(pattern.resource) && pattern.resource === capability.resource) {
+    return false;
+  }
+  if ((0, import_Capability.tierOf)(capability, { workspaceRoot }) !== tier) {
+    return false;
+  }
+  if (capability.action !== "fs:write") {
+    return true;
+  }
+  if (tier === "irreversible") {
+    return !hasResourceWildcard(pattern.resource);
+  }
+  const workspacePattern = new import_Capability.CapabilityPattern({
+    action: "fs:write",
+    resource: `${workspaceRoot.replace(/[\\/]+$/, "")}/**`
+  });
+  return pattern.resource === workspaceRoot || (0, import_Capability.subsumes)(workspacePattern, pattern);
+};
+const isValidEnvelopePattern = (pattern, workspaceRoot) => {
+  if (pattern.action.includes("*")) {
+    return false;
+  }
+  if (pattern.action !== "fs:write" || !hasResourceWildcard(pattern.resource)) {
+    return true;
+  }
+  const workspacePattern = new import_Capability.CapabilityPattern({
+    action: "fs:write",
+    resource: `${workspaceRoot.replace(/[\\/]+$/, "")}/**`
+  });
+  return (0, import_Capability.subsumes)(workspacePattern, pattern);
+};
+const normalizeRules = (rules) => {
+  if (rules === void 0 || rules.length === 0 || rules[0] === void 0) {
+    return { configured: [], remembered: [] };
+  }
+  if (rules.length > maximumRules) throw invalid(`rules exceed ${maximumRules} entries`);
+  if (Array.isArray(rules[0])) {
+    const rulesets = rules;
+    let count = 0;
+    for (const ruleset of rulesets) {
+      count += ruleset.length;
+      if (count > maximumRules) throw invalid(`rules exceed ${maximumRules} entries`);
+    }
+    return {
+      configured: Object.freeze(rulesets[0].map(snapshotRule)),
+      remembered: Object.freeze(rulesets.slice(1).flatMap((ruleset) => ruleset.map(snapshotRule)))
+    };
+  }
+  return {
+    configured: Object.freeze(rules.map(snapshotRule)),
+    remembered: []
+  };
+};
+const make = (options = {}) => import_effect.Effect.gen(function* () {
+  const attended = options.attended ?? true;
+  const runId = options.runId;
+  const planDigest = options.planDigest;
+  if (!validIdentity(runId)) {
+    return yield* import_effect.Effect.fail(invalid("runId is empty, malformed, or too long"));
+  }
+  if (!validIdentity(planDigest)) {
+    return yield* import_effect.Effect.fail(invalid("planDigest is empty, malformed, or too long"));
+  }
+  const workspace = yield* import_Workspace.Workspace;
+  const initialCeiling = yield* import_CapabilitySet.current;
+  const workspaceRoot = workspace.root;
+  const initial = yield* attemptSnapshot("rules", () => normalizeRules(options.rules));
+  const initialRunRules = yield* attemptSnapshot("runRules", () => {
+    const values = options.runRules ?? [];
+    if (values.length > maximumRules) throw invalid(`runRules exceed ${maximumRules} entries`);
+    return values.map(
+      (value) => "rule" in value ? {
+        rule: snapshotRule(value.rule),
+        ceiling: value.ceiling.reduce(
+          (ceiling, group) => (0, import_CapabilitySet.intersect)(ceiling, (0, import_CapabilitySet.fromPatterns)(group)),
+          initialCeiling
+        )
+      } : { rule: snapshotRule(value), ceiling: initialCeiling }
+    );
+  });
+  if (initial.configured.length + initial.remembered.length + initialRunRules.length > maximumRules) {
+    return yield* import_effect.Effect.fail(invalid(`rules exceed ${maximumRules} entries`));
+  }
+  const configuredRules = initial.configured;
+  const envelopeRules = [];
+  const runRules = initialRunRules;
+  const rememberedRules = [...initial.remembered];
+  const pending = /* @__PURE__ */ new Map();
+  const persist = options.persist ?? (() => import_effect.Effect.void);
+  const signatures = yield* attemptSnapshot("envelopeSignatures", () => {
+    const values = options.envelopeSignatures ?? [];
+    if (!Array.isArray(values) || values.length > maximumRules) {
+      throw invalid(`envelopeSignatures exceed ${maximumRules} entries`);
+    }
+    return values.map((value, index) => {
+      const signature = typeof value === "string" ? normalizeEnvelopeSignature(value) : value;
+      if (typeof signature !== "string" || !validIdentity(signature)) {
+        throw invalid(`envelopeSignatures[${index}] is malformed or too long`);
+      }
+      return signature;
+    });
+  });
+  const grantedEnvelopes = new Set(signatures);
+  let nextRequestId = 1;
+  let closed = false;
+  const mutation = yield* import_effect.Semaphore.make(1);
+  const persistEvent = (event) => {
+    const bytes = encoder.encode(JSON.stringify(event)).byteLength;
+    return bytes > maximumEventBytes ? import_effect.Effect.fail(invalid(`grant event exceeds ${maximumEventBytes} bytes`)) : import_effect.Effect.timeoutOrElse(persist(event), {
+      duration: maximumPersistMillis,
+      orElse: () => import_effect.Effect.fail(
+        new import_Permission.GrantStoreError({
+          code: "journal_failed",
+          message: `grant journal write exceeded ${maximumPersistMillis}ms`
+        })
+      )
+    });
+  };
+  const invalidRemembered = rememberedRules.findIndex(
+    (rule) => rule.effect === "allow" && !isValidEnvelopePattern(rule.pattern, workspaceRoot)
+  );
+  if (invalidRemembered !== -1) {
+    return yield* import_effect.Effect.fail(invalid(`rememberedRules[${invalidRemembered}] is outside the workspace envelope`));
+  }
+  const invalidRun = runRules.findIndex(
+    ({ rule }) => rule.effect === "allow" && !isValidEnvelopePattern(rule.pattern, workspaceRoot)
+  );
+  if (invalidRun !== -1) {
+    return yield* import_effect.Effect.fail(invalid(`runRules[${invalidRun}] is outside the workspace envelope`));
+  }
+  const admitEnvelope = (envelope) => import_effect.Effect.gen(function* () {
+    const { patterns, scope } = envelope;
+    if (patterns.length === 0) return false;
+    const signature = envelopeSignature(envelope.planDigest, scope, patterns);
+    const durable = grantedEnvelopes.has(signature);
+    const destination = scope === "remembered" ? rememberedRules : envelopeRules;
+    const replayed = scope === "remembered" ? rememberedRules : runRules.filter(({ ceiling }) => ceiling === initialCeiling).map(({ rule }) => rule);
+    const existing = /* @__PURE__ */ new Set();
+    for (const rule of replayed) {
+      if (rule.effect === "allow") existing.add((0, import_Capability.format)(rule.pattern));
+      else existing.clear();
+    }
+    const incoming = durable ? patterns.filter((pattern) => !existing.has((0, import_Capability.format)(pattern))) : patterns;
+    if (configuredRules.length + envelopeRules.length + runRules.length + rememberedRules.length + incoming.length > maximumRules) {
+      return yield* import_effect.Effect.fail(invalid(`rules exceed ${maximumRules} entries`));
+    }
+    if (!durable && grantedEnvelopes.size >= maximumRules) {
+      return yield* import_effect.Effect.fail(invalid(`grant envelopes exceed ${maximumRules} entries`));
+    }
+    if (!durable) {
+      yield* persistEvent(
+        new import_GrantEvent.EnvelopeGrant({
+          eventType: "flows.kernel.grant.envelope.v1",
+          runId: runId ?? "",
+          planDigest: envelope.planDigest,
+          patterns,
+          scope
+        })
+      );
+      grantedEnvelopes.add(signature);
+    }
+    for (const pattern of incoming) {
+      destination.push(snapshotRule(new import_Permission.Rule({ effect: "allow", pattern })));
+    }
+    return true;
+  });
+  if (options.envelope !== void 0) {
+    const envelope = yield* prepareEnvelope(options.envelope, planDigest, workspaceRoot);
+    yield* admitEnvelope(envelope);
+  }
+  const rulesets = (capability) => [
+    configuredRules,
+    envelopeRules,
+    runRules.filter(({ ceiling }) => (0, import_CapabilitySet.allows)(ceiling, capability)).map(({ rule }) => rule),
+    rememberedRules
+  ];
+  yield* import_effect.Effect.addFinalizer(
+    () => mutation.withPermit(
+      import_effect.Effect.gen(function* () {
+        closed = true;
+        const entries = [...pending.values()];
+        pending.clear();
+        yield* import_effect.Effect.forEach(
+          entries,
+          (entry) => import_effect.Deferred.fail(
+            entry.deferred,
+            (0, import_Permission.permissionDenied)(entry.capability, "grant store closed")
+          ),
+          { discard: true }
+        );
+      })
+    )
+  );
+  const allocateRequest = (capability, tier, meta, ceiling) => import_effect.Effect.gen(function* () {
+    if (pending.size >= maximumPendingRequests) {
+      return yield* import_effect.Effect.fail(invalid(`pending requests exceed ${maximumPendingRequests} entries`));
+    }
+    const requestId = `permission-${nextRequestId++}`;
+    const deferred = yield* import_effect.Deferred.make();
+    const entry = {
+      requestId,
+      capability,
+      tier,
+      meta,
+      ceiling,
+      deferred
+    };
+    pending.set(requestId, entry);
+    return entry;
+  });
+  const nextUnattendedRequestId = import_effect.Effect.sync(() => `permission-${nextRequestId++}`);
+  const check = import_effect.Effect.fn("GrantStore.check")(
+    (capability, meta = {}) => import_effect.Effect.uninterruptibleMask(
+      (restore) => import_effect.Effect.gen(function* () {
+        const request = yield* attemptSnapshot("permission request", () => ({
+          capability: snapshotCapability(capability),
+          meta: metadataSnapshot(meta)
+        }));
+        const entry = yield* restore(mutation.take(1)).pipe(
+          import_effect.Effect.andThen(
+            import_effect.Effect.gen(function* () {
+              if (closed) {
+                return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "store_closed" }));
+              }
+              const ceiling = yield* import_CapabilitySet.current;
+              if (!(0, import_CapabilitySet.allows)(ceiling, request.capability)) {
+                return yield* import_effect.Effect.fail((0, import_Permission.permissionDenied)(request.capability, "outside capability ceiling"));
+              }
+              const decision = (0, import_Permission.evaluate)(rulesets(request.capability), request.capability);
+              if (decision === "allow") {
+                return void 0;
+              }
+              if (decision === "deny") {
+                return yield* import_effect.Effect.fail((0, import_Permission.permissionDenied)(request.capability, "denied by permission policy"));
+              }
+              const tier = (0, import_Capability.tierOf)(request.capability, { workspaceRoot });
+              if (!attended) {
+                const requestId = yield* nextUnattendedRequestId;
+                return yield* import_effect.Effect.fail(
+                  (0, import_Permission.permissionRequired)({
+                    requestId,
+                    runId,
+                    capability: request.capability,
+                    tier,
+                    meta: request.meta
+                  })
+                );
+              }
+              return yield* allocateRequest(
+                request.capability,
+                tier,
+                request.meta,
+                ceiling
+              );
+            }).pipe(import_effect.Effect.ensuring(mutation.release(1)))
+          )
+        );
+        if (entry === void 0) {
+          return;
+        }
+        return yield* restore(import_effect.Deferred.await(entry.deferred)).pipe(
+          import_effect.Effect.ensuring(
+            mutation.withPermit(
+              import_effect.Effect.sync(() => {
+                pending.delete(entry.requestId);
+              })
+            )
+          )
+        );
+      })
+    )
+  );
+  const resolveCovered = import_effect.Effect.suspend(
+    () => import_effect.Effect.forEach(
+      [...pending.entries()],
+      ([requestId, entry]) => {
+        if (!(0, import_CapabilitySet.allows)(entry.ceiling, entry.capability) || (0, import_Permission.evaluate)(rulesets(entry.capability), entry.capability) !== "allow") {
+          return import_effect.Effect.void;
+        }
+        return import_effect.Deferred.succeed(entry.deferred, void 0).pipe(
+          import_effect.Effect.andThen(
+            import_effect.Effect.sync(() => {
+              pending.delete(requestId);
+            })
+          )
+        );
+      },
+      { discard: true }
+    ).pipe(import_effect.Effect.asVoid)
+  );
+  const resolving = /* @__PURE__ */ new Set();
+  const granting = /* @__PURE__ */ new Map();
+  let reservedRules = 0;
+  const planReply = (requestId, resolution, suppliedPattern) => import_effect.Effect.gen(function* () {
+    if (closed) {
+      return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "store_closed" }));
+    }
+    if (!isResolution(resolution)) {
+      return yield* import_effect.Effect.fail(
+        new import_Permission.GrantStoreError({
+          code: "invalid_resolution",
+          message: "unknown grant resolution"
+        })
+      );
+    }
+    const entry = pending.get(requestId);
+    if (entry === void 0 || resolving.has(requestId)) {
+      return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "request_not_found" }));
+    }
+    const pattern = yield* attemptSnapshot("grant pattern", () => {
+      if (resolution === "run" || resolution === "remembered") {
+        if (suppliedPattern !== void 0) return snapshotPattern(suppliedPattern);
+        const derived = (0, import_Capability.patternFromCapability)(entry.capability);
+        if (import_effect.Option.isNone(derived)) {
+          throw invalid(
+            "the requested resource contains glob metacharacters; supply an explicit grant pattern or resolve once"
+          );
+        }
+        return snapshotPattern(derived.value);
+      }
+      return snapshotPattern(exactPattern(entry.capability));
+    });
+    switch (resolution) {
+      case "once": {
+        resolving.add(requestId);
+        return {
+          resolution,
+          entry,
+          event: new import_GrantEvent.OnceGrant({
+            eventType: "flows.kernel.grant.once.v1",
+            requestId,
+            runId: runId ?? "",
+            ...planDigest === void 0 ? {} : { planDigest },
+            capability: entry.capability,
+            pattern,
+            scope: "once",
+            tier: entry.tier
+          })
+        };
+      }
+      case "run": {
+        if (planDigest === void 0) {
+          return yield* import_effect.Effect.fail(
+            new import_Permission.GrantStoreError({
+              code: "invalid_resolution",
+              message: "run grants require a plan digest"
+            })
+          );
+        }
+        if (!isValidGrantPattern(pattern, entry.capability, entry.tier, workspaceRoot)) {
+          return yield* import_effect.Effect.fail(invalid("grant pattern exceeds the requested authority"));
+        }
+        if (configuredRules.length + envelopeRules.length + runRules.length + rememberedRules.length + reservedRules >= maximumRules) {
+          return yield* import_effect.Effect.fail(invalid(`rules exceed ${maximumRules} entries`));
+        }
+        resolving.add(requestId);
+        reservedRules += 1;
+        return {
+          resolution,
+          entry,
+          rule: snapshotRule(new import_Permission.Rule({ effect: "allow", pattern })),
+          event: new import_GrantEvent.RunGrant({
+            eventType: "flows.kernel.grant.run.v2",
+            requestId,
+            runId: runId ?? "",
+            planDigest,
+            capability: entry.capability,
+            pattern,
+            ceiling: entry.ceiling.groups,
+            scope: "run",
+            tier: entry.tier
+          })
+        };
+      }
+      case "remembered": {
+        if (!isValidGrantPattern(pattern, entry.capability, entry.tier, workspaceRoot)) {
+          return yield* import_effect.Effect.fail(invalid("grant pattern exceeds the requested authority"));
+        }
+        if (configuredRules.length + envelopeRules.length + runRules.length + rememberedRules.length + reservedRules >= maximumRules) {
+          return yield* import_effect.Effect.fail(invalid(`rules exceed ${maximumRules} entries`));
+        }
+        resolving.add(requestId);
+        reservedRules += 1;
+        return {
+          resolution,
+          entry,
+          rule: snapshotRule(new import_Permission.Rule({ effect: "allow", pattern })),
+          event: new import_GrantEvent.RememberedGrant({
+            eventType: "flows.kernel.grant.remembered.v1",
+            requestId,
+            runId: runId ?? "",
+            ...planDigest === void 0 ? {} : { planDigest },
+            capability: entry.capability,
+            pattern,
+            scope: "remembered",
+            tier: entry.tier
+          })
+        };
+      }
+      case "deny": {
+        resolving.add(requestId);
+        return {
+          resolution,
+          entry,
+          event: new import_GrantEvent.DeniedGrant({
+            eventType: "flows.kernel.grant.denied.v1",
+            requestId,
+            runId: runId ?? "",
+            ...planDigest === void 0 ? {} : { planDigest },
+            capability: entry.capability,
+            pattern,
+            scope: "once",
+            tier: entry.tier
+          })
+        };
+      }
+    }
+  });
+  const activateReply = (requestId, planned) => import_effect.Effect.gen(function* () {
+    resolving.delete(requestId);
+    if (planned.resolution === "run" || planned.resolution === "remembered") reservedRules -= 1;
+    if (closed) {
+      return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "store_closed" }));
+    }
+    const entry = pending.get(requestId);
+    switch (planned.resolution) {
+      case "once": {
+        if (entry === void 0) {
+          return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "request_not_found" }));
+        }
+        yield* import_effect.Deferred.succeed(entry.deferred, void 0);
+        pending.delete(requestId);
+        return;
+      }
+      case "deny": {
+        if (entry === void 0) {
+          return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "request_not_found" }));
+        }
+        yield* import_effect.Deferred.fail(
+          entry.deferred,
+          (0, import_Permission.permissionDenied)(entry.capability, "permission request denied")
+        );
+        pending.delete(requestId);
+        return;
+      }
+      case "run": {
+        runRules.push({ rule: planned.rule, ceiling: planned.entry.ceiling });
+        yield* resolveCovered;
+        return;
+      }
+      case "remembered": {
+        rememberedRules.push(planned.rule);
+        yield* resolveCovered;
+        return;
+      }
+    }
+  });
+  const reply = import_effect.Effect.fn("GrantStore.reply")(
+    (requestId, resolution, suppliedPattern) => import_effect.Effect.uninterruptibleMask(
+      (restore) => import_effect.Effect.gen(function* () {
+        const planned = yield* mutation.withPermit(planReply(requestId, resolution, suppliedPattern));
+        yield* restore(persistEvent(planned.event)).pipe(
+          import_effect.Effect.onError(
+            () => mutation.withPermit(
+              import_effect.Effect.sync(() => {
+                resolving.delete(requestId);
+                if (planned.resolution === "run" || planned.resolution === "remembered") reservedRules -= 1;
+              })
+            )
+          )
+        );
+        yield* mutation.withPermit(activateReply(requestId, planned));
+      })
+    )
+  );
+  const list = import_effect.Effect.fn("GrantStore.list")(
+    () => mutation.withPermit(
+      import_effect.Effect.sync(
+        () => (
+          // Every entry's meta is already the frozen snapshot taken at check
+          // time; list copies the array and re-wraps identity without
+          // re-walking or re-serializing the metadata graph.
+          Object.freeze(Array.from(
+            pending.values(),
+            ({ requestId, capability, tier, meta }) => Object.freeze({
+              requestId,
+              capability: snapshotCapability(capability),
+              tier,
+              meta
+            })
+          ))
+        )
+      )
+    )
+  )();
+  const planEnvelope = (envelope) => import_effect.Effect.gen(function* () {
+    if (closed) {
+      return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "store_closed" }));
+    }
+    const { patterns, scope } = envelope;
+    const signature = envelopeSignature(envelope.planDigest, scope, patterns);
+    if (grantedEnvelopes.has(signature)) return { _tag: "Durable" };
+    const inFlight = granting.get(signature);
+    if (inFlight !== void 0) return { _tag: "Wait", completion: inFlight };
+    if (configuredRules.length + envelopeRules.length + runRules.length + rememberedRules.length + reservedRules + patterns.length > maximumRules) {
+      return yield* import_effect.Effect.fail(invalid(`rules exceed ${maximumRules} entries`));
+    }
+    if (grantedEnvelopes.size + granting.size >= maximumRules) {
+      return yield* import_effect.Effect.fail(invalid(`grant envelopes exceed ${maximumRules} entries`));
+    }
+    const completion = yield* import_effect.Deferred.make();
+    granting.set(signature, completion);
+    reservedRules += patterns.length;
+    return {
+      _tag: "Fresh",
+      signature,
+      scope,
+      patterns,
+      completion,
+      event: new import_GrantEvent.EnvelopeGrant({
+        eventType: "flows.kernel.grant.envelope.v1",
+        runId: runId ?? "",
+        planDigest: envelope.planDigest,
+        patterns,
+        scope
+      })
+    };
+  });
+  const activateEnvelope = (planned) => import_effect.Effect.gen(function* () {
+    granting.delete(planned.signature);
+    reservedRules -= planned.patterns.length;
+    if (closed) {
+      return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "store_closed" }));
+    }
+    grantedEnvelopes.add(planned.signature);
+    const destination = planned.scope === "remembered" ? rememberedRules : envelopeRules;
+    for (const pattern of planned.patterns) {
+      destination.push(snapshotRule(new import_Permission.Rule({ effect: "allow", pattern })));
+    }
+    yield* resolveCovered;
+  });
+  const grantEnvelope = import_effect.Effect.fn("GrantStore.grantEnvelope")(
+    (input) => import_effect.Effect.uninterruptibleMask((restore) => {
+      const admit = (prepared) => import_effect.Effect.gen(function* () {
+        const planned = yield* mutation.withPermit(planEnvelope(prepared));
+        switch (planned._tag) {
+          case "Durable":
+            return;
+          case "Wait": {
+            return yield* restore(import_effect.Deferred.await(planned.completion)).pipe(
+              import_effect.Effect.catchCause(
+                (cause) => import_effect.Cause.hasInterruptsOnly(cause) ? restore(import_effect.Effect.void).pipe(import_effect.Effect.andThen(admit(prepared))) : import_effect.Effect.failCause(cause)
+              )
+            );
+          }
+          case "Fresh": {
+            yield* restore(persistEvent(planned.event)).pipe(
+              import_effect.Effect.onError(
+                (cause) => mutation.withPermit(
+                  import_effect.Effect.gen(function* () {
+                    granting.delete(planned.signature);
+                    reservedRules -= planned.patterns.length;
+                    yield* import_effect.Deferred.failCause(planned.completion, cause);
+                  })
+                )
+              )
+            );
+            yield* mutation.withPermit(activateEnvelope(planned)).pipe(
+              import_effect.Effect.tap(() => import_effect.Deferred.succeed(planned.completion, void 0)),
+              import_effect.Effect.onError((cause) => import_effect.Deferred.failCause(planned.completion, cause))
+            );
+            return;
+          }
+        }
+      });
+      return import_effect.Effect.gen(function* () {
+        const prepared = yield* prepareEnvelope(input, planDigest, workspaceRoot);
+        if (prepared.patterns.length === 0) return;
+        yield* admit(prepared);
+      });
+    })
+  );
+  const policy = mutation.withPermit(import_effect.Effect.gen(function* () {
+    if (closed) return yield* import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "store_closed" }));
+    const ceiling = yield* import_CapabilitySet.current;
+    const unbounded = (rules) => rules.map(
+      (rule) => Object.freeze({ rule: snapshotRule(rule), ceiling: Object.freeze({ groups: Object.freeze([]) }) })
+    );
+    return Object.freeze({
+      ceiling,
+      groups: Object.freeze([
+        unbounded(configuredRules),
+        unbounded(envelopeRules),
+        runRules.map(({ rule, ceiling: ceiling2 }) => Object.freeze({ rule: snapshotRule(rule), ceiling: ceiling2 })),
+        unbounded(rememberedRules)
+      ].map((group) => Object.freeze(group)))
+    });
+  }));
+  return GrantStore.of({ check, reply, list, grantEnvelope, policy });
+});
+const layer = (options = {}) => import_effect.Layer.effect(GrantStore, make(options));
+const makeNoop = GrantStore.of({
+  policy: import_CapabilitySet.current.pipe(import_effect.Effect.map(
+    (ceiling) => Object.freeze({
+      ceiling,
+      groups: Object.freeze([Object.freeze(["*", "net:private"].map(
+        (action) => Object.freeze({
+          rule: snapshotRule(new import_Permission.Rule({ effect: "allow", pattern: new import_Capability.CapabilityPattern({ action, resource: "**" }) })),
+          ceiling: Object.freeze({ groups: Object.freeze([]) })
+        })
+      ))])
+    })
+  )),
+  check: import_effect.Effect.fn("GrantStore.check")(() => import_effect.Effect.void),
+  reply: import_effect.Effect.fn("GrantStore.reply")(() => import_effect.Effect.void),
+  list: import_effect.Effect.fn("GrantStore.list")(() => import_effect.Effect.succeed([]))(),
+  grantEnvelope: import_effect.Effect.fn("GrantStore.grantEnvelope")(() => import_effect.Effect.void)
+});
+const layerNoop = import_effect.Layer.succeed(GrantStore)(makeNoop);
+//# sourceMappingURL=GrantStore.js.map