@shipfox/expression 1.1.0

package/dist/plan/fill.js

@@ -0,0 +1,8 @@
+import { availabilitySites } from '../workflow-context/workflow-context.js';
+export function shouldFillAtSite(fillTarget, site) {
+    const fillTargetIndex = availabilitySites.indexOf(fillTarget);
+    if (fillTargetIndex < 0) return false;
+    return fillTargetIndex <= availabilitySites.indexOf(site);
+}
+
+//# sourceMappingURL=fill.js.map

package/dist/plan/fill.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/fill.ts"],"sourcesContent":["import {type AvailabilitySite, availabilitySites} from '../workflow-context/workflow-context.js';\n\nexport function shouldFillAtSite(fillTarget: string, site: AvailabilitySite): boolean {\n  const fillTargetIndex = availabilitySites.indexOf(fillTarget as AvailabilitySite);\n  if (fillTargetIndex < 0) return false;\n\n  return fillTargetIndex <= availabilitySites.indexOf(site);\n}\n"],"names":["availabilitySites","shouldFillAtSite","fillTarget","site","fillTargetIndex","indexOf"],"mappings":"AAAA,SAA+BA,iBAAiB,QAAO,0CAA0C;AAEjG,OAAO,SAASC,iBAAiBC,UAAkB,EAAEC,IAAsB;IACzE,MAAMC,kBAAkBJ,kBAAkBK,OAAO,CAACH;IAClD,IAAIE,kBAAkB,GAAG,OAAO;IAEhC,OAAOA,mBAAmBJ,kBAAkBK,OAAO,CAACF;AACtD"}

package/dist/plan/freeze-run-command.d.ts

@@ -0,0 +1,17 @@
+import type { WorkflowExpressionEvaluationContext } from '../evaluator/evaluate-workflow-expression.js';
+import type { AvailabilitySite, WorkflowInterpolationFailurePolicy } from '../workflow-context/workflow-context.js';
+import { type WorkflowTemplateDiagnostic } from './freeze.js';
+import type { ResolvedField } from './resolved-field.js';
+export interface FrozenPlannedRunCommand {
+    readonly command: string;
+    readonly env: Readonly<Record<string, string>>;
+    readonly diagnostics: readonly WorkflowTemplateDiagnostic[];
+}
+export declare function freezePlannedRunCommandAtSite(params: {
+    readonly field: ResolvedField;
+    readonly site: AvailabilitySite;
+    readonly context: WorkflowExpressionEvaluationContext;
+    readonly failurePolicy: WorkflowInterpolationFailurePolicy;
+    readonly reservedNames?: Iterable<string>;
+}): FrozenPlannedRunCommand;
+//# sourceMappingURL=freeze-run-command.d.ts.map

package/dist/plan/freeze-run-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"freeze-run-command.d.ts","sourceRoot":"","sources":["../../src/plan/freeze-run-command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,mCAAmC,EAAC,MAAM,8CAA8C,CAAC;AAEtG,OAAO,KAAK,EACV,gBAAgB,EAChB,kCAAkC,EACnC,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAA4B,KAAK,0BAA0B,EAAC,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAEvD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/C,QAAQ,CAAC,WAAW,EAAE,SAAS,0BAA0B,EAAE,CAAC;CAC7D;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE;IACpD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,mCAAmC,CAAC;IACtD,QAAQ,CAAC,aAAa,EAAE,kCAAkC,CAAC;IAC3D,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC3C,GAAG,uBAAuB,CAoB1B"}

package/dist/plan/freeze-run-command.js

@@ -0,0 +1,33 @@
+import { hoistPlannedRunCommand } from '../run/hoist-run-command.js';
+import { freezeResolvedFieldAtSite } from './freeze.js';
+export function freezePlannedRunCommandAtSite(params) {
+    const hoisted = hoistPlannedRunCommand({
+        field: params.field,
+        ...params.reservedNames === undefined ? {} : {
+            reservedNames: params.reservedNames
+        }
+    });
+    const env = {};
+    const diagnostics = [];
+    for (const binding of hoisted.bindings){
+        const resolved = freezeResolvedFieldAtSite({
+            field: {
+                segments: [
+                    binding.segment
+                ]
+            },
+            site: params.site,
+            context: params.context,
+            failurePolicy: params.failurePolicy
+        });
+        env[binding.name] = resolved.value;
+        diagnostics.push(...resolved.diagnostics);
+    }
+    return {
+        command: hoisted.command,
+        env,
+        diagnostics
+    };
+}
+
+//# sourceMappingURL=freeze-run-command.js.map

package/dist/plan/freeze-run-command.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/freeze-run-command.ts"],"sourcesContent":["import type {WorkflowExpressionEvaluationContext} from '../evaluator/evaluate-workflow-expression.js';\nimport {hoistPlannedRunCommand} from '../run/hoist-run-command.js';\nimport type {\n  AvailabilitySite,\n  WorkflowInterpolationFailurePolicy,\n} from '../workflow-context/workflow-context.js';\nimport {freezeResolvedFieldAtSite, type WorkflowTemplateDiagnostic} from './freeze.js';\nimport type {ResolvedField} from './resolved-field.js';\n\nexport interface FrozenPlannedRunCommand {\n  readonly command: string;\n  readonly env: Readonly<Record<string, string>>;\n  readonly diagnostics: readonly WorkflowTemplateDiagnostic[];\n}\n\nexport function freezePlannedRunCommandAtSite(params: {\n  readonly field: ResolvedField;\n  readonly site: AvailabilitySite;\n  readonly context: WorkflowExpressionEvaluationContext;\n  readonly failurePolicy: WorkflowInterpolationFailurePolicy;\n  readonly reservedNames?: Iterable<string>;\n}): FrozenPlannedRunCommand {\n  const hoisted = hoistPlannedRunCommand({\n    field: params.field,\n    ...(params.reservedNames === undefined ? {} : {reservedNames: params.reservedNames}),\n  });\n  const env: Record<string, string> = {};\n  const diagnostics: WorkflowTemplateDiagnostic[] = [];\n\n  for (const binding of hoisted.bindings) {\n    const resolved = freezeResolvedFieldAtSite({\n      field: {segments: [binding.segment]},\n      site: params.site,\n      context: params.context,\n      failurePolicy: params.failurePolicy,\n    });\n    env[binding.name] = resolved.value;\n    diagnostics.push(...resolved.diagnostics);\n  }\n\n  return {command: hoisted.command, env, diagnostics};\n}\n"],"names":["hoistPlannedRunCommand","freezeResolvedFieldAtSite","freezePlannedRunCommandAtSite","params","hoisted","field","reservedNames","undefined","env","diagnostics","binding","bindings","resolved","segments","segment","site","context","failurePolicy","name","value","push","command"],"mappings":"AACA,SAAQA,sBAAsB,QAAO,8BAA8B;AAKnE,SAAQC,yBAAyB,QAAwC,cAAc;AASvF,OAAO,SAASC,8BAA8BC,MAM7C;IACC,MAAMC,UAAUJ,uBAAuB;QACrCK,OAAOF,OAAOE,KAAK;QACnB,GAAIF,OAAOG,aAAa,KAAKC,YAAY,CAAC,IAAI;YAACD,eAAeH,OAAOG,aAAa;QAAA,CAAC;IACrF;IACA,MAAME,MAA8B,CAAC;IACrC,MAAMC,cAA4C,EAAE;IAEpD,KAAK,MAAMC,WAAWN,QAAQO,QAAQ,CAAE;QACtC,MAAMC,WAAWX,0BAA0B;YACzCI,OAAO;gBAACQ,UAAU;oBAACH,QAAQI,OAAO;iBAAC;YAAA;YACnCC,MAAMZ,OAAOY,IAAI;YACjBC,SAASb,OAAOa,OAAO;YACvBC,eAAed,OAAOc,aAAa;QACrC;QACAT,GAAG,CAACE,QAAQQ,IAAI,CAAC,GAAGN,SAASO,KAAK;QAClCV,YAAYW,IAAI,IAAIR,SAASH,WAAW;IAC1C;IAEA,OAAO;QAACY,SAASjB,QAAQiB,OAAO;QAAEb;QAAKC;IAAW;AACpD"}

package/dist/plan/freeze.d.ts

@@ -0,0 +1,48 @@
+import { type WorkflowExpressionEvaluationContext } from '../evaluator/index.js';
+import { type AvailabilitySite, type WorkflowInterpolationFailurePolicy } from '../workflow-context/workflow-context.js';
+import { type EvaluationTraceEntry } from './evaluation-trace.js';
+import type { ResolvedField } from './resolved-field.js';
+export type WorkflowTemplateFailurePolicy = WorkflowInterpolationFailurePolicy;
+export interface WorkflowTemplateDiagnostic {
+    readonly reason: 'missing-path';
+    readonly expression: string;
+    readonly contextRoots: readonly string[];
+}
+export interface FrozenResolvedField {
+    readonly value: string;
+    readonly diagnostics: readonly WorkflowTemplateDiagnostic[];
+    readonly trace: readonly EvaluationTraceEntry[];
+}
+export type SiteResolvedField = {
+    readonly kind: 'frozen';
+    readonly value: string;
+    readonly diagnostics: readonly WorkflowTemplateDiagnostic[];
+    readonly trace: readonly EvaluationTraceEntry[];
+} | {
+    readonly kind: 'residual';
+    readonly field: ResolvedField;
+    readonly diagnostics: readonly WorkflowTemplateDiagnostic[];
+    readonly trace: readonly EvaluationTraceEntry[];
+};
+/**
+ * Segment lifecycle:
+ *
+ * `{expr}` -> plan -> `{deferred, fillTarget}` -> freeze at a site at or after
+ * `fillTarget` -> `{literal}`. Runner-fill segments are never filled server-side.
+ *
+ * Value fields follow their declared policy at their fill target. Predicates use
+ * the planned predicate entry point and fail closed when evaluation is deferred.
+ */
+export declare function freezeResolvedFieldAtSite(params: {
+    readonly field: ResolvedField;
+    readonly failurePolicy: WorkflowInterpolationFailurePolicy;
+    readonly site: AvailabilitySite;
+    readonly context: WorkflowExpressionEvaluationContext;
+}): FrozenResolvedField;
+export declare function resolveFieldAtSite(params: {
+    readonly field: ResolvedField;
+    readonly failurePolicy: WorkflowInterpolationFailurePolicy;
+    readonly site: AvailabilitySite;
+    readonly context: WorkflowExpressionEvaluationContext;
+}): SiteResolvedField;
+//# sourceMappingURL=freeze.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"freeze.d.ts","sourceRoot":"","sources":["../../src/plan/freeze.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mCAAmC,EAEzC,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,KAAK,gBAAgB,EAErB,KAAK,kCAAkC,EACxC,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAC,KAAK,oBAAoB,EAAuB,MAAM,uBAAuB,CAAC;AAEtF,OAAO,KAAK,EACV,aAAa,EAGd,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,6BAA6B,GAAG,kCAAkC,CAAC;AAE/E,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACjD;AAED,MAAM,MAAM,iBAAiB,GACzB;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACjD,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACjD,CAAC;AAEN;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAChD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,kCAAkC,CAAC;IAC3D,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,mCAAmC,CAAC;CACvD,GAAG,mBAAmB,CA4CtB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,kCAAkC,CAAC;IAC3D,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,mCAAmC,CAAC;CACvD,GAAG,iBAAiB,CAmDpB"}

package/dist/plan/freeze.js

@@ -0,0 +1,148 @@
+import { evaluateWorkflowExpression, WorkflowExpressionEvaluationError } from '../evaluator/index.js';
+import { coerceWorkflowValueToString } from '../resolver/coerce-workflow-value-to-string.js';
+import { WorkflowTemplateResolutionError } from '../resolver/errors.js';
+import { resolveContextRootAvailability } from '../workflow-context/workflow-context.js';
+import { evaluationTraceEntry } from './evaluation-trace.js';
+import { shouldFillAtSite } from './fill.js';
+/**
+ * Segment lifecycle:
+ *
+ * `{expr}` -> plan -> `{deferred, fillTarget}` -> freeze at a site at or after
+ * `fillTarget` -> `{literal}`. Runner-fill segments are never filled server-side.
+ *
+ * Value fields follow their declared policy at their fill target. Predicates use
+ * the planned predicate entry point and fail closed when evaluation is deferred.
+ */ export function freezeResolvedFieldAtSite(params) {
+    let value = '';
+    const diagnostics = [];
+    const trace = [];
+    for (const segment of params.field.segments){
+        if (segment.kind === 'literal') {
+            value += segment.value;
+            continue;
+        }
+        if (!shouldFillAtSite(segment.fillTarget, params.site)) {
+            diagnostics.push(missingPathDiagnostic(segment));
+            continue;
+        }
+        try {
+            const literal = coerceWorkflowValueToString(evaluateWorkflowExpression(segment.expression, params.context));
+            value += literal;
+            trace.push(fillTraceEntry(segment, params.site, literal));
+        } catch (error) {
+            if (error instanceof WorkflowExpressionEvaluationError && error.reason === 'missing-path') {
+                if (missingPathRequiresFailure(segment, params.failurePolicy, params.site)) {
+                    throw new WorkflowTemplateResolutionError({
+                        source: segment.expression.source,
+                        cause: error
+                    });
+                }
+                diagnostics.push(missingPathDiagnostic(segment));
+                trace.push(fillTraceEntry(segment, params.site, '', true));
+                continue;
+            }
+            throw new WorkflowTemplateResolutionError({
+                source: segment.expression.source,
+                cause: error
+            });
+        }
+    }
+    return {
+        value,
+        diagnostics,
+        trace
+    };
+}
+export function resolveFieldAtSite(params) {
+    let value = '';
+    const diagnostics = [];
+    const trace = [];
+    const segments = [];
+    let hasResidual = false;
+    for (const segment of params.field.segments){
+        if (segment.kind === 'literal') {
+            value += segment.value;
+            segments.push(segment);
+            continue;
+        }
+        if (!shouldFillAtSite(segment.fillTarget, params.site)) {
+            hasResidual = true;
+            segments.push(segment);
+            continue;
+        }
+        try {
+            const literal = coerceWorkflowValueToString(evaluateWorkflowExpression(segment.expression, params.context));
+            value += literal;
+            segments.push({
+                kind: 'literal',
+                value: literal
+            });
+            trace.push(fillTraceEntry(segment, params.site, literal));
+        } catch (error) {
+            if (error instanceof WorkflowExpressionEvaluationError && error.reason === 'missing-path') {
+                if (missingPathRequiresFailure(segment, params.failurePolicy, params.site)) {
+                    throw new WorkflowTemplateResolutionError({
+                        source: segment.expression.source,
+                        cause: error
+                    });
+                }
+                diagnostics.push(missingPathDiagnostic(segment));
+                segments.push({
+                    kind: 'literal',
+                    value: ''
+                });
+                trace.push(fillTraceEntry(segment, params.site, '', true));
+                continue;
+            }
+            throw new WorkflowTemplateResolutionError({
+                source: segment.expression.source,
+                cause: error
+            });
+        }
+    }
+    if (hasResidual) return {
+        kind: 'residual',
+        field: {
+            segments
+        },
+        diagnostics,
+        trace
+    };
+    return {
+        kind: 'frozen',
+        value,
+        diagnostics,
+        trace
+    };
+}
+function fillTraceEntry(segment, site, value, degraded = false) {
+    return evaluationTraceEntry({
+        expression: segment.expression.source,
+        roots: segment.roots,
+        fillTarget: segment.fillTarget,
+        evaluatedAt: site,
+        value,
+        ...degraded ? {
+            degraded: true
+        } : {}
+    });
+}
+function missingPathDiagnostic(segment) {
+    return {
+        reason: 'missing-path',
+        expression: segment.expression.source,
+        contextRoots: segment.roots
+    };
+}
+function missingPathRequiresFailure(segment, failurePolicy, site) {
+    if (failurePolicy !== 'fail') return false;
+    const rootAvailabilities = segment.roots.flatMap((root)=>{
+        const availability = resolveContextRootAvailability(root);
+        return availability === undefined ? [] : [
+            availability
+        ];
+    });
+    return rootAvailabilities.length > 0 && rootAvailabilities.every((availability)=>shouldFillAtSite(availability, site));
+}
+
+//# sourceMappingURL=freeze.js.map

package/dist/plan/freeze.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/freeze.ts"],"sourcesContent":["import {\n  evaluateWorkflowExpression,\n  type WorkflowExpressionEvaluationContext,\n  WorkflowExpressionEvaluationError,\n} from '../evaluator/index.js';\nimport {coerceWorkflowValueToString} from '../resolver/coerce-workflow-value-to-string.js';\nimport {WorkflowTemplateResolutionError} from '../resolver/errors.js';\nimport {\n  type AvailabilitySite,\n  resolveContextRootAvailability,\n  type WorkflowInterpolationFailurePolicy,\n} from '../workflow-context/workflow-context.js';\nimport {type EvaluationTraceEntry, evaluationTraceEntry} from './evaluation-trace.js';\nimport {shouldFillAtSite} from './fill.js';\nimport type {\n  ResolvedField,\n  ResolvedFieldDeferredSegment,\n  ResolvedFieldSegment,\n} from './resolved-field.js';\n\nexport type WorkflowTemplateFailurePolicy = WorkflowInterpolationFailurePolicy;\n\nexport interface WorkflowTemplateDiagnostic {\n  readonly reason: 'missing-path';\n  readonly expression: string;\n  readonly contextRoots: readonly string[];\n}\n\nexport interface FrozenResolvedField {\n  readonly value: string;\n  readonly diagnostics: readonly WorkflowTemplateDiagnostic[];\n  readonly trace: readonly EvaluationTraceEntry[];\n}\n\nexport type SiteResolvedField =\n  | {\n      readonly kind: 'frozen';\n      readonly value: string;\n      readonly diagnostics: readonly WorkflowTemplateDiagnostic[];\n      readonly trace: readonly EvaluationTraceEntry[];\n    }\n  | {\n      readonly kind: 'residual';\n      readonly field: ResolvedField;\n      readonly diagnostics: readonly WorkflowTemplateDiagnostic[];\n      readonly trace: readonly EvaluationTraceEntry[];\n    };\n\n/**\n * Segment lifecycle:\n *\n * `{expr}` -> plan -> `{deferred, fillTarget}` -> freeze at a site at or after\n * `fillTarget` -> `{literal}`. Runner-fill segments are never filled server-side.\n *\n * Value fields follow their declared policy at their fill target. Predicates use\n * the planned predicate entry point and fail closed when evaluation is deferred.\n */\nexport function freezeResolvedFieldAtSite(params: {\n  readonly field: ResolvedField;\n  readonly failurePolicy: WorkflowInterpolationFailurePolicy;\n  readonly site: AvailabilitySite;\n  readonly context: WorkflowExpressionEvaluationContext;\n}): FrozenResolvedField {\n  let value = '';\n  const diagnostics: WorkflowTemplateDiagnostic[] = [];\n  const trace: EvaluationTraceEntry[] = [];\n\n  for (const segment of params.field.segments) {\n    if (segment.kind === 'literal') {\n      value += segment.value;\n      continue;\n    }\n\n    if (!shouldFillAtSite(segment.fillTarget, params.site)) {\n      diagnostics.push(missingPathDiagnostic(segment));\n      continue;\n    }\n\n    try {\n      const literal = coerceWorkflowValueToString(\n        evaluateWorkflowExpression(segment.expression, params.context),\n      );\n      value += literal;\n      trace.push(fillTraceEntry(segment, params.site, literal));\n    } catch (error) {\n      if (error instanceof WorkflowExpressionEvaluationError && error.reason === 'missing-path') {\n        if (missingPathRequiresFailure(segment, params.failurePolicy, params.site)) {\n          throw new WorkflowTemplateResolutionError({\n            source: segment.expression.source,\n            cause: error,\n          });\n        }\n\n        diagnostics.push(missingPathDiagnostic(segment));\n        trace.push(fillTraceEntry(segment, params.site, '', true));\n        continue;\n      }\n\n      throw new WorkflowTemplateResolutionError({\n        source: segment.expression.source,\n        cause: error,\n      });\n    }\n  }\n\n  return {value, diagnostics, trace};\n}\n\nexport function resolveFieldAtSite(params: {\n  readonly field: ResolvedField;\n  readonly failurePolicy: WorkflowInterpolationFailurePolicy;\n  readonly site: AvailabilitySite;\n  readonly context: WorkflowExpressionEvaluationContext;\n}): SiteResolvedField {\n  let value = '';\n  const diagnostics: WorkflowTemplateDiagnostic[] = [];\n  const trace: EvaluationTraceEntry[] = [];\n  const segments: ResolvedFieldSegment[] = [];\n  let hasResidual = false;\n\n  for (const segment of params.field.segments) {\n    if (segment.kind === 'literal') {\n      value += segment.value;\n      segments.push(segment);\n      continue;\n    }\n\n    if (!shouldFillAtSite(segment.fillTarget, params.site)) {\n      hasResidual = true;\n      segments.push(segment);\n      continue;\n    }\n\n    try {\n      const literal = coerceWorkflowValueToString(\n        evaluateWorkflowExpression(segment.expression, params.context),\n      );\n      value += literal;\n      segments.push({kind: 'literal', value: literal});\n      trace.push(fillTraceEntry(segment, params.site, literal));\n    } catch (error) {\n      if (error instanceof WorkflowExpressionEvaluationError && error.reason === 'missing-path') {\n        if (missingPathRequiresFailure(segment, params.failurePolicy, params.site)) {\n          throw new WorkflowTemplateResolutionError({\n            source: segment.expression.source,\n            cause: error,\n          });\n        }\n\n        diagnostics.push(missingPathDiagnostic(segment));\n        segments.push({kind: 'literal', value: ''});\n        trace.push(fillTraceEntry(segment, params.site, '', true));\n        continue;\n      }\n\n      throw new WorkflowTemplateResolutionError({\n        source: segment.expression.source,\n        cause: error,\n      });\n    }\n  }\n\n  if (hasResidual) return {kind: 'residual', field: {segments}, diagnostics, trace};\n  return {kind: 'frozen', value, diagnostics, trace};\n}\n\nfunction fillTraceEntry(\n  segment: ResolvedFieldDeferredSegment,\n  site: AvailabilitySite,\n  value: string,\n  degraded = false,\n): EvaluationTraceEntry {\n  return evaluationTraceEntry({\n    expression: segment.expression.source,\n    roots: segment.roots,\n    fillTarget: segment.fillTarget,\n    evaluatedAt: site,\n    value,\n    ...(degraded ? {degraded: true} : {}),\n  });\n}\n\nfunction missingPathDiagnostic(segment: ResolvedFieldDeferredSegment): WorkflowTemplateDiagnostic {\n  return {\n    reason: 'missing-path',\n    expression: segment.expression.source,\n    contextRoots: segment.roots,\n  };\n}\n\nfunction missingPathRequiresFailure(\n  segment: ResolvedFieldDeferredSegment,\n  failurePolicy: WorkflowInterpolationFailurePolicy,\n  site: AvailabilitySite,\n): boolean {\n  if (failurePolicy !== 'fail') return false;\n  const rootAvailabilities = segment.roots.flatMap((root) => {\n    const availability = resolveContextRootAvailability(root);\n    return availability === undefined ? [] : [availability];\n  });\n  return (\n    rootAvailabilities.length > 0 &&\n    rootAvailabilities.every((availability) => shouldFillAtSite(availability, site))\n  );\n}\n"],"names":["evaluateWorkflowExpression","WorkflowExpressionEvaluationError","coerceWorkflowValueToString","WorkflowTemplateResolutionError","resolveContextRootAvailability","evaluationTraceEntry","shouldFillAtSite","freezeResolvedFieldAtSite","params","value","diagnostics","trace","segment","field","segments","kind","fillTarget","site","push","missingPathDiagnostic","literal","expression","context","fillTraceEntry","error","reason","missingPathRequiresFailure","failurePolicy","source","cause","resolveFieldAtSite","hasResidual","degraded","roots","evaluatedAt","contextRoots","rootAvailabilities","flatMap","root","availability","undefined","length","every"],"mappings":"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"}

package/dist/plan/plan-field.d.ts

@@ -0,0 +1,26 @@
+import type { WorkflowTemplateSegment } from '../template/template-segment.js';
+import { type WorkflowInterpolationFailurePolicy, type WorkflowInterpolationField } from '../workflow-context/workflow-context.js';
+import type { ResolvedField } from './resolved-field.js';
+export type PlanViolation = {
+    readonly reason: 'runner-root-not-bare' | 'computed-context-key';
+    readonly source: string;
+    readonly runnerRoots?: readonly string[];
+    readonly contextRoots?: readonly string[];
+    readonly hint: string;
+};
+export interface FieldPlan {
+    readonly field: ResolvedField;
+    readonly failurePolicy: WorkflowInterpolationFailurePolicy;
+}
+export type FieldPlanResult = {
+    readonly ok: true;
+    readonly plan: FieldPlan;
+} | {
+    readonly ok: false;
+    readonly violations: readonly PlanViolation[];
+};
+export declare function planInterpolationField(params: {
+    readonly field: WorkflowInterpolationField;
+    readonly segments: readonly WorkflowTemplateSegment[];
+}): FieldPlanResult;
+//# sourceMappingURL=plan-field.d.ts.map

package/dist/plan/plan-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-field.d.ts","sourceRoot":"","sources":["../../src/plan/plan-field.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAML,KAAK,kCAAkC,EACvC,KAAK,0BAA0B,EAChC,MAAM,yCAAyC,CAAC;AAGjD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAMvD,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,sBAAsB,GAAG,sBAAsB,CAAC;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,kCAAkC,CAAC;CAC5D;AAED,MAAM,MAAM,eAAe,GACvB;IAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAC,GAC7C;IAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAA;CAAC,CAAC;AAExE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,QAAQ,CAAC,KAAK,EAAE,0BAA0B,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,uBAAuB,EAAE,CAAC;CACvD,GAAG,eAAe,CA2ClB"}

package/dist/plan/plan-field.js

@@ -0,0 +1,63 @@
+import { availabilitySites, getWorkflowInterpolationFieldFailurePolicy, getWorkflowInterpolationFieldMinimumFillTarget } from '../workflow-context/workflow-context.js';
+import { isBareContextReference } from './bare-reference.js';
+import { analyzeContextKeyAccess } from './context-key-access.js';
+import { routeExpression } from './route-expression.js';
+const templateExpressionOpen = '$' + '{{';
+const runnerRootNotBareHint = `split runner-host references into their own adjacent ${templateExpressionOpen} }} segments`;
+export function planInterpolationField(params) {
+    const violations = [];
+    const minimumFillTarget = getWorkflowInterpolationFieldMinimumFillTarget(params.field);
+    const resolvedSegments = params.segments.map((segment)=>{
+        if (segment.kind === 'literal') return {
+            kind: 'literal',
+            value: segment.text
+        };
+        const route = routeExpression(segment.expression);
+        const keyAccess = analyzeContextKeyAccess(segment.expression);
+        if (keyAccess.violations.length > 0) {
+            violations.push(...keyAccess.violations.map((violation)=>({
+                    reason: 'computed-context-key',
+                    source: violation.source,
+                    contextRoots: [
+                        violation.root
+                    ],
+                    hint: `${violation.root} references must use a literal dot key`
+                })));
+        } else if (route.runnerRoots.length > 0 && !isBareContextReference(segment.expression.source)) {
+            violations.push({
+                reason: 'runner-root-not-bare',
+                source: segment.expression.source,
+                runnerRoots: route.runnerRoots,
+                hint: runnerRootNotBareHint
+            });
+        }
+        return {
+            kind: 'deferred',
+            expression: segment.expression,
+            roots: route.roots,
+            fillTarget: applyMinimumFillTarget(route.fillTarget, minimumFillTarget)
+        };
+    });
+    if (violations.length > 0) return {
+        ok: false,
+        violations
+    };
+    return {
+        ok: true,
+        plan: {
+            field: {
+                segments: resolvedSegments
+            },
+            failurePolicy: getWorkflowInterpolationFieldFailurePolicy(params.field)
+        }
+    };
+}
+function applyMinimumFillTarget(fillTarget, minimumFillTarget) {
+    if (minimumFillTarget === undefined || fillTarget === 'runner-fill') return fillTarget;
+    const fillTargetIndex = availabilitySites.indexOf(fillTarget);
+    const minimumFillTargetIndex = availabilitySites.indexOf(minimumFillTarget);
+    if (fillTargetIndex < 0 || minimumFillTargetIndex < 0) return fillTarget;
+    return availabilitySites[Math.max(fillTargetIndex, minimumFillTargetIndex)] ?? fillTarget;
+}
+
+//# sourceMappingURL=plan-field.js.map

package/dist/plan/plan-field.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/plan-field.ts"],"sourcesContent":["import type {WorkflowTemplateSegment} from '../template/template-segment.js';\nimport {\n  type AvailabilitySite,\n  availabilitySites,\n  type FillTarget,\n  getWorkflowInterpolationFieldFailurePolicy,\n  getWorkflowInterpolationFieldMinimumFillTarget,\n  type WorkflowInterpolationFailurePolicy,\n  type WorkflowInterpolationField,\n} from '../workflow-context/workflow-context.js';\nimport {isBareContextReference} from './bare-reference.js';\nimport {analyzeContextKeyAccess} from './context-key-access.js';\nimport type {ResolvedField} from './resolved-field.js';\nimport {routeExpression} from './route-expression.js';\n\nconst templateExpressionOpen = '$' + '{{';\nconst runnerRootNotBareHint = `split runner-host references into their own adjacent ${templateExpressionOpen} }} segments`;\n\nexport type PlanViolation = {\n  readonly reason: 'runner-root-not-bare' | 'computed-context-key';\n  readonly source: string;\n  readonly runnerRoots?: readonly string[];\n  readonly contextRoots?: readonly string[];\n  readonly hint: string;\n};\n\nexport interface FieldPlan {\n  readonly field: ResolvedField;\n  readonly failurePolicy: WorkflowInterpolationFailurePolicy;\n}\n\nexport type FieldPlanResult =\n  | {readonly ok: true; readonly plan: FieldPlan}\n  | {readonly ok: false; readonly violations: readonly PlanViolation[]};\n\nexport function planInterpolationField(params: {\n  readonly field: WorkflowInterpolationField;\n  readonly segments: readonly WorkflowTemplateSegment[];\n}): FieldPlanResult {\n  const violations: PlanViolation[] = [];\n  const minimumFillTarget = getWorkflowInterpolationFieldMinimumFillTarget(params.field);\n  const resolvedSegments: ResolvedField['segments'] = params.segments.map((segment) => {\n    if (segment.kind === 'literal') return {kind: 'literal', value: segment.text};\n\n    const route = routeExpression(segment.expression);\n    const keyAccess = analyzeContextKeyAccess(segment.expression);\n    if (keyAccess.violations.length > 0) {\n      violations.push(\n        ...keyAccess.violations.map((violation) => ({\n          reason: 'computed-context-key' as const,\n          source: violation.source,\n          contextRoots: [violation.root],\n          hint: `${violation.root} references must use a literal dot key`,\n        })),\n      );\n    } else if (route.runnerRoots.length > 0 && !isBareContextReference(segment.expression.source)) {\n      violations.push({\n        reason: 'runner-root-not-bare',\n        source: segment.expression.source,\n        runnerRoots: route.runnerRoots,\n        hint: runnerRootNotBareHint,\n      });\n    }\n\n    return {\n      kind: 'deferred',\n      expression: segment.expression,\n      roots: route.roots,\n      fillTarget: applyMinimumFillTarget(route.fillTarget, minimumFillTarget),\n    };\n  });\n\n  if (violations.length > 0) return {ok: false, violations};\n\n  return {\n    ok: true,\n    plan: {\n      field: {segments: resolvedSegments},\n      failurePolicy: getWorkflowInterpolationFieldFailurePolicy(params.field),\n    },\n  };\n}\n\nfunction applyMinimumFillTarget(\n  fillTarget: FillTarget,\n  minimumFillTarget: AvailabilitySite | undefined,\n): FillTarget {\n  if (minimumFillTarget === undefined || fillTarget === 'runner-fill') return fillTarget;\n\n  const fillTargetIndex = availabilitySites.indexOf(fillTarget);\n  const minimumFillTargetIndex = availabilitySites.indexOf(minimumFillTarget);\n  if (fillTargetIndex < 0 || minimumFillTargetIndex < 0) return fillTarget;\n\n  return availabilitySites[Math.max(fillTargetIndex, minimumFillTargetIndex)] ?? fillTarget;\n}\n"],"names":["availabilitySites","getWorkflowInterpolationFieldFailurePolicy","getWorkflowInterpolationFieldMinimumFillTarget","isBareContextReference","analyzeContextKeyAccess","routeExpression","templateExpressionOpen","runnerRootNotBareHint","planInterpolationField","params","violations","minimumFillTarget","field","resolvedSegments","segments","map","segment","kind","value","text","route","expression","keyAccess","length","push","violation","reason","source","contextRoots","root","hint","runnerRoots","roots","fillTarget","applyMinimumFillTarget","ok","plan","failurePolicy","undefined","fillTargetIndex","indexOf","minimumFillTargetIndex","Math","max"],"mappings":"AACA,SAEEA,iBAAiB,EAEjBC,0CAA0C,EAC1CC,8CAA8C,QAGzC,0CAA0C;AACjD,SAAQC,sBAAsB,QAAO,sBAAsB;AAC3D,SAAQC,uBAAuB,QAAO,0BAA0B;AAEhE,SAAQC,eAAe,QAAO,wBAAwB;AAEtD,MAAMC,yBAAyB,MAAM;AACrC,MAAMC,wBAAwB,CAAC,qDAAqD,EAAED,uBAAuB,YAAY,CAAC;AAmB1H,OAAO,SAASE,uBAAuBC,MAGtC;IACC,MAAMC,aAA8B,EAAE;IACtC,MAAMC,oBAAoBT,+CAA+CO,OAAOG,KAAK;IACrF,MAAMC,mBAA8CJ,OAAOK,QAAQ,CAACC,GAAG,CAAC,CAACC;QACvE,IAAIA,QAAQC,IAAI,KAAK,WAAW,OAAO;YAACA,MAAM;YAAWC,OAAOF,QAAQG,IAAI;QAAA;QAE5E,MAAMC,QAAQf,gBAAgBW,QAAQK,UAAU;QAChD,MAAMC,YAAYlB,wBAAwBY,QAAQK,UAAU;QAC5D,IAAIC,UAAUZ,UAAU,CAACa,MAAM,GAAG,GAAG;YACnCb,WAAWc,IAAI,IACVF,UAAUZ,UAAU,CAACK,GAAG,CAAC,CAACU,YAAe,CAAA;oBAC1CC,QAAQ;oBACRC,QAAQF,UAAUE,MAAM;oBACxBC,cAAc;wBAACH,UAAUI,IAAI;qBAAC;oBAC9BC,MAAM,GAAGL,UAAUI,IAAI,CAAC,sCAAsC,CAAC;gBACjE,CAAA;QAEJ,OAAO,IAAIT,MAAMW,WAAW,CAACR,MAAM,GAAG,KAAK,CAACpB,uBAAuBa,QAAQK,UAAU,CAACM,MAAM,GAAG;YAC7FjB,WAAWc,IAAI,CAAC;gBACdE,QAAQ;gBACRC,QAAQX,QAAQK,UAAU,CAACM,MAAM;gBACjCI,aAAaX,MAAMW,WAAW;gBAC9BD,MAAMvB;YACR;QACF;QAEA,OAAO;YACLU,MAAM;YACNI,YAAYL,QAAQK,UAAU;YAC9BW,OAAOZ,MAAMY,KAAK;YAClBC,YAAYC,uBAAuBd,MAAMa,UAAU,EAAEtB;QACvD;IACF;IAEA,IAAID,WAAWa,MAAM,GAAG,GAAG,OAAO;QAACY,IAAI;QAAOzB;IAAU;IAExD,OAAO;QACLyB,IAAI;QACJC,MAAM;YACJxB,OAAO;gBAACE,UAAUD;YAAgB;YAClCwB,eAAepC,2CAA2CQ,OAAOG,KAAK;QACxE;IACF;AACF;AAEA,SAASsB,uBACPD,UAAsB,EACtBtB,iBAA+C;IAE/C,IAAIA,sBAAsB2B,aAAaL,eAAe,eAAe,OAAOA;IAE5E,MAAMM,kBAAkBvC,kBAAkBwC,OAAO,CAACP;IAClD,MAAMQ,yBAAyBzC,kBAAkBwC,OAAO,CAAC7B;IACzD,IAAI4B,kBAAkB,KAAKE,yBAAyB,GAAG,OAAOR;IAE9D,OAAOjC,iBAAiB,CAAC0C,KAAKC,GAAG,CAACJ,iBAAiBE,wBAAwB,IAAIR;AACjF"}

package/dist/plan/predicate-shape.d.ts

@@ -0,0 +1,2 @@
+export declare function predicateSourceIsBooleanShaped(source: string): boolean;
+//# sourceMappingURL=predicate-shape.d.ts.map

package/dist/plan/predicate-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-shape.d.ts","sourceRoot":"","sources":["../../src/plan/predicate-shape.ts"],"names":[],"mappings":"AAcA,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAMtE"}

package/dist/plan/predicate-shape.js

@@ -0,0 +1,45 @@
+import { parse as parseCel } from '@marcbachmann/cel-js';
+const comparisonOperators = new Set([
+    '!=',
+    '==',
+    'in',
+    '<',
+    '<=',
+    '>',
+    '>='
+]);
+const booleanReturningCalls = new Set([
+    'all',
+    'contains',
+    'endsWith',
+    'exists',
+    'exists_one',
+    'has',
+    'matches',
+    'startsWith'
+]);
+export function predicateSourceIsBooleanShaped(source) {
+    try {
+        return nodeIsBooleanShaped(parseCel(source).ast);
+    } catch  {
+        return false;
+    }
+}
+function nodeIsBooleanShaped(node) {
+    if (comparisonOperators.has(node.op)) return true;
+    if (node.op === '&&' || node.op === '||' || node.op === '!_') return true;
+    switch(node.op){
+        case 'value':
+            return typeof node.args === 'boolean';
+        case 'call':
+            return booleanReturningCalls.has(node.args[0]);
+        case 'rcall':
+            return booleanReturningCalls.has(node.args[0]);
+        case '?:':
+            return nodeIsBooleanShaped(node.args[1]) && nodeIsBooleanShaped(node.args[2]);
+        default:
+            return false;
+    }
+}
+
+//# sourceMappingURL=predicate-shape.js.map

package/dist/plan/predicate-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/predicate-shape.ts"],"sourcesContent":["import {type ASTNode, parse as parseCel} from '@marcbachmann/cel-js';\n\nconst comparisonOperators = new Set<string>(['!=', '==', 'in', '<', '<=', '>', '>=']);\nconst booleanReturningCalls = new Set([\n  'all',\n  'contains',\n  'endsWith',\n  'exists',\n  'exists_one',\n  'has',\n  'matches',\n  'startsWith',\n]);\n\nexport function predicateSourceIsBooleanShaped(source: string): boolean {\n  try {\n    return nodeIsBooleanShaped(parseCel(source).ast);\n  } catch {\n    return false;\n  }\n}\n\nfunction nodeIsBooleanShaped(node: ASTNode): boolean {\n  if (comparisonOperators.has(node.op)) return true;\n  if (node.op === '&&' || node.op === '||' || node.op === '!_') return true;\n\n  switch (node.op) {\n    case 'value':\n      return typeof node.args === 'boolean';\n    case 'call':\n      return booleanReturningCalls.has(node.args[0]);\n    case 'rcall':\n      return booleanReturningCalls.has(node.args[0]);\n    case '?:':\n      return nodeIsBooleanShaped(node.args[1]) && nodeIsBooleanShaped(node.args[2]);\n    default:\n      return false;\n  }\n}\n"],"names":["parse","parseCel","comparisonOperators","Set","booleanReturningCalls","predicateSourceIsBooleanShaped","source","nodeIsBooleanShaped","ast","node","has","op","args"],"mappings":"AAAA,SAAsBA,SAASC,QAAQ,QAAO,uBAAuB;AAErE,MAAMC,sBAAsB,IAAIC,IAAY;IAAC;IAAM;IAAM;IAAM;IAAK;IAAM;IAAK;CAAK;AACpF,MAAMC,wBAAwB,IAAID,IAAI;IACpC;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAED,OAAO,SAASE,+BAA+BC,MAAc;IAC3D,IAAI;QACF,OAAOC,oBAAoBN,SAASK,QAAQE,GAAG;IACjD,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAEA,SAASD,oBAAoBE,IAAa;IACxC,IAAIP,oBAAoBQ,GAAG,CAACD,KAAKE,EAAE,GAAG,OAAO;IAC7C,IAAIF,KAAKE,EAAE,KAAK,QAAQF,KAAKE,EAAE,KAAK,QAAQF,KAAKE,EAAE,KAAK,MAAM,OAAO;IAErE,OAAQF,KAAKE,EAAE;QACb,KAAK;YACH,OAAO,OAAOF,KAAKG,IAAI,KAAK;QAC9B,KAAK;YACH,OAAOR,sBAAsBM,GAAG,CAACD,KAAKG,IAAI,CAAC,EAAE;QAC/C,KAAK;YACH,OAAOR,sBAAsBM,GAAG,CAACD,KAAKG,IAAI,CAAC,EAAE;QAC/C,KAAK;YACH,OAAOL,oBAAoBE,KAAKG,IAAI,CAAC,EAAE,KAAKL,oBAAoBE,KAAKG,IAAI,CAAC,EAAE;QAC9E;YACE,OAAO;IACX;AACF"}

package/dist/plan/resolved-field.d.ts

@@ -0,0 +1,17 @@
+import type { WorkflowExpression } from '../expression/workflow-expression.js';
+import type { FillTarget } from '../workflow-context/workflow-context.js';
+export interface ResolvedFieldLiteralSegment {
+    readonly kind: 'literal';
+    readonly value: string;
+}
+export interface ResolvedFieldDeferredSegment {
+    readonly kind: 'deferred';
+    readonly expression: WorkflowExpression;
+    readonly roots: readonly string[];
+    readonly fillTarget: FillTarget;
+}
+export type ResolvedFieldSegment = ResolvedFieldLiteralSegment | ResolvedFieldDeferredSegment;
+export interface ResolvedField {
+    readonly segments: readonly ResolvedFieldSegment[];
+}
+//# sourceMappingURL=resolved-field.d.ts.map

package/dist/plan/resolved-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolved-field.d.ts","sourceRoot":"","sources":["../../src/plan/resolved-field.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,yCAAyC,CAAC;AAExE,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED,MAAM,MAAM,oBAAoB,GAAG,2BAA2B,GAAG,4BAA4B,CAAC;AAE9F,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACpD"}

package/dist/plan/resolved-field.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=resolved-field.js.map

package/dist/plan/resolved-field.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/resolved-field.ts"],"sourcesContent":["import type {WorkflowExpression} from '../expression/workflow-expression.js';\nimport type {FillTarget} from '../workflow-context/workflow-context.js';\n\nexport interface ResolvedFieldLiteralSegment {\n  readonly kind: 'literal';\n  readonly value: string;\n}\n\nexport interface ResolvedFieldDeferredSegment {\n  readonly kind: 'deferred';\n  readonly expression: WorkflowExpression;\n  readonly roots: readonly string[];\n  readonly fillTarget: FillTarget;\n}\n\nexport type ResolvedFieldSegment = ResolvedFieldLiteralSegment | ResolvedFieldDeferredSegment;\n\nexport interface ResolvedField {\n  readonly segments: readonly ResolvedFieldSegment[];\n}\n"],"names":[],"mappings":"AAiBA,WAEC"}

package/dist/plan/route-expression.d.ts

@@ -0,0 +1,9 @@
+import type { WorkflowExpression } from '../expression/workflow-expression.js';
+import { type FillTarget } from '../workflow-context/workflow-context.js';
+export interface RoutedExpression {
+    readonly roots: readonly string[];
+    readonly runnerRoots: readonly string[];
+    readonly fillTarget: FillTarget;
+}
+export declare function routeExpression(expression: WorkflowExpression): RoutedExpression;
+//# sourceMappingURL=route-expression.d.ts.map

package/dist/plan/route-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-expression.d.ts","sourceRoot":"","sources":["../../src/plan/route-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAEL,KAAK,UAAU,EAIhB,MAAM,yCAAyC,CAAC;AAIjD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,kBAAkB,GAAG,gBAAgB,CAchF"}

package/dist/plan/route-expression.js

@@ -0,0 +1,46 @@
+import { availabilitySites, resolveContextRootAvailability, resolveContextRootHost, runnerFillTarget } from '../workflow-context/workflow-context.js';
+import { analyzeContextRootKeyAccess } from './context-key-access.js';
+import { extractExactContextRoots } from './extract-exact-context-roots.js';
+export function routeExpression(expression) {
+    const roots = extractExactContextRoots(expression.source);
+    const knownRoots = roots.filter((root)=>resolveContextRootHost(root) !== undefined);
+    const runnerRoots = knownRoots.filter((root)=>resolveContextRootHost(root) === 'runner');
+    if (runnerRoots.length > 0) {
+        return {
+            roots,
+            runnerRoots,
+            fillTarget: runnerFillTarget
+        };
+    }
+    return {
+        roots,
+        runnerRoots,
+        fillTarget: expressionMinimumFillTarget(expression, maxAvailabilitySite(knownRoots))
+    };
+}
+function expressionMinimumFillTarget(expression, fillTarget) {
+    if (fillTarget === runnerFillTarget) return fillTarget;
+    if (!referencesExecutionFailed(expression)) return fillTarget;
+    return laterFillTarget(fillTarget, 'step-dispatch');
+}
+function referencesExecutionFailed(expression) {
+    const access = analyzeContextRootKeyAccess(expression, [
+        'execution'
+    ]);
+    return access.references.some((reference)=>reference.key === 'failed');
+}
+function laterFillTarget(left, right) {
+    if (left === runnerFillTarget || right === runnerFillTarget) return runnerFillTarget;
+    return availabilitySites.indexOf(left) >= availabilitySites.indexOf(right) ? left : right;
+}
+function maxAvailabilitySite(roots) {
+    let maxIndex = 0;
+    for (const root of roots){
+        const availability = resolveContextRootAvailability(root);
+        if (availability === undefined) continue;
+        maxIndex = Math.max(maxIndex, availabilitySites.indexOf(availability));
+    }
+    return availabilitySites[maxIndex] ?? availabilitySites[0];
+}
+
+//# sourceMappingURL=route-expression.js.map

package/dist/plan/route-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/route-expression.ts"],"sourcesContent":["import type {WorkflowExpression} from '../expression/workflow-expression.js';\nimport {\n  availabilitySites,\n  type FillTarget,\n  resolveContextRootAvailability,\n  resolveContextRootHost,\n  runnerFillTarget,\n} from '../workflow-context/workflow-context.js';\nimport {analyzeContextRootKeyAccess} from './context-key-access.js';\nimport {extractExactContextRoots} from './extract-exact-context-roots.js';\n\nexport interface RoutedExpression {\n  readonly roots: readonly string[];\n  readonly runnerRoots: readonly string[];\n  readonly fillTarget: FillTarget;\n}\n\nexport function routeExpression(expression: WorkflowExpression): RoutedExpression {\n  const roots = extractExactContextRoots(expression.source);\n  const knownRoots = roots.filter((root) => resolveContextRootHost(root) !== undefined);\n  const runnerRoots = knownRoots.filter((root) => resolveContextRootHost(root) === 'runner');\n\n  if (runnerRoots.length > 0) {\n    return {roots, runnerRoots, fillTarget: runnerFillTarget};\n  }\n\n  return {\n    roots,\n    runnerRoots,\n    fillTarget: expressionMinimumFillTarget(expression, maxAvailabilitySite(knownRoots)),\n  };\n}\n\nfunction expressionMinimumFillTarget(\n  expression: WorkflowExpression,\n  fillTarget: FillTarget,\n): FillTarget {\n  if (fillTarget === runnerFillTarget) return fillTarget;\n  if (!referencesExecutionFailed(expression)) return fillTarget;\n  return laterFillTarget(fillTarget, 'step-dispatch');\n}\n\nfunction referencesExecutionFailed(expression: WorkflowExpression): boolean {\n  const access = analyzeContextRootKeyAccess(expression, ['execution']);\n  return access.references.some((reference) => reference.key === 'failed');\n}\n\nfunction laterFillTarget(left: FillTarget, right: FillTarget): FillTarget {\n  if (left === runnerFillTarget || right === runnerFillTarget) return runnerFillTarget;\n  return availabilitySites.indexOf(left) >= availabilitySites.indexOf(right) ? left : right;\n}\n\nfunction maxAvailabilitySite(roots: readonly string[]): FillTarget {\n  let maxIndex = 0;\n  for (const root of roots) {\n    const availability = resolveContextRootAvailability(root);\n    if (availability === undefined) continue;\n    maxIndex = Math.max(maxIndex, availabilitySites.indexOf(availability));\n  }\n\n  return availabilitySites[maxIndex] ?? availabilitySites[0];\n}\n"],"names":["availabilitySites","resolveContextRootAvailability","resolveContextRootHost","runnerFillTarget","analyzeContextRootKeyAccess","extractExactContextRoots","routeExpression","expression","roots","source","knownRoots","filter","root","undefined","runnerRoots","length","fillTarget","expressionMinimumFillTarget","maxAvailabilitySite","referencesExecutionFailed","laterFillTarget","access","references","some","reference","key","left","right","indexOf","maxIndex","availability","Math","max"],"mappings":"AACA,SACEA,iBAAiB,EAEjBC,8BAA8B,EAC9BC,sBAAsB,EACtBC,gBAAgB,QACX,0CAA0C;AACjD,SAAQC,2BAA2B,QAAO,0BAA0B;AACpE,SAAQC,wBAAwB,QAAO,mCAAmC;AAQ1E,OAAO,SAASC,gBAAgBC,UAA8B;IAC5D,MAAMC,QAAQH,yBAAyBE,WAAWE,MAAM;IACxD,MAAMC,aAAaF,MAAMG,MAAM,CAAC,CAACC,OAASV,uBAAuBU,UAAUC;IAC3E,MAAMC,cAAcJ,WAAWC,MAAM,CAAC,CAACC,OAASV,uBAAuBU,UAAU;IAEjF,IAAIE,YAAYC,MAAM,GAAG,GAAG;QAC1B,OAAO;YAACP;YAAOM;YAAaE,YAAYb;QAAgB;IAC1D;IAEA,OAAO;QACLK;QACAM;QACAE,YAAYC,4BAA4BV,YAAYW,oBAAoBR;IAC1E;AACF;AAEA,SAASO,4BACPV,UAA8B,EAC9BS,UAAsB;IAEtB,IAAIA,eAAeb,kBAAkB,OAAOa;IAC5C,IAAI,CAACG,0BAA0BZ,aAAa,OAAOS;IACnD,OAAOI,gBAAgBJ,YAAY;AACrC;AAEA,SAASG,0BAA0BZ,UAA8B;IAC/D,MAAMc,SAASjB,4BAA4BG,YAAY;QAAC;KAAY;IACpE,OAAOc,OAAOC,UAAU,CAACC,IAAI,CAAC,CAACC,YAAcA,UAAUC,GAAG,KAAK;AACjE;AAEA,SAASL,gBAAgBM,IAAgB,EAAEC,KAAiB;IAC1D,IAAID,SAASvB,oBAAoBwB,UAAUxB,kBAAkB,OAAOA;IACpE,OAAOH,kBAAkB4B,OAAO,CAACF,SAAS1B,kBAAkB4B,OAAO,CAACD,SAASD,OAAOC;AACtF;AAEA,SAAST,oBAAoBV,KAAwB;IACnD,IAAIqB,WAAW;IACf,KAAK,MAAMjB,QAAQJ,MAAO;QACxB,MAAMsB,eAAe7B,+BAA+BW;QACpD,IAAIkB,iBAAiBjB,WAAW;QAChCgB,WAAWE,KAAKC,GAAG,CAACH,UAAU7B,kBAAkB4B,OAAO,CAACE;IAC1D;IAEA,OAAO9B,iBAAiB,CAAC6B,SAAS,IAAI7B,iBAAiB,CAAC,EAAE;AAC5D"}

package/dist/plan/validate-server-evaluable.d.ts

@@ -0,0 +1,14 @@
+import type { WorkflowExpression } from '../expression/workflow-expression.js';
+export type ServerEvaluabilityViolation = {
+    readonly reason: 'runner-root-in-server-expression';
+    readonly source: string;
+    readonly runnerRoots: readonly string[];
+};
+export type ServerEvaluabilityResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly violations: readonly ServerEvaluabilityViolation[];
+};
+export declare function validateServerEvaluable(expression: WorkflowExpression): ServerEvaluabilityResult;
+//# sourceMappingURL=validate-server-evaluable.d.ts.map

package/dist/plan/validate-server-evaluable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-server-evaluable.d.ts","sourceRoot":"","sources":["../../src/plan/validate-server-evaluable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,sCAAsC,CAAC;AAI7E,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,MAAM,EAAE,kCAAkC,CAAC;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAChC;IAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;CAAC,GACnB;IAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,SAAS,2BAA2B,EAAE,CAAA;CAAC,CAAC;AAEtF,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,kBAAkB,GAAG,wBAAwB,CAiBhG"}

package/dist/plan/validate-server-evaluable.js

@@ -0,0 +1,20 @@
+import { resolveContextRootHost } from '../workflow-context/workflow-context.js';
+import { extractExactContextRoots } from './extract-exact-context-roots.js';
+export function validateServerEvaluable(expression) {
+    const runnerRoots = extractExactContextRoots(expression.source).filter((root)=>resolveContextRootHost(root) === 'runner');
+    if (runnerRoots.length === 0) return {
+        ok: true
+    };
+    return {
+        ok: false,
+        violations: [
+            {
+                reason: 'runner-root-in-server-expression',
+                source: expression.source,
+                runnerRoots
+            }
+        ]
+    };
+}
+
+//# sourceMappingURL=validate-server-evaluable.js.map

package/dist/plan/validate-server-evaluable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plan/validate-server-evaluable.ts"],"sourcesContent":["import type {WorkflowExpression} from '../expression/workflow-expression.js';\nimport {resolveContextRootHost} from '../workflow-context/workflow-context.js';\nimport {extractExactContextRoots} from './extract-exact-context-roots.js';\n\nexport type ServerEvaluabilityViolation = {\n  readonly reason: 'runner-root-in-server-expression';\n  readonly source: string;\n  readonly runnerRoots: readonly string[];\n};\n\nexport type ServerEvaluabilityResult =\n  | {readonly ok: true}\n  | {readonly ok: false; readonly violations: readonly ServerEvaluabilityViolation[]};\n\nexport function validateServerEvaluable(expression: WorkflowExpression): ServerEvaluabilityResult {\n  const runnerRoots = extractExactContextRoots(expression.source).filter(\n    (root) => resolveContextRootHost(root) === 'runner',\n  );\n\n  if (runnerRoots.length === 0) return {ok: true};\n\n  return {\n    ok: false,\n    violations: [\n      {\n        reason: 'runner-root-in-server-expression',\n        source: expression.source,\n        runnerRoots,\n      },\n    ],\n  };\n}\n"],"names":["resolveContextRootHost","extractExactContextRoots","validateServerEvaluable","expression","runnerRoots","source","filter","root","length","ok","violations","reason"],"mappings":"AACA,SAAQA,sBAAsB,QAAO,0CAA0C;AAC/E,SAAQC,wBAAwB,QAAO,mCAAmC;AAY1E,OAAO,SAASC,wBAAwBC,UAA8B;IACpE,MAAMC,cAAcH,yBAAyBE,WAAWE,MAAM,EAAEC,MAAM,CACpE,CAACC,OAASP,uBAAuBO,UAAU;IAG7C,IAAIH,YAAYI,MAAM,KAAK,GAAG,OAAO;QAACC,IAAI;IAAI;IAE9C,OAAO;QACLA,IAAI;QACJC,YAAY;YACV;gBACEC,QAAQ;gBACRN,QAAQF,WAAWE,MAAM;gBACzBD;YACF;SACD;IACH;AACF"}