tool-approval-correlation-audit 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 1.0.0 — unreleased
+
+- Original bounded metadata-only correlation audit for calls, approval requests, decisions and explicitly gated execution observations.
+- Exact per-scope identities, duplicate/rebinding/conflict diagnostics, ordering and partial-trace semantics.
+- Fixed redacted findings, immutable reports and ESM/CommonJS/TypeScript entry points.
+- No authorization, execution, cryptography, network or storage.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Huzaifa Asif
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,130 @@
-# Temporary Holding Version
+# tool-approval-correlation-audit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Bounded offline diagnostics for approval observation correlation. Check the npm registry for available published versions.
+
+A small, zero-runtime-dependency diagnostic library for **saved observations** of tool calls, approval requests, decisions and explicitly approval-gated executions. It finds broken ID joins and ordering in adapter fixtures without importing a provider SDK or retaining tool arguments.
+
+This is **not an authorization system**. A consistent trace does not prove human consent, a safe operation, a real execution, correct policy, trusted evidence or absence of omitted events. Never use this report as a permission check.
+
+## Why it exists
+
+An adapter can emit an approval request before it emits the related call. A UI can associate a delayed answer with the wrong message. Transcript pruning can leave a response whose request no longer exists. Each looks like an approval problem but can be a correlation problem.
+
+Vercel AI [issue 23514](https://github.com/vercel/ai/issues/23514), opened October 17, 2026, reports the first pattern and remained open when checked October 28. The report concerns evaluation jobs, not a verified production incident. [Issue 21193](https://github.com/vercel/ai/issues/21193) and [issue 16385](https://github.com/vercel/ai/issues/16385) are **closed/merged historical examples**, not claims that today's SDK still has those bugs. Upgrade SDKs for upstream fixes first. This package diagnoses synthetic or sanitized adapter fixtures; it does not patch those frameworks.
+
+## Quick start
+
+Requires Node.js 20 or later. There are no runtime dependencies or lifecycle install scripts.
+
+```sh
+npm run check
+node examples/audit.js
+```
+
+Import locally during evaluation:
+
+```js
+import { auditApprovalTrace } from 'tool-approval-correlation-audit';
+const report = auditApprovalTrace([
+  { type: 'call', scope: 'session-1', callId: 'call-1' },
+  { type: 'request', scope: 'session-1', callId: 'call-1', approvalId: 'approval-1' },
+  { type: 'decision', scope: 'session-1', approvalId: 'approval-1', decision: 'approved' },
+  { type: 'execution', scope: 'session-1', callId: 'call-1', approvalId: 'approval-1' }
+]);
+console.log(report.consistent); // true: supplied complete observations correlate
+```
+
+CommonJS uses `require('tool-approval-correlation-audit')`. ESM, CommonJS and TypeScript declarations are included. To work from source, run `npm ci --ignore-scripts` and `npm run check`.
+
+For CI fixtures, fail your *test* if a complete trace is inconsistent. Do not use that boolean to decide whether to execute a real tool.
+
+## API
+
+`auditApprovalTrace(events, options?) -> AuditReport`
+
+`events` is a readonly array. Every event has a nonempty `scope`, which the caller chooses as an explicit session/run identity. IDs are compared literally, including case. Same IDs in different scopes are independent. Reuse within one scope is ambiguous. Do not truncate unrelated sessions into the same scope or put timestamps in place of identities.
+
+| Type | Required fields besides scope/type | Meaning |
+| --- | --- | --- |
+| call | callId | Caller observed the tool call being registered |
+| request | callId, approvalId | Caller observed an approval request for that call |
+| decision | approvalId, decision | Reported label: approved or denied |
+| execution | callId, approvalId | Caller observed an execution explicitly expected to be approval-gated |
+
+There is deliberately no operation name, raw argument, result, approver name, reason, token, signature or policy field. Extra fields are ignored and not read. `approved` is merely a caller-supplied label; no authenticity is inferred. Do not fabricate execution observations from a model's claim that it ran a tool.
+
+The API does **not** assume every tool execution requires approval. Only provide `execution` for calls whose approval requirement your adapter has independently established. Provider-executed tools and auto-approved tools can have different semantics; normalize them explicitly or leave them outside this narrow fixture. See the [AI SDK approval documentation](https://github.com/vercel/ai/blob/main/content/docs/03-ai-sdk-core/15-tools-and-tool-calling.mdx).
+
+Repeated execution of a call is diagnosed even when the second observation uses a different approved request ID. This model allows at most one execution observation per scoped call ID; adapters that intentionally retry must assign distinct call-attempt IDs rather than reuse a call ID. Repeated execution through the same approval ID is also diagnosed.
+
+### Options and bounds
+
+| Option | Default | Allowed |
+| --- | --- | --- |
+| maxEvents | 10,000 | integer 1–100,000 |
+| maxIdentities | 10,000 | integer 1–100,000 |
+| maxIdLength | 256 | integer 1–4,096 UTF-16 code units |
+| maxFindings | 1,000 | integer 1–10,000 |
+| traceStart | complete | complete or partial |
+| traceEnd | complete | complete or partial |
+
+Identity accounting includes each distinct retained scope, call and request ID. When a new identity would exceed the limit, scanning stops. Event overflow scans only the bounded prefix. Finding overflow retains the configured number but continues counting issues within the other bounds. No IDs are evicted and reused as if they were new.
+
+Malformed options throw a fixed `TypeError('Invalid audit options')`. Invalid events/traces yield fixed diagnostics and `complete:false`. Getters/proxies that throw while required fields are read are caught, but arbitrary JavaScript getters can run code or never return; this is not a sandbox. Prefer objects produced by parsing sanitized JSON. Each required field is read once per event. Unknown extra fields are not inspected.
+
+### Result
+
+- `consistent`: true only when evidence is declared complete, no limit/invalid evidence occurred and zero diagnostic issues were found. An empty complete trace is consistent because it declares no operations; this is not evidence that an operation occurred.
+- `complete`: false for caller-declared partial boundaries, invalid evidence or a limit. This does not verify the caller's completeness claim.
+- `findingsTruncated`: whether some diagnostics were omitted from the bounded findings array.
+- `counts`: observed array entries, recognized calls/requests/decisions/executions, retained identities, unresolved requests, total issues.
+- `findings`: fixed `code`, zero-based event `index`, and optional original `relatedIndex`. `invalid-trace` uses index -1; event-limit uses the first unexamined index.
+
+All returned objects/arrays are frozen. Reports do not echo caller-controlled identifiers, values, error messages or arguments. The library does not mutate input objects, though hostile getters can mutate themselves.
+
+### Ordering, partial evidence and ambiguity
+
+Input array order is *observation order*, not proven real-time causality. Correctly merge parallel event streams before analysis or keep separate scopes. The library does not reorder events or use timestamps to invent causality.
+
+A request before a call remains a finding after the call arrives. A decision before a request is not applied later. A repeated/conflicting decision never replaces the first decision. Duplicate calls or rebound request IDs taint the related records. Later clean-looking events cannot erase existing findings.
+
+At a declared complete end, unresolved requests produce `unresolved-request`. With `traceEnd:'partial'`, unresolved requests are counted but are not issues by themselves. Missing references in partial traces are **missing-context diagnostics**, not evidence that an unauthorized action happened. A positive decision without execution is permitted: consent does not guarantee an action was attempted.
+
+## Diagnostic codes
+
+Input/bounds: `invalid-trace`, `invalid-event`, `event-limit`, `identity-limit`.
+
+Correlation/order: `unknown-call`, `duplicate-call`, `ambiguous-call`, `duplicate-request`, `approval-rebound`, `decision-without-request`, `duplicate-decision`, `conflicting-decision`, `execution-without-request`, `execution-call-mismatch`, `ambiguous-approval`, `execution-before-decision`, `execution-after-denial`, `duplicate-execution`, `unresolved-request`.
+
+A duplicate execution is a duplicate *observation*, not proof of duplicate side effects or charges. An execution-after-denial finding is contradictory reported evidence, not a verified security incident.
+
+## Alternatives and scope
+
+- AI SDK `toolApproval` and message helpers provide the actual framework workflow. Prefer those for runtime behavior.
+- [mcp-approval](https://www.npmjs.com/package/mcp-approval) implements MCP confirmation/elicitation. Its indexed documentation was reviewed; direct page retrieval was blocked. This library neither replaces its gate nor issues tokens.
+- [FrontMCP's approval plugin](https://frontmcp.dev/reference/plugins/approval) adds an approval gate/store within that framework.
+- Throughline approvals and Alquimia worklog reducers integrate approval workflows into their ecosystems. They may be preferable if you already use them.
+- ApprovalTests compares snapshots rather than correlating request IDs.
+- `tool-call-closure` settles pending calls; `tool-execution-checkpoint` tracks execution/delivery; `tool-call-budget-audit` audits batch size/completeness. This package only joins approval observations.
+
+No claim of first, unique, exhaustive, production-proven or security-certified technology is made. Search coverage is limited to accessible public indexed material as of October 28, 2026.
+
+## Verification and supported runtimes
+
+Declared support is Node 20+. Current local execution and CI configuration must be reported separately in release evidence. CI is configured for Node 20,22,24; an unrun matrix is not a passed matrix. Run `npm run check` for syntax checks, unit tests with coverage, file/export boundaries and the shipped synthetic example. Strict TypeScript consumer fixture: `tsc --strict --noEmit --module NodeNext --moduleResolution NodeNext test/types.ts test/types.cts` using an approved TypeScript toolchain.
+
+No provider network integration, actual human approval, tool execution, persistence, cryptographic proof or browser UI is exercised by these tests. Release verification also checks the exact tarball through isolated ESM, CommonJS and strict TypeScript consumers.
+
+## Troubleshooting
+
+- `consistent:false` with no findings: check partial boundaries and `complete`.
+- `identity-limit`: raise the bounded limit within the hard ceiling or split independent scopes; never silently discard a relevant event.
+- Unknown call/request: verify all relevant earlier messages were exported and the adapter emits call registration before approval.
+- Duplicate findings: inspect replay behavior and identity scope; do not delete diagnostics merely to get a green result.
+- Frozen output errors: copy the result before modifying presentation state.
+
+## Privacy, accessibility and maintenance
+
+No network, logging, storage, environment reads, clocks or callbacks are used. Data remains in process memory for the duration of the call and is not returned except fixed codes/counts/indices. The caller remains responsible for sanitized source logs, retention and access control. The CLI example emits plain structured JSON that can be rendered accessibly; this library has no visual interface.
+
+See CONTRIBUTING.md, SECURITY.md and CHANGELOG.md. Original code is MIT. Copyright/license notice retention is a license obligation, not a requirement to provide promotional credit.

package/SECURITY.md

@@ -0,0 +1,5 @@
+# Security and privacy
+
+This diagnostic package is not a security boundary or approval authority. It cannot authenticate an approver, verify event truth/completeness, stop execution or prove effects. Do not process secrets or use `consistent` to authorize operations. Getters may execute arbitrary code; prefer sanitized JSON values. No dependency audit can prove this package secure.
+
+For a potential vulnerability, use GitHub private vulnerability reporting if enabled on the eventual public repository. Until a verified private channel exists, do not post sensitive details publicly; contact the maintainer through an established private channel. No response SLA is promised. Use synthetic minimal reproductions with no live credentials, tokens, customer identifiers or raw private traces.

package/examples/audit.js

@@ -0,0 +1,11 @@
+import { auditApprovalTrace } from '../src/index.js';
+// Synthetic metadata only. Never provide arguments, approval tokens or personal data.
+const trace = [
+  { type: 'request', scope: 'run-1', callId: 'call-1', approvalId: 'approval-1' },
+  { type: 'call', scope: 'run-1', callId: 'call-1' },
+  { type: 'decision', scope: 'run-1', approvalId: 'approval-1', decision: 'approved' },
+  { type: 'execution', scope: 'run-1', callId: 'call-1', approvalId: 'approval-1' }
+];
+const report = auditApprovalTrace(trace);
+if (!report.findings.some(finding => finding.code === 'unknown-call')) throw new Error('Expected adapter ordering diagnostic');
+console.log(JSON.stringify(report, null, 2));

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "tool-approval-correlation-audit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Bounded offline diagnostics for tool approval request, decision and execution observation correlation.",
+  "type": "module",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./src/index.d.ts",
+        "default": "./src/index.js"
+      },
+      "require": {
+        "types": "./src/index.d.cts",
+        "default": "./src/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "src",
+    "examples",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "SECURITY.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test --experimental-test-coverage test/*.test.js",
+    "lint": "node --check src/index.cjs && node --check src/index.js && node --check test/audit.test.js",
+    "build": "node scripts/check-package.js",
+    "example": "node examples/audit.js",
+    "check": "npm run lint && npm test && npm run build && npm run example"
+  },
+  "license": "MIT",
+  "author": "Huzaifa Asif",
+  "keywords": [
+    "tool-calling",
+    "approval",
+    "trace",
+    "diagnostics",
+    "testing"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Huzaifa-Asif/tool-approval-correlation-audit.git"
+  },
+  "homepage": "https://github.com/Huzaifa-Asif/tool-approval-correlation-audit#readme",
+  "bugs": {
+    "url": "https://github.com/Huzaifa-Asif/tool-approval-correlation-audit/issues"
+  }
+}

package/src/index.cjs

@@ -0,0 +1,127 @@
+'use strict';
+
+const DEFAULTS = Object.freeze({ maxEvents: 10000, maxIdentities: 10000, maxIdLength: 256, maxFindings: 1000 });
+const CEILINGS = Object.freeze({ maxEvents: 100000, maxIdentities: 100000, maxIdLength: 4096, maxFindings: 10000 });
+
+/** Audit caller-supplied observations, never authorize an operation. */
+function auditApprovalTrace(events, options = {}) {
+  let config;
+  try {
+    if (options === null || typeof options !== 'object' || Array.isArray(options)) throw 0;
+    config = {};
+    for (const key of Object.keys(DEFAULTS)) {
+      const value = options[key];
+      config[key] = value === undefined ? DEFAULTS[key] : value;
+      if (!Number.isSafeInteger(config[key]) || config[key] < 1 || config[key] > CEILINGS[key]) throw 0;
+    }
+    for (const key of ['traceStart', 'traceEnd']) {
+      const value = options[key];
+      config[key] = value === undefined ? 'complete' : value;
+      if (config[key] !== 'complete' && config[key] !== 'partial') throw 0;
+    }
+  } catch { throw new TypeError('Invalid audit options'); }
+
+  const findings = [];
+  const counts = { observed: 0, calls: 0, requests: 0, decisions: 0, executions: 0, identities: 0, unresolved: 0, issues: 0 };
+  let complete = config.traceStart === 'complete' && config.traceEnd === 'complete';
+  let findingsTruncated = false;
+  const scopes = new Map();
+  const issue = (code, index, relatedIndex) => {
+    counts.issues++;
+    if (findings.length < config.maxFindings) findings.push(Object.freeze(relatedIndex === undefined ? { code, index } : { code, index, relatedIndex }));
+    else { findingsTruncated = true; complete = false; }
+  };
+  const id = value => typeof value === 'string' && value.length > 0 && value.length <= config.maxIdLength;
+  const allocate = index => {
+    if (counts.identities >= config.maxIdentities) { complete = false; issue('identity-limit', index); return false; }
+    counts.identities++;
+    return true;
+  };
+  let length = 0;
+  try {
+    if (!Array.isArray(events)) throw 0;
+    const observedLength = events.length;
+    if (!Number.isSafeInteger(observedLength) || observedLength < 0) throw 0;
+    length = observedLength;
+  } catch { complete = false; issue('invalid-trace', -1); }
+  const readLength = Math.min(length, config.maxEvents);
+  if (length > readLength) { complete = false; issue('event-limit', readLength); }
+  for (let index = 0; index < readLength; index++) {
+    counts.observed++;
+    let event;
+    try {
+      const raw = events[index];
+      if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) throw 0;
+      const type = raw.type;
+      const scope = raw.scope;
+      if (!id(scope) || !['call', 'request', 'decision', 'execution'].includes(type)) throw 0;
+      event = { type, scope };
+      if (type !== 'decision') { event.callId = raw.callId; if (!id(event.callId)) throw 0; }
+      if (type !== 'call') { event.approvalId = raw.approvalId; if (!id(event.approvalId)) throw 0; }
+      if (type === 'decision') { event.decision = raw.decision; if (!['approved', 'denied'].includes(event.decision)) throw 0; }
+    } catch { complete = false; issue('invalid-event', index); continue; }
+    let scope = scopes.get(event.scope);
+    if (!scope) {
+      if (!allocate(index)) break;
+      scope = { calls: new Map(), approvals: new Map() };
+      scopes.set(event.scope, scope);
+    }
+    const call = scope.calls.get(event.callId);
+    const approval = scope.approvals.get(event.approvalId);
+    if (event.type === 'call') {
+      counts.calls++;
+      if (call) { call.tainted = true; issue('duplicate-call', index, call.index); }
+      else {
+        if (!allocate(index)) break;
+        scope.calls.set(event.callId, { index, tainted: false, executions: 0, executionIndex: null });
+      }
+    } else if (event.type === 'request') {
+      counts.requests++;
+      if (approval) {
+        approval.tainted = true;
+        issue(approval.callId === event.callId ? 'duplicate-request' : 'approval-rebound', index, approval.index);
+      } else {
+        if (!allocate(index)) break;
+        const missing = !call;
+        if (missing) issue('unknown-call', index);
+        if (call && call.tainted) issue('ambiguous-call', index, call.index);
+        scope.approvals.set(event.approvalId, { index, callId: event.callId, tainted: missing || Boolean(call?.tainted), decision: null, decisionIndex: null, executions: 0 });
+      }
+    } else if (event.type === 'decision') {
+      counts.decisions++;
+      if (!approval) issue('decision-without-request', index);
+      else if (approval.decision !== null) {
+        approval.tainted = true;
+        issue(approval.decision === event.decision ? 'duplicate-decision' : 'conflicting-decision', index, approval.decisionIndex);
+      } else {
+        approval.decision = event.decision;
+        approval.decisionIndex = index;
+      }
+    } else {
+      counts.executions++;
+      const repeatedCall = Boolean(call && call.executions > 0);
+      if (call) {
+        if (repeatedCall) issue('duplicate-execution', index, call.executionIndex);
+        else call.executionIndex = index;
+        call.executions++;
+      }
+      if (!approval) { issue('execution-without-request', index); continue; }
+      if (approval.callId !== event.callId) { approval.tainted = true; issue('execution-call-mismatch', index, approval.index); }
+      if (!call) issue('unknown-call', index);
+      if (approval.tainted || call?.tainted) issue('ambiguous-approval', index, approval.index);
+      if (approval.decision === null) issue('execution-before-decision', index, approval.index);
+      else if (approval.decision === 'denied') issue('execution-after-denial', index, approval.decisionIndex);
+      if (approval.executions++ && !repeatedCall) issue('duplicate-execution', index, approval.index);
+    }
+  }
+  for (const scope of scopes.values()) {
+    for (const approval of scope.approvals.values()) {
+      if (approval.decision === null) {
+        counts.unresolved++;
+        if (config.traceEnd === 'complete') issue('unresolved-request', approval.index);
+      }
+    }
+  }
+  return Object.freeze({ consistent: complete && counts.issues === 0, complete, findingsTruncated, counts: Object.freeze(counts), findings: Object.freeze(findings) });
+}
+module.exports = { auditApprovalTrace };

package/src/index.d.cts

@@ -0,0 +1,22 @@
+export type ApprovalEvent =
+  | Readonly<{ type: 'call'; scope: string; callId: string }>
+  | Readonly<{ type: 'request'; scope: string; callId: string; approvalId: string }>
+  | Readonly<{ type: 'decision'; scope: string; approvalId: string; decision: 'approved' | 'denied' }>
+  | Readonly<{ type: 'execution'; scope: string; callId: string; approvalId: string }>;
+export interface AuditOptions {
+  readonly maxEvents?: number;
+  readonly maxIdentities?: number;
+  readonly maxIdLength?: number;
+  readonly maxFindings?: number;
+  readonly traceStart?: 'complete' | 'partial';
+  readonly traceEnd?: 'complete' | 'partial';
+}
+export type FindingCode = 'invalid-trace' | 'invalid-event' | 'event-limit' | 'identity-limit' | 'duplicate-call' | 'duplicate-request' | 'approval-rebound' | 'unknown-call' | 'ambiguous-call' | 'decision-without-request' | 'duplicate-decision' | 'conflicting-decision' | 'execution-without-request' | 'execution-call-mismatch' | 'ambiguous-approval' | 'execution-before-decision' | 'execution-after-denial' | 'duplicate-execution' | 'unresolved-request';
+export interface AuditReport {
+  readonly consistent: boolean;
+  readonly complete: boolean;
+  readonly findingsTruncated: boolean;
+  readonly counts: Readonly<{ observed: number; calls: number; requests: number; decisions: number; executions: number; identities: number; unresolved: number; issues: number }>;
+  readonly findings: readonly Readonly<{ code: FindingCode; index: number; relatedIndex?: number }>[];
+}
+export declare function auditApprovalTrace(events: readonly ApprovalEvent[], options?: AuditOptions): AuditReport;

package/src/index.d.ts

@@ -0,0 +1,22 @@
+export type ApprovalEvent =
+  | Readonly<{ type: 'call'; scope: string; callId: string }>
+  | Readonly<{ type: 'request'; scope: string; callId: string; approvalId: string }>
+  | Readonly<{ type: 'decision'; scope: string; approvalId: string; decision: 'approved' | 'denied' }>
+  | Readonly<{ type: 'execution'; scope: string; callId: string; approvalId: string }>;
+export interface AuditOptions {
+  readonly maxEvents?: number;
+  readonly maxIdentities?: number;
+  readonly maxIdLength?: number;
+  readonly maxFindings?: number;
+  readonly traceStart?: 'complete' | 'partial';
+  readonly traceEnd?: 'complete' | 'partial';
+}
+export type FindingCode = 'invalid-trace' | 'invalid-event' | 'event-limit' | 'identity-limit' | 'duplicate-call' | 'duplicate-request' | 'approval-rebound' | 'unknown-call' | 'ambiguous-call' | 'decision-without-request' | 'duplicate-decision' | 'conflicting-decision' | 'execution-without-request' | 'execution-call-mismatch' | 'ambiguous-approval' | 'execution-before-decision' | 'execution-after-denial' | 'duplicate-execution' | 'unresolved-request';
+export interface AuditReport {
+  readonly consistent: boolean;
+  readonly complete: boolean;
+  readonly findingsTruncated: boolean;
+  readonly counts: Readonly<{ observed: number; calls: number; requests: number; decisions: number; executions: number; identities: number; unresolved: number; issues: number }>;
+  readonly findings: readonly Readonly<{ code: FindingCode; index: number; relatedIndex?: number }>[];
+}
+export declare function auditApprovalTrace(events: readonly ApprovalEvent[], options?: AuditOptions): AuditReport;

package/src/index.js

@@ -0,0 +1,2 @@
+import core from './index.cjs';
+export const { auditApprovalTrace } = core;