@kalada/core 0.2.0 → 0.4.0

package/dist/kalada-v1/evaluation-machine.js

@@ -0,0 +1,224 @@
+import { KaladaFailure } from './diagnostics.js';
+import { deliverFrame } from './evaluation-delivery.js';
+import { resolveReference } from './evaluation-resolution.js';
+import { captureMap, diagnosticContext, unwind, fail, charge, deliver, push, evaluate, reserveClosure, copyCaptures } from './evaluation-state.js';
+import { isCallable, coreCallable, closureFromMember, closureFromExpression } from './runtime-values.js';
+import { temporalLeaf } from './temporal-evaluation.js';
+import { Option } from './values.js';
+
+const FUNCTION_RUNTIME_DIAGNOSTICS = /* @__PURE__ */ new Set([
+  "KALADA_CAPTURE_LIMIT",
+  "KALADA_NOT_CALLABLE",
+  "KALADA_FUNCTION_ARITY",
+  "KALADA_FUNCTION_TYPE_MISMATCH",
+  "KALADA_CLOSURE_LIMIT",
+  "KALADA_CALL_DEPTH_LIMIT",
+  "KALADA_CONTINUATION_LIMIT",
+  "KALADA_COLLECTION_TYPE_MISMATCH",
+  "KALADA_COLLECTION_LIMIT",
+  "KALADA_FUNCTION_ESCAPE"
+]);
+function runEvaluation(expression, resolve, limits, functions, instant) {
+  const environment = /* @__PURE__ */ new Map();
+  const state = {
+    resolve,
+    limits,
+    captures: captureMap(functions),
+    instant,
+    stack: [],
+    task: { node: expression, path: ["expression"], environment },
+    value: null,
+    environment,
+    steps: 0,
+    closures: 0,
+    captured: 0,
+    callDepth: 0,
+    collectionIterations: 0
+  };
+  try {
+    return runLoop(state);
+  } catch (error) {
+    if (!(error instanceof KaladaFailure) || error.context) throw error;
+    const context = diagnosticContext(state);
+    const includeContext = context.length > 0 || FUNCTION_RUNTIME_DIAGNOSTICS.has(error.code);
+    unwind(state);
+    throw new KaladaFailure(error.code, error.path, includeContext ? context : void 0);
+  }
+}
+function runLoop(state) {
+  while (true) {
+    const result = advance(state);
+    if (result !== void 0) return result;
+  }
+}
+function advance(state) {
+  if (state.task) {
+    evaluateTask(state);
+    return void 0;
+  }
+  if (state.stack.length > 0) {
+    deliverFrame(state);
+    return void 0;
+  }
+  const value = state.value;
+  if (isCallable(value)) fail("KALADA_FUNCTION_ESCAPE", ["expression"]);
+  return value;
+}
+function evaluateTask(state) {
+  const task = state.task;
+  state.task = null;
+  state.environment = task.environment;
+  charge(task.path, state);
+  const { node, path } = task;
+  switch (node.kind) {
+    case "literal":
+      deliver(node.value, state);
+      break;
+    case "ref":
+      evaluateReference(node.ref, path, state);
+      break;
+    case "binding":
+      enterBinding(node, path, state);
+      break;
+    case "option":
+    case "result":
+      enterConstructor(node, path, state);
+      break;
+    case "match":
+      enterMatch(node, path, state);
+      break;
+    case "function":
+      deliver(materializeFunction(node, path, state), state);
+      break;
+    case "function-group":
+      enterGroup(node, path, state);
+      break;
+    case "call":
+      enterCall(node, path, state);
+      break;
+    case "core-function":
+      deliver(coreCallable(node.name), state);
+      break;
+    case "temporal-arithmetic":
+    case "temporal-comparison":
+      enterTemporal(node, path, state);
+      break;
+    default:
+      deliver(temporalLeaf(node, path, state.instant), state);
+  }
+}
+function evaluateReference(reference, path, state) {
+  if (typeof reference === "string" && state.environment.has(reference)) {
+    deliver(state.environment.get(reference), state);
+    return;
+  }
+  deliver(resolveReference(reference, path, state.resolve, state.limits), state);
+}
+function enterBinding(node, path, state) {
+  push(
+    {
+      kind: "binding",
+      phase: "value",
+      path,
+      name: node.name,
+      body: node.body,
+      outer: state.environment
+    },
+    [...path, "value"],
+    state
+  );
+  evaluate(node.value, [...path, "value"], state.environment, state);
+}
+function enterConstructor(node, path, state) {
+  if (node.kind === "option" && node.variant === "none") {
+    deliver(Option.none(), state);
+    return;
+  }
+  const type = node.kind === "option" ? "Option" : "Result";
+  push(
+    { kind: "constructor", phase: "payload", path, type, variant: node.variant },
+    [...path, "value"],
+    state
+  );
+  evaluate(node.value, [...path, "value"], state.environment, state);
+}
+function enterMatch(node, path, state) {
+  push(
+    {
+      kind: "match",
+      phase: "scrutinee",
+      path,
+      type: node.type,
+      arms: node.arms,
+      outer: state.environment,
+      scrutinee: null,
+      selected: null
+    },
+    [...path, "value"],
+    state
+  );
+  evaluate(node.value, [...path, "value"], state.environment, state);
+}
+function enterTemporal(node, path, state) {
+  push(
+    {
+      kind: "temporal-binary",
+      phase: "left",
+      path,
+      expressionKind: node.kind,
+      operator: node.operator,
+      right: node.right,
+      left: null
+    },
+    [...path, "left"],
+    state
+  );
+  evaluate(node.left, [...path, "left"], state.environment, state);
+}
+function enterCall(node, path, state) {
+  push(
+    { kind: "call-callee", phase: "callee", path, arguments: node.arguments },
+    [...path, "callee"],
+    state
+  );
+  evaluate(node.callee, [...path, "callee"], state.environment, state);
+}
+function enterGroup(node, path, state) {
+  const names = Object.freeze(node.functions.map((item) => item.name));
+  const closures = [];
+  const recursive = { names, closures };
+  node.functions.forEach((member, index) => {
+    const memberPath = [...path, "functions", index];
+    reserveClosure(memberPath, state);
+    const captured = copyCaptures(memberPath, state);
+    closures.push(closureFromMember(member, memberPath, captured, recursive));
+  });
+  Object.freeze(closures);
+  Object.freeze(recursive);
+  const group = new Map(state.environment);
+  names.forEach((name, index) => {
+    group.set(name, closures[index]);
+  });
+  push(
+    {
+      kind: "function-group-body",
+      phase: "body",
+      path,
+      body: node.body,
+      outer: state.environment,
+      group
+    },
+    [...path, "body"],
+    state
+  );
+  evaluate(node.body, [...path, "body"], group, state);
+}
+function materializeFunction(node, path, state) {
+  reserveClosure(path, state);
+  const captures = copyCaptures(path, state);
+  return closureFromExpression(node, path, captures);
+}
+
+export { runEvaluation };
+//# sourceMappingURL=evaluation-machine.js.map
+//# sourceMappingURL=evaluation-machine.js.map

package/dist/kalada-v1/evaluation-machine.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/evaluation-machine.ts"],"names":[],"mappings":"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","file":"evaluation-machine.js","sourcesContent":["import { KaladaFailure } from \"./diagnostics.js\";\nimport { deliverFrame } from \"./evaluation-delivery.js\";\nimport type { EvaluationTask, Path } from \"./evaluation-frames.js\";\nimport { resolveReference } from \"./evaluation-resolution.js\";\nimport {\n  captureMap,\n  charge,\n  copyCaptures,\n  deliver,\n  diagnosticContext,\n  evaluate,\n  fail,\n  type MachineState,\n  push,\n  reserveClosure,\n  unwind,\n} from \"./evaluation-state.js\";\nimport type { JsonValue } from \"./json.js\";\nimport type { ResolvedKaladaV1Limits } from \"./limits.js\";\nimport {\n  closureFromExpression,\n  closureFromMember,\n  coreCallable,\n  isCallable,\n  type RecursiveEnvironment,\n  type RuntimeValue,\n  type UserClosure,\n} from \"./runtime-values.js\";\nimport type { InstantValue } from \"./temporal.js\";\nimport { temporalLeaf } from \"./temporal-evaluation.js\";\nimport type { KaladaV1Expression, KaladaV1FunctionCapture, KaladaV1Resolver } from \"./types.js\";\nimport { type KaladaValue, Option } from \"./values.js\";\n\nconst FUNCTION_RUNTIME_DIAGNOSTICS = new Set([\n  \"KALADA_CAPTURE_LIMIT\",\n  \"KALADA_NOT_CALLABLE\",\n  \"KALADA_FUNCTION_ARITY\",\n  \"KALADA_FUNCTION_TYPE_MISMATCH\",\n  \"KALADA_CLOSURE_LIMIT\",\n  \"KALADA_CALL_DEPTH_LIMIT\",\n  \"KALADA_CONTINUATION_LIMIT\",\n  \"KALADA_COLLECTION_TYPE_MISMATCH\",\n  \"KALADA_COLLECTION_LIMIT\",\n  \"KALADA_FUNCTION_ESCAPE\",\n]);\n\nexport function runEvaluation<R extends JsonValue>(\n  expression: KaladaV1Expression<R>,\n  resolve: KaladaV1Resolver<R>,\n  limits: ResolvedKaladaV1Limits,\n  functions: readonly KaladaV1FunctionCapture[],\n  instant: InstantValue | undefined,\n): KaladaValue {\n  const environment = new Map<string, RuntimeValue>();\n  const state: MachineState<R> = {\n    resolve,\n    limits,\n    captures: captureMap(functions),\n    instant,\n    stack: [],\n    task: { node: expression, path: [\"expression\"], environment },\n    value: null,\n    environment,\n    steps: 0,\n    closures: 0,\n    captured: 0,\n    callDepth: 0,\n    collectionIterations: 0,\n  };\n  try {\n    return runLoop(state);\n  } catch (error) {\n    if (!(error instanceof KaladaFailure) || error.context) throw error;\n    const context = diagnosticContext(state);\n    const includeContext = context.length > 0 || FUNCTION_RUNTIME_DIAGNOSTICS.has(error.code);\n    unwind(state);\n    throw new KaladaFailure(error.code, error.path, includeContext ? context : undefined);\n  }\n}\n\nfunction runLoop<R extends JsonValue>(state: MachineState<R>): KaladaValue {\n  while (true) {\n    const result = advance(state);\n    if (result !== undefined) return result;\n  }\n}\n\nfunction advance<R extends JsonValue>(state: MachineState<R>): KaladaValue | undefined {\n  if (state.task) {\n    evaluateTask(state);\n    return undefined;\n  }\n  if (state.stack.length > 0) {\n    deliverFrame(state);\n    return undefined;\n  }\n  const value = state.value as RuntimeValue;\n  if (isCallable(value)) fail(\"KALADA_FUNCTION_ESCAPE\", [\"expression\"]);\n  return value;\n}\n\nfunction evaluateTask<R extends JsonValue>(state: MachineState<R>): void {\n  const task = state.task as EvaluationTask<R>;\n  state.task = null;\n  state.environment = task.environment;\n  charge(task.path, state);\n  const { node, path } = task;\n  switch (node.kind) {\n    case \"literal\":\n      deliver(node.value, state);\n      break;\n    case \"ref\":\n      evaluateReference(node.ref, path, state);\n      break;\n    case \"binding\":\n      enterBinding(node, path, state);\n      break;\n    case \"option\":\n    case \"result\":\n      enterConstructor(node, path, state);\n      break;\n    case \"match\":\n      enterMatch(node, path, state);\n      break;\n    case \"function\":\n      deliver(materializeFunction(node, path, state), state);\n      break;\n    case \"function-group\":\n      enterGroup(node, path, state);\n      break;\n    case \"call\":\n      enterCall(node, path, state);\n      break;\n    case \"core-function\":\n      deliver(coreCallable(node.name), state);\n      break;\n    case \"temporal-arithmetic\":\n    case \"temporal-comparison\":\n      enterTemporal(node, path, state);\n      break;\n    default:\n      deliver(temporalLeaf(node, path, state.instant), state);\n  }\n}\n\nfunction evaluateReference<R extends JsonValue>(\n  reference: R,\n  path: Path,\n  state: MachineState<R>,\n): void {\n  if (typeof reference === \"string\" && state.environment.has(reference)) {\n    deliver(state.environment.get(reference) as RuntimeValue, state);\n    return;\n  }\n  deliver(resolveReference(reference, path, state.resolve, state.limits), state);\n}\n\nfunction enterBinding<R extends JsonValue>(\n  node: Extract<KaladaV1Expression<R>, { kind: \"binding\" }>,\n  path: Path,\n  state: MachineState<R>,\n): void {\n  push(\n    {\n      kind: \"binding\",\n      phase: \"value\",\n      path,\n      name: node.name,\n      body: node.body,\n      outer: state.environment,\n    },\n    [...path, \"value\"],\n    state,\n  );\n  evaluate(node.value, [...path, \"value\"], state.environment, state);\n}\n\nfunction enterConstructor<R extends JsonValue>(\n  node: Extract<KaladaV1Expression<R>, { kind: \"option\" | \"result\" }>,\n  path: Path,\n  state: MachineState<R>,\n): void {\n  if (node.kind === \"option\" && node.variant === \"none\") {\n    deliver(Option.none(), state);\n    return;\n  }\n  const type = node.kind === \"option\" ? \"Option\" : \"Result\";\n  push(\n    { kind: \"constructor\", phase: \"payload\", path, type, variant: node.variant },\n    [...path, \"value\"],\n    state,\n  );\n  evaluate(node.value, [...path, \"value\"], state.environment, state);\n}\n\nfunction enterMatch<R extends JsonValue>(\n  node: Extract<KaladaV1Expression<R>, { kind: \"match\" }>,\n  path: Path,\n  state: MachineState<R>,\n): void {\n  push(\n    {\n      kind: \"match\",\n      phase: \"scrutinee\",\n      path,\n      type: node.type,\n      arms: node.arms,\n      outer: state.environment,\n      scrutinee: null,\n      selected: null,\n    },\n    [...path, \"value\"],\n    state,\n  );\n  evaluate(node.value, [...path, \"value\"], state.environment, state);\n}\n\nfunction enterTemporal<R extends JsonValue>(\n  node: Extract<KaladaV1Expression<R>, { kind: \"temporal-arithmetic\" | \"temporal-comparison\" }>,\n  path: Path,\n  state: MachineState<R>,\n): void {\n  push(\n    {\n      kind: \"temporal-binary\",\n      phase: \"left\",\n      path,\n      expressionKind: node.kind,\n      operator: node.operator,\n      right: node.right,\n      left: null,\n    },\n    [...path, \"left\"],\n    state,\n  );\n  evaluate(node.left, [...path, \"left\"], state.environment, state);\n}\n\nfunction enterCall<R extends JsonValue>(\n  node: Extract<KaladaV1Expression<R>, { kind: \"call\" }>,\n  path: Path,\n  state: MachineState<R>,\n): void {\n  push(\n    { kind: \"call-callee\", phase: \"callee\", path, arguments: node.arguments },\n    [...path, \"callee\"],\n    state,\n  );\n  evaluate(node.callee, [...path, \"callee\"], state.environment, state);\n}\n\nfunction enterGroup<R extends JsonValue>(\n  node: Extract<KaladaV1Expression<R>, { kind: \"function-group\" }>,\n  path: Path,\n  state: MachineState<R>,\n): void {\n  const names = Object.freeze(node.functions.map((item) => item.name));\n  const closures: UserClosure<R>[] = [];\n  const recursive = { names, closures } as RecursiveEnvironment<R>;\n  node.functions.forEach((member, index) => {\n    const memberPath = [...path, \"functions\", index];\n    reserveClosure(memberPath, state);\n    const captured = copyCaptures(memberPath, state);\n    closures.push(closureFromMember(member, memberPath, captured, recursive));\n  });\n  Object.freeze(closures);\n  Object.freeze(recursive);\n  const group = new Map(state.environment);\n  names.forEach((name, index) => {\n    group.set(name, closures[index] as UserClosure<R>);\n  });\n  push(\n    {\n      kind: \"function-group-body\",\n      phase: \"body\",\n      path,\n      body: node.body,\n      outer: state.environment,\n      group,\n    },\n    [...path, \"body\"],\n    state,\n  );\n  evaluate(node.body, [...path, \"body\"], group, state);\n}\n\nfunction materializeFunction<R extends JsonValue>(\n  node: Extract<KaladaV1Expression<R>, { kind: \"function\" }>,\n  path: Path,\n  state: MachineState<R>,\n): UserClosure<R> {\n  reserveClosure(path, state);\n  const captures = copyCaptures(path, state);\n  return closureFromExpression(node, path, captures);\n}\n"]}

package/dist/kalada-v1/evaluation-resolution.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+var callbackPromise_js = require('../kuery-v1/callback-promise.js');
+var diagnostics_js = require('./diagnostics.js');
+var json_js = require('./json.js');
+var temporal_js = require('./temporal.js');
+var values_js = require('./values.js');
+
+function resolveReference(reference, path, resolve, limits) {
+  let input;
+  try {
+    input = resolve(reference);
+  } catch {
+    throw new diagnostics_js.KaladaFailure("KALADA_REFERENCE_ERROR", path);
+  }
+  if (callbackPromise_js.rejectCallbackPromise(input)) throw new diagnostics_js.KaladaFailure("KALADA_ASYNC_UNSUPPORTED", path);
+  return parseResolution(input, path, limits);
+}
+function parseResolution(input, path, limits) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new diagnostics_js.KaladaFailure("KALADA_REFERENCE_ERROR", path);
+  }
+  const keys = safeKeys(input, path);
+  const found = safeData(input, "found", path);
+  if (typeof found !== "boolean") throw new diagnostics_js.KaladaFailure("KALADA_REFERENCE_ERROR", path);
+  if (!found) return missingResolution(input, keys, path);
+  if (keys.length !== 2 || !keys.includes("value")) failReference(path);
+  return safeValue(safeData(input, "value", path), path, limits);
+}
+function missingResolution(input, keys, path) {
+  if (keys.length === 1) throw new diagnostics_js.KaladaFailure("KALADA_REFERENCE_MISSING", path);
+  if (keys.length !== 2 || !keys.includes("reason")) failReference(path);
+  const reason = safeData(input, "reason", path);
+  if (reason === void 0 || reason === "missing") {
+    throw new diagnostics_js.KaladaFailure("KALADA_REFERENCE_MISSING", path);
+  }
+  if (reason === "denied") throw new diagnostics_js.KaladaFailure("KALADA_REFERENCE_DENIED", path);
+  return failReference(path);
+}
+function safeValue(input, path, limits) {
+  try {
+    if (values_js.isOption(input) || values_js.isResult(input) || temporal_js.isInstant(input) || temporal_js.isDuration(input)) {
+      values_js.validateKaladaValueLimits(input, {
+        maxDepth: limits.maxValueDepth,
+        maxNodes: limits.maxValueNodes,
+        maxStringLength: limits.maxStringLength
+      });
+      return input;
+    }
+    return json_js.cloneJson(input, {
+      maxDepth: limits.maxValueDepth,
+      maxNodes: limits.maxValueNodes,
+      maxStringLength: limits.maxStringLength
+    });
+  } catch (error) {
+    if (error instanceof RangeError) throw new diagnostics_js.KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_RESULT", path);
+  }
+}
+function safeKeys(input, path) {
+  try {
+    return Reflect.ownKeys(input);
+  } catch {
+    return failReference(path);
+  }
+}
+function safeData(input, key, path) {
+  try {
+    return json_js.dataValue(input, key);
+  } catch {
+    return failReference(path);
+  }
+}
+function failReference(path) {
+  throw new diagnostics_js.KaladaFailure("KALADA_REFERENCE_ERROR", path);
+}
+
+exports.resolveReference = resolveReference;
+//# sourceMappingURL=evaluation-resolution.cjs.map
+//# sourceMappingURL=evaluation-resolution.cjs.map

package/dist/kalada-v1/evaluation-resolution.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/evaluation-resolution.ts"],"names":["KaladaFailure","rejectCallbackPromise","isOption","isResult","isInstant","isDuration","validateKaladaValueLimits","cloneJson","dataValue"],"mappings":"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","file":"evaluation-resolution.cjs","sourcesContent":["import { rejectCallbackPromise } from \"../kuery-v1/callback-promise.js\";\nimport { KaladaFailure } from \"./diagnostics.js\";\nimport type { Path } from \"./evaluation-frames.js\";\nimport { cloneJson, dataValue, type JsonValue } from \"./json.js\";\nimport type { ResolvedKaladaV1Limits } from \"./limits.js\";\nimport { isDuration, isInstant } from \"./temporal.js\";\nimport type { KaladaV1Resolver } from \"./types.js\";\nimport { isOption, isResult, type KaladaValue, validateKaladaValueLimits } from \"./values.js\";\n\nexport function resolveReference<R extends JsonValue>(\n  reference: R,\n  path: Path,\n  resolve: KaladaV1Resolver<R>,\n  limits: ResolvedKaladaV1Limits,\n): KaladaValue {\n  let input: unknown;\n  try {\n    input = resolve(reference);\n  } catch {\n    throw new KaladaFailure(\"KALADA_REFERENCE_ERROR\", path);\n  }\n  if (rejectCallbackPromise(input)) throw new KaladaFailure(\"KALADA_ASYNC_UNSUPPORTED\", path);\n  return parseResolution(input, path, limits);\n}\n\nfunction parseResolution(input: unknown, path: Path, limits: ResolvedKaladaV1Limits): KaladaValue {\n  if (typeof input !== \"object\" || input === null || Array.isArray(input)) {\n    throw new KaladaFailure(\"KALADA_REFERENCE_ERROR\", path);\n  }\n  const keys = safeKeys(input, path);\n  const found = safeData(input, \"found\", path);\n  if (typeof found !== \"boolean\") throw new KaladaFailure(\"KALADA_REFERENCE_ERROR\", path);\n  if (!found) return missingResolution(input, keys, path);\n  if (keys.length !== 2 || !keys.includes(\"value\")) failReference(path);\n  return safeValue(safeData(input, \"value\", path), path, limits);\n}\n\nfunction missingResolution(input: object, keys: readonly PropertyKey[], path: Path): never {\n  if (keys.length === 1) throw new KaladaFailure(\"KALADA_REFERENCE_MISSING\", path);\n  if (keys.length !== 2 || !keys.includes(\"reason\")) failReference(path);\n  const reason = safeData(input, \"reason\", path);\n  if (reason === undefined || reason === \"missing\") {\n    throw new KaladaFailure(\"KALADA_REFERENCE_MISSING\", path);\n  }\n  if (reason === \"denied\") throw new KaladaFailure(\"KALADA_REFERENCE_DENIED\", path);\n  return failReference(path);\n}\n\nfunction safeValue(input: unknown, path: Path, limits: ResolvedKaladaV1Limits): KaladaValue {\n  try {\n    if (isOption(input) || isResult(input) || isInstant(input) || isDuration(input)) {\n      validateKaladaValueLimits(input, {\n        maxDepth: limits.maxValueDepth,\n        maxNodes: limits.maxValueNodes,\n        maxStringLength: limits.maxStringLength,\n      });\n      return input;\n    }\n    return cloneJson(input, {\n      maxDepth: limits.maxValueDepth,\n      maxNodes: limits.maxValueNodes,\n      maxStringLength: limits.maxStringLength,\n    });\n  } catch (error) {\n    if (error instanceof RangeError) throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n    throw new KaladaFailure(\"KALADA_INVALID_RESULT\", path);\n  }\n}\n\nfunction safeKeys(input: object, path: Path): PropertyKey[] {\n  try {\n    return Reflect.ownKeys(input);\n  } catch {\n    return failReference(path);\n  }\n}\n\nfunction safeData(input: object, key: string, path: Path): unknown {\n  try {\n    return dataValue(input, key);\n  } catch {\n    return failReference(path);\n  }\n}\n\nfunction failReference(path: Path): never {\n  throw new KaladaFailure(\"KALADA_REFERENCE_ERROR\", path);\n}\n"]}

package/dist/kalada-v1/evaluation-resolution.d.cts

@@ -0,0 +1,11 @@
+import { Path } from './evaluation-frames.cjs';
+import { JsonValue } from './json.cjs';
+import { ResolvedKaladaV1Limits } from './limits.cjs';
+import { KaladaV1Resolver } from './types.cjs';
+import { KaladaValue } from './values.cjs';
+import './runtime-values.cjs';
+import './temporal.cjs';
+
+declare function resolveReference<R extends JsonValue>(reference: R, path: Path, resolve: KaladaV1Resolver<R>, limits: ResolvedKaladaV1Limits): KaladaValue;
+
+export { resolveReference };

package/dist/kalada-v1/evaluation-resolution.d.ts

@@ -0,0 +1,11 @@
+import { Path } from './evaluation-frames.js';
+import { JsonValue } from './json.js';
+import { ResolvedKaladaV1Limits } from './limits.js';
+import { KaladaV1Resolver } from './types.js';
+import { KaladaValue } from './values.js';
+import './runtime-values.js';
+import './temporal.js';
+
+declare function resolveReference<R extends JsonValue>(reference: R, path: Path, resolve: KaladaV1Resolver<R>, limits: ResolvedKaladaV1Limits): KaladaValue;
+
+export { resolveReference };

package/dist/kalada-v1/evaluation-resolution.js

@@ -0,0 +1,78 @@
+import { rejectCallbackPromise } from '../kuery-v1/callback-promise.js';
+import { KaladaFailure } from './diagnostics.js';
+import { cloneJson, dataValue } from './json.js';
+import { isInstant, isDuration } from './temporal.js';
+import { isOption, isResult, validateKaladaValueLimits } from './values.js';
+
+function resolveReference(reference, path, resolve, limits) {
+  let input;
+  try {
+    input = resolve(reference);
+  } catch {
+    throw new KaladaFailure("KALADA_REFERENCE_ERROR", path);
+  }
+  if (rejectCallbackPromise(input)) throw new KaladaFailure("KALADA_ASYNC_UNSUPPORTED", path);
+  return parseResolution(input, path, limits);
+}
+function parseResolution(input, path, limits) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new KaladaFailure("KALADA_REFERENCE_ERROR", path);
+  }
+  const keys = safeKeys(input, path);
+  const found = safeData(input, "found", path);
+  if (typeof found !== "boolean") throw new KaladaFailure("KALADA_REFERENCE_ERROR", path);
+  if (!found) return missingResolution(input, keys, path);
+  if (keys.length !== 2 || !keys.includes("value")) failReference(path);
+  return safeValue(safeData(input, "value", path), path, limits);
+}
+function missingResolution(input, keys, path) {
+  if (keys.length === 1) throw new KaladaFailure("KALADA_REFERENCE_MISSING", path);
+  if (keys.length !== 2 || !keys.includes("reason")) failReference(path);
+  const reason = safeData(input, "reason", path);
+  if (reason === void 0 || reason === "missing") {
+    throw new KaladaFailure("KALADA_REFERENCE_MISSING", path);
+  }
+  if (reason === "denied") throw new KaladaFailure("KALADA_REFERENCE_DENIED", path);
+  return failReference(path);
+}
+function safeValue(input, path, limits) {
+  try {
+    if (isOption(input) || isResult(input) || isInstant(input) || isDuration(input)) {
+      validateKaladaValueLimits(input, {
+        maxDepth: limits.maxValueDepth,
+        maxNodes: limits.maxValueNodes,
+        maxStringLength: limits.maxStringLength
+      });
+      return input;
+    }
+    return cloneJson(input, {
+      maxDepth: limits.maxValueDepth,
+      maxNodes: limits.maxValueNodes,
+      maxStringLength: limits.maxStringLength
+    });
+  } catch (error) {
+    if (error instanceof RangeError) throw new KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+    throw new KaladaFailure("KALADA_INVALID_RESULT", path);
+  }
+}
+function safeKeys(input, path) {
+  try {
+    return Reflect.ownKeys(input);
+  } catch {
+    return failReference(path);
+  }
+}
+function safeData(input, key, path) {
+  try {
+    return dataValue(input, key);
+  } catch {
+    return failReference(path);
+  }
+}
+function failReference(path) {
+  throw new KaladaFailure("KALADA_REFERENCE_ERROR", path);
+}
+
+export { resolveReference };
+//# sourceMappingURL=evaluation-resolution.js.map
+//# sourceMappingURL=evaluation-resolution.js.map

package/dist/kalada-v1/evaluation-resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/evaluation-resolution.ts"],"names":[],"mappings":"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","file":"evaluation-resolution.js","sourcesContent":["import { rejectCallbackPromise } from \"../kuery-v1/callback-promise.js\";\nimport { KaladaFailure } from \"./diagnostics.js\";\nimport type { Path } from \"./evaluation-frames.js\";\nimport { cloneJson, dataValue, type JsonValue } from \"./json.js\";\nimport type { ResolvedKaladaV1Limits } from \"./limits.js\";\nimport { isDuration, isInstant } from \"./temporal.js\";\nimport type { KaladaV1Resolver } from \"./types.js\";\nimport { isOption, isResult, type KaladaValue, validateKaladaValueLimits } from \"./values.js\";\n\nexport function resolveReference<R extends JsonValue>(\n  reference: R,\n  path: Path,\n  resolve: KaladaV1Resolver<R>,\n  limits: ResolvedKaladaV1Limits,\n): KaladaValue {\n  let input: unknown;\n  try {\n    input = resolve(reference);\n  } catch {\n    throw new KaladaFailure(\"KALADA_REFERENCE_ERROR\", path);\n  }\n  if (rejectCallbackPromise(input)) throw new KaladaFailure(\"KALADA_ASYNC_UNSUPPORTED\", path);\n  return parseResolution(input, path, limits);\n}\n\nfunction parseResolution(input: unknown, path: Path, limits: ResolvedKaladaV1Limits): KaladaValue {\n  if (typeof input !== \"object\" || input === null || Array.isArray(input)) {\n    throw new KaladaFailure(\"KALADA_REFERENCE_ERROR\", path);\n  }\n  const keys = safeKeys(input, path);\n  const found = safeData(input, \"found\", path);\n  if (typeof found !== \"boolean\") throw new KaladaFailure(\"KALADA_REFERENCE_ERROR\", path);\n  if (!found) return missingResolution(input, keys, path);\n  if (keys.length !== 2 || !keys.includes(\"value\")) failReference(path);\n  return safeValue(safeData(input, \"value\", path), path, limits);\n}\n\nfunction missingResolution(input: object, keys: readonly PropertyKey[], path: Path): never {\n  if (keys.length === 1) throw new KaladaFailure(\"KALADA_REFERENCE_MISSING\", path);\n  if (keys.length !== 2 || !keys.includes(\"reason\")) failReference(path);\n  const reason = safeData(input, \"reason\", path);\n  if (reason === undefined || reason === \"missing\") {\n    throw new KaladaFailure(\"KALADA_REFERENCE_MISSING\", path);\n  }\n  if (reason === \"denied\") throw new KaladaFailure(\"KALADA_REFERENCE_DENIED\", path);\n  return failReference(path);\n}\n\nfunction safeValue(input: unknown, path: Path, limits: ResolvedKaladaV1Limits): KaladaValue {\n  try {\n    if (isOption(input) || isResult(input) || isInstant(input) || isDuration(input)) {\n      validateKaladaValueLimits(input, {\n        maxDepth: limits.maxValueDepth,\n        maxNodes: limits.maxValueNodes,\n        maxStringLength: limits.maxStringLength,\n      });\n      return input;\n    }\n    return cloneJson(input, {\n      maxDepth: limits.maxValueDepth,\n      maxNodes: limits.maxValueNodes,\n      maxStringLength: limits.maxStringLength,\n    });\n  } catch (error) {\n    if (error instanceof RangeError) throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n    throw new KaladaFailure(\"KALADA_INVALID_RESULT\", path);\n  }\n}\n\nfunction safeKeys(input: object, path: Path): PropertyKey[] {\n  try {\n    return Reflect.ownKeys(input);\n  } catch {\n    return failReference(path);\n  }\n}\n\nfunction safeData(input: object, key: string, path: Path): unknown {\n  try {\n    return dataValue(input, key);\n  } catch {\n    return failReference(path);\n  }\n}\n\nfunction failReference(path: Path): never {\n  throw new KaladaFailure(\"KALADA_REFERENCE_ERROR\", path);\n}\n"]}

package/dist/kalada-v1/evaluation-state.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var diagnostics_js = require('./diagnostics.js');
+
+function evaluate(node, path, environment, state) {
+  state.task = { node, path, environment };
+}
+function deliver(value, state) {
+  state.value = value;
+}
+function push(frame, failurePath, state) {
+  ensureCapacity(failurePath, state);
+  state.stack.push(frame);
+}
+function ensureCapacity(path, state) {
+  if (state.stack.length >= state.limits.maxContinuationFrames) {
+    fail("KALADA_CONTINUATION_LIMIT", path);
+  }
+}
+function charge(path, state) {
+  if (state.steps >= state.limits.maxEvaluationSteps) fail("KALADA_EVALUATION_LIMIT", path);
+  state.steps += 1;
+}
+function reserveCollectionIteration(path, state) {
+  if (state.collectionIterations >= state.limits.maxCollectionIterations) {
+    fail("KALADA_COLLECTION_LIMIT", path);
+  }
+  state.collectionIterations += 1;
+  charge(path, state);
+}
+function copyCaptures(path, state) {
+  const output = /* @__PURE__ */ new Map();
+  for (const name of state.captures.get(pathKey(path)) ?? []) {
+    if (state.captured >= state.limits.maxCapturedBindings) fail("KALADA_CAPTURE_LIMIT", path);
+    charge(path, state);
+    state.captured += 1;
+    output.set(name, state.environment.get(name));
+  }
+  return output;
+}
+function reserveClosure(path, state) {
+  if (state.closures >= state.limits.maxClosures) fail("KALADA_CLOSURE_LIMIT", path);
+  charge(path, state);
+  state.closures += 1;
+}
+function captureMap(functions) {
+  return new Map(functions.map((item) => [pathKey(item.path), item.captures]));
+}
+function unwind(state) {
+  while (state.stack.length > 0) {
+    const frame = state.stack.pop();
+    if (frame.kind === "binding" || frame.kind === "match") state.environment = frame.outer;
+    if (frame.kind === "function-group-body") state.environment = frame.outer;
+    if (frame.kind === "user-return") {
+      state.environment = frame.caller;
+      state.callDepth -= 1;
+    }
+    if (frame.kind === "core-iteration") state.callDepth -= 1;
+  }
+}
+function diagnosticContext(state) {
+  const context = [];
+  for (let index = state.stack.length - 1; index >= 0 && context.length < 32; index -= 1) {
+    const frame = state.stack[index];
+    if (frame.kind === "user-return") {
+      context.push({ kind: "function-call", name: frame.name, path: frame.path });
+    }
+    if (frame.kind === "core-iteration") {
+      context.push({ kind: "core-call", name: frame.operator, path: frame.path });
+    }
+  }
+  return context;
+}
+function fail(code, path) {
+  throw new diagnostics_js.KaladaFailure(code, path);
+}
+function pathKey(path) {
+  return JSON.stringify(path);
+}
+
+exports.captureMap = captureMap;
+exports.charge = charge;
+exports.copyCaptures = copyCaptures;
+exports.deliver = deliver;
+exports.diagnosticContext = diagnosticContext;
+exports.ensureCapacity = ensureCapacity;
+exports.evaluate = evaluate;
+exports.fail = fail;
+exports.push = push;
+exports.reserveClosure = reserveClosure;
+exports.reserveCollectionIteration = reserveCollectionIteration;
+exports.unwind = unwind;
+//# sourceMappingURL=evaluation-state.cjs.map
+//# sourceMappingURL=evaluation-state.cjs.map

package/dist/kalada-v1/evaluation-state.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/evaluation-state.ts"],"names":["KaladaFailure"],"mappings":"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","file":"evaluation-state.cjs","sourcesContent":["import { KaladaFailure } from \"./diagnostics.js\";\nimport type { EvaluationFrame, EvaluationTask, Path } from \"./evaluation-frames.js\";\nimport type { JsonValue } from \"./json.js\";\nimport type { ResolvedKaladaV1Limits } from \"./limits.js\";\nimport type { RuntimeEnvironment, RuntimeValue } from \"./runtime-values.js\";\nimport type { InstantValue } from \"./temporal.js\";\nimport type {\n  KaladaV1DiagnosticContextFrame,\n  KaladaV1Expression,\n  KaladaV1FunctionCapture,\n  KaladaV1Resolver,\n} from \"./types.js\";\n\nexport interface MachineState<R extends JsonValue> {\n  readonly resolve: KaladaV1Resolver<R>;\n  readonly limits: ResolvedKaladaV1Limits;\n  readonly captures: ReadonlyMap<string, readonly string[]>;\n  readonly instant: InstantValue | undefined;\n  readonly stack: EvaluationFrame<R>[];\n  task: EvaluationTask<R> | null;\n  value: RuntimeValue | null;\n  environment: RuntimeEnvironment;\n  steps: number;\n  closures: number;\n  captured: number;\n  callDepth: number;\n  collectionIterations: number;\n}\n\nexport function evaluate<R extends JsonValue>(\n  node: KaladaV1Expression<R>,\n  path: Path,\n  environment: RuntimeEnvironment,\n  state: MachineState<R>,\n): void {\n  state.task = { node, path, environment };\n}\n\nexport function deliver<R extends JsonValue>(value: RuntimeValue, state: MachineState<R>): void {\n  state.value = value;\n}\n\nexport function push<R extends JsonValue>(\n  frame: EvaluationFrame<R>,\n  failurePath: Path,\n  state: MachineState<R>,\n): void {\n  ensureCapacity(failurePath, state);\n  state.stack.push(frame);\n}\n\nexport function ensureCapacity<R extends JsonValue>(path: Path, state: MachineState<R>): void {\n  if (state.stack.length >= state.limits.maxContinuationFrames) {\n    fail(\"KALADA_CONTINUATION_LIMIT\", path);\n  }\n}\n\nexport function charge<R extends JsonValue>(path: Path, state: MachineState<R>): void {\n  if (state.steps >= state.limits.maxEvaluationSteps) fail(\"KALADA_EVALUATION_LIMIT\", path);\n  state.steps += 1;\n}\n\nexport function reserveCollectionIteration<R extends JsonValue>(\n  path: Path,\n  state: MachineState<R>,\n): void {\n  if (state.collectionIterations >= state.limits.maxCollectionIterations) {\n    fail(\"KALADA_COLLECTION_LIMIT\", path);\n  }\n  state.collectionIterations += 1;\n  charge(path, state);\n}\n\nexport function copyCaptures<R extends JsonValue>(\n  path: Path,\n  state: MachineState<R>,\n): RuntimeEnvironment {\n  const output = new Map<string, RuntimeValue>();\n  for (const name of state.captures.get(pathKey(path)) ?? []) {\n    if (state.captured >= state.limits.maxCapturedBindings) fail(\"KALADA_CAPTURE_LIMIT\", path);\n    charge(path, state);\n    state.captured += 1;\n    output.set(name, state.environment.get(name) as RuntimeValue);\n  }\n  return output;\n}\n\nexport function reserveClosure<R extends JsonValue>(path: Path, state: MachineState<R>): void {\n  if (state.closures >= state.limits.maxClosures) fail(\"KALADA_CLOSURE_LIMIT\", path);\n  charge(path, state);\n  state.closures += 1;\n}\n\nexport function captureMap(\n  functions: readonly KaladaV1FunctionCapture[],\n): ReadonlyMap<string, readonly string[]> {\n  return new Map(functions.map((item) => [pathKey(item.path), item.captures]));\n}\n\nexport function unwind<R extends JsonValue>(state: MachineState<R>): void {\n  while (state.stack.length > 0) {\n    const frame = state.stack.pop() as EvaluationFrame<R>;\n    if (frame.kind === \"binding\" || frame.kind === \"match\") state.environment = frame.outer;\n    if (frame.kind === \"function-group-body\") state.environment = frame.outer;\n    if (frame.kind === \"user-return\") {\n      state.environment = frame.caller;\n      state.callDepth -= 1;\n    }\n    if (frame.kind === \"core-iteration\") state.callDepth -= 1;\n  }\n}\n\nexport function diagnosticContext<R extends JsonValue>(\n  state: MachineState<R>,\n): readonly KaladaV1DiagnosticContextFrame[] {\n  const context: KaladaV1DiagnosticContextFrame[] = [];\n  for (let index = state.stack.length - 1; index >= 0 && context.length < 32; index -= 1) {\n    const frame = state.stack[index] as EvaluationFrame<R>;\n    if (frame.kind === \"user-return\") {\n      context.push({ kind: \"function-call\", name: frame.name, path: frame.path });\n    }\n    if (frame.kind === \"core-iteration\") {\n      context.push({ kind: \"core-call\", name: frame.operator, path: frame.path });\n    }\n  }\n  return context;\n}\n\nexport function fail(code: ConstructorParameters<typeof KaladaFailure>[0], path: Path): never {\n  throw new KaladaFailure(code, path);\n}\n\nfunction pathKey(path: Path): string {\n  return JSON.stringify(path);\n}\n"]}

package/dist/kalada-v1/evaluation-state.d.cts

@@ -0,0 +1,38 @@
+import { KaladaFailure } from './diagnostics.cjs';
+import { EvaluationFrame, EvaluationTask, Path } from './evaluation-frames.cjs';
+import { JsonValue } from './json.cjs';
+import { ResolvedKaladaV1Limits } from './limits.cjs';
+import { RuntimeValue, RuntimeEnvironment } from './runtime-values.cjs';
+import { InstantValue } from './temporal.cjs';
+import { KaladaV1Resolver, KaladaV1FunctionCapture, KaladaV1DiagnosticContextFrame, KaladaV1Expression } from './types.cjs';
+import './values.cjs';
+
+interface MachineState<R extends JsonValue> {
+    readonly resolve: KaladaV1Resolver<R>;
+    readonly limits: ResolvedKaladaV1Limits;
+    readonly captures: ReadonlyMap<string, readonly string[]>;
+    readonly instant: InstantValue | undefined;
+    readonly stack: EvaluationFrame<R>[];
+    task: EvaluationTask<R> | null;
+    value: RuntimeValue | null;
+    environment: RuntimeEnvironment;
+    steps: number;
+    closures: number;
+    captured: number;
+    callDepth: number;
+    collectionIterations: number;
+}
+declare function evaluate<R extends JsonValue>(node: KaladaV1Expression<R>, path: Path, environment: RuntimeEnvironment, state: MachineState<R>): void;
+declare function deliver<R extends JsonValue>(value: RuntimeValue, state: MachineState<R>): void;
+declare function push<R extends JsonValue>(frame: EvaluationFrame<R>, failurePath: Path, state: MachineState<R>): void;
+declare function ensureCapacity<R extends JsonValue>(path: Path, state: MachineState<R>): void;
+declare function charge<R extends JsonValue>(path: Path, state: MachineState<R>): void;
+declare function reserveCollectionIteration<R extends JsonValue>(path: Path, state: MachineState<R>): void;
+declare function copyCaptures<R extends JsonValue>(path: Path, state: MachineState<R>): RuntimeEnvironment;
+declare function reserveClosure<R extends JsonValue>(path: Path, state: MachineState<R>): void;
+declare function captureMap(functions: readonly KaladaV1FunctionCapture[]): ReadonlyMap<string, readonly string[]>;
+declare function unwind<R extends JsonValue>(state: MachineState<R>): void;
+declare function diagnosticContext<R extends JsonValue>(state: MachineState<R>): readonly KaladaV1DiagnosticContextFrame[];
+declare function fail(code: ConstructorParameters<typeof KaladaFailure>[0], path: Path): never;
+
+export { type MachineState, captureMap, charge, copyCaptures, deliver, diagnosticContext, ensureCapacity, evaluate, fail, push, reserveClosure, reserveCollectionIteration, unwind };