@jigx/core-sdk 1.2.0-next.2 → 1.2.0-next.4

package/dist/assets/example-extraction-cache.json

@@ -1,9 +1,9 @@
 {
   "version": "2.0.0",
-  "sourceHash": "ffdacae446d9594adc9f60a9c8e68368",
-  "timestamp": 1787038065610,
+  "sourceHash": "d4e1d2b256b3484699539f4a70ede121",
+  "timestamp": 1789125988357,
   "stats": {
-    "inputFiles": 426,
-    "extractionTimeMs": 272
+    "inputFiles": 427,
+    "extractionTimeMs": 284
   }
 }

package/dist/jsonata/builder.d.ts

@@ -95,15 +95,26 @@ export declare abstract class JsonataBuilderBase<TValue extends JsonataVariableV
     protected validateDeclaredVariables(contextPath: string): JsonataBuilderValidationIssue[];
     private validateDeclaredVariablesWithAst;
     /**
-     * Validate JSONata syntax of expression body.
+     * Validate JSONata syntax of the full built expression, bindings included.
+     *
+     * Parses the same string {@link JsonataBuilderBase._build} emits, so a malformed
+     * `$name := <value>;` declaration is caught here rather than at runtime on device.
+     *
+     * @param contextPath - Context path reported on any issue.
+     * @param ctx - Build-time consumption context used to resolve {@link ResolvableBinding} values.
      */
-    protected validateSyntax(contextPath: string): JsonataBuilderValidationIssue[];
+    protected validateSyntax(contextPath: string, ctx?: JsonataResolutionContext): JsonataBuilderValidationIssue[];
     /**
-     * Run base validation (syntax + declared variables).
+     * Run base validation (syntax of the full built expression + declared variables).
      * Subclasses should call this and then append domain-specific checks.
+     *
+     * @param options.contextPath - Context path reported on any issue.
+     * @param options.ctx - Build-time consumption context, passed through to `_build` so bindings
+     *   are validated exactly as they will be emitted.
      */
     protected _validateBase(options?: {
         contextPath?: string;
+        ctx?: JsonataResolutionContext;
     }): JsonataBuilderValidationResult;
     /**
      * Build final expression string.

package/dist/jsonata/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/jsonata/builder.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,wBAAwB,CAAA;AAExD;;;;;GAKG;AACH,MAAM,WAAW,4BAA4B;IAC3C,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,wFAAwF;IACxF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CACtC;AAED;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,4BAA4B,GAAG,OAAO,mBAAmB,CAAA;AAEhG;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,cAAc,CAAC,GAAG,EAAE,wBAAwB,GAAG,MAAM,CAAA;CACtD;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,iBAAiB,CAAA;AASvF;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,6BAA6B,EAAE,CAAA;CAC1D;AAED;;;;;;;;;GASG;AACH,8BAAsB,kBAAkB,CACtC,MAAM,SAAS,oBAAoB,GAAG,oBAAoB;IAE1D,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjD,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAEzC;;;OAGG;IACH,SAAS,aAAa,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EA+BrE;IAED;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpD;IAED;;OAEG;IACH,SAAS,CAAC,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,6BAA6B,EAAE,CAExF;IAED,OAAO,CAAC,gCAAgC;IAmExC;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,6BAA6B,EAAE,CAqB7E;IAED;;;OAGG;IACH,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,8BAA8B,CAY1F;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,OAAO,EAAE;QAAE,yBAAyB,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,wBAAwB,CAAA;KAAE,GAAG,MAAM,CAa9F;CACF"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/jsonata/builder.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,wBAAwB,CAAA;AAExD;;;;;GAKG;AACH,MAAM,WAAW,4BAA4B;IAC3C,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,wFAAwF;IACxF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CACtC;AAED;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,4BAA4B,GAAG,OAAO,mBAAmB,CAAA;AAEhG;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,cAAc,CAAC,GAAG,EAAE,wBAAwB,GAAG,MAAM,CAAA;CACtD;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,iBAAiB,CAAA;AA8GvF;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,6BAA6B,EAAE,CAAA;CAC1D;AAED;;;;;;;;;GASG;AACH,8BAAsB,kBAAkB,CACtC,MAAM,SAAS,oBAAoB,GAAG,oBAAoB;IAE1D,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjD,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAEzC;;;OAGG;IACH,SAAS,aAAa,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAwDrE;IAED;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpD;IAED;;OAEG;IACH,SAAS,CAAC,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,6BAA6B,EAAE,CAExF;IAED,OAAO,CAAC,gCAAgC;IAmExC;;;;;;;;OAQG;IACH,SAAS,CAAC,cAAc,CACtB,WAAW,EAAE,MAAM,EACnB,GAAG,CAAC,EAAE,wBAAwB,GAC7B,6BAA6B,EAAE,CAejC;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE;QAChC,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,GAAG,CAAC,EAAE,wBAAwB,CAAA;KAC/B,GAAG,8BAA8B,CAYjC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,OAAO,EAAE;QAAE,yBAAyB,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,wBAAwB,CAAA;KAAE,GAAG,MAAM,CAe9F;CACF"}

package/dist/jsonata/builder.js

@@ -16,6 +16,94 @@ export const RECORD_DATA_CONTEXT = 'RECORD_DATA_CONTEXT';
 function isResolvableBinding(value) {
     return value !== null && typeof value === 'object' && typeof value.resolveBinding === 'function';
 }
+/** A JSONata variable name: a letter or underscore, then letters, digits, or underscores. */
+const VARIABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+/**
+ * Does a `@`/`$`-prefixed string denote a JSONata reference rather than literal text?
+ *
+ * Parsing alone is too weak a test — `"$a := 1"` and `"$"` are both valid JSONata, but as a binding
+ * value they inject an assignment and the whole input context respectively. A reference is a `path`
+ * (`"@ctx.a.b"`), a `function` call (`"$now()"`), or a plain named `variable` (`"$someVar"`).
+ *
+ * Excluded, and therefore treated as literal text:
+ * - any `bind`, at the top level or nested — every binding shares one `(...)` block scope, so a
+ *   `:=` anywhere inside a value would reassign a sibling binding.
+ * - a variable whose name is not a plain identifier. The parser is permissive here: `"$"` and
+ *   `"$$"` yield an empty or `$` name, `"$5"` a digit, and `"$\"x\""` a name of `"x"` with the
+ *   quotes kept — each parses and evaluates to `undefined` or the whole input context. Matching
+ *   {@link VARIABLE_NAME_PATTERN} admits only real identifiers, so the rest stay literal text.
+ * - a variable carrying a predicate, such as `"$x[0]"`.
+ */
+function isReferenceFragment(trimmed) {
+    const ast = parseJsonataAst(trimmed);
+    if (ast === null || containsBind(ast)) {
+        return false;
+    }
+    const astType = getAstType(ast);
+    if (astType === 'path' || astType === 'function') {
+        return true;
+    }
+    if (astType !== 'variable') {
+        return false;
+    }
+    const name = getAstString(ast, 'value');
+    return name !== undefined && VARIABLE_NAME_PATTERN.test(name) && ast.predicate === undefined;
+}
+/**
+ * Does an AST assign to a variable anywhere within it?
+ *
+ * A `:=` nested inside an otherwise-valid reference — `"$trim($a := 1)"`, or a path predicate such
+ * as `"@ctx.items[$a := 1].name"` — reassigns whatever sibling binding shares that name, since
+ * {@link JsonataBuilderBase._build} splices every binding into one block scope.
+ */
+function containsBind(ast) {
+    let found = false;
+    visitAst(ast, (node) => {
+        if (getAstType(node) === 'bind') {
+            found = true;
+        }
+    });
+    return found;
+}
+/**
+ * Is a quote-wrapped string a single string literal, rather than an expression that merely starts
+ * and ends with a quote? `'"AB-12"'` is; `'"a" & "b"'` parses as a concatenation and is not.
+ */
+function isSingleStringLiteral(trimmed) {
+    const ast = parseJsonataAst(trimmed);
+    return ast !== null && getAstType(ast) === 'string';
+}
+/**
+ * Emit a string binding value as JSONata source.
+ *
+ * A string is emitted verbatim only when it is genuinely JSONata source: a `@`/`$`-prefixed
+ * reference that parses, or a single quoted literal. Anything else — prose, an empty string, a
+ * price like `"$5"`, a handle like `"@jigx"` — is literal text and is JSON-quoted, so it can
+ * neither produce an unparseable `$name := <value>;` declaration nor silently evaluate to
+ * something other than itself.
+ *
+ * Classification never guesses about an unprefixed, unquoted string: a bare word such as
+ * `Manufacturer` parses as a path lookup, so parsing cannot tell it apart from literal text. Those
+ * are always quoted.
+ */
+function emitStringBinding(value) {
+    const trimmed = value.trim();
+    const isQuoteWrapped = trimmed.length >= 2 &&
+        ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'")));
+    // Raw branches emit `trimmed`, never `value`: classification parses `trimmed`, and
+    // `String.prototype.trim()` strips the whole Unicode `White_Space` set while JSONata's lexer
+    // skips only ASCII whitespace. Emitting `value` would splice a padding NBSP back in and turn
+    // `"hello"` into the field lookup ` "hello" `, which evaluates to `undefined` and still parses,
+    // so validation cannot see it.
+    if (isQuoteWrapped) {
+        return isSingleStringLiteral(trimmed) ? trimmed : JSON.stringify(value);
+    }
+    if (trimmed.startsWith('@') || trimmed.startsWith('$')) {
+        return isReferenceFragment(trimmed) ? trimmed : JSON.stringify(value);
+    }
+    return JSON.stringify(value);
+}
 /**
  * Reusable JSONata builder base for variable-ized expressions.
  *
@@ -39,9 +127,8 @@ export class JsonataBuilderBase {
                 `The "=" prefix is handled internally by the builder.`);
         }
         this.variables = new Map();
-        const variableNamePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
         for (const [name, value] of Object.entries(variables ?? {})) {
-            if (!variableNamePattern.test(name)) {
+            if (!VARIABLE_NAME_PATTERN.test(name)) {
                 throw new Error(`Invalid variable name: "${name}". ` +
                     `Variable names must start with a letter or underscore, ` +
                     `followed by letters, digits, or underscores.`);
@@ -50,6 +137,24 @@ export class JsonataBuilderBase {
                 throw new Error(`Invalid variable value for "${name}": "${value}". ` +
                     `String values must not start with "=".`);
             }
+            // Without these, an object with no `resolveBinding` reaches `String(value)` in `_build` and
+            // emits the unparseable `$name := [object Object];`.
+            if (value instanceof JsonataBuilderBase) {
+                throw new Error(`Invalid variable value for "${name}": a builder cannot be nested inside another ` +
+                    `builder's variables. Inline its body and merge its variables, or pass a field ` +
+                    `reference such as \`field.valueRef()\`.`);
+            }
+            if (typeof value === 'object' && value !== null && !isResolvableBinding(value)) {
+                throw new Error(`Invalid variable value for "${name}": expected a string, number, boolean, null, or a ` +
+                    `ResolvableBinding (e.g. a field reference), but received an object.`);
+            }
+            // `TValue` excludes these, but an `any`-typed or deserialized map reaches here anyway, and
+            // `String(value)` would emit `$name := undefined;` — valid JSONata that evaluates to nothing.
+            const valueType = typeof value;
+            if (valueType === 'undefined' || valueType === 'function' || valueType === 'symbol') {
+                throw new Error(`Invalid variable value for "${name}": expected a string, number, boolean, null, or a ` +
+                    `ResolvableBinding (e.g. a field reference), but received ${valueType}.`);
+            }
             this.variables.set(name, value);
         }
         this.expressionBody = body;
@@ -124,16 +229,17 @@ export class JsonataBuilderBase {
         }));
     }
     /**
-     * Validate JSONata syntax of expression body.
+     * Validate JSONata syntax of the full built expression, bindings included.
+     *
+     * Parses the same string {@link JsonataBuilderBase._build} emits, so a malformed
+     * `$name := <value>;` declaration is caught here rather than at runtime on device.
+     *
+     * @param contextPath - Context path reported on any issue.
+     * @param ctx - Build-time consumption context used to resolve {@link ResolvableBinding} values.
      */
-    validateSyntax(contextPath) {
-        const transformed = transformForValidation(this.expressionBody);
-        let syntaxValidation = validateSyntax(transformed);
-        // Multi-statement JSONata often requires explicit block wrapping.
-        if (!syntaxValidation.isValid) {
-            const wrapped = transformForValidation(`(${this.expressionBody})`);
-            syntaxValidation = validateSyntax(wrapped);
-        }
+    validateSyntax(contextPath, ctx) {
+        const built = this._build({ shouldReturnRawExpression: true, ctx });
+        const syntaxValidation = validateSyntax(transformForValidation(built));
         if (!syntaxValidation.isValid && syntaxValidation.error) {
             return [
                 {
@@ -147,8 +253,12 @@ export class JsonataBuilderBase {
         return [];
     }
     /**
-     * Run base validation (syntax + declared variables).
+     * Run base validation (syntax of the full built expression + declared variables).
      * Subclasses should call this and then append domain-specific checks.
+     *
+     * @param options.contextPath - Context path reported on any issue.
+     * @param options.ctx - Build-time consumption context, passed through to `_build` so bindings
+     *   are validated exactly as they will be emitted.
      */
     _validateBase(options) {
         const contextPath = options?.contextPath ?? '';
@@ -156,7 +266,7 @@ export class JsonataBuilderBase {
         if (!this.expressionBody) {
             return { isValid: true, issues: [] };
         }
-        issues.push(...this.validateSyntax(contextPath));
+        issues.push(...this.validateSyntax(contextPath, options?.ctx));
         issues.push(...this.validateDeclaredVariables(contextPath));
         return { isValid: issues.length === 0, issues };
     }
@@ -176,11 +286,13 @@ export class JsonataBuilderBase {
         for (const [name, value] of this.variables) {
             const emitted = isResolvableBinding(value)
                 ? value.resolveBinding(ctx ?? RECORD_DATA_CONTEXT)
-                : String(value);
+                : typeof value === 'string'
+                    ? emitStringBinding(value)
+                    : String(value);
             jsonata += `$${name} := ${emitted};\n`;
         }
         jsonata += this.expressionBody;
         return shouldReturnRawExpression ? `(${jsonata})` : `=(${jsonata})`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../src/jsonata/builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { extractScopeReferences as extractCanonicalScopeReferences } from './expression.js'\nimport { parseJsonataAst, transformForValidation, validateSyntax } from './expression.js'\nimport { getAstString, getAstType, isAstNode, visitAst } from './ast.js'\n\n/**\n * Sentinel context meaning \"no consumption site — resolve against saved record data.\"\n *\n * Passed instead of a {@link JsonataResolutionContextSite} when a binding is built outside any\n * live component scope (e.g. expert-sdk step-level title/next/isRequired slots, dropdown list\n * data). A {@link ResolvableBinding} treats it as the explicit cross-step/persisted-data branch\n * rather than guessing from an empty object.\n */\nexport const RECORD_DATA_CONTEXT = 'RECORD_DATA_CONTEXT'\n\n/**\n * Site half of a {@link JsonataResolutionContext}: the live consumption site's step/array scope.\n *\n * Opaque to core-sdk: domain SDKs (e.g. expert-sdk) populate these fields and a\n * {@link ResolvableBinding} interprets them to pick the correct scope string.\n */\nexport interface JsonataResolutionContextSite {\n  /** Owning step id of the consumption site, when known. */\n  readonly stepId?: string\n  /** Array name of the consumption site, when the expression is built inside an array. */\n  readonly arrayName?: string\n  /**\n   * True when the site consumes the live current item of a list/array component — its\n   * per-item title/subtitle/description display slots. Same-array refs here resolve to\n   * `@ctx.current.item.*`.\n   */\n  readonly isCurrentItemScope?: boolean\n}\n\n/**\n * Build-time context describing where a JSONata expression is being consumed: either a live\n * {@link JsonataResolutionContextSite} (step/array scope) or the {@link RECORD_DATA_CONTEXT}\n * sentinel for bindings built outside any component scope.\n */\nexport type JsonataResolutionContext = JsonataResolutionContextSite | typeof RECORD_DATA_CONTEXT\n\n/**\n * A binding value that resolves to a JSONata-embeddable string at build time.\n *\n * Lets a domain SDK defer a binding's final scope string until {@link JsonataBuilderBase._build},\n * when the consumption-site {@link JsonataResolutionContext} is known, without coupling core-sdk\n * to the domain types.\n */\nexport interface ResolvableBinding {\n  /**\n   * Resolve to the final scope string given the build-time consumption context.\n   *\n   * @param ctx - Build-time consumption context: a {@link JsonataResolutionContextSite}, or\n   *   {@link RECORD_DATA_CONTEXT} when the binding is built outside any live component scope.\n   * @returns A JSONata-embeddable string (must not start with `=`).\n   */\n  resolveBinding(ctx: JsonataResolutionContext): string\n}\n\nexport type JsonataVariableValue = string | number | boolean | null | ResolvableBinding\n\n/**\n * Type guard for {@link ResolvableBinding} values inside a binding map.\n */\nfunction isResolvableBinding(value: JsonataVariableValue): value is ResolvableBinding {\n  return value !== null && typeof value === 'object' && typeof value.resolveBinding === 'function'\n}\n\n/**\n * Minimal, core-level JSONata validation issue emitted by {@link JsonataBuilderBase}.\n *\n * Domain SDKs can map this to richer issue models.\n */\nexport interface JsonataBuilderValidationIssue {\n  readonly scope: string\n  readonly severity: 'error'\n  readonly contextPath: string\n  readonly message: string\n}\n\n/**\n * Base validation result from {@link JsonataBuilderBase}.\n */\nexport interface JsonataBuilderValidationResult {\n  readonly isValid: boolean\n  readonly issues: readonly JsonataBuilderValidationIssue[]\n}\n\n/**\n * Reusable JSONata builder base for variable-ized expressions.\n *\n * Use this class when you need:\n * - a stable constructor for JSONata body + variables,\n * - syntax + undeclared variable checks,\n * - consistent output formatting (`=...` or raw).\n *\n * Extend this in domain packages (e.g. expert-sdk) to add domain policy checks.\n */\nexport abstract class JsonataBuilderBase<\n  TValue extends JsonataVariableValue = JsonataVariableValue,\n> {\n  protected readonly variables: Map<string, TValue>\n  protected readonly expressionBody: string\n\n  /**\n   * @param body JSONata body expression. Must not start with `=`.\n   * @param variables Optional variables used inside the body as `$name`.\n   */\n  protected constructor(body: string, variables?: Record<string, TValue>) {\n    if (body.startsWith('=')) {\n      throw new Error(\n        `JSONata expression body must not start with \"=\". ` +\n          `The \"=\" prefix is handled internally by the builder.`,\n      )\n    }\n\n    this.variables = new Map()\n    const variableNamePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/\n\n    for (const [name, value] of Object.entries(variables ?? {})) {\n      if (!variableNamePattern.test(name)) {\n        throw new Error(\n          `Invalid variable name: \"${name}\". ` +\n            `Variable names must start with a letter or underscore, ` +\n            `followed by letters, digits, or underscores.`,\n        )\n      }\n\n      if (typeof value === 'string' && value.startsWith('=')) {\n        throw new Error(\n          `Invalid variable value for \"${name}\": \"${value}\". ` +\n            `String values must not start with \"=\".`,\n        )\n      }\n\n      this.variables.set(name, value)\n    }\n\n    this.expressionBody = body\n  }\n\n  /**\n   * Extract canonical `ctx.*` scope references from arbitrary JSONata-like text.\n   */\n  static extractScopeReferences(text: string): string[] {\n    return extractCanonicalScopeReferences(text)\n  }\n\n  /**\n   * Validate `$var` references in expression body are declared, lambda params, or local assignments.\n   */\n  protected validateDeclaredVariables(contextPath: string): JsonataBuilderValidationIssue[] {\n    return this.validateDeclaredVariablesWithAst(contextPath)\n  }\n\n  private validateDeclaredVariablesWithAst(contextPath: string): JsonataBuilderValidationIssue[] {\n    const ast = parseJsonataAst(this.expressionBody)\n    if (ast === null) {\n      return [\n        {\n          scope: this.expressionBody,\n          severity: 'error',\n          contextPath,\n          message: 'Unable to parse JSONata expression for variable validation',\n        },\n      ]\n    }\n\n    const declared = new Set<string>(this.variables.keys())\n    const referenced = new Set<string>()\n    visitAst(ast, (node, parent, keyInParent) => {\n      const nodeType = getAstType(node)\n\n      if (nodeType === 'lambda' && Array.isArray(node.arguments)) {\n        for (const arg of node.arguments) {\n          if (isAstNode(arg) && getAstType(arg) === 'variable') {\n            const varName = getAstString(arg, 'value')\n            if (varName !== undefined) {\n              declared.add(varName)\n            }\n          }\n        }\n      }\n\n      if (nodeType === 'bind' && isAstNode(node.lhs) && getAstType(node.lhs) === 'variable') {\n        const lhsVar = getAstString(node.lhs, 'value')\n        if (lhsVar !== undefined) {\n          declared.add(lhsVar)\n        }\n      }\n\n      if (nodeType === 'variable') {\n        const variableName = getAstString(node, 'value')\n        if (variableName === undefined) return\n\n        const isContextRoot = variableName === '' || variableName === '$'\n        const isFunctionProcedure =\n          parent !== null && getAstType(parent) === 'function' && keyInParent === 'procedure'\n        if (!isContextRoot && !isFunctionProcedure) {\n          referenced.add(variableName)\n        }\n      }\n    })\n\n    const undeclared = Array.from(referenced).filter((name) => !declared.has(name))\n    if (undeclared.length === 0) {\n      return []\n    }\n\n    const variableList = undeclared.join(', ')\n    const message =\n      `JSONata expression references undeclared variables: ${variableList}. ` +\n      `Declare them in the variables map passed to the builder constructor.`\n\n    return undeclared.map((name) => ({\n      scope: `$${name}`,\n      severity: 'error' as const,\n      contextPath,\n      message,\n    }))\n  }\n\n  /**\n   * Validate JSONata syntax of expression body.\n   */\n  protected validateSyntax(contextPath: string): JsonataBuilderValidationIssue[] {\n    const transformed = transformForValidation(this.expressionBody)\n    let syntaxValidation = validateSyntax(transformed)\n\n    // Multi-statement JSONata often requires explicit block wrapping.\n    if (!syntaxValidation.isValid) {\n      const wrapped = transformForValidation(`(${this.expressionBody})`)\n      syntaxValidation = validateSyntax(wrapped)\n    }\n\n    if (!syntaxValidation.isValid && syntaxValidation.error) {\n      return [\n        {\n          scope: this.expressionBody,\n          severity: 'error',\n          contextPath,\n          message: syntaxValidation.error,\n        },\n      ]\n    }\n    return []\n  }\n\n  /**\n   * Run base validation (syntax + declared variables).\n   * Subclasses should call this and then append domain-specific checks.\n   */\n  protected _validateBase(options?: { contextPath?: string }): JsonataBuilderValidationResult {\n    const contextPath = options?.contextPath ?? ''\n    const issues: JsonataBuilderValidationIssue[] = []\n\n    if (!this.expressionBody) {\n      return { isValid: true, issues: [] }\n    }\n\n    issues.push(...this.validateSyntax(contextPath))\n    issues.push(...this.validateDeclaredVariables(contextPath))\n\n    return { isValid: issues.length === 0, issues }\n  }\n\n  /**\n   * Build final expression string.\n   *\n   * Resolvable bindings are resolved against `ctx` (or {@link RECORD_DATA_CONTEXT} when omitted);\n   * `null` and scalar bindings are emitted verbatim.\n   *\n   * @param options.shouldReturnRawExpression - Return `(${body})` instead of `=(${body})`.\n   * @param options.ctx - Build-time consumption context used to resolve {@link ResolvableBinding} values.\n   * @returns `=(${body})` by default, or `(${body})` when `shouldReturnRawExpression` is true.\n   */\n  _build(options: { shouldReturnRawExpression: boolean; ctx?: JsonataResolutionContext }): string {\n    const { shouldReturnRawExpression, ctx } = options\n    let jsonata = ''\n\n    for (const [name, value] of this.variables) {\n      const emitted = isResolvableBinding(value)\n        ? value.resolveBinding(ctx ?? RECORD_DATA_CONTEXT)\n        : String(value)\n      jsonata += `$${name} := ${emitted};\\n`\n    }\n\n    jsonata += this.expressionBody\n    return shouldReturnRawExpression ? `(${jsonata})` : `=(${jsonata})`\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../src/jsonata/builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { extractScopeReferences as extractCanonicalScopeReferences } from './expression.js'\nimport { parseJsonataAst, transformForValidation, validateSyntax } from './expression.js'\nimport { getAstString, getAstType, isAstNode, visitAst } from './ast.js'\n\n/**\n * Sentinel context meaning \"no consumption site — resolve against saved record data.\"\n *\n * Passed instead of a {@link JsonataResolutionContextSite} when a binding is built outside any\n * live component scope (e.g. expert-sdk step-level title/next/isRequired slots, dropdown list\n * data). A {@link ResolvableBinding} treats it as the explicit cross-step/persisted-data branch\n * rather than guessing from an empty object.\n */\nexport const RECORD_DATA_CONTEXT = 'RECORD_DATA_CONTEXT'\n\n/**\n * Site half of a {@link JsonataResolutionContext}: the live consumption site's step/array scope.\n *\n * Opaque to core-sdk: domain SDKs (e.g. expert-sdk) populate these fields and a\n * {@link ResolvableBinding} interprets them to pick the correct scope string.\n */\nexport interface JsonataResolutionContextSite {\n  /** Owning step id of the consumption site, when known. */\n  readonly stepId?: string\n  /** Array name of the consumption site, when the expression is built inside an array. */\n  readonly arrayName?: string\n  /**\n   * True when the site consumes the live current item of a list/array component — its\n   * per-item title/subtitle/description display slots. Same-array refs here resolve to\n   * `@ctx.current.item.*`.\n   */\n  readonly isCurrentItemScope?: boolean\n}\n\n/**\n * Build-time context describing where a JSONata expression is being consumed: either a live\n * {@link JsonataResolutionContextSite} (step/array scope) or the {@link RECORD_DATA_CONTEXT}\n * sentinel for bindings built outside any component scope.\n */\nexport type JsonataResolutionContext = JsonataResolutionContextSite | typeof RECORD_DATA_CONTEXT\n\n/**\n * A binding value that resolves to a JSONata-embeddable string at build time.\n *\n * Lets a domain SDK defer a binding's final scope string until {@link JsonataBuilderBase._build},\n * when the consumption-site {@link JsonataResolutionContext} is known, without coupling core-sdk\n * to the domain types.\n */\nexport interface ResolvableBinding {\n  /**\n   * Resolve to the final scope string given the build-time consumption context.\n   *\n   * @param ctx - Build-time consumption context: a {@link JsonataResolutionContextSite}, or\n   *   {@link RECORD_DATA_CONTEXT} when the binding is built outside any live component scope.\n   * @returns A JSONata-embeddable string (must not start with `=`).\n   */\n  resolveBinding(ctx: JsonataResolutionContext): string\n}\n\nexport type JsonataVariableValue = string | number | boolean | null | ResolvableBinding\n\n/**\n * Type guard for {@link ResolvableBinding} values inside a binding map.\n */\nfunction isResolvableBinding(value: JsonataVariableValue): value is ResolvableBinding {\n  return value !== null && typeof value === 'object' && typeof value.resolveBinding === 'function'\n}\n\n/** A JSONata variable name: a letter or underscore, then letters, digits, or underscores. */\nconst VARIABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/\n\n/**\n * Does a `@`/`$`-prefixed string denote a JSONata reference rather than literal text?\n *\n * Parsing alone is too weak a test — `\"$a := 1\"` and `\"$\"` are both valid JSONata, but as a binding\n * value they inject an assignment and the whole input context respectively. A reference is a `path`\n * (`\"@ctx.a.b\"`), a `function` call (`\"$now()\"`), or a plain named `variable` (`\"$someVar\"`).\n *\n * Excluded, and therefore treated as literal text:\n * - any `bind`, at the top level or nested — every binding shares one `(...)` block scope, so a\n *   `:=` anywhere inside a value would reassign a sibling binding.\n * - a variable whose name is not a plain identifier. The parser is permissive here: `\"$\"` and\n *   `\"$$\"` yield an empty or `$` name, `\"$5\"` a digit, and `\"$\\\"x\\\"\"` a name of `\"x\"` with the\n *   quotes kept — each parses and evaluates to `undefined` or the whole input context. Matching\n *   {@link VARIABLE_NAME_PATTERN} admits only real identifiers, so the rest stay literal text.\n * - a variable carrying a predicate, such as `\"$x[0]\"`.\n */\nfunction isReferenceFragment(trimmed: string): boolean {\n  const ast = parseJsonataAst(trimmed)\n  if (ast === null || containsBind(ast)) {\n    return false\n  }\n\n  const astType = getAstType(ast)\n  if (astType === 'path' || astType === 'function') {\n    return true\n  }\n\n  if (astType !== 'variable') {\n    return false\n  }\n\n  const name = getAstString(ast, 'value')\n  return name !== undefined && VARIABLE_NAME_PATTERN.test(name) && ast.predicate === undefined\n}\n\n/**\n * Does an AST assign to a variable anywhere within it?\n *\n * A `:=` nested inside an otherwise-valid reference — `\"$trim($a := 1)\"`, or a path predicate such\n * as `\"@ctx.items[$a := 1].name\"` — reassigns whatever sibling binding shares that name, since\n * {@link JsonataBuilderBase._build} splices every binding into one block scope.\n */\nfunction containsBind(ast: Record<string, unknown>): boolean {\n  let found = false\n  visitAst(ast, (node) => {\n    if (getAstType(node) === 'bind') {\n      found = true\n    }\n  })\n  return found\n}\n\n/**\n * Is a quote-wrapped string a single string literal, rather than an expression that merely starts\n * and ends with a quote? `'\"AB-12\"'` is; `'\"a\" & \"b\"'` parses as a concatenation and is not.\n */\nfunction isSingleStringLiteral(trimmed: string): boolean {\n  const ast = parseJsonataAst(trimmed)\n  return ast !== null && getAstType(ast) === 'string'\n}\n\n/**\n * Emit a string binding value as JSONata source.\n *\n * A string is emitted verbatim only when it is genuinely JSONata source: a `@`/`$`-prefixed\n * reference that parses, or a single quoted literal. Anything else — prose, an empty string, a\n * price like `\"$5\"`, a handle like `\"@jigx\"` — is literal text and is JSON-quoted, so it can\n * neither produce an unparseable `$name := <value>;` declaration nor silently evaluate to\n * something other than itself.\n *\n * Classification never guesses about an unprefixed, unquoted string: a bare word such as\n * `Manufacturer` parses as a path lookup, so parsing cannot tell it apart from literal text. Those\n * are always quoted.\n */\nfunction emitStringBinding(value: string): string {\n  const trimmed = value.trim()\n\n  const isQuoteWrapped =\n    trimmed.length >= 2 &&\n    ((trimmed.startsWith('\"') && trimmed.endsWith('\"')) ||\n      (trimmed.startsWith(\"'\") && trimmed.endsWith(\"'\")))\n\n  // Raw branches emit `trimmed`, never `value`: classification parses `trimmed`, and\n  // `String.prototype.trim()` strips the whole Unicode `White_Space` set while JSONata's lexer\n  // skips only ASCII whitespace. Emitting `value` would splice a padding NBSP back in and turn\n  // `\"hello\"` into the field lookup ` \"hello\" `, which evaluates to `undefined` and still parses,\n  // so validation cannot see it.\n  if (isQuoteWrapped) {\n    return isSingleStringLiteral(trimmed) ? trimmed : JSON.stringify(value)\n  }\n\n  if (trimmed.startsWith('@') || trimmed.startsWith('$')) {\n    return isReferenceFragment(trimmed) ? trimmed : JSON.stringify(value)\n  }\n\n  return JSON.stringify(value)\n}\n\n/**\n * Minimal, core-level JSONata validation issue emitted by {@link JsonataBuilderBase}.\n *\n * Domain SDKs can map this to richer issue models.\n */\nexport interface JsonataBuilderValidationIssue {\n  readonly scope: string\n  readonly severity: 'error'\n  readonly contextPath: string\n  readonly message: string\n}\n\n/**\n * Base validation result from {@link JsonataBuilderBase}.\n */\nexport interface JsonataBuilderValidationResult {\n  readonly isValid: boolean\n  readonly issues: readonly JsonataBuilderValidationIssue[]\n}\n\n/**\n * Reusable JSONata builder base for variable-ized expressions.\n *\n * Use this class when you need:\n * - a stable constructor for JSONata body + variables,\n * - syntax + undeclared variable checks,\n * - consistent output formatting (`=...` or raw).\n *\n * Extend this in domain packages (e.g. expert-sdk) to add domain policy checks.\n */\nexport abstract class JsonataBuilderBase<\n  TValue extends JsonataVariableValue = JsonataVariableValue,\n> {\n  protected readonly variables: Map<string, TValue>\n  protected readonly expressionBody: string\n\n  /**\n   * @param body JSONata body expression. Must not start with `=`.\n   * @param variables Optional variables used inside the body as `$name`.\n   */\n  protected constructor(body: string, variables?: Record<string, TValue>) {\n    if (body.startsWith('=')) {\n      throw new Error(\n        `JSONata expression body must not start with \"=\". ` +\n          `The \"=\" prefix is handled internally by the builder.`,\n      )\n    }\n\n    this.variables = new Map()\n    for (const [name, value] of Object.entries(variables ?? {})) {\n      if (!VARIABLE_NAME_PATTERN.test(name)) {\n        throw new Error(\n          `Invalid variable name: \"${name}\". ` +\n            `Variable names must start with a letter or underscore, ` +\n            `followed by letters, digits, or underscores.`,\n        )\n      }\n\n      if (typeof value === 'string' && value.startsWith('=')) {\n        throw new Error(\n          `Invalid variable value for \"${name}\": \"${value}\". ` +\n            `String values must not start with \"=\".`,\n        )\n      }\n\n      // Without these, an object with no `resolveBinding` reaches `String(value)` in `_build` and\n      // emits the unparseable `$name := [object Object];`.\n      if (value instanceof JsonataBuilderBase) {\n        throw new Error(\n          `Invalid variable value for \"${name}\": a builder cannot be nested inside another ` +\n            `builder's variables. Inline its body and merge its variables, or pass a field ` +\n            `reference such as \\`field.valueRef()\\`.`,\n        )\n      }\n\n      if (typeof value === 'object' && value !== null && !isResolvableBinding(value)) {\n        throw new Error(\n          `Invalid variable value for \"${name}\": expected a string, number, boolean, null, or a ` +\n            `ResolvableBinding (e.g. a field reference), but received an object.`,\n        )\n      }\n\n      // `TValue` excludes these, but an `any`-typed or deserialized map reaches here anyway, and\n      // `String(value)` would emit `$name := undefined;` — valid JSONata that evaluates to nothing.\n      const valueType = typeof value\n      if (valueType === 'undefined' || valueType === 'function' || valueType === 'symbol') {\n        throw new Error(\n          `Invalid variable value for \"${name}\": expected a string, number, boolean, null, or a ` +\n            `ResolvableBinding (e.g. a field reference), but received ${valueType}.`,\n        )\n      }\n\n      this.variables.set(name, value)\n    }\n\n    this.expressionBody = body\n  }\n\n  /**\n   * Extract canonical `ctx.*` scope references from arbitrary JSONata-like text.\n   */\n  static extractScopeReferences(text: string): string[] {\n    return extractCanonicalScopeReferences(text)\n  }\n\n  /**\n   * Validate `$var` references in expression body are declared, lambda params, or local assignments.\n   */\n  protected validateDeclaredVariables(contextPath: string): JsonataBuilderValidationIssue[] {\n    return this.validateDeclaredVariablesWithAst(contextPath)\n  }\n\n  private validateDeclaredVariablesWithAst(contextPath: string): JsonataBuilderValidationIssue[] {\n    const ast = parseJsonataAst(this.expressionBody)\n    if (ast === null) {\n      return [\n        {\n          scope: this.expressionBody,\n          severity: 'error',\n          contextPath,\n          message: 'Unable to parse JSONata expression for variable validation',\n        },\n      ]\n    }\n\n    const declared = new Set<string>(this.variables.keys())\n    const referenced = new Set<string>()\n    visitAst(ast, (node, parent, keyInParent) => {\n      const nodeType = getAstType(node)\n\n      if (nodeType === 'lambda' && Array.isArray(node.arguments)) {\n        for (const arg of node.arguments) {\n          if (isAstNode(arg) && getAstType(arg) === 'variable') {\n            const varName = getAstString(arg, 'value')\n            if (varName !== undefined) {\n              declared.add(varName)\n            }\n          }\n        }\n      }\n\n      if (nodeType === 'bind' && isAstNode(node.lhs) && getAstType(node.lhs) === 'variable') {\n        const lhsVar = getAstString(node.lhs, 'value')\n        if (lhsVar !== undefined) {\n          declared.add(lhsVar)\n        }\n      }\n\n      if (nodeType === 'variable') {\n        const variableName = getAstString(node, 'value')\n        if (variableName === undefined) return\n\n        const isContextRoot = variableName === '' || variableName === '$'\n        const isFunctionProcedure =\n          parent !== null && getAstType(parent) === 'function' && keyInParent === 'procedure'\n        if (!isContextRoot && !isFunctionProcedure) {\n          referenced.add(variableName)\n        }\n      }\n    })\n\n    const undeclared = Array.from(referenced).filter((name) => !declared.has(name))\n    if (undeclared.length === 0) {\n      return []\n    }\n\n    const variableList = undeclared.join(', ')\n    const message =\n      `JSONata expression references undeclared variables: ${variableList}. ` +\n      `Declare them in the variables map passed to the builder constructor.`\n\n    return undeclared.map((name) => ({\n      scope: `$${name}`,\n      severity: 'error' as const,\n      contextPath,\n      message,\n    }))\n  }\n\n  /**\n   * Validate JSONata syntax of the full built expression, bindings included.\n   *\n   * Parses the same string {@link JsonataBuilderBase._build} emits, so a malformed\n   * `$name := <value>;` declaration is caught here rather than at runtime on device.\n   *\n   * @param contextPath - Context path reported on any issue.\n   * @param ctx - Build-time consumption context used to resolve {@link ResolvableBinding} values.\n   */\n  protected validateSyntax(\n    contextPath: string,\n    ctx?: JsonataResolutionContext,\n  ): JsonataBuilderValidationIssue[] {\n    const built = this._build({ shouldReturnRawExpression: true, ctx })\n    const syntaxValidation = validateSyntax(transformForValidation(built))\n\n    if (!syntaxValidation.isValid && syntaxValidation.error) {\n      return [\n        {\n          scope: this.expressionBody,\n          severity: 'error',\n          contextPath,\n          message: syntaxValidation.error,\n        },\n      ]\n    }\n    return []\n  }\n\n  /**\n   * Run base validation (syntax of the full built expression + declared variables).\n   * Subclasses should call this and then append domain-specific checks.\n   *\n   * @param options.contextPath - Context path reported on any issue.\n   * @param options.ctx - Build-time consumption context, passed through to `_build` so bindings\n   *   are validated exactly as they will be emitted.\n   */\n  protected _validateBase(options?: {\n    contextPath?: string\n    ctx?: JsonataResolutionContext\n  }): JsonataBuilderValidationResult {\n    const contextPath = options?.contextPath ?? ''\n    const issues: JsonataBuilderValidationIssue[] = []\n\n    if (!this.expressionBody) {\n      return { isValid: true, issues: [] }\n    }\n\n    issues.push(...this.validateSyntax(contextPath, options?.ctx))\n    issues.push(...this.validateDeclaredVariables(contextPath))\n\n    return { isValid: issues.length === 0, issues }\n  }\n\n  /**\n   * Build final expression string.\n   *\n   * Resolvable bindings are resolved against `ctx` (or {@link RECORD_DATA_CONTEXT} when omitted);\n   * `null` and scalar bindings are emitted verbatim.\n   *\n   * @param options.shouldReturnRawExpression - Return `(${body})` instead of `=(${body})`.\n   * @param options.ctx - Build-time consumption context used to resolve {@link ResolvableBinding} values.\n   * @returns `=(${body})` by default, or `(${body})` when `shouldReturnRawExpression` is true.\n   */\n  _build(options: { shouldReturnRawExpression: boolean; ctx?: JsonataResolutionContext }): string {\n    const { shouldReturnRawExpression, ctx } = options\n    let jsonata = ''\n\n    for (const [name, value] of this.variables) {\n      const emitted = isResolvableBinding(value)\n        ? value.resolveBinding(ctx ?? RECORD_DATA_CONTEXT)\n        : typeof value === 'string'\n          ? emitStringBinding(value)\n          : String(value)\n      jsonata += `$${name} := ${emitted};\\n`\n    }\n\n    jsonata += this.expressionBody\n    return shouldReturnRawExpression ? `(${jsonata})` : `=(${jsonata})`\n  }\n}\n"]}

package/docs/pattern-build-deploy.md

@@ -33,7 +33,7 @@ npx tsx workspace/build.ts workspace/acumatica-apps/create-customer
 npx tsx workspace/build-yaml.ts workspace/acumatica-apps/create-customer
 
 # Deploy (env vars or .env)
-STAMP=PROD ORGANIZATION_ID="..." JIGX_API_KEY="..." \
+STAMP=CLF-PROD ORGANIZATION_ID="..." JIGX_API_KEY="..." \
   ./workspace/acumatica-apps/create-customer/build-publish.sh
 ```
 
@@ -87,5 +87,5 @@ All calls use `Authorization: Bearer {JIGX_API_KEY}`.
 Inline env vars override `.env` defaults — pass credentials on the command line to avoid storing prod keys:
 
 ```bash
-STAMP=PROD ORGANIZATION_ID="..." JIGX_API_KEY="..." ./workspace/acumatica-apps/create-customer/build-publish.sh
+STAMP=CLF-PROD ORGANIZATION_ID="..." JIGX_API_KEY="..." ./workspace/acumatica-apps/create-customer/build-publish.sh
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jigx/core-sdk",
-  "version": "1.2.0-next.2",
+  "version": "1.2.0-next.4",
   "description": "Jigx Software Development Kit - SDK for building Jigx applications",
   "type": "module",
   "main": "dist/index.js",