@xemahq/dsl 0.8.1 → 0.8.2

package/src/workflow/lib/deliverable-spec-source-scan.ts

@@ -1,280 +0,0 @@
-/**
- * Character-level scanner over TypeScript Zod source, used to locate the
- * `z.object({ … })` literals a deliverable spec declares at the TOP level
- * and to read their field names.
- *
- * Deliberately NOT a TypeScript parse or a Zod evaluation: introspection
- * runs inside the DSL compiler, the CI gate, and a request-scoped API
- * handler, none of which may transpile or execute spec-authored code.
- * A scanner is enough because the only question asked is "which
- * identifiers sit at depth 0 of this object literal".
- *
- * What it tracks, and why the naive regex it replaced could not:
- *   - comments, strings, template literals and regex literals, so a
- *     `z.object(`, a brace, or a comma appearing INSIDE one of those is
- *     never read as code;
- *   - brace + paren depth, so a NESTED `z.object(` (a field's own shape)
- *     is never confused with a top-level schema declaration;
- *   - the `const <Name> =` binding preceding each top-level literal, so a
- *     spec can name its contract instead of relying on source order.
- *
- * All three walkers below share ONE trivia primitive (`skipTriviaAt`) so
- * they cannot drift into disagreeing about what counts as code.
- */
-
-/** A `z.object({ … })` literal declared at the top level of the source. */
-export interface TopLevelZodObjectDeclaration {
-  /** Binding name (`export const Foo = z.object({…})` → `Foo`), or null when anonymous. */
-  readonly exportName: string | null;
-  /** Field identifiers at depth 0 of the literal, in source order, de-duplicated. */
-  readonly keys: readonly string[];
-}
-
-/**
- * If a comment / string / template / regex literal STARTS at `index`,
- * return the index just past its end; otherwise return `index` unchanged.
- * An unterminated token consumes the rest of the source, which makes the
- * callers treat it as "no readable shape from here" rather than
- * re-entering code state mid-literal.
- *
- * Regex detection is bounded on purpose: a `/` is treated as a regex only
- * when the previous non-whitespace code character is `(` or `,` — the only
- * positions a regex occupies in a schema-declaration module
- * (`.regex(/…/)`, `.refine(x, /…/)`). Division never appears in that
- * position, so there is no ambiguous case to guess at.
- */
-function skipTriviaAt(source: string, index: number, prevCode: string): number {
-  const ch = source[index];
-  const next = source[index + 1];
-
-  if (ch === '/' && next === '/') return endOfLineComment(source, index + 2);
-  if (ch === '/' && next === '*') return endOfBlockComment(source, index + 2);
-  if (ch === "'" || ch === '"' || ch === '`') {
-    return endOfQuoted(source, index + 1, ch);
-  }
-  if (ch === '/' && (prevCode === '(' || prevCode === ',')) {
-    return endOfQuoted(source, index + 1, '/');
-  }
-  return index;
-}
-
-function endOfLineComment(source: string, from: number): number {
-  const nl = source.indexOf('\n', from);
-  return nl === -1 ? source.length : nl + 1;
-}
-
-function endOfBlockComment(source: string, from: number): number {
-  const end = source.indexOf('*/', from);
-  return end === -1 ? source.length : end + 2;
-}
-
-/** End of a `'…'` / `"…"` / `` `…` `` / `/…/` token, honoring backslash escapes. */
-function endOfQuoted(source: string, from: number, terminator: string): number {
-  for (let i = from; i < source.length; i += 1) {
-    const ch = source[i];
-    if (ch === '\\') {
-      i += 1;
-      continue;
-    }
-    if (ch === terminator) return i + 1;
-  }
-  return source.length;
-}
-
-/** Nesting counters shared by the depth-tracking walkers. */
-interface Depths {
-  brace: number;
-  paren: number;
-  bracket: number;
-}
-
-function newDepths(): Depths {
-  return { brace: 0, paren: 0, bracket: 0 };
-}
-
-function applyDepth(depths: Depths, ch: string | undefined): void {
-  if (ch === '{') depths.brace += 1;
-  else if (ch === '}') depths.brace = Math.max(0, depths.brace - 1);
-  else if (ch === '(') depths.paren += 1;
-  else if (ch === ')') depths.paren = Math.max(0, depths.paren - 1);
-  else if (ch === '[') depths.bracket += 1;
-  else if (ch === ']') depths.bracket = Math.max(0, depths.bracket - 1);
-}
-
-function isAtTopLevel(depths: Depths): boolean {
-  return (
-    depths.brace === 0 && depths.paren === 0 && depths.bracket === 0
-  );
-}
-
-/**
- * Find every `z.object({ … })` literal that sits at depth 0 — i.e. every
- * schema the module declares in its own right, as opposed to a shape
- * nested inside another schema.
- *
- * Literals whose braces never close are skipped: an unbalanced source has
- * no readable shape, and reporting a truncated key list would be worse
- * than reporting none.
- */
-export function scanTopLevelZodObjectDeclarations(
-  source: string,
-): readonly TopLevelZodObjectDeclaration[] {
-  const out: TopLevelZodObjectDeclaration[] = [];
-  const depths = newDepths();
-  let prevCode = '';
-  let i = 0;
-
-  while (i < source.length) {
-    const afterTrivia = skipTriviaAt(source, i, prevCode);
-    if (afterTrivia !== i) {
-      i = afterTrivia;
-      continue;
-    }
-
-    if (isAtTopLevel(depths) && matchesZodObjectAt(source, i)) {
-      const bodyStart = openingBraceIndexAfterZodObject(source, i);
-      const bodyEnd =
-        bodyStart === null ? null : matchingBraceIndex(source, bodyStart);
-      if (bodyStart !== null && bodyEnd !== null) {
-        out.push({
-          exportName: bindingNameBefore(source, i),
-          keys: parseObjectKeysAtTopLevel(source.slice(bodyStart, bodyEnd)),
-        });
-        // Resume AFTER the literal: its interior is already accounted
-        // for, and re-walking it could only produce nested matches we
-        // deliberately exclude.
-        i = bodyEnd + 1;
-        prevCode = '}';
-        continue;
-      }
-    }
-
-    const ch = source[i];
-    applyDepth(depths, ch);
-    if (ch !== undefined && !/\s/.test(ch)) prevCode = ch;
-    i += 1;
-  }
-
-  return out;
-}
-
-/** True when `z.object` starts exactly at `index` and is not part of a longer identifier. */
-function matchesZodObjectAt(source: string, index: number): boolean {
-  if (!source.startsWith('z.object', index)) return false;
-  const prev = index > 0 ? (source[index - 1] ?? '') : '';
-  return !/[A-Za-z0-9_$.]/.test(prev);
-}
-
-/** Index just past the `{` of `z.object ( {`, or null when the call is not an object literal. */
-function openingBraceIndexAfterZodObject(
-  source: string,
-  index: number,
-): number | null {
-  let i = skipWhitespace(source, index + 'z.object'.length);
-  if (source[i] !== '(') return null;
-  i = skipWhitespace(source, i + 1);
-  if (source[i] !== '{') return null;
-  return i + 1;
-}
-
-/**
- * Index of the `}` closing the literal that starts at `bodyStart`, or null
- * when it never closes.
- */
-function matchingBraceIndex(source: string, bodyStart: number): number | null {
-  let depth = 1;
-  let prevCode = '{';
-  let i = bodyStart;
-
-  while (i < source.length) {
-    const afterTrivia = skipTriviaAt(source, i, prevCode);
-    if (afterTrivia !== i) {
-      i = afterTrivia;
-      continue;
-    }
-    const ch = source[i];
-    if (ch === '{') depth += 1;
-    else if (ch === '}') {
-      depth -= 1;
-      if (depth === 0) return i;
-    }
-    if (ch !== undefined && !/\s/.test(ch)) prevCode = ch;
-    i += 1;
-  }
-  return null;
-}
-
-const BINDING_LOOKBEHIND = 400;
-const BINDING_TAIL =
-  /(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*(?::[^=]*)?=\s*$/;
-
-/** Name bound to the literal starting at `index` (`export const Foo = z.object(`), or null. */
-function bindingNameBefore(source: string, index: number): string | null {
-  const from = Math.max(0, index - BINDING_LOOKBEHIND);
-  return BINDING_TAIL.exec(source.slice(from, index))?.[1] ?? null;
-}
-
-function skipWhitespace(source: string, index: number): number {
-  let i = index;
-  while (i < source.length && /\s/.test(source[i]!)) i += 1;
-  return i;
-}
-
-/**
- * Field identifiers at depth 0 of an object-literal body.
- *
- * Splits on depth-0 commas and reads the leading key of each segment, so
- * a key is recorded exactly once. (The predecessor scanned for a key after
- * BOTH the comma and the newline that followed it, emitting every
- * multi-line key twice — harmless for a set-membership test, but the
- * duplicates leaked into compiler error messages and the "known fields"
- * preview shown to authors.)
- */
-function parseObjectKeysAtTopLevel(body: string): readonly string[] {
-  const keys: string[] = [];
-  const seen = new Set<string>();
-  for (const segment of splitTopLevelSegments(body)) {
-    const key = leadingKeyOf(segment);
-    if (key !== null && !seen.has(key)) {
-      seen.add(key);
-      keys.push(key);
-    }
-  }
-  return Object.freeze(keys);
-}
-
-function splitTopLevelSegments(body: string): readonly string[] {
-  const segments: string[] = [];
-  const depths = newDepths();
-  let prevCode = '';
-  let start = 0;
-  let i = 0;
-
-  while (i < body.length) {
-    const afterTrivia = skipTriviaAt(body, i, prevCode);
-    if (afterTrivia !== i) {
-      i = afterTrivia;
-      continue;
-    }
-    const ch = body[i];
-    if (ch === ',' && isAtTopLevel(depths)) {
-      segments.push(body.slice(start, i));
-      start = i + 1;
-    } else {
-      applyDepth(depths, ch);
-    }
-    if (ch !== undefined && !/\s/.test(ch)) prevCode = ch;
-    i += 1;
-  }
-  segments.push(body.slice(start));
-  return segments;
-}
-
-const LEADING_TRIVIA = /^(?:\s|\/\/[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)+/;
-const LEADING_KEY = /^(?:([A-Za-z_$][A-Za-z0-9_$]*)|'([^']+)'|"([^"]+)")\s*:/;
-
-function leadingKeyOf(segment: string): string | null {
-  const match = LEADING_KEY.exec(segment.replace(LEADING_TRIVIA, ''));
-  if (!match) return null;
-  return match[1] ?? match[2] ?? match[3] ?? null;
-}

package/src/workflow/lib/dispatch-inputs/index.ts

@@ -1,160 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════════
-// ── Dispatch-input descriptor extraction ──
-//
-// Shared, tree-shakable module that projects a parsed workflow
-// document's `on.workflow_dispatch.inputs` declaration into a
-// normalized `DispatchInputDescriptor[]` the frontend renders as a
-// dispatch form and the engine consumes for endpoint-returned schema
-// metadata.
-//
-// Single source of truth: the engine and the web frontend both call
-// this function. Keeping the extraction + field-type enumeration in
-// one place removes the "two validation authorities" anti-pattern
-// (per CLAUDE.md fail-fast rule). The pure extraction logic here is
-// NOT validation — the engine's DSL validator (in `lib/validate.ts`)
-// remains the sole validator at compile + dispatch time.
-//
-// No Ajv, no js-yaml — this module is deliberately self-contained so
-// the frontend bundle can import it without pulling heavy
-// transitive deps through tree-shaking.
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Closed set of field types surfaced to the dispatch form. Mirrors
- * `WorkflowInputDeclaration.type` but narrows to the subset the form
- * renderer knows how to render. Unknown type values in the parsed
- * document cause the field to be skipped (fail-fast — no silent
- * downgrade to a string input).
- */
-export enum DispatchInputFieldType {
-  String = 'string',
-  Number = 'number',
-  Integer = 'integer',
-  Boolean = 'boolean',
-  Object = 'object',
-  Array = 'array',
-}
-
-/**
- * Normalized descriptor the dispatch form consumes. Flat + closed
- * shape so renderer code doesn't have to probe optional fields.
- */
-export interface DispatchInputDescriptor {
-  readonly name: string;
-  readonly type: DispatchInputFieldType;
-  readonly required: boolean;
-  readonly description: string | null;
-  /** String values only — non-string enum members are dropped. */
-  readonly enumValues: readonly string[] | null;
-  /** For `type: string`, a hint for multiline rendering. Closed set. */
-  readonly format: DispatchInputStringFormat | null;
-  /** For `type: array`, the item type (only `string[]` is form-rendered; other item types fall to raw JSON). */
-  readonly itemType: DispatchInputFieldType | null;
-  readonly defaultValue: unknown;
-}
-
-export enum DispatchInputStringFormat {
-  Multiline = 'multiline',
-}
-
-/**
- * Extracts descriptors from a parsed workflow document. Returns an
- * empty array when the document declares no dispatch inputs (reusable
- * workflows or schedule/webhook-only workflows). Never throws — a
- * malformed inputs bag (unknown `type`, non-object entries) drops the
- * offending field rather than failing the whole extraction, so the
- * dispatch UI stays renderable even if one input declaration is
- * stale. The engine's compile path remains authoritative for
- * validation.
- */
-export function extractDispatchInputDescriptors(
-  parsedDocument: unknown,
-): readonly DispatchInputDescriptor[] {
-  const inputs = readDispatchInputsBag(parsedDocument);
-  if (!inputs) return [];
-  const descriptors: DispatchInputDescriptor[] = [];
-  for (const [name, raw] of Object.entries(inputs)) {
-    const descriptor = toDescriptor(name, raw);
-    if (descriptor !== null) descriptors.push(descriptor);
-  }
-  return descriptors;
-}
-
-function readDispatchInputsBag(
-  parsedDocument: unknown,
-): Record<string, unknown> | null {
-  if (!parsedDocument || typeof parsedDocument !== 'object') return null;
-  const doc = parsedDocument as Record<string, unknown>;
-  const on = doc['on'];
-  if (!on || typeof on !== 'object') return null;
-  const wfDispatch = (on as Record<string, unknown>)['workflow_dispatch'];
-  if (!wfDispatch || typeof wfDispatch !== 'object') return null;
-  const inputs = (wfDispatch as Record<string, unknown>)['inputs'];
-  if (!inputs || typeof inputs !== 'object' || Array.isArray(inputs)) {
-    return null;
-  }
-  return inputs as Record<string, unknown>;
-}
-
-function toDescriptor(
-  name: string,
-  raw: unknown,
-): DispatchInputDescriptor | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const field = raw as Record<string, unknown>;
-  const type = parseFieldType(field['type']);
-  if (type === null) return null;
-  const required = field['required'] === true;
-  const description =
-    typeof field['description'] === 'string' ? field['description'] : null;
-  const enumValues = parseEnumValues(field['enum']);
-  const format = parseStringFormat(field['format']);
-  const itemType = parseItemType(field['items']);
-  return {
-    name,
-    type,
-    required,
-    description,
-    enumValues,
-    format,
-    itemType,
-    defaultValue: field['default'] ?? undefined,
-  };
-}
-
-function parseFieldType(value: unknown): DispatchInputFieldType | null {
-  if (typeof value !== 'string') return null;
-  switch (value) {
-    case 'string':
-      return DispatchInputFieldType.String;
-    case 'number':
-      return DispatchInputFieldType.Number;
-    case 'integer':
-      return DispatchInputFieldType.Integer;
-    case 'boolean':
-      return DispatchInputFieldType.Boolean;
-    case 'object':
-      return DispatchInputFieldType.Object;
-    case 'array':
-      return DispatchInputFieldType.Array;
-    default:
-      return null;
-  }
-}
-
-function parseEnumValues(value: unknown): readonly string[] | null {
-  if (!Array.isArray(value) || value.length === 0) return null;
-  const strings = value.filter((v): v is string => typeof v === 'string');
-  return strings.length === value.length ? strings : null;
-}
-
-function parseStringFormat(value: unknown): DispatchInputStringFormat | null {
-  if (value === 'multiline') return DispatchInputStringFormat.Multiline;
-  return null;
-}
-
-function parseItemType(value: unknown): DispatchInputFieldType | null {
-  if (!value || typeof value !== 'object') return null;
-  const items = value as Record<string, unknown>;
-  return parseFieldType(items['type']);
-}

package/src/workflow/lib/dispatch-inputs/to-json-schema.ts

@@ -1,60 +0,0 @@
-import {
-  DispatchInputFieldType,
-  DispatchInputStringFormat,
-  type DispatchInputDescriptor,
-} from './index';
-
-/**
- * Project a flat `DispatchInputDescriptor[]` into a JSON Schema
- * Draft 2020-12 object the MCP gateway uses as `inputSchema` on
- * workflow-tool projections (and the frontend dispatch dialog uses
- * for form rendering parity).
- *
- * Single source of truth for the descriptor → JSON Schema mapping so
- * the gateway, the engine, and the frontend agree on the shape an
- * agent sees vs the shape a human sees in the dispatch dialog.
- *
- * Closed-set conservatively: unknown enum values are dropped (the
- * extractor already filters), unknown type combinations fall back to
- * `{ type: 'object' }` to keep the schema valid rather than throwing.
- */
-export function dispatchInputsToJsonSchema(
-  descriptors: readonly DispatchInputDescriptor[],
-): Readonly<Record<string, unknown>> {
-  const properties: Record<string, Record<string, unknown>> = {};
-  const required: string[] = [];
-  for (const d of descriptors) {
-    properties[d.name] = descriptorToProperty(d);
-    if (d.required) required.push(d.name);
-  }
-  const schema: Record<string, unknown> = {
-    $schema: 'https://json-schema.org/draft/2020-12/schema',
-    type: 'object',
-    properties,
-    additionalProperties: false,
-  };
-  if (required.length > 0) {
-    schema['required'] = required;
-  }
-  return Object.freeze(schema);
-}
-
-function descriptorToProperty(d: DispatchInputDescriptor): Record<string, unknown> {
-  const prop: Record<string, unknown> = { type: d.type };
-  if (d.description) {
-    prop['description'] = d.description;
-  }
-  if (d.enumValues && d.enumValues.length > 0) {
-    prop['enum'] = [...d.enumValues];
-  }
-  if (d.format === DispatchInputStringFormat.Multiline) {
-    prop['x-widget'] = 'multiline';
-  }
-  if (d.type === DispatchInputFieldType.Array && d.itemType) {
-    prop['items'] = { type: d.itemType };
-  }
-  if (d.defaultValue !== undefined) {
-    prop['default'] = d.defaultValue;
-  }
-  return prop;
-}

package/src/workflow/lib/duration.ts

@@ -1,43 +0,0 @@
-import { WorkflowErrorCode } from '@xemahq/kernel-contracts/workflow';
-import { WorkflowDslError } from './errors';
-
-/**
- * Duration literal parser. Accepts `<int><unit>` where unit is `s`, `m`, or
- * `h`. Deterministic; rejects malformed input with a typed error. There is
- * no silent zero fallback — callers must pass a value that matches the
- * schema pattern (already enforced by Ajv upstream).
- *
- * Cap: total duration limited to 8760h (= 365 days), regardless of the
- * unit used. The cap is a sanity guard
- * against typos (`100000h` ≈ 11 years), not a policy bound — real
- * human-driven flows (compliance reviews, multi-stakeholder approvals,
- * SCM PRs that go a quarter without merging) routinely take months.
- *
- * For redraft loops (`xema/review@v3`), the workflow `continueAsNew`s
- * every 25 iterations, which resets the runtime clock — the practical
- * ceiling on a single review is unbounded. This cap applies only to a
- * single iteration window of the child workflow.
- */
-const MAX_HOURS = 8760;
-
-export function parseDurationMs(literal: string): number {
-  const match = /^([1-9][0-9]*)(s|m|h)$/.exec(literal);
-  if (!match) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_SCHEMA_INVALID,
-      `Duration literal does not match pattern <int><s|m|h>: ${literal}`,
-      { literal },
-    );
-  }
-  const value = Number.parseInt(match[1]!, 10);
-  const unit = match[2] as 's' | 'm' | 'h';
-  const ms = unit === 's' ? value * 1_000 : unit === 'm' ? value * 60_000 : value * 3_600_000;
-  if (ms > MAX_HOURS * 3_600_000) {
-    throw new WorkflowDslError(
-      WorkflowErrorCode.DSL_SCHEMA_INVALID,
-      `Duration exceeds cap of ${MAX_HOURS}h: ${literal}`,
-      { literal, maxHours: MAX_HOURS },
-    );
-  }
-  return ms;
-}

package/src/workflow/lib/errors.ts

@@ -1,37 +0,0 @@
-import { WorkflowErrorCode } from '@xemahq/kernel-contracts/workflow';
-
-/**
- * Structured error produced by every DSL entry point (validate, parseYaml,
- * evaluateExpression, compile). Callers MUST branch on `.code` — free-form
- * message matching is forbidden so error handling stays exhaustive.
- */
-export class WorkflowDslError extends Error {
-  readonly code: WorkflowErrorCode;
-  readonly details: Readonly<Record<string, unknown>>;
-
-  constructor(
-    code: WorkflowErrorCode,
-    message: string,
-    details: Readonly<Record<string, unknown>> = {},
-  ) {
-    super(message);
-    this.name = 'WorkflowDslError';
-    this.code = code;
-    this.details = details;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-
-  toJSON(): Readonly<Record<string, unknown>> {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      details: this.details,
-    };
-  }
-}
-
-/** Narrowing helper. */
-export function isWorkflowDslError(err: unknown): err is WorkflowDslError {
-  return err instanceof WorkflowDslError;
-}

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

@@ -1,108 +0,0 @@
-/**
- * AST node kinds for parsed expressions. Closed set.
- */
-export enum ExpressionNodeKind {
-  LITERAL = 'literal',
-  IDENTIFIER = 'identifier',
-  MEMBER = 'member',
-  INDEX = 'index',
-  CALL = 'call',
-  UNARY_NOT = 'unary-not',
-  BINARY_EQ = 'binary-eq',
-  BINARY_NEQ = 'binary-neq',
-  BINARY_AND = 'binary-and',
-  BINARY_OR = 'binary-or',
-}
-
-/** Closed set of root identifier bindings allowed in expressions. */
-export enum ExpressionRoot {
-  NEEDS = 'needs',
-  MATRIX = 'matrix',
-  INPUTS = 'inputs',
-  VARS = 'vars',
-  /**
-   * Project / org secret variables resolved at dispatch from the
-   * project-registry-api variable store, declared by the workflow under
-   * `requires.variables[*].secret: true`. Values are strings; expressions
-   * reading this namespace are subject to log redaction by the runtime.
-   */
-  SECRETS = 'secrets',
-  TRIGGER = 'trigger',
-  JOB = 'job',
-  /**
-   * System-managed canonical context for the run. Mirrors GitHub
-   * Actions' `github.*` namespace: stable, system-populated, available
-   * in every expression. Exposes org/project/run/workflow/job/actor
-   * fields so authors don't have to reach into trigger metadata for
-   * what is really run-level state.
-   */
-  XEMA = 'xema',
-}
-
-/** Closed set of built-in function names. Any other identifier-call fails. */
-export enum ExpressionFunction {
-  FROM_JSON = 'fromJSON',
-  TO_JSON = 'toJSON',
-  /**
-   * `format(template, ...args)` — GitHub-Actions-style positional
-   * interpolation. The template is a literal string with `{0}`, `{1}`,
-   * ... placeholders; each is replaced with the stringified arg at that
-   * index. Authors use this when they need to combine an expression
-   * value with surrounding literal text — partial `${{ ... }}`
-   * interpolation in YAML is intentionally rejected, so `format` is the
-   * supported way to build composed strings.
-   */
-  FORMAT = 'format',
-}
-
-export type ExpressionNode =
-  | LiteralNode
-  | IdentifierNode
-  | MemberNode
-  | IndexNode
-  | CallNode
-  | UnaryNotNode
-  | BinaryNode;
-
-export interface LiteralNode {
-  readonly kind: ExpressionNodeKind.LITERAL;
-  readonly value: string | number | boolean | null;
-}
-
-export interface IdentifierNode {
-  readonly kind: ExpressionNodeKind.IDENTIFIER;
-  readonly name: string;
-}
-
-export interface MemberNode {
-  readonly kind: ExpressionNodeKind.MEMBER;
-  readonly target: ExpressionNode;
-  readonly property: string;
-}
-
-export interface IndexNode {
-  readonly kind: ExpressionNodeKind.INDEX;
-  readonly target: ExpressionNode;
-  readonly index: ExpressionNode;
-}
-
-export interface CallNode {
-  readonly kind: ExpressionNodeKind.CALL;
-  readonly callee: ExpressionFunction;
-  readonly args: readonly ExpressionNode[];
-}
-
-export interface UnaryNotNode {
-  readonly kind: ExpressionNodeKind.UNARY_NOT;
-  readonly operand: ExpressionNode;
-}
-
-export interface BinaryNode {
-  readonly kind:
-    | ExpressionNodeKind.BINARY_EQ
-    | ExpressionNodeKind.BINARY_NEQ
-    | ExpressionNodeKind.BINARY_AND
-    | ExpressionNodeKind.BINARY_OR;
-  readonly left: ExpressionNode;
-  readonly right: ExpressionNode;
-}