@zintrust/trace 0.4.75 → 0.4.77

package/dist/utils/entryFilter.js

@@ -0,0 +1,95 @@
+import { EntryType } from '../types.js';
+const isObjectValue = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const normalizeTerms = (terms) => {
+    if (!Array.isArray(terms))
+        return [];
+    return terms
+        .filter((term) => typeof term === 'string')
+        .map((term) => term.trim().toLowerCase())
+        .filter((term) => term !== '');
+};
+const matchesRule = (haystack, rule) => {
+    if (!rule)
+        return true;
+    const include = normalizeTerms(rule.include);
+    const exclude = normalizeTerms(rule.exclude);
+    if (exclude.some((term) => haystack.includes(term)))
+        return false;
+    if (include.length === 0)
+        return true;
+    return include.some((term) => haystack.includes(term));
+};
+const toSearchableText = (entry) => {
+    const sections = [entry.type, entry.batchId, ...(entry.tags ?? [])];
+    try {
+        sections.push(JSON.stringify(entry.content) ?? '');
+    }
+    catch {
+        sections.push(String(entry.content ?? ''));
+    }
+    return sections.join(' ').toLowerCase();
+};
+const watcherKeyByEntryType = {
+    [EntryType.REQUEST]: 'request',
+    [EntryType.QUERY]: 'query',
+    [EntryType.EXCEPTION]: 'exception',
+    [EntryType.LOG]: 'log',
+    [EntryType.JOB]: 'job',
+    [EntryType.CACHE]: 'cache',
+    [EntryType.SCHEDULE]: 'schedule',
+    [EntryType.MAIL]: 'mail',
+    [EntryType.AUTH]: 'auth',
+    [EntryType.EVENT]: 'event',
+    [EntryType.MODEL]: 'model',
+    [EntryType.NOTIFICATION]: 'notification',
+    [EntryType.REDIS]: 'redis',
+    [EntryType.GATE]: 'gate',
+    [EntryType.MIDDLEWARE]: 'middleware',
+    [EntryType.COMMAND]: 'command',
+    [EntryType.BATCH]: 'batch',
+    [EntryType.DUMP]: 'dump',
+    [EntryType.VIEW]: 'view',
+    [EntryType.CLIENT_REQUEST]: 'clientRequest',
+};
+const getRequestMethodRule = (watcher, entry) => {
+    if (entry.type !== EntryType.REQUEST)
+        return undefined;
+    const content = isObjectValue(entry.content) ? entry.content : undefined;
+    const methodValue = content?.['method'];
+    const method = typeof methodValue === 'string' ? methodValue.trim().toLowerCase() : '';
+    if (method === 'get')
+        return watcher.get;
+    if (method === 'post')
+        return watcher.post;
+    if (method === 'put')
+        return watcher.put;
+    if (method === 'patch')
+        return watcher.patch;
+    if (method === 'delete' || method === 'del')
+        return watcher.delete;
+    return watcher.all;
+};
+export const TraceEntryFilter = Object.freeze({
+    shouldCapture(entry, config) {
+        const watcherKey = watcherKeyByEntryType[entry.type];
+        const watcher = config.watchers[watcherKey];
+        if (watcher === false)
+            return false;
+        if (!isObjectValue(watcher))
+            return true;
+        const haystack = toSearchableText(entry);
+        if (!matchesRule(haystack, watcher))
+            return false;
+        if (watcherKey === 'request') {
+            const requestWatcher = watcher;
+            const methodRule = getRequestMethodRule(requestWatcher, entry);
+            if (!matchesRule(haystack, requestWatcher.all))
+                return false;
+            if (!matchesRule(haystack, methodRule))
+                return false;
+        }
+        return true;
+    },
+});

package/dist/utils/redact.d.ts

@@ -2,5 +2,6 @@
  * Redaction helpers for @zintrust/trace watchers.
  */
 export declare const redactHeaders: (headers: Record<string, string>, fields: string[]) => Record<string, string>;
+export declare const redactUnknown: (value: unknown, fields: string[]) => unknown;
 export declare const redactObject: (obj: Record<string, unknown>, fields: string[]) => Record<string, unknown>;
 export declare const redactString: (value: string, fields: string[]) => string;

package/dist/utils/redact.js

@@ -1,7 +1,42 @@
 /**
  * Redaction helpers for @zintrust/trace watchers.
  */
-const REDACTED = '[REDACTED]';
+const REDACTED = '****';
+const isArrayValue = (value) => Array.isArray(value);
+const isObjectValue = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const normalizeFields = (fields) => {
+    const normalized = new Set();
+    for (const field of fields) {
+        if (typeof field !== 'string')
+            continue;
+        const key = field.trim().toLowerCase();
+        if (key !== '')
+            normalized.add(key);
+    }
+    return normalized;
+};
+const redactUnknownValue = (value, fields, seen) => {
+    if (isArrayValue(value)) {
+        return value.map((item) => redactUnknownValue(item, fields, seen));
+    }
+    if (!isObjectValue(value)) {
+        return value;
+    }
+    if (seen.has(value)) {
+        return '[Circular]';
+    }
+    seen.add(value);
+    const out = {};
+    for (const [key, entryValue] of Object.entries(value)) {
+        out[key] = fields.has(key.toLowerCase())
+            ? REDACTED
+            : redactUnknownValue(entryValue, fields, seen);
+    }
+    seen.delete(value);
+    return out;
+};
 const redactQuerySegment = (segment, fields) => {
     const separatorIndex = segment.indexOf('=');
     if (separatorIndex <= 0)
@@ -13,23 +48,22 @@ const redactQuerySegment = (segment, fields) => {
     return `${key}=${REDACTED}`;
 };
 export const redactHeaders = (headers, fields) => {
-    const lower = new Set(fields.map((f) => f.toLowerCase()));
+    const lower = normalizeFields(fields);
     const out = {};
     for (const [k, v] of Object.entries(headers)) {
         out[k] = lower.has(k.toLowerCase()) ? REDACTED : v;
     }
     return out;
 };
+export const redactUnknown = (value, fields) => {
+    return redactUnknownValue(value, normalizeFields(fields), new WeakSet());
+};
 export const redactObject = (obj, fields) => {
-    const lower = new Set(fields.map((f) => f.toLowerCase()));
-    const out = {};
-    for (const [k, v] of Object.entries(obj)) {
-        out[k] = lower.has(k.toLowerCase()) ? REDACTED : v;
-    }
-    return out;
+    const redacted = redactUnknown(obj, fields);
+    return isObjectValue(redacted) ? redacted : {};
 };
 export const redactString = (value, fields) => {
-    const lower = new Set(fields.map((f) => f.toLowerCase()));
+    const lower = normalizeFields(fields);
     if (value === '')
         return value;
     let output = '';

package/dist/utils/requestFilter.js

@@ -1,4 +1,4 @@
-import { TraceContext } from '../context';
+import { TraceContext } from '../context.js';
 const normalizePath = (input) => {
     const trimmed = input.trim();
     const [pathOnly] = trimmed.split('?');

package/dist/watchers/AuthWatcher.js

@@ -2,9 +2,9 @@
  * AuthWatcher — records login/logout/failed auth events.
  * Credentials are never stored; only the outcome.
  */
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (event, userId) => {

package/dist/watchers/BatchWatcher.js

@@ -1,6 +1,6 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (name, total, processed, failed, status) => {

package/dist/watchers/CacheWatcher.js

@@ -2,11 +2,11 @@
  * CacheWatcher — records cache operations.
  * Call CacheWatcher.emit() from within your cache driver instrumentation.
  */
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { redactString } from '../utils/redact';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { redactString } from '../utils/redact.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _redactionFields = [];
 let _ignoreRoutes = [];

package/dist/watchers/CommandWatcher.js

@@ -1,7 +1,7 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { redactObject } from '../utils/redact';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { redactObject } from '../utils/redact.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _redactKeys = [];
 let _ignoreRoutes = [];
@@ -39,7 +39,7 @@ export const CommandWatcher = Object.freeze({
         if (config.watchers.command === false)
             return () => undefined;
         _storage = storage;
-        _redactKeys = config.redaction?.body ?? [];
+        _redactKeys = [...(config.redaction?.keys ?? []), ...(config.redaction?.body ?? [])];
         _ignoreRoutes = config.ignoreRoutes;
         return () => {
             _storage = null;

package/dist/watchers/DumpWatcher.js

@@ -1,6 +1,6 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _enabled = false;
 let _ignoreRoutes = [];

package/dist/watchers/EventWatcher.js

@@ -1,7 +1,7 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (name, listenerCount, payload) => {

package/dist/watchers/ExceptionWatcher.js

@@ -4,12 +4,12 @@
  * from within its error handler, or the register() side-effect adds a
  * process-level unhandledRejection/uncaughtException listener as fallback.
  */
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { familyHash } from '../utils/familyHash';
-import { RequestFilter } from '../utils/requestFilter';
-import { parseStackFrameLine } from '../utils/stackFrame';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { familyHash } from '../utils/familyHash.js';
+import { RequestFilter } from '../utils/requestFilter.js';
+import { parseStackFrameLine } from '../utils/stackFrame.js';
 const getLinePreview = (_file, _line) => {
     return {};
 };

package/dist/watchers/GateWatcher.js

@@ -1,6 +1,6 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (ability, result, userId, subject) => {

package/dist/watchers/HttpClientWatcher.js

@@ -1,8 +1,8 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { redactHeaders } from '../utils/redact';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { redactHeaders } from '../utils/redact.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _redactHeaderNames = [];
 let _ignoreRoutes = [];
@@ -40,7 +40,7 @@ export const HttpClientWatcher = Object.freeze({
         if (config.watchers.clientRequest === false)
             return () => undefined;
         _storage = storage;
-        _redactHeaderNames = config.redaction?.headers ?? [];
+        _redactHeaderNames = [...(config.redaction?.keys ?? []), ...(config.redaction?.headers ?? [])];
         _ignoreRoutes = config.ignoreRoutes;
         return () => {
             _storage = null;

package/dist/watchers/HttpWatcher.js

@@ -1,8 +1,8 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { redactHeaders, redactObject } from '../utils/redact';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { redactHeaders, redactObject, redactUnknown } from '../utils/redact.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 const normalizeHeaders = (headers) => {
     if (!headers)
         return {};
@@ -14,16 +14,91 @@ const normalizeHeaders = (headers) => {
         return [];
     }));
 };
-const buildEntry = (req, res, start, config) => {
-    const headers = redactHeaders(normalizeHeaders(req.headers), config.redaction.headers);
-    const payload = req.body ? redactObject(req.body, config.redaction.body) : {};
+const normalizeHeaderValue = (value) => {
+    return Array.isArray(value) ? value.join(', ') : value;
+};
+const registerCompletionHandler = (response, onComplete) => {
+    const raw = response.getRaw();
+    if (typeof raw.once !== 'function')
+        return () => undefined;
+    let completed = false;
+    const cleanup = () => {
+        if (typeof raw.off === 'function') {
+            raw.off('finish', markCompleted);
+            raw.off('close', markCompleted);
+        }
+    };
+    const markCompleted = () => {
+        if (completed)
+            return;
+        completed = true;
+        cleanup();
+        onComplete();
+    };
+    raw.once('finish', markCompleted);
+    raw.once('close', markCompleted);
+    return cleanup;
+};
+const captureResponse = (response, config) => {
+    const headers = {};
+    const redactFields = [...config.redaction.keys, ...config.redaction.body];
+    const originalSetHeader = response.setHeader;
+    const originalJson = response.json;
+    const originalText = response.text;
+    const originalHtml = response.html;
+    const originalSend = response.send;
+    const capture = {
+        headers,
+        body: undefined,
+        restore() {
+            response.setHeader = originalSetHeader;
+            response.json = originalJson;
+            response.text = originalText;
+            response.html = originalHtml;
+            response.send = originalSend;
+        },
+    };
+    response.setHeader = function setHeader(name, value) {
+        headers[name] = normalizeHeaderValue(value);
+        return originalSetHeader.call(this, name, value);
+    };
+    response.json = function json(data) {
+        capture.body = redactUnknown(data, redactFields);
+        originalJson.call(this, data);
+    };
+    response.text = function text(value) {
+        capture.body = value;
+        originalText.call(this, value);
+    };
+    response.html = function html(value) {
+        capture.body = value;
+        originalHtml.call(this, value);
+    };
+    response.send = function send(data) {
+        capture.body = typeof data === 'string' ? data : `[binary ${data.length} bytes]`;
+        originalSend.call(this, data);
+    };
+    return capture;
+};
+const buildEntry = (req, res, start, config, responseCapture) => {
+    const headers = redactHeaders(normalizeHeaders(req.headers), [
+        ...config.redaction.keys,
+        ...config.redaction.headers,
+    ]);
+    const payload = req.body
+        ? redactObject(req.body, [...config.redaction.keys, ...config.redaction.body])
+        : {};
     return {
         method: req.getMethod(),
         uri: req.getPath(),
         headers,
         payload,
         responseStatus: res.getStatus(),
-        responseHeaders: {},
+        responseHeaders: redactHeaders(responseCapture.headers, [
+            ...config.redaction.keys,
+            ...config.redaction.headers,
+        ]),
+        responseBody: responseCapture.body,
         duration: Date.now() - start,
         memory: TraceContext.getMemory(),
         middleware: [],
@@ -48,22 +123,31 @@ export const HttpWatcher = Object.freeze({
                 return next();
             const start = TraceContext.now();
             const batchId = TraceContext.getBatchId();
+            const responseCapture = captureResponse(response, config);
+            let didPersist = false;
+            const persistEntry = () => {
+                if (didPersist)
+                    return;
+                didPersist = true;
+                const content = buildEntry(request, response, start, config, responseCapture);
+                const tags = AuthTag.append([]);
+                if (content.responseStatus >= 500)
+                    tags.push('failed');
+                responseCapture.restore();
+                storage
+                    .writeEntry({
+                    uuid: crypto.randomUUID(),
+                    batchId,
+                    type: EntryType.REQUEST,
+                    content,
+                    tags,
+                    isLatest: true,
+                    createdAt: TraceContext.now(),
+                })
+                    .catch(() => undefined); // fire-and-forget
+            };
+            registerCompletionHandler(response, persistEntry);
             await next();
-            const content = buildEntry(request, response, start, config);
-            const tags = AuthTag.append([]);
-            if (content.responseStatus >= 500)
-                tags.push('failed');
-            storage
-                .writeEntry({
-                uuid: crypto.randomUUID(),
-                batchId,
-                type: EntryType.REQUEST,
-                content,
-                tags,
-                isLatest: true,
-                createdAt: TraceContext.now(),
-            })
-                .catch(() => undefined); // fire-and-forget
         };
         registerMiddleware(middleware);
         return () => undefined;

package/dist/watchers/JobWatcher.js

@@ -3,10 +3,10 @@
  * Subsystems must call JobWatcher.onDispatch / onProcess / onFail from
  * within their queue implementation for full tracking.
  */
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
-import { parseStackFrameLine } from '../utils/stackFrame';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
+import { parseStackFrameLine } from '../utils/stackFrame.js';
 // Module-level storage ref so emit helpers can be called from outside.
 let _storage = null;
 let _ignoreRoutes = [];

package/dist/watchers/LogWatcher.js

@@ -2,10 +2,11 @@
  * LogWatcher — captures Logger output via Logger.addSink().
  */
 import { Logger } from '@zintrust/core';
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { RequestFilter } from '../utils/requestFilter.js';
+// type LoggerSink = (level: string, message: string, context?: Record<string, unknown>) => void;
 const LEVEL_PRIORITY = {
     debug: 0,
     info: 1,

package/dist/watchers/MailWatcher.js

@@ -2,9 +2,9 @@
  * MailWatcher — records mail dispatch intent.
  * Body is never captured; only to/subject/template.
  */
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (to, subject, template) => {

package/dist/watchers/MiddlewareWatcher.js

@@ -1,6 +1,6 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (name, event, duration) => {

package/dist/watchers/ModelWatcher.js

@@ -1,6 +1,6 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (action, model, id, changes) => {

package/dist/watchers/NotificationWatcher.js

@@ -1,7 +1,7 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (notification, channels, notifiable) => {

package/dist/watchers/QueryWatcher.js

@@ -1,11 +1,11 @@
 /**
  * QueryWatcher — hooks into Database.onAfterQuery to record SQL entries.
  */
-import { TraceContext } from '../context';
-import { TraceStorage } from '../storage';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { TraceStorage } from '../storage/index.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 const bindingsInterpolated = (sql, params) => {
     // Inline params for display only — safe, not for re-execution.
     let i = 0;

package/dist/watchers/RedisWatcher.js

@@ -1,7 +1,7 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { AuthTag } from '../utils/authTag';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { AuthTag } from '../utils/authTag.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 /** Emit a redis command trace. Key/value payload is intentionally omitted for security. */

package/dist/watchers/ScheduleWatcher.js

@@ -1,9 +1,9 @@
 /**
  * ScheduleWatcher — records scheduled task runs and outcomes.
  */
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (name, expression, status, duration, output) => {

package/dist/watchers/ViewWatcher.js

@@ -1,6 +1,6 @@
-import { TraceContext } from '../context';
-import { EntryType } from '../types';
-import { RequestFilter } from '../utils/requestFilter';
+import { TraceContext } from '../context.js';
+import { EntryType } from '../types.js';
+import { RequestFilter } from '../utils/requestFilter.js';
 let _storage = null;
 let _ignoreRoutes = [];
 const emit = (template, duration) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/trace",
-  "version": "0.4.75",
+  "version": "0.4.77",
   "description": "Trace assistant for ZinTrust: logs requests, queries, exceptions, jobs, and more.",
   "private": false,
   "type": "module",
@@ -40,7 +40,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.4.74"
+    "@zintrust/core": "^0.4.77"
   },
   "publishConfig": {
     "access": "public"
@@ -53,7 +53,7 @@
     "telescope"
   ],
   "scripts": {
-    "build": "npx lint-staged",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.migrations.json && node ../../scripts/fix-dist-esm-imports.mjs dist",
     "prepublishOnly": "npm run build"
   }
-}
+}