@invinite-org/chartlang-host-worker 1.2.0 → 1.3.0

package/dist/worker-boot.js

@@ -94,6 +94,29 @@ var Float64RingBuffer = class {
     this.head = -1;
     this.filled = 0;
   }
+  /**
+   * Overwrite this ring's entire state with a copy of `other`'s. A single
+   * `Float64Array.prototype.set()` memcpy plus a head/filled copy — `O(capacity)`
+   * with a small constant, not an element loop. `state.array`'s two-ring tick
+   * discipline (`packages/runtime/src/state/arrayStateSlot.ts`) calls this every
+   * tick to roll the tentative ring back to committed (and on close to commit it),
+   * so the typed-array `set()` is load-bearing for the hot path. Both rings in a
+   * slot share `capacity`, so this never reshapes the backing array.
+   *
+   * @since 1.3
+   * @stable
+   * @example
+   *     const a = new Float64RingBuffer(4);
+   *     const b = new Float64RingBuffer(4);
+   *     a.append(1);
+   *     b.copyFrom(a);
+   *     b.at(0); // 1
+   */
+  copyFrom(other) {
+    this.buf.set(other.buf);
+    this.head = other.head;
+    this.filled = other.filled;
+  }
 };
 
 // ../runtime/dist/seriesView.js
@@ -313,6 +336,20 @@ var input = Object.freeze({
   interval(defaultValue, opts) {
     return Object.freeze({ kind: "interval", defaultValue, ...opts });
   },
+  /**
+   * Build a session-window input descriptor (`"HH:MM-HH:MM"`). The value is
+   * a free string in v1 (the grammar is parsed at runtime by
+   * `session.isOpen`), mirroring `input.string`.
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const sess = input.session("0930-1600", { title: "Session" });
+   *     void sess;
+   */
+  session(defaultValue, opts) {
+    return Object.freeze({ kind: "session", defaultValue, ...opts });
+  },
   /**
    * Build an adapter-supplied external series input descriptor.
    *
@@ -406,6 +443,26 @@ var state = Object.freeze({
   series(_init) {
     return sentinel("state.series");
   },
+  /**
+   * Allocate or read a persistent **bounded collection** slot — a
+   * fixed-capacity FIFO ring you push values into across bars. `a.push(v)`
+   * appends (evicting the oldest once full); `a.get(n)` reads the `n`-th
+   * element from the newest; `a.last()` is the newest; `a.size` is the
+   * filled count; `a.capacity` is the bound; `a.clear()` empties it.
+   * `capacity` must be a compile-time numeric literal (the slot is bounded
+   * so it serializes). Unlike {@link state}.series (one value's bar-indexed
+   * history), this is a collection of many pushed values. v1 supports
+   * `number` element type.
+   *
+   * @since 1.3
+   * @stable
+   * @example
+   *     const fn: typeof state.array = state.array;
+   *     void fn;
+   */
+  array(_capacity) {
+    return sentinel("state.array");
+  },
   /**
    * Tick-persistent state slots, Pine `varip` semantics. Writes commit
    * immediately, even during a tick.
@@ -432,6 +489,154 @@ var state = Object.freeze({
   })
 });
 
+// ../core/dist/time-accessors/sessionAccessors.js
+var sentinel2 = (name) => {
+  throw new Error(`${name} called outside an active script step`);
+};
+var session = Object.freeze({
+  /**
+   * `true` when `t` falls inside the daily session window `spec`. `spec` is
+   * an `"HH:MM-HH:MM"` (or `"HHMM-HHMM"`) intraday window, e.g.
+   * `"0930-1600"`. The window is interpreted in `tz` (default
+   * `syminfo.timezone`, fallback `"UTC"`).
+   *
+   * v1 resolves UTC and fixed-offset zones only; a DST zone resolves to UTC
+   * plus a one-time diagnostic (see the determinism note in the docs).
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof session.isOpen = session.isOpen;
+   *     void fn;
+   */
+  isOpen(_t, _spec, _tz) {
+    return sentinel2("session.isOpen");
+  }
+});
+
+// ../core/dist/time-accessors/timeAccessors.js
+var sentinel3 = (name) => {
+  throw new Error(`${name} called outside an active script step`);
+};
+var time = Object.freeze({
+  /**
+   * Calendar year of `t` (e.g. `2024`).
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.year = time.year;
+   *     void fn;
+   */
+  year(_t, _tz) {
+    return sentinel3("time.year");
+  },
+  /**
+   * Calendar month of `t`, `1..12`.
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.month = time.month;
+   *     void fn;
+   */
+  month(_t, _tz) {
+    return sentinel3("time.month");
+  },
+  /**
+   * Day of the month of `t`, `1..31`.
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.dayofmonth = time.dayofmonth;
+   *     void fn;
+   */
+  dayofmonth(_t, _tz) {
+    return sentinel3("time.dayofmonth");
+  },
+  /**
+   * Day of the week of `t`, following Pine's convention `1=Sunday .. 7=Saturday`
+   * (note: NOT the ISO `1=Monday` convention).
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.dayofweek = time.dayofweek;
+   *     void fn;
+   */
+  dayofweek(_t, _tz) {
+    return sentinel3("time.dayofweek");
+  },
+  /**
+   * Hour-of-day of `t`, `0..23`.
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.hour = time.hour;
+   *     void fn;
+   */
+  hour(_t, _tz) {
+    return sentinel3("time.hour");
+  },
+  /**
+   * Minute-of-hour of `t`, `0..59`.
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.minute = time.minute;
+   *     void fn;
+   */
+  minute(_t, _tz) {
+    return sentinel3("time.minute");
+  },
+  /**
+   * Second-of-minute of `t`, `0..59`.
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.second = time.second;
+   *     void fn;
+   */
+  second(_t, _tz) {
+    return sentinel3("time.second");
+  },
+  /**
+   * Build a `Time` (UTC ms epoch) from calendar fields. `month` is `1..12`
+   * and `day` is `1..31`; `hour`/`minute`/`second` default to `0`. The
+   * fields are interpreted in `tz` (default `syminfo.timezone`, fallback
+   * `"UTC"`).
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.timestamp = time.timestamp;
+   *     void fn;
+   */
+  timestamp(_year, _month, _day, _hour, _minute, _second, _tz) {
+    return sentinel3("time.timestamp");
+  },
+  /**
+   * Close timestamp of the bar that starts at `t` — Pine's no-arg
+   * `time_close()`. Equals `t + interval`, where the interval is the active
+   * bar's `timeframe.inSeconds` the runtime reads internally (so this mirrors
+   * Pine's "current bar's interval" without an explicit interval argument).
+   * `tz` is accepted for surface symmetry with the other `time.*` accessors.
+   *
+   * @since 1.5
+   * @stable
+   * @example
+   *     const fn: typeof time.timeClose = time.timeClose;
+   *     void fn;
+   */
+  timeClose(_t, _tz) {
+    return sentinel3("time.timeClose");
+  }
+});
+
 // ../core/dist/views/barstate.js
 var barstate = Object.freeze({
   isfirst: false,
@@ -466,17 +671,22 @@ var timeframe = Object.freeze({
 });
 
 // ../core/dist/request/request.js
-var sentinel2 = (name) => {
+var sentinel4 = (name) => {
   throw new Error(`${name} called outside an active script step`);
 };
 function security(_opts, _expr) {
-  return sentinel2("request.security");
+  return sentinel4("request.security");
 }
 function lowerTf(_opts) {
-  return sentinel2("request.lowerTf");
+  return sentinel4("request.lowerTf");
 }
 var request = Object.freeze({ security, lowerTf });
 
+// ../core/dist/request/feedKey.js
+function feedKey(symbol, interval) {
+  return symbol === void 0 || symbol === "" ? interval : `${symbol}@${interval}`;
+}
+
 // ../core/dist/runtime/runtime.js
 function _logInfo(_message, _meta) {
   throw new Error("runtime.log.info called outside compiled runtime");
@@ -816,6 +1026,11 @@ var STATEFUL_PRIMITIVE_ENTRIES = [
   { name: "ta.nz", slot: false },
   { name: "plot", slot: true },
   { name: "hline", slot: true },
+  // Pine-ergonomic aliases lowering to the `bg-color` / `bar-color` plot
+  // styles. Slot-injected like `plot`/`hline` so each callsite gets a
+  // stable slot id and is listed in `manifest.plots` with its kind.
+  { name: "bgcolor", slot: true },
+  { name: "barcolor", slot: true },
   { name: "alert", slot: true },
   // Phase 3 — draw.* namespace. One entry per kind in DRAWING_KINDS
   // order. Names are camelCase (`draw.<kindCamelCase>`); the wire
@@ -892,12 +1107,27 @@ var STATEFUL_PRIMITIVE_ENTRIES = [
   { name: "state.tick.int", slot: true },
   { name: "state.tick.bool", slot: true },
   { name: "state.tick.string", slot: true },
+  { name: "state.array", slot: true },
   // Both the data form `request.security({ interval })` and the expression
   // form `request.security({ interval }, (bar) => …)` route through this one
   // entry: `slot: true` injects the slot id as the first argument regardless
   // of the optional second (callback) argument.
   { name: "request.security", slot: true },
   { name: "request.lowerTf", slot: true },
+  // Calendar / session accessors — stateless (slot: false). Like `ta.nz`,
+  // they ride the registry for the `stateful-call-inside-loop` diagnostic
+  // (Pine-parity) but take NO injected slot id: the runtime function
+  // receives the author's arguments directly.
+  { name: "time.year", slot: false },
+  { name: "time.month", slot: false },
+  { name: "time.dayofmonth", slot: false },
+  { name: "time.dayofweek", slot: false },
+  { name: "time.hour", slot: false },
+  { name: "time.minute", slot: false },
+  { name: "time.second", slot: false },
+  { name: "time.timestamp", slot: false },
+  { name: "time.timeClose", slot: false },
+  { name: "session.isOpen", slot: false },
   { name: "defineAlertCondition.signal", slot: false },
   { name: "runtime.log", slot: false },
   { name: "runtime.error", slot: false }
@@ -1137,13 +1367,13 @@ function intervalSpacingMs(interval) {
     return Number.NaN;
   }
 }
-function medianSpacingMs(time) {
-  const pairs = Math.min(time.length - 1, 100);
+function medianSpacingMs(time2) {
+  const pairs = Math.min(time2.length - 1, 100);
   if (pairs < 1)
     return Number.NaN;
   const deltas = [];
   for (let i = 0; i < pairs; i += 1) {
-    const delta = time.at(i) - time.at(i + 1);
+    const delta = time2.at(i) - time2.at(i + 1);
     if (Number.isFinite(delta))
       deltas.push(delta);
   }
@@ -1153,14 +1383,14 @@ function medianSpacingMs(time) {
   const mid = deltas.length >> 1;
   return deltas.length % 2 === 1 ? deltas[mid] : (deltas[mid - 1] + deltas[mid]) / 2;
 }
-function resolveBarPoint(time, interval, currentTime, offset, price) {
+function resolveBarPoint(time2, interval, currentTime, offset, price) {
   const p = Number(price);
   if (offset === 0)
     return { time: currentTime, price: p };
   if (offset < 0)
-    return { time: time.at(-offset), price: p };
+    return { time: time2.at(-offset), price: p };
   const spacing = (() => {
-    const median2 = medianSpacingMs(time);
+    const median2 = medianSpacingMs(time2);
     return Number.isFinite(median2) ? median2 : intervalSpacingMs(interval);
   })();
   return { time: currentTime + offset * spacing, price: p };
@@ -1384,6 +1614,142 @@ function inMemoryStateStore() {
   };
 }
 
+// ../runtime/dist/bufferSnapshot.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isInteger(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+function finiteOrNull(value) {
+  return Number.isFinite(value) ? value : null;
+}
+function restoreNumber(value) {
+  if (value === null)
+    return Number.NaN;
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isBufferSnapshot(value) {
+  if (!isRecord(value))
+    return false;
+  if (!isInteger(value.headIndex) || !isInteger(value.filled))
+    return false;
+  return Array.isArray(value.values) && value.values.every((entry) => entry === null || typeof entry === "number" && Number.isFinite(entry));
+}
+function serialiseBuffer(buffer) {
+  const snapshot6 = buffer.serialiseSnapshotBuffer();
+  return {
+    headIndex: snapshot6.headIndex,
+    filled: snapshot6.filled,
+    values: snapshot6.values
+  };
+}
+function restoreBuffer(snapshot6, capacity) {
+  const buffer = new Float64RingBuffer(capacity);
+  try {
+    buffer.restoreFromSnapshotBuffer(snapshot6);
+    return buffer;
+  } catch {
+    return null;
+  }
+}
+
+// ../runtime/dist/state/arrayStateSlot.js
+var ArrayStateSlot = class {
+  capacity;
+  committedRing;
+  tentativeRing;
+  handle;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.committedRing = new Float64RingBuffer(capacity);
+    this.tentativeRing = new Float64RingBuffer(capacity);
+    this.handle = buildArrayHandle(this);
+  }
+  /** Commit the tentative ring into the committed ring (bar close). */
+  onBarClose() {
+    this.committedRing.copyFrom(this.tentativeRing);
+  }
+  /** Roll the tentative ring back to the committed ring (head-replacing tick). */
+  onBarTick() {
+    this.tentativeRing.copyFrom(this.committedRing);
+  }
+};
+function buildArrayHandle(slot) {
+  return {
+    push(value) {
+      slot.tentativeRing.append(value);
+    },
+    get(n) {
+      return slot.tentativeRing.at(n);
+    },
+    last() {
+      return slot.tentativeRing.at(0);
+    },
+    clear() {
+      slot.tentativeRing.reset();
+    },
+    get size() {
+      return slot.tentativeRing.length;
+    },
+    get capacity() {
+      return slot.capacity;
+    }
+  };
+}
+function createArrayStateSlot(capacity) {
+  return new ArrayStateSlot(capacity);
+}
+function restoreArrayStateSlot(committedRing, tentativeRing) {
+  const slot = new ArrayStateSlot(committedRing.capacity);
+  slot.committedRing.copyFrom(committedRing);
+  slot.tentativeRing.copyFrom(tentativeRing);
+  return slot;
+}
+
+// ../runtime/dist/state/arrayPersistence.js
+var ARRAY_SLOT_SUFFIX = ":array";
+function isArraySlotSnapshotKey(key) {
+  return key.endsWith(ARRAY_SLOT_SUFFIX);
+}
+function serialiseArraySlots(ctx) {
+  const out = {};
+  for (const [key, slot] of ctx.arraySlots.entries()) {
+    out[key] = {
+      kind: "state.array",
+      capacity: slot.capacity,
+      committed: serialiseBuffer(slot.committedRing),
+      tentative: serialiseBuffer(slot.tentativeRing)
+    };
+  }
+  return Object.freeze(out);
+}
+function restoreArraySlotSnapshot(snapshot6) {
+  if (!isRecord(snapshot6) || snapshot6.kind !== "state.array")
+    return null;
+  if (!isInteger(snapshot6.capacity) || snapshot6.capacity <= 0)
+    return null;
+  const { committed, tentative } = snapshot6;
+  if (!isBufferSnapshot(committed) || !isBufferSnapshot(tentative))
+    return null;
+  const committedRing = restoreBuffer(committed, snapshot6.capacity);
+  const tentativeRing = restoreBuffer(tentative, snapshot6.capacity);
+  if (committedRing === null || tentativeRing === null)
+    return null;
+  return restoreArrayStateSlot(committedRing, tentativeRing);
+}
+function restoreArraySlots(ctx, slots) {
+  ctx.arraySlots.clear();
+  for (const [key, value] of Object.entries(slots)) {
+    if (!isArraySlotSnapshotKey(key))
+      continue;
+    const slot = restoreArraySlotSnapshot(value);
+    if (slot !== null) {
+      ctx.arraySlots.set(key, slot);
+    }
+  }
+}
+
 // ../runtime/dist/state/seriesSlot.js
 function makeSeriesSlotView(buffer) {
   const reads = makeSeriesView(buffer);
@@ -1484,44 +1850,14 @@ function resetSeriesHeads(ctx) {
     resetSeriesSlotHead(slot);
   }
 }
-
-// ../runtime/dist/bufferSnapshot.js
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isInteger(value) {
-  return typeof value === "number" && Number.isInteger(value);
-}
-function finiteOrNull(value) {
-  return Number.isFinite(value) ? value : null;
-}
-function restoreNumber(value) {
-  if (value === null)
-    return Number.NaN;
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function isBufferSnapshot(value) {
-  if (!isRecord(value))
-    return false;
-  if (!isInteger(value.headIndex) || !isInteger(value.filled))
-    return false;
-  return Array.isArray(value.values) && value.values.every((entry) => entry === null || typeof entry === "number" && Number.isFinite(entry));
-}
-function serialiseBuffer(buffer) {
-  const snapshot6 = buffer.serialiseSnapshotBuffer();
-  return {
-    headIndex: snapshot6.headIndex,
-    filled: snapshot6.filled,
-    values: snapshot6.values
-  };
+function resetTentativeArraySlots(ctx) {
+  for (const slot of ctx.arraySlots.values()) {
+    slot.onBarTick();
+  }
 }
-function restoreBuffer(snapshot6, capacity) {
-  const buffer = new Float64RingBuffer(capacity);
-  try {
-    buffer.restoreFromSnapshotBuffer(snapshot6);
-    return buffer;
-  } catch {
-    return null;
+function commitArraySlots(ctx) {
+  for (const slot of ctx.arraySlots.values()) {
+    slot.onBarClose();
   }
 }
 
@@ -1622,6 +1958,7 @@ function asMutableSlot(slot) {
 // ../runtime/dist/state/stateNamespace.js
 var stateKey = (ctx, slotId) => `${ctx.slotIdPrefix ?? ""}${slotId}:state`;
 var seriesKey = (ctx, slotId) => `${ctx.slotIdPrefix ?? ""}${slotId}:series`;
+var arrayKey = (ctx, slotId) => `${ctx.slotIdPrefix ?? ""}${slotId}:array`;
 function getCtx(name) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null) {
@@ -1655,6 +1992,17 @@ function getOrAllocateSeries(slotId, init) {
   ctx.seriesSlots.set(key, slot);
   return slot.view;
 }
+function getOrAllocateArray(slotId, capacity) {
+  const ctx = getCtx("state.array");
+  const key = arrayKey(ctx, slotId);
+  const existing = ctx.arraySlots.get(key);
+  if (existing !== void 0) {
+    return existing.handle;
+  }
+  const slot = createArrayStateSlot(capacity);
+  ctx.arraySlots.set(key, slot);
+  return slot.handle;
+}
 function buildStateNamespace() {
   const ns = {
     float: (slotId, init) => getOrAllocate("state.float", slotId, init, false),
@@ -1662,6 +2010,7 @@ function buildStateNamespace() {
     bool: (slotId, init) => getOrAllocate("state.bool", slotId, init, false),
     string: (slotId, init) => getOrAllocate("state.string", slotId, init, false),
     series: (slotId, init) => getOrAllocateSeries(slotId, init),
+    array: (slotId, capacity) => getOrAllocateArray(slotId, capacity),
     tick: {
       float: (slotId, init) => getOrAllocate("state.tick.float", slotId, init, true),
       int: (slotId, init) => getOrAllocate("state.tick.int", slotId, init, true),
@@ -1722,6 +2071,7 @@ function matchesDescriptor(descriptor, value) {
     case "color":
     case "symbol":
     case "interval":
+    case "session":
       return typeof value === "string";
     case "enum":
       return typeof value === "string" && descriptor.options.includes(value);
@@ -2047,7 +2397,7 @@ function createRuntimeViews(opts = {}) {
 }
 
 // ../runtime/dist/request/securityExprRunner.js
-function makeFoldBar(foldStream, interval) {
+function makeFoldBar(foldStream, symbol, interval) {
   const { seriesViews } = foldStream;
   return Object.freeze({
     time: seriesViews.time,
@@ -2060,7 +2410,7 @@ function makeFoldBar(foldStream, interval) {
     hlc3: seriesViews.hlc3,
     ohlc4: seriesViews.ohlc4,
     hlcc4: seriesViews.hlcc4,
-    symbol: makeConstantStringSeries(""),
+    symbol: makeConstantStringSeries(symbol),
     interval: makeConstantStringSeries(interval)
   });
 }
@@ -2090,12 +2440,15 @@ function buildExprContext(parent, slotId, foldStream) {
     scriptMaxDrawings: null,
     stateSlots: /* @__PURE__ */ new Map(),
     seriesSlots: /* @__PURE__ */ new Map(),
+    arraySlots: /* @__PURE__ */ new Map(),
+    chartSymbol: parent.chartSymbol,
     secondaryStreams: parent.secondaryStreams,
     requestSecurityBars: /* @__PURE__ */ new Map(),
     requestSecurityAlignments: /* @__PURE__ */ new Map(),
     requestSecurityAscendingBars: /* @__PURE__ */ new Map(),
     requestLowerTfViews: /* @__PURE__ */ new Map(),
     diagnosedRequestKeys: /* @__PURE__ */ new Set(),
+    diagnosedTzKeys: /* @__PURE__ */ new Set(),
     logBudget: 0,
     logBudgetExceededDiagnosed: false,
     resolvedInputs: parent.resolvedInputs,
@@ -2108,13 +2461,13 @@ function buildExprContext(parent, slotId, foldStream) {
   };
 }
 function createSecurityExprRunner(args) {
-  const { slotId, interval, capacity, parent } = args;
-  const foldStream = createStreamState({ interval, capacity, symbol: "" });
+  const { slotId, symbol, interval, capacity, parent } = args;
+  const foldStream = createStreamState({ interval, capacity, symbol });
   return {
     slotId,
     interval,
     foldStream,
-    foldBar: makeFoldBar(foldStream, interval),
+    foldBar: makeFoldBar(foldStream, symbol, interval),
     ctx: buildExprContext(parent, slotId, foldStream),
     output: new Float64RingBuffer(capacity),
     processedHtfCount: 0
@@ -2122,23 +2475,26 @@ function createSecurityExprRunner(args) {
 }
 function buildSecurityExprRunners(manifest, parent, capacity) {
   const bySlot = /* @__PURE__ */ new Map();
-  const byInterval = /* @__PURE__ */ new Map();
+  const byFeed = /* @__PURE__ */ new Map();
   for (const descriptor of manifest.securityExpressions ?? []) {
+    const resolved = descriptor.symbol === void 0 || descriptor.symbol === parent.chartSymbol ? void 0 : descriptor.symbol;
+    const key = feedKey(resolved, descriptor.interval);
     const runner = createSecurityExprRunner({
       slotId: descriptor.slotId,
+      symbol: descriptor.symbol ?? parent.chartSymbol,
       interval: descriptor.interval,
       capacity,
       parent
     });
     bySlot.set(descriptor.slotId, runner);
-    const list = byInterval.get(descriptor.interval);
+    const list = byFeed.get(key);
     if (list === void 0) {
-      byInterval.set(descriptor.interval, [runner]);
+      byFeed.set(key, [runner]);
     } else {
       list.push(runner);
     }
   }
-  return { bySlot, byInterval };
+  return { bySlot, byFeed };
 }
 function sampleOutput(result) {
   return typeof result === "number" ? result : result.current;
@@ -2173,8 +2529,8 @@ function foldTick(runner, bar) {
   replaceStreamHead(runner.foldStream, bar);
   runner.output.replaceHead(evaluate(runner, runner.callback, true));
 }
-function driveSecurityExpressions(parent, interval, mode, bar) {
-  const runners = parent.securityExprRunnersByInterval?.get(interval);
+function driveSecurityExpressions(parent, streamKey, mode, bar) {
+  const runners = parent.securityExprRunnersByFeed?.get(streamKey);
   if (runners === void 0)
     return;
   for (const runner of runners) {
@@ -2244,11 +2600,11 @@ function seriesAscending(stream, sourceKey) {
   }
   return values;
 }
-function alignmentKey(slotId, interval, sourceKey) {
-  return `${slotId}|${interval}|${sourceKey}`;
+function alignmentKey(slotId, feed, sourceKey) {
+  return `${slotId}|${feed}|${sourceKey}`;
 }
-function alignedSeries(ctx, slotId, interval, sourceKey, secondary) {
-  const key = alignmentKey(slotId, interval, sourceKey);
+function alignedSeries(ctx, slotId, feed, sourceKey, secondary) {
+  const key = alignmentKey(slotId, feed, sourceKey);
   const existing = ctx.requestSecurityAlignments.get(key);
   if (existing !== void 0)
     return existing;
@@ -2283,13 +2639,13 @@ function makeAlignedSeriesProxy(ctx, produce) {
     }
   });
 }
-function makeAlignedNumberSeries(ctx, slotId, interval, sourceKey, secondary) {
-  return makeAlignedSeriesProxy(ctx, () => alignedSeries(ctx, slotId, interval, sourceKey, secondary));
+function makeAlignedNumberSeries(ctx, slotId, feed, sourceKey, secondary) {
+  return makeAlignedSeriesProxy(ctx, () => alignedSeries(ctx, slotId, feed, sourceKey, secondary));
 }
-function makeLiveSecurityBar(ctx, slotId, interval, secondary) {
+function makeLiveSecurityBar(ctx, slotId, feed, interval, secondary) {
   const numeric = /* @__PURE__ */ new Map();
   for (const key of NUMERIC_SOURCE_KEYS) {
-    numeric.set(key, makeAlignedNumberSeries(ctx, slotId, interval, key, secondary));
+    numeric.set(key, makeAlignedNumberSeries(ctx, slotId, feed, key, secondary));
   }
   return Object.freeze({
     time: numeric.get("time") ?? makeSeries(Number.NaN),
@@ -2306,57 +2662,68 @@ function makeLiveSecurityBar(ctx, slotId, interval, secondary) {
     interval: makeConstantStringSeries(interval)
   });
 }
-function fallbackNaN(ctx, cacheKey, slotId, interval, code, message) {
-  pushOnce(ctx, code, slotId, interval, "security", message);
+var MULTI_SYMBOL_MSG = "Adapter declares multiSymbol: false; request.security for a different symbol returns NaN";
+function fallbackNaN(ctx, cacheKey, slotId, feed, code, message) {
+  pushOnce(ctx, code, slotId, feed, "security", message);
   const bar = makeNanSecurityBar();
   ctx.requestSecurityBars.set(cacheKey, bar);
   return bar;
 }
-function makeSecurityBar(ctx, slotId, interval) {
-  const cacheKey = `${slotId}|${interval}`;
+function makeSecurityBar(ctx, slotId, symbol, interval) {
+  const feed = feedKey(symbol, interval);
+  const cacheKey = `${slotId}|${feed}`;
   const existing = ctx.requestSecurityBars.get(cacheKey);
   if (existing !== void 0)
     return existing;
+  if (symbol !== void 0 && !ctx.capabilities.multiSymbol) {
+    return fallbackNaN(ctx, cacheKey, slotId, feed, "multi-symbol-not-supported", MULTI_SYMBOL_MSG);
+  }
   if (!ctx.capabilities.multiTimeframe) {
-    return fallbackNaN(ctx, cacheKey, slotId, interval, "multi-timeframe-not-supported", "Adapter declares multiTimeframe: false; request.security returns NaN");
+    return fallbackNaN(ctx, cacheKey, slotId, feed, "multi-timeframe-not-supported", "Adapter declares multiTimeframe: false; request.security returns NaN");
   }
   const known = ctx.capabilities.intervals.some((descriptor) => descriptor.value === interval);
   if (!known) {
-    return fallbackNaN(ctx, cacheKey, slotId, interval, "unsupported-interval", `Requested interval "${interval}" is not in Capabilities.intervals`);
+    return fallbackNaN(ctx, cacheKey, slotId, feed, "unsupported-interval", `Requested interval "${interval}" is not in Capabilities.intervals`);
   }
-  const secondary = ctx.secondaryStreams.get(interval);
+  const secondary = ctx.secondaryStreams.get(feed);
   if (secondary === void 0) {
-    return fallbackNaN(ctx, cacheKey, slotId, interval, "unknown-secondary-stream", `Requested interval "${interval}" has no registered secondary stream`);
+    return fallbackNaN(ctx, cacheKey, slotId, feed, "unknown-secondary-stream", `Requested interval "${interval}" has no registered secondary stream`);
   }
-  const bar = makeLiveSecurityBar(ctx, slotId, interval, secondary);
+  const bar = makeLiveSecurityBar(ctx, slotId, feed, interval, secondary);
   ctx.requestSecurityBars.set(cacheKey, bar);
   return bar;
 }
 function makeNanNumberSeries() {
   return makeSeries(Number.NaN);
 }
-function resolveSecondaryOrDiagnose(ctx, slotId, interval) {
+function resolveSecondaryOrDiagnose(ctx, slotId, feed, interval) {
   if (!ctx.capabilities.multiTimeframe) {
-    pushOnce(ctx, "multi-timeframe-not-supported", slotId, interval, "security", "Adapter declares multiTimeframe: false; request.security returns NaN");
+    pushOnce(ctx, "multi-timeframe-not-supported", slotId, feed, "security", "Adapter declares multiTimeframe: false; request.security returns NaN");
     return void 0;
   }
   if (!ctx.capabilities.intervals.some((descriptor) => descriptor.value === interval)) {
-    pushOnce(ctx, "unsupported-interval", slotId, interval, "security", `Requested interval "${interval}" is not in Capabilities.intervals`);
+    pushOnce(ctx, "unsupported-interval", slotId, feed, "security", `Requested interval "${interval}" is not in Capabilities.intervals`);
     return void 0;
   }
-  const secondary = ctx.secondaryStreams.get(interval);
+  const secondary = ctx.secondaryStreams.get(feed);
   if (secondary === void 0) {
-    pushOnce(ctx, "unknown-secondary-stream", slotId, interval, "security", `Requested interval "${interval}" has no registered secondary stream`);
+    pushOnce(ctx, "unknown-secondary-stream", slotId, feed, "security", `Requested interval "${interval}" has no registered secondary stream`);
   }
   return secondary;
 }
-function makeSecurityExprSeries(ctx, runner, interval) {
-  const cacheKey = `${runner.slotId}|${interval}`;
+function makeSecurityExprSeries(ctx, runner, feed, isDifferentSymbol) {
+  const cacheKey = `${runner.slotId}|${feed}`;
   const cache = ctx.requestSecurityExprSeries;
   const existing = cache?.get(cacheKey);
   if (existing !== void 0)
     return existing;
-  const secondary = resolveSecondaryOrDiagnose(ctx, runner.slotId, interval);
+  if (isDifferentSymbol && !ctx.capabilities.multiSymbol) {
+    pushOnce(ctx, "multi-symbol-not-supported", runner.slotId, feed, "security", MULTI_SYMBOL_MSG);
+    const nan = makeNanNumberSeries();
+    cache?.set(cacheKey, nan);
+    return nan;
+  }
+  const secondary = resolveSecondaryOrDiagnose(ctx, runner.slotId, feed, runner.interval);
   const series = secondary === void 0 ? makeNanNumberSeries() : makeAlignedSeriesProxy(ctx, () => getOrAlign(ascendingBarsFor(ctx, secondary), ascendingValues(runner.output), ascendingBarsFor(ctx, ctx.stream)));
   cache?.set(cacheKey, series);
   return series;
@@ -2370,18 +2737,23 @@ function getCtx2(name) {
   }
   return ctx;
 }
+function resolveSymbol(ctx, symbol) {
+  return symbol === void 0 || symbol === ctx.chartSymbol ? void 0 : symbol;
+}
 function security2(slotId, opts, expr) {
   const ctx = getCtx2("request.security");
+  const symbol = resolveSymbol(ctx, opts.symbol);
+  const feed = feedKey(symbol, opts.interval);
   const runner = ctx.securityExprRunners?.get(slotId);
   if (runner === void 0) {
-    return makeSecurityBar(ctx, slotId, opts.interval);
+    return makeSecurityBar(ctx, slotId, symbol, opts.interval);
   }
   if (expr !== void 0) {
-    const secondary = ctx.secondaryStreams.get(opts.interval);
+    const secondary = ctx.secondaryStreams.get(feed);
     if (secondary !== void 0)
       captureAndCatchUp(runner, expr, secondary);
   }
-  return makeSecurityExprSeries(ctx, runner, opts.interval);
+  return makeSecurityExprSeries(ctx, runner, feed, symbol !== void 0);
 }
 function lowerTf2(slotId, opts) {
   const ctx = getCtx2("request.lowerTf");
@@ -2515,6 +2887,7 @@ var VALID_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
   "unsupported-pane",
   "unsupported-interval",
   "multi-timeframe-not-supported",
+  "multi-symbol-not-supported",
   "unknown-secondary-stream",
   "lookback-exceeded",
   "drawing-budget-exceeded",
@@ -2829,6 +3202,12 @@ function validatePlotEmission(e) {
   if (value !== null && !isFiniteNumber(value)) {
     return bad("plot.value: must be a finite number or null");
   }
+  const colorValue = e.colorValue;
+  if (colorValue !== void 0 && colorValue !== null) {
+    const cv = validateColor(colorValue, "plot.colorValue");
+    if (!cv.ok)
+      return cv;
+  }
   const color2 = e.color;
   if (color2 !== null && typeof color2 !== "string") {
     return bad("plot.color: must be a string or null");
@@ -3922,6 +4301,63 @@ function validateEmission(e) {
   }
 }
 
+// ../adapter-kit/dist/geometry/_lib/arrowhead.js
+var ARROWHEAD_HALF_ANGLE = Math.PI / 6;
+
+// ../adapter-kit/dist/geometry/kinds/annotations.js
+var TWO_PI = Math.PI * 2;
+
+// ../adapter-kit/dist/geometry/kinds/boxes.js
+var TWO_PI2 = Math.PI * 2;
+
+// ../adapter-kit/dist/geometry/_lib/fibLevels.js
+var FIB_LEVELS = Object.freeze([
+  0,
+  0.236,
+  0.382,
+  0.5,
+  0.618,
+  0.786,
+  1,
+  1.272,
+  // biome-ignore lint/suspicious/noApproximativeNumericConstant: canonical fib ratio, not √2.
+  1.414,
+  1.618,
+  2,
+  2.618,
+  4.236
+]);
+
+// ../adapter-kit/dist/geometry/kinds/fibonacci.js
+var TAU = Math.PI * 2;
+var PHI = (1 + Math.sqrt(5)) / 2;
+var SPIRAL_K = 4 * (Math.sqrt(2) - 1) / 3;
+
+// ../adapter-kit/dist/geometry/_lib/gannLevels.js
+var GANN_LEVELS = Object.freeze([0, 0.25, 0.5, 0.75, 1]);
+var GANN_FAN_RATIOS = Object.freeze([
+  1,
+  2,
+  3,
+  0.5,
+  1 / 3,
+  4,
+  0.25,
+  8,
+  0.125
+]);
+var GANN_FAN_LABELS = Object.freeze([
+  "1x1",
+  "1x2",
+  "1x3",
+  "2x1",
+  "3x1",
+  "1x4",
+  "4x1",
+  "1x8",
+  "8x1"
+]);
+
 // ../runtime/dist/emit/emissionsQueue.js
 function pushPlot(queue, e) {
   const result = validateEmission(e);
@@ -4119,11 +4555,11 @@ function emit(slot) {
     return Number.NaN;
   return slot.sumRanges / slot.length;
 }
-function closeStep(slot, high, low, time) {
-  if (!Number.isFinite(high) || !Number.isFinite(low) || !Number.isFinite(time)) {
+function closeStep(slot, high, low, time2) {
+  if (!Number.isFinite(high) || !Number.isFinite(low) || !Number.isFinite(time2)) {
     return emit(slot);
   }
-  const dayKey = Math.floor(time / MS_PER_DAY);
+  const dayKey = Math.floor(time2 / MS_PER_DAY);
   if (Number.isNaN(slot.currentDayKey)) {
     slot.currentDayKey = dayKey;
     slot.dailyHigh = high;
@@ -4151,11 +4587,11 @@ function adr(slotId, opts) {
     slot = initSlot2(length, ctx.stream.ohlcv.close.capacity);
     ctx.stream.taSlots.set(slotId, slot);
   }
-  const { high, low, time } = ctx.stream.bar;
+  const { high, low, time: time2 } = ctx.stream.bar;
   if (ctx.isTick) {
     slot.outBuffer.replaceHead(emit(slot));
   } else {
-    slot.outBuffer.append(closeStep(slot, high, low, time));
+    slot.outBuffer.append(closeStep(slot, high, low, time2));
   }
   return slot.series;
 }
@@ -5018,15 +5454,173 @@ function applyPlotOverride(emission, override) {
   return next;
 }
 
-// ../runtime/dist/emit/draw/pushDrawing.js
-function effectiveBudget(ctx, bucket) {
-  const adapterCap = ctx.capabilities.maxDrawingsPerScript[bucket];
-  const scriptCap = ctx.scriptMaxDrawings?.[bucket] ?? Number.POSITIVE_INFINITY;
-  return Math.min(adapterCap, scriptCap);
+// ../runtime/dist/emit/plot.js
+var OUTSIDE_CTX_MESSAGE2 = "plot called outside an active script step";
+function isSeriesNumber(v) {
+  return typeof v === "object" && v !== null && "current" in v;
 }
-function pushDrawing(ctx, e) {
-  if (!ctx.capabilities.drawings.has(e.drawingKind)) {
-    pushDiagnostic(ctx.emissions, {
+function isNumberOrSeries(v) {
+  return typeof v === "number" || isSeriesNumber(v);
+}
+function resolveValue(value) {
+  const resolved = typeof value === "number" ? value : value.current;
+  return Number.isFinite(resolved) ? resolved : null;
+}
+function buildStyle(opts) {
+  const style = opts.style;
+  if (style === void 0) {
+    return {
+      kind: "line",
+      lineWidth: opts.lineWidth ?? 1,
+      lineStyle: opts.lineStyle ?? "solid"
+    };
+  }
+  switch (style.kind) {
+    case "histogram":
+      return { kind: "histogram", baseline: style.baseline ?? 0 };
+    case "marker":
+      return { kind: "marker", shape: style.shape, size: style.size };
+    case "shape":
+      return {
+        kind: "shape",
+        shape: style.shape,
+        size: style.size,
+        ...style.location === void 0 ? {} : { location: style.location }
+      };
+    case "character":
+      return {
+        kind: "character",
+        char: style.char,
+        size: style.size,
+        ...style.location === void 0 ? {} : { location: style.location }
+      };
+    case "arrow":
+      return { kind: "arrow", direction: style.direction, size: style.size };
+    case "candle-override":
+      return {
+        kind: "candle-override",
+        bull: style.bull,
+        bear: style.bear,
+        ...style.doji === void 0 ? {} : { doji: style.doji }
+      };
+    case "bar-override":
+      return { kind: "bar-override", color: style.color };
+    case "bg-color":
+      return {
+        kind: "bg-color",
+        color: style.color,
+        ...style.transp === void 0 ? {} : { transp: style.transp }
+      };
+    case "bar-color":
+      return { kind: "bar-color", color: style.color };
+    case "horizontal-histogram":
+      return { kind: "horizontal-histogram", buckets: style.buckets };
+    case "line":
+    case "step-line":
+    case "horizontal-line":
+      return {
+        kind: style.kind,
+        lineWidth: opts.lineWidth ?? 1,
+        lineStyle: opts.lineStyle ?? "solid"
+      };
+  }
+}
+function plotImpl(ctx, slotId, value, opts, dynamicColor) {
+  const style = buildStyle(opts);
+  if (!ctx.capabilities.plots.has(style.kind)) {
+    pushDiagnostic(ctx.emissions, {
+      kind: "diagnostic",
+      severity: "warning",
+      code: "unsupported-plot-kind",
+      message: `Adapter cannot render plot kind "${style.kind}".`,
+      slotId,
+      bar: ctx.barIndex()
+    });
+    return;
+  }
+  const pane = resolvePane(opts.pane, ctx, slotId);
+  const xShift = typeof value === "number" ? 0 : seriesOffsetOf(value);
+  const z = opts.z ?? 0;
+  const colorValue = dynamicColor;
+  const emission = {
+    kind: "plot",
+    slotId,
+    title: opts.title ?? "",
+    style,
+    bar: ctx.barIndex(),
+    time: ctx.stream.bar.time,
+    value: resolveValue(value),
+    color: opts.color ?? null,
+    meta: {},
+    pane,
+    ...xShift === 0 ? {} : { xShift },
+    ...z === 0 ? {} : { z },
+    ...colorValue === void 0 ? {} : { colorValue }
+  };
+  pushPlot(ctx.emissions, applyPlotOverride(emission, ctx.plotOverrides[slotId]));
+}
+function plot2(arg1, arg2, arg3) {
+  if (typeof arg1 !== "string") {
+    throw new Error(OUTSIDE_CTX_MESSAGE2);
+  }
+  const ctx = ACTIVE_RUNTIME_CONTEXT.current;
+  if (!ctx)
+    throw new Error(OUTSIDE_CTX_MESSAGE2);
+  if (!isNumberOrSeries(arg2)) {
+    throw new Error(OUTSIDE_CTX_MESSAGE2);
+  }
+  plotImpl(ctx, arg1, arg2, arg3 ?? {});
+}
+
+// ../runtime/dist/emit/barcolor.js
+var OUTSIDE_CTX_MESSAGE3 = "barcolor called outside an active script step";
+function barColorOpts(color2, opts) {
+  return {
+    style: { kind: "bar-color", color: color2 },
+    ...opts.title === void 0 ? {} : { title: opts.title }
+  };
+}
+function barcolor2(arg1, arg2, arg3) {
+  if (typeof arg1 !== "string" || typeof arg2 !== "string") {
+    throw new Error(OUTSIDE_CTX_MESSAGE3);
+  }
+  const ctx = ACTIVE_RUNTIME_CONTEXT.current;
+  if (!ctx)
+    throw new Error(OUTSIDE_CTX_MESSAGE3);
+  plotImpl(ctx, arg1, Number.NaN, barColorOpts(arg2, arg3 ?? {}), arg2);
+}
+
+// ../runtime/dist/emit/bgcolor.js
+var OUTSIDE_CTX_MESSAGE4 = "bgcolor called outside an active script step";
+function bgColorOpts(color2, opts) {
+  return {
+    style: {
+      kind: "bg-color",
+      color: color2,
+      ...opts.transp === void 0 ? {} : { transp: opts.transp }
+    },
+    ...opts.title === void 0 ? {} : { title: opts.title }
+  };
+}
+function bgcolor2(arg1, arg2, arg3) {
+  if (typeof arg1 !== "string" || typeof arg2 !== "string") {
+    throw new Error(OUTSIDE_CTX_MESSAGE4);
+  }
+  const ctx = ACTIVE_RUNTIME_CONTEXT.current;
+  if (!ctx)
+    throw new Error(OUTSIDE_CTX_MESSAGE4);
+  plotImpl(ctx, arg1, Number.NaN, bgColorOpts(arg2, arg3 ?? {}), arg2);
+}
+
+// ../runtime/dist/emit/draw/pushDrawing.js
+function effectiveBudget(ctx, bucket) {
+  const adapterCap = ctx.capabilities.maxDrawingsPerScript[bucket];
+  const scriptCap = ctx.scriptMaxDrawings?.[bucket] ?? Number.POSITIVE_INFINITY;
+  return Math.min(adapterCap, scriptCap);
+}
+function pushDrawing(ctx, e) {
+  if (!ctx.capabilities.drawings.has(e.drawingKind)) {
+    pushDiagnostic(ctx.emissions, {
       kind: "diagnostic",
       severity: "warning",
       code: "unsupported-drawing-kind",
@@ -5080,7 +5674,7 @@ function pushDrawing(ctx, e) {
 }
 
 // ../runtime/dist/emit/draw/handle.js
-var OUTSIDE_CTX_MESSAGE2 = "draw called outside an active script step";
+var OUTSIDE_CTX_MESSAGE5 = "draw called outside an active script step";
 function mergeState(prev, patch) {
   return { ...prev, ...patch, kind: prev.kind };
 }
@@ -5113,7 +5707,7 @@ function emit2(ctx, handleId, kind, op, state2, z) {
 function createDrawingHandle(slotId, subId, kind, initialState) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE2);
+    throw new Error(OUTSIDE_CTX_MESSAGE5);
   const handleId = `${slotId}#${subId}`;
   const existing = ctx.drawingSlots.get(handleId);
   const initial = splitZ(initialState);
@@ -5172,96 +5766,96 @@ function resetSubIdCounters(ctx) {
 }
 
 // ../runtime/dist/emit/draw/annotations/arrow.js
-var OUTSIDE_CTX_MESSAGE3 = "draw.arrow called outside an active script step";
+var OUTSIDE_CTX_MESSAGE6 = "draw.arrow called outside an active script step";
 function arrowImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE3);
+    throw new Error(OUTSIDE_CTX_MESSAGE6);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "arrow", anchors: [a, b], style: opts };
   return createDrawingHandle(slotId, subId, "arrow", state2);
 }
 function arrow(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE3);
+    throw new Error(OUTSIDE_CTX_MESSAGE6);
   }
   return arrowImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/annotations/arrowMarkDown.js
-var OUTSIDE_CTX_MESSAGE4 = "draw.arrowMarkDown called outside an active script step";
+var OUTSIDE_CTX_MESSAGE7 = "draw.arrowMarkDown called outside an active script step";
 function arrowMarkDownImpl(slotId, anchor, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE4);
+    throw new Error(OUTSIDE_CTX_MESSAGE7);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "arrow-mark-down", anchor, style: opts };
   return createDrawingHandle(slotId, subId, "arrow-mark-down", state2);
 }
 function arrowMarkDown(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE4);
+    throw new Error(OUTSIDE_CTX_MESSAGE7);
   }
   return arrowMarkDownImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/annotations/arrowMarkUp.js
-var OUTSIDE_CTX_MESSAGE5 = "draw.arrowMarkUp called outside an active script step";
+var OUTSIDE_CTX_MESSAGE8 = "draw.arrowMarkUp called outside an active script step";
 function arrowMarkUpImpl(slotId, anchor, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE5);
+    throw new Error(OUTSIDE_CTX_MESSAGE8);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "arrow-mark-up", anchor, style: opts };
   return createDrawingHandle(slotId, subId, "arrow-mark-up", state2);
 }
 function arrowMarkUp(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE5);
+    throw new Error(OUTSIDE_CTX_MESSAGE8);
   }
   return arrowMarkUpImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/annotations/arrowMarker.js
-var OUTSIDE_CTX_MESSAGE6 = "draw.arrowMarker called outside an active script step";
+var OUTSIDE_CTX_MESSAGE9 = "draw.arrowMarker called outside an active script step";
 function arrowMarkerImpl(slotId, anchor, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE6);
+    throw new Error(OUTSIDE_CTX_MESSAGE9);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "arrow-marker", anchor, style: opts };
   return createDrawingHandle(slotId, subId, "arrow-marker", state2);
 }
 function arrowMarker(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE6);
+    throw new Error(OUTSIDE_CTX_MESSAGE9);
   }
   return arrowMarkerImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/annotations/text.js
-var OUTSIDE_CTX_MESSAGE7 = "draw.text called outside an active script step";
+var OUTSIDE_CTX_MESSAGE10 = "draw.text called outside an active script step";
 function textImpl(slotId, anchor, body, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE7);
+    throw new Error(OUTSIDE_CTX_MESSAGE10);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "text", anchor, body, style: opts };
   return createDrawingHandle(slotId, subId, "text", state2);
 }
 function text(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || typeof arg2 === "string" || typeof arg3 !== "string") {
-    throw new Error(OUTSIDE_CTX_MESSAGE7);
+    throw new Error(OUTSIDE_CTX_MESSAGE10);
   }
   return textImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/circle.js
-var OUTSIDE_CTX_MESSAGE8 = "draw.circle called outside an active script step";
+var OUTSIDE_CTX_MESSAGE11 = "draw.circle called outside an active script step";
 function circleImpl(slotId, centre, radiusAnchor, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE8);
+    throw new Error(OUTSIDE_CTX_MESSAGE11);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "circle",
@@ -5272,51 +5866,51 @@ function circleImpl(slotId, centre, radiusAnchor, opts) {
 }
 function circle(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE8);
+    throw new Error(OUTSIDE_CTX_MESSAGE11);
   }
   return circleImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/ellipse.js
-var OUTSIDE_CTX_MESSAGE9 = "draw.ellipse called outside an active script step";
+var OUTSIDE_CTX_MESSAGE12 = "draw.ellipse called outside an active script step";
 function ellipseImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE9);
+    throw new Error(OUTSIDE_CTX_MESSAGE12);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "ellipse", anchors: [a, b], style: opts };
   return createDrawingHandle(slotId, subId, "ellipse", state2);
 }
 function ellipse(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE9);
+    throw new Error(OUTSIDE_CTX_MESSAGE12);
   }
   return ellipseImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/fillBetween.js
-var OUTSIDE_CTX_MESSAGE10 = "draw.fillBetween called outside an active script step";
+var OUTSIDE_CTX_MESSAGE13 = "draw.fillBetween called outside an active script step";
 function fillBetweenImpl(slotId, edgeA, edgeB, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE10);
+    throw new Error(OUTSIDE_CTX_MESSAGE13);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "fill-between", edgeA, edgeB, style: opts };
   return createDrawingHandle(slotId, subId, "fill-between", state2);
 }
 function fillBetween(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2) || arg3 === void 0 || !Array.isArray(arg3)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE10);
+    throw new Error(OUTSIDE_CTX_MESSAGE13);
   }
   return fillBetweenImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/marker.js
-var OUTSIDE_CTX_MESSAGE11 = "draw.marker called outside an active script step";
+var OUTSIDE_CTX_MESSAGE14 = "draw.marker called outside an active script step";
 function markerImpl(slotId, anchor, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE11);
+    throw new Error(OUTSIDE_CTX_MESSAGE14);
   const subId = nextSubId(ctx, slotId);
   const { text: text2, value, ...style } = opts;
   const state2 = {
@@ -5330,136 +5924,136 @@ function markerImpl(slotId, anchor, opts) {
 }
 function marker(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE11);
+    throw new Error(OUTSIDE_CTX_MESSAGE14);
   }
   return markerImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/path.js
-var OUTSIDE_CTX_MESSAGE12 = "draw.path called outside an active script step";
+var OUTSIDE_CTX_MESSAGE15 = "draw.path called outside an active script step";
 function pathImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE12);
+    throw new Error(OUTSIDE_CTX_MESSAGE15);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "path", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "path", state2);
 }
 function path(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE12);
+    throw new Error(OUTSIDE_CTX_MESSAGE15);
   }
   return pathImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/polyline.js
-var OUTSIDE_CTX_MESSAGE13 = "draw.polyline called outside an active script step";
+var OUTSIDE_CTX_MESSAGE16 = "draw.polyline called outside an active script step";
 function polylineImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE13);
+    throw new Error(OUTSIDE_CTX_MESSAGE16);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "polyline", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "polyline", state2);
 }
 function polyline(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE13);
+    throw new Error(OUTSIDE_CTX_MESSAGE16);
   }
   return polylineImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/rectangle.js
-var OUTSIDE_CTX_MESSAGE14 = "draw.rectangle called outside an active script step";
+var OUTSIDE_CTX_MESSAGE17 = "draw.rectangle called outside an active script step";
 function rectangleImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE14);
+    throw new Error(OUTSIDE_CTX_MESSAGE17);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "rectangle", anchors: [a, b], style: opts };
   return createDrawingHandle(slotId, subId, "rectangle", state2);
 }
 function rectangle(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE14);
+    throw new Error(OUTSIDE_CTX_MESSAGE17);
   }
   return rectangleImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/rotatedRectangle.js
-var OUTSIDE_CTX_MESSAGE15 = "draw.rotatedRectangle called outside an active script step";
+var OUTSIDE_CTX_MESSAGE18 = "draw.rotatedRectangle called outside an active script step";
 function rotatedRectangleImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE15);
+    throw new Error(OUTSIDE_CTX_MESSAGE18);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "rotated-rectangle", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "rotated-rectangle", state2);
 }
 function rotatedRectangle(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE15);
+    throw new Error(OUTSIDE_CTX_MESSAGE18);
   }
   return rotatedRectangleImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/boxes/triangle.js
-var OUTSIDE_CTX_MESSAGE16 = "draw.triangle called outside an active script step";
+var OUTSIDE_CTX_MESSAGE19 = "draw.triangle called outside an active script step";
 function triangleImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE16);
+    throw new Error(OUTSIDE_CTX_MESSAGE19);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "triangle", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "triangle", state2);
 }
 function triangle(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE16);
+    throw new Error(OUTSIDE_CTX_MESSAGE19);
   }
   return triangleImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/channels/disjointChannel.js
-var OUTSIDE_CTX_MESSAGE17 = "draw.disjointChannel called outside an active script step";
+var OUTSIDE_CTX_MESSAGE20 = "draw.disjointChannel called outside an active script step";
 function disjointChannelImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE17);
+    throw new Error(OUTSIDE_CTX_MESSAGE20);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "disjoint-channel", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "disjoint-channel", state2);
 }
 function disjointChannel(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE17);
+    throw new Error(OUTSIDE_CTX_MESSAGE20);
   }
   return disjointChannelImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/channels/flatTopBottom.js
-var OUTSIDE_CTX_MESSAGE18 = "draw.flatTopBottom called outside an active script step";
+var OUTSIDE_CTX_MESSAGE21 = "draw.flatTopBottom called outside an active script step";
 function flatTopBottomImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE18);
+    throw new Error(OUTSIDE_CTX_MESSAGE21);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "flat-top-bottom", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "flat-top-bottom", state2);
 }
 function flatTopBottom(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE18);
+    throw new Error(OUTSIDE_CTX_MESSAGE21);
   }
   return flatTopBottomImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/channels/regressionTrend.js
-var OUTSIDE_CTX_MESSAGE19 = "draw.regressionTrend called outside an active script step";
+var OUTSIDE_CTX_MESSAGE22 = "draw.regressionTrend called outside an active script step";
 function regressionTrendImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE19);
+    throw new Error(OUTSIDE_CTX_MESSAGE22);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "regression-trend",
@@ -5470,34 +6064,34 @@ function regressionTrendImpl(slotId, a, b, opts) {
 }
 function regressionTrend(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE19);
+    throw new Error(OUTSIDE_CTX_MESSAGE22);
   }
   return regressionTrendImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/channels/trendChannel.js
-var OUTSIDE_CTX_MESSAGE20 = "draw.trendChannel called outside an active script step";
+var OUTSIDE_CTX_MESSAGE23 = "draw.trendChannel called outside an active script step";
 function trendChannelImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE20);
+    throw new Error(OUTSIDE_CTX_MESSAGE23);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "trend-channel", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "trend-channel", state2);
 }
 function trendChannel(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE20);
+    throw new Error(OUTSIDE_CTX_MESSAGE23);
   }
   return trendChannelImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/containers/frame.js
-var OUTSIDE_CTX_MESSAGE21 = "draw.frame called outside an active script step";
+var OUTSIDE_CTX_MESSAGE24 = "draw.frame called outside an active script step";
 function frameImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE21);
+    throw new Error(OUTSIDE_CTX_MESSAGE24);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "frame",
@@ -5509,17 +6103,17 @@ function frameImpl(slotId, a, b, opts) {
 }
 function frame(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE21);
+    throw new Error(OUTSIDE_CTX_MESSAGE24);
   }
   return frameImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/containers/group.js
-var OUTSIDE_CTX_MESSAGE22 = "draw.group called outside an active script step";
+var OUTSIDE_CTX_MESSAGE25 = "draw.group called outside an active script step";
 function groupImpl(slotId, childHandleIds) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE22);
+    throw new Error(OUTSIDE_CTX_MESSAGE25);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "group",
@@ -5529,119 +6123,119 @@ function groupImpl(slotId, childHandleIds) {
 }
 function group(arg1, arg2) {
   if (typeof arg1 !== "string" || arg2 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE22);
+    throw new Error(OUTSIDE_CTX_MESSAGE25);
   }
   return groupImpl(arg1, arg2);
 }
 
 // ../runtime/dist/emit/draw/curves/arc.js
-var OUTSIDE_CTX_MESSAGE23 = "draw.arc called outside an active script step";
+var OUTSIDE_CTX_MESSAGE26 = "draw.arc called outside an active script step";
 function arcImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE23);
+    throw new Error(OUTSIDE_CTX_MESSAGE26);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "arc", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "arc", state2);
 }
 function arc(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE23);
+    throw new Error(OUTSIDE_CTX_MESSAGE26);
   }
   return arcImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/curves/brush.js
-var OUTSIDE_CTX_MESSAGE24 = "draw.brush called outside an active script step";
+var OUTSIDE_CTX_MESSAGE27 = "draw.brush called outside an active script step";
 function brushImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE24);
+    throw new Error(OUTSIDE_CTX_MESSAGE27);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "brush", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "brush", state2);
 }
 function brush(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2) || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE24);
+    throw new Error(OUTSIDE_CTX_MESSAGE27);
   }
   return brushImpl(arg1, arg2, arg3);
 }
 
 // ../runtime/dist/emit/draw/curves/curve.js
-var OUTSIDE_CTX_MESSAGE25 = "draw.curve called outside an active script step";
+var OUTSIDE_CTX_MESSAGE28 = "draw.curve called outside an active script step";
 function curveImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE25);
+    throw new Error(OUTSIDE_CTX_MESSAGE28);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "curve", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "curve", state2);
 }
 function curve(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE25);
+    throw new Error(OUTSIDE_CTX_MESSAGE28);
   }
   return curveImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/curves/doubleCurve.js
-var OUTSIDE_CTX_MESSAGE26 = "draw.doubleCurve called outside an active script step";
+var OUTSIDE_CTX_MESSAGE29 = "draw.doubleCurve called outside an active script step";
 function doubleCurveImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE26);
+    throw new Error(OUTSIDE_CTX_MESSAGE29);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "double-curve", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "double-curve", state2);
 }
 function doubleCurve(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE26);
+    throw new Error(OUTSIDE_CTX_MESSAGE29);
   }
   return doubleCurveImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/curves/highlighter.js
-var OUTSIDE_CTX_MESSAGE27 = "draw.highlighter called outside an active script step";
+var OUTSIDE_CTX_MESSAGE30 = "draw.highlighter called outside an active script step";
 function highlighterImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE27);
+    throw new Error(OUTSIDE_CTX_MESSAGE30);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "highlighter", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "highlighter", state2);
 }
 function highlighter(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2) || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE27);
+    throw new Error(OUTSIDE_CTX_MESSAGE30);
   }
   return highlighterImpl(arg1, arg2, arg3);
 }
 
 // ../runtime/dist/emit/draw/curves/pen.js
-var OUTSIDE_CTX_MESSAGE28 = "draw.pen called outside an active script step";
+var OUTSIDE_CTX_MESSAGE31 = "draw.pen called outside an active script step";
 function penImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE28);
+    throw new Error(OUTSIDE_CTX_MESSAGE31);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "pen", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "pen", state2);
 }
 function pen(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE28);
+    throw new Error(OUTSIDE_CTX_MESSAGE31);
   }
   return penImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/cycles/cyclicLines.js
-var OUTSIDE_CTX_MESSAGE29 = "draw.cyclicLines called outside an active script step";
+var OUTSIDE_CTX_MESSAGE32 = "draw.cyclicLines called outside an active script step";
 function cyclicLinesImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE29);
+    throw new Error(OUTSIDE_CTX_MESSAGE32);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "cyclic-lines",
@@ -5652,17 +6246,17 @@ function cyclicLinesImpl(slotId, a, b, opts) {
 }
 function cyclicLines(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE29);
+    throw new Error(OUTSIDE_CTX_MESSAGE32);
   }
   return cyclicLinesImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/cycles/sineLine.js
-var OUTSIDE_CTX_MESSAGE30 = "draw.sineLine called outside an active script step";
+var OUTSIDE_CTX_MESSAGE33 = "draw.sineLine called outside an active script step";
 function sineLineImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE30);
+    throw new Error(OUTSIDE_CTX_MESSAGE33);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "sine-line",
@@ -5673,17 +6267,17 @@ function sineLineImpl(slotId, a, b, opts) {
 }
 function sineLine(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE30);
+    throw new Error(OUTSIDE_CTX_MESSAGE33);
   }
   return sineLineImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/cycles/timeCycles.js
-var OUTSIDE_CTX_MESSAGE31 = "draw.timeCycles called outside an active script step";
+var OUTSIDE_CTX_MESSAGE34 = "draw.timeCycles called outside an active script step";
 function timeCyclesImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE31);
+    throw new Error(OUTSIDE_CTX_MESSAGE34);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "time-cycles",
@@ -5694,17 +6288,17 @@ function timeCyclesImpl(slotId, a, b, opts) {
 }
 function timeCycles(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE31);
+    throw new Error(OUTSIDE_CTX_MESSAGE34);
   }
   return timeCyclesImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/elliott/elliottCorrectionWave.js
-var OUTSIDE_CTX_MESSAGE32 = "draw.elliottCorrectionWave called outside an active script step";
+var OUTSIDE_CTX_MESSAGE35 = "draw.elliottCorrectionWave called outside an active script step";
 function elliottCorrectionWaveImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE32);
+    throw new Error(OUTSIDE_CTX_MESSAGE35);
   const subId = nextSubId(ctx, slotId);
   const { labels, ...style } = opts;
   const state2 = labels === void 0 ? { kind: "elliott-correction-wave", anchors, style } : { kind: "elliott-correction-wave", anchors, labels, style };
@@ -5712,17 +6306,17 @@ function elliottCorrectionWaveImpl(slotId, anchors, opts) {
 }
 function elliottCorrectionWave(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE32);
+    throw new Error(OUTSIDE_CTX_MESSAGE35);
   }
   return elliottCorrectionWaveImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/elliott/elliottDoubleCombo.js
-var OUTSIDE_CTX_MESSAGE33 = "draw.elliottDoubleCombo called outside an active script step";
+var OUTSIDE_CTX_MESSAGE36 = "draw.elliottDoubleCombo called outside an active script step";
 function elliottDoubleComboImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE33);
+    throw new Error(OUTSIDE_CTX_MESSAGE36);
   const subId = nextSubId(ctx, slotId);
   const { labels, ...style } = opts;
   const state2 = labels === void 0 ? { kind: "elliott-double-combo", anchors, style } : { kind: "elliott-double-combo", anchors, labels, style };
@@ -5730,17 +6324,17 @@ function elliottDoubleComboImpl(slotId, anchors, opts) {
 }
 function elliottDoubleCombo(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE33);
+    throw new Error(OUTSIDE_CTX_MESSAGE36);
   }
   return elliottDoubleComboImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/elliott/elliottImpulseWave.js
-var OUTSIDE_CTX_MESSAGE34 = "draw.elliottImpulseWave called outside an active script step";
+var OUTSIDE_CTX_MESSAGE37 = "draw.elliottImpulseWave called outside an active script step";
 function elliottImpulseWaveImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE34);
+    throw new Error(OUTSIDE_CTX_MESSAGE37);
   const subId = nextSubId(ctx, slotId);
   const { labels, ...style } = opts;
   const state2 = labels === void 0 ? { kind: "elliott-impulse-wave", anchors, style } : { kind: "elliott-impulse-wave", anchors, labels, style };
@@ -5748,17 +6342,17 @@ function elliottImpulseWaveImpl(slotId, anchors, opts) {
 }
 function elliottImpulseWave(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE34);
+    throw new Error(OUTSIDE_CTX_MESSAGE37);
   }
   return elliottImpulseWaveImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/elliott/elliottTriangleWave.js
-var OUTSIDE_CTX_MESSAGE35 = "draw.elliottTriangleWave called outside an active script step";
+var OUTSIDE_CTX_MESSAGE38 = "draw.elliottTriangleWave called outside an active script step";
 function elliottTriangleWaveImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE35);
+    throw new Error(OUTSIDE_CTX_MESSAGE38);
   const subId = nextSubId(ctx, slotId);
   const { labels, ...style } = opts;
   const state2 = labels === void 0 ? { kind: "elliott-triangle-wave", anchors, style } : { kind: "elliott-triangle-wave", anchors, labels, style };
@@ -5766,17 +6360,17 @@ function elliottTriangleWaveImpl(slotId, anchors, opts) {
 }
 function elliottTriangleWave(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE35);
+    throw new Error(OUTSIDE_CTX_MESSAGE38);
   }
   return elliottTriangleWaveImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/elliott/elliottTripleCombo.js
-var OUTSIDE_CTX_MESSAGE36 = "draw.elliottTripleCombo called outside an active script step";
+var OUTSIDE_CTX_MESSAGE39 = "draw.elliottTripleCombo called outside an active script step";
 function elliottTripleComboImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE36);
+    throw new Error(OUTSIDE_CTX_MESSAGE39);
   const subId = nextSubId(ctx, slotId);
   const { labels, ...style } = opts;
   const state2 = labels === void 0 ? { kind: "elliott-triple-combo", anchors, style } : { kind: "elliott-triple-combo", anchors, labels, style };
@@ -5784,34 +6378,34 @@ function elliottTripleComboImpl(slotId, anchors, opts) {
 }
 function elliottTripleCombo(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE36);
+    throw new Error(OUTSIDE_CTX_MESSAGE39);
   }
   return elliottTripleComboImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibA/fibChannel.js
-var OUTSIDE_CTX_MESSAGE37 = "draw.fibChannel called outside an active script step";
+var OUTSIDE_CTX_MESSAGE40 = "draw.fibChannel called outside an active script step";
 function fibChannelImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE37);
+    throw new Error(OUTSIDE_CTX_MESSAGE40);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "fib-channel", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "fib-channel", state2);
 }
 function fibChannel(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE37);
+    throw new Error(OUTSIDE_CTX_MESSAGE40);
   }
   return fibChannelImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibA/fibRetracement.js
-var OUTSIDE_CTX_MESSAGE38 = "draw.fibRetracement called outside an active script step";
+var OUTSIDE_CTX_MESSAGE41 = "draw.fibRetracement called outside an active script step";
 function fibRetracementImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE38);
+    throw new Error(OUTSIDE_CTX_MESSAGE41);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "fib-retracement",
@@ -5822,17 +6416,17 @@ function fibRetracementImpl(slotId, a, b, opts) {
 }
 function fibRetracement(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE38);
+    throw new Error(OUTSIDE_CTX_MESSAGE41);
   }
   return fibRetracementImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibA/fibTimeZone.js
-var OUTSIDE_CTX_MESSAGE39 = "draw.fibTimeZone called outside an active script step";
+var OUTSIDE_CTX_MESSAGE42 = "draw.fibTimeZone called outside an active script step";
 function fibTimeZoneImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE39);
+    throw new Error(OUTSIDE_CTX_MESSAGE42);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "fib-time-zone",
@@ -5843,17 +6437,17 @@ function fibTimeZoneImpl(slotId, a, b, opts) {
 }
 function fibTimeZone(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE39);
+    throw new Error(OUTSIDE_CTX_MESSAGE42);
   }
   return fibTimeZoneImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibA/fibTrendExtension.js
-var OUTSIDE_CTX_MESSAGE40 = "draw.fibTrendExtension called outside an active script step";
+var OUTSIDE_CTX_MESSAGE43 = "draw.fibTrendExtension called outside an active script step";
 function fibTrendExtensionImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE40);
+    throw new Error(OUTSIDE_CTX_MESSAGE43);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "fib-trend-extension",
@@ -5864,34 +6458,34 @@ function fibTrendExtensionImpl(slotId, anchors, opts) {
 }
 function fibTrendExtension(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE40);
+    throw new Error(OUTSIDE_CTX_MESSAGE43);
   }
   return fibTrendExtensionImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibA/fibWedge.js
-var OUTSIDE_CTX_MESSAGE41 = "draw.fibWedge called outside an active script step";
+var OUTSIDE_CTX_MESSAGE44 = "draw.fibWedge called outside an active script step";
 function fibWedgeImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE41);
+    throw new Error(OUTSIDE_CTX_MESSAGE44);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "fib-wedge", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "fib-wedge", state2);
 }
 function fibWedge(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE41);
+    throw new Error(OUTSIDE_CTX_MESSAGE44);
   }
   return fibWedgeImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibB/fibCircles.js
-var OUTSIDE_CTX_MESSAGE42 = "draw.fibCircles called outside an active script step";
+var OUTSIDE_CTX_MESSAGE45 = "draw.fibCircles called outside an active script step";
 function fibCirclesImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE42);
+    throw new Error(OUTSIDE_CTX_MESSAGE45);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "fib-circles",
@@ -5902,17 +6496,17 @@ function fibCirclesImpl(slotId, a, b, opts) {
 }
 function fibCircles(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE42);
+    throw new Error(OUTSIDE_CTX_MESSAGE45);
   }
   return fibCirclesImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibB/fibSpeedArcs.js
-var OUTSIDE_CTX_MESSAGE43 = "draw.fibSpeedArcs called outside an active script step";
+var OUTSIDE_CTX_MESSAGE46 = "draw.fibSpeedArcs called outside an active script step";
 function fibSpeedArcsImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE43);
+    throw new Error(OUTSIDE_CTX_MESSAGE46);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "fib-speed-arcs",
@@ -5923,17 +6517,17 @@ function fibSpeedArcsImpl(slotId, a, b, opts) {
 }
 function fibSpeedArcs(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE43);
+    throw new Error(OUTSIDE_CTX_MESSAGE46);
   }
   return fibSpeedArcsImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibB/fibSpeedFan.js
-var OUTSIDE_CTX_MESSAGE44 = "draw.fibSpeedFan called outside an active script step";
+var OUTSIDE_CTX_MESSAGE47 = "draw.fibSpeedFan called outside an active script step";
 function fibSpeedFanImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE44);
+    throw new Error(OUTSIDE_CTX_MESSAGE47);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "fib-speed-fan",
@@ -5944,17 +6538,17 @@ function fibSpeedFanImpl(slotId, a, b, opts) {
 }
 function fibSpeedFan(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE44);
+    throw new Error(OUTSIDE_CTX_MESSAGE47);
   }
   return fibSpeedFanImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibB/fibSpiral.js
-var OUTSIDE_CTX_MESSAGE45 = "draw.fibSpiral called outside an active script step";
+var OUTSIDE_CTX_MESSAGE48 = "draw.fibSpiral called outside an active script step";
 function fibSpiralImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE45);
+    throw new Error(OUTSIDE_CTX_MESSAGE48);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "fib-spiral",
@@ -5965,17 +6559,17 @@ function fibSpiralImpl(slotId, a, b, opts) {
 }
 function fibSpiral(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE45);
+    throw new Error(OUTSIDE_CTX_MESSAGE48);
   }
   return fibSpiralImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/fibB/fibTrendTime.js
-var OUTSIDE_CTX_MESSAGE46 = "draw.fibTrendTime called outside an active script step";
+var OUTSIDE_CTX_MESSAGE49 = "draw.fibTrendTime called outside an active script step";
 function fibTrendTimeImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE46);
+    throw new Error(OUTSIDE_CTX_MESSAGE49);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "fib-trend-time",
@@ -5986,17 +6580,17 @@ function fibTrendTimeImpl(slotId, anchors, opts) {
 }
 function fibTrendTime(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE46);
+    throw new Error(OUTSIDE_CTX_MESSAGE49);
   }
   return fibTrendTimeImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/gann/gannBox.js
-var OUTSIDE_CTX_MESSAGE47 = "draw.gannBox called outside an active script step";
+var OUTSIDE_CTX_MESSAGE50 = "draw.gannBox called outside an active script step";
 function gannBoxImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE47);
+    throw new Error(OUTSIDE_CTX_MESSAGE50);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "gann-box",
@@ -6007,17 +6601,17 @@ function gannBoxImpl(slotId, a, b, opts) {
 }
 function gannBox(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE47);
+    throw new Error(OUTSIDE_CTX_MESSAGE50);
   }
   return gannBoxImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/gann/gannFan.js
-var OUTSIDE_CTX_MESSAGE48 = "draw.gannFan called outside an active script step";
+var OUTSIDE_CTX_MESSAGE51 = "draw.gannFan called outside an active script step";
 function gannFanImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE48);
+    throw new Error(OUTSIDE_CTX_MESSAGE51);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "gann-fan",
@@ -6028,17 +6622,17 @@ function gannFanImpl(slotId, a, b, opts) {
 }
 function gannFan(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE48);
+    throw new Error(OUTSIDE_CTX_MESSAGE51);
   }
   return gannFanImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/gann/gannSquare.js
-var OUTSIDE_CTX_MESSAGE49 = "draw.gannSquare called outside an active script step";
+var OUTSIDE_CTX_MESSAGE52 = "draw.gannSquare called outside an active script step";
 function gannSquareImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE49);
+    throw new Error(OUTSIDE_CTX_MESSAGE52);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "gann-square",
@@ -6049,17 +6643,17 @@ function gannSquareImpl(slotId, a, b, opts) {
 }
 function gannSquare(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE49);
+    throw new Error(OUTSIDE_CTX_MESSAGE52);
   }
   return gannSquareImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/gann/gannSquareFixed.js
-var OUTSIDE_CTX_MESSAGE50 = "draw.gannSquareFixed called outside an active script step";
+var OUTSIDE_CTX_MESSAGE53 = "draw.gannSquareFixed called outside an active script step";
 function gannSquareFixedImpl(slotId, anchor, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE50);
+    throw new Error(OUTSIDE_CTX_MESSAGE53);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "gann-square-fixed",
@@ -6070,153 +6664,153 @@ function gannSquareFixedImpl(slotId, anchor, opts) {
 }
 function gannSquareFixed(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE50);
+    throw new Error(OUTSIDE_CTX_MESSAGE53);
   }
   return gannSquareFixedImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/lines/crossLine.js
-var OUTSIDE_CTX_MESSAGE51 = "draw.crossLine called outside an active script step";
+var OUTSIDE_CTX_MESSAGE54 = "draw.crossLine called outside an active script step";
 function crossLineImpl(slotId, anchor, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE51);
+    throw new Error(OUTSIDE_CTX_MESSAGE54);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "cross-line", anchor, style: opts };
   return createDrawingHandle(slotId, subId, "cross-line", state2);
 }
 function crossLine(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || typeof arg2 !== "object") {
-    throw new Error(OUTSIDE_CTX_MESSAGE51);
+    throw new Error(OUTSIDE_CTX_MESSAGE54);
   }
   return crossLineImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/lines/horizontalLine.js
-var OUTSIDE_CTX_MESSAGE52 = "draw.horizontalLine called outside an active script step";
+var OUTSIDE_CTX_MESSAGE55 = "draw.horizontalLine called outside an active script step";
 function horizontalLineImpl(slotId, price, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE52);
+    throw new Error(OUTSIDE_CTX_MESSAGE55);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "horizontal-line", price, style: opts };
   return createDrawingHandle(slotId, subId, "horizontal-line", state2);
 }
 function horizontalLine(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || typeof arg2 !== "number") {
-    throw new Error(OUTSIDE_CTX_MESSAGE52);
+    throw new Error(OUTSIDE_CTX_MESSAGE55);
   }
   return horizontalLineImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/lines/horizontalRay.js
-var OUTSIDE_CTX_MESSAGE53 = "draw.horizontalRay called outside an active script step";
+var OUTSIDE_CTX_MESSAGE56 = "draw.horizontalRay called outside an active script step";
 function horizontalRayImpl(slotId, anchor, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE53);
+    throw new Error(OUTSIDE_CTX_MESSAGE56);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "horizontal-ray", anchor, style: opts };
   return createDrawingHandle(slotId, subId, "horizontal-ray", state2);
 }
 function horizontalRay(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || typeof arg2 !== "object") {
-    throw new Error(OUTSIDE_CTX_MESSAGE53);
+    throw new Error(OUTSIDE_CTX_MESSAGE56);
   }
   return horizontalRayImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/lines/line.js
-var OUTSIDE_CTX_MESSAGE54 = "draw.line called outside an active script step";
+var OUTSIDE_CTX_MESSAGE57 = "draw.line called outside an active script step";
 function lineImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE54);
+    throw new Error(OUTSIDE_CTX_MESSAGE57);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "line", anchors: [a, b], style: opts };
   return createDrawingHandle(slotId, subId, "line", state2);
 }
 function line(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE54);
+    throw new Error(OUTSIDE_CTX_MESSAGE57);
   }
   return lineImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/lines/trendAngle.js
-var OUTSIDE_CTX_MESSAGE55 = "draw.trendAngle called outside an active script step";
+var OUTSIDE_CTX_MESSAGE58 = "draw.trendAngle called outside an active script step";
 function trendAngleImpl(slotId, a, b, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE55);
+    throw new Error(OUTSIDE_CTX_MESSAGE58);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "trend-angle", anchors: [a, b], style: opts };
   return createDrawingHandle(slotId, subId, "trend-angle", state2);
 }
 function trendAngle(arg1, arg2, arg3, arg4) {
   if (typeof arg1 !== "string" || arg2 === void 0 || arg3 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE55);
+    throw new Error(OUTSIDE_CTX_MESSAGE58);
   }
   return trendAngleImpl(arg1, arg2, arg3, arg4 ?? {});
 }
 
 // ../runtime/dist/emit/draw/lines/verticalLine.js
-var OUTSIDE_CTX_MESSAGE56 = "draw.verticalLine called outside an active script step";
-function verticalLineImpl(slotId, time, opts) {
+var OUTSIDE_CTX_MESSAGE59 = "draw.verticalLine called outside an active script step";
+function verticalLineImpl(slotId, time2, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE56);
+    throw new Error(OUTSIDE_CTX_MESSAGE59);
   const subId = nextSubId(ctx, slotId);
-  const state2 = { kind: "vertical-line", time, style: opts };
+  const state2 = { kind: "vertical-line", time: time2, style: opts };
   return createDrawingHandle(slotId, subId, "vertical-line", state2);
 }
 function verticalLine(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || typeof arg2 !== "number") {
-    throw new Error(OUTSIDE_CTX_MESSAGE56);
+    throw new Error(OUTSIDE_CTX_MESSAGE59);
   }
   return verticalLineImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/patterns/abcdPattern.js
-var OUTSIDE_CTX_MESSAGE57 = "draw.abcdPattern called outside an active script step";
+var OUTSIDE_CTX_MESSAGE60 = "draw.abcdPattern called outside an active script step";
 function abcdPatternImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE57);
+    throw new Error(OUTSIDE_CTX_MESSAGE60);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "abcd-pattern", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "abcd-pattern", state2);
 }
 function abcdPattern(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE57);
+    throw new Error(OUTSIDE_CTX_MESSAGE60);
   }
   return abcdPatternImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/patterns/cypherPattern.js
-var OUTSIDE_CTX_MESSAGE58 = "draw.cypherPattern called outside an active script step";
+var OUTSIDE_CTX_MESSAGE61 = "draw.cypherPattern called outside an active script step";
 function cypherPatternImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE58);
+    throw new Error(OUTSIDE_CTX_MESSAGE61);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "cypher-pattern", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "cypher-pattern", state2);
 }
 function cypherPattern(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE58);
+    throw new Error(OUTSIDE_CTX_MESSAGE61);
   }
   return cypherPatternImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/patterns/headAndShoulders.js
-var OUTSIDE_CTX_MESSAGE59 = "draw.headAndShoulders called outside an active script step";
+var OUTSIDE_CTX_MESSAGE62 = "draw.headAndShoulders called outside an active script step";
 function headAndShouldersImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE59);
+    throw new Error(OUTSIDE_CTX_MESSAGE62);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "head-and-shoulders",
@@ -6227,17 +6821,17 @@ function headAndShouldersImpl(slotId, anchors, opts) {
 }
 function headAndShoulders(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE59);
+    throw new Error(OUTSIDE_CTX_MESSAGE62);
   }
   return headAndShouldersImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/patterns/threeDrivesPattern.js
-var OUTSIDE_CTX_MESSAGE60 = "draw.threeDrivesPattern called outside an active script step";
+var OUTSIDE_CTX_MESSAGE63 = "draw.threeDrivesPattern called outside an active script step";
 function threeDrivesPatternImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE60);
+    throw new Error(OUTSIDE_CTX_MESSAGE63);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "three-drives-pattern",
@@ -6248,17 +6842,17 @@ function threeDrivesPatternImpl(slotId, anchors, opts) {
 }
 function threeDrivesPattern(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE60);
+    throw new Error(OUTSIDE_CTX_MESSAGE63);
   }
   return threeDrivesPatternImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/patterns/trianglePattern.js
-var OUTSIDE_CTX_MESSAGE61 = "draw.trianglePattern called outside an active script step";
+var OUTSIDE_CTX_MESSAGE64 = "draw.trianglePattern called outside an active script step";
 function trianglePatternImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE61);
+    throw new Error(OUTSIDE_CTX_MESSAGE64);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "triangle-pattern",
@@ -6269,51 +6863,51 @@ function trianglePatternImpl(slotId, anchors, opts) {
 }
 function trianglePattern(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE61);
+    throw new Error(OUTSIDE_CTX_MESSAGE64);
   }
   return trianglePatternImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/patterns/xabcdPattern.js
-var OUTSIDE_CTX_MESSAGE62 = "draw.xabcdPattern called outside an active script step";
+var OUTSIDE_CTX_MESSAGE65 = "draw.xabcdPattern called outside an active script step";
 function xabcdPatternImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE62);
+    throw new Error(OUTSIDE_CTX_MESSAGE65);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "xabcd-pattern", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "xabcd-pattern", state2);
 }
 function xabcdPattern(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE62);
+    throw new Error(OUTSIDE_CTX_MESSAGE65);
   }
   return xabcdPatternImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/pitchforks/pitchfan.js
-var OUTSIDE_CTX_MESSAGE63 = "draw.pitchfan called outside an active script step";
+var OUTSIDE_CTX_MESSAGE66 = "draw.pitchfan called outside an active script step";
 function pitchfanImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE63);
+    throw new Error(OUTSIDE_CTX_MESSAGE66);
   const subId = nextSubId(ctx, slotId);
   const state2 = { kind: "pitchfan", anchors, style: opts };
   return createDrawingHandle(slotId, subId, "pitchfan", state2);
 }
 function pitchfan(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE63);
+    throw new Error(OUTSIDE_CTX_MESSAGE66);
   }
   return pitchfanImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/pitchforks/pitchfork.js
-var OUTSIDE_CTX_MESSAGE64 = "draw.pitchfork called outside an active script step";
+var OUTSIDE_CTX_MESSAGE67 = "draw.pitchfork called outside an active script step";
 function pitchforkImpl(slotId, anchors, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE64);
+    throw new Error(OUTSIDE_CTX_MESSAGE67);
   const subId = nextSubId(ctx, slotId);
   const { variant: variantOpt, ...style } = opts;
   const state2 = {
@@ -6326,17 +6920,17 @@ function pitchforkImpl(slotId, anchors, opts) {
 }
 function pitchfork(arg1, arg2, arg3) {
   if (typeof arg1 !== "string" || arg2 === void 0 || !Array.isArray(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE64);
+    throw new Error(OUTSIDE_CTX_MESSAGE67);
   }
   return pitchforkImpl(arg1, arg2, arg3 ?? {});
 }
 
 // ../runtime/dist/emit/draw/table/table.js
-var OUTSIDE_CTX_MESSAGE65 = "draw.table called outside an active script step";
+var OUTSIDE_CTX_MESSAGE68 = "draw.table called outside an active script step";
 function tableImpl(slotId, opts) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null)
-    throw new Error(OUTSIDE_CTX_MESSAGE65);
+    throw new Error(OUTSIDE_CTX_MESSAGE68);
   const subId = nextSubId(ctx, slotId);
   const state2 = {
     kind: "table",
@@ -6350,7 +6944,7 @@ function tableImpl(slotId, opts) {
 }
 function table2(arg1, arg2) {
   if (typeof arg1 !== "string" || arg2 === void 0) {
-    throw new Error(OUTSIDE_CTX_MESSAGE65);
+    throw new Error(OUTSIDE_CTX_MESSAGE68);
   }
   return tableImpl(arg1, arg2);
 }
@@ -6449,7 +7043,7 @@ var DRAW_NAMESPACE = new Proxy(KIND_IMPLS, {
 });
 
 // ../runtime/dist/emit/hline.js
-var OUTSIDE_CTX_MESSAGE66 = "hline called outside an active script step";
+var OUTSIDE_CTX_MESSAGE69 = "hline called outside an active script step";
 function hlineImpl(ctx, slotId, price, opts) {
   const style = {
     kind: "horizontal-line",
@@ -6484,13 +7078,13 @@ function hlineImpl(ctx, slotId, price, opts) {
 }
 function hline2(arg1, arg2, arg3) {
   if (typeof arg1 !== "string") {
-    throw new Error(OUTSIDE_CTX_MESSAGE66);
+    throw new Error(OUTSIDE_CTX_MESSAGE69);
   }
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (!ctx)
-    throw new Error(OUTSIDE_CTX_MESSAGE66);
+    throw new Error(OUTSIDE_CTX_MESSAGE69);
   if (typeof arg2 !== "number") {
-    throw new Error(OUTSIDE_CTX_MESSAGE66);
+    throw new Error(OUTSIDE_CTX_MESSAGE69);
   }
   hlineImpl(ctx, arg1, arg2, arg3 ?? {});
 }
@@ -6607,122 +7201,6 @@ function buildRuntimeNamespace(ctx) {
   });
 }
 
-// ../runtime/dist/emit/plot.js
-var OUTSIDE_CTX_MESSAGE67 = "plot called outside an active script step";
-function isSeriesNumber(v) {
-  return typeof v === "object" && v !== null && "current" in v;
-}
-function isNumberOrSeries(v) {
-  return typeof v === "number" || isSeriesNumber(v);
-}
-function resolveValue(value) {
-  const resolved = typeof value === "number" ? value : value.current;
-  return Number.isFinite(resolved) ? resolved : null;
-}
-function buildStyle(opts) {
-  const style = opts.style;
-  if (style === void 0) {
-    return {
-      kind: "line",
-      lineWidth: opts.lineWidth ?? 1,
-      lineStyle: opts.lineStyle ?? "solid"
-    };
-  }
-  switch (style.kind) {
-    case "histogram":
-      return { kind: "histogram", baseline: style.baseline ?? 0 };
-    case "marker":
-      return { kind: "marker", shape: style.shape, size: style.size };
-    case "shape":
-      return {
-        kind: "shape",
-        shape: style.shape,
-        size: style.size,
-        ...style.location === void 0 ? {} : { location: style.location }
-      };
-    case "character":
-      return {
-        kind: "character",
-        char: style.char,
-        size: style.size,
-        ...style.location === void 0 ? {} : { location: style.location }
-      };
-    case "arrow":
-      return { kind: "arrow", direction: style.direction, size: style.size };
-    case "candle-override":
-      return {
-        kind: "candle-override",
-        bull: style.bull,
-        bear: style.bear,
-        ...style.doji === void 0 ? {} : { doji: style.doji }
-      };
-    case "bar-override":
-      return { kind: "bar-override", color: style.color };
-    case "bg-color":
-      return {
-        kind: "bg-color",
-        color: style.color,
-        ...style.transp === void 0 ? {} : { transp: style.transp }
-      };
-    case "bar-color":
-      return { kind: "bar-color", color: style.color };
-    case "horizontal-histogram":
-      return { kind: "horizontal-histogram", buckets: style.buckets };
-    case "line":
-    case "step-line":
-    case "horizontal-line":
-      return {
-        kind: style.kind,
-        lineWidth: opts.lineWidth ?? 1,
-        lineStyle: opts.lineStyle ?? "solid"
-      };
-  }
-}
-function plotImpl(ctx, slotId, value, opts) {
-  const style = buildStyle(opts);
-  if (!ctx.capabilities.plots.has(style.kind)) {
-    pushDiagnostic(ctx.emissions, {
-      kind: "diagnostic",
-      severity: "warning",
-      code: "unsupported-plot-kind",
-      message: `Adapter cannot render plot kind "${style.kind}".`,
-      slotId,
-      bar: ctx.barIndex()
-    });
-    return;
-  }
-  const pane = resolvePane(opts.pane, ctx, slotId);
-  const xShift = typeof value === "number" ? 0 : seriesOffsetOf(value);
-  const z = opts.z ?? 0;
-  const emission = {
-    kind: "plot",
-    slotId,
-    title: opts.title ?? "",
-    style,
-    bar: ctx.barIndex(),
-    time: ctx.stream.bar.time,
-    value: resolveValue(value),
-    color: opts.color ?? null,
-    meta: {},
-    pane,
-    ...xShift === 0 ? {} : { xShift },
-    ...z === 0 ? {} : { z }
-  };
-  pushPlot(ctx.emissions, applyPlotOverride(emission, ctx.plotOverrides[slotId]));
-}
-function plot2(arg1, arg2, arg3) {
-  if (typeof arg1 !== "string") {
-    throw new Error(OUTSIDE_CTX_MESSAGE67);
-  }
-  const ctx = ACTIVE_RUNTIME_CONTEXT.current;
-  if (!ctx)
-    throw new Error(OUTSIDE_CTX_MESSAGE67);
-  if (!isNumberOrSeries(arg2)) {
-    throw new Error(OUTSIDE_CTX_MESSAGE67);
-  }
-  plotImpl(ctx, arg1, arg2, arg3 ?? {});
-}
-
 // ../runtime/dist/ta/lib/volume-profile/scaffold.js
 var DEFAULT_ROW_SIZE = 24;
 var DEFAULT_VALUE_AREA_PCT = 0.7;
@@ -6879,15 +7357,15 @@ function collectBars(ctx, anchor) {
   const { ohlcv } = ctx.stream;
   const bars = [];
   for (let lookback = ohlcv.close.length - 1; lookback >= 0; lookback -= 1) {
-    const time = ohlcv.time.at(lookback);
-    if (time < anchor)
+    const time2 = ohlcv.time.at(lookback);
+    if (time2 < anchor)
       continue;
     bars.push({
       close: ohlcv.close.at(lookback),
       high: ohlcv.high.at(lookback),
       low: ohlcv.low.at(lookback),
       open: ohlcv.open.at(lookback),
-      time,
+      time: time2,
       volume: ohlcv.volume.at(lookback)
     });
   }
@@ -6947,8 +7425,8 @@ function readSource(ctx, source) {
       return ctx.stream.bar.hlcc4;
   }
 }
-function fold(inCumPV, inCumV, inStarted, anchorTime, time, src, volume) {
-  if (time < anchorTime) {
+function fold(inCumPV, inCumV, inStarted, anchorTime, time2, src, volume) {
+  if (time2 < anchorTime) {
     return { cumPV: inCumPV, cumV: inCumV, started: inStarted };
   }
   let cumPV = inCumPV;
@@ -6974,16 +7452,16 @@ function anchoredVwap(slotId, anchorTime, opts) {
   }
   const src = readSource(ctx, source);
   const volume = ctx.stream.bar.volume;
-  const time = ctx.stream.bar.time;
+  const time2 = ctx.stream.bar.time;
   if (ctx.isTick) {
-    const next2 = fold(slot.prevClosedCumPV, slot.prevClosedCumV, slot.prevClosedStarted, slot.anchorTime, time, src, volume);
+    const next2 = fold(slot.prevClosedCumPV, slot.prevClosedCumV, slot.prevClosedStarted, slot.anchorTime, time2, src, volume);
     slot.outBuffer.replaceHead(valueFromCum(next2.started, next2.cumPV, next2.cumV));
     return slot.series;
   }
   slot.prevClosedCumPV = slot.cumPV;
   slot.prevClosedCumV = slot.cumV;
   slot.prevClosedStarted = slot.started;
-  const next = fold(slot.cumPV, slot.cumV, slot.started, slot.anchorTime, time, src, volume);
+  const next = fold(slot.cumPV, slot.cumV, slot.started, slot.anchorTime, time2, src, volume);
   slot.cumPV = next.cumPV;
   slot.cumV = next.cumV;
   slot.started = next.started;
@@ -9724,15 +10202,15 @@ function collectBars2(ctx, from, to) {
   const { ohlcv } = ctx.stream;
   const bars = [];
   for (let lookback = ohlcv.close.length - 1; lookback >= 0; lookback -= 1) {
-    const time = ohlcv.time.at(lookback);
-    if (time < from || time > to)
+    const time2 = ohlcv.time.at(lookback);
+    if (time2 < from || time2 > to)
       continue;
     bars.push({
       close: ohlcv.close.at(lookback),
       high: ohlcv.high.at(lookback),
       low: ohlcv.low.at(lookback),
       open: ohlcv.open.at(lookback),
-      time,
+      time: time2,
       volume: ohlcv.volume.at(lookback)
     });
   }
@@ -11553,8 +12031,8 @@ function emitLevels(slot, levels, isTick) {
     slot.s3Buffer.append(levels.s3);
   }
 }
-function closeStep3(slot, time, high, low, close) {
-  const dayKey = Math.floor(time / MS_PER_DAY2);
+function closeStep3(slot, time2, high, low, close) {
+  const dayKey = Math.floor(time2 / MS_PER_DAY2);
   snapshot(slot);
   if (slot.barCount === 0) {
     slot.barCount = 1;
@@ -11581,11 +12059,11 @@ function closeStep3(slot, time, high, low, close) {
   slot.barCount += 1;
   return computeLevels(slot);
 }
-function tickStep2(slot, time, _high, _low, _close) {
+function tickStep2(slot, time2, _high, _low, _close) {
   if (slot.prevClosedBarCount === 0) {
     return makeNaNLevels();
   }
-  const dayKey = Math.floor(time / MS_PER_DAY2);
+  const dayKey = Math.floor(time2 / MS_PER_DAY2);
   const snapKey = slot.prevClosedCurrentDayKey;
   const snapPrevHigh = slot.prevClosedPrevDayHigh;
   const snapPrevLow = slot.prevClosedPrevDayLow;
@@ -12510,6 +12988,26 @@ function rvi(slotId, source, length, opts) {
   return viewForOffset21(slot, opts?.offset ?? 0);
 }
 
+// ../runtime/dist/time-accessors/sessionWindow.js
+var SESSION_WINDOW = /^(\d{1,2})(?::?(\d{2}))?\s*-\s*(\d{1,2})(?::?(\d{2}))?$/;
+function parseSessionWindowMinutes(spec) {
+  const match = SESSION_WINDOW.exec(spec.trim());
+  if (match === null)
+    return null;
+  const startHour = Number(match[1]);
+  const startMinute = match[2] === void 0 ? 0 : Number(match[2]);
+  const endHour = Number(match[3]);
+  const endMinute = match[4] === void 0 ? 0 : Number(match[4]);
+  if (startHour < 0 || startHour > 23 || startMinute < 0 || startMinute > 59)
+    return null;
+  if (endHour < 0 || endHour > 23 || endMinute < 0 || endMinute > 59)
+    return null;
+  return {
+    startMinutes: startHour * 60 + startMinute,
+    endMinutes: endHour * 60 + endMinute
+  };
+}
+
 // ../runtime/dist/ta/sessionVolumeProfile.js
 var DAY_MS = 864e5;
 function getCtx77() {
@@ -12552,33 +13050,16 @@ function resultForOffset10(slot, offset) {
   }
   return cached;
 }
-function utcDayStart(time) {
-  return Math.floor(time / DAY_MS) * DAY_MS;
-}
-function parseSessionWindowMinutes(session) {
-  const match = /^(\d{1,2})(?::?(\d{2}))?\s*-\s*(\d{1,2})(?::?(\d{2}))?$/.exec(session.trim());
-  if (match === null)
-    return null;
-  const startHour = Number(match[1]);
-  const startMinute = match[2] === void 0 ? 0 : Number(match[2]);
-  const endHour = Number(match[3]);
-  const endMinute = match[4] === void 0 ? 0 : Number(match[4]);
-  if (startHour < 0 || startHour > 23 || startMinute < 0 || startMinute > 59)
-    return null;
-  if (endHour < 0 || endHour > 23 || endMinute < 0 || endMinute > 59)
-    return null;
-  return {
-    startMinutes: startHour * 60 + startMinute,
-    endMinutes: endHour * 60 + endMinute
-  };
+function utcDayStart(time2) {
+  return Math.floor(time2 / DAY_MS) * DAY_MS;
 }
-function sessionBoundaryFromDescriptor(time, session) {
-  const parsed = parseSessionWindowMinutes(session);
+function sessionBoundaryFromDescriptor(time2, session2) {
+  const parsed = parseSessionWindowMinutes(session2);
   if (parsed === null)
     return null;
-  const dayStart = utcDayStart(time);
+  const dayStart = utcDayStart(time2);
   const boundary = dayStart + parsed.startMinutes * 6e4;
-  return time >= boundary ? boundary : boundary - DAY_MS;
+  return time2 >= boundary ? boundary : boundary - DAY_MS;
 }
 function diagnoseMissingSession(ctx, slotId) {
   const key = `session-info-missing|${slotId}`;
@@ -12597,12 +13078,12 @@ function diagnoseMissingSession(ctx, slotId) {
 function resolveSessionStart(ctx, slotId, opts) {
   if (opts?.sessionStart !== void 0)
     return opts.sessionStart;
-  const session = ctx.views.syminfo.session;
-  if (!ctx.capabilities.symInfoFields.has("session") || session === "") {
+  const session2 = ctx.views.syminfo.session;
+  if (!ctx.capabilities.symInfoFields.has("session") || session2 === "") {
     diagnoseMissingSession(ctx, slotId);
     return utcDayStart(ctx.stream.bar.time);
   }
-  const boundary = sessionBoundaryFromDescriptor(ctx.stream.bar.time, session);
+  const boundary = sessionBoundaryFromDescriptor(ctx.stream.bar.time, session2);
   if (boundary === null) {
     diagnoseMissingSession(ctx, slotId);
     return utcDayStart(ctx.stream.bar.time);
@@ -12613,15 +13094,15 @@ function collectBars3(ctx, sessionStart) {
   const { ohlcv } = ctx.stream;
   const bars = [];
   for (let lookback = ohlcv.close.length - 1; lookback >= 0; lookback -= 1) {
-    const time = ohlcv.time.at(lookback);
-    if (time <= sessionStart)
+    const time2 = ohlcv.time.at(lookback);
+    if (time2 <= sessionStart)
       continue;
     bars.push({
       close: ohlcv.close.at(lookback),
       high: ohlcv.high.at(lookback),
       low: ohlcv.low.at(lookback),
       open: ohlcv.open.at(lookback),
-      time,
+      time: time2,
       volume: ohlcv.volume.at(lookback)
     });
   }
@@ -13539,15 +14020,15 @@ function collectBars4(ctx) {
   const { fromTime, toTime } = ctx.stream.bar.viewport;
   const bars = [];
   for (let lookback = ohlcv.close.length - 1; lookback >= 0; lookback -= 1) {
-    const time = ohlcv.time.at(lookback);
-    if (time < fromTime || time > toTime)
+    const time2 = ohlcv.time.at(lookback);
+    if (time2 < fromTime || time2 > toTime)
       continue;
     bars.push({
       close: ohlcv.close.at(lookback),
       high: ohlcv.high.at(lookback),
       low: ohlcv.low.at(lookback),
       open: ohlcv.open.at(lookback),
-      time,
+      time: time2,
       volume: ohlcv.volume.at(lookback)
     });
   }
@@ -13913,8 +14394,8 @@ function readSource2(ctx, source) {
       return ctx.stream.bar.hlcc4;
   }
 }
-function dayKeyOf(time) {
-  return Math.floor(time / MS_PER_DAY3);
+function dayKeyOf(time2) {
+  return Math.floor(time2 / MS_PER_DAY3);
 }
 function fold7(inCumPV, inCumV, inDayKey, dayKey, src, volume) {
   let cumPV = inCumPV;
@@ -14669,6 +15150,196 @@ var TA_REGISTRY_METADATA = Object.freeze({
 // ../runtime/dist/primitives.js
 var ta3 = TA_REGISTRY;
 
+// ../runtime/dist/time-accessors/civil.js
+var DAY_MS2 = 864e5;
+function floorDiv(a, b) {
+  return Math.floor(a / b);
+}
+function mod(a, b) {
+  return a - floorDiv(a, b) * b;
+}
+function civilFromDays(z) {
+  const shifted = z + 719468;
+  const era = floorDiv(shifted >= 0 ? shifted : shifted - 146096, 146097);
+  const doe = shifted - era * 146097;
+  const yoe = floorDiv(doe - floorDiv(doe, 1460) + floorDiv(doe, 36524) - floorDiv(doe, 146096), 365);
+  const y = yoe + era * 400;
+  const doy = doe - (365 * yoe + floorDiv(yoe, 4) - floorDiv(yoe, 100));
+  const mp = floorDiv(5 * doy + 2, 153);
+  const d = doy - floorDiv(153 * mp + 2, 5) + 1;
+  const m = mp < 10 ? mp + 3 : mp - 9;
+  return { y: m <= 2 ? y + 1 : y, m, d };
+}
+function daysFromCivil(y, m, d) {
+  const yy = m <= 2 ? y - 1 : y;
+  const era = floorDiv(yy >= 0 ? yy : yy - 399, 400);
+  const yoe = yy - era * 400;
+  const doy = floorDiv(153 * (m > 2 ? m - 3 : m + 9) + 2, 5) + d - 1;
+  const doe = yoe * 365 + floorDiv(yoe, 4) - floorDiv(yoe, 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+function splitEpoch(ms, offsetMin) {
+  const local = Math.floor(ms) + offsetMin * 6e4;
+  const z = floorDiv(local, DAY_MS2);
+  const secondsOfDay = floorDiv(mod(local, DAY_MS2), 1e3);
+  const { y, m, d } = civilFromDays(z);
+  return {
+    y,
+    m,
+    d,
+    hh: floorDiv(secondsOfDay, 3600),
+    mm: floorDiv(mod(secondsOfDay, 3600), 60),
+    ss: mod(secondsOfDay, 60),
+    dow: mod(z + 4, 7)
+  };
+}
+
+// ../runtime/dist/time-accessors/tzDiagnostic.js
+function buildTzDstReporter(ctx) {
+  return (tz) => {
+    const key = `tz-dst-unsupported|${tz}`;
+    if (ctx.diagnosedTzKeys.has(key))
+      return;
+    ctx.diagnosedTzKeys.add(key);
+    pushDiagnostic(ctx.emissions, {
+      kind: "diagnostic",
+      severity: "warning",
+      code: "tz-dst-unsupported",
+      message: `Timezone \`${tz}\` needs DST data unavailable in this build; calendar fields used UTC.`,
+      slotId: null,
+      bar: ctx.barIndex()
+    });
+  };
+}
+
+// ../runtime/dist/time-accessors/tzOffset.js
+var UTC_ALIASES = /* @__PURE__ */ new Set(["", "UTC", "ETC/UTC", "GMT", "Z"]);
+var UTC = { offsetMin: 0, dstUnsupported: false };
+var DST_UNSUPPORTED = { offsetMin: 0, dstUnsupported: true };
+var SIGNED_OFFSET = /^([+-])(\d{1,2})(?::?(\d{2}))?$/;
+var UTC_PREFIXED = /^(?:UTC|GMT)([+-]\d{1,2}(?::?\d{2})?)$/;
+var ETC_GMT = /^ETC\/GMT([+-])(\d{1,2})$/;
+function parseSignedOffset(value) {
+  const match = SIGNED_OFFSET.exec(value);
+  if (match === null)
+    return null;
+  const hours = Number(match[2]);
+  const minutes = match[3] === void 0 ? 0 : Number(match[3]);
+  if (hours > 23 || minutes > 59)
+    return null;
+  const magnitude = hours * 60 + minutes;
+  return match[1] === "-" ? -magnitude : magnitude;
+}
+function resolveOffsetMinutes(tz) {
+  const normalized = tz.trim().toUpperCase();
+  if (UTC_ALIASES.has(normalized))
+    return UTC;
+  const signed = parseSignedOffset(normalized);
+  if (signed !== null)
+    return { offsetMin: signed, dstUnsupported: false };
+  const utcPrefixed = UTC_PREFIXED.exec(normalized);
+  if (utcPrefixed !== null) {
+    const minutes = parseSignedOffset(utcPrefixed[1]);
+    if (minutes !== null)
+      return { offsetMin: minutes, dstUnsupported: false };
+  }
+  const etcGmt = ETC_GMT.exec(normalized);
+  if (etcGmt !== null) {
+    const hours = Number(etcGmt[2]);
+    if (hours <= 23) {
+      const magnitude = hours * 60;
+      return { offsetMin: etcGmt[1] === "-" ? magnitude : -magnitude, dstUnsupported: false };
+    }
+  }
+  return DST_UNSUPPORTED;
+}
+
+// ../runtime/dist/time-accessors/timeAccessors.js
+function resolveTz(tz, getDefaultTz) {
+  if (tz !== void 0 && tz !== "")
+    return tz;
+  const fallback2 = getDefaultTz();
+  return fallback2 === "" ? "UTC" : fallback2;
+}
+function isInt(value) {
+  return Number.isInteger(value);
+}
+function createTimeNamespace(getDefaultTz, getIntervalMs, onDstUnsupported) {
+  function offsetFor(tz) {
+    const resolved = resolveTz(tz, getDefaultTz);
+    const { offsetMin, dstUnsupported } = resolveOffsetMinutes(resolved);
+    if (dstUnsupported)
+      onDstUnsupported(resolved);
+    return offsetMin;
+  }
+  function field(t, tz, key) {
+    const offsetMin = offsetFor(tz);
+    if (!Number.isFinite(t))
+      return Number.NaN;
+    return splitEpoch(t, offsetMin)[key];
+  }
+  return Object.freeze({
+    year: (t, tz) => field(t, tz, "y"),
+    month: (t, tz) => field(t, tz, "m"),
+    dayofmonth: (t, tz) => field(t, tz, "d"),
+    hour: (t, tz) => field(t, tz, "hh"),
+    minute: (t, tz) => field(t, tz, "mm"),
+    second: (t, tz) => field(t, tz, "ss"),
+    dayofweek: (t, tz) => {
+      const offsetMin = offsetFor(tz);
+      if (!Number.isFinite(t))
+        return Number.NaN;
+      return splitEpoch(t, offsetMin).dow + 1;
+    },
+    timestamp: (year, month, day, hour, minute, second, tz) => {
+      const offsetMin = offsetFor(tz);
+      const hh = hour ?? 0;
+      const mm = minute ?? 0;
+      const ss = second ?? 0;
+      if (!isInt(year) || !isInt(month) || !isInt(day) || !isInt(hh) || !isInt(mm) || !isInt(ss) || month < 1 || month > 12 || day < 1 || day > 31 || hh < 0 || hh > 23 || mm < 0 || mm > 59 || ss < 0 || ss > 59) {
+        return Number.NaN;
+      }
+      return daysFromCivil(year, month, day) * 864e5 + (hh * 3600 + mm * 60 + ss) * 1e3 - offsetMin * 6e4;
+    },
+    timeClose: (t, tz) => {
+      offsetFor(tz);
+      if (!Number.isFinite(t))
+        return Number.NaN;
+      return t + getIntervalMs();
+    }
+  });
+}
+function buildTimeNamespace(ctx) {
+  return createTimeNamespace(() => ctx.views.syminfo.timezone, () => ctx.views.timeframe.inSeconds * 1e3, buildTzDstReporter(ctx));
+}
+
+// ../runtime/dist/time-accessors/sessionAccessors.js
+function createSessionNamespace(getDefaultTz, onDstUnsupported) {
+  return Object.freeze({
+    isOpen(t, spec, tz) {
+      if (!Number.isFinite(t))
+        return false;
+      const parsed = parseSessionWindowMinutes(spec);
+      if (parsed === null)
+        return false;
+      const resolved = resolveTz(tz, getDefaultTz);
+      const { offsetMin, dstUnsupported } = resolveOffsetMinutes(resolved);
+      if (dstUnsupported)
+        onDstUnsupported(resolved);
+      const { hh, mm } = splitEpoch(t, offsetMin);
+      const minuteOfDay = hh * 60 + mm;
+      const { startMinutes, endMinutes } = parsed;
+      if (endMinutes <= startMinutes) {
+        return minuteOfDay >= startMinutes || minuteOfDay < endMinutes;
+      }
+      return minuteOfDay >= startMinutes && minuteOfDay < endMinutes;
+    }
+  });
+}
+function buildSessionNamespace(ctx) {
+  return createSessionNamespace(() => ctx.views.syminfo.timezone, buildTzDstReporter(ctx));
+}
+
 // ../runtime/dist/buildComputeContext.js
 function buildComputeContext(state2) {
   const base = {
@@ -14677,12 +15348,16 @@ function buildComputeContext(state2) {
     ta: ta3,
     plot: plot2,
     hline: hline2,
+    bgcolor: bgcolor2,
+    barcolor: barcolor2,
     alert: alert2,
     draw: DRAW_NAMESPACE,
     state: buildStateNamespace(),
     barstate: state2.runtimeContext.views.barstate,
     syminfo: state2.runtimeContext.views.syminfo,
     timeframe: state2.runtimeContext.views.timeframe,
+    time: buildTimeNamespace(state2.runtimeContext),
+    session: buildSessionNamespace(state2.runtimeContext),
     request: buildRequestNamespace(),
     runtime: buildRuntimeNamespace(state2.runtimeContext)
   };
@@ -14720,6 +15395,7 @@ async function runComputeBody(args) {
     if (isTick) {
       resetTentativeStateSlots(state2.runtimeContext);
       resetSeriesHeads(state2.runtimeContext);
+      resetTentativeArraySlots(state2.runtimeContext);
     } else {
       advanceSeriesSlots(state2.runtimeContext);
     }
@@ -14730,6 +15406,7 @@ async function runComputeBody(args) {
         commitStateSlots(state2.runtimeContext);
         flushStateSlots(state2.runtimeContext);
         commitSeriesSlots(state2.runtimeContext);
+        commitArraySlots(state2.runtimeContext);
       }
     } catch (err) {
       if (!isRuntimeErrorHalt(err))
@@ -14883,12 +15560,15 @@ function buildSubRunnerState(args, slotIdPrefix, isDep) {
       scriptMaxDrawings: args.compiled.manifest.maxDrawings ?? null,
       stateSlots: /* @__PURE__ */ new Map(),
       seriesSlots: /* @__PURE__ */ new Map(),
+      arraySlots: /* @__PURE__ */ new Map(),
+      chartSymbol: args.chartSymbol,
       secondaryStreams: args.secondaryStreams,
       requestSecurityBars: /* @__PURE__ */ new Map(),
       requestSecurityAlignments: /* @__PURE__ */ new Map(),
       requestSecurityAscendingBars: /* @__PURE__ */ new Map(),
       requestLowerTfViews: /* @__PURE__ */ new Map(),
       diagnosedRequestKeys: /* @__PURE__ */ new Set(),
+      diagnosedTzKeys: /* @__PURE__ */ new Set(),
       alertConditions,
       diagnosedAlertConditionKeys: /* @__PURE__ */ new Set(),
       logBudget: 0,
@@ -15010,13 +15690,13 @@ async function runSiblingStep(sibling, parentState, rawBar, eventKind, isTick) {
 
 // ../runtime/dist/dep/depOutput.js
 var DEP_OUTPUT_GLOBAL_KEY = "__chartlang_depOutput";
-var OUTSIDE_CTX_MESSAGE68 = "__chartlang_depOutput called outside an active script step";
+var OUTSIDE_CTX_MESSAGE70 = "__chartlang_depOutput called outside an active script step";
 var NO_STORE_MESSAGE = "__chartlang_depOutput called on a runner with no dep output store";
 var NAN_SERIES = makeSeriesView(new Float64RingBuffer(1));
 function __chartlang_depOutput(slotId, localId, title) {
   const ctx = ACTIVE_RUNTIME_CONTEXT.current;
   if (ctx === null) {
-    throw new Error(OUTSIDE_CTX_MESSAGE68);
+    throw new Error(OUTSIDE_CTX_MESSAGE70);
   }
   const store = ctx.depOutputStore;
   if (store === void 0 || store === null) {
@@ -15092,6 +15772,7 @@ function dispose(state2) {
   state2.runtimeContext.drawingSubIdCounters.clear();
   state2.runtimeContext.stateSlots.clear();
   state2.runtimeContext.seriesSlots.clear();
+  state2.runtimeContext.arraySlots.clear();
   state2.runtimeContext.secondaryStreams.clear();
   state2.runtimeContext.requestSecurityBars.clear();
   state2.runtimeContext.requestSecurityAlignments.clear();
@@ -15110,6 +15791,7 @@ function dispose(state2) {
   }
   state2.runtimeContext.requestLowerTfViews.clear();
   state2.runtimeContext.diagnosedRequestKeys.clear();
+  state2.runtimeContext.diagnosedTzKeys.clear();
   state2.runtimeContext.diagnosedInputKeys.clear();
   const counters = state2.runtimeContext.drawingBucketCounters;
   counters.lines = 0;
@@ -15497,6 +16179,7 @@ function primarySectionSlots(state2) {
   return Object.freeze({
     ...serialiseStateSlots(state2.runtimeContext),
     ...serialiseSeriesSlots(state2.runtimeContext),
+    ...serialiseArraySlots(state2.runtimeContext),
     ...serialiseTaSlots(state2.mainStream)
   });
 }
@@ -15504,7 +16187,8 @@ function runnerSection(ctx) {
   return Object.freeze({
     slots: Object.freeze({
       ...serialiseStateSlots(ctx),
-      ...serialiseSeriesSlots(ctx)
+      ...serialiseSeriesSlots(ctx),
+      ...serialiseArraySlots(ctx)
     })
   });
 }
@@ -15553,7 +16237,7 @@ function resolveMainStreamSnapshot(snapshot6, mainInterval) {
 function scalarStateSlots(slots) {
   const out = {};
   for (const [slotKey, value] of Object.entries(slots)) {
-    if (!isTaSlotSnapshotKey(slotKey) && !isSeriesSlotSnapshotKey(slotKey)) {
+    if (!isTaSlotSnapshotKey(slotKey) && !isSeriesSlotSnapshotKey(slotKey) && !isArraySlotSnapshotKey(slotKey)) {
       out[slotKey] = value;
     }
   }
@@ -15562,6 +16246,7 @@ function scalarStateSlots(slots) {
 function restoreRunnerSlots(ctx, slots, capacity) {
   restoreStateSlots(ctx, scalarStateSlots(slots));
   restoreSeriesSlots(ctx, slots, capacity);
+  restoreArraySlots(ctx, slots);
 }
 function pushMalformedSection(state2, message) {
   pushDiagnostic(state2.emissions, {
@@ -15672,12 +16357,19 @@ function resolveCapacity(manifest) {
   const fallback2 = manifest.maxLookback + 1;
   return Math.max(1, ohlcv ?? fallback2, dynamicFallback ?? 0);
 }
-function createSecondaryStreams(manifest, capacity) {
+function legacyFeedsFromIntervals(manifest) {
+  return manifest.requestedIntervals.map((interval) => ({ interval }));
+}
+function createSecondaryStreams(manifest, capacity, chartSymbol) {
   const streams = /* @__PURE__ */ new Map();
-  for (const interval of manifest.requestedIntervals) {
-    if (streams.has(interval))
+  const feeds = manifest.requestedFeeds ?? legacyFeedsFromIntervals(manifest);
+  for (const feed of feeds) {
+    const resolved = feed.symbol === void 0 || feed.symbol === chartSymbol ? void 0 : feed.symbol;
+    const key = feedKey(resolved, feed.interval);
+    if (streams.has(key))
       continue;
-    streams.set(interval, createStreamState({ interval, capacity, symbol: "" }));
+    const symbol = feed.symbol ?? chartSymbol;
+    streams.set(key, createStreamState({ interval: feed.interval, capacity, symbol }));
   }
   return streams;
 }
@@ -15734,8 +16426,9 @@ function primaryOf(compiled) {
 }
 function buildPrimaryState(args, primary) {
   const capacity = resolveCapacity(primary.manifest);
+  const chartSymbol = args.symInfo?.ticker ?? "";
   const mainStream = createStreamState({ interval: "", capacity, symbol: "" });
-  const secondaryStreams = createSecondaryStreams(primary.manifest, capacity);
+  const secondaryStreams = createSecondaryStreams(primary.manifest, capacity, chartSymbol);
   const stateStore = args.stateStore ?? inMemoryStateStore();
   const now = args.now ?? Date.now;
   const views = createRuntimeViews({
@@ -15781,12 +16474,15 @@ function buildPrimaryState(args, primary) {
       scriptMaxDrawings: primary.manifest.maxDrawings ?? null,
       stateSlots: /* @__PURE__ */ new Map(),
       seriesSlots: /* @__PURE__ */ new Map(),
+      arraySlots: /* @__PURE__ */ new Map(),
+      chartSymbol,
       secondaryStreams,
       requestSecurityBars: /* @__PURE__ */ new Map(),
       requestSecurityAlignments: /* @__PURE__ */ new Map(),
       requestSecurityAscendingBars: /* @__PURE__ */ new Map(),
       requestLowerTfViews: /* @__PURE__ */ new Map(),
       diagnosedRequestKeys: /* @__PURE__ */ new Set(),
+      diagnosedTzKeys: /* @__PURE__ */ new Set(),
       alertConditions,
       diagnosedAlertConditionKeys: /* @__PURE__ */ new Set(),
       logBudget: 0,
@@ -15810,7 +16506,7 @@ function buildPrimaryState(args, primary) {
   state2.runtimeContext.plotOverrides = args.plotOverrides ?? args.resolvePlotOverrides?.(primary.manifest.name) ?? Object.freeze({});
   const exprRunners = buildSecurityExprRunners(primary.manifest, state2.runtimeContext, capacity);
   state2.runtimeContext.securityExprRunners = exprRunners.bySlot;
-  state2.runtimeContext.securityExprRunnersByInterval = exprRunners.byInterval;
+  state2.runtimeContext.securityExprRunnersByFeed = exprRunners.byFeed;
   state2.runtimeContext.requestSecurityExprSeries = /* @__PURE__ */ new Map();
   return state2;
 }
@@ -15832,10 +16528,12 @@ function attachBundle(primary, bundle, capabilities2, now) {
     }))
   ];
   const store = createDepOutputStore({ producers, capacity: storeCapacity });
+  const { chartSymbol } = primary.runtimeContext;
   const depRunners = bundle.dependencies.map((entry) => createDepRunner({
     compiled: entry.compiled,
     localId: entry.localId,
     parentCapabilities: capabilities2,
+    chartSymbol,
     mainStream: primary.mainStream,
     secondaryStreams: primary.runtimeContext.secondaryStreams,
     depOutputStore: store,
@@ -15846,6 +16544,7 @@ function attachBundle(primary, bundle, capabilities2, now) {
     compiled: entry.compiled,
     exportName: entry.exportName,
     parentCapabilities: capabilities2,
+    chartSymbol,
     mainStream: primary.mainStream,
     secondaryStreams: primary.runtimeContext.secondaryStreams,
     depOutputStore: store,
@@ -16059,15 +16758,15 @@ function isCompiledScriptObject(v) {
   const o = v;
   return typeof o.compute === "function" && typeof o.manifest === "object" && o.manifest !== null;
 }
-function buildBundleFromModule(mod) {
-  const manifest = mod.__manifest;
-  const dependencies = mod.__dependencies ?? [];
+function buildBundleFromModule(mod2) {
+  const manifest = mod2.__manifest;
+  const dependencies = mod2.__dependencies ?? [];
   const isBundle = Array.isArray(manifest) || dependencies.length > 0;
   if (!isBundle) {
     if (isSingleManifest(manifest)) {
-      return Object.freeze({ ...mod.default, manifest });
+      return Object.freeze({ ...mod2.default, manifest });
     }
-    return mod.default;
+    return mod2.default;
   }
   const siblings = [];
   if (Array.isArray(manifest)) {
@@ -16075,7 +16774,7 @@ function buildBundleFromModule(mod) {
       const entry = manifest[i];
       const exportName = entry.exportName;
       if (exportName === void 0 || exportName === "default") continue;
-      const compiled = mod[exportName];
+      const compiled = mod2[exportName];
       if (!isCompiledScriptObject(compiled)) continue;
       siblings.push(Object.freeze({ exportName, compiled }));
     }
@@ -16088,7 +16787,7 @@ function buildBundleFromModule(mod) {
     })
   );
   return Object.freeze({
-    primary: mod.default,
+    primary: mod2.default,
     siblings: Object.freeze(siblings),
     dependencies: Object.freeze(frozenDeps)
   });
@@ -16107,8 +16806,8 @@ function createWorkerBoot(scope) {
     }
     if (msg.kind === "load") {
       try {
-        const mod = await importCompiledModule(msg.compiled.moduleSource);
-        const compiled = buildBundleFromModule(mod);
+        const mod2 = await importCompiledModule(msg.compiled.moduleSource);
+        const compiled = buildBundleFromModule(mod2);
         runner = createScriptRunner({
           compiled,
           capabilities: msg.capabilities,