adispatchd 0.0.0-stage → 0.1.0

package/dist/ui/public/js/shared/sse.js

@@ -0,0 +1,193 @@
+/**
+ * Live connection to `GET /api/v1/events` (Spec §15, docs/api.md) with
+ * reconnect logic, independent of the DOM (the browser passes
+ * `url => new EventSource(url)`, tests pass a fake).
+ *
+ * - The browser's EventSource reconnects by itself after a dropped connection
+ *   (`readyState` CONNECTING) and sends `Last-Event-ID`; the server replays
+ *   missed persistent events.
+ * - If the EventSource gives up (`readyState` CLOSED, e.g. HTTP 503 during a
+ *   restart), a new one is created after an exponential backoff, passing the
+ *   last seen ID as `?lastEventId=`.
+ * - Non-persistent events (logs, actions, system status) are lost while
+ *   disconnected: after every re-open (and on `stream.reset`) `onResync` is
+ *   called so the current page reloads its state via REST.
+ * - Persistent events already delivered (ID ≤ last seen ID) are dropped.
+ */
+/** EventSource `readyState` values. */
+export const ES_CONNECTING = 0;
+export const ES_OPEN = 1;
+export const ES_CLOSED = 2;
+/** All event types sent by the server (`event:` field). */
+export const LIVE_EVENT_TYPES = [
+    'stream.open',
+    'stream.reset',
+    'run.event',
+    'run.output',
+    'run.action',
+    'block.created',
+    'block.cleared',
+    'system.status',
+    'system.ready',
+    'notification',
+    'config.reloaded',
+    'retention.finished',
+];
+/** Parse one SSE message; `null` if the data is not a JSON object. */
+export function parseLiveMessage(type, data) {
+    if (typeof data !== 'string')
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const o = parsed;
+    // Only the `id` inside the data marks a persistent event. `MessageEvent.lastEventId` is NOT used: the
+    // browser carries the last seen ID over to later non-persistent messages (they would look like duplicates).
+    const id = typeof o.id === 'number' && Number.isInteger(o.id) && o.id >= 0 ? o.id : null;
+    const payload = o.payload && typeof o.payload === 'object' && !Array.isArray(o.payload) ? o.payload : {};
+    return { type: typeof o.type === 'string' ? o.type : type, time: typeof o.time === 'string' ? o.time : null, id, payload };
+}
+/** Reconnect delay for the n-th consecutive failed attempt (1-based). */
+export function backoffDelay(attempt, initialMs = 1000, maxMs = 30_000) {
+    const n = Math.max(1, Math.floor(attempt));
+    return Math.min(maxMs, initialMs * 2 ** Math.min(n - 1, 20));
+}
+/** Build the stream URL with an optional `lastEventId`. */
+export function streamUrl(base, lastEventId) {
+    if (lastEventId === null)
+        return base;
+    return `${base}${base.includes('?') ? '&' : '?'}lastEventId=${lastEventId}`;
+}
+/** See module comment. */
+export class LiveConnection {
+    opts;
+    es = null;
+    timer = null;
+    attempts = 0;
+    opened = false;
+    stopped = true;
+    current = 'closed';
+    /** Highest persistent event ID seen. */
+    lastEventId = null;
+    timers;
+    constructor(opts) {
+        this.opts = opts;
+        this.timers = opts.timers ?? {
+            setTimeout: (fn, ms) => setTimeout(fn, ms),
+            clearTimeout: (h) => clearTimeout(h),
+        };
+    }
+    get state() {
+        return this.current;
+    }
+    /** Connect (idempotent). */
+    start() {
+        if (!this.stopped)
+            return;
+        this.stopped = false;
+        this.connect();
+    }
+    /** Disconnect and stop reconnecting. */
+    stop() {
+        this.stopped = true;
+        this.clearTimer();
+        this.es?.close();
+        this.es = null;
+        this.setState('closed');
+    }
+    /** Reconnect now (e.g. browser came back online) if currently waiting for a retry. */
+    reconnectNow() {
+        if (this.stopped || this.timer === null)
+            return;
+        this.clearTimer();
+        this.connect();
+    }
+    connect() {
+        this.setState(this.opened ? 'reconnecting' : 'connecting');
+        const es = this.opts.create(streamUrl(this.opts.url, this.lastEventId));
+        this.es = es;
+        es.onopen = () => {
+            if (this.es !== es)
+                return;
+            this.attempts = 0;
+        };
+        es.onerror = () => {
+            if (this.es !== es || this.stopped)
+                return;
+            if (es.readyState === ES_CLOSED) {
+                es.close();
+                this.es = null;
+                this.scheduleReconnect();
+            }
+            else {
+                // The browser retries by itself (Last-Event-ID is sent automatically).
+                this.setState('reconnecting');
+            }
+        };
+        for (const type of LIVE_EVENT_TYPES) {
+            es.addEventListener(type, (ev) => {
+                if (this.es !== es || this.stopped)
+                    return;
+                this.handle(type, ev);
+            });
+        }
+    }
+    handle(type, ev) {
+        const msg = parseLiveMessage(type, ev.data);
+        if (!msg)
+            return;
+        if (msg.type === 'stream.open') {
+            const reopened = this.opened;
+            this.opened = true;
+            this.attempts = 0;
+            if (msg.id !== null && (this.lastEventId === null || msg.id > this.lastEventId))
+                this.lastEventId = msg.id;
+            this.setState('open');
+            if (reopened)
+                this.opts.onResync('reconnected');
+            return;
+        }
+        if (msg.type === 'stream.reset') {
+            // The server's baseline wins (it may be lower, e.g. after a data-dir restore).
+            if (msg.id !== null)
+                this.lastEventId = msg.id;
+            this.opts.onResync('reset');
+            return;
+        }
+        if (msg.id !== null) {
+            if (this.lastEventId !== null && msg.id <= this.lastEventId)
+                return; // duplicate
+            this.lastEventId = msg.id;
+        }
+        if (this.current !== 'open')
+            this.setState('open');
+        this.opts.onMessage(msg);
+    }
+    scheduleReconnect() {
+        this.attempts++;
+        this.setState('reconnecting');
+        const delay = backoffDelay(this.attempts, this.opts.initialDelayMs ?? 1000, this.opts.maxDelayMs ?? 30_000);
+        this.timer = this.timers.setTimeout(() => {
+            this.timer = null;
+            if (!this.stopped)
+                this.connect();
+        }, delay);
+    }
+    clearTimer() {
+        if (this.timer !== null)
+            this.timers.clearTimeout(this.timer);
+        this.timer = null;
+    }
+    setState(state) {
+        if (this.current === state)
+            return;
+        this.current = state;
+        this.opts.onState?.(state);
+    }
+}

package/dist/ui/public/js/shared/throttle.js

@@ -0,0 +1,65 @@
+/**
+ * Coalescing refresher: many live events → at most one REST reload per
+ * interval, never two concurrent reloads, and always a trailing reload after
+ * the last trigger.
+ */
+const defaultTimers = {
+    setTimeout: (fn, ms) => setTimeout(fn, ms),
+    clearTimeout: (h) => clearTimeout(h),
+};
+/** Create a {@link Refresher} for `fn` with a minimal distance of `intervalMs`. */
+export function createRefresher(fn, intervalMs, timers = defaultTimers) {
+    let timer = null;
+    let running = null;
+    let dirty = false;
+    let disposed = false;
+    const run = async () => {
+        if (disposed)
+            return;
+        if (running) {
+            dirty = true;
+            return running;
+        }
+        dirty = false;
+        running = (async () => {
+            try {
+                await fn();
+            }
+            catch {
+                // errors are reported by fn itself
+            }
+        })();
+        try {
+            await running;
+        }
+        finally {
+            running = null;
+        }
+        if (dirty && !disposed)
+            schedule();
+    };
+    const schedule = () => {
+        if (disposed || timer !== null)
+            return;
+        timer = timers.setTimeout(() => {
+            timer = null;
+            void run();
+        }, intervalMs);
+    };
+    return {
+        trigger: schedule,
+        now: () => {
+            if (timer !== null) {
+                timers.clearTimeout(timer);
+                timer = null;
+            }
+            return run();
+        },
+        dispose: () => {
+            disposed = true;
+            if (timer !== null)
+                timers.clearTimeout(timer);
+            timer = null;
+        },
+    };
+}

package/dist/views/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Component `views` – public API (WI-10): read-only views over one or more
+ * sources with run enrichment (Spec §17). Other components import from this
+ * module only.
+ */
+export { ViewService, UnknownViewError, DEFAULT_VIEW_CACHE_TTL_MS, MAX_VIEW_ROWS, VIEW_RUN_FIELDS, runFields, safeLink, type ViewCell, type ViewColumn, type ViewItemsResult, type ViewRow, type ViewServiceOptions, type ViewSummary, } from './service.js';

package/dist/views/index.js

@@ -0,0 +1,7 @@
+/**
+ * Component `views` – public API (WI-10): read-only views over one or more
+ * sources with run enrichment (Spec §17). Other components import from this
+ * module only.
+ */
+export { ViewService, UnknownViewError, DEFAULT_VIEW_CACHE_TTL_MS, MAX_VIEW_ROWS, VIEW_RUN_FIELDS, runFields, safeLink, } from './service.js';
+//# sourceMappingURL=index.js.map

package/dist/views/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/views/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,yBAAyB,EACzB,aAAa,EACb,eAAe,EACf,SAAS,EACT,QAAQ,GAOT,MAAM,cAAc,CAAC"}

package/dist/views/service.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Read-only views (Spec §17): items from one or more sources of the same
+ * adapter type, filtered declaratively (no shell), enriched with internal run
+ * metadata (`run.last_*`) by the global item key, sorted, with link columns.
+ *
+ * - Data is loaded on open/refresh; results are cached briefly (default 30 s).
+ * - The view filter is evaluated locally on every item (adapters may receive
+ *   the pushable part but are allowed to ignore it); only `true` matches –
+ *   `unknown` items are not shown (counted in `filterUnknown`).
+ * - Unavailable columns stay recognizably empty (`value: null`, `known: false`).
+ * - A failing source does not hide the other sources' rows (`errors`).
+ */
+import { OrchestratorError, VIEW_RUN_FIELDS, type Clock, type FieldType, type FieldValue, type Logger, type Redactor, type SourceAdapter } from '../core/index.js';
+import type { ConfigManager, ViewConfig } from '../config/index.js';
+import type { RunRecord, RunRepository } from '../persistence/index.js';
+/** Default cache lifetime of view results. */
+export declare const DEFAULT_VIEW_CACHE_TTL_MS = 30000;
+/** Max rows returned per view (more are cut off, `truncated: true`). */
+export declare const MAX_VIEW_ROWS = 2000;
+/** Internal run fields available to views (defined in core so config validation can use them). */
+export { VIEW_RUN_FIELDS };
+/** A view column. */
+export interface ViewColumn {
+    field: string;
+    label: string;
+    /** Field providing the link target (http(s) only). */
+    link: string | null;
+    /** Declared type, if known. */
+    type: FieldType | null;
+}
+/** One cell (same order as the columns). */
+export interface ViewCell {
+    /** `null` when empty or unavailable. */
+    value: FieldValue | null;
+    /** False if the field could not be resolved (unknown field, missing permission, ...). */
+    known: boolean;
+    /** http(s) URL of the link column, if any. */
+    link: string | null;
+}
+/** One row (= one external item). */
+export interface ViewRow {
+    /** Global item key `<sourceId>:<itemId>`. */
+    key: string;
+    sourceId: string;
+    itemId: string;
+    url: string | null;
+    /** Latest run of this item (for linking into the run detail), if any. */
+    lastRunId: string | null;
+    cells: ViewCell[];
+}
+/** Result of {@link ViewService.items}. */
+export interface ViewItemsResult {
+    view: {
+        id: string;
+        title: string;
+        sources: string[];
+    };
+    columns: ViewColumn[];
+    rows: ViewRow[];
+    /** Per-source problems (other sources still contribute rows). */
+    errors: Array<{
+        sourceId: string;
+        message: string;
+    }>;
+    /** Items whose filter evaluated to `unknown` (not shown). */
+    filterUnknown: number;
+    truncated: boolean;
+    fetchedAt: string;
+    /** True if served from the cache. */
+    cached: boolean;
+}
+/** View definition as exposed by the API. */
+export interface ViewSummary {
+    id: string;
+    title: string;
+    file: string;
+    sources: string[];
+    columns: ViewColumn[];
+    sort: ViewConfig['sort'];
+    filter: ViewConfig['filter'];
+}
+/** Options of {@link ViewService}. */
+export interface ViewServiceOptions {
+    config: Pick<ConfigManager, 'current'>;
+    sources: (sourceId: string) => SourceAdapter | undefined;
+    runs: Pick<RunRepository, 'lastRunsForItems'>;
+    clock?: Clock;
+    logger?: Logger;
+    cacheTtlMs?: number;
+    /** Redaction of error texts (shared `SecretRedactor`). */
+    redact?: Redactor;
+}
+/** Error for unknown views. */
+export declare class UnknownViewError extends OrchestratorError {
+    readonly viewId: string;
+    constructor(viewId: string);
+}
+/** See module docs. */
+export declare class ViewService {
+    private readonly options;
+    private readonly clock;
+    private readonly logger;
+    private readonly ttl;
+    private readonly redact;
+    private readonly cache;
+    private readonly inflight;
+    constructor(options: ViewServiceOptions);
+    /** All view definitions, sorted by title. */
+    list(): ViewSummary[];
+    /** One view definition or `undefined`. */
+    get(viewId: string): ViewSummary | undefined;
+    /** Drop cached results (config reload). */
+    invalidate(): void;
+    /**
+     * Current items of a view. Cached for the TTL unless `refresh`; concurrent
+     * requests for the same view share one load.
+     * @throws UnknownViewError
+     */
+    items(viewId: string, options?: {
+        refresh?: boolean;
+    }): Promise<ViewItemsResult>;
+    private view;
+    private summary;
+    private definitionsFor;
+    private columns;
+    private load;
+}
+/** `run.last_*` values for an item (known empty if the item has no run). */
+export declare function runFields(run: RunRecord | null): Record<string, FieldValue>;
+/** Only absolute http(s) URLs are used as links (XSS, Spec §20.5). */
+export declare function safeLink(value: unknown): string | null;

package/dist/views/service.js

@@ -0,0 +1,264 @@
+/**
+ * Read-only views (Spec §17): items from one or more sources of the same
+ * adapter type, filtered declaratively (no shell), enriched with internal run
+ * metadata (`run.last_*`) by the global item key, sorted, with link columns.
+ *
+ * - Data is loaded on open/refresh; results are cached briefly (default 30 s).
+ * - The view filter is evaluated locally on every item (adapters may receive
+ *   the pushable part but are allowed to ignore it); only `true` matches –
+ *   `unknown` items are not shown (counted in `filterUnknown`).
+ * - Unavailable columns stay recognizably empty (`value: null`, `known: false`).
+ * - A failing source does not hide the other sources' rows (`errors`).
+ */
+import { errorMessage, noopLogger, OrchestratorError, systemClock, VIEW_RUN_FIELDS, } from '../core/index.js';
+import { collectFields, createItemFieldSource, evaluateFilter, naturalCompare, splitForPushdown } from '../filters/index.js';
+/** Default cache lifetime of view results. */
+export const DEFAULT_VIEW_CACHE_TTL_MS = 30_000;
+/** Max rows returned per view (more are cut off, `truncated: true`). */
+export const MAX_VIEW_ROWS = 2_000;
+/** Internal run fields available to views (defined in core so config validation can use them). */
+export { VIEW_RUN_FIELDS };
+/** Error for unknown views. */
+export class UnknownViewError extends OrchestratorError {
+    viewId;
+    constructor(viewId) {
+        super('view_not_found', `Unknown view "${viewId}"`, { details: { viewId } });
+        this.viewId = viewId;
+    }
+}
+/** See module docs. */
+export class ViewService {
+    options;
+    clock;
+    logger;
+    ttl;
+    redact;
+    cache = new Map();
+    inflight = new Map();
+    constructor(options) {
+        this.options = options;
+        this.clock = options.clock ?? systemClock;
+        this.logger = (options.logger ?? noopLogger).child({ component: 'views' });
+        this.ttl = options.cacheTtlMs ?? DEFAULT_VIEW_CACHE_TTL_MS;
+        this.redact = options.redact ?? ((t) => t);
+    }
+    /** All view definitions, sorted by title. */
+    list() {
+        return Object.values(this.options.config.current.views)
+            .map((v) => this.summary(v))
+            .sort((a, b) => naturalCompare(a.title, b.title) || naturalCompare(a.id, b.id));
+    }
+    /** One view definition or `undefined`. */
+    get(viewId) {
+        const view = this.view(viewId);
+        return view ? this.summary(view) : undefined;
+    }
+    /** Drop cached results (config reload). */
+    invalidate() {
+        this.cache.clear();
+    }
+    /**
+     * Current items of a view. Cached for the TTL unless `refresh`; concurrent
+     * requests for the same view share one load.
+     * @throws UnknownViewError
+     */
+    async items(viewId, options = {}) {
+        const view = this.view(viewId);
+        if (!view)
+            throw new UnknownViewError(viewId);
+        const version = this.options.config.current.version;
+        const now = this.clock.now().getTime();
+        const hit = this.cache.get(viewId);
+        if (!options.refresh && hit && hit.configVersion === version && now - hit.at < this.ttl) {
+            return { ...hit.result, cached: true };
+        }
+        const running = this.inflight.get(viewId);
+        if (running)
+            return running;
+        const load = this.load(view)
+            .then((result) => {
+            if (this.options.config.current.version === version)
+                this.cache.set(viewId, { at: now, configVersion: version, result });
+            return result;
+        })
+            .finally(() => this.inflight.delete(viewId));
+        this.inflight.set(viewId, load);
+        return load;
+    }
+    view(viewId) {
+        const views = this.options.config.current.views;
+        return Object.hasOwn(views, viewId) ? views[viewId] : undefined;
+    }
+    summary(view) {
+        return {
+            id: view.id,
+            title: view.title,
+            file: view.file,
+            sources: [...view.sources],
+            columns: this.columns(view, this.definitionsFor(view)),
+            sort: view.sort,
+            filter: view.filter,
+        };
+    }
+    definitionsFor(view) {
+        const defs = new Map();
+        for (const sourceId of view.sources) {
+            const adapter = this.options.sources(sourceId);
+            for (const d of adapter?.fieldDefinitions() ?? [])
+                if (!defs.has(d.name))
+                    defs.set(d.name, d);
+        }
+        for (const d of VIEW_RUN_FIELDS)
+            defs.set(d.name, d);
+        return defs;
+    }
+    columns(view, defs) {
+        return view.fields.map((f) => {
+            const def = defs.get(f.field);
+            return { field: f.field, label: f.label, link: f.link ?? def?.link ?? null, type: def?.type ?? null };
+        });
+    }
+    async load(view) {
+        const fetchedAt = this.clock.now().toISOString();
+        const defs = this.definitionsFor(view);
+        const columns = this.columns(view, defs);
+        const errors = [];
+        const loaded = [];
+        await Promise.all(view.sources.map(async (sourceId) => {
+            const adapter = this.options.sources(sourceId);
+            if (!adapter) {
+                errors.push({ sourceId, message: `source '${sourceId}' is not available` });
+                return;
+            }
+            try {
+                const { pushdown } = splitForPushdown(view.filter, adapter.fieldDefinitions());
+                const items = await adapter.listCandidates(pushdown ? { filter: pushdown } : {});
+                for (const item of items)
+                    loaded.push({ item, adapter });
+            }
+            catch (err) {
+                const message = this.redact(errorMessage(err));
+                this.logger.warn('view source failed', { view: view.id, sourceId, error: message });
+                errors.push({ sourceId, message });
+            }
+        }));
+        // Run enrichment (one query for all items).
+        const lastRuns = this.options.runs.lastRunsForItems(loaded.map((l) => l.item.key));
+        const wanted = [...new Set([...collectFields(view.filter), ...view.fields.flatMap((f) => [f.field, ...(f.link ? [f.link] : [])])])];
+        if (view.sort)
+            wanted.push(view.sort.field);
+        let filterUnknown = 0;
+        const seen = new Set();
+        const rows = [];
+        await Promise.all(loaded.map(async ({ item, adapter }) => {
+            if (seen.has(item.key))
+                return;
+            seen.add(item.key);
+            const run = lastRuns.get(item.key) ?? null;
+            const fields = createItemFieldSource(item, {
+                // Run fields are declared too, so that their types apply (dates compare as instants).
+                definitions: [...adapter.fieldDefinitions(), ...VIEW_RUN_FIELDS],
+                resolveFields: (i, f) => adapter.resolveFields(i, f),
+                wantedFields: wanted,
+                extraFields: runFields(run),
+            });
+            const verdict = (await evaluateFilter(view.filter, fields)).value;
+            if (verdict !== true) {
+                if (verdict === 'unknown')
+                    filterUnknown++;
+                return;
+            }
+            const resolve = async (field) => {
+                try {
+                    return await fields.resolve(field);
+                }
+                catch (err) {
+                    return { known: false, reason: errorMessage(err) };
+                }
+            };
+            const cells = [];
+            for (const column of columns) {
+                const res = await resolve(column.field);
+                const linkRes = column.link ? await resolve(column.link) : null;
+                cells.push({
+                    value: res.known ? (res.value ?? null) : null,
+                    known: res.known,
+                    link: linkRes?.known ? safeLink(linkRes.value) : null,
+                });
+            }
+            const sortRes = view.sort ? await resolve(view.sort.field) : null;
+            rows.push({
+                row: { key: item.key, sourceId: item.sourceId, itemId: item.itemId, url: safeLink(item.url), lastRunId: run?.id ?? null, cells },
+                sortValue: sortRes?.known ? (sortRes.value ?? null) : null,
+            });
+        }));
+        const sortType = view.sort ? (defs.get(view.sort.field)?.type ?? null) : null;
+        const direction = view.sort?.direction === 'desc' ? -1 : 1;
+        rows.sort((a, b) => {
+            if (view.sort) {
+                const c = compareValues(a.sortValue, b.sortValue, sortType, direction);
+                if (c !== 0)
+                    return c;
+            }
+            return naturalCompare(a.row.key, b.row.key);
+        });
+        errors.sort((a, b) => naturalCompare(a.sourceId, b.sourceId));
+        return {
+            view: { id: view.id, title: view.title, sources: [...view.sources] },
+            columns,
+            rows: rows.slice(0, MAX_VIEW_ROWS).map((r) => r.row),
+            errors,
+            filterUnknown,
+            truncated: rows.length > MAX_VIEW_ROWS,
+            fetchedAt,
+            cached: false,
+        };
+    }
+}
+/** `run.last_*` values for an item (known empty if the item has no run). */
+export function runFields(run) {
+    const result = run?.result;
+    return {
+        'run.last_id': run?.id ?? null,
+        'run.last_workflow': run?.workflowId ?? null,
+        'run.last_status': run?.status ?? null,
+        'run.last_result': run?.businessResult ?? null,
+        'run.last_result.message': typeof result?.message === 'string' ? result.message : null,
+        'run.last_status_message': run?.statusMessage ?? null,
+        'run.last_started_at': run?.startedAt ?? null,
+        'run.last_finished_at': run?.finishedAt ?? null,
+    };
+}
+/** Only absolute http(s) URLs are used as links (XSS, Spec §20.5). */
+export function safeLink(value) {
+    if (typeof value !== 'string')
+        return null;
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.toString() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Compare two cell values; empty values always last, independent of the direction. */
+function compareValues(a, b, type, direction) {
+    const emptyA = a === null || a === undefined;
+    const emptyB = b === null || b === undefined;
+    if (emptyA || emptyB)
+        return emptyA === emptyB ? 0 : emptyA ? 1 : -1;
+    if (type === 'date' && typeof a === 'string' && typeof b === 'string') {
+        const ta = Date.parse(a);
+        const tb = Date.parse(b);
+        if (!Number.isNaN(ta) && !Number.isNaN(tb))
+            return direction * Math.sign(ta - tb);
+    }
+    if (typeof a === 'number' && typeof b === 'number')
+        return direction * Math.sign(a - b);
+    if (typeof a === 'boolean' && typeof b === 'boolean')
+        return direction * (Number(a) - Number(b));
+    const sa = Array.isArray(a) ? a.join(', ') : String(a);
+    const sb = Array.isArray(b) ? b.join(', ') : String(b);
+    return direction * naturalCompare(sa, sb);
+}
+//# sourceMappingURL=service.js.map