@orangecharts/wrun-chart-host 0.4.0 → 0.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +17 -5
- package/dist/constants/exchange-names.leaf.d.ts +8 -0
- package/dist/constants/exchange-names.leaf.js +101 -0
- package/dist/constants/feature-flags.constants.js +7 -2
- package/dist/constants/kscript-data-interval-restrictions.constants.d.ts +15 -0
- package/dist/constants/kscript-data-interval-restrictions.constants.js +40 -0
- package/dist/constants/opra-compliance.constants.d.ts +19 -0
- package/dist/constants/opra-compliance.constants.js +19 -0
- package/dist/constants/replay-ladder.leaf.d.ts +30 -0
- package/dist/constants/replay-ladder.leaf.js +99 -0
- package/dist/constants/scriptEditor/cme-official-scripts.constants.d.ts +168 -0
- package/dist/constants/scriptEditor/cme-official-scripts.constants.js +398 -0
- package/dist/constants/scriptEditor/converted-script-id.leaf.d.ts +8 -0
- package/dist/constants/scriptEditor/converted-script-id.leaf.js +10 -0
- package/dist/constants/scriptEditor/execution.constants.d.ts +4 -0
- package/dist/constants/scriptEditor/execution.constants.js +14 -0
- package/dist/constants/wrun-prefix-safe.constants.d.ts +23 -0
- package/dist/constants/wrun-prefix-safe.constants.js +26 -0
- package/dist/host-env.d.ts +301 -22
- package/dist/host-env.js +15 -0
- package/dist/host-ports.types.d.ts +853 -29
- package/dist/index.d.ts +140 -2
- package/dist/index.js +140 -2
- package/dist/instances/script-engine-worker-ohlcv-transfer.d.ts +31 -0
- package/dist/instances/script-engine-worker-ohlcv-transfer.js +164 -0
- package/dist/interfaces/market-event.interface.d.ts +231 -0
- package/dist/interfaces/market-event.interface.js +15 -0
- package/dist/interfaces/opra-realtime.interface.d.ts +70 -134
- package/dist/interfaces/opra-realtime.interface.js +34 -59
- package/dist/interfaces/replay.interface.d.ts +285 -0
- package/dist/interfaces/replay.interface.js +1 -0
- package/dist/interfaces/wrun-runtime.interface.d.ts +88 -13
- package/dist/interfaces/wrun-runtime.interface.js +17 -3
- package/dist/kscript-data/controls/live-ohlcv-merge.util.d.ts +1 -0
- package/dist/kscript-data/controls/live-ohlcv-merge.util.js +93 -0
- package/dist/kscript-data/controls/live-trades-merge.util.d.ts +5 -1
- package/dist/kscript-data/controls/live-trades-merge.util.js +2 -2
- package/dist/market-data/billing.interface.d.ts +219 -0
- package/dist/market-data/billing.interface.js +58 -0
- package/dist/market-data/venue-governed.util.d.ts +2 -0
- package/dist/market-data/venue-governed.util.js +10 -0
- package/dist/market-data/venue.d.ts +122 -0
- package/dist/market-data/venue.js +1 -0
- package/dist/market-data/venues/index.d.ts +97 -0
- package/dist/market-data/venues/index.js +33 -0
- package/dist/market-data/venues/opra.contract.copy.json +35 -0
- package/dist/market-data/venues/opra.d.ts +70 -0
- package/dist/market-data/venues/opra.js +74 -0
- package/dist/replay/replayIndicatorRows.d.ts +31 -0
- package/dist/replay/replayIndicatorRows.js +117 -0
- package/dist/replay/replayLadder.d.ts +85 -0
- package/dist/replay/replayLadder.js +388 -0
- package/dist/utility/auth/server-clock.util.d.ts +81 -0
- package/dist/utility/auth/server-clock.util.js +238 -0
- package/dist/utility/chart/builtin-identity.util.d.ts +18 -0
- package/dist/utility/chart/builtin-identity.util.js +51 -0
- package/dist/utility/chart/cache-alignment.util.d.ts +454 -0
- package/dist/utility/chart/cache-alignment.util.js +926 -0
- package/dist/utility/chart/chart-data-fetch-generation.util.d.ts +15 -0
- package/dist/utility/chart/chart-data-fetch-generation.util.js +22 -0
- package/dist/utility/chart/chart-mount-epoch.util.d.ts +17 -0
- package/dist/utility/chart/chart-mount-epoch.util.js +61 -0
- package/dist/utility/chart/chart-time-domain.util.d.ts +12 -0
- package/dist/utility/chart/chart-time-domain.util.js +23 -0
- package/dist/utility/chart/color-customization.leaf.d.ts +10 -0
- package/dist/utility/chart/color-customization.leaf.js +16 -0
- package/dist/utility/chart/footprint-tick-grid.util.d.ts +106 -0
- package/dist/utility/chart/footprint-tick-grid.util.js +167 -0
- package/dist/utility/chart/gesture-timing.leaf.d.ts +29 -0
- package/dist/utility/chart/gesture-timing.leaf.js +29 -0
- package/dist/utility/chart/governed-contract-coin.util.d.ts +22 -0
- package/dist/utility/chart/governed-contract-coin.util.js +39 -0
- package/dist/utility/chart/host-bar-placement.util.d.ts +107 -0
- package/dist/utility/chart/host-bar-placement.util.js +447 -0
- package/dist/utility/chart/index-host-tier.util.d.ts +31 -0
- package/dist/utility/chart/index-host-tier.util.js +118 -0
- package/dist/utility/chart/index-mode-admission.util.d.ts +34 -0
- package/dist/utility/chart/index-mode-admission.util.js +67 -0
- package/dist/utility/chart/indicator-error-message.util.d.ts +35 -0
- package/dist/utility/chart/indicator-error-message.util.js +44 -0
- package/dist/utility/chart/kscript-apply-fingerprint.util.d.ts +65 -0
- package/dist/utility/chart/kscript-apply-fingerprint.util.js +357 -0
- package/dist/utility/chart/kscript-chart-flush.leaf.d.ts +22 -0
- package/dist/utility/chart/kscript-chart-flush.leaf.js +13 -0
- package/dist/utility/chart/kscript-data-interval-restriction.leaf.d.ts +6 -0
- package/dist/utility/chart/kscript-data-interval-restriction.leaf.js +27 -0
- package/dist/utility/chart/kscript-integration-decision.leaf.d.ts +89 -0
- package/dist/utility/chart/kscript-integration-decision.leaf.js +80 -0
- package/dist/utility/chart/kscript-live-coalesce.util.d.ts +76 -0
- package/dist/utility/chart/kscript-live-coalesce.util.js +156 -0
- package/dist/utility/chart/kscript-live-rest-pace.util.d.ts +34 -0
- package/dist/utility/chart/kscript-live-rest-pace.util.js +134 -0
- package/dist/utility/chart/kscript-live-source-identity.util.d.ts +98 -0
- package/dist/utility/chart/kscript-live-source-identity.util.js +121 -0
- package/dist/utility/chart/kscript-mounted-plot-set.leaf.d.ts +48 -0
- package/dist/utility/chart/kscript-mounted-plot-set.leaf.js +145 -0
- package/dist/utility/chart/kscript-perf-tracker.util.d.ts +243 -0
- package/dist/utility/chart/kscript-perf-tracker.util.js +522 -0
- package/dist/utility/chart/kscript-run-interval-projection.util.d.ts +43 -0
- package/dist/utility/chart/kscript-run-interval-projection.util.js +471 -0
- package/dist/utility/chart/kscript-run-result-equality.util.d.ts +38 -0
- package/dist/utility/chart/kscript-run-result-equality.util.js +89 -0
- package/dist/utility/chart/kscript-settings-revision.leaf.d.ts +2 -0
- package/dist/utility/chart/kscript-settings-revision.leaf.js +12 -0
- package/dist/utility/chart/kscript-source-degrade.leaf.d.ts +63 -0
- package/dist/utility/chart/kscript-source-degrade.leaf.js +68 -0
- package/dist/utility/chart/kscript-source-retention.util.d.ts +134 -0
- package/dist/utility/chart/kscript-source-retention.util.js +218 -0
- package/dist/utility/chart/kscript-standin-identity.leaf.d.ts +57 -0
- package/dist/utility/chart/kscript-standin-identity.leaf.js +61 -0
- package/dist/utility/chart/kscript-titancharts-preparation.util.d.ts +15 -0
- package/dist/utility/chart/kscript-titancharts-preparation.util.js +376 -0
- package/dist/utility/chart/kscript-titancharts-render-keys.constants.d.ts +9 -0
- package/dist/utility/chart/kscript-titancharts-render-keys.constants.js +130 -0
- package/dist/utility/chart/kscript-venue-policy.util.d.ts +217 -0
- package/dist/utility/chart/kscript-venue-policy.util.js +324 -0
- package/dist/utility/chart/live-cadence.util.d.ts +38 -0
- package/dist/utility/chart/live-cadence.util.js +37 -0
- package/dist/utility/chart/live-feed-series-match.leaf.d.ts +13 -0
- package/dist/utility/chart/live-feed-series-match.leaf.js +21 -0
- package/dist/utility/chart/local-engine-self-heal-backoff.util.d.ts +46 -0
- package/dist/utility/chart/local-engine-self-heal-backoff.util.js +46 -0
- package/dist/utility/chart/local-engine-uninit.leaf.d.ts +21 -0
- package/dist/utility/chart/local-engine-uninit.leaf.js +22 -0
- package/dist/utility/chart/local-kscript-source-revalidation.util.d.ts +62 -0
- package/dist/utility/chart/local-kscript-source-revalidation.util.js +123 -0
- package/dist/utility/chart/local-kscript-warmup-depth.util.d.ts +214 -0
- package/dist/utility/chart/local-kscript-warmup-depth.util.js +376 -0
- package/dist/utility/chart/local-technical-script-live-apply-coalescer.util.d.ts +85 -0
- package/dist/utility/chart/local-technical-script-live-apply-coalescer.util.js +197 -0
- package/dist/utility/chart/local-technical-script-range.leaf.d.ts +72 -0
- package/dist/utility/chart/local-technical-script-range.leaf.js +126 -0
- package/dist/utility/chart/mixed-mode.util.d.ts +167 -0
- package/dist/utility/chart/mixed-mode.util.js +139 -0
- package/dist/utility/chart/ohlcv-row-readiness.util.d.ts +36 -0
- package/dist/utility/chart/ohlcv-row-readiness.util.js +90 -0
- package/dist/utility/chart/opra-user-scripts-gate.util.d.ts +19 -0
- package/dist/utility/chart/opra-user-scripts-gate.util.js +32 -0
- package/dist/utility/chart/overlay-execution-guard-key.leaf.d.ts +8 -0
- package/dist/utility/chart/overlay-execution-guard-key.leaf.js +10 -0
- package/dist/utility/chart/price-precision.util.d.ts +40 -0
- package/dist/utility/chart/price-precision.util.js +70 -0
- package/dist/utility/chart/profile-block-size.util.d.ts +64 -0
- package/dist/utility/chart/profile-block-size.util.js +141 -0
- package/dist/utility/chart/protected-kscript-degenerate-rows.leaf.d.ts +11 -0
- package/dist/utility/chart/protected-kscript-degenerate-rows.leaf.js +29 -0
- package/dist/utility/chart/protected-kscript-empty-output.util.d.ts +28 -0
- package/dist/utility/chart/protected-kscript-empty-output.util.js +84 -0
- package/dist/utility/chart/run-interval-unservable.leaf.d.ts +9 -0
- package/dist/utility/chart/run-interval-unservable.leaf.js +20 -0
- package/dist/utility/chart/run-interval-warmup.leaf.d.ts +19 -0
- package/dist/utility/chart/run-interval-warmup.leaf.js +35 -0
- package/dist/utility/chart/titan-constants.pin.d.ts +9 -5
- package/dist/utility/chart/titan-constants.pin.js +18 -5
- package/dist/utility/chart/warmup-backfill-retry.leaf.d.ts +9 -0
- package/dist/utility/chart/warmup-backfill-retry.leaf.js +9 -0
- package/dist/utility/chart/wrun-bar-session-facts.util.d.ts +11 -2
- package/dist/utility/chart/wrun-bar-session-facts.util.js +10 -3
- package/dist/utility/chart/wrun-run-result.util.d.ts +5 -1
- package/dist/utility/chart/wrun-run-result.util.js +20 -14
- package/dist/utility/common/data-processing.util.d.ts +138 -0
- package/dist/utility/common/data-processing.util.js +346 -0
- package/dist/utility/common/visible-timeout.util.d.ts +13 -4
- package/dist/utility/common/visible-timeout.util.js +23 -8
- package/dist/utility/exchange-format.leaf.d.ts +1 -0
- package/dist/utility/exchange-format.leaf.js +47 -0
- package/dist/utility/market-events/earnings-scope.util.d.ts +60 -0
- package/dist/utility/market-events/earnings-scope.util.js +92 -0
- package/dist/utility/market-events/market-events.util.d.ts +147 -0
- package/dist/utility/market-events/market-events.util.js +392 -0
- package/dist/utility/market-events/zoned-clock.util.d.ts +1 -0
- package/dist/utility/market-events/zoned-clock.util.js +11 -0
- package/dist/utility/options/option-venue-disclosure.util.d.ts +43 -0
- package/dist/utility/options/option-venue-disclosure.util.js +56 -0
- package/dist/utility/scriptEditor/package-semver.util.d.ts +51 -0
- package/dist/utility/scriptEditor/package-semver.util.js +120 -0
- package/dist/utility/scriptEditor/temp-script-id.util.d.ts +18 -0
- package/dist/utility/scriptEditor/temp-script-id.util.js +25 -0
- package/dist/utility/symbol-selection/markets-request-from-symbols.leaf.d.ts +20 -0
- package/dist/utility/symbol-selection/markets-request-from-symbols.leaf.js +81 -0
- package/dist/utility/v2/governed-tier.leaf.d.ts +103 -0
- package/dist/utility/v2/governed-tier.leaf.js +113 -0
- package/dist/utility/watchlist/import/import-request.leaf.d.ts +10 -0
- package/dist/utility/watchlist/import/import-request.leaf.js +10 -0
- package/dist/utility/wrun/sources/lanes/series.js +2 -2
- package/dist/utility/wrun/sources/row-lanes/option_contract_state.d.ts +4 -4
- package/dist/utility/wrun/sources/row-lanes/option_contract_state.js +5 -6
- package/dist/utility/wrun/wrun-alert-outputs.registry.d.ts +166 -0
- package/dist/utility/wrun/wrun-alert-outputs.registry.js +219 -0
- package/dist/utility/wrun/wrun-bar-count.util.d.ts +94 -0
- package/dist/utility/wrun/wrun-bar-count.util.js +274 -0
- package/dist/utility/wrun/wrun-chart-context-names.util.d.ts +84 -0
- package/dist/utility/wrun/wrun-chart-context-names.util.js +186 -0
- package/dist/utility/wrun/wrun-chart-market-facts.util.d.ts +253 -0
- package/dist/utility/wrun/wrun-chart-market-facts.util.js +731 -0
- package/dist/utility/wrun/wrun-cloud-opra-stamp.util.d.ts +28 -0
- package/dist/utility/wrun/wrun-cloud-opra-stamp.util.js +45 -0
- package/dist/utility/wrun/wrun-coin-lane-live.util.d.ts +18 -0
- package/dist/utility/wrun/wrun-coin-lane-live.util.js +47 -0
- package/dist/utility/wrun/wrun-deadline.util.js +2 -1
- package/dist/utility/wrun/wrun-debug-output.util.d.ts +39 -0
- package/dist/utility/wrun/wrun-debug-output.util.js +63 -0
- package/dist/utility/wrun/wrun-declared-warmup.util.d.ts +113 -0
- package/dist/utility/wrun/wrun-declared-warmup.util.js +181 -0
- package/dist/utility/wrun/wrun-draft-legend-note.util.d.ts +43 -0
- package/dist/utility/wrun/wrun-draft-legend-note.util.js +158 -0
- package/dist/utility/wrun/wrun-draft-overlay.util.d.ts +181 -0
- package/dist/utility/wrun/wrun-draft-overlay.util.js +357 -0
- package/dist/utility/wrun/wrun-draw-skipped.leaf.d.ts +16 -0
- package/dist/utility/wrun/wrun-draw-skipped.leaf.js +16 -0
- package/dist/utility/wrun/wrun-earnings-facts.util.d.ts +42 -0
- package/dist/utility/wrun/wrun-earnings-facts.util.js +131 -0
- package/dist/utility/wrun/wrun-first-run-depth.util.d.ts +32 -0
- package/dist/utility/wrun/wrun-first-run-depth.util.js +118 -0
- package/dist/utility/wrun/wrun-gate-plane-readers.util.d.ts +24 -0
- package/dist/utility/wrun/wrun-gate-plane-readers.util.js +31 -0
- package/dist/utility/wrun/wrun-held-lanes.util.d.ts +32 -0
- package/dist/utility/wrun/wrun-held-lanes.util.js +94 -0
- package/dist/utility/wrun/wrun-host-visible-clock.util.d.ts +2 -0
- package/dist/utility/wrun/wrun-host-visible-clock.util.js +17 -0
- package/dist/utility/wrun/wrun-host.service.d.ts +330 -0
- package/dist/utility/wrun/wrun-host.service.js +855 -0
- package/dist/utility/wrun/wrun-hover.util.d.ts +3 -0
- package/dist/utility/wrun/wrun-hover.util.js +25 -4
- package/dist/utility/wrun/wrun-inert-legend.util.d.ts +33 -0
- package/dist/utility/wrun/wrun-inert-legend.util.js +125 -0
- package/dist/utility/wrun/wrun-input-requirements.leaf.d.ts +155 -0
- package/dist/utility/wrun/wrun-input-requirements.leaf.js +450 -0
- package/dist/utility/wrun/wrun-integration-route.util.d.ts +51 -0
- package/dist/utility/wrun/wrun-integration-route.util.js +59 -0
- package/dist/utility/wrun/wrun-latest-history.leaf.d.ts +8 -0
- package/dist/utility/wrun/wrun-latest-history.leaf.js +8 -0
- package/dist/utility/wrun/wrun-legend-hover.lazy.d.ts +12 -0
- package/dist/utility/wrun/wrun-legend-hover.lazy.js +96 -0
- package/dist/utility/wrun/wrun-lifecycle-runtime.util.d.ts +21 -0
- package/dist/utility/wrun/wrun-lifecycle-runtime.util.js +21 -0
- package/dist/utility/wrun/wrun-live-hidden-hold.util.d.ts +23 -0
- package/dist/utility/wrun/wrun-live-hidden-hold.util.js +13 -0
- package/dist/utility/wrun/wrun-live-intake.util.d.ts +374 -0
- package/dist/utility/wrun/wrun-live-intake.util.js +2027 -0
- package/dist/utility/wrun/wrun-live-patch.util.d.ts +116 -0
- package/dist/utility/wrun/wrun-live-patch.util.js +523 -0
- package/dist/utility/wrun/wrun-live-tick.util.d.ts +619 -0
- package/dist/utility/wrun/wrun-live-tick.util.js +4974 -0
- package/dist/utility/wrun/wrun-loading-owner.util.d.ts +58 -0
- package/dist/utility/wrun/wrun-loading-owner.util.js +89 -0
- package/dist/utility/wrun/wrun-official-scope.leaf.d.ts +29 -0
- package/dist/utility/wrun/wrun-official-scope.leaf.js +36 -0
- package/dist/utility/wrun/wrun-oi-lane.util.d.ts +27 -0
- package/dist/utility/wrun/wrun-oi-lane.util.js +42 -0
- package/dist/utility/wrun/wrun-options-stop.util.d.ts +52 -0
- package/dist/utility/wrun/wrun-options-stop.util.js +123 -0
- package/dist/utility/wrun/wrun-overlay-drivers.util.d.ts +719 -0
- package/dist/utility/wrun/wrun-overlay-drivers.util.js +1180 -0
- package/dist/utility/wrun/wrun-overlay-lifecycle.lazy.d.ts +50 -0
- package/dist/utility/wrun/wrun-overlay-lifecycle.lazy.js +131 -0
- package/dist/utility/wrun/wrun-overlay-lifecycle.util.d.ts +118 -0
- package/dist/utility/wrun/wrun-overlay-lifecycle.util.js +466 -0
- package/dist/utility/wrun/wrun-overlay-metadata.util.d.ts +45 -0
- package/dist/utility/wrun/wrun-overlay-metadata.util.js +112 -0
- package/dist/utility/wrun/wrun-overlay-recovery.util.d.ts +114 -0
- package/dist/utility/wrun/wrun-overlay-recovery.util.js +971 -0
- package/dist/utility/wrun/wrun-overlay-run.util.d.ts +858 -0
- package/dist/utility/wrun/wrun-overlay-run.util.js +11013 -0
- package/dist/utility/wrun/wrun-pack.util.d.ts +2 -1
- package/dist/utility/wrun/wrun-panel-mount.util.d.ts +24 -9
- package/dist/utility/wrun/wrun-panel-mount.util.js +138 -43
- package/dist/utility/wrun/wrun-param-map.util.d.ts +19 -4
- package/dist/utility/wrun/wrun-param-map.util.js +40 -47
- package/dist/utility/wrun/wrun-param-values.util.d.ts +9 -3
- package/dist/utility/wrun/wrun-param-values.util.js +5 -5
- package/dist/utility/wrun/wrun-prefix-cohort.util.d.ts +93 -0
- package/dist/utility/wrun/wrun-prefix-cohort.util.js +484 -0
- package/dist/utility/wrun/wrun-prefix-lanes.util.d.ts +114 -0
- package/dist/utility/wrun/wrun-prefix-lanes.util.js +486 -0
- package/dist/utility/wrun/wrun-prefix-proof.util.d.ts +317 -0
- package/dist/utility/wrun/wrun-prefix-proof.util.js +630 -0
- package/dist/utility/wrun/wrun-refusal-surface.util.d.ts +73 -0
- package/dist/utility/wrun/wrun-refusal-surface.util.js +380 -0
- package/dist/utility/wrun/wrun-refusal-text.util.d.ts +15 -0
- package/dist/utility/wrun/wrun-refusal-text.util.js +40 -0
- package/dist/utility/wrun/wrun-registry-errors.util.d.ts +5 -3
- package/dist/utility/wrun/wrun-replay-lane.util.d.ts +139 -0
- package/dist/utility/wrun/wrun-replay-lane.util.js +520 -0
- package/dist/utility/wrun/wrun-replay-rows.util.d.ts +21 -0
- package/dist/utility/wrun/wrun-replay-rows.util.js +172 -0
- package/dist/utility/wrun/wrun-row-source-factory.d.ts +53 -0
- package/dist/utility/wrun/wrun-row-source-factory.js +435 -0
- package/dist/utility/wrun/wrun-run-cells.util.d.ts +36 -0
- package/dist/utility/wrun/wrun-run-cells.util.js +46 -0
- package/dist/utility/wrun/wrun-run-interval-session.util.d.ts +133 -0
- package/dist/utility/wrun/wrun-run-interval-session.util.js +121 -0
- package/dist/utility/wrun/wrun-run-interval.util.d.ts +98 -0
- package/dist/utility/wrun/wrun-run-interval.util.js +207 -0
- package/dist/utility/wrun/wrun-run-retained.util.d.ts +122 -0
- package/dist/utility/wrun/wrun-run-retained.util.js +255 -0
- package/dist/utility/wrun/wrun-sandbox-row-source.d.ts +184 -0
- package/dist/utility/wrun/wrun-sandbox-row-source.js +444 -0
- package/dist/utility/wrun/wrun-script-inputs.util.js +4 -4
- package/dist/utility/wrun/wrun-series-stream.util.d.ts +86 -0
- package/dist/utility/wrun/wrun-series-stream.util.js +537 -0
- package/dist/utility/wrun/wrun-sha256.leaf.d.ts +13 -0
- package/dist/utility/wrun/wrun-sha256.leaf.js +84 -0
- package/dist/utility/wrun/wrun-sheet-remembered.util.d.ts +21 -0
- package/dist/utility/wrun/wrun-sheet-remembered.util.js +36 -0
- package/dist/utility/wrun/wrun-signal-sound-reasons.leaf.d.ts +7 -0
- package/dist/utility/wrun/wrun-signal-sound-reasons.leaf.js +12 -0
- package/dist/utility/wrun/wrun-socket-row-source.js +4 -2
- package/dist/utility/wrun/wrun-source-rows.util.d.ts +175 -3
- package/dist/utility/wrun/wrun-source-rows.util.js +294 -8
- package/dist/utility/wrun/wrun-stats-strip.util.d.ts +46 -0
- package/dist/utility/wrun/wrun-stats-strip.util.js +87 -0
- package/dist/utility/wrun/wrun-table-chrome.util.d.ts +163 -0
- package/dist/utility/wrun/wrun-table-chrome.util.js +557 -0
- package/dist/utility/wrun/wrun-text-params.util.d.ts +11 -6
- package/dist/utility/wrun/wrun-text-params.util.js +19 -30
- package/dist/utility/wrun/wrun-transient-rerun.util.d.ts +64 -0
- package/dist/utility/wrun/wrun-transient-rerun.util.js +317 -0
- package/dist/utility/wrun/wrun-twin-lookback.util.d.ts +10 -0
- package/dist/utility/wrun/wrun-twin-lookback.util.js +43 -0
- package/dist/utility/wrun/wrun-warmup-head-store.util.d.ts +41 -0
- package/dist/utility/wrun/wrun-warmup-head-store.util.js +120 -0
- package/dist/utility/wrun-alert-params.leaf.d.ts +24 -0
- package/dist/utility/wrun-alert-params.leaf.js +24 -0
- package/dist/utils/replay/replay-buffer-math.d.ts +148 -0
- package/dist/utils/replay/replay-buffer-math.js +684 -0
- package/dist/workers/wrun/wrun-abi-host.d.ts +203 -0
- package/dist/workers/wrun/wrun-abi-host.js +1220 -0
- package/dist/workers/wrun/wrun-engine-handler.d.ts +20 -0
- package/dist/workers/wrun/wrun-engine-handler.js +380 -0
- package/package.json +3 -3
|
@@ -0,0 +1,537 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* A registry poll lane's LIVE channel on a browser wrun session (LIVE-SERIES P3 C10, unit U17), and
|
|
3
|
+
* the `series` lane's channel: the relay feed stream (`src/services/feed-stream.service.ts`).
|
|
4
|
+
*
|
|
5
|
+
* The contract of `WrunPollLane.live` (its types sit tersely in `wrun-poll-lane.types.ts`, which
|
|
6
|
+
* rides the boot path): `subscribe(ask, sink)` answers a handle at once, importing its transport
|
|
7
|
+
* inside. The ask names the instance's recorded extras (`extras`, as `plan` answered them), the
|
|
8
|
+
* session's grid (`intervalMs`) and the newest bucket its buffer holds (`newestTs`, ms, or null): a
|
|
9
|
+
* channel that can replay what it stored replays what came after it. The sink takes lane rows
|
|
10
|
+
* (`rows`: `[bucket_ts_ms, ...columns]` on the grid's bar opens, the shape the lane's fetch
|
|
11
|
+
* answers, each a level, the newest the channel read for its bucket), reopens (`reopened`: the
|
|
12
|
+
* channel came back after a drop or a wake, what it missed is the reconcile's), spans it cannot
|
|
13
|
+
* stand for (`stale(fromTs)`: rows it may have skipped from that bucket on, owed to a read) and
|
|
14
|
+
* declaration changes (`replan`: the source changed what the plan judged; the channel stops
|
|
15
|
+
* before folding anything more and the session plans the lane again). The handle's
|
|
16
|
+
* `isUp()` answers true while the channel carries the instance; `unsubscribe()` is idempotent. A
|
|
17
|
+
* channel refuses nothing (a declaration is judged in `plan`): an instance it cannot carry answers
|
|
18
|
+
* a handle that is never up.
|
|
19
|
+
*
|
|
20
|
+
* The session side, for any lane naming `live`:
|
|
21
|
+
* - `openWrunPollLaneLiveChannels(context)`, at every install the run pass makes (beside the
|
|
22
|
+
* session-start reconcile): one channel per planned instance whose lane has `live`, opened with
|
|
23
|
+
* the instance's recorded extras, the session's grid and the newest bucket its buffer holds. The
|
|
24
|
+
* replaced session's channel of the same instance on the same grid carries over with the rows it
|
|
25
|
+
* queued (a settings save or a rerun never reopens the stream, whose re-dial would reconcile
|
|
26
|
+
* every feed it carries), unless its source's declaration changed; its other channels close. A
|
|
27
|
+
* replay session opens none; a reseed keeps the session, so its channels.
|
|
28
|
+
* - The poll-lane intake: a channel's rows (levels on the grid's bar opens) queue on the session,
|
|
29
|
+
* the newest per bucket, and request the live tick's drain (`setWrunPollLaneLiveDrainRequester`,
|
|
30
|
+
* registered by the tick, which this module never imports). The drain folds them beside the push
|
|
31
|
+
* intake's (`drainWrunPollLaneLiveRows`): a held bucket's row replaced, a new bucket inserted in
|
|
32
|
+
* order, never a second row for one bucket, no fed mark (the rows are the series as its source
|
|
33
|
+
* stored it, nothing for a reconcile to confirm), a committed bar they revise owing the late
|
|
34
|
+
* reseed (`dirtyFromTs`); then the tick computes the forming bar without a fetch. The queue
|
|
35
|
+
* follows the session: a reseed keeps it, a rerun keeps a carried channel's (a level folds to
|
|
36
|
+
* nothing over a fresh fetch that holds it) and drops the others'. It lives here, off the boot
|
|
37
|
+
* path, where the push intake does not.
|
|
38
|
+
* - A reopen marks `wake` (deduped while one is pending), so the next drain's reconcile asks the
|
|
39
|
+
* lane's own fetch for what the channel missed. A stale span rolls the lane's coverage back to
|
|
40
|
+
* its start (the reconcile window reaches it, a failed ask's obligation) and marks `poll-due`:
|
|
41
|
+
* the lane owes a read (`wrunPollLaneLiveOwed`), which the routine poll asks whatever the channel
|
|
42
|
+
* says, until a reconcile answers past it. A re-plan marks `wake` and hands the overlay to its
|
|
43
|
+
* full-run driver (`rerunWrunOverlayForChartWave`, at most once a minute per overlay, so a stream
|
|
44
|
+
* ahead of the plan's read never loops reruns); the replanned channel is never carried over.
|
|
45
|
+
* Nothing reaches a session while its chart replays (the poll's rule), nothing reaches it from a
|
|
46
|
+
* channel it no longer holds, and a session whose context left without its teardown closes its
|
|
47
|
+
* channels at their next event.
|
|
48
|
+
* - `wrunPollLaneLiveUp(context, lane)`: the live tick's routine poll waits while it answers true
|
|
49
|
+
* (`wrunPollLaneRecheckDue`); a channel that is down leaves the poll the lane's path, and a lane
|
|
50
|
+
* whose coverage is behind (a failed answer) is asked whatever the channel says.
|
|
51
|
+
* - The drivers' teardown hook closes the session's channels and drops its queue (a teardown and a
|
|
52
|
+
* suspend alike: Resume reruns the overlay, which opens them again), registered with the first
|
|
53
|
+
* channel that opens: importing this module registers nothing.
|
|
54
|
+
*
|
|
55
|
+
* The series channel (`openWrunSeriesStream`, loaded by the lane's `live.subscribe` with its first
|
|
56
|
+
* session): one stream subscription per instance, `sinceTs` the newest bucket its buffer holds (the
|
|
57
|
+
* relay replays the stored readings after it before `up`). A `reading` is the stored row of one
|
|
58
|
+
* slot as the relay holds it, a level, never an increment: its value is the lane's key, the feed's
|
|
59
|
+
* first value key (the relay's default for a bars read), position 0 of the reading's values (the
|
|
60
|
+
* head's `values` order), landed on the chart bar holding its stamp (`wrunLiveBucketTs`: the UTC
|
|
61
|
+
* floor, a week on its Monday, the relay's own buckets) as `[bucket_ts_ms, value]`, the shape the
|
|
62
|
+
* lane's fetch answers. Newest per bucket: a reading older than one the channel already handed for
|
|
63
|
+
* its bucket is skipped (a bucket's value is its newest slot's). A state or null cell is no reading
|
|
64
|
+
* (the fetch's rule). A feed combining by any rule but `last` is not carried (one slot's level is
|
|
65
|
+
* not its bucket's combined value): its channel is never up and the poll stays its path, as with
|
|
66
|
+
* the stream switched off. `up { reopened: true }` once the channel was up is a reopen; a `head` is
|
|
67
|
+
* held against the declaration the session planned (`openWrunSeriesStream`); `down` and `gone`
|
|
68
|
+
* answer through `isUp()`.
|
|
69
|
+
*/
|
|
70
|
+
import { wrunChartHostEnv } from '../../host-env.js';
|
|
71
|
+
import { WRUN_SERIES_LANE_KEY, wrunSeriesFeedAddress, wrunSeriesPlannedHead } from './sources/lanes/series.js';
|
|
72
|
+
import { wrunPollLaneByKey } from './sources/registry.js';
|
|
73
|
+
import { markWrunLiveGap, noteWrunLiveIntakeEvent, wrunLiveBucketTs } from './wrun-live-intake.util.js';
|
|
74
|
+
import { getWrunOverlayLiveContext, onWrunOverlayLiveTeardown, rerunWrunOverlayForChartWave, } from './wrun-overlay-drivers.util.js';
|
|
75
|
+
/** A channel that never carries its instance (a feed the stream does not carry, a channel that failed
|
|
76
|
+
* to open): the poll stays the lane's path. */
|
|
77
|
+
const WRUN_POLL_LANE_LIVE_NEVER_UP = Object.freeze({
|
|
78
|
+
unsubscribe: () => undefined,
|
|
79
|
+
isUp: () => false,
|
|
80
|
+
});
|
|
81
|
+
/** A declaration change re-plans an overlay at most this often (a stream head ahead of the plan's
|
|
82
|
+
* read must never loop reruns): within it, the change drops the channel and reconciles only. */
|
|
83
|
+
export const WRUN_POLL_LANE_REPLAN_MIN_MS = 60_000;
|
|
84
|
+
const replannedAtMs = new Map();
|
|
85
|
+
/** The open channels per overlay, held by the session (the live context) they feed. */
|
|
86
|
+
const liveSessions = new Map();
|
|
87
|
+
let drainRequester = null;
|
|
88
|
+
/** The live tick registers its drain scheduler here at import, so a channel's rows wake the drain
|
|
89
|
+
* (this module never imports the tick). */
|
|
90
|
+
export function setWrunPollLaneLiveDrainRequester(fn) {
|
|
91
|
+
drainRequester = fn;
|
|
92
|
+
}
|
|
93
|
+
function closeChannels(indicatorId, channels) {
|
|
94
|
+
for (const channel of channels) {
|
|
95
|
+
try {
|
|
96
|
+
channel.subscription.unsubscribe();
|
|
97
|
+
}
|
|
98
|
+
catch (error) {
|
|
99
|
+
console.warn(`[wrun] live channel of '${channel.lane}' failed to close for '${indicatorId}':`, error);
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
/** Close every live channel the overlay holds (the teardown hook's; idempotent). */
|
|
104
|
+
export function closeWrunPollLaneLiveChannels(indicatorId) {
|
|
105
|
+
replannedAtMs.delete(indicatorId);
|
|
106
|
+
const session = liveSessions.get(indicatorId);
|
|
107
|
+
if (session === undefined)
|
|
108
|
+
return;
|
|
109
|
+
liveSessions.delete(indicatorId);
|
|
110
|
+
closeChannels(indicatorId, session.channels.values());
|
|
111
|
+
session.channels.clear();
|
|
112
|
+
session.queued.clear();
|
|
113
|
+
session.owed.clear();
|
|
114
|
+
}
|
|
115
|
+
/** The overlay's live session while it holds `channel`, else undefined. A session that is no
|
|
116
|
+
* longer the overlay's live one (its context left without the teardown hook) closes here. */
|
|
117
|
+
function sessionHolding(indicatorId, channel) {
|
|
118
|
+
const session = liveSessions.get(indicatorId);
|
|
119
|
+
if (session === undefined || session.channels.get(channel.lane) !== channel)
|
|
120
|
+
return undefined;
|
|
121
|
+
if (getWrunOverlayLiveContext(indicatorId) === session.context)
|
|
122
|
+
return session;
|
|
123
|
+
closeWrunPollLaneLiveChannels(indicatorId);
|
|
124
|
+
return undefined;
|
|
125
|
+
}
|
|
126
|
+
function sinkOf(indicatorId, channel) {
|
|
127
|
+
return {
|
|
128
|
+
rows(rows) {
|
|
129
|
+
const session = sessionHolding(indicatorId, channel);
|
|
130
|
+
if (session === undefined)
|
|
131
|
+
return;
|
|
132
|
+
// The poll's rule: a chart that replays takes nothing live (its replay lane owns the session).
|
|
133
|
+
if (wrunChartHostEnv().chart.isReplaying(session.context.chartIndex)) {
|
|
134
|
+
noteWrunLiveIntakeEvent(indicatorId, { kind: 'ignored', verdict: 'ignored:replaying' });
|
|
135
|
+
return;
|
|
136
|
+
}
|
|
137
|
+
const queue = session.queued.get(channel.lane) ?? new Map();
|
|
138
|
+
for (const row of rows)
|
|
139
|
+
queue.set(Number(row[0]), row);
|
|
140
|
+
session.queued.set(channel.lane, queue);
|
|
141
|
+
drainRequester?.(indicatorId);
|
|
142
|
+
},
|
|
143
|
+
reopened() {
|
|
144
|
+
const session = sessionHolding(indicatorId, channel);
|
|
145
|
+
if (session === undefined || wrunChartHostEnv().chart.isReplaying(session.context.chartIndex))
|
|
146
|
+
return;
|
|
147
|
+
markWrunLiveGap(indicatorId, 'wake');
|
|
148
|
+
},
|
|
149
|
+
stale(fromTs) {
|
|
150
|
+
const session = sessionHolding(indicatorId, channel);
|
|
151
|
+
if (session === undefined || !Number.isFinite(fromTs))
|
|
152
|
+
return;
|
|
153
|
+
if (wrunChartHostEnv().chart.isReplaying(session.context.chartIndex))
|
|
154
|
+
return;
|
|
155
|
+
// The lane's coverage rolls back to the span's start, so the reconcile window reaches it (a
|
|
156
|
+
// failed ask's obligation), and the lane owes a read: the routine poll asks it whatever the
|
|
157
|
+
// channel says (`wrunPollLaneLiveOwed`). A lane with no answered window is asked anyway.
|
|
158
|
+
const { coveredThroughTs } = session.context;
|
|
159
|
+
const covered = coveredThroughTs[channel.lane];
|
|
160
|
+
if (typeof covered === 'number' && Number.isFinite(covered)) {
|
|
161
|
+
const watermark = Math.min(covered, fromTs);
|
|
162
|
+
coveredThroughTs[channel.lane] = watermark;
|
|
163
|
+
session.owed.set(channel.lane, Math.min(session.owed.get(channel.lane) ?? watermark, watermark));
|
|
164
|
+
}
|
|
165
|
+
markWrunLiveGap(indicatorId, 'poll-due');
|
|
166
|
+
},
|
|
167
|
+
replan() {
|
|
168
|
+
const session = sessionHolding(indicatorId, channel);
|
|
169
|
+
if (session === undefined)
|
|
170
|
+
return;
|
|
171
|
+
// The channel is the source's old declaration: the next session opens a fresh one.
|
|
172
|
+
channel.replanned = true;
|
|
173
|
+
if (wrunChartHostEnv().chart.isReplaying(session.context.chartIndex))
|
|
174
|
+
return;
|
|
175
|
+
markWrunLiveGap(indicatorId, 'wake');
|
|
176
|
+
const nowMs = Date.now();
|
|
177
|
+
const lastMs = replannedAtMs.get(indicatorId);
|
|
178
|
+
if (lastMs !== undefined && nowMs - lastMs < WRUN_POLL_LANE_REPLAN_MIN_MS)
|
|
179
|
+
return;
|
|
180
|
+
replannedAtMs.set(indicatorId, nowMs);
|
|
181
|
+
void rerunWrunOverlayForChartWave(indicatorId, { reason: 'live-rebuild' })?.catch(() => undefined);
|
|
182
|
+
},
|
|
183
|
+
};
|
|
184
|
+
}
|
|
185
|
+
/** The newest bucket a lane buffer holds, ms, or null. */
|
|
186
|
+
function newestBucketOf(rows) {
|
|
187
|
+
const newest = rows !== undefined && rows.length > 0 ? Number(rows[rows.length - 1][0]) : Number.NaN;
|
|
188
|
+
return Number.isFinite(newest) ? newest : null;
|
|
189
|
+
}
|
|
190
|
+
/**
|
|
191
|
+
* Open the live channels of a session the run pass just installed (`context`, already the
|
|
192
|
+
* overlay's live context): one per planned instance whose lane names `live`. The replaced
|
|
193
|
+
* session's channel of the same instance on the same grid carries over (no reopen: the stream
|
|
194
|
+
* keeps its connection, and the fresh buffers already hold what it delivered); its other channels
|
|
195
|
+
* close. Idempotent for the same context; a replay session, or one planning no such lane, opens
|
|
196
|
+
* none. A channel that fails to open leaves the poll its path.
|
|
197
|
+
*/
|
|
198
|
+
export function openWrunPollLaneLiveChannels(context) {
|
|
199
|
+
const { indicatorId } = context;
|
|
200
|
+
const previous = liveSessions.get(indicatorId);
|
|
201
|
+
if (previous?.context === context)
|
|
202
|
+
return;
|
|
203
|
+
const session = { context, channels: new Map(), queued: new Map(), owed: new Map() };
|
|
204
|
+
liveSessions.set(indicatorId, session);
|
|
205
|
+
if (context.replay !== true) {
|
|
206
|
+
for (const instance of context.pollLanes ?? []) {
|
|
207
|
+
if (session.channels.has(instance.key))
|
|
208
|
+
continue;
|
|
209
|
+
const live = wrunPollLaneByKey(instance.laneKey)?.live;
|
|
210
|
+
if (live === undefined)
|
|
211
|
+
continue;
|
|
212
|
+
const kept = previous?.channels.get(instance.key);
|
|
213
|
+
if (kept !== undefined && kept.intervalMs === context.intervalMs && kept.replanned !== true) {
|
|
214
|
+
previous?.channels.delete(instance.key);
|
|
215
|
+
session.channels.set(instance.key, kept);
|
|
216
|
+
// What it handed since the replaced session's last drain is owed to this one (levels: a
|
|
217
|
+
// row the fresh fetch already holds folds to nothing).
|
|
218
|
+
const queued = previous?.queued.get(instance.key);
|
|
219
|
+
if (queued !== undefined)
|
|
220
|
+
session.queued.set(instance.key, queued);
|
|
221
|
+
continue;
|
|
222
|
+
}
|
|
223
|
+
const channel = {
|
|
224
|
+
lane: instance.key,
|
|
225
|
+
intervalMs: context.intervalMs,
|
|
226
|
+
subscription: WRUN_POLL_LANE_LIVE_NEVER_UP,
|
|
227
|
+
};
|
|
228
|
+
try {
|
|
229
|
+
channel.subscription = live.subscribe({
|
|
230
|
+
extras: context.acquisition[instance.key] ?? instance.extras,
|
|
231
|
+
intervalMs: context.intervalMs,
|
|
232
|
+
newestTs: newestBucketOf(context.pollLaneRows?.[instance.key]),
|
|
233
|
+
}, sinkOf(indicatorId, channel));
|
|
234
|
+
session.channels.set(instance.key, channel);
|
|
235
|
+
}
|
|
236
|
+
catch (error) {
|
|
237
|
+
console.warn(`[wrun] live channel of '${instance.key}' did not open for '${indicatorId}' (the poll stays its path):`, error);
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
}
|
|
241
|
+
if (session.channels.size === 0)
|
|
242
|
+
liveSessions.delete(indicatorId);
|
|
243
|
+
else
|
|
244
|
+
registerWrunPollLaneLiveTeardown();
|
|
245
|
+
if (previous !== undefined) {
|
|
246
|
+
closeChannels(indicatorId, previous.channels.values());
|
|
247
|
+
previous.channels.clear();
|
|
248
|
+
}
|
|
249
|
+
}
|
|
250
|
+
/** Two lane rows the session cannot tell apart: the same cells, NaN equal to NaN. */
|
|
251
|
+
function sameLaneRow(a, b) {
|
|
252
|
+
if (a.length !== b.length)
|
|
253
|
+
return false;
|
|
254
|
+
for (let at = 0; at < a.length; at += 1) {
|
|
255
|
+
if (!Object.is(a[at], b[at]) && a[at] !== b[at])
|
|
256
|
+
return false;
|
|
257
|
+
}
|
|
258
|
+
return true;
|
|
259
|
+
}
|
|
260
|
+
/** The index of the first row whose ts is at or after `ts` (rows ascending). */
|
|
261
|
+
function lowerBound(rows, ts) {
|
|
262
|
+
let low = 0;
|
|
263
|
+
let high = rows.length;
|
|
264
|
+
while (low < high) {
|
|
265
|
+
const mid = (low + high) >>> 1;
|
|
266
|
+
if (Number(rows[mid][0]) < ts)
|
|
267
|
+
low = mid + 1;
|
|
268
|
+
else
|
|
269
|
+
high = mid;
|
|
270
|
+
}
|
|
271
|
+
return low;
|
|
272
|
+
}
|
|
273
|
+
/**
|
|
274
|
+
* Fold a poll lane's live rows (`[bucket_ts, ...columns]` on the grid's bar opens, levels) into its
|
|
275
|
+
* buffer: a bucket the buffer holds has its row REPLACED, a new bucket is inserted in order, a row
|
|
276
|
+
* equal to the held one touches nothing; never a second row for one bucket, never an increment.
|
|
277
|
+
* Returns the new buffer and the touched buckets (ascending), null when nothing moved. Never
|
|
278
|
+
* mutates its inputs.
|
|
279
|
+
*/
|
|
280
|
+
export function foldWrunPollLaneLiveRows(rows, live) {
|
|
281
|
+
const pending = new Map();
|
|
282
|
+
for (const row of live) {
|
|
283
|
+
const ts = Number(row?.[0]);
|
|
284
|
+
if (Number.isFinite(ts))
|
|
285
|
+
pending.set(ts, row);
|
|
286
|
+
}
|
|
287
|
+
const out = [...(rows ?? [])];
|
|
288
|
+
const touched = [];
|
|
289
|
+
for (const [ts, row] of [...pending].sort((a, b) => a[0] - b[0])) {
|
|
290
|
+
const at = lowerBound(out, ts);
|
|
291
|
+
if (at < out.length && Number(out[at][0]) === ts) {
|
|
292
|
+
if (sameLaneRow(out[at], row))
|
|
293
|
+
continue;
|
|
294
|
+
out[at] = row;
|
|
295
|
+
}
|
|
296
|
+
else {
|
|
297
|
+
out.splice(at, 0, row);
|
|
298
|
+
}
|
|
299
|
+
touched.push(ts);
|
|
300
|
+
}
|
|
301
|
+
return touched.length === 0 ? null : { rows: out, touched };
|
|
302
|
+
}
|
|
303
|
+
/**
|
|
304
|
+
* The live tick's drain of a session's channel rows (beside the push intake's): every instance's
|
|
305
|
+
* queued rows folded into its buffer (`foldWrunPollLaneLiveRows`, a new array under a new record:
|
|
306
|
+
* the tail builder and a reseed read the context's own), no fed mark. Returns the oldest bucket they
|
|
307
|
+
* revised before the session's newest row (a committed bar, owed the late reseed, also stamped on
|
|
308
|
+
* the context's `dirtyFromTs`), else null. Nothing for a context the channels do not feed.
|
|
309
|
+
*/
|
|
310
|
+
export function drainWrunPollLaneLiveRows(context) {
|
|
311
|
+
const session = liveSessions.get(context.indicatorId);
|
|
312
|
+
if (session === undefined || session.context !== context || session.queued.size === 0)
|
|
313
|
+
return null;
|
|
314
|
+
const queued = session.queued;
|
|
315
|
+
session.queued = new Map();
|
|
316
|
+
let lateTs = null;
|
|
317
|
+
for (const [lane, rows] of queued) {
|
|
318
|
+
// An instance the session does not plan has no buffer to fold into.
|
|
319
|
+
if (!context.pollLanes?.some((instance) => instance.key === lane))
|
|
320
|
+
continue;
|
|
321
|
+
const folded = foldWrunPollLaneLiveRows(context.pollLaneRows?.[lane], [...rows.values()]);
|
|
322
|
+
if (folded === null)
|
|
323
|
+
continue;
|
|
324
|
+
context.pollLaneRows = { ...context.pollLaneRows, [lane]: folded.rows };
|
|
325
|
+
const oldest = folded.touched[0];
|
|
326
|
+
if (oldest < context.lastRowTs && (lateTs === null || oldest < lateTs))
|
|
327
|
+
lateTs = oldest;
|
|
328
|
+
}
|
|
329
|
+
if (lateTs !== null && (context.dirtyFromTs === null || lateTs < context.dirtyFromTs))
|
|
330
|
+
context.dirtyFromTs = lateTs;
|
|
331
|
+
return lateTs;
|
|
332
|
+
}
|
|
333
|
+
/** Whether the lane instance owes a read its live channel cannot stand for (a span it skipped, a
|
|
334
|
+
* join that may have missed readings: `stale`): true until a reconcile answers past the watermark
|
|
335
|
+
* the span rolled its coverage back to. The routine poll asks it then, whatever the channel says. */
|
|
336
|
+
export function wrunPollLaneLiveOwed(context, lane) {
|
|
337
|
+
const session = liveSessions.get(context.indicatorId);
|
|
338
|
+
const owed = session?.context === context ? session.owed.get(lane) : undefined;
|
|
339
|
+
if (session === undefined || owed === undefined)
|
|
340
|
+
return false;
|
|
341
|
+
const covered = context.coveredThroughTs[lane];
|
|
342
|
+
if (typeof covered === 'number' && Number.isFinite(covered) && covered > owed) {
|
|
343
|
+
session.owed.delete(lane);
|
|
344
|
+
return false;
|
|
345
|
+
}
|
|
346
|
+
return true;
|
|
347
|
+
}
|
|
348
|
+
/** Whether the lane instance's live channel carries it for this session right now: a routine poll
|
|
349
|
+
* waits while it does (`wrunPollLaneRecheckDue`). False for a session that opened none. */
|
|
350
|
+
export function wrunPollLaneLiveUp(context, lane) {
|
|
351
|
+
const session = liveSessions.get(context.indicatorId);
|
|
352
|
+
const channel = session?.context === context ? session.channels.get(lane) : undefined;
|
|
353
|
+
if (channel === undefined)
|
|
354
|
+
return false;
|
|
355
|
+
try {
|
|
356
|
+
return channel.subscription.isUp() === true;
|
|
357
|
+
}
|
|
358
|
+
catch {
|
|
359
|
+
return false;
|
|
360
|
+
}
|
|
361
|
+
}
|
|
362
|
+
/** The rows a session's channels queued and no drain folded yet (diagnostics and specs). */
|
|
363
|
+
export function wrunPollLaneLiveQueued(indicatorId) {
|
|
364
|
+
let count = 0;
|
|
365
|
+
for (const rows of liveSessions.get(indicatorId)?.queued.values() ?? [])
|
|
366
|
+
count += rows.size;
|
|
367
|
+
return count;
|
|
368
|
+
}
|
|
369
|
+
/** Close every session's channels, drop their queues and the re-plan clock (specs only). */
|
|
370
|
+
export function __resetWrunPollLaneLiveForTests() {
|
|
371
|
+
for (const indicatorId of [...liveSessions.keys()])
|
|
372
|
+
closeWrunPollLaneLiveChannels(indicatorId);
|
|
373
|
+
replannedAtMs.clear();
|
|
374
|
+
}
|
|
375
|
+
let teardownRegistered = false;
|
|
376
|
+
/** The drivers' teardown hook, registered once, with the first channel that opens (so a module that
|
|
377
|
+
* merely imports this one registers nothing), tolerating a node spec's partial mock of the drivers
|
|
378
|
+
* util (reading a missing export of a mocked module throws there): retried at the next open. */
|
|
379
|
+
function registerWrunPollLaneLiveTeardown() {
|
|
380
|
+
if (teardownRegistered)
|
|
381
|
+
return;
|
|
382
|
+
try {
|
|
383
|
+
onWrunOverlayLiveTeardown((indicatorId) => closeWrunPollLaneLiveChannels(indicatorId));
|
|
384
|
+
teardownRegistered = true;
|
|
385
|
+
}
|
|
386
|
+
catch {
|
|
387
|
+
// A partial mock of the drivers util: retried at the next open.
|
|
388
|
+
}
|
|
389
|
+
}
|
|
390
|
+
// ---------------------------------------------------------------------------
|
|
391
|
+
// The series channel: the relay feed stream
|
|
392
|
+
// ---------------------------------------------------------------------------
|
|
393
|
+
/** The lane's key in a reading's values: the feed's first value key (the relay's default for a
|
|
394
|
+
* bars read, the column the lane's fetch reads). */
|
|
395
|
+
export const WRUN_SERIES_READING_COLUMN = 0;
|
|
396
|
+
/** The lane id a reading is bucketed under: every poll lane lands on the chart's own bar opens. */
|
|
397
|
+
const WRUN_SERIES_BUCKET_LANE = `poll:${WRUN_SERIES_LANE_KEY}`;
|
|
398
|
+
/** How many buckets a channel remembers the newest reading of (the newest ones, by arrival). */
|
|
399
|
+
const WRUN_SERIES_NEWEST_KEPT = 64;
|
|
400
|
+
/** Whether a stream reading stands for its bucket: a feed combining by `last` (the default, and the
|
|
401
|
+
* rule of a head that names none, whose bars carry no `combined`), never by another rule (a slot's
|
|
402
|
+
* level is not its bucket's sum, mean, first, max or min). */
|
|
403
|
+
export function wrunSeriesStreamCarries(extras) {
|
|
404
|
+
return extras.combine === undefined || extras.combine === 'last';
|
|
405
|
+
}
|
|
406
|
+
/** A stream reading as the lane's row on a grid of `intervalMs`: `[bucket_ts_ms, value]`, the
|
|
407
|
+
* value the lane's key (position 0), or null for a state or null cell or an unusable stamp. */
|
|
408
|
+
export function wrunSeriesReadingRow(reading, intervalMs) {
|
|
409
|
+
const value = reading.values[WRUN_SERIES_READING_COLUMN];
|
|
410
|
+
if (typeof value !== 'number' || !Number.isFinite(value))
|
|
411
|
+
return null;
|
|
412
|
+
const tsMs = reading.ts * 1000;
|
|
413
|
+
if (!Number.isFinite(tsMs) || !(intervalMs > 0))
|
|
414
|
+
return null;
|
|
415
|
+
const bucket = wrunLiveBucketTs(WRUN_SERIES_BUCKET_LANE, tsMs, intervalMs);
|
|
416
|
+
return bucket === null ? null : [bucket, value];
|
|
417
|
+
}
|
|
418
|
+
/** The newer of two optional stamps. */
|
|
419
|
+
function newerOf(a, b) {
|
|
420
|
+
if (typeof b !== 'number' || !Number.isFinite(b))
|
|
421
|
+
return a;
|
|
422
|
+
return a === null || b > a ? b : a;
|
|
423
|
+
}
|
|
424
|
+
/**
|
|
425
|
+
* The series lane's live channel for one instance (the lane's `live.subscribe` loads this module
|
|
426
|
+
* and calls it): the feed's stream through the seam, imported here, so nothing of the stream
|
|
427
|
+
* client loads before a session reads a feed. A ref that is no feed address, a feed combining by
|
|
428
|
+
* another rule than `last`, and a stream switched off (`feedStreamEnabled`) answer a channel that
|
|
429
|
+
* is never up without subscribing.
|
|
430
|
+
*
|
|
431
|
+
* Beside the readings (the module doc), the channel guards what it folds:
|
|
432
|
+
* - The declaration: its baseline is the head the session's `plan` judged
|
|
433
|
+
* (`wrunSeriesPlannedHead`; without one, the first head the stream sends). A newer plan of the
|
|
434
|
+
* feed on this grid answering other facts, or a stream `head` of a newer version (a changed rule,
|
|
435
|
+
* cadence, grain or exact interval), ends the channel before any further reading (never up, its
|
|
436
|
+
* readings dropped) and re-plans the session (`replan`): the plan judges the new declaration, and
|
|
437
|
+
* a rule other than `last` keeps the feed on the poll.
|
|
438
|
+
* - A skipped span: a reading landing more than one slot (the larger of the chart interval and the
|
|
439
|
+
* cadence) after the newest bucket the lane holds may follow rows the stream never sent (its
|
|
440
|
+
* sampler keeps the newest row per interval, its catch-up the newest 2,000): the span from the
|
|
441
|
+
* bucket after that one is owed to a reconcile (`stale`), and the reading still folds.
|
|
442
|
+
* - A late join: on the channel's first `up`, when the newest reading the feed is known to hold
|
|
443
|
+
* (its readings and heads, or the tab's newest head of the feed) is after the newest bucket the
|
|
444
|
+
* lane held at open, the readings between the lane's fetch and its subscribe may be missing (a
|
|
445
|
+
* feed another subscriber carried replays no catch-up): that bucket on is owed (`stale`).
|
|
446
|
+
*/
|
|
447
|
+
export async function openWrunSeriesStream(ask, sink) {
|
|
448
|
+
const ref = wrunSeriesFeedAddress(ask.extras.ref);
|
|
449
|
+
if (ref === undefined || !wrunSeriesStreamCarries(ask.extras))
|
|
450
|
+
return WRUN_POLL_LANE_LIVE_NEVER_UP;
|
|
451
|
+
const { feedStreamEnabled, subscribeFeedStream, seenFeedHead } = await wrunChartHostEnv().transport.loadFeedStream();
|
|
452
|
+
if (!feedStreamEnabled())
|
|
453
|
+
return WRUN_POLL_LANE_LIVE_NEVER_UP;
|
|
454
|
+
const cadenceS = typeof ask.extras.cadence_s === 'number' ? ask.extras.cadence_s : 0;
|
|
455
|
+
const planned = wrunSeriesPlannedHead(ref, ask.intervalMs);
|
|
456
|
+
if (planned !== undefined && (planned.cadence_s !== cadenceS || planned.combine !== ask.extras.combine)) {
|
|
457
|
+
// A newer plan of this feed on this grid read another declaration than the session's.
|
|
458
|
+
sink.replan();
|
|
459
|
+
return WRUN_POLL_LANE_LIVE_NEVER_UP;
|
|
460
|
+
}
|
|
461
|
+
/** One slot: a reading further than this after the newest bucket may follow skipped rows. */
|
|
462
|
+
const slotMs = Math.max(ask.intervalMs, cadenceS * 1000);
|
|
463
|
+
let baselineVersion = planned?.version ?? null;
|
|
464
|
+
let ended = false;
|
|
465
|
+
let upOnce = false;
|
|
466
|
+
// The newest bucket the lane holds (at open, then every bucket handed), and the newest stamp the
|
|
467
|
+
// feed is known to hold.
|
|
468
|
+
let newestBucket = ask.newestTs;
|
|
469
|
+
let feedNewestSec = null;
|
|
470
|
+
// Per bucket, the stamp of the newest reading this channel handed for it.
|
|
471
|
+
const newest = new Map();
|
|
472
|
+
const subscription = subscribeFeedStream(ref, (event) => {
|
|
473
|
+
if (ended)
|
|
474
|
+
return;
|
|
475
|
+
switch (event.kind) {
|
|
476
|
+
case 'head': {
|
|
477
|
+
const version = event.head.version;
|
|
478
|
+
if (typeof version === 'number' && Number.isFinite(version)) {
|
|
479
|
+
if (baselineVersion === null)
|
|
480
|
+
baselineVersion = version;
|
|
481
|
+
else if (version > baselineVersion) {
|
|
482
|
+
ended = true;
|
|
483
|
+
sink.replan();
|
|
484
|
+
return;
|
|
485
|
+
}
|
|
486
|
+
}
|
|
487
|
+
feedNewestSec = newerOf(feedNewestSec, event.head.last_ts);
|
|
488
|
+
return;
|
|
489
|
+
}
|
|
490
|
+
case 'reading': {
|
|
491
|
+
feedNewestSec = newerOf(feedNewestSec, event.ts);
|
|
492
|
+
const row = wrunSeriesReadingRow(event, ask.intervalMs);
|
|
493
|
+
if (row === null)
|
|
494
|
+
return;
|
|
495
|
+
const seen = newest.get(row[0]);
|
|
496
|
+
if (seen !== undefined && event.ts < seen)
|
|
497
|
+
return;
|
|
498
|
+
newest.set(row[0], event.ts);
|
|
499
|
+
if (newest.size > WRUN_SERIES_NEWEST_KEPT)
|
|
500
|
+
newest.delete(newest.keys().next().value);
|
|
501
|
+
if (newestBucket !== null && row[0] - newestBucket > slotMs)
|
|
502
|
+
sink.stale(newestBucket + ask.intervalMs);
|
|
503
|
+
if (newestBucket === null || row[0] > newestBucket)
|
|
504
|
+
newestBucket = row[0];
|
|
505
|
+
sink.rows([row]);
|
|
506
|
+
return;
|
|
507
|
+
}
|
|
508
|
+
case 'up': {
|
|
509
|
+
if (!upOnce) {
|
|
510
|
+
// The first up: only a stream dialed from this channel's `sinceTs` replays the readings
|
|
511
|
+
// stored since the lane's fetch (a joined feed replays none, another subscriber's stamp may
|
|
512
|
+
// be newer), so a feed known to hold a reading after the lane's newest bucket at open owes
|
|
513
|
+
// that bucket on to a read.
|
|
514
|
+
const known = newerOf(feedNewestSec, seenFeedHead(ref)?.last_ts);
|
|
515
|
+
if (known !== null && (ask.newestTs === null || ask.newestTs < known * 1000)) {
|
|
516
|
+
if (ask.newestTs === null)
|
|
517
|
+
sink.reopened();
|
|
518
|
+
else
|
|
519
|
+
sink.stale(ask.newestTs);
|
|
520
|
+
}
|
|
521
|
+
}
|
|
522
|
+
else if (event.reopened) {
|
|
523
|
+
sink.reopened();
|
|
524
|
+
}
|
|
525
|
+
upOnce = true;
|
|
526
|
+
return;
|
|
527
|
+
}
|
|
528
|
+
default:
|
|
529
|
+
// down and gone: `isUp()` answers for them.
|
|
530
|
+
return;
|
|
531
|
+
}
|
|
532
|
+
}, { sinceTs: ask.newestTs === null ? null : Math.floor(ask.newestTs / 1000) });
|
|
533
|
+
return {
|
|
534
|
+
unsubscribe: () => subscription.unsubscribe(),
|
|
535
|
+
isUp: () => !ended && subscription.isUp(),
|
|
536
|
+
};
|
|
537
|
+
}
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* SHA-256 of a wrun module's bytes, synchronously and with no global: the engine worker's load path
|
|
3
|
+
* (wrun-engine-handler.ts) hashes every module it is handed before it checks the sheet's `wasm_sha256` pin, and mints
|
|
4
|
+
* the module's cache key from the digest. The main thread never hashes a module (wrun-host.service.ts posts the bytes
|
|
5
|
+
* and reads the digest off the worker's reply), so nothing here may reach for `crypto.subtle`: it is missing outside a
|
|
6
|
+
* secure context, it answers only through a promise, and the worker's load has no await to spare before its cache
|
|
7
|
+
* entry exists.
|
|
8
|
+
*
|
|
9
|
+
* Ported from the phone's `wrunSha256Hex` (kiyotaka-frontend-app chart-web/src/wrun/wrun-memory-clamp.ts:242), which
|
|
10
|
+
* phase A moves onto this leaf before its own copy goes. FIPS 180-4 sections 4.2.2 and 5.3.3.
|
|
11
|
+
*/
|
|
12
|
+
/** SHA-256 of `bytes` (the view's own range) as 64 lowercase hex digits, synchronously. */
|
|
13
|
+
export declare function wrunSha256Hex(bytes: Uint8Array): string;
|
|
@@ -0,0 +1,84 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* SHA-256 of a wrun module's bytes, synchronously and with no global: the engine worker's load path
|
|
3
|
+
* (wrun-engine-handler.ts) hashes every module it is handed before it checks the sheet's `wasm_sha256` pin, and mints
|
|
4
|
+
* the module's cache key from the digest. The main thread never hashes a module (wrun-host.service.ts posts the bytes
|
|
5
|
+
* and reads the digest off the worker's reply), so nothing here may reach for `crypto.subtle`: it is missing outside a
|
|
6
|
+
* secure context, it answers only through a promise, and the worker's load has no await to spare before its cache
|
|
7
|
+
* entry exists.
|
|
8
|
+
*
|
|
9
|
+
* Ported from the phone's `wrunSha256Hex` (kiyotaka-frontend-app chart-web/src/wrun/wrun-memory-clamp.ts:242), which
|
|
10
|
+
* phase A moves onto this leaf before its own copy goes. FIPS 180-4 sections 4.2.2 and 5.3.3.
|
|
11
|
+
*/
|
|
12
|
+
// The round constants, typed out rather than derived from the prime roots at load: a derived table would hang on each
|
|
13
|
+
// engine's Math.cbrt rounding, and a wrong constant refuses every package.
|
|
14
|
+
const SHA256_K = new Uint32Array([
|
|
15
|
+
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98,
|
|
16
|
+
0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
|
|
17
|
+
0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8,
|
|
18
|
+
0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
|
|
19
|
+
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
|
|
20
|
+
0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
|
|
21
|
+
0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
|
|
22
|
+
0xc67178f2,
|
|
23
|
+
]);
|
|
24
|
+
const SHA256_INIT = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
|
|
25
|
+
// One 64-byte block into `state`. Sums stay exact in doubles (five terms under 2^35), and the Uint32Array stores wrap
|
|
26
|
+
// them mod 2^32, which is the algorithm's own addition.
|
|
27
|
+
function sha256Block(state, w, view, offset) {
|
|
28
|
+
for (let i = 0; i < 16; i += 1)
|
|
29
|
+
w[i] = view.getUint32(offset + i * 4);
|
|
30
|
+
for (let i = 16; i < 64; i += 1) {
|
|
31
|
+
const x = w[i - 15];
|
|
32
|
+
const y = w[i - 2];
|
|
33
|
+
const s0 = ((x >>> 7) | (x << 25)) ^ ((x >>> 18) | (x << 14)) ^ (x >>> 3);
|
|
34
|
+
const s1 = ((y >>> 17) | (y << 15)) ^ ((y >>> 19) | (y << 13)) ^ (y >>> 10);
|
|
35
|
+
w[i] = w[i - 16] + s0 + w[i - 7] + s1;
|
|
36
|
+
}
|
|
37
|
+
let [a, b, c, d, e, f, g, h] = state;
|
|
38
|
+
for (let i = 0; i < 64; i += 1) {
|
|
39
|
+
const s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
|
|
40
|
+
const t1 = (h + s1 + ((e & f) ^ (~e & g)) + SHA256_K[i] + w[i]) | 0;
|
|
41
|
+
const s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
|
|
42
|
+
const t2 = (s0 + ((a & b) ^ (a & c) ^ (b & c))) | 0;
|
|
43
|
+
h = g;
|
|
44
|
+
g = f;
|
|
45
|
+
f = e;
|
|
46
|
+
e = (d + t1) | 0;
|
|
47
|
+
d = c;
|
|
48
|
+
c = b;
|
|
49
|
+
b = a;
|
|
50
|
+
a = (t1 + t2) | 0;
|
|
51
|
+
}
|
|
52
|
+
state[0] += a;
|
|
53
|
+
state[1] += b;
|
|
54
|
+
state[2] += c;
|
|
55
|
+
state[3] += d;
|
|
56
|
+
state[4] += e;
|
|
57
|
+
state[5] += f;
|
|
58
|
+
state[6] += g;
|
|
59
|
+
state[7] += h;
|
|
60
|
+
}
|
|
61
|
+
/** SHA-256 of `bytes` (the view's own range) as 64 lowercase hex digits, synchronously. */
|
|
62
|
+
export function wrunSha256Hex(bytes) {
|
|
63
|
+
const state = Uint32Array.from(SHA256_INIT);
|
|
64
|
+
const w = new Uint32Array(64);
|
|
65
|
+
const length = bytes.byteLength;
|
|
66
|
+
const fullBlocks = Math.floor(length / 64);
|
|
67
|
+
const view = new DataView(bytes.buffer, bytes.byteOffset, length);
|
|
68
|
+
for (let block = 0; block < fullBlocks; block += 1)
|
|
69
|
+
sha256Block(state, w, view, block * 64);
|
|
70
|
+
const rest = length - fullBlocks * 64;
|
|
71
|
+
const tail = new Uint8Array(rest + 9 <= 64 ? 64 : 128);
|
|
72
|
+
tail.set(bytes.subarray(fullBlocks * 64));
|
|
73
|
+
tail[rest] = 0x80;
|
|
74
|
+
const tailView = new DataView(tail.buffer);
|
|
75
|
+
// The message length in bits, big-endian over the last 8 bytes: the high word first (length * 8 / 2^32).
|
|
76
|
+
tailView.setUint32(tail.length - 8, Math.floor(length / 0x20000000));
|
|
77
|
+
tailView.setUint32(tail.length - 4, (length * 8) >>> 0);
|
|
78
|
+
for (let offset = 0; offset < tail.length; offset += 64)
|
|
79
|
+
sha256Block(state, w, tailView, offset);
|
|
80
|
+
let hex = '';
|
|
81
|
+
for (let i = 0; i < 8; i += 1)
|
|
82
|
+
hex += state[i].toString(16).padStart(8, '0');
|
|
83
|
+
return hex;
|
|
84
|
+
}
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* A seam between the wrun sheet memory (wrun-overlay-metadata.util's
|
|
3
|
+
* `rememberWrunOverlayMetadata`, where every loader registers a mounted
|
|
4
|
+
* overlay's sheet: the registry loader at its driver registration, which the
|
|
5
|
+
* add, draft and rehydrate paths pass, a hosted doc adopted over its
|
|
6
|
+
* placeholder, a cloud batch's compiled sheet, the dev loader) and whoever
|
|
7
|
+
* reads a sheet's declarations off the chart. The anchor history demand in
|
|
8
|
+
* instances/titan-charts reads the sheets' `time` params, which exist only
|
|
9
|
+
* from here: after a reload the boot-tail rehydrate registers the sheet after
|
|
10
|
+
* the boot landing already read the chart without it. The memory never
|
|
11
|
+
* imports the instance module for it, and a listener that throws never
|
|
12
|
+
* reaches the loader.
|
|
13
|
+
*/
|
|
14
|
+
type WrunSheetRememberedListener = (indicatorId: string) => void;
|
|
15
|
+
/** Subscribe to remembered sheets (by overlay id); returns the unsubscribe. */
|
|
16
|
+
export declare function onWrunSheetRemembered(listener: WrunSheetRememberedListener): () => void;
|
|
17
|
+
/** Announce the sheet just remembered for `indicatorId`; a throwing listener is dropped for this call only. */
|
|
18
|
+
export declare function notifyWrunSheetRemembered(indicatorId: string): void;
|
|
19
|
+
/** Test seam: forget every listener. */
|
|
20
|
+
export declare function __resetWrunSheetRememberedListenersForTests(): void;
|
|
21
|
+
export {};
|