opencandle 0.5.0 → 0.6.0

package/dist/market-state/service.js

@@ -0,0 +1,1099 @@
+export class MarketStateService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getDefaultWatchlist() {
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT OR IGNORE INTO watchlists (name, is_default, created_at, updated_at)
+         SELECT 'Default', 1, ?, ?
+         WHERE NOT EXISTS (SELECT 1 FROM watchlists WHERE is_default = 1)`)
+            .run(now, now);
+        const row = this.db
+            .prepare("SELECT * FROM watchlists WHERE is_default = 1 LIMIT 1")
+            .get();
+        return mapCollection(row);
+    }
+    getDefaultPortfolio() {
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT OR IGNORE INTO portfolios (name, base_currency, is_default, created_at, updated_at)
+         SELECT 'Default', 'USD', 1, ?, ?
+         WHERE NOT EXISTS (SELECT 1 FROM portfolios WHERE is_default = 1)`)
+            .run(now, now);
+        const row = this.db
+            .prepare("SELECT * FROM portfolios WHERE is_default = 1 LIMIT 1")
+            .get();
+        return {
+            ...mapCollection(row),
+            baseCurrency: row.base_currency,
+        };
+    }
+    findInstrumentByAlias(lookup) {
+        const source = normalizeSource(lookup.source);
+        const sourceId = normalizeNullable(lookup.sourceId);
+        const alias = sourceId == null
+            ? this.db
+                .prepare(`SELECT id, instrument_id FROM instrument_aliases
+           WHERE source = ?
+             AND source_symbol = ?
+             AND IFNULL(source_exchange, '') = IFNULL(?, '')
+             AND IFNULL(source_asset_type, '') = IFNULL(?, '')
+           LIMIT 1`)
+                .get(source, normalizeSourceSymbol(lookup.sourceSymbol ?? ""), normalizeExchange(lookup.sourceExchange), normalizeAssetType(lookup.sourceAssetType))
+            : this.db
+                .prepare(`SELECT id, instrument_id FROM instrument_aliases
+           WHERE source = ? AND source_id = ?
+           LIMIT 1`)
+                .get(source, sourceId);
+        if (alias == null)
+            return null;
+        const row = this.db
+            .prepare("SELECT * FROM instruments WHERE id = ?")
+            .get(alias.instrument_id);
+        return row == null ? null : mapInstrument(row);
+    }
+    addWatchlistItem(params) {
+        const tx = this.db.transaction(() => {
+            const watchlistId = params.watchlistId ?? this.getDefaultWatchlist().id;
+            const instrument = this.upsertInstrument(params.instrument);
+            const now = new Date().toISOString();
+            const existing = this.db
+                .prepare(`SELECT * FROM watchlist_items
+           WHERE watchlist_id = ? AND instrument_id = ?`)
+                .get(watchlistId, instrument.id);
+            if (existing) {
+                this.db
+                    .prepare(`UPDATE watchlist_items
+             SET target_price = ?, stop_price = ?, price_currency = ?, thesis = ?,
+                 notes = ?, tags_json = ?, source = ?, source_row_id = ?,
+                 source_metadata_json = ?, updated_at = ?
+             WHERE id = ?`)
+                    .run(params.targetPrice === undefined ? existing.target_price : params.targetPrice, params.stopPrice === undefined ? existing.stop_price : params.stopPrice, params.priceCurrency === undefined ? existing.price_currency : params.priceCurrency, params.thesis === undefined ? existing.thesis : params.thesis, params.notes === undefined ? existing.notes : params.notes, params.tags == null ? existing.tags_json : JSON.stringify(params.tags), params.source === undefined ? existing.source : normalizeNullable(params.source), params.sourceRowId === undefined
+                    ? existing.source_row_id
+                    : normalizeNullable(params.sourceRowId), params.sourceMetadata === undefined
+                    ? existing.source_metadata_json
+                    : params.sourceMetadata == null
+                        ? null
+                        : JSON.stringify(params.sourceMetadata), now, existing.id);
+                return existing.id;
+            }
+            const result = this.db
+                .prepare(`INSERT INTO watchlist_items (
+             watchlist_id, instrument_id, thesis, notes, tags_json,
+             target_price, stop_price, price_currency, source, source_row_id,
+             source_metadata_json, created_at, updated_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(watchlistId, instrument.id, params.thesis ?? null, params.notes ?? null, params.tags == null ? null : JSON.stringify(params.tags), params.targetPrice ?? null, params.stopPrice ?? null, params.priceCurrency ?? params.instrument.currency ?? null, normalizeNullable(params.source), normalizeNullable(params.sourceRowId), params.sourceMetadata == null ? null : JSON.stringify(params.sourceMetadata), now, now);
+            return Number(result.lastInsertRowid);
+        });
+        return this.getWatchlistItem(tx());
+    }
+    listWatchlistItems(watchlistId = this.getDefaultWatchlist().id) {
+        const rows = this.db
+            .prepare(`SELECT wi.*, i.symbol, i.name, i.asset_type, i.exchange, i.currency
+         FROM watchlist_items wi
+         JOIN instruments i ON i.id = wi.instrument_id
+         WHERE wi.watchlist_id = ?
+         ORDER BY i.symbol`)
+            .all(watchlistId);
+        return rows.map(mapWatchlistItem);
+    }
+    removeWatchlistItemBySymbol(symbol, watchlistId = this.getDefaultWatchlist().id) {
+        const result = this.db
+            .prepare(`DELETE FROM watchlist_items
+         WHERE watchlist_id = ?
+           AND instrument_id IN (SELECT id FROM instruments WHERE symbol = ?)`)
+            .run(watchlistId, symbol.trim().toUpperCase());
+        return result.changes > 0;
+    }
+    updateWatchlistItemBySymbol(symbol, params) {
+        const watchlistId = params.watchlistId ?? this.getDefaultWatchlist().id;
+        const existing = this.db
+            .prepare(`SELECT wi.*
+         FROM watchlist_items wi
+         JOIN instruments i ON i.id = wi.instrument_id
+         WHERE wi.watchlist_id = ? AND i.symbol = ?
+         LIMIT 1`)
+            .get(watchlistId, symbol.trim().toUpperCase());
+        if (existing == null)
+            return null;
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`UPDATE watchlist_items
+         SET target_price = ?, stop_price = ?, price_currency = ?, thesis = ?,
+             notes = ?, tags_json = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(params.targetPrice === undefined ? existing.target_price : params.targetPrice, params.stopPrice === undefined ? existing.stop_price : params.stopPrice, params.priceCurrency === undefined ? existing.price_currency : params.priceCurrency, params.thesis === undefined ? existing.thesis : params.thesis, params.notes === undefined ? existing.notes : params.notes, params.tags == null ? existing.tags_json : JSON.stringify(params.tags), now, existing.id);
+        return this.getWatchlistItem(existing.id);
+    }
+    addPortfolioLot(params) {
+        assertPositiveFinitePortfolioLotNumber(params.quantity, "quantity");
+        assertPositiveFinitePortfolioLotNumber(params.avgCost, "average cost");
+        const tx = this.db.transaction(() => {
+            const portfolioId = params.portfolioId ?? this.getDefaultPortfolio().id;
+            const instrument = this.upsertInstrument(params.instrument);
+            const now = new Date().toISOString();
+            const result = this.db
+                .prepare(`INSERT INTO portfolio_lots (
+             portfolio_id, instrument_id, quantity, avg_cost, currency,
+             opened_at, notes, source, source_account_ref, source_lot_id,
+             source_row_id, source_metadata_json, created_at, updated_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(portfolioId, instrument.id, params.quantity, params.avgCost, params.currency.toUpperCase(), params.openedAt ?? now, params.notes ?? null, normalizeNullable(params.source), normalizeNullable(params.sourceAccountRef), normalizeNullable(params.sourceLotId), normalizeNullable(params.sourceRowId), params.sourceMetadata == null ? null : JSON.stringify(params.sourceMetadata), now, now);
+            return Number(result.lastInsertRowid);
+        });
+        return this.getPortfolioLot(tx());
+    }
+    listPortfolioLots(portfolioId = this.getDefaultPortfolio().id) {
+        const rows = this.db
+            .prepare(`SELECT pl.*, i.symbol, i.name, i.asset_type, i.exchange, i.currency AS instrument_currency
+         FROM portfolio_lots pl
+         JOIN instruments i ON i.id = pl.instrument_id
+         WHERE pl.portfolio_id = ?
+         ORDER BY pl.id`)
+            .all(portfolioId);
+        return rows.map(mapPortfolioLot);
+    }
+    removePortfolioLotsBySymbol(symbol, portfolioId = this.getDefaultPortfolio().id) {
+        const result = this.db
+            .prepare(`DELETE FROM portfolio_lots
+         WHERE portfolio_id = ?
+           AND instrument_id IN (SELECT id FROM instruments WHERE symbol = ?)`)
+            .run(portfolioId, symbol.trim().toUpperCase());
+        return result.changes > 0;
+    }
+    removePortfolioLot(id) {
+        const existing = this.getPortfolioLotOrNull(id);
+        if (existing == null)
+            return null;
+        this.db.prepare("DELETE FROM portfolio_lots WHERE id = ?").run(id);
+        return existing;
+    }
+    updatePortfolioLot(id, params) {
+        if (params.quantity != null) {
+            assertPositiveFinitePortfolioLotNumber(params.quantity, "quantity");
+        }
+        if (params.avgCost != null) {
+            assertPositiveFinitePortfolioLotNumber(params.avgCost, "average cost");
+        }
+        const existing = this.db.prepare("SELECT * FROM portfolio_lots WHERE id = ?").get(id);
+        if (existing == null)
+            return null;
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`UPDATE portfolio_lots
+         SET quantity = ?, avg_cost = ?, currency = ?, opened_at = ?, notes = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(params.quantity ?? existing.quantity, params.avgCost ?? existing.avg_cost, params.currency == null ? existing.currency : params.currency.toUpperCase(), params.openedAt ?? existing.opened_at, params.notes ?? existing.notes, now, id);
+        return this.getPortfolioLot(id);
+    }
+    updatePortfolioLotsBySymbol(symbol, params) {
+        const portfolioId = params.portfolioId ?? this.getDefaultPortfolio().id;
+        const rows = this.db
+            .prepare(`SELECT pl.*
+         FROM portfolio_lots pl
+         JOIN instruments i ON i.id = pl.instrument_id
+         WHERE pl.portfolio_id = ? AND i.symbol = ?
+         ORDER BY pl.id`)
+            .all(portfolioId, symbol.trim().toUpperCase());
+        return rows.flatMap((row) => {
+            const updated = this.updatePortfolioLot(row.id, params);
+            return updated == null ? [] : [updated];
+        });
+    }
+    recordPrediction(params) {
+        const tx = this.db.transaction(() => {
+            const instrument = this.upsertInstrument(params.instrument);
+            const opened = params.now ?? new Date();
+            const expires = new Date(opened);
+            expires.setDate(expires.getDate() + params.timeframeDays);
+            const nowIso = opened.toISOString();
+            const result = this.db
+                .prepare(`INSERT INTO prediction_records (
+             instrument_id, direction, conviction, entry_price, target_price,
+             opened_at, expires_at, status, created_at, updated_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`)
+                .run(instrument.id, params.direction, params.conviction, params.entryPrice, params.targetPrice ?? null, nowIso, expires.toISOString(), nowIso, nowIso);
+            return Number(result.lastInsertRowid);
+        });
+        return this.getPrediction(tx());
+    }
+    listPredictions() {
+        const rows = this.db
+            .prepare(`SELECT pr.*, i.symbol
+         FROM prediction_records pr
+         JOIN instruments i ON i.id = pr.instrument_id
+         ORDER BY pr.opened_at, pr.id`)
+            .all();
+        return rows.map(mapPrediction);
+    }
+    updatePredictionOutcome(params) {
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`UPDATE prediction_records
+         SET status = ?, resolved_at = ?, result_json = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(params.status, params.resolvedAt, JSON.stringify(params.result), now, params.id);
+        return this.getPrediction(params.id);
+    }
+    createAlertRule(params) {
+        const now = new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO alert_rules (
+           scope_type, scope_id, instrument_id, condition_type, condition_version,
+           condition_json, timeframe, enabled, check_interval_seconds, next_check_at,
+           retrigger_mode, cooldown_seconds, created_at, updated_at
+         )
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(params.scopeType, params.scopeId ?? null, params.instrumentId ?? null, params.conditionType, params.conditionVersion, JSON.stringify(params.condition), params.timeframe, params.enabled === false ? 0 : 1, params.checkIntervalSeconds ?? null, params.nextCheckAt ?? null, params.retriggerMode ?? "recurring", params.cooldownSeconds ?? null, now, now);
+        return this.getAlertRule(Number(result.lastInsertRowid));
+    }
+    listAlertRules() {
+        const rows = this.db
+            .prepare("SELECT * FROM alert_rules ORDER BY created_at, id")
+            .all();
+        return rows.map(mapAlertRule);
+    }
+    setAlertRuleEnabled(id, enabled) {
+        const now = new Date().toISOString();
+        const result = this.db
+            .prepare(`UPDATE alert_rules
+         SET enabled = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(enabled ? 1 : 0, now, id);
+        if (result.changes === 0)
+            return null;
+        return this.getAlertRule(id);
+    }
+    getInstrument(id) {
+        const row = this.db.prepare("SELECT * FROM instruments WHERE id = ?").get(id);
+        return row == null ? null : mapInstrument(row);
+    }
+    upsertInstrumentRecord(input) {
+        return mapInstrument(this.upsertInstrument(input));
+    }
+    acquireAutomationRunnerLease(params) {
+        const now = params.now ?? new Date().toISOString();
+        const nowMs = new Date(now).getTime();
+        const expiresAt = new Date(nowMs + params.ttlSeconds * 1000).toISOString();
+        const tx = this.db.transaction(() => {
+            const current = this.db
+                .prepare("SELECT owner_id, owner_kind, acquired_at, heartbeat_at, expires_at FROM automation_runner_leases WHERE id = 1")
+                .get();
+            if (current != null &&
+                current.owner_id !== params.ownerId &&
+                new Date(current.expires_at).getTime() > nowMs) {
+                return { acquired: false, ...mapAutomationRunnerLease(current) };
+            }
+            this.db
+                .prepare(`INSERT INTO automation_runner_leases (
+             id, owner_id, owner_kind, acquired_at, heartbeat_at, expires_at
+           )
+           VALUES (1, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             owner_id = excluded.owner_id,
+             owner_kind = excluded.owner_kind,
+             acquired_at = excluded.acquired_at,
+             heartbeat_at = excluded.heartbeat_at,
+             expires_at = excluded.expires_at`)
+                .run(params.ownerId, params.ownerKind, now, now, expiresAt);
+            return {
+                acquired: true,
+                ownerId: params.ownerId,
+                ownerKind: params.ownerKind,
+                acquiredAt: now,
+                heartbeatAt: now,
+                expiresAt,
+            };
+        });
+        return tx();
+    }
+    getAutomationRunnerLease(now = new Date().toISOString()) {
+        const row = this.db
+            .prepare("SELECT owner_id, owner_kind, acquired_at, heartbeat_at, expires_at FROM automation_runner_leases WHERE id = 1")
+            .get();
+        if (row == null)
+            return null;
+        if (new Date(row.expires_at).getTime() <= new Date(now).getTime())
+            return null;
+        return mapAutomationRunnerLease(row);
+    }
+    releaseAutomationRunnerLease(ownerId) {
+        const result = this.db
+            .prepare("DELETE FROM automation_runner_leases WHERE id = 1 AND owner_id = ?")
+            .run(ownerId);
+        return result.changes > 0;
+    }
+    startAlertCheckRun(params) {
+        const startedAt = params.startedAt ?? new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO alert_check_runs (
+           started_at, status, trigger_type, owner_id
+         )
+         VALUES (?, 'running', ?, ?)`)
+            .run(startedAt, params.triggerType, params.ownerId ?? null);
+        return this.getAlertCheckRun(Number(result.lastInsertRowid));
+    }
+    completeAlertCheckRun(id, params) {
+        const completedAt = params.completedAt ?? new Date().toISOString();
+        this.db
+            .prepare(`UPDATE alert_check_runs
+         SET completed_at = ?,
+             status = ?,
+             checked_count = ?,
+             triggered_count = ?,
+             unavailable_count = ?,
+             error_json = ?,
+             provider_status_json = ?
+         WHERE id = ?`)
+            .run(completedAt, params.status, params.checkedCount, params.triggeredCount, params.unavailableCount, params.error == null ? null : JSON.stringify(params.error), params.providerStatus == null ? null : JSON.stringify(params.providerStatus), id);
+        return this.getAlertCheckRun(id);
+    }
+    getAlertCheckRun(id) {
+        const row = this.db.prepare("SELECT * FROM alert_check_runs WHERE id = ?").get(id);
+        if (row == null)
+            throw new Error(`alert check run ${id} not found`);
+        return mapAlertCheckRun(row);
+    }
+    listAlertCheckRuns() {
+        const rows = this.db
+            .prepare("SELECT * FROM alert_check_runs ORDER BY started_at DESC, id DESC")
+            .all();
+        return rows.map(mapAlertCheckRun);
+    }
+    markStaleAutomationRunsLost(params) {
+        const now = params.now ?? new Date().toISOString();
+        const cutoff = new Date(new Date(now).getTime() - params.graceSeconds * 1000).toISOString();
+        const tx = this.db.transaction(() => {
+            const alertResult = this.db
+                .prepare(`UPDATE alert_check_runs
+           SET status = 'lost',
+               completed_at = COALESCE(completed_at, ?),
+               error_json = COALESCE(error_json, ?)
+           WHERE status = 'running' AND started_at < ?`)
+                .run(now, JSON.stringify({ message: "runner lease expired before completion" }), cutoff);
+            const reportResult = this.db
+                .prepare(`UPDATE report_runs
+           SET status = 'lost',
+               completed_at = COALESCE(completed_at, ?),
+               errors_json = COALESCE(errors_json, ?)
+           WHERE status = 'running' AND started_at < ?`)
+                .run(now, JSON.stringify(["runner lease expired before completion"]), cutoff);
+            return {
+                alertCheckRuns: alertResult.changes,
+                reportRuns: reportResult.changes,
+            };
+        });
+        return tx();
+    }
+    recordNotificationEvent(params) {
+        const createdAt = params.createdAt ?? new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO notification_events (
+           source_type, source_id, severity, title, body, payload_json, status, created_at
+         )
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(params.sourceType, params.sourceId ?? null, params.severity, params.title, params.body, params.payload == null ? null : JSON.stringify(params.payload), params.status ?? "unread", createdAt);
+        return this.getNotificationEvent(Number(result.lastInsertRowid));
+    }
+    listNotificationEvents() {
+        const rows = this.db
+            .prepare("SELECT * FROM notification_events ORDER BY created_at DESC, id DESC")
+            .all();
+        return rows.map(mapNotificationEvent);
+    }
+    getNotificationEvent(id) {
+        const row = this.db.prepare("SELECT * FROM notification_events WHERE id = ?").get(id);
+        if (row == null)
+            throw new Error(`notification event ${id} not found`);
+        return mapNotificationEvent(row);
+    }
+    acknowledgeNotificationEvent(id, acknowledgedAt = new Date().toISOString()) {
+        this.db
+            .prepare(`UPDATE notification_events
+         SET status = 'acknowledged',
+             acknowledged_at = ?
+         WHERE id = ?`)
+            .run(acknowledgedAt, id);
+        return this.getNotificationEvent(id);
+    }
+    recordNotificationDeliveryAttempt(params) {
+        const attemptedAt = params.attemptedAt ?? new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO notification_delivery_attempts (
+           notification_event_id, channel, status, attempted_at, completed_at,
+           response_json, error
+         )
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(params.notificationEventId, params.channel, params.status, attemptedAt, params.completedAt ?? null, params.response == null ? null : JSON.stringify(params.response), params.error ?? null);
+        return this.getNotificationDeliveryAttempt(Number(result.lastInsertRowid));
+    }
+    listNotificationDeliveryAttempts(notificationEventId) {
+        const rows = notificationEventId == null
+            ? this.db
+                .prepare("SELECT * FROM notification_delivery_attempts ORDER BY attempted_at DESC, id DESC")
+                .all()
+            : this.db
+                .prepare("SELECT * FROM notification_delivery_attempts WHERE notification_event_id = ? ORDER BY attempted_at DESC, id DESC")
+                .all(notificationEventId);
+        return rows.map(mapNotificationDeliveryAttempt);
+    }
+    getNotificationDeliveryAttempt(id) {
+        const row = this.db
+            .prepare("SELECT * FROM notification_delivery_attempts WHERE id = ?")
+            .get(id);
+        if (row == null)
+            throw new Error(`notification delivery attempt ${id} not found`);
+        return mapNotificationDeliveryAttempt(row);
+    }
+    updateAlertObservation(params) {
+        const checkedAt = params.checkedAt ?? new Date().toISOString();
+        this.db
+            .prepare(`UPDATE alert_rules
+         SET last_checked_at = ?,
+             last_observed_json = ?,
+             last_triggered_at = COALESCE(?, last_triggered_at),
+             updated_at = ?
+         WHERE id = ?`)
+            .run(checkedAt, JSON.stringify(params.observed), params.triggeredAt ?? null, checkedAt, params.ruleId);
+        return this.getAlertRule(params.ruleId);
+    }
+    recordAlertEvent(params) {
+        const triggeredAt = params.triggeredAt ?? new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO alert_events (
+           alert_rule_id, instrument_id, observed_value_json, triggered_at, status, message
+         )
+         VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(params.alertRuleId, params.instrumentId ?? null, JSON.stringify(params.observedValue), triggeredAt, params.status, params.message);
+        return this.getAlertEvent(Number(result.lastInsertRowid));
+    }
+    recordAlertCheckResult(params) {
+        const tx = this.db.transaction(() => {
+            const row = this.db.prepare("SELECT * FROM alert_rules WHERE id = ?").get(params.ruleId);
+            if (row == null) {
+                throw new Error(`alert rule ${params.ruleId} not found`);
+            }
+            const currentPrevious = lastObservedValueFromJson(row.last_observed_json);
+            const currentLastTriggeredAt = row.last_triggered_at ?? null;
+            const canTrigger = params.trigger != null &&
+                currentPrevious === params.trigger.expectedPreviousValue &&
+                currentLastTriggeredAt === params.trigger.expectedLastTriggeredAt;
+            if (canTrigger && params.trigger) {
+                this.db
+                    .prepare(`INSERT INTO alert_events (
+               alert_rule_id, instrument_id, observed_value_json, triggered_at, status, message
+             )
+             VALUES (?, ?, ?, ?, 'triggered', ?)`)
+                    .run(params.ruleId, params.trigger.instrumentId, JSON.stringify(params.observed), params.trigger.triggeredAt, params.trigger.message);
+            }
+            this.db
+                .prepare(`UPDATE alert_rules
+           SET last_checked_at = ?,
+               last_observed_json = ?,
+               last_triggered_at = COALESCE(?, last_triggered_at),
+               updated_at = ?
+           WHERE id = ?`)
+                .run(params.checkedAt, JSON.stringify(params.observed), canTrigger && params.trigger ? params.trigger.triggeredAt : null, params.checkedAt, params.ruleId);
+            return canTrigger;
+        });
+        const triggered = tx();
+        return { triggered, rule: this.getAlertRule(params.ruleId) };
+    }
+    recordAlertEvaluationResult(params) {
+        const tx = this.db.transaction(() => {
+            const row = this.db.prepare("SELECT * FROM alert_rules WHERE id = ?").get(params.ruleId);
+            if (row == null) {
+                throw new Error(`alert rule ${params.ruleId} not found`);
+            }
+            const rearmed = params.conditionState === "false" && row.last_condition_state === "true";
+            const nextArmCycleId = rearmed ? row.arm_cycle_id + 1 : row.arm_cycle_id;
+            let eventId = null;
+            const canInsertTrigger = params.trigger != null &&
+                row.enabled === 1 &&
+                row.status === "active" &&
+                row.last_condition_state !== "true";
+            if (params.trigger != null && canInsertTrigger) {
+                const result = this.db
+                    .prepare(`INSERT OR IGNORE INTO alert_events (
+               alert_rule_id, instrument_id, observed_value_json, triggered_at,
+               observed_at, provider_data_at, source_provider, cache_status,
+               data_delay_ms, trigger_source, dedupe_key, status, message
+             )
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(params.ruleId, params.trigger.instrumentId, JSON.stringify(params.observed), params.trigger.triggeredAt, params.trigger.observedAt, params.trigger.providerDataAt ?? null, params.trigger.sourceProvider ?? null, params.trigger.cacheStatus ?? "live", params.trigger.dataDelayMs ?? null, params.trigger.triggerSource, params.trigger.dedupeKey, params.trigger.status ?? "triggered", params.trigger.message);
+                if (result.changes > 0) {
+                    eventId = Number(result.lastInsertRowid);
+                    this.db
+                        .prepare(`INSERT INTO notification_events (
+                 source_type, source_id, severity, title, body, payload_json, status, created_at
+               )
+               VALUES ('alert_event', ?, 'warning', ?, ?, ?, 'unread', ?)`)
+                        .run(eventId, params.trigger.title ?? "Alert triggered", params.trigger.message, JSON.stringify({
+                        ruleId: params.ruleId,
+                        observed: params.observed,
+                        sourceProvider: params.trigger.sourceProvider ?? null,
+                        providerDataAt: params.trigger.providerDataAt ?? null,
+                        cacheStatus: params.trigger.cacheStatus ?? "live",
+                        dataDelayMs: params.trigger.dataDelayMs ?? null,
+                    }), params.trigger.observedAt);
+                }
+            }
+            const triggered = eventId != null;
+            const completeOneShot = triggered && row.retrigger_mode === "once";
+            this.db
+                .prepare(`UPDATE alert_rules
+           SET last_checked_at = ?,
+               last_observed_json = ?,
+               last_condition_state = ?,
+               arm_cycle_id = ?,
+               next_check_at = ?,
+               last_triggered_at = COALESCE(?, last_triggered_at),
+               enabled = CASE WHEN ? THEN 0 ELSE enabled END,
+               status = CASE WHEN ? THEN 'completed' ELSE status END,
+               updated_at = ?
+           WHERE id = ?`)
+                .run(params.checkedAt, JSON.stringify(params.observed), params.conditionState, nextArmCycleId, nextAlertCheckAt(row, params.checkedAt), triggered && params.trigger ? params.trigger.triggeredAt : null, completeOneShot ? 1 : 0, completeOneShot ? 1 : 0, params.checkedAt, params.ruleId);
+            return { triggered, eventId };
+        });
+        const result = tx();
+        return {
+            triggered: result.triggered,
+            event: result.eventId == null ? null : this.getAlertEvent(result.eventId),
+            rule: this.getAlertRule(params.ruleId),
+        };
+    }
+    recordAlertUnavailable(params) {
+        const tx = this.db.transaction(() => {
+            const row = this.db.prepare("SELECT * FROM alert_rules WHERE id = ?").get(params.ruleId);
+            if (row == null) {
+                throw new Error(`alert rule ${params.ruleId} not found`);
+            }
+            const result = this.db
+                .prepare(`INSERT INTO alert_events (
+             alert_rule_id, instrument_id, observed_value_json, triggered_at, status, message
+           )
+           VALUES (?, ?, ?, ?, 'unavailable', ?)`)
+                .run(params.ruleId, params.instrumentId ?? null, JSON.stringify({ status: "unavailable", reason: params.reason, at: params.checkedAt }), params.checkedAt, `Alert unavailable: ${params.reason}`);
+            this.db
+                .prepare(`UPDATE alert_rules
+           SET last_checked_at = ?,
+               next_check_at = ?,
+               updated_at = ?
+           WHERE id = ?`)
+                .run(params.checkedAt, nextAlertCheckAt(row, params.checkedAt), params.checkedAt, params.ruleId);
+            return Number(result.lastInsertRowid);
+        });
+        const eventId = tx();
+        return { event: this.getAlertEvent(eventId), rule: this.getAlertRule(params.ruleId) };
+    }
+    listAlertEvents() {
+        const rows = this.db
+            .prepare("SELECT * FROM alert_events ORDER BY triggered_at, id")
+            .all();
+        return rows.map(mapAlertEvent);
+    }
+    createReportTemplate(params) {
+        const now = new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO report_templates (
+           name, report_type, cadence, timezone, local_time, config_json,
+           enabled, next_run_at, created_at, updated_at
+         )
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(params.name, params.reportType, params.cadence, params.timezone, params.localTime, JSON.stringify(params.config), params.enabled === false ? 0 : 1, params.nextRunAt ?? null, now, now);
+        return this.getReportTemplate(Number(result.lastInsertRowid));
+    }
+    updateReportTemplate(id, params) {
+        const existing = this.getReportTemplate(id);
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`UPDATE report_templates
+         SET name = ?, report_type = ?, cadence = ?, timezone = ?, local_time = ?,
+             config_json = ?, enabled = ?, next_run_at = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(params.name ?? existing.name, params.reportType ?? existing.reportType, params.cadence ?? existing.cadence, params.timezone ?? existing.timezone, params.localTime ?? existing.localTime, JSON.stringify(params.config ?? existing.configJson), params.enabled == null ? (existing.enabled ? 1 : 0) : params.enabled ? 1 : 0, params.nextRunAt === undefined ? existing.nextRunAt : params.nextRunAt, now, id);
+        return this.getReportTemplate(id);
+    }
+    claimDueReportTemplateRun(id, params) {
+        const result = this.db
+            .prepare(`UPDATE report_templates
+         SET next_run_at = ?, updated_at = ?
+         WHERE id = ? AND enabled = 1 AND next_run_at = ?`)
+            .run(params.nextRunAt, params.claimedAt ?? new Date().toISOString(), id, params.scheduledFor);
+        return result.changes === 0 ? null : this.getReportTemplate(id);
+    }
+    listReportTemplates() {
+        const rows = this.db
+            .prepare("SELECT * FROM report_templates ORDER BY created_at, id")
+            .all();
+        return rows.map(mapReportTemplate);
+    }
+    recordReportRun(params) {
+        const startedAt = params.startedAt ?? new Date().toISOString();
+        const tx = this.db.transaction(() => {
+            const result = this.db
+                .prepare(`INSERT INTO report_runs (
+             template_id, started_at, completed_at, status, trigger_type, scheduled_for,
+             owner_id, artifact_path, summary_json, errors_json
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(params.templateId ?? null, startedAt, params.completedAt ?? null, params.status, params.triggerType ?? "manual", params.scheduledFor ?? null, params.ownerId ?? null, params.artifactPath ?? null, params.summary == null ? null : JSON.stringify(params.summary), params.errors == null ? null : JSON.stringify(params.errors));
+            if (params.templateId != null) {
+                this.db
+                    .prepare("UPDATE report_templates SET last_run_at = ?, updated_at = ? WHERE id = ?")
+                    .run(startedAt, startedAt, params.templateId);
+            }
+            return Number(result.lastInsertRowid);
+        });
+        return this.getReportRun(tx());
+    }
+    listReportRuns() {
+        const rows = this.db
+            .prepare("SELECT * FROM report_runs ORDER BY started_at DESC, id DESC")
+            .all();
+        return rows.map(mapReportRun);
+    }
+    recordImportBatch(params) {
+        const importedAt = params.importedAt ?? new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO import_batches (
+           source, source_label, imported_at, status, raw_metadata_json
+         )
+         VALUES (?, ?, ?, ?, ?)`)
+            .run(normalizeNullable(params.source) ?? "unknown", normalizeNullable(params.sourceLabel), importedAt, params.status, params.rawMetadata == null ? null : JSON.stringify(params.rawMetadata));
+        return this.getImportBatch(Number(result.lastInsertRowid));
+    }
+    recordImportRow(params) {
+        const result = this.db
+            .prepare(`INSERT INTO import_rows (
+           batch_id, row_type, source_symbol, source_row_id, source_account_ref,
+           normalized_instrument_id, status, error, source_metadata_json, raw_json
+         )
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(params.batchId, params.rowType, normalizeNullable(params.sourceSymbol), normalizeNullable(params.sourceRowId), normalizeNullable(params.sourceAccountRef), params.normalizedInstrumentId ?? null, params.status, normalizeNullable(params.error), params.sourceMetadata == null ? null : JSON.stringify(params.sourceMetadata), params.raw == null ? null : JSON.stringify(params.raw));
+        return this.getImportRow(Number(result.lastInsertRowid));
+    }
+    upsertInstrument(input) {
+        const symbol = input.symbol.trim().toUpperCase();
+        const assetType = input.assetType.trim().toLowerCase();
+        const provider = input.provider.trim().toLowerCase();
+        const exchange = normalizeNullable(input.exchange);
+        const now = new Date().toISOString();
+        const resolvedAt = (input.resolvedAt ?? new Date()).toISOString();
+        const existing = this.db
+            .prepare(`SELECT * FROM instruments
+         WHERE provider = ?
+           AND symbol = ?
+           AND asset_type = ?
+           AND IFNULL(exchange, '') = IFNULL(?, '')`)
+            .get(provider, symbol, assetType, exchange);
+        if (existing) {
+            this.db
+                .prepare(`UPDATE instruments
+           SET name = ?, currency = ?, provider_metadata_json = ?,
+               last_resolved_at = ?, updated_at = ?
+           WHERE id = ?`)
+                .run(normalizeNullable(input.name), normalizeNullable(input.currency)?.toUpperCase() ?? null, input.providerMetadata == null ? null : JSON.stringify(input.providerMetadata), resolvedAt, now, existing.id);
+            this.upsertInstrumentAliases(existing.id, input.aliases ?? []);
+            return this.db
+                .prepare("SELECT * FROM instruments WHERE id = ?")
+                .get(existing.id);
+        }
+        const result = this.db
+            .prepare(`INSERT INTO instruments (
+           symbol, asset_type, name, exchange, currency, provider,
+           provider_metadata_json, last_resolved_at, created_at, updated_at
+         )
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(symbol, assetType, normalizeNullable(input.name), exchange, normalizeNullable(input.currency)?.toUpperCase() ?? null, provider, input.providerMetadata == null ? null : JSON.stringify(input.providerMetadata), resolvedAt, now, now);
+        const instrumentId = Number(result.lastInsertRowid);
+        this.upsertInstrumentAliases(instrumentId, input.aliases ?? []);
+        return this.db
+            .prepare("SELECT * FROM instruments WHERE id = ?")
+            .get(instrumentId);
+    }
+    upsertInstrumentAliases(instrumentId, aliases) {
+        if (aliases.length === 0)
+            return;
+        const now = new Date().toISOString();
+        for (const alias of aliases) {
+            const source = normalizeSource(alias.source);
+            const sourceSymbol = normalizeSourceSymbol(alias.sourceSymbol);
+            const sourceExchange = normalizeExchange(alias.sourceExchange);
+            const sourceAssetType = normalizeAssetType(alias.sourceAssetType);
+            const sourceId = normalizeNullable(alias.sourceId);
+            const rawJson = alias.raw == null ? null : JSON.stringify(alias.raw);
+            const existing = sourceId == null
+                ? this.db
+                    .prepare(`SELECT id, instrument_id FROM instrument_aliases
+             WHERE source = ?
+               AND source_symbol = ?
+               AND IFNULL(source_exchange, '') = IFNULL(?, '')
+               AND IFNULL(source_asset_type, '') = IFNULL(?, '')
+             LIMIT 1`)
+                    .get(source, sourceSymbol, sourceExchange, sourceAssetType)
+                : this.db
+                    .prepare(`SELECT id, instrument_id FROM instrument_aliases
+             WHERE source = ? AND source_id = ?
+             LIMIT 1`)
+                    .get(source, sourceId);
+            if (existing) {
+                this.db
+                    .prepare(`UPDATE instrument_aliases
+             SET instrument_id = ?, source_symbol = ?, source_exchange = ?,
+                 source_asset_type = ?, source_id = ?, raw_json = ?, updated_at = ?
+             WHERE id = ?`)
+                    .run(instrumentId, sourceSymbol, sourceExchange, sourceAssetType, sourceId, rawJson, now, existing.id);
+                continue;
+            }
+            this.db
+                .prepare(`INSERT INTO instrument_aliases (
+             instrument_id, source, source_symbol, source_exchange,
+             source_asset_type, source_id, raw_json, created_at, updated_at
+           )
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(instrumentId, source, sourceSymbol, sourceExchange, sourceAssetType, sourceId, rawJson, now, now);
+        }
+    }
+    getWatchlistItem(id) {
+        const row = this.db
+            .prepare(`SELECT wi.*, i.symbol, i.name, i.asset_type, i.exchange, i.currency
+         FROM watchlist_items wi
+         JOIN instruments i ON i.id = wi.instrument_id
+         WHERE wi.id = ?`)
+            .get(id);
+        return mapWatchlistItem(row);
+    }
+    getPortfolioLot(id) {
+        const row = this.getPortfolioLotOrNull(id);
+        if (row == null) {
+            throw new Error(`portfolio lot ${id} not found`);
+        }
+        return row;
+    }
+    getPortfolioLotOrNull(id) {
+        const row = this.db
+            .prepare(`SELECT pl.*, i.symbol, i.name, i.asset_type, i.exchange, i.currency AS instrument_currency
+         FROM portfolio_lots pl
+         JOIN instruments i ON i.id = pl.instrument_id
+         WHERE pl.id = ?`)
+            .get(id);
+        return row == null ? null : mapPortfolioLot(row);
+    }
+    getPrediction(id) {
+        const row = this.db
+            .prepare(`SELECT pr.*, i.symbol
+         FROM prediction_records pr
+         JOIN instruments i ON i.id = pr.instrument_id
+         WHERE pr.id = ?`)
+            .get(id);
+        return mapPrediction(row);
+    }
+    getAlertRule(id) {
+        const row = this.db.prepare("SELECT * FROM alert_rules WHERE id = ?").get(id);
+        return mapAlertRule(row);
+    }
+    getAlertEvent(id) {
+        const row = this.db.prepare("SELECT * FROM alert_events WHERE id = ?").get(id);
+        return mapAlertEvent(row);
+    }
+    getReportTemplate(id) {
+        const row = this.db
+            .prepare("SELECT * FROM report_templates WHERE id = ?")
+            .get(id);
+        return mapReportTemplate(row);
+    }
+    getReportRun(id) {
+        const row = this.db.prepare("SELECT * FROM report_runs WHERE id = ?").get(id);
+        return mapReportRun(row);
+    }
+    getImportBatch(id) {
+        const row = this.db
+            .prepare("SELECT * FROM import_batches WHERE id = ?")
+            .get(id);
+        return mapImportBatch(row);
+    }
+    getImportRow(id) {
+        const row = this.db.prepare("SELECT * FROM import_rows WHERE id = ?").get(id);
+        return mapImportRow(row);
+    }
+}
+function mapCollection(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        isDefault: row.is_default === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapInstrument(row) {
+    return {
+        id: row.id,
+        symbol: row.symbol,
+        assetType: row.asset_type,
+        name: row.name,
+        exchange: row.exchange,
+        currency: row.currency,
+        provider: row.provider,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapWatchlistItem(row) {
+    return {
+        id: row.id,
+        watchlistId: row.watchlist_id,
+        instrumentId: row.instrument_id,
+        symbol: row.symbol,
+        name: row.name,
+        assetType: row.asset_type,
+        exchange: row.exchange,
+        currency: row.currency,
+        targetPrice: row.target_price,
+        stopPrice: row.stop_price,
+        priceCurrency: row.price_currency,
+        thesis: row.thesis,
+        notes: row.notes,
+        tags: row.tags_json == null ? null : JSON.parse(row.tags_json),
+        source: row.source,
+        sourceRowId: row.source_row_id,
+        sourceMetadata: row.source_metadata_json == null ? null : JSON.parse(row.source_metadata_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapPortfolioLot(row) {
+    return {
+        id: row.id,
+        portfolioId: row.portfolio_id,
+        instrumentId: row.instrument_id,
+        symbol: row.symbol,
+        name: row.name,
+        assetType: row.asset_type,
+        exchange: row.exchange,
+        instrumentCurrency: row.instrument_currency,
+        quantity: row.quantity,
+        avgCost: row.avg_cost,
+        currency: row.currency,
+        openedAt: row.opened_at,
+        notes: row.notes,
+        source: row.source,
+        sourceAccountRef: row.source_account_ref,
+        sourceLotId: row.source_lot_id,
+        sourceRowId: row.source_row_id,
+        sourceMetadata: row.source_metadata_json == null ? null : JSON.parse(row.source_metadata_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapPrediction(row) {
+    return {
+        id: row.id,
+        instrumentId: row.instrument_id,
+        symbol: row.symbol,
+        direction: row.direction,
+        conviction: row.conviction,
+        entryPrice: row.entry_price,
+        targetPrice: row.target_price,
+        openedAt: row.opened_at,
+        expiresAt: row.expires_at,
+        status: row.status,
+        resolvedAt: row.resolved_at,
+        resultJson: row.result_json,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapAlertRule(row) {
+    return {
+        id: row.id,
+        scopeType: row.scope_type,
+        scopeId: row.scope_id,
+        instrumentId: row.instrument_id,
+        conditionType: row.condition_type,
+        conditionVersion: row.condition_version,
+        conditionJson: JSON.parse(row.condition_json),
+        timeframe: row.timeframe,
+        enabled: row.enabled === 1,
+        checkIntervalSeconds: row.check_interval_seconds,
+        nextCheckAt: row.next_check_at,
+        lastCheckedAt: row.last_checked_at,
+        lastObservedJson: row.last_observed_json == null ? null : JSON.parse(row.last_observed_json),
+        status: row.status,
+        retriggerMode: row.retrigger_mode,
+        lastConditionState: row.last_condition_state,
+        ruleRevision: row.rule_revision,
+        armCycleId: row.arm_cycle_id,
+        cooldownSeconds: row.cooldown_seconds,
+        lastTriggeredAt: row.last_triggered_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapAlertEvent(row) {
+    return {
+        id: row.id,
+        alertRuleId: row.alert_rule_id,
+        instrumentId: row.instrument_id,
+        observedValueJson: row.observed_value_json == null ? null : JSON.parse(row.observed_value_json),
+        triggeredAt: row.triggered_at,
+        observedAt: row.observed_at,
+        providerDataAt: row.provider_data_at,
+        sourceProvider: row.source_provider,
+        cacheStatus: row.cache_status,
+        dataDelayMs: row.data_delay_ms,
+        triggerSource: row.trigger_source,
+        dedupeKey: row.dedupe_key,
+        status: row.status,
+        message: row.message,
+    };
+}
+function mapAutomationRunnerLease(row) {
+    return {
+        ownerId: row.owner_id,
+        ownerKind: row.owner_kind,
+        acquiredAt: row.acquired_at,
+        heartbeatAt: row.heartbeat_at,
+        expiresAt: row.expires_at,
+    };
+}
+function mapAlertCheckRun(row) {
+    return {
+        id: row.id,
+        startedAt: row.started_at,
+        completedAt: row.completed_at,
+        status: row.status,
+        triggerType: row.trigger_type,
+        checkedCount: row.checked_count,
+        triggeredCount: row.triggered_count,
+        unavailableCount: row.unavailable_count,
+        ownerId: row.owner_id,
+        errorJson: row.error_json == null ? null : JSON.parse(row.error_json),
+        providerStatusJson: row.provider_status_json == null ? null : JSON.parse(row.provider_status_json),
+    };
+}
+function mapNotificationEvent(row) {
+    return {
+        id: row.id,
+        sourceType: row.source_type,
+        sourceId: row.source_id,
+        severity: row.severity,
+        title: row.title,
+        body: row.body,
+        payloadJson: row.payload_json == null ? null : JSON.parse(row.payload_json),
+        status: row.status,
+        createdAt: row.created_at,
+        acknowledgedAt: row.acknowledged_at,
+    };
+}
+function mapNotificationDeliveryAttempt(row) {
+    return {
+        id: row.id,
+        notificationEventId: row.notification_event_id,
+        channel: row.channel,
+        status: row.status,
+        attemptedAt: row.attempted_at,
+        completedAt: row.completed_at,
+        responseJson: row.response_json == null ? null : JSON.parse(row.response_json),
+        error: row.error,
+    };
+}
+function nextAlertCheckAt(row, checkedAt) {
+    if (row.check_interval_seconds == null)
+        return null;
+    const checkedAtMs = new Date(checkedAt).getTime();
+    if (!Number.isFinite(checkedAtMs))
+        return null;
+    return new Date(checkedAtMs + row.check_interval_seconds * 1000).toISOString();
+}
+function mapReportTemplate(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        reportType: row.report_type,
+        cadence: row.cadence,
+        timezone: row.timezone,
+        localTime: row.local_time,
+        configJson: JSON.parse(row.config_json),
+        enabled: row.enabled === 1,
+        lastRunAt: row.last_run_at,
+        nextRunAt: row.next_run_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapReportRun(row) {
+    return {
+        id: row.id,
+        templateId: row.template_id,
+        startedAt: row.started_at,
+        completedAt: row.completed_at,
+        status: row.status,
+        triggerType: row.trigger_type,
+        scheduledFor: row.scheduled_for,
+        ownerId: row.owner_id,
+        artifactPath: row.artifact_path,
+        summaryJson: row.summary_json == null ? null : JSON.parse(row.summary_json),
+        errorsJson: row.errors_json == null ? null : JSON.parse(row.errors_json),
+    };
+}
+function mapImportBatch(row) {
+    return {
+        id: row.id,
+        source: row.source,
+        sourceLabel: row.source_label,
+        importedAt: row.imported_at,
+        status: row.status,
+        rawMetadata: row.raw_metadata_json == null ? null : JSON.parse(row.raw_metadata_json),
+    };
+}
+function mapImportRow(row) {
+    return {
+        id: row.id,
+        batchId: row.batch_id,
+        rowType: row.row_type,
+        sourceSymbol: row.source_symbol,
+        sourceRowId: row.source_row_id,
+        sourceAccountRef: row.source_account_ref,
+        normalizedInstrumentId: row.normalized_instrument_id,
+        status: row.status,
+        error: row.error,
+        sourceMetadata: row.source_metadata_json == null ? null : JSON.parse(row.source_metadata_json),
+        raw: row.raw_json == null ? null : JSON.parse(row.raw_json),
+    };
+}
+function normalizeNullable(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+}
+function assertPositiveFinitePortfolioLotNumber(value, label) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Portfolio lot ${label} must be a positive finite number.`);
+    }
+}
+function lastObservedValueFromJson(value) {
+    if (value == null)
+        return null;
+    const parsed = JSON.parse(value);
+    return typeof parsed?.value === "number" ? parsed.value : null;
+}
+function normalizeSource(value) {
+    return value.trim().toLowerCase();
+}
+function normalizeSourceSymbol(value) {
+    return value.trim().toUpperCase();
+}
+function normalizeExchange(value) {
+    return normalizeNullable(value)?.toUpperCase() ?? null;
+}
+function normalizeAssetType(value) {
+    return normalizeNullable(value)?.toLowerCase() ?? null;
+}
+//# sourceMappingURL=service.js.map