@cxpinsight/survey-spec 0.4.0 → 0.5.1

package/dist/evaluateTree.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Walk a compiled condition tree.
+ *
+ * The counterpart to `evaluateCondition`, which parses an author's expression
+ * string every time it is asked. The server can compile that string once, at
+ * publish time, and send the tree instead — so a client never carries a
+ * tokeniser or a precedence table. That is 206 of expressionEval's 321 lines
+ * gone from every future SDK, and the remaining evaluator is small enough to
+ * write again in Swift or Kotlin without it becoming a project.
+ *
+ * Node grammar and every coercion rule are in
+ * contracts/sdk/vocabulary.v1.json. The coercion rules matter more than they
+ * look: a differential test against a Swift implementation of exactly this
+ * disagreed on 7% of generated inputs, and every divergence came from one of
+ * them being unstated.
+ *
+ * Returns `null` for a tree carrying something this build cannot execute —
+ * never `false`. A condition that could not be evaluated must not silently
+ * hide a question; the caller decides.
+ */
+export type Operand = {
+    lit: unknown;
+} | {
+    ref: string;
+} | {
+    arith: '+' | '-' | '*' | '/';
+    of: [Operand, Operand];
+};
+export type ConditionNode = {
+    logic: 'all' | 'any' | 'not';
+    of: ConditionNode[];
+} | {
+    left: Operand;
+    op: string;
+    right: Operand;
+};
+export interface TreeContext {
+    answers?: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+}
+/** The contract's cap. Deeper than this, Apple Foundation refuses the payload. */
+export declare const MAX_TREE_DEPTH = 32;
+/** `null` means an operator this build does not implement — reject, never guess. */
+export declare function compareValues(a: unknown, op: string, b: unknown): boolean | null;
+/**
+ * A null tree means "no condition", which every renderer treats as SHOW.
+ * @returns true, false, or null when the tree could not be executed.
+ */
+export declare function evaluateTree(node: unknown, ctx: TreeContext, depth?: number): boolean | null;
+//# sourceMappingURL=evaluateTree.d.ts.map

package/dist/evaluateTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluateTree.d.ts","sourceRoot":"","sources":["../src/evaluateTree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,MAAM,OAAO,GACf;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,GAChB;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GACf;IAAE,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAAC,EAAE,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC;AAE7D,MAAM,MAAM,aAAa,GACrB;IAAE,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IAAC,EAAE,EAAE,aAAa,EAAE,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAElD,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED,kFAAkF;AAClF,eAAO,MAAM,cAAc,KAAK,CAAC;AA0DjC,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAqChF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,KAAK,SAAI,GAAG,OAAO,GAAG,IAAI,CAsBvF"}

package/dist/evaluateTree.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Walk a compiled condition tree.
+ *
+ * The counterpart to `evaluateCondition`, which parses an author's expression
+ * string every time it is asked. The server can compile that string once, at
+ * publish time, and send the tree instead — so a client never carries a
+ * tokeniser or a precedence table. That is 206 of expressionEval's 321 lines
+ * gone from every future SDK, and the remaining evaluator is small enough to
+ * write again in Swift or Kotlin without it becoming a project.
+ *
+ * Node grammar and every coercion rule are in
+ * contracts/sdk/vocabulary.v1.json. The coercion rules matter more than they
+ * look: a differential test against a Swift implementation of exactly this
+ * disagreed on 7% of generated inputs, and every divergence came from one of
+ * them being unstated.
+ *
+ * Returns `null` for a tree carrying something this build cannot execute —
+ * never `false`. A condition that could not be evaluated must not silently
+ * hide a question; the caller decides.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_TREE_DEPTH = void 0;
+exports.compareValues = compareValues;
+exports.evaluateTree = evaluateTree;
+/** The contract's cap. Deeper than this, Apple Foundation refuses the payload. */
+exports.MAX_TREE_DEPTH = 32;
+const own = (o, k) => (o != null && Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined);
+/**
+ * Text form. NOT `String(v)`: `String(null)` is the four characters "null", so
+ * `{q1} contains "null"` would match an unanswered question.
+ */
+function str(v) {
+    if (v === null || v === undefined)
+        return '';
+    if (Array.isArray(v))
+        return v.map(str).join(',');
+    return String(v);
+}
+/** Absent, empty text, or an empty multi-select. */
+function empty(v) {
+    return v === null || v === undefined || v === '' || (Array.isArray(v) && v.length === 0);
+}
+/** Both sides numeric-looking? Then compare as numbers, not as text. */
+function numeric(a, b) {
+    return a !== '' && b !== '' && a != null && b != null &&
+        !isNaN(Number(a)) && !isNaN(Number(b));
+}
+/** Follow `answers.q1` / `variables.user.plan`, own properties only. */
+function resolve(ref, ctx) {
+    const parts = String(ref).split('.');
+    let cur = own(ctx, parts[0]);
+    for (let i = 1; i < parts.length && cur != null; i++)
+        cur = own(cur, parts[i]);
+    if (cur === undefined && parts.length > 2) {
+        const flat = own(own(ctx, parts[0]) || {}, parts.slice(1).join('.'));
+        if (flat !== undefined)
+            return flat;
+    }
+    return cur;
+}
+function operand(node, ctx) {
+    if (node == null || typeof node !== 'object')
+        return undefined;
+    const n = node;
+    if ('lit' in n)
+        return n.lit;
+    if ('ref' in n)
+        return resolve(String(n.ref), ctx);
+    if ('arith' in n) {
+        const of = n.of;
+        const a = Number(operand(of[0], ctx));
+        const b = Number(operand(of[1], ctx));
+        switch (n.arith) {
+            case '+': return a + b;
+            case '-': return a - b;
+            case '*': return a * b;
+            case '/': return b === 0 ? undefined : a / b;
+            default: return undefined;
+        }
+    }
+    return undefined;
+}
+/** `null` means an operator this build does not implement — reject, never guess. */
+function compareValues(a, op, b) {
+    switch (op) {
+        case 'truthy': return !!a && a !== '0' && a !== 'false';
+        // An ABSENT value equals nothing, not even the empty string.
+        //
+        // str() renders absent as '', which made `{why} != ""` FALSE for an
+        // unanswered question — the parser says true, and a follow-up gated on
+        // "why has been answered" would have stopped appearing. Found by the
+        // end-to-end test walking a real respondent's path; forty-three expression
+        // fixtures never paired a missing answer with an empty-string literal.
+        //
+        // This is the seam between "absent renders as empty text" (right, and what
+        // keeps `contains "null"` from matching nothing) and "absent IS empty text"
+        // (wrong, and a behaviour change).
+        case 'eq': {
+            const aAbsent = a === null || a === undefined;
+            const bAbsent = b === null || b === undefined;
+            if (aAbsent !== bAbsent)
+                return false;
+            if (aAbsent && bAbsent)
+                return true;
+            return numeric(a, b) ? Number(a) === Number(b) : str(a) === str(b);
+        }
+        case 'neq': {
+            const e = compareValues(a, 'eq', b);
+            return e === null ? null : !e;
+        }
+        case 'gt': return numeric(a, b) && Number(a) > Number(b);
+        case 'gte': return numeric(a, b) && Number(a) >= Number(b);
+        case 'lt': return numeric(a, b) && Number(a) < Number(b);
+        case 'lte': return numeric(a, b) && Number(a) <= Number(b);
+        case 'in': return (Array.isArray(b) ? b : str(b).split(',').map((x) => x.trim()))
+            .some((v) => str(v) === str(a));
+        case 'not_in': {
+            const i = compareValues(a, 'in', b);
+            return i === null ? null : !i;
+        }
+        case 'contains': return str(a).toLowerCase().includes(str(b).toLowerCase());
+        case 'not_contains': {
+            const c = compareValues(a, 'contains', b);
+            return c === null ? null : !c;
+        }
+        case 'starts_with': return str(a).toLowerCase().startsWith(str(b).toLowerCase());
+        case 'ends_with': return str(a).toLowerCase().endsWith(str(b).toLowerCase());
+        case 'exists': return !empty(a);
+        case 'not_exists': return empty(a);
+        default: return null;
+    }
+}
+/**
+ * A null tree means "no condition", which every renderer treats as SHOW.
+ * @returns true, false, or null when the tree could not be executed.
+ */
+function evaluateTree(node, ctx, depth = 0) {
+    if (depth > exports.MAX_TREE_DEPTH)
+        return null;
+    if (node == null)
+        return true;
+    if (typeof node !== 'object')
+        return null;
+    const c = {
+        answers: (ctx && ctx.answers) || {},
+        variables: (ctx && ctx.variables) || {},
+    };
+    const n = node;
+    if (n.logic) {
+        const kids = (n.of || []).map((k) => evaluateTree(k, ctx, depth + 1));
+        if (kids.some((k) => k === null))
+            return null;
+        const vals = kids;
+        if (n.logic === 'all')
+            return vals.every(Boolean);
+        if (n.logic === 'any')
+            return vals.some(Boolean);
+        if (n.logic === 'not')
+            return !vals[0];
+        return null;
+    }
+    if (typeof n.op !== 'string')
+        return null;
+    return compareValues(operand(n.left, c), n.op, operand(n.right, c));
+}

package/dist/index.d.ts

@@ -11,10 +11,15 @@
  * fails on any disagreement.
  */
 export { evaluateExpression, evaluateCondition, isParseable } from './expressionEval';
+export { evaluateTree, compareValues, MAX_TREE_DEPTH } from './evaluateTree';
+export type { ConditionNode, Operand, TreeContext } from './evaluateTree';
 export { resolveVariable } from './resolveVariable';
 export { splitIntoPages } from './pageFlow';
-export { validateAnswer, impliedChoices, impliedActions } from './validate';
-export type { ValidatableQuestion } from './validate';
+export { validateAnswer, impliedChoices, impliedActions, impliedStepActions, impliedEqualProminence, safeActionHref, safeImageSrc, isDeferChoice, canSwipeToDismiss, autoDismissMs, deadlineCountdown, formatCountdown, outcomeFor, voiceUsable, rewardToShow, cardClickTarget, cardHoverEffect, resolveAction } from './validate';
+export type { ValidatableQuestion, OutcomeKind, OutcomeInput, ActionKind, RawAction, ResolvedAction } from './validate';
+export { validateAnswerCode } from './validate';
+export { wordMessage, EN_MESSAGES, MESSAGE_CODES } from './messages';
+export type { ValidationMessage } from './messages';
 export type { Page, PageItem, PageFlowOptions, FlowQuestion, FlowSection } from './pageFlow';
 export { normalizeTranscript, matchBoolean, matchOption, matchOptions, rankOptions, matchNumberInRange, matchDate, distinctiveLabels, voiceSupport, voiceCanHandle, auditVoiceQuestions, voiceDisclaimer, skipNoteText, scaffoldFor, buildPromptText, shortCode, optionLabelOf, optionValueOf, voiceOptionsOf, optionLabelsOf, } from './voice';
 export type { VoiceSupport, VoiceQuestion, VoiceOption, VoiceScaffold } from './voice';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5E,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,EACL,mBAAmB,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EACzE,kBAAkB,EAAE,SAAS,EAAE,iBAAiB,EAChD,YAAY,EAAE,cAAc,EAAE,mBAAmB,EACjD,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,SAAS,EACtE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,GAC7D,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACvF,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC7E,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,aAAa,EAAE,iBAAiB,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACnU,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACxH,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACrE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,EACL,mBAAmB,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EACzE,kBAAkB,EAAE,SAAS,EAAE,iBAAiB,EAChD,YAAY,EAAE,cAAc,EAAE,mBAAmB,EACjD,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,SAAS,EACtE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,GAC7D,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACvF,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.optionLabelsOf = exports.voiceOptionsOf = exports.optionValueOf = exports.optionLabelOf = exports.shortCode = exports.buildPromptText = exports.scaffoldFor = exports.skipNoteText = exports.voiceDisclaimer = exports.auditVoiceQuestions = exports.voiceCanHandle = exports.voiceSupport = exports.distinctiveLabels = exports.matchDate = exports.matchNumberInRange = exports.rankOptions = exports.matchOptions = exports.matchOption = exports.matchBoolean = exports.normalizeTranscript = exports.impliedActions = exports.impliedChoices = exports.validateAnswer = exports.splitIntoPages = exports.resolveVariable = exports.isParseable = exports.evaluateCondition = exports.evaluateExpression = void 0;
+exports.optionLabelsOf = exports.voiceOptionsOf = exports.optionValueOf = exports.optionLabelOf = exports.shortCode = exports.buildPromptText = exports.scaffoldFor = exports.skipNoteText = exports.voiceDisclaimer = exports.auditVoiceQuestions = exports.voiceCanHandle = exports.voiceSupport = exports.distinctiveLabels = exports.matchDate = exports.matchNumberInRange = exports.rankOptions = exports.matchOptions = exports.matchOption = exports.matchBoolean = exports.normalizeTranscript = exports.MESSAGE_CODES = exports.EN_MESSAGES = exports.wordMessage = exports.validateAnswerCode = exports.resolveAction = exports.cardHoverEffect = exports.cardClickTarget = exports.rewardToShow = exports.voiceUsable = exports.outcomeFor = exports.formatCountdown = exports.deadlineCountdown = exports.autoDismissMs = exports.canSwipeToDismiss = exports.isDeferChoice = exports.safeImageSrc = exports.safeActionHref = exports.impliedEqualProminence = exports.impliedStepActions = exports.impliedActions = exports.impliedChoices = exports.validateAnswer = exports.splitIntoPages = exports.resolveVariable = exports.MAX_TREE_DEPTH = exports.compareValues = exports.evaluateTree = exports.isParseable = exports.evaluateCondition = exports.evaluateExpression = void 0;
 /**
  * @cxpinsight/survey-spec
  *
@@ -17,6 +17,10 @@ var expressionEval_1 = require("./expressionEval");
 Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return expressionEval_1.evaluateExpression; } });
 Object.defineProperty(exports, "evaluateCondition", { enumerable: true, get: function () { return expressionEval_1.evaluateCondition; } });
 Object.defineProperty(exports, "isParseable", { enumerable: true, get: function () { return expressionEval_1.isParseable; } });
+var evaluateTree_1 = require("./evaluateTree");
+Object.defineProperty(exports, "evaluateTree", { enumerable: true, get: function () { return evaluateTree_1.evaluateTree; } });
+Object.defineProperty(exports, "compareValues", { enumerable: true, get: function () { return evaluateTree_1.compareValues; } });
+Object.defineProperty(exports, "MAX_TREE_DEPTH", { enumerable: true, get: function () { return evaluateTree_1.MAX_TREE_DEPTH; } });
 var resolveVariable_1 = require("./resolveVariable");
 Object.defineProperty(exports, "resolveVariable", { enumerable: true, get: function () { return resolveVariable_1.resolveVariable; } });
 var pageFlow_1 = require("./pageFlow");
@@ -25,6 +29,27 @@ var validate_1 = require("./validate");
 Object.defineProperty(exports, "validateAnswer", { enumerable: true, get: function () { return validate_1.validateAnswer; } });
 Object.defineProperty(exports, "impliedChoices", { enumerable: true, get: function () { return validate_1.impliedChoices; } });
 Object.defineProperty(exports, "impliedActions", { enumerable: true, get: function () { return validate_1.impliedActions; } });
+Object.defineProperty(exports, "impliedStepActions", { enumerable: true, get: function () { return validate_1.impliedStepActions; } });
+Object.defineProperty(exports, "impliedEqualProminence", { enumerable: true, get: function () { return validate_1.impliedEqualProminence; } });
+Object.defineProperty(exports, "safeActionHref", { enumerable: true, get: function () { return validate_1.safeActionHref; } });
+Object.defineProperty(exports, "safeImageSrc", { enumerable: true, get: function () { return validate_1.safeImageSrc; } });
+Object.defineProperty(exports, "isDeferChoice", { enumerable: true, get: function () { return validate_1.isDeferChoice; } });
+Object.defineProperty(exports, "canSwipeToDismiss", { enumerable: true, get: function () { return validate_1.canSwipeToDismiss; } });
+Object.defineProperty(exports, "autoDismissMs", { enumerable: true, get: function () { return validate_1.autoDismissMs; } });
+Object.defineProperty(exports, "deadlineCountdown", { enumerable: true, get: function () { return validate_1.deadlineCountdown; } });
+Object.defineProperty(exports, "formatCountdown", { enumerable: true, get: function () { return validate_1.formatCountdown; } });
+Object.defineProperty(exports, "outcomeFor", { enumerable: true, get: function () { return validate_1.outcomeFor; } });
+Object.defineProperty(exports, "voiceUsable", { enumerable: true, get: function () { return validate_1.voiceUsable; } });
+Object.defineProperty(exports, "rewardToShow", { enumerable: true, get: function () { return validate_1.rewardToShow; } });
+Object.defineProperty(exports, "cardClickTarget", { enumerable: true, get: function () { return validate_1.cardClickTarget; } });
+Object.defineProperty(exports, "cardHoverEffect", { enumerable: true, get: function () { return validate_1.cardHoverEffect; } });
+Object.defineProperty(exports, "resolveAction", { enumerable: true, get: function () { return validate_1.resolveAction; } });
+var validate_2 = require("./validate");
+Object.defineProperty(exports, "validateAnswerCode", { enumerable: true, get: function () { return validate_2.validateAnswerCode; } });
+var messages_1 = require("./messages");
+Object.defineProperty(exports, "wordMessage", { enumerable: true, get: function () { return messages_1.wordMessage; } });
+Object.defineProperty(exports, "EN_MESSAGES", { enumerable: true, get: function () { return messages_1.EN_MESSAGES; } });
+Object.defineProperty(exports, "MESSAGE_CODES", { enumerable: true, get: function () { return messages_1.MESSAGE_CODES; } });
 var voice_1 = require("./voice");
 Object.defineProperty(exports, "normalizeTranscript", { enumerable: true, get: function () { return voice_1.normalizeTranscript; } });
 Object.defineProperty(exports, "matchBoolean", { enumerable: true, get: function () { return voice_1.matchBoolean; } });

package/dist/messages.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Validation messages, as codes and English wording.
+ *
+ * The validator used to build its sentences inline —
+ * `` `Please keep this under ${question.maxLength} characters` `` — which welded
+ * English into the rule engine. Three consequences, all of them costs someone
+ * eventually pays:
+ *
+ *   • A message cannot be translated. Arabic is on the roadmap and every one of
+ *     these sentences would have had to be intercepted by string matching.
+ *   • A port to Swift or Kotlin re-implements the copy, or drifts from it. The
+ *     contract's whole point is that the part which must agree exactly is small,
+ *     and prose is not that part.
+ *   • A product change to the wording is a change to the shared spec, a publish,
+ *     and a release of three renderers.
+ *
+ * So the rules return `{ code, params }` and the wording lives here. English is
+ * the default so nothing changes for a caller that does not care; a renderer
+ * that does calls `validateAnswerCode` and words it itself.
+ */
+export interface ValidationMessage {
+    code: string;
+    params: Record<string, unknown>;
+}
+/** English wording, one entry per code. The only prose in the validator. */
+export declare const EN_MESSAGES: Record<string, (p: Record<string, unknown>) => string>;
+/**
+ * Word a message in English.
+ *
+ * An unknown code returns the code itself rather than empty or a throw: a
+ * respondent seeing `max_length` is confusing, but a respondent seeing NOTHING
+ * where a validation error should be is worse — they cannot submit and cannot
+ * tell why.
+ */
+export declare function wordMessage(message: ValidationMessage | null): string | null;
+/** Every code the validator can return, for a translator to work from. */
+export declare const MESSAGE_CODES: string[];
+//# sourceMappingURL=messages.d.ts.map

package/dist/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,4EAA4E;AAC5E,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CA4B9E,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAI5E;AAED,0EAA0E;AAC1E,eAAO,MAAM,aAAa,UAA2B,CAAC"}

package/dist/messages.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Validation messages, as codes and English wording.
+ *
+ * The validator used to build its sentences inline —
+ * `` `Please keep this under ${question.maxLength} characters` `` — which welded
+ * English into the rule engine. Three consequences, all of them costs someone
+ * eventually pays:
+ *
+ *   • A message cannot be translated. Arabic is on the roadmap and every one of
+ *     these sentences would have had to be intercepted by string matching.
+ *   • A port to Swift or Kotlin re-implements the copy, or drifts from it. The
+ *     contract's whole point is that the part which must agree exactly is small,
+ *     and prose is not that part.
+ *   • A product change to the wording is a change to the shared spec, a publish,
+ *     and a release of three renderers.
+ *
+ * So the rules return `{ code, params }` and the wording lives here. English is
+ * the default so nothing changes for a caller that does not care; a renderer
+ * that does calls `validateAnswerCode` and words it itself.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGE_CODES = exports.EN_MESSAGES = void 0;
+exports.wordMessage = wordMessage;
+/** English wording, one entry per code. The only prose in the validator. */
+exports.EN_MESSAGES = {
+    required: () => 'This field is required',
+    choose_option: () => 'Please choose an option',
+    format_email: () => 'Please enter a valid email address (e.g., you@example.com)',
+    format_url: () => 'Please enter a full URL, including https://',
+    format_number: () => 'Please enter a number',
+    // Deliberately permissive upstream; the message stays vague to match.
+    format_tel: () => 'Please enter a valid phone number',
+    max_length: (p) => `Please keep this under ${p.max} characters`,
+    min_length: (p) => `Please enter at least ${p.min} characters`,
+    min_selected: (p) => `Please select at least ${p.min}`,
+    max_selected: (p) => `Please select at most ${p.max}`,
+    min_value: (p) => `Must be at least ${p.min}`,
+    max_value: (p) => `Must be at most ${p.max}`,
+    // spec §8 author-declared rules[]. Worded differently from the built-in
+    // checks above because the author chose to add them explicitly, and the
+    // shorter phrasing is what shipped.
+    rule_min_length: (p) => `At least ${p.min} characters`,
+    rule_max_length: (p) => `At most ${p.max} characters`,
+    rule_email: () => 'Please enter a valid email address',
+    rule_url: () => 'Please enter a valid URL',
+    rule_pattern: () => "Format doesn't match",
+    // The author's own wording, in whatever language they typed it. Passed
+    // through untouched — translating an author's sentence is not this table's
+    // job, and guessing at its language would be worse than leaving it.
+    author_message: (p) => String(p.text ?? ''),
+};
+/**
+ * Word a message in English.
+ *
+ * An unknown code returns the code itself rather than empty or a throw: a
+ * respondent seeing `max_length` is confusing, but a respondent seeing NOTHING
+ * where a validation error should be is worse — they cannot submit and cannot
+ * tell why.
+ */
+function wordMessage(message) {
+    if (!message)
+        return null;
+    const wording = exports.EN_MESSAGES[message.code];
+    return wording ? wording(message.params || {}) : message.code;
+}
+/** Every code the validator can return, for a translator to work from. */
+exports.MESSAGE_CODES = Object.keys(exports.EN_MESSAGES);

package/dist/resolveVariable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveVariable.d.ts","sourceRoot":"","sources":["../src/resolveVariable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CA4BT"}
+{"version":3,"file":"resolveVariable.d.ts","sourceRoot":"","sources":["../src/resolveVariable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAsCT"}

package/dist/resolveVariable.js

@@ -29,6 +29,10 @@ function resolveVariable(variables, name, suffix) {
     }
     else {
         // 2. Walk the dotted path into nested namespaces.
+        //    OWN properties only. A plain `cursor[seg]` walks the prototype chain,
+        //    so `{{constructor}}` resolved to the Object function and rendered
+        //    "function Object() { [native code] }" to the respondent — the same
+        //    class of leak as the namespace object above, from the same syntax.
         const segments = full.split('.');
         let cursor = variables;
         for (const seg of segments) {
@@ -36,6 +40,10 @@ function resolveVariable(variables, name, suffix) {
                 cursor = undefined;
                 break;
             }
+            if (!Object.prototype.hasOwnProperty.call(cursor, seg)) {
+                cursor = undefined;
+                break;
+            }
             cursor = cursor[seg];
         }
         value = cursor;
@@ -47,5 +55,10 @@ function resolveVariable(variables, name, suffix) {
     //    Arrays are values (a multi-select answer), so they pass.
     if (value !== null && typeof value === 'object' && !Array.isArray(value))
         return undefined;
+    // 4. Nor is a function. `typeof fn` is 'function', not 'object', so the check
+    //    above lets one through, and String(fn) prints its source. Nothing in a
+    //    variable bag should ever be callable, so this only fires on a leak.
+    if (typeof value === 'function')
+        return undefined;
     return value;
 }