@lovelaces-io/storyteller 0.3.0 → 0.4.0

package/dist/index.d.cts

@@ -1,515 +1,5 @@
-/**
- * Which default audience a storyteller registers.
- *
- * - `text` — colorized console output for a person watching
- * - `ndjson` — one JSON object per line for a program reading
- */
-type OutputFormat = "text" | "ndjson";
-/**
- * A level written any of the ways people and agents actually write it.
- * `report("...", { level: "warn" })` should not be a type error.
- */
-type LevelInput = StoryLevel | "info" | "information" | "warn" | "warning" | "oops" | "error";
-/**
- * Resolve any accepted level spelling to a stored level label.
- *
- * @param input - A level in any accepted spelling
- * @returns The canonical StoryLevel, defaulting to Information
- */
-declare function toStoryLevel(input?: LevelInput): StoryLevel;
-/**
- * Read an environment variable, tolerating runtimes that have no environment at all.
- *
- * @param name - Variable name
- * @returns The trimmed value, or undefined when unset or unavailable
- */
-declare function readEnvironmentValue(name: string): string | undefined;
-/**
- * Resolve the minimum level to deliver, from an explicit option then `STORYTELLER_LEVEL`.
- *
- * @param requested - Explicit level, if the caller set one
- * @returns The threshold level, defaulting to Information (deliver everything)
- */
-declare function resolveMinimumLevel(requested?: StoryLevel | string): StoryLevel;
-/**
- * Check whether a level clears the configured minimum.
- *
- * @param level - The emission's level
- * @param minimum - The configured threshold
- */
-declare function meetsLevel(level: StoryLevel, minimum: StoryLevel): boolean;
-/**
- * Resolve which default audience to register, from an explicit option then
- * `STORYTELLER_FORMAT`.
- *
- * Deliberately not inferred from whether stdout is a TTY: output that silently
- * changes shape when a process is piped is a debugging afternoon nobody asked for.
- *
- * @param requested - Explicit format, if the caller set one
- * @returns The format, defaulting to text
- */
-declare function resolveOutputFormat(requested?: OutputFormat): OutputFormat;
-/**
- * Resolve whether to colorize, from an explicit option then `STORYTELLER_COLOR`.
- *
- * @param requested - Explicit choice, if the caller set one
- * @returns Whether colors should be used, defaulting to true
- */
-declare function resolveColors(requested?: boolean): boolean;
-
-/** A value that survives JSON.stringify with no loss and no throwing */
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-type NormalizeOptions = {
-    /** How many levels deep to descend before replacing the value with a truncation marker */
-    maxDepth?: number;
-    /** How many array entries to keep before truncating */
-    maxArrayLength?: number;
-    /** How many object properties to keep before truncating */
-    maxProperties?: number;
-    /** How many characters of a string to keep before truncating */
-    maxStringLength?: number;
-    /** Property names whose values are replaced with the redaction marker */
-    redactKeys?: string[];
-    /** Set false to keep secret-shaped values as-is */
-    redact?: boolean;
-};
-/** Marker written in place of a value that matched a redacted key name */
-declare const REDACTED = "[redacted]";
-/**
- * Property names whose values are replaced with {@link REDACTED}.
- * Matching ignores case and separators, so `apiKey`, `api_key` and `API-KEY` all match.
- */
-declare const DEFAULT_REDACT_KEYS: string[];
-/**
- * Convert any value into a JSON-safe structure suitable for a story record.
- *
- * Handles the shapes real code actually holds — errors, dates, maps, sets, class
- * instances, binary buffers, circular references, throwing getters — and never throws,
- * so a hostile object logged by a caller cannot break the delivery pipeline.
- *
- * Data dropped for size is replaced with an explicit `@truncated` marker rather than
- * disappearing silently, so a consumer can tell the difference between "this was empty"
- * and "this was too big".
- *
- * @param input - Any value
- * @param options - Depth, size and redaction limits
- * @returns A value that JSON.stringify can always serialize
- *
- * @example
- * ```ts
- * normalizeValue({ user: new Map([["id", 1]]), apiKey: "sk-live-abc" });
- * // { user: { "@type": "Map", entries: { id: 1 } }, apiKey: "[redacted]" }
- * ```
- */
-declare function normalizeValue(input: unknown, options?: NormalizeOptions): JsonValue;
-/**
- * Convert an unknown thrown value into a serializable StoryError,
- * following the `cause` chain and collecting AggregateError members.
- *
- * @param rawError - Any thrown or rejected value
- * @param options - Depth, size and redaction limits applied to attached data
- * @returns A StoryError safe to store and serialize
- */
-declare function normalizeError(rawError: unknown, options?: NormalizeOptions): StoryError;
-
-/** Human-readable level labels stored in story records */
-type StoryLevel = "Information" | "Warning" | "Error";
-/**
- * A stored context value. Always JSON-safe — whatever the caller passed in has
- * already been through the normalizer by the time it reaches a record.
- */
-type StoryContextValue = JsonValue;
-/** Context accepted from callers. Anything goes; the normalizer makes it storable. */
-type StoryContextInput = unknown;
-type StoryError = {
-    name?: string;
-    message?: string;
-    stack?: string;
-    cause?: JsonValue;
-    /** Members of an AggregateError */
-    errors?: StoryError[];
-};
-/** Origin as stored on a record */
-type StoryOrigin = {
-    who?: StoryContextValue;
-    what?: StoryContextValue;
-    where?: StoryContextValue;
-};
-/** Origin as accepted from callers */
-type StoryOriginInput = {
-    who?: StoryContextInput;
-    what?: StoryContextInput;
-    where?: StoryContextInput;
-};
-type StoryNote = {
-    timestamp: string;
-    /**
-     * Position within the story, assigned when the note is taken. Gap-free from 0.
-     * Optional so records written before sequencing existed still typecheck.
-     */
-    sequence?: number;
-    note: string;
-    /** Omitted when the note carries the story's default Information level */
-    level?: StoryLevel;
-    who?: StoryContextValue;
-    what?: StoryContextValue;
-    where?: StoryContextValue;
-    error?: StoryError;
-};
-type StoryEventBase = {
-    timestamp: string;
-    level: StoryLevel;
-    title: string;
-    /**
-     * Correlates every note emission with the story it belongs to. Always set on
-     * events this library builds; optional so older stored records still typecheck.
-     */
-    storyId?: string;
-    /**
-     * The story this one is a chapter of. Absent on a top-level story.
-     * Following this field reconstructs the tree of a nested run.
-     */
-    parentStoryId?: string;
-    origin?: StoryOrigin;
-    notes: StoryNote[];
-    durationMs?: number;
-    /**
-     * How many emissions were dropped for back-pressure while this story was being
-     * collected. Present only when something was actually lost, so the loss shows up
-     * in the record instead of vanishing.
-     */
-    droppedEmissions?: number;
-    error?: StoryError;
-};
-type ReportOptions = {
-    timezone?: string;
-    locale?: string;
-    detail?: "brief" | "normal" | "full";
-    noteLimit?: number;
-    showData?: boolean;
-    colors?: boolean;
-};
-/** @deprecated Use ReportOptions instead */
-type StorySummaryOptions = ReportOptions;
-type PreviewOptions = ReportOptions & {
-    title?: string;
-    level?: StoryLevel;
-    error?: unknown;
-};
-/** @deprecated Use PreviewOptions instead */
-type StoryPreviewOptions = PreviewOptions;
-type ReportNote = {
-    timestamp: string;
-    when: string;
-    note: string;
-    text: string;
-    who?: StoryContextValue;
-    what?: StoryContextValue;
-    where?: StoryContextValue;
-    error?: StoryError;
-};
-/** @deprecated Use ReportNote instead */
-type StorySummaryNote = ReportNote;
-type StoryReport = {
-    title: string;
-    level: StoryLevel;
-    when: string;
-    durationMs?: number;
-    duration?: string;
-    origin?: StoryEventBase["origin"];
-    notes: ReportNote[];
-    error?: StoryError;
-};
-/** @deprecated Use StoryReport instead */
-type StorySummaryData = StoryReport;
-type FormattedReport = {
-    text: string;
-    data: StoryReport;
-};
-/** @deprecated Use FormattedReport instead */
-type StorySummary = FormattedReport;
-type StoryEvent = StoryEventBase & {
-    kind: "story";
-    summarize: (options?: ReportOptions) => FormattedReport;
-};
-/** @deprecated Use StoryEvent — the story-shaped emission */
-type StoryEmission = StoryEvent;
-/** The two things an audience can hear */
-type EmissionKind = "note" | "story";
-/**
- * A single beat, delivered the moment it happens when narration is live.
- *
- * `storyId` and `sequence` are what make streaming lossless: a consumer holding
- * the beats of a story can order and group them back into the record that
- * collected narration would have produced.
- */
-type NoteEmission = StoryNote & {
-    kind: "note";
-    storyId: string;
-    parentStoryId?: string;
-    sequence: number;
-    level: StoryLevel;
-    origin?: StoryOrigin;
-};
-type Emission = NoteEmission | StoryEvent;
-type AudienceMember = {
-    name: string;
-    /**
-     * Which emission kinds this audience wants. Defaults to `["story"]`, so an
-     * audience written before live narration existed keeps hearing only stories.
-     */
-    hears?: EmissionKind[];
-    /**
-     * Declared with method syntax deliberately. TypeScript checks method parameters
-     * bivariantly, so an audience written as `hear: (event: StoryEvent) => void`
-     * still compiles. That would be unsound if such an audience could receive a note
-     * emission — it cannot, because `hears` defaults to stories only.
-     */
-    accepts?(emission: Emission): boolean;
-    hear(emission: Emission): void | Promise<void>;
-};
-/**
- * How a storyteller narrates.
- *
- * - `collected` — beats are buffered and leave as one story record (the default)
- * - `live` — each beat is emitted as it happens, and the story still lands at the end
- *
- * Live narration adds emissions, it never removes them: a consumer that only wants
- * beats says so with `hears: ["note"]` rather than by silencing the record.
- */
-type Narration = "collected" | "live";
-/** @deprecated `both` is now the behavior of `live` — beats stream and the story still lands */
-type NarrationInput = Narration | "both";
-type NoteData = {
-    who?: StoryContextInput;
-    what?: StoryContextInput;
-    where?: StoryContextInput;
-    error?: unknown;
-    /** Level for this beat alone. Defaults to Information. */
-    level?: LevelInput;
-    /** Emit this beat immediately even when narration is collected */
-    live?: boolean;
-    /** Deliver this beat only to the named audiences */
-    to?: string[];
-};
-type FinishOptions = {
-    /** Defaults to Information */
-    level?: LevelInput;
-    /** The error that ended the story, normalized onto the record */
-    error?: unknown;
-};
-type ChapterOptions = {
-    /** Merged over the parent's origin */
-    origin?: StoryOriginInput;
-    /** Defaults to the parent's setting */
-    narration?: NarrationInput;
-    /** Defaults to the parent's setting */
-    level?: LevelInput;
-    /** Defaults to the parent's handler */
-    onAudienceError?: AudienceErrorHandler;
-    /** Defaults to the parent's bound */
-    maxInFlight?: number;
-};
-type StorytellerOptions = {
-    origin?: StoryOriginInput;
-    audiences?: AudienceMember[];
-    /** Defaults to `STORYTELLER_NARRATION`, then `collected` */
-    narration?: NarrationInput;
-    /**
-     * Which default audience to register: colorized text for a person, NDJSON for a
-     * program. Defaults to `STORYTELLER_FORMAT`, then `text`.
-     */
-    format?: OutputFormat;
-    /**
-     * Share another storyteller's audience registry instead of creating one.
-     * Audiences added to it later reach this storyteller too. When given, no
-     * default audience is registered — the registry already has whatever it has.
-     */
-    audience?: AudienceRegistry;
-    /** The story this one is a chapter of. Set by `chapter()`. */
-    parentStoryId?: string;
-    /**
-     * Drop emissions below this level before they reach any audience.
-     * Defaults to `STORYTELLER_LEVEL`, then Information (deliver everything).
-     */
-    level?: LevelInput;
-    /**
-     * Called when an audience throws or rejects. Without one, a single throttled
-     * warning per audience goes to the console — a logging library that loses
-     * records in silence is worse than one that complains.
-     */
-    onAudienceError?: AudienceErrorHandler;
-    /**
-     * Cap on deliveries in flight to a single audience at once. Live narration is
-     * fire-and-forget, so a slow audience would otherwise grow an unbounded queue.
-     * Past the cap, emissions are dropped and counted on the closing story.
-     */
-    maxInFlight?: number;
-};
-/** Called when an audience member throws or rejects while hearing an emission */
-type AudienceErrorHandler = (error: unknown, member: AudienceMember, emission: Emission) => void;
-/** Manages the set of audience members that receive story events */
-declare class AudienceRegistry {
-    private members;
-    /** Register an audience member, replacing any existing member with the same name */
-    add(member: AudienceMember): this;
-    /** Remove an audience member by name */
-    remove(name: string): this;
-    /** Return all registered audience members */
-    getAll(): AudienceMember[];
-    /** Return only the audience members matching the given names */
-    getOnly(names: string[]): AudienceMember[];
-    /** Check if an audience member is registered by name */
-    has(name: string): boolean;
-    /** List the names of all registered audience members */
-    names(): string[];
-}
-/**
- * Collects timestamped notes and emits them as one structured story — and, when
- * narration is live, emits each note the moment it is taken.
- *
- * @example
- * ```ts
- * const story = new Storyteller({ origin: { who: "api-server" }, narration: "live" });
- * story.report("Request received", { what: { path: "/checkout" } });
- * story.report("Validated cart");
- * story.finish("Checkout started");
- * ```
- */
-declare class Storyteller {
-    readonly audience: AudienceRegistry;
-    private readonly origin?;
-    private readonly parentStoryId?;
-    private notes;
-    private narration;
-    private readonly minimumLevel;
-    private readonly onAudienceError;
-    private readonly maxInFlight;
-    /** Deliveries currently awaiting each audience, keyed by audience name */
-    private readonly inFlight;
-    /** Emissions dropped for back-pressure since the current story began */
-    private droppedEmissions;
-    /** Identifies the story currently being collected; regenerated after each telling */
-    private storyId;
-    /** Position of the next note within the current story */
-    private nextSequence;
-    constructor(options?: StorytellerOptions);
-    /**
-     * 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: NarrationInput): this;
-    /** The id of the story currently being collected */
-    get currentStoryId(): string;
-    /**
-     * 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?: ChapterOptions): Storyteller;
-    /**
-     * 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: unknown, data?: NoteData): this;
-    /** Clear all accumulated notes without emitting a story, and start a new story id */
-    reset(): this;
-    /** Preview the current notes as a formatted report without emitting or clearing them */
-    summarize(options?: PreviewOptions): FormattedReport;
-    /**
-     * 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: string, options?: FinishOptions): {
-        to: (...names: string[]) => void;
-    };
-    /** @deprecated Use `finish(title)`. Removed at 1.0. */
-    tell(title: string): {
-        to: (...names: string[]) => void;
-    };
-    /** @deprecated Use `finish(title, { level: "warn" })`. Removed at 1.0. */
-    warn(title: string): {
-        to: (...names: string[]) => void;
-    };
-    /** @deprecated Use `finish(title, { level: "oops", error })`. Removed at 1.0. */
-    oops(title: string, error?: unknown): {
-        to: (...names: string[]) => void;
-    };
-    /** @deprecated Use `report()`. Removed at 1.0. */
-    note(input: unknown, data?: NoteData): this;
-    /** Emit a single note to the audiences listening for notes */
-    private emitNote;
-    /** Build a story event and schedule delivery, returning a handle to override the audience list */
-    private createDelivery;
-    /** Assemble the story event from current notes and start a fresh story */
-    private buildEvent;
-    /** Begin a new story: fresh id, sequence back to zero */
-    private startNewStory;
-    /** Deliver an emission to the audience members listening for its kind */
-    private deliver;
-    /** Run an audience's accepts() without letting a throw from it lose the emission */
-    private acceptsSafely;
-    /**
-     * 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.
-     */
-    private hearSafely;
-    /** Report an audience failure without ever letting it reach caller code */
-    private handleAudienceError;
-}
+import { S as StoryEventBase, R as ReportOptions, F as FormattedReport, a as StoryOriginInput, N as NarrationInput, b as Storyteller, A as AudienceMember, E as EmissionKind, c as StoryEvent, d as StoryLevel, e as StoryStore, f as StoryOrigin, J as JsonValue, g as StoryError } from './stories-BgN4BSoZ.cjs';
+export { v as AnyAudienceMember, B as AudienceErrorHandler, D as AudienceRegistry, O as CanonicalRow, C as ChapterOptions, H as DEFAULT_REDACT_KEYS, $ as DurationInput, t as Emission, u as EmissionOf, y as FinishOptions, L as LevelInput, w as Narration, G as NormalizeOptions, x as NoteData, s as NoteEmission, a4 as OutputFormat, P as PreviewOptions, M as REDACTED, m as ReportNote, Q as StoredStory, a0 as StoriesOptions, i as StoryContextInput, h as StoryContextValue, r as StoryEmission, j as StoryNote, l as StoryPreviewOptions, T as StoryQuery, a3 as StoryQueryBuilder, o as StoryReport, q as StorySummary, p as StorySummaryData, n as StorySummaryNote, k as StorySummaryOptions, z as StorytellerOptions, U as ToStoredStoryOptions, V as applyQuery, W as canonicalRow, X as flattenOrigin, Y as matchesQuery, a8 as meetsLevel, K as normalizeError, I as normalizeValue, a1 as parseDuration, a6 as readEnvironmentValue, aa as resolveColors, a7 as resolveMinimumLevel, a9 as resolveOutputFormat, a2 as stories, Z as storySearchText, _ as toStoredStory, a5 as toStoryLevel } from './stories-BgN4BSoZ.cjs';
 
 /**
  * Format a story event into a human-readable report with optional colors.
@@ -570,7 +60,7 @@ type ConsoleAudienceOptions = {
  * story.audience.add(consoleAudience());
  * ```
  */
-declare function consoleAudience(options?: ConsoleAudienceOptions): AudienceMember;
+declare function consoleAudience(options?: ConsoleAudienceOptions): AudienceMember<EmissionKind>;
 
 /**
  * Create an audience that stores warn and oops stories via your insert function.
@@ -623,7 +113,57 @@ type NdjsonAudienceOptions = {
  * story.audience.add(ndjsonAudience({ stream: process.stderr }));
  * ```
  */
-declare function ndjsonAudience(options?: NdjsonAudienceOptions): AudienceMember;
+declare function ndjsonAudience(options?: NdjsonAudienceOptions): AudienceMember<EmissionKind>;
+
+type MemoryStoreOptions = {
+    /**
+     * How many stories to keep before the oldest are forgotten. A process that
+     * runs for a month must not grow without bound. Default 10 000.
+     */
+    capacity?: number;
+};
+type MemoryStore = StoryStore & {
+    /** How many stories are kept right now */
+    readonly size: number;
+    /** Forget everything */
+    clear(): void;
+};
+/**
+ * The reference StoryStore: a Map, no dependencies, browser-safe.
+ *
+ * Every other adapter is measured against this one — same query, same
+ * results. It is also the right store for tests, for a CLI run that reads its
+ * own stories back before exiting, and for a browser session.
+ */
+declare function memoryStore(options?: MemoryStoreOptions): MemoryStore;
+
+type StoreAudienceOptions = {
+    /** Register under a different name, e.g. to feed two stores */
+    name?: string;
+    /** Minimum level to keep. Default: everything. */
+    level?: StoryLevel;
+    /** A further filter, on top of the level */
+    accepts?: (event: StoryEvent) => boolean;
+};
+/**
+ * The bridge from delivery to persistence: every story the audience hears is
+ * appended to the store, unchanged.
+ *
+ * Keeps everything by default. Storage that only keeps failures cannot answer
+ * "what happened", only "what broke" — and a store has `prune()` for the rest.
+ *
+ * A store that rejects is reported through `onAudienceError`, like any other
+ * audience failure; nothing propagates into the code that told the story.
+ *
+ * @example
+ * ```ts
+ * const stories = memoryStore();
+ * story.audience.add(storeAudience(stories));
+ * // later
+ * await stories.query({ failed: true, since: new Date(Date.now() - 3_600_000) });
+ * ```
+ */
+declare function storeAudience(store: StoryStore, options?: StoreAudienceOptions): AudienceMember;
 
 type StoryReportOptions = {
     timezone?: string;
@@ -664,4 +204,4 @@ declare function summarizeContext(note: {
     error?: StoryError;
 }): string | undefined;
 
-export { ANSI, type AudienceErrorHandler, type AudienceMember, AudienceRegistry, type ChapterOptions, type ConsoleAudienceOptions, DEFAULT_REDACT_KEYS, type Emission, type EmissionKind, type FinishOptions, type FormattedReport, type JsonValue, type LevelInput, type LineWriter, type Narration, type NarrationInput, type NdjsonAudienceOptions, type NormalizeOptions, type NoteData, type NoteEmission, type OutputFormat, type PreviewOptions, REDACTED, type ReportNote, type ReportOptions, type StoryContextInput, type StoryContextValue, type StoryEmission, type StoryError, type StoryEvent, type StoryEventBase, type StoryLevel, type StoryNote, type StoryOrigin, type StoryOriginInput, type StoryPreviewOptions, type StoryReport, type StoryReportOptions, type StorySummary, type StorySummaryData, type StorySummaryNote, type StorySummaryOptions, Storyteller, type StorytellerOptions, consoleAudience, dbAudience, formatDuration, formatOrigin, formatStory, getLevelColor, meetsLevel, ndjsonAudience, normalizeError, normalizeValue, readEnvironmentValue, resolveColors, resolveMinimumLevel, resolveOutputFormat, summarizeContext, summarizeStory, toStoryLevel, useStoryteller, writeStoryReport };
+export { ANSI, AudienceMember, type ConsoleAudienceOptions, EmissionKind, FormattedReport, JsonValue, type LineWriter, type MemoryStore, type MemoryStoreOptions, NarrationInput, type NdjsonAudienceOptions, ReportOptions, type StoreAudienceOptions, StoryError, StoryEvent, StoryEventBase, StoryLevel, StoryOrigin, StoryOriginInput, type StoryReportOptions, StoryStore, Storyteller, consoleAudience, dbAudience, formatDuration, formatOrigin, formatStory, getLevelColor, memoryStore, ndjsonAudience, storeAudience, summarizeContext, summarizeStory, useStoryteller, writeStoryReport };