@lovelaces-io/storyteller 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -21,19 +21,79 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ANSI: () => ANSI,
+  AudienceRegistry: () => AudienceRegistry,
+  DEFAULT_REDACT_KEYS: () => DEFAULT_REDACT_KEYS,
+  REDACTED: () => REDACTED,
   Storyteller: () => Storyteller,
-  colorizeJsonSections: () => colorizeJsonSections,
   consoleAudience: () => consoleAudience,
-  countBrackets: () => countBrackets,
   dbAudience: () => dbAudience,
+  formatDuration: () => formatDuration,
   formatOrigin: () => formatOrigin,
+  formatStory: () => formatStory,
   getLevelColor: () => getLevelColor,
+  meetsLevel: () => meetsLevel,
+  ndjsonAudience: () => ndjsonAudience,
+  normalizeError: () => normalizeError,
+  normalizeValue: () => normalizeValue,
+  readEnvironmentValue: () => readEnvironmentValue,
+  resolveColors: () => resolveColors,
+  resolveMinimumLevel: () => resolveMinimumLevel,
+  resolveOutputFormat: () => resolveOutputFormat,
+  summarizeContext: () => summarizeContext,
   summarizeStory: () => summarizeStory,
+  toStoryLevel: () => toStoryLevel,
   useStoryteller: () => useStoryteller,
   writeStoryReport: () => writeStoryReport
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/environment.ts
+var LEVEL_RANK = {
+  Information: 0,
+  Warning: 1,
+  Error: 2
+};
+var LEVEL_ALIASES = {
+  info: "Information",
+  information: "Information",
+  tell: "Information",
+  warn: "Warning",
+  warning: "Warning",
+  oops: "Error",
+  error: "Error"
+};
+function toStoryLevel(input) {
+  if (!input) return "Information";
+  return LEVEL_ALIASES[String(input).toLowerCase()] ?? "Information";
+}
+function readEnvironmentValue(name) {
+  try {
+    const runtime = globalThis;
+    const value = runtime.process?.env?.[name];
+    return typeof value === "string" && value.length ? value.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveMinimumLevel(requested) {
+  const value = requested ?? readEnvironmentValue("STORYTELLER_LEVEL");
+  if (!value) return "Information";
+  return LEVEL_ALIASES[String(value).toLowerCase()] ?? "Information";
+}
+function meetsLevel(level, minimum) {
+  return LEVEL_RANK[level] >= LEVEL_RANK[minimum];
+}
+function resolveOutputFormat(requested) {
+  const value = requested ?? readEnvironmentValue("STORYTELLER_FORMAT");
+  return value === "ndjson" ? "ndjson" : "text";
+}
+function resolveColors(requested) {
+  if (requested !== void 0) return requested;
+  const value = readEnvironmentValue("STORYTELLER_COLOR");
+  if (value === void 0) return true;
+  return !(value === "0" || value.toLowerCase() === "false");
+}
+
 // src/utils.ts
 var ANSI = {
   reset: "\x1B[0m",
@@ -41,18 +101,24 @@ var ANSI = {
   yellow: "\x1B[33m",
   red: "\x1B[38;2;250;128;114m",
   grayLight: "\x1B[37m",
-  grayDark: "\x1B[37m"
+  grayDark: "\x1B[90m"
 };
 function getLevelColor(level) {
-  if (level === "tell") return ANSI.green;
-  if (level === "warn") return ANSI.yellow;
+  if (level === "Information") return ANSI.green;
+  if (level === "Warning") return ANSI.yellow;
   return ANSI.red;
 }
 function formatOrigin(origin) {
   if (!origin?.where) return;
   if (typeof origin.where === "string") return origin.where;
+  if (typeof origin.where !== "object" || Array.isArray(origin.where)) {
+    return String(origin.where);
+  }
   const whereRecord = origin.where;
-  const parts = [whereRecord.app, whereRecord.service, whereRecord.page, whereRecord.component].filter(Boolean).map(String);
+  const priorityKeys = ["app", "service", "page", "component"];
+  const priorityParts = priorityKeys.filter((key) => whereRecord[key] != null).map((key) => String(whereRecord[key]));
+  const extraParts = Object.entries(whereRecord).filter(([key, value]) => !priorityKeys.includes(key) && value != null).map(([_, value]) => String(value));
+  const parts = [...priorityParts, ...extraParts];
   return parts.length ? parts.join(" / ") : void 0;
 }
 function colorizeJsonSections(json, colors) {
@@ -79,192 +145,482 @@ function countBrackets(line) {
   const closeCount = (line.match(/\]/g) || []).length;
   return openCount - closeCount;
 }
+var CONTEXT_LINE_LIMIT = 120;
+function summarizeContext(note) {
+  const parts = [];
+  appendContextParts(parts, note.what);
+  appendContextParts(parts, note.where);
+  if (note.error) {
+    const errorLine = [note.error.name, note.error.message].filter(Boolean).join(": ");
+    if (errorLine && errorLine !== note.note) parts.push(errorLine);
+  }
+  if (!parts.length) return void 0;
+  const joined = parts.join(" ");
+  const text = joined.length > CONTEXT_LINE_LIMIT ? `${joined.slice(0, CONTEXT_LINE_LIMIT)}\u2026` : joined;
+  return `{${text}}`;
+}
+function appendContextParts(parts, value) {
+  if (value == null) return;
+  if (typeof value !== "object") {
+    parts.push(String(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    parts.push(`[${value.length}]`);
+    return;
+  }
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry == null) continue;
+    if (key.startsWith("@")) continue;
+    parts.push(`${key}=${typeof entry === "object" ? summarizeNested(entry) : String(entry)}`);
+  }
+}
+function summarizeNested(value) {
+  if (Array.isArray(value)) return `[${value.length}]`;
+  if (value && typeof value === "object") return `{${Object.keys(value).length}}`;
+  return String(value);
+}
 
 // src/audiences/consoleAudience.ts
-function consoleAudience() {
+var LEVEL_LABELS = {
+  Information: "info",
+  Warning: "warn",
+  Error: "oops"
+};
+var LEVEL_STYLES = {
+  Information: "color:#16a34a;font-weight:600",
+  Warning: "color:#f59e0b;font-weight:600",
+  Error: "color:#dc2626;font-weight:600"
+};
+function consoleAudience(options = {}) {
+  const colors = resolveColors(options.colors);
   return {
     name: "console",
-    hear: (event) => {
-      const prefix = "Storyteller";
-      const style = event.level === "tell" ? "color:#16a34a;font-weight:600" : event.level === "warn" ? "color:#f59e0b;font-weight:600" : "color:#dc2626;font-weight:600";
-      const header = `${prefix}: ${event.title}`;
-      console.groupCollapsed(`%c${header}`, style);
-      const payload = JSON.stringify(event, null, 2);
-      const coloredPayload = event.level === "oops" ? `${ANSI.red}${payload}${ANSI.reset}` : payload;
-      if (event.level === "tell") {
-        console.log(header, payload);
-      } else if (event.level === "warn") {
-        console.warn(header, payload);
-      } else {
-        console.error(header, coloredPayload);
+    hears: ["note", "story"],
+    hear: (emission) => {
+      if (emission.kind === "note") {
+        printNote(emission, colors);
+        return;
       }
-      console.groupEnd();
+      printStory(emission);
     }
   };
 }
+function printNote(note, colors) {
+  const time = readClockTime(note.timestamp);
+  const label = LEVEL_LABELS[note.level];
+  const origin = formatOrigin(note.origin);
+  const context = summarizeContext(note);
+  const head = colors ? `${getLevelColor(note.level)}${label}${ANSI.reset}` : label;
+  const line = [
+    colors ? `${ANSI.grayDark}${time}${ANSI.reset}` : time,
+    head,
+    origin ? colors ? `${ANSI.grayDark}${origin}${ANSI.reset}` : origin : void 0,
+    note.note,
+    context ? colors ? `${ANSI.grayDark}${context}${ANSI.reset}` : context : void 0
+  ].filter(Boolean).join("  ");
+  if (note.level === "Information") {
+    console.log(line);
+  } else if (note.level === "Warning") {
+    console.warn(line);
+  } else {
+    console.error(line);
+  }
+}
+function printStory(event) {
+  const prefix = "Storyteller";
+  const header = `${prefix}: ${event.title}`;
+  console.groupCollapsed(`%c${header}`, LEVEL_STYLES[event.level]);
+  const payload = JSON.stringify(event, null, 2);
+  if (event.level === "Information") {
+    console.log(header, payload);
+  } else if (event.level === "Warning") {
+    console.warn(header, payload);
+  } else {
+    console.error(header, payload);
+  }
+  console.groupEnd();
+}
+function readClockTime(timestamp) {
+  const timePart = timestamp.slice(11, 19);
+  return timePart.length === 8 ? timePart : timestamp;
+}
 
-// src/storyteller.ts
-var AudienceRegistry = class {
-  members = /* @__PURE__ */ new Map();
-  /** Register an audience member, replacing any existing member with the same name */
-  add(member) {
-    this.members.set(member.name, member);
-    return this;
+// src/normalize.ts
+var REDACTED = "[redacted]";
+var DEFAULT_REDACT_KEYS = [
+  "password",
+  "passphrase",
+  "token",
+  "secret",
+  "apiKey",
+  "accessKey",
+  "authorization",
+  "auth",
+  "cookie",
+  "sessionId",
+  "privateKey",
+  "clientSecret",
+  "refreshToken"
+];
+var DEFAULT_MAX_DEPTH = 6;
+var DEFAULT_MAX_ARRAY_LENGTH = 100;
+var DEFAULT_MAX_PROPERTIES = 100;
+var DEFAULT_MAX_STRING_LENGTH = 8e3;
+var MAX_CAUSE_DEPTH = 5;
+var BINARY_PREVIEW_BYTES = 16;
+function normalizeValue(input, options = {}) {
+  const resolved = {
+    maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
+    maxArrayLength: options.maxArrayLength ?? DEFAULT_MAX_ARRAY_LENGTH,
+    maxProperties: options.maxProperties ?? DEFAULT_MAX_PROPERTIES,
+    maxStringLength: options.maxStringLength ?? DEFAULT_MAX_STRING_LENGTH,
+    redactKeys: new Set(
+      (options.redactKeys ?? DEFAULT_REDACT_KEYS).map(normalizeKeyForMatching)
+    ),
+    redact: options.redact ?? true
+  };
+  try {
+    return normalizeUnknown(input, resolved, 0, "$", /* @__PURE__ */ new Map());
+  } catch (failure) {
+    return `[Unreadable: ${describeFailure(failure)}]`;
   }
-  /** Remove an audience member by name */
-  remove(name) {
-    this.members.delete(name);
-    return this;
+}
+function normalizeError(rawError, options = {}) {
+  const resolved = {
+    maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
+    maxArrayLength: options.maxArrayLength ?? DEFAULT_MAX_ARRAY_LENGTH,
+    maxProperties: options.maxProperties ?? DEFAULT_MAX_PROPERTIES,
+    maxStringLength: options.maxStringLength ?? DEFAULT_MAX_STRING_LENGTH,
+    redactKeys: new Set(
+      (options.redactKeys ?? DEFAULT_REDACT_KEYS).map(normalizeKeyForMatching)
+    ),
+    redact: options.redact ?? true
+  };
+  return normalizeErrorInternal(rawError, resolved, 0);
+}
+function normalizeErrorInternal(rawError, options, causeDepth) {
+  if (!(rawError instanceof Error)) {
+    if (isPlainRecord(rawError)) {
+      const record = rawError;
+      const message = typeof record["message"] === "string" ? record["message"] : void 0;
+      const name = typeof record["name"] === "string" ? record["name"] : void 0;
+      if (message !== void 0 || name !== void 0) {
+        return {
+          ...name !== void 0 ? { name } : {},
+          ...message !== void 0 ? { message } : {}
+        };
+      }
+    }
+    return { message: safeStringify(rawError, options.maxStringLength) };
   }
-  /** Return all registered audience members */
-  getAll() {
-    return [...this.members.values()];
+  const normalized = {
+    name: rawError.name,
+    message: rawError.message
+  };
+  if (rawError.stack !== void 0) {
+    normalized.stack = truncateString(rawError.stack, options.maxStringLength);
   }
-  /** Return only the audience members matching the given names */
-  getOnly(names) {
-    return names.map((name) => this.members.get(name)).filter(Boolean);
+  const cause = rawError.cause;
+  if (cause !== void 0) {
+    if (causeDepth >= MAX_CAUSE_DEPTH) {
+      normalized.cause = { "@truncated": { kind: "causeChain" } };
+    } else if (cause instanceof Error) {
+      normalized.cause = normalizeErrorInternal(cause, options, causeDepth + 1);
+    } else {
+      normalized.cause = normalizeUnknown(cause, options, 0, "$.cause", /* @__PURE__ */ new Map());
+    }
   }
-};
-var Storyteller = class {
-  audience = new AudienceRegistry();
-  origin;
-  notes = [];
-  constructor(options) {
-    this.origin = options?.origin;
-    this.audience.add(consoleAudience());
-    options?.audiences?.forEach((audience) => this.audience.add(audience));
+  const aggregated = rawError.errors;
+  if (Array.isArray(aggregated)) {
+    normalized.errors = aggregated.slice(0, options.maxArrayLength).map((member) => normalizeErrorInternal(member, options, causeDepth + 1));
   }
-  /** Add a timestamped note with optional context (who, what, where, error) */
-  note(text, data = {}) {
-    this.notes.push({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      note: text,
-      ...data.who ? { who: data.who } : {},
-      ...data.what ? { what: data.what } : {},
-      ...data.where ? { where: data.where } : {},
-      ...data.error ? { error: normalizeError(data.error) } : {}
-    });
-    return this;
+  return normalized;
+}
+function normalizeUnknown(value, options, depth, path, ancestors) {
+  if (value === null) return null;
+  const valueType = typeof value;
+  if (valueType === "string") {
+    return truncateString(value, options.maxStringLength);
   }
-  /** Clear all accumulated notes without emitting a story */
-  reset() {
-    this.notes = [];
-    return this;
+  if (valueType === "number") {
+    return Number.isFinite(value) ? value : String(value);
   }
-  /** Generate a formatted summary of current notes without emitting or clearing them */
-  summarize(options = {}) {
-    const {
-      title = "Story preview",
-      level = "tell",
-      error,
-      ...summaryOptions
-    } = options;
-    const event = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      title,
-      ...this.origin ? { origin: this.origin } : {},
-      notes: [...this.notes],
-      ...error ? { error: normalizeError(error) } : {}
-    };
-    return summarizeStory(event, summaryOptions);
+  if (valueType === "boolean") return value;
+  if (valueType === "undefined") return null;
+  if (valueType === "bigint") return `${String(value)}n`;
+  if (valueType === "symbol") return String(value);
+  if (valueType === "function") {
+    const name = value.name;
+    return `[Function: ${name ? name : "anonymous"}]`;
   }
-  /** Emit a story at the "tell" level (success / informational) */
-  tell(title) {
-    return this.createDelivery("tell", title);
+  const objectValue = value;
+  const existingPath = ancestors.get(objectValue);
+  if (existingPath !== void 0) {
+    return `[Circular \u2192 ${existingPath}]`;
   }
-  /** Emit a story at the "warn" level (something was off) */
-  warn(title) {
-    return this.createDelivery("warn", title);
+  if (depth > options.maxDepth) {
+    return { "@truncated": { kind: "depth", depth: options.maxDepth } };
   }
-  /** Emit a story at the "oops" level (something broke) with an optional error */
-  oops(title, error) {
-    return this.createDelivery("oops", title, error);
+  const wellKnown = normalizeWellKnown(objectValue, options, depth, path, ancestors);
+  if (wellKnown !== void 0) return wellKnown;
+  ancestors.set(objectValue, path);
+  try {
+    if (Array.isArray(objectValue)) {
+      return normalizeArray(objectValue, options, depth, path, ancestors);
+    }
+    return normalizeObject(objectValue, options, depth, path, ancestors);
+  } finally {
+    ancestors.delete(objectValue);
   }
-  /** Build a story event and schedule delivery, returning a handle to override the audience list */
-  createDelivery(level, title, error) {
-    const event = this.buildEvent(level, title, error);
-    let delivered = false;
-    let defaultCancelled = false;
-    queueMicrotask(() => {
-      if (delivered || defaultCancelled) return;
-      delivered = true;
-      void this.deliver(event);
-    });
-    return {
-      to: (...names) => {
-        defaultCancelled = true;
-        if (delivered) return;
-        delivered = true;
-        void this.deliver(event, { only: names });
+}
+function normalizeWellKnown(value, options, depth, path, ancestors) {
+  if (value instanceof Error) {
+    return normalizeErrorInternal(value, options, 0);
+  }
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isNaN(time) ? "[Invalid Date]" : value.toISOString();
+  }
+  if (value instanceof RegExp) return String(value);
+  if (value instanceof URL) return value.href;
+  if (value instanceof Map) {
+    const entries = {};
+    let index = 0;
+    let omitted = 0;
+    for (const [entryKey, entryValue] of value) {
+      if (index >= options.maxProperties) {
+        omitted += 1;
+        continue;
       }
+      const keyLabel = safeStringify(entryKey, options.maxStringLength);
+      entries[keyLabel] = redactOrNormalize(
+        keyLabel,
+        entryValue,
+        options,
+        depth + 1,
+        `${path}.${keyLabel}`,
+        ancestors
+      );
+      index += 1;
+    }
+    return {
+      "@type": "Map",
+      entries,
+      ...omitted ? { "@truncated": { kind: "mapEntries", omitted } } : {}
     };
   }
-  /** Assemble the story event from current notes and clear notes for the next story */
-  buildEvent(level, title, error) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const collectedNotes = [...this.notes];
-    this.notes = [];
-    const event = {
-      timestamp: now,
-      level,
-      title,
-      ...this.origin ? { origin: this.origin } : {},
-      notes: collectedNotes,
-      ...error ? { error: normalizeError(error) } : {}
+  if (value instanceof Set) {
+    const values = [];
+    let omitted = 0;
+    for (const member of value) {
+      if (values.length >= options.maxArrayLength) {
+        omitted += 1;
+        continue;
+      }
+      values.push(
+        normalizeUnknown(member, options, depth + 1, `${path}[${values.length}]`, ancestors)
+      );
+    }
+    return {
+      "@type": "Set",
+      values,
+      ...omitted ? { "@truncated": { kind: "setValues", omitted } } : {}
     };
-    const eventWithSummary = event;
-    Object.defineProperty(eventWithSummary, "summarize", {
-      value: (options) => summarizeStory(event, options),
-      enumerable: false
-    });
-    return eventWithSummary;
   }
-  /** Deliver a story event to matching audience members */
-  async deliver(event, options) {
-    const targets = options?.only?.length ? this.audience.getOnly(options.only) : this.audience.getAll();
-    await Promise.allSettled(
-      targets.filter((member) => member.accepts ? member.accepts(event) : true).map((member) => member.hear(event))
+  if (value instanceof WeakMap) return "[WeakMap]";
+  if (value instanceof WeakSet) return "[WeakSet]";
+  if (value instanceof Promise) return "[Promise]";
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    return describeBinary(value);
+  }
+  const converted = callToJson(value);
+  if (converted !== void 0) {
+    return normalizeUnknown(converted, options, depth, path, ancestors);
+  }
+  return void 0;
+}
+function callToJson(value) {
+  let toJson;
+  try {
+    toJson = value.toJSON;
+  } catch {
+    return void 0;
+  }
+  if (typeof toJson !== "function") return void 0;
+  try {
+    return toJson.call(value);
+  } catch (failure) {
+    return `[Unreadable: ${describeFailure(failure)}]`;
+  }
+}
+function describeBinary(value) {
+  const typeName = readConstructorName(value) ?? "ArrayBuffer";
+  const byteLength = value.byteLength;
+  let preview;
+  try {
+    const bytes = value instanceof ArrayBuffer ? new Uint8Array(value, 0, Math.min(BINARY_PREVIEW_BYTES, byteLength)) : new Uint8Array(
+      value.buffer,
+      value.byteOffset,
+      Math.min(BINARY_PREVIEW_BYTES, value.byteLength)
     );
+    preview = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join(" ");
+  } catch {
+    preview = "";
   }
-};
-function normalizeError(rawError) {
-  if (rawError instanceof Error) {
-    const normalized = {
-      name: rawError.name,
-      message: rawError.message
-    };
-    if (rawError.stack !== void 0) {
-      normalized.stack = rawError.stack;
+  return {
+    "@type": typeName,
+    byteLength,
+    ...preview ? { preview } : {},
+    ...byteLength > BINARY_PREVIEW_BYTES ? { "@truncated": { kind: "bytes", omitted: byteLength - BINARY_PREVIEW_BYTES } } : {}
+  };
+}
+function normalizeArray(value, options, depth, path, ancestors) {
+  const kept = [];
+  const limit = Math.min(value.length, options.maxArrayLength);
+  for (let index = 0; index < limit; index += 1) {
+    kept.push(
+      normalizeUnknown(value[index], options, depth + 1, `${path}[${index}]`, ancestors)
+    );
+  }
+  if (value.length > limit) {
+    kept.push({ "@truncated": { kind: "array", omitted: value.length - limit } });
+  }
+  return kept;
+}
+function normalizeObject(value, options, depth, path, ancestors) {
+  const result = {};
+  const className = readConstructorName(value);
+  if (className && className !== "Object") {
+    result["@type"] = className;
+  }
+  let keys;
+  try {
+    keys = Object.keys(value);
+  } catch {
+    return `[Unreadable: keys could not be listed]`;
+  }
+  let kept = 0;
+  let omitted = 0;
+  for (const key of keys) {
+    if (kept >= options.maxProperties) {
+      omitted += 1;
+      continue;
     }
-    const cause = rawError.cause;
-    if (cause !== void 0) {
-      normalized.cause = cause;
+    let propertyValue;
+    try {
+      propertyValue = value[key];
+    } catch (failure) {
+      result[key] = `[Unreadable: ${describeFailure(failure)}]`;
+      kept += 1;
+      continue;
     }
-    return normalized;
+    if (propertyValue === void 0) continue;
+    result[key] = redactOrNormalize(
+      key,
+      propertyValue,
+      options,
+      depth + 1,
+      `${path}.${key}`,
+      ancestors
+    );
+    kept += 1;
+  }
+  if (omitted) {
+    result["@truncated"] = { kind: "properties", omitted };
   }
-  return { message: String(rawError) };
+  return result;
 }
-function calculateNoteDuration(notes) {
-  if (notes.length <= 1) {
-    return {
-      durationMs: void 0
-    };
+function redactOrNormalize(key, value, options, depth, path, ancestors) {
+  if (options.redact && options.redactKeys.has(normalizeKeyForMatching(key))) {
+    return REDACTED;
   }
-  const startTime = Date.parse(notes[0].timestamp);
-  const endTime = Date.parse(notes[notes.length - 1].timestamp);
+  return normalizeUnknown(value, options, depth, path, ancestors);
+}
+function normalizeKeyForMatching(key) {
+  return key.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+}
+function readConstructorName(value) {
+  try {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === null) return void 0;
+    const name = prototype.constructor?.name;
+    return typeof name === "string" && name.length ? name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function truncateString(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength)}\u2026[+${value.length - maxLength} chars]`;
+}
+function safeStringify(value, maxLength) {
+  try {
+    return truncateString(String(value), maxLength);
+  } catch {
+    return "[unstringifiable]";
+  }
+}
+function describeFailure(failure) {
+  if (failure instanceof Error && failure.message) return failure.message;
+  try {
+    return String(failure);
+  } catch {
+    return "unknown error";
+  }
+}
+
+// src/audiences/ndjsonAudience.ts
+function ndjsonAudience(options = {}) {
+  const writer = options.stream ?? createDefaultWriter();
+  const minimumLevel = resolveMinimumLevel(options.level);
   return {
-    durationMs: Number.isFinite(startTime) && Number.isFinite(endTime) ? Math.max(0, endTime - startTime) : void 0
+    name: options.name ?? "ndjson",
+    hears: ["note", "story"],
+    accepts: (emission) => meetsLevel(emission.level, minimumLevel),
+    hear: (emission) => {
+      writer.write(`${serializeEmission(emission)}
+`);
+    }
   };
 }
-function summarizeStory(story, options = {}) {
+function serializeEmission(emission) {
+  try {
+    return JSON.stringify(emission);
+  } catch {
+    try {
+      return JSON.stringify(normalizeValue(emission));
+    } catch {
+      return JSON.stringify({
+        kind: emission.kind,
+        level: emission.level,
+        error: "[Unserializable emission]"
+      });
+    }
+  }
+}
+function createDefaultWriter() {
+  const runtime = globalThis;
+  const write = runtime.process?.stdout?.write;
+  if (typeof write === "function") {
+    const stdout = runtime.process.stdout;
+    return { write: (chunk) => write.call(stdout, chunk) };
+  }
+  return { write: (chunk) => console.log(chunk.replace(/\n$/, "")) };
+}
+
+// src/formatting.ts
+function formatStory(story, options = {}) {
   const {
     timezone = Intl.DateTimeFormat().resolvedOptions().timeZone,
     locale = "en-US",
-    verbosity = "normal",
-    maxNotes = 50,
+    detail = "normal",
+    noteLimit = 50,
     showData = true,
-    colorize = true
+    colors = true
   } = options;
   const dateTimeFormatter = new Intl.DateTimeFormat(locale, {
     timeZone: timezone,
@@ -284,15 +640,14 @@ function summarizeStory(story, options = {}) {
   const orderedNotes = [...story.notes].sort(
     (noteA, noteB) => Date.parse(noteA.timestamp) - Date.parse(noteB.timestamp)
   );
-  const noteTiming = calculateNoteDuration(orderedNotes);
-  const originLabel = formatOrigin(story.origin);
-  const duration = noteTiming.durationMs != null ? formatDuration(noteTiming.durationMs) : void 0;
-  const slicedNotes = orderedNotes.slice(0, maxNotes);
-  const summaryNotes = slicedNotes.map((note) => ({
+  const durationMs = story.durationMs ?? calculateNoteDuration(orderedNotes);
+  const duration = durationMs != null ? formatDuration(durationMs) : void 0;
+  const slicedNotes = orderedNotes.slice(0, noteLimit);
+  const reportNotes = slicedNotes.map((note) => ({
     timestamp: note.timestamp,
     when: timeFormatter.format(new Date(note.timestamp)),
     note: note.note,
-    text: formatNoteText(note, verbosity),
+    text: formatNoteText(note, detail),
     ...note.who ? { who: note.who } : {},
     ...note.what ? { what: note.what } : {},
     ...note.where ? { where: note.where } : {},
@@ -302,18 +657,28 @@ function summarizeStory(story, options = {}) {
     title: story.title,
     level: story.level,
     when: dateTimeFormatter.format(new Date(story.timestamp)),
-    ...noteTiming.durationMs != null ? { durationMs: noteTiming.durationMs } : {},
+    ...durationMs != null ? { durationMs } : {},
     ...duration ? { duration } : {},
     ...story.origin ? { origin: story.origin } : {},
-    notes: summaryNotes,
+    notes: reportNotes,
     ...story.error ? { error: story.error } : {}
   };
+  const lines = buildReportText(story, data, reportNotes, orderedNotes, {
+    colors,
+    detail,
+    showData,
+    duration
+  });
+  return { text: lines.join("\n"), data };
+}
+function buildReportText(story, data, reportNotes, orderedNotes, options) {
   const levelColor = getLevelColor(story.level);
-  const label = (text) => colorize ? `${levelColor}${text}${ANSI.reset}` : text;
+  const label = (text) => options.colors ? `${levelColor}${text}${ANSI.reset}` : text;
+  const originLabel = formatOrigin(story.origin);
   const lines = [];
   lines.push(`${label("Story")}: ${story.title}`);
   lines.push(`${label("Level")}: ${story.level}`);
-  lines.push(`${label("Time")}: ${data.when}${duration ? ` (${duration})` : ""}`);
+  lines.push(`${label("Time")}: ${data.when}${options.duration ? ` (${options.duration})` : ""}`);
   if (originLabel) {
     lines.push(`${label("Origin")}: ${originLabel}`);
   }
@@ -321,19 +686,19 @@ function summarizeStory(story, options = {}) {
     const errorLine = [story.error.name, story.error.message].filter(Boolean).join(": ");
     if (errorLine) lines.push(`${label("Error")}: ${errorLine}`);
   }
-  if (verbosity !== "brief" && summaryNotes.length) {
+  if (options.detail !== "brief" && reportNotes.length) {
     lines.push(`${label("Notes")}:`);
-    for (const note of summaryNotes) {
+    for (const note of reportNotes) {
       lines.push(`  ${note.when} \u2014 ${note.text}`);
     }
-    if (orderedNotes.length > summaryNotes.length) {
-      lines.push(`  \u2026 (${orderedNotes.length - summaryNotes.length} more)`);
+    if (orderedNotes.length > reportNotes.length) {
+      lines.push(`  \u2026 (${orderedNotes.length - reportNotes.length} more)`);
     }
   }
-  if (showData) {
+  if (options.showData) {
     lines.push(`${label("Data")}:`);
     const json = JSON.stringify(data, null, 2);
-    if (colorize) {
+    if (options.colors) {
       const colored = colorizeJsonSections(json, {
         base: ANSI.grayLight,
         notes: ANSI.grayDark,
@@ -344,7 +709,13 @@ function summarizeStory(story, options = {}) {
       lines.push(...json.split("\n"));
     }
   }
-  return { text: lines.join("\n"), data };
+  return lines;
+}
+function calculateNoteDuration(notes) {
+  if (notes.length <= 1) return void 0;
+  const startTime = Date.parse(notes[0].timestamp);
+  const endTime = Date.parse(notes[notes.length - 1].timestamp);
+  return Number.isFinite(startTime) && Number.isFinite(endTime) ? Math.max(0, endTime - startTime) : void 0;
 }
 function formatDuration(milliseconds) {
   if (milliseconds < 1e3) return `${milliseconds}ms`;
@@ -354,6 +725,7 @@ function formatDuration(milliseconds) {
   const remainingSeconds = Math.round(seconds % 60).toString().padStart(2, "0");
   return `${minutes}:${remainingSeconds}m`;
 }
+var summarizeStory = formatStory;
 function formatNoteText(note, verbosity) {
   if (verbosity !== "full") return note.note;
   const details = [];
@@ -362,13 +734,16 @@ function formatNoteText(note, verbosity) {
   if (typeof what === "string") {
     details.push(`what=${what}`);
   } else if (what) {
-    if (what.field) details.push(`field=${String(what.field)}`);
-    if (what.status) details.push(`status=${String(what.status)}`);
+    for (const [key, value] of Object.entries(what)) {
+      if (value != null) details.push(`${key}=${String(value)}`);
+    }
   }
   if (typeof where === "string") {
     details.push(`where=${where}`);
   } else if (where) {
-    if (where.component) details.push(`component=${String(where.component)}`);
+    for (const [key, value] of Object.entries(where)) {
+      if (value != null) details.push(`${key}=${String(value)}`);
+    }
   }
   if (note.error) {
     const errorLine = [note.error.name, note.error.message].filter(Boolean).join(": ");
@@ -377,11 +752,453 @@ function formatNoteText(note, verbosity) {
   return details.length ? `${note.note} (${details.join(" ")})` : note.note;
 }
 
+// src/storyteller.ts
+var AudienceRegistry = class {
+  members = /* @__PURE__ */ new Map();
+  /** Register an audience member, replacing any existing member with the same name */
+  add(member) {
+    this.members.set(member.name, member);
+    return this;
+  }
+  /** Remove an audience member by name */
+  remove(name) {
+    this.members.delete(name);
+    return this;
+  }
+  /** Return all registered audience members */
+  getAll() {
+    return [...this.members.values()];
+  }
+  /** Return only the audience members matching the given names */
+  getOnly(names) {
+    return names.map((name) => this.members.get(name)).filter(Boolean);
+  }
+  /** Check if an audience member is registered by name */
+  has(name) {
+    return this.members.has(name);
+  }
+  /** List the names of all registered audience members */
+  names() {
+    return [...this.members.keys()];
+  }
+};
+var Storyteller = class _Storyteller {
+  audience;
+  origin;
+  parentStoryId;
+  notes = [];
+  narration;
+  minimumLevel;
+  onAudienceError;
+  maxInFlight;
+  /** Deliveries currently awaiting each audience, keyed by audience name */
+  inFlight = /* @__PURE__ */ new Map();
+  /** Emissions dropped for back-pressure since the current story began */
+  droppedEmissions = 0;
+  /** Identifies the story currently being collected; regenerated after each telling */
+  storyId = createStoryId();
+  /** Position of the next note within the current story */
+  nextSequence = 0;
+  constructor(options) {
+    const normalizedOrigin = normalizeOrigin(options?.origin);
+    if (normalizedOrigin) {
+      this.origin = normalizedOrigin;
+    }
+    if (options?.parentStoryId !== void 0) {
+      this.parentStoryId = options.parentStoryId;
+    }
+    this.narration = resolveNarration(options?.narration);
+    this.minimumLevel = resolveMinimumLevel(options?.level);
+    this.onAudienceError = options?.onAudienceError ?? reportAudienceErrorToConsole;
+    this.maxInFlight = options?.maxInFlight ?? DEFAULT_MAX_IN_FLIGHT;
+    if (options?.audience) {
+      this.audience = options.audience;
+    } else {
+      this.audience = new AudienceRegistry();
+      this.audience.add(
+        resolveOutputFormat(options?.format) === "ndjson" ? ndjsonAudience({ level: this.minimumLevel }) : consoleAudience()
+      );
+    }
+    options?.audiences?.forEach((audience) => this.audience.add(audience));
+  }
+  /**
+   * Switch between collected and live narration at runtime.
+   * Takes effect on the next note; already-buffered notes are not replayed.
+   *
+   * @param narration - `collected` to buffer, `live` to emit each note as it happens
+   * @returns `this` for chaining
+   */
+  narrate(narration) {
+    this.narration = resolveNarration(narration);
+    return this;
+  }
+  /** The id of the story currently being collected */
+  get currentStoryId() {
+    return this.storyId;
+  }
+  /**
+   * Start a chapter: a child storyteller whose stories are linked back to this
+   * one by `parentStoryId`.
+   *
+   * Real work nests — an agent spawns subtasks, a batch runs per-item operations.
+   * A chapter keeps each of those a complete story in its own right while leaving
+   * the run reconstructable as a tree.
+   *
+   * The child shares this storyteller's audience registry, so audiences added
+   * later reach it too, and inherits narration, level and delivery settings.
+   * Its stories are separate records — a chapter is not folded into the parent's
+   * notes.
+   *
+   * @param options - Origin to merge over the parent's, and any setting to override
+   * @returns A child Storyteller
+   *
+   * @example
+   * ```ts
+   * for (const account of accounts) {
+   *   const chapter = story.chapter({ origin: { what: account.id } });
+   *   chapter.report("Fetching invoices");
+   *   chapter.finish(`Synced ${account.id}`);
+   * }
+   * ```
+   */
+  chapter(options = {}) {
+    const mergedOrigin = { ...this.origin, ...options.origin };
+    return new _Storyteller({
+      audience: this.audience,
+      // Captured now, so a parent that finishes first does not orphan its chapters
+      parentStoryId: this.storyId,
+      ...Object.keys(mergedOrigin).length ? { origin: mergedOrigin } : {},
+      narration: options.narration ?? this.narration,
+      level: options.level ?? this.minimumLevel,
+      onAudienceError: options.onAudienceError ?? this.onAudienceError,
+      maxInFlight: options.maxInFlight ?? this.maxInFlight
+    });
+  }
+  /**
+   * Report a beat of the current story.
+   *
+   * In collected narration the beat is buffered and leaves with the story. In live
+   * narration it is emitted the moment you call this, so whoever is tuned in sees
+   * the work as it happens.
+   *
+   * Accepts anything, not just a string — pass an error, an API response, a Map, a
+   * class instance — and the value is normalized into a storable shape with the note
+   * text derived from it.
+   *
+   * @param input - What happened: a message, or any value to describe
+   * @param data - Optional context: who did it, what was involved, where it happened, any error
+   * @returns `this` for chaining
+   *
+   * @example
+   * ```ts
+   * story.report("Card charged", { what: { amount: "$42" }, where: "stripe" });
+   * story.report(await response.json());
+   * ```
+   */
+  report(input, data = {}) {
+    const described = describeInput(input);
+    const level = toStoryLevel(data.level);
+    const note = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sequence: this.nextSequence,
+      note: described.text,
+      ...level !== "Information" ? { level } : {},
+      ...data.who !== void 0 ? { who: normalizeValue(data.who) } : {},
+      ...data.what !== void 0 ? { what: normalizeValue(data.what) } : described.what !== void 0 ? { what: described.what } : {},
+      ...data.where !== void 0 ? { where: normalizeValue(data.where) } : {},
+      ...data.error !== void 0 ? { error: normalizeError(data.error) } : described.error !== void 0 ? { error: described.error } : {}
+    };
+    this.nextSequence += 1;
+    this.notes.push(note);
+    if (this.narration === "live" || data.live) {
+      this.emitNote(note, level, data.to);
+    }
+    return this;
+  }
+  /** Clear all accumulated notes without emitting a story, and start a new story id */
+  reset() {
+    this.notes = [];
+    this.startNewStory();
+    return this;
+  }
+  /** Preview the current notes as a formatted report without emitting or clearing them */
+  summarize(options = {}) {
+    const {
+      title = "Story preview",
+      level = "Information",
+      error,
+      ...reportOptions
+    } = options;
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      title,
+      storyId: this.storyId,
+      ...this.parentStoryId !== void 0 ? { parentStoryId: this.parentStoryId } : {},
+      ...this.origin ? { origin: this.origin } : {},
+      notes: [...this.notes],
+      ...error !== void 0 ? { error: normalizeError(error) } : {}
+    };
+    return formatStory(event, reportOptions);
+  }
+  /**
+   * Finish the story: emit everything collected so far as one record, and start fresh.
+   *
+   * @param title - What the story was about
+   * @param options - Level, and the error that ended it
+   * @returns A one-shot handle whose `.to()` overrides the audience list — call it
+   *   synchronously, delivery happens on the next microtask
+   *
+   * @example
+   * ```ts
+   * story.finish("Sync complete");
+   * story.finish("Sync failed", { level: "oops", error }).to("db");
+   * ```
+   */
+  finish(title, options = {}) {
+    return this.createDelivery(toStoryLevel(options.level), title, options.error);
+  }
+  /** @deprecated Use `finish(title)`. Removed at 1.0. */
+  tell(title) {
+    warnDeprecated("tell", "finish");
+    return this.createDelivery("Information", title);
+  }
+  /** @deprecated Use `finish(title, { level: "warn" })`. Removed at 1.0. */
+  warn(title) {
+    warnDeprecated("warn", 'finish(title, { level: "warn" })');
+    return this.createDelivery("Warning", title);
+  }
+  /** @deprecated Use `finish(title, { level: "oops", error })`. Removed at 1.0. */
+  oops(title, error) {
+    warnDeprecated("oops", 'finish(title, { level: "oops", error })');
+    return this.createDelivery("Error", title, error);
+  }
+  /** @deprecated Use `report()`. Removed at 1.0. */
+  note(input, data = {}) {
+    warnDeprecated("note", "report");
+    return this.report(input, data);
+  }
+  /** Emit a single note to the audiences listening for notes */
+  emitNote(note, level, only) {
+    const emission = {
+      ...note,
+      kind: "note",
+      storyId: this.storyId,
+      ...this.parentStoryId !== void 0 ? { parentStoryId: this.parentStoryId } : {},
+      sequence: note.sequence ?? 0,
+      level,
+      ...this.origin ? { origin: this.origin } : {}
+    };
+    void this.deliver(emission, only ? { only } : {});
+  }
+  /** Build a story event and schedule delivery, returning a handle to override the audience list */
+  createDelivery(level, title, error) {
+    const event = this.buildEvent(level, title, error);
+    let delivered = false;
+    let defaultCancelled = false;
+    queueMicrotask(() => {
+      if (delivered || defaultCancelled) return;
+      delivered = true;
+      void this.deliver(event);
+    });
+    return {
+      to: (...names) => {
+        defaultCancelled = true;
+        if (delivered) return;
+        delivered = true;
+        void this.deliver(event, { only: names });
+      }
+    };
+  }
+  /** Assemble the story event from current notes and start a fresh story */
+  buildEvent(level, title, error) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const storyId = this.storyId;
+    const droppedEmissions = this.droppedEmissions;
+    const sortedNotes = [...this.notes].sort(
+      (noteA, noteB) => Date.parse(noteA.timestamp) - Date.parse(noteB.timestamp) || (noteA.sequence ?? 0) - (noteB.sequence ?? 0)
+    );
+    this.notes = [];
+    this.startNewStory();
+    const durationMs = calculateNoteDuration2(sortedNotes).durationMs;
+    const event = {
+      timestamp: now,
+      level,
+      title,
+      storyId,
+      ...this.parentStoryId !== void 0 ? { parentStoryId: this.parentStoryId } : {},
+      ...this.origin ? { origin: this.origin } : {},
+      notes: sortedNotes,
+      ...durationMs != null ? { durationMs } : {},
+      ...droppedEmissions ? { droppedEmissions } : {},
+      ...error !== void 0 ? { error: normalizeError(error) } : {}
+    };
+    const eventWithSummary = event;
+    Object.defineProperty(eventWithSummary, "kind", {
+      value: "story",
+      enumerable: true
+    });
+    Object.defineProperty(eventWithSummary, "summarize", {
+      value: (options) => formatStory(event, options),
+      enumerable: false
+    });
+    return eventWithSummary;
+  }
+  /** Begin a new story: fresh id, sequence back to zero */
+  startNewStory() {
+    this.storyId = createStoryId();
+    this.nextSequence = 0;
+    this.droppedEmissions = 0;
+  }
+  /** Deliver an emission to the audience members listening for its kind */
+  async deliver(emission, options) {
+    if (!meetsLevel(emission.level, this.minimumLevel)) return;
+    const targets = options?.only?.length ? this.audience.getOnly(options.only) : this.audience.getAll();
+    await Promise.all(
+      targets.filter((member) => hearsKind(member, emission.kind)).filter((member) => this.acceptsSafely(member, emission)).map((member) => this.hearSafely(member, emission))
+    );
+  }
+  /** Run an audience's accepts() without letting a throw from it lose the emission */
+  acceptsSafely(member, emission) {
+    if (!member.accepts) return true;
+    try {
+      return member.accepts(emission);
+    } catch (error) {
+      this.handleAudienceError(error, member, emission);
+      return false;
+    }
+  }
+  /**
+   * Hand an emission to one audience, keeping its failures and its slowness
+   * contained: a throw is reported rather than swallowed, and a backlog is dropped
+   * rather than grown without limit.
+   */
+  async hearSafely(member, emission) {
+    const pending = this.inFlight.get(member.name) ?? 0;
+    if (pending >= this.maxInFlight) {
+      this.droppedEmissions += 1;
+      return;
+    }
+    this.inFlight.set(member.name, pending + 1);
+    try {
+      await member.hear(emission);
+    } catch (error) {
+      this.handleAudienceError(error, member, emission);
+    } finally {
+      const remaining = (this.inFlight.get(member.name) ?? 1) - 1;
+      if (remaining > 0) this.inFlight.set(member.name, remaining);
+      else this.inFlight.delete(member.name);
+    }
+  }
+  /** Report an audience failure without ever letting it reach caller code */
+  handleAudienceError(error, member, emission) {
+    try {
+      this.onAudienceError(error, member, emission);
+    } catch {
+    }
+  }
+};
+var warnedDeprecations = /* @__PURE__ */ new Set();
+function warnDeprecated(oldName, replacement) {
+  if (warnedDeprecations.has(oldName)) return;
+  if (readEnvironmentValue("STORYTELLER_DEPRECATION_WARNINGS") !== "1") return;
+  warnedDeprecations.add(oldName);
+  console.warn(
+    `Storyteller: ${oldName}() is deprecated and will be removed at 1.0 \u2014 use ${replacement}.`
+  );
+}
+var DEFAULT_MAX_IN_FLIGHT = 1e3;
+var AUDIENCE_ERROR_THROTTLE_MS = 5e3;
+var lastReportedAudienceError = /* @__PURE__ */ new Map();
+function reportAudienceErrorToConsole(error, member, emission) {
+  const now = Date.now();
+  const lastReported = lastReportedAudienceError.get(member.name);
+  if (lastReported !== void 0 && now - lastReported < AUDIENCE_ERROR_THROTTLE_MS) {
+    return;
+  }
+  lastReportedAudienceError.set(member.name, now);
+  const reason = error instanceof Error ? error.message : String(error);
+  console.error(
+    `Storyteller: audience "${member.name}" failed to hear a ${emission.kind} \u2014 ${reason}`
+  );
+}
+function hearsKind(member, kind) {
+  const kinds = member.hears ?? ["story"];
+  return kinds.includes(kind);
+}
+function resolveNarration(requested) {
+  const value = requested ?? readEnvironmentValue("STORYTELLER_NARRATION");
+  if (value === "live" || value === "both") return "live";
+  return "collected";
+}
+function createStoryId() {
+  try {
+    const runtimeCrypto = globalThis.crypto;
+    if (typeof runtimeCrypto?.randomUUID === "function") {
+      return runtimeCrypto.randomUUID();
+    }
+  } catch {
+  }
+  return `story-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function normalizeOrigin(origin) {
+  if (!origin) return void 0;
+  const normalized = {
+    ...origin.who !== void 0 ? { who: normalizeValue(origin.who) } : {},
+    ...origin.what !== void 0 ? { what: normalizeValue(origin.what) } : {},
+    ...origin.where !== void 0 ? { where: normalizeValue(origin.where) } : {}
+  };
+  return Object.keys(normalized).length ? normalized : void 0;
+}
+function describeInput(input) {
+  if (typeof input === "string") return { text: input };
+  if (input instanceof Error) {
+    const error = normalizeError(input);
+    const label = [error.name, error.message].filter(Boolean).join(": ");
+    return { text: label || "Error", error };
+  }
+  if (input === null) return { text: "null" };
+  if (input === void 0) return { text: "undefined" };
+  const normalized = normalizeValue(input);
+  if (typeof normalized !== "object" || normalized === null) {
+    return { text: String(normalized), what: normalized };
+  }
+  if (Array.isArray(normalized)) {
+    return { text: `Array(${normalized.length})`, what: normalized };
+  }
+  for (const key of ["message", "title", "name", "summary", "event"]) {
+    const candidate = normalized[key];
+    if (typeof candidate === "string" && candidate.length) {
+      return { text: candidate, what: normalized };
+    }
+  }
+  const typeName = normalized["@type"];
+  return {
+    text: typeof typeName === "string" ? typeName : "Object",
+    what: normalized
+  };
+}
+function calculateNoteDuration2(notes) {
+  if (notes.length <= 1) {
+    return {
+      durationMs: void 0
+    };
+  }
+  const startTime = Date.parse(notes[0].timestamp);
+  const endTime = Date.parse(notes[notes.length - 1].timestamp);
+  return {
+    durationMs: Number.isFinite(startTime) && Number.isFinite(endTime) ? Math.max(0, endTime - startTime) : void 0
+  };
+}
+
 // src/useStoryteller.ts
 var sharedInstance;
 function useStoryteller(options = {}) {
   if (!sharedInstance || options.reset) {
-    sharedInstance = new Storyteller({ origin: options.origin });
+    sharedInstance = new Storyteller({
+      ...options.origin !== void 0 ? { origin: options.origin } : {},
+      ...options.narration !== void 0 ? { narration: options.narration } : {}
+    });
     return sharedInstance;
   }
   return sharedInstance;
@@ -391,9 +1208,11 @@ function useStoryteller(options = {}) {
 function dbAudience(insert) {
   return {
     name: "db",
-    accepts: (event) => event.level === "warn" || event.level === "oops",
-    hear: async (event) => {
-      await insert(event);
+    hears: ["story"],
+    accepts: (emission) => emission.kind === "story" && (emission.level === "Warning" || emission.level === "Error"),
+    hear: async (emission) => {
+      if (emission.kind !== "story") return;
+      await insert(emission);
     }
   };
 }
@@ -403,10 +1222,10 @@ function writeStoryReport(stories, options = {}) {
   const {
     timezone = Intl.DateTimeFormat().resolvedOptions().timeZone,
     locale = "en-US",
-    verbosity = "normal",
-    maxNotesPerStory = 50,
+    detail = "normal",
+    noteLimit = 50,
     showData = true,
-    colorize = true
+    colors = true
   } = options;
   if (!stories.length) {
     return "Storyteller Report\n\n(no stories)\n";
@@ -443,17 +1262,17 @@ function writeStoryReport(stories, options = {}) {
   for (const [day, dayStories] of storiesByDay) {
     lines.push(day);
     for (const story of dayStories) {
-      const summary = summarizeStory(story, {
+      const report = formatStory(story, {
         timezone,
         locale,
-        verbosity,
-        maxNotes: maxNotesPerStory,
-        colorize
+        detail,
+        noteLimit,
+        colors
       });
-      const { data } = summary;
+      const { data } = report;
       const originLabel = formatOrigin(story.origin);
       const levelColor = getLevelColor(story.level);
-      const label = (text) => colorize ? `${levelColor}${text}${ANSI.reset}` : text;
+      const label = (text) => colors ? `${levelColor}${text}${ANSI.reset}` : text;
       const duration = data.duration ? ` (${data.duration})` : "";
       lines.push(`${label("Story")}: ${story.title}`);
       lines.push(`${label("Level")}: ${story.level}`);
@@ -468,10 +1287,10 @@ function writeStoryReport(stories, options = {}) {
         ].filter(Boolean).join(": ");
         if (errorLine) lines.push(`${label("Error")}: ${errorLine}`);
       }
-      if (verbosity !== "brief" && data.notes.length) {
+      if (detail !== "brief" && data.notes.length) {
         lines.push(`  ${label("Notes")}:`);
-        for (const summaryNote of data.notes) {
-          lines.push(`    ${summaryNote.when} \u2014 ${summaryNote.text}`);
+        for (const reportNote of data.notes) {
+          lines.push(`    ${reportNote.when} \u2014 ${reportNote.text}`);
         }
         if (story.notes.length > data.notes.length) {
           lines.push(
@@ -482,7 +1301,7 @@ function writeStoryReport(stories, options = {}) {
       if (showData) {
         lines.push(`${label("Data")}:`);
         const json = JSON.stringify(data, null, 2);
-        if (colorize) {
+        if (colors) {
           const colored = colorizeJsonSections(json, {
             base: ANSI.grayLight,
             notes: ANSI.grayDark,
@@ -501,14 +1320,27 @@ function writeStoryReport(stories, options = {}) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ANSI,
+  AudienceRegistry,
+  DEFAULT_REDACT_KEYS,
+  REDACTED,
   Storyteller,
-  colorizeJsonSections,
   consoleAudience,
-  countBrackets,
   dbAudience,
+  formatDuration,
   formatOrigin,
+  formatStory,
   getLevelColor,
+  meetsLevel,
+  ndjsonAudience,
+  normalizeError,
+  normalizeValue,
+  readEnvironmentValue,
+  resolveColors,
+  resolveMinimumLevel,
+  resolveOutputFormat,
+  summarizeContext,
   summarizeStory,
+  toStoryLevel,
   useStoryteller,
   writeStoryReport
 });