@catp-protocol/cli 0.7.3 → 0.7.5

package/dist/audit/durable.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Narrow filesystem seam used by the durable primitives. Production code binds
+ * this to node:fs; unit tests inject a fake to assert operation order and to
+ * inject failures without touching a real disk.
+ */
+export interface DurableFs {
+    existsSync(path: string): boolean;
+    mkdirSync(path: string, opts: {
+        recursive: boolean;
+        mode: number;
+    }): void;
+    openSync(path: string, flags: string, mode: number): number;
+    writeSync(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null): number;
+    fsyncSync(fd: number): void;
+    closeSync(fd: number): void;
+    readFileSync(path: string): Buffer;
+    renameSync(oldPath: string, newPath: string): void;
+    unlinkSync(path: string): void;
+    /** Size of a file in bytes, used to record the pre-append rollback point. */
+    statSync(path: string): {
+        size: number;
+    };
+    /** Truncate an open file to `len` bytes, used to roll back a torn append. */
+    ftruncateSync(fd: number, len: number): void;
+}
+/** Production binding of {@link DurableFs} to node:fs. */
+export declare const nodeFs: DurableFs;
+/**
+ * Create `path` (and any missing ancestors) and make the new directory entries
+ * durable. Missing components are collected before creation, created with
+ * 0o700, then fsynced from the deepest component upward followed by the
+ * deepest pre-existing ancestor. If `path` already exists this is a no-op.
+ */
+export declare function ensureDirectoryDurable(path: string, fs?: DurableFs): void;
+/**
+ * Durably append one line to a JSONL-style log file. Sequence: create parent
+ * directories, open append/create with 0o600, write the complete UTF-8 line
+ * plus exactly one newline, fsync the file, close it, and fsync the parent
+ * directory when the file was newly created.
+ *
+ * Torn-append safety: the pre-append file length is recorded first (inside the
+ * caller's audit lock, so no other appender can interleave). If the write or
+ * fsync fails after some bytes may have landed, the file is truncated back to
+ * that length and flushed before the ORIGINAL error propagates, so a partial
+ * line can never be left behind to corrupt every subsequent append. A crash
+ * that prevents this handler from running is recovered explicitly by
+ * `repairAuditLogTail` (`catp log repair`), never silently by the append path.
+ */
+export declare function durableAppendLine(path: string, line: string, fs?: DurableFs): void;
+/**
+ * Durably create an empty file (and its parent directories) if it does not
+ * already exist: open append/create with 0o600, fsync the new file, close it,
+ * then fsync the parent directory. When the file already exists the barrier is
+ * re-established (fsync the existing file + its parent directory) WITHOUT
+ * writing any bytes, so a prior attempt that created the file and then failed
+ * the parent-dir fsync cannot leave a non-durable entry behind on retry. This
+ * is used to materialize the audit log so a lock manager that resolves the
+ * target realpath never bypasses the new-file durability path.
+ */
+export declare function durableCreateEmptyFile(path: string, fs?: DurableFs): void;
+/**
+ * Durably write content-addressed `bytes` to `path` via a same-directory temp
+ * file: create parents, write the temp with 0o600, fsync it, close, atomically
+ * rename onto the target, then fsync the parent directory.
+ *
+ * If the target already exists its bytes are compared: identical bytes
+ * re-establish the durability barrier (fsync the existing file, then its parent
+ * directory) and succeed WITHOUT rewriting, so a retry after "rename succeeded,
+ * parent-dir fsync failed" cannot skip the barrier; differing bytes are reported
+ * as corruption. Descriptors are closed and the temp file removed on any
+ * failure while preserving the original exception.
+ */
+export declare function durableWriteContentAddressed(path: string, bytes: Uint8Array, fs?: DurableFs): void;
+/**
+ * Storage seam threaded through the audit logger and hook options. It exists
+ * solely so tests can inject failures; CLI execution always uses
+ * {@link nodeAuditStorage}.
+ */
+export interface AuditStorage {
+    ensureDirectoryDurable(path: string): void;
+    createEmptyFile(path: string): void;
+    appendLine(path: string, line: string): void;
+    writeContentAddressed(path: string, bytes: Uint8Array): void;
+}
+/** Production {@link AuditStorage} backed by the fsync durable primitives. */
+export declare const nodeAuditStorage: AuditStorage;
+//# sourceMappingURL=durable.d.ts.map

package/dist/audit/durable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable.d.ts","sourceRoot":"","sources":["../../src/audit/durable.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5D,SAAS,CACP,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GAAG,IAAI,GACtB,MAAM,CAAC;IACV,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,6EAA6E;IAC7E,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9C;AAED,0DAA0D;AAC1D,eAAO,MAAM,MAAM,EAAE,SAyBpB,CAAC;AA8CF;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAE,SAAkB,GAAG,IAAI,CAsBjF;AAiBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAE,SAAkB,GAAG,IAAI,CAoC1F;AASD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAE,SAAkB,GAAG,IAAI,CA4BjF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,UAAU,EACjB,EAAE,GAAE,SAAkB,GACrB,IAAI,CAiDN;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;CAC9D;AAED,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,EAAE,YAK9B,CAAC"}

package/dist/audit/durable.js

@@ -0,0 +1,285 @@
+import { closeSync, existsSync, fsyncSync, ftruncateSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync, } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+/** Production binding of {@link DurableFs} to node:fs. */
+export const nodeFs = {
+    existsSync: (p) => existsSync(p),
+    mkdirSync: (p, opts) => {
+        mkdirSync(p, opts);
+    },
+    openSync: (p, flags, mode) => openSync(p, flags, mode),
+    writeSync: (fd, buffer, offset, length, position) => writeSync(fd, buffer, offset, length, position),
+    fsyncSync: (fd) => {
+        fsyncSync(fd);
+    },
+    closeSync: (fd) => {
+        closeSync(fd);
+    },
+    readFileSync: (p) => readFileSync(p),
+    renameSync: (o, n) => {
+        renameSync(o, n);
+    },
+    unlinkSync: (p) => {
+        unlinkSync(p);
+    },
+    statSync: (p) => statSync(p),
+    ftruncateSync: (fd, len) => {
+        ftruncateSync(fd, len);
+    },
+};
+const FILE_MODE = 0o600;
+const DIR_MODE = 0o700;
+/**
+ * Write every byte of `buffer`, looping until the whole buffer is consumed. A
+ * single writeSync call is not guaranteed to consume the entire buffer, so the
+ * returned count is advanced explicitly.
+ */
+function writeFull(fs, fd, buffer) {
+    let offset = 0;
+    while (offset < buffer.byteLength) {
+        const written = fs.writeSync(fd, buffer, offset, buffer.byteLength - offset, null);
+        if (written <= 0) {
+            throw new Error("durable write failed to make progress");
+        }
+        offset += written;
+    }
+}
+/** fsync a directory so a newly created directory entry becomes durable. */
+function fsyncDirectory(fs, dir) {
+    const fd = fs.openSync(dir, "r", DIR_MODE);
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * fsync an existing regular file so its data and inode metadata are durable.
+ * Opened read-only with FILE_MODE; fsync does not require write access. This is
+ * the file half of the barrier the idempotent paths below re-run so a retry
+ * after a partial failure cannot report durability it never established.
+ */
+function fsyncExistingFile(fs, path) {
+    const fd = fs.openSync(path, "r", FILE_MODE);
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Create `path` (and any missing ancestors) and make the new directory entries
+ * durable. Missing components are collected before creation, created with
+ * 0o700, then fsynced from the deepest component upward followed by the
+ * deepest pre-existing ancestor. If `path` already exists this is a no-op.
+ */
+export function ensureDirectoryDurable(path, fs = nodeFs) {
+    const target = resolve(path);
+    const missing = [];
+    let probe = target;
+    while (!fs.existsSync(probe)) {
+        missing.unshift(probe);
+        const parent = dirname(probe);
+        if (parent === probe)
+            break; // reached the filesystem root
+        probe = parent;
+    }
+    if (missing.length === 0)
+        return; // nothing created, nothing to flush
+    fs.mkdirSync(target, { recursive: true, mode: DIR_MODE });
+    for (let i = missing.length - 1; i >= 0; i--) {
+        fsyncDirectory(fs, missing[i]);
+    }
+    // Flush the pre-existing parent that now holds the shallowest new entry.
+    // Skip when the walk terminated at the filesystem root, in which case probe
+    // is itself one of the newly created components and was already flushed.
+    if (!missing.includes(probe)) {
+        fsyncDirectory(fs, probe);
+    }
+}
+/**
+ * Attach a rollback failure to the primary write/fsync error without masking
+ * it. The original error is what the caller must observe to fail closed, but a
+ * failed rollback (the file could not be restored to its pre-append length) is
+ * critical diagnostic context, so it is surfaced in the message and kept as the
+ * error `cause`.
+ */
+function annotateRollbackFailure(primary, rollbackErr) {
+    const rollbackMsg = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+    if (primary instanceof Error) {
+        primary.message = `${primary.message} (torn-append rollback also failed: ${rollbackMsg})`;
+        primary.cause = rollbackErr;
+    }
+}
+/**
+ * Durably append one line to a JSONL-style log file. Sequence: create parent
+ * directories, open append/create with 0o600, write the complete UTF-8 line
+ * plus exactly one newline, fsync the file, close it, and fsync the parent
+ * directory when the file was newly created.
+ *
+ * Torn-append safety: the pre-append file length is recorded first (inside the
+ * caller's audit lock, so no other appender can interleave). If the write or
+ * fsync fails after some bytes may have landed, the file is truncated back to
+ * that length and flushed before the ORIGINAL error propagates, so a partial
+ * line can never be left behind to corrupt every subsequent append. A crash
+ * that prevents this handler from running is recovered explicitly by
+ * `repairAuditLogTail` (`catp log repair`), never silently by the append path.
+ */
+export function durableAppendLine(path, line, fs = nodeFs) {
+    const dir = dirname(path);
+    ensureDirectoryDurable(dir, fs);
+    const existed = fs.existsSync(path);
+    // Rollback boundary: for an existing file this is its current length; for a
+    // brand-new file it is 0 (a failed create leaves an empty file, not a torn one).
+    const originalSize = existed ? fs.statSync(path).size : 0;
+    const fd = fs.openSync(path, "a", FILE_MODE);
+    let closed = false;
+    try {
+        writeFull(fs, fd, Buffer.from(line + "\n", "utf8"));
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        closed = true;
+    }
+    catch (err) {
+        // Roll back the torn append, then close without letting a secondary close
+        // error (POSIX can report a pending EIO on close after a failed fsync) mask
+        // the original write/fsync failure the caller must observe to fail closed.
+        if (!closed) {
+            try {
+                fs.ftruncateSync(fd, originalSize);
+                fs.fsyncSync(fd);
+            }
+            catch (rollbackErr) {
+                annotateRollbackFailure(err, rollbackErr);
+            }
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // preserve the original exception
+            }
+        }
+        throw err;
+    }
+    if (!existed) {
+        fsyncDirectory(fs, dir);
+    }
+}
+let tempCounter = 0;
+function uniqueTempPath(dir, base) {
+    tempCounter = (tempCounter + 1) % Number.MAX_SAFE_INTEGER;
+    return join(dir, `.${base}.${process.pid}.${Date.now()}.${tempCounter}.tmp`);
+}
+/**
+ * Durably create an empty file (and its parent directories) if it does not
+ * already exist: open append/create with 0o600, fsync the new file, close it,
+ * then fsync the parent directory. When the file already exists the barrier is
+ * re-established (fsync the existing file + its parent directory) WITHOUT
+ * writing any bytes, so a prior attempt that created the file and then failed
+ * the parent-dir fsync cannot leave a non-durable entry behind on retry. This
+ * is used to materialize the audit log so a lock manager that resolves the
+ * target realpath never bypasses the new-file durability path.
+ */
+export function durableCreateEmptyFile(path, fs = nodeFs) {
+    const dir = dirname(path);
+    ensureDirectoryDurable(dir, fs);
+    if (fs.existsSync(path)) {
+        // Idempotent path: re-run the barrier rather than returning blindly. A
+        // previous call may have created the file and thrown at the dir fsync, so
+        // success here must still imply the file's existence is durable.
+        fsyncExistingFile(fs, path);
+        fsyncDirectory(fs, dir);
+        return;
+    }
+    const fd = fs.openSync(path, "a", FILE_MODE);
+    let closed = false;
+    try {
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        closed = true;
+    }
+    catch (err) {
+        if (!closed) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // preserve the original exception
+            }
+        }
+        throw err;
+    }
+    fsyncDirectory(fs, dir);
+}
+/**
+ * Durably write content-addressed `bytes` to `path` via a same-directory temp
+ * file: create parents, write the temp with 0o600, fsync it, close, atomically
+ * rename onto the target, then fsync the parent directory.
+ *
+ * If the target already exists its bytes are compared: identical bytes
+ * re-establish the durability barrier (fsync the existing file, then its parent
+ * directory) and succeed WITHOUT rewriting, so a retry after "rename succeeded,
+ * parent-dir fsync failed" cannot skip the barrier; differing bytes are reported
+ * as corruption. Descriptors are closed and the temp file removed on any
+ * failure while preserving the original exception.
+ */
+export function durableWriteContentAddressed(path, bytes, fs = nodeFs) {
+    const dir = dirname(path);
+    ensureDirectoryDurable(dir, fs);
+    if (fs.existsSync(path)) {
+        const existing = fs.readFileSync(path);
+        if (Buffer.compare(Buffer.from(bytes), existing) !== 0) {
+            throw new Error(`content-addressed file already exists with different bytes: ${path}`);
+        }
+        // Identical bytes are NOT an automatic success. A prior attempt may have
+        // renamed the temp file into place and then failed the parent-dir fsync, so
+        // neither the file's data nor its directory entry can be assumed durable.
+        // Re-run the full barrier and fail closed if either flush fails; only then
+        // report idempotent success. This is the exact window that let a retry
+        // append an audit entry whose action sidecar was never made durable.
+        fsyncExistingFile(fs, path);
+        fsyncDirectory(fs, dir);
+        return;
+    }
+    const temp = uniqueTempPath(dir, basename(path));
+    const fd = fs.openSync(temp, "w", FILE_MODE);
+    let closed = false;
+    let renamed = false;
+    try {
+        writeFull(fs, fd, bytes);
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        closed = true;
+        fs.renameSync(temp, path);
+        renamed = true;
+        fsyncDirectory(fs, dir);
+    }
+    catch (err) {
+        if (!closed) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // ignore close failure; preserve the original error
+            }
+        }
+        if (!renamed) {
+            try {
+                fs.unlinkSync(temp);
+            }
+            catch {
+                // best-effort temp cleanup; preserve the original error
+            }
+        }
+        throw err;
+    }
+}
+/** Production {@link AuditStorage} backed by the fsync durable primitives. */
+export const nodeAuditStorage = {
+    ensureDirectoryDurable: (path) => ensureDirectoryDurable(path),
+    createEmptyFile: (path) => durableCreateEmptyFile(path),
+    appendLine: (path, line) => durableAppendLine(path, line),
+    writeContentAddressed: (path, bytes) => durableWriteContentAddressed(path, bytes),
+};
+//# sourceMappingURL=durable.js.map

package/dist/audit/durable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable.js","sourceRoot":"","sources":["../../src/audit/durable.ts"],"names":[],"mappings":"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"}

package/dist/audit/logger.d.ts

@@ -1,14 +1,89 @@
-import type { AuditEntry, AuthorizationAction } from "../policy/types.js";
+import { type CanonicalToolActionV1 } from "../evidence/commitments.js";
+import { type AuditStorage } from "./durable.js";
+import type { AuditEntry, AuditEntryV4, AuthorizationAction } from "../policy/types.js";
 import type { ToolAction } from "../runtime/types.js";
 import type { RuntimePhase } from "../runtime/types.js";
 export declare function computeCommitment(tool: string, decision: "allow" | "deny", ts: string, prev?: string, ruleMatched?: string | null, inputSummary?: string, authorization?: AuthorizationAction, commitmentVersion?: 1 | 2 | 3, phase?: RuntimePhase): string;
 export declare function summarizeInput(input: ToolAction): string;
+export interface AuditEntryV4Fields {
+    phase: RuntimePhase;
+    tool: string;
+    decision: "allow" | "deny";
+    ts: string;
+    ruleMatched: string | null;
+    reason: string;
+    inputSummary: string;
+    policyCommitment: string;
+    actionCommitment: string;
+    authorization?: AuthorizationAction;
+    prev: string;
+}
+/**
+ * Version-4 entry commitment. Covers every security-relevant field with a
+ * domain separator: prev_commitment, phase, tool, decision, ts, rule, reason,
+ * the enforcement-time policy commitment, and the complete-action commitment.
+ * `inputSummary` is chained for display tamper-evidence only; the authoritative
+ * action binding is `actionCommitment`.
+ */
+export declare function computeCommitmentV4(fields: AuditEntryV4Fields): string;
 export declare function auditDir(agentId: string): string;
 export declare function getLastCommitment(agentId: string): string;
-export declare function appendAuditEntry(agentId: string, entry: AuditEntry): void;
+export declare function appendAuditEntry(agentId: string, entry: AuditEntry, storage?: AuditStorage): void;
+/**
+ * Append a v4 entry produced by `build`, persisting the complete canonical
+ * action as a content-addressed sidecar BEFORE the entry that references it.
+ *
+ * The sidecar write and the entry append both happen while holding the same
+ * per-log lock used to choose `prev_commitment`, so the ordering is atomic with
+ * respect to concurrent appends. A crash may leave an unreferenced sidecar, but
+ * never a committed entry whose action evidence was not flushed first. Any
+ * storage/fsync error propagates so the caller (pre-hook) can fail closed.
+ */
 export declare function appendChainedAuditEntry<T extends {
-    auditEntry: AuditEntry;
-}>(agentId: string, build: (prevCommitment: string) => T): T;
-export declare function buildEntry(input: ToolAction, decision: "allow" | "deny", ruleMatched: string | null, prevCommitment?: string): AuditEntry;
+    auditEntry: AuditEntryV4;
+    action: CanonicalToolActionV1;
+}>(agentId: string, build: (prevCommitment: string) => T, storage?: AuditStorage): T;
+export interface AuditEntryBindings {
+    reason: string;
+    policyCommitment: string;
+    actionCommitment: string;
+}
+/**
+ * Build a version-4 audit entry that binds the decision to the exact
+ * enforcement-time policy commitment and complete-action commitment. The caller
+ * (enforcement core) computes both commitments from the normalized policy and
+ * canonical action used for the decision; this function never recomputes them
+ * from mutable files.
+ */
+export declare function buildEntry(input: ToolAction, decision: "allow" | "deny", ruleMatched: string | null, prevCommitment: string, bindings: AuditEntryBindings): AuditEntryV4;
 export declare function extractAuthorizationAction(input: ToolAction): AuthorizationAction | undefined;
+export interface AuditRepairResult {
+    file: string;
+    /** `clean` = nothing to remove; `repaired` = a torn fragment was truncated. */
+    status: "clean" | "repaired";
+    /** Number of complete, chain-verified entries retained after the repair. */
+    entries: number;
+    /** The unterminated fragment that was truncated, or null when clean. */
+    removedFragment: string | null;
+    removedBytes: number;
+}
+/**
+ * Explicitly repair a torn audit-log tail left by a crashed append. This is the
+ * ONLY sanctioned recovery path for a partial final line; the append path itself
+ * stays fail-closed and never self-heals silently.
+ *
+ * Lock-protected (same per-log lock appends use) and deliberately conservative:
+ * 1. The complete, newline-terminated prefix is parsed and its hash chain
+ *    verified BEFORE anything is removed. A corrupt or chain-broken COMPLETE
+ *    entry is never auto-deleted -- such a file is reported and left untouched.
+ * 2. Only a trailing fragment that CANNOT be a complete JSONL entry (it does not
+ *    parse as JSON) is truncated, back to the last verified newline boundary.
+ * 3. A trailing fragment that DOES parse as a complete JSON object is left
+ *    alone and reported: it may be a genuine entry whose newline never flushed,
+ *    so guessing would risk destroying valid evidence.
+ *
+ * Repairs the current (today's) daily log for the agent, which is the file new
+ * appends target and therefore the one a torn tail would block.
+ */
+export declare function repairAuditLogTail(agentId: string, storage?: AuditStorage): AuditRepairResult;
 //# sourceMappingURL=logger.d.ts.map

package/dist/audit/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/audit/logger.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAexD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,GAAG,MAAM,EAC1B,EAAE,EAAE,MAAM,EACV,IAAI,GAAE,MAAY,EAClB,WAAW,GAAE,MAAM,GAAG,IAAW,EACjC,YAAY,GAAE,MAAW,EACzB,aAAa,CAAC,EAAE,mBAAmB,EACnC,iBAAiB,GAAE,CAAC,GAAG,CAAC,GAAG,CAAK,EAChC,KAAK,CAAC,EAAE,YAAY,GACnB,MAAM,CASR;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAGxD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAIzD;AAsCD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAKzE;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS;IAAE,UAAU,EAAE,UAAU,CAAA;CAAE,EAC1E,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,CAAC,GACnC,CAAC,CAUH;AAkCD,wBAAgB,UAAU,CACxB,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,OAAO,GAAG,MAAM,EAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,cAAc,GAAE,MAAY,GAC3B,UAAU,CA4BZ;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,mBAAmB,GAAG,SAAS,CAsB7F"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/audit/logger.ts"],"names":[],"mappings":"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"}