@kalada/syntax 0.1.0

package/dist/index.js

@@ -0,0 +1,2017 @@
+import { KaladaV1, compileKaladaV1Program } from '@kalada/core';
+
+// src/freeze.ts
+function freezeRange(start, end) {
+  return Object.freeze({ start, end });
+}
+function deepFreeze(value) {
+  if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor && "value" in descriptor) deepFreeze(descriptor.value);
+  }
+  return Object.freeze(value);
+}
+
+// src/diagnostics.ts
+var KALADA_SYNTAX_DIAGNOSTIC_MESSAGES = Object.freeze({
+  KALADA_SYNTAX_INVALID_INPUT: "Kalada syntax input is invalid.",
+  KALADA_SYNTAX_LIMIT_EXCEEDED: "Kalada syntax input exceeds a configured limit.",
+  KALADA_SYNTAX_UNEXPECTED_TOKEN: "Kalada syntax contains an unexpected token.",
+  KALADA_SYNTAX_EXPECTED_EXPRESSION: "Kalada syntax expected an expression.",
+  KALADA_SYNTAX_EXPECTED_FIELD: "Kalada syntax expected a field name.",
+  KALADA_SYNTAX_EXPECTED_RIGHT_PARENTHESIS: "Kalada syntax expected a closing parenthesis.",
+  KALADA_SYNTAX_EXPECTED_COLON: "Kalada syntax expected a colon.",
+  KALADA_SYNTAX_INVALID_NUMBER: "Kalada syntax contains an invalid JSON number.",
+  KALADA_SYNTAX_INVALID_STRING: "Kalada syntax contains an invalid JSON string.",
+  KALADA_SYNTAX_UNSUPPORTED_FORM: "Kalada syntax form is not supported.",
+  KALADA_SYNTAX_UNSUPPORTED_OPERATOR: "Kalada syntax operator is not supported.",
+  KALADA_SYNTAX_RELATIONAL_CHAIN: "Kalada relational and membership operators cannot be chained.",
+  KALADA_SYNTAX_COALESCE_LOGICAL_MIX: "Kalada null coalescing cannot be mixed with && or || without parentheses.",
+  KALADA_SYNTAX_UNKNOWN_REFERENCE: "Kalada reference is not present in the lowering environment.",
+  KALADA_SYNTAX_WRITE_INELIGIBLE: "Expression is not a static direct write location.",
+  KALADA_SYNTAX_WRITE_BINDING_INVALID: "Write location binding is missing or invalid.",
+  KALADA_SYNTAX_WRITE_PROPERTY_INVALID: "Write location property is missing or invalid."
+});
+var DiagnosticSink = class {
+  diagnostics;
+  limits;
+  limitIndex;
+  constructor(limits, initial = []) {
+    this.limits = limits;
+    this.diagnostics = [...initial];
+    const limitIndex = initial.findIndex((item) => item.code === "KALADA_SYNTAX_LIMIT_EXCEEDED");
+    this.limitIndex = limitIndex < 0 ? null : limitIndex;
+  }
+  add(phase, code, range, path = []) {
+    if (this.diagnostics.length >= this.limits.maxDiagnostics) {
+      if (this.limitIndex === null) this.limit(phase, range);
+      return;
+    }
+    this.diagnostics.push(
+      diagnostic(phase, code, KALADA_SYNTAX_DIAGNOSTIC_MESSAGES[code], range, path)
+    );
+  }
+  limit(phase, range) {
+    const current = this.limitIndex === null ? void 0 : this.diagnostics[this.limitIndex];
+    if (current && current.range.start <= range.start) return;
+    const problem = diagnostic(
+      phase,
+      "KALADA_SYNTAX_LIMIT_EXCEEDED",
+      KALADA_SYNTAX_DIAGNOSTIC_MESSAGES.KALADA_SYNTAX_LIMIT_EXCEEDED,
+      range,
+      []
+    );
+    if (this.limitIndex !== null) {
+      this.diagnostics.splice(this.limitIndex, 1, problem);
+      return;
+    }
+    if (this.diagnostics.length >= this.limits.maxDiagnostics) {
+      this.diagnostics.splice(-1, 1, problem);
+      this.limitIndex = this.diagnostics.length - 1;
+      return;
+    }
+    this.diagnostics.push(problem);
+    this.limitIndex = this.diagnostics.length - 1;
+  }
+  hasLexicalLimitAt(start) {
+    return this.diagnostics.some(
+      (item) => item.phase === "lex" && item.code === "KALADA_SYNTAX_LIMIT_EXCEEDED" && item.range.start === start
+    );
+  }
+};
+function diagnostic(phase, code, message, range, path) {
+  return deepFreeze({
+    phase,
+    code,
+    message,
+    range: freezeRange(range.start, range.end),
+    path: [...path]
+  });
+}
+
+// src/limits.ts
+var DEFAULT_KALADA_SYNTAX_LIMITS = Object.freeze({
+  maxSourceLength: 1e5,
+  maxTokens: 2e4,
+  maxCstDepth: 64,
+  maxCstNodes: 1e4,
+  maxDiagnostics: 100,
+  maxRecoveryTokens: 1e3,
+  maxIdentifierLength: 1e3,
+  maxDecodedStringLength: 1e4,
+  maxStaticTypeDepth: 64
+});
+var MAXIMUM_KALADA_SYNTAX_LIMITS = Object.freeze({
+  maxSourceLength: 1e6,
+  maxTokens: 2e5,
+  maxCstDepth: 256,
+  maxCstNodes: 1e5,
+  maxDiagnostics: 1e3,
+  maxRecoveryTokens: 1e4,
+  maxIdentifierLength: 1e5,
+  maxDecodedStringLength: 1e6,
+  maxStaticTypeDepth: 256
+});
+function resolveSyntaxLimits(options) {
+  if (options === void 0) return DEFAULT_KALADA_SYNTAX_LIMITS;
+  if (!hasOnlyKeys(options, /* @__PURE__ */ new Set(["limits"]))) return null;
+  const limitsProperty = ownDataProperty(options, "limits");
+  if (!limitsProperty.ok) return null;
+  if (!limitsProperty.present) return DEFAULT_KALADA_SYNTAX_LIMITS;
+  const limits = limitsProperty.value;
+  if (!isPlainRecord(limits)) return null;
+  const output = { ...DEFAULT_KALADA_SYNTAX_LIMITS };
+  for (const key of Object.keys(DEFAULT_KALADA_SYNTAX_LIMITS)) {
+    const property2 = ownDataProperty(limits, key);
+    if (!property2.ok) return null;
+    if (!property2.present || property2.value === void 0) continue;
+    const value = property2.value;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > MAXIMUM_KALADA_SYNTAX_LIMITS[key])
+      return null;
+    output[key] = value;
+  }
+  return Object.freeze(output);
+}
+function ownDataProperty(input, key) {
+  if (typeof input !== "object" && typeof input !== "function" || input === null)
+    return { ok: false, present: false };
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (!descriptor) return { ok: true, present: false };
+    return "value" in descriptor ? { ok: true, present: true, value: descriptor.value } : { ok: false, present: true };
+  } catch {
+    return { ok: false, present: false };
+  }
+}
+function isPlainRecord(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return false;
+  try {
+    const keys = Reflect.ownKeys(input);
+    const allowed = new Set(Reflect.ownKeys(DEFAULT_KALADA_SYNTAX_LIMITS));
+    return keys.every((key) => typeof key === "string" && allowed.has(key));
+  } catch {
+    return false;
+  }
+}
+function hasOnlyKeys(input, allowed) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return false;
+  try {
+    return Reflect.ownKeys(input).every((key) => typeof key === "string" && allowed.has(key));
+  } catch {
+    return false;
+  }
+}
+
+// src/lex-literals.ts
+function token(kind, text, start, end) {
+  return Object.freeze({ kind, text, range: freezeRange(start, end) });
+}
+function limitedToken(source, start, end, sink, guest) {
+  const limitEnd = guest ? end : source.length;
+  sink.limit("lex", freezeRange(start, limitEnd));
+  if (guest) guest.limited = true;
+  return token("invalid", source.slice(start, limitEnd), start, limitEnd);
+}
+function scanNumber(source, start, sink) {
+  let end = scanDigits(source, start);
+  if (source[end] === "." && isDigit(source[end + 1])) {
+    end = scanDigits(source, end + 1);
+  }
+  if (source[end] === "e" || source[end] === "E") {
+    end += 1;
+    if (source[end] === "+" || source[end] === "-") end += 1;
+    end = scanDigits(source, end);
+  }
+  let text = source.slice(start, end);
+  let valid = validNumber(text);
+  if (source[end] === "." && !(valid && isIdentifierStart(source[end + 1]))) {
+    end += 1;
+    text = source.slice(start, end);
+    valid = false;
+  }
+  if (!valid) sink.add("lex", "KALADA_SYNTAX_INVALID_NUMBER", freezeRange(start, end));
+  return token(valid ? "number" : "invalid", text, start, end);
+}
+function scanDigits(source, start) {
+  let end = start;
+  while (end < source.length && isDigit(source[end])) end += 1;
+  return end;
+}
+function validNumber(text) {
+  return /^(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u.test(text) && Number.isFinite(Number(text));
+}
+function scanString(source, start, limits, sink, guest) {
+  let end = start + 1;
+  let escaped = false;
+  while (end < source.length) {
+    const character = source[end];
+    end += 1;
+    if (!escaped && character === '"') break;
+    escaped = !escaped && character === "\\";
+    if (character !== "\\") escaped = false;
+  }
+  const text = source.slice(start, end);
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    value = null;
+  }
+  if (typeof value === "string" && value.length > limits.maxDecodedStringLength) {
+    return limitedToken(source, start, end, sink, guest);
+  }
+  const valid = typeof value === "string";
+  if (!valid) sink.add("lex", "KALADA_SYNTAX_INVALID_STRING", freezeRange(start, end));
+  return token(valid ? "string" : "invalid", text, start, end);
+}
+function isIdentifierStart(value) {
+  return value?.length === 1 && /[A-Za-z_]/u.test(value);
+}
+function isDigit(value) {
+  return /[0-9]/u.test(value);
+}
+
+// src/lexer.ts
+var VALID_OPERATORS = [
+  "??",
+  "&&",
+  "||",
+  "==",
+  "!=",
+  "<=",
+  ">=",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "!",
+  "<",
+  ">"
+];
+var UNSUPPORTED_OPERATORS = [
+  "===",
+  "!==",
+  "=>",
+  "**",
+  "++",
+  "--",
+  "<<",
+  ">>",
+  "^",
+  "&",
+  "|",
+  "=",
+  "~"
+];
+function lex(source, limits) {
+  const sink = new DiagnosticSink(limits);
+  if (source.length > limits.maxSourceLength) {
+    sink.limit("lex", freezeRange(0, source.length));
+    return result(
+      [token("invalid", source, 0, source.length), token("eof", "", source.length, source.length)],
+      sink
+    );
+  }
+  const tokens = [];
+  let offset = 0;
+  while (offset < source.length) {
+    if (tokens.length >= limits.maxTokens) {
+      sink.limit("lex", freezeRange(offset, source.length));
+      tokens.push(token("invalid", source.slice(offset), offset, source.length));
+      offset = source.length;
+      break;
+    }
+    const next = scanToken(source, offset, limits, sink);
+    tokens.push(next);
+    offset = next.range.end;
+  }
+  tokens.push(token("eof", "", source.length, source.length));
+  return result(tokens, sink);
+}
+function lexGuest(source, start, limits) {
+  const window = source.slice(start, start + limits.maxSourceLength + 1);
+  const scanned = scanGuest(window, limits);
+  return deepFreeze({
+    stop: scanned.stop === null ? null : start + scanned.stop,
+    unmatchedParentheses: scanned.unmatchedParentheses,
+    unsupportedComment: scanned.unsupportedComment,
+    unsupportedQuote: scanned.unsupportedQuote,
+    tokens: scanned.tokens.map(
+      (item) => token(item.kind, item.text, start + item.range.start, start + item.range.end)
+    ),
+    diagnostics: scanned.diagnostics.map(
+      (item) => diagnostic(
+        item.phase,
+        item.code,
+        item.message,
+        freezeRange(start + item.range.start, start + item.range.end),
+        item.path
+      )
+    )
+  });
+}
+function scanGuest(source, limits) {
+  const sink = new DiagnosticSink(limits);
+  const tokens = [];
+  let offset = 0;
+  let depth = 0;
+  let unmatchedParentheses = false;
+  let unsupportedComment = false;
+  let unsupportedQuote = false;
+  let stop = null;
+  while (offset < source.length) {
+    if (source[offset] === "}") {
+      stop = offset;
+      unmatchedParentheses ||= depth !== 0;
+      break;
+    }
+    if (offset >= limits.maxSourceLength || tokens.length >= limits.maxTokens) {
+      sink.limit("lex", freezeRange(offset, offset));
+      break;
+    }
+    const opener = ambiguousGuestOpener(source, offset);
+    if (opener !== null) {
+      sink.add("lex", "KALADA_SYNTAX_UNSUPPORTED_FORM", freezeRange(offset, offset));
+      stop = offset;
+      unsupportedComment = opener === "comment";
+      unsupportedQuote = opener === "quote";
+      break;
+    }
+    const guest = { limited: false };
+    const next = scanToken(source, offset, limits, sink, guest);
+    tokens.push(next);
+    offset = next.range.end;
+    if (guest.limited) break;
+    depth += parenthesisDelta(next);
+    unmatchedParentheses ||= depth < 0;
+    if (offset > limits.maxSourceLength)
+      sink.limit("lex", freezeRange(limits.maxSourceLength, offset));
+  }
+  if (stop === null && source.length > limits.maxSourceLength) {
+    sink.limit("lex", freezeRange(limits.maxSourceLength, limits.maxSourceLength));
+  }
+  return finishGuest(tokens, sink, offset, {
+    stop,
+    unmatchedParentheses,
+    unsupportedComment,
+    unsupportedQuote
+  });
+}
+function finishGuest(tokens, sink, offset, state) {
+  tokens.push(token("eof", "", offset, offset));
+  return deepFreeze({
+    tokens,
+    diagnostics: sink.diagnostics,
+    ...state
+  });
+}
+function ambiguousGuestOpener(source, offset) {
+  if (source.startsWith("//", offset) || source.startsWith("/*", offset)) return "comment";
+  if (source[offset] === "'" || source[offset] === "`") return "quote";
+  return null;
+}
+function parenthesisDelta(found) {
+  if (found.kind === "left-parenthesis") return 1;
+  if (found.kind === "right-parenthesis") return -1;
+  return 0;
+}
+function scanToken(source, start, limits, sink, guest) {
+  const character = source[start];
+  if (isWhitespace(character)) return scanWhile(source, start, isWhitespace, "whitespace");
+  if (isIdentifierStart2(character)) return scanIdentifier(source, start, limits, sink, guest);
+  if (isDigit(character)) return scanNumber(source, start, sink);
+  if (character === '"') return scanString(source, start, limits, sink, guest);
+  return scanSymbol(source, start, sink);
+}
+function scanSymbol(source, start, sink) {
+  const character = source[start];
+  if (character === "/" && source[start + 1] === "/" || character === "/" && source[start + 1] === "*") {
+    return scanComment(source, start, sink);
+  }
+  if (character === "'" || character === "`") return scanQuotedUnsupported(source, start, sink);
+  if (source.startsWith("?.", start)) return token("optional-dot", "?.", start, start + 2);
+  const unsupported = matchAt(source, start, UNSUPPORTED_OPERATORS);
+  const operator = matchAt(source, start, VALID_OPERATORS);
+  if (unsupported && (!operator || unsupported.length > operator.length)) {
+    return unsupportedToken(source, start, unsupported.length, sink, "operator");
+  }
+  if (operator) return token("operator", operator, start, start + operator.length);
+  if (unsupported) return unsupportedToken(source, start, unsupported.length, sink, "operator");
+  const navigation = scanNavigation(source, start);
+  if (navigation) return navigation;
+  if ("[]{};,".includes(character)) return unsupportedToken(source, start, 1, sink, "form");
+  sink.add("lex", "KALADA_SYNTAX_UNEXPECTED_TOKEN", freezeRange(start, start + 1));
+  return token("invalid", character, start, start + 1);
+}
+function scanIdentifier(source, start, limits, sink, guest) {
+  const found = scanWhile(source, start, isIdentifierContinue, "identifier");
+  if (found.text.length > limits.maxIdentifierLength) {
+    return limitedToken(source, start, found.range.end, sink, guest);
+  }
+  const keyword = ["true", "false", "null", "in", "xor"].find(
+    (item) => item === found.text
+  );
+  return keyword ? token(keyword, found.text, found.range.start, found.range.end) : found;
+}
+function scanComment(source, start, sink) {
+  const line = source.startsWith("//", start);
+  let end = start + 2;
+  if (line) while (end < source.length && source[end] !== "\n" && source[end] !== "\r") end += 1;
+  else {
+    const close = source.indexOf("*/", end);
+    end = close < 0 ? source.length : close + 2;
+  }
+  return unsupportedToken(source, start, end - start, sink, "form");
+}
+function scanQuotedUnsupported(source, start, sink) {
+  const quote = source[start];
+  let end = start + 1;
+  while (end < source.length && source[end] !== quote && source[end] !== "\n" && source[end] !== "\r")
+    end += 1;
+  if (source[end] === quote) end += 1;
+  return unsupportedToken(source, start, end - start, sink, "form");
+}
+function scanNavigation(source, start) {
+  if (source.startsWith("?.", start)) return token("optional-dot", "?.", start, start + 2);
+  const kinds = {
+    "(": "left-parenthesis",
+    ")": "right-parenthesis",
+    ".": "dot",
+    "?": "question",
+    ":": "colon"
+  };
+  const text = source[start];
+  return kinds[text] ? token(kinds[text], text, start, start + 1) : null;
+}
+function unsupportedToken(source, start, length, sink, type) {
+  const end = start + length;
+  sink.add(
+    "lex",
+    type === "form" ? "KALADA_SYNTAX_UNSUPPORTED_FORM" : "KALADA_SYNTAX_UNSUPPORTED_OPERATOR",
+    freezeRange(start, end)
+  );
+  return token("unsupported", source.slice(start, end), start, end);
+}
+function scanWhile(source, start, predicate, kind) {
+  let end = start + 1;
+  while (end < source.length && predicate(source[end])) end += 1;
+  return token(kind, source.slice(start, end), start, end);
+}
+function matchAt(source, start, values) {
+  return [...values].sort((left, right) => right.length - left.length).find((value) => source.startsWith(value, start)) ?? null;
+}
+function result(tokens, sink) {
+  return deepFreeze({ tokens, diagnostics: sink.diagnostics });
+}
+function isWhitespace(value) {
+  return value === " " || value === "	" || value === "\r" || value === "\n";
+}
+function isIdentifierStart2(value) {
+  return value?.length === 1 && /[A-Za-z_]/u.test(value);
+}
+function isIdentifierContinue(value) {
+  return value?.length === 1 && /[A-Za-z0-9_]/u.test(value);
+}
+
+// src/operators.ts
+var tiers = Object.freeze({
+  multiplicative: Object.freeze(["*", "/", "%"]),
+  additive: Object.freeze(["+", "-"]),
+  relational: Object.freeze(["<", "<=", ">", ">=", "in"]),
+  equality: Object.freeze(["==", "!="]),
+  logicalAnd: Object.freeze(["&&"]),
+  logicalXor: Object.freeze(["xor"]),
+  logicalOr: Object.freeze(["||"]),
+  coalesce: Object.freeze(["??"])
+});
+var BINARY_OPERATOR_TIERS = Object.freeze({
+  multiplicative: new Set(tiers.multiplicative),
+  additive: new Set(tiers.additive),
+  relational: new Set(tiers.relational),
+  equality: new Set(tiers.equality),
+  logicalAnd: new Set(tiers.logicalAnd),
+  logicalXor: new Set(tiers.logicalXor),
+  logicalOr: new Set(tiers.logicalOr),
+  coalesce: new Set(tiers.coalesce)
+});
+var BINARY_OPERATORS = Object.freeze([
+  ...tiers.multiplicative,
+  ...tiers.additive,
+  ...tiers.relational,
+  ...tiers.equality,
+  ...tiers.logicalAnd,
+  ...tiers.logicalXor,
+  ...tiers.logicalOr,
+  ...tiers.coalesce
+]);
+function isAdditiveOperator(operator) {
+  return BINARY_OPERATOR_TIERS.additive.has(operator);
+}
+
+// src/parser-budget.ts
+var ParserLimit = class extends Error {
+  node;
+  constructor(node) {
+    super("KALADA_SYNTAX_LIMIT_EXCEEDED");
+    this.node = node;
+  }
+};
+var ParserBudget = class {
+  nodes = 0;
+  recovered = 0;
+  pendingDepth = 0;
+  stopped = false;
+  limits;
+  sink;
+  sourceEnd;
+  constructor(limits, sink, sourceEnd) {
+    this.limits = limits;
+    this.sink = sink;
+    this.sourceEnd = sourceEnd;
+  }
+  create(node) {
+    if (this.nodes >= this.limits.maxCstNodes) this.stop(node.range.start);
+    this.nodes += 1;
+    return Object.freeze(node);
+  }
+  finishDepth(depth, start) {
+    if (this.pendingDepth + depth > this.limits.maxCstDepth) this.stop(start);
+  }
+  recover(range) {
+    if (this.recovered >= this.limits.maxRecoveryTokens) this.stop(range.start);
+    this.recovered += 1;
+  }
+  exhaust(start) {
+    return this.stop(start);
+  }
+  withWrapper(start, parse) {
+    if (this.pendingDepth + 1 >= this.limits.maxCstDepth) this.stop(start);
+    this.pendingDepth += 1;
+    try {
+      return parse();
+    } finally {
+      this.pendingDepth -= 1;
+    }
+  }
+  withConditional(conditionDepth, start, parse) {
+    if (this.pendingDepth + conditionDepth + 1 > this.limits.maxCstDepth) this.stop(start);
+    return this.withWrapper(start, parse);
+  }
+  withinWrapper(start, parse) {
+    if (this.pendingDepth >= this.limits.maxCstDepth) this.stop(start);
+    return parse();
+  }
+  stop(start) {
+    const range = freezeRange(start, this.sourceEnd);
+    if (!this.stopped) {
+      this.stopped = true;
+      this.sink.limit("parse", range);
+    }
+    throw new ParserLimit(Object.freeze({ kind: "error", token: null, range }));
+  }
+};
+
+// src/parser-types.ts
+function maxParsedDepth(...values) {
+  return Math.max(...values.map((value) => value.depth));
+}
+
+// src/parser.ts
+var OPERATORS = BINARY_OPERATOR_TIERS;
+var Parser = class {
+  index = 0;
+  sink;
+  tokens;
+  budget;
+  constructor(tokens, limits, diagnostics) {
+    this.tokens = tokens;
+    this.sink = new DiagnosticSink(limits, diagnostics);
+    this.budget = new ParserBudget(limits, this.sink, tokens[tokens.length - 1]?.range.end ?? 0);
+  }
+  parse() {
+    try {
+      const expression = this.parseConditional().node;
+      while (!this.at("eof")) {
+        const current = this.current();
+        this.budget.recover(current.range);
+        const alreadyDiagnosed = current.kind === "unsupported" || current.kind === "invalid";
+        if (current.kind === "left-parenthesis")
+          this.sink.add("parse", "KALADA_SYNTAX_UNSUPPORTED_FORM", current.range);
+        if (current.kind !== "left-parenthesis" && !alreadyDiagnosed) {
+          this.sink.add("parse", "KALADA_SYNTAX_UNEXPECTED_TOKEN", current.range);
+        }
+        this.consume();
+      }
+      return expression;
+    } catch (error) {
+      if (error instanceof ParserLimit) {
+        this.index = this.tokens.length - 1;
+        return error.node;
+      }
+      throw error;
+    }
+  }
+  parseConditional() {
+    const condition = this.parseCoalesce();
+    if (!this.at("question")) return condition;
+    const branches = this.parseConditionalBranches(condition.depth);
+    const node = this.create({
+      kind: "conditional",
+      condition: condition.node,
+      questionToken: branches.questionToken,
+      // biome-ignore lint/suspicious/noThenProperty: The CST field mirrors ternary syntax.
+      then: branches.then.node,
+      colonToken: branches.colonToken,
+      else: branches.otherwise.node,
+      range: freezeRange(condition.node.range.start, branches.otherwise.node.range.end)
+    });
+    return this.parsed(
+      node,
+      false,
+      false,
+      maxParsedDepth(condition, branches.then, branches.otherwise) + 1
+    );
+  }
+  parseConditionalBranches(conditionDepth) {
+    return this.budget.withConditional(conditionDepth, this.current().range.start, () => {
+      const questionToken = this.consume();
+      const then = this.budget.withinWrapper(
+        this.current().range.start,
+        () => this.parseConditional()
+      );
+      let colonToken = null;
+      if (this.at("colon")) colonToken = this.consume();
+      else this.sink.add("parse", "KALADA_SYNTAX_EXPECTED_COLON", this.current().range);
+      const otherwise = this.budget.withinWrapper(
+        this.current().range.start,
+        () => this.parseConditional()
+      );
+      return { questionToken, then, colonToken, otherwise };
+    });
+  }
+  parseCoalesce() {
+    let left = this.parseLogicalOr();
+    while (this.currentOperator(OPERATORS.coalesce)) {
+      const operatorToken = this.consume();
+      const right = this.parseLogicalOr();
+      if (left.logical || right.logical) {
+        this.sink.add(
+          "parse",
+          "KALADA_SYNTAX_COALESCE_LOGICAL_MIX",
+          this.token(operatorToken).range
+        );
+      }
+      left = this.binary(left, right, "??", operatorToken, true, left.logical || right.logical);
+    }
+    return left;
+  }
+  parseLogicalOr() {
+    return this.parseBinaryTier(() => this.parseLogicalXor(), OPERATORS.logicalOr, true);
+  }
+  parseLogicalXor() {
+    return this.parseBinaryTier(() => this.parseLogicalAnd(), OPERATORS.logicalXor, false);
+  }
+  parseLogicalAnd() {
+    return this.parseBinaryTier(() => this.parseEquality(), OPERATORS.logicalAnd, true);
+  }
+  parseEquality() {
+    return this.parseBinaryTier(() => this.parseRelational(), OPERATORS.equality, false);
+  }
+  parseRelational() {
+    let left = this.parseAdditive();
+    let seen = false;
+    while (this.currentOperator(OPERATORS.relational)) {
+      const operatorToken = this.consume();
+      if (seen) {
+        this.sink.add("parse", "KALADA_SYNTAX_RELATIONAL_CHAIN", this.token(operatorToken).range);
+      }
+      seen = true;
+      const operator = this.token(operatorToken).text;
+      left = this.binary(
+        left,
+        this.parseAdditive(),
+        operator,
+        operatorToken,
+        left.coalesce,
+        left.logical
+      );
+    }
+    return left;
+  }
+  parseAdditive() {
+    return this.parseBinaryTier(() => this.parseMultiplicative(), OPERATORS.additive, false);
+  }
+  parseMultiplicative() {
+    return this.parseBinaryTier(() => this.parseUnary(), OPERATORS.multiplicative, false);
+  }
+  parseBinaryTier(next, operators, logical) {
+    let left = next();
+    while (this.currentOperator(operators)) {
+      const operatorToken = this.consume();
+      const operator = this.token(operatorToken).text;
+      const right = next();
+      if (logical && (left.coalesce || right.coalesce)) {
+        this.sink.add(
+          "parse",
+          "KALADA_SYNTAX_COALESCE_LOGICAL_MIX",
+          this.token(operatorToken).range
+        );
+      }
+      left = this.binary(
+        left,
+        right,
+        operator,
+        operatorToken,
+        left.coalesce || right.coalesce,
+        logical || left.logical || right.logical
+      );
+    }
+    return left;
+  }
+  parseUnary() {
+    const token2 = this.current();
+    if (token2.kind !== "operator" || !["!", "+", "-"].includes(token2.text))
+      return this.parsePostfix();
+    const operatorToken = this.consume();
+    const operand = this.budget.withWrapper(this.current().range.start, () => this.parseUnary());
+    const node = this.create({
+      kind: "unary",
+      operator: token2.text,
+      operatorToken,
+      operand: operand.node,
+      range: freezeRange(token2.range.start, operand.node.range.end)
+    });
+    return this.parsed(node, operand.coalesce, operand.logical, operand.depth + 1);
+  }
+  parsePostfix() {
+    let target2 = this.parsePrimary();
+    while (this.at("dot") || this.at("optional-dot")) {
+      const operatorToken = this.consume();
+      const operator = this.token(operatorToken);
+      const fieldToken = this.fieldToken();
+      const field = fieldToken === null ? null : this.token(fieldToken).text;
+      const end = fieldToken === null ? operator.range.end : this.token(fieldToken).range.end;
+      const node = this.create({
+        kind: "field-access",
+        target: target2.node,
+        optional: operator.kind === "optional-dot",
+        operatorToken,
+        fieldToken,
+        field,
+        range: freezeRange(target2.node.range.start, end)
+      });
+      target2 = this.parsed(node, target2.coalesce, target2.logical, target2.depth + 1);
+    }
+    return target2;
+  }
+  parsePrimary() {
+    const current = this.current();
+    if (current.kind === "identifier") return this.reference();
+    if (["number", "string", "true", "false", "null"].includes(current.kind)) return this.literal();
+    if (current.kind === "left-parenthesis") return this.group();
+    if (current.kind === "invalid" || current.kind === "unsupported") {
+      return this.parsed(this.error(this.recoverAdvance()), false, false, 1);
+    }
+    this.sink.add("parse", "KALADA_SYNTAX_EXPECTED_EXPRESSION", current.range);
+    const synchronizer = current.kind === "eof" || current.kind === "right-parenthesis" || current.kind === "colon" || this.isBinary(current);
+    const token2 = synchronizer ? null : this.recoverAdvance();
+    return this.parsed(this.error(token2), false, false, 1);
+  }
+  group() {
+    const openToken = this.consume();
+    const expression = this.budget.withWrapper(
+      this.current().range.start,
+      () => this.parseConditional()
+    );
+    let closeToken = null;
+    if (this.at("right-parenthesis")) closeToken = this.consume();
+    else this.sink.add("parse", "KALADA_SYNTAX_EXPECTED_RIGHT_PARENTHESIS", this.current().range);
+    const end = closeToken === null ? expression.node.range.end : this.token(closeToken).range.end;
+    const node = this.create({
+      kind: "group",
+      openToken,
+      expression: expression.node,
+      closeToken,
+      range: freezeRange(this.token(openToken).range.start, end)
+    });
+    return this.parsed(node, false, false, expression.depth + 1);
+  }
+  reference() {
+    const index = this.consume();
+    const found = this.token(index);
+    const node = this.create({
+      kind: "reference",
+      token: index,
+      name: found.text,
+      range: found.range
+    });
+    return this.parsed(node, false, false, 1);
+  }
+  literal() {
+    const index = this.consume();
+    const found = this.token(index);
+    const value = found.kind === "number" ? Number(found.text) : found.kind === "string" ? JSON.parse(found.text) : found.kind === "true" ? true : found.kind === "false" ? false : null;
+    const literalKind = found.kind === "true" || found.kind === "false" ? "boolean" : found.kind;
+    const node = this.create({
+      kind: "literal",
+      literalKind,
+      token: index,
+      value,
+      range: found.range
+    });
+    return this.parsed(node, false, false, 1);
+  }
+  fieldToken() {
+    const current = this.current();
+    if (["identifier", "true", "false", "null", "in", "xor"].includes(current.kind))
+      return this.consume();
+    this.sink.add("parse", "KALADA_SYNTAX_EXPECTED_FIELD", current.range);
+    return null;
+  }
+  binary(left, right, operator, operatorToken, coalesce2, logical) {
+    const node = this.create({
+      kind: "binary",
+      operator,
+      operatorToken,
+      left: left.node,
+      right: right.node,
+      range: freezeRange(left.node.range.start, right.node.range.end)
+    });
+    return this.parsed(
+      node,
+      coalesce2 || operator === "??",
+      logical,
+      Math.max(left.depth, right.depth) + 1
+    );
+  }
+  parsed(node, coalesce2, logical, depth) {
+    this.budget.finishDepth(depth, node.range.start);
+    return { node, coalesce: coalesce2, logical, depth };
+  }
+  create(node) {
+    return this.budget.create(node);
+  }
+  error(index) {
+    const range = index === null ? this.current().range : this.token(index).range;
+    return this.create({ kind: "error", token: index, range });
+  }
+  recoverAdvance() {
+    if (this.at("eof")) return null;
+    this.budget.recover(this.current().range);
+    const found = this.consume();
+    return found;
+  }
+  currentOperator(operators) {
+    const current = this.current();
+    return (current.kind === "operator" || current.kind === "in" || current.kind === "xor") && operators.has(current.text);
+  }
+  isBinary(value) {
+    return value.kind === "in" || value.kind === "xor" || value.kind === "operator" && !["!"].includes(value.text);
+  }
+  at(kind) {
+    return this.current().kind === kind;
+  }
+  current() {
+    this.skipTrivia();
+    const found = this.token(this.index);
+    if (found.kind === "invalid" && this.sink.hasLexicalLimitAt(found.range.start))
+      this.budget.exhaust(found.range.start);
+    return found;
+  }
+  token(index) {
+    const found = this.tokens[index] ?? this.tokens[this.tokens.length - 1];
+    if (found === void 0) throw new Error("Parser token invariant failed.");
+    return found;
+  }
+  consume() {
+    this.skipTrivia();
+    const found = this.index;
+    if (this.tokens[found]?.kind !== "eof") this.index += 1;
+    return found;
+  }
+  skipTrivia() {
+    while (this.tokens[this.index]?.kind === "whitespace") this.index += 1;
+  }
+};
+
+// src/parse.ts
+var parseLimits = /* @__PURE__ */ new WeakMap();
+function parseKaladaV1Expression(source, options) {
+  if (typeof source !== "string") return invalidParseResult();
+  let limits;
+  try {
+    limits = resolveSyntaxLimits(options);
+  } catch {
+    limits = null;
+  }
+  if (limits === null) return invalidParseResult(source);
+  const scanned = lex(source, limits);
+  return parseTokens(source, scanned.tokens, limits, scanned.diagnostics);
+}
+function parseTokens(source, tokens, limits, diagnostics) {
+  const parser = new Parser(tokens, limits, diagnostics);
+  const document = {
+    source,
+    tokens,
+    expression: parser.parse()
+  };
+  const result2 = deepFreeze({ document, diagnostics: parser.sink.diagnostics });
+  parseLimits.set(result2, limits);
+  return result2;
+}
+function invalidParseResult(source = "") {
+  const range = freezeRange(0, source.length);
+  const eof = Object.freeze({
+    kind: "eof",
+    text: "",
+    range: freezeRange(source.length, source.length)
+  });
+  const result2 = deepFreeze({
+    document: {
+      source,
+      tokens: [eof],
+      expression: { kind: "error", token: null, range }
+    },
+    diagnostics: [
+      diagnostic(
+        "parse",
+        "KALADA_SYNTAX_INVALID_INPUT",
+        "Kalada syntax input is invalid.",
+        range,
+        []
+      )
+    ]
+  });
+  parseLimits.set(result2, DEFAULT_KALADA_SYNTAX_LIMITS);
+  return result2;
+}
+function syntaxLimitsFor(parsed) {
+  return parseLimits.get(parsed) ?? null;
+}
+
+// src/static-types.ts
+function projectStaticType(type) {
+  if (type === "dynamic") return type;
+  if (!("shape" in type)) return type;
+  const value = projectStaticType(type.value);
+  return value === "dynamic" ? "dynamic" : deepFreeze({ kind: "option-type", value });
+}
+var primitive = (name) => Object.freeze({ kind: "primitive-type", name });
+function literalType(value) {
+  if (value === null) return primitive("null");
+  return primitive(typeof value);
+}
+function readStaticType(input, maxDepth) {
+  if (input === "dynamic") return "dynamic";
+  return readType(input, 1, maxDepth);
+}
+function readType(input, depth, maximum) {
+  if (depth > maximum) return null;
+  const record2 = ownRecord(input);
+  if (record2 === null || typeof record2.kind !== "string") return null;
+  if (record2.kind === "primitive-type") return readExactPrimitive(record2);
+  if (record2.kind === "array-type" || record2.kind === "option-type")
+    return readCollection(record2, depth, maximum);
+  if (record2.kind === "result-type") return readExactResult(record2, depth, maximum);
+  if (record2.kind === "function-type") return readExactFunction(record2, depth, maximum);
+  return null;
+}
+function readExactPrimitive(record2) {
+  return exactKeys(record2, ["kind", "name"]) ? readPrimitive(record2) : null;
+}
+function readCollection(record2, depth, maximum) {
+  const array = record2.kind === "array-type";
+  const field = array ? "element" : "value";
+  if (!exactKeys(record2, ["kind", field])) return null;
+  const value = readType(record2[field], depth + 1, maximum);
+  return value ? deepFreeze({ kind: record2.kind, [field]: value }) : null;
+}
+function readExactResult(record2, depth, maximum) {
+  return exactKeys(record2, ["kind", "ok", "error"]) ? readResult(record2, depth, maximum) : null;
+}
+function readExactFunction(record2, depth, maximum) {
+  return exactKeys(record2, ["kind", "parameters", "returns"]) ? readFunction(record2, depth, maximum) : null;
+}
+function readPrimitive(record2) {
+  const names = ["null", "boolean", "number", "string", "json", "Instant", "Duration"];
+  if (typeof record2.name !== "string" || !names.includes(record2.name)) return null;
+  return primitive(record2.name);
+}
+function readResult(record2, depth, maximum) {
+  const ok = readType(record2.ok, depth + 1, maximum);
+  const error = readType(record2.error, depth + 1, maximum);
+  return ok && error ? deepFreeze({ kind: "result-type", ok, error }) : null;
+}
+function readFunction(record2, depth, maximum) {
+  if (!Array.isArray(record2.parameters)) return null;
+  const parameters = [];
+  for (let index = 0; index < record2.parameters.length; index++) {
+    const found = readType(record2.parameters[index], depth + 1, maximum);
+    if (found === null) return null;
+    parameters.push(found);
+  }
+  const returns = readType(record2.returns, depth + 1, maximum);
+  return returns ? deepFreeze({ kind: "function-type", parameters, returns }) : null;
+}
+function ownRecord(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return null;
+  const output = /* @__PURE__ */ Object.create(null);
+  try {
+    for (const key of Reflect.ownKeys(input)) {
+      if (typeof key !== "string") return null;
+      const descriptor = Object.getOwnPropertyDescriptor(input, key);
+      if (!descriptor || !("value" in descriptor)) return null;
+      output[key] = descriptor.value;
+    }
+  } catch {
+    return null;
+  }
+  return output;
+}
+function exactKeys(record2, expected) {
+  const keys = Object.keys(record2);
+  return keys.length === expected.length && expected.every((key) => keys.includes(key));
+}
+function typeIs(type, name) {
+  return type !== "dynamic" && !("shape" in type) && type.kind === "primitive-type" && type.name === name;
+}
+function isCallable(type) {
+  return type !== "dynamic" && !("shape" in type) && type.kind === "function-type";
+}
+function isOption(type) {
+  return type !== "dynamic" && ("shape" in type && type.shape === "option" || !("shape" in type) && type.kind === "option-type");
+}
+function equalTypes(left, right) {
+  return left === right || left !== "dynamic" && right !== "dynamic" && JSON.stringify(left) === JSON.stringify(right);
+}
+function joinTypes(left, right) {
+  if (equalTypes(left, right)) return left;
+  if (left === "dynamic" || right === "dynamic") return "dynamic";
+  if (!("shape" in left) && !("shape" in right) && isJsonCompatible(left) && isJsonCompatible(right))
+    return primitive("json");
+  return null;
+}
+function isJsonCompatible(type) {
+  if (type.kind === "array-type") return isJsonCompatible(type.element);
+  return type.kind === "primitive-type" && ["null", "boolean", "number", "string", "json"].includes(type.name);
+}
+
+// src/direct-location.ts
+function failure(code, range) {
+  return deepFreeze({
+    ok: false,
+    diagnostics: [diagnostic("lower", code, KALADA_SYNTAX_DIAGNOSTIC_MESSAGES[code], range, [])]
+  });
+}
+function safeKey(value) {
+  return typeof value === "string" && value.length > 0 && !["__proto__", "prototype", "constructor"].includes(value);
+}
+function record(input, keys, optional = []) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return false;
+  try {
+    const found = Reflect.ownKeys(input);
+    return found.every(
+      (key) => typeof key === "string" && (keys.includes(key) || optional.includes(key))
+    ) && keys.every((key) => ownDataProperty(input, key).present && ownDataProperty(input, key).ok) && found.every((key) => ownDataProperty(input, key).ok);
+  } catch {
+    return false;
+  }
+}
+function target(input, max) {
+  if (!record(input, ["namespace", "segments"], ["scope"])) return null;
+  const namespace = ownDataProperty(input, "namespace").value;
+  const scope = ownDataProperty(input, "scope");
+  const segments = ownDataProperty(input, "segments").value;
+  if (namespace !== "data" || scope.present && !safeKey(scope.value)) return null;
+  const copy = copySegments(segments, max, scope.present);
+  if (copy === null) return null;
+  return scope.present ? { namespace: "data", scope: scope.value, segments: copy } : { namespace: "data", segments: copy };
+}
+function copySegments(segments, max, scoped) {
+  if (!Array.isArray(segments)) return null;
+  const copy = [];
+  try {
+    if (Object.getPrototypeOf(segments) !== Array.prototype) return null;
+    const keys = Reflect.ownKeys(segments);
+    const length = arrayLength(segments, keys);
+    if (length > max || !scoped && length === 0) return null;
+    for (let i = 0; i < length; i++) {
+      const part = ownDataProperty(segments, String(i));
+      if (!part.ok || !part.present || !safeKey(part.value)) return null;
+      copy.push(part.value);
+    }
+    if (!keys.every((key) => typeof key === "string" && arrayKey(key, length))) return null;
+  } catch {
+    return null;
+  }
+  return copy;
+}
+function snapshotType(input) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const budget = { remaining: 512 };
+  try {
+    return copyType(input, ancestors, budget, 0);
+  } catch {
+    return null;
+  }
+}
+function copyType(input, ancestors, budget, depth) {
+  if (input === null || typeof input === "string" || typeof input === "boolean") return input;
+  if (typeof input === "number" && Number.isFinite(input)) return input;
+  if (typeof input !== "object") throw Error("non-data type leaf");
+  if (depth >= 256 || ancestors.has(input)) throw Error("invalid type graph");
+  ancestors.add(input);
+  try {
+    const array = Array.isArray(input);
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== null && prototype !== (array ? Array.prototype : Object.prototype))
+      throw Error("exotic type prototype");
+    const keys = Reflect.ownKeys(input);
+    budget.remaining -= keys.length + 1;
+    if (budget.remaining < 0) throw Error("type graph too large");
+    const output = array ? [] : /* @__PURE__ */ Object.create(null);
+    copyTypeFields(input, output, keys, array, ancestors, budget, depth);
+    if (array) Object.setPrototypeOf(output, null);
+    return Object.freeze(output);
+  } finally {
+    ancestors.delete(input);
+  }
+}
+function copyTypeFields(input, output, keys, array, ancestors, budget, depth) {
+  const length = array ? arrayLength(input, keys) : 0;
+  for (const key of keys) {
+    if (typeof key !== "string" || array && !arrayKey(key, length))
+      throw Error("invalid type key");
+    if (array && key === "length") continue;
+    copyTypeField(input, output, key, ancestors, budget, depth);
+  }
+}
+function arrayLength(input, keys) {
+  const length = ownDataProperty(input, "length").value;
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length > 512)
+    throw Error("invalid type array");
+  if (keys.length !== length + 1) throw Error("sparse type array");
+  return length;
+}
+function copyTypeField(input, output, key, ancestors, budget, depth) {
+  const part = ownDataProperty(input, key);
+  if (!part.ok || !part.present) throw Error("invalid type descriptor");
+  Object.defineProperty(output, key, {
+    value: copyType(part.value, ancestors, budget, depth + 1),
+    enumerable: true,
+    configurable: true
+  });
+}
+function arrayKey(key, length) {
+  if (key === "length") return true;
+  const index = Number(key);
+  return Number.isInteger(index) && index >= 0 && index < length && String(index) === key;
+}
+function property(input, binding, max) {
+  if (!record(input, binding ? ["target", "type", "writable"] : ["type", "writable"], ["properties"]))
+    return null;
+  if (ownDataProperty(input, "writable").value !== true) return null;
+  const snapshot = snapshotType(ownDataProperty(input, "type").value);
+  if (snapshot === null) return null;
+  const type = readStaticType(snapshot, max);
+  if (type === null || type === "dynamic" || "shape" in type) return null;
+  const properties = ownDataProperty(input, "properties");
+  if (properties.present && (type.kind !== "primitive-type" || type.name !== "json" || typeof properties.value !== "object" || properties.value === null || Array.isArray(properties.value)))
+    return null;
+  return { type, properties: properties.value };
+}
+function chain(node, max) {
+  const fields = [];
+  const range = node.range;
+  let current = node;
+  for (let depth = 0; depth <= max; depth++) {
+    if (current.kind === "group" && current.closeToken !== null) {
+      current = current.expression;
+      continue;
+    }
+    if (current.kind === "reference")
+      return { reference: current.name, fields: fields.reverse(), range };
+    if (current.kind !== "field-access" || current.optional || current.fieldToken === null || !safeKey(current.field))
+      return null;
+    fields.push({ name: current.field, range: current.range });
+    current = current.target;
+  }
+  return null;
+}
+function checkKaladaV1DirectLocation(source, options) {
+  try {
+    return checkSource(source, options);
+  } catch {
+    return failure(
+      "KALADA_SYNTAX_WRITE_BINDING_INVALID",
+      freezeRange(0, typeof source === "string" ? source.length : 0)
+    );
+  }
+}
+function checkSource(source, options) {
+  const limits = ownDataProperty(options, "limits");
+  const bindings = ownDataProperty(options, "bindings");
+  if (!record(options, ["bindings"], ["limits"]) || !bindings.ok || !bindings.present || !limits.ok)
+    return failure(
+      "KALADA_SYNTAX_WRITE_BINDING_INVALID",
+      freezeRange(0, typeof source === "string" ? source.length : 0)
+    );
+  const parsed = parseKaladaV1Expression(
+    source,
+    limits.present ? { limits: limits.value } : void 0
+  );
+  if (parsed.diagnostics.length) return deepFreeze({ ok: false, diagnostics: parsed.diagnostics });
+  const range = parsed.document.expression.range;
+  const found = chain(parsed.document.expression, 256);
+  if (!found) return failure("KALADA_SYNTAX_WRITE_INELIGIBLE", range);
+  return resolveLocation(found, bindings.value);
+}
+function resolveLocation(found, bindings) {
+  const range = found.range;
+  const binding = ownDataProperty(bindings, found.reference);
+  if (!binding.ok || !binding.present) return failure("KALADA_SYNTAX_WRITE_BINDING_INVALID", range);
+  let entry = property(binding.value, true, 256);
+  const base = target(ownDataProperty(binding.value, "target").value, 256);
+  if (!entry || !base || !safeKey(found.reference))
+    return failure("KALADA_SYNTAX_WRITE_BINDING_INVALID", range);
+  const segments = [...base.segments];
+  for (const field of found.fields) {
+    const next = ownDataProperty(entry.properties, field.name);
+    if (!next.ok || !next.present)
+      return failure("KALADA_SYNTAX_WRITE_PROPERTY_INVALID", field.range);
+    entry = property(next.value, false, 256);
+    if (!entry) return failure("KALADA_SYNTAX_WRITE_PROPERTY_INVALID", field.range);
+    segments.push(field.name);
+  }
+  return deepFreeze({
+    ok: true,
+    location: {
+      target: { ...base, segments },
+      type: entry.type,
+      range: freezeRange(range.start, range.end)
+    }
+  });
+}
+
+// src/format.ts
+function formatKaladaV1Expression(source, options) {
+  const parsed = parseKaladaV1Expression(source, options);
+  if (parsed.diagnostics.length > 0) {
+    return deepFreeze({ ok: false, diagnostics: parsed.diagnostics });
+  }
+  return Object.freeze({ ok: true, text: formatNode(parsed.document.expression, parsed.document) });
+}
+function formatNode(node, document) {
+  if (node.kind === "literal" || node.kind === "reference") {
+    return document.tokens[node.token]?.text ?? "";
+  }
+  if (node.kind === "group") return formatGroup(node, document);
+  if (node.kind === "field-access") {
+    const operator = document.tokens[node.operatorToken]?.text ?? "";
+    const field = node.fieldToken === null ? "" : document.tokens[node.fieldToken]?.text ?? "";
+    return `${formatNode(node.target, document)}${operator}${field}`;
+  }
+  if (node.kind === "unary") return formatUnary(node, document);
+  if (node.kind === "binary") {
+    return `${formatNode(node.left, document)} ${node.operator} ${formatNode(node.right, document)}`;
+  }
+  if (node.kind === "conditional") {
+    return `${formatNode(node.condition, document)} ? ${formatNode(node.then, document)} : ${formatNode(node.else, document)}`;
+  }
+  return "";
+}
+function formatUnary(node, document) {
+  const sameSign = (node.operator === "+" || node.operator === "-") && node.operand.kind === "unary" && node.operand.operator === node.operator;
+  return `${node.operator}${sameSign ? " " : ""}${formatNode(node.operand, document)}`;
+}
+function formatGroup(node, document) {
+  return `(${formatNode(node.expression, document)})`;
+}
+
+// src/guest-boundary.ts
+function parseGuestExpressionPrefix(source, start, options) {
+  let limits;
+  try {
+    limits = resolveSyntaxLimits(options);
+  } catch {
+    limits = null;
+  }
+  if (typeof source !== "string" || !Number.isSafeInteger(start) || start < 0 || start > source.length || limits === null) {
+    return deepFreeze({
+      ok: false,
+      range: freezeRange(0, 0),
+      stop: 0,
+      reason: "invalid-start",
+      parsed: null,
+      diagnostics: []
+    });
+  }
+  const scanned = lexGuest(source, start, limits);
+  const stop = scanned.stop ?? scanned.tokens[scanned.tokens.length - 1]?.range.start ?? start;
+  const sink = new DiagnosticSink(limits, scanned.diagnostics);
+  const limited = sink.diagnostics.some((item) => item.code === "KALADA_SYNTAX_LIMIT_EXCEEDED");
+  const reason = guestStopReason(scanned, limited);
+  if (reason === "eof")
+    sink.add("parse", "KALADA_SYNTAX_UNEXPECTED_TOKEN", freezeRange(stop, stop));
+  const parsed = parseTokens(source, scanned.tokens, limits, sink.diagnostics);
+  return deepFreeze({
+    ok: reason === "outer-brace" && parsed.diagnostics.length === 0,
+    range: freezeRange(start, stop),
+    stop,
+    reason,
+    parsed,
+    diagnostics: parsed.diagnostics
+  });
+}
+function guestStopReason(scanned, limited) {
+  if (scanned.stop === null) return limited ? "limit" : "eof";
+  if (scanned.unsupportedComment) return "unsupported-comment";
+  if (scanned.unsupportedQuote) return "unsupported-quote";
+  return scanned.unmatchedParentheses ? "unmatched-parentheses" : "outer-brace";
+}
+
+// src/dispatch.ts
+var DispatchFailure = class extends Error {
+  code;
+  operand;
+  constructor(code, operand) {
+    super(code);
+    this.code = code;
+    this.operand = operand;
+  }
+};
+function dispatchBinary(operator, left, right) {
+  if (BINARY_OPERATOR_TIERS.equality.has(operator)) return equality(left, right);
+  if (BINARY_OPERATOR_TIERS.relational.has(operator) && operator !== "in")
+    return ordering(left, right);
+  if (operator === "in") return membership(left, right);
+  if (isAdditiveOperator(operator)) return additive(operator, left, right);
+  if (BINARY_OPERATOR_TIERS.multiplicative.has(operator)) return numeric(left, right);
+  if (operator === "&&" || operator === "||") return booleanLogical(left, right);
+  if (operator === "xor") return booleanXor(left, right);
+  return coalesce(left, right);
+}
+function dispatchUnary(operator, operand) {
+  requireType(operand, operator === "!" ? "boolean" : "number", "left");
+  return {
+    family: operator === "!" ? "boolean-logical" : "numeric-binary",
+    type: primitive(operator === "!" ? "boolean" : "number")
+  };
+}
+function dispatchField(target2, optional) {
+  if (!optional) {
+    if (target2 !== "dynamic" && !typeIs(target2, "json"))
+      fail("KALADA_FIELD_TYPE_MISMATCH", "target");
+    return "dynamic";
+  }
+  if (target2 === "dynamic") return option("dynamic");
+  if (typeIs(target2, "null")) return option(primitive("null"));
+  if (typeIs(target2, "json")) return option("dynamic");
+  if (isOption(target2) && validOptionalPayload(target2.value))
+    return option(typeIs(target2.value, "null") ? primitive("null") : "dynamic");
+  return fail("KALADA_FIELD_TYPE_MISMATCH", "target");
+}
+function dispatchConditional(condition, thenType, elseType) {
+  requireType(condition, "boolean", "condition");
+  const joined = joinTypes(thenType, elseType);
+  return joined ?? fail("KALADA_OPERATOR_TYPE", "else");
+}
+function equality(left, right) {
+  if (isCallable(left)) fail("KALADA_OPERATOR_TYPE", "left");
+  if (isCallable(right)) fail("KALADA_OPERATOR_TYPE", "right");
+  return { family: "equality", type: primitive("boolean") };
+}
+function ordering(left, right) {
+  const leftDomain = orderedDomain(left);
+  const rightDomain = orderedDomain(right);
+  if (leftDomain === "unsupported") fail("KALADA_OPERATOR_TYPE", "left");
+  if (rightDomain === "unsupported") fail("KALADA_OPERATOR_TYPE", "right");
+  if (leftDomain === "dynamic" && rightDomain === "dynamic")
+    fail("KALADA_OPERATOR_AMBIGUOUS", "operator");
+  const domain = leftDomain === "dynamic" ? rightDomain : leftDomain;
+  if (rightDomain !== "dynamic" && leftDomain !== "dynamic" && leftDomain !== rightDomain)
+    fail("KALADA_OPERATOR_TYPE", "right");
+  const family = domain === "number" ? "ordered-number" : domain === "string" ? "ordered-string" : "temporal-comparison";
+  return { family, type: primitive("boolean") };
+}
+function membership(left, right) {
+  if (isCallable(left)) fail("KALADA_OPERATOR_TYPE", "needle");
+  if (right !== "dynamic" && ("shape" in right || right.kind !== "array-type"))
+    fail("KALADA_OPERATOR_TYPE", "array");
+  return { family: "membership", type: primitive("boolean") };
+}
+function additive(operator, left, right) {
+  if (left === "dynamic" && right === "dynamic") fail("KALADA_OPERATOR_AMBIGUOUS", "operator");
+  if (typeIs(left, "number") || left === "dynamic" && typeIs(right, "number"))
+    return numeric(left, right);
+  if (typeIs(left, "number")) return numeric(left, right);
+  if (isTemporalCandidate(left, right, operator)) return temporalResult(operator, left, right);
+  if (left !== "dynamic" && !isTemporal(left)) fail("KALADA_OPERATOR_TYPE", "left");
+  return fail("KALADA_OPERATOR_TYPE", "right");
+}
+function numeric(left, right) {
+  requireType(left, "number", "left");
+  requireType(right, "number", "right");
+  return { family: "numeric-binary", type: primitive("number") };
+}
+function temporalResult(operator, left, right) {
+  let type = "dynamic";
+  if (operator === "+" && typeIs(left, "Instant")) type = primitive("Instant");
+  if (operator === "+" && typeIs(left, "Duration")) type = primitive("Duration");
+  if (operator === "-" && typeIs(left, "Duration")) type = primitive("Duration");
+  if (operator === "-" && typeIs(left, "Instant") && typeIs(right, "Duration"))
+    type = primitive("Instant");
+  if (operator === "-" && typeIs(right, "Instant")) type = primitive("Duration");
+  return { family: "temporal-arithmetic", type };
+}
+function booleanLogical(left, right) {
+  requireType(left, "boolean", "left");
+  requireType(right, "boolean", "right");
+  return { family: "boolean-logical", type: primitive("boolean") };
+}
+function booleanXor(left, right) {
+  const result2 = booleanLogical(left, right);
+  return { ...result2, family: "boolean-xor" };
+}
+function coalesce(left, right) {
+  const payload = left === "dynamic" ? "dynamic" : isOption(left) ? left.value : fail("KALADA_OPTION_REQUIRED", "option");
+  const joined = joinTypes(payload, right);
+  if (joined === null) fail("KALADA_OPERATOR_TYPE", "fallback");
+  return { family: "option-coalesce", type: joined };
+}
+function orderedDomain(type) {
+  if (type === "dynamic") return "dynamic";
+  if ("shape" in type) return "unsupported";
+  if (type.kind !== "primitive-type") return "unsupported";
+  return ["number", "string", "Instant", "Duration"].includes(type.name) ? type.name : "unsupported";
+}
+function isTemporalCandidate(left, right, operator) {
+  if (operator === "+")
+    return typeIs(left, "Instant") && (typeIs(right, "Duration") || right === "dynamic") || typeIs(left, "Duration") && (typeIs(right, "Duration") || right === "dynamic") || left === "dynamic" && typeIs(right, "Duration");
+  return typeIs(left, "Instant") && (isTemporal(right) || right === "dynamic") || typeIs(left, "Duration") && (typeIs(right, "Duration") || right === "dynamic") || left === "dynamic" && isTemporal(right);
+}
+function isTemporal(type) {
+  return typeIs(type, "Instant") || typeIs(type, "Duration");
+}
+function validOptionalPayload(type) {
+  return type === "dynamic" || typeIs(type, "json") || typeIs(type, "null");
+}
+function option(value) {
+  return Object.freeze({ shape: "option", value });
+}
+function requireType(type, name, operand) {
+  if (type !== "dynamic" && !typeIs(type, name)) fail("KALADA_OPERATOR_TYPE", operand);
+}
+function fail(code, operand) {
+  throw new DispatchFailure(code, operand);
+}
+
+// src/reference-environment.ts
+function readLowerConfiguration(options, limits) {
+  if (options === void 0) return { environment: null, coreOptions: {} };
+  if (!hasOnlyKeys(options, /* @__PURE__ */ new Set(["references", "coreOptions"]))) return null;
+  const referencesProperty = ownDataProperty(options, "references");
+  const coreOptionsProperty = ownDataProperty(options, "coreOptions");
+  if (!referencesProperty.ok || !coreOptionsProperty.ok) return null;
+  const references = referencesProperty.value;
+  const coreOptions = coreOptionsProperty.value;
+  if (coreOptionsProperty.present && (typeof coreOptions !== "object" || coreOptions === null))
+    return null;
+  const environment = referencesProperty.present ? readEnvironment(references, limits) : null;
+  if (referencesProperty.present && environment === null) return null;
+  return { environment, coreOptions: coreOptions ?? {} };
+}
+function readEnvironment(input, limits) {
+  try {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) return null;
+    const output = /* @__PURE__ */ new Map();
+    for (const key of Reflect.ownKeys(input)) {
+      if (typeof key !== "string") return null;
+      const descriptor = Object.getOwnPropertyDescriptor(input, key);
+      if (!descriptor || !("value" in descriptor)) return null;
+      const binding = readBinding(descriptor.value, limits);
+      if (binding === null) return null;
+      output.set(key, binding);
+    }
+    return output;
+  } catch {
+    return null;
+  }
+}
+function readBinding(input, limits) {
+  if (!hasOnlyKeys(input, /* @__PURE__ */ new Set(["reference", "type"]))) return null;
+  const reference = dataProperty(input, "reference");
+  const rawType = dataProperty(input, "type");
+  if (!reference.found || !rawType.found) return null;
+  const type = readStaticType(rawType.value, limits.maxStaticTypeDepth);
+  if (type === null) return null;
+  return Object.freeze({ reference: reference.value, type });
+}
+function dataProperty(input, key) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    return descriptor && "value" in descriptor ? { found: true, value: descriptor.value } : { found: false };
+  } catch {
+    return { found: false };
+  }
+}
+
+// src/semantic-inference.ts
+function analyzeSemantics(parsed, configuration) {
+  const state = {
+    configuration,
+    inferred: /* @__PURE__ */ new Map(),
+    diagnostics: [...parsed.diagnostics],
+    incomplete: parsed.diagnostics.length > 0
+  };
+  const ordered = postorder(parsed.document.expression);
+  for (const node of ordered) state.inferred.set(node, inferNode(node, state));
+  return {
+    ordered,
+    inferred: state.inferred,
+    diagnostics: state.diagnostics,
+    incomplete: state.incomplete
+  };
+}
+function inferNode(node, state) {
+  if (node.kind === "literal") return complete(literalType(node.value));
+  if (node.kind === "reference") return inferReference(node, state);
+  if (node.kind === "error") return incomplete(state);
+  try {
+    return inferComposite(node, state);
+  } catch (error) {
+    return failed(node, error, state);
+  }
+}
+function inferComposite(node, state) {
+  if (node.kind === "group") {
+    const child = childInference(node.expression, state);
+    return node.closeToken === null || !child.complete ? incomplete(state) : child;
+  }
+  if (node.kind === "field-access") return inferField(node, state);
+  if (node.kind === "unary") return inferUnary(node, state);
+  if (node.kind === "binary") return inferBinary(node, state);
+  return inferConditional(node, state);
+}
+function inferField(node, state) {
+  const target2 = childInference(node.target, state);
+  if (!target2.complete || node.field === null || node.fieldToken === null) return incomplete(state);
+  return complete(dispatchField(target2.type, node.optional));
+}
+function inferUnary(node, state) {
+  const operand = childInference(node.operand, state);
+  if (!operand.complete) return incomplete(state);
+  const dispatch = dispatchUnary(node.operator, operand.type);
+  return complete(dispatch.type, dispatch);
+}
+function inferBinary(node, state) {
+  const left = childInference(node.left, state);
+  const right = childInference(node.right, state);
+  if (!left.complete || !right.complete) return incomplete(state);
+  const dispatch = dispatchBinary(node.operator, left.type, right.type);
+  return complete(dispatch.type, dispatch);
+}
+function inferConditional(node, state) {
+  const condition = childInference(node.condition, state);
+  const then = childInference(node.then, state);
+  const otherwise = childInference(node.else, state);
+  if (node.colonToken === null || !condition.complete || !then.complete || !otherwise.complete) {
+    return incomplete(state);
+  }
+  return complete(dispatchConditional(condition.type, then.type, otherwise.type));
+}
+function inferReference(node, state) {
+  const environment = state.configuration.environment;
+  const binding = environment?.get(node.name);
+  if (!environment || binding) return complete(binding?.type ?? "dynamic");
+  state.incomplete = true;
+  state.diagnostics.push(
+    diagnostic(
+      "lower",
+      "KALADA_SYNTAX_UNKNOWN_REFERENCE",
+      "Kalada reference is not present in the lowering environment.",
+      node.range,
+      []
+    )
+  );
+  return { type: "dynamic", complete: false };
+}
+function failed(node, error, state) {
+  state.incomplete = true;
+  const failure2 = error instanceof DispatchFailure ? error : void 0;
+  state.diagnostics.push(
+    diagnostic(
+      "lower",
+      failure2?.code ?? "KALADA_SYNTAX_INVALID_INPUT",
+      "Kalada semantic analysis could not determine this expression.",
+      node.range,
+      []
+    )
+  );
+  return { type: "dynamic", complete: false, ...failure2 ? { failure: failure2 } : {} };
+}
+function childInference(node, state) {
+  return state.inferred.get(node) ?? incomplete(state);
+}
+function complete(type, dispatch) {
+  return { type, complete: true, ...dispatch ? { dispatch } : {} };
+}
+function incomplete(state) {
+  state.incomplete = true;
+  return { type: "dynamic", complete: false };
+}
+function postorder(root) {
+  const output = [];
+  const stack = [{ node: root, visited: false }];
+  while (stack.length > 0) {
+    const entry = stack.pop();
+    if (!entry) continue;
+    if (entry.visited) output.push(entry.node);
+    else scheduleChildren(stack, entry.node);
+  }
+  return output;
+}
+function scheduleChildren(stack, node) {
+  stack.push({ node, visited: true });
+  const children = nodeChildren(node);
+  for (let index = children.length - 1; index >= 0; index -= 1) {
+    const child = children[index];
+    if (child) stack.push({ node: child, visited: false });
+  }
+}
+function nodeChildren(node) {
+  if (node.kind === "group") return [node.expression];
+  if (node.kind === "field-access") return [node.target];
+  if (node.kind === "unary") return [node.operand];
+  if (node.kind === "binary") return [node.left, node.right];
+  if (node.kind === "conditional") return [node.condition, node.then, node.else];
+  return [];
+}
+
+// src/source-map.ts
+var ROLE_ORDER = Object.freeze({
+  node: 0,
+  operator: 1,
+  literal: 2,
+  reference: 3,
+  field: 4,
+  group: 5
+});
+function addMap(entries, path, role, range) {
+  entries.push({ path: [...path], role, range: freezeRange(range.start, range.end) });
+}
+function widenNode(entries, path, range) {
+  const index = entries.findIndex((entry) => entry.role === "node" && equalPath(entry.path, path));
+  if (index < 0) return;
+  const found = entries[index];
+  entries[index] = { ...found, range: freezeRange(range.start, range.end) };
+}
+function finishMap(entries) {
+  entries.sort(compareEntries);
+  return deepFreeze(entries);
+}
+function rangeForPath(entries, path, fallback) {
+  const exact = entries.filter((entry) => equalPath(entry.path, path)).sort(preferNarrow)[0];
+  if (exact) return exact.range;
+  for (let length = path.length - 1; length >= 1; length -= 1) {
+    const ancestor = path.slice(0, length);
+    const found = entries.find((entry) => entry.role === "node" && equalPath(entry.path, ancestor));
+    if (found) return found.range;
+  }
+  return fallback;
+}
+function compareEntries(left, right) {
+  return left.range.start - right.range.start || left.range.end - right.range.end || ROLE_ORDER[left.role] - ROLE_ORDER[right.role] || pathKey(left.path).localeCompare(pathKey(right.path));
+}
+function preferNarrow(left, right) {
+  const leftLength = left.range.end - left.range.start;
+  const rightLength = right.range.end - right.range.start;
+  return leftLength - rightLength || ROLE_ORDER[left.role] - ROLE_ORDER[right.role];
+}
+function equalPath(left, right) {
+  return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function pathKey(path) {
+  return JSON.stringify(path);
+}
+
+// src/lower.ts
+var CORE_MESSAGES = Object.freeze({
+  KALADA_OPERATOR_TYPE: "Kalada operator received an incompatible value.",
+  KALADA_OPERATOR_AMBIGUOUS: "Kalada operator domain is ambiguous.",
+  KALADA_OPTION_REQUIRED: "Kalada option coalesce requires an Option value.",
+  KALADA_FIELD_TYPE_MISMATCH: "Kalada field access requires a JSON object."
+});
+var LowerFailure = class extends Error {
+  diagnostic;
+  constructor(diagnostic2) {
+    super(diagnostic2.code);
+    this.diagnostic = diagnostic2;
+  }
+};
+function lowerKaladaV1Expression(parsed, options) {
+  const limits = syntaxLimitsFor(parsed);
+  if (limits === null) return invalidOutcome();
+  if (parsed.diagnostics.length > 0)
+    return deepFreeze({ ok: false, diagnostics: parsed.diagnostics });
+  let configuration;
+  try {
+    configuration = readLowerConfiguration(options, limits);
+  } catch {
+    configuration = null;
+  }
+  if (configuration === null) return invalidOutcome(parsed.document.expression.range);
+  const analysis = analyzeSemantics(parsed, configuration);
+  const state = { parsed, configuration, entries: [], inferred: analysis.inferred };
+  try {
+    const lowered = lowerNode(parsed.document.expression, ["expression"], state);
+    const input = KaladaV1.program(lowered.expression);
+    const compiled = compileKaladaV1Program(input, configuration.coreOptions);
+    if (!compiled.ok) throw coreFailure(compiled.diagnostic, state);
+    return deepFreeze({
+      ok: true,
+      program: compiled.value.program,
+      sourceMap: finishMap(state.entries),
+      resultType: projectStaticType(lowered.type)
+    });
+  } catch (error) {
+    const problem = error instanceof LowerFailure ? error.diagnostic : invalidDiagnostic(parsed.document.expression.range);
+    return deepFreeze({ ok: false, diagnostics: [problem] });
+  }
+}
+function lowerNode(node, path, state) {
+  if (node.kind === "literal") return lowerLiteral(node, path, state);
+  if (node.kind === "reference") return lowerReference(node, path, state);
+  if (node.kind === "group") return lowerGroup(node, path, state);
+  if (node.kind === "field-access") return lowerField(node, path, state);
+  if (node.kind === "unary") return lowerUnary(node, path, state);
+  if (node.kind === "binary") return lowerBinary(node, path, state);
+  if (node.kind === "conditional") return lowerConditional(node, path, state);
+  throw new LowerFailure(invalidDiagnostic(node.range));
+}
+function lowerLiteral(node, path, state) {
+  addMap(state.entries, path, "node", node.range);
+  addMap(state.entries, [...path, "value"], "literal", node.range);
+  return { expression: KaladaV1.literal(node.value), type: inferenceFor(node, state).type };
+}
+function lowerReference(node, path, state) {
+  const binding = state.configuration.environment?.get(node.name);
+  if (state.configuration.environment && !binding) {
+    throw syntaxFailure("KALADA_SYNTAX_UNKNOWN_REFERENCE", node.range, [...path, "ref"]);
+  }
+  addMap(state.entries, path, "node", node.range);
+  addMap(state.entries, [...path, "ref"], "reference", node.range);
+  const type = inferenceFor(node, state).type;
+  return binding ? { expression: KaladaV1.ref(binding.reference), type } : { expression: KaladaV1.ref(node.name), type };
+}
+function lowerGroup(node, path, state) {
+  const child = lowerNode(node.expression, path, state);
+  addMap(state.entries, path, "group", node.range);
+  widenNode(state.entries, path, node.range);
+  return child;
+}
+function lowerField(node, path, state) {
+  const target2 = lowerNode(node.target, [...path, "target"], state);
+  const operatorRange = sourceRange(state, node.operatorToken);
+  addMap(state.entries, path, "operator", operatorRange);
+  const fieldRange = node.fieldToken === null ? operatorRange : sourceRange(state, node.fieldToken);
+  addMap(state.entries, [...path, "field"], "field", fieldRange);
+  const inferred = inferenceFor(node, state);
+  if (inferred.failure) throw dispatchFailure(inferred.failure, path, state, node.range);
+  if (!inferred.complete) throw new LowerFailure(invalidDiagnostic(node.range));
+  const expression = node.optional ? KaladaV1.optionalFieldAccess(target2.expression, node.field) : KaladaV1.fieldAccess(target2.expression, node.field);
+  addMap(state.entries, path, "node", node.range);
+  return { expression, type: inferred.type };
+}
+function lowerUnary(node, path, state) {
+  const operand = lowerNode(node.operand, [...path, "operand"], state);
+  const operatorPath = node.operator === "!" ? path : [...path, "operator"];
+  addMap(state.entries, operatorPath, "operator", sourceRange(state, node.operatorToken));
+  const inferred = inferenceFor(node, state);
+  if (inferred.failure) throw dispatchFailure(inferred.failure, path, state, node.range, "operand");
+  const result2 = requireDispatch(inferred, node.range);
+  const expression = node.operator === "!" ? KaladaV1.booleanNot(operand.expression) : KaladaV1.numericUnary(node.operator === "+" ? "plus" : "negate", operand.expression);
+  addMap(state.entries, path, "node", node.range);
+  return { expression, type: result2.type };
+}
+function lowerBinary(node, path, state) {
+  const [leftKey, rightKey] = binaryKeys(node.operator);
+  const left = lowerNode(node.left, [...path, leftKey], state);
+  const right = lowerNode(node.right, [...path, rightKey], state);
+  const operatorPath = operatorHasField(node.operator) ? [...path, "operator"] : path;
+  addMap(state.entries, operatorPath, "operator", sourceRange(state, node.operatorToken));
+  const inferred = inferenceFor(node, state);
+  if (inferred.failure) throw dispatchFailure(inferred.failure, path, state, node.range);
+  const dispatch = requireDispatch(inferred, node.range);
+  const expression = binaryExpression(
+    node.operator,
+    dispatch.family,
+    left.expression,
+    right.expression
+  );
+  addMap(state.entries, path, "node", node.range);
+  return { expression, type: dispatch.type };
+}
+function lowerConditional(node, path, state) {
+  const condition = lowerNode(node.condition, [...path, "condition"], state);
+  const then = lowerNode(node.then, [...path, "then"], state);
+  const otherwise = lowerNode(node.else, [...path, "else"], state);
+  addMap(state.entries, path, "operator", sourceRange(state, node.questionToken));
+  if (node.colonToken !== null)
+    addMap(state.entries, path, "operator", sourceRange(state, node.colonToken));
+  const inferred = inferenceFor(node, state);
+  if (inferred.failure) throw dispatchFailure(inferred.failure, path, state, node.range);
+  if (!inferred.complete) throw new LowerFailure(invalidDiagnostic(node.range));
+  addMap(state.entries, path, "node", node.range);
+  return {
+    expression: KaladaV1.conditional(condition.expression, then.expression, otherwise.expression),
+    type: inferred.type
+  };
+}
+function binaryExpression(operator, family, left, right) {
+  if (family === "equality")
+    return KaladaV1.equality(operator === "==" ? "equal" : "not-equal", left, right);
+  if (family === "ordered-number" || family === "ordered-string")
+    return KaladaV1.orderedComparison(
+      family === "ordered-number" ? "number" : "string",
+      comparisonOperator(operator),
+      left,
+      right
+    );
+  if (family === "temporal-comparison")
+    return KaladaV1.temporalComparison(comparisonOperator(operator), left, right);
+  return remainingBinaryExpression(operator, family, left, right);
+}
+function remainingBinaryExpression(operator, family, left, right) {
+  if (family === "membership") return KaladaV1.membership(left, right);
+  if (family === "numeric-binary")
+    return KaladaV1.numericBinary(numericOperator(operator), left, right);
+  if (family === "temporal-arithmetic")
+    return KaladaV1.temporalArithmetic(operator === "+" ? "add" : "subtract", left, right);
+  if (family === "boolean-logical")
+    return KaladaV1.booleanLogical(operator === "&&" ? "and" : "or", left, right);
+  if (family === "boolean-xor") return KaladaV1.booleanXor(left, right);
+  return KaladaV1.optionCoalesce(left, right);
+}
+function comparisonOperator(operator) {
+  const values = {
+    "<": "less-than",
+    "<=": "less-than-or-equal",
+    ">": "greater-than",
+    ">=": "greater-than-or-equal"
+  };
+  return values[operator];
+}
+function numericOperator(operator) {
+  const values = {
+    "+": "add",
+    "-": "subtract",
+    "*": "multiply",
+    "/": "divide",
+    "%": "remainder"
+  };
+  return values[operator];
+}
+function binaryKeys(operator) {
+  if (operator === "in") return ["needle", "array"];
+  if (operator === "??") return ["option", "fallback"];
+  return ["left", "right"];
+}
+function operatorHasField(operator) {
+  return !["in", "xor", "??"].includes(operator);
+}
+function dispatchFailure(error, path, state, fallback, unaryOperand) {
+  if (!(error instanceof DispatchFailure)) return new LowerFailure(invalidDiagnostic(fallback));
+  const key = unaryOperand ?? error.operand;
+  const diagnosticPath = key === "operator" ? [...path, "operator"] : [...path, key];
+  const range = rangeForPath(state.entries, diagnosticPath, fallback);
+  return new LowerFailure(
+    diagnostic("lower", error.code, CORE_MESSAGES[error.code], range, diagnosticPath)
+  );
+}
+function coreFailure(problem, state) {
+  const range = rangeForPath(state.entries, problem.path, state.parsed.document.expression.range);
+  return new LowerFailure(diagnostic("lower", problem.code, problem.message, range, problem.path));
+}
+function syntaxFailure(code, range, path) {
+  return new LowerFailure(
+    diagnostic(
+      "lower",
+      code,
+      "Kalada reference is not present in the lowering environment.",
+      range,
+      path
+    )
+  );
+}
+function invalidDiagnostic(range = freezeRange(0, 0)) {
+  return diagnostic(
+    "lower",
+    "KALADA_SYNTAX_INVALID_INPUT",
+    "Kalada syntax input is invalid.",
+    range,
+    []
+  );
+}
+function invalidOutcome(range) {
+  return deepFreeze({ ok: false, diagnostics: [invalidDiagnostic(range)] });
+}
+function sourceRange(state, token2) {
+  return state.parsed.document.tokens[token2]?.range ?? state.parsed.document.expression.range;
+}
+function inferenceFor(node, state) {
+  return state.inferred.get(node) ?? { type: "dynamic", complete: false };
+}
+function requireDispatch(inferred, range) {
+  if (!inferred.complete || !inferred.dispatch) throw new LowerFailure(invalidDiagnostic(range));
+  return inferred.dispatch;
+}
+
+// src/semantic-query.ts
+function queryKaladaV1Semantics(parsed, options) {
+  const limits = syntaxLimitsFor(parsed);
+  if (limits === null) return invalidQuery();
+  const configuration = safeConfiguration(options, limits);
+  if (configuration === null) return invalidQuery(parsed.document.expression.range);
+  const analysis = analyzeSemantics(parsed, configuration);
+  const nodes = analysis.ordered.map(
+    (node) => describeNode(node, analysis.inferred.get(node) ?? unknownInference())
+  );
+  return deepFreeze({
+    nodes,
+    diagnostics: analysis.diagnostics,
+    incomplete: analysis.incomplete
+  });
+}
+function safeConfiguration(options, limits) {
+  try {
+    return readLowerConfiguration(options, limits);
+  } catch {
+    return null;
+  }
+}
+function describeNode(node, inference) {
+  const type = projectStaticType(inference.type);
+  return {
+    range: node.range,
+    type,
+    known: inference.complete && type !== "dynamic",
+    fieldAccess: {
+      plain: fieldSupport(inference, false),
+      optional: fieldSupport(inference, true)
+    },
+    operators: BINARY_OPERATORS.map((operator) => ({
+      operator,
+      support: operatorSupport(operator, inference)
+    }))
+  };
+}
+function fieldSupport(inference, optional) {
+  if (!inference.complete || inference.type === "dynamic") return "conditional";
+  try {
+    dispatchField(inference.type, optional);
+    return "supported";
+  } catch {
+    return "unsupported";
+  }
+}
+function operatorSupport(operator, left) {
+  if (!left.complete) return "conditional";
+  return dispatchSupport(operator, left.type, "dynamic", false);
+}
+function dispatchSupport(operator, left, right, completeOperands) {
+  try {
+    dispatchBinary(operator, left, right);
+    if (!completeOperands || containsDynamic(left) || containsDynamic(right)) return "conditional";
+    return "supported";
+  } catch {
+    return left === "dynamic" ? "conditional" : "unsupported";
+  }
+}
+function containsDynamic(type) {
+  return type === "dynamic" || "shape" in type && containsDynamic(type.value);
+}
+function unknownInference() {
+  return { type: "dynamic", complete: false };
+}
+function invalidQuery(range = Object.freeze({ start: 0, end: 0 })) {
+  return deepFreeze({
+    nodes: [],
+    diagnostics: [
+      diagnostic(
+        "lower",
+        "KALADA_SYNTAX_INVALID_INPUT",
+        "Kalada syntax input is invalid.",
+        range,
+        []
+      )
+    ],
+    incomplete: true
+  });
+}
+
+export { DEFAULT_KALADA_SYNTAX_LIMITS, KALADA_SYNTAX_DIAGNOSTIC_MESSAGES, MAXIMUM_KALADA_SYNTAX_LIMITS, checkKaladaV1DirectLocation, parseGuestExpressionPrefix as experimentalParseKaladaV1GuestExpressionPrefix, formatKaladaV1Expression, lowerKaladaV1Expression, parseKaladaV1Expression, queryKaladaV1Semantics };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map