@bazariodev/docket 0.0.0-stage → 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,159 @@
+import type {
+  LEVELS,
+  LIMITS,
+  LOGGING_ERROR_CODES,
+  LOGGING_ERROR_SOURCES,
+  STORE_MODES,
+} from "./constants.cjs";
+
+type ValueOf<Values> = Values[keyof Values];
+export type LogLevel = ValueOf<typeof LEVELS>;
+export type LogValue =
+  | null
+  | boolean
+  | number
+  | string
+  | readonly LogValue[]
+  | { readonly [key: string]: LogValue };
+export type LogFields = Readonly<Record<string, LogValue>>;
+export type LogContext = Readonly<Record<string, string | number>>;
+export type SerializedError = Readonly<{
+  name: string;
+  message: string;
+  stack?: string;
+  fields?: Readonly<Record<string, LogValue>>;
+  cause?: SerializedError;
+  errors?: readonly SerializedError[];
+}>;
+export type LogRecord = Readonly<{
+  runId: string;
+  seq: number;
+  at: number;
+  level: LogLevel;
+  area: string;
+  scope: string;
+  message: string;
+  redactionVersion: string;
+  fields?: LogFields;
+  context?: LogContext;
+  error?: SerializedError;
+  truncated?: true;
+}>;
+export type LogDraft = Readonly<
+  Omit<LogRecord, 'fields' | 'error' | 'redactionVersion' | 'truncated'> & {
+    data?: unknown;
+  }
+>;
+export type Logger = Readonly<{
+  debug: (message: string, data?: unknown) => void;
+  info: (message: string, data?: unknown) => void;
+  warn: (message: string, data?: unknown) => void;
+  error: (message: string, data?: unknown) => void;
+  child: (
+    binding: Readonly<{ scope?: string; context?: LogContext }>,
+  ) => Logger;
+}>;
+export type AreaDefinition<TArea extends string = string> = Readonly<{
+  id: TArea;
+  level?: LogLevel;
+}>;
+export type LevelState = Readonly<{
+  level: LogLevel;
+  defaultLevel: LogLevel;
+  until?: number;
+}>;
+export type LoggingScheduler = Readonly<{
+  setTimeout: (callback: () => void, delayMs: number) => unknown;
+  clearTimeout: (handle: unknown) => void;
+}>;
+export type KeyValueStorage = Readonly<{
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+}>;
+export type LoggingErrorSource = ValueOf<typeof LOGGING_ERROR_SOURCES>;
+export type LoggingError = Error &
+  Readonly<{ code: ValueOf<typeof LOGGING_ERROR_CODES> }>;
+export type LoggingOptions<TArea extends string> = Readonly<{
+  areas: readonly AreaDefinition<TArea>[];
+  redactor: Redactor;
+  sinks?: readonly LogSink[];
+  context?: LogContext;
+  levelStorage?: Readonly<{ storage: KeyValueStorage; key: string }>;
+  maxOverrideMs?: number;
+  stormLimit?: number | false;
+  scheduler?: LoggingScheduler;
+  now?: () => number;
+  monotonicNow?: () => number;
+  createRunId?: () => string;
+  onError?: (error: unknown, source: LoggingErrorSource) => void;
+  isActive?: () => boolean;
+}>;
+export type Logging<TArea extends string> = Readonly<{
+  runId: string;
+  getLogger: (area: TArea, scope: string) => Logger;
+  setLevel: (
+    area: TArea,
+    level: LogLevel,
+    options?: Readonly<{ durationMs?: number }>,
+  ) => void;
+  resetLevel: (area?: TArea) => void;
+  reloadLevels: () => void;
+  getLevels: () => Readonly<Record<TArea, LevelState>>;
+  setContext: (
+    context: Readonly<Record<string, string | number | undefined>>,
+  ) => void;
+  addSink: (sink: LogSink) => () => void;
+  flush: () => Promise<void>;
+  stop: () => Promise<void>;
+}>;
+export declare function createLogging<TArea extends string>(
+  options: LoggingOptions<TArea>,
+): Logging<TArea>;
+
+export type Redactor = Readonly<{
+  version: string;
+  limits: Readonly<{ [Key in keyof typeof LIMITS]: number }>;
+  redact: (draft: LogDraft) => LogRecord;
+  redactValue: (value: unknown) => LogValue;
+  redactText: (text: string) => string;
+  mask: (value: string) => string;
+  hash?: (value: string) => string;
+}>;
+
+export type LogSink = Readonly<{
+  // Finish admission synchronously. The hub ignores the return value.
+  write: (record: LogRecord) => void;
+  flush?: () => Promise<void>;
+  stop?: () => Promise<void>;
+}>;
+export type LogQuery<TArea extends string = string> = Readonly<{
+  areas?: readonly TArea[];
+  from?: number;
+  to?: number;
+}>;
+export type LogStoreStatus = Readonly<{
+  mode: ValueOf<typeof STORE_MODES>;
+  droppedRecords: number;
+  unavailableHistory: boolean;
+  unprotected: boolean;
+  canRecover: boolean;
+}>;
+export type LogSource = Readonly<{
+  query: (query?: LogQuery) => Promise<readonly LogRecord[]>;
+  getStatus?: () => LogStoreStatus;
+}>;
+export type LogStore = LogSink &
+  LogSource &
+  Readonly<{
+    flush: () => Promise<void>;
+    stop: (options?: Readonly<{ discard?: boolean }>) => Promise<void>;
+    clear: () => Promise<void>;
+    getStatus: () => LogStoreStatus;
+  }>;
+export type ConsoleLike = Readonly<
+  Record<LogLevel, (...values: unknown[]) => void>
+>;
+export declare function createConsoleSink(
+  options?: Readonly<{ level?: LogLevel; console?: ConsoleLike }>,
+): LogSink;
+export declare function formatRecord(record: LogRecord): string;

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+import type {
+  LEVELS,
+  LIMITS,
+  LOGGING_ERROR_CODES,
+  LOGGING_ERROR_SOURCES,
+  STORE_MODES,
+} from './constants.js';
+
+type ValueOf<Values> = Values[keyof Values];
+export type LogLevel = ValueOf<typeof LEVELS>;
+export type LogValue =
+  | null
+  | boolean
+  | number
+  | string
+  | readonly LogValue[]
+  | { readonly [key: string]: LogValue };
+export type LogFields = Readonly<Record<string, LogValue>>;
+export type LogContext = Readonly<Record<string, string | number>>;
+export type SerializedError = Readonly<{
+  name: string;
+  message: string;
+  stack?: string;
+  fields?: Readonly<Record<string, LogValue>>;
+  cause?: SerializedError;
+  errors?: readonly SerializedError[];
+}>;
+export type LogRecord = Readonly<{
+  runId: string;
+  seq: number;
+  at: number;
+  level: LogLevel;
+  area: string;
+  scope: string;
+  message: string;
+  redactionVersion: string;
+  fields?: LogFields;
+  context?: LogContext;
+  error?: SerializedError;
+  truncated?: true;
+}>;
+export type LogDraft = Readonly<
+  Omit<LogRecord, 'fields' | 'error' | 'redactionVersion' | 'truncated'> & {
+    data?: unknown;
+  }
+>;
+export type Logger = Readonly<{
+  debug: (message: string, data?: unknown) => void;
+  info: (message: string, data?: unknown) => void;
+  warn: (message: string, data?: unknown) => void;
+  error: (message: string, data?: unknown) => void;
+  child: (
+    binding: Readonly<{ scope?: string; context?: LogContext }>,
+  ) => Logger;
+}>;
+export type AreaDefinition<TArea extends string = string> = Readonly<{
+  id: TArea;
+  level?: LogLevel;
+}>;
+export type LevelState = Readonly<{
+  level: LogLevel;
+  defaultLevel: LogLevel;
+  until?: number;
+}>;
+export type LoggingScheduler = Readonly<{
+  setTimeout: (callback: () => void, delayMs: number) => unknown;
+  clearTimeout: (handle: unknown) => void;
+}>;
+export type KeyValueStorage = Readonly<{
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+}>;
+export type LoggingErrorSource = ValueOf<typeof LOGGING_ERROR_SOURCES>;
+export type LoggingError = Error &
+  Readonly<{ code: ValueOf<typeof LOGGING_ERROR_CODES> }>;
+export type LoggingOptions<TArea extends string> = Readonly<{
+  areas: readonly AreaDefinition<TArea>[];
+  redactor: Redactor;
+  sinks?: readonly LogSink[];
+  context?: LogContext;
+  levelStorage?: Readonly<{ storage: KeyValueStorage; key: string }>;
+  maxOverrideMs?: number;
+  stormLimit?: number | false;
+  scheduler?: LoggingScheduler;
+  now?: () => number;
+  monotonicNow?: () => number;
+  createRunId?: () => string;
+  onError?: (error: unknown, source: LoggingErrorSource) => void;
+  isActive?: () => boolean;
+}>;
+export type Logging<TArea extends string> = Readonly<{
+  runId: string;
+  getLogger: (area: TArea, scope: string) => Logger;
+  setLevel: (
+    area: TArea,
+    level: LogLevel,
+    options?: Readonly<{ durationMs?: number }>,
+  ) => void;
+  resetLevel: (area?: TArea) => void;
+  reloadLevels: () => void;
+  getLevels: () => Readonly<Record<TArea, LevelState>>;
+  setContext: (
+    context: Readonly<Record<string, string | number | undefined>>,
+  ) => void;
+  addSink: (sink: LogSink) => () => void;
+  flush: () => Promise<void>;
+  stop: () => Promise<void>;
+}>;
+export declare function createLogging<TArea extends string>(
+  options: LoggingOptions<TArea>,
+): Logging<TArea>;
+
+export type Redactor = Readonly<{
+  version: string;
+  limits: Readonly<{ [Key in keyof typeof LIMITS]: number }>;
+  redact: (draft: LogDraft) => LogRecord;
+  redactValue: (value: unknown) => LogValue;
+  redactText: (text: string) => string;
+  mask: (value: string) => string;
+  hash?: (value: string) => string;
+}>;
+
+export type LogSink = Readonly<{
+  // Finish admission synchronously. The hub ignores the return value.
+  write: (record: LogRecord) => void;
+  flush?: () => Promise<void>;
+  stop?: () => Promise<void>;
+}>;
+export type LogQuery<TArea extends string = string> = Readonly<{
+  areas?: readonly TArea[];
+  from?: number;
+  to?: number;
+}>;
+export type LogStoreStatus = Readonly<{
+  mode: ValueOf<typeof STORE_MODES>;
+  droppedRecords: number;
+  unavailableHistory: boolean;
+  unprotected: boolean;
+  canRecover: boolean;
+}>;
+export type LogSource = Readonly<{
+  query: (query?: LogQuery) => Promise<readonly LogRecord[]>;
+  getStatus?: () => LogStoreStatus;
+}>;
+export type LogStore = LogSink &
+  LogSource &
+  Readonly<{
+    flush: () => Promise<void>;
+    stop: (options?: Readonly<{ discard?: boolean }>) => Promise<void>;
+    clear: () => Promise<void>;
+    getStatus: () => LogStoreStatus;
+  }>;
+export type ConsoleLike = Readonly<
+  Record<LogLevel, (...values: unknown[]) => void>
+>;
+export declare function createConsoleSink(
+  options?: Readonly<{ level?: LogLevel; console?: ConsoleLike }>,
+): LogSink;
+export declare function formatRecord(record: LogRecord): string;

package/dist/index.js

@@ -0,0 +1,6 @@
+export { c as createConsoleSink, f as formatRecord } from './chunk-DYcNnkOV.js';
+export { c as createLogging } from './chunk-DkvWLziD.js';
+import './chunk-LRCHwVuE.js';
+import './chunk-CSS3f4_M.js';
+import './chunk-7ld72rnl.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/indexeddb/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+function createIndexedDbLogStore(options, createStore) {
+  if (typeof createStore !== 'function')
+    throw new TypeError('An IndexedDB store factory is required');
+  return createStore(databaseOptions(options));
+}
+
+async function clearIndexedDbLogStore(options, clearStore) {
+  if (typeof clearStore !== 'function')
+    throw new TypeError('An IndexedDB cleanup function is required');
+  return clearStore(databaseOptions(options));
+}
+
+function databaseOptions(options) {
+  const { databaseName, lockName } = options ?? {};
+  if (typeof databaseName !== 'string' || !databaseName)
+    throw new TypeError('An IndexedDB database name is required');
+  if (typeof lockName !== 'string' || !lockName)
+    throw new TypeError('An IndexedDB lock name is required');
+  return options;
+}
+
+exports.clearIndexedDbLogStore = clearIndexedDbLogStore;
+exports.createIndexedDbLogStore = createIndexedDbLogStore;
+//# sourceMappingURL=index.cjs.map

package/dist/indexeddb/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../src/indexeddb/index.js"],"sourcesContent":["export function createIndexedDbLogStore(options, createStore) {\n  if (typeof createStore !== 'function')\n    throw new TypeError('An IndexedDB store factory is required');\n  return createStore(databaseOptions(options));\n}\n\nexport async function clearIndexedDbLogStore(options, clearStore) {\n  if (typeof clearStore !== 'function')\n    throw new TypeError('An IndexedDB cleanup function is required');\n  return clearStore(databaseOptions(options));\n}\n\nfunction databaseOptions(options) {\n  const { databaseName, lockName } = options ?? {};\n  if (typeof databaseName !== 'string' || !databaseName)\n    throw new TypeError('An IndexedDB database name is required');\n  if (typeof lockName !== 'string' || !lockName)\n    throw new TypeError('An IndexedDB lock name is required');\n  return options;\n}\n"],"names":[],"mappings":";;AAAO,SAAS,uBAAuB,CAAC,OAAO,EAAE,WAAW,EAAE;AAC9D,EAAE,IAAI,OAAO,WAAW,KAAK,UAAU;AACvC,IAAI,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC;AACjE,EAAE,OAAO,WAAW,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;AAC9C;;AAEO,eAAe,sBAAsB,CAAC,OAAO,EAAE,UAAU,EAAE;AAClE,EAAE,IAAI,OAAO,UAAU,KAAK,UAAU;AACtC,IAAI,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC;AACpE,EAAE,OAAO,UAAU,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;AAC7C;;AAEA,SAAS,eAAe,CAAC,OAAO,EAAE;AAClC,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,IAAI,EAAE;AAClD,EAAE,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,YAAY;AACvD,IAAI,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC;AACjE,EAAE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,QAAQ;AAC/C,IAAI,MAAM,IAAI,SAAS,CAAC,oCAAoC,CAAC;AAC7D,EAAE,OAAO,OAAO;AAChB;;;"}

package/dist/indexeddb/index.d.cts

@@ -0,0 +1,61 @@
+import type { LogRecord, LogStore } from "../index.cjs";
+import type { MemoryLogStoreOptions } from "../storage/contracts.cjs";
+
+export type {
+  LogOverflowStrategy,
+  LogStoreError,
+  MemoryLogStoreOptions,
+} from "../storage/contracts.cjs";
+
+export type IndexedDbLogStoreOptions = Omit<
+  MemoryLogStoreOptions,
+  'isRotationEnabled'
+> &
+  Readonly<{
+    databaseName: string;
+    lockName: string;
+    indexedDB?: IDBFactory;
+    keyRange?: Pick<typeof IDBKeyRange, 'bound' | 'lowerBound'> | null;
+    locks?: Pick<LockManager, 'request'>;
+    allowUnprotected?: boolean;
+    flushIntervalMs?: number;
+    maxBatchSize?: number;
+    maxQueuedRecords?: number;
+    maxQueuedSize?: number;
+    onStatusChange?: () => void;
+    fallback?: Omit<
+      MemoryLogStoreOptions,
+      | 'overflowStrategy'
+      | 'onRotate'
+      | 'onError'
+      | 'scheduler'
+      | 'isRotationEnabled'
+    >;
+  }>;
+export type IndexedDbStoreFactory = (
+  options: IndexedDbLogStoreOptions &
+    Readonly<{
+      isRotationEnabled?: () => boolean;
+    }>,
+) => LogStore;
+export declare function createIndexedDbLogStore(
+  options: IndexedDbLogStoreOptions,
+  createStore: IndexedDbStoreFactory,
+): LogStore;
+export type IndexedDbLogCleanupOptions = Pick<
+  IndexedDbLogStoreOptions,
+  | 'databaseName'
+  | 'lockName'
+  | 'indexedDB'
+  | 'locks'
+  | 'allowUnprotected'
+  | 'scheduler'
+>;
+export type IndexedDbCleanup = (
+  options: IndexedDbLogCleanupOptions,
+) => Promise<void>;
+export declare function clearIndexedDbLogStore(
+  options: IndexedDbLogCleanupOptions,
+  clearStore: IndexedDbCleanup,
+): Promise<void>;
+export type { LogRecord };

package/dist/indexeddb/index.d.ts

@@ -0,0 +1,61 @@
+import type { LogRecord, LogStore } from '../index.js';
+import type { MemoryLogStoreOptions } from '../storage/contracts.js';
+
+export type {
+  LogOverflowStrategy,
+  LogStoreError,
+  MemoryLogStoreOptions,
+} from '../storage/contracts.js';
+
+export type IndexedDbLogStoreOptions = Omit<
+  MemoryLogStoreOptions,
+  'isRotationEnabled'
+> &
+  Readonly<{
+    databaseName: string;
+    lockName: string;
+    indexedDB?: IDBFactory;
+    keyRange?: Pick<typeof IDBKeyRange, 'bound' | 'lowerBound'> | null;
+    locks?: Pick<LockManager, 'request'>;
+    allowUnprotected?: boolean;
+    flushIntervalMs?: number;
+    maxBatchSize?: number;
+    maxQueuedRecords?: number;
+    maxQueuedSize?: number;
+    onStatusChange?: () => void;
+    fallback?: Omit<
+      MemoryLogStoreOptions,
+      | 'overflowStrategy'
+      | 'onRotate'
+      | 'onError'
+      | 'scheduler'
+      | 'isRotationEnabled'
+    >;
+  }>;
+export type IndexedDbStoreFactory = (
+  options: IndexedDbLogStoreOptions &
+    Readonly<{
+      isRotationEnabled?: () => boolean;
+    }>,
+) => LogStore;
+export declare function createIndexedDbLogStore(
+  options: IndexedDbLogStoreOptions,
+  createStore: IndexedDbStoreFactory,
+): LogStore;
+export type IndexedDbLogCleanupOptions = Pick<
+  IndexedDbLogStoreOptions,
+  | 'databaseName'
+  | 'lockName'
+  | 'indexedDB'
+  | 'locks'
+  | 'allowUnprotected'
+  | 'scheduler'
+>;
+export type IndexedDbCleanup = (
+  options: IndexedDbLogCleanupOptions,
+) => Promise<void>;
+export declare function clearIndexedDbLogStore(
+  options: IndexedDbLogCleanupOptions,
+  clearStore: IndexedDbCleanup,
+): Promise<void>;
+export type { LogRecord };

package/dist/indexeddb/index.js

@@ -0,0 +1,23 @@
+function createIndexedDbLogStore(options, createStore) {
+  if (typeof createStore !== 'function')
+    throw new TypeError('An IndexedDB store factory is required');
+  return createStore(databaseOptions(options));
+}
+
+async function clearIndexedDbLogStore(options, clearStore) {
+  if (typeof clearStore !== 'function')
+    throw new TypeError('An IndexedDB cleanup function is required');
+  return clearStore(databaseOptions(options));
+}
+
+function databaseOptions(options) {
+  const { databaseName, lockName } = options ?? {};
+  if (typeof databaseName !== 'string' || !databaseName)
+    throw new TypeError('An IndexedDB database name is required');
+  if (typeof lockName !== 'string' || !lockName)
+    throw new TypeError('An IndexedDB lock name is required');
+  return options;
+}
+
+export { clearIndexedDbLogStore, createIndexedDbLogStore };
+//# sourceMappingURL=index.js.map

package/dist/indexeddb/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/indexeddb/index.js"],"sourcesContent":["export function createIndexedDbLogStore(options, createStore) {\n  if (typeof createStore !== 'function')\n    throw new TypeError('An IndexedDB store factory is required');\n  return createStore(databaseOptions(options));\n}\n\nexport async function clearIndexedDbLogStore(options, clearStore) {\n  if (typeof clearStore !== 'function')\n    throw new TypeError('An IndexedDB cleanup function is required');\n  return clearStore(databaseOptions(options));\n}\n\nfunction databaseOptions(options) {\n  const { databaseName, lockName } = options ?? {};\n  if (typeof databaseName !== 'string' || !databaseName)\n    throw new TypeError('An IndexedDB database name is required');\n  if (typeof lockName !== 'string' || !lockName)\n    throw new TypeError('An IndexedDB lock name is required');\n  return options;\n}\n"],"names":[],"mappings":"AAAO,SAAS,uBAAuB,CAAC,OAAO,EAAE,WAAW,EAAE;AAC9D,EAAE,IAAI,OAAO,WAAW,KAAK,UAAU;AACvC,IAAI,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC;AACjE,EAAE,OAAO,WAAW,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;AAC9C;;AAEO,eAAe,sBAAsB,CAAC,OAAO,EAAE,UAAU,EAAE;AAClE,EAAE,IAAI,OAAO,UAAU,KAAK,UAAU;AACtC,IAAI,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC;AACpE,EAAE,OAAO,UAAU,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;AAC7C;;AAEA,SAAS,eAAe,CAAC,OAAO,EAAE;AAClC,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,IAAI,EAAE;AAClD,EAAE,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,YAAY;AACvD,IAAI,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC;AACjE,EAAE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,QAAQ;AAC/C,IAAI,MAAM,IAAI,SAAS,CAAC,oCAAoC,CAAC;AAC7D,EAAE,OAAO,OAAO;AAChB;;"}

package/dist/redaction/index.cjs

@@ -0,0 +1,154 @@
+'use strict';
+
+var common = require('../chunk-CXZYNALm.cjs');
+var constants = require('../chunk-BLf-eCDO.cjs');
+
+function createRedactor(
+  policy = {},
+  { createRedactor: createValueRedactor, TEXT_RULES: providerTextRules } = {},
+) {
+  if (typeof createValueRedactor !== 'function')
+    throw new TypeError('A value redactor factory is required');
+  if (!Array.isArray(policy.text) && !providerTextRules)
+    throw new TypeError('Default text rules are required');
+  const limits = common.resolveLimits(policy.limits);
+  const version = policy.version ?? '1';
+  if (
+    typeof version !== 'string' ||
+    !version ||
+    version.length > limits.maxStringLength
+  )
+    throw new TypeError('Invalid redaction version');
+  const { fields, unknownFields, hash, text } = policy;
+  const textRules = text ?? Object.values(providerTextRules);
+  const engine = createValueRedactor({
+    fields,
+    unknownFields,
+    hash:
+      typeof hash === 'function' ? (value) => hash.call(policy, value) : hash,
+    limits: { ...limits, maxOutputSize: limits.maxRecordSize },
+    text: text
+      ? textRules.map(({ name, pattern, requiresHash, replace }) => ({
+          name,
+          pattern,
+          requiresHash,
+          replace:
+            typeof replace === 'function'
+              ? function (match) {
+                  return replace.call(this, match, api);
+                }
+              : replace,
+        }))
+      : textRules,
+  });
+  let active;
+  const api = {
+    version,
+    limits,
+    mask: engine.mask,
+    redactText(value) {
+      return (active?.walk ?? engine.createSession()).redactText(value);
+    },
+
+    redactValue(value) {
+      const walk = engine.createSession();
+      const result = walk.redactValue(value);
+      if (active && walk.truncated) active.truncated = true;
+      return JSON.stringify(result).length <= limits.maxRecordSize
+        ? result
+        : constants.MARKERS.LIMIT;
+    },
+
+    redact(draft) {
+      const previous = active;
+      const walk = engine.createSession();
+      active = { walk, truncated: false };
+      try {
+        let didTruncate = false;
+        const record = {};
+        for (const key of [
+          'runId',
+          'seq',
+          'at',
+          'level',
+          'area',
+          'scope',
+          'message',
+        ])
+          common.define(
+            record,
+            key,
+            typeof draft[key] === 'string' && !['runId', 'level'].includes(key)
+              ? walk.redactText(draft[key])
+              : draft[key],
+          );
+        record.redactionVersion = version;
+        if (draft.context) record.context = walk.redactValue(draft.context);
+        const data = draft.data;
+        if (common.isError(data)) {
+          const converted = walk.redactValue(data);
+          record.error =
+            typeof converted === 'string'
+              ? { name: 'Error', message: converted }
+              : converted;
+        } else if (data !== undefined) {
+          if (
+            data &&
+            typeof data === 'object' &&
+            !Array.isArray(data) &&
+            [Object.prototype, null].includes(Object.getPrototypeOf(data))
+          ) {
+            const error =
+              walk.fieldRule('error') === 'drop'
+                ? undefined
+                : common.own(data, 'error');
+            const promoted = common.isError(error);
+            if (promoted) {
+              const converted = walk.redactError(error, 'error');
+              if (converted !== undefined) record.error = converted;
+            }
+            const values = {};
+            let count = 0;
+            for (const key of Reflect.ownKeys(data)) {
+              if (++count > limits.maxKeys) {
+                common.define(values, '[truncated]', constants.MARKERS.LIMIT);
+                didTruncate = true;
+                break;
+              }
+              if (key === 'error' && promoted) continue;
+              const descriptor = Object.getOwnPropertyDescriptor(data, key);
+              if (typeof key === 'string' && descriptor?.enumerable)
+                Object.defineProperty(values, key, descriptor);
+            }
+            const converted = walk.redactValue(values);
+            record.fields =
+              converted &&
+              typeof converted === 'object' &&
+              !Array.isArray(converted)
+                ? converted
+                : { value: converted };
+          } else record.fields = { value: walk.redactValue(data) };
+        }
+        if (walk.truncated || active.truncated || didTruncate)
+          record.truncated = true;
+        if (JSON.stringify(record).length > limits.maxRecordSize) {
+          delete record.fields;
+          delete record.context;
+          delete record.error;
+          record.fields = { value: constants.MARKERS.LIMIT };
+          record.truncated = true;
+          if (JSON.stringify(record).length > limits.maxRecordSize)
+            throw new TypeError('Record headers exceed size limit');
+        }
+        return record;
+      } finally {
+        active = previous;
+      }
+    },
+  };
+  if (engine.hash) api.hash = engine.hash;
+  return Object.freeze(api);
+}
+
+exports.createRedactor = createRedactor;
+//# sourceMappingURL=index.cjs.map