@kalada/core 0.0.0

package/dist/kuery-v1/canonicalize.js

@@ -0,0 +1,178 @@
+import { dataProperties, cloneJson, exceedsStringLimit, arrayLength, stableJson } from './inspect.js';
+import { resolveLimits } from './limits.js';
+import { failure, success, ExpressionFailure } from './result.js';
+
+const NODE_KEYS = Object.freeze({
+  literal: /* @__PURE__ */ new Set(["kind", "value"]),
+  ref: /* @__PURE__ */ new Set(["kind", "ref"]),
+  op: /* @__PURE__ */ new Set(["kind", "op", "args"])
+});
+const ALL_NODE_KEYS = /* @__PURE__ */ new Set(["kind", "value", "ref", "op", "args"]);
+function canonicalizeExpression(input, options = {}) {
+  let limits;
+  try {
+    limits = resolveLimits(options.limits);
+  } catch {
+    return failure("EXPRESSION_LIMIT_EXCEEDED", []);
+  }
+  const state = {
+    limits,
+    options,
+    maxDepth: limits.maxDepth,
+    maxNodes: limits.maxNodes,
+    maxStringLength: limits.maxStringLength,
+    nodes: 0,
+    active: /* @__PURE__ */ new WeakSet()
+  };
+  try {
+    return success(canonicalizeNode(input, [], 0, state));
+  } catch (error) {
+    const problem = error instanceof ExpressionFailure ? error : new ExpressionFailure("EXPRESSION_INVALID_INPUT", []);
+    return failure(problem.code, problem.expressionPath);
+  }
+}
+function canonicalizeNode(input, path, depth, state) {
+  countNode(path, depth, state);
+  if (typeof input !== "object" || input === null)
+    throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", path);
+  if (state.active.has(input)) throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", path);
+  state.active.add(input);
+  try {
+    const initial = dataProperties(input, path, ALL_NODE_KEYS, 3);
+    const kind = initial.kind;
+    if (kind !== "literal" && kind !== "ref" && kind !== "op") {
+      throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", [...path, "kind"]);
+    }
+    const properties = selectNodeProperties(initial, path, NODE_KEYS[kind]);
+    if (kind === "literal") return canonicalLiteral(properties, path, depth, state);
+    if (kind === "ref") return canonicalReference(properties, path, depth, state);
+    return canonicalOperator(properties, path, depth, state);
+  } finally {
+    state.active.delete(input);
+  }
+}
+function selectNodeProperties(properties, path, allowed) {
+  for (const key of Object.keys(properties)) {
+    if (!allowed.has(key)) throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", [...path, key]);
+  }
+  return properties;
+}
+function countNode(path, depth, state) {
+  state.nodes += 1;
+  if (depth > state.limits.maxDepth || state.nodes > state.limits.maxNodes) {
+    throw new ExpressionFailure("EXPRESSION_LIMIT_EXCEEDED", path);
+  }
+}
+function canonicalLiteral(properties, path, depth, state) {
+  if (!("value" in properties))
+    throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", [...path, "value"]);
+  const value = cloneJson(properties.value, [...path, "value"], depth + 1, state);
+  return Object.freeze({ kind: "literal", value });
+}
+function canonicalReference(properties, path, depth, state) {
+  if (!("ref" in properties))
+    throw new ExpressionFailure("EXPRESSION_INVALID_REFERENCE", [...path, "ref"]);
+  const refPath = [...path, "ref"];
+  const raw = properties.ref;
+  const codec = state.options.reference;
+  if (!codec && typeof raw === "string" && exceedsStringLimit(raw, state.limits.maxReferenceLength)) {
+    throw new ExpressionFailure("EXPRESSION_LIMIT_EXCEEDED", refPath);
+  }
+  const cloned = cloneReference(raw, refPath, depth + 1, state);
+  if (codec ? !safeValidate(codec.validate, cloned) : !defaultReference(cloned)) {
+    throw new ExpressionFailure("EXPRESSION_INVALID_REFERENCE", refPath);
+  }
+  if (referenceExceedsLength(cloned, state.limits.maxReferenceLength)) {
+    throw new ExpressionFailure("EXPRESSION_LIMIT_EXCEEDED", refPath);
+  }
+  if (!codec?.canonicalize) return Object.freeze({ kind: "ref", ref: cloned });
+  const replacement = canonicalReferenceValue(cloned, codec.canonicalize, refPath);
+  const output = cloneReference(replacement, refPath, depth + 1, state);
+  if (!safeValidate(codec.validate, output))
+    throw new ExpressionFailure("EXPRESSION_INVALID_REFERENCE", refPath);
+  if (referenceExceedsLength(output, state.limits.maxReferenceLength)) {
+    throw new ExpressionFailure("EXPRESSION_LIMIT_EXCEEDED", refPath);
+  }
+  return Object.freeze({ kind: "ref", ref: output });
+}
+function cloneReference(input, path, depth, state) {
+  try {
+    return cloneJson(input, path, depth, state);
+  } catch (error) {
+    if (error instanceof ExpressionFailure && error.code === "EXPRESSION_LIMIT_EXCEEDED")
+      throw error;
+    throw new ExpressionFailure("EXPRESSION_INVALID_REFERENCE", path);
+  }
+}
+function safeValidate(validate, input) {
+  try {
+    return validate(input) === true;
+  } catch {
+    return false;
+  }
+}
+function defaultReference(input) {
+  return typeof input === "string" && input.length > 0;
+}
+function canonicalReferenceValue(reference, canonicalize, path) {
+  try {
+    return canonicalize(reference);
+  } catch {
+    throw new ExpressionFailure("EXPRESSION_INVALID_REFERENCE", path);
+  }
+}
+function canonicalOperator(properties, path, depth, state) {
+  if (typeof properties.op !== "string" || !Array.isArray(properties.args)) {
+    throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", path);
+  }
+  if (properties.op.length === 0 || exceedsStringLimit(properties.op, state.limits.maxStringLength)) {
+    throw new ExpressionFailure("EXPRESSION_LIMIT_EXCEEDED", [...path, "op"]);
+  }
+  const args = canonicalArgs(properties.args, path, depth, state);
+  return Object.freeze({ kind: "op", op: properties.op, args });
+}
+function canonicalArgs(input, path, depth, state) {
+  const argsPath = [...path, "args"];
+  const length = arrayLength(input, argsPath);
+  if (length > state.limits.maxArgs || length > state.maxNodes - state.nodes) {
+    throw new ExpressionFailure("EXPRESSION_LIMIT_EXCEEDED", argsPath);
+  }
+  validateArrayKeys(input, argsPath, length);
+  const output = [];
+  for (let index = 0; index < length; index += 1) {
+    const descriptor = arrayElement(input, index, argsPath);
+    output.push(canonicalizeNode(descriptor.value, [...argsPath, index], depth + 1, state));
+  }
+  return Object.freeze(output);
+}
+function validateArrayKeys(input, path, length) {
+  try {
+    const keys = Reflect.ownKeys(input);
+    if (keys.length !== length + 1) throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", path);
+  } catch (error) {
+    if (error instanceof ExpressionFailure) throw error;
+    throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", path);
+  }
+}
+function arrayElement(input, index, path) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(input, String(index));
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+      throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", [...path, index]);
+    }
+    return descriptor;
+  } catch (error) {
+    if (error instanceof ExpressionFailure) throw error;
+    throw new ExpressionFailure("EXPRESSION_INVALID_INPUT", [...path, index]);
+  }
+}
+function referenceIdentity(reference) {
+  return stableJson(reference);
+}
+function referenceExceedsLength(reference, maxLength) {
+  return typeof reference === "string" ? exceedsStringLimit(reference, maxLength) : stableJson(reference).length > maxLength;
+}
+
+export { canonicalizeExpression, referenceIdentity };
+//# sourceMappingURL=canonicalize.js.map
+//# sourceMappingURL=canonicalize.js.map

package/dist/kuery-v1/canonicalize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kuery-v1/canonicalize.ts"],"names":[],"mappings":"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","file":"canonicalize.js","sourcesContent":["import {\n  arrayLength,\n  cloneJson,\n  dataProperties,\n  exceedsStringLimit,\n  stableJson,\n  type ValidationState,\n} from \"./inspect.js\";\nimport { resolveLimits } from \"./limits.js\";\nimport { ExpressionFailure, failure, success } from \"./result.js\";\nimport type {\n  CanonicalizeExpressionOptions,\n  ExpressionLimits,\n  ExpressionPath,\n  JsonValue,\n  Result,\n  ValueExpression,\n} from \"./types.js\";\n\nconst NODE_KEYS = Object.freeze({\n  literal: new Set([\"kind\", \"value\"]),\n  ref: new Set([\"kind\", \"ref\"]),\n  op: new Set([\"kind\", \"op\", \"args\"]),\n});\nconst ALL_NODE_KEYS = new Set([\"kind\", \"value\", \"ref\", \"op\", \"args\"]);\n\ninterface CanonicalState<R extends JsonValue> extends ValidationState {\n  readonly limits: ExpressionLimits;\n  readonly options: CanonicalizeExpressionOptions<R>;\n}\n\n/** Validate unknown input and return a deeply frozen, canonical expression snapshot. */\nexport function canonicalizeExpression<R extends JsonValue = string>(\n  input: unknown,\n  options: CanonicalizeExpressionOptions<R> = {},\n): Result<ValueExpression<R>> {\n  let limits: ExpressionLimits;\n  try {\n    limits = resolveLimits(options.limits);\n  } catch {\n    return failure(\"EXPRESSION_LIMIT_EXCEEDED\", []);\n  }\n  const state: CanonicalState<R> = {\n    limits,\n    options,\n    maxDepth: limits.maxDepth,\n    maxNodes: limits.maxNodes,\n    maxStringLength: limits.maxStringLength,\n    nodes: 0,\n    active: new WeakSet(),\n  };\n  try {\n    return success(canonicalizeNode(input, [], 0, state));\n  } catch (error) {\n    const problem =\n      error instanceof ExpressionFailure\n        ? error\n        : new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", []);\n    return failure(problem.code, problem.expressionPath);\n  }\n}\n\nfunction canonicalizeNode<R extends JsonValue>(\n  input: unknown,\n  path: ExpressionPath,\n  depth: number,\n  state: CanonicalState<R>,\n): ValueExpression<R> {\n  countNode(path, depth, state);\n  if (typeof input !== \"object\" || input === null)\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", path);\n  if (state.active.has(input)) throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", path);\n  state.active.add(input);\n  try {\n    const initial = dataProperties(input, path, ALL_NODE_KEYS, 3);\n    const kind = initial.kind;\n    if (kind !== \"literal\" && kind !== \"ref\" && kind !== \"op\") {\n      throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", [...path, \"kind\"]);\n    }\n    const properties = selectNodeProperties(initial, path, NODE_KEYS[kind]);\n    if (kind === \"literal\") return canonicalLiteral(properties, path, depth, state);\n    if (kind === \"ref\") return canonicalReference(properties, path, depth, state);\n    return canonicalOperator(properties, path, depth, state);\n  } finally {\n    state.active.delete(input);\n  }\n}\n\nfunction selectNodeProperties(\n  properties: Readonly<Record<string, unknown>>,\n  path: ExpressionPath,\n  allowed: ReadonlySet<string>,\n): Readonly<Record<string, unknown>> {\n  for (const key of Object.keys(properties)) {\n    if (!allowed.has(key)) throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", [...path, key]);\n  }\n  return properties;\n}\n\nfunction countNode(\n  path: ExpressionPath,\n  depth: number,\n  state: ValidationState & { readonly limits: ExpressionLimits },\n): void {\n  state.nodes += 1;\n  if (depth > state.limits.maxDepth || state.nodes > state.limits.maxNodes) {\n    throw new ExpressionFailure(\"EXPRESSION_LIMIT_EXCEEDED\", path);\n  }\n}\n\nfunction canonicalLiteral<R extends JsonValue>(\n  properties: Readonly<Record<string, unknown>>,\n  path: ExpressionPath,\n  depth: number,\n  state: CanonicalState<R>,\n): ValueExpression<R> {\n  if (!(\"value\" in properties))\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", [...path, \"value\"]);\n  const value = cloneJson(properties.value, [...path, \"value\"], depth + 1, state);\n  return Object.freeze({ kind: \"literal\", value });\n}\n\nfunction canonicalReference<R extends JsonValue>(\n  properties: Readonly<Record<string, unknown>>,\n  path: ExpressionPath,\n  depth: number,\n  state: CanonicalState<R>,\n): ValueExpression<R> {\n  if (!(\"ref\" in properties))\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_REFERENCE\", [...path, \"ref\"]);\n  const refPath = [...path, \"ref\"];\n  const raw = properties.ref;\n  const codec = state.options.reference;\n  if (\n    !codec &&\n    typeof raw === \"string\" &&\n    exceedsStringLimit(raw, state.limits.maxReferenceLength)\n  ) {\n    throw new ExpressionFailure(\"EXPRESSION_LIMIT_EXCEEDED\", refPath);\n  }\n  const cloned = cloneReference<R>(raw, refPath, depth + 1, state);\n  if (codec ? !safeValidate(codec.validate, cloned) : !defaultReference(cloned)) {\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_REFERENCE\", refPath);\n  }\n  if (referenceExceedsLength(cloned, state.limits.maxReferenceLength)) {\n    throw new ExpressionFailure(\"EXPRESSION_LIMIT_EXCEEDED\", refPath);\n  }\n  if (!codec?.canonicalize) return Object.freeze({ kind: \"ref\", ref: cloned });\n  const replacement = canonicalReferenceValue(cloned, codec.canonicalize, refPath);\n  const output = cloneReference<R>(replacement, refPath, depth + 1, state);\n  if (!safeValidate(codec.validate, output))\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_REFERENCE\", refPath);\n  if (referenceExceedsLength(output, state.limits.maxReferenceLength)) {\n    throw new ExpressionFailure(\"EXPRESSION_LIMIT_EXCEEDED\", refPath);\n  }\n  return Object.freeze({ kind: \"ref\", ref: output });\n}\n\nfunction cloneReference<R extends JsonValue>(\n  input: unknown,\n  path: ExpressionPath,\n  depth: number,\n  state: CanonicalState<R>,\n): R {\n  try {\n    return cloneJson(input, path, depth, state) as R;\n  } catch (error) {\n    if (error instanceof ExpressionFailure && error.code === \"EXPRESSION_LIMIT_EXCEEDED\")\n      throw error;\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_REFERENCE\", path);\n  }\n}\n\nfunction safeValidate<R>(validate: (input: unknown) => input is R, input: unknown): input is R {\n  try {\n    return validate(input) === true;\n  } catch {\n    return false;\n  }\n}\n\nfunction defaultReference(input: unknown): input is string {\n  return typeof input === \"string\" && input.length > 0;\n}\n\nfunction canonicalReferenceValue<R extends JsonValue>(\n  reference: R,\n  canonicalize: (reference: R) => R,\n  path: ExpressionPath,\n): R {\n  try {\n    return canonicalize(reference);\n  } catch {\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_REFERENCE\", path);\n  }\n}\n\nfunction canonicalOperator<R extends JsonValue>(\n  properties: Readonly<Record<string, unknown>>,\n  path: ExpressionPath,\n  depth: number,\n  state: CanonicalState<R>,\n): ValueExpression<R> {\n  if (typeof properties.op !== \"string\" || !Array.isArray(properties.args)) {\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", path);\n  }\n  if (\n    properties.op.length === 0 ||\n    exceedsStringLimit(properties.op, state.limits.maxStringLength)\n  ) {\n    throw new ExpressionFailure(\"EXPRESSION_LIMIT_EXCEEDED\", [...path, \"op\"]);\n  }\n  const args = canonicalArgs(properties.args, path, depth, state);\n  return Object.freeze({ kind: \"op\", op: properties.op, args });\n}\n\nfunction canonicalArgs<R extends JsonValue>(\n  input: unknown[],\n  path: ExpressionPath,\n  depth: number,\n  state: CanonicalState<R>,\n): readonly ValueExpression<R>[] {\n  const argsPath = [...path, \"args\"];\n  const length = arrayLength(input, argsPath);\n  if (length > state.limits.maxArgs || length > state.maxNodes - state.nodes) {\n    throw new ExpressionFailure(\"EXPRESSION_LIMIT_EXCEEDED\", argsPath);\n  }\n  validateArrayKeys(input, argsPath, length);\n  const output: ValueExpression<R>[] = [];\n  for (let index = 0; index < length; index += 1) {\n    const descriptor = arrayElement(input, index, argsPath);\n    output.push(canonicalizeNode(descriptor.value, [...argsPath, index], depth + 1, state));\n  }\n  return Object.freeze(output);\n}\n\nfunction validateArrayKeys(input: unknown[], path: ExpressionPath, length: number): void {\n  try {\n    const keys = Reflect.ownKeys(input);\n    if (keys.length !== length + 1) throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", path);\n  } catch (error) {\n    if (error instanceof ExpressionFailure) throw error;\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", path);\n  }\n}\n\nfunction arrayElement(\n  input: unknown[],\n  index: number,\n  path: ExpressionPath,\n): PropertyDescriptor & { value: unknown } {\n  try {\n    const descriptor = Object.getOwnPropertyDescriptor(input, String(index));\n    if (!descriptor || !(\"value\" in descriptor) || !descriptor.enumerable) {\n      throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", [...path, index]);\n    }\n    return descriptor as PropertyDescriptor & { value: unknown };\n  } catch (error) {\n    if (error instanceof ExpressionFailure) throw error;\n    throw new ExpressionFailure(\"EXPRESSION_INVALID_INPUT\", [...path, index]);\n  }\n}\n\nexport function referenceIdentity(reference: JsonValue): string {\n  return stableJson(reference);\n}\n\nfunction referenceExceedsLength(reference: JsonValue, maxLength: number): boolean {\n  return typeof reference === \"string\"\n    ? exceedsStringLimit(reference, maxLength)\n    : stableJson(reference).length > maxLength;\n}\n"]}

package/dist/kuery-v1/compile.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var canonicalize_js = require('./canonicalize.js');
+var dependencies_js = require('./dependencies.js');
+var evaluate_js = require('./evaluate.js');
+var limits_js = require('./limits.js');
+var profile_js = require('./profile.js');
+var result_js = require('./result.js');
+
+function compileExpression(input, options) {
+  if (!options || !(options.profile instanceof profile_js.ExpressionProfile))
+    return result_js.failure("EXPRESSION_INVALID_INPUT", []);
+  const canonical = canonicalize_js.canonicalizeExpression(input, options);
+  if (!canonical.ok) return canonical;
+  const operators = /* @__PURE__ */ new Map();
+  const validation = validateOperators(canonical.value, options.profile, [], operators);
+  if (!validation.ok) return validation;
+  let limits;
+  try {
+    limits = limits_js.resolveLimits(options.limits);
+  } catch {
+    return result_js.failure("EXPRESSION_LIMIT_EXCEEDED", []);
+  }
+  const expression = canonical.value;
+  const dependencies = dependencies_js.collectExpressionDependencies(expression);
+  const compiled = {
+    expression,
+    dependencies,
+    evaluate: (resolve) => evaluate_js.evaluateCompiled(expression, resolve, operators, limits)
+  };
+  return result_js.success(Object.freeze(compiled));
+}
+function validateOperators(node, profile, path, output) {
+  if (node.kind !== "op") return result_js.success(void 0);
+  const operator = profile.get(node.op);
+  if (!operator) return result_js.failure("EXPRESSION_UNKNOWN_OPERATOR", [...path, "op"]);
+  if (!validArity(operator, node.args.length))
+    return result_js.failure("EXPRESSION_INVALID_ARITY", [...path, "args"]);
+  output.set(node, operator);
+  for (let index = 0; index < node.args.length; index += 1) {
+    const result = validateOperators(node.args[index], profile, [...path, "args", index], output);
+    if (!result.ok) return result;
+  }
+  return result_js.success(void 0);
+}
+function validArity(operator, length) {
+  if (operator.arity !== void 0) return length === operator.arity;
+  return length >= (operator.minArgs ?? 0) && length <= (operator.maxArgs ?? profile_js.MAX_EXPRESSION_OPERATOR_ARGS);
+}
+
+exports.compileExpression = compileExpression;
+//# sourceMappingURL=compile.cjs.map
+//# sourceMappingURL=compile.cjs.map

package/dist/kuery-v1/compile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kuery-v1/compile.ts"],"names":["ExpressionProfile","failure","canonicalizeExpression","resolveLimits","collectExpressionDependencies","evaluateCompiled","success","MAX_EXPRESSION_OPERATOR_ARGS"],"mappings":";;;;;;;;;AA0BO,SAAS,iBAAA,CACd,OACA,OAAA,EAC+B;AAC/B,EAAA,IAAI,CAAC,OAAA,IAAW,EAAE,OAAA,CAAQ,OAAA,YAAmBA,4BAAA,CAAA;AAC3C,IAAA,OAAOC,iBAAA,CAAQ,0BAAA,EAA4B,EAAE,CAAA;AAC/C,EAAA,MAAM,SAAA,GAAYC,sCAAA,CAA0B,KAAA,EAAO,OAAO,CAAA;AAC1D,EAAA,IAAI,CAAC,SAAA,CAAU,EAAA,EAAI,OAAO,SAAA;AAC1B,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAA4C;AAClE,EAAA,MAAM,UAAA,GAAa,kBAAkB,SAAA,CAAU,KAAA,EAAO,QAAQ,OAAA,EAAS,IAAI,SAAS,CAAA;AACpF,EAAA,IAAI,CAAC,UAAA,CAAW,EAAA,EAAI,OAAO,UAAA;AAC3B,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI;AACF,IAAA,MAAA,GAASC,uBAAA,CAAc,QAAQ,MAAM,CAAA;AAAA,EACvC,CAAA,CAAA,MAAQ;AACN,IAAA,OAAOF,iBAAA,CAAQ,2BAAA,EAA6B,EAAE,CAAA;AAAA,EAChD;AACA,EAAA,MAAM,aAAa,SAAA,CAAU,KAAA;AAC7B,EAAA,MAAM,YAAA,GAAeG,8CAA8B,UAAU,CAAA;AAC7D,EAAA,MAAM,QAAA,GAAkC;AAAA,IACtC,UAAA;AAAA,IACA,YAAA;AAAA,IACA,UAAU,CAAC,OAAA,KAAYC,6BAAiB,UAAA,EAAY,OAAA,EAAS,WAAW,MAAM;AAAA,GAChF;AACA,EAAA,OAAOC,iBAAA,CAAQ,MAAA,CAAO,MAAA,CAAO,QAAQ,CAAC,CAAA;AACxC;AAEA,SAAS,iBAAA,CACP,IAAA,EACA,OAAA,EACA,IAAA,EACA,MAAA,EACmB;AACnB,EAAA,IAAI,IAAA,CAAK,IAAA,KAAS,IAAA,EAAM,OAAOA,kBAAQ,MAAS,CAAA;AAChD,EAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AACpC,EAAA,IAAI,CAAC,UAAU,OAAOL,iBAAA,CAAQ,+BAA+B,CAAC,GAAG,IAAA,EAAM,IAAI,CAAC,CAAA;AAC5E,EAAA,IAAI,CAAC,UAAA,CAAW,QAAA,EAAU,IAAA,CAAK,KAAK,MAAM,CAAA;AACxC,IAAA,OAAOA,kBAAQ,0BAAA,EAA4B,CAAC,GAAG,IAAA,EAAM,MAAM,CAAC,CAAA;AAC9D,EAAA,MAAA,CAAO,GAAA,CAAI,MAAM,QAAQ,CAAA;AACzB,EAAA,KAAA,IAAS,QAAQ,CAAA,EAAG,KAAA,GAAQ,KAAK,IAAA,CAAK,MAAA,EAAQ,SAAS,CAAA,EAAG;AACxD,IAAA,MAAM,MAAA,GAAS,iBAAA,CAAkB,IAAA,CAAK,IAAA,CAAK,KAAK,CAAA,EAAI,OAAA,EAAS,CAAC,GAAG,IAAA,EAAM,MAAA,EAAQ,KAAK,GAAG,MAAM,CAAA;AAC7F,IAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,OAAO,MAAA;AAAA,EACzB;AACA,EAAA,OAAOK,kBAAQ,MAAS,CAAA;AAC1B;AAEA,SAAS,UAAA,CAAW,UAA8B,MAAA,EAAyB;AACzE,EAAA,IAAI,QAAA,CAAS,KAAA,KAAU,MAAA,EAAW,OAAO,WAAW,QAAA,CAAS,KAAA;AAC7D,EAAA,OACE,WAAW,QAAA,CAAS,OAAA,IAAW,CAAA,CAAA,IAC/B,MAAA,KAAW,SAAS,OAAA,IAAWC,uCAAA,CAAA;AAEnC","file":"compile.cjs","sourcesContent":["import { canonicalizeExpression } from \"./canonicalize.js\";\nimport { collectExpressionDependencies } from \"./dependencies.js\";\nimport { evaluateCompiled } from \"./evaluate.js\";\nimport { resolveLimits } from \"./limits.js\";\nimport {\n  type ExpressionOperator,\n  ExpressionProfile,\n  MAX_EXPRESSION_OPERATOR_ARGS,\n} from \"./profile.js\";\nimport { failure, success } from \"./result.js\";\nimport type {\n  CanonicalizeExpressionOptions,\n  CompiledExpression,\n  ExpressionLimits,\n  ExpressionPath,\n  JsonValue,\n  Result,\n  ValueExpression,\n} from \"./types.js\";\n\nexport interface CompileExpressionOptions<R extends JsonValue>\n  extends CanonicalizeExpressionOptions<R> {\n  readonly profile: ExpressionProfile;\n}\n\n/** Compile and validate a complete expression against one structurally immutable profile. */\nexport function compileExpression<R extends JsonValue = string>(\n  input: unknown,\n  options: CompileExpressionOptions<R>,\n): Result<CompiledExpression<R>> {\n  if (!options || !(options.profile instanceof ExpressionProfile))\n    return failure(\"EXPRESSION_INVALID_INPUT\", []);\n  const canonical = canonicalizeExpression<R>(input, options);\n  if (!canonical.ok) return canonical;\n  const operators = new Map<ValueExpression<R>, ExpressionOperator>();\n  const validation = validateOperators(canonical.value, options.profile, [], operators);\n  if (!validation.ok) return validation;\n  let limits: ExpressionLimits;\n  try {\n    limits = resolveLimits(options.limits);\n  } catch {\n    return failure(\"EXPRESSION_LIMIT_EXCEEDED\", []);\n  }\n  const expression = canonical.value;\n  const dependencies = collectExpressionDependencies(expression);\n  const compiled: CompiledExpression<R> = {\n    expression,\n    dependencies,\n    evaluate: (resolve) => evaluateCompiled(expression, resolve, operators, limits),\n  };\n  return success(Object.freeze(compiled));\n}\n\nfunction validateOperators<R extends JsonValue>(\n  node: ValueExpression<R>,\n  profile: ExpressionProfile,\n  path: ExpressionPath,\n  output: Map<ValueExpression<R>, ExpressionOperator>,\n): Result<undefined> {\n  if (node.kind !== \"op\") return success(undefined);\n  const operator = profile.get(node.op);\n  if (!operator) return failure(\"EXPRESSION_UNKNOWN_OPERATOR\", [...path, \"op\"]);\n  if (!validArity(operator, node.args.length))\n    return failure(\"EXPRESSION_INVALID_ARITY\", [...path, \"args\"]);\n  output.set(node, operator);\n  for (let index = 0; index < node.args.length; index += 1) {\n    const result = validateOperators(node.args[index]!, profile, [...path, \"args\", index], output);\n    if (!result.ok) return result;\n  }\n  return success(undefined);\n}\n\nfunction validArity(operator: ExpressionOperator, length: number): boolean {\n  if (operator.arity !== undefined) return length === operator.arity;\n  return (\n    length >= (operator.minArgs ?? 0) &&\n    length <= (operator.maxArgs ?? MAX_EXPRESSION_OPERATOR_ARGS)\n  );\n}\n"]}

package/dist/kuery-v1/compile.d.cts

@@ -0,0 +1,10 @@
+import { ExpressionProfile } from './profile.cjs';
+import { JsonValue, CanonicalizeExpressionOptions, Result, CompiledExpression } from './types.cjs';
+
+interface CompileExpressionOptions<R extends JsonValue> extends CanonicalizeExpressionOptions<R> {
+    readonly profile: ExpressionProfile;
+}
+/** Compile and validate a complete expression against one structurally immutable profile. */
+declare function compileExpression<R extends JsonValue = string>(input: unknown, options: CompileExpressionOptions<R>): Result<CompiledExpression<R>>;
+
+export { type CompileExpressionOptions, compileExpression };

package/dist/kuery-v1/compile.d.ts

@@ -0,0 +1,10 @@
+import { ExpressionProfile } from './profile.js';
+import { JsonValue, CanonicalizeExpressionOptions, Result, CompiledExpression } from './types.js';
+
+interface CompileExpressionOptions<R extends JsonValue> extends CanonicalizeExpressionOptions<R> {
+    readonly profile: ExpressionProfile;
+}
+/** Compile and validate a complete expression against one structurally immutable profile. */
+declare function compileExpression<R extends JsonValue = string>(input: unknown, options: CompileExpressionOptions<R>): Result<CompiledExpression<R>>;
+
+export { type CompileExpressionOptions, compileExpression };

package/dist/kuery-v1/compile.js

@@ -0,0 +1,51 @@
+import { canonicalizeExpression } from './canonicalize.js';
+import { collectExpressionDependencies } from './dependencies.js';
+import { evaluateCompiled } from './evaluate.js';
+import { resolveLimits } from './limits.js';
+import { ExpressionProfile, MAX_EXPRESSION_OPERATOR_ARGS } from './profile.js';
+import { failure, success } from './result.js';
+
+function compileExpression(input, options) {
+  if (!options || !(options.profile instanceof ExpressionProfile))
+    return failure("EXPRESSION_INVALID_INPUT", []);
+  const canonical = canonicalizeExpression(input, options);
+  if (!canonical.ok) return canonical;
+  const operators = /* @__PURE__ */ new Map();
+  const validation = validateOperators(canonical.value, options.profile, [], operators);
+  if (!validation.ok) return validation;
+  let limits;
+  try {
+    limits = resolveLimits(options.limits);
+  } catch {
+    return failure("EXPRESSION_LIMIT_EXCEEDED", []);
+  }
+  const expression = canonical.value;
+  const dependencies = collectExpressionDependencies(expression);
+  const compiled = {
+    expression,
+    dependencies,
+    evaluate: (resolve) => evaluateCompiled(expression, resolve, operators, limits)
+  };
+  return success(Object.freeze(compiled));
+}
+function validateOperators(node, profile, path, output) {
+  if (node.kind !== "op") return success(void 0);
+  const operator = profile.get(node.op);
+  if (!operator) return failure("EXPRESSION_UNKNOWN_OPERATOR", [...path, "op"]);
+  if (!validArity(operator, node.args.length))
+    return failure("EXPRESSION_INVALID_ARITY", [...path, "args"]);
+  output.set(node, operator);
+  for (let index = 0; index < node.args.length; index += 1) {
+    const result = validateOperators(node.args[index], profile, [...path, "args", index], output);
+    if (!result.ok) return result;
+  }
+  return success(void 0);
+}
+function validArity(operator, length) {
+  if (operator.arity !== void 0) return length === operator.arity;
+  return length >= (operator.minArgs ?? 0) && length <= (operator.maxArgs ?? MAX_EXPRESSION_OPERATOR_ARGS);
+}
+
+export { compileExpression };
+//# sourceMappingURL=compile.js.map
+//# sourceMappingURL=compile.js.map

package/dist/kuery-v1/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kuery-v1/compile.ts"],"names":[],"mappings":";;;;;;;AA0BO,SAAS,iBAAA,CACd,OACA,OAAA,EAC+B;AAC/B,EAAA,IAAI,CAAC,OAAA,IAAW,EAAE,OAAA,CAAQ,OAAA,YAAmB,iBAAA,CAAA;AAC3C,IAAA,OAAO,OAAA,CAAQ,0BAAA,EAA4B,EAAE,CAAA;AAC/C,EAAA,MAAM,SAAA,GAAY,sBAAA,CAA0B,KAAA,EAAO,OAAO,CAAA;AAC1D,EAAA,IAAI,CAAC,SAAA,CAAU,EAAA,EAAI,OAAO,SAAA;AAC1B,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAA4C;AAClE,EAAA,MAAM,UAAA,GAAa,kBAAkB,SAAA,CAAU,KAAA,EAAO,QAAQ,OAAA,EAAS,IAAI,SAAS,CAAA;AACpF,EAAA,IAAI,CAAC,UAAA,CAAW,EAAA,EAAI,OAAO,UAAA;AAC3B,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI;AACF,IAAA,MAAA,GAAS,aAAA,CAAc,QAAQ,MAAM,CAAA;AAAA,EACvC,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,OAAA,CAAQ,2BAAA,EAA6B,EAAE,CAAA;AAAA,EAChD;AACA,EAAA,MAAM,aAAa,SAAA,CAAU,KAAA;AAC7B,EAAA,MAAM,YAAA,GAAe,8BAA8B,UAAU,CAAA;AAC7D,EAAA,MAAM,QAAA,GAAkC;AAAA,IACtC,UAAA;AAAA,IACA,YAAA;AAAA,IACA,UAAU,CAAC,OAAA,KAAY,iBAAiB,UAAA,EAAY,OAAA,EAAS,WAAW,MAAM;AAAA,GAChF;AACA,EAAA,OAAO,OAAA,CAAQ,MAAA,CAAO,MAAA,CAAO,QAAQ,CAAC,CAAA;AACxC;AAEA,SAAS,iBAAA,CACP,IAAA,EACA,OAAA,EACA,IAAA,EACA,MAAA,EACmB;AACnB,EAAA,IAAI,IAAA,CAAK,IAAA,KAAS,IAAA,EAAM,OAAO,QAAQ,MAAS,CAAA;AAChD,EAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AACpC,EAAA,IAAI,CAAC,UAAU,OAAO,OAAA,CAAQ,+BAA+B,CAAC,GAAG,IAAA,EAAM,IAAI,CAAC,CAAA;AAC5E,EAAA,IAAI,CAAC,UAAA,CAAW,QAAA,EAAU,IAAA,CAAK,KAAK,MAAM,CAAA;AACxC,IAAA,OAAO,QAAQ,0BAAA,EAA4B,CAAC,GAAG,IAAA,EAAM,MAAM,CAAC,CAAA;AAC9D,EAAA,MAAA,CAAO,GAAA,CAAI,MAAM,QAAQ,CAAA;AACzB,EAAA,KAAA,IAAS,QAAQ,CAAA,EAAG,KAAA,GAAQ,KAAK,IAAA,CAAK,MAAA,EAAQ,SAAS,CAAA,EAAG;AACxD,IAAA,MAAM,MAAA,GAAS,iBAAA,CAAkB,IAAA,CAAK,IAAA,CAAK,KAAK,CAAA,EAAI,OAAA,EAAS,CAAC,GAAG,IAAA,EAAM,MAAA,EAAQ,KAAK,GAAG,MAAM,CAAA;AAC7F,IAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,OAAO,MAAA;AAAA,EACzB;AACA,EAAA,OAAO,QAAQ,MAAS,CAAA;AAC1B;AAEA,SAAS,UAAA,CAAW,UAA8B,MAAA,EAAyB;AACzE,EAAA,IAAI,QAAA,CAAS,KAAA,KAAU,MAAA,EAAW,OAAO,WAAW,QAAA,CAAS,KAAA;AAC7D,EAAA,OACE,WAAW,QAAA,CAAS,OAAA,IAAW,CAAA,CAAA,IAC/B,MAAA,KAAW,SAAS,OAAA,IAAW,4BAAA,CAAA;AAEnC","file":"compile.js","sourcesContent":["import { canonicalizeExpression } from \"./canonicalize.js\";\nimport { collectExpressionDependencies } from \"./dependencies.js\";\nimport { evaluateCompiled } from \"./evaluate.js\";\nimport { resolveLimits } from \"./limits.js\";\nimport {\n  type ExpressionOperator,\n  ExpressionProfile,\n  MAX_EXPRESSION_OPERATOR_ARGS,\n} from \"./profile.js\";\nimport { failure, success } from \"./result.js\";\nimport type {\n  CanonicalizeExpressionOptions,\n  CompiledExpression,\n  ExpressionLimits,\n  ExpressionPath,\n  JsonValue,\n  Result,\n  ValueExpression,\n} from \"./types.js\";\n\nexport interface CompileExpressionOptions<R extends JsonValue>\n  extends CanonicalizeExpressionOptions<R> {\n  readonly profile: ExpressionProfile;\n}\n\n/** Compile and validate a complete expression against one structurally immutable profile. */\nexport function compileExpression<R extends JsonValue = string>(\n  input: unknown,\n  options: CompileExpressionOptions<R>,\n): Result<CompiledExpression<R>> {\n  if (!options || !(options.profile instanceof ExpressionProfile))\n    return failure(\"EXPRESSION_INVALID_INPUT\", []);\n  const canonical = canonicalizeExpression<R>(input, options);\n  if (!canonical.ok) return canonical;\n  const operators = new Map<ValueExpression<R>, ExpressionOperator>();\n  const validation = validateOperators(canonical.value, options.profile, [], operators);\n  if (!validation.ok) return validation;\n  let limits: ExpressionLimits;\n  try {\n    limits = resolveLimits(options.limits);\n  } catch {\n    return failure(\"EXPRESSION_LIMIT_EXCEEDED\", []);\n  }\n  const expression = canonical.value;\n  const dependencies = collectExpressionDependencies(expression);\n  const compiled: CompiledExpression<R> = {\n    expression,\n    dependencies,\n    evaluate: (resolve) => evaluateCompiled(expression, resolve, operators, limits),\n  };\n  return success(Object.freeze(compiled));\n}\n\nfunction validateOperators<R extends JsonValue>(\n  node: ValueExpression<R>,\n  profile: ExpressionProfile,\n  path: ExpressionPath,\n  output: Map<ValueExpression<R>, ExpressionOperator>,\n): Result<undefined> {\n  if (node.kind !== \"op\") return success(undefined);\n  const operator = profile.get(node.op);\n  if (!operator) return failure(\"EXPRESSION_UNKNOWN_OPERATOR\", [...path, \"op\"]);\n  if (!validArity(operator, node.args.length))\n    return failure(\"EXPRESSION_INVALID_ARITY\", [...path, \"args\"]);\n  output.set(node, operator);\n  for (let index = 0; index < node.args.length; index += 1) {\n    const result = validateOperators(node.args[index]!, profile, [...path, \"args\", index], output);\n    if (!result.ok) return result;\n  }\n  return success(undefined);\n}\n\nfunction validArity(operator: ExpressionOperator, length: number): boolean {\n  if (operator.arity !== undefined) return length === operator.arity;\n  return (\n    length >= (operator.minArgs ?? 0) &&\n    length <= (operator.maxArgs ?? MAX_EXPRESSION_OPERATOR_ARGS)\n  );\n}\n"]}

package/dist/kuery-v1/dependencies.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var canonicalize_js = require('./canonicalize.js');
+var result_js = require('./result.js');
+
+function extractExpressionDependencies(input, options = {}) {
+  const canonical = canonicalize_js.canonicalizeExpression(input, options);
+  if (!canonical.ok) return canonical;
+  return result_js.success(collectExpressionDependencies(canonical.value));
+}
+function collectExpressionDependencies(expression) {
+  const dependencies = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node.kind === "ref") {
+      const identity = canonicalize_js.referenceIdentity(node.ref);
+      if (!seen.has(identity)) {
+        seen.add(identity);
+        dependencies.push(node.ref);
+      }
+      return;
+    }
+    if (node.kind === "op") node.args.forEach(visit);
+  };
+  visit(expression);
+  return Object.freeze(dependencies);
+}
+
+exports.collectExpressionDependencies = collectExpressionDependencies;
+exports.extractExpressionDependencies = extractExpressionDependencies;
+//# sourceMappingURL=dependencies.cjs.map
+//# sourceMappingURL=dependencies.cjs.map

package/dist/kuery-v1/dependencies.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kuery-v1/dependencies.ts"],"names":["canonicalizeExpression","success","referenceIdentity"],"mappings":";;;;;AAKO,SAAS,6BAAA,CACd,KAAA,EACA,OAAA,GAA4C,EAAC,EACvB;AACtB,EAAA,MAAM,SAAA,GAAYA,sCAAA,CAA0B,KAAA,EAAO,OAAO,CAAA;AAC1D,EAAA,IAAI,CAAC,SAAA,CAAU,EAAA,EAAI,OAAO,SAAA;AAC1B,EAAA,OAAOC,iBAAA,CAAQ,6BAAA,CAA8B,SAAA,CAAU,KAAK,CAAC,CAAA;AAC/D;AAEO,SAAS,8BACd,UAAA,EACc;AACd,EAAA,MAAM,eAAoB,EAAC;AAC3B,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAC7B,EAAA,MAAM,KAAA,GAAQ,CAAC,IAAA,KAAmC;AAChD,IAAA,IAAI,IAAA,CAAK,SAAS,KAAA,EAAO;AACvB,MAAA,MAAM,QAAA,GAAWC,iCAAA,CAAkB,IAAA,CAAK,GAAG,CAAA;AAC3C,MAAA,IAAI,CAAC,IAAA,CAAK,GAAA,CAAI,QAAQ,CAAA,EAAG;AACvB,QAAA,IAAA,CAAK,IAAI,QAAQ,CAAA;AACjB,QAAA,YAAA,CAAa,IAAA,CAAK,KAAK,GAAG,CAAA;AAAA,MAC5B;AACA,MAAA;AAAA,IACF;AACA,IAAA,IAAI,KAAK,IAAA,KAAS,IAAA,EAAM,IAAA,CAAK,IAAA,CAAK,QAAQ,KAAK,CAAA;AAAA,EACjD,CAAA;AACA,EAAA,KAAA,CAAM,UAAU,CAAA;AAChB,EAAA,OAAO,MAAA,CAAO,OAAO,YAAY,CAAA;AACnC","file":"dependencies.cjs","sourcesContent":["import { canonicalizeExpression, referenceIdentity } from \"./canonicalize.js\";\nimport { success } from \"./result.js\";\nimport type { CanonicalizeExpressionOptions, JsonValue, Result, ValueExpression } from \"./types.js\";\n\n/** Extract canonical references in first-seen AST order, deduplicated by structural JSON equality. */\nexport function extractExpressionDependencies<R extends JsonValue = string>(\n  input: unknown,\n  options: CanonicalizeExpressionOptions<R> = {},\n): Result<readonly R[]> {\n  const canonical = canonicalizeExpression<R>(input, options);\n  if (!canonical.ok) return canonical;\n  return success(collectExpressionDependencies(canonical.value));\n}\n\nexport function collectExpressionDependencies<R extends JsonValue>(\n  expression: ValueExpression<R>,\n): readonly R[] {\n  const dependencies: R[] = [];\n  const seen = new Set<string>();\n  const visit = (node: ValueExpression<R>): void => {\n    if (node.kind === \"ref\") {\n      const identity = referenceIdentity(node.ref);\n      if (!seen.has(identity)) {\n        seen.add(identity);\n        dependencies.push(node.ref);\n      }\n      return;\n    }\n    if (node.kind === \"op\") node.args.forEach(visit);\n  };\n  visit(expression);\n  return Object.freeze(dependencies);\n}\n"]}

package/dist/kuery-v1/dependencies.d.cts

@@ -0,0 +1,7 @@
+import { JsonValue, ValueExpression, CanonicalizeExpressionOptions, Result } from './types.cjs';
+
+/** Extract canonical references in first-seen AST order, deduplicated by structural JSON equality. */
+declare function extractExpressionDependencies<R extends JsonValue = string>(input: unknown, options?: CanonicalizeExpressionOptions<R>): Result<readonly R[]>;
+declare function collectExpressionDependencies<R extends JsonValue>(expression: ValueExpression<R>): readonly R[];
+
+export { collectExpressionDependencies, extractExpressionDependencies };

package/dist/kuery-v1/dependencies.d.ts

@@ -0,0 +1,7 @@
+import { JsonValue, ValueExpression, CanonicalizeExpressionOptions, Result } from './types.js';
+
+/** Extract canonical references in first-seen AST order, deduplicated by structural JSON equality. */
+declare function extractExpressionDependencies<R extends JsonValue = string>(input: unknown, options?: CanonicalizeExpressionOptions<R>): Result<readonly R[]>;
+declare function collectExpressionDependencies<R extends JsonValue>(expression: ValueExpression<R>): readonly R[];
+
+export { collectExpressionDependencies, extractExpressionDependencies };

package/dist/kuery-v1/dependencies.js

@@ -0,0 +1,29 @@
+import { canonicalizeExpression, referenceIdentity } from './canonicalize.js';
+import { success } from './result.js';
+
+function extractExpressionDependencies(input, options = {}) {
+  const canonical = canonicalizeExpression(input, options);
+  if (!canonical.ok) return canonical;
+  return success(collectExpressionDependencies(canonical.value));
+}
+function collectExpressionDependencies(expression) {
+  const dependencies = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node.kind === "ref") {
+      const identity = referenceIdentity(node.ref);
+      if (!seen.has(identity)) {
+        seen.add(identity);
+        dependencies.push(node.ref);
+      }
+      return;
+    }
+    if (node.kind === "op") node.args.forEach(visit);
+  };
+  visit(expression);
+  return Object.freeze(dependencies);
+}
+
+export { collectExpressionDependencies, extractExpressionDependencies };
+//# sourceMappingURL=dependencies.js.map
+//# sourceMappingURL=dependencies.js.map

package/dist/kuery-v1/dependencies.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kuery-v1/dependencies.ts"],"names":[],"mappings":";;;AAKO,SAAS,6BAAA,CACd,KAAA,EACA,OAAA,GAA4C,EAAC,EACvB;AACtB,EAAA,MAAM,SAAA,GAAY,sBAAA,CAA0B,KAAA,EAAO,OAAO,CAAA;AAC1D,EAAA,IAAI,CAAC,SAAA,CAAU,EAAA,EAAI,OAAO,SAAA;AAC1B,EAAA,OAAO,OAAA,CAAQ,6BAAA,CAA8B,SAAA,CAAU,KAAK,CAAC,CAAA;AAC/D;AAEO,SAAS,8BACd,UAAA,EACc;AACd,EAAA,MAAM,eAAoB,EAAC;AAC3B,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAC7B,EAAA,MAAM,KAAA,GAAQ,CAAC,IAAA,KAAmC;AAChD,IAAA,IAAI,IAAA,CAAK,SAAS,KAAA,EAAO;AACvB,MAAA,MAAM,QAAA,GAAW,iBAAA,CAAkB,IAAA,CAAK,GAAG,CAAA;AAC3C,MAAA,IAAI,CAAC,IAAA,CAAK,GAAA,CAAI,QAAQ,CAAA,EAAG;AACvB,QAAA,IAAA,CAAK,IAAI,QAAQ,CAAA;AACjB,QAAA,YAAA,CAAa,IAAA,CAAK,KAAK,GAAG,CAAA;AAAA,MAC5B;AACA,MAAA;AAAA,IACF;AACA,IAAA,IAAI,KAAK,IAAA,KAAS,IAAA,EAAM,IAAA,CAAK,IAAA,CAAK,QAAQ,KAAK,CAAA;AAAA,EACjD,CAAA;AACA,EAAA,KAAA,CAAM,UAAU,CAAA;AAChB,EAAA,OAAO,MAAA,CAAO,OAAO,YAAY,CAAA;AACnC","file":"dependencies.js","sourcesContent":["import { canonicalizeExpression, referenceIdentity } from \"./canonicalize.js\";\nimport { success } from \"./result.js\";\nimport type { CanonicalizeExpressionOptions, JsonValue, Result, ValueExpression } from \"./types.js\";\n\n/** Extract canonical references in first-seen AST order, deduplicated by structural JSON equality. */\nexport function extractExpressionDependencies<R extends JsonValue = string>(\n  input: unknown,\n  options: CanonicalizeExpressionOptions<R> = {},\n): Result<readonly R[]> {\n  const canonical = canonicalizeExpression<R>(input, options);\n  if (!canonical.ok) return canonical;\n  return success(collectExpressionDependencies(canonical.value));\n}\n\nexport function collectExpressionDependencies<R extends JsonValue>(\n  expression: ValueExpression<R>,\n): readonly R[] {\n  const dependencies: R[] = [];\n  const seen = new Set<string>();\n  const visit = (node: ValueExpression<R>): void => {\n    if (node.kind === \"ref\") {\n      const identity = referenceIdentity(node.ref);\n      if (!seen.has(identity)) {\n        seen.add(identity);\n        dependencies.push(node.ref);\n      }\n      return;\n    }\n    if (node.kind === \"op\") node.args.forEach(visit);\n  };\n  visit(expression);\n  return Object.freeze(dependencies);\n}\n"]}

package/dist/kuery-v1/evaluate.cjs

@@ -0,0 +1,174 @@
+'use strict';
+
+var callbackPromise_js = require('./callback-promise.js');
+var inspect_js = require('./inspect.js');
+var profile_js = require('./profile.js');
+var result_js = require('./result.js');
+
+function evaluateCompiled(expression, resolve, operators, limits) {
+  const state = { resolve, operators, limits, steps: 0 };
+  try {
+    const outcome = evaluateNode(expression, [], state);
+    if (!outcome.found) {
+      return result_js.failure(
+        outcome.denied ? "EXPRESSION_REFERENCE_DENIED" : "EXPRESSION_REFERENCE_MISSING",
+        outcome.path ?? []
+      );
+    }
+    return result_js.success(outcome.value);
+  } catch (error) {
+    const problem = error instanceof result_js.ExpressionFailure ? error : new result_js.ExpressionFailure("EXPRESSION_OPERATOR_ERROR", []);
+    return result_js.failure(problem.code, problem.expressionPath);
+  }
+}
+function evaluateNode(node, path, state) {
+  state.steps += 1;
+  if (state.steps > state.limits.maxEvaluationSteps) {
+    throw new result_js.ExpressionFailure("EXPRESSION_EVALUATION_LIMIT", path);
+  }
+  if (node.kind === "literal") return { found: true, value: node.value };
+  if (node.kind === "ref") return resolveReference(node.ref, path, state.resolve, state.limits);
+  const operator = state.operators.get(node);
+  if (!operator) throw new result_js.ExpressionFailure("EXPRESSION_UNKNOWN_OPERATOR", [...path, "op"]);
+  return evaluateOperator(node, operator, path, state);
+}
+function resolveReference(reference, path, resolve, limits) {
+  try {
+    const result = resolve(reference);
+    if (callbackPromise_js.rejectCallbackPromise(result))
+      throw new result_js.ExpressionFailure("EXPRESSION_ASYNC_UNSUPPORTED", path);
+    const parsed = parseResolution(result);
+    if (!parsed.valid) throw new result_js.ExpressionFailure("EXPRESSION_REFERENCE_ERROR", path);
+    if (!parsed.found) return { ...parsed, path };
+    return { found: true, value: safeCallbackValue(parsed.value, path, limits) };
+  } catch (error) {
+    if (error instanceof result_js.ExpressionFailure) throw error;
+    throw new result_js.ExpressionFailure("EXPRESSION_REFERENCE_ERROR", path);
+  }
+}
+function parseResolution(input) {
+  if (typeof input !== "object" || input === null) return { valid: false };
+  try {
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null) return { valid: false };
+    const found = Object.getOwnPropertyDescriptor(input, "found");
+    if (!found || !("value" in found) || !found.enumerable || typeof found.value !== "boolean")
+      return { valid: false };
+    const keys = Reflect.ownKeys(input);
+    if (!found.value) return parseMissingResolution(input, keys);
+    const value = Object.getOwnPropertyDescriptor(input, "value");
+    if (keys.length !== 2 || !keys.every((key) => key === "found" || key === "value") || !value || !("value" in value) || !value.enumerable) {
+      return { valid: false };
+    }
+    return { valid: true, found: true, value: value.value };
+  } catch {
+    return { valid: false };
+  }
+}
+function parseMissingResolution(input, keys) {
+  if (keys.length === 1 && keys[0] === "found") return { valid: true, found: false };
+  if (keys.length !== 2 || !keys.includes("found") || !keys.includes("reason"))
+    return { valid: false };
+  const reason = Object.getOwnPropertyDescriptor(input, "reason");
+  if (!reason || !("value" in reason) || !reason.enumerable) return { valid: false };
+  if (reason.value === void 0 || reason.value === "missing")
+    return { valid: true, found: false };
+  if (reason.value === "denied") return { valid: true, found: false, denied: true };
+  return { valid: false };
+}
+function evaluateOperator(node, operator, path, state) {
+  const strategy = profile_js.internalProfile.getEvaluationStrategy(operator);
+  if (strategy === "exists") return evaluateExists(node.args[0], [...path, "args", 0], state);
+  if (strategy === "and" || strategy === "or") return evaluateBoolean(node, strategy, path, state);
+  if (strategy === "coalesce") return evaluateCoalesce(node, path, state);
+  if (strategy === "if") return evaluateIf(node, path, state);
+  const args = [];
+  for (let index = 0; index < node.args.length; index += 1) {
+    const argPath = [...path, "args", index];
+    const outcome = evaluateNode(node.args[index], argPath, state);
+    if (!outcome.found) return outcome;
+    args.push(outcome.value);
+  }
+  return { found: true, value: execute(operator, args, path, state.limits) };
+}
+function evaluateExists(argument, path, state) {
+  const outcome = evaluateNode(argument, path, state);
+  if (outcome.denied)
+    throw new result_js.ExpressionFailure("EXPRESSION_REFERENCE_DENIED", outcome.path ?? path);
+  return { found: true, value: outcome.found };
+}
+function evaluateBoolean(node, strategy, path, state) {
+  const expected = strategy === "and";
+  for (let index = 0; index < node.args.length; index += 1) {
+    const argPath = [...path, "args", index];
+    const outcome = evaluateNode(node.args[index], argPath, state);
+    if (!outcome.found) return outcome;
+    const value = outcome.value;
+    assertType(value, "boolean", argPath);
+    if (value !== expected) return { found: true, value: !expected };
+  }
+  return { found: true, value: expected };
+}
+function evaluateIf(node, path, state) {
+  const conditionPath = [...path, "args", 0];
+  const condition = evaluateNode(node.args[0], conditionPath, state);
+  if (!condition.found) return condition;
+  assertType(condition.value, "boolean", conditionPath);
+  const selected = condition.value ? 1 : 2;
+  return evaluateNode(node.args[selected], [...path, "args", selected], state);
+}
+function evaluateCoalesce(node, path, state) {
+  for (let index = 0; index < node.args.length; index += 1) {
+    const argPath = [...path, "args", index];
+    const outcome = evaluateNode(node.args[index], argPath, state);
+    if (outcome.denied)
+      throw new result_js.ExpressionFailure("EXPRESSION_REFERENCE_DENIED", outcome.path ?? argPath);
+    if (outcome.found && outcome.value !== null) return outcome;
+  }
+  return { found: true, value: null };
+}
+function execute(operator, args, path, limits) {
+  validateInputTypes(operator, args, path);
+  try {
+    const result = operator.execute(Object.freeze([...args]));
+    if (callbackPromise_js.rejectCallbackPromise(result))
+      throw new result_js.ExpressionFailure("EXPRESSION_ASYNC_UNSUPPORTED", path);
+    const value = safeCallbackValue(result, path, limits);
+    if (operator.resultType) assertType(value, operator.resultType, path);
+    return value;
+  } catch (error) {
+    if (error instanceof result_js.ExpressionFailure) throw new result_js.ExpressionFailure(error.code, path);
+    throw new result_js.ExpressionFailure("EXPRESSION_OPERATOR_ERROR", path);
+  }
+}
+function validateInputTypes(operator, args, path) {
+  if (!operator.inputTypes) return;
+  args.forEach((value, index) => {
+    const expected = operator.inputTypes[index] ?? operator.inputTypes[0];
+    if (expected) assertType(value, expected, [...path, "args", index]);
+  });
+}
+function assertType(value, expected, path) {
+  if (expected === "any") return;
+  const actual = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+  if (actual !== expected) throw new result_js.ExpressionFailure("EXPRESSION_TYPE_MISMATCH", path);
+}
+function safeCallbackValue(input, path, limits) {
+  try {
+    return inspect_js.cloneJson(input, path, 0, {
+      maxDepth: limits.maxDepth,
+      maxNodes: limits.maxNodes,
+      maxStringLength: limits.maxStringLength,
+      nodes: 0,
+      active: /* @__PURE__ */ new WeakSet()
+    });
+  } catch (error) {
+    if (error instanceof result_js.ExpressionFailure && error.code === "EXPRESSION_LIMIT_EXCEEDED")
+      throw error;
+    throw new result_js.ExpressionFailure("EXPRESSION_INVALID_RESULT", path);
+  }
+}
+
+exports.evaluateCompiled = evaluateCompiled;
+//# sourceMappingURL=evaluate.cjs.map
+//# sourceMappingURL=evaluate.cjs.map