Add files using upload-large-folder tool

backend/node_modules/effect/src/internal/metric/boundaries.ts

@@ -0,0 +1,75 @@
+import * as Arr from "../../Array.js"
+import * as Chunk from "../../Chunk.js"
+import * as Equal from "../../Equal.js"
+import { pipe } from "../../Function.js"
+import * as Hash from "../../Hash.js"
+import type * as MetricBoundaries from "../../MetricBoundaries.js"
+import { pipeArguments } from "../../Pipeable.js"
+import { hasProperty } from "../../Predicate.js"
+
+/** @internal */
+const MetricBoundariesSymbolKey = "effect/MetricBoundaries"
+
+/** @internal */
+export const MetricBoundariesTypeId: MetricBoundaries.MetricBoundariesTypeId = Symbol.for(
+  MetricBoundariesSymbolKey
+) as MetricBoundaries.MetricBoundariesTypeId
+
+/** @internal */
+class MetricBoundariesImpl implements MetricBoundaries.MetricBoundaries {
+  readonly [MetricBoundariesTypeId]: MetricBoundaries.MetricBoundariesTypeId = MetricBoundariesTypeId
+  constructor(readonly values: ReadonlyArray<number>) {
+    this._hash = pipe(
+      Hash.string(MetricBoundariesSymbolKey),
+      Hash.combine(Hash.array(this.values))
+    )
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](u: unknown): boolean {
+    return isMetricBoundaries(u) && Equal.equals(this.values, u.values)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const isMetricBoundaries = (u: unknown): u is MetricBoundaries.MetricBoundaries =>
+  hasProperty(u, MetricBoundariesTypeId)
+
+/** @internal */
+export const fromIterable = (iterable: Iterable<number>): MetricBoundaries.MetricBoundaries => {
+  const values = pipe(
+    iterable,
+    Arr.appendAll(Chunk.of(Number.POSITIVE_INFINITY)),
+    Arr.dedupe
+  )
+  return new MetricBoundariesImpl(values)
+}
+
+/** @internal */
+export const linear = (options: {
+  readonly start: number
+  readonly width: number
+  readonly count: number
+}): MetricBoundaries.MetricBoundaries =>
+  pipe(
+    Arr.makeBy(options.count - 1, (i) => options.start + i * options.width),
+    Chunk.unsafeFromArray,
+    fromIterable
+  )
+
+/** @internal */
+export const exponential = (options: {
+  readonly start: number
+  readonly factor: number
+  readonly count: number
+}): MetricBoundaries.MetricBoundaries =>
+  pipe(
+    Arr.makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)),
+    Chunk.unsafeFromArray,
+    fromIterable
+  )

backend/node_modules/effect/src/internal/metric/hook.ts

@@ -0,0 +1,483 @@
+import * as Arr from "../../Array.js"
+import * as Duration from "../../Duration.js"
+import type { LazyArg } from "../../Function.js"
+import { dual, pipe } from "../../Function.js"
+import type * as MetricHook from "../../MetricHook.js"
+import type * as MetricKey from "../../MetricKey.js"
+import type * as MetricState from "../../MetricState.js"
+import * as number from "../../Number.js"
+import * as Option from "../../Option.js"
+import { pipeArguments } from "../../Pipeable.js"
+import * as metricState from "./state.js"
+
+/** @internal */
+const MetricHookSymbolKey = "effect/MetricHook"
+
+/** @internal */
+export const MetricHookTypeId: MetricHook.MetricHookTypeId = Symbol.for(
+  MetricHookSymbolKey
+) as MetricHook.MetricHookTypeId
+
+const metricHookVariance = {
+  /* c8 ignore next */
+  _In: (_: unknown) => _,
+  /* c8 ignore next */
+  _Out: (_: never) => _
+}
+
+/** @internal */
+export const make = <In, Out>(
+  options: {
+    readonly get: LazyArg<Out>
+    readonly update: (input: In) => void
+    readonly modify: (input: In) => void
+  }
+): MetricHook.MetricHook<In, Out> => ({
+  [MetricHookTypeId]: metricHookVariance,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  ...options
+})
+
+/** @internal */
+export const onModify = dual<
+  <In, Out>(f: (input: In) => void) => (self: MetricHook.MetricHook<In, Out>) => MetricHook.MetricHook<In, Out>,
+  <In, Out>(self: MetricHook.MetricHook<In, Out>, f: (input: In) => void) => MetricHook.MetricHook<In, Out>
+>(2, (self, f) => ({
+  [MetricHookTypeId]: metricHookVariance,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  get: self.get,
+  update: self.update,
+  modify: (input) => {
+    self.modify(input)
+    return f(input)
+  }
+}))
+
+/** @internal */
+export const onUpdate = dual<
+  <In, Out>(f: (input: In) => void) => (self: MetricHook.MetricHook<In, Out>) => MetricHook.MetricHook<In, Out>,
+  <In, Out>(self: MetricHook.MetricHook<In, Out>, f: (input: In) => void) => MetricHook.MetricHook<In, Out>
+>(2, (self, f) => ({
+  [MetricHookTypeId]: metricHookVariance,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  get: self.get,
+  update: (input) => {
+    self.update(input)
+    return f(input)
+  },
+  modify: self.modify
+}))
+
+const bigint0 = BigInt(0)
+
+/** @internal */
+export const counter = <A extends (number | bigint)>(
+  key: MetricKey.MetricKey.Counter<A>
+): MetricHook.MetricHook.Counter<A> => {
+  let sum: A = key.keyType.bigint ? bigint0 as A : 0 as A
+  const canUpdate = key.keyType.incremental
+    ? key.keyType.bigint
+      ? (value: A) => value >= bigint0
+      : (value: A) => value >= 0
+    : (_value: A) => true
+  const update = (value: A) => {
+    if (canUpdate(value)) {
+      sum = (sum as any) + value
+    }
+  }
+  return make({
+    get: () => metricState.counter(sum as number) as unknown as MetricState.MetricState.Counter<A>,
+    update,
+    modify: update
+  })
+}
+
+/** @internal */
+export const frequency = (key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency => {
+  const values = new Map<string, number>()
+  for (const word of key.keyType.preregisteredWords) {
+    values.set(word, 0)
+  }
+  const update = (word: string) => {
+    const slotCount = values.get(word) ?? 0
+    values.set(word, slotCount + 1)
+  }
+  return make({
+    get: () => metricState.frequency(values),
+    update,
+    modify: update
+  })
+}
+
+/** @internal */
+export const gauge: {
+  (key: MetricKey.MetricKey.Gauge<number>, startAt: number): MetricHook.MetricHook.Gauge<number>
+  (key: MetricKey.MetricKey.Gauge<bigint>, startAt: bigint): MetricHook.MetricHook.Gauge<bigint>
+} = <A extends (number | bigint)>(
+  _key: MetricKey.MetricKey.Gauge<A>,
+  startAt: A
+): MetricHook.MetricHook.Gauge<A> => {
+  let value = startAt
+  return make({
+    get: () => metricState.gauge(value as number) as unknown as MetricState.MetricState.Gauge<A>,
+    update: (v) => {
+      value = v
+    },
+    modify: (v) => {
+      value = (value as any) + v
+    }
+  })
+}
+
+/** @internal */
+export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.MetricHook.Histogram => {
+  const bounds = key.keyType.boundaries.values
+  const size = bounds.length
+  const values = new Uint32Array(size + 1)
+  // NOTE: while 64-bit floating point precision shoule be enough for any
+  // practical histogram boundary values, there is still a small chance that
+  // precision will be lost with very large / very small numbers. If we find
+  // that is the case, a more complex approach storing the histogram boundary
+  // values as a tuple of `[original: string, numeric: number]` may be warranted
+  const boundaries = new Float64Array(size)
+  let count = 0
+  let sum = 0
+  let min = Number.MAX_VALUE
+  let max = Number.MIN_VALUE
+
+  pipe(
+    bounds,
+    Arr.sort(number.Order),
+    Arr.map((n, i) => {
+      boundaries[i] = n
+    })
+  )
+
+  // Insert the value into the right bucket with a binary search
+  const update = (value: number) => {
+    let from = 0
+    let to = size
+    while (from !== to) {
+      const mid = Math.floor(from + (to - from) / 2)
+      const boundary = boundaries[mid]
+      if (value <= boundary) {
+        to = mid
+      } else {
+        from = mid
+      }
+      // The special case when to / from have a distance of one
+      if (to === from + 1) {
+        if (value <= boundaries[from]) {
+          to = from
+        } else {
+          from = to
+        }
+      }
+    }
+    values[from] = values[from]! + 1
+    count = count + 1
+    sum = sum + value
+    if (value < min) {
+      min = value
+    }
+    if (value > max) {
+      max = value
+    }
+  }
+
+  const getBuckets = (): ReadonlyArray<readonly [number, number]> => {
+    const builder: Array<readonly [number, number]> = Arr.allocate(size) as any
+    let cumulated = 0
+    for (let i = 0; i < size; i++) {
+      const boundary = boundaries[i]
+      const value = values[i]
+      cumulated = cumulated + value
+      builder[i] = [boundary, cumulated]
+    }
+    return builder
+  }
+
+  return make({
+    get: () =>
+      metricState.histogram({
+        buckets: getBuckets(),
+        count,
+        min,
+        max,
+        sum
+      }),
+    update,
+    modify: update
+  })
+}
+
+/** @internal */
+export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook.Summary => {
+  const { error, maxAge, maxSize, quantiles } = key.keyType
+  const sortedQuantiles = pipe(quantiles, Arr.sort(number.Order))
+  const values = Arr.allocate<readonly [number, number]>(maxSize)
+
+  let head = 0
+  let count = 0
+  let sum = 0
+  let min = 0
+  let max = 0
+
+  // Just before the snapshot we filter out all values older than maxAge
+  const snapshot = (now: number): ReadonlyArray<readonly [number, Option.Option<number>]> => {
+    const builder: Array<number> = []
+    // If the buffer is not full yet it contains valid items at the 0..last
+    // indices and null values at the rest of the positions.
+    //
+    // If the buffer is already full then all elements contains a valid
+    // measurement with timestamp.
+    //
+    // At any given point in time we can enumerate all the non-null elements in
+    // the buffer and filter them by timestamp to get a valid view of a time
+    // window.
+    //
+    // The order does not matter because it gets sorted before passing to
+    // `calculateQuantiles`.
+    let i = 0
+    while (i !== maxSize - 1) {
+      const item = values[i]
+      if (item != null) {
+        const [t, v] = item
+        const age = Duration.millis(now - t)
+        if (Duration.greaterThanOrEqualTo(age, Duration.zero) && Duration.lessThanOrEqualTo(age, maxAge)) {
+          builder.push(v)
+        }
+      }
+      i = i + 1
+    }
+    return calculateQuantiles(
+      error,
+      sortedQuantiles,
+      Arr.sort(builder, number.Order)
+    )
+  }
+
+  const observe = (value: number, timestamp: number) => {
+    if (maxSize > 0) {
+      head = head + 1
+      const target = head % maxSize
+      values[target] = [timestamp, value] as const
+    }
+
+    min = count === 0 ? value : Math.min(min, value)
+    max = count === 0 ? value : Math.max(max, value)
+
+    count = count + 1
+    sum = sum + value
+  }
+
+  return make({
+    get: () =>
+      metricState.summary({
+        error,
+        quantiles: snapshot(Date.now()),
+        count,
+        min,
+        max,
+        sum
+      }),
+    update: ([value, timestamp]) => observe(value, timestamp),
+    modify: ([value, timestamp]) => observe(value, timestamp)
+  })
+}
+
+/** @internal */
+interface ResolvedQuantile {
+  /**
+   * The quantile that shall be resolved.
+   */
+  readonly quantile: number
+  /**
+   * `Some<number>` if a value for the quantile could be found, otherwise
+   * `None`.
+   */
+  readonly value: Option.Option<number>
+  /**
+   * How many samples have been consumed prior to this quantile.
+   */
+  readonly consumed: number
+  /**
+   * The rest of the samples after the quantile has been resolved.
+   */
+  readonly rest: ReadonlyArray<number>
+}
+
+/** @internal */
+const calculateQuantiles = (
+  error: number,
+  sortedQuantiles: ReadonlyArray<number>,
+  sortedSamples: ReadonlyArray<number>
+): ReadonlyArray<readonly [number, Option.Option<number>]> => {
+  // The number of samples examined
+  const sampleCount = sortedSamples.length
+  if (!Arr.isNonEmptyReadonlyArray(sortedQuantiles)) {
+    return Arr.empty()
+  }
+  const head = sortedQuantiles[0]
+  const tail = sortedQuantiles.slice(1)
+  const resolvedHead = resolveQuantile(
+    error,
+    sampleCount,
+    Option.none(),
+    0,
+    head,
+    sortedSamples
+  )
+  const resolved = Arr.of(resolvedHead)
+  tail.forEach((quantile) => {
+    resolved.push(
+      resolveQuantile(
+        error,
+        sampleCount,
+        resolvedHead.value,
+        resolvedHead.consumed,
+        quantile,
+        resolvedHead.rest
+      )
+    )
+  })
+  return Arr.map(resolved, (rq) => [rq.quantile, rq.value] as const)
+}
+
+/** @internal */
+const resolveQuantile = (
+  error: number,
+  sampleCount: number,
+  current: Option.Option<number>,
+  consumed: number,
+  quantile: number,
+  rest: ReadonlyArray<number>
+): ResolvedQuantile => {
+  let error_1 = error
+  let sampleCount_1 = sampleCount
+  let current_1 = current
+  let consumed_1 = consumed
+  let quantile_1 = quantile
+  let rest_1 = rest
+  let error_2 = error
+  let sampleCount_2 = sampleCount
+  let current_2 = current
+  let consumed_2 = consumed
+  let quantile_2 = quantile
+  let rest_2 = rest
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    // If the remaining list of samples is empty, there is nothing more to resolve
+    if (!Arr.isNonEmptyReadonlyArray(rest_1)) {
+      return {
+        quantile: quantile_1,
+        value: Option.none(),
+        consumed: consumed_1,
+        rest: []
+      }
+    }
+    // If the quantile is the 100% quantile, we can take the maximum of all the
+    // remaining values as the result
+    if (quantile_1 === 1) {
+      return {
+        quantile: quantile_1,
+        value: Option.some(Arr.lastNonEmpty(rest_1)),
+        consumed: consumed_1 + rest_1.length,
+        rest: []
+      }
+    }
+    // Split into two chunks - the first chunk contains all elements of the same
+    // value as the chunk head
+    const headValue = Arr.headNonEmpty(rest_1) // Get head value since rest_1 is non-empty
+    const sameHead = Arr.span(rest_1, (n) => n === headValue)
+    // How many elements do we want to accept for this quantile
+    const desired = quantile_1 * sampleCount_1
+    // The error margin
+    const allowedError = (error_1 / 2) * desired
+    // Taking into account the elements consumed from the samples so far and the
+    // number of same elements at the beginning of the chunk, calculate the number
+    // of elements we would have if we selected the current head as result
+    const candConsumed = consumed_1 + sameHead[0].length
+    const candError = Math.abs(candConsumed - desired)
+    // If we haven't got enough elements yet, recurse
+    if (candConsumed < desired - allowedError) {
+      error_2 = error_1
+      sampleCount_2 = sampleCount_1
+      current_2 = Arr.head(rest_1)
+      consumed_2 = candConsumed
+      quantile_2 = quantile_1
+      rest_2 = sameHead[1]
+      error_1 = error_2
+      sampleCount_1 = sampleCount_2
+      current_1 = current_2
+      consumed_1 = consumed_2
+      quantile_1 = quantile_2
+      rest_1 = rest_2
+      continue
+    }
+    // If consuming this chunk leads to too many elements (rank is too high)
+    if (candConsumed > desired + allowedError) {
+      const valueToReturn = Option.isNone(current_1)
+        ? Option.some(headValue)
+        : current_1
+      return {
+        quantile: quantile_1,
+        value: valueToReturn,
+        consumed: consumed_1,
+        rest: rest_1
+      }
+    }
+    // If we are in the target interval, select the current head and hand back the leftover after dropping all elements
+    // from the sample chunk that are equal to the current head
+    switch (current_1._tag) {
+      case "None": {
+        error_2 = error_1
+        sampleCount_2 = sampleCount_1
+        current_2 = Arr.head(rest_1)
+        consumed_2 = candConsumed
+        quantile_2 = quantile_1
+        rest_2 = sameHead[1]
+        error_1 = error_2
+        sampleCount_1 = sampleCount_2
+        current_1 = current_2
+        consumed_1 = consumed_2
+        quantile_1 = quantile_2
+        rest_1 = rest_2
+        continue
+      }
+      case "Some": {
+        const prevError = Math.abs(desired - current_1.value)
+        if (candError < prevError) {
+          error_2 = error_1
+          sampleCount_2 = sampleCount_1
+          current_2 = Arr.head(rest_1)
+          consumed_2 = candConsumed
+          quantile_2 = quantile_1
+          rest_2 = sameHead[1]
+          error_1 = error_2
+          sampleCount_1 = sampleCount_2
+          current_1 = current_2
+          consumed_1 = consumed_2
+          quantile_1 = quantile_2
+          rest_1 = rest_2
+          continue
+        }
+        return {
+          quantile: quantile_1,
+          value: Option.some(current_1.value),
+          consumed: consumed_1,
+          rest: rest_1
+        }
+      }
+    }
+  }
+  throw new Error(
+    "BUG: MetricHook.resolveQuantiles - please report an issue at https://github.com/Effect-TS/effect/issues"
+  )
+}

backend/node_modules/effect/src/internal/metric/key.ts

@@ -0,0 +1,167 @@
+import * as Arr from "../../Array.js"
+import type * as Duration from "../../Duration.js"
+import * as Equal from "../../Equal.js"
+import { dual, pipe } from "../../Function.js"
+import * as Hash from "../../Hash.js"
+import type * as MetricBoundaries from "../../MetricBoundaries.js"
+import type * as MetricKey from "../../MetricKey.js"
+import type * as MetricKeyType from "../../MetricKeyType.js"
+import type * as MetricLabel from "../../MetricLabel.js"
+import * as Option from "../../Option.js"
+import { pipeArguments } from "../../Pipeable.js"
+import { hasProperty } from "../../Predicate.js"
+import * as metricKeyType from "./keyType.js"
+import * as metricLabel from "./label.js"
+
+/** @internal */
+const MetricKeySymbolKey = "effect/MetricKey"
+
+/** @internal */
+export const MetricKeyTypeId: MetricKey.MetricKeyTypeId = Symbol.for(
+  MetricKeySymbolKey
+) as MetricKey.MetricKeyTypeId
+
+const metricKeyVariance = {
+  /* c8 ignore next */
+  _Type: (_: never) => _
+}
+
+const arrayEquivilence = Arr.getEquivalence(Equal.equals)
+
+/** @internal */
+class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
+  readonly [MetricKeyTypeId] = metricKeyVariance
+  constructor(
+    readonly name: string,
+    readonly keyType: Type,
+    readonly description: Option.Option<string>,
+    readonly tags: ReadonlyArray<MetricLabel.MetricLabel> = []
+  ) {
+    this._hash = pipe(
+      Hash.string(this.name + this.description),
+      Hash.combine(Hash.hash(this.keyType)),
+      Hash.combine(Hash.array(this.tags))
+    )
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](u: unknown): boolean {
+    return isMetricKey(u) &&
+      this.name === u.name &&
+      Equal.equals(this.keyType, u.keyType) &&
+      Equal.equals(this.description, u.description) &&
+      arrayEquivilence(this.tags, u.tags)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const isMetricKey = (u: unknown): u is MetricKey.MetricKey<MetricKeyType.MetricKeyType<unknown, unknown>> =>
+  hasProperty(u, MetricKeyTypeId)
+
+/** @internal */
+export const counter: {
+  (name: string, options?: {
+    readonly description?: string | undefined
+    readonly bigint?: false | undefined
+    readonly incremental?: boolean | undefined
+  }): MetricKey.MetricKey.Counter<number>
+  (name: string, options: {
+    readonly description?: string | undefined
+    readonly bigint: true
+    readonly incremental?: boolean | undefined
+  }): MetricKey.MetricKey.Counter<bigint>
+} = (name: string, options) =>
+  new MetricKeyImpl(
+    name,
+    metricKeyType.counter(options as any),
+    Option.fromNullable(options?.description)
+  )
+
+/** @internal */
+export const frequency = (name: string, options?: {
+  readonly description?: string | undefined
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): MetricKey.MetricKey.Frequency =>
+  new MetricKeyImpl(name, metricKeyType.frequency(options), Option.fromNullable(options?.description))
+
+/** @internal */
+export const gauge: {
+  (name: string, options?: {
+    readonly description?: string | undefined
+    readonly bigint?: false | undefined
+  }): MetricKey.MetricKey.Gauge<number>
+  (name: string, options: {
+    readonly description?: string | undefined
+    readonly bigint: true
+  }): MetricKey.MetricKey.Gauge<bigint>
+} = (name, options) =>
+  new MetricKeyImpl(
+    name,
+    metricKeyType.gauge(options as any),
+    Option.fromNullable(options?.description)
+  )
+
+/** @internal */
+export const histogram = (
+  name: string,
+  boundaries: MetricBoundaries.MetricBoundaries,
+  description?: string
+): MetricKey.MetricKey.Histogram =>
+  new MetricKeyImpl(
+    name,
+    metricKeyType.histogram(boundaries),
+    Option.fromNullable(description)
+  )
+
+/** @internal */
+export const summary = (
+  options: {
+    readonly name: string
+    readonly maxAge: Duration.DurationInput
+    readonly maxSize: number
+    readonly error: number
+    readonly quantiles: ReadonlyArray<number>
+    readonly description?: string | undefined
+  }
+): MetricKey.MetricKey.Summary =>
+  new MetricKeyImpl(
+    options.name,
+    metricKeyType.summary(options),
+    Option.fromNullable(options.description)
+  )
+
+/** @internal */
+export const tagged = dual<
+  (
+    key: string,
+    value: string
+  ) => <Type extends MetricKeyType.MetricKeyType<any, any>>(
+    self: MetricKey.MetricKey<Type>
+  ) => MetricKey.MetricKey<Type>,
+  <Type extends MetricKeyType.MetricKeyType<any, any>>(
+    self: MetricKey.MetricKey<Type>,
+    key: string,
+    value: string
+  ) => MetricKey.MetricKey<Type>
+>(3, (self, key, value) => taggedWithLabels(self, [metricLabel.make(key, value)]))
+
+/** @internal */
+export const taggedWithLabels = dual<
+  (
+    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
+  ) => <Type extends MetricKeyType.MetricKeyType<any, any>>(
+    self: MetricKey.MetricKey<Type>
+  ) => MetricKey.MetricKey<Type>,
+  <Type extends MetricKeyType.MetricKeyType<any, any>>(
+    self: MetricKey.MetricKey<Type>,
+    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
+  ) => MetricKey.MetricKey<Type>
+>(2, (self, extraTags) =>
+  extraTags.length === 0
+    ? self
+    : new MetricKeyImpl(self.name, self.keyType, self.description, Arr.union(self.tags, extraTags)))

backend/node_modules/effect/src/internal/metric/keyType.ts

@@ -0,0 +1,238 @@
+import * as Duration from "../../Duration.js"
+import * as Equal from "../../Equal.js"
+import { pipe } from "../../Function.js"
+import * as Hash from "../../Hash.js"
+import type * as MetricBoundaries from "../../MetricBoundaries.js"
+import type * as MetricKeyType from "../../MetricKeyType.js"
+import { pipeArguments } from "../../Pipeable.js"
+import { hasProperty } from "../../Predicate.js"
+
+/** @internal */
+const MetricKeyTypeSymbolKey = "effect/MetricKeyType"
+
+/** @internal */
+export const MetricKeyTypeTypeId: MetricKeyType.MetricKeyTypeTypeId = Symbol.for(
+  MetricKeyTypeSymbolKey
+) as MetricKeyType.MetricKeyTypeTypeId
+
+/** @internal */
+const CounterKeyTypeSymbolKey = "effect/MetricKeyType/Counter"
+
+/** @internal */
+export const CounterKeyTypeTypeId: MetricKeyType.CounterKeyTypeTypeId = Symbol.for(
+  CounterKeyTypeSymbolKey
+) as MetricKeyType.CounterKeyTypeTypeId
+
+/** @internal */
+const FrequencyKeyTypeSymbolKey = "effect/MetricKeyType/Frequency"
+
+/** @internal */
+export const FrequencyKeyTypeTypeId: MetricKeyType.FrequencyKeyTypeTypeId = Symbol.for(
+  FrequencyKeyTypeSymbolKey
+) as MetricKeyType.FrequencyKeyTypeTypeId
+
+/** @internal */
+const GaugeKeyTypeSymbolKey = "effect/MetricKeyType/Gauge"
+
+/** @internal */
+export const GaugeKeyTypeTypeId: MetricKeyType.GaugeKeyTypeTypeId = Symbol.for(
+  GaugeKeyTypeSymbolKey
+) as MetricKeyType.GaugeKeyTypeTypeId
+
+/** @internal */
+const HistogramKeyTypeSymbolKey = "effect/MetricKeyType/Histogram"
+
+/** @internal */
+export const HistogramKeyTypeTypeId: MetricKeyType.HistogramKeyTypeTypeId = Symbol.for(
+  HistogramKeyTypeSymbolKey
+) as MetricKeyType.HistogramKeyTypeTypeId
+
+/** @internal */
+const SummaryKeyTypeSymbolKey = "effect/MetricKeyType/Summary"
+
+/** @internal */
+export const SummaryKeyTypeTypeId: MetricKeyType.SummaryKeyTypeTypeId = Symbol.for(
+  SummaryKeyTypeSymbolKey
+) as MetricKeyType.SummaryKeyTypeTypeId
+
+const metricKeyTypeVariance = {
+  /* c8 ignore next */
+  _In: (_: unknown) => _,
+  /* c8 ignore next */
+  _Out: (_: never) => _
+}
+
+/** @internal */
+class CounterKeyType<A extends (number | bigint)> implements MetricKeyType.MetricKeyType.Counter<A> {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [CounterKeyTypeTypeId]: MetricKeyType.CounterKeyTypeTypeId = CounterKeyTypeTypeId
+  constructor(readonly incremental: boolean, readonly bigint: boolean) {
+    this._hash = Hash.string(CounterKeyTypeSymbolKey)
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isCounterKey(that)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const FrequencyKeyTypeHash = Hash.string(FrequencyKeyTypeSymbolKey)
+
+/** @internal */
+class FrequencyKeyType implements MetricKeyType.MetricKeyType.Frequency {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId
+  constructor(readonly preregisteredWords: ReadonlyArray<string>) {}
+  [Hash.symbol](): number {
+    return FrequencyKeyTypeHash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isFrequencyKey(that)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const GaugeKeyTypeHash = Hash.string(GaugeKeyTypeSymbolKey)
+
+/** @internal */
+class GaugeKeyType<A extends (number | bigint)> implements MetricKeyType.MetricKeyType.Gauge<A> {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [GaugeKeyTypeTypeId]: MetricKeyType.GaugeKeyTypeTypeId = GaugeKeyTypeTypeId
+  constructor(readonly bigint: boolean) {}
+  [Hash.symbol](): number {
+    return GaugeKeyTypeHash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isGaugeKey(that)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export class HistogramKeyType implements MetricKeyType.MetricKeyType.Histogram {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [HistogramKeyTypeTypeId]: MetricKeyType.HistogramKeyTypeTypeId = HistogramKeyTypeTypeId
+  constructor(readonly boundaries: MetricBoundaries.MetricBoundaries) {
+    this._hash = pipe(
+      Hash.string(HistogramKeyTypeSymbolKey),
+      Hash.combine(Hash.hash(this.boundaries))
+    )
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isHistogramKey(that) && Equal.equals(this.boundaries, that.boundaries)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+class SummaryKeyType implements MetricKeyType.MetricKeyType.Summary {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [SummaryKeyTypeTypeId]: MetricKeyType.SummaryKeyTypeTypeId = SummaryKeyTypeTypeId
+  constructor(
+    readonly maxAge: Duration.Duration,
+    readonly maxSize: number,
+    readonly error: number,
+    readonly quantiles: ReadonlyArray<number>
+  ) {
+    this._hash = pipe(
+      Hash.string(SummaryKeyTypeSymbolKey),
+      Hash.combine(Hash.hash(this.maxAge)),
+      Hash.combine(Hash.hash(this.maxSize)),
+      Hash.combine(Hash.hash(this.error)),
+      Hash.combine(Hash.array(this.quantiles))
+    )
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isSummaryKey(that) &&
+      Equal.equals(this.maxAge, that.maxAge) &&
+      this.maxSize === that.maxSize &&
+      this.error === that.error &&
+      Equal.equals(this.quantiles, that.quantiles)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const counter: <A extends number | bigint>(options?: {
+  readonly bigint: boolean
+  readonly incremental: boolean
+}) => CounterKeyType<A> = (options) =>
+  new CounterKeyType(
+    options?.incremental ?? false,
+    options?.bigint ?? false
+  )
+
+/** @internal */
+export const frequency = (options?: {
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): MetricKeyType.MetricKeyType.Frequency => new FrequencyKeyType(options?.preregisteredWords ?? [])
+
+/** @internal */
+export const gauge: <A extends number | bigint>(options?: {
+  readonly bigint: boolean
+}) => GaugeKeyType<A> = (options) =>
+  new GaugeKeyType(
+    options?.bigint ?? false
+  )
+
+/** @internal */
+export const histogram = (boundaries: MetricBoundaries.MetricBoundaries): MetricKeyType.MetricKeyType.Histogram => {
+  return new HistogramKeyType(boundaries)
+}
+
+/** @internal */
+export const summary = (
+  options: {
+    readonly maxAge: Duration.DurationInput
+    readonly maxSize: number
+    readonly error: number
+    readonly quantiles: ReadonlyArray<number>
+  }
+): MetricKeyType.MetricKeyType.Summary => {
+  return new SummaryKeyType(Duration.decode(options.maxAge), options.maxSize, options.error, options.quantiles)
+}
+
+/** @internal */
+export const isMetricKeyType = (u: unknown): u is MetricKeyType.MetricKeyType<unknown, unknown> =>
+  hasProperty(u, MetricKeyTypeTypeId)
+
+/** @internal */
+export const isCounterKey = (u: unknown): u is MetricKeyType.MetricKeyType.Counter<number | bigint> =>
+  hasProperty(u, CounterKeyTypeTypeId)
+
+/** @internal */
+export const isFrequencyKey = (u: unknown): u is MetricKeyType.MetricKeyType.Frequency =>
+  hasProperty(u, FrequencyKeyTypeTypeId)
+
+/** @internal */
+export const isGaugeKey = (u: unknown): u is MetricKeyType.MetricKeyType.Gauge<number | bigint> =>
+  hasProperty(u, GaugeKeyTypeTypeId)
+
+/** @internal */
+export const isHistogramKey = (u: unknown): u is MetricKeyType.MetricKeyType.Histogram =>
+  hasProperty(u, HistogramKeyTypeTypeId)
+
+/** @internal */
+export const isSummaryKey = (u: unknown): u is MetricKeyType.MetricKeyType.Summary =>
+  hasProperty(u, SummaryKeyTypeTypeId)

backend/node_modules/effect/src/internal/metric/registry.ts

@@ -0,0 +1,187 @@
+import { pipe } from "../../Function.js"
+import type * as MetricHook from "../../MetricHook.js"
+import type * as MetricKey from "../../MetricKey.js"
+import type * as MetricKeyType from "../../MetricKeyType.js"
+import type * as MetricPair from "../../MetricPair.js"
+import type * as MetricRegistry from "../../MetricRegistry.js"
+import * as MutableHashMap from "../../MutableHashMap.js"
+import * as Option from "../../Option.js"
+import * as metricHook from "./hook.js"
+import * as metricKeyType from "./keyType.js"
+import * as metricPair from "./pair.js"
+
+/** @internal */
+const MetricRegistrySymbolKey = "effect/MetricRegistry"
+
+/** @internal */
+export const MetricRegistryTypeId: MetricRegistry.MetricRegistryTypeId = Symbol.for(
+  MetricRegistrySymbolKey
+) as MetricRegistry.MetricRegistryTypeId
+
+/** @internal */
+class MetricRegistryImpl implements MetricRegistry.MetricRegistry {
+  readonly [MetricRegistryTypeId]: MetricRegistry.MetricRegistryTypeId = MetricRegistryTypeId
+
+  private map = MutableHashMap.empty<
+    MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
+    MetricHook.MetricHook.Root
+  >()
+
+  snapshot(): Array<MetricPair.MetricPair.Untyped> {
+    const result: Array<MetricPair.MetricPair.Untyped> = []
+    for (const [key, hook] of this.map) {
+      result.push(metricPair.unsafeMake(key, hook.get()))
+    }
+    return result
+  }
+
+  get<Type extends MetricKeyType.MetricKeyType<any, any>>(
+    key: MetricKey.MetricKey<Type>
+  ): MetricHook.MetricHook<
+    MetricKeyType.MetricKeyType.InType<typeof key["keyType"]>,
+    MetricKeyType.MetricKeyType.OutType<typeof key["keyType"]>
+  > {
+    const hook = pipe(
+      this.map,
+      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
+      Option.getOrUndefined
+    )
+    if (hook == null) {
+      if (metricKeyType.isCounterKey(key.keyType)) {
+        return this.getCounter(key as unknown as MetricKey.MetricKey.Counter<any>) as any
+      }
+      if (metricKeyType.isGaugeKey(key.keyType)) {
+        return this.getGauge(key as unknown as MetricKey.MetricKey.Gauge<any>) as any
+      }
+      if (metricKeyType.isFrequencyKey(key.keyType)) {
+        return this.getFrequency(key as unknown as MetricKey.MetricKey.Frequency) as any
+      }
+      if (metricKeyType.isHistogramKey(key.keyType)) {
+        return this.getHistogram(key as unknown as MetricKey.MetricKey.Histogram) as any
+      }
+      if (metricKeyType.isSummaryKey(key.keyType)) {
+        return this.getSummary(key as unknown as MetricKey.MetricKey.Summary) as any
+      }
+      throw new Error(
+        "BUG: MetricRegistry.get - unknown MetricKeyType - please report an issue at https://github.com/Effect-TS/effect/issues"
+      )
+    } else {
+      return hook as any
+    }
+  }
+
+  getCounter<A extends (number | bigint)>(key: MetricKey.MetricKey.Counter<A>): MetricHook.MetricHook.Counter<A> {
+    let value = pipe(
+      this.map,
+      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
+      Option.getOrUndefined
+    )
+    if (value == null) {
+      const counter = metricHook.counter(key)
+      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
+        pipe(
+          this.map,
+          MutableHashMap.set(
+            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
+            counter as MetricHook.MetricHook.Root
+          )
+        )
+      }
+      value = counter
+    }
+    return value as MetricHook.MetricHook.Counter<A>
+  }
+
+  getFrequency(key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency {
+    let value = pipe(
+      this.map,
+      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
+      Option.getOrUndefined
+    )
+    if (value == null) {
+      const frequency = metricHook.frequency(key)
+      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
+        pipe(
+          this.map,
+          MutableHashMap.set(
+            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
+            frequency as MetricHook.MetricHook.Root
+          )
+        )
+      }
+      value = frequency
+    }
+    return value as MetricHook.MetricHook.Frequency
+  }
+
+  getGauge<A extends (number | bigint)>(key: MetricKey.MetricKey.Gauge<A>): MetricHook.MetricHook.Gauge<A> {
+    let value = pipe(
+      this.map,
+      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
+      Option.getOrUndefined
+    )
+    if (value == null) {
+      const gauge = metricHook.gauge(key as any, key.keyType.bigint ? BigInt(0) as any : 0)
+      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
+        pipe(
+          this.map,
+          MutableHashMap.set(
+            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
+            gauge as MetricHook.MetricHook.Root
+          )
+        )
+      }
+      value = gauge
+    }
+    return value as MetricHook.MetricHook.Gauge<A>
+  }
+
+  getHistogram(key: MetricKey.MetricKey.Histogram): MetricHook.MetricHook.Histogram {
+    let value = pipe(
+      this.map,
+      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
+      Option.getOrUndefined
+    )
+    if (value == null) {
+      const histogram = metricHook.histogram(key)
+      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
+        pipe(
+          this.map,
+          MutableHashMap.set(
+            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
+            histogram as MetricHook.MetricHook.Root
+          )
+        )
+      }
+      value = histogram
+    }
+    return value as MetricHook.MetricHook.Histogram
+  }
+
+  getSummary(key: MetricKey.MetricKey.Summary): MetricHook.MetricHook.Summary {
+    let value = pipe(
+      this.map,
+      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
+      Option.getOrUndefined
+    )
+    if (value == null) {
+      const summary = metricHook.summary(key)
+      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
+        pipe(
+          this.map,
+          MutableHashMap.set(
+            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
+            summary as MetricHook.MetricHook.Root
+          )
+        )
+      }
+      value = summary
+    }
+    return value as MetricHook.MetricHook.Summary
+  }
+}
+
+/** @internal */
+export const make = (): MetricRegistry.MetricRegistry => {
+  return new MetricRegistryImpl()
+}

backend/node_modules/effect/src/internal/opCodes/channelChildExecutorDecision.ts

@@ -0,0 +1,17 @@
+/** @internal */
+export const OP_CONTINUE = "Continue" as const
+
+/** @internal */
+export type OP_CONTINUE = typeof OP_CONTINUE
+
+/** @internal */
+export const OP_CLOSE = "Close" as const
+
+/** @internal */
+export type OP_CLOSE = typeof OP_CLOSE
+
+/** @internal */
+export const OP_YIELD = "Yield" as const
+
+/** @internal */
+export type OP_YIELD = typeof OP_YIELD

backend/node_modules/effect/src/internal/opCodes/channelMergeState.ts

@@ -0,0 +1,17 @@
+/** @internal */
+export const OP_BOTH_RUNNING = "BothRunning" as const
+
+/** @internal */
+export type OP_BOTH_RUNNING = typeof OP_BOTH_RUNNING
+
+/** @internal */
+export const OP_LEFT_DONE = "LeftDone" as const
+
+/** @internal */
+export type OP_LEFT_DONE = typeof OP_LEFT_DONE
+
+/** @internal */
+export const OP_RIGHT_DONE = "RightDone" as const
+
+/** @internal */
+export type OP_RIGHT_DONE = typeof OP_RIGHT_DONE

backend/node_modules/effect/src/internal/opCodes/effect.ts

@@ -0,0 +1,89 @@
+/** @internal */
+export type OP_ASYNC = typeof OP_ASYNC
+
+/** @internal */
+export const OP_ASYNC = "Async" as const
+
+/** @internal */
+export type OP_COMMIT = typeof OP_COMMIT
+
+/** @internal */
+export const OP_COMMIT = "Commit" as const
+
+/** @internal */
+export type OP_FAILURE = typeof OP_FAILURE
+
+/** @internal */
+export const OP_FAILURE = "Failure" as const
+
+/** @internal */
+export type OP_ON_FAILURE = typeof OP_ON_FAILURE
+
+/** @internal */
+export const OP_ON_FAILURE = "OnFailure" as const
+
+/** @internal */
+export type OP_ON_SUCCESS = typeof OP_ON_SUCCESS
+
+/** @internal */
+export const OP_ON_SUCCESS = "OnSuccess" as const
+
+/** @internal */
+export type OP_ON_SUCCESS_AND_FAILURE = typeof OP_ON_SUCCESS_AND_FAILURE
+
+/** @internal */
+export const OP_ON_SUCCESS_AND_FAILURE = "OnSuccessAndFailure" as const
+
+/** @internal */
+export type OP_SUCCESS = typeof OP_SUCCESS
+
+/** @internal */
+export const OP_SUCCESS = "Success" as const
+
+/** @internal */
+export type OP_SYNC = typeof OP_SYNC
+
+/** @internal */
+export const OP_SYNC = "Sync" as const
+
+/** @internal */
+export const OP_TAG = "Tag" as const
+
+/** @internal */
+export type OP_TAG = typeof OP_TAG
+
+/** @internal */
+export type OP_UPDATE_RUNTIME_FLAGS = typeof OP_UPDATE_RUNTIME_FLAGS
+
+/** @internal */
+export const OP_UPDATE_RUNTIME_FLAGS = "UpdateRuntimeFlags" as const
+
+/** @internal */
+export type OP_WHILE = typeof OP_WHILE
+
+/** @internal */
+export const OP_WHILE = "While" as const
+
+/** @internal */
+export type OP_ITERATOR = typeof OP_ITERATOR
+
+/** @internal */
+export const OP_ITERATOR = "Iterator" as const
+
+/** @internal */
+export type OP_WITH_RUNTIME = typeof OP_WITH_RUNTIME
+
+/** @internal */
+export const OP_WITH_RUNTIME = "WithRuntime" as const
+
+/** @internal */
+export type OP_YIELD = typeof OP_YIELD
+
+/** @internal */
+export const OP_YIELD = "Yield" as const
+
+/** @internal */
+export type OP_REVERT_FLAGS = typeof OP_REVERT_FLAGS
+
+/** @internal */
+export const OP_REVERT_FLAGS = "RevertFlags" as const

backend/node_modules/effect/src/internal/opCodes/layer.ts

@@ -0,0 +1,59 @@
+/** @internal */
+export const OP_EXTEND_SCOPE = "ExtendScope" as const
+
+/** @internal */
+export type OP_EXTEND_SCOPE = typeof OP_EXTEND_SCOPE
+
+/** @internal */
+export const OP_FOLD = "Fold" as const
+
+/** @internal */
+export type OP_FOLD = typeof OP_FOLD
+
+/** @internal */
+export const OP_FRESH = "Fresh" as const
+
+/** @internal */
+export type OP_FRESH = typeof OP_FRESH
+
+/** @internal */
+export const OP_FROM_EFFECT = "FromEffect" as const
+
+/** @internal */
+export type OP_FROM_EFFECT = typeof OP_FROM_EFFECT
+
+/** @internal */
+export const OP_SCOPED = "Scoped" as const
+
+/** @internal */
+export type OP_SCOPED = typeof OP_SCOPED
+
+/** @internal */
+export const OP_SUSPEND = "Suspend" as const
+
+/** @internal */
+export type OP_SUSPEND = typeof OP_SUSPEND
+
+/** @internal */
+export const OP_PROVIDE = "Provide" as const
+
+/** @internal */
+export type OP_PROVIDE = typeof OP_PROVIDE
+
+/** @internal */
+export const OP_PROVIDE_MERGE = "ProvideMerge" as const
+
+/** @internal */
+export type OP_PROVIDE_MERGE = typeof OP_PROVIDE_MERGE
+
+/** @internal */
+export const OP_MERGE_ALL = "MergeAll" as const
+
+/** @internal */
+export type OP_MERGE_ALL = typeof OP_MERGE_ALL
+
+/** @internal */
+export const OP_ZIP_WITH = "ZipWith" as const
+
+/** @internal */
+export type OP_ZIP_WITH = typeof OP_ZIP_WITH

backend/src/app.js

@@ -0,0 +1,78 @@
+/**
+ * Aplicacion Express principal — configuracion de middlewares y montaje de rutas.
+ *
+ * Middlewares aplicados (en orden):
+ *   1. helmet()            — headers de seguridad (X-Frame-Options, HSTS, etc.).
+ *   2. cors()              — CORS con origen configurable (CORS_ORIGIN).
+ *   3. rateLimit()         — 200 peticiones / 15 min por IP.
+ *   4. express.json()      — parseo de JSON con limite de 1 MB.
+ *
+ * Rutas REST montadas bajo /api/v1:
+ *   - /auth       → login, perfil (auth.routes.js)
+ *   - /markets    → listado y detalle de mercados (markets.routes.js)
+ *   - /markets    → senales IA por mercado (signals.routes.js, subruta)
+ *   - /positions  → simulador de posiciones virtuales (positions.routes.js)
+ *   - /watchlist  → lista de seguimiento (watchlist.routes.js)
+ *   - /alerts     → historial de alertas (alerts.routes.js)
+ *   - /health     → healthcheck basico
+ *
+ * Manejo de errores:
+ *   - notFound      → 404 para rutas no definidas.
+ *   - errorHandler  → 500 generico en produccion, detalles en desarrollo.
+ */
+
+import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import rateLimit from 'express-rate-limit';
+import { config } from './config.js';
+import { ok } from './utils/apiResponse.js';
+import authRoutes from './auth/auth.routes.js';
+import marketsRoutes from './markets/markets.routes.js';
+import signalsRoutes from './signals/signals.routes.js';
+import positionsRoutes from './positions/positions.routes.js';
+import watchlistRoutes from './watchlist/watchlist.routes.js';
+import alertsRoutes from './alerts/alerts.routes.js';
+import statsRoutes from './stats/stats.routes.js';
+import { notFound } from './middlewares/notFound.js';
+import { errorHandler } from './middlewares/errorHandler.js';
+
+const app = express();
+
+app.use(helmet());
+app.use(cors({ origin: config.CORS_ORIGIN, credentials: true }));
+
+// Rate limit: muy permisivo en desarrollo, restrictivo en producción
+const rateLimitMax = config.NODE_ENV === 'production' ? 200 : 5000;
+app.use(
+  rateLimit({
+    windowMs: 15 * 60 * 1000,
+    max: rateLimitMax,
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: { ok: false, error: { code: 'TOO_MANY_REQUESTS', message: 'Rate limit exceeded' } },
+  }),
+);
+app.use(express.json({ limit: '1mb' }));
+
+app.get('/api/v1/health', (_req, res) => ok(res, { status: 'up' }));
+app.use('/api/v1/auth', authRoutes);
+app.use('/api/v1/markets', marketsRoutes);
+app.use('/api/v1/markets', signalsRoutes);
+app.use('/api/v1/positions', positionsRoutes);
+app.use('/api/v1/watchlist', watchlistRoutes);
+app.use('/api/v1/alerts', alertsRoutes);
+app.use('/api/v1/stats', statsRoutes);
+
+// Servir frontend estático en producción (HuggingFace Spaces)
+if (config.NODE_ENV === 'production') {
+  app.use(express.static('../frontend/dist'));
+  app.get('*', (_req, res) => {
+    res.sendFile('index.html', { root: '../frontend/dist' });
+  });
+}
+
+app.use(notFound);
+app.use(errorHandler);
+
+export default app;

backend/src/auth/auth.controller.js

@@ -0,0 +1,29 @@
+/**
+ * Controladores del modulo de autenticacion.
+ *
+ * Responsabilidades:
+ *   - login  → recibir credenciales, delegar validacion a auth.service.js,
+ *              responder con { token, user }.
+ *   - me     → devolver el usuario autenticado extraido del JWT (req.user).
+ *
+ * Errores:
+ *   - 401 INVALID_CREDENTIALS → email o password incorrectos (mensaje generico).
+ *   - 401 UNAUTHORIZED        → token invalido o ausente (en requireAuth).
+ */
+
+import * as authService from './auth.service.js';
+import { ok } from '../utils/apiResponse.js';
+
+export const login = async (req, res) => {
+  const data = await authService.login(req.body);
+  ok(res, data);
+};
+
+export const register = async (req, res) => {
+  const data = await authService.register(req.body);
+  ok(res, data);
+};
+
+export const me = async (req, res) => {
+  ok(res, { user: req.user });
+};

backend/src/auth/auth.routes.js

@@ -0,0 +1,30 @@
+/**
+ * Rutas REST de autenticacion.
+ *
+ * Endpoints:
+ *   POST /api/v1/auth/login
+ *     → rateLimitLogin (5 intentos / 15 min)
+ *     → validate(loginSchema)
+ *     → authController.login
+ *     → Devuelve JWT + objeto usuario.
+ *
+ *   GET /api/v1/auth/me
+ *     → requireAuth
+ *     → authController.me
+ *     → Devuelve el usuario autenticado (req.user).
+ */
+
+import { Router } from 'express';
+import * as ctrl from './auth.controller.js';
+import { loginSchema, registerSchema } from './auth.validators.js';
+import { validate } from '../middlewares/validate.js';
+import { requireAuth } from '../middlewares/requireAuth.js';
+import { rateLimitLogin } from '../middlewares/rateLimitLogin.js';
+
+const router = Router();
+
+router.post('/login', rateLimitLogin, validate(loginSchema), ctrl.login);
+router.post('/register', validate(registerSchema), ctrl.register);
+router.get('/me', requireAuth, ctrl.me);
+
+export default router;

backend/src/auth/auth.service.js

@@ -0,0 +1,57 @@
+/**
+ * Logica de negocio del modulo de autenticacion.
+ *
+ * Responsabilidades:
+ *   - login({ email, password }) → buscar usuario, comparar hash con bcrypt,
+ *     verificar que este activo (isActive) y firmar JWT.
+ *
+ * Seguridad:
+ *   - Mensaje generico en fallo ("Email or password is incorrect")
+ *     para no revelar si el email existe.
+ *   - Bcrypt con salt rounds configurable (BCRYPT_ROUNDS, default 10).
+ *   - JWT firmado con HS256 y expiracion (JWT_EXPIRES_IN).
+ *
+ * Devuelve:
+ *   { token: string, user: { id, email } }
+ */
+
+import bcrypt from 'bcryptjs';
+import { prisma } from '../utils/prisma.js';
+import { HttpError } from '../utils/apiResponse.js';
+import { signToken } from './jwt.js';
+
+const INVALID_CREDENTIALS = new HttpError(401, 'INVALID_CREDENTIALS', 'Email or password is incorrect');
+
+export const login = async ({ email, password }) => {
+  const user = await prisma.user.findUnique({ where: { email } });
+  if (!user || !user.isActive) throw INVALID_CREDENTIALS;
+
+  const passwordOk = await bcrypt.compare(password, user.passwordHash);
+  if (!passwordOk) throw INVALID_CREDENTIALS;
+
+  const token = signToken({ sub: user.id, email: user.email });
+
+  return {
+    token,
+    user: { id: user.id, email: user.email },
+  };
+};
+
+export const register = async ({ email, password }) => {
+  const existing = await prisma.user.findUnique({ where: { email } });
+  if (existing) {
+    throw new HttpError(409, 'EMAIL_EXISTS', 'Email already registered');
+  }
+
+  const passwordHash = await bcrypt.hash(password, 10);
+  const user = await prisma.user.create({
+    data: { email, passwordHash, isActive: true },
+  });
+
+  const token = signToken({ sub: user.id, email: user.email });
+
+  return {
+    token,
+    user: { id: user.id, email: user.email },
+  };
+};

backend/src/auth/auth.validators.js

@@ -0,0 +1,22 @@
+/**
+ * Esquemas Zod para validar inputs del modulo de autenticacion.
+ *
+ * Responsabilidades:
+ *   - loginSchema: validar email (formato correcto, lowercase, trim)
+ *                  y password (minimo 8 caracteres).
+ *
+ * Consumido por:
+ *   - auth.routes.js → validate(loginSchema) en POST /login.
+ */
+
+import { z } from 'zod';
+
+export const loginSchema = z.object({
+  email: z.string().email('Invalid email').toLowerCase().trim(),
+  password: z.string().min(8, 'Password must be at least 8 characters'),
+});
+
+export const registerSchema = z.object({
+  email: z.string().email('Invalid email').toLowerCase().trim(),
+  password: z.string().min(8, 'Password must be at least 8 characters'),
+});

backend/src/auth/jwt.js

@@ -0,0 +1,27 @@
+/**
+ * Helpers para firmar y verificar tokens JWT.
+ *
+ * Responsabilidades:
+ *   - signToken(payload)  → firma un token HS256 con expiracion configurable.
+ *   - verifyToken(token)  → verifica firma, expiracion y algoritmo (solo HS256).
+ *
+ * Consumido por:
+ *   - auth.service.js   → al hacer login exitoso.
+ *   - requireAuth.js    → en cada peticion protegida.
+ *
+ * Configuracion:
+ *   - JWT_SECRET    : minimo 32 chars (validado en config.js).
+ *   - JWT_EXPIRES_IN: default '1h'.
+ */
+
+import jwt from 'jsonwebtoken';
+import { config } from '../config.js';
+
+export const signToken = (payload) =>
+  jwt.sign(payload, config.JWT_SECRET, {
+    algorithm: 'HS256',
+    expiresIn: config.JWT_EXPIRES_IN,
+  });
+
+export const verifyToken = (token) =>
+  jwt.verify(token, config.JWT_SECRET, { algorithms: ['HS256'] });

backend/src/index.js

@@ -0,0 +1,46 @@
+/**
+ * Entry point de la aplicacion PolySignal.
+ *
+ * Inicializa el servidor HTTP nativo de Node.js, monta Express sobre el,
+ * configura Socket.io para comunicacion en tiempo real, arranca el scheduler
+ * de tareas periodicas (node-cron) y gestiona el cierre limpio ante SIGTERM/SIGINT.
+ *
+ * Flujo de arranque:
+ *   1. Crear servidor HTTP y adjuntar Express (app.js).
+ *   2. Inicializar Socket.io con CORS permitido desde CORS_ORIGIN.
+ *   3. Conectar el broadcaster (socket/broadcaster.js) para emitir eventos.
+ *   4. Escuchar en el puerto configurado (default 7860 para HF Spaces).
+ *   5. En modo no-test, iniciar scheduler (sync mercados, senales IA, PnL, alertas).
+ *
+ * Puerto por defecto: 7860 (requerido por HuggingFace Spaces).
+ */
+
+import http from 'node:http';
+import { Server as IOServer } from 'socket.io';
+import app from './app.js';
+import { config } from './config.js';
+import { logger } from './utils/logger.js';
+import { prisma } from './utils/prisma.js';
+import { attachBroadcaster } from './socket/broadcaster.js';
+import { startScheduler } from './scheduler.js';
+
+const httpServer = http.createServer(app);
+const io = new IOServer(httpServer, { cors: { origin: config.CORS_ORIGIN } });
+attachBroadcaster(io);
+
+httpServer.listen(config.PORT, () => {
+  logger.info({ port: config.PORT, env: config.NODE_ENV }, 'PolySignal backend up');
+});
+
+if (config.NODE_ENV !== 'test') {
+  startScheduler();
+}
+
+for (const sig of ['SIGTERM', 'SIGINT']) {
+  process.on(sig, async () => {
+    logger.info({ sig }, 'shutting down');
+    httpServer.close();
+    await prisma.$disconnect();
+    process.exit(0);
+  });
+}

backend/src/scheduler.js

@@ -0,0 +1,83 @@
+/**
+ * Scheduler de tareas periodicas usando node-cron.
+ *
+ * Define y ejecuta los 4 jobs principales del backend:
+ *   1. syncMarkets        — cada 30s, sincroniza precios desde Polymarket Gamma API.
+ *   2. generateSignals    — cada 5 min, genera senales IA para el top 20 mercados activos.
+ *   3. updatePositionsPnL — cada 30s, recalcula P&L de posiciones abiertas.
+ *   4. processAlerts      — cada 60s, revisa watchlist y envia alertas por Telegram.
+ *
+ * Cada job captura sus propios errores para evitar que un fallo afecte a los demas.
+ * Se ejecuta inmediatamente al arrancar (llamada manual) y luego segun cron.
+ */
+
+import { schedule } from 'node-cron';
+import { fetchActiveMarkets } from './markets/polymarket.client.js';
+import { marketsRepository } from './markets/markets.repository.js';
+import { signalsService } from './signals/signals.service.js';
+import { positionsService } from './positions/positions.service.js';
+import { alertsService } from './alerts/alerts.service.js';
+import { emitMarketUpdate } from './socket/broadcaster.js';
+import { logger } from './utils/logger.js';
+
+async function syncMarkets() {
+  try {
+    const markets = await fetchActiveMarkets();
+    await Promise.all(markets.map((m) => marketsRepository.upsert(m)));
+    // Purga mercados activos que no aparecieron en este sync (restos de syncs previos)
+    const deactivated = await marketsRepository.deactivateStale(markets.map((m) => m.id));
+    for (const m of markets) {
+      emitMarketUpdate({ marketId: m.id, yesPrice: m.yesPrice, noPrice: m.noPrice, volumeEur: m.volumeEur });
+    }
+    logger.info({ count: markets.length, deactivated }, 'markets synced');
+  } catch (err) {
+    logger.error({ err: err.message }, 'syncMarkets failed');
+  }
+}
+
+async function generateSignals() {
+  try {
+    // Seleccion diversificada por categoria + liquidez (40 mercados/ciclo)
+    const markets = await marketsRepository.findDiversified(40);
+    const byCategory = markets.reduce((acc, m) => {
+      acc[m.category] = (acc[m.category] || 0) + 1;
+      return acc;
+    }, {});
+    logger.info({ total: markets.length, byCategory }, 'generating signals for diversified set');
+
+    for (const market of markets) {
+      try {
+        await signalsService.generateForMarket(market);
+      } catch (err) {
+        logger.error({ err: err.message, marketId: market.id }, 'signal generation failed for market');
+      }
+    }
+  } catch (err) {
+    logger.error({ err: err.message }, 'generateSignals failed');
+  }
+}
+
+async function updatePositionsPnL() {
+  try {
+    await positionsService.updateAllPnL();
+  } catch (err) {
+    logger.error({ err: err.message }, 'updatePositionsPnL failed');
+  }
+}
+
+async function processAlerts() {
+  try {
+    await alertsService.processAll();
+  } catch (err) {
+    logger.error({ err: err.message }, 'processAlerts failed');
+  }
+}
+
+export function startScheduler() {
+  syncMarkets();
+  schedule('*/30 * * * * *', syncMarkets);
+  schedule('*/5 * * * *', generateSignals);
+  schedule('*/30 * * * * *', updatePositionsPnL);
+  schedule('* * * * *', processAlerts);
+  logger.info('scheduler started');
+}

backend/src/signals/signals.controller.js

@@ -0,0 +1,30 @@
+/**
+ * Controladores del modulo de senales IA.
+ *
+ * Responsabilidades:
+ *   - getLatest(req, res) → devuelve la senal mas reciente de un mercado.
+ *
+ * Endpoint:
+ *   GET /api/v1/markets/:marketId/signal
+ *
+ * Errores:
+ *   - 404 NOT_FOUND si el mercado no existe.
+ *   - 404 NOT_FOUND si aun no hay senal generada para ese mercado.
+ */
+
+import { ok } from '../utils/apiResponse.js';
+import { signalsService } from './signals.service.js';
+
+export const signalsController = {
+  async getLatest(req, res) {
+    const signal = await signalsService.getLatest(req.params.marketId);
+    ok(res, signal);
+  },
+
+  async getLatestBatch(req, res) {
+    const ids = req.query.marketIds;
+    const marketIds = ids ? ids.split(',').filter(Boolean) : [];
+    const signals = await signalsService.getLatestBatch(marketIds);
+    ok(res, signals);
+  },
+};

backend/src/signals/signals.repository.js

@@ -0,0 +1,45 @@
+/**
+ * Repositorio de acceso a datos para el modelo AISignal.
+ *
+ * Responsabilidades:
+ *   - create(data)          → inserta una nueva senal generada por IA.
+ *   - findLatestByMarket(id) → devuelve la senal mas reciente de un mercado.
+ *
+ * Campos persistidos:
+ *   signal, confidence, summary, keyRisk, newsCount, modelVersion, generatedAt.
+ *
+ * Todas las operaciones usan Prisma ORM.
+ */
+
+import { prisma } from '../utils/prisma.js';
+
+export const signalsRepository = {
+  create({ marketId, signal, confidence, summary, keyRisk, newsCount, modelVersion, impliedProb, fairProb, edgePoints }) {
+    return prisma.aISignal.create({
+      data: { marketId, signal, confidence, summary, keyRisk, newsCount, modelVersion, impliedProb, fairProb, edgePoints },
+    });
+  },
+
+  findLatestByMarket(marketId) {
+    return prisma.aISignal.findFirst({
+      where: { marketId },
+      orderBy: { generatedAt: 'desc' },
+    });
+  },
+
+  findLatestForMarkets(marketIds) {
+    if (!marketIds || marketIds.length === 0) return Promise.resolve([]);
+    return prisma.aISignal.findMany({
+      where: { marketId: { in: marketIds } },
+      orderBy: [{ marketId: 'asc' }, { generatedAt: 'desc' }],
+    }).then((rows) => {
+      // Tomar solo la más reciente por marketId
+      const seen = new Set();
+      return rows.filter((r) => {
+        if (seen.has(r.marketId)) return false;
+        seen.add(r.marketId);
+        return true;
+      });
+    });
+  },
+};

backend/src/signals/signals.routes.js

@@ -0,0 +1,22 @@
+/**
+ * Rutas REST del modulo de senales IA.
+ *
+ * Endpoint (montado en /api/v1/markets):
+ *   GET /:marketId/signal → senal mas reciente del mercado.
+ *
+ * No requiere autenticacion (datos publicos).
+ */
+
+import { Router } from 'express';
+import { signalsController } from './signals.controller.js';
+
+const router = Router();
+
+// Batch: últimas señales para múltiples mercados (debe ir ANTES de la ruta dinámica)
+// mounted at /api/v1/markets → full path: GET /api/v1/markets/signals/latest?marketIds=id1,id2
+router.get('/signals/latest', signalsController.getLatestBatch);
+
+// mounted at /api/v1/markets → full path: GET /api/v1/markets/:marketId/signal
+router.get('/:marketId/signal', signalsController.getLatest);
+
+export default router;