@livefolio/sdk 0.4.0 → 0.4.2

package/dist/index.d.ts

@@ -577,6 +577,11 @@ type PriceMap = ReadonlyMap<AssetId, number>;
  *   value and existing share counts.
  * @param prices - Current prices for all assets that appear in `targets` or are
  *   currently held. Throws `Error` if a target asset is missing from this map.
+ * @param assets - Optional canonical {@link Asset} metadata keyed by id. When
+ *   `reconcile` needs to emit an order for an asset that is not yet held in the
+ *   portfolio, it consults this map for the proper `symbol`/`kind`. If the
+ *   asset is missing here too, the order falls back to a synthesized
+ *   `{ kind: 'equity', id, symbol: id }` — lossless but display-unfriendly.
  * @returns A readonly array of `RebalanceOrder` objects. The array may be empty
  *   if the portfolio is already at the target allocation. Order IDs are
  *   deterministic within a single call (`rebal_<assetId>_<counter>`).
@@ -603,7 +608,7 @@ type PriceMap = ReadonlyMap<AssetId, number>;
  * // ]
  * ```
  */
-declare function reconcile(targets: TargetWeights, portfolio: Portfolio, prices: PriceMap): ReadonlyArray<RebalanceOrder>;
+declare function reconcile(targets: TargetWeights, portfolio: Portfolio, prices: PriceMap, assets?: ReadonlyMap<AssetId, Asset>): ReadonlyArray<RebalanceOrder>;
 
 /**
  * A flat record of fundamental data points for an asset at a point in time.
@@ -1884,6 +1889,100 @@ type RunLiveOptions<F extends Features = Features, S = unknown> = {
  */
 declare function runLive<F extends Features = Features, S = unknown>(opts: RunLiveOptions<F, S>): AsyncIterable<LiveEvent<F, S>>;
 
+/**
+ * A point-in-time quote for an asset. The `t` field is the vendor-stamped
+ * quote time — callers should treat it as the staleness upper bound, not
+ * "now". `price` is the last trade price, or the mid when the vendor only
+ * exposes bid/ask. `bid` and `ask` surface Level 1 data when available.
+ *
+ * @example
+ * ```ts
+ * import type { Quote } from '@livefolio/sdk';
+ *
+ * const q: Quote = {
+ *   asset:    { kind: 'equity', id: 'AAPL', symbol: 'AAPL' },
+ *   t:        new Date('2024-06-03T13:30:00Z'),
+ *   price:    195.12,
+ *   bid:      195.11,
+ *   ask:      195.13,
+ *   currency: 'USD',
+ * };
+ * ```
+ */
+type Quote = {
+    asset: Asset;
+    /** Vendor-stamped quote time. */
+    t: Date;
+    /** Last trade price, or mid if the vendor only exposes bid/ask. */
+    price: number;
+    /** Best bid, when the vendor exposes Level 1 data. */
+    bid?: number;
+    /** Best ask, when the vendor exposes Level 1 data. */
+    ask?: number;
+    /** Quote currency, when the vendor reports it. */
+    currency?: string;
+};
+/**
+ * One-shot current-price source. Sibling interface to {@link DataFeed} and
+ * {@link StreamingDataFeed} — they are NOT a union and there is no
+ * composition helper. Historical adapters implement `DataFeed.bars()`;
+ * streaming adapters implement `StreamingDataFeed.subscribe()`; quote
+ * adapters implement `QuoteFeed.quote()`. A vendor that offers all three
+ * implements all three interfaces on one class.
+ *
+ * Implementations MUST guarantee:
+ * - `quote` returns a freshly fetched {@link Quote} each call. Implementations
+ *   MAY cache for a short TTL to coalesce bursts; cache behavior MUST be
+ *   documented on the adapter.
+ * - The returned `Quote.t` is the vendor's stamp, not the local clock.
+ * - `quote` rejects with a typed error if the asset is unsupported or the
+ *   vendor is unreachable. It MUST NOT silently return a stale or fabricated
+ *   price.
+ *
+ * `quoteBatch` is optional. Vendors whose endpoints accept a symbol list
+ * SHOULD implement it to avoid N-round-trip storms. Callers feature-detect:
+ *
+ * ```ts
+ * const quotes = feed.quoteBatch
+ *   ? await feed.quoteBatch(assets)
+ *   : await Promise.all(assets.map((a) => feed.quote(a)));
+ * ```
+ *
+ * When `quoteBatch` is implemented, the returned array MUST preserve request
+ * order — `quotes[i]` corresponds to `assets[i]`.
+ *
+ * @example
+ * ```ts
+ * import type { QuoteFeed } from '@livefolio/sdk';
+ *
+ * const feed: QuoteFeed = {
+ *   async quote(asset) {
+ *     return { asset, t: new Date(), price: 195.12 };
+ *   },
+ * };
+ * ```
+ */
+interface QuoteFeed {
+    /**
+     * Returns a freshly fetched quote for `asset`.
+     *
+     * @param asset - The instrument to quote.
+     * @returns A {@link Quote} carrying the vendor-stamped time and price.
+     */
+    quote(asset: Asset): Promise<Quote>;
+    /**
+     * Returns quotes for `assets` in a single vendor round-trip. Optional —
+     * adapters whose vendor does not expose a batch endpoint may omit this.
+     *
+     * Returned array MUST preserve request order: `result[i]` corresponds to
+     * `assets[i]`.
+     *
+     * @param assets - The instruments to quote.
+     * @returns An array of {@link Quote} objects in request order.
+     */
+    quoteBatch?(assets: ReadonlyArray<Asset>): Promise<ReadonlyArray<Quote>>;
+}
+
 /**
  * In-process, Map-backed implementation of {@link FeatureCache}. Caches
  * computed indicator series in memory for the lifetime of the instance.
@@ -2095,6 +2194,49 @@ declare class RoutingStreamingDataFeed implements StreamingDataFeed {
     private merged;
 }
 
+/**
+ * Error thrown by {@link RoutingQuoteFeed} when an asset cannot be routed.
+ */
+declare class RoutingQuoteFeedError extends Error {
+    constructor(message: string);
+}
+/** Function form of the routing rule. Returns the feed for `asset`, or `undefined` when no feed handles it. */
+type RoutingQuoteFeedRouteFn = (asset: Asset) => QuoteFeed | undefined;
+/** Map form of the routing rule. Keys are `Asset['kind']` discriminants. */
+type RoutingQuoteFeedRouteMap = Readonly<Partial<Record<Asset['kind'], QuoteFeed>>>;
+/**
+ * A {@link QuoteFeed} that delegates each call to one of several underlying
+ * feeds based on the asset. Use this to compose vendors — e.g. Alpaca for
+ * equity quotes and a polling adapter for macro series — behind a single
+ * `QuoteFeed` instance.
+ *
+ * Routing rules:
+ * - **Map form:** `new RoutingQuoteFeed({ equity: alpaca, macro: fredPolling })`.
+ *   Keys are `asset.kind` discriminants. The 90% case.
+ * - **Function form:** `new RoutingQuoteFeed((a) => a.kind === 'macro' ? fred : alpaca)`.
+ *   Use when routing depends on more than `kind` (e.g. allowlists).
+ *
+ * The router always implements `quoteBatch` — even if some inner feeds lack
+ * it, the router falls back to per-asset `quote()` calls within that group,
+ * preserving request order across the full result.
+ *
+ * @example
+ * ```ts
+ * import { RoutingQuoteFeed } from '@livefolio/sdk';
+ *
+ * const feed = new RoutingQuoteFeed({ equity: alpacaQuotes, macro: fredQuotes });
+ * const quotes = await feed.quoteBatch([aaplAsset, dgs10Asset, msftAsset]);
+ * // quotes[0] is for AAPL, quotes[1] for DGS10, quotes[2] for MSFT — request order preserved.
+ * ```
+ */
+declare class RoutingQuoteFeed implements QuoteFeed {
+    private readonly route;
+    constructor(routes: RoutingQuoteFeedRouteMap | RoutingQuoteFeedRouteFn);
+    quote(asset: Asset): Promise<Quote>;
+    quoteBatch(assets: ReadonlyArray<Asset>): Promise<ReadonlyArray<Quote>>;
+    private resolve;
+}
+
 type PollingSchedule = {
     kind: 'interval';
     intervalMs: number;
@@ -2915,6 +3057,67 @@ declare function evaluateFeatureSpecs(specs: ReadonlyArray<TacticalFeatureSpec>,
  * ```
  */
 declare function withSynthetics(dataFeed: DataFeed, synthetics: ReadonlyArray<SyntheticAsset>): DataFeed;
+/**
+ * Options for {@link withStreamingSynthetics}.
+ */
+interface WithStreamingSyntheticsOptions {
+    /**
+     * Last known close per asset id, used to seed `prevUnderlyingClose` and
+     * `prevSynthClose` so the first live tick of a synthetic continues smoothly
+     * from the end of its historical series.
+     *
+     * Build it from a {@link BacktestResult}:
+     * ```ts
+     * const seedLastCloses = new Map<AssetId, number>();
+     * for (const [id, bars] of history.bars) {
+     *   const last = bars.at(-1)?.close;
+     *   if (last !== undefined) seedLastCloses.set(id, last);
+     * }
+     * ```
+     *
+     * Without seeding, the first synthesized tick lands on the underlying's
+     * price and produces a visible jump in live preview.
+     */
+    seedLastCloses: ReadonlyMap<AssetId, number>;
+}
+/**
+ * Streaming-feed counterpart to {@link withSynthetics}. Wraps a
+ * {@link StreamingDataFeed} so that subscriptions for synthetic asset ids
+ * resolve to upstream subscriptions on the underlying, with each underlying
+ * tick re-emitted as a synthesized tick on the synthetic's id using the same
+ * `(1 + leverage × r) × (1 − expense/252)` formula as the historical wrapper.
+ *
+ * Behavior:
+ * - Non-synthetic ids in the `assets` argument pass through to the inner feed
+ *   unchanged.
+ * - Underlyings that aren't directly in `assets` but are needed by a synthetic
+ *   are subscribed silently — only the synthesized ticks are yielded back to
+ *   the caller for those.
+ * - Underlyings that the caller _did_ ask for in `assets` are yielded both as
+ *   the raw underlying tick and as the synthesized tick(s).
+ *
+ * Throws at construction time if `synthetics` contains duplicate `id` values.
+ *
+ * @example
+ * ```ts
+ * import { withStreamingSynthetics, runLive } from '@livefolio/sdk';
+ *
+ * const seedLastCloses = new Map<AssetId, number>();
+ * for (const [id, bars] of history.bars) {
+ *   const last = bars.at(-1)?.close;
+ *   if (last !== undefined) seedLastCloses.set(id, last);
+ * }
+ *
+ * const liveFeed = withStreamingSynthetics(rawStreamingFeed, spec.synthetics ?? [], {
+ *   seedLastCloses,
+ * });
+ *
+ * for await (const event of runLive({ strategy, history, dataFeed: liveFeed, executor, calendar })) {
+ *   // …
+ * }
+ * ```
+ */
+declare function withStreamingSynthetics(inner: StreamingDataFeed, synthetics: ReadonlyArray<SyntheticAsset>, opts: WithStreamingSyntheticsOptions): StreamingDataFeed;
 
 /** Test-only: reset the once-per-process deprecation gate. */
 declare function _resetTacticalDeprecationWarningForTesting(): void;
@@ -3018,15 +3221,17 @@ type index$1_TacticalFeatureSpec = TacticalFeatureSpec;
 type index$1_TacticalFeatures = TacticalFeatures;
 type index$1_TacticalSpec = TacticalSpec;
 type index$1_Tolerance = Tolerance;
+type index$1_WithStreamingSyntheticsOptions = WithStreamingSyntheticsOptions;
 declare const index$1__resetTacticalDeprecationWarningForTesting: typeof _resetTacticalDeprecationWarningForTesting;
 declare const index$1_evaluateFeatureSpecs: typeof evaluateFeatureSpecs;
 declare const index$1_evaluateRuleTree: typeof evaluateRuleTree;
 declare const index$1_fromSpec: typeof fromSpec;
 declare const index$1_isRebalanceDay: typeof isRebalanceDay;
 declare const index$1_periodKey: typeof periodKey;
+declare const index$1_withStreamingSynthetics: typeof withStreamingSynthetics;
 declare const index$1_withSynthetics: typeof withSynthetics;
 declare namespace index$1 {
-  export { type index$1_AllocateNode as AllocateNode, type index$1_AssetRef as AssetRef, type index$1_Comparison as Comparison, type index$1_ComparisonOp as ComparisonOp, type index$1_FeatureRef as FeatureRef, type index$1_FromSpecOptions as FromSpecOptions, type index$1_IfNode as IfNode, type index$1_RebalanceConfig as RebalanceConfig, type index$1_RebalanceFrequency as RebalanceFrequency, type index$1_RuleNode as RuleNode, type index$1_RuleTreeState as RuleTreeState, type index$1_SyntheticAsset as SyntheticAsset, type index$1_TacticalFeatureKind as TacticalFeatureKind, type index$1_TacticalFeatureSpec as TacticalFeatureSpec, type index$1_TacticalFeatures as TacticalFeatures, type index$1_TacticalSpec as TacticalSpec, type index$1_Tolerance as Tolerance, index$1__resetTacticalDeprecationWarningForTesting as _resetTacticalDeprecationWarningForTesting, index$1_evaluateFeatureSpecs as evaluateFeatureSpecs, index$1_evaluateRuleTree as evaluateRuleTree, index$1_fromSpec as fromSpec, index$1_isRebalanceDay as isRebalanceDay, index$1_periodKey as periodKey, index$1_withSynthetics as withSynthetics };
+  export { type index$1_AllocateNode as AllocateNode, type index$1_AssetRef as AssetRef, type index$1_Comparison as Comparison, type index$1_ComparisonOp as ComparisonOp, type index$1_FeatureRef as FeatureRef, type index$1_FromSpecOptions as FromSpecOptions, type index$1_IfNode as IfNode, type index$1_RebalanceConfig as RebalanceConfig, type index$1_RebalanceFrequency as RebalanceFrequency, type index$1_RuleNode as RuleNode, type index$1_RuleTreeState as RuleTreeState, type index$1_SyntheticAsset as SyntheticAsset, type index$1_TacticalFeatureKind as TacticalFeatureKind, type index$1_TacticalFeatureSpec as TacticalFeatureSpec, type index$1_TacticalFeatures as TacticalFeatures, type index$1_TacticalSpec as TacticalSpec, type index$1_Tolerance as Tolerance, type index$1_WithStreamingSyntheticsOptions as WithStreamingSyntheticsOptions, index$1__resetTacticalDeprecationWarningForTesting as _resetTacticalDeprecationWarningForTesting, index$1_evaluateFeatureSpecs as evaluateFeatureSpecs, index$1_evaluateRuleTree as evaluateRuleTree, index$1_fromSpec as fromSpec, index$1_isRebalanceDay as isRebalanceDay, index$1_periodKey as periodKey, index$1_withStreamingSynthetics as withStreamingSynthetics, index$1_withSynthetics as withSynthetics };
 }
 
 /**
@@ -3393,4 +3598,4 @@ declare function applyFills(portfolio: Portfolio, fills: ReadonlyArray<Fill>, or
  */
 declare function applyOrders(portfolio: Portfolio, orders: ReadonlyArray<Order>): Portfolio;
 
-export { type AdhocTimeOverrides, type AdjustOrder, type AllocateNode, type Asset, type AssetId, type AssetRef, BacktestExecutor, type BacktestExecutorOptions, type BacktestResult, type BacktestSnapshot, type Bar, type BarField, type Calendar, type CloseOrder, type Comparison, type ComparisonOp, type ComputeFn, Crypto24x7Calendar, type DataEvent, type DataFeed, type DateRange, type EquityAsset, type EventKind, ExchangeCalendar, type ExchangeName, type Executor, type FeatureCache, type FeatureKey, type FeatureKind, type FeatureRef, FeatureRuntime, type FeatureRuntimeOptions, type FeatureScope, type FeatureSpec, type Features, type Fill, type Frequency, type FromSpecOptions, type Fundamentals, type HolidayRule, type IfNode, LSEExchangeCalendar, type LiveEvent, type MacroAsset, MemoryFeatureCache, NYSEExchangeCalendar, type NextOpenFn, type OpenOrder, type Order, type PollingSchedule, type PollingStreamOptions, type Portfolio, type Position, type PositionId, type PriceMap, type RebalanceConfig, type RebalanceFrequency, type RebalanceOrder, type ReturnMode, RoutingDataFeed, RoutingDataFeedError, type RoutingDataFeedRouteFn, type RoutingDataFeedRouteMap, RoutingStreamingDataFeed, RoutingStreamingDataFeedError, type RoutingStreamingDataFeedRouteFn, type RoutingStreamingDataFeedRouteMap, type RuleNode, type RuleTreeState, type RunBacktestOptions, type RunLiveOptions, type Series, type Session, type SpecialClose, type SpecialOpen, type Strategy, type StreamingBar, type StreamingDataFeed, type SyntheticAsset, type TacticalFeatureKind, type TacticalFeatureSpec, type TacticalFeatures, type TacticalSpec, type TargetWeights, type TimeOfDay, type Tolerance, applyFills, applyOrders, barsToSeries, collectBars, defineFeature, drawdown, ema, evaluateFeatureSpecs, evaluateRuleTree, index as features, fromSpec, getCalendar, getFeatureCompute, isRebalanceDay, paramsHash, periodKey, pollingStreamFromHistorical, reconcile, returnSeries, rsi, runBacktest, runLive, seriesAt, sma, index$1 as tactical, volatility, withSynthetics };
+export { type AdhocTimeOverrides, type AdjustOrder, type AllocateNode, type Asset, type AssetId, type AssetRef, BacktestExecutor, type BacktestExecutorOptions, type BacktestResult, type BacktestSnapshot, type Bar, type BarField, type Calendar, type CloseOrder, type Comparison, type ComparisonOp, type ComputeFn, Crypto24x7Calendar, type DataEvent, type DataFeed, type DateRange, type EquityAsset, type EventKind, ExchangeCalendar, type ExchangeName, type Executor, type FeatureCache, type FeatureKey, type FeatureKind, type FeatureRef, FeatureRuntime, type FeatureRuntimeOptions, type FeatureScope, type FeatureSpec, type Features, type Fill, type Frequency, type FromSpecOptions, type Fundamentals, type HolidayRule, type IfNode, LSEExchangeCalendar, type LiveEvent, type MacroAsset, MemoryFeatureCache, NYSEExchangeCalendar, type NextOpenFn, type OpenOrder, type Order, type PollingSchedule, type PollingStreamOptions, type Portfolio, type Position, type PositionId, type PriceMap, type Quote, type QuoteFeed, type RebalanceConfig, type RebalanceFrequency, type RebalanceOrder, type ReturnMode, RoutingDataFeed, RoutingDataFeedError, type RoutingDataFeedRouteFn, type RoutingDataFeedRouteMap, RoutingQuoteFeed, RoutingQuoteFeedError, type RoutingQuoteFeedRouteFn, type RoutingQuoteFeedRouteMap, RoutingStreamingDataFeed, RoutingStreamingDataFeedError, type RoutingStreamingDataFeedRouteFn, type RoutingStreamingDataFeedRouteMap, type RuleNode, type RuleTreeState, type RunBacktestOptions, type RunLiveOptions, type Series, type Session, type SpecialClose, type SpecialOpen, type Strategy, type StreamingBar, type StreamingDataFeed, type SyntheticAsset, type TacticalFeatureKind, type TacticalFeatureSpec, type TacticalFeatures, type TacticalSpec, type TargetWeights, type TimeOfDay, type Tolerance, type WithStreamingSyntheticsOptions, applyFills, applyOrders, barsToSeries, collectBars, defineFeature, drawdown, ema, evaluateFeatureSpecs, evaluateRuleTree, index as features, fromSpec, getCalendar, getFeatureCompute, isRebalanceDay, paramsHash, periodKey, pollingStreamFromHistorical, reconcile, returnSeries, rsi, runBacktest, runLive, seriesAt, sma, index$1 as tactical, volatility, withStreamingSynthetics, withSynthetics };

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/strategy/reconcile.ts
-function reconcile(targets, portfolio, prices) {
+function reconcile(targets, portfolio, prices, assets) {
   const longByAsset = /* @__PURE__ */ new Map();
   for (const p of portfolio.positions) {
     if (p.side !== "long") continue;
@@ -33,10 +33,10 @@ function reconcile(targets, portfolio, prices) {
     const delta = targetShares - currentShares;
     seen.add(assetId);
     if (delta !== 0) {
-      const asset = held?.asset ?? {
+      const asset = held?.asset ?? assets?.get(assetId) ?? {
         kind: "equity",
         id: assetId,
-        symbol: assetId.split(":").pop() ?? assetId
+        symbol: assetId
       };
       orders.push({ id: nextId(assetId), kind: "rebalance", asset, delta });
     }
@@ -925,6 +925,58 @@ async function* mergeIterators(iters) {
   }
 }
 
+// src/reference/routing-quote-feed.ts
+var RoutingQuoteFeedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RoutingQuoteFeedError";
+  }
+};
+var RoutingQuoteFeed = class {
+  route;
+  constructor(routes) {
+    if (typeof routes === "function") {
+      this.route = routes;
+    } else {
+      this.route = (asset) => routes[asset.kind];
+    }
+  }
+  async quote(asset) {
+    return this.resolve(asset).quote(asset);
+  }
+  async quoteBatch(assets) {
+    if (assets.length === 0) return [];
+    const groups = /* @__PURE__ */ new Map();
+    for (let i = 0; i < assets.length; i++) {
+      const asset = assets[i];
+      const feed = this.resolve(asset);
+      const bucket = groups.get(feed) ?? [];
+      bucket.push({ asset, index: i });
+      groups.set(feed, bucket);
+    }
+    const output = new Array(assets.length);
+    await Promise.all(
+      [...groups.entries()].map(async ([feed, bucket]) => {
+        const bucketAssets = bucket.map((b) => b.asset);
+        const results = typeof feed.quoteBatch === "function" ? await feed.quoteBatch(bucketAssets) : await Promise.all(bucketAssets.map((a) => feed.quote(a)));
+        for (let i = 0; i < bucket.length; i++) {
+          output[bucket[i].index] = results[i];
+        }
+      })
+    );
+    return output;
+  }
+  resolve(asset) {
+    const feed = this.route(asset);
+    if (feed === void 0) {
+      throw new RoutingQuoteFeedError(
+        `RoutingQuoteFeed: no feed registered for asset.kind="${asset.kind}" (id="${asset.id}")`
+      );
+    }
+    return feed;
+  }
+};
+
 // src/reference/polling-stream-from-historical.ts
 function pollingStreamFromHistorical(opts) {
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
@@ -2490,6 +2542,7 @@ __export(tactical_exports, {
   fromSpec: () => fromSpec,
   isRebalanceDay: () => isRebalanceDay,
   periodKey: () => periodKey,
+  withStreamingSynthetics: () => withStreamingSynthetics,
   withSynthetics: () => withSynthetics
 });
 
@@ -2642,19 +2695,27 @@ async function evaluateFeatureSpecs(specs, runtime, t) {
 
 // src/tactical/synthetics.ts
 var TRADING_DAYS_PER_YEAR = 252;
-async function* synthesize(underlyingBars, leverage, expense) {
+function nextSynthClose(opts) {
+  const { prevSynthClose, prevUnderlyingClose, underlyingClose, leverage, expense } = opts;
+  if (prevSynthClose === void 0 || prevUnderlyingClose === void 0) {
+    return underlyingClose;
+  }
   const drag = (expense ?? 0) / TRADING_DAYS_PER_YEAR;
+  const safe = Number.isFinite(prevUnderlyingClose) && prevUnderlyingClose !== 0;
+  const r = safe ? (underlyingClose - prevUnderlyingClose) / prevUnderlyingClose : 0;
+  return prevSynthClose * (1 + leverage * r) * (1 - drag);
+}
+async function* synthesize(underlyingBars, leverage, expense) {
   let prevUnderlyingClose;
   let prevSynthClose;
   for await (const u of underlyingBars) {
-    let close;
-    if (prevSynthClose === void 0 || prevUnderlyingClose === void 0) {
-      close = u.close;
-    } else {
-      const safe = Number.isFinite(prevUnderlyingClose) && prevUnderlyingClose !== 0;
-      const r = safe ? (u.close - prevUnderlyingClose) / prevUnderlyingClose : 0;
-      close = prevSynthClose * (1 + leverage * r) * (1 - drag);
-    }
+    const close = nextSynthClose({
+      prevSynthClose,
+      prevUnderlyingClose,
+      underlyingClose: u.close,
+      leverage,
+      expense
+    });
     yield {
       t: u.t,
       open: close,
@@ -2691,6 +2752,83 @@ function withSynthetics(dataFeed, synthetics) {
   }
   return wrapped;
 }
+function withStreamingSynthetics(inner, synthetics, opts) {
+  const synthById = /* @__PURE__ */ new Map();
+  for (const s of synthetics) {
+    if (synthById.has(s.id)) {
+      throw new Error(`withStreamingSynthetics: duplicate synthetic asset id "${s.id}"`);
+    }
+    synthById.set(s.id, s);
+  }
+  return {
+    async *subscribe(assets) {
+      const passthroughIds = /* @__PURE__ */ new Set();
+      const requestedSynths = [];
+      const upstream = [];
+      const upstreamSeen = /* @__PURE__ */ new Set();
+      for (const a of assets) {
+        const synth = synthById.get(a.id);
+        if (synth) {
+          requestedSynths.push(synth);
+          if (!upstreamSeen.has(synth.underlying.id)) {
+            upstreamSeen.add(synth.underlying.id);
+            upstream.push(resolveAssetRef(synth.underlying));
+          }
+        } else {
+          passthroughIds.add(a.id);
+          if (!upstreamSeen.has(a.id)) {
+            upstreamSeen.add(a.id);
+            upstream.push(a);
+          }
+        }
+      }
+      const synthsByUnderlying = /* @__PURE__ */ new Map();
+      for (const s of requestedSynths) {
+        const st = {
+          synth: s,
+          asset: resolveAssetRef({ id: s.id, symbol: s.symbol }),
+          prevUnderlyingClose: opts.seedLastCloses.get(s.underlying.id),
+          prevSynthClose: opts.seedLastCloses.get(s.id)
+        };
+        const list = synthsByUnderlying.get(s.underlying.id) ?? [];
+        list.push(st);
+        synthsByUnderlying.set(s.underlying.id, list);
+      }
+      for await (const tick of inner.subscribe(upstream)) {
+        if (passthroughIds.has(tick.asset.id)) {
+          yield tick;
+        }
+        const states = synthsByUnderlying.get(tick.asset.id);
+        if (!states) continue;
+        const underlyingClose = tick.bar.close;
+        for (const st of states) {
+          const synthClose = nextSynthClose({
+            prevSynthClose: st.prevSynthClose,
+            prevUnderlyingClose: st.prevUnderlyingClose,
+            underlyingClose,
+            leverage: st.synth.leverage,
+            expense: st.synth.expense
+          });
+          yield {
+            asset: st.asset,
+            bar: {
+              t: tick.bar.t,
+              open: synthClose,
+              high: synthClose,
+              low: synthClose,
+              close: synthClose,
+              volume: tick.bar.volume
+            }
+          };
+          st.prevSynthClose = synthClose;
+        }
+        for (const st of states) {
+          st.prevUnderlyingClose = underlyingClose;
+        }
+      }
+    }
+  };
+}
 
 // src/tactical/from-spec.ts
 var _warnedV0 = false;
@@ -2752,6 +2890,13 @@ function fromSpec(spec, opts) {
   }
   validateSynthetics(spec);
   const universe = spec.universe.map(resolveAssetRef);
+  const assetsById = /* @__PURE__ */ new Map();
+  for (const a of universe) assetsById.set(a.id, a);
+  for (const s of spec.synthetics ?? []) {
+    if (!assetsById.has(s.id)) {
+      assetsById.set(s.id, { kind: "equity", id: s.id, symbol: s.symbol });
+    }
+  }
   const { runtime, calendar } = opts;
   const cadence = spec.rebalance?.frequency ?? "Daily";
   return {
@@ -2796,7 +2941,7 @@ function fromSpec(spec, opts) {
         }
       }
       return {
-        orders: reconcile(evaluated.weights, portfolio, features.prices),
+        orders: reconcile(evaluated.weights, portfolio, features.prices, assetsById),
         state: evaluated.state
       };
     }
@@ -2830,6 +2975,8 @@ export {
   NYSEExchangeCalendar,
   RoutingDataFeed,
   RoutingDataFeedError,
+  RoutingQuoteFeed,
+  RoutingQuoteFeedError,
   RoutingStreamingDataFeed,
   RoutingStreamingDataFeedError,
   applyFills,
@@ -2858,6 +3005,7 @@ export {
   sma,
   tactical_exports as tactical,
   volatility,
+  withStreamingSynthetics,
   withSynthetics
 };
 //# sourceMappingURL=index.js.map