@felspar/sdk 0.1.1 → 0.2.1

package/dist/chunks/chunk-Y6KRRIQI.js

@@ -0,0 +1,908 @@
+import {
+  createHostedFelsparClient
+} from "./chunk-XLKRU5RA.js";
+
+// src/draft-action-gate-outputs.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parsedJson(text2) {
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return null;
+  }
+}
+function replyOf(output) {
+  let value = output;
+  for (let depth = 0; depth < 5; depth += 1) {
+    if (typeof value === "string") {
+      value = parsedJson(value);
+    } else if (Array.isArray(value)) {
+      value = value.find((part) => isRecord(part) && part.type === "text");
+    } else if (!isRecord(value) || value.isError === true) {
+      return null;
+    } else if (typeof value.checkId === "string") {
+      return value;
+    } else if (isRecord(value.structuredContent)) {
+      value = value.structuredContent;
+    } else {
+      value = Array.isArray(value.content) ? value.content : value.text;
+    }
+  }
+  return null;
+}
+var text = (value) => typeof value === "string" ? value : null;
+function outputCheckFromResult(jobId, output) {
+  const reply = replyOf(output);
+  const receipt = isRecord(reply?.receipt) ? reply.receipt : null;
+  const decision = isRecord(reply?.decision) ? reply.decision : null;
+  const fields = {
+    checkId: text(reply?.checkId),
+    output: text(reply?.output),
+    decisionReceiptDigest: text(decision?.receiptDigest),
+    artifactDigest: text(receipt?.artifactDigest),
+    receiptDigest: text(receipt?.receiptDigest)
+  };
+  if (reply?.status !== "pass" || Object.values(fields).includes(null)) {
+    return null;
+  }
+  return {
+    checkId: fields.checkId ?? "",
+    jobId,
+    output: fields.output ?? "",
+    status: "pass",
+    decisionReceiptDigest: fields.decisionReceiptDigest ?? "",
+    artifactDigest: fields.artifactDigest ?? "",
+    receiptDigest: fields.receiptDigest ?? ""
+  };
+}
+async function outputTextDigest(value) {
+  const encoder = new TextEncoder();
+  const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(value)));
+  return `sha256:${Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function checkedText(rule, input) {
+  const wanted = new Set(rule.fields.map((field) => field.toLowerCase()));
+  const values = Object.entries(input).filter(([field]) => wanted.has(field.toLowerCase())).map(([, value]) => value);
+  const [only] = values;
+  return typeof only === "string" && values.length === 1 ? only : null;
+}
+async function outputCheckProblem(rule, call) {
+  const value = checkedText(rule, call.input);
+  if (value === null) {
+    return `the call must set exactly one text field of ${rule.fields.join(", ")}`;
+  }
+  const digest = await outputTextDigest(value);
+  let check;
+  for (const row of call.checks) {
+    const isOutput = rule.output === void 0 || row.output === rule.output;
+    const isText2 = row.artifactDigest === digest;
+    const isDecision = row.decisionReceiptDigest === call.decisionReceiptDigest;
+    const isPass = row.status === "pass";
+    if (isPass && isText2 && isDecision && isOutput) {
+      check = row;
+    }
+  }
+  if (check === void 0) {
+    return "Felspar has not passed this exact text for this decision; call check_output first";
+  }
+  if (call.verify === void 0) {
+    return "no output-check verifier is configured";
+  }
+  const confirmed = await call.verify(check);
+  const isConfirmed = confirmed?.status === "pass" && confirmed.receiptDigest === check.receiptDigest && confirmed.artifactDigest === check.artifactDigest && confirmed.decisionReceiptDigest === check.decisionReceiptDigest;
+  return isConfirmed ? null : "Felspar did not confirm the output check";
+}
+function felsparOutputCheckVerifier(configuration) {
+  let client;
+  return async (check) => {
+    client ??= createHostedFelsparClient(configuration);
+    const kept = await client.readOutputCheck(check.jobId, check.checkId);
+    return {
+      status: kept.status,
+      receiptDigest: kept.receipt?.receiptDigest ?? null,
+      artifactDigest: kept.receipt?.artifactDigest ?? null,
+      decisionReceiptDigest: kept.decision.receiptDigest
+    };
+  };
+}
+
+// src/draft-action-gate-decisions.ts
+var identityModes = ["provided", "fields", "content", "issued"];
+var escalationTriggers = ["outcome", "unresolved", "attempt_limit"];
+var isIdentityMode = (value) => identityModes.includes(value);
+var isEscalationTrigger = (value) => escalationTriggers.includes(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parsedJson2(text2) {
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return null;
+  }
+}
+function innerValue(value) {
+  if (typeof value === "string") {
+    return parsedJson2(value);
+  }
+  if (Array.isArray(value)) {
+    return value.find((part) => isRecord2(part) && part.type === "text") ?? null;
+  }
+  if (!isRecord2(value)) {
+    return void 0;
+  }
+  if (value.isError === true) {
+    return null;
+  }
+  if (isRecord2(value.structuredContent)) {
+    return value.structuredContent;
+  }
+  if (Array.isArray(value.content)) {
+    return value.content;
+  }
+  return value.type === "text" && typeof value.text === "string" ? value.text : void 0;
+}
+function jobResponse(output) {
+  let value = output;
+  for (let depth = 0; depth < 5; depth += 1) {
+    const inner = innerValue(value);
+    if (inner === void 0) {
+      return isRecord2(value) && isRecord2(value.result) ? value : null;
+    }
+    value = inner;
+  }
+  return null;
+}
+function jobOf(input) {
+  return isRecord2(input) && typeof input.job === "string" ? input.job : void 0;
+}
+function entityIdOf(input) {
+  return isRecord2(input) && typeof input.entity_id === "string" ? input.entity_id : void 0;
+}
+function freshnessOf(explanation) {
+  return isRecord2(explanation) && typeof explanation.evidenceFreshUntil === "string" ? explanation.evidenceFreshUntil : null;
+}
+var isId = (value) => typeof value === "string" && value.length > 0 && value.length <= 200;
+function caseOf(result) {
+  if (!Object.hasOwn(result, "case")) {
+    return void 0;
+  }
+  const found = result.case;
+  return isRecord2(found) && isId(found.id) && isIdentityMode(found.mode) ? { id: found.id, mode: found.mode } : null;
+}
+function escalationOf(result) {
+  const found = result.escalation;
+  if (!isRecord2(found) || !isId(found.id) || !isEscalationTrigger(found.trigger)) {
+    return void 0;
+  }
+  const why = isRecord2(found.why) && typeof found.why.text === "string" ? found.why.text : "";
+  return { id: found.id, trigger: found.trigger, why };
+}
+var requestOf = (request) => typeof request === "string" ? { entity: request } : request;
+function decidedOf(result) {
+  const { receipt, outcome, executionObjectId } = result;
+  if (typeof outcome !== "string" || typeof executionObjectId !== "string" || !isRecord2(receipt)) {
+    return null;
+  }
+  const { receiptDigest } = receipt;
+  return typeof receiptDigest === "string" ? { outcome, executionObjectId, receipt: { ...receipt, receiptDigest } } : null;
+}
+function decisionFromResult(request, output) {
+  const result = jobResponse(output)?.result;
+  if (!isRecord2(result)) {
+    return null;
+  }
+  const { entity, job } = requestOf(request);
+  const found = caseOf(result);
+  const key = found === void 0 ? entity : found?.id;
+  const decided = decidedOf(result);
+  if (decided === null || found === null || key === void 0 || key.length === 0) {
+    return null;
+  }
+  const escalation = escalationOf(result);
+  return {
+    entity: key,
+    ...found !== void 0 && { case: found },
+    ...job !== void 0 && { job },
+    ...isId(result.releaseId) && { releaseId: result.releaseId },
+    ...escalation !== void 0 && { escalation },
+    ...decided,
+    context: result.context ?? null,
+    evidenceFreshUntil: freshnessOf(result.explanation)
+  };
+}
+function trim(map, limit) {
+  for (const key of map.keys()) {
+    if (map.size <= limit) {
+      return;
+    }
+    map.delete(key);
+  }
+}
+function createDecisionRecorder(limits = {}) {
+  const maxSessions = limits.sessions ?? 1e3;
+  const maxDecisions = limits.decisionsPerSession ?? 200;
+  const maxPending = limits.pendingRequests ?? 1e3;
+  const requested = /* @__PURE__ */ new Map();
+  const decided = /* @__PURE__ */ new Map();
+  const checked = /* @__PURE__ */ new Map();
+  function record(sessionId, request, output) {
+    const decision = decisionFromResult(request, output);
+    if (decision === null) {
+      return null;
+    }
+    const rows = [...decided.get(sessionId) ?? [], decision].slice(-maxDecisions);
+    decided.delete(sessionId);
+    decided.set(sessionId, rows);
+    trim(decided, maxSessions);
+    return decision;
+  }
+  return {
+    record,
+    noteRequest(callId, request) {
+      requested.set(callId, request);
+      trim(requested, maxPending);
+    },
+    noteResult(sessionId, callId, output) {
+      const noted = requested.get(callId);
+      requested.delete(callId);
+      return noted === void 0 ? null : record(sessionId, noted, output);
+    },
+    decisionsIn: (sessionId) => decided.get(sessionId) ?? [],
+    recordOutputCheck(sessionId, jobId, output) {
+      const check = outputCheckFromResult(jobId, output);
+      if (check === null) {
+        return null;
+      }
+      const rows = [...checked.get(sessionId) ?? [], check].slice(-maxDecisions);
+      checked.delete(sessionId);
+      checked.set(sessionId, rows);
+      trim(checked, maxSessions);
+      return check;
+    },
+    outputChecksIn: (sessionId) => checked.get(sessionId) ?? [],
+    forget(sessionId) {
+      decided.delete(sessionId);
+      checked.delete(sessionId);
+    }
+  };
+}
+
+// src/draft-action-gate-describe.ts
+function felsparJobDescriber(configuration) {
+  let client;
+  return async (releaseId, jobId) => {
+    client ??= createHostedFelsparClient(configuration);
+    return await client.describeJob(releaseId, jobId);
+  };
+}
+async function describedFor(describe, releaseId, jobId) {
+  const description = await describe(releaseId, jobId);
+  if (description.job !== jobId || description.release.releaseId !== releaseId) {
+    throw new Error("Felspar described a different release or job");
+  }
+  return description;
+}
+function outcomeIn(description, outcome) {
+  const matches = description.outcomes.filter((row) => row.id === outcome);
+  return matches.length === 1 ? matches[0] : void 0;
+}
+async function writesProblem(describe, decided) {
+  if (describe === void 0) {
+    return "no job describer is configured";
+  }
+  if (decided.releaseId === void 0) {
+    return "Felspar's replay names no release";
+  }
+  let description;
+  try {
+    description = await describedFor(describe, decided.releaseId, decided.jobId);
+  } catch (error) {
+    return `Felspar's job description could not be read: ${String(error)}`;
+  }
+  const outputs = outcomeIn(description, decided.outcome)?.outputs ?? [];
+  return outputs.some((row) => row.id === decided.output) ? null : `${decided.outcome} doesn't ask for ${decided.output}`;
+}
+async function subjectOf(describe, releaseId, jobId) {
+  const { subject, identity } = await describedFor(describe, releaseId, jobId);
+  return subject === void 0 ? null : { type: subject.type, match: subject.match, mode: identity?.mode ?? "provided" };
+}
+var fixOutputCheck = "Fix what check_output flagged, check it again, then retry.";
+var quotedText = (quoted) => typeof quoted?.text === "string" && quoted.text.length > 0 ? quoted.text : null;
+function escalationIdOf(step, description) {
+  if (step.kind === "unresolved") {
+    const id2 = description?.escalations?.unresolved ?? null;
+    return id2 === null ? null : { id: id2, trigger: "unresolved" };
+  }
+  if (step.replayed !== void 0) {
+    return step.replayed.trigger === "outcome" ? { id: step.replayed.id, trigger: "outcome" } : null;
+  }
+  const id = description === null ? void 0 : outcomeIn(description, step.outcome)?.escalate;
+  return id === void 0 ? null : { id, trigger: "outcome" };
+}
+function escalationOf2(step, description) {
+  const named = escalationIdOf(step, description);
+  if (named === null) {
+    return null;
+  }
+  const route = description?.escalations?.routes.find((row) => row.id === named.id);
+  const recorded = step.kind === "outcome" && step.recorded?.id === named.id ? step.recorded.why : null;
+  const why = quotedText(route?.quote) ?? (recorded === "" ? null : recorded);
+  return { ...named, why };
+}
+function nextStepOf(step, description) {
+  return step.kind === "unresolved" ? description.whenUnresolved : outcomeIn(description, step.outcome)?.nextStep;
+}
+async function describedStep(step, describe, jobId) {
+  if (describe === void 0 || step.releaseId === void 0) {
+    return null;
+  }
+  try {
+    return await describedFor(describe, step.releaseId, jobId);
+  } catch {
+    return null;
+  }
+}
+async function escalationFor(step, describe, jobId) {
+  if (step?.kind === "output-check") {
+    return { escalate: fixOutputCheck };
+  }
+  if (step === void 0) {
+    return {};
+  }
+  const description = await describedStep(step, describe, jobId);
+  const escalate = description === null ? null : quotedText(nextStepOf(step, description));
+  const escalation = escalationOf2(step, description);
+  return {
+    ...escalate !== null && { escalate },
+    ...escalation !== null && { escalation }
+  };
+}
+
+// src/draft-action-gate-cases.ts
+var emailRecipientFields = ["to", "cc", "bcc", "replyTo", "reply_to"];
+var emailSubjectFields = ["subject"];
+var foldCase = (text2) => text2.replaceAll(/[A-Z]/gu, (letter) => letter.toLowerCase());
+var sameField = (names) => {
+  const lower = new Set(names.map((name) => name.toLowerCase()));
+  return (field) => lower.has(field.toLowerCase());
+};
+function fieldValues(input, names) {
+  const isWanted = sameField(names);
+  const values = [];
+  const unreadable = [];
+  for (const [field, value] of Object.entries(input)) {
+    if (!isWanted(field)) {
+      continue;
+    }
+    for (const item of [value].flat()) {
+      if (typeof item === "string") {
+        values.push(item.trim());
+      } else if (item !== void 0 && item !== null) {
+        unreadable.push(field);
+      }
+    }
+  }
+  return { values, unreadable };
+}
+var isAscii = (text2) => /^[!-~]+$/u.test(text2);
+var plainAddress = /^[a-z0-9._+-]+@([a-z0-9-]+(?:\.[a-z0-9-]+)+)$/u;
+var isUnder = (domain, entity) => domain === entity || domain.endsWith(`.${entity}`);
+function domainsIn(text2, entities) {
+  return entities.filter((entity) => {
+    const escaped = entity.replaceAll(".", String.raw`\.`);
+    const whole = new RegExp(`(?:^|[^a-z0-9.-])${escaped}(?:$|[^a-z0-9-])`, "u");
+    return whole.test(text2);
+  });
+}
+function offTestList(recipients, rules) {
+  const listed = new Set((rules.testRecipients ?? []).map((address) => address.trim().toLowerCase()));
+  const outside = recipients.filter((address) => !listed.has(address));
+  return outside.length > 0 ? `recipient not on the test list: ${outside.join(", ")}` : null;
+}
+function testCompany(recipients, subject, scope) {
+  const outside = offTestList(recipients, scope.rules);
+  if (outside !== null) {
+    return { reason: outside };
+  }
+  const named = domainsIn(subject.toLowerCase(), scope.entities);
+  return named.length === 1 ? { company: named[0] } : { reason: `the subject names ${named.length} decided companies, not one` };
+}
+function recipientCompany(recipients, entities) {
+  const companies = /* @__PURE__ */ new Set();
+  for (const address of recipients) {
+    const domain = plainAddress.exec(address)?.[1] ?? "";
+    const owners = entities.filter((entity) => isUnder(domain, entity));
+    if (owners.length === 0) {
+      return { reason: `${address} is not at a company Felspar decided on`, missing: true };
+    }
+    for (const owner of owners) {
+      companies.add(owner);
+    }
+  }
+  return companies.size === 1 ? { company: [...companies][0] } : { reason: "the recipients belong to more than one company" };
+}
+function recipientsOf(scope, input) {
+  const { rules, rule } = scope;
+  const recipientFields = rule.recipientFields ?? rules.recipientFields ?? emailRecipientFields;
+  const recipients = fieldValues(input, recipientFields);
+  if (recipients.unreadable.length > 0) {
+    return { reason: `${recipients.unreadable.join(", ")} holds a value that is not an address` };
+  }
+  const malformed = recipients.values.find((address) => !isAscii(address) || !plainAddress.test(address.toLowerCase()));
+  return malformed === void 0 ? { addresses: recipients.values.map((address) => address.toLowerCase()) } : { reason: `"${malformed}" is not one plain address` };
+}
+function companyFor(scope, input) {
+  const { rules, rule } = scope;
+  const { addresses, reason } = recipientsOf(scope, input);
+  if (addresses === void 0) {
+    return { reason };
+  }
+  if (addresses.length === 0) {
+    return { reason: "the call has no recipients" };
+  }
+  if (rules.testRecipients === void 0) {
+    return recipientCompany(addresses, scope.entities);
+  }
+  const subjectFields = rule.subjectFields ?? rules.subjectFields ?? emailSubjectFields;
+  const subject = fieldValues(input, subjectFields).values.join("\n");
+  return testCompany(addresses, subject, scope);
+}
+function testListProblem(scope, input) {
+  if (scope.rules.testRecipients === void 0) {
+    return null;
+  }
+  const { addresses, reason } = recipientsOf({ ...scope, entities: [] }, input);
+  return addresses === void 0 ? reason : offTestList(addresses, scope.rules);
+}
+function fieldEntity(scope, field, input) {
+  const { values, unreadable } = fieldValues(input, [field]);
+  if (unreadable.length > 0 || values.length !== 1) {
+    return { reason: `the call must set ${field} to exactly one ID` };
+  }
+  const [value = ""] = values;
+  if (value.length === 0) {
+    return { reason: `the call's ${field} is empty` };
+  }
+  const outside = testListProblem(scope, input);
+  return outside === null ? { company: value } : { reason: outside };
+}
+function caseFor(scope, input) {
+  const { entity } = scope.rule;
+  return entity === void 0 ? companyFor(scope, input) : fieldEntity(scope, entity.field, input);
+}
+
+// src/draft-action-gate-rules.ts
+var isText = (value) => typeof value === "string" && value.trim().length > 0;
+function ruleProblem(rule) {
+  if (rule.outcomes === void 0 === (rule.writes === void 0)) {
+    return "this tool's rule must give exactly one of outcomes or writes";
+  }
+  const { outcomes, writes, entity } = rule;
+  if (outcomes !== void 0 && !(Array.isArray(outcomes) && outcomes.every(isText))) {
+    return "this tool's rule has unreadable outcomes";
+  }
+  if (writes !== void 0 && !isText(writes)) {
+    return "this tool's rule has an unreadable writes";
+  }
+  if (entity !== void 0 && !isText(entity.field)) {
+    return "this tool's rule has an unreadable entity field";
+  }
+  const checked = rule.outputCheck?.output;
+  return writes !== void 0 && checked !== void 0 && checked !== writes ? "this tool's output check is for a different output than it writes" : null;
+}
+function fieldProblem(refuse, rule, input) {
+  const isAllowed = sameField(rule.fields);
+  const isRefused = sameField(refuse);
+  const unknown = Object.keys(input).filter((field) => !isAllowed(field));
+  if (unknown.length > 0) {
+    return `the call sets ${unknown.join(", ")}, which this tool's rule doesn't allow`;
+  }
+  const refused = Object.keys(input).filter((field) => isRefused(field));
+  return refused.length > 0 ? `the call sets ${refused.join(", ")}` : null;
+}
+function checkRuleOf(rule) {
+  const { outputCheck, writes } = rule;
+  return outputCheck !== void 0 && writes !== void 0 && outputCheck.output === void 0 ? { ...outputCheck, output: writes } : outputCheck;
+}
+
+// src/draft-action-gate-domains.ts
+var publicSuffixes = [
+  "ac.uk",
+  "co.uk",
+  "gov.uk",
+  "ltd.uk",
+  "me.uk",
+  "net.uk",
+  "org.uk",
+  "plc.uk",
+  "sch.uk",
+  "com.au",
+  "edu.au",
+  "gov.au",
+  "net.au",
+  "org.au",
+  "co.nz",
+  "net.nz",
+  "org.nz",
+  "ac.jp",
+  "co.jp",
+  "ne.jp",
+  "or.jp",
+  "co.kr",
+  "or.kr",
+  "co.in",
+  "net.in",
+  "org.in",
+  "co.za",
+  "org.za",
+  "co.il",
+  "co.id",
+  "co.ke",
+  "co.th",
+  "com.ar",
+  "com.br",
+  "com.cn",
+  "com.co",
+  "com.eg",
+  "com.hk",
+  "com.mx",
+  "com.my",
+  "com.ng",
+  "com.ph",
+  "com.pk",
+  "com.sa",
+  "com.sg",
+  "com.tr",
+  "com.tw",
+  "com.ua",
+  "com.vn",
+  "net.cn",
+  "org.cn",
+  "gov.cn",
+  "edu.cn",
+  "appspot.com",
+  "azurewebsites.net",
+  "blogspot.com",
+  "cloudfront.net",
+  "firebaseapp.com",
+  "github.io",
+  "herokuapp.com",
+  "netlify.app",
+  "pages.dev",
+  "vercel.app",
+  "web.app",
+  "workers.dev"
+];
+var freeMail = [
+  "126.com",
+  "163.com",
+  "aol.com",
+  "fastmail.com",
+  "gmail.com",
+  "googlemail.com",
+  "gmx.com",
+  "gmx.de",
+  "gmx.net",
+  "hey.com",
+  "hotmail.co.uk",
+  "hotmail.com",
+  "icloud.com",
+  "live.com",
+  "mac.com",
+  "mail.com",
+  "mail.ru",
+  "me.com",
+  "msn.com",
+  "outlook.com",
+  "pm.me",
+  "proton.me",
+  "protonmail.com",
+  "qq.com",
+  "tuta.io",
+  "tutanota.com",
+  "web.de",
+  "yahoo.co.uk",
+  "yahoo.com",
+  "yandex.com",
+  "yandex.ru",
+  "ymail.com",
+  "zoho.com"
+];
+var sharedDomains = [...publicSuffixes, ...freeMail];
+var builtIn = new Set(sharedDomains);
+var domainShape = /^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/u;
+function isCompanyDomain(entity, extraShared = []) {
+  return domainShape.test(entity) && !builtIn.has(entity) && extraShared.every((domain) => domain.toLowerCase() !== entity);
+}
+
+// src/draft-action-gate-subject.ts
+var trimmed = (id) => id.trim();
+var folded = (id) => foldCase(id.trim());
+function keyingFor(subject, path) {
+  const isFolded = path === "recipients" || subject?.match === "case-insensitive";
+  const key = isFolded ? folded : trimmed;
+  return { key, decisionKey: (decision) => key(decision.case?.id ?? decision.entity) };
+}
+async function subjectFor(scope, decision) {
+  if (decision === void 0) {
+    return null;
+  }
+  const { describe } = scope;
+  const { releaseId } = decision;
+  const described = describe === void 0 || releaseId === void 0 ? null : await subjectOf(describe, releaseId, scope.rules.job);
+  const mode = decision.case?.mode ?? "provided";
+  return described === null && mode !== "provided" ? { type: "case", match: "exact", mode } : described;
+}
+var isRecipientJob = (subject) => subject === null || subject.mode === "provided" && subject.match === "case-insensitive";
+var distinct = (keys) => [...new Set(keys)];
+async function pick(scope, found) {
+  const { company, keying, subject } = found;
+  const decision = scope.decisions.filter((row) => keying.decisionKey(row) === company).at(-1);
+  if (decision === void 0) {
+    return { reason: `no decision for ${company}`, missing: true };
+  }
+  const own = await subjectFor(scope, decision);
+  return JSON.stringify(own) === JSON.stringify(subject) ? { company, decision, keying } : { reason: `${company} was decided on a release that identifies cases differently` };
+}
+async function onlyCase(scope, subject, input) {
+  const keying = keyingFor(subject, "case");
+  const keys = distinct(scope.decisions.map((row) => keying.decisionKey(row)));
+  if (keys.length !== 1) {
+    return {
+      reason: keys.length === 0 ? `no decision for this job's ${subject.type}` : `this session decided ${keys.length} ${subject.type} cases and the call doesn't say which; give the tool's rule an entity field holding the case ID`,
+      ...keys.length === 0 && { missing: true }
+    };
+  }
+  const outside = testListProblem(scope, input);
+  const [company = ""] = keys;
+  return outside === null ? await pick(scope, { company, keying, subject }) : { reason: outside };
+}
+async function selected(scope, input) {
+  const { rules, rule } = scope;
+  const subject = await subjectFor(scope, scope.decisions.at(-1));
+  if (rule.entity !== void 0) {
+    const keying2 = keyingFor(subject, "case");
+    const found2 = caseFor({ rules, rule, entities: [] }, input);
+    return found2.company === void 0 ? { reason: found2.reason ?? "no case" } : await pick(scope, { company: keying2.key(found2.company), keying: keying2, subject });
+  }
+  const keying = keyingFor(subject, "recipients");
+  const keys = distinct(scope.decisions.map((row) => keying.decisionKey(row)));
+  if (subject !== null && !isRecipientJob(subject)) {
+    return await onlyCase(scope, subject, input);
+  }
+  const entities = keys.filter((key) => isCompanyDomain(key, rules.sharedDomains));
+  const found = caseFor({ rules, rule, entities }, input);
+  return found.company === void 0 ? { reason: found.reason ?? "no case", ...found.missing === true && { missing: true } } : await pick(scope, { company: found.company, keying, subject });
+}
+async function selectCase(scope, input) {
+  const decisions = scope.decisions.filter((row) => row.job === void 0 || row.job === scope.rules.job);
+  try {
+    return await selected({ ...scope, decisions }, input);
+  } catch (error) {
+    return { reason: `Felspar's job description could not be read: ${String(error)}` };
+  }
+}
+
+// src/draft-action-gate-verifier.ts
+function felsparVerifier(configuration) {
+  let client;
+  return async (decision) => {
+    client ??= createHostedFelsparClient(configuration);
+    const verification = await client.verifyReceipt(decision.executionObjectId, {
+      receipt: decision.receipt,
+      expectedReceiptDigest: decision.receipt.receiptDigest,
+      deliveredCapsule: decision.context ?? null
+    });
+    return verification.status === "reproduced" && verification.decided !== void 0 ? verification.decided : null;
+  };
+}
+
+// src/draft-action-gate.ts
+function denialText(verdict) {
+  const parts = [verdict.reason];
+  if (verdict.escalate !== void 0) {
+    parts.push(`Next step: ${verdict.escalate}`);
+  }
+  const { escalation } = verdict;
+  if (escalation !== void 0) {
+    const why = escalation.why === null ? "" : `: ${escalation.why}`;
+    parts.push(`Escalation ${escalation.id} (${escalation.trigger})${why}`);
+  }
+  return parts.join(". ");
+}
+function gatedRule(rules, toolName) {
+  return Object.hasOwn(rules.tools, toolName) ? rules.tools[toolName] : void 0;
+}
+var isInput = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function caseProblem(decision, verified) {
+  const recorded = decision.case;
+  const replayed = verified.case;
+  if (recorded === void 0 && replayed === void 0) {
+    return null;
+  }
+  const isSame = recorded?.id === replayed?.id && recorded?.mode === replayed?.mode && replayed?.id === verified.entityId;
+  return isSame ? null : `the receipt is for case ${replayed?.id ?? "(none)"}, not ${recorded?.id ?? "(none)"}`;
+}
+function replayProblem(rules, found, verified) {
+  const { company, decision, keying } = found;
+  if (verified.jobId !== rules.job) {
+    return `the receipt is for job ${verified.jobId}, not ${rules.job}`;
+  }
+  if (keying.key(verified.entityId) !== company) {
+    return `the receipt is for ${verified.entityId}, not ${company}`;
+  }
+  const mismatch = caseProblem(decision, verified);
+  if (mismatch !== null) {
+    return mismatch;
+  }
+  const { releases } = rules;
+  const isUnpinned = releases !== void 0 && !releases.includes(verified.releaseId ?? "");
+  return isUnpinned ? `the receipt is for release ${verified.releaseId ?? "(none)"}, which is not allowed` : null;
+}
+function staleness(decision, now) {
+  const until = decision.evidenceFreshUntil;
+  if (typeof until !== "string") {
+    return null;
+  }
+  return Date.parse(until) > now ? null : `the decision's evidence went stale at ${until}`;
+}
+async function permitProblem(rule, decided, request) {
+  const { verified, decision } = decided;
+  const { releaseId, outcome } = verified;
+  let problem = null;
+  if (rule.writes !== void 0) {
+    problem = await writesProblem(request.describe, {
+      releaseId,
+      jobId: request.rules.job,
+      outcome,
+      output: rule.writes
+    });
+  } else if (rule.outcomes?.includes(outcome) !== true) {
+    problem = `${verified.entityId} is ${outcome}, which doesn't allow this`;
+  }
+  if (problem === null) {
+    return null;
+  }
+  const recorded = decision.escalation;
+  const step = {
+    kind: "outcome",
+    releaseId,
+    outcome,
+    ...verified.escalation !== void 0 && { replayed: verified.escalation },
+    ...recorded?.trigger === "outcome" && { recorded }
+  };
+  return { allow: false, reason: problem, step };
+}
+async function verifiedFor(rule, found, request) {
+  const { company, decision } = found;
+  const stale = staleness(decision, (request.now ?? Date.now)());
+  if (stale !== null) {
+    return { allow: false, reason: stale };
+  }
+  const verified = await request.verify(decision);
+  if (verified === null) {
+    return { allow: false, reason: `Felspar did not reproduce ${company}'s receipt` };
+  }
+  const problem = replayProblem(request.rules, found, verified);
+  if (problem !== null) {
+    return { allow: false, reason: problem };
+  }
+  const { outcome } = verified;
+  if (outcome === null) {
+    const reason = `${verified.entityId} is undecided, which doesn't allow this`;
+    return { allow: false, reason, step: { kind: "unresolved", releaseId: verified.releaseId } };
+  }
+  const denied = await permitProblem(rule, { verified: { ...verified, outcome }, decision }, request);
+  if (denied !== null) {
+    return denied;
+  }
+  const checkRule = checkRuleOf(rule);
+  if (checkRule !== void 0) {
+    const checked = await outputCheckProblem(checkRule, {
+      input: found.input,
+      decisionReceiptDigest: decision.receipt.receiptDigest,
+      checks: request.outputChecks ?? [],
+      verify: request.verifyOutputCheck
+    });
+    if (checked !== null) {
+      return { allow: false, reason: checked, step: { kind: "output-check" } };
+    }
+  }
+  return {
+    allow: true,
+    reason: `${company} is ${outcome}; Felspar reproduced the receipt`,
+    decision: { ...decision, outcome }
+  };
+}
+async function decide(request) {
+  const { rules, toolName, decisions } = request;
+  const rule = gatedRule(rules, toolName);
+  if (rule === void 0) {
+    return { allow: false, reason: "not a gated tool" };
+  }
+  const invalid = ruleProblem(rule);
+  if (invalid !== null) {
+    return { allow: false, reason: invalid };
+  }
+  const input = isInput(request.input) ? request.input : {};
+  const problem = fieldProblem(rules.refuse ?? [], rule, input);
+  if (problem !== null) {
+    return { allow: false, reason: problem };
+  }
+  const selected2 = await selectCase({ rules, rule, decisions, describe: request.describe }, input);
+  if (selected2.company === void 0) {
+    const pinned = rules.releases?.length === 1 ? rules.releases[0] : void 0;
+    return {
+      allow: false,
+      reason: selected2.reason,
+      ...selected2.missing === true && { step: { kind: "unresolved", releaseId: pinned } }
+    };
+  }
+  return await verifiedFor(rule, { ...selected2, input }, request);
+}
+async function checkAction(request) {
+  let decided;
+  try {
+    decided = await decide(request);
+  } catch (error) {
+    return { allow: false, reason: `gate error: ${String(error)}` };
+  }
+  if (decided.allow) {
+    return decided;
+  }
+  const { step, ...denied } = decided;
+  return { ...denied, ...await escalationFor(step, request.describe, request.rules.job) };
+}
+function report(onVerdict, toolName, verdict) {
+  if (onVerdict === void 0) {
+    return;
+  }
+  try {
+    onVerdict(toolName, verdict);
+  } catch {
+  }
+}
+function createActionGate(config) {
+  const { verify, decisions = createDecisionRecorder(), decisionTool, outputCheckTool, verifyOutputCheck, describe, now, onVerdict, ...rules } = config;
+  return {
+    rules,
+    decisions,
+    isGated: (toolName) => gatedRule(rules, toolName) !== void 0,
+    isDecisionTool: (toolName) => toolName === decisionTool,
+    isOutputCheckTool: (toolName) => outputCheckTool !== void 0 && toolName === outputCheckTool,
+    async check(sessionId, toolName, input) {
+      const verdict = await checkAction({
+        rules,
+        toolName,
+        input,
+        decisions: decisions.decisionsIn(sessionId),
+        verify,
+        outputChecks: decisions.outputChecksIn(sessionId),
+        ...verifyOutputCheck !== void 0 && { verifyOutputCheck },
+        ...describe !== void 0 && { describe },
+        ...now !== void 0 && { now }
+      });
+      report(onVerdict, toolName, verdict);
+      return verdict;
+    }
+  };
+}
+
+export {
+  outputCheckFromResult,
+  outputTextDigest,
+  felsparOutputCheckVerifier,
+  jobOf,
+  entityIdOf,
+  decisionFromResult,
+  createDecisionRecorder,
+  felsparJobDescriber,
+  emailRecipientFields,
+  emailSubjectFields,
+  sharedDomains,
+  isCompanyDomain,
+  felsparVerifier,
+  denialText,
+  gatedRule,
+  checkAction,
+  createActionGate
+};