@rawdash/server 0.13.0 → 0.15.0

package/README.md

@@ -3,11 +3,28 @@
 [![npm version](https://img.shields.io/npm/v/@rawdash/server)](https://www.npmjs.com/package/@rawdash/server)
 [![license](https://img.shields.io/npm/l/@rawdash/server)](https://github.com/rawdash/rawdash/blob/main/LICENSE)
 
-Standalone Hono HTTP server hosting the rawdash data API.
+Framework-agnostic rawdash request handlers, sync engine, and wire-contract types. **No HTTP framework dependency** — wrap with [`@rawdash/hono`](https://www.npmjs.com/package/@rawdash/hono) (or another adapter) to serve over HTTP.
 
 ## What it is
 
-`@rawdash/server` takes a rawdash config, runs the sync engine in-process, and exposes a REST API for widget data. Deploy it as a standalone service alongside your frontend, or use `createServer` to get the raw Hono app and deploy it to any JS runtime (Cloudflare Workers, Bun, Deno, etc.).
+`@rawdash/server` is the engine half of rawdash:
+
+- The **sync engine** (`runSync`, `createEngine`) that drives connectors and writes to storage.
+- **Pure HTTP handlers** (`listWidgets`, `getWidget`, `triggerSync`, `getSyncStateHandler`, `getHealth`, `runRetentionOnce`) — async functions you can call from any framework.
+- **`EngineContext`** — the per-request interface adapters use to inject `DashboardConfig` and `ServerStorage`. The handler doesn't care whether those come from a static config or are looked up fresh per request — that decision belongs to the adapter.
+- **`ROUTES`** — canonical URL paths, the single source of truth for the wire contract.
+- **`RawdashError`** — structured errors with `status` and `code` for adapters to translate.
+- The **`SyncState` types** and `InMemoryStorage` (re-exported from `@rawdash/core`).
+
+This package does **not** know about Hono, Express, Node's `http`, or any HTTP framework. Pick an adapter.
+
+## When to use what
+
+| You want to…                                                 | Use                                                                                           |
+| ------------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
+| Serve rawdash over HTTP in a Hono / Workers / Bun / Deno app | [`@rawdash/hono`](https://www.npmjs.com/package/@rawdash/hono) (depends on `@rawdash/server`) |
+| Build a different framework adapter (Express, NestJS, etc.)  | This package directly — wrap the pure handlers                                                |
+| Use the engine without HTTP (background job, CLI, MCP)       | This package — `createEngine` / `runSync`                                                     |
 
 ## Install
 
@@ -15,99 +32,160 @@ Standalone Hono HTTP server hosting the rawdash data API.
 npm install @rawdash/server
 ```
 
-## Quick example
+## The contract for adapter authors
+
+Each pure handler takes an `EngineContext` (and any path parameters) and returns the response body or throws a `RawdashError`. Your adapter:
+
+1. Routes the HTTP request to the matching handler.
+2. Constructs an `EngineContext` from the request — `getConfig` and `getStorage` can return constants or values derived from the request (e.g. read from a database keyed by a path param or auth header).
+3. Awaits the handler and serializes the result as JSON.
+4. Catches `RawdashError` and maps `status` + `code` to a structured HTTP response.
 
 ```ts
-import { GitHubConnector } from '@rawdash/connector-github';
-import { defineConfig, defineDashboard, secret } from '@rawdash/core';
-import { serve } from '@rawdash/server';
-
-const github = new GitHubConnector(
-  {
-    owner: 'my-org',
-    repo: 'my-repo',
-  },
-  {
-    token: secret('GITHUB_TOKEN'),
-  },
-);
-
-serve(
-  defineConfig({
-    connectors: [{ connector: github }],
-    dashboards: {
-      engineering: defineDashboard({ widgets: {} }),
-    },
-  }),
-  { port: 8080 },
-);
+import { RawdashError, isRawdashError, listWidgets } from '@rawdash/server';
+
+// example: a hypothetical Express adapter
+app.get('/dashboards/:id/widgets', async (req, res) => {
+  try {
+    const body = await listWidgets(
+      {
+        getConfig: () => loadConfig(),
+        getStorage: () => loadStorage(),
+      },
+      req.params.id,
+    );
+    res.json(body);
+  } catch (err) {
+    if (isRawdashError(err)) {
+      res.status(err.status).json({ error: err.message, code: err.code });
+      return;
+    }
+    throw err;
+  }
+});
 ```
 
-## API
+## The wire contract
 
-### `serve(config, options?)`
+| Route                                        | Method | Handler               | Response                                      |
+| -------------------------------------------- | ------ | --------------------- | --------------------------------------------- |
+| `/health`                                    | GET    | `getHealth`           | `{status:'ok'}` (liveness, no storage access) |
+| `/sync/state`                                | GET    | `getSyncStateHandler` | `SyncState`                                   |
+| `/sync`                                      | POST   | `triggerSync`         | `{queued: boolean}` — returns immediately     |
+| `/dashboards/:dashboardId/widgets`           | GET    | `listWidgets`         | `WidgetsListResponse`                         |
+| `/dashboards/:dashboardId/widgets/:widgetId` | GET    | `getWidget`           | `CachedWidget`                                |
+| `/retention/retain`                          | POST   | `runRetentionOnce`    | `{triggered: true}` (synchronous)             |
 
-Starts the HTTP server on Node.js (via `@hono/node-server`). Options:
+Paths are exported as constants from `ROUTES`. Use them in adapters (and in clients) instead of hard-coding.
 
-| Option    | Type            | Default   | Description                            |
-| --------- | --------------- | --------- | -------------------------------------- |
-| `port`    | `number`        | `8080`    | Port to listen on                      |
-| `storage` | `ServerStorage` | in-memory | Storage backend (e.g. `LibsqlStorage`) |
+### `SyncState`
 
-### `createServer(config, options?)`
+```ts
+type SyncStatus = 'idle' | 'queued' | 'running' | 'succeeded' | 'failed';
+interface SyncState {
+  status: SyncStatus;
+  queuedAt: string | null;
+  startedAt: string | null;
+  lastSyncAt: string | null;
+  lastError: string | null;
+}
+```
 
-Returns the Hono app without binding to a port. Use when you need the app object directly.
+Transitions:
 
-```ts
-import { createServer } from '@rawdash/server';
+- `idle → queued → running → succeeded` (happy path; cloud may use `queued`, OSS skips it)
+- `running → failed` (sets `lastError`)
+- Any terminal state can transition back to `queued` / `running` on the next trigger.
 
-const app = createServer(config);
-export default app; // deploy to Cloudflare Workers, Bun, Deno, etc.
-```
+Clients (`@rawdash/client`) poll `/sync/state` and wait for `!isSyncActive(status)` to settle.
 
-## HTTP endpoints
+### `CachedWidget.syncState`
 
-### `GET /dashboards/:dashboardId/widgets`
+`listWidgets` and `getWidget` populate `syncState` (and `meta.connectorStatus`) on each `CachedWidget` from the underlying `StorageHandle.getHealth?()`. When storage doesn't implement `getHealth`, `syncState` falls back to `'unsynced'` (no data) or `'fresh'` (data exists).
 
-Returns all cached widget entries for a dashboard.
+| Value        | Meaning                                                                              |
+| ------------ | ------------------------------------------------------------------------------------ |
+| `'fresh'`    | Data exists and the connector's `lastSyncAt` is within `2 × syncIntervalSeconds`     |
+| `'stale'`    | Data exists but the connector hasn't synced inside its freshness window              |
+| `'unsynced'` | No successful sync yet for this connector                                            |
+| `'syncing'`  | A sync is actively in progress for the connector backing this widget                 |
+| `'failing'`  | Connector is in `error` / `auth_failed` / `paused` — surface a reauthorize CTA in UI |
 
-```json
-[
-  {
-    "id": "github:pull_requests",
-    "connectorId": "github",
-    "widgetId": "pull_requests",
-    "data": [],
-    "cachedAt": "2026-04-11T10:00:00.000Z"
-  }
-]
+Storage adapters implement `getHealth?(): Promise<ConnectorHealth | null>` per `StorageHandle` to expose `status`, `lastSyncAt`, `lastError`, and `syncIntervalSeconds`. `InMemoryStorage` provides a minimal implementation (last-write time as `lastSyncAt`, `syncIntervalSeconds: 0`); adapters with first-class per-connector status (e.g. cloud, libSQL) populate it richly.
+
+### `triggerSync` modes
+
+`triggerSync(ctx, opts?)` accepts an optional `opts.mode`:
+
+- **`'in-process'`** (default): the handler records the `queued` transition and then fires `runSync(config, storage)` as a background promise that iterates `config.connectors`. Right for self-hosted, single-process OSS deployments.
+- **`'deferred'`**: the handler only records the `queued` transition. `runSync` is not invoked, and `getConfig` is not called (and may be omitted from `ctx`). The `running → succeeded/failed` transitions are the responsibility of an external runner — typically a queue consumer worker that decrypts credentials, applies retries, and drives storage directly.
+
+```ts
+// Self-hosted, in-process (default):
+await triggerSync({ getConfig, getStorage });
+
+// Queue-backed runner:
+await triggerSync({ getStorage }, { mode: 'deferred' });
 ```
 
-### `GET /dashboards/:dashboardId/widgets/:widgetId`
+In deferred mode, the wire response is unchanged: `{queued: true}` if `markSyncQueued()` accepted the transition, `{queued: false}` if a sync was already active.
 
-Returns a single widget by ID. Returns `404` if not found.
+## Engine without HTTP
 
-### `POST /sync`
+```ts
+import { createEngine } from '@rawdash/server';
+
+const engine = createEngine(config, { storage });
+const widgets = await engine.getWidgets('engineering');
+const state = await engine.getSyncState();
+```
 
-Triggers an immediate sync across all configured connectors. Returns `{ "triggered": false }` if a sync is already in progress.
+`createEngine` exposes the same shape as the handlers but bypasses HTTP entirely — useful for jobs, CLI tools, or the MCP server.
 
-### `GET /health`
+## Widget cache (optional)
 
-Returns the current sync state.
+`listWidgets` and `getWidget` accept an optional `WidgetCache` so deployments can avoid hitting storage for every widget on every request:
 
-```json
-{
-  "status": "idle",
-  "lastSyncAt": "2026-04-11T10:00:00.000Z",
-  "lastError": null
+```ts
+import type { WidgetCache } from '@rawdash/server';
+
+class LruWidgetCache implements WidgetCache {
+  private store = new Map<string, { value: CachedWidget; expiresAt: number }>();
+  async get({ dashboardId, widgetId }) {
+    const hit = this.store.get(`${dashboardId}/${widgetId}`);
+    if (!hit || hit.expiresAt < Date.now()) return undefined;
+    return hit.value;
+  }
+  async set({ dashboardId, widgetId, widget }, value) {
+    const ttlMs = ttlForWidget(widget); // e.g. derive from connector syncIntervalSeconds
+    this.store.set(`${dashboardId}/${widgetId}`, {
+      value,
+      expiresAt: Date.now() + ttlMs,
+    });
+  }
 }
+
+const cache = new LruWidgetCache();
+await listWidgets(ctx, 'engineering', cache);
 ```
 
-`status` is one of `"idle"`, `"syncing"`, or `"error"`.
+The cache impl owns TTL, eviction, and the backing store (LRU, KV, Redis…). If `cache` is omitted, behavior is identical to the no-cache path. Errors thrown from `cache.get` fall through to a fresh resolution; errors from `cache.set` are logged via `console.warn` and do not affect the response.
+
+`@rawdash/hono`'s `createWidgetsRouter` accepts a `cache: (c: Context) => WidgetCache` factory invoked once per request, so the cache can be scoped to the request's tenant/auth context.
+
+## Storage
+
+Provide any `ServerStorage` implementation:
+
+- `InMemoryStorage` (re-exported here) — dev/test.
+- [`@rawdash/adapter-libsql`](https://www.npmjs.com/package/@rawdash/adapter-libsql) — durable libSQL/Turso/SQLite backend.
+- Roll your own by implementing the [`ServerStorage`](https://github.com/rawdash/rawdash/blob/main/packages/core/src/server-storage.ts) interface.
 
 ## Links
 
 - [rawdash docs](https://rawdash.dev)
+- [`@rawdash/hono`](https://www.npmjs.com/package/@rawdash/hono) — Hono adapter
+- [`@rawdash/client`](https://www.npmjs.com/package/@rawdash/client) — typed HTTP client
 - [GitHub](https://github.com/rawdash/rawdash)
 - [Issues](https://github.com/rawdash/rawdash/issues)
 

package/dist/index.d.ts

@@ -1,31 +1,175 @@
-import { ServerStorage, DashboardConfig, CachedWidget, SyncState, TriggerSyncResponse } from '@rawdash/core';
-export { DashboardConfig, InMemoryStorage, ServerStorage, computeMetric } from '@rawdash/core';
-import { Hono } from 'hono';
+import { DashboardConfig, ServerStorage, Widget, CachedWidget, ConnectorRegistry, SecretsResolver, HealthResponse, SyncState, WidgetsListResponse, TriggerSyncResponse, RetentionConfig } from '@rawdash/core';
+export { ACTIVE_SYNC_STATUSES, CachedWidget, ConfiguredConnector, ConnectorClass, ConnectorHealth, ConnectorRegistry, DashboardConfig, HealthResponse, InMemoryStorage, SecretsResolver, ServerStorage, SyncState, SyncStatus, TriggerSyncResponse, Widget, WidgetSyncState, WidgetsListResponse, computeMetric, instantiateConnector, isSyncActive } from '@rawdash/core';
 
-interface ServeOptions {
-    port?: number;
-    storage?: ServerStorage;
+/**
+ * Per-request lookup functions an HTTP adapter passes to engine handlers.
+ *
+ * Adapters can close over per-request data (e.g. an id extracted from a
+ * path parameter or auth header) when constructing `getConfig` /
+ * `getStorage`. The handlers themselves only know how to operate on a
+ * given `DashboardConfig` and `ServerStorage` — they don't know or care
+ * how those are obtained.
+ */
+interface EngineContext {
+    getConfig: () => DashboardConfig | Promise<DashboardConfig>;
+    getStorage: () => ServerStorage | Promise<ServerStorage>;
 }
 
-interface RouterMount {
-    mount(app: Hono): void;
+/**
+ * Thrown by `@rawdash/server` handlers when a request fails in a way the
+ * HTTP adapter should translate to a structured response (e.g. 404, 400).
+ * Framework adapters (`@rawdash/hono`, etc.) should catch this and map
+ * `status` to the appropriate HTTP status code.
+ */
+declare class RawdashError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
 }
+declare function isRawdashError(err: unknown): err is RawdashError;
 
-declare function createServer(routers: RouterMount[]): Hono;
+/**
+ * Canonical URL path conventions for the rawdash HTTP wire contract.
+ *
+ * Framework adapters (`@rawdash/hono`, etc.) and clients
+ * (`@rawdash/client`) should use these constants instead of hard-coding
+ * paths, so the contract stays in one place.
+ */
+declare const ROUTES: {
+    readonly health: "/health";
+    readonly syncState: "/sync/state";
+    readonly sync: "/sync";
+    readonly retention: "/retention/retain";
+    readonly widgets: {
+        readonly list: (dashboardId: string) => string;
+        readonly single: (dashboardId: string, widgetId: string) => string;
+    };
+};
 
-declare function createEngineRouters(config: DashboardConfig, storage?: ServerStorage): RouterMount[];
+interface WidgetCacheKey {
+    dashboardId: string;
+    widgetId: string;
+    widget: Widget;
+}
+interface WidgetCache {
+    get(key: WidgetCacheKey): Promise<CachedWidget | undefined>;
+    set(key: WidgetCacheKey, value: CachedWidget): Promise<void>;
+}
+
+/**
+ * Per-request lookup shape accepted by `triggerSync` in deferred mode.
+ * `getConfig` is optional because the trigger handler never calls
+ * `runSync` — deployments that delegate the actual sync work to an
+ * external runner may not be able to materialize a `DashboardConfig` at
+ * request time.
+ */
+interface DeferredTriggerSyncContext {
+    getConfig?: () => DashboardConfig | Promise<DashboardConfig>;
+    getStorage: () => ServerStorage | Promise<ServerStorage>;
+}
+/**
+ * Per-request lookup shape accepted by `triggerSync` in in-process
+ * mode. `getConfig` is required because the trigger handler kicks off
+ * `runSync(config, storage)` in the background. `connectorRegistry` is
+ * required so the background runner can instantiate connector
+ * implementations on demand from the declarative `DashboardConfig`.
+ */
+interface InProcessTriggerSyncContext {
+    getConfig: () => DashboardConfig | Promise<DashboardConfig>;
+    getStorage: () => ServerStorage | Promise<ServerStorage>;
+    connectorRegistry: ConnectorRegistry;
+    secretsResolver?: SecretsResolver;
+}
+/**
+ * @deprecated Prefer `InProcessTriggerSyncContext` /
+ * `DeferredTriggerSyncContext`. Retained as the union for callers that
+ * need a single type covering both modes.
+ */
+type TriggerSyncContext = DeferredTriggerSyncContext;
+type TriggerSyncMode = 'in-process' | 'deferred';
+interface TriggerSyncOptions {
+    /**
+     * `'in-process'` (default): the trigger handler also runs the sync in
+     * the background by invoking `runSync(config, storage)`. Suitable for
+     * self-hosted, single-process deployments.
+     *
+     * `'deferred'`: the trigger handler only persists the `queued`
+     * transition and returns. The `running → succeeded/failed` transitions
+     * are the responsibility of an external runner (e.g. a queue consumer
+     * worker), which must drive the storage accordingly.
+     */
+    mode?: TriggerSyncMode;
+}
+/**
+ * Framework-agnostic request handlers for the rawdash wire contract.
+ *
+ * Each function takes an `EngineContext` (providing per-request access to
+ * the config + storage) and returns the response body, or throws a
+ * `RawdashError` on a client-visible failure. HTTP adapters
+ * (`@rawdash/hono`, etc.) wrap these in their framework's request/response
+ * cycle and translate `RawdashError` into a structured error response.
+ */
+declare function getHealth(): HealthResponse;
+declare function getSyncStateHandler(ctx: EngineContext): Promise<SyncState>;
+declare function triggerSync(ctx: InProcessTriggerSyncContext, opts?: {
+    mode?: 'in-process';
+}): Promise<TriggerSyncResponse>;
+declare function triggerSync(ctx: DeferredTriggerSyncContext, opts: {
+    mode: 'deferred';
+}): Promise<TriggerSyncResponse>;
+declare function listWidgets(ctx: EngineContext, dashboardId: string, cache?: WidgetCache): Promise<WidgetsListResponse>;
+declare function getWidget(ctx: EngineContext, dashboardId: string, widgetId: string, cache?: WidgetCache): Promise<CachedWidget>;
+declare function runRetentionOnce(ctx: EngineContext): Promise<void>;
+
+declare const FULL_SYNC_TIMEOUT_MS = 300000;
+interface RunSyncOptions {
+    connectorRegistry: ConnectorRegistry;
+    secretsResolver?: SecretsResolver;
+}
+/**
+ * Run a full sync across all connectors in the config in parallel via
+ * `Promise.allSettled`, so one failure doesn't abort the others. Each
+ * connector run is wrapped in a hard timeout (`FULL_SYNC_TIMEOUT_MS`)
+ * raced against the connector's own `Promise`, so a connector that
+ * ignores `AbortSignal` (or a storage call that hangs) can still not
+ * pin sync state in `running` indefinitely.
+ *
+ * The per-run storage handle is bound to the same `AbortController`, so
+ * once the timeout fires every subsequent write call on that handle
+ * becomes a no-op. That makes tail writes from a timed-out connector
+ * invisible to the next sync even if the connector itself keeps running
+ * — see `withAbortSignal` in `@rawdash/core` and the safety-net note in
+ * `docs/authoring-a-connector.md`.
+ *
+ * Transitions storage through `queued` → `running` → `succeeded`/`failed`.
+ * The `queued` step is a no-op if the caller (typically `triggerSync`)
+ * already marked the run as queued.
+ *
+ * Returns silently if another sync acquired the `running` lock first.
+ */
+declare function runSync(config: DashboardConfig, storage: ServerStorage, options: RunSyncOptions): Promise<void>;
+
+declare const DEFAULT_RETENTION_INTERVAL_MS: number;
+declare function hasPruningPolicy(config: RetentionConfig): boolean;
+/**
+ * Apply the retention policy in `config` to every connector's stored data.
+ * No-op if the config has no pruning policy. Throws an aggregated error if
+ * any connector fails.
+ */
+declare function runRetention(config: DashboardConfig, storage: ServerStorage): Promise<void>;
 
 interface EngineOptions {
     storage?: ServerStorage;
+    connectorRegistry?: ConnectorRegistry;
+    secretsResolver?: SecretsResolver;
 }
 interface Engine {
     getWidget(dashboardId: string, widgetId: string): Promise<CachedWidget | undefined>;
     getWidgets(dashboardId: string): Promise<CachedWidget[]>;
-    getHealth(): Promise<SyncState>;
+    getHealth(): Promise<HealthResponse>;
+    getSyncState(): Promise<SyncState>;
     triggerSync(): Promise<TriggerSyncResponse>;
 }
 declare function createEngine(config: DashboardConfig, options?: EngineOptions): Engine;
 
-declare function serve(config: DashboardConfig, options?: ServeOptions): void;
-
-export { type Engine, type EngineOptions, type RouterMount, type ServeOptions, createEngine, createEngineRouters, createServer, serve };
+export { DEFAULT_RETENTION_INTERVAL_MS, type DeferredTriggerSyncContext, type Engine, type EngineContext, type EngineOptions, FULL_SYNC_TIMEOUT_MS, type InProcessTriggerSyncContext, ROUTES, RawdashError, type RunSyncOptions, type TriggerSyncContext, type TriggerSyncMode, type TriggerSyncOptions, type WidgetCache, type WidgetCacheKey, createEngine, getHealth, getSyncStateHandler, getWidget, hasPruningPolicy, isRawdashError, listWidgets, runRetention, runRetentionOnce, runSync, triggerSync };

package/dist/index.js

@@ -1,116 +1,85 @@
-// src/index.ts
-import { serve as honoServe } from "@hono/node-server";
-
-// src/routers/health.ts
-var HealthRouter = class {
-  constructor(storage) {
-    this.storage = storage;
+// src/errors.ts
+var RawdashError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "RawdashError";
   }
-  storage;
-  mount(app) {
-    app.get("/health", async (c) => {
-      return c.json(await this.storage.getSyncState());
-    });
+  status;
+  code;
+};
+function isRawdashError(err) {
+  return err instanceof RawdashError;
+}
+
+// src/routes.ts
+var ROUTES = {
+  health: "/health",
+  syncState: "/sync/state",
+  sync: "/sync",
+  retention: "/retention/retain",
+  widgets: {
+    list: (dashboardId) => `/dashboards/${encodeURIComponent(dashboardId)}/widgets`,
+    single: (dashboardId, widgetId) => `/dashboards/${encodeURIComponent(dashboardId)}/widgets/${encodeURIComponent(widgetId)}`
   }
 };
 
-// src/routers/retention.ts
+// src/handlers.ts
+import { isSyncActive, resolveWidget } from "@rawdash/core";
+
+// src/retention.ts
 import { selectForDeletion } from "@rawdash/core";
-var DEFAULT_INTERVAL_MS = 60 * 60 * 1e3;
+var DEFAULT_RETENTION_INTERVAL_MS = 60 * 60 * 1e3;
 function hasPruningPolicy(config) {
   return config.maxAge !== void 0 || config.maxSize !== void 0;
 }
-var RetentionRouter = class {
-  constructor(config, storage) {
-    this.config = config;
-    this.storage = storage;
-  }
-  config;
-  storage;
-  interval = null;
-  inFlight = null;
-  async runRetention() {
-    if (this.inFlight) {
-      return this.inFlight;
-    }
-    this.inFlight = this.runRetentionOnce().finally(() => {
-      this.inFlight = null;
-    });
-    return this.inFlight;
+async function runRetention(config, storage) {
+  const retentionConfig = config.retention;
+  if (!retentionConfig || !hasPruningPolicy(retentionConfig)) {
+    return;
   }
-  async runRetentionOnce() {
-    const retentionConfig = this.config.retention;
-    if (!retentionConfig || !hasPruningPolicy(retentionConfig)) {
-      return;
-    }
-    const nowMs = Date.now();
-    const results = await Promise.allSettled(
-      this.config.connectors.map(async ({ connector }) => {
-        const handle = this.storage.getStorageHandle(connector.id);
-        const [events, metrics, distributions] = await Promise.all([
-          handle.queryEvents({}),
-          handle.queryMetrics({}),
-          handle.queryDistributions({})
-        ]);
-        await applyRetentionToShape(
-          events,
-          (e) => e.start_ts,
-          retentionConfig,
-          nowMs,
-          (survivors, names) => handle.events(survivors, { names })
-        );
-        await applyRetentionToShape(
-          metrics,
-          (m) => m.ts,
-          retentionConfig,
-          nowMs,
-          (survivors, names) => handle.metrics(survivors, { names })
-        );
-        await applyRetentionToShape(
-          distributions,
-          (d) => d.ts,
-          retentionConfig,
-          nowMs,
-          (survivors, names) => handle.distributions(survivors, { names })
-        );
-      })
-    );
-    const failures = results.filter(
-      (r) => r.status === "rejected"
-    );
-    if (failures.length > 0) {
-      throw new Error(
-        `Retention failed for ${failures.length} connector(s): ${failures.map((f) => String(f.reason)).join("; ")}`
+  const nowMs = Date.now();
+  const results = await Promise.allSettled(
+    config.connectors.map(async (entry) => {
+      const handle = storage.getStorageHandle(entry.name);
+      const [events, metrics, distributions] = await Promise.all([
+        handle.queryEvents({}),
+        handle.queryMetrics({}),
+        handle.queryDistributions({})
+      ]);
+      await applyRetentionToShape(
+        events,
+        (e) => e.start_ts,
+        retentionConfig,
+        nowMs,
+        (survivors, names) => handle.events(survivors, { names })
       );
-    }
-  }
-  mount(app) {
-    app.post("/retain", async (c) => {
-      try {
-        await this.runRetention();
-        return c.json({ triggered: true });
-      } catch (err) {
-        console.error("retention run failed", err);
-        return c.json({ triggered: false }, 500);
-      }
-    });
-    const retentionConfig = this.config.retention;
-    if (retentionConfig && hasPruningPolicy(retentionConfig)) {
-      const intervalMs = retentionConfig.intervalMs ?? DEFAULT_INTERVAL_MS;
-      this.interval = setInterval(() => {
-        void this.runRetention().catch((err) => {
-          console.error("retention run failed", err);
-        });
-      }, intervalMs);
-    }
-  }
-  stop() {
-    if (this.interval !== null) {
-      clearInterval(this.interval);
-      this.interval = null;
-    }
+      await applyRetentionToShape(
+        metrics,
+        (m) => m.ts,
+        retentionConfig,
+        nowMs,
+        (survivors, names) => handle.metrics(survivors, { names })
+      );
+      await applyRetentionToShape(
+        distributions,
+        (d) => d.ts,
+        retentionConfig,
+        nowMs,
+        (survivors, names) => handle.distributions(survivors, { names })
+      );
+    })
+  );
+  const failures = results.filter(
+    (r) => r.status === "rejected"
+  );
+  if (failures.length > 0) {
+    throw new Error(
+      `Retention failed for ${failures.length} connector(s): ${failures.map((f) => String(f.reason)).join("; ")}`
+    );
   }
-};
+}
 async function applyRetentionToShape(rows, getTs, config, nowMs, writeSurvivors) {
   if (rows.length === 0) {
     return;
@@ -125,146 +94,203 @@ async function applyRetentionToShape(rows, getTs, config, nowMs, writeSurvivors)
   await writeSurvivors(survivors, allNames);
 }
 
-// src/routers/sync.ts
+// src/sync.ts
+import { instantiateConnector } from "@rawdash/core";
 var FULL_SYNC_TIMEOUT_MS = 3e5;
-var SyncRouter = class {
-  constructor(config, storage) {
-    this.config = config;
-    this.storage = storage;
+async function runSync(config, storage, options) {
+  await storage.markSyncQueued();
+  const acquired = await storage.markSyncRunning();
+  if (!acquired) {
+    return;
   }
-  config;
-  storage;
-  async runSync() {
-    const acquired = await this.storage.setSyncing();
-    if (!acquired) {
-      return;
-    }
-    const errors = [];
-    await Promise.allSettled(
-      this.config.connectors.map(async ({ connector }) => {
-        const handle = this.storage.getStorageHandle(connector.id);
-        const controller = new AbortController();
-        const timer = setTimeout(
-          () => controller.abort(),
-          FULL_SYNC_TIMEOUT_MS
+  const errors = [];
+  await Promise.allSettled(
+    config.connectors.map(async (entry) => {
+      if (entry.enabled === false) {
+        return;
+      }
+      const controller = new AbortController();
+      const handle = storage.getStorageHandle(entry.name, {
+        signal: controller.signal
+      });
+      let timer;
+      try {
+        const connector = instantiateConnector(
+          entry,
+          options.connectorRegistry,
+          options.secretsResolver
         );
-        try {
-          const result = await connector.sync(
-            { mode: "full" },
-            handle,
-            controller.signal
-          );
-          if (!result.done) {
-            errors.push(
-              `${connector.id} did not complete in one chunk (chunked syncs are only supported in cloud)`
-            );
-          }
-        } catch (err) {
-          if (err instanceof Error && err.name === "AbortError") {
-            errors.push(
-              `${connector.id} timed out after ${FULL_SYNC_TIMEOUT_MS}ms`
+        const syncPromise = connector.sync(
+          { mode: "full" },
+          handle,
+          controller.signal
+        );
+        const timeoutPromise = new Promise((_resolve, reject) => {
+          timer = setTimeout(() => {
+            controller.abort();
+            const err = new Error(
+              `${entry.name} timed out after ${FULL_SYNC_TIMEOUT_MS}ms`
             );
-          } else {
-            errors.push(err instanceof Error ? err.message : String(err));
-          }
-        } finally {
+            err.name = "AbortError";
+            reject(err);
+          }, FULL_SYNC_TIMEOUT_MS);
+        });
+        const result = await Promise.race([syncPromise, timeoutPromise]);
+        if (!result.done) {
+          errors.push(
+            `${entry.name} did not complete in one chunk (chunked syncs are only supported in cloud)`
+          );
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          errors.push(
+            `${entry.name} timed out after ${FULL_SYNC_TIMEOUT_MS}ms`
+          );
+        } else {
+          errors.push(err instanceof Error ? err.message : String(err));
+        }
+      } finally {
+        if (timer !== void 0) {
           clearTimeout(timer);
         }
-      })
-    );
-    if (errors.length > 0) {
-      await this.storage.setSyncError(errors.join("; "));
-    } else {
-      await this.storage.setSyncSuccess();
-    }
-  }
-  mount(app) {
-    app.post("/sync", async (c) => {
-      const state = await this.storage.getSyncState();
-      if (state.status === "syncing") {
-        return c.json({ triggered: false });
       }
-      void this.runSync();
-      return c.json({ triggered: true });
-    });
+    })
+  );
+  if (errors.length > 0) {
+    await storage.markSyncFailed(errors.join("; "));
+  } else {
+    await storage.markSyncSucceeded();
   }
-};
+}
 
-// src/routers/widgets.ts
-import { resolveWidget } from "@rawdash/core";
-var WidgetsRouter = class {
-  constructor(dashboardId, dashboard, connectors, storage) {
-    this.dashboardId = dashboardId;
-    this.dashboard = dashboard;
-    this.connectors = connectors;
-    this.storage = storage;
+// src/handlers.ts
+async function cacheGetSafe(cache, dashboardId, widgetId, widget) {
+  try {
+    return await cache.get({ dashboardId, widgetId, widget });
+  } catch (err) {
+    console.warn("Rawdash widget cache get failed", err);
+    return void 0;
   }
-  dashboardId;
-  dashboard;
-  connectors;
-  storage;
-  resolve(id, widget) {
-    return resolveWidget(id, widget, this.connectors, this.storage);
+}
+async function cacheSetSafe(cache, dashboardId, widgetId, widget, value) {
+  try {
+    await cache.set({ dashboardId, widgetId, widget }, value);
+  } catch (err) {
+    console.warn("Rawdash widget cache set failed", err);
   }
-  mount(app) {
-    const base = `/dashboards/${this.dashboardId}/widgets`;
-    app.get(base, async (c) => {
-      const entries = Object.entries(this.dashboard.widgets);
-      const resolved = await Promise.all(
-        entries.map(([key, widget]) => this.resolve(key, widget))
-      );
-      const widgets = resolved.filter(
-        (w) => w !== void 0
+}
+async function resolveWithCache(dashboardId, widgetId, widget, connectorNames, storage, cache) {
+  if (cache) {
+    const hit = await cacheGetSafe(cache, dashboardId, widgetId, widget);
+    if (hit) {
+      return hit;
+    }
+  }
+  const fresh = await resolveWidget(widgetId, widget, connectorNames, storage);
+  if (fresh && cache) {
+    await cacheSetSafe(cache, dashboardId, widgetId, widget, fresh);
+  }
+  return fresh;
+}
+function getHealth() {
+  return { status: "ok" };
+}
+async function getSyncStateHandler(ctx) {
+  const storage = await ctx.getStorage();
+  return storage.getSyncState();
+}
+async function triggerSync(ctx, opts = {}) {
+  const mode = opts.mode ?? "in-process";
+  const storage = await ctx.getStorage();
+  const state = await storage.getSyncState();
+  if (isSyncActive(state.status)) {
+    return { queued: false };
+  }
+  let config;
+  if (mode === "in-process") {
+    if (!ctx.getConfig) {
+      throw new Error(
+        'triggerSync: getConfig is required when mode is "in-process"'
       );
-      const response = { widgets };
-      return c.json(response);
-    });
-    app.get(`${base}/:widgetId`, async (c) => {
-      const widgetId = c.req.param("widgetId");
-      const widget = this.dashboard.widgets[widgetId];
-      if (!widget) {
-        return c.json({ error: "Widget not found" }, 404);
-      }
-      const result = await this.resolve(widgetId, widget);
-      if (!result) {
-        return c.json({ error: "Widget not found" }, 404);
-      }
-      return c.json(result);
-    });
+    }
+    config = await ctx.getConfig();
   }
-};
-
-// src/storage.ts
-import { InMemoryStorage } from "@rawdash/core";
-
-// src/engine-router.ts
-function createEngineRouters(config, storage = new InMemoryStorage()) {
-  const widgetRouters = Object.entries(config.dashboards).map(
-    ([dashboardId, dashboard]) => new WidgetsRouter(dashboardId, dashboard, config.connectors, storage)
+  const queued = await storage.markSyncQueued();
+  if (!queued) {
+    return { queued: false };
+  }
+  if (mode === "deferred") {
+    return { queued: true };
+  }
+  const inProcessCtx = ctx;
+  void runSync(config, storage, {
+    connectorRegistry: inProcessCtx.connectorRegistry,
+    secretsResolver: inProcessCtx.secretsResolver
+  }).catch((err) => {
+    console.error("Rawdash sync failed", err);
+  });
+  return { queued: true };
+}
+async function listWidgets(ctx, dashboardId, cache) {
+  const config = await ctx.getConfig();
+  const dashboard = config.dashboards[dashboardId];
+  if (!dashboard) {
+    throw new RawdashError(404, "DASHBOARD_NOT_FOUND", "Dashboard not found");
+  }
+  const storage = await ctx.getStorage();
+  const connectorNames = config.connectors.map((c) => c.name);
+  const entries = Object.entries(dashboard.widgets);
+  const resolved = await Promise.all(
+    entries.map(
+      ([key, widget]) => resolveWithCache(
+        dashboardId,
+        key,
+        widget,
+        connectorNames,
+        storage,
+        cache
+      )
+    )
   );
-  return [
-    ...widgetRouters,
-    new SyncRouter(config, storage),
-    new RetentionRouter(config, storage),
-    new HealthRouter(storage)
-  ];
+  const widgets = resolved.filter((w) => w !== void 0);
+  return { widgets };
 }
-
-// src/server.ts
-import { Hono } from "hono";
-function createServer(routers) {
-  const app = new Hono();
-  for (const router of routers) {
-    router.mount(app);
+async function getWidget(ctx, dashboardId, widgetId, cache) {
+  const config = await ctx.getConfig();
+  const dashboard = config.dashboards[dashboardId];
+  if (!dashboard) {
+    throw new RawdashError(404, "DASHBOARD_NOT_FOUND", "Dashboard not found");
   }
-  return app;
+  const widget = dashboard.widgets[widgetId];
+  if (!widget) {
+    throw new RawdashError(404, "WIDGET_NOT_FOUND", "Widget not found");
+  }
+  const storage = await ctx.getStorage();
+  const connectorNames = config.connectors.map((c) => c.name);
+  const result = await resolveWithCache(
+    dashboardId,
+    widgetId,
+    widget,
+    connectorNames,
+    storage,
+    cache
+  );
+  if (!result) {
+    throw new RawdashError(404, "WIDGET_NOT_FOUND", "Widget not found");
+  }
+  return result;
+}
+async function runRetentionOnce(ctx) {
+  const config = await ctx.getConfig();
+  const storage = await ctx.getStorage();
+  await runRetention(config, storage);
 }
 
 // src/engine.ts
-import { InMemoryStorage as InMemoryStorage2, resolveWidget as resolveWidget2 } from "@rawdash/core";
+import { InMemoryStorage, isSyncActive as isSyncActive2, resolveWidget as resolveWidget2 } from "@rawdash/core";
 function createEngine(config, options = {}) {
-  const storage = options.storage ?? new InMemoryStorage2();
-  const syncRouter = new SyncRouter(config, storage);
+  const storage = options.storage ?? new InMemoryStorage();
+  const connectorNames = config.connectors.map((c) => c.name);
   return {
     async getWidget(dashboardId, widgetId) {
       const dashboard = config.dashboards[dashboardId];
@@ -275,7 +301,7 @@ function createEngine(config, options = {}) {
       if (!widget) {
         return void 0;
       }
-      return resolveWidget2(widgetId, widget, config.connectors, storage);
+      return resolveWidget2(widgetId, widget, connectorNames, storage);
     },
     async getWidgets(dashboardId) {
       const dashboard = config.dashboards[dashboardId];
@@ -285,23 +311,38 @@ function createEngine(config, options = {}) {
       const entries = Object.entries(dashboard.widgets);
       const resolved = await Promise.all(
         entries.map(
-          ([key, widget]) => resolveWidget2(key, widget, config.connectors, storage)
+          ([key, widget]) => resolveWidget2(key, widget, connectorNames, storage)
         )
       );
       return resolved.filter((w) => w !== void 0);
     },
     async getHealth() {
+      return { status: "ok" };
+    },
+    async getSyncState() {
       return storage.getSyncState();
     },
     async triggerSync() {
+      if (!options.connectorRegistry) {
+        throw new Error(
+          "createEngine: connectorRegistry is required to triggerSync"
+        );
+      }
       const state = await storage.getSyncState();
-      if (state.status === "syncing") {
-        return { triggered: false };
+      if (isSyncActive2(state.status)) {
+        return { queued: false };
+      }
+      const queued = await storage.markSyncQueued();
+      if (!queued) {
+        return { queued: false };
       }
-      void syncRouter.runSync().catch((error) => {
+      void runSync(config, storage, {
+        connectorRegistry: options.connectorRegistry,
+        secretsResolver: options.secretsResolver
+      }).catch((error) => {
         console.error("Rawdash sync failed", error);
       });
-      return { triggered: true };
+      return { queued: true };
     }
   };
 }
@@ -309,18 +350,32 @@ function createEngine(config, options = {}) {
 // src/compute.ts
 import { computeMetric } from "@rawdash/core";
 
+// src/storage.ts
+import { InMemoryStorage as InMemoryStorage2 } from "@rawdash/core";
+
 // src/index.ts
-function serve(config, options = {}) {
-  const { port = 8080, storage } = options;
-  const app = createServer(createEngineRouters(config, storage));
-  honoServe({ fetch: app.fetch, port });
-}
+import { isSyncActive as isSyncActive3, ACTIVE_SYNC_STATUSES } from "@rawdash/core";
+import { instantiateConnector as instantiateConnector2 } from "@rawdash/core";
 export {
-  InMemoryStorage,
+  ACTIVE_SYNC_STATUSES,
+  DEFAULT_RETENTION_INTERVAL_MS,
+  FULL_SYNC_TIMEOUT_MS,
+  InMemoryStorage2 as InMemoryStorage,
+  ROUTES,
+  RawdashError,
   computeMetric,
   createEngine,
-  createEngineRouters,
-  createServer,
-  serve
+  getHealth,
+  getSyncStateHandler,
+  getWidget,
+  hasPruningPolicy,
+  instantiateConnector2 as instantiateConnector,
+  isRawdashError,
+  isSyncActive3 as isSyncActive,
+  listWidgets,
+  runRetention,
+  runRetentionOnce,
+  runSync,
+  triggerSync
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/routers/health.ts","../src/routers/retention.ts","../src/routers/sync.ts","../src/routers/widgets.ts","../src/storage.ts","../src/engine-router.ts","../src/server.ts","../src/engine.ts","../src/compute.ts"],"sourcesContent":["import { serve as honoServe } from '@hono/node-server';\n\nimport { createEngineRouters } from './engine-router';\nimport { createServer } from './server';\nimport type { DashboardConfig, ServeOptions } from './types';\n\nexport { createServer } from './server';\nexport { createEngineRouters } from './engine-router';\nexport { createEngine } from './engine';\nexport { computeMetric } from './compute';\nexport { InMemoryStorage } from './storage';\nexport type { RouterMount } from './router';\nexport type { DashboardConfig, ServeOptions, ServerStorage } from './types';\nexport type { Engine, EngineOptions } from './engine';\n\nexport function serve(\n  config: DashboardConfig,\n  options: ServeOptions = {},\n): void {\n  const { port = 8080, storage } = options;\n  const app = createServer(createEngineRouters(config, storage));\n  honoServe({ fetch: app.fetch, port });\n}\n","import type { Hono } from 'hono';\n\nimport type { RouterMount } from '../router';\nimport type { ServerStorage } from '../types';\n\nexport class HealthRouter implements RouterMount {\n  constructor(private storage: ServerStorage) {}\n\n  mount(app: Hono): void {\n    app.get('/health', async (c) => {\n      return c.json(await this.storage.getSyncState());\n    });\n  }\n}\n","import type { DashboardConfig, RetentionConfig } from '@rawdash/core';\nimport { selectForDeletion } from '@rawdash/core';\nimport type { Hono } from 'hono';\n\nimport type { RouterMount } from '../router';\nimport type { ServerStorage } from '../types';\n\nconst DEFAULT_INTERVAL_MS = 60 * 60 * 1000; // 1 hour\n\nfunction hasPruningPolicy(config: RetentionConfig): boolean {\n  return config.maxAge !== undefined || config.maxSize !== undefined;\n}\n\nexport class RetentionRouter implements RouterMount {\n  private interval: ReturnType<typeof setInterval> | null = null;\n  private inFlight: Promise<void> | null = null;\n\n  constructor(\n    private config: DashboardConfig,\n    private storage: ServerStorage,\n  ) {}\n\n  async runRetention(): Promise<void> {\n    if (this.inFlight) {\n      return this.inFlight;\n    }\n\n    this.inFlight = this.runRetentionOnce().finally(() => {\n      this.inFlight = null;\n    });\n\n    return this.inFlight;\n  }\n\n  private async runRetentionOnce(): Promise<void> {\n    const retentionConfig = this.config.retention;\n    if (!retentionConfig || !hasPruningPolicy(retentionConfig)) {\n      return;\n    }\n\n    const nowMs = Date.now();\n\n    const results = await Promise.allSettled(\n      this.config.connectors.map(async ({ connector }) => {\n        const handle = this.storage.getStorageHandle(connector.id);\n\n        const [events, metrics, distributions] = await Promise.all([\n          handle.queryEvents({}),\n          handle.queryMetrics({}),\n          handle.queryDistributions({}),\n        ]);\n\n        await applyRetentionToShape(\n          events,\n          (e) => e.start_ts,\n          retentionConfig,\n          nowMs,\n          (survivors, names) => handle.events(survivors, { names }),\n        );\n\n        await applyRetentionToShape(\n          metrics,\n          (m) => m.ts,\n          retentionConfig,\n          nowMs,\n          (survivors, names) => handle.metrics(survivors, { names }),\n        );\n\n        await applyRetentionToShape(\n          distributions,\n          (d) => d.ts,\n          retentionConfig,\n          nowMs,\n          (survivors, names) => handle.distributions(survivors, { names }),\n        );\n      }),\n    );\n\n    const failures = results.filter(\n      (r): r is PromiseRejectedResult => r.status === 'rejected',\n    );\n    if (failures.length > 0) {\n      throw new Error(\n        `Retention failed for ${failures.length} connector(s): ${failures.map((f) => String(f.reason)).join('; ')}`,\n      );\n    }\n  }\n\n  mount(app: Hono): void {\n    app.post('/retain', async (c) => {\n      try {\n        await this.runRetention();\n        return c.json({ triggered: true });\n      } catch (err) {\n        console.error('retention run failed', err);\n        return c.json({ triggered: false }, 500);\n      }\n    });\n\n    const retentionConfig = this.config.retention;\n    if (retentionConfig && hasPruningPolicy(retentionConfig)) {\n      const intervalMs = retentionConfig.intervalMs ?? DEFAULT_INTERVAL_MS;\n      this.interval = setInterval(() => {\n        void this.runRetention().catch((err) => {\n          console.error('retention run failed', err);\n        });\n      }, intervalMs);\n    }\n  }\n\n  stop(): void {\n    if (this.interval !== null) {\n      clearInterval(this.interval);\n      this.interval = null;\n    }\n  }\n}\n\nasync function applyRetentionToShape<T extends { name: string }>(\n  rows: T[],\n  getTs: (row: T) => number,\n  config: RetentionConfig,\n  nowMs: number,\n  writeSurvivors: (survivors: T[], names: string[]) => Promise<void>,\n): Promise<void> {\n  if (rows.length === 0) {\n    return;\n  }\n\n  const sorted = [...rows].sort((a, b) => getTs(b) - getTs(a));\n  const toDeleteSet = new Set(selectForDeletion(sorted, getTs, config, nowMs));\n\n  if (toDeleteSet.size === 0) {\n    return;\n  }\n\n  const survivors = sorted.filter((r) => !toDeleteSet.has(r));\n  const allNames = [...new Set(rows.map((r) => r.name))];\n\n  await writeSurvivors(survivors, allNames);\n}\n","import type { DashboardConfig } from '@rawdash/core';\nimport type { Hono } from 'hono';\n\nimport type { RouterMount } from '../router';\nimport type { ServerStorage } from '../types';\n\nconst FULL_SYNC_TIMEOUT_MS = 300_000;\n\nexport class SyncRouter implements RouterMount {\n  constructor(\n    private config: DashboardConfig,\n    private storage: ServerStorage,\n  ) {}\n\n  async runSync(): Promise<void> {\n    const acquired = await this.storage.setSyncing();\n    if (!acquired) {\n      return;\n    }\n    const errors: string[] = [];\n    await Promise.allSettled(\n      this.config.connectors.map(async ({ connector }) => {\n        const handle = this.storage.getStorageHandle(connector.id);\n        const controller = new AbortController();\n        const timer = setTimeout(\n          () => controller.abort(),\n          FULL_SYNC_TIMEOUT_MS,\n        );\n        try {\n          const result = await connector.sync(\n            { mode: 'full' },\n            handle,\n            controller.signal,\n          );\n          if (!result.done) {\n            errors.push(\n              `${connector.id} did not complete in one chunk (chunked syncs are only supported in cloud)`,\n            );\n          }\n        } catch (err) {\n          if (err instanceof Error && err.name === 'AbortError') {\n            errors.push(\n              `${connector.id} timed out after ${FULL_SYNC_TIMEOUT_MS}ms`,\n            );\n          } else {\n            errors.push(err instanceof Error ? err.message : String(err));\n          }\n        } finally {\n          clearTimeout(timer);\n        }\n      }),\n    );\n    if (errors.length > 0) {\n      await this.storage.setSyncError(errors.join('; '));\n    } else {\n      await this.storage.setSyncSuccess();\n    }\n  }\n\n  mount(app: Hono): void {\n    app.post('/sync', async (c) => {\n      const state = await this.storage.getSyncState();\n      if (state.status === 'syncing') {\n        return c.json({ triggered: false });\n      }\n      void this.runSync();\n      return c.json({ triggered: true });\n    });\n  }\n}\n","import type {\n  CachedWidget,\n  ConfiguredConnector,\n  Dashboard,\n  Widget,\n  WidgetsListResponse,\n} from '@rawdash/core';\nimport { resolveWidget } from '@rawdash/core';\nimport type { Hono } from 'hono';\n\nimport type { RouterMount } from '../router';\nimport type { ServerStorage } from '../types';\n\nexport class WidgetsRouter implements RouterMount {\n  constructor(\n    private dashboardId: string,\n    private dashboard: Dashboard,\n    private connectors: ConfiguredConnector[],\n    private storage: ServerStorage,\n  ) {}\n\n  private resolve(\n    id: string,\n    widget: Widget,\n  ): Promise<CachedWidget | undefined> {\n    return resolveWidget(id, widget, this.connectors, this.storage);\n  }\n\n  mount(app: Hono): void {\n    const base = `/dashboards/${this.dashboardId}/widgets`;\n\n    app.get(base, async (c) => {\n      const entries = Object.entries(this.dashboard.widgets);\n      const resolved = await Promise.all(\n        entries.map(([key, widget]) => this.resolve(key, widget)),\n      );\n      const widgets = resolved.filter(\n        (w): w is CachedWidget => w !== undefined,\n      );\n      const response: WidgetsListResponse = { widgets };\n      return c.json(response);\n    });\n\n    app.get(`${base}/:widgetId`, async (c) => {\n      const widgetId = c.req.param('widgetId');\n      const widget = this.dashboard.widgets[widgetId];\n      if (!widget) {\n        return c.json({ error: 'Widget not found' }, 404);\n      }\n      const result = await this.resolve(widgetId, widget);\n      if (!result) {\n        return c.json({ error: 'Widget not found' }, 404);\n      }\n      return c.json(result);\n    });\n  }\n}\n","export { InMemoryStorage } from '@rawdash/core';\n","import type { DashboardConfig } from '@rawdash/core';\n\nimport type { RouterMount } from './router';\nimport { HealthRouter } from './routers/health';\nimport { RetentionRouter } from './routers/retention';\nimport { SyncRouter } from './routers/sync';\nimport { WidgetsRouter } from './routers/widgets';\nimport { InMemoryStorage } from './storage';\nimport type { ServerStorage } from './types';\n\nexport function createEngineRouters(\n  config: DashboardConfig,\n  storage: ServerStorage = new InMemoryStorage(),\n): RouterMount[] {\n  const widgetRouters = Object.entries(config.dashboards).map(\n    ([dashboardId, dashboard]) =>\n      new WidgetsRouter(dashboardId, dashboard, config.connectors, storage),\n  );\n\n  return [\n    ...widgetRouters,\n    new SyncRouter(config, storage),\n    new RetentionRouter(config, storage),\n    new HealthRouter(storage),\n  ];\n}\n","import { Hono } from 'hono';\n\nimport type { RouterMount } from './router';\n\nexport function createServer(routers: RouterMount[]): Hono {\n  const app = new Hono();\n  for (const router of routers) {\n    router.mount(app);\n  }\n  return app;\n}\n","import type {\n  CachedWidget,\n  DashboardConfig,\n  SyncState,\n  TriggerSyncResponse,\n} from '@rawdash/core';\nimport { InMemoryStorage, resolveWidget } from '@rawdash/core';\n\nimport { SyncRouter } from './routers/sync';\nimport type { ServerStorage } from './types';\n\nexport interface EngineOptions {\n  storage?: ServerStorage;\n}\n\nexport interface Engine {\n  getWidget(\n    dashboardId: string,\n    widgetId: string,\n  ): Promise<CachedWidget | undefined>;\n  getWidgets(dashboardId: string): Promise<CachedWidget[]>;\n  getHealth(): Promise<SyncState>;\n  triggerSync(): Promise<TriggerSyncResponse>;\n}\n\nexport function createEngine(\n  config: DashboardConfig,\n  options: EngineOptions = {},\n): Engine {\n  const storage: ServerStorage = options.storage ?? new InMemoryStorage();\n  const syncRouter = new SyncRouter(config, storage);\n\n  return {\n    async getWidget(dashboardId, widgetId) {\n      const dashboard = config.dashboards[dashboardId];\n      if (!dashboard) {\n        return undefined;\n      }\n      const widget = dashboard.widgets[widgetId];\n      if (!widget) {\n        return undefined;\n      }\n      return resolveWidget(widgetId, widget, config.connectors, storage);\n    },\n\n    async getWidgets(dashboardId) {\n      const dashboard = config.dashboards[dashboardId];\n      if (!dashboard) {\n        return [];\n      }\n      const entries = Object.entries(dashboard.widgets);\n      const resolved = await Promise.all(\n        entries.map(([key, widget]) =>\n          resolveWidget(key, widget, config.connectors, storage),\n        ),\n      );\n      return resolved.filter((w): w is CachedWidget => w !== undefined);\n    },\n\n    async getHealth() {\n      return storage.getSyncState();\n    },\n\n    async triggerSync() {\n      const state = await storage.getSyncState();\n      if (state.status === 'syncing') {\n        return { triggered: false };\n      }\n      void syncRouter.runSync().catch((error) => {\n        console.error('Rawdash sync failed', error);\n      });\n      return { triggered: true };\n    },\n  };\n}\n","export { computeMetric } from '@rawdash/core';\n"],"mappings":"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","names":["InMemoryStorage","resolveWidget","InMemoryStorage","resolveWidget"]}
+{"version":3,"sources":["../src/errors.ts","../src/routes.ts","../src/handlers.ts","../src/retention.ts","../src/sync.ts","../src/engine.ts","../src/compute.ts","../src/storage.ts","../src/index.ts"],"sourcesContent":["/**\n * Thrown by `@rawdash/server` handlers when a request fails in a way the\n * HTTP adapter should translate to a structured response (e.g. 404, 400).\n * Framework adapters (`@rawdash/hono`, etc.) should catch this and map\n * `status` to the appropriate HTTP status code.\n */\nexport class RawdashError extends Error {\n  constructor(\n    readonly status: number,\n    readonly code: string,\n    message: string,\n  ) {\n    super(message);\n    this.name = 'RawdashError';\n  }\n}\n\nexport function isRawdashError(err: unknown): err is RawdashError {\n  return err instanceof RawdashError;\n}\n","/**\n * Canonical URL path conventions for the rawdash HTTP wire contract.\n *\n * Framework adapters (`@rawdash/hono`, etc.) and clients\n * (`@rawdash/client`) should use these constants instead of hard-coding\n * paths, so the contract stays in one place.\n */\nexport const ROUTES = {\n  health: '/health',\n  syncState: '/sync/state',\n  sync: '/sync',\n  retention: '/retention/retain',\n  widgets: {\n    list: (dashboardId: string): string =>\n      `/dashboards/${encodeURIComponent(dashboardId)}/widgets`,\n    single: (dashboardId: string, widgetId: string): string =>\n      `/dashboards/${encodeURIComponent(dashboardId)}/widgets/${encodeURIComponent(widgetId)}`,\n  },\n} as const;\n","import type {\n  CachedWidget,\n  ConnectorRegistry,\n  HealthResponse,\n  SecretsResolver,\n  SyncState,\n  TriggerSyncResponse,\n  Widget,\n  WidgetsListResponse,\n} from '@rawdash/core';\nimport { isSyncActive, resolveWidget } from '@rawdash/core';\nimport type { DashboardConfig, ServerStorage } from '@rawdash/core';\n\nimport type { EngineContext } from './context';\nimport { RawdashError } from './errors';\nimport { runRetention } from './retention';\nimport { runSync } from './sync';\nimport type { WidgetCache } from './widget-cache';\n\nasync function cacheGetSafe(\n  cache: WidgetCache,\n  dashboardId: string,\n  widgetId: string,\n  widget: Widget,\n): Promise<CachedWidget | undefined> {\n  try {\n    return await cache.get({ dashboardId, widgetId, widget });\n  } catch (err) {\n    console.warn('Rawdash widget cache get failed', err);\n    return undefined;\n  }\n}\n\nasync function cacheSetSafe(\n  cache: WidgetCache,\n  dashboardId: string,\n  widgetId: string,\n  widget: Widget,\n  value: CachedWidget,\n): Promise<void> {\n  try {\n    await cache.set({ dashboardId, widgetId, widget }, value);\n  } catch (err) {\n    console.warn('Rawdash widget cache set failed', err);\n  }\n}\n\nasync function resolveWithCache(\n  dashboardId: string,\n  widgetId: string,\n  widget: Widget,\n  connectorNames: readonly string[],\n  storage: ServerStorage,\n  cache: WidgetCache | undefined,\n): Promise<CachedWidget | undefined> {\n  if (cache) {\n    const hit = await cacheGetSafe(cache, dashboardId, widgetId, widget);\n    if (hit) {\n      return hit;\n    }\n  }\n  const fresh = await resolveWidget(widgetId, widget, connectorNames, storage);\n  if (fresh && cache) {\n    await cacheSetSafe(cache, dashboardId, widgetId, widget, fresh);\n  }\n  return fresh;\n}\n\n/**\n * Per-request lookup shape accepted by `triggerSync` in deferred mode.\n * `getConfig` is optional because the trigger handler never calls\n * `runSync` — deployments that delegate the actual sync work to an\n * external runner may not be able to materialize a `DashboardConfig` at\n * request time.\n */\nexport interface DeferredTriggerSyncContext {\n  getConfig?: () => DashboardConfig | Promise<DashboardConfig>;\n  getStorage: () => ServerStorage | Promise<ServerStorage>;\n}\n\n/**\n * Per-request lookup shape accepted by `triggerSync` in in-process\n * mode. `getConfig` is required because the trigger handler kicks off\n * `runSync(config, storage)` in the background. `connectorRegistry` is\n * required so the background runner can instantiate connector\n * implementations on demand from the declarative `DashboardConfig`.\n */\nexport interface InProcessTriggerSyncContext {\n  getConfig: () => DashboardConfig | Promise<DashboardConfig>;\n  getStorage: () => ServerStorage | Promise<ServerStorage>;\n  connectorRegistry: ConnectorRegistry;\n  secretsResolver?: SecretsResolver;\n}\n\n/**\n * @deprecated Prefer `InProcessTriggerSyncContext` /\n * `DeferredTriggerSyncContext`. Retained as the union for callers that\n * need a single type covering both modes.\n */\nexport type TriggerSyncContext = DeferredTriggerSyncContext;\n\nexport type TriggerSyncMode = 'in-process' | 'deferred';\n\nexport interface TriggerSyncOptions {\n  /**\n   * `'in-process'` (default): the trigger handler also runs the sync in\n   * the background by invoking `runSync(config, storage)`. Suitable for\n   * self-hosted, single-process deployments.\n   *\n   * `'deferred'`: the trigger handler only persists the `queued`\n   * transition and returns. The `running → succeeded/failed` transitions\n   * are the responsibility of an external runner (e.g. a queue consumer\n   * worker), which must drive the storage accordingly.\n   */\n  mode?: TriggerSyncMode;\n}\n\n/**\n * Framework-agnostic request handlers for the rawdash wire contract.\n *\n * Each function takes an `EngineContext` (providing per-request access to\n * the config + storage) and returns the response body, or throws a\n * `RawdashError` on a client-visible failure. HTTP adapters\n * (`@rawdash/hono`, etc.) wrap these in their framework's request/response\n * cycle and translate `RawdashError` into a structured error response.\n */\n\nexport function getHealth(): HealthResponse {\n  return { status: 'ok' };\n}\n\nexport async function getSyncStateHandler(\n  ctx: EngineContext,\n): Promise<SyncState> {\n  const storage = await ctx.getStorage();\n  return storage.getSyncState();\n}\n\nexport function triggerSync(\n  ctx: InProcessTriggerSyncContext,\n  opts?: { mode?: 'in-process' },\n): Promise<TriggerSyncResponse>;\nexport function triggerSync(\n  ctx: DeferredTriggerSyncContext,\n  opts: { mode: 'deferred' },\n): Promise<TriggerSyncResponse>;\nexport async function triggerSync(\n  ctx: InProcessTriggerSyncContext | DeferredTriggerSyncContext,\n  opts: TriggerSyncOptions = {},\n): Promise<TriggerSyncResponse> {\n  const mode: TriggerSyncMode = opts.mode ?? 'in-process';\n  const storage = await ctx.getStorage();\n  const state = await storage.getSyncState();\n  if (isSyncActive(state.status)) {\n    return { queued: false };\n  }\n  let config: DashboardConfig | undefined;\n  if (mode === 'in-process') {\n    if (!ctx.getConfig) {\n      throw new Error(\n        'triggerSync: getConfig is required when mode is \"in-process\"',\n      );\n    }\n    config = await ctx.getConfig();\n  }\n  const queued = await storage.markSyncQueued();\n  if (!queued) {\n    return { queued: false };\n  }\n  if (mode === 'deferred') {\n    return { queued: true };\n  }\n  const inProcessCtx = ctx as InProcessTriggerSyncContext;\n  void runSync(config!, storage, {\n    connectorRegistry: inProcessCtx.connectorRegistry,\n    secretsResolver: inProcessCtx.secretsResolver,\n  }).catch((err) => {\n    console.error('Rawdash sync failed', err);\n  });\n  return { queued: true };\n}\n\nexport async function listWidgets(\n  ctx: EngineContext,\n  dashboardId: string,\n  cache?: WidgetCache,\n): Promise<WidgetsListResponse> {\n  const config = await ctx.getConfig();\n  const dashboard = config.dashboards[dashboardId];\n  if (!dashboard) {\n    throw new RawdashError(404, 'DASHBOARD_NOT_FOUND', 'Dashboard not found');\n  }\n  const storage = await ctx.getStorage();\n  const connectorNames = config.connectors.map((c) => c.name);\n  const entries = Object.entries(dashboard.widgets);\n  const resolved = await Promise.all(\n    entries.map(([key, widget]) =>\n      resolveWithCache(\n        dashboardId,\n        key,\n        widget,\n        connectorNames,\n        storage,\n        cache,\n      ),\n    ),\n  );\n  const widgets = resolved.filter((w): w is CachedWidget => w !== undefined);\n  return { widgets };\n}\n\nexport async function getWidget(\n  ctx: EngineContext,\n  dashboardId: string,\n  widgetId: string,\n  cache?: WidgetCache,\n): Promise<CachedWidget> {\n  const config = await ctx.getConfig();\n  const dashboard = config.dashboards[dashboardId];\n  if (!dashboard) {\n    throw new RawdashError(404, 'DASHBOARD_NOT_FOUND', 'Dashboard not found');\n  }\n  const widget = dashboard.widgets[widgetId];\n  if (!widget) {\n    throw new RawdashError(404, 'WIDGET_NOT_FOUND', 'Widget not found');\n  }\n  const storage = await ctx.getStorage();\n  const connectorNames = config.connectors.map((c) => c.name);\n  const result = await resolveWithCache(\n    dashboardId,\n    widgetId,\n    widget,\n    connectorNames,\n    storage,\n    cache,\n  );\n  if (!result) {\n    throw new RawdashError(404, 'WIDGET_NOT_FOUND', 'Widget not found');\n  }\n  return result;\n}\n\nexport async function runRetentionOnce(ctx: EngineContext): Promise<void> {\n  const config = await ctx.getConfig();\n  const storage = await ctx.getStorage();\n  await runRetention(config, storage);\n}\n","import type {\n  DashboardConfig,\n  RetentionConfig,\n  ServerStorage,\n} from '@rawdash/core';\nimport { selectForDeletion } from '@rawdash/core';\n\nexport const DEFAULT_RETENTION_INTERVAL_MS = 60 * 60 * 1000; // 1 hour\n\nexport function hasPruningPolicy(config: RetentionConfig): boolean {\n  return config.maxAge !== undefined || config.maxSize !== undefined;\n}\n\n/**\n * Apply the retention policy in `config` to every connector's stored data.\n * No-op if the config has no pruning policy. Throws an aggregated error if\n * any connector fails.\n */\nexport async function runRetention(\n  config: DashboardConfig,\n  storage: ServerStorage,\n): Promise<void> {\n  const retentionConfig = config.retention;\n  if (!retentionConfig || !hasPruningPolicy(retentionConfig)) {\n    return;\n  }\n\n  const nowMs = Date.now();\n\n  const results = await Promise.allSettled(\n    config.connectors.map(async (entry) => {\n      const handle = storage.getStorageHandle(entry.name);\n\n      const [events, metrics, distributions] = await Promise.all([\n        handle.queryEvents({}),\n        handle.queryMetrics({}),\n        handle.queryDistributions({}),\n      ]);\n\n      await applyRetentionToShape(\n        events,\n        (e) => e.start_ts,\n        retentionConfig,\n        nowMs,\n        (survivors, names) => handle.events(survivors, { names }),\n      );\n\n      await applyRetentionToShape(\n        metrics,\n        (m) => m.ts,\n        retentionConfig,\n        nowMs,\n        (survivors, names) => handle.metrics(survivors, { names }),\n      );\n\n      await applyRetentionToShape(\n        distributions,\n        (d) => d.ts,\n        retentionConfig,\n        nowMs,\n        (survivors, names) => handle.distributions(survivors, { names }),\n      );\n    }),\n  );\n\n  const failures = results.filter(\n    (r): r is PromiseRejectedResult => r.status === 'rejected',\n  );\n  if (failures.length > 0) {\n    throw new Error(\n      `Retention failed for ${failures.length} connector(s): ${failures.map((f) => String(f.reason)).join('; ')}`,\n    );\n  }\n}\n\nasync function applyRetentionToShape<T extends { name: string }>(\n  rows: T[],\n  getTs: (row: T) => number,\n  config: RetentionConfig,\n  nowMs: number,\n  writeSurvivors: (survivors: T[], names: string[]) => Promise<void>,\n): Promise<void> {\n  if (rows.length === 0) {\n    return;\n  }\n\n  const sorted = [...rows].sort((a, b) => getTs(b) - getTs(a));\n  const toDeleteSet = new Set(selectForDeletion(sorted, getTs, config, nowMs));\n\n  if (toDeleteSet.size === 0) {\n    return;\n  }\n\n  const survivors = sorted.filter((r) => !toDeleteSet.has(r));\n  const allNames = [...new Set(rows.map((r) => r.name))];\n\n  await writeSurvivors(survivors, allNames);\n}\n","import type {\n  ConnectorRegistry,\n  DashboardConfig,\n  SecretsResolver,\n  ServerStorage,\n} from '@rawdash/core';\nimport { instantiateConnector } from '@rawdash/core';\n\nexport const FULL_SYNC_TIMEOUT_MS = 300_000;\n\nexport interface RunSyncOptions {\n  connectorRegistry: ConnectorRegistry;\n  secretsResolver?: SecretsResolver;\n}\n\n/**\n * Run a full sync across all connectors in the config in parallel via\n * `Promise.allSettled`, so one failure doesn't abort the others. Each\n * connector run is wrapped in a hard timeout (`FULL_SYNC_TIMEOUT_MS`)\n * raced against the connector's own `Promise`, so a connector that\n * ignores `AbortSignal` (or a storage call that hangs) can still not\n * pin sync state in `running` indefinitely.\n *\n * The per-run storage handle is bound to the same `AbortController`, so\n * once the timeout fires every subsequent write call on that handle\n * becomes a no-op. That makes tail writes from a timed-out connector\n * invisible to the next sync even if the connector itself keeps running\n * — see `withAbortSignal` in `@rawdash/core` and the safety-net note in\n * `docs/authoring-a-connector.md`.\n *\n * Transitions storage through `queued` → `running` → `succeeded`/`failed`.\n * The `queued` step is a no-op if the caller (typically `triggerSync`)\n * already marked the run as queued.\n *\n * Returns silently if another sync acquired the `running` lock first.\n */\nexport async function runSync(\n  config: DashboardConfig,\n  storage: ServerStorage,\n  options: RunSyncOptions,\n): Promise<void> {\n  await storage.markSyncQueued();\n  const acquired = await storage.markSyncRunning();\n  if (!acquired) {\n    return;\n  }\n  const errors: string[] = [];\n  await Promise.allSettled(\n    config.connectors.map(async (entry) => {\n      if (entry.enabled === false) {\n        return;\n      }\n      const controller = new AbortController();\n      const handle = storage.getStorageHandle(entry.name, {\n        signal: controller.signal,\n      });\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      try {\n        const connector = instantiateConnector(\n          entry,\n          options.connectorRegistry,\n          options.secretsResolver,\n        );\n        const syncPromise = connector.sync(\n          { mode: 'full' },\n          handle,\n          controller.signal,\n        );\n        const timeoutPromise = new Promise<never>((_resolve, reject) => {\n          timer = setTimeout(() => {\n            controller.abort();\n            const err = new Error(\n              `${entry.name} timed out after ${FULL_SYNC_TIMEOUT_MS}ms`,\n            );\n            err.name = 'AbortError';\n            reject(err);\n          }, FULL_SYNC_TIMEOUT_MS);\n        });\n        const result = await Promise.race([syncPromise, timeoutPromise]);\n        if (!result.done) {\n          errors.push(\n            `${entry.name} did not complete in one chunk (chunked syncs are only supported in cloud)`,\n          );\n        }\n      } catch (err) {\n        if (err instanceof Error && err.name === 'AbortError') {\n          errors.push(\n            `${entry.name} timed out after ${FULL_SYNC_TIMEOUT_MS}ms`,\n          );\n        } else {\n          errors.push(err instanceof Error ? err.message : String(err));\n        }\n      } finally {\n        if (timer !== undefined) {\n          clearTimeout(timer);\n        }\n      }\n    }),\n  );\n  if (errors.length > 0) {\n    await storage.markSyncFailed(errors.join('; '));\n  } else {\n    await storage.markSyncSucceeded();\n  }\n}\n","import type {\n  CachedWidget,\n  ConnectorRegistry,\n  DashboardConfig,\n  HealthResponse,\n  SecretsResolver,\n  ServerStorage,\n  SyncState,\n  TriggerSyncResponse,\n} from '@rawdash/core';\nimport { InMemoryStorage, isSyncActive, resolveWidget } from '@rawdash/core';\n\nimport { runSync } from './sync';\n\nexport interface EngineOptions {\n  storage?: ServerStorage;\n  connectorRegistry?: ConnectorRegistry;\n  secretsResolver?: SecretsResolver;\n}\n\nexport interface Engine {\n  getWidget(\n    dashboardId: string,\n    widgetId: string,\n  ): Promise<CachedWidget | undefined>;\n  getWidgets(dashboardId: string): Promise<CachedWidget[]>;\n  getHealth(): Promise<HealthResponse>;\n  getSyncState(): Promise<SyncState>;\n  triggerSync(): Promise<TriggerSyncResponse>;\n}\n\nexport function createEngine(\n  config: DashboardConfig,\n  options: EngineOptions = {},\n): Engine {\n  const storage: ServerStorage = options.storage ?? new InMemoryStorage();\n  const connectorNames = config.connectors.map((c) => c.name);\n\n  return {\n    async getWidget(dashboardId, widgetId) {\n      const dashboard = config.dashboards[dashboardId];\n      if (!dashboard) {\n        return undefined;\n      }\n      const widget = dashboard.widgets[widgetId];\n      if (!widget) {\n        return undefined;\n      }\n      return resolveWidget(widgetId, widget, connectorNames, storage);\n    },\n\n    async getWidgets(dashboardId) {\n      const dashboard = config.dashboards[dashboardId];\n      if (!dashboard) {\n        return [];\n      }\n      const entries = Object.entries(dashboard.widgets);\n      const resolved = await Promise.all(\n        entries.map(([key, widget]) =>\n          resolveWidget(key, widget, connectorNames, storage),\n        ),\n      );\n      return resolved.filter((w): w is CachedWidget => w !== undefined);\n    },\n\n    async getHealth() {\n      return { status: 'ok' };\n    },\n\n    async getSyncState() {\n      return storage.getSyncState();\n    },\n\n    async triggerSync() {\n      if (!options.connectorRegistry) {\n        throw new Error(\n          'createEngine: connectorRegistry is required to triggerSync',\n        );\n      }\n      const state = await storage.getSyncState();\n      if (isSyncActive(state.status)) {\n        return { queued: false };\n      }\n      const queued = await storage.markSyncQueued();\n      if (!queued) {\n        return { queued: false };\n      }\n      void runSync(config, storage, {\n        connectorRegistry: options.connectorRegistry,\n        secretsResolver: options.secretsResolver,\n      }).catch((error) => {\n        console.error('Rawdash sync failed', error);\n      });\n      return { queued: true };\n    },\n  };\n}\n","export { computeMetric } from '@rawdash/core';\n","export { InMemoryStorage } from '@rawdash/core';\n","export type { EngineContext } from './context';\nexport { RawdashError, isRawdashError } from './errors';\nexport { ROUTES } from './routes';\nexport {\n  getHealth,\n  getSyncStateHandler,\n  getWidget,\n  listWidgets,\n  runRetentionOnce,\n  triggerSync,\n} from './handlers';\nexport type {\n  DeferredTriggerSyncContext,\n  InProcessTriggerSyncContext,\n  TriggerSyncContext,\n  TriggerSyncMode,\n  TriggerSyncOptions,\n} from './handlers';\nexport type { WidgetCache, WidgetCacheKey } from './widget-cache';\nexport { runSync, FULL_SYNC_TIMEOUT_MS } from './sync';\nexport type { RunSyncOptions } from './sync';\nexport {\n  runRetention,\n  hasPruningPolicy,\n  DEFAULT_RETENTION_INTERVAL_MS,\n} from './retention';\nexport { createEngine } from './engine';\nexport type { Engine, EngineOptions } from './engine';\nexport { computeMetric } from './compute';\nexport { InMemoryStorage } from './storage';\nexport type {\n  CachedWidget,\n  ConfiguredConnector,\n  ConnectorHealth,\n  DashboardConfig,\n  HealthResponse,\n  ServerStorage,\n  SyncState,\n  SyncStatus,\n  TriggerSyncResponse,\n  Widget,\n  WidgetSyncState,\n  WidgetsListResponse,\n} from './types';\nexport { isSyncActive, ACTIVE_SYNC_STATUSES } from '@rawdash/core';\nexport { instantiateConnector } from '@rawdash/core';\nexport type {\n  ConnectorClass,\n  ConnectorRegistry,\n  SecretsResolver,\n} from '@rawdash/core';\n"],"mappings":"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","names":["isSyncActive","resolveWidget","resolveWidget","isSyncActive","InMemoryStorage","isSyncActive","instantiateConnector"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rawdash/server",
-  "version": "0.13.0",
-  "description": "Rawdash standalone Hono server",
+  "version": "0.15.0",
+  "description": "Framework-agnostic rawdash request handlers, engine, and wire contract. Wrap with @rawdash/hono (or another adapter) to serve over HTTP.",
   "license": "Apache-2.0",
   "type": "module",
   "repository": {
@@ -22,18 +22,14 @@
     }
   },
   "dependencies": {
-    "@hono/node-server": "^1.13.7",
-    "hono": "^4.7.7",
-    "@rawdash/core": "0.13.0"
+    "@rawdash/core": "0.15.0"
   },
   "devDependencies": {
     "tsup": "^8.0.0",
-    "tsx": "^4.19.2",
     "typescript": "^5.7.2"
   },
   "scripts": {
     "build": "tsup",
-    "dev": "tsx src/dev.ts",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src",
     "test": "vitest run"