@texuli/blocks 0.0.0-stage → 0.1.0-next.0

package/dist/interactive/engine.js

@@ -0,0 +1,12 @@
+/**
+ * `@texuli/blocks/interactive/engine` — Svelte-free interactive parsers + formula.
+ * Prefer `@texuli/blocks/formula` when only the calculator AST is needed.
+ */
+import { INTERACTIVE_BLOCK_TYPES, } from "./schema.js";
+export { evaluateCondition, evaluateFormula, FORMULA_LIMITS, formatFormulaValue, formulaJsonPath, formulaVariables, parseFormula, roundTo, } from "../core/formula/index.js";
+export { checkInteractiveBlock } from "./check.js";
+export { DEFAULT_INTERACTIVE_BLOCK_LABELS, resolveInteractiveBlockLabels, } from "./labels.js";
+export { evaluateCalculator, INTERACTIVE_BLOCK_TYPES, parseInteractiveBlock, } from "./schema.js";
+export function isInteractiveFamilyBlock(block) {
+    return INTERACTIVE_BLOCK_TYPES.includes(block.type);
+}

package/dist/interactive/family.d.ts

@@ -0,0 +1,6 @@
+import type { Component } from 'svelte';
+import type { InteractiveBlockViewProps } from './engine.js';
+export { type CalculatorBlock, type ChecklistBlock, INTERACTIVE_BLOCK_TYPES, type InteractiveBlock, type InteractiveBlockType, type InteractiveBlockViewProps, type InteractiveFamilyBlock, type InteractiveFamilyBlockType, isInteractiveFamilyBlock, type PollBlock, type QuizBlock, } from './engine.js';
+export declare function loadInteractiveFamily(): Promise<{
+    default: Component<InteractiveBlockViewProps>;
+}>;

package/dist/interactive/family.js

@@ -0,0 +1,4 @@
+export { INTERACTIVE_BLOCK_TYPES, isInteractiveFamilyBlock, } from "./engine.js";
+export function loadInteractiveFamily() {
+    return import('./InteractiveBlockView.svelte');
+}

package/dist/interactive/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference path="../css-modules.d.ts" />
+/**
+ * `@texuli/blocks` interactive family: poll, quiz, calculator, checklist.
+ *
+ * The closed formula engine is also re-exported here for compatibility.
+ * Prefer `@texuli/blocks/formula` for a cold start that must not pull
+ * interactive renderers (Protoyard adoption).
+ */
+export { type ArithmeticOp, type ComparisonOp, type Condition, evaluateCondition, evaluateFormula, FORMULA_LIMITS, type FormatFormulaOptions, type FormulaDiagnostic, type FormulaInputs, type FormulaParseResult, type FormulaUnit, formatFormulaValue, formulaJsonPath, formulaVariables, type NumberFormula, type ParseFormulaOptions, parseFormula, roundTo, } from '../core/formula/index.js';
+export { checkInteractiveBlock, type InteractiveBlockCheck } from './check.js';
+export { INTERACTIVE_BLOCK_TYPES, type InteractiveBlockViewProps, type InteractiveFamilyBlock, type InteractiveFamilyBlockType, isInteractiveFamilyBlock, loadInteractiveFamily, } from './family.js';
+export { DEFAULT_INTERACTIVE_BLOCK_LABELS, type InteractiveBlockLabelOverrides, type InteractiveBlockLabels, resolveInteractiveBlockLabels, } from './labels.js';
+export { type CalculatorBlock, type CalculatorInput, type ChecklistBlock, type ChecklistItem, evaluateCalculator, type InteractiveBlock, type InteractiveBlockType, type PollBlock, type PollOption, parseInteractiveBlock, type QuizBlock, type QuizOption, type QuizQuestion, } from './schema.js';

package/dist/interactive/index.js

@@ -0,0 +1,13 @@
+/**
+ * `@texuli/blocks` interactive family: poll, quiz, calculator, checklist.
+ *
+ * The closed formula engine is also re-exported here for compatibility.
+ * Prefer `@texuli/blocks/formula` for a cold start that must not pull
+ * interactive renderers (Protoyard adoption).
+ */
+// Light engine — same surface as `@texuli/blocks/formula`.
+export { evaluateCondition, evaluateFormula, FORMULA_LIMITS, formatFormulaValue, formulaJsonPath, formulaVariables, parseFormula, roundTo, } from "../core/formula/index.js";
+export { checkInteractiveBlock } from "./check.js";
+export { INTERACTIVE_BLOCK_TYPES, isInteractiveFamilyBlock, loadInteractiveFamily, } from "./family.js";
+export { DEFAULT_INTERACTIVE_BLOCK_LABELS, resolveInteractiveBlockLabels, } from "./labels.js";
+export { evaluateCalculator, parseInteractiveBlock, } from "./schema.js";

package/dist/interactive/interactive.css

@@ -0,0 +1,97 @@
+@layer tx.components {
+  .tx-block-interactive {
+    display: grid;
+    gap: 0.75rem;
+    padding: 1rem;
+    border: 1px solid var(--tx-border, ButtonBorder);
+    border-radius: var(--tx-radius, 0.625rem);
+    background: var(--tx-surface, Canvas);
+    color: var(--tx-foreground, CanvasText);
+    max-inline-size: 40rem;
+  }
+
+  .tx-block-interactive__title {
+    margin: 0;
+    font-size: 1.05rem;
+    font-weight: 600;
+  }
+
+  .tx-block-interactive__prompt {
+    margin: 0;
+    font-size: 0.95rem;
+  }
+
+  .tx-block-interactive__options {
+    display: grid;
+    gap: 0.4rem;
+  }
+
+  .tx-block-interactive__option {
+    display: flex;
+    gap: 0.5rem;
+    align-items: flex-start;
+  }
+
+  .tx-block-interactive__actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+  }
+
+  .tx-block-interactive__result {
+    margin: 0;
+    font-weight: 600;
+  }
+
+  .tx-block-interactive__bar {
+    display: grid;
+    gap: 0.15rem;
+  }
+
+  .tx-block-interactive__bar-track {
+    block-size: 0.5rem;
+    border-radius: 999px;
+    background: var(--tx-muted, color-mix(in srgb, CanvasText 10%, Canvas));
+    overflow: hidden;
+  }
+
+  .tx-block-interactive__bar-fill {
+    block-size: 100%;
+    background: var(--tx-primary, Highlight);
+    inline-size: 0%;
+  }
+
+  .tx-block-interactive__inputs {
+    display: grid;
+    gap: 0.65rem;
+  }
+
+  .tx-block-interactive__field {
+    display: grid;
+    gap: 0.25rem;
+  }
+
+  .tx-block-interactive__field input {
+    min-block-size: 2.25rem;
+    padding-inline: 0.5rem;
+    border: 1px solid var(--tx-input, var(--tx-border, ButtonBorder));
+    border-radius: calc(var(--tx-radius, 0.625rem) * 0.5);
+    background: var(--tx-background, Canvas);
+    color: inherit;
+    font: inherit;
+  }
+
+  .tx-block-invalid {
+    margin: 0;
+    padding: 0.75rem 1rem;
+    border: 1px solid var(--tx-destructive, Mark);
+    border-radius: var(--tx-radius, 0.5rem);
+  }
+
+  @media (forced-colors: active) {
+    .tx-block-interactive,
+    .tx-block-interactive__field input {
+      border: 1px solid ButtonText;
+    }
+  }
+}

package/dist/interactive/interactive.css.d.ts

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

package/dist/interactive/labels.d.ts

@@ -0,0 +1,16 @@
+export type InteractiveBlockLabels = {
+    invalid: string;
+    pollSubmit: string;
+    pollReset: string;
+    pollResults: string;
+    quizSubmit: string;
+    quizNext: string;
+    quizScore: string;
+    quizCorrect: string;
+    quizIncorrect: string;
+    calculatorResult: string;
+    checklistProgress: string;
+};
+export type InteractiveBlockLabelOverrides = Partial<InteractiveBlockLabels>;
+export declare const DEFAULT_INTERACTIVE_BLOCK_LABELS: InteractiveBlockLabels;
+export declare function resolveInteractiveBlockLabels(overrides?: InteractiveBlockLabelOverrides): InteractiveBlockLabels;

package/dist/interactive/labels.js

@@ -0,0 +1,16 @@
+export const DEFAULT_INTERACTIVE_BLOCK_LABELS = {
+    invalid: 'This interactive block is not valid.',
+    pollSubmit: 'Vote',
+    pollReset: 'Reset',
+    pollResults: 'Results',
+    quizSubmit: 'Check answer',
+    quizNext: 'Next question',
+    quizScore: 'Score',
+    quizCorrect: 'Correct',
+    quizIncorrect: 'Not quite',
+    calculatorResult: 'Result',
+    checklistProgress: 'Completed',
+};
+export function resolveInteractiveBlockLabels(overrides) {
+    return { ...DEFAULT_INTERACTIVE_BLOCK_LABELS, ...overrides };
+}

package/dist/interactive/renderers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Eager entry for hosts that render interactive blocks on first paint.
+ * Prefer `loadInteractiveFamily()` for a lazy chunk.
+ */
+export { default as CalculatorBlock } from './CalculatorBlock.svelte';
+export { default as ChecklistBlock } from './ChecklistBlock.svelte';
+export { default as InteractiveBlockView } from './InteractiveBlockView.svelte';
+export { default as PollBlock } from './PollBlock.svelte';
+export { default as QuizBlock } from './QuizBlock.svelte';

package/dist/interactive/renderers.js

@@ -0,0 +1,9 @@
+/**
+ * Eager entry for hosts that render interactive blocks on first paint.
+ * Prefer `loadInteractiveFamily()` for a lazy chunk.
+ */
+export { default as CalculatorBlock } from './CalculatorBlock.svelte';
+export { default as ChecklistBlock } from './ChecklistBlock.svelte';
+export { default as InteractiveBlockView } from './InteractiveBlockView.svelte';
+export { default as PollBlock } from './PollBlock.svelte';
+export { default as QuizBlock } from './QuizBlock.svelte';

package/dist/interactive/schema.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Interactive-family block shapes: poll, quiz, calculator, checklist.
+ * Wired into core `safeParseBlock` via `parseInteractiveBlock`.
+ */
+import { type FormulaUnit, type NumberFormula } from '../core/formula/index.js';
+import { type BlockBase, type ParseResult } from '../core/schema/primitives.js';
+export type PollOption = {
+    id: string;
+    label: string;
+};
+export type PollBlock = BlockBase & {
+    type: 'poll';
+    question: string;
+    options: PollOption[];
+    allowMultiple?: boolean;
+};
+export type QuizOption = {
+    id: string;
+    label: string;
+};
+export type QuizQuestion = {
+    id: string;
+    prompt: string;
+    options: QuizOption[];
+    /** Single correct option id. */
+    correctId: string;
+    explanation?: string;
+};
+export type QuizBlock = BlockBase & {
+    type: 'quiz';
+    title?: string;
+    questions: QuizQuestion[];
+};
+export type CalculatorInput = {
+    name: string;
+    label: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    default?: number;
+};
+export type CalculatorBlock = BlockBase & {
+    type: 'calculator';
+    title?: string;
+    description?: string;
+    inputs: CalculatorInput[];
+    formula: NumberFormula;
+    unit?: FormulaUnit;
+    outputLabel?: string;
+};
+export type ChecklistItem = {
+    id: string;
+    label: string;
+    done?: boolean;
+};
+export type ChecklistBlock = BlockBase & {
+    type: 'checklist';
+    title?: string;
+    items: ChecklistItem[];
+};
+export type InteractiveBlock = PollBlock | QuizBlock | CalculatorBlock | ChecklistBlock;
+export type InteractiveBlockType = 'poll' | 'quiz' | 'calculator' | 'checklist';
+export declare const INTERACTIVE_BLOCK_TYPES: readonly ["poll", "quiz", "calculator", "checklist"];
+/**
+ * Parse an interactive-family block, or `null` when `type` is not interactive.
+ */
+export declare function parseInteractiveBlock(type: string, record: Record<string, unknown>, path: (string | number)[], base: BlockBase): ParseResult<InteractiveBlock> | null;
+/** Evaluate a calculator block against current input values (finite numbers only). */
+export declare function evaluateCalculator(block: CalculatorBlock, values: Readonly<Record<string, number | null | undefined>>): {
+    ok: true;
+    value: number | null;
+    formatted: string;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/interactive/schema.js

@@ -0,0 +1,324 @@
+/**
+ * Interactive-family block shapes: poll, quiz, calculator, checklist.
+ * Wired into core `safeParseBlock` via `parseInteractiveBlock`.
+ */
+import { evaluateFormula, formatFormulaValue, parseFormula, } from "../core/formula/index.js";
+import { BLOCK_CONTENT_LIMITS, fail, failMany, ok, parseMultilineText, parsePlainText, } from "../core/schema/primitives.js";
+import { isBlockTone } from "../core/schema/vocabulary.js";
+const OPTION_ID = /^[a-z][a-z0-9-]{0,31}$/;
+const VAR_NAME = /^[a-z][a-z0-9_]{0,31}$/;
+const FORMULA_UNITS = ['number', 'compact', 'cents', 'percent'];
+export const INTERACTIVE_BLOCK_TYPES = [
+    'poll',
+    'quiz',
+    'calculator',
+    'checklist',
+];
+function plainObject(value, path) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return fail(path, 'Expected an object');
+    }
+    return ok(value);
+}
+function parseOptionId(value, path) {
+    if (typeof value !== 'string' || !OPTION_ID.test(value)) {
+        return fail(path, 'Expected a stable option id (lowercase, max 32)');
+    }
+    return ok(value);
+}
+function parseOptions(value, path, max) {
+    if (!Array.isArray(value) || value.length < 2) {
+        return fail(path, 'Expected at least two options');
+    }
+    if (value.length > max)
+        return fail(path, `At most ${max} options`);
+    const options = [];
+    const seen = new Set();
+    const issues = [];
+    for (let i = 0; i < value.length; i += 1) {
+        const itemPath = [...path, i];
+        const obj = plainObject(value[i], itemPath);
+        if (!obj.success) {
+            issues.push(...obj.issues);
+            continue;
+        }
+        const id = parseOptionId(obj.data.id, [...itemPath, 'id']);
+        const label = parsePlainText(obj.data.label, [...itemPath, 'label'], BLOCK_CONTENT_LIMITS.plain);
+        if (!id.success) {
+            issues.push(...id.issues);
+            continue;
+        }
+        if (!label.success) {
+            issues.push(...label.issues);
+            continue;
+        }
+        if (seen.has(id.data)) {
+            issues.push({ path: [...itemPath, 'id'], message: 'Duplicate option id' });
+            continue;
+        }
+        seen.add(id.data);
+        options.push({ id: id.data, label: label.data });
+    }
+    if (issues.length > 0)
+        return failMany(issues);
+    return ok(options);
+}
+function parsePollBlock(record, path, base) {
+    const question = parseMultilineText(record.question, [...path, 'question'], BLOCK_CONTENT_LIMITS.shortMarkdown);
+    if (!question.success)
+        return question;
+    const options = parseOptions(record.options, [...path, 'options'], BLOCK_CONTENT_LIMITS.pollOptions);
+    if (!options.success)
+        return options;
+    const block = {
+        ...base,
+        type: 'poll',
+        question: question.data,
+        options: options.data,
+    };
+    if (record.allowMultiple === true)
+        block.allowMultiple = true;
+    if (record.tone !== undefined) {
+        if (!isBlockTone(record.tone))
+            return fail([...path, 'tone'], 'Invalid tone');
+        block.tone = record.tone;
+    }
+    return ok(block);
+}
+function parseQuizBlock(record, path, base) {
+    if (!Array.isArray(record.questions) || record.questions.length < 1) {
+        return fail([...path, 'questions'], 'Expected at least one question');
+    }
+    if (record.questions.length > BLOCK_CONTENT_LIMITS.steps) {
+        return fail([...path, 'questions'], `At most ${BLOCK_CONTENT_LIMITS.steps} questions`);
+    }
+    const questions = [];
+    const seenQ = new Set();
+    const issues = [];
+    for (let i = 0; i < record.questions.length; i += 1) {
+        const qPath = [...path, 'questions', i];
+        const obj = plainObject(record.questions[i], qPath);
+        if (!obj.success) {
+            issues.push(...obj.issues);
+            continue;
+        }
+        const id = parseOptionId(obj.data.id, [...qPath, 'id']);
+        const prompt = parseMultilineText(obj.data.prompt, [...qPath, 'prompt'], BLOCK_CONTENT_LIMITS.shortMarkdown);
+        const options = parseOptions(obj.data.options, [...qPath, 'options'], BLOCK_CONTENT_LIMITS.pollOptions);
+        if (!id.success || !prompt.success || !options.success) {
+            if (!id.success)
+                issues.push(...id.issues);
+            if (!prompt.success)
+                issues.push(...prompt.issues);
+            if (!options.success)
+                issues.push(...options.issues);
+            continue;
+        }
+        if (seenQ.has(id.data)) {
+            issues.push({ path: [...qPath, 'id'], message: 'Duplicate question id' });
+            continue;
+        }
+        seenQ.add(id.data);
+        const correctId = parseOptionId(obj.data.correctId, [...qPath, 'correctId']);
+        if (!correctId.success) {
+            issues.push(...correctId.issues);
+            continue;
+        }
+        if (!options.data.some((o) => o.id === correctId.data)) {
+            issues.push({
+                path: [...qPath, 'correctId'],
+                message: 'correctId must match an option id',
+            });
+            continue;
+        }
+        const q = {
+            id: id.data,
+            prompt: prompt.data,
+            options: options.data,
+            correctId: correctId.data,
+        };
+        if (obj.data.explanation !== undefined) {
+            const explanation = parseMultilineText(obj.data.explanation, [...qPath, 'explanation'], BLOCK_CONTENT_LIMITS.shortMarkdown);
+            if (!explanation.success) {
+                issues.push(...explanation.issues);
+                continue;
+            }
+            q.explanation = explanation.data;
+        }
+        questions.push(q);
+    }
+    if (issues.length > 0)
+        return failMany(issues);
+    const block = { ...base, type: 'quiz', questions };
+    if (record.title !== undefined) {
+        const title = parsePlainText(record.title, [...path, 'title'], BLOCK_CONTENT_LIMITS.heading);
+        if (!title.success)
+            return title;
+        block.title = title.data;
+    }
+    return ok(block);
+}
+function parseFiniteNumber(value, path) {
+    if (value === undefined)
+        return ok(undefined);
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fail(path, 'Expected a finite number');
+    }
+    return ok(value);
+}
+function parseCalculatorBlock(record, path, base) {
+    if (!Array.isArray(record.inputs) || record.inputs.length < 1) {
+        return fail([...path, 'inputs'], 'Expected at least one input');
+    }
+    if (record.inputs.length > BLOCK_CONTENT_LIMITS.formFields) {
+        return fail([...path, 'inputs'], `At most ${BLOCK_CONTENT_LIMITS.formFields} inputs`);
+    }
+    const inputs = [];
+    const names = new Set();
+    const issues = [];
+    for (let i = 0; i < record.inputs.length; i += 1) {
+        const iPath = [...path, 'inputs', i];
+        const obj = plainObject(record.inputs[i], iPath);
+        if (!obj.success) {
+            issues.push(...obj.issues);
+            continue;
+        }
+        if (typeof obj.data.name !== 'string' || !VAR_NAME.test(obj.data.name)) {
+            issues.push({ path: [...iPath, 'name'], message: 'Invalid input name' });
+            continue;
+        }
+        if (names.has(obj.data.name)) {
+            issues.push({ path: [...iPath, 'name'], message: 'Duplicate input name' });
+            continue;
+        }
+        names.add(obj.data.name);
+        const label = parsePlainText(obj.data.label, [...iPath, 'label'], BLOCK_CONTENT_LIMITS.plain);
+        if (!label.success) {
+            issues.push(...label.issues);
+            continue;
+        }
+        const input = { name: obj.data.name, label: label.data };
+        for (const key of ['min', 'max', 'step', 'default']) {
+            if (obj.data[key] === undefined)
+                continue;
+            const n = parseFiniteNumber(obj.data[key], [...iPath, key]);
+            if (!n.success) {
+                issues.push(...n.issues);
+                continue;
+            }
+            if (n.data !== undefined)
+                input[key] = n.data;
+        }
+        inputs.push(input);
+    }
+    if (issues.length > 0)
+        return failMany(issues);
+    const formulaResult = parseFormula(record.formula, {
+        variables: [...names],
+    });
+    if (!formulaResult.success) {
+        return fail([...path, 'formula'], formulaResult.diagnostics[0]?.message ?? 'Invalid formula');
+    }
+    const block = {
+        ...base,
+        type: 'calculator',
+        inputs,
+        formula: formulaResult.formula,
+    };
+    if (record.title !== undefined) {
+        const title = parsePlainText(record.title, [...path, 'title'], BLOCK_CONTENT_LIMITS.heading);
+        if (!title.success)
+            return title;
+        block.title = title.data;
+    }
+    if (record.description !== undefined) {
+        const description = parseMultilineText(record.description, [...path, 'description'], BLOCK_CONTENT_LIMITS.shortMarkdown);
+        if (!description.success)
+            return description;
+        block.description = description.data;
+    }
+    if (record.outputLabel !== undefined) {
+        const outputLabel = parsePlainText(record.outputLabel, [...path, 'outputLabel'], BLOCK_CONTENT_LIMITS.plain);
+        if (!outputLabel.success)
+            return outputLabel;
+        block.outputLabel = outputLabel.data;
+    }
+    if (record.unit !== undefined) {
+        if (typeof record.unit !== 'string' ||
+            !FORMULA_UNITS.includes(record.unit)) {
+            return fail([...path, 'unit'], 'Invalid formula unit');
+        }
+        block.unit = record.unit;
+    }
+    return ok(block);
+}
+function parseChecklistBlock(record, path, base) {
+    if (!Array.isArray(record.items) || record.items.length < 1) {
+        return fail([...path, 'items'], 'Expected at least one item');
+    }
+    if (record.items.length > BLOCK_CONTENT_LIMITS.listItems) {
+        return fail([...path, 'items'], `At most ${BLOCK_CONTENT_LIMITS.listItems} items`);
+    }
+    const items = [];
+    const seen = new Set();
+    const issues = [];
+    for (let i = 0; i < record.items.length; i += 1) {
+        const iPath = [...path, 'items', i];
+        const obj = plainObject(record.items[i], iPath);
+        if (!obj.success) {
+            issues.push(...obj.issues);
+            continue;
+        }
+        const id = parseOptionId(obj.data.id, [...iPath, 'id']);
+        const label = parsePlainText(obj.data.label, [...iPath, 'label'], BLOCK_CONTENT_LIMITS.plain);
+        if (!id.success || !label.success) {
+            if (!id.success)
+                issues.push(...id.issues);
+            if (!label.success)
+                issues.push(...label.issues);
+            continue;
+        }
+        if (seen.has(id.data)) {
+            issues.push({ path: [...iPath, 'id'], message: 'Duplicate item id' });
+            continue;
+        }
+        seen.add(id.data);
+        const item = { id: id.data, label: label.data };
+        if (obj.data.done === true)
+            item.done = true;
+        items.push(item);
+    }
+    if (issues.length > 0)
+        return failMany(issues);
+    const block = { ...base, type: 'checklist', items };
+    if (record.title !== undefined) {
+        const title = parsePlainText(record.title, [...path, 'title'], BLOCK_CONTENT_LIMITS.heading);
+        if (!title.success)
+            return title;
+        block.title = title.data;
+    }
+    return ok(block);
+}
+/**
+ * Parse an interactive-family block, or `null` when `type` is not interactive.
+ */
+export function parseInteractiveBlock(type, record, path, base) {
+    switch (type) {
+        case 'poll':
+            return parsePollBlock(record, path, base);
+        case 'quiz':
+            return parseQuizBlock(record, path, base);
+        case 'calculator':
+            return parseCalculatorBlock(record, path, base);
+        case 'checklist':
+            return parseChecklistBlock(record, path, base);
+        default:
+            return null;
+    }
+}
+/** Evaluate a calculator block against current input values (finite numbers only). */
+export function evaluateCalculator(block, values) {
+    const result = evaluateFormula(block.formula, values);
+    const formatted = formatFormulaValue(result, block.unit ?? 'number');
+    return { ok: true, value: result, formatted };
+}