@shipfox/expression 1.2.1 → 2.1.0

package/dist/workflow-context/workflow-context.d.ts

@@ -1,14 +1,15 @@
+import type { WorkflowExpressionEvaluationContext } from '../evaluator/evaluate-workflow-expression.js';
 import type { ExpressionType, ExpressionTypeEnvironment } from '../expression/workflow-expression.js';
 import { type OutputDeclarations } from '../outputs/output-declarations.js';
-export declare const workflowContextNames: readonly ["run", "trigger", "event", "inputs", "job", "executions", "execution", "jobs", "needs", "steps", "step", "vars", "secrets"];
+export declare const workflowContextNames: readonly ['workflow', 'run', 'trigger', 'event', 'inputs', 'job', 'executions', 'execution', 'jobs', 'needs', 'steps', 'step', 'vars', 'secrets'];
 export type WorkflowContextName = (typeof workflowContextNames)[number];
-export declare const availabilitySites: readonly ["ingest", "run-creation", "execution-creation", "job-activation", "step-dispatch", "step-report", "execution-resolution", "job-resolution"];
+export declare const availabilitySites: readonly ['ingest', 'run-creation', 'execution-creation', 'job-activation', 'step-dispatch', 'step-report', 'execution-resolution', 'job-resolution'];
 export type AvailabilitySite = (typeof availabilitySites)[number];
 export declare const runnerFillTarget = "runner-fill";
 export type FillTarget = AvailabilitySite | typeof runnerFillTarget;
-export declare const workflowContextSensitivities: readonly ["persistable", "ephemeral"];
+export declare const workflowContextSensitivities: readonly ['persistable', 'ephemeral'];
 export type WorkflowContextSensitivity = (typeof workflowContextSensitivities)[number];
-export declare const workflowContextHosts: readonly ["server", "runner"];
+export declare const workflowContextHosts: readonly ['server', 'runner'];
 export type WorkflowContextHost = (typeof workflowContextHosts)[number];
 export type ReservedRootDefinition = {
     readonly host: 'server';
@@ -18,30 +19,25 @@ export type ReservedRootDefinition = {
 };
 export declare const workflowContextReservedRoots: {
     readonly matrix: {
-        readonly host: "server";
-        readonly availability: "job-activation";
+        readonly host: 'server';
+        readonly availability: 'job-activation';
     };
     readonly runner: {
-        readonly host: "runner";
+        readonly host: 'runner';
     };
 };
 export type WorkflowContextReservedRoot = keyof typeof workflowContextReservedRoots;
-export declare const workflowContextTrustTiers: readonly ["trusted", "untrusted"];
-export type WorkflowContextTrustTier = (typeof workflowContextTrustTiers)[number];
 export type WorkflowContextShape = 'known' | 'open';
 export interface TypedWorkflowContextDefinition {
     readonly availability: AvailabilitySite;
-    readonly trustTier: WorkflowContextTrustTier;
     readonly sensitivity: WorkflowContextSensitivity;
     readonly host: 'server';
     readonly shape: 'known';
     readonly checkMode: 'typed';
     readonly typeEnvironment: ExpressionTypeEnvironment;
-    readonly untrustedPaths?: readonly string[];
 }
 export interface OpenWorkflowContextDefinition {
     readonly availability: AvailabilitySite;
-    readonly trustTier: WorkflowContextTrustTier;
     readonly sensitivity: WorkflowContextSensitivity;
     readonly host: 'server';
     readonly shape: 'open';
@@ -49,7 +45,6 @@ export interface OpenWorkflowContextDefinition {
     readonly literalKeyOnly?: boolean;
 }
 export interface RunnerWorkflowContextDefinition {
-    readonly trustTier: WorkflowContextTrustTier;
     readonly sensitivity: 'ephemeral';
     readonly host: 'runner';
     readonly shape: 'open';
@@ -72,364 +67,342 @@ export declare function buildTypedRootsEnvironment(params: {
     readonly needs?: readonly WorkflowJobTypeOverlay[];
 }): ExpressionTypeEnvironment;
 export declare const workflowContextDefinitions: {
+    readonly workflow: {
+        readonly availability: 'run-creation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'known';
+        readonly checkMode: 'typed';
+        readonly typeEnvironment: {
+            readonly workflow: {
+                readonly kind: 'object';
+                readonly fields: {
+                    readonly id: 'string';
+                    readonly name: 'string';
+                };
+            };
+        };
+    };
     readonly run: {
-        readonly availability: "run-creation";
-        readonly trustTier: "trusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "known";
-        readonly checkMode: "typed";
+        readonly availability: 'run-creation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'known';
+        readonly checkMode: 'typed';
         readonly typeEnvironment: {
             readonly run: {
-                readonly kind: "object";
+                readonly kind: 'object';
                 readonly fields: {
-                    readonly id: "string";
-                    readonly name: "string";
-                    readonly definition_id: "string";
-                    readonly project_id: "string";
-                    readonly workspace_id: "string";
-                    readonly created_at: "timestamp";
+                    readonly id: 'string';
+                    readonly number: 'int';
+                    readonly name: 'string';
+                    readonly project_id: 'string';
+                    readonly workspace_id: 'string';
+                    readonly created_at: 'timestamp';
                 };
             };
         };
     };
     readonly trigger: {
-        readonly availability: "ingest";
-        readonly trustTier: "trusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "known";
-        readonly checkMode: "typed";
+        readonly availability: 'ingest';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'known';
+        readonly checkMode: 'typed';
         readonly typeEnvironment: {
             readonly trigger: {
-                readonly kind: "object";
+                readonly kind: 'object';
                 readonly fields: {
-                    readonly source: "string";
-                    readonly event: "string";
+                    readonly project: {
+                        readonly kind: 'object';
+                        readonly fields: {
+                            readonly id: 'string';
+                        };
+                    };
+                    readonly repository: 'string';
+                    readonly ref: 'string';
+                    readonly commit: 'string';
+                    readonly source: 'string';
+                    readonly event: 'string';
                 };
             };
         };
     };
     readonly event: {
-        readonly availability: "ingest";
-        readonly trustTier: "untrusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "open";
-        readonly checkMode: "syntax";
+        readonly availability: 'ingest';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'open';
+        readonly checkMode: 'syntax';
     };
     readonly inputs: {
-        readonly availability: "run-creation";
-        readonly trustTier: "untrusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "open";
-        readonly checkMode: "syntax";
+        readonly availability: 'run-creation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'open';
+        readonly checkMode: 'syntax';
     };
     readonly job: {
-        readonly availability: "run-creation";
-        readonly trustTier: "trusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "known";
-        readonly checkMode: "typed";
+        readonly availability: 'run-creation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'known';
+        readonly checkMode: 'typed';
         readonly typeEnvironment: {
             readonly job: {
-                readonly kind: "object";
+                readonly kind: 'object';
                 readonly fields: {
-                    readonly key: "string";
+                    readonly key: 'string';
+                    readonly name: 'string';
                 };
             };
         };
     };
     readonly executions: {
-        readonly availability: "execution-creation";
-        readonly trustTier: "trusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "known";
-        readonly checkMode: "typed";
+        readonly availability: 'execution-creation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'known';
+        readonly checkMode: 'typed';
         readonly typeEnvironment: {
             readonly executions: {
-                readonly kind: "list";
+                readonly kind: 'list';
                 readonly element: {
-                    readonly kind: "object";
+                    readonly kind: 'object';
                     readonly fields: {
-                        readonly index: "int";
-                        readonly name: "string";
-                        readonly status: "string";
-                        readonly failed: "bool";
-                        readonly started_at: "timestamp";
-                        readonly finished_at: "timestamp";
+                        readonly index: 'int';
+                        readonly name: 'string';
+                        readonly status: 'string';
+                        readonly started_at: 'timestamp';
+                        readonly finished_at: 'timestamp';
                         readonly events: {
-                            readonly kind: "list";
+                            readonly kind: 'list';
                             readonly element: {
-                                readonly kind: "object";
+                                readonly kind: 'object';
                                 readonly fields: {
-                                    readonly source: "string";
-                                    readonly event: "string";
-                                    readonly delivery_id: "string";
-                                    readonly received_at: "timestamp";
+                                    readonly project: {
+                                        readonly kind: 'object';
+                                        readonly fields: {
+                                            readonly id: 'string';
+                                        };
+                                    };
+                                    readonly repository: 'string';
+                                    readonly ref: 'string';
+                                    readonly commit: 'string';
+                                    readonly source: 'string';
+                                    readonly event: 'string';
+                                    readonly delivery_id: 'string';
+                                    readonly received_at: 'timestamp';
                                     readonly data: {
-                                        readonly kind: "object";
+                                        readonly kind: 'object';
                                         readonly fields: {};
                                     };
                                 };
                             };
                         };
                         readonly outputs: {
-                            readonly kind: "map";
+                            readonly kind: 'map';
                         };
                     };
                 };
             };
         };
-        readonly untrustedPaths: readonly ["events"];
     };
     readonly execution: {
-        readonly availability: "execution-creation";
-        readonly trustTier: "trusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "known";
-        readonly checkMode: "typed";
+        readonly availability: 'execution-creation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'known';
+        readonly checkMode: 'typed';
         readonly typeEnvironment: {
             readonly execution: {
-                readonly kind: "object";
+                readonly kind: 'object';
                 readonly fields: {
-                    readonly index: "int";
-                    readonly name: "string";
-                    readonly status: "string";
-                    readonly failed: "bool";
-                    readonly started_at: "timestamp";
-                    readonly finished_at: "timestamp";
+                    readonly index: 'int';
+                    readonly name: 'string';
+                    readonly status: 'string';
+                    readonly started_at: 'timestamp';
+                    readonly finished_at: 'timestamp';
                     readonly events: {
-                        readonly kind: "list";
+                        readonly kind: 'list';
                         readonly element: {
-                            readonly kind: "object";
+                            readonly kind: 'object';
                             readonly fields: {
-                                readonly source: "string";
-                                readonly event: "string";
-                                readonly delivery_id: "string";
-                                readonly received_at: "timestamp";
+                                readonly project: {
+                                    readonly kind: 'object';
+                                    readonly fields: {
+                                        readonly id: 'string';
+                                    };
+                                };
+                                readonly repository: 'string';
+                                readonly ref: 'string';
+                                readonly commit: 'string';
+                                readonly source: 'string';
+                                readonly event: 'string';
+                                readonly delivery_id: 'string';
+                                readonly received_at: 'timestamp';
                                 readonly data: {
-                                    readonly kind: "object";
+                                    readonly kind: 'object';
                                     readonly fields: {};
                                 };
                             };
                         };
                     };
                     readonly outputs: {
-                        readonly kind: "map";
+                        readonly kind: 'map';
                     };
+                    readonly failed: 'bool';
                 };
             };
         };
-        readonly untrustedPaths: readonly ["events"];
     };
     readonly jobs: {
-        readonly availability: "job-activation";
-        readonly trustTier: "untrusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "open";
-        readonly checkMode: "syntax";
+        readonly availability: 'job-activation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'open';
+        readonly checkMode: 'syntax';
     };
     readonly needs: {
-        readonly availability: "job-activation";
-        readonly trustTier: "untrusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "known";
-        readonly checkMode: "typed";
+        readonly availability: 'job-activation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'known';
+        readonly checkMode: 'typed';
         readonly typeEnvironment: {
             readonly needs: {
-                readonly kind: "list";
+                readonly kind: 'list';
                 readonly element: ExpressionType;
             };
         };
     };
     readonly steps: {
-        readonly availability: "step-dispatch";
-        readonly trustTier: "trusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "open";
-        readonly checkMode: "syntax";
+        readonly availability: 'step-dispatch';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'open';
+        readonly checkMode: 'syntax';
     };
     readonly step: {
-        readonly availability: "step-dispatch";
-        readonly trustTier: "trusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "known";
-        readonly checkMode: "typed";
+        readonly availability: 'step-dispatch';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'known';
+        readonly checkMode: 'typed';
         readonly typeEnvironment: {
             readonly step: {
-                readonly kind: "object";
+                readonly kind: 'object';
                 readonly fields: {
-                    readonly attempt: "int";
-                    readonly is_retry: "bool";
+                    readonly attempt: 'int';
+                    readonly is_retry: 'bool';
                     readonly restart: {
-                        readonly kind: "object";
+                        readonly kind: 'object';
                         readonly fields: {
                             readonly from: {
-                                readonly kind: "object";
+                                readonly kind: 'object';
                                 readonly fields: {
+                                    readonly status: 'string';
+                                    readonly exit_code: 'int';
+                                    readonly outputs: {
+                                        readonly kind: 'map';
+                                    };
+                                    readonly response: 'string';
+                                    readonly gate: {
+                                        readonly kind: 'object';
+                                        readonly fields: {
+                                            readonly passed: 'bool';
+                                            readonly source: 'string';
+                                            readonly reason: 'string';
+                                            readonly exit_code: 'int';
+                                        };
+                                    };
                                     readonly attempts: {
-                                        readonly kind: "list";
+                                        readonly kind: 'list';
                                         readonly element: {
-                                            readonly kind: "object";
+                                            readonly kind: 'object';
                                             readonly fields: {
-                                                readonly status: "string";
-                                                readonly exit_code: "int";
+                                                readonly status: 'string';
+                                                readonly exit_code: 'int';
                                                 readonly outputs: {
-                                                    readonly kind: "map";
+                                                    readonly kind: 'map';
                                                 };
-                                                readonly response: "string";
+                                                readonly response: 'string';
                                                 readonly gate: {
-                                                    readonly kind: "object";
+                                                    readonly kind: 'object';
                                                     readonly fields: {
-                                                        readonly passed: "bool";
-                                                        readonly source: "string";
-                                                        readonly reason: "string";
-                                                        readonly exit_code: "int";
+                                                        readonly passed: 'bool';
+                                                        readonly source: 'string';
+                                                        readonly reason: 'string';
+                                                        readonly exit_code: 'int';
                                                     };
                                                 };
                                             };
                                         };
                                     };
-                                    readonly status: "string";
-                                    readonly exit_code: "int";
-                                    readonly outputs: {
-                                        readonly kind: "map";
-                                    };
-                                    readonly response: "string";
-                                    readonly gate: {
-                                        readonly kind: "object";
-                                        readonly fields: {
-                                            readonly passed: "bool";
-                                            readonly source: "string";
-                                            readonly reason: "string";
-                                            readonly exit_code: "int";
-                                        };
-                                    };
                                 };
                             };
-                            readonly feedback: "string";
+                            readonly feedback: 'string';
                         };
                     };
-                    readonly exit_code: "int";
-                    readonly status: "string";
+                    readonly exit_code: 'int';
+                    readonly status: 'string';
                     readonly outputs: {
-                        readonly kind: "map";
+                        readonly kind: 'map';
                     };
                 };
             };
         };
-        readonly untrustedPaths: readonly ["outputs"];
     };
     readonly vars: {
-        readonly availability: "run-creation";
-        readonly trustTier: "trusted";
-        readonly sensitivity: "persistable";
-        readonly host: "server";
-        readonly shape: "open";
-        readonly checkMode: "syntax";
+        readonly availability: 'run-creation';
+        readonly sensitivity: 'persistable';
+        readonly host: 'server';
+        readonly shape: 'open';
+        readonly checkMode: 'syntax';
         readonly literalKeyOnly: true;
     };
     readonly secrets: {
-        readonly trustTier: "trusted";
-        readonly sensitivity: "ephemeral";
-        readonly host: "runner";
-        readonly shape: "open";
-        readonly checkMode: "syntax";
+        readonly sensitivity: 'ephemeral';
+        readonly host: 'runner';
+        readonly shape: 'open';
+        readonly checkMode: 'syntax';
         readonly literalKeyOnly: true;
     };
 };
-export type WorkflowInterpolationField = 'run' | 'env.value' | 'agent.prompt' | 'agent.model' | 'agent.provider' | 'agent.thinking' | 'job.runner' | 'job.outputs' | 'job.name' | 'step.name' | 'step.feedback';
-export declare const workflowFieldFailurePolicies: readonly ["fail", "degrade", "fail-closed"];
+export type WorkflowInterpolationField = 'run' | 'env.value' | 'agent.prompt' | 'agent.model' | 'agent.provider' | 'agent.thinking' | 'job.runner' | 'job.outputs' | 'workflow.run_name' | 'job.execution_name' | 'step.name' | 'step.working_directory' | 'step.feedback' | 'checkout.project' | 'checkout.connection' | 'checkout.repository' | 'checkout.ref' | 'checkout.path';
+export declare const workflowFieldFailurePolicies: readonly ['fail', 'degrade', 'fail-closed'];
 export type WorkflowFieldFailurePolicy = (typeof workflowFieldFailurePolicies)[number];
 export type WorkflowInterpolationFailurePolicy = Exclude<WorkflowFieldFailurePolicy, 'fail-closed'>;
 export interface WorkflowInterpolationFieldPolicy {
-    readonly acceptedTrustTiers: readonly WorkflowContextTrustTier[];
     readonly acceptedHosts: readonly WorkflowContextHost[];
     readonly failurePolicy: WorkflowInterpolationFailurePolicy;
-    readonly renderSanitize: boolean;
     readonly minimumFillTarget?: AvailabilitySite;
-}
-export declare const workflowInterpolationFieldPolicies: {
-    readonly run: {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
-    };
-    readonly 'env.value': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
-    };
-    readonly 'agent.prompt': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
-    };
-    readonly 'agent.model': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
+    readonly selfReference?: {
+        readonly root: WorkflowContextName;
+        readonly key: string;
     };
-    readonly 'agent.provider': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
-    };
-    readonly 'agent.thinking': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
-    };
-    readonly 'job.runner': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
-    };
-    readonly 'job.outputs': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
-        readonly minimumFillTarget: "execution-resolution";
-    };
-    readonly 'job.name': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "degrade";
-        readonly renderSanitize: true;
-    };
-    readonly 'step.name': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "degrade";
-        readonly renderSanitize: true;
-    };
-    readonly 'step.feedback': {
-        readonly acceptedTrustTiers: readonly ("trusted" | "untrusted")[];
-        readonly acceptedHosts: readonly ("server" | "runner")[];
-        readonly failurePolicy: "fail";
-        readonly renderSanitize: false;
-    };
-};
+}
+export declare const workflowInterpolationFieldPolicies: Readonly<Record<WorkflowInterpolationField, WorkflowInterpolationFieldPolicy>>;
 export declare const workflowInterpolationFields: readonly WorkflowInterpolationField[];
-export declare const workflowPredicateFields: readonly ["step.success", "job.success", "trigger.filter", "listener.on", "listener.until", "job.if", "step.if"];
+export declare const workflowPredicateFields: readonly ['step.success', 'job.success', 'trigger.filter', 'listener.on', 'listener.until', 'job.if', 'step.if'];
 export type WorkflowPredicateField = (typeof workflowPredicateFields)[number];
+/**
+ * The roots that the runtime passes to each server-evaluated predicate.
+ *
+ * This is intentionally narrower than lifecycle availability. A root can
+ * exist by the time a predicate runs and still not belong to that predicate's
+ * evaluation context.
+ */
+export declare const workflowPredicateContextRoots: {
+    readonly 'step.success': readonly ["step", "vars"];
+    readonly 'job.success': readonly ["executions", "jobs", "vars"];
+    readonly 'trigger.filter': readonly ["event", "trigger"];
+    readonly 'listener.on': readonly ["event", "workflow", "run", "trigger", "inputs", "vars", "job", "jobs"];
+    readonly 'listener.until': readonly ["event", "workflow", "run", "trigger", "inputs", "vars", "job", "jobs"];
+    readonly 'job.if': readonly ["workflow", "run", "trigger", "event", "inputs", "vars", "jobs", "needs"];
+    readonly 'step.if': readonly ["vars", "jobs", "execution", "step", "steps"];
+};
+export type WorkflowPredicateContextRoot<Field extends WorkflowPredicateField = WorkflowPredicateField> = (typeof workflowPredicateContextRoots)[Field][number];
 export declare const workflowPredicateFieldFailurePolicy: "fail-closed";
 export declare function getWorkflowContextDefinition(name: WorkflowContextName): WorkflowContextDefinition;
 export declare function getWorkflowContextAvailability(name: WorkflowContextName): AvailabilitySite | undefined;
@@ -440,14 +413,26 @@ export declare function getWorkflowContextSensitivity(name: WorkflowContextName)
 export declare function rootsAvailableAt(site: AvailabilitySite): readonly WorkflowContextName[];
 export declare function unavailableRootsAt(roots: readonly WorkflowContextName[], site: AvailabilitySite): readonly WorkflowContextName[];
 export declare function getWorkflowContextTypeEnvironment(name: WorkflowContextName): ExpressionTypeEnvironment | undefined;
-export declare function getWorkflowContextUntrustedPaths(name: WorkflowContextName): readonly string[] | undefined;
-export declare function workflowInterpolationFieldAcceptsTrustTier(field: WorkflowInterpolationField, trustTier: WorkflowContextTrustTier): boolean;
 export declare function workflowInterpolationFieldAcceptsHost(field: WorkflowInterpolationField, host: WorkflowContextHost): boolean;
-export declare function workflowInterpolationFieldAcceptsContext(field: WorkflowInterpolationField, context: WorkflowContextName): boolean;
 export declare function workflowContextRootRequiresLiteralKey(root: string): boolean;
 export declare function getWorkflowInterpolationFieldFailurePolicy(field: WorkflowInterpolationField): WorkflowInterpolationFailurePolicy;
+export declare function getWorkflowInterpolationFieldSelfReference(field: WorkflowInterpolationField): WorkflowInterpolationFieldPolicy['selfReference'];
 export declare function getWorkflowInterpolationFieldMinimumFillTarget(field: WorkflowInterpolationField): AvailabilitySite | undefined;
 export declare function getWorkflowPredicateFieldMinimumFillTarget(field: WorkflowPredicateField): AvailabilitySite;
+export declare function getWorkflowPredicateFieldTypeEnvironment(field: WorkflowPredicateField, root: WorkflowContextName): ExpressionTypeEnvironment | undefined;
+export declare function getWorkflowPredicateContextRoots<Field extends WorkflowPredicateField>(field: Field): readonly WorkflowPredicateContextRoot<Field>[];
+/**
+ * The roots a field can read, whichever kind of field it is.
+ *
+ * A predicate has an enumerated contract because the runtime assembles one
+ * context for it. A template has no single context: each reference is filled
+ * where its data arrives, so its only field-level constraint is which host can
+ * resolve it. Callers that document or check fields should use this instead of
+ * choosing a mechanism themselves.
+ */
+export declare function contextRootsForField(field: WorkflowPredicateField | WorkflowInterpolationField): readonly WorkflowContextName[];
+export declare function isWorkflowPredicateField(field: string): field is WorkflowPredicateField;
+export declare function projectWorkflowPredicateContext(field: WorkflowPredicateField, context: WorkflowExpressionEvaluationContext): WorkflowExpressionEvaluationContext;
 export interface WorkflowContextAvailabilityReferenceEntry {
     readonly root: WorkflowContextName | WorkflowContextReservedRoot;
     readonly availability?: AvailabilitySite;