@jigx/core-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './abstract/index.js';
+export * from './action/index.js';
+export { type Application, type ApplicationInput, ApplicationBuilder, CTX, } from './application/index.js';
+export * from './component/index.js';
+export * from './database/index.js';
+export * from './datasource/index.js';
+export * from './function/index.js';
+export * from './icon/index.js';
+export * from './jsonata/index.js';
+export * from './runtime/index.js';
+export * from './screen/index.js';
+export * from './widget/index.js';
+export { PACKAGE } from './PACKAGE.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsbUJBQW1CLENBQUE7QUFDakMsT0FBTyxFQUNMLEtBQUssV0FBVyxFQUNoQixLQUFLLGdCQUFnQixFQUNyQixrQkFBa0IsRUFDbEIsR0FBRyxHQUNKLE1BQU0sd0JBQXdCLENBQUE7QUFFL0IsY0FBYyxzQkFBc0IsQ0FBQTtBQUNwQyxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsdUJBQXVCLENBQUE7QUFDckMsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLGlCQUFpQixDQUFBO0FBQy9CLGNBQWMsb0JBQW9CLENBQUE7QUFFbEMsY0FBYyxvQkFBb0IsQ0FBQTtBQUNsQyxjQUFjLG1CQUFtQixDQUFBO0FBQ2pDLGNBQWMsbUJBQW1CLENBQUE7QUFDakMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGNBQWMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3QvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2FjdGlvbi9pbmRleC5qcydcbmV4cG9ydCB7XG4gIHR5cGUgQXBwbGljYXRpb24sXG4gIHR5cGUgQXBwbGljYXRpb25JbnB1dCxcbiAgQXBwbGljYXRpb25CdWlsZGVyLFxuICBDVFgsXG59IGZyb20gJy4vYXBwbGljYXRpb24vaW5kZXguanMnXG4vLyBleHBvcnQgKiBmcm9tICcuL2J1aWxkZXIvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC9pbmRleC5qcydcbmV4cG9ydCAqIGZyb20gJy4vZGF0YWJhc2UvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2RhdGFzb3VyY2UvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2Z1bmN0aW9uL2luZGV4LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9pY29uL2luZGV4LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9qc29uYXRhL2luZGV4LmpzJ1xuLy8gZXhwb3J0ICogZnJvbSAnLi9sb2dnZXIvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL3J1bnRpbWUvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL3NjcmVlbi9pbmRleC5qcydcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0L2luZGV4LmpzJ1xuZXhwb3J0IHsgUEFDS0FHRSB9IGZyb20gJy4vUEFDS0FHRS5qcydcbiJdfQ==

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,kBAAkB,EAClB,GAAG,GACJ,MAAM,wBAAwB,CAAA;AAE/B,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAElC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA","sourcesContent":["export * from './abstract/index.js'\nexport * from './action/index.js'\nexport {\n  type Application,\n  type ApplicationInput,\n  ApplicationBuilder,\n  CTX,\n} from './application/index.js'\n// export * from './builder/index.js'\nexport * from './component/index.js'\nexport * from './database/index.js'\nexport * from './datasource/index.js'\nexport * from './function/index.js'\nexport * from './icon/index.js'\nexport * from './jsonata/index.js'\n// export * from './logger/index.js'\nexport * from './runtime/index.js'\nexport * from './screen/index.js'\nexport * from './widget/index.js'\nexport { PACKAGE } from './PACKAGE.js'\n"]}

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from './abstract/index.js';
+export * from './action/index.js';
+export { ApplicationBuilder, CTX, } from './application/index.js';
+export * from './component/index.js';
+export * from './database/index.js';
+export * from './datasource/index.js';
+export * from './function/index.js';
+export * from './icon/index.js';
+export * from './jsonata/index.js';
+export * from './runtime/index.js';
+export * from './screen/index.js';
+export * from './widget/index.js';
+export { PACKAGE } from './PACKAGE.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLG1CQUFtQixDQUFBO0FBQ2pDLE9BQU8sRUFHTCxrQkFBa0IsRUFDbEIsR0FBRyxHQUNKLE1BQU0sd0JBQXdCLENBQUE7QUFFL0IsY0FBYyxzQkFBc0IsQ0FBQTtBQUNwQyxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsdUJBQXVCLENBQUE7QUFDckMsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLGlCQUFpQixDQUFBO0FBQy9CLGNBQWMsb0JBQW9CLENBQUE7QUFFbEMsY0FBYyxvQkFBb0IsQ0FBQTtBQUNsQyxjQUFjLG1CQUFtQixDQUFBO0FBQ2pDLGNBQWMsbUJBQW1CLENBQUE7QUFDakMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGNBQWMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3QvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2FjdGlvbi9pbmRleC5qcydcbmV4cG9ydCB7XG4gIHR5cGUgQXBwbGljYXRpb24sXG4gIHR5cGUgQXBwbGljYXRpb25JbnB1dCxcbiAgQXBwbGljYXRpb25CdWlsZGVyLFxuICBDVFgsXG59IGZyb20gJy4vYXBwbGljYXRpb24vaW5kZXguanMnXG4vLyBleHBvcnQgKiBmcm9tICcuL2J1aWxkZXIvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC9pbmRleC5qcydcbmV4cG9ydCAqIGZyb20gJy4vZGF0YWJhc2UvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2RhdGFzb3VyY2UvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2Z1bmN0aW9uL2luZGV4LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9pY29uL2luZGV4LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9qc29uYXRhL2luZGV4LmpzJ1xuLy8gZXhwb3J0ICogZnJvbSAnLi9sb2dnZXIvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL3J1bnRpbWUvaW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL3NjcmVlbi9pbmRleC5qcydcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0L2luZGV4LmpzJ1xuZXhwb3J0IHsgUEFDS0FHRSB9IGZyb20gJy4vUEFDS0FHRS5qcydcbiJdfQ==

package/dist/jsonata/ast.d.ts

@@ -0,0 +1,15 @@
+export interface FullContextReference {
+    readonly original: string;
+    readonly prefix: '@ctx';
+    readonly segments: string[];
+}
+type AstNode = Record<string, unknown>;
+export declare function parseAstFromTransformed(transformed: string): AstNode | null;
+export declare function isAstNode(value: unknown): value is AstNode;
+export declare function getAstType(node: AstNode): string | null;
+export declare function getAstString(node: AstNode, key: string): string | undefined;
+export declare function visitAst(value: unknown, visitor: (node: AstNode, parent: AstNode | null, keyInParent?: string) => void): void;
+export declare function extractContextReferencesFromAstNode(ast: Record<string, unknown>): FullContextReference[];
+export declare function extractContextFunctionReferencesFromAstNode(ast: Record<string, unknown>): string[];
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/jsonata/ast.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,oBAAoB;IAEnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IAEzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAC5B;AAED,KAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAMtC,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAU3E;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAEvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE3E;AAED,wBAAgB,QAAQ,CACtB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,EAAE,WAAW,CAAC,EAAE,MAAM,KAAK,IAAI,GAC7E,IAAI,CAcN;AAED,wBAAgB,mCAAmC,CACjD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,oBAAoB,EAAE,CA6DxB;AAED,wBAAgB,2CAA2C,CACzD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,MAAM,EAAE,CA0BV","sourcesContent":["import jsonata from 'jsonata'\n\n/**\n * Normalized context reference extracted from JSONata AST traversal.\n */\nexport interface FullContextReference {\n  /** Original reference token as found in expression text. */\n  readonly original: string\n  /** Canonical prefix used for extracted references. */\n  readonly prefix: '@ctx'\n  /** Parsed path segments (bracket access normalized to `@bracket`). */\n  readonly segments: string[]\n}\n\ntype AstNode = Record<string, unknown>\n\n/**\n * Parse transformed JSONata text.\n * Tries direct parse first, then wrapped block form for multi-statement expressions.\n */\nexport function parseAstFromTransformed(transformed: string): AstNode | null {\n  try {\n    return jsonata(transformed).ast() as unknown as AstNode\n  } catch {\n    try {\n      return jsonata(`(${transformed})`).ast() as unknown as AstNode\n    } catch {\n      return null\n    }\n  }\n}\n\nexport function isAstNode(value: unknown): value is AstNode {\n  return typeof value === 'object' && value !== null\n}\n\nexport function getAstType(node: AstNode): string | null {\n  return typeof node.type === 'string' ? node.type : null\n}\n\nexport function getAstString(node: AstNode, key: string): string | undefined {\n  return typeof node[key] === 'string' ? node[key] : undefined\n}\n\nexport function visitAst(\n  value: unknown,\n  visitor: (node: AstNode, parent: AstNode | null, keyInParent?: string) => void,\n): void {\n  const walk = (current: unknown, parent: AstNode | null, keyInParent?: string): void => {\n    if (!isAstNode(current)) return\n    visitor(current, parent, keyInParent)\n    for (const [k, v] of Object.entries(current)) {\n      if (Array.isArray(v)) {\n        for (const child of v) walk(child, current, k)\n      } else {\n        walk(v, current, k)\n      }\n    }\n  }\n\n  walk(value, null)\n}\n\nexport function extractContextReferencesFromAstNode(\n  ast: Record<string, unknown>,\n): FullContextReference[] {\n  const root = ast as AstNode\n  const refs: FullContextReference[] = []\n\n  const addPathRef = (node: AstNode): void => {\n    // Context refs are JSONata paths rooted at `$`.\n    const steps = Array.isArray(node.steps) ? node.steps : null\n    // Need at least root + one named segment.\n    if (!steps || steps.length < 2) return\n\n    const first = steps[0]\n    // Only treat root variable paths as context references.\n    if (!isAstNode(first)) return\n    if (getAstType(first) !== 'variable') return\n    if (first.value !== '$') return\n\n    const segments: string[] = []\n    for (let i = 1; i < steps.length; i++) {\n      const step = steps[i]\n      // Only named path segments contribute to extracted context path.\n      if (!isAstNode(step)) continue\n      if (getAstType(step) !== 'name') continue\n      if (typeof step.value !== 'string') continue\n      segments.push(step.value)\n\n      // Filter stages correspond to bracket access (`[...]`) on this path step.\n      const stages = Array.isArray(step.stages) ? step.stages : null\n      if (stages) {\n        for (const stage of stages) {\n          if (isAstNode(stage) && getAstType(stage) === 'filter') {\n            segments.push('@bracket')\n          }\n        }\n      }\n    }\n\n    // Skip empty/invalid paths; otherwise emit canonical @ctx.* form.\n    if (segments.length > 0) {\n      refs.push({\n        original: `@ctx.${segments.filter((s) => s !== '@bracket').join('.')}`,\n        prefix: '@ctx',\n        segments,\n      })\n    }\n  }\n\n  visitAst(root, (node) => {\n    // Collect path references at this node before traversing children.\n    if (getAstType(node) === 'path') {\n      addPathRef(node)\n    }\n  })\n\n  const seen = new Set<string>()\n  // Deduplicate equivalent references found multiple times in traversal.\n  return refs.filter((r) => {\n    const key = `${r.prefix}:${r.segments.join('.')}`\n    if (seen.has(key)) return false\n    seen.add(key)\n    return true\n  })\n}\n\nexport function extractContextFunctionReferencesFromAstNode(\n  ast: Record<string, unknown>,\n): string[] {\n  const root = ast as AstNode\n  const refs = new Set<string>()\n\n  visitAst(root, (node) => {\n    // Function refs are procedures that resolve to root-path calls.\n    if (getAstType(node) === 'function' && isAstNode(node.procedure)) {\n      const proc = node.procedure\n      if (getAstType(proc) === 'path' && Array.isArray(proc.steps) && proc.steps.length >= 2) {\n        const first = proc.steps[0]\n        const second = proc.steps[1]\n        // Match `$.<fnName>(...)` and normalize to `@ctx.<fnName>`.\n        if (\n          isAstNode(first) &&\n          getAstType(first) === 'variable' &&\n          first.value === '$' &&\n          isAstNode(second) &&\n          getAstType(second) === 'name' &&\n          typeof second.value === 'string'\n        ) {\n          refs.add(`@ctx.${second.value}`)\n        }\n      }\n    }\n  })\n  return Array.from(refs)\n}\n"]}

package/dist/jsonata/ast.js

@@ -0,0 +1,118 @@
+import jsonata from 'jsonata';
+export function parseAstFromTransformed(transformed) {
+    try {
+        return jsonata(transformed).ast();
+    }
+    catch {
+        try {
+            return jsonata(`(${transformed})`).ast();
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export function isAstNode(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function getAstType(node) {
+    return typeof node.type === 'string' ? node.type : null;
+}
+export function getAstString(node, key) {
+    return typeof node[key] === 'string' ? node[key] : undefined;
+}
+export function visitAst(value, visitor) {
+    const walk = (current, parent, keyInParent) => {
+        if (!isAstNode(current))
+            return;
+        visitor(current, parent, keyInParent);
+        for (const [k, v] of Object.entries(current)) {
+            if (Array.isArray(v)) {
+                for (const child of v)
+                    walk(child, current, k);
+            }
+            else {
+                walk(v, current, k);
+            }
+        }
+    };
+    walk(value, null);
+}
+export function extractContextReferencesFromAstNode(ast) {
+    const root = ast;
+    const refs = [];
+    const addPathRef = (node) => {
+        const steps = Array.isArray(node.steps) ? node.steps : null;
+        if (!steps || steps.length < 2)
+            return;
+        const first = steps[0];
+        if (!isAstNode(first))
+            return;
+        if (getAstType(first) !== 'variable')
+            return;
+        if (first.value !== '$')
+            return;
+        const segments = [];
+        for (let i = 1; i < steps.length; i++) {
+            const step = steps[i];
+            if (!isAstNode(step))
+                continue;
+            if (getAstType(step) !== 'name')
+                continue;
+            if (typeof step.value !== 'string')
+                continue;
+            segments.push(step.value);
+            const stages = Array.isArray(step.stages) ? step.stages : null;
+            if (stages) {
+                for (const stage of stages) {
+                    if (isAstNode(stage) && getAstType(stage) === 'filter') {
+                        segments.push('@bracket');
+                    }
+                }
+            }
+        }
+        if (segments.length > 0) {
+            refs.push({
+                original: `@ctx.${segments.filter((s) => s !== '@bracket').join('.')}`,
+                prefix: '@ctx',
+                segments,
+            });
+        }
+    };
+    visitAst(root, (node) => {
+        if (getAstType(node) === 'path') {
+            addPathRef(node);
+        }
+    });
+    const seen = new Set();
+    return refs.filter((r) => {
+        const key = `${r.prefix}:${r.segments.join('.')}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export function extractContextFunctionReferencesFromAstNode(ast) {
+    const root = ast;
+    const refs = new Set();
+    visitAst(root, (node) => {
+        if (getAstType(node) === 'function' && isAstNode(node.procedure)) {
+            const proc = node.procedure;
+            if (getAstType(proc) === 'path' && Array.isArray(proc.steps) && proc.steps.length >= 2) {
+                const first = proc.steps[0];
+                const second = proc.steps[1];
+                if (isAstNode(first) &&
+                    getAstType(first) === 'variable' &&
+                    first.value === '$' &&
+                    isAstNode(second) &&
+                    getAstType(second) === 'name' &&
+                    typeof second.value === 'string') {
+                    refs.add(`@ctx.${second.value}`);
+                }
+            }
+        }
+    });
+    return Array.from(refs);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ast.js","sourceRoot":"","sources":["../../src/jsonata/ast.ts"],"names":[],"mappings":"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","sourcesContent":["import jsonata from 'jsonata'\n\n/**\n * Normalized context reference extracted from JSONata AST traversal.\n */\nexport interface FullContextReference {\n  /** Original reference token as found in expression text. */\n  readonly original: string\n  /** Canonical prefix used for extracted references. */\n  readonly prefix: '@ctx'\n  /** Parsed path segments (bracket access normalized to `@bracket`). */\n  readonly segments: string[]\n}\n\ntype AstNode = Record<string, unknown>\n\n/**\n * Parse transformed JSONata text.\n * Tries direct parse first, then wrapped block form for multi-statement expressions.\n */\nexport function parseAstFromTransformed(transformed: string): AstNode | null {\n  try {\n    return jsonata(transformed).ast() as unknown as AstNode\n  } catch {\n    try {\n      return jsonata(`(${transformed})`).ast() as unknown as AstNode\n    } catch {\n      return null\n    }\n  }\n}\n\nexport function isAstNode(value: unknown): value is AstNode {\n  return typeof value === 'object' && value !== null\n}\n\nexport function getAstType(node: AstNode): string | null {\n  return typeof node.type === 'string' ? node.type : null\n}\n\nexport function getAstString(node: AstNode, key: string): string | undefined {\n  return typeof node[key] === 'string' ? node[key] : undefined\n}\n\nexport function visitAst(\n  value: unknown,\n  visitor: (node: AstNode, parent: AstNode | null, keyInParent?: string) => void,\n): void {\n  const walk = (current: unknown, parent: AstNode | null, keyInParent?: string): void => {\n    if (!isAstNode(current)) return\n    visitor(current, parent, keyInParent)\n    for (const [k, v] of Object.entries(current)) {\n      if (Array.isArray(v)) {\n        for (const child of v) walk(child, current, k)\n      } else {\n        walk(v, current, k)\n      }\n    }\n  }\n\n  walk(value, null)\n}\n\nexport function extractContextReferencesFromAstNode(\n  ast: Record<string, unknown>,\n): FullContextReference[] {\n  const root = ast as AstNode\n  const refs: FullContextReference[] = []\n\n  const addPathRef = (node: AstNode): void => {\n    // Context refs are JSONata paths rooted at `$`.\n    const steps = Array.isArray(node.steps) ? node.steps : null\n    // Need at least root + one named segment.\n    if (!steps || steps.length < 2) return\n\n    const first = steps[0]\n    // Only treat root variable paths as context references.\n    if (!isAstNode(first)) return\n    if (getAstType(first) !== 'variable') return\n    if (first.value !== '$') return\n\n    const segments: string[] = []\n    for (let i = 1; i < steps.length; i++) {\n      const step = steps[i]\n      // Only named path segments contribute to extracted context path.\n      if (!isAstNode(step)) continue\n      if (getAstType(step) !== 'name') continue\n      if (typeof step.value !== 'string') continue\n      segments.push(step.value)\n\n      // Filter stages correspond to bracket access (`[...]`) on this path step.\n      const stages = Array.isArray(step.stages) ? step.stages : null\n      if (stages) {\n        for (const stage of stages) {\n          if (isAstNode(stage) && getAstType(stage) === 'filter') {\n            segments.push('@bracket')\n          }\n        }\n      }\n    }\n\n    // Skip empty/invalid paths; otherwise emit canonical @ctx.* form.\n    if (segments.length > 0) {\n      refs.push({\n        original: `@ctx.${segments.filter((s) => s !== '@bracket').join('.')}`,\n        prefix: '@ctx',\n        segments,\n      })\n    }\n  }\n\n  visitAst(root, (node) => {\n    // Collect path references at this node before traversing children.\n    if (getAstType(node) === 'path') {\n      addPathRef(node)\n    }\n  })\n\n  const seen = new Set<string>()\n  // Deduplicate equivalent references found multiple times in traversal.\n  return refs.filter((r) => {\n    const key = `${r.prefix}:${r.segments.join('.')}`\n    if (seen.has(key)) return false\n    seen.add(key)\n    return true\n  })\n}\n\nexport function extractContextFunctionReferencesFromAstNode(\n  ast: Record<string, unknown>,\n): string[] {\n  const root = ast as AstNode\n  const refs = new Set<string>()\n\n  visitAst(root, (node) => {\n    // Function refs are procedures that resolve to root-path calls.\n    if (getAstType(node) === 'function' && isAstNode(node.procedure)) {\n      const proc = node.procedure\n      if (getAstType(proc) === 'path' && Array.isArray(proc.steps) && proc.steps.length >= 2) {\n        const first = proc.steps[0]\n        const second = proc.steps[1]\n        // Match `$.<fnName>(...)` and normalize to `@ctx.<fnName>`.\n        if (\n          isAstNode(first) &&\n          getAstType(first) === 'variable' &&\n          first.value === '$' &&\n          isAstNode(second) &&\n          getAstType(second) === 'name' &&\n          typeof second.value === 'string'\n        ) {\n          refs.add(`@ctx.${second.value}`)\n        }\n      }\n    }\n  })\n  return Array.from(refs)\n}\n"]}

package/dist/jsonata/base.d.ts

@@ -0,0 +1,7 @@
+import { type z } from 'zod/v4';
+export declare function validateExpression(value: string): void;
+export interface ExpressionOptions {
+    readonly yamlConversion?: boolean;
+}
+export declare function convertOrExpression<T>(value: unknown, schema: z.ZodType<T>, typeName: string, options?: ExpressionOptions, yamlTypeCheck?: (yaml: unknown, expr: string) => boolean, yamlSchema?: 'yaml-1.1' | 'core'): T;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/jsonata/base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS/B,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAoBtD;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAClC;AAQD,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EACpB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,iBAAiB,EAC3B,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,EACxD,UAAU,CAAC,EAAE,UAAU,GAAG,MAAM,GAC/B,CAAC,CAkCH","sourcesContent":["import { parse as parseYaml } from 'yaml'\nimport { type z } from 'zod/v4'\nimport { validateJsonataExpression } from './expression.js'\n\n/**\n * Validates expressions that start with '=' against JSONata syntax and Jigx variable patterns.\n * Skips validation for non-expressions (literals without '=' prefix).\n * @param value - The string to validate (expressions or literals)\n * @throws Error if expression syntax is invalid or context tokens don't follow proper shape\n */\nexport function validateExpression(value: string): void {\n  // Only validate expressions (starting with =), skip literals\n  if (!value.trimStart().startsWith('=')) return\n\n  // Use the parser to validate all expressions\n  const validation = validateJsonataExpression(value)\n\n  if (!validation.isValid) {\n    if (validation.syntaxError) {\n      throw new Error(\n        `Invalid expression syntax: ${validation.syntaxError}. Expression: '${value}'`,\n      )\n    }\n    if (validation.invalidContextPaths && validation.invalidContextPaths.length > 0) {\n      const invalidToken = validation.invalidContextPaths[0]\n      throw new Error(\n        `Invalid JSONata expression: '${invalidToken}'. Must follow Jigx variable patterns. See https://docs.jigx.com/examples/jigx-variables`,\n      )\n    }\n  }\n}\n\nexport interface ExpressionOptions {\n  readonly yamlConversion?: boolean\n}\n\n/**\n * Generic utility for converting values to *OrExpression types with YAML folding.\n * Internal implementation shared between sdk.expression.ts and zod.types.ts.\n *\n * @internal - Not exported from barrel, for internal use only\n */\nexport function convertOrExpression<T>(\n  value: unknown,\n  schema: z.ZodType<T>,\n  typeName: string,\n  options?: ExpressionOptions,\n  yamlTypeCheck?: (yaml: unknown, expr: string) => boolean,\n  yamlSchema?: 'yaml-1.1' | 'core',\n): T {\n  const parseResult = schema.safeParse(value)\n  if (!parseResult.success) throw new Error(`Invalid ${typeName}: ${value}`)\n\n  const parsed: T = parseResult.data\n\n  // Early returns for non-string expressions or disabled YAML conversion\n  if (typeof parsed !== 'string' || parsed === '') {\n    return parsed\n  }\n\n  // Bail if not an expression\n  const s = parsed.trimStart()\n  if (!s.startsWith('=')) return parsed\n\n  // Validate expression syntax\n  validateExpression(parsed)\n\n  // TODO: Do we actually need this\n  if (options?.yamlConversion) {\n    try {\n      const val = s.slice(1).trim()\n      const yaml = parseYaml(val, yamlSchema ? { schema: yamlSchema } : undefined)\n\n      // Use custom type check or default to typeof check for string\n      if (yamlTypeCheck ? yamlTypeCheck(yaml, val) : typeof yaml === 'string') {\n        return yaml as T\n      }\n    } catch {\n      // Not valid YAML, continue to expression validation\n    }\n  }\n\n  return parsed\n}\n"]}

package/dist/jsonata/base.js

@@ -0,0 +1,43 @@
+import { parse as parseYaml } from 'yaml';
+import { validateJsonataExpression } from './expression.js';
+export function validateExpression(value) {
+    if (!value.trimStart().startsWith('='))
+        return;
+    const validation = validateJsonataExpression(value);
+    if (!validation.isValid) {
+        if (validation.syntaxError) {
+            throw new Error(`Invalid expression syntax: ${validation.syntaxError}. Expression: '${value}'`);
+        }
+        if (validation.invalidContextPaths && validation.invalidContextPaths.length > 0) {
+            const invalidToken = validation.invalidContextPaths[0];
+            throw new Error(`Invalid JSONata expression: '${invalidToken}'. Must follow Jigx variable patterns. See https://docs.jigx.com/examples/jigx-variables`);
+        }
+    }
+}
+export function convertOrExpression(value, schema, typeName, options, yamlTypeCheck, yamlSchema) {
+    const parseResult = schema.safeParse(value);
+    if (!parseResult.success)
+        throw new Error(`Invalid ${typeName}: ${value}`);
+    const parsed = parseResult.data;
+    if (typeof parsed !== 'string' || parsed === '') {
+        return parsed;
+    }
+    const s = parsed.trimStart();
+    if (!s.startsWith('='))
+        return parsed;
+    validateExpression(parsed);
+    if (options?.yamlConversion) {
+        try {
+            const val = s.slice(1).trim();
+            const yaml = parseYaml(val, yamlSchema ? { schema: yamlSchema } : undefined);
+            if (yamlTypeCheck ? yamlTypeCheck(yaml, val) : typeof yaml === 'string') {
+                return yaml;
+            }
+        }
+        catch {
+            // Not valid YAML, continue to expression validation
+        }
+    }
+    return parsed;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/jsonata/builder.d.ts

@@ -0,0 +1,28 @@
+export type JsonataVariableValue = string | number | boolean | null;
+export interface JsonataBuilderValidationIssue {
+    readonly scope: string;
+    readonly severity: 'error';
+    readonly contextPath: string;
+    readonly message: string;
+}
+export interface JsonataBuilderValidationResult {
+    readonly isValid: boolean;
+    readonly issues: readonly JsonataBuilderValidationIssue[];
+}
+export declare abstract class JsonataBuilderBase<TValue extends JsonataVariableValue = JsonataVariableValue> {
+    protected readonly variables: Map<string, TValue>;
+    protected readonly expressionBody: string;
+    protected constructor(body: string, variables?: Record<string, TValue>);
+    static extractScopeReferences(text: string): string[];
+    protected validateDeclaredVariables(contextPath: string): JsonataBuilderValidationIssue[];
+    private validateDeclaredVariablesWithAst;
+    protected validateSyntax(contextPath: string): JsonataBuilderValidationIssue[];
+    protected _validateBase(options?: {
+        contextPath?: string;
+    }): JsonataBuilderValidationResult;
+    protected extractScopeReferencesFromVariables(): string[];
+    _build(options: {
+        shouldReturnRawExpression: boolean;
+    }): string;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/jsonata/builder.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;AAOnE,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;AAKD,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,6BAA6B,EAAE,CAAA;CAC1D;AAYD,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;IAMzC,SAAS,aAAa,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EA+BrE;IAKD,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpD;IAKD,SAAS,CAAC,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,6BAA6B,EAAE,CAExF;IAED,OAAO,CAAC,gCAAgC;IAsExC,SAAS,CAAC,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,6BAA6B,EAAE,CAqB7E;IAMD,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,8BAA8B,CAY1F;IAKD,SAAS,CAAC,mCAAmC,IAAI,MAAM,EAAE,CASxD;IAOD,MAAM,CAAC,OAAO,EAAE;QAAE,yBAAyB,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAU9D;CACF","sourcesContent":["import { extractScopeReferences as extractCanonicalScopeReferences } from './expression.js'\nimport { parseJsonataAst, transformForValidation, validateSyntax } from './expression.js'\nimport { getAstString, getAstType, isAstNode, visitAst } from './ast.js'\n\nexport type JsonataVariableValue = string | number | boolean | null\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   * Extract canonical `ctx.*` scope references from string variable values.\n   */\n  protected extractScopeReferencesFromVariables(): string[] {\n    const scopes = new Set<string>()\n    for (const value of this.variables.values()) {\n      if (typeof value === 'string') {\n        const found = JsonataBuilderBase.extractScopeReferences(value)\n        found.forEach((scope) => scopes.add(scope))\n      }\n    }\n    return Array.from(scopes)\n  }\n\n  /**\n   * Build final expression string.\n   *\n   * @returns `=(${body})` by default, or `(${body})` when `shouldReturnRawExpression` is true.\n   */\n  _build(options: { shouldReturnRawExpression: boolean }): string {\n    const { shouldReturnRawExpression } = options\n    let jsonata = ''\n\n    for (const [name, value] of this.variables) {\n      jsonata += `$${name} := ${value};\\n`\n    }\n\n    jsonata += this.expressionBody\n    return shouldReturnRawExpression ? `(${jsonata})` : `=(${jsonata})`\n  }\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/jsonata/builder.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;AAOnE,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;AAKD,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,6BAA6B,EAAE,CAAA;CAC1D;AAYD,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;IAMzC,SAAS,aAAa,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EA+BrE;IAKD,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpD;IAKD,SAAS,CAAC,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,6BAA6B,EAAE,CAExF;IAED,OAAO,CAAC,gCAAgC;IAsExC,SAAS,CAAC,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,6BAA6B,EAAE,CAqB7E;IAMD,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,8BAA8B,CAY1F;IAKD,SAAS,CAAC,mCAAmC,IAAI,MAAM,EAAE,CASxD;IAOD,MAAM,CAAC,OAAO,EAAE;QAAE,yBAAyB,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAU9D;CACF","sourcesContent":["import { extractScopeReferences as extractCanonicalScopeReferences } from './expression.js'\nimport { parseJsonataAst, transformForValidation, validateSyntax } from './expression.js'\nimport { getAstString, getAstType, isAstNode, visitAst } from './ast.js'\n\nexport type JsonataVariableValue = string | number | boolean | null\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   * Extract canonical `ctx.*` scope references from string variable values.\n   */\n  protected extractScopeReferencesFromVariables(): string[] {\n    const scopes = new Set<string>()\n    for (const value of this.variables.values()) {\n      if (typeof value === 'string') {\n        const found = JsonataBuilderBase.extractScopeReferences(value)\n        found.forEach((scope) => scopes.add(scope))\n      }\n    }\n    return Array.from(scopes)\n  }\n\n  /**\n   * Build final expression string.\n   *\n   * @returns `=(${body})` by default, or `(${body})` when `shouldReturnRawExpression` is true.\n   */\n  _build(options: { shouldReturnRawExpression: boolean }): string {\n    const { shouldReturnRawExpression } = options\n    let jsonata = ''\n\n    for (const [name, value] of this.variables) {\n      jsonata += `$${name} := ${value};\\n`\n    }\n\n    jsonata += this.expressionBody\n    return shouldReturnRawExpression ? `(${jsonata})` : `=(${jsonata})`\n  }\n}\n"]}

package/dist/jsonata/builder.js

@@ -0,0 +1,140 @@
+import { extractScopeReferences as extractCanonicalScopeReferences } from './expression.js';
+import { parseJsonataAst, transformForValidation, validateSyntax } from './expression.js';
+import { getAstString, getAstType, isAstNode, visitAst } from './ast.js';
+export class JsonataBuilderBase {
+    variables;
+    expressionBody;
+    constructor(body, variables) {
+        if (body.startsWith('=')) {
+            throw new Error(`JSONata expression body must not start with "=". ` +
+                `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)) {
+                throw new Error(`Invalid variable name: "${name}". ` +
+                    `Variable names must start with a letter or underscore, ` +
+                    `followed by letters, digits, or underscores.`);
+            }
+            if (typeof value === 'string' && value.startsWith('=')) {
+                throw new Error(`Invalid variable value for "${name}": "${value}". ` +
+                    `String values must not start with "=".`);
+            }
+            this.variables.set(name, value);
+        }
+        this.expressionBody = body;
+    }
+    static extractScopeReferences(text) {
+        return extractCanonicalScopeReferences(text);
+    }
+    validateDeclaredVariables(contextPath) {
+        return this.validateDeclaredVariablesWithAst(contextPath);
+    }
+    validateDeclaredVariablesWithAst(contextPath) {
+        const ast = parseJsonataAst(this.expressionBody);
+        if (ast === null) {
+            return [
+                {
+                    scope: this.expressionBody,
+                    severity: 'error',
+                    contextPath,
+                    message: 'Unable to parse JSONata expression for variable validation',
+                },
+            ];
+        }
+        const declared = new Set(this.variables.keys());
+        const referenced = new Set();
+        visitAst(ast, (node, parent, keyInParent) => {
+            const nodeType = getAstType(node);
+            if (nodeType === 'lambda' && Array.isArray(node.arguments)) {
+                for (const arg of node.arguments) {
+                    if (isAstNode(arg) && getAstType(arg) === 'variable') {
+                        const varName = getAstString(arg, 'value');
+                        if (varName !== undefined) {
+                            declared.add(varName);
+                        }
+                    }
+                }
+            }
+            if (nodeType === 'bind' && isAstNode(node.lhs) && getAstType(node.lhs) === 'variable') {
+                const lhsVar = getAstString(node.lhs, 'value');
+                if (lhsVar !== undefined) {
+                    declared.add(lhsVar);
+                }
+            }
+            if (nodeType === 'variable') {
+                const variableName = getAstString(node, 'value');
+                if (variableName === undefined)
+                    return;
+                const isContextRoot = variableName === '' || variableName === '$';
+                const isFunctionProcedure = parent !== null && getAstType(parent) === 'function' && keyInParent === 'procedure';
+                if (!isContextRoot && !isFunctionProcedure) {
+                    referenced.add(variableName);
+                }
+            }
+        });
+        const undeclared = Array.from(referenced).filter((name) => !declared.has(name));
+        if (undeclared.length === 0) {
+            return [];
+        }
+        const variableList = undeclared.join(', ');
+        const message = `JSONata expression references undeclared variables: ${variableList}. ` +
+            `Declare them in the variables map passed to the builder constructor.`;
+        return undeclared.map((name) => ({
+            scope: `$${name}`,
+            severity: 'error',
+            contextPath,
+            message,
+        }));
+    }
+    validateSyntax(contextPath) {
+        const transformed = transformForValidation(this.expressionBody);
+        let syntaxValidation = validateSyntax(transformed);
+        if (!syntaxValidation.isValid) {
+            const wrapped = transformForValidation(`(${this.expressionBody})`);
+            syntaxValidation = validateSyntax(wrapped);
+        }
+        if (!syntaxValidation.isValid && syntaxValidation.error) {
+            return [
+                {
+                    scope: this.expressionBody,
+                    severity: 'error',
+                    contextPath,
+                    message: syntaxValidation.error,
+                },
+            ];
+        }
+        return [];
+    }
+    _validateBase(options) {
+        const contextPath = options?.contextPath ?? '';
+        const issues = [];
+        if (!this.expressionBody) {
+            return { isValid: true, issues: [] };
+        }
+        issues.push(...this.validateSyntax(contextPath));
+        issues.push(...this.validateDeclaredVariables(contextPath));
+        return { isValid: issues.length === 0, issues };
+    }
+    extractScopeReferencesFromVariables() {
+        const scopes = new Set();
+        for (const value of this.variables.values()) {
+            if (typeof value === 'string') {
+                const found = JsonataBuilderBase.extractScopeReferences(value);
+                found.forEach((scope) => scopes.add(scope));
+            }
+        }
+        return Array.from(scopes);
+    }
+    _build(options) {
+        const { shouldReturnRawExpression } = options;
+        let jsonata = '';
+        for (const [name, value] of this.variables) {
+            jsonata += `$${name} := ${value};\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\nexport type JsonataVariableValue = string | number | boolean | null\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   * Extract canonical `ctx.*` scope references from string variable values.\n   */\n  protected extractScopeReferencesFromVariables(): string[] {\n    const scopes = new Set<string>()\n    for (const value of this.variables.values()) {\n      if (typeof value === 'string') {\n        const found = JsonataBuilderBase.extractScopeReferences(value)\n        found.forEach((scope) => scopes.add(scope))\n      }\n    }\n    return Array.from(scopes)\n  }\n\n  /**\n   * Build final expression string.\n   *\n   * @returns `=(${body})` by default, or `(${body})` when `shouldReturnRawExpression` is true.\n   */\n  _build(options: { shouldReturnRawExpression: boolean }): string {\n    const { shouldReturnRawExpression } = options\n    let jsonata = ''\n\n    for (const [name, value] of this.variables) {\n      jsonata += `$${name} := ${value};\\n`\n    }\n\n    jsonata += this.expressionBody\n    return shouldReturnRawExpression ? `(${jsonata})` : `=(${jsonata})`\n  }\n}\n"]}