@shipfox/expression 1.1.0

package/dist/plan/context-key-access.js

@@ -0,0 +1,249 @@
+import { parse as parseCel } from '@marcbachmann/cel-js';
+import { workflowContextRootRequiresLiteralKey } from '../workflow-context/workflow-context.js';
+const binaryOperators = new Set([
+    '!=',
+    '==',
+    'in',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '<',
+    '<=',
+    '>',
+    '>='
+]);
+const comprehensionMethods = new Set([
+    'all',
+    'exists',
+    'exists_one',
+    'filter',
+    'map'
+]);
+export function analyzeContextKeyAccess(expression) {
+    const source = typeof expression === 'string' ? expression : expression.source;
+    const references = [];
+    const violations = [];
+    collectContextAccesses(parseCel(source).ast, source, new Set(), {
+        shouldRecord: (chain)=>workflowContextRootRequiresLiteralKey(chain.root),
+        record: (chain, expressionSource)=>recordLiteralKeyRootAccess(chain, expressionSource, references, violations)
+    });
+    return {
+        references,
+        violations
+    };
+}
+export function analyzeContextRootKeyAccess(expression, roots) {
+    const source = typeof expression === 'string' ? expression : expression.source;
+    const references = [];
+    const violations = [];
+    const selectedRoots = new Set(roots);
+    collectContextAccesses(parseCel(source).ast, source, new Set(), {
+        shouldRecord: (chain)=>selectedRoots.has(chain.root),
+        record: (chain, expressionSource)=>recordContextRootKeyAccess(chain, expressionSource, references, violations)
+    });
+    return {
+        references,
+        violations
+    };
+}
+function collectContextAccesses(node, source, scopedIdentifiers, visitor) {
+    if (binaryOperators.has(node.op) || node.op === '||' || node.op === '&&') {
+        collectBinaryContextAccesses(node.args, source, scopedIdentifiers, visitor);
+        return;
+    }
+    const chain = accessChain(node, scopedIdentifiers);
+    if (chain && visitor.shouldRecord(chain)) {
+        visitor.record(chain, source);
+        return;
+    }
+    switch(node.op){
+        case 'id':
+        case 'value':
+            return;
+        case '.':
+        case '.?':
+            collectContextAccesses(node.args[0], source, scopedIdentifiers, visitor);
+            return;
+        case '[]':
+        case '[?]':
+            collectBinaryContextAccesses(node.args, source, scopedIdentifiers, visitor);
+            return;
+        case 'call':
+            for (const argument of node.args[1]){
+                collectContextAccesses(argument, source, scopedIdentifiers, visitor);
+            }
+            return;
+        case 'rcall':
+            {
+                const [method, receiver, args] = node.args;
+                collectContextAccesses(receiver, source, scopedIdentifiers, visitor);
+                const binding = bindComprehensionAlias(method, args, scopedIdentifiers);
+                for (const argument of args.slice(binding.skipArgs)){
+                    collectContextAccesses(argument, source, binding.scopedIdentifiers, visitor);
+                }
+                return;
+            }
+        case 'list':
+            for (const element of node.args){
+                collectContextAccesses(element, source, scopedIdentifiers, visitor);
+            }
+            return;
+        case 'map':
+            for (const [key, value] of node.args){
+                if (key.op !== 'id') {
+                    collectContextAccesses(key, source, scopedIdentifiers, visitor);
+                }
+                collectContextAccesses(value, source, scopedIdentifiers, visitor);
+            }
+            return;
+        case '?:':
+            collectContextAccesses(node.args[0], source, scopedIdentifiers, visitor);
+            collectContextAccesses(node.args[1], source, scopedIdentifiers, visitor);
+            collectContextAccesses(node.args[2], source, scopedIdentifiers, visitor);
+            return;
+        case '!_':
+        case '-_':
+            collectContextAccesses(node.args, source, scopedIdentifiers, visitor);
+            return;
+    }
+    throw new Error(`Unsupported CEL AST operator: ${node.op}`);
+}
+function collectBinaryContextAccesses([left, right], source, scopedIdentifiers, visitor) {
+    collectContextAccesses(left, source, scopedIdentifiers, visitor);
+    collectContextAccesses(right, source, scopedIdentifiers, visitor);
+}
+function recordLiteralKeyRootAccess(chain, source, references, violations) {
+    if (chain.computed) {
+        violations.push({
+            root: chain.root,
+            source
+        });
+        return;
+    }
+    if (chain.root === 'vars' && chain.segments.length === 1) {
+        const key = chain.segments[0];
+        if (key === undefined) throw new Error('Expected vars key segment');
+        references.push({
+            root: chain.root,
+            key
+        });
+        return;
+    }
+    if (chain.root === 'secrets' && chain.segments.length === 1) {
+        const key = chain.segments[0];
+        if (key === undefined) throw new Error('Expected secret key segment');
+        references.push({
+            root: chain.root,
+            key
+        });
+        return;
+    }
+    if (chain.root === 'secrets' && chain.segments.length === 2) {
+        const store = chain.segments[0];
+        const key = chain.segments[1];
+        if (store === undefined || key === undefined) {
+            throw new Error('Expected secret store and key segments');
+        }
+        references.push({
+            root: chain.root,
+            store,
+            key
+        });
+        return;
+    }
+    violations.push({
+        root: chain.root,
+        source
+    });
+}
+function recordContextRootKeyAccess(chain, source, references, violations) {
+    const [key] = chain.segments;
+    if (chain.computed || key === undefined) {
+        violations.push({
+            root: chain.root,
+            source
+        });
+        return;
+    }
+    references.push({
+        root: chain.root,
+        key
+    });
+}
+function accessChain(node, scopedIdentifiers) {
+    switch(node.op){
+        case 'id':
+            return scopedIdentifiers.has(node.args) ? undefined : {
+                root: node.args,
+                segments: [],
+                computed: false
+            };
+        case '.':
+            {
+                const target = accessChain(node.args[0], scopedIdentifiers);
+                if (target === undefined) return undefined;
+                return {
+                    ...target,
+                    segments: [
+                        ...target.segments,
+                        node.args[1]
+                    ]
+                };
+            }
+        case '.?':
+            {
+                const target = accessChain(node.args[0], scopedIdentifiers);
+                if (target === undefined) return undefined;
+                return {
+                    ...target,
+                    segments: [
+                        ...target.segments,
+                        node.args[1]
+                    ],
+                    computed: true
+                };
+            }
+        case '[]':
+        case '[?]':
+            {
+                const target = accessChain(node.args[0], scopedIdentifiers);
+                if (target === undefined) return undefined;
+                const literalSegment = literalStringValue(node.args[1]);
+                return {
+                    ...target,
+                    segments: literalSegment === undefined ? target.segments : [
+                        ...target.segments,
+                        literalSegment
+                    ],
+                    computed: true
+                };
+            }
+        default:
+            return undefined;
+    }
+}
+function literalStringValue(node) {
+    return node.op === 'value' && typeof node.args === 'string' ? node.args : undefined;
+}
+function bindComprehensionAlias(method, args, scopedIdentifiers) {
+    if (!comprehensionMethods.has(method)) return {
+        scopedIdentifiers,
+        skipArgs: 0
+    };
+    const [alias] = args;
+    if (alias?.op !== 'id') return {
+        scopedIdentifiers,
+        skipArgs: 0
+    };
+    return {
+        scopedIdentifiers: new Set([
+            ...scopedIdentifiers,
+            alias.args
+        ]),
+        skipArgs: 1
+    };
+}
+
+//# sourceMappingURL=context-key-access.js.map

package/dist/plan/context-key-access.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/context-key-access.ts"],"sourcesContent":["import {type ASTNode, type BinaryOperator, parse as parseCel} from '@marcbachmann/cel-js';\nimport type {WorkflowExpression} from '../expression/workflow-expression.js';\nimport {workflowContextRootRequiresLiteralKey} from '../workflow-context/workflow-context.js';\n\nconst binaryOperators = new Set<BinaryOperator>([\n  '!=',\n  '==',\n  'in',\n  '+',\n  '-',\n  '*',\n  '/',\n  '%',\n  '<',\n  '<=',\n  '>',\n  '>=',\n]);\n\nconst comprehensionMethods = new Set(['all', 'exists', 'exists_one', 'filter', 'map']);\n\nexport interface ContextKeyAccessReference {\n  readonly root: 'vars' | 'secrets';\n  readonly store?: string;\n  readonly key: string;\n}\n\nexport interface ContextKeyAccessViolation {\n  readonly root: string;\n  readonly source: string;\n}\n\nexport interface ContextKeyAccessAnalysis {\n  readonly references: readonly ContextKeyAccessReference[];\n  readonly violations: readonly ContextKeyAccessViolation[];\n}\n\nexport interface ContextRootKeyAccessReference {\n  readonly root: string;\n  readonly key: string;\n}\n\nexport interface ContextRootKeyAccessAnalysis {\n  readonly references: readonly ContextRootKeyAccessReference[];\n  readonly violations: readonly ContextKeyAccessViolation[];\n}\n\ninterface AccessChain {\n  readonly root: string;\n  readonly segments: readonly string[];\n  readonly computed: boolean;\n}\n\ninterface ContextAccessVisitor {\n  readonly shouldRecord: (chain: AccessChain) => boolean;\n  readonly record: (chain: AccessChain, source: string) => void;\n}\n\nexport function analyzeContextKeyAccess(\n  expression: WorkflowExpression | string,\n): ContextKeyAccessAnalysis {\n  const source = typeof expression === 'string' ? expression : expression.source;\n  const references: ContextKeyAccessReference[] = [];\n  const violations: ContextKeyAccessViolation[] = [];\n\n  collectContextAccesses(parseCel(source).ast, source, new Set(), {\n    shouldRecord: (chain) => workflowContextRootRequiresLiteralKey(chain.root),\n    record: (chain, expressionSource) =>\n      recordLiteralKeyRootAccess(chain, expressionSource, references, violations),\n  });\n\n  return {references, violations};\n}\n\nexport function analyzeContextRootKeyAccess(\n  expression: WorkflowExpression | string,\n  roots: readonly string[],\n): ContextRootKeyAccessAnalysis {\n  const source = typeof expression === 'string' ? expression : expression.source;\n  const references: ContextRootKeyAccessReference[] = [];\n  const violations: ContextKeyAccessViolation[] = [];\n  const selectedRoots = new Set(roots);\n\n  collectContextAccesses(parseCel(source).ast, source, new Set(), {\n    shouldRecord: (chain) => selectedRoots.has(chain.root),\n    record: (chain, expressionSource) =>\n      recordContextRootKeyAccess(chain, expressionSource, references, violations),\n  });\n\n  return {references, violations};\n}\n\nfunction collectContextAccesses(\n  node: ASTNode,\n  source: string,\n  scopedIdentifiers: ReadonlySet<string>,\n  visitor: ContextAccessVisitor,\n): void {\n  if (binaryOperators.has(node.op as BinaryOperator) || node.op === '||' || node.op === '&&') {\n    collectBinaryContextAccesses(\n      node.args as [ASTNode, ASTNode],\n      source,\n      scopedIdentifiers,\n      visitor,\n    );\n    return;\n  }\n\n  const chain = accessChain(node, scopedIdentifiers);\n  if (chain && visitor.shouldRecord(chain)) {\n    visitor.record(chain, source);\n    return;\n  }\n\n  switch (node.op) {\n    case 'id':\n    case 'value':\n      return;\n    case '.':\n    case '.?':\n      collectContextAccesses(node.args[0], source, scopedIdentifiers, visitor);\n      return;\n    case '[]':\n    case '[?]':\n      collectBinaryContextAccesses(node.args, source, scopedIdentifiers, visitor);\n      return;\n    case 'call':\n      for (const argument of node.args[1]) {\n        collectContextAccesses(argument, source, scopedIdentifiers, visitor);\n      }\n      return;\n    case 'rcall': {\n      const [method, receiver, args] = node.args as [string, ASTNode, ASTNode[]];\n      collectContextAccesses(receiver, source, scopedIdentifiers, visitor);\n      const binding = bindComprehensionAlias(method, args, scopedIdentifiers);\n      for (const argument of args.slice(binding.skipArgs)) {\n        collectContextAccesses(argument, source, binding.scopedIdentifiers, visitor);\n      }\n      return;\n    }\n    case 'list':\n      for (const element of node.args) {\n        collectContextAccesses(element, source, scopedIdentifiers, visitor);\n      }\n      return;\n    case 'map':\n      for (const [key, value] of node.args) {\n        if (key.op !== 'id') {\n          collectContextAccesses(key, source, scopedIdentifiers, visitor);\n        }\n        collectContextAccesses(value, source, scopedIdentifiers, visitor);\n      }\n      return;\n    case '?:':\n      collectContextAccesses(node.args[0], source, scopedIdentifiers, visitor);\n      collectContextAccesses(node.args[1], source, scopedIdentifiers, visitor);\n      collectContextAccesses(node.args[2], source, scopedIdentifiers, visitor);\n      return;\n    case '!_':\n    case '-_':\n      collectContextAccesses(node.args, source, scopedIdentifiers, visitor);\n      return;\n  }\n\n  throw new Error(`Unsupported CEL AST operator: ${(node as {op: string}).op}`);\n}\n\nfunction collectBinaryContextAccesses(\n  [left, right]: [ASTNode, ASTNode],\n  source: string,\n  scopedIdentifiers: ReadonlySet<string>,\n  visitor: ContextAccessVisitor,\n): void {\n  collectContextAccesses(left, source, scopedIdentifiers, visitor);\n  collectContextAccesses(right, source, scopedIdentifiers, visitor);\n}\n\nfunction recordLiteralKeyRootAccess(\n  chain: AccessChain,\n  source: string,\n  references: ContextKeyAccessReference[],\n  violations: ContextKeyAccessViolation[],\n): void {\n  if (chain.computed) {\n    violations.push({root: chain.root, source});\n    return;\n  }\n\n  if (chain.root === 'vars' && chain.segments.length === 1) {\n    const key = chain.segments[0];\n    if (key === undefined) throw new Error('Expected vars key segment');\n    references.push({root: chain.root, key});\n    return;\n  }\n\n  if (chain.root === 'secrets' && chain.segments.length === 1) {\n    const key = chain.segments[0];\n    if (key === undefined) throw new Error('Expected secret key segment');\n    references.push({root: chain.root, key});\n    return;\n  }\n\n  if (chain.root === 'secrets' && chain.segments.length === 2) {\n    const store = chain.segments[0];\n    const key = chain.segments[1];\n    if (store === undefined || key === undefined) {\n      throw new Error('Expected secret store and key segments');\n    }\n    references.push({root: chain.root, store, key});\n    return;\n  }\n\n  violations.push({root: chain.root, source});\n}\n\nfunction recordContextRootKeyAccess(\n  chain: AccessChain,\n  source: string,\n  references: ContextRootKeyAccessReference[],\n  violations: ContextKeyAccessViolation[],\n): void {\n  const [key] = chain.segments;\n  if (chain.computed || key === undefined) {\n    violations.push({root: chain.root, source});\n    return;\n  }\n\n  references.push({root: chain.root, key});\n}\n\nfunction accessChain(\n  node: ASTNode,\n  scopedIdentifiers: ReadonlySet<string>,\n): AccessChain | undefined {\n  switch (node.op) {\n    case 'id':\n      return scopedIdentifiers.has(node.args)\n        ? undefined\n        : {root: node.args, segments: [], computed: false};\n    case '.': {\n      const target = accessChain(node.args[0], scopedIdentifiers);\n      if (target === undefined) return undefined;\n      return {...target, segments: [...target.segments, node.args[1]]};\n    }\n    case '.?': {\n      const target = accessChain(node.args[0], scopedIdentifiers);\n      if (target === undefined) return undefined;\n      return {...target, segments: [...target.segments, node.args[1]], computed: true};\n    }\n    case '[]':\n    case '[?]': {\n      const target = accessChain(node.args[0], scopedIdentifiers);\n      if (target === undefined) return undefined;\n      const literalSegment = literalStringValue(node.args[1]);\n      return {\n        ...target,\n        segments:\n          literalSegment === undefined ? target.segments : [...target.segments, literalSegment],\n        computed: true,\n      };\n    }\n    default:\n      return undefined;\n  }\n}\n\nfunction literalStringValue(node: ASTNode): string | undefined {\n  return node.op === 'value' && typeof node.args === 'string' ? node.args : undefined;\n}\n\nfunction bindComprehensionAlias(\n  method: string,\n  args: readonly ASTNode[],\n  scopedIdentifiers: ReadonlySet<string>,\n): {readonly scopedIdentifiers: ReadonlySet<string>; readonly skipArgs: number} {\n  if (!comprehensionMethods.has(method)) return {scopedIdentifiers, skipArgs: 0};\n\n  const [alias] = args;\n  if (alias?.op !== 'id') return {scopedIdentifiers, skipArgs: 0};\n\n  return {\n    scopedIdentifiers: new Set([...scopedIdentifiers, alias.args]),\n    skipArgs: 1,\n  };\n}\n"],"names":["parse","parseCel","workflowContextRootRequiresLiteralKey","binaryOperators","Set","comprehensionMethods","analyzeContextKeyAccess","expression","source","references","violations","collectContextAccesses","ast","shouldRecord","chain","root","record","expressionSource","recordLiteralKeyRootAccess","analyzeContextRootKeyAccess","roots","selectedRoots","has","recordContextRootKeyAccess","node","scopedIdentifiers","visitor","op","collectBinaryContextAccesses","args","accessChain","argument","method","receiver","binding","bindComprehensionAlias","slice","skipArgs","element","key","value","Error","left","right","computed","push","segments","length","undefined","store","target","literalSegment","literalStringValue","alias"],"mappings":"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"}

package/dist/plan/evaluate-planned-predicate.d.ts

@@ -0,0 +1,14 @@
+import { type FailClosedPredicateOutcome, type WorkflowExpressionEvaluationContext } from '../evaluator/evaluate-workflow-expression.js';
+import type { WorkflowExpression } from '../expression/workflow-expression.js';
+import type { AvailabilitySite, WorkflowPredicateField } from '../workflow-context/workflow-context.js';
+import { type RoutedExpression } from './route-expression.js';
+export interface PlannedPredicateEvaluationResult extends FailClosedPredicateOutcome {
+    readonly route: RoutedExpression;
+}
+export declare function evaluatePlannedPredicateAtSite(params: {
+    readonly expression: WorkflowExpression;
+    readonly field: WorkflowPredicateField;
+    readonly site: AvailabilitySite;
+    readonly context: WorkflowExpressionEvaluationContext;
+}): PlannedPredicateEvaluationResult;
+//# sourceMappingURL=evaluate-planned-predicate.d.ts.map

package/dist/plan/evaluate-planned-predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-planned-predicate.d.ts","sourceRoot":"","sources":["../../src/plan/evaluate-planned-predicate.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,mCAAmC,EACzC,MAAM,8CAA8C,CAAC;AACtD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EACV,gBAAgB,EAEhB,sBAAsB,EACvB,MAAM,yCAAyC,CAAC;AAGjD,OAAO,EAAC,KAAK,gBAAgB,EAAkB,MAAM,uBAAuB,CAAC;AAE7E,MAAM,WAAW,gCAAiC,SAAQ,0BAA0B;IAClF,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;CAClC;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,mCAAmC,CAAC;CACvD,GAAG,gCAAgC,CAOnC"}

package/dist/plan/evaluate-planned-predicate.js

@@ -0,0 +1,31 @@
+import { evaluateWorkflowPredicateFailClosed } from '../evaluator/evaluate-workflow-expression.js';
+import { getWorkflowPredicateFieldMinimumFillTarget } from '../workflow-context/workflow-context.js';
+import { shouldFillAtSite } from './fill.js';
+import { routeExpression } from './route-expression.js';
+export function evaluatePlannedPredicateAtSite(params) {
+    const route = routePredicateExpression(params.expression, params.field);
+    if (!shouldFillAtSite(route.fillTarget, params.site)) {
+        return {
+            value: false,
+            evaluationFailed: true,
+            route
+        };
+    }
+    return {
+        ...evaluateWorkflowPredicateFailClosed(params.expression, params.context),
+        route
+    };
+}
+function routePredicateExpression(expression, field) {
+    const route = routeExpression(expression);
+    return {
+        ...route,
+        fillTarget: laterFillTarget(route.fillTarget, getWorkflowPredicateFieldMinimumFillTarget(field))
+    };
+}
+function laterFillTarget(left, right) {
+    if (left === 'runner-fill') return left;
+    return shouldFillAtSite(right, left) ? left : right;
+}
+
+//# sourceMappingURL=evaluate-planned-predicate.js.map

package/dist/plan/evaluate-planned-predicate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/evaluate-planned-predicate.ts"],"sourcesContent":["import {\n  evaluateWorkflowPredicateFailClosed,\n  type FailClosedPredicateOutcome,\n  type WorkflowExpressionEvaluationContext,\n} from '../evaluator/evaluate-workflow-expression.js';\nimport type {WorkflowExpression} from '../expression/workflow-expression.js';\nimport type {\n  AvailabilitySite,\n  FillTarget,\n  WorkflowPredicateField,\n} from '../workflow-context/workflow-context.js';\nimport {getWorkflowPredicateFieldMinimumFillTarget} from '../workflow-context/workflow-context.js';\nimport {shouldFillAtSite} from './fill.js';\nimport {type RoutedExpression, routeExpression} from './route-expression.js';\n\nexport interface PlannedPredicateEvaluationResult extends FailClosedPredicateOutcome {\n  readonly route: RoutedExpression;\n}\n\nexport function evaluatePlannedPredicateAtSite(params: {\n  readonly expression: WorkflowExpression;\n  readonly field: WorkflowPredicateField;\n  readonly site: AvailabilitySite;\n  readonly context: WorkflowExpressionEvaluationContext;\n}): PlannedPredicateEvaluationResult {\n  const route = routePredicateExpression(params.expression, params.field);\n  if (!shouldFillAtSite(route.fillTarget, params.site)) {\n    return {value: false, evaluationFailed: true, route};\n  }\n\n  return {...evaluateWorkflowPredicateFailClosed(params.expression, params.context), route};\n}\n\nfunction routePredicateExpression(\n  expression: WorkflowExpression,\n  field: WorkflowPredicateField,\n): RoutedExpression {\n  const route = routeExpression(expression);\n  return {\n    ...route,\n    fillTarget: laterFillTarget(\n      route.fillTarget,\n      getWorkflowPredicateFieldMinimumFillTarget(field),\n    ),\n  };\n}\n\nfunction laterFillTarget(left: FillTarget, right: AvailabilitySite): FillTarget {\n  if (left === 'runner-fill') return left;\n  return shouldFillAtSite(right, left) ? left : right;\n}\n"],"names":["evaluateWorkflowPredicateFailClosed","getWorkflowPredicateFieldMinimumFillTarget","shouldFillAtSite","routeExpression","evaluatePlannedPredicateAtSite","params","route","routePredicateExpression","expression","field","fillTarget","site","value","evaluationFailed","context","laterFillTarget","left","right"],"mappings":"AAAA,SACEA,mCAAmC,QAG9B,+CAA+C;AAOtD,SAAQC,0CAA0C,QAAO,0CAA0C;AACnG,SAAQC,gBAAgB,QAAO,YAAY;AAC3C,SAA+BC,eAAe,QAAO,wBAAwB;AAM7E,OAAO,SAASC,+BAA+BC,MAK9C;IACC,MAAMC,QAAQC,yBAAyBF,OAAOG,UAAU,EAAEH,OAAOI,KAAK;IACtE,IAAI,CAACP,iBAAiBI,MAAMI,UAAU,EAAEL,OAAOM,IAAI,GAAG;QACpD,OAAO;YAACC,OAAO;YAAOC,kBAAkB;YAAMP;QAAK;IACrD;IAEA,OAAO;QAAC,GAAGN,oCAAoCK,OAAOG,UAAU,EAAEH,OAAOS,OAAO,CAAC;QAAER;IAAK;AAC1F;AAEA,SAASC,yBACPC,UAA8B,EAC9BC,KAA6B;IAE7B,MAAMH,QAAQH,gBAAgBK;IAC9B,OAAO;QACL,GAAGF,KAAK;QACRI,YAAYK,gBACVT,MAAMI,UAAU,EAChBT,2CAA2CQ;IAE/C;AACF;AAEA,SAASM,gBAAgBC,IAAgB,EAAEC,KAAuB;IAChE,IAAID,SAAS,eAAe,OAAOA;IACnC,OAAOd,iBAAiBe,OAAOD,QAAQA,OAAOC;AAChD"}

package/dist/plan/evaluation-trace.d.ts

@@ -0,0 +1,44 @@
+import type { AvailabilitySite, FillTarget } from '../workflow-context/workflow-context.js';
+import type { RoutedExpression } from './route-expression.js';
+export declare const EVALUATION_TRACE_VALUE_CAP_BYTES = 1024;
+export declare const EVALUATION_TRACE_MAX_ENTRIES = 256;
+export interface EvaluationTraceEntry {
+    readonly expression: string;
+    readonly roots: readonly string[];
+    readonly fillTarget: FillTarget;
+    readonly evaluatedAt: AvailabilitySite;
+    readonly value?: string;
+    readonly truncated?: boolean;
+    readonly exprTruncated?: boolean;
+    readonly reference?: boolean;
+    readonly degraded?: boolean;
+}
+export interface EvaluationTraceLimitEntry {
+    readonly truncated: true;
+    readonly dropped: number;
+}
+export type EvaluationTraceRowEntry = EvaluationTraceEntry | EvaluationTraceLimitEntry;
+export interface EvaluationTraceEntryInput {
+    readonly expression: string;
+    readonly roots: readonly string[];
+    readonly fillTarget: FillTarget;
+    readonly evaluatedAt: AvailabilitySite;
+    readonly value?: string;
+    readonly reference?: boolean;
+    readonly degraded?: boolean;
+}
+export interface PredicateTraceEntryInput {
+    readonly expression: string;
+    readonly route: RoutedExpression;
+    readonly site: AvailabilitySite;
+    readonly value: boolean;
+    readonly degraded?: boolean;
+}
+export declare function capTraceValue(value: string): {
+    value: string;
+    truncated: boolean;
+};
+export declare function evaluationTraceEntry(input: EvaluationTraceEntryInput): EvaluationTraceEntry;
+export declare function predicateTraceEntry(input: PredicateTraceEntryInput): EvaluationTraceEntry;
+export declare function capTraceEntries<Entry extends EvaluationTraceRowEntry>(entries: readonly Entry[]): readonly (Exclude<Entry, EvaluationTraceLimitEntry> | EvaluationTraceLimitEntry)[];
+//# sourceMappingURL=evaluation-trace.d.ts.map

package/dist/plan/evaluation-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-trace.d.ts","sourceRoot":"","sources":["../../src/plan/evaluation-trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,UAAU,EAAC,MAAM,yCAAyC,CAAC;AAC1F,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,uBAAuB,CAAC;AAE5D,eAAO,MAAM,gCAAgC,OAAO,CAAC;AACrD,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAKhD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,uBAAuB,GAAG,oBAAoB,GAAG,yBAAyB,CAAC;AAEvF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC,CAkBhF;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,GAAG,oBAAoB,CAgB3F;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,oBAAoB,CASzF;AAED,wBAAgB,eAAe,CAAC,KAAK,SAAS,uBAAuB,EACnE,OAAO,EAAE,SAAS,KAAK,EAAE,GACxB,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,yBAAyB,CAAC,GAAG,yBAAyB,CAAC,EAAE,CAsBpF"}

package/dist/plan/evaluation-trace.js

@@ -0,0 +1,95 @@
+export const EVALUATION_TRACE_VALUE_CAP_BYTES = 1024;
+export const EVALUATION_TRACE_MAX_ENTRIES = 256;
+const TRACE_TRUNCATION_MARKER = '...[truncated]';
+const textEncoder = new TextEncoder();
+export function capTraceValue(value) {
+    if (textEncoder.encode(value).byteLength <= EVALUATION_TRACE_VALUE_CAP_BYTES) {
+        return {
+            value,
+            truncated: false
+        };
+    }
+    const budget = EVALUATION_TRACE_VALUE_CAP_BYTES - textEncoder.encode(TRACE_TRUNCATION_MARKER).byteLength;
+    let used = 0;
+    let capped = '';
+    for (const char of value){
+        const charBytes = textEncoder.encode(char).byteLength;
+        if (used + charBytes > budget) break;
+        capped += char;
+        used += charBytes;
+    }
+    return {
+        value: capped + TRACE_TRUNCATION_MARKER,
+        truncated: true
+    };
+}
+export function evaluationTraceEntry(input) {
+    const expression = capTraceValue(input.expression);
+    const value = input.value === undefined || input.reference === true ? undefined : capTraceValue(input.value);
+    return {
+        expression: expression.value,
+        roots: input.roots,
+        fillTarget: input.fillTarget,
+        evaluatedAt: input.evaluatedAt,
+        ...value === undefined ? {} : {
+            value: value.value
+        },
+        ...value?.truncated === true ? {
+            truncated: true
+        } : {},
+        ...expression.truncated ? {
+            exprTruncated: true
+        } : {},
+        ...input.reference === true ? {
+            reference: true
+        } : {},
+        ...input.degraded === true ? {
+            degraded: true
+        } : {}
+    };
+}
+export function predicateTraceEntry(input) {
+    return evaluationTraceEntry({
+        expression: input.expression,
+        roots: input.route.roots,
+        fillTarget: input.route.fillTarget,
+        evaluatedAt: input.site,
+        value: String(input.value),
+        ...input.degraded === true ? {
+            degraded: true
+        } : {}
+    });
+}
+export function capTraceEntries(entries) {
+    const traceEntries = [];
+    let dropped = 0;
+    for (const entry of entries){
+        if (isEvaluationTraceLimitEntry(entry)) {
+            dropped += entry.dropped;
+            continue;
+        }
+        traceEntries.push(entry);
+    }
+    const keepCount = EVALUATION_TRACE_MAX_ENTRIES - 1;
+    if (traceEntries.length + (dropped > 0 ? 1 : 0) <= EVALUATION_TRACE_MAX_ENTRIES) {
+        return dropped === 0 ? traceEntries : [
+            ...traceEntries,
+            {
+                truncated: true,
+                dropped
+            }
+        ];
+    }
+    return [
+        ...traceEntries.slice(0, keepCount),
+        {
+            truncated: true,
+            dropped: dropped + traceEntries.length - keepCount
+        }
+    ];
+}
+function isEvaluationTraceLimitEntry(entry) {
+    return 'dropped' in entry;
+}
+
+//# sourceMappingURL=evaluation-trace.js.map

package/dist/plan/evaluation-trace.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/evaluation-trace.ts"],"sourcesContent":["import type {AvailabilitySite, FillTarget} from '../workflow-context/workflow-context.js';\nimport type {RoutedExpression} from './route-expression.js';\n\nexport const EVALUATION_TRACE_VALUE_CAP_BYTES = 1024;\nexport const EVALUATION_TRACE_MAX_ENTRIES = 256;\n\nconst TRACE_TRUNCATION_MARKER = '...[truncated]';\nconst textEncoder = new TextEncoder();\n\nexport interface EvaluationTraceEntry {\n  readonly expression: string;\n  readonly roots: readonly string[];\n  readonly fillTarget: FillTarget;\n  readonly evaluatedAt: AvailabilitySite;\n  readonly value?: string;\n  readonly truncated?: boolean;\n  readonly exprTruncated?: boolean;\n  readonly reference?: boolean;\n  readonly degraded?: boolean;\n}\n\nexport interface EvaluationTraceLimitEntry {\n  readonly truncated: true;\n  readonly dropped: number;\n}\n\nexport type EvaluationTraceRowEntry = EvaluationTraceEntry | EvaluationTraceLimitEntry;\n\nexport interface EvaluationTraceEntryInput {\n  readonly expression: string;\n  readonly roots: readonly string[];\n  readonly fillTarget: FillTarget;\n  readonly evaluatedAt: AvailabilitySite;\n  readonly value?: string;\n  readonly reference?: boolean;\n  readonly degraded?: boolean;\n}\n\nexport interface PredicateTraceEntryInput {\n  readonly expression: string;\n  readonly route: RoutedExpression;\n  readonly site: AvailabilitySite;\n  readonly value: boolean;\n  readonly degraded?: boolean;\n}\n\nexport function capTraceValue(value: string): {value: string; truncated: boolean} {\n  if (textEncoder.encode(value).byteLength <= EVALUATION_TRACE_VALUE_CAP_BYTES) {\n    return {value, truncated: false};\n  }\n\n  const budget =\n    EVALUATION_TRACE_VALUE_CAP_BYTES - textEncoder.encode(TRACE_TRUNCATION_MARKER).byteLength;\n  let used = 0;\n  let capped = '';\n\n  for (const char of value) {\n    const charBytes = textEncoder.encode(char).byteLength;\n    if (used + charBytes > budget) break;\n    capped += char;\n    used += charBytes;\n  }\n\n  return {value: capped + TRACE_TRUNCATION_MARKER, truncated: true};\n}\n\nexport function evaluationTraceEntry(input: EvaluationTraceEntryInput): EvaluationTraceEntry {\n  const expression = capTraceValue(input.expression);\n  const value =\n    input.value === undefined || input.reference === true ? undefined : capTraceValue(input.value);\n\n  return {\n    expression: expression.value,\n    roots: input.roots,\n    fillTarget: input.fillTarget,\n    evaluatedAt: input.evaluatedAt,\n    ...(value === undefined ? {} : {value: value.value}),\n    ...(value?.truncated === true ? {truncated: true} : {}),\n    ...(expression.truncated ? {exprTruncated: true} : {}),\n    ...(input.reference === true ? {reference: true} : {}),\n    ...(input.degraded === true ? {degraded: true} : {}),\n  };\n}\n\nexport function predicateTraceEntry(input: PredicateTraceEntryInput): EvaluationTraceEntry {\n  return evaluationTraceEntry({\n    expression: input.expression,\n    roots: input.route.roots,\n    fillTarget: input.route.fillTarget,\n    evaluatedAt: input.site,\n    value: String(input.value),\n    ...(input.degraded === true ? {degraded: true} : {}),\n  });\n}\n\nexport function capTraceEntries<Entry extends EvaluationTraceRowEntry>(\n  entries: readonly Entry[],\n): readonly (Exclude<Entry, EvaluationTraceLimitEntry> | EvaluationTraceLimitEntry)[] {\n  const traceEntries: Exclude<Entry, EvaluationTraceLimitEntry>[] = [];\n  let dropped = 0;\n\n  for (const entry of entries) {\n    if (isEvaluationTraceLimitEntry(entry)) {\n      dropped += entry.dropped;\n      continue;\n    }\n\n    traceEntries.push(entry as Exclude<Entry, EvaluationTraceLimitEntry>);\n  }\n\n  const keepCount = EVALUATION_TRACE_MAX_ENTRIES - 1;\n  if (traceEntries.length + (dropped > 0 ? 1 : 0) <= EVALUATION_TRACE_MAX_ENTRIES) {\n    return dropped === 0 ? traceEntries : [...traceEntries, {truncated: true, dropped}];\n  }\n\n  return [\n    ...traceEntries.slice(0, keepCount),\n    {truncated: true, dropped: dropped + traceEntries.length - keepCount},\n  ];\n}\n\nfunction isEvaluationTraceLimitEntry(\n  entry: EvaluationTraceRowEntry,\n): entry is EvaluationTraceLimitEntry {\n  return 'dropped' in entry;\n}\n"],"names":["EVALUATION_TRACE_VALUE_CAP_BYTES","EVALUATION_TRACE_MAX_ENTRIES","TRACE_TRUNCATION_MARKER","textEncoder","TextEncoder","capTraceValue","value","encode","byteLength","truncated","budget","used","capped","char","charBytes","evaluationTraceEntry","input","expression","undefined","reference","roots","fillTarget","evaluatedAt","exprTruncated","degraded","predicateTraceEntry","route","site","String","capTraceEntries","entries","traceEntries","dropped","entry","isEvaluationTraceLimitEntry","push","keepCount","length","slice"],"mappings":"AAGA,OAAO,MAAMA,mCAAmC,KAAK;AACrD,OAAO,MAAMC,+BAA+B,IAAI;AAEhD,MAAMC,0BAA0B;AAChC,MAAMC,cAAc,IAAIC;AAuCxB,OAAO,SAASC,cAAcC,KAAa;IACzC,IAAIH,YAAYI,MAAM,CAACD,OAAOE,UAAU,IAAIR,kCAAkC;QAC5E,OAAO;YAACM;YAAOG,WAAW;QAAK;IACjC;IAEA,MAAMC,SACJV,mCAAmCG,YAAYI,MAAM,CAACL,yBAAyBM,UAAU;IAC3F,IAAIG,OAAO;IACX,IAAIC,SAAS;IAEb,KAAK,MAAMC,QAAQP,MAAO;QACxB,MAAMQ,YAAYX,YAAYI,MAAM,CAACM,MAAML,UAAU;QACrD,IAAIG,OAAOG,YAAYJ,QAAQ;QAC/BE,UAAUC;QACVF,QAAQG;IACV;IAEA,OAAO;QAACR,OAAOM,SAASV;QAAyBO,WAAW;IAAI;AAClE;AAEA,OAAO,SAASM,qBAAqBC,KAAgC;IACnE,MAAMC,aAAaZ,cAAcW,MAAMC,UAAU;IACjD,MAAMX,QACJU,MAAMV,KAAK,KAAKY,aAAaF,MAAMG,SAAS,KAAK,OAAOD,YAAYb,cAAcW,MAAMV,KAAK;IAE/F,OAAO;QACLW,YAAYA,WAAWX,KAAK;QAC5Bc,OAAOJ,MAAMI,KAAK;QAClBC,YAAYL,MAAMK,UAAU;QAC5BC,aAAaN,MAAMM,WAAW;QAC9B,GAAIhB,UAAUY,YAAY,CAAC,IAAI;YAACZ,OAAOA,MAAMA,KAAK;QAAA,CAAC;QACnD,GAAIA,OAAOG,cAAc,OAAO;YAACA,WAAW;QAAI,IAAI,CAAC,CAAC;QACtD,GAAIQ,WAAWR,SAAS,GAAG;YAACc,eAAe;QAAI,IAAI,CAAC,CAAC;QACrD,GAAIP,MAAMG,SAAS,KAAK,OAAO;YAACA,WAAW;QAAI,IAAI,CAAC,CAAC;QACrD,GAAIH,MAAMQ,QAAQ,KAAK,OAAO;YAACA,UAAU;QAAI,IAAI,CAAC,CAAC;IACrD;AACF;AAEA,OAAO,SAASC,oBAAoBT,KAA+B;IACjE,OAAOD,qBAAqB;QAC1BE,YAAYD,MAAMC,UAAU;QAC5BG,OAAOJ,MAAMU,KAAK,CAACN,KAAK;QACxBC,YAAYL,MAAMU,KAAK,CAACL,UAAU;QAClCC,aAAaN,MAAMW,IAAI;QACvBrB,OAAOsB,OAAOZ,MAAMV,KAAK;QACzB,GAAIU,MAAMQ,QAAQ,KAAK,OAAO;YAACA,UAAU;QAAI,IAAI,CAAC,CAAC;IACrD;AACF;AAEA,OAAO,SAASK,gBACdC,OAAyB;IAEzB,MAAMC,eAA4D,EAAE;IACpE,IAAIC,UAAU;IAEd,KAAK,MAAMC,SAASH,QAAS;QAC3B,IAAII,4BAA4BD,QAAQ;YACtCD,WAAWC,MAAMD,OAAO;YACxB;QACF;QAEAD,aAAaI,IAAI,CAACF;IACpB;IAEA,MAAMG,YAAYnC,+BAA+B;IACjD,IAAI8B,aAAaM,MAAM,GAAIL,CAAAA,UAAU,IAAI,IAAI,CAAA,KAAM/B,8BAA8B;QAC/E,OAAO+B,YAAY,IAAID,eAAe;eAAIA;YAAc;gBAACtB,WAAW;gBAAMuB;YAAO;SAAE;IACrF;IAEA,OAAO;WACFD,aAAaO,KAAK,CAAC,GAAGF;QACzB;YAAC3B,WAAW;YAAMuB,SAASA,UAAUD,aAAaM,MAAM,GAAGD;QAAS;KACrE;AACH;AAEA,SAASF,4BACPD,KAA8B;IAE9B,OAAO,aAAaA;AACtB"}

package/dist/plan/extract-exact-context-roots.d.ts

@@ -0,0 +1,2 @@
+export declare function extractExactContextRoots(source: string): string[];
+//# sourceMappingURL=extract-exact-context-roots.d.ts.map

package/dist/plan/extract-exact-context-roots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-exact-context-roots.d.ts","sourceRoot":"","sources":["../../src/plan/extract-exact-context-roots.ts"],"names":[],"mappings":"AAmBA,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAIjE"}

package/dist/plan/extract-exact-context-roots.js

@@ -0,0 +1,114 @@
+import { parse as parseCel } from '@marcbachmann/cel-js';
+const binaryOperators = new Set([
+    '!=',
+    '==',
+    'in',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '<',
+    '<=',
+    '>',
+    '>='
+]);
+const comprehensionMethods = new Set([
+    'all',
+    'exists',
+    'exists_one',
+    'filter',
+    'map'
+]);
+export function extractExactContextRoots(source) {
+    const roots = new Set();
+    collectExactContextRoots(parseCel(source).ast, roots, new Set());
+    return [
+        ...roots
+    ].sort();
+}
+function collectExactContextRoots(node, roots, scopedIdentifiers) {
+    if (binaryOperators.has(node.op) || node.op === '||' || node.op === '&&') {
+        collectBinaryExactContextRoots(node.args, roots, scopedIdentifiers);
+        return;
+    }
+    switch(node.op){
+        case 'id':
+            if (!scopedIdentifiers.has(node.args)) roots.add(node.args);
+            return;
+        case 'value':
+            return;
+        case '.':
+        case '.?':
+            collectExactContextRoots(node.args[0], roots, scopedIdentifiers);
+            return;
+        case '[]':
+        case '[?]':
+            collectBinaryExactContextRoots(node.args, roots, scopedIdentifiers);
+            return;
+        case 'call':
+            for (const argument of node.args[1]){
+                collectExactContextRoots(argument, roots, scopedIdentifiers);
+            }
+            return;
+        case 'rcall':
+            {
+                const [method, receiver, args] = node.args;
+                collectExactContextRoots(receiver, roots, scopedIdentifiers);
+                const binding = bindComprehensionAlias(method, args, scopedIdentifiers);
+                for (const argument of args.slice(binding.skipArgs)){
+                    collectExactContextRoots(argument, roots, binding.scopedIdentifiers);
+                }
+                return;
+            }
+        case 'list':
+            for (const element of node.args){
+                collectExactContextRoots(element, roots, scopedIdentifiers);
+            }
+            return;
+        case 'map':
+            for (const [key, value] of node.args){
+                collectMapKeyExactContextRoots(key, roots, scopedIdentifiers);
+                collectExactContextRoots(value, roots, scopedIdentifiers);
+            }
+            return;
+        case '?:':
+            collectExactContextRoots(node.args[0], roots, scopedIdentifiers);
+            collectExactContextRoots(node.args[1], roots, scopedIdentifiers);
+            collectExactContextRoots(node.args[2], roots, scopedIdentifiers);
+            return;
+        case '!_':
+        case '-_':
+            collectExactContextRoots(node.args, roots, scopedIdentifiers);
+            return;
+    }
+    throw new Error(`Unsupported CEL AST operator: ${node.op}`);
+}
+function collectBinaryExactContextRoots([left, right], roots, scopedIdentifiers) {
+    collectExactContextRoots(left, roots, scopedIdentifiers);
+    collectExactContextRoots(right, roots, scopedIdentifiers);
+}
+function collectMapKeyExactContextRoots(key, roots, scopedIdentifiers) {
+    if (key.op === 'id') return;
+    collectExactContextRoots(key, roots, scopedIdentifiers);
+}
+function bindComprehensionAlias(method, args, scopedIdentifiers) {
+    if (!comprehensionMethods.has(method)) return {
+        scopedIdentifiers,
+        skipArgs: 0
+    };
+    const [alias] = args;
+    if (alias?.op !== 'id') return {
+        scopedIdentifiers,
+        skipArgs: 0
+    };
+    return {
+        scopedIdentifiers: new Set([
+            ...scopedIdentifiers,
+            alias.args
+        ]),
+        skipArgs: 1
+    };
+}
+
+//# sourceMappingURL=extract-exact-context-roots.js.map

package/dist/plan/extract-exact-context-roots.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/extract-exact-context-roots.ts"],"sourcesContent":["import {type ASTNode, type BinaryOperator, parse as parseCel} from '@marcbachmann/cel-js';\n\nconst binaryOperators = new Set<BinaryOperator>([\n  '!=',\n  '==',\n  'in',\n  '+',\n  '-',\n  '*',\n  '/',\n  '%',\n  '<',\n  '<=',\n  '>',\n  '>=',\n]);\n\nconst comprehensionMethods = new Set(['all', 'exists', 'exists_one', 'filter', 'map']);\n\nexport function extractExactContextRoots(source: string): string[] {\n  const roots = new Set<string>();\n  collectExactContextRoots(parseCel(source).ast, roots, new Set());\n  return [...roots].sort();\n}\n\nfunction collectExactContextRoots(\n  node: ASTNode,\n  roots: Set<string>,\n  scopedIdentifiers: ReadonlySet<string>,\n): void {\n  if (binaryOperators.has(node.op as BinaryOperator) || node.op === '||' || node.op === '&&') {\n    collectBinaryExactContextRoots(node.args as [ASTNode, ASTNode], roots, scopedIdentifiers);\n    return;\n  }\n\n  switch (node.op) {\n    case 'id':\n      if (!scopedIdentifiers.has(node.args)) roots.add(node.args);\n      return;\n    case 'value':\n      return;\n    case '.':\n    case '.?':\n      collectExactContextRoots(node.args[0], roots, scopedIdentifiers);\n      return;\n    case '[]':\n    case '[?]':\n      collectBinaryExactContextRoots(node.args, roots, scopedIdentifiers);\n      return;\n    case 'call':\n      for (const argument of node.args[1]) {\n        collectExactContextRoots(argument, roots, scopedIdentifiers);\n      }\n      return;\n    case 'rcall': {\n      const [method, receiver, args] = node.args as [string, ASTNode, ASTNode[]];\n      collectExactContextRoots(receiver, roots, scopedIdentifiers);\n      const binding = bindComprehensionAlias(method, args, scopedIdentifiers);\n      for (const argument of args.slice(binding.skipArgs)) {\n        collectExactContextRoots(argument, roots, binding.scopedIdentifiers);\n      }\n      return;\n    }\n    case 'list':\n      for (const element of node.args) {\n        collectExactContextRoots(element, roots, scopedIdentifiers);\n      }\n      return;\n    case 'map':\n      for (const [key, value] of node.args) {\n        collectMapKeyExactContextRoots(key, roots, scopedIdentifiers);\n        collectExactContextRoots(value, roots, scopedIdentifiers);\n      }\n      return;\n    case '?:':\n      collectExactContextRoots(node.args[0], roots, scopedIdentifiers);\n      collectExactContextRoots(node.args[1], roots, scopedIdentifiers);\n      collectExactContextRoots(node.args[2], roots, scopedIdentifiers);\n      return;\n    case '!_':\n    case '-_':\n      collectExactContextRoots(node.args, roots, scopedIdentifiers);\n      return;\n  }\n\n  throw new Error(`Unsupported CEL AST operator: ${(node as {op: string}).op}`);\n}\n\nfunction collectBinaryExactContextRoots(\n  [left, right]: [ASTNode, ASTNode],\n  roots: Set<string>,\n  scopedIdentifiers: ReadonlySet<string>,\n): void {\n  collectExactContextRoots(left, roots, scopedIdentifiers);\n  collectExactContextRoots(right, roots, scopedIdentifiers);\n}\n\nfunction collectMapKeyExactContextRoots(\n  key: ASTNode,\n  roots: Set<string>,\n  scopedIdentifiers: ReadonlySet<string>,\n): void {\n  if (key.op === 'id') return;\n  collectExactContextRoots(key, roots, scopedIdentifiers);\n}\n\nfunction bindComprehensionAlias(\n  method: string,\n  args: readonly ASTNode[],\n  scopedIdentifiers: ReadonlySet<string>,\n): {readonly scopedIdentifiers: ReadonlySet<string>; readonly skipArgs: number} {\n  if (!comprehensionMethods.has(method)) return {scopedIdentifiers, skipArgs: 0};\n\n  const [alias] = args;\n  if (alias?.op !== 'id') return {scopedIdentifiers, skipArgs: 0};\n\n  return {\n    scopedIdentifiers: new Set([...scopedIdentifiers, alias.args]),\n    skipArgs: 1,\n  };\n}\n"],"names":["parse","parseCel","binaryOperators","Set","comprehensionMethods","extractExactContextRoots","source","roots","collectExactContextRoots","ast","sort","node","scopedIdentifiers","has","op","collectBinaryExactContextRoots","args","add","argument","method","receiver","binding","bindComprehensionAlias","slice","skipArgs","element","key","value","collectMapKeyExactContextRoots","Error","left","right","alias"],"mappings":"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"}

package/dist/plan/fill.d.ts

@@ -0,0 +1,3 @@
+import { type AvailabilitySite } from '../workflow-context/workflow-context.js';
+export declare function shouldFillAtSite(fillTarget: string, site: AvailabilitySite): boolean;
+//# sourceMappingURL=fill.d.ts.map

package/dist/plan/fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill.d.ts","sourceRoot":"","sources":["../../src/plan/fill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,gBAAgB,EAAoB,MAAM,yCAAyC,CAAC;AAEjG,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAKpF"}