@xemahq/dsl 0.8.0 → 0.8.2

package/src/workflow/lib/expression/context.ts

@@ -1,148 +0,0 @@
-import type { TriggerPayload } from '@xemahq/kernel-contracts/workflow';
-
-/**
- * Per-run, read-only cache of pre-fetched artifact payloads keyed by
- * `versionId`. Populated by the workflow runtime BEFORE each step's
- * expressions are evaluated, which owns the fetch + cache plumbing.
- * The evaluator only ever reads from this map;
- * concurrent reads are safe by construction (no writes once frozen for a
- * step). Empty when no expression in scope reaches into a typed
- * payload or invokes `fromJSON(ref)`.
- *
- * Values are the parsed payload (any JSON-shaped value). The runtime is
- * responsible for parse-time validation; the evaluator surfaces a
- * missing-key as `DSL_PAYLOAD_PARSE_ERROR` so authors get a clear
- * "this ref was never resolved" signal rather than a generic null
- * dereference.
- */
-export type PayloadCache = ReadonlyMap<string, unknown>;
-
-/**
- * Runtime binding context passed to the evaluator. Every entry is a plain
- * JSON value — no closures, no functions — so evaluation is pure and
- * deterministic for any given input.
- */
-export interface ExpressionContext {
-  readonly needs: Readonly<Record<string, NeedsEntry>>;
-  readonly matrix: Readonly<Record<string, unknown>>;
-  readonly inputs: Readonly<Record<string, unknown>>;
-  readonly vars: Readonly<Record<string, unknown>>;
-  /**
-   * Project / org secret variables, populated at dispatch from
-   * `requires.variables[*].secret: true` entries. Always present; empty
-   * when the workflow declares no secret requirements.
-   */
-  readonly secrets: Readonly<Record<string, string>>;
-  /**
-   * The trigger that started this run. Readers access via `trigger.kind`,
-   * `trigger.inputs`, etc. as defined by {@link TriggerPayload}.
-   */
-  readonly trigger: TriggerPayload;
-  /**
-   * Outputs of the current job (if an expression is evaluated at job-level,
-   * e.g. inside `job.outputs`). Empty when evaluating matrix/needs/if.
-   */
-  readonly job: { readonly outputs: Readonly<Record<string, unknown>> };
-  /**
-   * System-managed canonical context for the run — see {@link XemaContext}.
-   * Always present. Authors reach for `${{ xema.project.id }}` instead of
-   * `${{ trigger.projectId }}` because project id is run-level state, not
-   * trigger metadata.
-   */
-  readonly xema: XemaContext;
-  /**
-   * Pre-fetched artifact payloads for the current step, keyed by
-   * `ArtifactRef.versionId`. Used by `fromJSON(ref)` to return the
-   * already-parsed payload without a runtime fetch. Empty map when the
-   * step has no payload-reaching expressions. Always present so the
-   * evaluator can distinguish "ref not resolved" (missing key →
-   * `DSL_PAYLOAD_PARSE_ERROR`) from "no cache at all".
-   */
-  readonly payloadCache: PayloadCache;
-}
-
-export interface NeedsEntry {
-  readonly outputs: Readonly<Record<string, unknown>>;
-}
-
-/**
- * Canonical system-managed context. Modelled after GitHub Actions'
- * `github.*` so authors reach for an obvious, stable namespace rather
- * than digging into `trigger.*` metadata for run-level state.
- *
- * Every nested record is a plain JSON object — evaluator-safe.
- */
-export interface XemaContext {
-  readonly org: { readonly id: string };
-  readonly project: { readonly id: string };
-  readonly run: {
-    readonly id: string;
-    readonly attempt: number;
-    /** ISO-8601 wall-clock at trigger dispatch (mirrors `trigger.triggeredAt`). */
-    readonly startedAtIso: string;
-    readonly correlationId: string;
-    readonly actor: XemaActor;
-  };
-  readonly workflow: {
-    readonly key: string;
-    readonly revisionNumber: number;
-  };
-  readonly job: {
-    readonly key: string;
-    readonly attempt: number;
-  };
-}
-
-export interface XemaActor {
-  /** Subject id of the user who initiated the run; null for scheduled / webhook triggers. */
-  readonly subject: string | null;
-  readonly kind: XemaActorKind;
-}
-
-/**
- * Closed set of run-actor kinds. `user` is set whenever a subject id is
- * present; `webhook` / `schedule` come from the trigger discriminator
- * for unattended runs; `system` is the fallback for engine-initiated
- * dispatches with no actor (e.g. internal recovery).
- */
-export enum XemaActorKind {
-  User = 'user',
-  System = 'system',
-  Webhook = 'webhook',
-  Schedule = 'schedule',
-}
-
-/** Empty-but-typed seeds for contexts where an axis doesn't apply yet. */
-export const EMPTY_CONTEXT_SEEDS = {
-  needs: Object.freeze({}) as Readonly<Record<string, NeedsEntry>>,
-  matrix: Object.freeze({}) as Readonly<Record<string, unknown>>,
-  vars: Object.freeze({}) as Readonly<Record<string, unknown>>,
-  secrets: Object.freeze({}) as Readonly<Record<string, string>>,
-  job: Object.freeze({ outputs: Object.freeze({}) }) as {
-    readonly outputs: Readonly<Record<string, unknown>>;
-  },
-  /**
-   * Empty payload cache for compile-time / static contexts where no
-   * artifact resolution has been performed. The runtime replaces this
-   * with the per-step populated map.
-   */
-  payloadCache: new Map<string, unknown>() as PayloadCache,
-  /**
-   * Seed `xema` for compile-time evaluation contexts (concurrency,
-   * static workflow checks) where the canonical fields aren't available
-   * yet. Runtime callers always replace this with the populated shape.
-   */
-  xema: Object.freeze({
-    org: Object.freeze({ id: '' }),
-    project: Object.freeze({ id: '' }),
-    run: Object.freeze({
-      id: '',
-      attempt: 0,
-      startedAtIso: '',
-      correlationId: '',
-      actor: Object.freeze({ subject: null, kind: XemaActorKind.System }),
-    }),
-    workflow: Object.freeze({ key: '', revisionNumber: 0 }),
-    job: Object.freeze({ key: '', attempt: 0 }),
-  }) as XemaContext,
-} as const;

package/src/workflow/lib/expression/evaluator.ts

@@ -1,492 +0,0 @@
-import {
-  isArtifactRef,
-  isArtifactRefEnvelopeField,
-  WorkflowErrorCode,
-  type ArtifactRef,
-} from '@xemahq/kernel-contracts/workflow';
-import { WorkflowDslError } from '../errors';
-import {
-  type BinaryNode,
-  type CallNode,
-  type ExpressionNode,
-  ExpressionFunction,
-  ExpressionNodeKind,
-  ExpressionRoot,
-  type IdentifierNode,
-  type IndexNode,
-  type LiteralNode,
-  type MemberNode,
-} from './ast';
-import type { ExpressionContext } from './context';
-import { parseExpression } from './parser';
-import { tokenize } from './tokenizer';
-
-/**
- * Compile a source expression into an {@link ExpressionNode} tree. Used by
- * the workflow compiler to pre-validate every expression at compile time
- * (so runtime evaluation can only fail on unknown bindings, not on
- * syntax). Reject unknown identifiers, roots, and function calls.
- */
-export function compileExpression(source: string): ExpressionNode {
-  if (source.length === 0) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      'Expression source must not be empty',
-      { source },
-    );
-  }
-  const tokens = tokenize(source);
-  return parseExpression(source, tokens);
-}
-
-/**
- * Evaluate a pre-compiled {@link ExpressionNode} against a bound context.
- * Deterministic: same (node, context) always produces the same value, no
- * implicit time/random/env access, no silent coercion.
- *
- * Throws {@link WorkflowDslError} with code DSL_EXPRESSION_INVALID on any
- * unknown property lookup or type mismatch — the caller must surface the
- * error; silent substitution is forbidden.
- */
-export function evaluateExpression(node: ExpressionNode, ctx: ExpressionContext): unknown {
-  switch (node.kind) {
-    case ExpressionNodeKind.LITERAL:
-      return evalLiteral(node);
-    case ExpressionNodeKind.IDENTIFIER:
-      return evalIdentifier(node, ctx);
-    case ExpressionNodeKind.MEMBER:
-      return evalMember(node, ctx);
-    case ExpressionNodeKind.INDEX:
-      return evalIndex(node, ctx);
-    case ExpressionNodeKind.CALL:
-      return evalCall(node, ctx);
-    case ExpressionNodeKind.UNARY_NOT: {
-      const operand = evaluateExpression(node.operand, ctx);
-      return !toBool(operand);
-    }
-    case ExpressionNodeKind.BINARY_EQ:
-    case ExpressionNodeKind.BINARY_NEQ:
-    case ExpressionNodeKind.BINARY_AND:
-    case ExpressionNodeKind.BINARY_OR:
-      return evalBinary(node, ctx);
-  }
-}
-
-function evalLiteral(node: LiteralNode): unknown {
-  return node.value;
-}
-
-function evalIdentifier(node: IdentifierNode, ctx: ExpressionContext): unknown {
-  switch (node.name as ExpressionRoot) {
-    case ExpressionRoot.NEEDS:
-      return ctx.needs;
-    case ExpressionRoot.MATRIX:
-      return ctx.matrix;
-    case ExpressionRoot.INPUTS:
-      return ctx.inputs;
-    case ExpressionRoot.VARS:
-      return ctx.vars;
-    case ExpressionRoot.SECRETS:
-      return ctx.secrets;
-    case ExpressionRoot.TRIGGER:
-      return ctx.trigger;
-    case ExpressionRoot.JOB:
-      return ctx.job;
-    case ExpressionRoot.XEMA:
-      return ctx.xema;
-    default:
-      throw new WorkflowDslError(
-        WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-        `Unknown identifier root '${node.name}'`,
-        { name: node.name },
-      );
-  }
-}
-
-function evalMember(node: MemberNode, ctx: ExpressionContext): unknown {
-  const target = evaluateExpression(node.target, ctx);
-  return readPropertyWithPayloadCache(target, node.property, ctx);
-}
-
-function evalIndex(node: IndexNode, ctx: ExpressionContext): unknown {
-  const target = evaluateExpression(node.target, ctx);
-  const key = evaluateExpression(node.index, ctx);
-
-  if (Array.isArray(target)) {
-    if (typeof key !== 'number' || !Number.isInteger(key)) {
-      throw new WorkflowDslError(
-        WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-        `Array index must be an integer, received ${typeof key}`,
-        { key, targetKind: 'array' },
-      );
-    }
-    if (key < 0 || key >= target.length) {
-      throw new WorkflowDslError(
-        WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-        `Array index out of range: ${key} (length ${target.length})`,
-        { key, length: target.length },
-      );
-    }
-    return target[key];
-  }
-
-  if (typeof target === 'object' && target !== null) {
-    if (typeof key !== 'string') {
-      throw new WorkflowDslError(
-        WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-        `Object index must be a string, received ${typeof key}`,
-        { key, targetKind: 'object' },
-      );
-    }
-    return readPropertyWithPayloadCache(target, key, ctx);
-  }
-
-  throw new WorkflowDslError(
-    WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-    `Indexing is only supported on arrays or objects. Target kind: ${typeof target}`,
-    { targetKind: typeof target },
-  );
-}
-
-function evalCall(node: CallNode, ctx: ExpressionContext): unknown {
-  switch (node.callee) {
-    case ExpressionFunction.FROM_JSON:
-      return evalFromJson(node, ctx);
-    case ExpressionFunction.TO_JSON:
-      return evalToJson(node, ctx);
-    case ExpressionFunction.FORMAT:
-      return evalFormat(node, ctx);
-  }
-}
-
-/**
- * `fromJSON` accepts two argument shapes:
- *
- *   1. `string` — JSON-parse the string (matches GitHub Actions semantics).
- *      Parse failure → `DSL_EXPRESSION_INVALID` (the source is authored
- *      literal text; we treat it as a syntax-level error).
- *   2. `ArtifactRef` — look up the pre-fetched parsed payload in the
- *      `payloadCache` (keyed on `versionId`). Missing entry →
- *      `DSL_PAYLOAD_PARSE_ERROR`: the runtime is responsible for
- *      pre-resolving every ref referenced by an expression before the
- *      evaluator runs. A cache miss is a runtime infra bug, not an
- *      author bug, so it carries a runtime-coded error.
- *
- * This is the untyped escape hatch. Authors who want compile-time field
- * validation use the typed reach-in (`outputs.foo.field`).
- */
-function evalFromJson(node: CallNode, ctx: ExpressionContext): unknown {
-  const argNode = singleArg(node, 'fromJSON');
-  const arg = evaluateExpression(argNode, ctx);
-  if (typeof arg === 'string') {
-    try {
-      return JSON.parse(arg);
-    } catch (err) {
-      throw new WorkflowDslError(
-        WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-        `fromJSON failed to parse argument as JSON: ${(err as Error).message}`,
-        { callee: node.callee },
-      );
-    }
-  }
-  if (isArtifactRef(arg)) {
-    const cached = ctx.payloadCache.get(arg.versionId);
-    if (cached === undefined) {
-      throw new WorkflowDslError(
-        WorkflowErrorCode.DSL_PAYLOAD_PARSE_ERROR,
-        `fromJSON(<ArtifactRef>) called against versionId='${arg.versionId}' but the runtime did not pre-resolve its payload into the per-step cache. This is a runtime infra failure — the worker is expected to fetch and parse every referenced artifact before evaluating expressions.`,
-        {
-          callee: node.callee,
-          artifactId: arg.artifactId,
-          versionId: arg.versionId,
-          type: arg.type,
-        },
-      );
-    }
-    return cached;
-  }
-  throw new WorkflowDslError(
-    WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-    `fromJSON requires a string or ArtifactRef argument, received ${typeof arg}`,
-    { callee: node.callee, argKind: typeof arg },
-  );
-}
-
-function evalToJson(node: CallNode, ctx: ExpressionContext): string {
-  const argNode = singleArg(node, 'toJSON');
-  return JSON.stringify(evaluateExpression(argNode, ctx));
-}
-
-function evalFormat(node: CallNode, ctx: ExpressionContext): string {
-  if (node.args.length < 1) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `format expects at least one argument (the template string)`,
-      { callee: node.callee, arity: node.args.length },
-    );
-  }
-  const [templateNode, ...argNodes] = node.args;
-  if (!templateNode) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `format template is missing from AST`,
-      { callee: node.callee },
-    );
-  }
-  const template = evaluateExpression(templateNode, ctx);
-  if (typeof template !== 'string') {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `format template must be a string, received ${typeof template}`,
-      { callee: node.callee, templateKind: typeof template },
-    );
-  }
-  const args = argNodes.map((argNode) => evaluateExpression(argNode, ctx));
-  return formatTemplate(template, args);
-}
-
-function singleArg(node: CallNode, fnName: string): ExpressionNode {
-  if (node.args.length !== 1) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `${fnName} expects exactly one argument, received ${node.args.length}`,
-      { callee: node.callee, arity: node.args.length },
-    );
-  }
-  const [argNode] = node.args;
-  if (!argNode) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `${fnName} argument is missing from AST`,
-      { callee: node.callee },
-    );
-  }
-  return argNode;
-}
-
-/**
- * Replace `{N}` placeholders in `template` with the stringified arg at
- * index N. Escape `{{` / `}}` for literal braces. Out-of-range indices
- * fail fast — silent emptiness would be a footgun for authors.
- */
-function formatTemplate(template: string, args: readonly unknown[]): string {
-  let out = '';
-  let i = 0;
-  while (i < template.length) {
-    const ch = template[i];
-    if (ch === '{') {
-      const advance = consumeOpenBrace(template, i, args);
-      out += advance.text;
-      i = advance.next;
-      continue;
-    }
-    if (ch === '}') {
-      const advance = consumeCloseBrace(template, i);
-      out += advance.text;
-      i = advance.next;
-      continue;
-    }
-    out += ch;
-    i++;
-  }
-  return out;
-}
-
-interface FormatAdvance {
-  readonly text: string;
-  readonly next: number;
-}
-
-function consumeOpenBrace(
-  template: string,
-  i: number,
-  args: readonly unknown[],
-): FormatAdvance {
-  if (template[i + 1] === '{') {
-    return { text: '{', next: i + 2 };
-  }
-  const close = template.indexOf('}', i + 1);
-  if (close === -1) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `format template has unclosed '{' starting at index ${i}: ${template}`,
-      { template },
-    );
-  }
-  const indexLiteral = template.slice(i + 1, close);
-  const idx = parseFormatIndex(template, indexLiteral, args.length);
-  return { text: stringifyFormatArg(args[idx]), next: close + 1 };
-}
-
-function consumeCloseBrace(template: string, i: number): FormatAdvance {
-  if (template[i + 1] === '}') {
-    return { text: '}', next: i + 2 };
-  }
-  throw new WorkflowDslError(
-    WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-    `format template has unmatched '}' at index ${i}: ${template}`,
-    { template },
-  );
-}
-
-function parseFormatIndex(template: string, indexLiteral: string, argCount: number): number {
-  if (!/^\d+$/.test(indexLiteral)) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `format placeholder '{${indexLiteral}}' is not a non-negative integer`,
-      { template, placeholder: indexLiteral },
-    );
-  }
-  const idx = Number(indexLiteral);
-  if (idx >= argCount) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `format placeholder '{${idx}}' has no matching argument (received ${argCount} arg(s))`,
-      { template, placeholder: idx, argCount },
-    );
-  }
-  return idx;
-}
-
-function stringifyFormatArg(value: unknown): string {
-  if (typeof value === 'string') return value;
-  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
-  if (value === null) return 'null';
-  if (value === undefined) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `format argument resolved to undefined; expressions must produce a defined value`,
-      {},
-    );
-  }
-  // Objects + arrays serialize as JSON so authors can build deterministic
-  // strings without risk of `[object Object]` slipping through.
-  return JSON.stringify(value);
-}
-
-function evalBinary(node: BinaryNode, ctx: ExpressionContext): unknown {
-  switch (node.kind) {
-    case ExpressionNodeKind.BINARY_EQ: {
-      const left = evaluateExpression(node.left, ctx);
-      const right = evaluateExpression(node.right, ctx);
-      return strictEquals(left, right);
-    }
-    case ExpressionNodeKind.BINARY_NEQ: {
-      const left = evaluateExpression(node.left, ctx);
-      const right = evaluateExpression(node.right, ctx);
-      return !strictEquals(left, right);
-    }
-    case ExpressionNodeKind.BINARY_AND: {
-      const left = evaluateExpression(node.left, ctx);
-      if (!toBool(left)) return false;
-      return toBool(evaluateExpression(node.right, ctx));
-    }
-    case ExpressionNodeKind.BINARY_OR: {
-      const left = evaluateExpression(node.left, ctx);
-      if (toBool(left)) return true;
-      return toBool(evaluateExpression(node.right, ctx));
-    }
-  }
-}
-
-/**
- * Property-read wrapper that transparently redirects payload reach-in
- * (`outputs.foo.<payload-field>`) through the per-step `payloadCache`.
- *
- * When `target` is an `ArtifactRef`:
- *   • envelope-field property (artifactId/versionId/version/hash/type/title)
- *     → read directly off the ref (no fetch).
- *   • any other property → look up the artifact's parsed payload in
- *     `ctx.payloadCache` (populated by the worker's reach-in pre-fetch)
- *     and read the field off that. Cache miss surfaces as
- *     `DSL_PAYLOAD_PARSE_ERROR` so the author sees a clean DSL error
- *     instead of a misleading "Unknown property" on the ref.
- *
- * Anything else delegates to the plain `readProperty` path.
- */
-function readPropertyWithPayloadCache(
-  target: unknown,
-  property: string,
-  ctx: ExpressionContext,
-): unknown {
-  if (isArtifactRef(target) && !isArtifactRefEnvelopeField(property)) {
-    return readPayloadField(target, property, ctx);
-  }
-  return readProperty(target, property);
-}
-
-function readPayloadField(
-  ref: ArtifactRef,
-  property: string,
-  ctx: ExpressionContext,
-): unknown {
-  if (!ctx.payloadCache.has(ref.versionId)) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_PAYLOAD_PARSE_ERROR,
-      `Payload reach-in '${property}' on artifact '${ref.artifactId}' v${ref.version} ` +
-        `(versionId '${ref.versionId}') is not available — the per-step payloadCache ` +
-        `has no entry for this version. The runtime pre-fetch should have populated ` +
-        `the cache before this expression evaluated; this typically means the ref ` +
-        `surfaced from an indirection the pre-fetch walker can't trace (e.g. a ` +
-        `dynamically computed ref). Use 'fromJSON(<ref>)' as the documented ` +
-        `escape hatch when the runtime cannot statically pre-fetch.`,
-      { artifactId: ref.artifactId, versionId: ref.versionId, version: ref.version, property },
-    );
-  }
-  const payload = ctx.payloadCache.get(ref.versionId);
-  if (payload === null || payload === undefined) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_PAYLOAD_PARSE_ERROR,
-      `Payload reach-in '${property}' on artifact '${ref.artifactId}' v${ref.version} ` +
-        `failed: cached payload is ${payload === null ? 'null' : 'undefined'}.`,
-      { artifactId: ref.artifactId, versionId: ref.versionId, property },
-    );
-  }
-  return readProperty(payload, property);
-}
-
-function readProperty(target: unknown, property: string): unknown {
-  if (target === null || target === undefined) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `Cannot read property '${property}' of ${target === null ? 'null' : 'undefined'}`,
-      { property },
-    );
-  }
-  if (typeof target !== 'object' || Array.isArray(target)) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `Member access '${property}' is not supported on ${Array.isArray(target) ? 'arrays' : typeof target}`,
-      { property, targetKind: Array.isArray(target) ? 'array' : typeof target },
-    );
-  }
-  const record = target as Record<string, unknown>;
-  if (!Object.prototype.hasOwnProperty.call(record, property)) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-      `Unknown property '${property}'. Available keys: ${Object.keys(record).sort().join(', ') || '(none)'}.`,
-      { property, availableKeys: Object.keys(record) },
-    );
-  }
-  return record[property];
-}
-
-function toBool(value: unknown): boolean {
-  // Deterministic boolean coercion — closed set of accepted types. Anything
-  // else is a typed error. No JS truthiness footguns in expressions.
-  if (typeof value === 'boolean') return value;
-  if (value === null) return false;
-  throw new WorkflowDslError(
-    WorkflowErrorCode.DSL_EXPRESSION_INVALID,
-    `Expected boolean, received ${typeof value}. Xema expressions do not implicitly coerce truthiness.`,
-    { valueKind: value === null ? 'null' : typeof value },
-  );
-}
-
-function strictEquals(a: unknown, b: unknown): boolean {
-  // Primitive equality only. Arrays/objects fall through to reference
-  // equality — expression authors should compare primitives.
-  if (typeof a !== typeof b) return false;
-  if (a === b) return true;
-  return false;
-}

package/src/workflow/lib/expression/index.ts

@@ -1,28 +0,0 @@
-export {
-  type ExpressionContext,
-  type NeedsEntry,
-  type PayloadCache,
-  type XemaActor,
-  type XemaContext,
-  XemaActorKind,
-  EMPTY_CONTEXT_SEEDS,
-} from './context';
-export { compileExpression, evaluateExpression } from './evaluator';
-export { ExpressionFunction, ExpressionNodeKind, ExpressionRoot } from './ast';
-export type { ExpressionNode } from './ast';
-export { extractInterpolations, isInterpolationWrapped, stripInterpolation } from './interpolation';
-export {
-  extractUpstreamJobKey,
-  extractUpstreamOutputName,
-  walkRuntimeArtifactRefTargets,
-} from './walk-artifact-refs';
-export {
-  parseTemplate,
-  templateHasExpressions,
-  TemplateSegmentKind,
-} from './template';
-export type {
-  TemplateExpressionSegment,
-  TemplateLiteralSegment,
-  TemplateSegment,
-} from './template';