@livefolio/sdk 0.4.2 → 0.4.4

package/dist/index.d.ts

@@ -2760,12 +2760,27 @@ type FeatureRef = {
  * - `'lt'`  — strictly less than (`l < r`)
  * - `'gte'` — greater than or equal to (`l >= r`)
  * - `'lte'` — less than or equal to (`l <= r`)
+ * - `'eq'`  — equality. Without {@link Tolerance}, this is strict `l === r`
+ *   (no epsilon) — intended for comparing integer-valued features (e.g.
+ *   calendar features like `dayOfWeek`) against integer literals. With
+ *   {@link Tolerance}, this is "within the symmetric band around `r`" —
+ *   `true` while `l ∈ [r − tol, r + tol]`, `false` outside. State is still
+ *   persisted via {@link RuleTreeState} but, because entry and exit share
+ *   the same band edges, the per-step result is effectively stateless.
  */
-type ComparisonOp = 'gt' | 'lt' | 'gte' | 'lte';
+type ComparisonOp = 'gt' | 'lt' | 'gte' | 'lte' | 'eq';
 /**
- * Hysteresis band applied to a {@link Comparison} with `op: 'gt'` or `op: 'lt'`.
- * Once the comparison has flipped, it will not flip back until the left operand
- * exits the tolerance band around the right operand.
+ * Tolerance band applied to a {@link Comparison} with `op: 'gt'`, `op: 'lt'`,
+ * or `op: 'eq'`.
+ *
+ * For `gt` / `lt`, the band implements **hysteresis**: once the comparison
+ * has flipped, it will not flip back until the left operand exits the band
+ * around the right operand. Entry and exit thresholds differ.
+ *
+ * For `eq`, the band defines a **symmetric range** around `right`: the
+ * comparison is `true` while `l ∈ [r − value, r + value]`. Entry and exit
+ * share the same edges, so behavior is stateless in practice even though the
+ * outcome is still recorded in {@link RuleTreeState}.
  *
  * `mode: 'absolute'` defines a ±`value` band around `right`.
  * `mode: 'relative'` defines a ±`value`% band (i.e. `value` is a percentage).
@@ -2774,7 +2789,7 @@ type ComparisonOp = 'gt' | 'lt' | 'gte' | 'lte';
  * so the runtime can persist the last-known state across rebalance periods.
  */
 type Tolerance = {
-    /** Half-width of the hysteresis band. */
+    /** Half-width of the band. */
     value: number;
     /** `'absolute'` uses raw units; `'relative'` uses a percentage of `right`. */
     mode: 'absolute' | 'relative';
@@ -2809,8 +2824,9 @@ type Comparison = {
     /** Right-hand operand — a feature reference or a literal number. */
     right: FeatureRef | number;
     /**
-     * Optional hysteresis band. Requires `op` to be `'gt'` or `'lt'` and
-     * requires `id` to be set.
+     * Optional tolerance band. Requires `op` to be `'gt'`, `'lt'`, or `'eq'`,
+     * and requires `id` to be set. For `gt`/`lt` the band implements
+     * hysteresis; for `eq` it defines a symmetric range around `right`.
      */
     tolerance?: Tolerance;
     /**
@@ -3528,7 +3544,10 @@ declare namespace index {
  * - `'close'`     — removes shares from an existing position and credits cash.
  * - `'adjust'`    — updates the position's `quantity`; only fees are debited.
  * - `'rebalance'` — buys or sells shares in the long position for `asset`;
- *                   creates or removes the position as needed.
+ *                   creates the position on a positive `delta`, removes it
+ *                   when fully reduced. A reduce against a non-existent
+ *                   long position is silently ignored (matching the same
+ *                   case in {@link applyOrders}).
  *
  * The returned `portfolio.t` is updated to the maximum fill timestamp.
  *

package/dist/index.js

@@ -27,7 +27,7 @@ function reconcile(targets, portfolio, prices, assets) {
     if (price === void 0) {
       throw new Error(`reconcile: missing price for target asset ${assetId}`);
     }
-    const targetShares = Math.floor(totalValue * weight / price);
+    const targetShares = Math.max(0, Math.floor(totalValue * weight / price));
     const held = longByAsset.get(assetId);
     const currentShares = held?.quantity ?? 0;
     const delta = targetShares - currentShares;
@@ -125,10 +125,7 @@ function applyFills(portfolio, fills, orders) {
               basis: prev.basis + cost
             };
           }
-        } else {
-          if (idx < 0) {
-            throw new Error(`applyFills: rebalance reduce on ${order.asset.id} but no long position exists`);
-          }
+        } else if (idx >= 0) {
           const prev = positions[idx];
           cash += fill.quantity * fill.price - fill.fees;
           const remaining = prev.quantity - fill.quantity;
@@ -2568,6 +2565,8 @@ function rawCompare(op, l, r) {
       return l >= r;
     case "lte":
       return l <= r;
+    case "eq":
+      return l === r;
   }
 }
 function band(right, tol) {
@@ -2586,13 +2585,15 @@ function evalComparison(cond, values, state, outState) {
   if (cond.id === void 0) {
     throw new Error("evaluateRuleTree: comparison with tolerance requires id");
   }
-  if (cond.op !== "gt" && cond.op !== "lt") {
-    throw new Error(`evaluateRuleTree: tolerance is only supported for op gt/lt, got ${cond.op}`);
+  if (cond.op !== "gt" && cond.op !== "lt" && cond.op !== "eq") {
+    throw new Error(`evaluateRuleTree: tolerance is only supported for op gt/lt/eq, got ${cond.op}`);
   }
   const prev = state.get(cond.id);
   const { lower, upper } = band(r, cond.tolerance);
   let result;
-  if (prev === void 0) {
+  if (cond.op === "eq") {
+    result = l >= lower && l <= upper ? 1 : 0;
+  } else if (prev === void 0) {
     result = rawCompare(cond.op, l, r) ? 1 : 0;
   } else if (cond.op === "gt") {
     if (prev === 1) result = l < lower ? 0 : 1;