@svgrid/enterprise 3.0.2 → 3.0.3

package/dist/index.js

@@ -1,7 +1,10 @@
 export { setLicenseKey, clearLicenseKey, getLicenseKey, isLicenseKeySet, hasValidLicense, assertEnterpriseLicensed, nudgeEnterprise, checkLicenseKey, 
 // Trial expiry. The built-in card already appears on its own once a trial
 // lapses; these are for hosts that would rather render their own banner.
-isLicenseExpired, getLicenseExpiry, } from './license.js';
+isLicenseExpired, getLicenseExpiry, 
+// Editions. `licenseCovers` is the one most apps want: hide a Suite-only
+// entry point rather than let it nudge.
+licenseCovers, getLicenseEdition, nudgeEnterpriseFor, editionCovers, } from './license.js';
 export { parseLicenseExpiry } from './license-core.js';
 export { exportGrid, copyExportToClipboard, } from './export.js';
 export { default as SvExportMenu } from './SvExportMenu.svelte';
@@ -17,6 +20,12 @@ export { enableSchedulerView, SvGridScheduler } from './scheduler.js';
 // Kanban board view (Pro). `enableBoardView()` registers the renderer so
 // `<SvGrid board={...}>` shows lanes of cards. Config types live in @svgrid/grid.
 export { enableBoardView, SvGridBoard } from './board.js';
+// Gantt view (Pro). `enableGanttView()` registers the renderer so
+// `<SvGrid gantt={...}>` shows a task table beside a time chart. The `gantt`
+// prop and its config types live in @svgrid/grid; the layout model, the
+// planning helpers and the renderer are here. Also its own entry point,
+// `@svgrid/enterprise/gantt`.
+export * from './gantt/index.js';
 // Bulk-action bar over the row selection (Pro). `enableSelectionBar()` registers
 // the renderer so `<SvGrid selectionBar={...}>` floats a bar over the grid while
 // rows are selected. The prop + its config types live in @svgrid/grid.
@@ -30,16 +39,21 @@ export { default as SvGridBulkEditDrawer } from './SvGridBulkEditDrawer.svelte';
 export { enablePivot } from './pivot-enable.js';
 export { enableSheet } from './sheet-enable.js';
 export { createTableRegistry, isValidTableName, resolveTableRange, columnIndexOf, rowCountOf, } from './sheet/tables.js';
+export { TABLE_STYLES, DEFAULT_TABLE_STYLE, NO_TABLE_STYLE, findTableStyle, tableStyleColours, tableStyleLabel, } from './sheet/table-styles.js';
 export { goalSeek, goalSeekCell, } from './sheet/goal-seek.js';
+export { evaluationSteps, printNode, printValue, } from './sheet/evaluate-steps.js';
+export { checkSheet, describeFinding, ERROR_MEANINGS, } from './sheet/error-check.js';
+export { imageCall, isDrawableImageSource } from './sheet/cell-images.js';
+export { livePresence, presenceOnSheet, presenceAnchor, presenceColour, presenceInitials, PRESENCE_COLOURS, } from './sheet/presence.js';
 export { default as SvSheetTabs } from './SvSheetTabs.svelte';
-export { createWorkbook, isValidSheetName, } from './sheet/workbook.js';
+export { createWorkbook, isValidSheetName, cleanIteration, DEFAULT_ITERATION, } from './sheet/workbook.js';
 export { setWorkbook, getWorkbook } from './sheet/shortcuts.js';
 export { createSheetDocument, } from './sheet/document.js';
 export { shiftRect, shiftRects, subtractRect, rectContains, rectsIntersect, remapNotes, lineShift } from './sheet/rects.js';
-export { isLocked, rectsHaveLocked, rectsMixLocked, PROTECTED_MESSAGE } from './sheet/protection.js';
-export { commentAt, withComment, listComments, nextComment } from './sheet/comments.js';
+export { isLocked, cellLocked, inEditRange, rectsHaveLocked, rectsMixLocked, PROTECTED_MESSAGE, PROTECTION_PERMISSIONS, defaultProtection, copyProtection, newEditRangeId, parseRangeText, rangeText, } from './sheet/protection.js';
+export { commentAt, withComment, withThread, threadAt, threadOf, threadText, notesOf, isThreaded, listComments, nextComment, } from './sheet/comments.js';
 export { ruleAt, rulesIn, checkEntry, listChoices, shiftValidation, removeValidation, describeRule, dateValue, validationId, DEFAULT_ALERT_MESSAGE, OPERATOR_LABELS, } from './sheet/validation.js';
-export { ruleStats, evaluateCf, shiftCf, removeCf, cfIn, describeCf, scaleColor, iconIndex, hasStyle, cfId, CF_PRESET_STYLES, COLOR_SCALES, DATA_BAR_COLOR, } from './sheet/conditional-formats.js';
+export { ruleStats, evaluateCf, shiftCf, removeCf, cfIn, describeCf, scaleColor, iconIndex, hasStyle, cfId, CF_PRESET_STYLES, COLOR_SCALES, DATA_BAR_COLOR, DATA_BAR_NEGATIVE_COLOR, } from './sheet/conditional-formats.js';
 export { mergePlan, unmergePlan, mergeDropsValues, mergesIn, mergeAt as sheetMergeAt, isCoveredCell, selectionMerged, toGridMerges, sortBlockedByMerges, reorderMerges, normalRect, } from './sheet/merges.js';
 export { distinctValues, hiddenRowsFor, passesFilter, isFiltering, withColumnFilter, valuesFilter, shiftAutoFilter, describeFilter, } from './sheet/auto-filter.js';
 export { splitText, textToColumns, guessDelimiter, findDuplicates, removeDuplicates, } from './sheet/transforms.js';
@@ -67,15 +81,34 @@ export { default as SvSheetNameManager } from './SvSheetNameManager.svelte';
 export { default as SvSheetGoalSeek } from './SvSheetGoalSeek.svelte';
 export { default as SvSheetTextToColumns } from './SvSheetTextToColumns.svelte';
 export { default as SvSheetRemoveDuplicates } from './SvSheetRemoveDuplicates.svelte';
+export { default as SvSheetSort } from './SvSheetSort.svelte';
+export { sortOrder, guessHeaderRow } from './sheet/sort.js';
+export { documentToXlsxParts, documentFromXlsxParts, documentToXlsx, documentFromXlsx } from './sheet/xlsx-document.js';
+export { csvText, csvRows, guessCsvSeparator, sheetStateFromCsv } from './sheet/csv.js';
+export { sheetStateFromOds, documentFromOds, documentToOds, documentToOdsParts, formulaFromOdf, formulaToOdf } from './sheet/ods-document.js';
+export { sheetStateFromXls, documentFromXls, documentToXls, isXlsFile } from './sheet/xls-document.js';
+export { formulaFromRpn, rpnFromFormula } from './sheet/xls-formula.js';
+export { documentFromFile, readSpreadsheetFile } from './sheet/open-file.js';
+export { defaultPageSetup, copyPageSetup, marginPresetOf, shiftPageSetup, marginsCss, MARGIN_PRESETS, PAPER_SIZES, } from './sheet/page-setup.js';
+export { sheetPrintHtml, printAreas } from './sheet/print.js';
+export { sheetCellsFromRows, cellTextOf } from './sheet/from-rows.js';
+export { builtinEngine } from './sheet/engine.js';
+export { chartSpecOf, chartFromRange, shiftObject, shiftObjects, objectAt, copyObject, objectId, SHEET_CHART_TYPES, } from './sheet/objects.js';
+export { sparklineSeries, sparklineAt, sparklineScale, sparklinesFromRange, clearSparklines, shiftSparkline, shiftSparklines, copySparkline, sparklineId, isColumnLocation, SPARKLINE_TYPES, } from './sheet/sparklines.js';
+export { pivotFields, pivotFieldValues, pivotRecords, filteredRecords, pivotBlock, pivotLayout, pivotDrill, pivotFromRange, pivotWrittenRect, flattenPivotColumns, ALL_VALUES, shiftPivot, shiftPivots, copyPivot, pivotId, SHEET_PIVOT_AGGS, } from './sheet/pivot-range.js';
+export { createDeltaStream, applySheetDelta, partsOfReasons, } from './sheet/delta.js';
+export { linkAt, setLink, removeLink, listLinks, shiftLinks, copyLinks, parseLinkTarget, isSafeLinkTarget, linkTitle, } from './sheet/links.js';
 export { functionCatalog, FUNCTION_GROUPS } from './sheet/function-catalog.js';
 export { parseEntry, completeEntry } from './sheet/entry.js';
 export { cycleReference } from './sheet/edit-keys.js';
 export { RIBBON_TABS, ribbonItems, withDecimals, applyBorders, } from './sheet/ribbon.js';
 export { RIBBON_ICONS, RIBBON_ICON_NAMES } from './sheet/ribbon-icons.js';
 export { THEME_COLOURS, STANDARD_COLOURS, ALL_COLOURS, tint } from './sheet/palette.js';
+export { defaultSheetMessages, defaultSheetTextMessages, defaultDialogMessages, ribbonMessageDefaults, resolveSheetMessages, formatMessage, } from './sheet/messages.js';
+export { provideSheetText, useSheetText } from './sheet-text.js';
 export { default as SvRibbonIcon } from './SvRibbonIcon.svelte';
 export { move, selectRegion, selectLine, applyFormat, toggleFormat, preset, autoSum, structural, switchSheet, gridOf, } from './sheet/shortcuts.js';
-export { compileNumberFormat, formatWithPattern, FORMAT_PRESETS, } from './sheet/number-format.js';
+export { compileNumberFormat, formatWithPattern, FORMAT_PRESETS, FORMAT_CATEGORY_PATTERNS, SPECIAL_FORMATS, formatCategory, accountingPattern, accountingParts, } from './sheet/number-format.js';
 export { createFormatStore, entryToStyle, borderShadows, } from './sheet/format-store.js';
 export { createNames, isValidName, } from './sheet/names.js';
 export { suggestFunctions, applySuggestion, signatureAt, partialAt, SIGNATURES, } from './sheet/autocomplete.js';
@@ -87,6 +120,7 @@ export { setFormatTarget, getFormatTarget, setFormatDialogHandler, } from './she
 export { parseFormula, parse as parseFormulaTokens } from './sheet/parse.js';
 export { tokenize as tokenizeFormula } from './sheet/tokenize.js';
 export { evaluate as evaluateFormula, formatValue as formatCellValue, } from './sheet/evaluate.js';
+export { ARRAY_FUNCTIONS } from './sheet/packs/array.js';
 export { FUNCTIONS as SHEET_FUNCTIONS, withCustomFunctions, } from './sheet/functions.js';
 export { translateFormula, fixupReferences, renameSheetReferences, formatFormula, referenceSpans, REFERENCE_COLOURS, } from './sheet/refs.js';
 export { createDependencyGraph as createSheetDependencyGraph, precedentsOf, cellKey, parseCellKey, } from './sheet/deps.js';
@@ -114,7 +148,10 @@ export { dismissUnlicensedNudge } from './watermark.js';
 export { showUpgradePrompt, dismissUpgradePrompt, } from './upgrade-prompt.js';
 export { createPivotModel, pivotAggregators, filterCollapsedPivotRows, } from './pivot.js';
 export { titleCase, resolveIdField, schemaToColumns, schemaToFormFields, isFieldHidden, validateField, applyComputed, validateEntity, } from './schema.js';
-export { planQuery, coerce, createInMemoryDataSource, createKitDataSource, createKitHandlers, createSqlDataSource, planToSql, } from './sveltekit/index.js';
+export { planQuery, coerce, createInMemoryDataSource, createKitDataSource, createKitHandlers, createSqlDataSource, planToSql, BUILTIN_AGGREGATORS, } from './sveltekit/index.js';
+// Server-Side Row Model: lazy server-side grouping and tree data over the
+// free grid's datasource contract. Also available as '@svgrid/enterprise/server'.
+export { createServerRowModel, serverRowModelRows, serverRowModelNav, serverGroupText, defaultServerGroupMessages, resolveServerGroupMessages, GRAND_TOTAL_ROW_ID, GROUP_TOTAL_ROW_ID_PREFIX, createServerSelectionModel, buildPivotResultColumns, adaptCallbackDatasource, toCallbackDatasource, fromCallbackRequest, toCallbackRequest, fromCallbackFilterModel, toCallbackFilterModel, fromCallbackSelectionState, toCallbackSelectionState, isCallbackSelectionState, createServerGroupModel, serverGroupRows, serverGroupNav, enableServerRowModel, SvGroupCell, SvRowGroupPanel, } from './server/index.js';
 export { createSupabaseDataSource, createRestDataSource, offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, introspectSupabaseTable, listSupabaseTables, createSupabaseRealtime, createRelationLookup, createSupabaseAuth, aggregateRows, chartFieldsFromSchema, normalizeFilters, buildEntitySchema, pickLabelField, linkRelationLabels, withEntityRules, withRelationLabels, reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, } from './sources/index.js';
 export { buildInitialValues, controlKind, editMode, evalValidationRules, fieldState, sectionVisible, hasFieldConditions, rowId, stripHiddenValues, toSubmitValues, validateAll, visibleFormFields, } from './edit-panel.js';
 export { default as SvGridEditPanel } from './SvGridEditPanel.svelte';

package/dist/install.js

@@ -9,10 +9,12 @@ import { aiFilter, aiSmartFill, aiSummarize, aiClassify, aiExport, aiFindAnomali
 import { createPivotModel, } from './pivot.js';
 import { enableSchedulerView } from './scheduler.js';
 import { enableBoardView } from './board.js';
+import { enableGanttView } from './gantt/gantt.js';
 import { enableSelectionBar } from './selection-bar.js';
 import { enableAdvancedFilter } from './advanced-filter-enable.js';
 import { enablePivot } from './pivot-enable.js';
 import { enableSheet } from './sheet-enable.js';
+import { enableServerRowModel } from './server/enable.js';
 /**
  * Augment a SvGridApi instance with Pro methods (`exportData`, `print`,
  * `ai.*`). Mutates and returns the same object so existing references
@@ -44,6 +46,8 @@ export function installEnterprise(api) {
     enableSchedulerView();
     // Register the Kanban board view (no-op without the `board` prop).
     enableBoardView();
+    // Register the Gantt view (no-op without the `gantt` prop).
+    enableGanttView();
     enableSelectionBar();
     // Register the export engine so built-in AI exports (aiExport) can write the
     // enterprise formats (xlsx / pdf / ...); free grids without it get the plan only.
@@ -54,6 +58,9 @@ export function installEnterprise(api) {
     // grid interprets a key itself only when nothing claims it, so a free grid
     // is unaffected.
     enableSheet();
+    // Raise the unlicensed nudge for the server-side row model. No registry to fill -
+    // the model hands the grid ordinary rows - so this only nudges when unlicensed.
+    enableServerRowModel();
     pro.pivot = {
         build: (config) => createPivotModel(pro.getData(), config),
         buildFrom: (data, config) => 
@@ -62,7 +69,7 @@ export function installEnterprise(api) {
         // the caller-side generic enforces.
         createPivotModel(data, config),
     };
-    // Surface the soft-gate state at install time so the watermark appears
+    // Surface the unlicensed state at install time so the watermark appears
     // alongside the grid, not just after the user clicks Export.
     if (!isLicenseKeySet())
         emitUnlicensedNudge();

package/dist/license-core.d.ts

@@ -1,16 +1,32 @@
 export declare const VALID_PREFIX = "SVENTERPRISE-";
+/**
+ * What an order bought. `grid` is the enterprise grid on its own; `suite` adds
+ * the spreadsheet and the Studio. Keys issued before editions existed carry no
+ * edition segment and read as `suite`, so nothing an existing customer already
+ * ships changes when this lands.
+ */
+export type LicenseEdition = 'grid' | 'suite';
+/** The three things an edition can gate. */
+export type LicensedProduct = 'grid' | 'spreadsheet' | 'studio';
+/** Does `edition` cover `product`? Pure, and the only place the answer lives. */
+export declare function editionCovers(edition: LicenseEdition, product: LicensedProduct): boolean;
 export type LicenseStatus = 'unset' | 'invalid' | 'revoked' | 'dev' | 'eval' | 'licensed';
 export type LicenseInfo = {
     status: LicenseStatus;
     /** True when the key permits use (dev / eval / licensed). */
     valid: boolean;
+    /**
+     * What the key covers. Always `suite` for dev and eval keys, so a trial sees
+     * everything, and for any key that names no edition.
+     */
+    edition: LicenseEdition;
     /** Expiry encoded in the key, when it carries one. Undefined otherwise. */
     expiresAt?: Date;
     /**
      * True once `expiresAt` has passed. Deliberately does NOT clear `valid`:
      * an expired trial keeps working and the callers nudge instead. Turning a
      * lapsed key into a hard stop would break a running app on a date boundary,
-     * which is exactly what a soft gate exists to avoid.
+     * which is exactly what the evaluation model exists to avoid.
      */
     expired?: boolean;
 };

package/dist/license-core.js

@@ -4,10 +4,14 @@
 // "what a valid key is," so the two contexts can never drift.
 //
 // This is deliberately NOT crypto (see license.ts). It classifies a key string;
-// callers decide what to do with the result. The Studio is soft-gate only:
+// callers decide what to do with the result. The Studio never blocks:
 // unlicensed use still works, it just nudges.
 import { REVOKED_KEYS } from './revoked.js';
 export const VALID_PREFIX = 'SVENTERPRISE-';
+/** Does `edition` cover `product`? Pure, and the only place the answer lives. */
+export function editionCovers(edition, product) {
+    return edition === 'suite' || product === 'grid';
+}
 /**
  * Pull the expiry out of a key.
  *
@@ -62,12 +66,15 @@ export function parseLicenseExpiry(key) {
 /** Classify a license key string. Pure and side-effect-free.
  *  `now` is injectable so expiry behaviour is testable without faking clocks. */
 export function checkLicenseKey(key, now = new Date()) {
+    // An unusable key reports `suite` rather than a narrower edition on purpose:
+    // callers branch on `valid` first, and an edition on a rejected key would
+    // read as though something had been granted.
     if (key == null || key === '')
-        return { status: 'unset', valid: false };
+        return { status: 'unset', valid: false, edition: 'suite' };
     if (!key.startsWith(VALID_PREFIX))
-        return { status: 'invalid', valid: false };
+        return { status: 'invalid', valid: false, edition: 'suite' };
     if (REVOKED_KEYS.has(key))
-        return { status: 'revoked', valid: false };
+        return { status: 'revoked', valid: false, edition: 'suite' };
     const expiresAt = parseLicenseExpiry(key) ?? undefined;
     // Left undefined rather than false when the key encodes no date, so callers
     // can tell "not expired" apart from "no expiry to check".
@@ -77,5 +84,9 @@ export function checkLicenseKey(key, now = new Date()) {
         : key.startsWith('SVENTERPRISE-EVAL')
             ? 'eval'
             : 'licensed';
-    return { status, valid: true, expiresAt, expired };
+    // Only a paid key can be narrowed: a trial evaluates the whole product, and
+    // `SVENTERPRISE-GRID` is an edition marker rather than a kind, so it lands in
+    // the same segment DEV and EVAL use.
+    const edition = status === 'licensed' && key.startsWith(`${VALID_PREFIX}GRID-`) ? 'grid' : 'suite';
+    return { status, valid: true, edition, expiresAt, expired };
 }

package/dist/license.d.ts

@@ -1,5 +1,6 @@
+import { type LicenseInfo, type LicensedProduct } from './license-core.js';
 import { type EnterpriseFeatureLabel } from './upgrade-prompt.js';
-export { checkLicenseKey, type LicenseInfo, type LicenseStatus } from './license-core.js';
+export { checkLicenseKey, editionCovers, type LicenseInfo, type LicenseStatus, type LicenseEdition, type LicensedProduct, } from './license-core.js';
 export { dismissUnlicensedNudge } from './watermark.js';
 export declare function setLicenseKey(key: string): void;
 export declare function clearLicenseKey(): void;
@@ -21,11 +22,26 @@ export declare function isLicenseExpired(): boolean;
 /** When the current key lapses, or null if it encodes no expiry. */
 export declare function getLicenseExpiry(): Date | null;
 /**
- * Soft-gate a Pro surface: if the current key isn't valid, nudge (watermark +
+ * Gate a Pro surface: if the current key isn't valid, nudge (watermark +
  * one-time console log + a moment-of-intent upgrade card naming `feature`) and
  * return. NEVER throws and NEVER blocks - the feature always runs. This is the
  * gate the Studio uses, and it's safe to call on the server (the nudges no-op
  * without a DOM). Idempotent/self-throttling, so call it freely at chokepoints.
  */
 export declare function nudgeEnterprise(feature?: EnterpriseFeatureLabel): void;
+/**
+ * True when the current key covers `product`. Use it to hide a Suite-only entry
+ * point in your own UI instead of letting it nudge. An unlicensed app returns
+ * false for everything, which keeps "no key" and "wrong edition" on the same
+ * side of the branch for UI purposes.
+ */
+export declare function licenseCovers(product: LicensedProduct): boolean;
+/** The edition the current key names, or null when no usable key is set. */
+export declare function getLicenseEdition(): LicenseInfo['edition'] | null;
+/**
+ * Gate a surface that an edition can exclude. Same contract as
+ * {@link nudgeEnterprise} - never throws, never blocks, safe on the server -
+ * but it also nudges a valid key that simply does not reach this product.
+ */
+export declare function nudgeEnterpriseFor(product: LicensedProduct, feature?: EnterpriseFeatureLabel): void;
 export declare function assertEnterpriseLicensed(feature?: EnterpriseFeatureLabel): void;

package/dist/license.js

@@ -6,7 +6,7 @@
 //
 //   currentKey state                  -> result
 //   ────────────────────────────────────────────────────────────────────
-//   null (no key set)                 -> soft-gate: watermark + console.log,
+//   null (no key set)                 -> evaluation: watermark + console.log,
 //                                        feature still runs
 //   does not start with "SVENTERPRISE-"      -> throws (programmer error)
 //   in REVOKED_KEYS                   -> throws (revoked / leaked / expired)
@@ -15,13 +15,18 @@
 //   an EXPIRED dev/eval key            -> still works, but stops looking
 //                                        licensed: watermark + a one-time
 //                                        console notice naming the expiry date
-//                                        + the upgrade card. Stays a soft gate
+//                                        + the upgrade card. Never blocks,
 //                                        so a trial ending cannot break a build.
 //   any other "SVENTERPRISE-..."             -> works silently (paid production)
-import { checkLicenseKey, VALID_PREFIX } from './license-core.js';
+//
+// Editions cut across that matrix. A paid key names GRID or SUITE (and a key
+// issued before editions existed reads as SUITE). `nudgeEnterpriseFor` is the
+// gate for a surface a GRID key does not reach: same never-blocks contract, with
+// its own console notice saying which edition covers it.
+import { checkLicenseKey, editionCovers, VALID_PREFIX, } from './license-core.js';
 import { emitUnlicensedNudge } from './watermark.js';
 import { showUpgradePrompt } from './upgrade-prompt.js';
-export { checkLicenseKey } from './license-core.js';
+export { checkLicenseKey, editionCovers, } from './license-core.js';
 // The nudge the key silences, on the same subpath as the key: an app that only
 // wants to set its licence imports `@svgrid/enterprise/license` and never
 // pulls the component barrel (the package has no `sideEffects` flag, so a
@@ -30,6 +35,9 @@ export { dismissUnlicensedNudge } from './watermark.js';
 let currentKey = null;
 let noticedDev = false;
 let noticedExpired = false;
+/** One notice per product, not per call site: reaching four Studio seams on a
+ *  Grid key is one licensing fact, not four. */
+const noticedEdition = new Set();
 /** One-time console notice for a trial that has run out. Separate from the
  *  dev/eval notice: that one says "not for production", this one says the
  *  evaluation is over and names the date, which is the actionable part. */
@@ -50,11 +58,13 @@ export function setLicenseKey(key) {
     currentKey = key;
     noticedDev = false;
     noticedExpired = false;
+    noticedEdition.clear();
 }
 export function clearLicenseKey() {
     currentKey = null;
     noticedDev = false;
     noticedExpired = false;
+    noticedEdition.clear();
 }
 export function getLicenseKey() {
     return currentKey;
@@ -84,7 +94,7 @@ export function getLicenseExpiry() {
     return checkLicenseKey(currentKey).expiresAt ?? null;
 }
 /**
- * Soft-gate a Pro surface: if the current key isn't valid, nudge (watermark +
+ * Gate a Pro surface: if the current key isn't valid, nudge (watermark +
  * one-time console log + a moment-of-intent upgrade card naming `feature`) and
  * return. NEVER throws and NEVER blocks - the feature always runs. This is the
  * gate the Studio uses, and it's safe to call on the server (the nudges no-op
@@ -105,11 +115,66 @@ export function nudgeEnterprise(feature) {
         noticeExpired(info);
     showUpgradePrompt(feature, { expired: lapsedTrial });
 }
+/** Human name for a product, for the console notice. */
+const PRODUCT_LABEL = {
+    grid: 'the enterprise grid',
+    spreadsheet: 'the spreadsheet',
+    studio: 'the Studio',
+};
+/** One-time console notice for a feature the current edition does not cover.
+ *  Distinct from the unlicensed nudge: the key is real and paid, it just does
+ *  not reach this far, so the actionable part is which edition to move to. */
+function noticeEdition(product) {
+    if (noticedEdition.has(product))
+        return;
+    noticedEdition.add(product);
+    // eslint-disable-next-line no-console
+    console.info(`@svgrid/enterprise: your Grid license does not cover ${PRODUCT_LABEL[product]}. ` +
+        'Everything still works, but the watermark and upgrade notice stay until the ' +
+        'license is upgraded to Suite. Contact sales@jqwidgets.com or see ' +
+        'https://svgrid.com/pricing');
+}
+/**
+ * True when the current key covers `product`. Use it to hide a Suite-only entry
+ * point in your own UI instead of letting it nudge. An unlicensed app returns
+ * false for everything, which keeps "no key" and "wrong edition" on the same
+ * side of the branch for UI purposes.
+ */
+export function licenseCovers(product) {
+    const info = checkLicenseKey(currentKey);
+    return info.valid && editionCovers(info.edition, product);
+}
+/** The edition the current key names, or null when no usable key is set. */
+export function getLicenseEdition() {
+    const info = checkLicenseKey(currentKey);
+    return info.valid ? info.edition : null;
+}
+/**
+ * Gate a surface that an edition can exclude. Same contract as
+ * {@link nudgeEnterprise} - never throws, never blocks, safe on the server -
+ * but it also nudges a valid key that simply does not reach this product.
+ */
+export function nudgeEnterpriseFor(product, feature) {
+    const info = checkLicenseKey(currentKey);
+    const covered = info.valid && editionCovers(info.edition, product);
+    if (covered && !info.expired)
+        return;
+    // A key that is valid, unexpired and merely out of edition is a different
+    // message from an unlicensed or lapsed one, so it gets its own notice. The
+    // watermark and the card are the same either way.
+    const outOfEdition = info.valid && info.expired !== true && !covered;
+    emitUnlicensedNudge();
+    if (outOfEdition)
+        noticeEdition(product);
+    else if (info.valid && info.expired === true)
+        noticeExpired(info);
+    showUpgradePrompt(feature, { expired: info.valid && info.expired === true });
+}
 export function assertEnterpriseLicensed(feature) {
     const info = checkLicenseKey(currentKey);
     switch (info.status) {
         case 'unset':
-            // Soft-gate: the feature still runs, but the user gets a watermark +
+            // Evaluation: the feature still runs, but the user gets a watermark +
             // a one-time console.log nudge directing them to pricing, plus a
             // contextual moment-of-intent upgrade card naming the feature they
             // just reached for.