@pie-players/pie-calculator-cortex 0.3.68

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/index.js'
+export {}

package/dist/index.js

@@ -0,0 +1,63 @@
+import { i as d, n as l, o as u, r as p, s as t } from "./chunks/settings-C0zxv5EL.js";
+var h = class {
+  providerId = "cortex";
+  providerName = "PIE Open-Source Calculator";
+  supportedTypes = [
+    "basic",
+    "scientific",
+    "graphing"
+  ];
+  version = "1";
+  initialized = !1;
+  destroyed = !1;
+  instances = /* @__PURE__ */ new Set();
+  onTelemetry;
+  constructor(e = {}) {
+    this.onTelemetry = e.onTelemetry;
+  }
+  async initialize(e = {}) {
+    if (!this.initialized) {
+      if (this.destroyed) throw new t("worker-unavailable", "This calculator provider has been destroyed.", { recoverable: !1 });
+      if (typeof window > "u" || typeof document > "u") throw new t("worker-unavailable", "Cortex calculators can only be initialized in a browser.", { recoverable: !1 });
+      if (typeof Worker > "u") throw new t("worker-unavailable", "This browser does not support module workers.", { recoverable: !1 });
+      this.onTelemetry = e.onTelemetry ?? this.onTelemetry, this.initialized = !0;
+    }
+  }
+  async createCalculator(e, r, s = {}) {
+    if (this.initialized || await this.initialize(), !this.supportsType(e)) throw new t("unsupported-expression", `Cortex does not support calculator type: ${e}.`);
+    if (!(r instanceof HTMLElement)) throw new t("invalid-state", "A valid HTML container is required.");
+    const o = l(e, s), { createCortexCalculator: a } = await import("./chunks/runtime-BiXEoJDs.js"), i = a(this, r, o, this.onTelemetry, (n) => this.instances.delete(n));
+    return this.instances.add(i), i;
+  }
+  supportsType(e) {
+    return this.supportedTypes.includes(e);
+  }
+  destroy() {
+    if (!this.destroyed) {
+      this.destroyed = !0;
+      for (const e of [...this.instances]) e.destroy();
+      this.instances.clear(), this.initialized = !1, this.onTelemetry = void 0;
+    }
+  }
+  getCapabilities() {
+    return {
+      supportsHistory: !0,
+      supportsGraphing: !0,
+      supportsExpressions: !0,
+      canExport: !0,
+      maxPrecision: 21,
+      inputMethods: [
+        "keyboard",
+        "mouse",
+        "touch"
+      ]
+    };
+  }
+};
+export {
+  t as CortexCalculatorError,
+  h as CortexCalculatorProvider,
+  p as cortexDutchMessages,
+  d as cortexEnglishMessages,
+  u as localeDirection
+};

package/dist/src/CalculatorView.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/dist/src/GraphView.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/dist/src/Icon.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/dist/src/Keypad.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/dist/src/MathFieldInput.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/dist/src/calculator-controller.d.ts

@@ -0,0 +1,65 @@
+import { CalculationHistoryEntry, CalculatorState } from '@pie-players/pie-calculator';
+import { CortexCalculatorErrorCode } from './errors.js';
+import { ResolvedCortexSettings } from './settings.js';
+import { CortexAngleMode, CortexGraphState, CortexGraphViewport, CortexOuterCalculatorState } from './types.js';
+import { SampledSeries } from './worker-protocol.js';
+export interface CortexCalculatorSnapshot {
+    readonly inputLatex: string;
+    readonly result: string;
+    readonly errorCode: CortexCalculatorErrorCode | null;
+    readonly busy: boolean;
+    readonly graphUpdating: boolean;
+    readonly history: readonly CalculationHistoryEntry[];
+    readonly angleMode: CortexAngleMode;
+    readonly graph: CortexGraphState | null;
+    readonly series: readonly SampledSeries[];
+    readonly focusRequest: number;
+    readonly resizeRequest: number;
+}
+type Subscriber = (snapshot: CortexCalculatorSnapshot) => void;
+type TelemetryCallback = (eventName: string, payload?: Record<string, unknown>) => void | Promise<void>;
+export declare class CortexCalculatorController {
+    readonly settings: ResolvedCortexSettings;
+    private readonly onTelemetry?;
+    private readonly subscribers;
+    private readonly mainEngine;
+    private evaluationClient;
+    private destroyed;
+    private operationGeneration;
+    private currentAngleMode;
+    private inputLatex;
+    private result;
+    private errorCode;
+    private busy;
+    private inFlightEvaluations;
+    private graphUpdating;
+    private history;
+    private graph;
+    private series;
+    private focusRequest;
+    private resizeRequest;
+    constructor(settings: ResolvedCortexSettings, onTelemetry?: TelemetryCallback | undefined);
+    private effectiveSettings;
+    getSnapshot(): CortexCalculatorSnapshot;
+    private publish;
+    private telemetry;
+    subscribe(subscriber: Subscriber): () => void;
+    getValue(): string;
+    setValue(latex: string): void;
+    setGraphExpression(id: string, latex: string): void;
+    addGraphExpression(): void;
+    removeGraphExpression(id: string): void;
+    toggleGraphExpression(id: string): void;
+    setAngleMode(mode: CortexAngleMode): void;
+    evaluate(latex?: string): Promise<string>;
+    sampleGraph(viewport: CortexGraphViewport, pixelWidth: number): Promise<void>;
+    clear(): void;
+    getHistory(): CalculationHistoryEntry[];
+    clearHistory(): void;
+    exportState(): CortexOuterCalculatorState;
+    importState(state: CalculatorState): void;
+    requestFocus(): void;
+    requestResize(): void;
+    destroy(): void;
+}
+export {};

package/dist/src/cortex-provider.d.ts

@@ -0,0 +1,18 @@
+import { Calculator, CalculatorProvider, CalculatorProviderCapabilities, CalculatorType } from '@pie-players/pie-calculator';
+import { CortexCalculatorProviderConfig, CortexCalculatorProviderInit } from './types.js';
+export declare class CortexCalculatorProvider implements CalculatorProvider {
+    readonly providerId = "cortex";
+    readonly providerName = "PIE Open-Source Calculator";
+    readonly supportedTypes: CalculatorType[];
+    readonly version = "1";
+    private initialized;
+    private destroyed;
+    private readonly instances;
+    private onTelemetry;
+    constructor(config?: CortexCalculatorProviderInit);
+    initialize(config?: CortexCalculatorProviderInit): Promise<void>;
+    createCalculator(type: CalculatorType, container: HTMLElement, config?: CortexCalculatorProviderConfig): Promise<Calculator>;
+    supportsType(type: CalculatorType): boolean;
+    destroy(): void;
+    getCapabilities(): CalculatorProviderCapabilities;
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,10 @@
+export type CortexCalculatorErrorCode = "invalid-expression" | "unsupported-expression" | "expression-too-complex" | "evaluation-timeout" | "invalid-state" | "worker-unavailable";
+export declare class CortexCalculatorError extends Error {
+    readonly code: CortexCalculatorErrorCode;
+    readonly recoverable: boolean;
+    constructor(code: CortexCalculatorErrorCode, message: string, options?: {
+        recoverable?: boolean;
+        cause?: unknown;
+    });
+}
+export declare function asCortexError(error: unknown, fallbackCode: CortexCalculatorErrorCode, fallbackMessage: string): CortexCalculatorError;

package/dist/src/evaluation-client.d.ts

@@ -0,0 +1,26 @@
+import { ResolvedCortexSettings } from './settings.js';
+import { CortexGraphViewport } from './types.js';
+import { EvaluationResult, SampledSeries } from './worker-protocol.js';
+export declare class EvaluationClient {
+    private settings;
+    private worker;
+    private readonly pending;
+    private readonly instanceId;
+    private nextRequestId;
+    private generation;
+    private destroyed;
+    constructor(settings: ResolvedCortexSettings);
+    updateSettings(settings: ResolvedCortexSettings): void;
+    private workerSettings;
+    private ensureWorker;
+    private readonly handleMessage;
+    private readonly handleWorkerError;
+    private resetWorker;
+    private request;
+    evaluate(latex: string): Promise<EvaluationResult>;
+    sample(expressions: Array<{
+        id: string;
+        latex: string;
+    }>, viewport: CortexGraphViewport, pixelWidth: number): Promise<SampledSeries[]>;
+    destroy(): void;
+}

package/dist/src/evaluation-engine.d.ts

@@ -0,0 +1,9 @@
+import { ResolvedCortexSettings } from './settings.js';
+import { CortexGraphViewport } from './types.js';
+import { EvaluationResult, SampledSeries, WorkerEvaluationSettings } from './worker-protocol.js';
+export declare function workerSettingsToResolved(type: "basic" | "scientific" | "graphing", settings: WorkerEvaluationSettings): ResolvedCortexSettings;
+export declare function evaluateLatex(type: "basic" | "scientific" | "graphing", latex: string, settings: WorkerEvaluationSettings): EvaluationResult;
+export declare function sampleLatex(expressions: Array<{
+    id: string;
+    latex: string;
+}>, viewport: CortexGraphViewport, pixelWidth: number, settings: WorkerEvaluationSettings): SampledSeries[];

package/dist/src/evaluation-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/function-policy.d.ts

@@ -0,0 +1,15 @@
+import { ComputeEngine, Expression } from '@cortex-js/compute-engine';
+import { ResolvedCortexSettings } from './settings.js';
+export interface EditBufferInspection {
+    readonly latex: string;
+    readonly empty: boolean;
+}
+export interface ValidatedExpression {
+    readonly latex: string;
+    readonly expression: Expression;
+    readonly nodeCount: number;
+    readonly depth: number;
+}
+export declare function inspectEditBuffer(latex: string): EditBufferInspection;
+export declare function unwrapGraphExpression(latex: string): string;
+export declare function validateExpression(engine: ComputeEngine, latex: string, settings: ResolvedCortexSettings): ValidatedExpression;

package/dist/src/icons.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Icon geometry for the tool's glyph-faced buttons.
+ *
+ * Paths rather than font characters: `⌫` (U+232B) is the face a backspace button
+ * wants and the one least likely to be in a host's font stack, and a missing glyph
+ * renders as a notdef box — a control with no legible face at all. The arrows and
+ * math signs elsewhere in this package stay as text, since those code points are
+ * in every font a browser will fall back to.
+ *
+ * Drawn on a 24x24 grid and stroked in `currentColor`, so a button's own colour
+ * carries the icon — including under forced colours, where these buttons take
+ * `ButtonText`.
+ */
+export declare const ICON_VIEW_BOX = "0 0 24 24";
+/** Stroke geometry shared by every icon here. */
+export declare const ICON_STROKE: {
+    readonly fill: "none";
+    readonly stroke: "currentColor";
+    readonly "stroke-width": "1.75";
+    readonly "stroke-linecap": "round";
+    readonly "stroke-linejoin": "round";
+};
+/**
+ * A key with a cross in it, pointing at what it deletes. The point sits at x=4 so
+ * the shape reads as directional at 20px, which a symmetrical box does not.
+ */
+export declare const BACKSPACE_ICON: string[];
+/**
+ * A cross in a circle — the affordance a browser puts in its own search fields for
+ * exactly this, and deliberately not the bare cross the tool shell's close button
+ * uses, which sits a few pixels away in the same panel.
+ */
+export declare const CLEAR_ICON: string[];

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { CortexCalculatorProvider } from './cortex-provider.js';
+export { cortexDutchMessages, cortexEnglishMessages, localeDirection, } from './localization.js';
+export { CortexCalculatorError, type CortexCalculatorErrorCode, } from './errors.js';
+export type { CortexAngleMode, CortexCalculatorMessageKey, CortexCalculatorMessageOverrides, CortexCalculatorMessages, CortexCalculatorProviderConfig, CortexCalculatorProviderInit, CortexCalculatorSettings, CortexCalculatorState, CortexCalculatorStateV1, CortexFunctionId, CortexGraphExpressionState, CortexGraphLineStyle, CortexGraphSettings, CortexGraphState, CortexGraphViewport, CortexTextDirection, } from './types.js';

package/dist/src/keypad-layouts.d.ts

@@ -0,0 +1,70 @@
+import { CortexCalculatorLocalization } from './localization.js';
+import { ResolvedCortexSettings } from './settings.js';
+import { CortexCalculatorMessageKey, CortexFunctionId } from './types.js';
+/**
+ * The keypad this package renders itself.
+ *
+ * It is not MathLive's virtual keyboard, and that is deliberate. MathLive's is a
+ * viewport-fixed singleton whose keycaps are `div[tabindex="-1"]` with no `role`,
+ * whose toggle carries `role="button"` with no `tabindex`, and which therefore
+ * contains zero focusable elements — it cannot be opened or operated by keyboard
+ * or switch access at all. Its `container` setter also throws inside an iframe
+ * (`VirtualKeyboardProxy`), which is how assessments are commonly delivered. So
+ * the layouts live here as data and render as real buttons.
+ *
+ * `visualLabel` is what a learner sees. Keys labelled with a word carry that word
+ * inside their accessible name (WCAG 2.5.3 Label in Name, and what voice control
+ * speaks); keys labelled with a glyph are named freely.
+ *
+ * `requires` gates a key on `settings.allowedFunctions`. A host may narrow that
+ * set, and `validateExpression` throws `unsupported-expression` for anything
+ * outside it — so an ungated keypad would offer keys that raise a `role="alert"`
+ * error when pressed.
+ */
+export interface KeypadKey {
+    /** Stable id, used for keyed iteration and the roving tab index. */
+    readonly id: string;
+    /** LaTeX handed to the mathfield, `#0` marking where the caret lands. */
+    readonly latex: string;
+    /** Rendered as the key's face. `math` is typeset by MathLive, `text` is not. */
+    readonly visualLabel: string;
+    readonly labelKind: "math" | "text" | "glyph";
+    /** Message key for the accessible name. */
+    readonly nameKey: CortexCalculatorMessageKey;
+    readonly nameValues?: Readonly<Record<string, string | number>>;
+    /** Key class, which drives grouping and emphasis rather than decoration. */
+    readonly role: "digit" | "operator" | "function" | "commit" | "edit";
+    /** Omit the key unless every listed capability is allowed. */
+    readonly requires?: readonly CortexFunctionId[];
+    /** Basic mode rejects constants outright (`validateSymbol`). */
+    readonly scientificOnly?: boolean;
+    /**
+     * Grid column to place the key in, 1-based over the five key columns, instead
+     * of the position its index implies. The commit key uses it to hold the same
+     * corner on a short row as it does on a full one.
+     */
+    readonly column?: number;
+}
+export interface KeypadLayer {
+    readonly id: string;
+    readonly labelKey: CortexCalculatorMessageKey;
+    readonly rows: readonly (readonly KeypadKey[])[];
+}
+/**
+ * The layers for one calculator, already filtered to what the host permits.
+ *
+ * Scientific stacks its functions in a *second layer* rather than extra rows. The
+ * shipped panels are 380x500 basic, 380x560 scientific and 720x660 graphing, with a
+ * 480px floor for the first two (see `registrations/calculator.ts`). Row count is a
+ * layout budget rather than a target-size one: keys hold 44px from a token whose
+ * value the density tiers in `CalculatorView.svelte` step down only in a panel too
+ * short for it, so an extra row costs panel height at every size that ships. Eight
+ * rows in one layer would put the keypad 250px past the floor, which is a scroll to
+ * reach `sin`.
+ *
+ * Four rows is the budget; the graphing layer spends five because it carries the
+ * five graph keys as well. Both fit the shipped panels with no scroll in either
+ * axis, and the e2e suite measures every layer at both the size the panel opens at
+ * and its resizable minimum.
+ */
+export declare function keypadLayers(settings: ResolvedCortexSettings, localization: CortexCalculatorLocalization): readonly KeypadLayer[];

package/dist/src/localization.d.ts

@@ -0,0 +1,35 @@
+import { CortexCalculatorErrorCode } from './errors.js';
+import { CortexCalculatorMessageKey, CortexCalculatorMessageOverrides, CortexCalculatorMessages, CortexGraphLineStyle, CortexTextDirection } from './types.js';
+/**
+ * The decimal separator this locale writes, `.` or `,`.
+ *
+ * One resolver for the whole package: the mathfield class is configured with it,
+ * the keypad's separator key is labelled with it, and a displayed result is
+ * punctuated with it, so a tapped key, a typed character and an answer all agree.
+ */
+export declare function localeDecimalSeparator(locale: string): "." | ",";
+export declare function localeDirection(locale: string): CortexTextDirection;
+export interface CortexCalculatorLocalization {
+    readonly locale: string;
+    readonly direction: CortexTextDirection;
+    readonly messages: CortexCalculatorMessages;
+    t(key: CortexCalculatorMessageKey, values?: Readonly<Record<string, string | number>>): string;
+    formatNumber(value: number, maximumSignificantDigits?: number): string;
+    /**
+     * Punctuate an already-formatted result for this locale.
+     *
+     * A separator swap, not a reformat. `formatted` carries the host's
+     * `displayPrecision` and, past the exponential thresholds, an exponent
+     * (`2.432902008e+18`); handing that to `Intl.NumberFormat` would re-round it to
+     * `maximumSignificantDigits` and expand the exponent into nineteen digits. The
+     * model value keeps `.` -- `getResult`, the history entries and the serialized
+     * state are read back by hosts and across locales, so only the display is
+     * punctuated.
+     */
+    formatResult(text: string): string;
+    errorMessage(code: CortexCalculatorErrorCode): string;
+    lineStyle(style: CortexGraphLineStyle): string;
+}
+export declare function createCortexLocalization(locale: string, overrides?: CortexCalculatorMessageOverrides, direction?: CortexTextDirection | "auto"): CortexCalculatorLocalization;
+export declare const cortexEnglishMessages: Readonly<CortexCalculatorMessages>;
+export declare const cortexDutchMessages: Readonly<CortexCalculatorMessages>;

package/dist/src/mathlive-runtime.d.ts

@@ -0,0 +1,17 @@
+import { MathfieldElement } from 'mathlive';
+import { CortexCalculatorLocalization, localeDecimalSeparator } from './localization.js';
+interface MathfieldSettings {
+    locale: string;
+    decimalSeparator: "." | ",";
+}
+/**
+ * Point the mathfield class at this calculator's locale, and return the release
+ * that puts the page's own setting back.
+ *
+ * Idempotent per owner: re-acquiring only moves ownership, so a caller that
+ * acquires on every focus does not rebuild anything.
+ */
+export declare function acquireMathfieldSettings(owner: symbol, localization: CortexCalculatorLocalization, mathfieldConstructor: MathfieldSettings): () => void;
+/** Which decimal separator a locale writes, exposed for the keypad's own key. */
+export { localeDecimalSeparator as mathfieldDecimalSeparator };
+export declare function configureMathfield(mathfield: MathfieldElement, label: string, restrictedMode: boolean): void;

package/dist/src/runtime.d.ts

@@ -0,0 +1,5 @@
+import { Calculator, CalculatorProvider } from '@pie-players/pie-calculator';
+import { ResolvedCortexSettings } from './settings.js';
+type TelemetryCallback = (eventName: string, payload?: Record<string, unknown>) => void | Promise<void>;
+export declare function createCortexCalculator(provider: CalculatorProvider, container: HTMLElement, settings: ResolvedCortexSettings, onTelemetry: TelemetryCallback | undefined, onDestroy: (calculator: Calculator) => void): Calculator;
+export {};

package/dist/src/settings.d.ts

@@ -0,0 +1,29 @@
+import { CalculatorType } from '@pie-players/pie-calculator';
+import { CortexCalculatorLocalization } from './localization.js';
+import { CortexAngleMode, CortexCalculatorProviderConfig, CortexFunctionId, CortexGraphViewport } from './types.js';
+export declare const CORTEX_INPUT_LENGTH_LIMIT = 1024;
+export declare const CORTEX_AST_NODE_LIMIT = 256;
+export declare const CORTEX_AST_DEPTH_LIMIT = 32;
+export declare const CORTEX_GRAPH_EXPRESSION_LIMIT = 6;
+export declare const CORTEX_GRAPH_SAMPLE_LIMIT = 1200;
+export interface ResolvedCortexSettings {
+    readonly type: CalculatorType;
+    readonly angleMode: CortexAngleMode;
+    readonly calculationPrecision: number;
+    readonly displayPrecision: number;
+    readonly historyLimit: number;
+    readonly evaluationTimeLimitMs: number;
+    readonly allowedFunctions: ReadonlySet<CortexFunctionId>;
+    readonly allowClipboard: boolean;
+    readonly restrictedMode: boolean;
+    readonly locale: string;
+    readonly theme: "light" | "dark" | "auto";
+    readonly localization: CortexCalculatorLocalization;
+    readonly graph: {
+        readonly viewport: CortexGraphViewport;
+        readonly showAxes: boolean;
+        readonly showGrid: boolean;
+    };
+}
+export declare function resolveCortexSettings(type: CalculatorType, config?: CortexCalculatorProviderConfig): ResolvedCortexSettings;
+export declare function isCortexFunctionId(value: unknown): value is CortexFunctionId;

package/dist/src/state-codec.d.ts

@@ -0,0 +1,10 @@
+import { ComputeEngine } from '@cortex-js/compute-engine';
+import { CalculationHistoryEntry, CalculatorState, CalculatorType } from '@pie-players/pie-calculator';
+import { ResolvedCortexSettings } from './settings.js';
+import { CortexCalculatorStateV1, CortexGraphState, CortexOuterCalculatorState } from './types.js';
+export interface DecodedCortexState {
+    readonly state: CortexCalculatorStateV1;
+    readonly history: CalculationHistoryEntry[];
+}
+export declare function decodeCortexState(value: CalculatorState, type: CalculatorType, engine: ComputeEngine, settings: ResolvedCortexSettings): DecodedCortexState;
+export declare function encodeCortexState(type: CalculatorType, inputLatex: string, history: readonly CalculationHistoryEntry[], settings: ResolvedCortexSettings, angleMode: "degree" | "radian", graph?: CortexGraphState): CortexOuterCalculatorState;

package/dist/src/types.d.ts

@@ -0,0 +1,157 @@
+import { CalculatorProviderConfig, CalculatorProviderInit, CalculatorState, CalculatorType } from '@pie-players/pie-calculator';
+export type CortexAngleMode = "degree" | "radian";
+export type CortexFunctionId = "square-root" | "power" | "root" | "exponential" | "natural-log" | "common-log" | "log-base-n" | "sine" | "cosine" | "tangent" | "inverse-sine" | "inverse-cosine" | "inverse-tangent" | "absolute-value" | "factorial";
+export interface CortexGraphViewport {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+export interface CortexGraphSettings {
+    viewport?: CortexGraphViewport;
+    showAxes?: boolean;
+    showGrid?: boolean;
+}
+export type CortexTextDirection = "ltr" | "rtl";
+export interface CortexCalculatorMessages {
+    basicCalculator: string;
+    scientificCalculator: string;
+    graphingCalculator: string;
+    expressionLabel: string;
+    angleMode: string;
+    degrees: string;
+    radians: string;
+    calculate: string;
+    calculating: string;
+    backspace: string;
+    clear: string;
+    result: string;
+    calculationHistory: string;
+    clearHistory: string;
+    virtualKeyboardBasic: string;
+    virtualKeyboardScientific: string;
+    virtualKeyboardGraphing: string;
+    keypad: string;
+    keypadLayer: string;
+    angleModeDegreesShort: string;
+    angleModeRadiansShort: string;
+    angleModeChanged: string;
+    inserted: string;
+    keySine: string;
+    keyCosine: string;
+    keyTangent: string;
+    keyInverseSine: string;
+    keyInverseCosine: string;
+    keyInverseTangent: string;
+    keyNaturalLog: string;
+    keyCommonLog: string;
+    keyLogBaseN: string;
+    keyFraction: string;
+    keySquareRoot: string;
+    keyNthRoot: string;
+    keyPower: string;
+    keySquared: string;
+    keyCubed: string;
+    keyExponential: string;
+    keyAbsoluteValue: string;
+    keyFactorial: string;
+    keyPi: string;
+    keyEuler: string;
+    keyPercent: string;
+    keyOpenParenthesis: string;
+    keyCloseParenthesis: string;
+    keyDecimalSeparator: string;
+    keyDigit: string;
+    keyAdd: string;
+    keySubtract: string;
+    keyMultiply: string;
+    keyDivide: string;
+    keyVariableX: string;
+    graphExpressions: string;
+    graphExpressionLabel: string;
+    seriesDescription: string;
+    showExpression: string;
+    hideExpression: string;
+    show: string;
+    hide: string;
+    removeExpression: string;
+    remove: string;
+    addExpression: string;
+    graph: string;
+    viewportControls: string;
+    zoomIn: string;
+    zoomOut: string;
+    panLeft: string;
+    panRight: string;
+    panUp: string;
+    panDown: string;
+    resetView: string;
+    updatingGraph: string;
+    graphSummary: string;
+    viewportSummary: string;
+    seriesSummary: string;
+    keyboardGraphTrace: string;
+    keyboardTrace: string;
+    series: string;
+    seriesOption: string;
+    previousPoint: string;
+    nextPoint: string;
+    tracePoint: string;
+    noSampledPoint: string;
+    lineStyleSolid: string;
+    lineStyleDashed: string;
+    lineStyleDotted: string;
+    errorInvalidExpression: string;
+    errorUnsupportedExpression: string;
+    errorExpressionTooComplex: string;
+    errorEvaluationTimeout: string;
+    errorInvalidState: string;
+    errorWorkerUnavailable: string;
+}
+export type CortexCalculatorMessageKey = keyof CortexCalculatorMessages;
+export type CortexCalculatorMessageOverrides = Partial<CortexCalculatorMessages>;
+export interface CortexCalculatorSettings extends Record<string, unknown> {
+    angleMode?: CortexAngleMode;
+    calculationPrecision?: number;
+    displayPrecision?: number;
+    historyLimit?: number;
+    evaluationTimeLimitMs?: number;
+    allowedFunctions?: readonly CortexFunctionId[];
+    allowClipboard?: boolean;
+    /** Override any package-owned visible or assistive label for this instance. */
+    messages?: CortexCalculatorMessageOverrides;
+    /** Derive direction from `locale` by default; override only for host policy. */
+    direction?: CortexTextDirection | "auto";
+    graph?: CortexGraphSettings;
+}
+export type CortexCalculatorProviderInit = Pick<CalculatorProviderInit, "onTelemetry">;
+export interface CortexCalculatorProviderConfig extends Omit<CalculatorProviderConfig, "settings"> {
+    settings?: CortexCalculatorSettings;
+}
+export type CortexGraphLineStyle = "solid" | "dashed" | "dotted";
+export interface CortexGraphExpressionState {
+    id: string;
+    latex: string;
+    colorIndex: number;
+    lineStyle: CortexGraphLineStyle;
+    hidden: boolean;
+}
+export interface CortexGraphState {
+    viewport: CortexGraphViewport;
+    expressions: CortexGraphExpressionState[];
+}
+export interface CortexCalculatorStateV1 {
+    schema: "pie-calculator-cortex";
+    version: 1;
+    type: CalculatorType;
+    angleMode: CortexAngleMode;
+    calculationPrecision: number;
+    displayPrecision: number;
+    inputLatex: string;
+    graph?: CortexGraphState;
+}
+export type CortexCalculatorState = CortexCalculatorStateV1;
+export type CortexOuterCalculatorState = CalculatorState & {
+    provider: "cortex";
+    providerState: CortexCalculatorState;
+};