@chelone/core 0.5.0 → 0.6.0

package/dist/assistant/assistant-session.d.ts

@@ -0,0 +1,22 @@
+import { type MicroStore } from "../store/micro-store.js";
+import type { AssistantMessage, AssistantTool, AssistantToolCall, AssistantTransport } from "./types.js";
+export interface AssistantSessionState {
+    messages: AssistantMessage[];
+    status: "idle" | "streaming" | "error";
+    error: Error | null;
+}
+export interface CreateAssistantSessionOptions {
+    transport: AssistantTransport;
+    tools: Record<string, AssistantTool>;
+    /** Follow-up turns after tool calls before the session gives up. Default 5. */
+    maxToolRounds?: number;
+    /** Answers for tools that set `confirm`. Without it they never run. */
+    confirmTool?: (call: AssistantToolCall) => boolean | Promise<boolean>;
+}
+export interface AssistantSession extends MicroStore<AssistantSessionState> {
+    /** Resolves when the turn, with its tool rounds, ends. */
+    send(text: string): Promise<void>;
+    stop(): void;
+    reset(): void;
+}
+export declare function createAssistantSession({ transport, tools, maxToolRounds, confirmTool, }: CreateAssistantSessionOptions): AssistantSession;

package/dist/assistant/assistant-session.js

@@ -0,0 +1,185 @@
+import { createMicroStore } from "../store/micro-store.js";
+const toError = (error) => error instanceof Error ? error : new Error(String(error));
+const issuesText = (issues) => issues.map((issue) => issue.message).join("; ");
+function raceAbort(promise, signal) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => resolve(void 0);
+    if (signal.aborted) return onAbort();
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
+}
+function createAssistantSession({
+  transport,
+  tools,
+  maxToolRounds = 5,
+  confirmTool
+}) {
+  const store = createMicroStore({
+    messages: [],
+    status: "idle",
+    error: null
+  });
+  const declarations = Object.fromEntries(
+    Object.entries(tools).map(([name, { description, parameters }]) => [
+      name,
+      { description, parameters }
+    ])
+  );
+  let active = null;
+  let destroyed = false;
+  store.onDestroy(() => {
+    destroyed = true;
+    active?.abort();
+    active = null;
+  });
+  async function runTool(call, signal) {
+    const base = {
+      role: "tool",
+      id: call.id,
+      toolName: call.toolName
+    };
+    const definition = Object.hasOwn(tools, call.toolName) ? tools[call.toolName] : void 0;
+    if (!definition) {
+      return { ...base, error: `Unknown tool: ${call.toolName}` };
+    }
+    const stopped = { ...base, error: "Stopped" };
+    try {
+      let args = call.args;
+      if (definition.schema) {
+        const outcome = await definition.schema["~standard"].validate(args);
+        if (signal.aborted) return stopped;
+        if (outcome.issues) {
+          return {
+            ...base,
+            error: `Invalid arguments: ${issuesText(outcome.issues)}`
+          };
+        }
+        args = outcome.value;
+      }
+      if (definition.confirm) {
+        const answer = await confirmTool?.(call);
+        if (signal.aborted) return stopped;
+        if (!answer) {
+          return { ...base, error: "The user declined to run this tool" };
+        }
+      }
+      return { ...base, result: await definition.handler(args) };
+    } catch (error) {
+      return { ...base, error: toError(error).message };
+    }
+  }
+  async function run(controller) {
+    const { signal } = controller;
+    const update = (patch) => {
+      if (!signal.aborted) store.setState(patch);
+    };
+    for (let round = 0; ; round++) {
+      let content = "";
+      let index = -1;
+      const calls = [];
+      let iterator;
+      try {
+        iterator = transport.send(store.getSnapshot().messages, declarations, { signal })[Symbol.asyncIterator]();
+        for (; ; ) {
+          const step = await raceAbort(iterator.next(), signal);
+          if (!step || step.done || signal.aborted) break;
+          const chunk = step.value;
+          if (chunk.type === "done") break;
+          if (chunk.type === "tool-call") {
+            const { id, toolName, args } = chunk;
+            calls.push({ id, toolName, args });
+            continue;
+          }
+          content += chunk.delta;
+          const text = content;
+          if (index < 0) {
+            index = store.getSnapshot().messages.length;
+            update((s) => ({
+              messages: [...s.messages, { role: "assistant", content: text }]
+            }));
+          } else {
+            update((s) => ({
+              messages: s.messages.map(
+                (m, i) => i === index ? { role: "assistant", content: text } : m
+              )
+            }));
+          }
+        }
+      } catch (error) {
+        if (!signal.aborted) {
+          update(() => ({ status: "error", error: toError(error) }));
+        }
+        return;
+      } finally {
+        iterator?.return?.().catch(() => {
+        });
+      }
+      if (signal.aborted) return;
+      if (calls.length === 0) break;
+      if (round >= maxToolRounds) {
+        update(() => ({
+          status: "error",
+          error: new Error(
+            `The assistant kept calling tools after ${maxToolRounds} rounds`
+          )
+        }));
+        return;
+      }
+      const results = [];
+      for (const call of calls) {
+        const result = await raceAbort(runTool(call, signal), signal);
+        if (!result) return;
+        results.push(result);
+        if (signal.aborted) return;
+      }
+      const assistant = {
+        role: "assistant",
+        content,
+        toolCalls: calls
+      };
+      update((s) => ({
+        messages: index < 0 ? [...s.messages, assistant, ...results] : [
+          ...s.messages.map((m, i) => i === index ? assistant : m),
+          ...results
+        ]
+      }));
+    }
+    update(() => ({ status: "idle" }));
+  }
+  return {
+    ...store,
+    async send(text) {
+      if (destroyed) return;
+      if (!text.trim() || store.getSnapshot().status === "streaming") return;
+      const controller = new AbortController();
+      active = controller;
+      store.setState((s) => ({
+        messages: [...s.messages, { role: "user", content: text }],
+        status: "streaming",
+        error: null
+      }));
+      try {
+        await run(controller);
+      } finally {
+        if (active === controller) active = null;
+      }
+    },
+    stop() {
+      if (!active) return;
+      active.abort();
+      active = null;
+      store.setState({ status: "idle" });
+    },
+    reset() {
+      active?.abort();
+      active = null;
+      store.setState({ messages: [], status: "idle", error: null });
+    }
+  };
+}
+export {
+  createAssistantSession
+};

package/dist/assistant/echo-transport.d.ts

@@ -0,0 +1,7 @@
+import type { AssistantTransport } from "./types.js";
+export interface EchoAssistantTransportOptions {
+    /** Waits this long before each character. */
+    delayMs?: number;
+}
+/** Replies `Echo: <last user text>` one character at a time, with no model behind it. */
+export declare function echoAssistantTransport({ delayMs, }?: EchoAssistantTransportOptions): AssistantTransport;

package/dist/assistant/echo-transport.js

@@ -0,0 +1,31 @@
+const wait = (ms, signal) => new Promise((resolve) => {
+  const timer = setTimeout(done, ms);
+  function done() {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", done);
+    resolve();
+  }
+  signal.addEventListener("abort", done, { once: true });
+});
+function echoAssistantTransport({
+  delayMs = 0
+} = {}) {
+  return {
+    async *send(messages, _tools, { signal }) {
+      let said = "";
+      for (const message of messages) {
+        if (message.role === "user") said = message.content;
+      }
+      const reply = `Echo: ${said}`;
+      for (const delta of reply) {
+        if (delayMs > 0) await wait(delayMs, signal);
+        if (signal.aborted) return;
+        yield { type: "text", delta };
+      }
+      yield { type: "done" };
+    }
+  };
+}
+export {
+  echoAssistantTransport
+};

package/dist/assistant/types.d.ts

@@ -0,0 +1,60 @@
+import type { StandardSchemaV1 } from "@tanstack/form-core";
+/** What crosses the model boundary: arguments in, results out. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+/** A tool call the model asked for. `id` ties the result back to it. */
+export interface AssistantToolCall {
+    id: string;
+    toolName: string;
+    args: JsonObject;
+}
+export type AssistantMessage = {
+    role: "user";
+    content: string;
+} | {
+    role: "assistant";
+    content: string;
+    /** Present once the calls ran and their results follow as tool messages. */
+    toolCalls?: AssistantToolCall[];
+} | {
+    role: "tool";
+    /** The `id` of the call this answers. */
+    id: string;
+    toolName: string;
+    /** What the handler returned; absent when `error` is set. */
+    result?: JsonValue;
+    error?: string;
+};
+export type AssistantChunk = {
+    type: "text";
+    delta: string;
+} | ({
+    type: "tool-call";
+} & AssistantToolCall) | {
+    type: "done";
+};
+export interface AssistantTool {
+    description: string;
+    /** A JSON Schema object, handed to the transport as is. */
+    parameters: JsonObject;
+    /** Method syntax keeps a handler with narrower `args` assignable. */
+    handler(args: JsonObject): JsonValue | undefined | Promise<JsonValue | undefined>;
+    /** Checks the arguments before `handler` runs; its output reaches `handler`. */
+    schema?: StandardSchemaV1<JsonObject, JsonObject>;
+    /** Ask the user through the session's `confirmTool` before this tool runs. */
+    confirm?: boolean;
+}
+/** What a transport learns about a tool: no handler, schema or confirm. */
+export interface AssistantToolDeclaration {
+    description: string;
+    parameters: JsonObject;
+}
+export interface AssistantTransport {
+    send(messages: readonly AssistantMessage[], tools: Readonly<Record<string, AssistantToolDeclaration>>, options: {
+        signal: AbortSignal;
+    }): AsyncIterable<AssistantChunk>;
+}

package/dist/chart/chart-data.d.ts

@@ -0,0 +1,25 @@
+/** Theme variables the registry ships, in series order. */
+export declare const DEFAULT_CHART_COLORS: readonly string[];
+export declare function chartColor(index: number, colors?: readonly string[]): string;
+/** One point of a series: `x` is the row's value as given, `y` a finite number or a `null` gap. */
+export type CartesianRow<TX> = {
+    index: number;
+    x: TX;
+    y: number | null;
+};
+export declare function toCartesianRows<TRow extends object, TX extends keyof TRow & string, TY extends keyof TRow & string>(data: readonly TRow[], xField: TX, yField: TY): CartesianRow<TRow[TX]>[];
+export declare function hasChartValues(rows: readonly {
+    y: number | null;
+}[]): boolean;
+export type DonutSlice = {
+    label: string;
+    value: number;
+    share: number;
+};
+export declare function toDonutSlices<TRow extends object, TLabel extends keyof TRow & string, TValue extends keyof TRow & string>(data: readonly TRow[], labelField: TLabel, valueField: TValue): DonutSlice[];
+export type MetricDelta = {
+    direction: "up" | "down" | "flat";
+    text: string;
+};
+/** `delta` is a ratio (0.05 is 5.0%). Direction follows the sign of `delta`, not of the rounded text. */
+export declare function getMetricDelta(delta: number | undefined): MetricDelta | null;

package/dist/chart/chart-data.js

@@ -0,0 +1,59 @@
+const DEFAULT_CHART_COLORS = [
+  "var(--chart-1)",
+  "var(--chart-2)",
+  "var(--chart-3)",
+  "var(--chart-4)",
+  "var(--chart-5)"
+];
+const FALLBACK_COLOR = "var(--chart-1)";
+function chartColor(index, colors = DEFAULT_CHART_COLORS) {
+  const list = colors.length > 0 ? colors : DEFAULT_CHART_COLORS;
+  const length = list.length;
+  return list[(index % length + length) % length] ?? FALLBACK_COLOR;
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function toCartesianRows(data, xField, yField) {
+  return data.map((row, index) => ({
+    index,
+    x: row[xField],
+    y: toFiniteNumber(row[yField])
+  }));
+}
+function hasChartValues(rows) {
+  return rows.some((row) => row.y !== null);
+}
+function toLabel(value) {
+  return value === void 0 || value === null ? "" : String(value);
+}
+function toDonutSlices(data, labelField, valueField) {
+  const kept = [];
+  for (const row of data) {
+    const value = toFiniteNumber(row[valueField]);
+    if (value !== null && value > 0) {
+      kept.push({ label: toLabel(row[labelField]), value });
+    }
+  }
+  const total = kept.reduce((sum, slice) => sum + slice.value, 0);
+  if (total <= 0) return [];
+  return kept.map((slice) => ({ ...slice, share: slice.value / total }));
+}
+function getMetricDelta(delta) {
+  if (delta === void 0 || !Number.isFinite(delta)) return null;
+  const direction = delta > 0 ? "up" : delta < 0 ? "down" : "flat";
+  return { direction, text: `${(delta * 100).toFixed(1)}%` };
+}
+export {
+  DEFAULT_CHART_COLORS,
+  chartColor,
+  getMetricDelta,
+  hasChartValues,
+  toCartesianRows,
+  toDonutSlices
+};

package/dist/controller/infinite-list-controller.js

@@ -1,5 +1,5 @@
 import { QueryClient, InfiniteQueryObserver } from "@tanstack/query-core";
-import { getListOptions, getInfiniteListOptions } from "../data/query-options.js";
+import { getInfiniteListOptions, getListOptions } from "../data/query-options.js";
 import { createMicroStore } from "../store/micro-store.js";
 import { createListController, createErrorAnnouncer, runSelectAll } from "./list-controller.js";
 function createInfiniteListController(ctx, resource, options = {}) {

package/dist/controller/job-monitor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Pure rules behind a job monitor's Retry and Cancel buttons, so every adapter
+ * offers them on the same jobs and writes the same patch.
+ *
+ * These are UI rules, not security ones: the server has to refuse a retry of a
+ * job that is not failed. Retry writes only the status; the worker counts
+ * attempts.
+ */
+import type { Identifier } from "../resource/identifier.js";
+import type { ResourceRecord } from "../resource/record.js";
+import type { SourceKey } from "../resource/source-path.js";
+/** The monitor's tabs, in order. One `buildKanbanBuckets` column per status. */
+export declare const DEFAULT_JOB_TABS: readonly ["running", "queued", "failed", "done"];
+export interface JobActionOptions<TRecord = Record<string, unknown>> {
+    /** Record field holding the job status, a top-level key. Default `"status"`. */
+    statusSource?: SourceKey<TRecord>;
+    /** Statuses a job can be retried from. Default `["failed"]`. */
+    retryFrom?: readonly string[];
+    /** Statuses a job can be cancelled from. Default `["running", "queued"]`. */
+    cancelFrom?: readonly string[];
+    /** Status Retry writes. Default `"queued"`. */
+    retryValue?: string;
+    /** Status Cancel writes. Default `"cancelled"`. */
+    cancelValue?: string;
+}
+export interface JobActions {
+    /** The job's status as a string; `""` when it has none. */
+    status: string;
+    canRetry: boolean;
+    canCancel: boolean;
+}
+/** The arguments of one `update` call, ready to hand to a data provider. */
+export interface JobPlan<TRecord> {
+    id: Identifier;
+    data: Record<string, string>;
+    previousData: TRecord;
+}
+export declare function getJobActions<TRecord = Record<string, unknown>>(record: TRecord & object, options?: JobActionOptions<TRecord>): JobActions;
+/** The `update` that retries the job, or `null` when it cannot be retried. */
+export declare function planJobRetry<TRecord extends ResourceRecord = ResourceRecord>(record: TRecord, options?: JobActionOptions<TRecord>): JobPlan<TRecord> | null;
+/** The `update` that cancels the job, or `null` when it cannot be cancelled. */
+export declare function planJobCancel<TRecord extends ResourceRecord = ResourceRecord>(record: TRecord, options?: JobActionOptions<TRecord>): JobPlan<TRecord> | null;

package/dist/controller/job-monitor.js

@@ -0,0 +1,59 @@
+import { getAllowedTransitions } from "./record-workflow.js";
+const DEFAULT_JOB_TABS = [
+  "running",
+  "queued",
+  "failed",
+  "done"
+];
+function canMove(record, source, from, to) {
+  const transitions = Object.fromEntries(from.map((status) => [status, [to]]));
+  const { current, allowed } = getAllowedTransitions(record, {
+    source,
+    transitions
+  });
+  return { status: current, allowed: allowed.includes(to) };
+}
+function getJobActions(record, options = {}) {
+  const {
+    statusSource = "status",
+    retryFrom = ["failed"],
+    cancelFrom = ["running", "queued"],
+    retryValue = "queued",
+    cancelValue = "cancelled"
+  } = options;
+  const retry = canMove(record, statusSource, retryFrom, retryValue);
+  const cancel = canMove(record, statusSource, cancelFrom, cancelValue);
+  return {
+    status: retry.status,
+    canRetry: retry.allowed,
+    canCancel: cancel.allowed
+  };
+}
+function plan(record, source, value, allowed) {
+  if (!allowed) return null;
+  return { id: record.id, data: { [source]: value }, previousData: record };
+}
+function planJobRetry(record, options = {}) {
+  const { statusSource = "status", retryValue = "queued" } = options;
+  return plan(
+    record,
+    statusSource,
+    retryValue,
+    getJobActions(record, options).canRetry
+  );
+}
+function planJobCancel(record, options = {}) {
+  const { statusSource = "status", cancelValue = "cancelled" } = options;
+  return plan(
+    record,
+    statusSource,
+    cancelValue,
+    getJobActions(record, options).canCancel
+  );
+}
+export {
+  DEFAULT_JOB_TABS,
+  getJobActions,
+  planJobCancel,
+  planJobRetry
+};

package/dist/controller/pivot-grid.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pure rule for pivoting a flat record list into a row by column table. No
+ * react, no vue: both PivotGrid adapters build the same table from the same
+ * records and print numbers the same way.
+ */
+import type { SourcePath } from "../resource/source-path.js";
+export type PivotAggregator = "count" | "sum" | "avg" | "min" | "max";
+export interface PivotOptions<R> {
+    rowSource: SourcePath<R>;
+    columnSource: SourcePath<R>;
+    /** Read by every aggregator but `count`. */
+    valueSource?: SourcePath<R>;
+    /** Defaults to `count`. */
+    aggregator?: PivotAggregator;
+}
+export interface PivotTable {
+    rowKeys: string[];
+    columnKeys: string[];
+    /** `cells[row][column]` follows the order of `rowKeys` and `columnKeys`. */
+    cells: (number | null)[][];
+    rowTotals: (number | null)[];
+    columnTotals: (number | null)[];
+    grandTotal: number | null;
+}
+/**
+ * A row or column key is `String(value)`, and a null, undefined or empty value
+ * is the key `""`. Keys sort numerically (`10` after `9`) with `""` last.
+ * `count` counts records and ignores `valueSource`. The other aggregators use
+ * finite numbers and numeric strings, and skip anything else. A cell with no
+ * records is `null`, and so is a cell with no usable value, unless it counts.
+ * A total aggregates the raw values of its row, column or table, never the
+ * cell results, so an average total is not a sum of averages.
+ */
+export declare function buildPivotTable<R>(records: readonly R[], options: PivotOptions<R>): PivotTable;
+/** Integers print bare and fractions round to two digits. */
+export declare function formatPivotValue(value: number, locale?: string): string;

package/dist/controller/pivot-grid.js

@@ -0,0 +1,105 @@
+import { getAtPath } from "../resource/get-at-path.js";
+const collator = new Intl.Collator(void 0, { numeric: true });
+const NUMERIC_KEY = /^-?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i;
+const compareKeys = (a, b) => {
+  if (a === b) return 0;
+  if (a === "") return 1;
+  if (b === "") return -1;
+  if (NUMERIC_KEY.test(a) && NUMERIC_KEY.test(b)) {
+    const difference = Number(a) - Number(b);
+    if (difference !== 0 && !Number.isNaN(difference)) return difference;
+  }
+  return collator.compare(a, b) || (a < b ? -1 : 1);
+};
+const toKey = (value) => value == null || value === "" ? "" : String(value);
+const toNumber = (value) => {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "string" && value !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+};
+const aggregate = (group, aggregator) => {
+  if (group.count === 0) return null;
+  if (aggregator === "count") return group.count;
+  const { values } = group;
+  if (values.length === 0) return null;
+  switch (aggregator) {
+    case "sum":
+      return values.reduce((total, value) => total + value, 0);
+    case "avg":
+      return values.reduce((total, value) => total + value, 0) / values.length;
+    case "min":
+      return values.reduce((a, b) => b < a ? b : a);
+    case "max":
+      return values.reduce((a, b) => b > a ? b : a);
+  }
+};
+const newGroup = () => ({ count: 0, values: [] });
+const getOrCreate = (map, key, create) => {
+  const existing = map.get(key);
+  if (existing !== void 0) return existing;
+  const created = create();
+  map.set(key, created);
+  return created;
+};
+const add = (group, value) => {
+  group.count += 1;
+  if (value !== void 0) group.values.push(value);
+};
+function buildPivotTable(records, options) {
+  const {
+    rowSource,
+    columnSource,
+    valueSource,
+    aggregator = "count"
+  } = options;
+  const readsValue = aggregator !== "count" && valueSource !== void 0;
+  const cellGroups = /* @__PURE__ */ new Map();
+  const rowGroups = /* @__PURE__ */ new Map();
+  const columnGroups = /* @__PURE__ */ new Map();
+  const tableGroup = newGroup();
+  for (const record of records) {
+    const row = toKey(getAtPath(record, rowSource));
+    const column = toKey(getAtPath(record, columnSource));
+    const value = readsValue ? toNumber(getAtPath(record, valueSource)) : void 0;
+    const cellRow = getOrCreate(cellGroups, row, () => /* @__PURE__ */ new Map());
+    const cell = getOrCreate(cellRow, column, newGroup);
+    const rowGroup = getOrCreate(rowGroups, row, newGroup);
+    const columnGroup = getOrCreate(columnGroups, column, newGroup);
+    add(cell, value);
+    add(rowGroup, value);
+    add(columnGroup, value);
+    add(tableGroup, value);
+  }
+  const rowKeys = [...rowGroups.keys()].sort(compareKeys);
+  const columnKeys = [...columnGroups.keys()].sort(compareKeys);
+  const empty = newGroup();
+  return {
+    rowKeys,
+    columnKeys,
+    cells: rowKeys.map(
+      (row) => columnKeys.map(
+        (column) => aggregate(cellGroups.get(row)?.get(column) ?? empty, aggregator)
+      )
+    ),
+    rowTotals: rowKeys.map(
+      (row) => aggregate(rowGroups.get(row), aggregator)
+    ),
+    columnTotals: columnKeys.map(
+      (column) => aggregate(columnGroups.get(column), aggregator)
+    ),
+    grandTotal: aggregate(tableGroup, aggregator)
+  };
+}
+function formatPivotValue(value, locale) {
+  return new Intl.NumberFormat(locale, { maximumFractionDigits: 2 }).format(
+    value
+  );
+}
+export {
+  buildPivotTable,
+  formatPivotValue
+};

package/dist/controller/record-timeline.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pure rules for a record timeline. No react, no vue: both RecordTimeline
+ * adapters read the same entries from the same records and print the same
+ * relative time text.
+ */
+import type { Identifier } from "../resource/identifier.js";
+import type { SourcePath } from "../resource/source-path.js";
+export interface RecordTimelineEntry<R> {
+    id: Identifier;
+    record: R;
+    message: string;
+    /** `undefined` when the timestamp is missing or not a valid date. */
+    date: Date | undefined;
+    user: string | undefined;
+    icon: string | undefined;
+}
+export interface ToTimelineEntriesOptions<R> {
+    messageSource: SourcePath<R>;
+    timestampSource: SourcePath<R>;
+    userSource?: SourcePath<R>;
+    iconSource?: SourcePath<R>;
+}
+/**
+ * One entry per record, in list order: the data provider's sort decides the
+ * order, and the records are not changed.
+ */
+export declare function toTimelineEntries<R extends {
+    id: Identifier;
+}>(records: readonly R[], options: ToTimelineEntriesOptions<R>): RecordTimelineEntry<R>[];
+/**
+ * "2 hours ago" or "in 3 days", from the distance between `date` and `now`
+ * in whole seconds, minutes, hours, days or 30-day months. It takes `now` so
+ * a caller decides what the present is.
+ */
+export declare function formatRelativeTime(date: Date, now: Date, locale?: string): string;