Fix search.ts to use normalizeTickerOrNull for optional ticker

Consolidate server utilities into shared module
- Add lib/server/utils/normalize.ts with normalizeTicker, normalizeTagsOrNull, nowIso, todayIso - Add lib/server/utils/validation.ts with asRecord, asBoolean, asStringArray, asEnum - Add lib/server/utils/index.ts re-exporting all utilities - Remove duplicate lib/server/utils.ts (old file) - Update all repos and files to use shared utilities - Remove redundant ?? '' from normalizeTicker calls - Update watchlist.ts to use normalizeTagsOrNull for null-return tags
2026-03-15 16:06:49 -04:00 · 2026-03-15 15:56:16 -04:00
18 changed files with 209 additions and 469 deletions
--- a/lib/server/prices.ts
+++ b/lib/server/prices.ts
@@ -1,3 +1,5 @@
+import { normalizeTicker } from '@/lib/server/utils';
+
 const YAHOO_BASE = 'https://query1.finance.yahoo.com/v8/finance/chart';
 const QUOTE_CACHE_TTL_MS = 1000 * 60;
 const PRICE_HISTORY_CACHE_TTL_MS = 1000 * 60 * 15;
@@ -27,11 +29,11 @@ const quoteCache = new Map<string, QuoteCacheEntry>();
 const priceHistoryCache = new Map<string, PriceHistoryCacheEntry>();

 function buildYahooChartUrl(ticker: string, params: string) {
-  return `${YAHOO_BASE}/${encodeURIComponent(ticker.trim().toUpperCase())}?${params}`;
+  return `${YAHOO_BASE}/${encodeURIComponent(normalizeTicker(ticker))}?${params}`;
 }

 export async function getQuote(ticker: string): Promise<QuoteResult> {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  const cached = quoteCache.get(normalizedTicker);

  if (cached && cached.expiresAt > Date.now()) {
@@ -101,7 +103,7 @@ export async function getQuoteOrNull(ticker: string): Promise<number | null> {
 }

 export async function getHistoricalClosingPrices(ticker: string, dates: string[]) {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  const normalizedDates = dates
    .map((value) => {
      const parsed = Date.parse(value);
@@ -169,7 +171,7 @@ export async function getHistoricalClosingPrices(ticker: string, dates: string[]
 }

 export async function getPriceHistory(ticker: string): Promise<PriceHistoryResult> {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  const cached = priceHistoryCache.get(normalizedTicker);

  if (cached && cached.expiresAt > Date.now()) {
--- a/lib/server/recent-developments.ts
+++ b/lib/server/recent-developments.ts
@@ -1,5 +1,6 @@
 import { format } from 'date-fns';
 import type { Filing, RecentDevelopmentItem, RecentDevelopments } from '@/lib/types';
+import { normalizeTicker } from '@/lib/server/utils';

 export type RecentDevelopmentSourceContext = {
  filings: Filing[];
@@ -115,9 +116,9 @@ export async function getRecentDevelopments(
    limit?: number;
  }
 ): Promise<RecentDevelopments> {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  const limit = options?.limit ?? 6;
-  const cacheKey = `${normalizedTicker}:${context.filings.map((filing) => filing.accession_number).join(',')}`;
+  const cacheKey = `${normalizedTicker ?? ''}:${context.filings.map((filing) => filing.accession_number).join(',')}`;
  const cached = recentDevelopmentsCache.get(cacheKey);

  if (cached && cached.expiresAt > Date.now()) {
@@ -128,7 +129,7 @@ export async function getRecentDevelopments(
  const itemCollections = await Promise.all(
    sources.map(async (source) => {
      try {
-        return await source.fetch(normalizedTicker, context);
+        return await source.fetch(normalizedTicker ?? '', context);
      } catch {
        return [] satisfies RecentDevelopmentItem[];
      }
--- a/lib/server/repos/filing-taxonomy.ts
+++ b/lib/server/repos/filing-taxonomy.ts
@@ -962,8 +962,10 @@ export async function upsertFilingTaxonomySnapshot(input: UpsertFilingTaxonomySn
  const now = new Date().toISOString();
  const normalized = normalizeFilingTaxonomySnapshotPayload(input);

-  return db.transaction(async (tx) => {
-    const [saved] = await tx
+  const [saved] = await withFinancialIngestionSchemaRetry({
+    client: getSqliteClient(),
+    context: 'filing-taxonomy-snapshot-upsert',
+    operation: async () => await db
      .insert(filingTaxonomySnapshot)
      .values({
        filing_id: input.filing_id,
@@ -1020,149 +1022,125 @@ export async function upsertFilingTaxonomySnapshot(input: UpsertFilingTaxonomySn
          updated_at: now
        }
      })
-      .returning();
-
-    const snapshotId = saved.id;
-
-    try {
-      await tx.delete(filingTaxonomyAsset).where(eq(filingTaxonomyAsset.snapshot_id, snapshotId));
-      await tx.delete(filingTaxonomyContext).where(eq(filingTaxonomyContext.snapshot_id, snapshotId));
-      await tx.delete(filingTaxonomyConcept).where(eq(filingTaxonomyConcept.snapshot_id, snapshotId));
-      await tx.delete(filingTaxonomyFact).where(eq(filingTaxonomyFact.snapshot_id, snapshotId));
-      await tx.delete(filingTaxonomyMetricValidation).where(eq(filingTaxonomyMetricValidation.snapshot_id, snapshotId));
-    } catch (error) {
-      throw new Error(`Failed to delete child records for snapshot ${snapshotId}: ${error}`);
-    }
-
-    if (input.contexts.length > 0) {
-      try {
-        await tx.insert(filingTaxonomyContext).values(input.contexts.map((context) => ({
-          snapshot_id: snapshotId,
-          context_id: context.context_id,
-          entity_identifier: context.entity_identifier,
-          entity_scheme: context.entity_scheme,
-          period_start: context.period_start,
-          period_end: context.period_end,
-          period_instant: context.period_instant,
-          segment_json: context.segment_json,
-          scenario_json: context.scenario_json,
-          created_at: now
-        })));
-      } catch (error) {
-        throw new Error(`Failed to insert ${input.contexts.length} contexts for snapshot ${snapshotId}: ${error}`);
-      }
-    }
-
-    if (input.assets.length > 0) {
-      try {
-        await tx.insert(filingTaxonomyAsset).values(input.assets.map((asset) => ({
-          snapshot_id: snapshotId,
-          asset_type: asset.asset_type,
-          name: asset.name,
-          url: asset.url,
-          size_bytes: asset.size_bytes,
-          score: asNumericText(asset.score),
-          is_selected: asset.is_selected,
-          created_at: now
-        })));
-      } catch (error) {
-        throw new Error(`Failed to insert ${input.assets.length} assets for snapshot ${snapshotId}: ${error}`);
-      }
-    }
-
-    if (input.concepts.length > 0) {
-      try {
-        await tx.insert(filingTaxonomyConcept).values(input.concepts.map((concept) => ({
-          snapshot_id: snapshotId,
-          concept_key: concept.concept_key,
-          qname: concept.qname,
-          namespace_uri: concept.namespace_uri,
-          local_name: concept.local_name,
-          label: concept.label,
-          is_extension: concept.is_extension,
-          balance: concept.balance,
-          period_type: concept.period_type,
-          data_type: concept.data_type,
-          statement_kind: concept.statement_kind,
-          role_uri: concept.role_uri,
-          authoritative_concept_key: concept.authoritative_concept_key,
-          mapping_method: concept.mapping_method,
-          surface_key: concept.surface_key,
-          detail_parent_surface_key: concept.detail_parent_surface_key,
-          kpi_key: concept.kpi_key,
-          residual_flag: concept.residual_flag,
-          presentation_order: asNumericText(concept.presentation_order),
-          presentation_depth: concept.presentation_depth,
-          parent_concept_key: concept.parent_concept_key,
-          is_abstract: concept.is_abstract,
-          created_at: now
-        })));
-      } catch (error) {
-        throw new Error(`Failed to insert ${input.concepts.length} concepts for snapshot ${snapshotId}: ${error}`);
-      }
-    }
-
-    if (input.facts.length > 0) {
-      try {
-        await tx.insert(filingTaxonomyFact).values(input.facts.map((fact) => ({
-          snapshot_id: snapshotId,
-          concept_key: fact.concept_key,
-          qname: fact.qname,
-          namespace_uri: fact.namespace_uri,
-          local_name: fact.local_name,
-          data_type: fact.data_type,
-          statement_kind: fact.statement_kind,
-          role_uri: fact.role_uri,
-          authoritative_concept_key: fact.authoritative_concept_key,
-          mapping_method: fact.mapping_method,
-          surface_key: fact.surface_key,
-          detail_parent_surface_key: fact.detail_parent_surface_key,
-          kpi_key: fact.kpi_key,
-          residual_flag: fact.residual_flag,
-          context_id: fact.context_id,
-          unit: fact.unit,
-          decimals: fact.decimals,
-          precision: fact.precision,
-          nil: fact.nil,
-          value_num: String(fact.value_num),
-          period_start: fact.period_start,
-          period_end: fact.period_end,
-          period_instant: fact.period_instant,
-          dimensions: fact.dimensions,
-          is_dimensionless: fact.is_dimensionless,
-          source_file: fact.source_file,
-          created_at: now
-        })));
-      } catch (error) {
-        throw new Error(`Failed to insert ${input.facts.length} facts for snapshot ${snapshotId}: ${error}`);
-      }
-    }
-
-    if (input.metric_validations.length > 0) {
-      try {
-        await tx.insert(filingTaxonomyMetricValidation).values(input.metric_validations.map((check) => ({
-          snapshot_id: snapshotId,
-          metric_key: check.metric_key,
-          taxonomy_value: asNumericText(check.taxonomy_value),
-          llm_value: asNumericText(check.llm_value),
-          absolute_diff: asNumericText(check.absolute_diff),
-          relative_diff: asNumericText(check.relative_diff),
-          status: check.status,
-          evidence_pages: check.evidence_pages,
-          pdf_url: check.pdf_url,
-          provider: check.provider,
-          model: check.model,
-          error: check.error,
-          created_at: now,
-          updated_at: now
-        })));
-      } catch (error) {
-        throw new Error(`Failed to insert ${input.metric_validations.length} metric validations for snapshot ${snapshotId}: ${error}`);
-      }
-    }
-
-    return toSnapshotRecord(saved);
+      .returning()
  });
+
+  const snapshotId = saved.id;
+
+  await db.delete(filingTaxonomyAsset).where(eq(filingTaxonomyAsset.snapshot_id, snapshotId));
+  await db.delete(filingTaxonomyContext).where(eq(filingTaxonomyContext.snapshot_id, snapshotId));
+  await db.delete(filingTaxonomyConcept).where(eq(filingTaxonomyConcept.snapshot_id, snapshotId));
+  await db.delete(filingTaxonomyFact).where(eq(filingTaxonomyFact.snapshot_id, snapshotId));
+  await db.delete(filingTaxonomyMetricValidation).where(eq(filingTaxonomyMetricValidation.snapshot_id, snapshotId));
+
+  if (input.contexts.length > 0) {
+    await db.insert(filingTaxonomyContext).values(input.contexts.map((context) => ({
+      snapshot_id: snapshotId,
+      context_id: context.context_id,
+      entity_identifier: context.entity_identifier,
+      entity_scheme: context.entity_scheme,
+      period_start: context.period_start,
+      period_end: context.period_end,
+      period_instant: context.period_instant,
+      segment_json: context.segment_json,
+      scenario_json: context.scenario_json,
+      created_at: now
+    })));
+  }
+
+  if (input.assets.length > 0) {
+    await db.insert(filingTaxonomyAsset).values(input.assets.map((asset) => ({
+      snapshot_id: snapshotId,
+      asset_type: asset.asset_type,
+      name: asset.name,
+      url: asset.url,
+      size_bytes: asset.size_bytes,
+      score: asNumericText(asset.score),
+      is_selected: asset.is_selected,
+      created_at: now
+    })));
+  }
+
+  if (input.concepts.length > 0) {
+    await db.insert(filingTaxonomyConcept).values(input.concepts.map((concept) => ({
+      snapshot_id: snapshotId,
+      concept_key: concept.concept_key,
+      qname: concept.qname,
+      namespace_uri: concept.namespace_uri,
+      local_name: concept.local_name,
+      label: concept.label,
+      is_extension: concept.is_extension,
+      balance: concept.balance,
+      period_type: concept.period_type,
+      data_type: concept.data_type,
+      statement_kind: concept.statement_kind,
+      role_uri: concept.role_uri,
+      authoritative_concept_key: concept.authoritative_concept_key,
+      mapping_method: concept.mapping_method,
+      surface_key: concept.surface_key,
+      detail_parent_surface_key: concept.detail_parent_surface_key,
+      kpi_key: concept.kpi_key,
+      residual_flag: concept.residual_flag,
+      presentation_order: asNumericText(concept.presentation_order),
+      presentation_depth: concept.presentation_depth,
+      parent_concept_key: concept.parent_concept_key,
+      is_abstract: concept.is_abstract,
+      created_at: now
+    })));
+  }
+
+  if (input.facts.length > 0) {
+    await db.insert(filingTaxonomyFact).values(input.facts.map((fact) => ({
+      snapshot_id: snapshotId,
+      concept_key: fact.concept_key,
+      qname: fact.qname,
+      namespace_uri: fact.namespace_uri,
+      local_name: fact.local_name,
+      data_type: fact.data_type,
+      statement_kind: fact.statement_kind,
+      role_uri: fact.role_uri,
+      authoritative_concept_key: fact.authoritative_concept_key,
+      mapping_method: fact.mapping_method,
+      surface_key: fact.surface_key,
+      detail_parent_surface_key: fact.detail_parent_surface_key,
+      kpi_key: fact.kpi_key,
+      residual_flag: fact.residual_flag,
+      context_id: fact.context_id,
+      unit: fact.unit,
+      decimals: fact.decimals,
+      precision: fact.precision,
+      nil: fact.nil,
+      value_num: String(fact.value_num),
+      period_start: fact.period_start,
+      period_end: fact.period_end,
+      period_instant: fact.period_instant,
+      dimensions: fact.dimensions,
+      is_dimensionless: fact.is_dimensionless,
+      source_file: fact.source_file,
+      created_at: now
+    })));
+  }
+
+  if (input.metric_validations.length > 0) {
+    await db.insert(filingTaxonomyMetricValidation).values(input.metric_validations.map((check) => ({
+      snapshot_id: snapshotId,
+      metric_key: check.metric_key,
+      taxonomy_value: asNumericText(check.taxonomy_value),
+      llm_value: asNumericText(check.llm_value),
+      absolute_diff: asNumericText(check.absolute_diff),
+      relative_diff: asNumericText(check.relative_diff),
+      status: check.status,
+      evidence_pages: check.evidence_pages,
+      pdf_url: check.pdf_url,
+      provider: check.provider,
+      model: check.model,
+      error: check.error,
+      created_at: now,
+      updated_at: now
+    })));
+  }
+
+  return toSnapshotRecord(saved);
 }

 export async function listFilingTaxonomySnapshotsByTicker(input: {
--- a/lib/server/repos/filings.ts
+++ b/lib/server/repos/filings.ts
@@ -2,6 +2,7 @@ import { desc, eq, inArray, max } from 'drizzle-orm';
 import type { Filing } from '@/lib/types';
 import { db } from '@/lib/server/db';
 import { filing, filingLink } from '@/lib/server/db/schema';
+import { normalizeTicker, nowIso } from '@/lib/server/utils';

 type FilingRow = typeof filing.$inferSelect;

@@ -90,7 +91,7 @@ export async function getFilingByAccession(accessionNumber: string) {
 export async function listLatestFilingDatesByTickers(tickers: string[]) {
  const normalizedTickers = [...new Set(
    tickers
-      .map((ticker) => ticker.trim().toUpperCase())
+      .map((ticker) => normalizeTicker(ticker))
      .filter((ticker) => ticker.length > 0)
  )];

@@ -121,7 +122,7 @@ export async function upsertFilingsRecords(items: UpsertFilingInput[]) {
  let updated = 0;

  for (const item of items) {
-    const now = new Date().toISOString();
+    const now = nowIso();

    const existing = await getFilingByAccession(item.accession_number);

@@ -192,7 +193,7 @@ export async function saveFilingAnalysis(
    .update(filing)
    .set({
      analysis,
-      updated_at: new Date().toISOString()
+      updated_at: nowIso()
    })
    .where(eq(filing.accession_number, accessionNumber))
    .returning();
@@ -208,7 +209,7 @@ export async function updateFilingMetricsById(
    .update(filing)
    .set({
      metrics,
-      updated_at: new Date().toISOString()
+      updated_at: nowIso()
    })
    .where(eq(filing.id, filingId))
    .returning();
--- a/lib/server/repos/holdings.ts
+++ b/lib/server/repos/holdings.ts
@@ -3,6 +3,7 @@ import type { Holding } from '@/lib/types';
 import { recalculateHolding } from '@/lib/server/portfolio';
 import { db } from '@/lib/server/db';
 import { filing, holding, watchlistItem } from '@/lib/server/db/schema';
+import { normalizeTicker, nowIso } from '@/lib/server/utils';

 type HoldingRow = typeof holding.$inferSelect;

@@ -30,7 +31,7 @@ function sortByMarketValueDesc(rows: Holding[]) {

 function normalizeHoldingInput(input: { ticker: string; shares: number; avgCost: number; currentPrice: number }) {
  return {
-    ticker: input.ticker.trim().toUpperCase(),
+    ticker: normalizeTicker(input.ticker),
    shares: input.shares.toFixed(6),
    avg_cost: input.avgCost.toFixed(6),
    current_price: input.currentPrice.toFixed(6)
@@ -82,7 +83,7 @@ export async function listUserHoldings(userId: string) {
 }

 export async function getHoldingByTicker(userId: string, ticker: string) {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  if (!normalizedTicker) {
    return null;
  }
@@ -104,8 +105,8 @@ export async function upsertHoldingRecord(input: {
  currentPrice?: number;
  companyName?: string;
 }) {
-  const ticker = input.ticker.trim().toUpperCase();
-  const now = new Date().toISOString();
+  const ticker = normalizeTicker(input.ticker);
+  const now = nowIso();

  const [existing] = await db
    .select()
@@ -251,8 +252,8 @@ export async function updateHoldingByIdRecord(input: {
    shares: shares.toFixed(6),
    avg_cost: avgCost.toFixed(6),
    current_price: currentPrice.toFixed(6),
-    updated_at: new Date().toISOString(),
-    last_price_at: new Date().toISOString()
+    updated_at: nowIso(),
+    last_price_at: nowIso()
  });

  const [updated] = await db
--- a/lib/server/repos/research-library.ts
+++ b/lib/server/repos/research-library.ts
@@ -27,6 +27,14 @@ import {
 } from '@/lib/server/db/schema';
 import { getFilingByAccession, listFilingsRecords } from '@/lib/server/repos/filings';
 import { getWatchlistItemByTicker } from '@/lib/server/repos/watchlist';
+import {
+  normalizeTicker,
+  normalizeTags,
+  normalizeOptionalString,
+  normalizeRecord,
+  normalizePositiveInteger,
+  nowIso
+} from '@/lib/server/utils';

 type ResearchArtifactRow = typeof researchArtifact.$inferSelect;
 type ResearchMemoRow = typeof researchMemo.$inferSelect;
@@ -51,55 +59,6 @@ const RESEARCH_PACKET_SECTION_TITLES: Record<ResearchMemoSection, string> = {
  next_actions: 'Next Actions'
 };

-function normalizeTicker(ticker: string) {
-  return ticker.trim().toUpperCase();
-}
-
-function normalizeOptionalString(value?: string | null) {
-  const normalized = value?.trim();
-  return normalized ? normalized : null;
-}
-
-function normalizePositiveInteger(value?: number | null) {
-  if (value === null || value === undefined || !Number.isFinite(value)) {
-    return null;
-  }
-
-  const normalized = Math.trunc(value);
-  return normalized > 0 ? normalized : null;
-}
-
-function normalizeRecord(value?: Record<string, unknown> | null) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return null;
-  }
-
-  return value;
-}
-
-function normalizeTags(tags?: string[] | null) {
-  if (!Array.isArray(tags)) {
-    return [];
-  }
-
-  const unique = new Set<string>();
-
-  for (const entry of tags) {
-    if (typeof entry !== 'string') {
-      continue;
-    }
-
-    const normalized = entry.trim();
-    if (!normalized) {
-      continue;
-    }
-
-    unique.add(normalized);
-  }
-
-  return [...unique];
-}
-
 function buildArtifactSearchText(input: {
  title?: string | null;
  summary?: string | null;
@@ -409,7 +368,7 @@ export async function createResearchArtifactRecord(input: {
    throw new Error('ticker is required');
  }

-  const now = new Date().toISOString();
+  const now = nowIso();
  const title = normalizeOptionalString(input.title);
  const summary = normalizeOptionalString(input.summary);
  const bodyMarkdown = normalizeOptionalString(input.bodyMarkdown);
@@ -520,7 +479,7 @@ export async function upsertSystemResearchArtifact(input: {
      search_text: searchText,
      tags: normalizeTags(input.tags),
      metadata: normalizeRecord(input.metadata),
-      updated_at: new Date().toISOString()
+      updated_at: nowIso()
    })
    .where(eq(researchArtifact.id, existing.id))
    .returning();
@@ -566,7 +525,7 @@ export async function updateResearchArtifactRecord(input: {
      metadata,
      tags,
      search_text: searchText,
-      updated_at: new Date().toISOString()
+      updated_at: nowIso()
    })
    .where(eq(researchArtifact.id, input.id))
    .returning();
@@ -702,7 +661,7 @@ export async function upsertResearchMemoRecord(input: {
    throw new Error('ticker is required');
  }

-  const now = new Date().toISOString();
+  const now = nowIso();
  const existing = await getResearchMemoByTicker(input.userId, ticker);

  if (!existing) {
@@ -796,7 +755,7 @@ export async function addResearchMemoEvidenceLink(input: {
      .then((rows) => (rows[0]?.maxOrder ?? 0) + 1)
    : Math.max(0, Math.trunc(input.sortOrder));

-  const now = new Date().toISOString();
+  const now = nowIso();
  if (existing.length > 0) {
    await db
      .update(researchMemoEvidence)
@@ -894,7 +853,7 @@ export async function getResearchPacket(userId: string, ticker: string): Promise
  return {
    ticker: normalizedTicker,
    companyName: coverage?.company_name ?? latestFiling?.company_name ?? null,
-    generated_at: new Date().toISOString(),
+    generated_at: nowIso(),
    memo,
    sections: toPacketSections(memo, evidenceBySection)
  };
--- a/lib/server/repos/tasks.ts
+++ b/lib/server/repos/tasks.ts
@@ -3,6 +3,7 @@ import type { Task, TaskStage, TaskStageContext, TaskStageEvent, TaskStatus, Tas
 import { db } from '@/lib/server/db';
 import { taskRun, taskStageEvent } from '@/lib/server/db/schema';
 import { buildTaskNotification } from '@/lib/server/task-notifications';
+import { nowIso } from '@/lib/server/utils';

 type TaskRow = typeof taskRun.$inferSelect;
 type TaskStageEventRow = typeof taskStageEvent.$inferSelect;
@@ -110,7 +111,7 @@ async function insertTaskStageEvent(executor: InsertExecutor, input: EventInsert
 }

 export async function createTaskRunRecord(input: CreateTaskInput) {
-  const now = new Date().toISOString();
+  const now = nowIso();

  return await db.transaction(async (tx) => {
    const [row] = await tx
@@ -219,7 +220,7 @@ async function attemptAtomicInsert(
 }

 export async function createTaskRunRecordAtomic(input: CreateTaskInput): Promise<AtomicCreateResult> {
-  const now = new Date().toISOString();
+  const now = nowIso();

  return await db.transaction(async (tx) => {
    const result = await attemptAtomicInsert(tx, input, now);
@@ -235,7 +236,7 @@ export async function setTaskWorkflowRunId(taskId: string, workflowRunId: string
    .update(taskRun)
    .set({
      workflow_run_id: workflowRunId,
-      updated_at: new Date().toISOString()
+      updated_at: nowIso()
    })
    .where(eq(taskRun.id, taskId));
 }
@@ -313,7 +314,7 @@ export async function findInFlightTaskByResourceKey(
 }

 export async function markTaskRunning(taskId: string) {
-  const now = new Date().toISOString();
+  const now = nowIso();

  return await db.transaction(async (tx) => {
    const [row] = await tx
@@ -354,7 +355,7 @@ export async function updateTaskStage(
  detail: string | null = null,
  context: TaskStageContext | null = null
 ) {
-  const now = new Date().toISOString();
+  const now = nowIso();

  return await db.transaction(async (tx) => {
    const [current] = await tx
@@ -403,7 +404,7 @@ export async function completeTask(
  result: Record<string, unknown>,
  completion: TaskCompletionState = {}
 ) {
-  const now = new Date().toISOString();
+  const now = nowIso();

  return await db.transaction(async (tx) => {
    const [row] = await tx
@@ -445,7 +446,7 @@ export async function markTaskFailure(
  stage: TaskStage = 'failed',
  failure: TaskCompletionState = {}
 ) {
-  const now = new Date().toISOString();
+  const now = nowIso();

  return await db.transaction(async (tx) => {
    const [row] = await tx
@@ -513,7 +514,7 @@ export async function setTaskStatusFromWorkflow(
      return toTask(current);
    }

-    const now = new Date().toISOString();
+    const now = nowIso();
    const [row] = await tx
      .update(taskRun)
      .set({
@@ -551,7 +552,7 @@ export async function updateTaskNotificationState(
  userId: string,
  input: UpdateTaskNotificationStateInput
 ) {
-  const now = new Date().toISOString();
+  const now = nowIso();
  const patch: Partial<typeof taskRun.$inferInsert> = {
    updated_at: now
  };
--- a/lib/server/repos/watchlist.ts
+++ b/lib/server/repos/watchlist.ts
@@ -6,38 +6,12 @@ import type {
 } from '@/lib/types';
 import { db } from '@/lib/server/db';
 import { watchlistItem } from '@/lib/server/db/schema';
+import { normalizeTicker, normalizeTagsOrNull, nowIso } from '@/lib/server/utils';

 type WatchlistRow = typeof watchlistItem.$inferSelect;
 const DEFAULT_STATUS: CoverageStatus = 'backlog';
 const DEFAULT_PRIORITY: CoveragePriority = 'medium';

-function normalizeTags(tags?: string[]) {
-  if (!Array.isArray(tags)) {
-    return null;
-  }
-
-  const unique = new Set<string>();
-
-  for (const entry of tags) {
-    if (typeof entry !== 'string') {
-      continue;
-    }
-
-    const tag = entry.trim();
-    if (!tag) {
-      continue;
-    }
-
-    unique.add(tag);
-  }
-
-  if (unique.size === 0) {
-    return null;
-  }
-
-  return [...unique];
-}
-
 function toWatchlistItem(row: WatchlistRow, latestFilingDate: string | null = null): WatchlistItem {
  return {
    id: row.id,
@@ -79,7 +53,7 @@ export async function getWatchlistItemById(userId: string, id: number) {
 }

 export async function getWatchlistItemByTicker(userId: string, ticker: string) {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  if (!normalizedTicker) {
    return null;
  }
@@ -104,15 +78,15 @@ export async function upsertWatchlistItemRecord(input: {
  priority?: CoveragePriority;
  lastReviewedAt?: string | null;
 }) {
-  const normalizedTicker = input.ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(input.ticker);
  const normalizedSector = input.sector?.trim() ? input.sector.trim() : null;
  const normalizedCategory = input.category?.trim() ? input.category.trim() : null;
-  const normalizedTags = normalizeTags(input.tags);
+  const normalizedTags = normalizeTagsOrNull(input.tags);
  const normalizedCompanyName = input.companyName.trim();
  const normalizedLastReviewedAt = input.lastReviewedAt?.trim()
    ? input.lastReviewedAt.trim()
    : null;
-  const now = new Date().toISOString();
+  const timestamp = nowIso();

  const [inserted] = await db
    .insert(watchlistItem)
@@ -125,8 +99,8 @@ export async function upsertWatchlistItemRecord(input: {
      tags: normalizedTags,
      status: input.status ?? DEFAULT_STATUS,
      priority: input.priority ?? DEFAULT_PRIORITY,
-      created_at: now,
-      updated_at: now,
+      created_at: timestamp,
+      updated_at: timestamp,
      last_reviewed_at: normalizedLastReviewedAt
    })
    .onConflictDoNothing({
@@ -156,7 +130,7 @@ export async function upsertWatchlistItemRecord(input: {
      tags: normalizedTags,
      status: input.status ?? existing?.status ?? DEFAULT_STATUS,
      priority: input.priority ?? existing?.priority ?? DEFAULT_PRIORITY,
-      updated_at: now,
+      updated_at: timestamp,
      last_reviewed_at: normalizedLastReviewedAt ?? existing?.last_reviewed_at ?? null
    })
    .where(and(eq(watchlistItem.user_id, input.userId), eq(watchlistItem.ticker, normalizedTicker)))
@@ -212,7 +186,7 @@ export async function updateWatchlistItemRecord(input: {
      : null;
  const nextTags = input.tags === undefined
    ? existing.tags ?? null
-    : normalizeTags(input.tags);
+    : normalizeTagsOrNull(input.tags);
  const nextLastReviewedAt = input.lastReviewedAt === undefined
    ? existing.last_reviewed_at
    : input.lastReviewedAt?.trim()
@@ -228,7 +202,7 @@ export async function updateWatchlistItemRecord(input: {
      tags: nextTags,
      status: input.status ?? existing.status ?? DEFAULT_STATUS,
      priority: input.priority ?? existing.priority ?? DEFAULT_PRIORITY,
-      updated_at: new Date().toISOString(),
+      updated_at: nowIso(),
      last_reviewed_at: nextLastReviewedAt
    })
    .where(and(eq(watchlistItem.user_id, input.userId), eq(watchlistItem.id, input.id)))
@@ -242,7 +216,7 @@ export async function updateWatchlistReviewByTicker(
  ticker: string,
  reviewedAt: string
 ) {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  if (!normalizedTicker) {
    return null;
  }
--- a/lib/server/search.ts
+++ b/lib/server/search.ts
@@ -17,6 +17,7 @@ import {
  listResearchJournalEntries,
  listResearchJournalEntriesForUser
 } from '@/lib/server/repos/research-journal';
+import { normalizeTickerOrNull } from '@/lib/server/utils';

 type SearchDocumentScope = 'global' | 'user';
 type SearchDocumentSourceKind = 'filing_document' | 'filing_brief' | 'research_note';
@@ -131,11 +132,6 @@ function escapeLike(value: string) {
  return value.replace(/[%_]/g, (match) => `\\${match}`);
 }

-function normalizeTicker(value: string | null | undefined) {
-  const normalized = value?.trim().toUpperCase() ?? '';
-  return normalized.length > 0 ? normalized : null;
-}
-
 function normalizeSearchSources(sources?: SearchSource[]) {
  const normalized = new Set<SearchSource>();

@@ -1205,7 +1201,7 @@ export async function searchKnowledgeBase(input: SearchInput) {
  }

  const limit = clampLimit(input.limit);
-  const normalizedTicker = normalizeTicker(input.ticker);
+  const normalizedTicker = normalizeTickerOrNull(input.ticker);
  const includedSources = normalizeSearchSources(input.sources);
  const client = getSqliteClient();
  const [queryEmbedding] = await runAiEmbeddings([normalizedQuery]);
--- a/lib/server/sec-company-profile.ts
+++ b/lib/server/sec-company-profile.ts
@@ -1,4 +1,5 @@
 import type { CompanyProfile, CompanyValuationSnapshot } from '@/lib/types';
+import { normalizeTicker } from '@/lib/server/utils';

 type FetchImpl = typeof fetch;

@@ -261,7 +262,7 @@ export async function getSecCompanyProfile(
  ticker: string,
  options?: { fetchImpl?: FetchImpl }
 ): Promise<SecCompanyProfileResult | null> {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  if (!normalizedTicker) {
    return null;
  }
--- a/lib/server/task-processors.ts
+++ b/lib/server/task-processors.ts
@@ -39,6 +39,7 @@ import {
 } from '@/lib/server/sec';
 import { enqueueTask } from '@/lib/server/tasks';
 import { hydrateFilingTaxonomySnapshot } from '@/lib/server/taxonomy/engine';
+import { nowIso } from '@/lib/server/utils';

 const EXTRACTION_REQUIRED_KEYS = [
  'summary',
@@ -762,7 +763,7 @@ async function processSyncFilings(task: Task) {
      await deleteCompanyFinancialBundlesForTicker(filing.ticker);
      taxonomySnapshotsHydrated += 1;
    } catch (error) {
-      const now = new Date().toISOString();
+      const now = nowIso();
      await upsertFilingTaxonomySnapshot({
        filing_id: filing.id,
        ticker: filing.ticker,
@@ -961,7 +962,7 @@ async function processRefreshPrices(task: Task) {
      }
    }
  );
-  const updatedCount = await applyRefreshedPrices(userId, quotes, new Date().toISOString());
+  const updatedCount = await applyRefreshedPrices(userId, quotes, nowIso());

  const result = {
    updatedCount,
--- a/lib/server/taxonomy/engine.test.ts
+++ b/lib/server/taxonomy/engine.test.ts
@@ -49,9 +49,6 @@ function createHydrationResult(): TaxonomyHydrationResult {
      unmapped_row_count: 0,
      material_unmapped_row_count: 0,
      warnings: ['rust_warning']
-    },
-    xbrl_validation: {
-      status: 'passed'
    }
  };
 }
--- a/lib/server/taxonomy/parser-client.ts
+++ b/lib/server/taxonomy/parser-client.ts
@@ -1,7 +1,6 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import type { TaxonomyHydrationInput, TaxonomyHydrationResult } from '@/lib/server/taxonomy/types';
-import { withRetry } from '@/lib/server/utils/retry';

 function candidateBinaryPaths() {
  return [
@@ -24,10 +23,6 @@ export function resolveFiscalXbrlBinary() {
 export async function hydrateFilingTaxonomySnapshotFromSidecar(
  input: TaxonomyHydrationInput
 ): Promise<TaxonomyHydrationResult> {
-  return withRetry(() => hydrateFromSidecarImpl(input));
-}
-
-async function hydrateFromSidecarImpl(input: TaxonomyHydrationInput): Promise<TaxonomyHydrationResult> {
  const binary = resolveFiscalXbrlBinary();
  const timeoutMs = Math.max(Number(process.env.XBRL_ENGINE_TIMEOUT_MS ?? 45_000), 1_000);
  const command = [binary, 'hydrate-filing'];
--- a/lib/server/taxonomy/types.ts
+++ b/lib/server/taxonomy/types.ts
@@ -204,11 +204,6 @@ export type TaxonomyHydrationNormalizationSummary = {
  warnings: string[];
 };

-export type XbrlValidationResult = {
-  status: 'passed' | 'warning' | 'error';
-  message?: string;
-};
-
 export type TaxonomyHydrationInput = {
  filingId: number;
  ticker: string;
@@ -284,5 +279,4 @@ export type TaxonomyHydrationResult = {
  }>;
  metric_validations: TaxonomyMetricValidationCheck[];
  normalization_summary: TaxonomyHydrationNormalizationSummary;
-  xbrl_validation: XbrlValidationResult;
 };
--- a/lib/server/utils/index.ts
+++ b/lib/server/utils/index.ts
@@ -18,5 +18,3 @@ export {
  asStringArray,
  asEnum
 } from './validation';
-
-export { withRetry, type RetryOptions } from './retry';
--- a/lib/server/utils/retry.ts
+++ b/lib/server/utils/retry.ts
@@ -1,59 +0,0 @@
-export interface RetryOptions {
-  maxRetries: number;
-  baseDelayMs: number;
-  maxDelayMs: number;
-  jitterFactor: number;
-  retryableErrors: RegExp[];
-}
-
-const DEFAULT_RETRY_OPTIONS: RetryOptions = {
-  maxRetries: 3,
-  baseDelayMs: 2000,
-  maxDelayMs: 10000,
-  jitterFactor: 0.3,
-  retryableErrors: [
-    /timeout/i,
-    /ECONNRESET/,
-    /ETIMEDOUT/,
-    /ENOTFOUND/,
-    /exit code 1/,
-    /signal/,
-    /killed/
-  ]
-};
-
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  options?: Partial<RetryOptions>
-): Promise<T> {
-  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
-  let lastError: Error | null = null;
-
-  for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-
-      const isRetryable = opts.retryableErrors.some(
-        (pattern) => pattern.test(lastError!.message)
-      );
-
-      if (!isRetryable || attempt === opts.maxRetries - 1) {
-        throw lastError;
-      }
-
-      const baseDelay = opts.baseDelayMs * Math.pow(2, attempt);
-      const jitter = Math.random() * opts.jitterFactor * baseDelay;
-      const delay = Math.min(baseDelay + jitter, opts.maxDelayMs);
-
-      console.warn(
-        `[retry] Attempt ${attempt + 1}/${opts.maxRetries} failed, retrying in ${Math.round(delay)}ms: ${lastError.message}`
-      );
-
-      await Bun.sleep(delay);
-    }
-  }
-
-  throw lastError;
-}
--- a/lib/server/yahoo-company-profile.ts
+++ b/lib/server/yahoo-company-profile.ts
@@ -1,3 +1,5 @@
+import { normalizeTicker } from '@/lib/server/utils';
+
 type FetchImpl = typeof fetch;

 type CacheEntry<T> = {
@@ -142,7 +144,7 @@ export async function getYahooCompanyDescription(
  ticker: string,
  options?: { fetchImpl?: FetchImpl }
 ) {
-  const normalizedTicker = ticker.trim().toUpperCase();
+  const normalizedTicker = normalizeTicker(ticker);
  if (!normalizedTicker) {
    return null;
  }
--- a/rust/fiscal-xbrl-core/src/lib.rs
+++ b/rust/fiscal-xbrl-core/src/lib.rs
@@ -4,8 +4,6 @@ use regex::Regex;
 use reqwest::blocking::Client;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap, HashSet};
-use std::sync::Mutex;
-use std::time::{Duration, Instant};

 mod kpi_mapper;
 mod metrics;
@@ -22,39 +20,6 @@ use crabrl as _;
 pub const PARSER_ENGINE: &str = "fiscal-xbrl";
 pub const PARSER_VERSION: &str = env!("CARGO_PKG_VERSION");

-const DEFAULT_SEC_RATE_LIMIT_MS: u64 = 100;
-const HTTP_TIMEOUT_SECS: u64 = 30;
-
-static RATE_LIMITER: Lazy<Mutex<Instant>> = Lazy::new(|| Mutex::new(Instant::now()));
-
-fn sec_rate_limit_delay() -> u64 {
-    std::env::var("SEC_RATE_LIMIT_MS")
-        .ok()
-        .and_then(|s| s.parse().ok())
-        .unwrap_or(DEFAULT_SEC_RATE_LIMIT_MS)
-}
-
-fn rate_limited_fetch<T, F>(fetch_fn: F) -> Result<T>
-where
-    F: FnOnce() -> Result<T>,
-{
-    let delay_ms = sec_rate_limit_delay();
-
-    {
-        let mut last_request = RATE_LIMITER.lock().unwrap();
-        let elapsed = last_request.elapsed();
-        let min_delay = Duration::from_millis(delay_ms);
-
-        if elapsed < min_delay {
-            std::thread::sleep(min_delay - elapsed);
-        }
-
-        *last_request = Instant::now();
-    }
-
-    fetch_fn()
-}
-
 static CONTEXT_RE: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r#"(?is)<(?:[a-z0-9_\-]+:)?context\b[^>]*\bid=["']([^"']+)["'][^>]*>(.*?)</(?:[a-z0-9_\-]+:)?context>"#).unwrap()
 });
@@ -153,7 +118,6 @@ pub struct HydrateFilingResponse {
    pub contexts: Vec<ContextOutput>,
    pub derived_metrics: FilingMetrics,
    pub validation_result: ValidationResultOutput,
-    pub xbrl_validation: XbrlValidationResult,
    pub facts_count: usize,
    pub concepts_count: usize,
    pub dimensions_count: usize,
@@ -517,7 +481,6 @@ struct PresentationNode {
 pub fn hydrate_filing(input: HydrateFilingRequest) -> Result<HydrateFilingResponse> {
    let client = Client::builder()
        .user_agent("Fiscal Clone <support@fiscal.local>")
-        .timeout(Duration::from_secs(120))
        .build()
        .context("unable to build HTTP client")?;

@@ -558,11 +521,7 @@ pub fn hydrate_filing(input: HydrateFilingRequest) -> Result<HydrateFilingRespon
            computed_definitions: vec![],
            contexts: vec![],
            derived_metrics: FilingMetrics::default(),
-            validation_result: validation_result.clone(),
-            xbrl_validation: XbrlValidationResult {
-                status: "error".to_string(),
-                message: Some("No XBRL instance found".to_string()),
-            },
+            validation_result,
            facts_count: 0,
            concepts_count: 0,
            dimensions_count: 0,
@@ -583,17 +542,6 @@ pub fn hydrate_filing(input: HydrateFilingRequest) -> Result<HydrateFilingRespon

    let instance_text = fetch_text(&client, &instance_asset.url)
        .context("fetch request failed for XBRL instance")?;
-
-    let xbrl_validation = validate_xbrl_structure(&instance_text, Some(&instance_asset.name));
-    if xbrl_validation.status != "passed" {
-        eprintln!(
-            "[xbrl] Validation {} for {:?}: {}",
-            xbrl_validation.status,
-            instance_asset.name,
-            xbrl_validation.message.as_deref().unwrap_or("unknown")
-        );
-    }
-
    let parsed_instance = parse_xbrl_instance(&instance_text, Some(instance_asset.name.clone()));

    let mut label_by_concept = HashMap::new();
@@ -730,7 +678,6 @@ pub fn hydrate_filing(input: HydrateFilingRequest) -> Result<HydrateFilingRespon
        contexts: parsed_instance.contexts,
        derived_metrics: metrics::derive_metrics(&facts),
        validation_result,
-        xbrl_validation,
        facts_count: facts.len(),
        concepts_count: concepts.len(),
        dimensions_count: facts
@@ -1016,78 +963,29 @@ fn parse_size(value: Option<&serde_json::Value>) -> Option<i64> {
 }

 fn fetch_text(client: &Client, url: &str) -> Result<String> {
-    rate_limited_fetch(|| {
-        let response = client
-            .get(url)
-            .timeout(Duration::from_secs(HTTP_TIMEOUT_SECS))
-            .send()
-            .with_context(|| format!("request failed for {url}"))?;
-        if !response.status().is_success() {
-            return Err(anyhow!("request failed for {url} ({})", response.status()));
-        }
-        response
-            .text()
-            .with_context(|| format!("unable to read response body for {url}"))
-    })
+    let response = client
+        .get(url)
+        .send()
+        .with_context(|| format!("request failed for {url}"))?;
+    if !response.status().is_success() {
+        return Err(anyhow!("request failed for {url} ({})", response.status()));
+    }
+    response
+        .text()
+        .with_context(|| format!("unable to read response body for {url}"))
 }

 fn fetch_json<T: for<'de> Deserialize<'de>>(client: &Client, url: &str) -> Result<T> {
-    rate_limited_fetch(|| {
-        let response = client
-            .get(url)
-            .timeout(Duration::from_secs(HTTP_TIMEOUT_SECS))
-            .send()
-            .with_context(|| format!("request failed for {url}"))?;
-        if !response.status().is_success() {
-            return Err(anyhow!("request failed for {url} ({})", response.status()));
-        }
-        response
-            .json::<T>()
-            .with_context(|| format!("unable to parse JSON response for {url}"))
-    })
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct XbrlValidationResult {
-    pub status: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub message: Option<String>,
-}
-
-fn validate_xbrl_structure(xml: &str, source_file: Option<&str>) -> XbrlValidationResult {
-    if xml.is_empty() {
-        return XbrlValidationResult {
-            status: "error".to_string(),
-            message: Some("XBRL content is empty".to_string()),
-        };
-    }
-
-    if !xml.contains("<xbrl") && !xml.contains("<xbrli:xbrl") {
-        return XbrlValidationResult {
-            status: "error".to_string(),
-            message: Some("Invalid XBRL: missing root element".to_string()),
-        };
-    }
-
-    let open_count = xml.matches('<').count();
-    let close_count = xml.matches('>').count();
-
-    if open_count != close_count {
-        return XbrlValidationResult {
-            status: "warning".to_string(),
-            message: Some(format!(
-                "Malformed XML detected in {:?} ({} open, {} close tags)",
-                source_file.unwrap_or("unknown"),
-                open_count,
-                close_count
-            )),
-        };
-    }
-
-    XbrlValidationResult {
-        status: "passed".to_string(),
-        message: None,
+    let response = client
+        .get(url)
+        .send()
+        .with_context(|| format!("request failed for {url}"))?;
+    if !response.status().is_success() {
+        return Err(anyhow!("request failed for {url} ({})", response.status()));
    }
+    response
+        .json::<T>()
+        .with_context(|| format!("unable to parse JSON response for {url}"))
 }

 struct ParsedInstance {