@nostrwatch/route66 0.0.1

package/dist/node/services/ChronicleService.js

@@ -0,0 +1,788 @@
+/**
+ * ChronicleService
+ *
+ * Service for accessing relay history and time series data from Kind 1066 delta events.
+ * Leverages route66's existing websocket adapter to avoid duplicate connections.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Service } from './Service';
+import { Route66EventStorage } from '@nostrwatch/relay-chronicle';
+import { generateRttSeries, generateUptimeSeries, uptimeHistory, } from '@nostrwatch/relay-chronicle';
+import { deterministicHash } from '../utils';
+import { DeltaEvent } from '../models';
+/**
+ * ChronicleService - Access relay history via Kind 1066 delta events
+ *
+ * This service integrates relay-chronicle with route66's existing infrastructure:
+ * - Uses websocket adapter for fetching events (no duplicate connections)
+ * - Uses cache adapter for querying stored events
+ * - Provides time series data for charting
+ *
+ * @example
+ * ```typescript
+ * const chronicle = new ChronicleService(route66.adapters, {
+ *   autoSync: true,
+ *   syncRelays: ['wss://relay.nostr.watch'],
+ * });
+ *
+ * // Sync a relay (fetch and subscribe to Kind 1066)
+ * await chronicle.syncRelay('wss://relay.example.com');
+ *
+ * // Get RTT time series for charting
+ * const rttData = await chronicle.getTimeSeriesData({
+ *   relay: 'wss://relay.example.com',
+ *   type: 'rtt',
+ *   since: Date.now() / 1000 - 86400, // Last 24h
+ * });
+ * ```
+ */
+var ChronicleService = /** @class */ (function (_super) {
+    __extends(ChronicleService, _super);
+    function ChronicleService(adapters, options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b;
+        var _this = _super.call(this, adapters) || this;
+        _this.memoryByRelay = new Map();
+        _this.memoryBoundsByRelay = new Map();
+        _this.kind1066Subscriptions = new Map();
+        _this.syncInFlight = new Map();
+        _this.desiredSinceByRelay = new Map();
+        _this.storage = new Route66EventStorage(_this.cacheAdapter);
+        _this.options = {
+            autoSync: (_a = options.autoSync) !== null && _a !== void 0 ? _a : false,
+            syncRelays: (_b = options.syncRelays) !== null && _b !== void 0 ? _b : [],
+        };
+        _this.init();
+        return _this;
+    }
+    ChronicleService.prototype.aggregateTimeSeries = function (points, bucketSize, fn) {
+        var _a;
+        if (!Array.isArray(points) || points.length === 0)
+            return [];
+        if (!Number.isFinite(bucketSize) || bucketSize <= 0)
+            return points;
+        var buckets = new Map();
+        for (var _i = 0, points_1 = points; _i < points_1.length; _i++) {
+            var point = points_1[_i];
+            var timestamp = point === null || point === void 0 ? void 0 : point.timestamp;
+            if (typeof timestamp !== 'number' || !Number.isFinite(timestamp))
+                continue;
+            var bucketTimestamp = Math.floor(timestamp / bucketSize) * bucketSize;
+            var raw = point === null || point === void 0 ? void 0 : point.value;
+            var value = typeof raw === 'number'
+                ? raw
+                : typeof raw === 'boolean'
+                    ? raw
+                        ? 1
+                        : 0
+                    : null;
+            if (value == null || !Number.isFinite(value))
+                continue;
+            var bucket = (_a = buckets.get(bucketTimestamp)) !== null && _a !== void 0 ? _a : { values: [] };
+            bucket.values.push(value);
+            if (point === null || point === void 0 ? void 0 : point.eventId)
+                bucket.eventId = point.eventId;
+            buckets.set(bucketTimestamp, bucket);
+        }
+        var aggregated = [];
+        buckets.forEach(function (bucket, timestamp) {
+            var values = bucket.values;
+            if (!values.length)
+                return;
+            var aggregatedValue = 0;
+            switch (fn) {
+                case 'avg':
+                    aggregatedValue = values.reduce(function (a, b) { return a + b; }, 0) / values.length;
+                    break;
+                case 'min':
+                    aggregatedValue = Math.min.apply(Math, values);
+                    break;
+                case 'max':
+                    aggregatedValue = Math.max.apply(Math, values);
+                    break;
+                case 'sum':
+                    aggregatedValue = values.reduce(function (a, b) { return a + b; }, 0);
+                    break;
+            }
+            aggregated.push(__assign({ timestamp: timestamp, date: new Date(timestamp * 1000).toISOString(), value: aggregatedValue }, (bucket.eventId ? { eventId: bucket.eventId } : {})));
+        });
+        return aggregated.sort(function (a, b) { return a.timestamp - b.timestamp; });
+    };
+    ChronicleService.prototype.normalizeRelayKey = function (relay) {
+        var trimmed = (relay || '').trim();
+        if (!trimmed)
+            return '';
+        return trimmed.replace(/\/+$/, '');
+    };
+    ChronicleService.prototype.normalizeSince = function (since) {
+        if (typeof since !== 'number')
+            return undefined;
+        if (!Number.isFinite(since))
+            return undefined;
+        return since;
+    };
+    ChronicleService.prototype.relayTagValues = function (relay) {
+        var trimmed = (relay || '').trim();
+        if (!trimmed)
+            return [];
+        var withoutTrailingSlash = trimmed.replace(/\/+$/, '');
+        var withTrailingSlash = "".concat(withoutTrailingSlash, "/");
+        return Array.from(new Set([trimmed, withoutTrailingSlash, withTrailingSlash]));
+    };
+    /**
+     * Values to use for *remote* `#r` filtering.
+     *
+     * Some relays (notably `wss://relay.nostr.watch`) appear to mishandle multiple values
+     * within a single `#r: [...]` array. To remain compatible, we query each candidate
+     * as a separate filter/request.
+     */
+    ChronicleService.prototype.relayTagQueryValues = function (relay) {
+        var trimmed = (relay || '').trim();
+        if (!trimmed)
+            return [];
+        var withoutTrailingSlash = trimmed.replace(/\/+$/, '');
+        if (!withoutTrailingSlash)
+            return [];
+        var withTrailingSlash = "".concat(withoutTrailingSlash, "/");
+        return Array.from(new Set([withoutTrailingSlash, withTrailingSlash]));
+    };
+    ChronicleService.prototype.updateMemoryBounds = function (relayKey, createdAt) {
+        if (!Number.isFinite(createdAt))
+            return;
+        var existing = this.memoryBoundsByRelay.get(relayKey);
+        if (!existing) {
+            this.memoryBoundsByRelay.set(relayKey, { min: createdAt, max: createdAt });
+            return;
+        }
+        if (createdAt < existing.min)
+            existing.min = createdAt;
+        if (createdAt > existing.max)
+            existing.max = createdAt;
+    };
+    ChronicleService.prototype.extractRelayKeyFromEvent = function (event) {
+        var _a;
+        var ev = event;
+        if (!ev || ev.kind !== 1066)
+            return null;
+        var rTag = Array.isArray(ev.tags) ? (_a = ev.tags.find(function (t) { return (t === null || t === void 0 ? void 0 : t[0]) === 'r'; })) === null || _a === void 0 ? void 0 : _a[1] : undefined;
+        if (typeof rTag !== 'string' || !rTag)
+            return null;
+        return this.normalizeRelayKey(rTag);
+    };
+    ChronicleService.prototype.rememberEvent = function (event, relayKey) {
+        var ev = event;
+        if (!ev || ev.kind !== 1066 || typeof ev.id !== 'string')
+            return;
+        if (typeof ev.created_at === 'number') {
+            this.updateMemoryBounds(relayKey, ev.created_at);
+        }
+        var relayMap = this.memoryByRelay.get(relayKey);
+        if (!relayMap) {
+            relayMap = new Map();
+            this.memoryByRelay.set(relayKey, relayMap);
+        }
+        // Store the raw event - it should already have the correct DeltaEvent structure
+        // Validate it's a proper Kind 1066 event before storing
+        if (DeltaEvent.KIND === ev.kind) {
+            relayMap.set(ev.id, ev);
+        }
+    };
+    ChronicleService.prototype.backfillKind1066ForRelayTag = function (relayKey, relayTagValue, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var PAGE_LIMIT, MAX_PAGES, targetSince, cursorUntil, pages, lastOldest, filter, args, events, res, err_1, oldest, _i, events_1, event_1, ev, nextUntil;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        PAGE_LIMIT = 5000;
+                        MAX_PAGES = 250;
+                        targetSince = this.normalizeSince(options === null || options === void 0 ? void 0 : options.since);
+                        cursorUntil = (_a = this.normalizeSince(options === null || options === void 0 ? void 0 : options.until)) !== null && _a !== void 0 ? _a : Math.floor(Date.now() / 1000);
+                        pages = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(pages < MAX_PAGES)) return [3 /*break*/, 6];
+                        filter = {
+                            kinds: [1066],
+                            '#r': [relayTagValue],
+                            until: cursorUntil,
+                            limit: PAGE_LIMIT,
+                        };
+                        if (typeof targetSince === 'number')
+                            filter.since = targetSince;
+                        args = {
+                            filters: [filter],
+                            relays: this.options.syncRelays,
+                            hash: deterministicHash([filter]),
+                            options: {
+                                cache: false,
+                                stream: false,
+                                keepAlive: false,
+                                returnResults: true,
+                            },
+                        };
+                        events = [];
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.fetchFromWebsocket(args)];
+                    case 3:
+                        res = _b.sent();
+                        events = Array.isArray(res) ? res : [];
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _b.sent();
+                        console.warn("[Chronicle] Fetch error for ".concat(relayTagValue, ":"), err_1);
+                        return [2 /*return*/];
+                    case 5:
+                        if (!events.length)
+                            return [2 /*return*/];
+                        oldest = void 0;
+                        for (_i = 0, events_1 = events; _i < events_1.length; _i++) {
+                            event_1 = events_1[_i];
+                            ev = event_1;
+                            if (!ev || ev.kind !== 1066)
+                                continue;
+                            if (this.extractRelayKeyFromEvent(ev) !== relayKey)
+                                continue;
+                            if (typeof ev.created_at === 'number') {
+                                if (oldest === undefined || ev.created_at < oldest)
+                                    oldest = ev.created_at;
+                            }
+                            this.rememberEvent(ev, relayKey);
+                        }
+                        // If we didn't see any matching events in this page, bail (either relay has no data,
+                        // or the remote relay isn't returning the expected tag variant).
+                        if (oldest === undefined)
+                            return [2 /*return*/];
+                        if (typeof targetSince === 'number' && oldest <= targetSince)
+                            return [2 /*return*/];
+                        // If we got fewer than the page limit, we likely exhausted history for this tag/range.
+                        if (events.length < PAGE_LIMIT)
+                            return [2 /*return*/];
+                        // Safety: avoid infinite loops if server keeps returning the same oldest timestamp.
+                        if (oldest === lastOldest)
+                            return [2 /*return*/];
+                        lastOldest = oldest;
+                        nextUntil = oldest - 1;
+                        if (!Number.isFinite(nextUntil) || nextUntil <= 0)
+                            return [2 /*return*/];
+                        if (nextUntil >= cursorUntil)
+                            return [2 /*return*/];
+                        cursorUntil = nextUntil;
+                        pages += 1;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ChronicleService.prototype.backfillKind1066ForRelay = function (relay, relayKey, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var targetSince, bounds, tagValues, _i, tagValues_1, tagValue;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        targetSince = this.normalizeSince(options === null || options === void 0 ? void 0 : options.since);
+                        bounds = this.memoryBoundsByRelay.get(relayKey);
+                        if (typeof targetSince === 'number' &&
+                            bounds &&
+                            Number.isFinite(bounds.min) &&
+                            bounds.min <= targetSince) {
+                            return [2 /*return*/];
+                        }
+                        tagValues = this.relayTagQueryValues(relay);
+                        _i = 0, tagValues_1 = tagValues;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < tagValues_1.length)) return [3 /*break*/, 4];
+                        tagValue = tagValues_1[_i];
+                        return [4 /*yield*/, this.backfillKind1066ForRelayTag(relayKey, tagValue, options)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ChronicleService.prototype.getMemoryStorage = function () {
+        var memoryByRelay = this.memoryByRelay;
+        var relayTagValues = this.relayTagValues.bind(this);
+        var normalizeRelayKey = this.normalizeRelayKey.bind(this);
+        return {
+            query: function (options) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var relayKeys, relayMaps, byId, _i, relayMaps_1, relayMap, events, allowed_1;
+                    return __generator(this, function (_a) {
+                        relayKeys = relayTagValues(options.relay);
+                        relayMaps = relayKeys
+                            .map(function (key) { return memoryByRelay.get(normalizeRelayKey(key)); })
+                            .filter(function (m) { return Boolean(m && m.size); });
+                        if (relayMaps.length === 0)
+                            return [2 /*return*/, []];
+                        byId = new Map();
+                        for (_i = 0, relayMaps_1 = relayMaps; _i < relayMaps_1.length; _i++) {
+                            relayMap = relayMaps_1[_i];
+                            relayMap.forEach(function (ev, id) { return byId.set(id, ev); });
+                        }
+                        events = Array.from(byId.values());
+                        if (typeof options.since === 'number' && Number.isFinite(options.since)) {
+                            events = events.filter(function (e) { return e.created_at >= options.since; });
+                        }
+                        if (typeof options.until === 'number' && Number.isFinite(options.until)) {
+                            events = events.filter(function (e) { return e.created_at <= options.until; });
+                        }
+                        if (options.statusOnly) {
+                            events = events.filter(function (e) {
+                                return Array.isArray(e.tags) &&
+                                    e.tags.some(function (t) { return ((t === null || t === void 0 ? void 0 : t[0]) === 'status' || (t === null || t === void 0 ? void 0 : t[0]) === 'O') && ((t === null || t === void 0 ? void 0 : t[1]) === 'init' || (t === null || t === void 0 ? void 0 : t[1]) === 'up' || (t === null || t === void 0 ? void 0 : t[1]) === 'down'); });
+                            });
+                        }
+                        if (options.periods && options.periods.length > 0) {
+                            allowed_1 = new Set(options.periods);
+                            events = events.filter(function (e) {
+                                return Array.isArray(e.tags) &&
+                                    e.tags.some(function (t) { var _a; return (t === null || t === void 0 ? void 0 : t[0]) === 'T' && allowed_1.has(String((_a = t === null || t === void 0 ? void 0 : t[1]) !== null && _a !== void 0 ? _a : '')); });
+                            });
+                        }
+                        events.sort(function (a, b) { return a.created_at - b.created_at; });
+                        if (typeof options.limit === 'number' && Number.isFinite(options.limit) && options.limit > 0) {
+                            // Nostr `limit` semantics typically return most recent events; after sorting ASC,
+                            // keep the last N.
+                            events = events.slice(-options.limit);
+                        }
+                        return [2 /*return*/, events];
+                    });
+                });
+            },
+        };
+    };
+    ChronicleService.prototype.init = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cacheAdapter.ready()];
+                    case 1:
+                        _a.sent();
+                        this._ready = true;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Subscribe to Kind 1066 delta events for a relay
+     *
+     * Uses route66's websocket adapter to fetch and subscribe to events.
+     * Events are automatically cached by the cache adapter.
+     *
+     * @param relay - Relay URL to sync
+     * @param options - Sync options
+     */
+    ChronicleService.prototype.syncRelay = function (relay, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keepAlive, relayKey, requestedSince, prevDesiredSince, desiredSince, existing, effectiveSince, bounds, needsBackfill, needsLiveSubscription, inFlightNow, task;
+            var _this = this;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _c.sent();
+                        keepAlive = (_b = (_a = options === null || options === void 0 ? void 0 : options.keepAlive) !== null && _a !== void 0 ? _a : this.options.autoSync) !== null && _b !== void 0 ? _b : false;
+                        relayKey = this.normalizeRelayKey(relay);
+                        requestedSince = this.normalizeSince(options === null || options === void 0 ? void 0 : options.since);
+                        prevDesiredSince = this.desiredSinceByRelay.get(relayKey);
+                        desiredSince = requestedSince === undefined
+                            ? prevDesiredSince
+                            : prevDesiredSince === undefined
+                                ? requestedSince
+                                : Math.min(prevDesiredSince, requestedSince);
+                        this.desiredSinceByRelay.set(relayKey, desiredSince);
+                        existing = this.syncInFlight.get(relayKey);
+                        if (!existing) return [3 /*break*/, 3];
+                        // If another sync is already in-flight, wait for it, then re-evaluate whether we
+                        // still need to start/extend syncing (e.g. the requested `since` expanded).
+                        return [4 /*yield*/, existing];
+                    case 2:
+                        // If another sync is already in-flight, wait for it, then re-evaluate whether we
+                        // still need to start/extend syncing (e.g. the requested `since` expanded).
+                        _c.sent();
+                        _c.label = 3;
+                    case 3:
+                        effectiveSince = this.desiredSinceByRelay.get(relayKey);
+                        bounds = this.memoryBoundsByRelay.get(relayKey);
+                        needsBackfill = typeof effectiveSince === 'number'
+                            ? !bounds || !Number.isFinite(bounds.min) || bounds.min > effectiveSince
+                            : false;
+                        needsLiveSubscription = keepAlive && !this.kind1066Subscriptions.has(relayKey);
+                        inFlightNow = this.syncInFlight.get(relayKey);
+                        if (inFlightNow)
+                            return [2 /*return*/, inFlightNow];
+                        if (!needsBackfill && !needsLiveSubscription)
+                            return [2 /*return*/];
+                        task = (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var liveSince_1, tagValues, filters, hash, args, callbacks;
+                            var _this = this;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (keepAlive) {
+                                            // Start a lightweight live subscription for new deltas. Historical ranges are fetched
+                                            // explicitly via backfill to avoid relay `limit` caps truncating initial results.
+                                            if (!this.kind1066Subscriptions.has(relayKey)) {
+                                                liveSince_1 = Math.floor(Date.now() / 1000) - 60;
+                                                tagValues = this.relayTagQueryValues(relay);
+                                                filters = tagValues.map(function (tagValue) { return ({
+                                                    kinds: [1066],
+                                                    '#r': [tagValue],
+                                                    since: liveSince_1,
+                                                }); });
+                                                hash = deterministicHash({ kind: 1066, relay: relayKey, tagValues: tagValues });
+                                                args = {
+                                                    filters: filters,
+                                                    relays: this.options.syncRelays,
+                                                    hash: hash,
+                                                    options: {
+                                                        cache: false,
+                                                        stream: true,
+                                                        keepAlive: true,
+                                                        returnResults: true,
+                                                    },
+                                                };
+                                                callbacks = {
+                                                    onevent: function (event) {
+                                                        var eventRelayKey = _this.extractRelayKeyFromEvent(event);
+                                                        if (!eventRelayKey || eventRelayKey !== relayKey)
+                                                            return;
+                                                        _this.rememberEvent(event, relayKey);
+                                                    },
+                                                };
+                                                this.subscribe(args, callbacks, true).catch(function (err) {
+                                                    console.warn("[Chronicle] Subscribe error for ".concat(relay, ":"), err);
+                                                });
+                                                this.kind1066Subscriptions.set(relayKey, hash);
+                                            }
+                                        }
+                                        if (!needsBackfill) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this.backfillKind1066ForRelay(relay, relayKey, { since: effectiveSince })];
+                                    case 1:
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); })().finally(function () {
+                            _this.syncInFlight.delete(relayKey);
+                        });
+                        this.syncInFlight.set(relayKey, task);
+                        return [2 /*return*/, task];
+                }
+            });
+        });
+    };
+    /**
+     * Stop syncing Kind 1066 events for a relay
+     *
+     * @param relay - Relay URL to stop syncing
+     */
+    ChronicleService.prototype.unsyncRelay = function (relay) {
+        return __awaiter(this, void 0, void 0, function () {
+            var relayKey, hash;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        relayKey = this.normalizeRelayKey(relay);
+                        hash = this.kind1066Subscriptions.get(relayKey);
+                        this.desiredSinceByRelay.delete(relayKey);
+                        this.memoryByRelay.delete(relayKey);
+                        this.memoryBoundsByRelay.delete(relayKey);
+                        if (!hash) return [3 /*break*/, 2];
+                        this.kind1066Subscriptions.delete(relayKey);
+                        return [4 /*yield*/, this.unsubscribe(hash)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get time series data for charting
+     *
+     * Extracts time series data from Kind 1066 events.
+     * Queries memory first (events captured during sync), then falls back to cache.
+     * Optionally syncs the relay first if autoSync is enabled.
+     *
+     * @param options - Time series query options
+     * @returns Array of time series points
+     */
+    ChronicleService.prototype.getTimeSeriesData = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var memoryStorage, storage, events, timeSeries, _a, uptimeSeries;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _b.sent();
+                        if (!(this.options.autoSync &&
+                            !this.kind1066Subscriptions.has(this.normalizeRelayKey(options.relay)))) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.syncRelay(options.relay, { since: options.since })];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        memoryStorage = this.getMemoryStorage();
+                        storage = memoryStorage;
+                        return [4 /*yield*/, memoryStorage.query({
+                                relay: options.relay,
+                                since: options.since,
+                                until: options.until,
+                            })];
+                    case 4:
+                        events = _b.sent();
+                        if (!(events.length === 0)) return [3 /*break*/, 6];
+                        storage = this.storage;
+                        return [4 /*yield*/, this.storage.query({
+                                relay: options.relay,
+                                since: options.since,
+                                until: options.until,
+                            })];
+                    case 5:
+                        events = _b.sent();
+                        _b.label = 6;
+                    case 6:
+                        if (events.length === 0) {
+                            console.warn("[Chronicle] No events found for ".concat(options.relay));
+                            return [2 /*return*/, []];
+                        }
+                        timeSeries = [];
+                        _a = options.type;
+                        switch (_a) {
+                            case 'rtt': return [3 /*break*/, 7];
+                            case 'uptime': return [3 /*break*/, 9];
+                        }
+                        return [3 /*break*/, 11];
+                    case 7: return [4 /*yield*/, generateRttSeries({
+                            storage: storage,
+                            relay: options.relay,
+                            since: options.since,
+                            until: options.until,
+                        })];
+                    case 8:
+                        timeSeries = _b.sent();
+                        return [3 /*break*/, 12];
+                    case 9: return [4 /*yield*/, generateUptimeSeries({
+                            storage: storage,
+                            relay: options.relay,
+                            since: options.since,
+                            until: options.until,
+                        })];
+                    case 10:
+                        uptimeSeries = _b.sent();
+                        // Convert UptimePoint[] to TimeSeriesPoint[]
+                        timeSeries = uptimeSeries.map(function (point) { return ({
+                            timestamp: point.timestamp,
+                            date: point.date,
+                            value: point.value === 'online' ? 1 : 0,
+                        }); });
+                        return [3 /*break*/, 12];
+                    case 11:
+                        console.warn("[Chronicle] Unknown time series type: ".concat(options.type));
+                        _b.label = 12;
+                    case 12:
+                        // Apply aggregation if specified
+                        if (options.aggregate) {
+                            timeSeries = this.aggregateTimeSeries(timeSeries, options.aggregate.bucketSize, options.aggregate.fn);
+                        }
+                        return [2 /*return*/, timeSeries];
+                }
+            });
+        });
+    };
+    /**
+     * Get uptime/downtime periods for timeline visualization
+     *
+     * Queries memory first (events captured during sync), then falls back to cache.
+     *
+     * @param relay - Relay URL
+     * @param options - Query options
+     * @returns Array of uptime/downtime periods
+     */
+    ChronicleService.prototype.getUptimeHistory = function (relay, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var memoryStorage, periods;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _a.sent();
+                        memoryStorage = this.getMemoryStorage();
+                        return [4 /*yield*/, uptimeHistory(memoryStorage, relay, options)];
+                    case 2:
+                        periods = _a.sent();
+                        if (!(periods.length === 0)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, uptimeHistory(this.storage, relay, options)];
+                    case 3:
+                        periods = _a.sent();
+                        _a.label = 4;
+                    case 4: 
+                    // Convert to UptimePeriod format
+                    return [2 /*return*/, periods.map(function (period) { return ({
+                            start: period.start,
+                            end: period.end || null,
+                            online: period.type === 'uptime',
+                            rtt: undefined, // TODO: Extract RTT from period if available
+                        }); })];
+                }
+            });
+        });
+    };
+    /**
+     * Get raw Kind 1066 delta events for a relay
+     *
+     * Queries memory first (events captured during sync), then falls back to cache storage.
+     * Optionally syncs the relay first if autoSync is enabled.
+     */
+    ChronicleService.prototype.getDeltaEvents = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var memoryStorage, events;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _a.sent();
+                        if (!(this.options.autoSync && !this.kind1066Subscriptions.has(this.normalizeRelayKey(options.relay)))) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.syncRelay(options.relay, { since: options.since })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        memoryStorage = this.getMemoryStorage();
+                        return [4 /*yield*/, memoryStorage.query(options)];
+                    case 4:
+                        events = _a.sent();
+                        if (!(events.length === 0)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.storage.query(options)];
+                    case 5:
+                        events = _a.sent();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/, events];
+                }
+            });
+        });
+    };
+    /**
+     * Check if a relay is currently being synced
+     *
+     * @param relay - Relay URL to check
+     * @returns True if relay is being synced
+     */
+    ChronicleService.prototype.isSyncing = function (relay) {
+        return this.kind1066Subscriptions.has(this.normalizeRelayKey(relay));
+    };
+    /**
+     * Get list of currently synced relays
+     *
+     * @returns Array of relay URLs being synced
+     */
+    ChronicleService.prototype.getSyncedRelays = function () {
+        return Array.from(this.kind1066Subscriptions.keys());
+    };
+    /**
+     * Stop syncing all relays
+     */
+    ChronicleService.prototype.unsyncAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var relays, _i, relays_1, relay;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        relays = this.getSyncedRelays();
+                        _i = 0, relays_1 = relays;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < relays_1.length)) return [3 /*break*/, 4];
+                        relay = relays_1[_i];
+                        return [4 /*yield*/, this.unsyncRelay(relay)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ChronicleService;
+}(Service));
+export { ChronicleService };
+//# sourceMappingURL=ChronicleService.js.map