@forgecharts/sdk 1.2.5 → 1.2.6

package/dist/react/index.js

@@ -10606,8 +10606,126 @@ var TradingOverlayStore = class {
   }
 };
 
+// src/licensing/licenseTypes.ts
+var TRADING_FEATURE_KEYS = /* @__PURE__ */ new Set([
+  "orderEntry",
+  "managedTrading",
+  "draggableOrders",
+  "bracketOrders",
+  "trailingStops",
+  "positionsOverlay"
+]);
+
+// src/licensing/capabilityMatrix.ts
+var CURRENT_SCHEMA_VERSION = 2;
+var BASE_MATRIX = {
+  core: {
+    orderEntry: false,
+    managedTrading: false,
+    draggableOrders: false,
+    bracketOrders: false,
+    externalIngestion: true,
+    symbolResolverRequired: true,
+    tradingBridgeRequired: false,
+    fullAppShell: false
+  },
+  trading: {
+    orderEntry: true,
+    managedTrading: false,
+    draggableOrders: true,
+    bracketOrders: true,
+    externalIngestion: true,
+    symbolResolverRequired: true,
+    tradingBridgeRequired: true,
+    fullAppShell: false
+  },
+  platform: {
+    orderEntry: true,
+    managedTrading: true,
+    draggableOrders: true,
+    bracketOrders: true,
+    externalIngestion: false,
+    symbolResolverRequired: false,
+    tradingBridgeRequired: false,
+    fullAppShell: true
+  }
+};
+function getDefaultCapabilities(productTier, deploymentMode) {
+  const base = BASE_MATRIX[productTier];
+  if (deploymentMode === "unmanaged") {
+    return { ...base, managedTrading: false, fullAppShell: false };
+  }
+  return { ...base };
+}
+function isValidCombination(deploymentMode, capabilities) {
+  if (deploymentMode === "managed" && capabilities.fullAppShell === false) return false;
+  return true;
+}
+function hasAnyTradingFeature(features) {
+  if (!features) return false;
+  for (const key of TRADING_FEATURE_KEYS) {
+    if (features[key] === true) return true;
+  }
+  return false;
+}
+function inferProductTier(raw, mode) {
+  if (mode === "managed") return "platform";
+  if (raw.tier === "trading" || raw.tier === "dom") return "trading";
+  if (hasAnyTradingFeature(raw.features)) return "trading";
+  return "core";
+}
+function migrateLegacyPayload(raw) {
+  const warnings = [];
+  const mode = raw.deploymentMode ?? raw.mode ?? "unmanaged";
+  let productTier = raw.productTier;
+  if (!productTier) {
+    productTier = inferProductTier(raw, mode);
+    warnings.push(
+      `License payload has no productTier \u2014 inferred '${productTier}' from mode='${mode}'` + (raw.tier ? ` and legacy tier='${raw.tier}'` : "") + "."
+    );
+  }
+  let capabilities = raw.capabilities;
+  if (!capabilities) {
+    capabilities = getDefaultCapabilities(productTier, mode);
+    warnings.push(`License payload has no capabilities \u2014 derived defaults for productTier='${productTier}', deploymentMode='${mode}'.`);
+  }
+  if (!raw.schemaVersion || raw.schemaVersion < CURRENT_SCHEMA_VERSION) {
+    warnings.push(`License payload schemaVersion=${raw.schemaVersion ?? 1} is legacy \u2014 migrated to v${CURRENT_SCHEMA_VERSION}.`);
+  }
+  const payload = {
+    licenseKey: raw.licenseKey ?? "",
+    mode,
+    deploymentMode: mode,
+    productTier,
+    capabilities,
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    ...raw.tier != null && { tier: raw.tier },
+    ...raw.plan != null && { plan: raw.plan },
+    ...raw.expires != null && { expires: raw.expires },
+    ...raw.features != null && { features: raw.features }
+  };
+  return { payload, warnings };
+}
+function validateLicensePolicy(payload) {
+  const warnings = [];
+  const capabilities = payload.capabilities ?? getDefaultCapabilities(payload.productTier ?? "core", payload.mode);
+  if (isValidCombination(payload.mode, capabilities)) {
+    return { valid: true, normalized: { ...payload, capabilities }, warnings };
+  }
+  warnings.push(
+    `Invalid license combination: deploymentMode='${payload.mode}' requires fullAppShell capability. Normalizing productTier to 'platform'.`
+  );
+  const normalizedCapabilities = getDefaultCapabilities("platform", payload.mode);
+  return {
+    valid: false,
+    normalized: { ...payload, productTier: "platform", capabilities: normalizedCapabilities },
+    warnings
+  };
+}
+
 // src/licensing/LicenseManager.ts
 var DEFAULT_MODE = "unmanaged";
+var DEFAULT_PRODUCT_TIER = "core";
 var DEFAULT_FEATURES = {};
 var LicenseManager = class _LicenseManager {
   static instance = null;
@@ -10670,22 +10788,42 @@ var LicenseManager = class _LicenseManager {
     if (!data.valid) {
       throw new Error(data.reason ?? "License invalid");
     }
-    const payload = {
+    const raw = {
       licenseKey: data.licenseKey ?? key.trim().toUpperCase(),
       mode: data.mode ?? "unmanaged",
+      ...data.tier != null && { tier: data.tier },
+      ...data.productTier != null && { productTier: data.productTier },
+      ...data.capabilities != null && { capabilities: data.capabilities },
+      ...data.schemaVersion != null && { schemaVersion: data.schemaVersion },
       ...data.plan != null && { plan: data.plan },
       ...data.expiresAt != null && { expires: data.expiresAt },
       ...data.features != null && { features: data.features }
     };
+    const payload = this.#applyPolicyPipeline(raw);
     this.payload = payload;
     this.notify();
     return payload;
   }
-  /** Load a pre-validated payload (e.g. from cache / localStorage). */
+  /** Load a pre-validated payload (e.g. from cache / localStorage). Runs through the same migration + guardrail pipeline as `validateLicense`. */
   loadLicense(payload) {
-    this.payload = payload;
+    this.payload = this.#applyPolicyPipeline(payload);
     this.notify();
   }
+  /**
+   * Runs a raw/legacy/partial payload through `migrateLegacyPayload` (fills
+   * missing productTier/capabilities/schemaVersion, deterministically, with
+   * warnings) then `validateLicensePolicy` (guardrail normalization).
+   * Any warnings are surfaced via `console.warn` — callers never see a
+   * payload without `capabilities`.
+   */
+  #applyPolicyPipeline(raw) {
+    const { payload: migrated, warnings: migrationWarnings } = migrateLegacyPayload(raw);
+    const { normalized, warnings: policyWarnings } = validateLicensePolicy(migrated);
+    for (const warning of [...migrationWarnings, ...policyWarnings]) {
+      console.warn(`[LicenseManager] ${warning}`);
+    }
+    return normalized;
+  }
   /** Return the currently loaded payload, or null if none. */
   getLicense() {
     return this.payload;
@@ -10706,6 +10844,25 @@ var LicenseManager = class _LicenseManager {
   hasFeature(name) {
     return this.getFeatures()[name] === true;
   }
+  /**
+   * The entitlement tier driven by the active license.
+   * Defaults to 'core' — the most restrictive tier — so no trading/managed
+   * capability appears without a valid license.
+   */
+  getProductTier() {
+    return this.payload?.productTier ?? DEFAULT_PRODUCT_TIER;
+  }
+  /**
+   * The resolved capability set for the active license (or the safest
+   * defaults — unmanaged/core — when no license is loaded yet).
+   */
+  getCapabilities() {
+    return this.payload?.capabilities ?? getDefaultCapabilities(DEFAULT_PRODUCT_TIER, DEFAULT_MODE);
+  }
+  /** Check whether a specific capability is enabled on the active license. */
+  hasCapability(name) {
+    return this.getCapabilities()[name] === true;
+  }
   /** Clear the current license state (returns to safe unmanaged defaults). */
   clear() {
     this.payload = null;
@@ -10713,16 +10870,6 @@ var LicenseManager = class _LicenseManager {
   }
 };
 
-// src/licensing/licenseTypes.ts
-var TRADING_FEATURE_KEYS = /* @__PURE__ */ new Set([
-  "orderEntry",
-  "managedTrading",
-  "draggableOrders",
-  "bracketOrders",
-  "trailingStops",
-  "positionsOverlay"
-]);
-
 // src/licensing/ChartRuntimeResolver.ts
 var ChartRuntimeResolver = class _ChartRuntimeResolver {
   static instance = null;
@@ -10751,15 +10898,23 @@ var ChartRuntimeResolver = class _ChartRuntimeResolver {
   /**
    * Check whether a specific platform feature is enabled.
    *
-   * Resolution:
-   *   1. If the feature is a trading feature and mode is unmanaged → false.
+   * Resolution (capability-driven — never gated on deploymentMode alone):
+   *   1. If the feature is a trading feature and productTier is 'core' → false.
    *   2. If the feature has an explicit flag in the license → use it.
-   *   3. Default: true for managed, true for non-trading unmanaged features.
+   *   3. Default: true for platform/trading tier, true for non-trading features.
    */
   hasFeature(name) {
-    if (TRADING_FEATURE_KEYS.has(name) && this.isUnmanagedMode()) return false;
+    if (TRADING_FEATURE_KEYS.has(name) && this.#isCoreTier()) return false;
     return this.#featureOrDefault(name, true);
   }
+  /** The entitlement tier driven by the active license. */
+  getProductTier() {
+    return this.lm.getProductTier();
+  }
+  /** True when the active license's productTier is 'core' (no trading capabilities). */
+  #isCoreTier() {
+    return this.lm.getProductTier() === "core";
+  }
   // ── Charting capability queries ─────────────────────────────────────────────
   /** Chart type selection (candlestick, bar, line, area, etc.). */
   canUseChartTypes() {
@@ -10813,50 +10968,77 @@ var ChartRuntimeResolver = class _ChartRuntimeResolver {
   // ── Trading capability queries (managed-only by default) ────────────────────
   /**
    * Built-in order entry UI hooks.
-   * Requires managed mode — unmanaged licenses cannot use order entry.
+   * Ceiling driven by `productTier` (core = false, trading/platform = true) —
+   * available in both Unmanaged Trading and Managed Platform. An explicit
+   * `features.orderEntry` flag on the payload may only narrow below the
+   * ceiling, never elevate above it.
    */
   canUseOrderEntry() {
-    if (this.isUnmanagedMode()) return false;
-    return this.#featureOrDefault("orderEntry", true);
+    return this.#capabilityWithOverride("orderEntry");
   }
   /**
    * Managed trading service hooks (broker execution, position management).
-   * Requires managed mode.
+   * Only true for Managed Platform — `managedTrading` is forced off under
+   * unmanaged deployment regardless of tier (see capabilityMatrix).
    */
   canUseManagedTrading() {
-    if (this.isUnmanagedMode()) return false;
-    return this.#featureOrDefault("managedTrading", true);
+    return this.#capabilityWithOverride("managedTrading");
   }
   /**
    * Drag-to-price order placement.
-   * Requires managed mode.
+   * Ceiling driven by `productTier` — available in Unmanaged Trading and
+   * Managed Platform.
    */
   canUseDraggableOrders() {
-    if (this.isUnmanagedMode()) return false;
-    return this.#featureOrDefault("draggableOrders", true);
+    return this.#capabilityWithOverride("draggableOrders");
   }
   /**
    * Bracket / OCO order support.
-   * Requires managed mode.
+   * Ceiling driven by `productTier` — available in Unmanaged Trading and
+   * Managed Platform.
    */
   canUseBracketOrders() {
-    if (this.isUnmanagedMode()) return false;
-    return this.#featureOrDefault("bracketOrders", true);
+    return this.#capabilityWithOverride("bracketOrders");
+  }
+  /**
+   * Resolve one of the 4 override-able capability keys: the tier×mode matrix
+   * sets the ceiling, an explicit `features[name]` flag may only narrow it.
+   */
+  #capabilityWithOverride(name) {
+    const ceiling = this.lm.getCapabilities()[name];
+    if (!ceiling) return false;
+    const explicit = this.lm.getFeatures()[name];
+    return explicit === void 0 ? true : explicit === true;
+  }
+  /**
+   * Whether trading UI must route execution through host-supplied intent
+   * handlers rather than a managed backend (Unmanaged Trading only).
+   */
+  requiresTradingBridge() {
+    return this.lm.getCapabilities().tradingBridgeRequired;
+  }
+  /** Whether the host must supply an `ISymbolResolver` (unmanaged tiers). */
+  requiresSymbolResolver() {
+    return this.lm.getCapabilities().symbolResolverRequired;
+  }
+  /** Whether the full managed app shell should render (Managed Platform only). */
+  hasFullAppShell() {
+    return this.lm.getCapabilities().fullAppShell;
   }
   /**
-   * Trailing stop orders.
-   * Requires managed mode.
+   * Trailing stop orders. Not part of the core capability set — gated on
+   * productTier (not deploymentMode) to keep the two axes independent.
    */
   canUseTrailingStops() {
-    if (this.isUnmanagedMode()) return false;
+    if (this.#isCoreTier()) return false;
     return this.#featureOrDefault("trailingStops", true);
   }
   /**
-   * Positions overlay on chart.
-   * Requires managed mode.
+   * Positions overlay on chart. Not part of the core capability set — gated
+   * on productTier (not deploymentMode) to keep the two axes independent.
    */
   canUsePositionsOverlay() {
-    if (this.isUnmanagedMode()) return false;
+    if (this.#isCoreTier()) return false;
     return this.#featureOrDefault("positionsOverlay", true);
   }
   // ── Scripting capability queries ────────────────────────────────────────────
@@ -10896,11 +11078,11 @@ var ChartRuntimeResolver = class _ChartRuntimeResolver {
   // ── Legacy / backward-compat ────────────────────────────────────────────────
   /**
    * External data ingestion APIs (e.g. pushing tick data from an external broker).
-   * Available in unmanaged mode only — in managed mode the built-in feed owns data.
+   * Driven by `productTier`/`deploymentMode` via `capabilities.externalIngestion`
+   * — true for core/trading, false for Managed Platform (the managed feed owns data).
    */
   canUseExternalIngestion() {
-    if (this.isUnmanagedMode()) return true;
-    return this.#featureOrDefault("unmanagedIngestion", false);
+    return this.lm.getCapabilities().externalIngestion;
   }
   // ── UI render capability checks ──────────────────────────────────────────────
   // Component-level gates derived from the feature-level checks above.
@@ -10961,8 +11143,13 @@ var ChartRuntimeResolver = class _ChartRuntimeResolver {
    */
   getCapabilities() {
     return {
-      // ── Mode ────────────────────────────────────────────────────────────
+      // ── Mode / tier ─────────────────────────────────────────────────────
       mode: this.lm.getMode(),
+      productTier: this.lm.getProductTier(),
+      // ── Capabilities (the 3-model matrix) ──────────────────────────────
+      symbolResolverRequired: this.requiresSymbolResolver(),
+      tradingBridgeRequired: this.requiresTradingBridge(),
+      fullAppShell: this.hasFullAppShell(),
       // ── Charting features ───────────────────────────────────────────────
       chartTypes: this.canUseChartTypes(),
       drawingTools: this.canUseDrawingTools(),
@@ -11114,19 +11301,11 @@ function assertManagedMode() {
     );
   }
 }
-function assertCanPlaceOrders() {
-  assertManagedMode();
-  if (!resolver2().canUseOrderEntry()) {
-    throw new Error(
-      "[ForgeCharts] Order entry is not enabled on the active license. Contact your license provider to enable the orderEntry feature."
-    );
-  }
-}
-function assertCanUseBrackets() {
-  assertCanPlaceOrders();
+function assertCanUseManagedBrackets() {
+  assertCanUseManagedTrading();
   if (!resolver2().canUseBracketOrders()) {
     throw new Error(
-      "[ForgeCharts] Bracket orders are not enabled on the active license. Contact your license provider to enable the bracketOrders feature."
+      "[ForgeCharts] Bracket orders are not enabled on the active license. Contact your license provider to enable the bracketOrders capability."
     );
   }
 }
@@ -11134,7 +11313,7 @@ function assertCanUseManagedTrading() {
   assertManagedMode();
   if (!resolver2().canUseManagedTrading()) {
     throw new Error(
-      "[ForgeCharts] Managed trading is not enabled on the active license. Contact your license provider to enable the managedTrading feature."
+      "[ForgeCharts] Managed trading is not enabled on the active license. Contact your license provider to enable the managedTrading capability (requires productTier=platform)."
     );
   }
 }
@@ -11193,7 +11372,7 @@ var ManagedTradingController = class {
    *       (provider event stream) and call _store.upsertOrder() as status changes.
    */
   async placeOrder(input) {
-    assertCanPlaceOrders();
+    assertCanUseManagedTrading();
     if (!this._provider) notImplemented("placeOrder");
     const clientId = makeId();
     const overlayOrder = {
@@ -11231,7 +11410,7 @@ var ManagedTradingController = class {
    *       visually fades out rather than disappearing instantly).
    */
   async cancelOrder(orderId) {
-    assertCanPlaceOrders();
+    assertCanUseManagedTrading();
     if (!this._provider) notImplemented("cancelOrder");
     await this._provider.cancelOrder(orderId);
     const existing = this._store.getOrders().find((o) => o.id === orderId);
@@ -11251,7 +11430,7 @@ var ManagedTradingController = class {
    *       before forwarding to the provider.
    */
   async modifyOrder(orderId, updates) {
-    assertCanPlaceOrders();
+    assertCanUseManagedTrading();
     if (!this._provider) notImplemented("modifyOrder");
     const ack = await this._provider.modifyOrder(orderId, updates);
     const existing = this._store.getOrders().find((o) => o.id === orderId);
@@ -11278,7 +11457,7 @@ var ManagedTradingController = class {
    *       users can adjust prices before confirming.
    */
   async placeBracketOrder(input) {
-    assertCanUseBrackets();
+    assertCanUseManagedBrackets();
     if (!this._provider) notImplemented("placeBracketOrder");
     const groupId = input.entry.groupId ?? makeId();
     const ack = await this._provider.placeBracketOrder({