@wenathlan/devthink 2.0.12 → 2.0.14

package/gates.ts

@@ -0,0 +1,307 @@
+/**
+ * The gates module of the 1.1.90 consolidation: every correlated variation of the human confirmation gate logic interned in this one file, so the module family carries one surface without duplicate variations.
+ * The correlation is the human gate itself: confirmgates holds the sensitive class gates of the run steps (confirmpay for money, confirmdelete for destruction and confirmcreds for credentials, each resolved only through one distinct human action with no timeout path and no batch approval) and approvalgate holds the remote client gates of the agent protocol (the approval raise with the full call arguments, the client identity and the called tool in every prompt, the secret redaction of the marked fields, the approve and refuse resolution with its actor and latency record and the timeout that refuses an unanswered gate by default).
+ * No gate window, class list or batch rule is ever hardcoded anywhere in the family: every timeout stays the user's choice beside the documented default, the gate payloads show exactly what the human reviews, and no gate ever resolves without its distinct human action.
+ */
+
+/* ── Merged from confirmgates.ts ── */
+
+import type { confirmgate, gatekind, gateresolution, sensitiveclass, toolstep } from "./types.js";
+import { randomid } from "./memory.js";
+
+/**
+ * Confirm gates of the 1.1.62 family.
+ * The human gates for money, destruction and credentials live here: payment class steps pause in front of confirmpay, destructive delete steps pause in front of confirmdelete and credential use steps pause in front of confirmcreds, and each gate resolves only through one distinct human action — no timeout ever resolves a gate and no batch approval resolves two.
+ * The payloads show exactly what the human reviews: confirmpay shows the amount, the payee origin and the target element, confirmdelete shows the target, the scope and the irreversibility, and confirmcreds shows the credential label only, never its value.
+ */
+
+/** Reads the option payload of one step without throwing on malformed json. */
+function stepoptions(step: Pick<toolstep, "options">): Record<string, unknown> {
+  if (!step.options) return {};
+  try {
+    const parsed = JSON.parse(step.options);
+    return Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Maps the sensitive classes of one step to its gated family: payment classes gate through confirmpay, delete classes through confirmdelete and credential classes through confirmcreds, while publish grades and plain sensitive by default steps ride their consent window prompt alone. */
+export function gatekindfor(classes: sensitiveclass[]): gatekind | undefined {
+  if (classes.includes("payment")) return "confirmpay";
+  if (classes.includes("delete")) return "confirmdelete";
+  if (classes.includes("credential")) return "confirmcreds";
+  return undefined;
+}
+
+/** Builds the payload of one confirmpay gate: the amount, the payee origin and the target element of the step the human reviews. */
+export function paypayload(input: { amount?: string; payeeorigin: string; target?: string }): Record<string, string> {
+  const payload: Record<string, string> = { payeeorigin: input.payeeorigin };
+  if (input.amount !== undefined && input.amount.trim() !== "") payload.amount = input.amount.trim();
+  if (input.target !== undefined && input.target.trim() !== "") payload.target = input.target.trim();
+  return payload;
+}
+
+/** Builds the payload of one confirmdelete gate: the target, the scope and the irreversibility of the destructive step the human reviews. */
+export function deletepayload(input: {
+  target?: string;
+  scope: string;
+  irreversibility: string;
+}): Record<string, string> {
+  const payload: Record<string, string> = { scope: input.scope, irreversibility: input.irreversibility };
+  if (input.target !== undefined && input.target.trim() !== "") payload.target = input.target.trim();
+  return payload;
+}
+
+/** Builds the payload of one confirmcreds gate: the credential label only, because the value stays behind the vault and no gate ever reveals it. */
+export function credspayload(label: string): Record<string, string> {
+  if (label.trim() === "")
+    throw new Error("The confirmcreds gate names its credential label; the value never appears.");
+  return { label: label.trim() };
+}
+
+/** Opens one confirm gate for a gated step: the payload the human reviews, the origin provenance and the open state that only an explicit user action resolves. */
+export function opengate(input: {
+  kind: gatekind;
+  stepid: string;
+  runid: string;
+  origin: string;
+  payload: Record<string, string>;
+  now: number;
+  gateid?: string;
+}): confirmgate {
+  if (input.stepid.trim() === "" || input.runid.trim() === "" || input.origin.trim() === "")
+    throw new Error("The confirm gate needs its step, run and origin.");
+  if (Object.keys(input.payload).length === 0)
+    throw new Error("The confirm gate carries the payload the human reviews.");
+  return {
+    gateid: input.gateid ?? randomid(),
+    kind: input.kind,
+    stepid: input.stepid,
+    runid: input.runid,
+    origin: input.origin,
+    payload: { ...input.payload },
+    state: "open",
+    openedat: input.now,
+  };
+}
+
+/** Reads the state of the gate one step waits at: no gate, an open gate the step pauses at, a resolved gate the step passes and a refused gate the step never dispatches through. */
+export function gatestateof(
+  gates: confirmgate[],
+  stepid: string,
+): { state: "none" | "open" | "resolved" | "refused"; gate?: confirmgate } {
+  const gate = [...gates].reverse().find((candidate) => candidate.stepid === stepid);
+  if (gate === undefined) return { state: "none" };
+  return { state: gate.state, gate };
+}
+
+/** Resolves exactly one gate through one explicit human action: the decision names its acting user, an already resolved or refused gate stays terminal, and no timeout path exists because only a human resolves a gate. */
+export function resolvegate(input: {
+  gates: confirmgate[];
+  gateid: string;
+  decision: "resolved" | "refused";
+  actor: string;
+  now: number;
+}): { gates: confirmgate[]; resolution?: gateresolution } {
+  if (input.actor.trim() === "")
+    throw new Error("The gate resolution names its acting user; only a human resolves a gate.");
+  const gate = input.gates.find((candidate) => candidate.gateid === input.gateid);
+  if (gate === undefined) return { gates: input.gates };
+  if (gate.state !== "open") return { gates: input.gates };
+  const resolution: gateresolution = {
+    gateid: gate.gateid,
+    kind: gate.kind,
+    stepid: gate.stepid,
+    decision: input.decision,
+    actor: input.actor,
+    at: input.now,
+  };
+  return {
+    gates: input.gates.map((candidate) =>
+      candidate.gateid === input.gateid
+        ? { ...candidate, state: input.decision, resolvedat: input.now, actor: input.actor }
+        : candidate,
+    ),
+    resolution,
+  };
+}
+
+/** Refuses batch approvals: one human action resolves exactly one gate, so a resolution request that names several gates refuses in full. */
+export function nobatchresolution(gateids: string[]): { allowed: boolean; reason: string } {
+  if (gateids.length > 1)
+    return {
+      allowed: false,
+      reason: `One human action resolves exactly one gate; the batch of ${gateids.length} gates refuses in full because no batch approval exists.`,
+    };
+  if (gateids.length === 0) return { allowed: false, reason: "A gate resolution names its single gate." };
+  return {
+    allowed: true,
+    reason: "The resolution names exactly one gate; the distinct human action resolves it alone.",
+  };
+}
+
+/** Builds the plain language prompt of one gate: confirmpay names the amount, the payee origin and the target element, confirmdelete names the target, the scope and the irreversibility, and confirmcreds names the credential label only. */
+export function gateprompttext(gate: confirmgate): string {
+  if (gate.kind === "confirmpay") {
+    const amount =
+      gate.payload.amount !== undefined ? `the amount ${gate.payload.amount}` : "an amount the step options name";
+    const target = gate.payload.target !== undefined ? ` on ${gate.payload.target}` : "";
+    return `Approve the payment of ${amount} to ${gate.payload.payeeorigin}${target}? The step dispatches only after this distinct human action.`;
+  }
+  if (gate.kind === "confirmdelete") {
+    const target = gate.payload.target !== undefined ? ` on ${gate.payload.target}` : "";
+    return `Approve the destructive delete${target} scoped to ${gate.payload.scope}? ${gate.payload.irreversibility} The step dispatches only after this distinct human action.`;
+  }
+  return `Approve the use of the credential ${gate.payload.label} on ${gate.origin}? The value stays behind the vault; the label is everything this prompt shows.`;
+}
+
+/** Builds the gate descriptor of one gated step from its reviewed shape: the payload fields the human reviews read from the step options, the plan origin and the vault label of a credential step. */
+export function gateforstep(input: {
+  step: Pick<toolstep, "id" | "kind" | "target" | "options">;
+  classes: sensitiveclass[];
+  runid: string;
+  origin: string;
+  credentiallabel?: string;
+  now: number;
+}): confirmgate | undefined {
+  const kind = gatekindfor(input.classes);
+  if (kind === undefined) return undefined;
+  const options = stepoptions(input.step);
+  if (kind === "confirmpay") {
+    const amount =
+      typeof options.amount === "string"
+        ? options.amount
+        : typeof options.value === "string"
+          ? options.value
+          : undefined;
+    return opengate({
+      kind,
+      stepid: input.step.id,
+      runid: input.runid,
+      origin: input.origin,
+      payload: paypayload({
+        ...(amount !== undefined && amount !== "" ? { amount } : {}),
+        payeeorigin: String(options.payeeorigin ?? input.origin),
+        ...(input.step.target !== undefined && input.step.target !== "" ? { target: input.step.target } : {}),
+      }),
+      now: input.now,
+    });
+  }
+  if (kind === "confirmdelete") {
+    return opengate({
+      kind,
+      stepid: input.step.id,
+      runid: input.runid,
+      origin: input.origin,
+      payload: deletepayload({
+        ...(input.step.target !== undefined && input.step.target !== "" ? { target: input.step.target } : {}),
+        scope: String(options.scope ?? input.origin),
+        irreversibility: String(
+          options.irreversibility ?? "A destructive delete destroys state the page cannot restore.",
+        ),
+      }),
+      now: input.now,
+    });
+  }
+  if (input.credentiallabel === undefined || input.credentiallabel.trim() === "") return undefined;
+  return opengate({
+    kind,
+    stepid: input.step.id,
+    runid: input.runid,
+    origin: input.origin,
+    payload: credspayload(input.credentiallabel),
+    now: input.now,
+  });
+}
+
+/* ── Merged from approvalgate.ts ── */
+
+import type { allowlistentry, approvalrequest, approvalstate, approvalexec, clientidentity } from "./types.js";
+
+/**
+ * Approval gates of the 1.1.55 agent protocol part two.
+ * Every sensitive tool call a remote client raises lands behind a human approval gate in this file: the gate raise with the full call arguments, the client identity and the called tool in every prompt, the secret redaction of the fields the user marked secret, the approve and refuse resolution with its actor and latency record, and the timeout that refuses an unanswered gate by default.
+ * The gates never bypass review: an approved gate executes exactly the call it holds while refused and expired gates never execute anything.
+ */
+
+/** The documented default approval window of two minutes; any user configured window wins and an unanswered gate refuses by default. */
+export const defaultapprovalwindowms = 120_000;
+
+/** Raises one approval gate for a sensitive tool call: the full call arguments, the reason in plain language, the fields the user marked secret and the timeout that refuses by default. */
+export function requireapproval(input: {
+  clientid: string;
+  tool: string;
+  reason: string;
+  params: Record<string, unknown>;
+  now: number;
+  timeout?: number;
+  secretfields?: string[];
+  id?: string;
+}): approvalrequest {
+  return {
+    id: input.id ?? randomid(),
+    clientid: input.clientid,
+    tool: input.tool,
+    reason: input.reason,
+    params: input.params,
+    ...(input.secretfields !== undefined && input.secretfields.length > 0 ? { secretfields: input.secretfields } : {}),
+    state: "pending",
+    raisedat: input.now,
+    ...(input.timeout !== undefined ? { timeoutat: input.now + input.timeout } : {}),
+  };
+}
+
+/** Resolves one pending approval gate: the decision of the acting user closes the gate and returns the execution record with the latency from the raise; already closed gates stay untouched. */
+export function resolveapproval(input: {
+  requests: approvalrequest[];
+  id: string;
+  decision: "approved" | "refused";
+  actor: string;
+  now: number;
+}): { requests: approvalrequest[]; exec?: approvalexec } {
+  const gate = input.requests.find((request) => request.id === input.id);
+  if (gate === undefined || gate.state !== "pending") return { requests: input.requests };
+  const decision: approvalstate = input.decision;
+  const requests = input.requests.map((request) =>
+    request.id === input.id ? { ...request, state: decision, decidedat: input.now, actor: input.actor } : request,
+  );
+  return {
+    requests,
+    exec: { requestid: input.id, decision, actor: input.actor, at: input.now, latencyms: input.now - gate.raisedat },
+  };
+}
+
+/** Expires every unanswered approval gate past its timeout window: the default disposition of an expired gate is refusal and the records stay for the audit trail. */
+export function expireapprovals(requests: approvalrequest[], now: number): approvalrequest[] {
+  return requests.map((request) =>
+    request.state === "pending" && request.timeoutat !== undefined && now >= request.timeoutat
+      ? { ...request, state: "expired" as const }
+      : request,
+  );
+}
+
+/** Returns the pending and resolved gates of the approval view, newest raise first. */
+export function listapprovals(requests: approvalrequest[]): approvalrequest[] {
+  return [...requests].sort((one, two) => two.raisedat - one.raisedat);
+}
+
+/** Redacts the call arguments of one approval prompt: every field the user marked secret carries its redaction marker while the rest of the arguments stay visible for review. */
+export function redactparams(params: Record<string, unknown>, secretfields: string[]): Record<string, unknown> {
+  const redacted: Record<string, unknown> = {};
+  for (const [name, value] of Object.entries(params))
+    redacted[name] = secretfields.includes(name) ? "[redacted]" : value;
+  return redacted;
+}
+
+/** Builds the plain language approval prompt every gate surfaces: the client identity, the called tool, the reason and the full call arguments with the secret fields redacted. */
+export function approvalprompt(request: approvalrequest, identity?: clientidentity): string {
+  const who =
+    identity !== undefined
+      ? `the client ${identity.displayname} (${identity.fingerprint})`
+      : `the client ${request.clientid}`;
+  const params = JSON.stringify(redactparams(request.params, request.secretfields ?? []));
+  return `${who} calls ${request.tool}: ${request.reason} Arguments: ${params}`;
+}

package/gateway.ts

@@ -0,0 +1,34 @@
+/** Style: DevThink Terminal Atelier — browser gateway client that stores only an ephemeral pairing token, never a provider credential. */
+
+export type GatewayContext = { url?: string; token?: string };
+
+export function gatewayContext(): GatewayContext {
+  const query = new URLSearchParams(window.location.search);
+  const url = query.get("gateway") || window.sessionStorage.getItem("devthink.gateway") || undefined;
+  const token = window.sessionStorage.getItem("devthink.pair.token") || undefined;
+  /** exactOptionalPropertyTypes: never assign an explicit undefined to an optional property */
+  const context: GatewayContext = {};
+  if (url !== undefined) context.url = url.replace(/\/$/, "");
+  if (token !== undefined) context.token = token;
+  return context;
+}
+
+export function gatewayUrl(): string | undefined {
+  return gatewayContext().url;
+}
+
+export async function gatewayJson<T>(path: string, init?: RequestInit): Promise<T> {
+  const context = gatewayContext();
+  if (!context.url) throw new Error("A local DevThink gateway is not paired.");
+  const headers = new Headers(init?.headers);
+  if (context.token) headers.set("authorization", `Bearer ${context.token}`);
+  if (init?.body && !headers.has("content-type")) headers.set("content-type", "application/json");
+  const response = await fetch(`${context.url}${path}`, { ...init, headers });
+  if (!response.ok) throw new Error(`Gateway returned ${response.status}.`);
+  return response.json() as Promise<T>;
+}
+
+export function gatewayReady(): boolean {
+  const context = gatewayContext();
+  return Boolean(context.url && context.token);
+}

package/hardening.ts

@@ -0,0 +1,191 @@
+/** The security hardening family of the 1.1.95 release: the gates the release candidates carry live in their own root module beside the policy family so the frozen library surface of index.ts stays byte identical — the background service worker imports these gates directly, tests/pentest.mjs exercises every one of them against the compiled dist/hardening.js bundle, and the module stays out of the index.ts export graph because the api freeze of 1.1.91 pins that surface until 2.0.0. The family covers the log text masking of the audit trail, the local signature check of the virus scanning hook, the visible confirmation banner of the escape hatch, the review mode pause on new domains, the run trace purge, the key rotation of the encrypted sync path, the client signature verification of the local stdio bridge and the masking plus redaction pass of the transparency exports. */
+import { maskexport, maskvalue, maskingfield } from "./security.js";
+import type { policyevaluation, redactregion, scanverdict } from "./types.js";
+
+/** Masks the secret shaped key value pairs of one free form log text: a summary a step, a body or a console line embedded stays masked when its key matches a masked shape, because a log field the families gained since the masking audit never leaks its typed value through the text the audit trail keeps. */
+export function masklogtext(input: { text: string; shapes: string[] }): {
+  text: string;
+  maskedkeys: string[];
+  reason: string;
+} {
+  const maskedkeys: string[] = [];
+  let text = input.text;
+  /* the json shape ("password": "x"), the query shape (password=x) and the labeled shape (password: x) all recognize through the same field shape grammar the named fields read */
+  const patterns: Array<[RegExp, (match: RegExpExecArray) => string]> = [
+    [/(\w+)\s*:\s*"((?:[^"\\]|\\.)*)"/g, (match) => `${match[1]}: "${maskvalue(match[2] ?? "")}"`],
+    [/(\w+)\s*=\s*([^\s&;]+)/g, (match) => `${match[1]}=${maskvalue(match[2] ?? "")}`],
+    [/(\w+)\s*:\s*([^\s,;]+)/g, (match) => `${match[1]}: ${maskvalue(match[2] ?? "")}`],
+  ];
+  for (const [pattern, rewrite] of patterns) {
+    text = text.replace(pattern, (full, key, ...rest) => {
+      if (!maskingfield(String(key), input.shapes)) return full;
+      maskedkeys.push(String(key));
+      return rewrite([full, String(key), String(rest[0] ?? "")] as unknown as RegExpExecArray);
+    });
+  }
+  const unique = [...new Set(maskedkeys)];
+  return {
+    text,
+    maskedkeys: unique,
+    reason:
+      unique.length === 0
+        ? "The log text carries no secret shaped key value pair; the masking pass changed nothing."
+        : `The masking pass covered the log field${unique.length === 1 ? "" : "s"} ${unique.join(", ")} the text carried since the audit; the typed values answer the redaction marker.`,
+  };
+}
+
+/** Gates the local signature check option of the virus scanning hook: a scanner configured with a local signature list answers its verdict on the device before any remote endpoint fires, and a digest that matches a local signature flags the file while a digest that matches nothing leaves the verdict to the configured hook. */
+export function localscangate(input: { hook?: { scanner: string; localsignatures?: string[] }; digest?: string }): {
+  verdict: scanverdict;
+  reason: string;
+} {
+  const signatures = input.hook?.localsignatures ?? [];
+  if (signatures.length === 0)
+    return {
+      verdict: "pending",
+      reason:
+        "The scanning hook carries no local signature list; the verdict stays with the configured scanner endpoint and the file holds.",
+    };
+  if (input.digest === undefined || input.digest.trim() === "")
+    return {
+      verdict: "pending",
+      reason: `The local signature check of ${input.hook?.scanner ?? "the scanning hook"} needs the file digest; a digest nobody computed flags nothing.`,
+    };
+  if (signatures.includes(input.digest))
+    return {
+      verdict: "flagged",
+      reason: `The local signature list of ${input.hook?.scanner} matched the file digest; the quarantine deletes the file and no remote endpoint ever fires.`,
+    };
+  return {
+    verdict: "pending",
+    reason: `The local signature list of ${input.hook?.scanner} matched no signature; the verdict falls back to the configured scanner endpoint and the file holds.`,
+  };
+}
+
+/** Builds the visible confirmation banner of the escape hatch: one record the surfaces render after the key press, because a halt of every native call at once deserves a confirmation the user sees and the audit trail keeps. */
+export function hatchbannerof(input: { halted: number; at: number }): {
+  title: string;
+  explanation: string;
+  halted: number;
+  at: number;
+} {
+  return {
+    title: `Escape hatch: ${input.halted} in flight call${input.halted === 1 ? "" : "s"} halted`,
+    explanation: `The escape hatch key stopped every native call in one press at ${new Date(input.at).toISOString()}; the transport detached until you reattach and the halt stays recorded in the audit trail.`,
+    halted: input.halted,
+    at: input.at,
+  };
+}
+
+/** Decides the review mode pause on a new domain: a navigation step that lands on a domain the profile workspace never recorded pauses the run with the explanatory card instead of dispatching silently, because a new domain is a new trust boundary the review walks the user through. */
+export function newdomainpausecard(input: { origin: string; knownorigins: string[]; kind: string }): {
+  pause: boolean;
+  card: { title: string; explanation: string; origin: string };
+  reason: string;
+} {
+  if (input.knownorigins.includes(input.origin))
+    return {
+      pause: false,
+      card: { title: "", explanation: "", origin: input.origin },
+      reason: `The domain ${input.origin} sits inside the recorded origins; the review mode runs the ${input.kind} step without the new domain pause.`,
+    };
+  return {
+    pause: true,
+    card: {
+      title: `New domain: ${input.origin}`,
+      explanation: `The ${input.kind} step targets a domain the profile workspace never recorded. The run pauses here so you can review the new trust boundary: the safedefaults profile applied reads only, every sensitive class stays denied, and the next explicit grant opens the domain the same way the first one did.`,
+      origin: input.origin,
+    },
+    reason: `The review mode paused the ${input.kind} step on the new domain ${input.origin} with the explanatory card; the run resumes after the domain review.`,
+  };
+}
+
+/** Selects every stored key that carries the trace of one run: the per run keys the families write end with the run id, so the purge of a run deletes every key that names it and no key survives with the run's data. */
+export function runtracekeys(input: { runid: string; keys: string[] }): {
+  keys: string[];
+  kept: string[];
+  reason: string;
+} {
+  if (input.runid.trim() === "")
+    throw new Error("The run trace purge names its run; a nameless run trace purges nothing.");
+  const runid = input.runid.trim();
+  const keys = input.keys.filter((key) => key === runid || key.endsWith(runid));
+  const kept = input.keys.filter((key) => !keys.includes(key));
+  return {
+    keys,
+    kept,
+    reason:
+      keys.length === 0
+        ? `No stored key carries the trace of the run ${runid}; the run trace purge deletes nothing.`
+        : `The run trace purge deletes ${keys.length} stored key${keys.length === 1 ? "" : "s"} carrying the trace of the run ${runid} — ${keys.join(", ")} — while ${kept.length} key${kept.length === 1 ? "" : "s"} of other runs survive.`,
+  };
+}
+
+/** Gates the key rotation entry point of the encrypted sync path: the rotation needs both the current passphrase and the next one, and a rotation that reuses the same passphrase rekeys nothing. */
+export function syncrotationgate(input: { current?: string; next?: string }): policyevaluation {
+  if ((input.current ?? "").trim() === "" || (input.next ?? "").trim() === "")
+    return {
+      allowed: false,
+      reason:
+        "The key rotation names both the current passphrase and the next one; a rotation without either passphrase never rekeys because no key ever defaults in code.",
+    };
+  if (input.current === input.next)
+    return {
+      allowed: false,
+      reason:
+        "The key rotation needs a next passphrase that differs from the current one; rotating onto the same key rekeys nothing.",
+    };
+  return {
+    allowed: true,
+    reason:
+      "The key rotation entry point opens with both passphrases present; the derived key rekeys the sync payloads while the passphrases never persist.",
+  };
+}
+
+/** Verifies the client signature of the local stdio bridge: the platform verifier answers when the platform allows signature verification, a presented signature that fails refuses the bridge, and a platform without a verifier keeps the bridge running unverified while the record says so. */
+export function stdioclientsignaturegate(input: {
+  platformverifier?: (host: string, signature: string) => boolean;
+  host: string;
+  signature?: string;
+}): { verified: boolean; allowed: boolean; reason: string } {
+  if (input.signature === undefined || input.platformverifier === undefined)
+    return {
+      verified: false,
+      allowed: true,
+      reason:
+        "The platform carries no signature verifier the bridge can call; the local stdio bridge stays unverified while the record marks it.",
+    };
+  if (!input.platformverifier(input.host, input.signature))
+    return {
+      verified: false,
+      allowed: false,
+      reason: `The client signature of the ${input.host} bridge failed the platform verification; the local stdio bridge refuses the client and no frame relays.`,
+    };
+  return {
+    verified: true,
+    allowed: true,
+    reason: `The platform verifier confirmed the client signature of the ${input.host} bridge; the local stdio bridge relays its frames under the verified client.`,
+  };
+}
+
+/** Masks and redacts one transparency export payload: the shape masking covers every typed field of the report while the redact regions of the origin mark the capture derived entries, so an export the transparency page issues leaves with the same masking and redaction the captures carry. */
+export function transparencyexportmask(input: {
+  report: Record<string, unknown>;
+  shapes: string[];
+  regions: redactregion[];
+}): { payload: Record<string, unknown>; maskedfields: string[]; redactedregions: number; reason: string } {
+  const payload = maskexport(input.report, input.shapes) as Record<string, unknown>;
+  const maskedfields = Object.keys(input.report).filter((key) => maskingfield(key, input.shapes));
+  if (input.regions.length > 0 && Array.isArray(payload.captures))
+    payload.captures = (payload.captures as unknown[]).map((entry) =>
+      Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)
+        ? { ...(entry as Record<string, unknown>), redacted: true, redactedregions: input.regions.length }
+        : entry,
+    );
+  return {
+    payload,
+    maskedfields,
+    redactedregions: input.regions.length,
+    reason: `The transparency export left with the masking pass over ${maskedfields.length} shaped field${maskedfields.length === 1 ? "" : "s"} and ${input.regions.length} redact region${input.regions.length === 1 ? "" : "s"} covering its capture derived entries; the raw values stay behind the redaction marker.`,
+  };
+}