@ubercode/chronicler 0.1.0

package/dist/index.js

@@ -0,0 +1,759 @@
+// src/core/constants.ts
+var LOG_LEVELS = {
+  fatal: 0,
+  // System is unusable
+  critical: 1,
+  // Critical conditions requiring immediate attention
+  alert: 2,
+  // Action must be taken immediately
+  error: 3,
+  // Error conditions
+  warn: 4,
+  // Warning conditions
+  audit: 5,
+  // Audit trail events (compliance, security)
+  info: 6,
+  // Informational messages
+  debug: 7,
+  // Debug-level messages
+  trace: 8
+  // Trace-level messages (very verbose)
+};
+var DEFAULT_REQUIRED_LEVELS = Object.keys(LOG_LEVELS);
+var DEFAULT_CORRELATION_TIMEOUT_MS = 5 * 60 * 1e3;
+var ROOT_FORK_ID = "0";
+var FORK_ID_SEPARATOR = ".";
+var DEFAULT_MAX_CONTEXT_KEYS = 100;
+var DEFAULT_MAX_FORK_DEPTH = 10;
+var DEFAULT_MAX_ACTIVE_CORRELATIONS = 1e3;
+
+// src/core/errors.ts
+var ChroniclerError = class extends Error {
+  code;
+  /**
+   * @param code - Machine-readable error category discriminator
+   * @param message - Human-readable description of the error
+   */
+  constructor(code, message) {
+    super(message);
+    this.name = "ChroniclerError";
+    this.code = code;
+  }
+};
+
+// src/core/backend.ts
+var CONSOLE_LEVEL_MAP = {
+  fatal: "error",
+  critical: "error",
+  alert: "error",
+  error: "error",
+  warn: "warn",
+  audit: "info",
+  info: "info",
+  debug: "debug",
+  trace: "debug"
+};
+var LEVEL_FALLBACK_CHAINS = {
+  fatal: ["critical", "error", "warn", "info"],
+  critical: ["error", "warn", "info"],
+  alert: ["error", "warn", "info"],
+  error: ["warn", "info"],
+  warn: ["info"],
+  audit: ["info"],
+  info: [],
+  debug: ["info"],
+  trace: ["debug", "info"]
+};
+var callBackendMethod = (backend, level, message, payload) => {
+  if (typeof backend[level] !== "function") {
+    throw new ChroniclerError("BACKEND_METHOD", `Backend does not support log level: ${level}`);
+  }
+  try {
+    backend[level](message, payload);
+  } catch (err) {
+    console.error(
+      "[chronicler] Backend error during log emission:",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+  }
+};
+var createConsoleBackend = () => {
+  const backend = {};
+  for (const level of DEFAULT_REQUIRED_LEVELS) {
+    const method = CONSOLE_LEVEL_MAP[level];
+    backend[level] = (message, payload) => console[method](message, payload);
+  }
+  return backend;
+};
+var createBackend = (partial) => {
+  const backend = {};
+  for (const level of DEFAULT_REQUIRED_LEVELS) {
+    if (typeof partial[level] === "function") {
+      backend[level] = partial[level];
+      continue;
+    }
+    const fallback = LEVEL_FALLBACK_CHAINS[level].find((fb) => typeof partial[fb] === "function");
+    if (fallback) {
+      backend[level] = partial[fallback];
+    } else {
+      const method = CONSOLE_LEVEL_MAP[level];
+      backend[level] = (message, payload) => console[method](message, payload);
+    }
+  }
+  return backend;
+};
+var createRouterBackend = (routes) => {
+  if (routes.length === 0) {
+    throw new Error("createRouterBackend requires at least one route.");
+  }
+  const backend = {};
+  for (const level of DEFAULT_REQUIRED_LEVELS) {
+    backend[level] = (message, payload) => {
+      for (const route of routes) {
+        if (!route.filter || route.filter(level, payload)) {
+          callBackendMethod(route.backend, level, message, payload);
+        }
+      }
+    };
+  }
+  return backend;
+};
+
+// src/core/reserved.ts
+var RESERVED_TOP_LEVEL_FIELDS = [
+  "eventKey",
+  "level",
+  "message",
+  "correlationId",
+  "forkId",
+  "timestamp",
+  "fields",
+  "_validation"
+];
+var TOP_LEVEL_SET = new Set(RESERVED_TOP_LEVEL_FIELDS);
+var isReservedTopLevelField = (key) => TOP_LEVEL_SET.has(key);
+var assertNoReservedKeys = (record) => {
+  const invalid = [];
+  for (const key of Object.keys(record)) {
+    if (isReservedTopLevelField(key)) {
+      invalid.push(key);
+    }
+  }
+  return invalid;
+};
+
+// src/core/context.ts
+var isSimpleValue = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "toString",
+  "valueOf",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "toLocaleString",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+var sanitizeContextInput = (context, existingContext = {}, maxNewKeys = Infinity) => {
+  const sanitized = {};
+  const reserved = [];
+  const collisionDetails = [];
+  const dropped = [];
+  let acceptedCount = 0;
+  for (const [key, rawValue] of Object.entries(context)) {
+    if (isReservedTopLevelField(key)) {
+      reserved.push(key);
+      continue;
+    }
+    if (DANGEROUS_KEYS.has(key)) {
+      reserved.push(key);
+      continue;
+    }
+    if (!isSimpleValue(rawValue)) continue;
+    if (Object.hasOwn(existingContext, key) || Object.hasOwn(sanitized, key)) {
+      const existingValue = Object.hasOwn(sanitized, key) ? sanitized[key] : existingContext[key];
+      collisionDetails.push({ key, existingValue, attemptedValue: rawValue });
+      continue;
+    }
+    if (acceptedCount >= maxNewKeys) {
+      dropped.push(key);
+      continue;
+    }
+    sanitized[key] = rawValue;
+    acceptedCount++;
+  }
+  return { context: sanitized, validation: { reserved, collisionDetails, dropped } };
+};
+var ContextStore = class {
+  context = {};
+  maxKeys;
+  constructor(initial = {}, maxKeys = Infinity) {
+    this.maxKeys = maxKeys;
+    const { context } = sanitizeContextInput(initial, {}, maxKeys);
+    this.context = context;
+  }
+  /**
+   * Merge new context into the store.
+   *
+   * @param raw - Key-value pairs to add
+   * @returns Validation result with any collisions or reserved field attempts
+   */
+  add(raw) {
+    const remaining = Math.max(0, this.maxKeys - Object.keys(this.context).length);
+    const { context, validation } = sanitizeContextInput(raw, this.context, remaining);
+    Object.assign(this.context, context);
+    return validation;
+  }
+  /**
+   * Return a shallow copy of the current context.
+   *
+   * @returns A new object containing all accumulated context key-value pairs
+   */
+  snapshot() {
+    return { ...this.context };
+  }
+};
+
+// src/core/fields.ts
+function makeOptional(type, doc) {
+  return {
+    _type: type,
+    _required: false,
+    _doc: doc,
+    doc: (description) => makeOptional(type, description)
+  };
+}
+function makeRequired(type, doc) {
+  return {
+    _type: type,
+    _required: true,
+    _doc: doc,
+    optional: () => makeOptional(type, doc),
+    doc: (description) => makeRequired(type, description)
+  };
+}
+var field = {
+  string: () => makeRequired("string", void 0),
+  number: () => makeRequired("number", void 0),
+  boolean: () => makeRequired("boolean", void 0),
+  error: () => makeRequired("error", void 0)
+};
+
+// src/core/events.ts
+var correlationAutoFields = {
+  complete: {
+    duration: field.number().optional().doc("Duration of the correlation in milliseconds")
+  },
+  fail: {
+    duration: field.number().optional().doc("Duration of the correlation in milliseconds"),
+    error: field.error().optional().doc("Error that caused the failure")
+  }};
+var MAX_EVENT_KEY_LENGTH = 256;
+var EVENT_KEY_RE = /^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)*$/;
+var validateEventKey = (key, label) => {
+  if (key.length > MAX_EVENT_KEY_LENGTH) {
+    throw new Error(
+      `${label} key "${key.slice(0, 50)}..." exceeds maximum length of ${MAX_EVENT_KEY_LENGTH} characters.`
+    );
+  }
+  if (!EVENT_KEY_RE.test(key)) {
+    throw new Error(
+      `Invalid ${label} key "${key}". Keys must be dotted camelCase identifiers (e.g. "user.created", "http.request.started").`
+    );
+  }
+};
+var defineEvent = (event) => {
+  validateEventKey(event.key, "Event");
+  return event;
+};
+var prefixEventKeys = (groupKey, events) => {
+  if (!events) return events;
+  const result = {};
+  for (const [name, event] of Object.entries(events)) {
+    if (event.key.startsWith(`${groupKey}.`)) {
+      result[name] = event;
+    } else {
+      result[name] = { ...event, key: `${groupKey}.${name}` };
+    }
+  }
+  return result;
+};
+var defineEventGroup = (group) => {
+  validateEventKey(group.key, "Group");
+  const prefixed = prefixEventKeys(group.key, group.events);
+  if (prefixed !== group.events) {
+    return { ...group, events: prefixed };
+  }
+  return group;
+};
+var buildAutoEvents = (groupKey) => ({
+  start: {
+    key: `${groupKey}.start`,
+    level: "info",
+    message: `${groupKey} started`,
+    doc: "Auto-generated correlation start event"
+  },
+  complete: {
+    key: `${groupKey}.complete`,
+    level: "info",
+    message: `${groupKey} completed`,
+    doc: "Auto-generated correlation completion event",
+    fields: correlationAutoFields.complete
+  },
+  fail: {
+    key: `${groupKey}.fail`,
+    level: "error",
+    message: `${groupKey} failed`,
+    doc: "Auto-generated correlation failure event",
+    fields: correlationAutoFields.fail
+  },
+  timeout: {
+    key: `${groupKey}.timeout`,
+    level: "warn",
+    message: `${groupKey} timed out`,
+    doc: "Auto-generated correlation timeout event"
+  }
+});
+var defineCorrelationGroup = (group) => {
+  validateEventKey(group.key, "Group");
+  const autoEvents = buildAutoEvents(group.key);
+  const prefixed = prefixEventKeys(group.key, group.events) ?? {};
+  const autoKeys = Object.keys(autoEvents);
+  const conflicts = autoKeys.filter((k) => Object.hasOwn(prefixed, k));
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Correlation group "${group.key}" defines events that collide with auto-generated lifecycle events: ${conflicts.join(", ")}. Rename these events to avoid the conflict.`
+    );
+  }
+  return {
+    ...group,
+    timeout: group.timeout ?? DEFAULT_CORRELATION_TIMEOUT_MS,
+    events: {
+      ...prefixed,
+      ...autoEvents
+    }
+  };
+};
+
+// src/core/validation.ts
+var ANSI_ESCAPE_RE = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+var NEWLINE_RE = /[\r\n]/g;
+var sanitizeString = (value) => value.replace(ANSI_ESCAPE_RE, "").replace(NEWLINE_RE, "\\n");
+var sanitizeLogFields = (fields) => {
+  const result = {};
+  for (const [key, value] of Object.entries(fields)) {
+    result[key] = typeof value === "string" ? sanitizeString(value) : value;
+  }
+  return result;
+};
+var checkFieldType = (value, type) => {
+  switch (type) {
+    case "error":
+      return value instanceof Error || typeof value === "string" ? "ok" : "type_error";
+    case "string":
+      return typeof value === "string" ? "ok" : "type_error";
+    case "number":
+      if (typeof value !== "number") return "type_error";
+      return Number.isFinite(value) ? "ok" : "invalid_value";
+    case "boolean":
+      return typeof value === "boolean" ? "ok" : "type_error";
+    default:
+      return "type_error";
+  }
+};
+var validateFields = (event, payload) => {
+  const providedFields = payload ?? {};
+  const normalizedFields = {};
+  const missingFields = [];
+  const typeErrors = [];
+  const invalidValues = [];
+  const unknownFields = [];
+  const fieldBuilders = event.fields ?? {};
+  const definedFieldNames = new Set(Object.keys(fieldBuilders));
+  for (const [name, builder] of Object.entries(fieldBuilders)) {
+    const value = providedFields[name];
+    const fieldType = builder._type;
+    const isRequired = builder._required;
+    if (value === void 0 || value === null) {
+      if (isRequired) {
+        missingFields.push(name);
+      }
+      continue;
+    }
+    const typeCheck = checkFieldType(value, fieldType);
+    if (typeCheck === "type_error") {
+      typeErrors.push(name);
+      continue;
+    }
+    if (typeCheck === "invalid_value") {
+      invalidValues.push(name);
+      continue;
+    }
+    if (fieldType === "error") {
+      try {
+        normalizedFields[name] = value instanceof Error ? value.stack ?? value.message : typeof value === "string" ? value : "[unknown error]";
+      } catch {
+        normalizedFields[name] = "[unserializable error]";
+      }
+    } else if (fieldType === "string" && typeof value === "string") {
+      normalizedFields[name] = sanitizeString(value);
+    } else {
+      normalizedFields[name] = value;
+    }
+  }
+  for (const [name, value] of Object.entries(providedFields)) {
+    if (!definedFieldNames.has(name) && value !== void 0 && value !== null) {
+      unknownFields.push(name);
+      if (typeof value === "function" || typeof value === "symbol") {
+        continue;
+      }
+      if (typeof value === "string") {
+        normalizedFields[name] = sanitizeString(value);
+      } else {
+        normalizedFields[name] = value;
+      }
+    }
+  }
+  return { missingFields, typeErrors, invalidValues, unknownFields, normalizedFields };
+};
+var buildValidationMetadata = (fieldValidation) => {
+  const entries = Object.entries({
+    missingFields: fieldValidation.missingFields,
+    typeErrors: fieldValidation.typeErrors,
+    invalidValues: fieldValidation.invalidValues,
+    unknownFields: fieldValidation.unknownFields
+  }).filter(([, v]) => Array.isArray(v) && v.length > 0);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+
+// src/core/chronicle.ts
+var buildPayload = (args) => {
+  const fieldValidation = validateFields(args.eventDef, args.fields);
+  if (args.strict) {
+    const issues = [];
+    if (fieldValidation.missingFields.length > 0) {
+      issues.push(`missing required fields: ${fieldValidation.missingFields.join(", ")}`);
+    }
+    if (fieldValidation.typeErrors.length > 0) {
+      issues.push(`type errors on fields: ${fieldValidation.typeErrors.join(", ")}`);
+    }
+    if (fieldValidation.invalidValues.length > 0) {
+      issues.push(`invalid values on fields: ${fieldValidation.invalidValues.join(", ")}`);
+    }
+    if (issues.length > 0) {
+      throw new ChroniclerError(
+        "FIELD_VALIDATION",
+        `Event "${args.eventDef.key}" failed validation: ${issues.join("; ")}`
+      );
+    }
+  }
+  const validationMetadata = buildValidationMetadata(fieldValidation);
+  return {
+    eventKey: args.eventDef.key,
+    fields: fieldValidation.normalizedFields,
+    correlationId: args.currentCorrelationId(),
+    forkId: args.forkId,
+    metadata: args.contextStore.snapshot(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...validationMetadata ? { _validation: validationMetadata } : {}
+  };
+};
+var forkDepthFromId = (forkId) => forkId === ROOT_FORK_ID ? 0 : forkId.split(FORK_ID_SEPARATOR).length;
+var nextForkId = (parentForkId, counter, maxDepth) => {
+  const childForkId = parentForkId === ROOT_FORK_ID ? String(counter) : `${parentForkId}${FORK_ID_SEPARATOR}${counter}`;
+  const depth = forkDepthFromId(childForkId);
+  if (depth > maxDepth) {
+    throw new ChroniclerError(
+      "FORK_DEPTH_EXCEEDED",
+      `Fork depth ${depth} exceeds maximum allowed depth of ${maxDepth}`
+    );
+  }
+  return childForkId;
+};
+var isAlreadyNormalized = (group) => typeof group.timeout === "number" && group.events !== void 0 && "start" in group.events;
+var resolveCorrelationGroup = (group) => isAlreadyNormalized(group) ? group : defineCorrelationGroup(group);
+var createChronicleInstance = (args) => {
+  const {
+    config,
+    contextStore,
+    currentCorrelationId,
+    correlationIdGenerator,
+    forkId,
+    hooks = {},
+    activeCorrelations = { count: 0 }
+  } = args;
+  let forkCounter = 0;
+  return {
+    event(eventDef, fields) {
+      if (LOG_LEVELS[eventDef.level] > config.minLevel) return;
+      const payload = buildPayload({
+        contextStore,
+        eventDef,
+        // Deliberate type erasure: EventFields<E> → Record<string, unknown>
+        fields,
+        currentCorrelationId,
+        forkId,
+        strict: config.strict
+      });
+      callBackendMethod(config.backend, eventDef.level, eventDef.message, payload);
+      hooks.onActivity?.();
+    },
+    log(level, message, fields = {}) {
+      if (LOG_LEVELS[level] > config.minLevel) return;
+      const payload = {
+        eventKey: "",
+        fields: sanitizeLogFields(fields),
+        correlationId: currentCorrelationId(),
+        forkId,
+        metadata: contextStore.snapshot(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      callBackendMethod(config.backend, level, message, payload);
+      hooks.onActivity?.();
+    },
+    addContext(context) {
+      return contextStore.add(context);
+    },
+    fork(extraContext = {}) {
+      forkCounter++;
+      const childForkId = nextForkId(forkId, forkCounter, config.limits.maxForkDepth);
+      const forkStore = new ContextStore(contextStore.snapshot(), config.limits.maxContextKeys);
+      const forkChronicle = createChronicleInstance({
+        config,
+        contextStore: forkStore,
+        currentCorrelationId,
+        correlationIdGenerator,
+        forkId: childForkId,
+        hooks,
+        activeCorrelations
+      });
+      if (Object.keys(extraContext).length > 0) {
+        forkChronicle.addContext(extraContext);
+      }
+      return forkChronicle;
+    },
+    startCorrelation(group, metadata = {}) {
+      if (activeCorrelations.count >= config.limits.maxActiveCorrelations) {
+        throw new ChroniclerError(
+          "CORRELATION_LIMIT_EXCEEDED",
+          `Active correlation limit of ${config.limits.maxActiveCorrelations} exceeded`
+        );
+      }
+      const definedGroup = resolveCorrelationGroup(group);
+      activeCorrelations.count++;
+      const correlationStore = new ContextStore(
+        contextStore.snapshot(),
+        config.limits.maxContextKeys
+      );
+      if (Object.keys(metadata).length > 0) {
+        correlationStore.add(metadata);
+      }
+      const correlationId = correlationIdGenerator();
+      return new CorrelationChronicleImpl({
+        config,
+        group: definedGroup,
+        contextStore: correlationStore,
+        currentCorrelationId: () => correlationId,
+        correlationIdGenerator,
+        forkId,
+        activeCorrelations
+      });
+    }
+  };
+};
+var CorrelationTimer = class {
+  constructor(timeout, onTimeout) {
+    this.timeout = timeout;
+    this.onTimeout = onTimeout;
+  }
+  timeoutId;
+  start() {
+    this.clear();
+    if (this.timeout > 0) {
+      this.timeoutId = setTimeout(this.onTimeout, this.timeout);
+      this.timeoutId.unref();
+    }
+  }
+  /** Reset the timer (keep-alive on activity). */
+  touch() {
+    this.start();
+  }
+  clear() {
+    if (this.timeoutId !== void 0) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = void 0;
+    }
+  }
+};
+var CorrelationChronicleImpl = class {
+  config;
+  contextStore;
+  currentCorrelationId;
+  correlationIdGenerator;
+  forkId;
+  activeCorrelations;
+  timer;
+  completed = false;
+  startedAt = Date.now();
+  autoEvents;
+  forkCounter = 0;
+  constructor(args) {
+    this.config = args.config;
+    this.contextStore = args.contextStore;
+    this.currentCorrelationId = args.currentCorrelationId;
+    this.correlationIdGenerator = args.correlationIdGenerator;
+    this.forkId = args.forkId;
+    this.activeCorrelations = args.activeCorrelations ?? { count: 0 };
+    this.timer = new CorrelationTimer(args.group.timeout, () => this.timeout());
+    this.autoEvents = args.group.events;
+    this.timer.start();
+    this.emitAutoEvent(this.autoEvents.start, {});
+  }
+  event(eventDef, fields) {
+    if (this.completed) return;
+    if (LOG_LEVELS[eventDef.level] > this.config.minLevel) return;
+    const payload = buildPayload({
+      contextStore: this.contextStore,
+      eventDef,
+      // Deliberate type erasure: EventFields<E> → Record<string, unknown>
+      fields,
+      currentCorrelationId: this.currentCorrelationId,
+      forkId: this.forkId,
+      strict: this.config.strict
+    });
+    callBackendMethod(this.config.backend, eventDef.level, eventDef.message, payload);
+    this.timer.touch();
+  }
+  log(level, message, fields = {}) {
+    if (this.completed) return;
+    if (LOG_LEVELS[level] > this.config.minLevel) return;
+    const payload = {
+      eventKey: "",
+      fields: sanitizeLogFields(fields),
+      correlationId: this.currentCorrelationId(),
+      forkId: this.forkId,
+      metadata: this.contextStore.snapshot(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    callBackendMethod(this.config.backend, level, message, payload);
+    this.timer.touch();
+  }
+  addContext(context) {
+    return this.contextStore.add(context);
+  }
+  fork(extraContext = {}) {
+    this.forkCounter++;
+    const childForkId = nextForkId(this.forkId, this.forkCounter, this.config.limits.maxForkDepth);
+    const forkStore = new ContextStore(
+      this.contextStore.snapshot(),
+      this.config.limits.maxContextKeys
+    );
+    const forkChronicle = createChronicleInstance({
+      config: this.config,
+      contextStore: forkStore,
+      currentCorrelationId: this.currentCorrelationId,
+      correlationIdGenerator: this.correlationIdGenerator,
+      forkId: childForkId,
+      hooks: { onActivity: () => this.timer.touch() },
+      activeCorrelations: this.activeCorrelations
+    });
+    if (Object.keys(extraContext).length > 0) {
+      forkChronicle.addContext(extraContext);
+    }
+    return forkChronicle;
+  }
+  complete(fields = {}) {
+    if (!this.finalize()) return;
+    this.emitAutoEvent(this.autoEvents.complete, {
+      duration: Date.now() - this.startedAt,
+      ...fields
+    });
+  }
+  fail(error, fields = {}) {
+    if (!this.finalize()) return;
+    this.emitAutoEvent(this.autoEvents.fail, {
+      duration: Date.now() - this.startedAt,
+      error,
+      ...fields
+    });
+  }
+  timeout() {
+    if (!this.finalize()) return;
+    this.emitAutoEvent(this.autoEvents.timeout, {});
+  }
+  /** Mark correlation as done: decrement counter, clear timer. Returns false if already completed. */
+  finalize() {
+    if (this.completed) return false;
+    this.activeCorrelations.count--;
+    this.completed = true;
+    this.timer.clear();
+    return true;
+  }
+  emitAutoEvent(eventDef, fields) {
+    if (LOG_LEVELS[eventDef.level] > this.config.minLevel) return;
+    const payload = buildPayload({
+      contextStore: this.contextStore,
+      eventDef,
+      fields,
+      currentCorrelationId: this.currentCorrelationId,
+      forkId: this.forkId,
+      strict: this.config.strict
+    });
+    callBackendMethod(this.config.backend, eventDef.level, eventDef.message, payload);
+  }
+};
+var resolveChroniclerConfig = (config) => {
+  const resolvedBackend = config.backend ?? createConsoleBackend();
+  const missingLevels = DEFAULT_REQUIRED_LEVELS.filter(
+    (level) => typeof resolvedBackend[level] !== "function"
+  );
+  if (missingLevels.length > 0) {
+    throw new ChroniclerError(
+      "UNSUPPORTED_LOG_LEVEL",
+      `Log backend is missing level(s): ${missingLevels.join(", ")}. A valid backend must implement all 9 levels: ${DEFAULT_REQUIRED_LEVELS.join(", ")}. Use createBackend() for automatic fallback handling.`
+    );
+  }
+  const reservedMetadata = assertNoReservedKeys(config.metadata);
+  if (reservedMetadata.length > 0) {
+    throw new ChroniclerError(
+      "RESERVED_FIELD",
+      `Reserved fields cannot be used in metadata: ${reservedMetadata.join(", ")}`
+    );
+  }
+  const resolvedLimits = {
+    maxContextKeys: config.limits?.maxContextKeys ?? DEFAULT_MAX_CONTEXT_KEYS,
+    maxForkDepth: config.limits?.maxForkDepth ?? DEFAULT_MAX_FORK_DEPTH,
+    maxActiveCorrelations: config.limits?.maxActiveCorrelations ?? DEFAULT_MAX_ACTIVE_CORRELATIONS
+  };
+  return {
+    resolved: {
+      backend: resolvedBackend,
+      limits: resolvedLimits,
+      minLevel: LOG_LEVELS[config.minLevel ?? "trace"],
+      strict: config.strict
+    },
+    correlationIdGenerator: config.correlationIdGenerator ?? (() => crypto.randomUUID())
+  };
+};
+var createChronicle = (config) => {
+  const { resolved, correlationIdGenerator } = resolveChroniclerConfig(config);
+  const baseContextStore = new ContextStore(config.metadata, resolved.limits.maxContextKeys);
+  return createChronicleInstance({
+    config: resolved,
+    contextStore: baseContextStore,
+    currentCorrelationId: () => "",
+    correlationIdGenerator,
+    forkId: ROOT_FORK_ID,
+    /** Shared mutable counter tracking uncompleted correlations for limit enforcement. */
+    activeCorrelations: { count: 0 }
+  });
+};
+
+export { ChroniclerError, createBackend, createChronicle, createConsoleBackend, createRouterBackend, defineCorrelationGroup, defineEvent, defineEventGroup, field };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map