@kalada/core 0.2.0 → 0.4.0

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

@@ -0,0 +1,95 @@
+'use strict';
+
+var diagnostics_js = require('./diagnostics.js');
+var temporal_js = require('./temporal.js');
+
+function temporalLeaf(node, path, instant) {
+  if (node.kind === "instant") return temporal_js.Instant.fromMilliseconds(node.milliseconds);
+  if (node.kind === "duration") return temporal_js.Duration.fromMilliseconds(node.milliseconds);
+  if (!instant) throw new diagnostics_js.KaladaFailure("KALADA_INSTANT_REQUIRED", path);
+  return instant;
+}
+function applyTemporalBinary(kind, operator, left, right, rightPath) {
+  if (!temporal_js.isInstant(left) && !temporal_js.isDuration(left)) mismatch(rightPath.slice(0, -1).concat("left"));
+  if (!temporal_js.isInstant(right) && !temporal_js.isDuration(right)) mismatch(rightPath);
+  if (kind === "temporal-comparison") {
+    assertSameType(left, right, rightPath);
+    return compare(
+      operator,
+      left.milliseconds,
+      right.milliseconds
+    );
+  }
+  return operator === "add" ? add(left, right, rightPath) : subtract(left, right, rightPath);
+}
+function isTemporalExpression(node) {
+  return node.kind === "instant" || node.kind === "duration" || node.kind === "current-instant" || node.kind === "temporal-arithmetic" || node.kind === "temporal-comparison";
+}
+function evaluateTemporalExpression(node, path, instant, evaluate) {
+  if (node.kind === "instant") return temporal_js.Instant.fromMilliseconds(node.milliseconds);
+  if (node.kind === "duration") return temporal_js.Duration.fromMilliseconds(node.milliseconds);
+  if (node.kind === "current-instant") {
+    if (!instant) throw new diagnostics_js.KaladaFailure("KALADA_INSTANT_REQUIRED", path);
+    return instant;
+  }
+  const left = temporalOperand(evaluate, node.left, [...path, "left"]);
+  const right = temporalOperand(evaluate, node.right, [...path, "right"]);
+  if (node.kind === "temporal-comparison") {
+    assertSameType(left, right, [...path, "right"]);
+    return compare(node.operator, left.milliseconds, right.milliseconds);
+  }
+  return node.operator === "add" ? add(left, right, [...path, "right"]) : subtract(left, right, [...path, "right"]);
+}
+function temporalOperand(evaluate, node, path) {
+  const value = evaluate(node, path);
+  if (!temporal_js.isInstant(value) && !temporal_js.isDuration(value)) mismatch(path);
+  return value;
+}
+function add(left, right, path) {
+  if (temporal_js.isInstant(left) && temporal_js.isDuration(right)) {
+    return temporal_js.Instant.fromMilliseconds(checked(left.milliseconds + right.milliseconds, path));
+  }
+  if (temporal_js.isDuration(left) && temporal_js.isDuration(right)) {
+    return temporal_js.Duration.fromMilliseconds(checked(left.milliseconds + right.milliseconds, path));
+  }
+  return mismatch(path);
+}
+function subtract(left, right, path) {
+  if (temporal_js.isInstant(left) && temporal_js.isInstant(right)) {
+    return temporal_js.Duration.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));
+  }
+  if (temporal_js.isInstant(left) && temporal_js.isDuration(right)) {
+    return temporal_js.Instant.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));
+  }
+  if (temporal_js.isDuration(left) && temporal_js.isDuration(right)) {
+    return temporal_js.Duration.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));
+  }
+  return mismatch(path);
+}
+function assertSameType(left, right, path) {
+  if (temporal_js.isInstant(left) && !temporal_js.isInstant(right) || temporal_js.isDuration(left) && !temporal_js.isDuration(right)) {
+    mismatch(path);
+  }
+}
+function compare(operator, left, right) {
+  if (operator === "equal") return left === right;
+  if (operator === "not-equal") return left !== right;
+  if (operator === "less-than") return left < right;
+  if (operator === "less-than-or-equal") return left <= right;
+  if (operator === "greater-than") return left > right;
+  return left >= right;
+}
+function checked(output, path) {
+  if (!Number.isSafeInteger(output)) throw new diagnostics_js.KaladaFailure("KALADA_TEMPORAL_OVERFLOW", path);
+  return Object.is(output, -0) ? 0 : output;
+}
+function mismatch(path) {
+  throw new diagnostics_js.KaladaFailure("KALADA_TEMPORAL_TYPE_MISMATCH", path);
+}
+
+exports.applyTemporalBinary = applyTemporalBinary;
+exports.evaluateTemporalExpression = evaluateTemporalExpression;
+exports.isTemporalExpression = isTemporalExpression;
+exports.temporalLeaf = temporalLeaf;
+//# sourceMappingURL=temporal-evaluation.cjs.map
+//# sourceMappingURL=temporal-evaluation.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/temporal-evaluation.ts"],"names":["Instant","Duration","KaladaFailure","isInstant","isDuration"],"mappings":"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","file":"temporal-evaluation.cjs","sourcesContent":["import { KaladaFailure } from \"./diagnostics.js\";\nimport type { JsonValue } from \"./json.js\";\nimport {\n  Duration,\n  type DurationValue,\n  Instant,\n  type InstantValue,\n  isDuration,\n  isInstant,\n} from \"./temporal.js\";\nimport type { KaladaV1Expression } from \"./types.js\";\nimport type { KaladaValue } from \"./values.js\";\n\ntype Path = readonly (string | number)[];\ntype TemporalExpression<R extends JsonValue> = Extract<\n  KaladaV1Expression<R>,\n  { kind: \"instant\" | \"duration\" | \"current-instant\" | `temporal-${string}` }\n>;\ntype TemporalValue = InstantValue | DurationValue;\n\nexport function temporalLeaf(\n  node: Extract<\n    TemporalExpression<JsonValue>,\n    { kind: \"instant\" | \"duration\" | \"current-instant\" }\n  >,\n  path: Path,\n  instant: InstantValue | undefined,\n): TemporalValue {\n  if (node.kind === \"instant\") return Instant.fromMilliseconds(node.milliseconds);\n  if (node.kind === \"duration\") return Duration.fromMilliseconds(node.milliseconds);\n  if (!instant) throw new KaladaFailure(\"KALADA_INSTANT_REQUIRED\", path);\n  return instant;\n}\n\nexport function applyTemporalBinary(\n  kind: \"temporal-arithmetic\" | \"temporal-comparison\",\n  operator: string,\n  left: KaladaValue,\n  right: KaladaValue,\n  rightPath: Path,\n): KaladaValue {\n  if (!isInstant(left) && !isDuration(left)) mismatch(rightPath.slice(0, -1).concat(\"left\"));\n  if (!isInstant(right) && !isDuration(right)) mismatch(rightPath);\n  if (kind === \"temporal-comparison\") {\n    assertSameType(left, right, rightPath);\n    return compare(\n      operator as Parameters<typeof compare>[0],\n      left.milliseconds,\n      right.milliseconds,\n    );\n  }\n  return operator === \"add\" ? add(left, right, rightPath) : subtract(left, right, rightPath);\n}\n\nexport function isTemporalExpression<R extends JsonValue>(\n  node: KaladaV1Expression<R>,\n): node is TemporalExpression<R> {\n  return (\n    node.kind === \"instant\" ||\n    node.kind === \"duration\" ||\n    node.kind === \"current-instant\" ||\n    node.kind === \"temporal-arithmetic\" ||\n    node.kind === \"temporal-comparison\"\n  );\n}\n\nexport function evaluateTemporalExpression<R extends JsonValue>(\n  node: TemporalExpression<R>,\n  path: Path,\n  instant: InstantValue | undefined,\n  evaluate: (node: KaladaV1Expression<R>, path: Path) => KaladaValue,\n): KaladaValue {\n  if (node.kind === \"instant\") return Instant.fromMilliseconds(node.milliseconds);\n  if (node.kind === \"duration\") return Duration.fromMilliseconds(node.milliseconds);\n  if (node.kind === \"current-instant\") {\n    if (!instant) throw new KaladaFailure(\"KALADA_INSTANT_REQUIRED\", path);\n    return instant;\n  }\n  const left = temporalOperand(evaluate, node.left, [...path, \"left\"]);\n  const right = temporalOperand(evaluate, node.right, [...path, \"right\"]);\n  if (node.kind === \"temporal-comparison\") {\n    assertSameType(left, right, [...path, \"right\"]);\n    return compare(node.operator, left.milliseconds, right.milliseconds);\n  }\n  return node.operator === \"add\"\n    ? add(left, right, [...path, \"right\"])\n    : subtract(left, right, [...path, \"right\"]);\n}\n\nfunction temporalOperand<R extends JsonValue>(\n  evaluate: (node: KaladaV1Expression<R>, path: Path) => KaladaValue,\n  node: KaladaV1Expression<R>,\n  path: Path,\n): TemporalValue {\n  const value = evaluate(node, path);\n  if (!isInstant(value) && !isDuration(value)) mismatch(path);\n  return value;\n}\n\nfunction add(left: TemporalValue, right: TemporalValue, path: Path): TemporalValue {\n  if (isInstant(left) && isDuration(right)) {\n    return Instant.fromMilliseconds(checked(left.milliseconds + right.milliseconds, path));\n  }\n  if (isDuration(left) && isDuration(right)) {\n    return Duration.fromMilliseconds(checked(left.milliseconds + right.milliseconds, path));\n  }\n  return mismatch(path);\n}\n\nfunction subtract(left: TemporalValue, right: TemporalValue, path: Path): TemporalValue {\n  if (isInstant(left) && isInstant(right)) {\n    return Duration.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));\n  }\n  if (isInstant(left) && isDuration(right)) {\n    return Instant.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));\n  }\n  if (isDuration(left) && isDuration(right)) {\n    return Duration.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));\n  }\n  return mismatch(path);\n}\n\nfunction assertSameType(left: TemporalValue, right: TemporalValue, path: Path): void {\n  if ((isInstant(left) && !isInstant(right)) || (isDuration(left) && !isDuration(right))) {\n    mismatch(path);\n  }\n}\n\nfunction compare(\n  operator: Extract<KaladaV1Expression, { kind: \"temporal-comparison\" }>[\"operator\"],\n  left: number,\n  right: number,\n): boolean {\n  if (operator === \"equal\") return left === right;\n  if (operator === \"not-equal\") return left !== right;\n  if (operator === \"less-than\") return left < right;\n  if (operator === \"less-than-or-equal\") return left <= right;\n  if (operator === \"greater-than\") return left > right;\n  return left >= right;\n}\n\nfunction checked(output: number, path: Path): number {\n  if (!Number.isSafeInteger(output)) throw new KaladaFailure(\"KALADA_TEMPORAL_OVERFLOW\", path);\n  return Object.is(output, -0) ? 0 : output;\n}\n\nfunction mismatch(path: Path): never {\n  throw new KaladaFailure(\"KALADA_TEMPORAL_TYPE_MISMATCH\", path);\n}\n"]}

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

@@ -0,0 +1,18 @@
+import { JsonValue } from './json.cjs';
+import { InstantValue, DurationValue } from './temporal.cjs';
+import { KaladaV1Expression } from './types.cjs';
+import { KaladaValue } from './values.cjs';
+
+type Path = readonly (string | number)[];
+type TemporalExpression<R extends JsonValue> = Extract<KaladaV1Expression<R>, {
+    kind: "instant" | "duration" | "current-instant" | `temporal-${string}`;
+}>;
+type TemporalValue = InstantValue | DurationValue;
+declare function temporalLeaf(node: Extract<TemporalExpression<JsonValue>, {
+    kind: "instant" | "duration" | "current-instant";
+}>, path: Path, instant: InstantValue | undefined): TemporalValue;
+declare function applyTemporalBinary(kind: "temporal-arithmetic" | "temporal-comparison", operator: string, left: KaladaValue, right: KaladaValue, rightPath: Path): KaladaValue;
+declare function isTemporalExpression<R extends JsonValue>(node: KaladaV1Expression<R>): node is TemporalExpression<R>;
+declare function evaluateTemporalExpression<R extends JsonValue>(node: TemporalExpression<R>, path: Path, instant: InstantValue | undefined, evaluate: (node: KaladaV1Expression<R>, path: Path) => KaladaValue): KaladaValue;
+
+export { applyTemporalBinary, evaluateTemporalExpression, isTemporalExpression, temporalLeaf };

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

@@ -0,0 +1,18 @@
+import { JsonValue } from './json.js';
+import { InstantValue, DurationValue } from './temporal.js';
+import { KaladaV1Expression } from './types.js';
+import { KaladaValue } from './values.js';
+
+type Path = readonly (string | number)[];
+type TemporalExpression<R extends JsonValue> = Extract<KaladaV1Expression<R>, {
+    kind: "instant" | "duration" | "current-instant" | `temporal-${string}`;
+}>;
+type TemporalValue = InstantValue | DurationValue;
+declare function temporalLeaf(node: Extract<TemporalExpression<JsonValue>, {
+    kind: "instant" | "duration" | "current-instant";
+}>, path: Path, instant: InstantValue | undefined): TemporalValue;
+declare function applyTemporalBinary(kind: "temporal-arithmetic" | "temporal-comparison", operator: string, left: KaladaValue, right: KaladaValue, rightPath: Path): KaladaValue;
+declare function isTemporalExpression<R extends JsonValue>(node: KaladaV1Expression<R>): node is TemporalExpression<R>;
+declare function evaluateTemporalExpression<R extends JsonValue>(node: TemporalExpression<R>, path: Path, instant: InstantValue | undefined, evaluate: (node: KaladaV1Expression<R>, path: Path) => KaladaValue): KaladaValue;
+
+export { applyTemporalBinary, evaluateTemporalExpression, isTemporalExpression, temporalLeaf };

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

@@ -0,0 +1,90 @@
+import { KaladaFailure } from './diagnostics.js';
+import { Instant, Duration, isInstant, isDuration } from './temporal.js';
+
+function temporalLeaf(node, path, instant) {
+  if (node.kind === "instant") return Instant.fromMilliseconds(node.milliseconds);
+  if (node.kind === "duration") return Duration.fromMilliseconds(node.milliseconds);
+  if (!instant) throw new KaladaFailure("KALADA_INSTANT_REQUIRED", path);
+  return instant;
+}
+function applyTemporalBinary(kind, operator, left, right, rightPath) {
+  if (!isInstant(left) && !isDuration(left)) mismatch(rightPath.slice(0, -1).concat("left"));
+  if (!isInstant(right) && !isDuration(right)) mismatch(rightPath);
+  if (kind === "temporal-comparison") {
+    assertSameType(left, right, rightPath);
+    return compare(
+      operator,
+      left.milliseconds,
+      right.milliseconds
+    );
+  }
+  return operator === "add" ? add(left, right, rightPath) : subtract(left, right, rightPath);
+}
+function isTemporalExpression(node) {
+  return node.kind === "instant" || node.kind === "duration" || node.kind === "current-instant" || node.kind === "temporal-arithmetic" || node.kind === "temporal-comparison";
+}
+function evaluateTemporalExpression(node, path, instant, evaluate) {
+  if (node.kind === "instant") return Instant.fromMilliseconds(node.milliseconds);
+  if (node.kind === "duration") return Duration.fromMilliseconds(node.milliseconds);
+  if (node.kind === "current-instant") {
+    if (!instant) throw new KaladaFailure("KALADA_INSTANT_REQUIRED", path);
+    return instant;
+  }
+  const left = temporalOperand(evaluate, node.left, [...path, "left"]);
+  const right = temporalOperand(evaluate, node.right, [...path, "right"]);
+  if (node.kind === "temporal-comparison") {
+    assertSameType(left, right, [...path, "right"]);
+    return compare(node.operator, left.milliseconds, right.milliseconds);
+  }
+  return node.operator === "add" ? add(left, right, [...path, "right"]) : subtract(left, right, [...path, "right"]);
+}
+function temporalOperand(evaluate, node, path) {
+  const value = evaluate(node, path);
+  if (!isInstant(value) && !isDuration(value)) mismatch(path);
+  return value;
+}
+function add(left, right, path) {
+  if (isInstant(left) && isDuration(right)) {
+    return Instant.fromMilliseconds(checked(left.milliseconds + right.milliseconds, path));
+  }
+  if (isDuration(left) && isDuration(right)) {
+    return Duration.fromMilliseconds(checked(left.milliseconds + right.milliseconds, path));
+  }
+  return mismatch(path);
+}
+function subtract(left, right, path) {
+  if (isInstant(left) && isInstant(right)) {
+    return Duration.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));
+  }
+  if (isInstant(left) && isDuration(right)) {
+    return Instant.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));
+  }
+  if (isDuration(left) && isDuration(right)) {
+    return Duration.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));
+  }
+  return mismatch(path);
+}
+function assertSameType(left, right, path) {
+  if (isInstant(left) && !isInstant(right) || isDuration(left) && !isDuration(right)) {
+    mismatch(path);
+  }
+}
+function compare(operator, left, right) {
+  if (operator === "equal") return left === right;
+  if (operator === "not-equal") return left !== right;
+  if (operator === "less-than") return left < right;
+  if (operator === "less-than-or-equal") return left <= right;
+  if (operator === "greater-than") return left > right;
+  return left >= right;
+}
+function checked(output, path) {
+  if (!Number.isSafeInteger(output)) throw new KaladaFailure("KALADA_TEMPORAL_OVERFLOW", path);
+  return Object.is(output, -0) ? 0 : output;
+}
+function mismatch(path) {
+  throw new KaladaFailure("KALADA_TEMPORAL_TYPE_MISMATCH", path);
+}
+
+export { applyTemporalBinary, evaluateTemporalExpression, isTemporalExpression, temporalLeaf };
+//# sourceMappingURL=temporal-evaluation.js.map
+//# sourceMappingURL=temporal-evaluation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/temporal-evaluation.ts"],"names":[],"mappings":";;;AAoBO,SAAS,YAAA,CACd,IAAA,EAIA,IAAA,EACA,OAAA,EACe;AACf,EAAA,IAAI,KAAK,IAAA,KAAS,SAAA,SAAkB,OAAA,CAAQ,gBAAA,CAAiB,KAAK,YAAY,CAAA;AAC9E,EAAA,IAAI,KAAK,IAAA,KAAS,UAAA,SAAmB,QAAA,CAAS,gBAAA,CAAiB,KAAK,YAAY,CAAA;AAChF,EAAA,IAAI,CAAC,OAAA,EAAS,MAAM,IAAI,aAAA,CAAc,2BAA2B,IAAI,CAAA;AACrE,EAAA,OAAO,OAAA;AACT;AAEO,SAAS,mBAAA,CACd,IAAA,EACA,QAAA,EACA,IAAA,EACA,OACA,SAAA,EACa;AACb,EAAA,IAAI,CAAC,SAAA,CAAU,IAAI,CAAA,IAAK,CAAC,WAAW,IAAI,CAAA,EAAG,QAAA,CAAS,SAAA,CAAU,MAAM,CAAA,EAAG,EAAE,CAAA,CAAE,MAAA,CAAO,MAAM,CAAC,CAAA;AACzF,EAAA,IAAI,CAAC,UAAU,KAAK,CAAA,IAAK,CAAC,UAAA,CAAW,KAAK,CAAA,EAAG,QAAA,CAAS,SAAS,CAAA;AAC/D,EAAA,IAAI,SAAS,qBAAA,EAAuB;AAClC,IAAA,cAAA,CAAe,IAAA,EAAM,OAAO,SAAS,CAAA;AACrC,IAAA,OAAO,OAAA;AAAA,MACL,QAAA;AAAA,MACA,IAAA,CAAK,YAAA;AAAA,MACL,KAAA,CAAM;AAAA,KACR;AAAA,EACF;AACA,EAAA,OAAO,QAAA,KAAa,KAAA,GAAQ,GAAA,CAAI,IAAA,EAAM,KAAA,EAAO,SAAS,CAAA,GAAI,QAAA,CAAS,IAAA,EAAM,KAAA,EAAO,SAAS,CAAA;AAC3F;AAEO,SAAS,qBACd,IAAA,EAC+B;AAC/B,EAAA,OACE,IAAA,CAAK,IAAA,KAAS,SAAA,IACd,IAAA,CAAK,IAAA,KAAS,UAAA,IACd,IAAA,CAAK,IAAA,KAAS,iBAAA,IACd,IAAA,CAAK,IAAA,KAAS,qBAAA,IACd,KAAK,IAAA,KAAS,qBAAA;AAElB;AAEO,SAAS,0BAAA,CACd,IAAA,EACA,IAAA,EACA,OAAA,EACA,QAAA,EACa;AACb,EAAA,IAAI,KAAK,IAAA,KAAS,SAAA,SAAkB,OAAA,CAAQ,gBAAA,CAAiB,KAAK,YAAY,CAAA;AAC9E,EAAA,IAAI,KAAK,IAAA,KAAS,UAAA,SAAmB,QAAA,CAAS,gBAAA,CAAiB,KAAK,YAAY,CAAA;AAChF,EAAA,IAAI,IAAA,CAAK,SAAS,iBAAA,EAAmB;AACnC,IAAA,IAAI,CAAC,OAAA,EAAS,MAAM,IAAI,aAAA,CAAc,2BAA2B,IAAI,CAAA;AACrE,IAAA,OAAO,OAAA;AAAA,EACT;AACA,EAAA,MAAM,IAAA,GAAO,gBAAgB,QAAA,EAAU,IAAA,CAAK,MAAM,CAAC,GAAG,IAAA,EAAM,MAAM,CAAC,CAAA;AACnE,EAAA,MAAM,KAAA,GAAQ,gBAAgB,QAAA,EAAU,IAAA,CAAK,OAAO,CAAC,GAAG,IAAA,EAAM,OAAO,CAAC,CAAA;AACtE,EAAA,IAAI,IAAA,CAAK,SAAS,qBAAA,EAAuB;AACvC,IAAA,cAAA,CAAe,MAAM,KAAA,EAAO,CAAC,GAAG,IAAA,EAAM,OAAO,CAAC,CAAA;AAC9C,IAAA,OAAO,QAAQ,IAAA,CAAK,QAAA,EAAU,IAAA,CAAK,YAAA,EAAc,MAAM,YAAY,CAAA;AAAA,EACrE;AACA,EAAA,OAAO,KAAK,QAAA,KAAa,KAAA,GACrB,IAAI,IAAA,EAAM,KAAA,EAAO,CAAC,GAAG,IAAA,EAAM,OAAO,CAAC,CAAA,GACnC,SAAS,IAAA,EAAM,KAAA,EAAO,CAAC,GAAG,IAAA,EAAM,OAAO,CAAC,CAAA;AAC9C;AAEA,SAAS,eAAA,CACP,QAAA,EACA,IAAA,EACA,IAAA,EACe;AACf,EAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,IAAA,EAAM,IAAI,CAAA;AACjC,EAAA,IAAI,CAAC,UAAU,KAAK,CAAA,IAAK,CAAC,UAAA,CAAW,KAAK,CAAA,EAAG,QAAA,CAAS,IAAI,CAAA;AAC1D,EAAA,OAAO,KAAA;AACT;AAEA,SAAS,GAAA,CAAI,IAAA,EAAqB,KAAA,EAAsB,IAAA,EAA2B;AACjF,EAAA,IAAI,SAAA,CAAU,IAAI,CAAA,IAAK,UAAA,CAAW,KAAK,CAAA,EAAG;AACxC,IAAA,OAAO,OAAA,CAAQ,iBAAiB,OAAA,CAAQ,IAAA,CAAK,eAAe,KAAA,CAAM,YAAA,EAAc,IAAI,CAAC,CAAA;AAAA,EACvF;AACA,EAAA,IAAI,UAAA,CAAW,IAAI,CAAA,IAAK,UAAA,CAAW,KAAK,CAAA,EAAG;AACzC,IAAA,OAAO,QAAA,CAAS,iBAAiB,OAAA,CAAQ,IAAA,CAAK,eAAe,KAAA,CAAM,YAAA,EAAc,IAAI,CAAC,CAAA;AAAA,EACxF;AACA,EAAA,OAAO,SAAS,IAAI,CAAA;AACtB;AAEA,SAAS,QAAA,CAAS,IAAA,EAAqB,KAAA,EAAsB,IAAA,EAA2B;AACtF,EAAA,IAAI,SAAA,CAAU,IAAI,CAAA,IAAK,SAAA,CAAU,KAAK,CAAA,EAAG;AACvC,IAAA,OAAO,QAAA,CAAS,iBAAiB,OAAA,CAAQ,IAAA,CAAK,eAAe,KAAA,CAAM,YAAA,EAAc,IAAI,CAAC,CAAA;AAAA,EACxF;AACA,EAAA,IAAI,SAAA,CAAU,IAAI,CAAA,IAAK,UAAA,CAAW,KAAK,CAAA,EAAG;AACxC,IAAA,OAAO,OAAA,CAAQ,iBAAiB,OAAA,CAAQ,IAAA,CAAK,eAAe,KAAA,CAAM,YAAA,EAAc,IAAI,CAAC,CAAA;AAAA,EACvF;AACA,EAAA,IAAI,UAAA,CAAW,IAAI,CAAA,IAAK,UAAA,CAAW,KAAK,CAAA,EAAG;AACzC,IAAA,OAAO,QAAA,CAAS,iBAAiB,OAAA,CAAQ,IAAA,CAAK,eAAe,KAAA,CAAM,YAAA,EAAc,IAAI,CAAC,CAAA;AAAA,EACxF;AACA,EAAA,OAAO,SAAS,IAAI,CAAA;AACtB;AAEA,SAAS,cAAA,CAAe,IAAA,EAAqB,KAAA,EAAsB,IAAA,EAAkB;AACnF,EAAA,IAAK,SAAA,CAAU,IAAI,CAAA,IAAK,CAAC,SAAA,CAAU,KAAK,CAAA,IAAO,UAAA,CAAW,IAAI,CAAA,IAAK,CAAC,UAAA,CAAW,KAAK,CAAA,EAAI;AACtF,IAAA,QAAA,CAAS,IAAI,CAAA;AAAA,EACf;AACF;AAEA,SAAS,OAAA,CACP,QAAA,EACA,IAAA,EACA,KAAA,EACS;AACT,EAAA,IAAI,QAAA,KAAa,OAAA,EAAS,OAAO,IAAA,KAAS,KAAA;AAC1C,EAAA,IAAI,QAAA,KAAa,WAAA,EAAa,OAAO,IAAA,KAAS,KAAA;AAC9C,EAAA,IAAI,QAAA,KAAa,WAAA,EAAa,OAAO,IAAA,GAAO,KAAA;AAC5C,EAAA,IAAI,QAAA,KAAa,oBAAA,EAAsB,OAAO,IAAA,IAAQ,KAAA;AACtD,EAAA,IAAI,QAAA,KAAa,cAAA,EAAgB,OAAO,IAAA,GAAO,KAAA;AAC/C,EAAA,OAAO,IAAA,IAAQ,KAAA;AACjB;AAEA,SAAS,OAAA,CAAQ,QAAgB,IAAA,EAAoB;AACnD,EAAA,IAAI,CAAC,OAAO,aAAA,CAAc,MAAM,GAAG,MAAM,IAAI,aAAA,CAAc,0BAAA,EAA4B,IAAI,CAAA;AAC3F,EAAA,OAAO,MAAA,CAAO,EAAA,CAAG,MAAA,EAAQ,EAAE,IAAI,CAAA,GAAI,MAAA;AACrC;AAEA,SAAS,SAAS,IAAA,EAAmB;AACnC,EAAA,MAAM,IAAI,aAAA,CAAc,+BAAA,EAAiC,IAAI,CAAA;AAC/D","file":"temporal-evaluation.js","sourcesContent":["import { KaladaFailure } from \"./diagnostics.js\";\nimport type { JsonValue } from \"./json.js\";\nimport {\n  Duration,\n  type DurationValue,\n  Instant,\n  type InstantValue,\n  isDuration,\n  isInstant,\n} from \"./temporal.js\";\nimport type { KaladaV1Expression } from \"./types.js\";\nimport type { KaladaValue } from \"./values.js\";\n\ntype Path = readonly (string | number)[];\ntype TemporalExpression<R extends JsonValue> = Extract<\n  KaladaV1Expression<R>,\n  { kind: \"instant\" | \"duration\" | \"current-instant\" | `temporal-${string}` }\n>;\ntype TemporalValue = InstantValue | DurationValue;\n\nexport function temporalLeaf(\n  node: Extract<\n    TemporalExpression<JsonValue>,\n    { kind: \"instant\" | \"duration\" | \"current-instant\" }\n  >,\n  path: Path,\n  instant: InstantValue | undefined,\n): TemporalValue {\n  if (node.kind === \"instant\") return Instant.fromMilliseconds(node.milliseconds);\n  if (node.kind === \"duration\") return Duration.fromMilliseconds(node.milliseconds);\n  if (!instant) throw new KaladaFailure(\"KALADA_INSTANT_REQUIRED\", path);\n  return instant;\n}\n\nexport function applyTemporalBinary(\n  kind: \"temporal-arithmetic\" | \"temporal-comparison\",\n  operator: string,\n  left: KaladaValue,\n  right: KaladaValue,\n  rightPath: Path,\n): KaladaValue {\n  if (!isInstant(left) && !isDuration(left)) mismatch(rightPath.slice(0, -1).concat(\"left\"));\n  if (!isInstant(right) && !isDuration(right)) mismatch(rightPath);\n  if (kind === \"temporal-comparison\") {\n    assertSameType(left, right, rightPath);\n    return compare(\n      operator as Parameters<typeof compare>[0],\n      left.milliseconds,\n      right.milliseconds,\n    );\n  }\n  return operator === \"add\" ? add(left, right, rightPath) : subtract(left, right, rightPath);\n}\n\nexport function isTemporalExpression<R extends JsonValue>(\n  node: KaladaV1Expression<R>,\n): node is TemporalExpression<R> {\n  return (\n    node.kind === \"instant\" ||\n    node.kind === \"duration\" ||\n    node.kind === \"current-instant\" ||\n    node.kind === \"temporal-arithmetic\" ||\n    node.kind === \"temporal-comparison\"\n  );\n}\n\nexport function evaluateTemporalExpression<R extends JsonValue>(\n  node: TemporalExpression<R>,\n  path: Path,\n  instant: InstantValue | undefined,\n  evaluate: (node: KaladaV1Expression<R>, path: Path) => KaladaValue,\n): KaladaValue {\n  if (node.kind === \"instant\") return Instant.fromMilliseconds(node.milliseconds);\n  if (node.kind === \"duration\") return Duration.fromMilliseconds(node.milliseconds);\n  if (node.kind === \"current-instant\") {\n    if (!instant) throw new KaladaFailure(\"KALADA_INSTANT_REQUIRED\", path);\n    return instant;\n  }\n  const left = temporalOperand(evaluate, node.left, [...path, \"left\"]);\n  const right = temporalOperand(evaluate, node.right, [...path, \"right\"]);\n  if (node.kind === \"temporal-comparison\") {\n    assertSameType(left, right, [...path, \"right\"]);\n    return compare(node.operator, left.milliseconds, right.milliseconds);\n  }\n  return node.operator === \"add\"\n    ? add(left, right, [...path, \"right\"])\n    : subtract(left, right, [...path, \"right\"]);\n}\n\nfunction temporalOperand<R extends JsonValue>(\n  evaluate: (node: KaladaV1Expression<R>, path: Path) => KaladaValue,\n  node: KaladaV1Expression<R>,\n  path: Path,\n): TemporalValue {\n  const value = evaluate(node, path);\n  if (!isInstant(value) && !isDuration(value)) mismatch(path);\n  return value;\n}\n\nfunction add(left: TemporalValue, right: TemporalValue, path: Path): TemporalValue {\n  if (isInstant(left) && isDuration(right)) {\n    return Instant.fromMilliseconds(checked(left.milliseconds + right.milliseconds, path));\n  }\n  if (isDuration(left) && isDuration(right)) {\n    return Duration.fromMilliseconds(checked(left.milliseconds + right.milliseconds, path));\n  }\n  return mismatch(path);\n}\n\nfunction subtract(left: TemporalValue, right: TemporalValue, path: Path): TemporalValue {\n  if (isInstant(left) && isInstant(right)) {\n    return Duration.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));\n  }\n  if (isInstant(left) && isDuration(right)) {\n    return Instant.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));\n  }\n  if (isDuration(left) && isDuration(right)) {\n    return Duration.fromMilliseconds(checked(left.milliseconds - right.milliseconds, path));\n  }\n  return mismatch(path);\n}\n\nfunction assertSameType(left: TemporalValue, right: TemporalValue, path: Path): void {\n  if ((isInstant(left) && !isInstant(right)) || (isDuration(left) && !isDuration(right))) {\n    mismatch(path);\n  }\n}\n\nfunction compare(\n  operator: Extract<KaladaV1Expression, { kind: \"temporal-comparison\" }>[\"operator\"],\n  left: number,\n  right: number,\n): boolean {\n  if (operator === \"equal\") return left === right;\n  if (operator === \"not-equal\") return left !== right;\n  if (operator === \"less-than\") return left < right;\n  if (operator === \"less-than-or-equal\") return left <= right;\n  if (operator === \"greater-than\") return left > right;\n  return left >= right;\n}\n\nfunction checked(output: number, path: Path): number {\n  if (!Number.isSafeInteger(output)) throw new KaladaFailure(\"KALADA_TEMPORAL_OVERFLOW\", path);\n  return Object.is(output, -0) ? 0 : output;\n}\n\nfunction mismatch(path: Path): never {\n  throw new KaladaFailure(\"KALADA_TEMPORAL_TYPE_MISMATCH\", path);\n}\n"]}

package/dist/kalada-v1/temporal.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+const instantBrands = /* @__PURE__ */ new WeakSet();
+const durationBrands = /* @__PURE__ */ new WeakSet();
+function milliseconds(input) {
+  if (!Number.isSafeInteger(input)) throw new RangeError("Milliseconds must be a safe integer.");
+  return Object.is(input, -0) ? 0 : input;
+}
+function branded(brands, value) {
+  Object.freeze(value);
+  brands.add(value);
+  return value;
+}
+const Instant = Object.freeze({
+  fromMilliseconds(value) {
+    return branded(instantBrands, {
+      type: "Instant",
+      milliseconds: milliseconds(value)
+    });
+  }
+});
+const Duration = Object.freeze({
+  fromMilliseconds(value) {
+    return branded(durationBrands, {
+      type: "Duration",
+      milliseconds: milliseconds(value)
+    });
+  }
+});
+function isInstant(value) {
+  return typeof value === "object" && value !== null && instantBrands.has(value);
+}
+function isDuration(value) {
+  return typeof value === "object" && value !== null && durationBrands.has(value);
+}
+
+exports.Duration = Duration;
+exports.Instant = Instant;
+exports.isDuration = isDuration;
+exports.isInstant = isInstant;
+//# sourceMappingURL=temporal.cjs.map
+//# sourceMappingURL=temporal.cjs.map

package/dist/kalada-v1/temporal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/temporal.ts"],"names":[],"mappings":";;AAAA,MAAM,aAAA,uBAAoB,OAAA,EAAgB;AAC1C,MAAM,cAAA,uBAAqB,OAAA,EAAgB;AAiB3C,SAAS,aAAa,KAAA,EAAuB;AAC3C,EAAA,IAAI,CAAC,OAAO,aAAA,CAAc,KAAK,GAAG,MAAM,IAAI,WAAW,sCAAsC,CAAA;AAC7F,EAAA,OAAO,MAAA,CAAO,EAAA,CAAG,KAAA,EAAO,EAAE,IAAI,CAAA,GAAI,KAAA;AACpC;AAEA,SAAS,OAAA,CAA0B,QAAyB,KAAA,EAAa;AACvE,EAAA,MAAA,CAAO,OAAO,KAAK,CAAA;AACnB,EAAA,MAAA,CAAO,IAAI,KAAK,CAAA;AAChB,EAAA,OAAO,KAAA;AACT;AAEO,MAAM,OAAA,GAAU,OAAO,MAAA,CAAO;AAAA,EACnC,iBAAiB,KAAA,EAA6B;AAC5C,IAAA,OAAO,QAAQ,aAAA,EAAe;AAAA,MAC5B,IAAA,EAAM,SAAA;AAAA,MACN,YAAA,EAAc,aAAa,KAAK;AAAA,KACjB,CAAA;AAAA,EACnB;AACF,CAAC;AAEM,MAAM,QAAA,GAAW,OAAO,MAAA,CAAO;AAAA,EACpC,iBAAiB,KAAA,EAA8B;AAC7C,IAAA,OAAO,QAAQ,cAAA,EAAgB;AAAA,MAC7B,IAAA,EAAM,UAAA;AAAA,MACN,YAAA,EAAc,aAAa,KAAK;AAAA,KAChB,CAAA;AAAA,EACpB;AACF,CAAC;AAEM,SAAS,UAAU,KAAA,EAAuC;AAC/D,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,UAAU,IAAA,IAAQ,aAAA,CAAc,IAAI,KAAK,CAAA;AAC/E;AAEO,SAAS,WAAW,KAAA,EAAwC;AACjE,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,UAAU,IAAA,IAAQ,cAAA,CAAe,IAAI,KAAK,CAAA;AAChF","file":"temporal.cjs","sourcesContent":["const instantBrands = new WeakSet<object>();\nconst durationBrands = new WeakSet<object>();\n\ndeclare const instantBrand: unique symbol;\ndeclare const durationBrand: unique symbol;\n\nexport interface InstantValue {\n  readonly [instantBrand]: true;\n  readonly type: \"Instant\";\n  readonly milliseconds: number;\n}\n\nexport interface DurationValue {\n  readonly [durationBrand]: true;\n  readonly type: \"Duration\";\n  readonly milliseconds: number;\n}\n\nfunction milliseconds(input: number): number {\n  if (!Number.isSafeInteger(input)) throw new RangeError(\"Milliseconds must be a safe integer.\");\n  return Object.is(input, -0) ? 0 : input;\n}\n\nfunction branded<T extends object>(brands: WeakSet<object>, value: T): T {\n  Object.freeze(value);\n  brands.add(value);\n  return value;\n}\n\nexport const Instant = Object.freeze({\n  fromMilliseconds(value: number): InstantValue {\n    return branded(instantBrands, {\n      type: \"Instant\",\n      milliseconds: milliseconds(value),\n    } as InstantValue);\n  },\n});\n\nexport const Duration = Object.freeze({\n  fromMilliseconds(value: number): DurationValue {\n    return branded(durationBrands, {\n      type: \"Duration\",\n      milliseconds: milliseconds(value),\n    } as DurationValue);\n  },\n});\n\nexport function isInstant(value: unknown): value is InstantValue {\n  return typeof value === \"object\" && value !== null && instantBrands.has(value);\n}\n\nexport function isDuration(value: unknown): value is DurationValue {\n  return typeof value === \"object\" && value !== null && durationBrands.has(value);\n}\n"]}

package/dist/kalada-v1/temporal.d.cts

@@ -0,0 +1,22 @@
+declare const instantBrand: unique symbol;
+declare const durationBrand: unique symbol;
+interface InstantValue {
+    readonly [instantBrand]: true;
+    readonly type: "Instant";
+    readonly milliseconds: number;
+}
+interface DurationValue {
+    readonly [durationBrand]: true;
+    readonly type: "Duration";
+    readonly milliseconds: number;
+}
+declare const Instant: Readonly<{
+    fromMilliseconds(value: number): InstantValue;
+}>;
+declare const Duration: Readonly<{
+    fromMilliseconds(value: number): DurationValue;
+}>;
+declare function isInstant(value: unknown): value is InstantValue;
+declare function isDuration(value: unknown): value is DurationValue;
+
+export { Duration, type DurationValue, Instant, type InstantValue, isDuration, isInstant };

package/dist/kalada-v1/temporal.d.ts

@@ -0,0 +1,22 @@
+declare const instantBrand: unique symbol;
+declare const durationBrand: unique symbol;
+interface InstantValue {
+    readonly [instantBrand]: true;
+    readonly type: "Instant";
+    readonly milliseconds: number;
+}
+interface DurationValue {
+    readonly [durationBrand]: true;
+    readonly type: "Duration";
+    readonly milliseconds: number;
+}
+declare const Instant: Readonly<{
+    fromMilliseconds(value: number): InstantValue;
+}>;
+declare const Duration: Readonly<{
+    fromMilliseconds(value: number): DurationValue;
+}>;
+declare function isInstant(value: unknown): value is InstantValue;
+declare function isDuration(value: unknown): value is DurationValue;
+
+export { Duration, type DurationValue, Instant, type InstantValue, isDuration, isInstant };

package/dist/kalada-v1/temporal.js

@@ -0,0 +1,37 @@
+const instantBrands = /* @__PURE__ */ new WeakSet();
+const durationBrands = /* @__PURE__ */ new WeakSet();
+function milliseconds(input) {
+  if (!Number.isSafeInteger(input)) throw new RangeError("Milliseconds must be a safe integer.");
+  return Object.is(input, -0) ? 0 : input;
+}
+function branded(brands, value) {
+  Object.freeze(value);
+  brands.add(value);
+  return value;
+}
+const Instant = Object.freeze({
+  fromMilliseconds(value) {
+    return branded(instantBrands, {
+      type: "Instant",
+      milliseconds: milliseconds(value)
+    });
+  }
+});
+const Duration = Object.freeze({
+  fromMilliseconds(value) {
+    return branded(durationBrands, {
+      type: "Duration",
+      milliseconds: milliseconds(value)
+    });
+  }
+});
+function isInstant(value) {
+  return typeof value === "object" && value !== null && instantBrands.has(value);
+}
+function isDuration(value) {
+  return typeof value === "object" && value !== null && durationBrands.has(value);
+}
+
+export { Duration, Instant, isDuration, isInstant };
+//# sourceMappingURL=temporal.js.map
+//# sourceMappingURL=temporal.js.map

package/dist/kalada-v1/temporal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/temporal.ts"],"names":[],"mappings":"AAAA,MAAM,aAAA,uBAAoB,OAAA,EAAgB;AAC1C,MAAM,cAAA,uBAAqB,OAAA,EAAgB;AAiB3C,SAAS,aAAa,KAAA,EAAuB;AAC3C,EAAA,IAAI,CAAC,OAAO,aAAA,CAAc,KAAK,GAAG,MAAM,IAAI,WAAW,sCAAsC,CAAA;AAC7F,EAAA,OAAO,MAAA,CAAO,EAAA,CAAG,KAAA,EAAO,EAAE,IAAI,CAAA,GAAI,KAAA;AACpC;AAEA,SAAS,OAAA,CAA0B,QAAyB,KAAA,EAAa;AACvE,EAAA,MAAA,CAAO,OAAO,KAAK,CAAA;AACnB,EAAA,MAAA,CAAO,IAAI,KAAK,CAAA;AAChB,EAAA,OAAO,KAAA;AACT;AAEO,MAAM,OAAA,GAAU,OAAO,MAAA,CAAO;AAAA,EACnC,iBAAiB,KAAA,EAA6B;AAC5C,IAAA,OAAO,QAAQ,aAAA,EAAe;AAAA,MAC5B,IAAA,EAAM,SAAA;AAAA,MACN,YAAA,EAAc,aAAa,KAAK;AAAA,KACjB,CAAA;AAAA,EACnB;AACF,CAAC;AAEM,MAAM,QAAA,GAAW,OAAO,MAAA,CAAO;AAAA,EACpC,iBAAiB,KAAA,EAA8B;AAC7C,IAAA,OAAO,QAAQ,cAAA,EAAgB;AAAA,MAC7B,IAAA,EAAM,UAAA;AAAA,MACN,YAAA,EAAc,aAAa,KAAK;AAAA,KAChB,CAAA;AAAA,EACpB;AACF,CAAC;AAEM,SAAS,UAAU,KAAA,EAAuC;AAC/D,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,UAAU,IAAA,IAAQ,aAAA,CAAc,IAAI,KAAK,CAAA;AAC/E;AAEO,SAAS,WAAW,KAAA,EAAwC;AACjE,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,UAAU,IAAA,IAAQ,cAAA,CAAe,IAAI,KAAK,CAAA;AAChF","file":"temporal.js","sourcesContent":["const instantBrands = new WeakSet<object>();\nconst durationBrands = new WeakSet<object>();\n\ndeclare const instantBrand: unique symbol;\ndeclare const durationBrand: unique symbol;\n\nexport interface InstantValue {\n  readonly [instantBrand]: true;\n  readonly type: \"Instant\";\n  readonly milliseconds: number;\n}\n\nexport interface DurationValue {\n  readonly [durationBrand]: true;\n  readonly type: \"Duration\";\n  readonly milliseconds: number;\n}\n\nfunction milliseconds(input: number): number {\n  if (!Number.isSafeInteger(input)) throw new RangeError(\"Milliseconds must be a safe integer.\");\n  return Object.is(input, -0) ? 0 : input;\n}\n\nfunction branded<T extends object>(brands: WeakSet<object>, value: T): T {\n  Object.freeze(value);\n  brands.add(value);\n  return value;\n}\n\nexport const Instant = Object.freeze({\n  fromMilliseconds(value: number): InstantValue {\n    return branded(instantBrands, {\n      type: \"Instant\",\n      milliseconds: milliseconds(value),\n    } as InstantValue);\n  },\n});\n\nexport const Duration = Object.freeze({\n  fromMilliseconds(value: number): DurationValue {\n    return branded(durationBrands, {\n      type: \"Duration\",\n      milliseconds: milliseconds(value),\n    } as DurationValue);\n  },\n});\n\nexport function isInstant(value: unknown): value is InstantValue {\n  return typeof value === \"object\" && value !== null && instantBrands.has(value);\n}\n\nexport function isDuration(value: unknown): value is DurationValue {\n  return typeof value === \"object\" && value !== null && durationBrands.has(value);\n}\n"]}

package/dist/kalada-v1/types.d.cts

@@ -1,4 +1,5 @@
 import { JsonValue } from './json.cjs';
+import { InstantValue } from './temporal.cjs';
 import { KaladaValue } from './values.cjs';
 
 type KaladaV1Expression<R extends JsonValue = string> = {
@@ -7,7 +8,81 @@ type KaladaV1Expression<R extends JsonValue = string> = {
 } | {
     readonly kind: "ref";
     readonly ref: R;
-} | BindingExpression<R> | OptionExpression<R> | ResultExpression<R> | MatchExpression<R>;
+} | BindingExpression<R> | OptionExpression<R> | ResultExpression<R> | MatchExpression<R> | InstantExpression | DurationExpression | CurrentInstantExpression | TemporalArithmeticExpression<R> | TemporalComparisonExpression<R> | FunctionExpression<R> | CallExpression<R> | FunctionGroupExpression<R> | CoreFunctionExpression;
+type KaladaPrimitiveTypeName = "null" | "boolean" | "number" | "string" | "json" | "Instant" | "Duration";
+type KaladaType = {
+    readonly kind: "primitive-type";
+    readonly name: KaladaPrimitiveTypeName;
+} | {
+    readonly kind: "option-type";
+    readonly value: KaladaType;
+} | {
+    readonly kind: "result-type";
+    readonly ok: KaladaType;
+    readonly error: KaladaType;
+} | {
+    readonly kind: "array-type";
+    readonly element: KaladaType;
+} | KaladaFunctionType;
+interface KaladaFunctionType {
+    readonly kind: "function-type";
+    readonly parameters: readonly KaladaType[];
+    readonly returns: KaladaType;
+}
+interface KaladaFunctionParameter {
+    readonly name: string;
+    readonly type: KaladaType;
+}
+interface FunctionExpression<R extends JsonValue> {
+    readonly kind: "function";
+    readonly parameters: readonly KaladaFunctionParameter[];
+    readonly returns: KaladaType;
+    readonly body: KaladaV1Expression<R>;
+}
+interface CallExpression<R extends JsonValue> {
+    readonly kind: "call";
+    readonly callee: KaladaV1Expression<R>;
+    readonly arguments: readonly KaladaV1Expression<R>[];
+}
+interface NamedFunction<R extends JsonValue> {
+    readonly name: string;
+    readonly parameters: readonly KaladaFunctionParameter[];
+    readonly returns: KaladaType;
+    readonly body: KaladaV1Expression<R>;
+}
+interface FunctionGroupExpression<R extends JsonValue> {
+    readonly kind: "function-group";
+    readonly functions: readonly NamedFunction<R>[];
+    readonly body: KaladaV1Expression<R>;
+}
+type KaladaCoreFunctionName = "map" | "filter" | "some" | "every";
+interface CoreFunctionExpression {
+    readonly kind: "core-function";
+    readonly name: KaladaCoreFunctionName;
+}
+interface InstantExpression {
+    readonly kind: "instant";
+    readonly milliseconds: number;
+}
+interface DurationExpression {
+    readonly kind: "duration";
+    readonly milliseconds: number;
+}
+interface CurrentInstantExpression {
+    readonly kind: "current-instant";
+}
+interface TemporalArithmeticExpression<R extends JsonValue> {
+    readonly kind: "temporal-arithmetic";
+    readonly operator: "add" | "subtract";
+    readonly left: KaladaV1Expression<R>;
+    readonly right: KaladaV1Expression<R>;
+}
+interface TemporalComparisonExpression<R extends JsonValue> {
+    readonly kind: "temporal-comparison";
+    readonly operator: "equal" | "not-equal" | "less-than" | "less-than-or-equal" | "greater-than" | "greater-than-or-equal";
+    readonly left: KaladaV1Expression<R>;
+    readonly right: KaladaV1Expression<R>;
+}
 interface BindingExpression<R extends JsonValue> {
     readonly kind: "binding";
     readonly name: string;
@@ -44,11 +119,17 @@ interface KaladaV1Program<R extends JsonValue = string> {
     readonly profile: "kalada-v1";
     readonly expression: KaladaV1Expression<R>;
 }
-type KaladaV1DiagnosticCode = "KALADA_INVALID_INPUT" | "KALADA_LIMIT_EXCEEDED" | "KALADA_INVALID_REFERENCE" | "KALADA_MATCH_MISSING_ARM" | "KALADA_MATCH_DUPLICATE_ARM" | "KALADA_MATCH_UNKNOWN_ARM" | "KALADA_MATCH_UNREACHABLE_ARM" | "KALADA_MATCH_TYPE_MISMATCH" | "KALADA_REFERENCE_ERROR" | "KALADA_REFERENCE_MISSING" | "KALADA_REFERENCE_DENIED" | "KALADA_ASYNC_UNSUPPORTED" | "KALADA_INVALID_RESULT" | "KALADA_EVALUATION_LIMIT";
+type KaladaV1DiagnosticCode = "KALADA_INVALID_INPUT" | "KALADA_LIMIT_EXCEEDED" | "KALADA_INVALID_REFERENCE" | "KALADA_MATCH_MISSING_ARM" | "KALADA_MATCH_DUPLICATE_ARM" | "KALADA_MATCH_UNKNOWN_ARM" | "KALADA_MATCH_UNREACHABLE_ARM" | "KALADA_MATCH_TYPE_MISMATCH" | "KALADA_REFERENCE_ERROR" | "KALADA_REFERENCE_MISSING" | "KALADA_REFERENCE_DENIED" | "KALADA_ASYNC_UNSUPPORTED" | "KALADA_INVALID_RESULT" | "KALADA_EVALUATION_LIMIT" | "KALADA_INSTANT_REQUIRED" | "KALADA_TEMPORAL_TYPE_MISMATCH" | "KALADA_TEMPORAL_OVERFLOW" | "KALADA_CLOCK_ERROR" | "KALADA_INVALID_CLOCK" | "KALADA_DUPLICATE_BINDING" | "KALADA_INVALID_FUNCTION_TYPE" | "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";
+interface KaladaV1DiagnosticContextFrame {
+    readonly kind: "function-call" | "core-call";
+    readonly name: string | null;
+    readonly path: readonly (string | number)[];
+}
 interface KaladaV1Diagnostic {
     readonly code: KaladaV1DiagnosticCode;
     readonly path: readonly (string | number)[];
     readonly message: string;
+    readonly context?: readonly KaladaV1DiagnosticContextFrame[];
 }
 type KaladaV1Outcome<T> = {
     readonly ok: true;
@@ -66,13 +147,29 @@ interface KaladaV1Limits {
     readonly maxReferenceLength: number;
     readonly maxEvaluationSteps: number;
 }
+interface KaladaV1FunctionLimits {
+    readonly maxFunctionParameters: number;
+    readonly maxFunctionGroupSize: number;
+    readonly maxCapturesPerClosure: number;
+    readonly maxCapturedBindings: number;
+    readonly maxClosures: number;
+    readonly maxCallDepth: number;
+    readonly maxContinuationFrames: number;
+    readonly maxCollectionLength: number;
+    readonly maxCollectionIterations: number;
+}
+interface KaladaV1FunctionCapture {
+    readonly path: readonly (string | number)[];
+    readonly name: string | null;
+    readonly captures: readonly string[];
+}
 interface KaladaV1ReferenceCodec<R extends JsonValue> {
     readonly validate: (input: unknown) => input is R;
     readonly canonicalize?: (reference: R) => R;
 }
 interface KaladaV1Options<R extends JsonValue> {
     readonly reference?: KaladaV1ReferenceCodec<R>;
-    readonly limits?: Partial<KaladaV1Limits>;
+    readonly limits?: Partial<KaladaV1Limits & KaladaV1FunctionLimits>;
 }
 type KaladaV1Resolution = {
     readonly found: true;
@@ -82,10 +179,16 @@ type KaladaV1Resolution = {
     readonly reason?: "missing" | "denied";
 };
 type KaladaV1Resolver<R extends JsonValue> = (reference: R) => KaladaV1Resolution;
+interface KaladaV1EvaluationInputs {
+    readonly instant?: InstantValue;
+}
+type KaladaV1Clock = () => InstantValue;
 interface CompiledKaladaV1Program<R extends JsonValue> {
     readonly program: KaladaV1Program<R>;
     readonly dependencies: readonly R[];
-    evaluate(resolve: KaladaV1Resolver<R>): KaladaV1Outcome<KaladaValue>;
+    readonly functions: readonly KaladaV1FunctionCapture[];
+    evaluate(resolve: KaladaV1Resolver<R>, inputs?: KaladaV1EvaluationInputs): KaladaV1Outcome<KaladaValue>;
+    evaluateWithClock(resolve: KaladaV1Resolver<R>, clock: KaladaV1Clock): KaladaV1Outcome<KaladaValue>;
 }
 
-export type { BindingExpression, CompiledKaladaV1Program, KaladaV1Diagnostic, KaladaV1DiagnosticCode, KaladaV1Expression, KaladaV1Limits, KaladaV1Options, KaladaV1Outcome, KaladaV1Program, KaladaV1ReferenceCodec, KaladaV1Resolution, KaladaV1Resolver, MatchArm, MatchExpression, OptionExpression, ResultExpression };
+export type { BindingExpression, CallExpression, CompiledKaladaV1Program, CoreFunctionExpression, CurrentInstantExpression, DurationExpression, FunctionExpression, FunctionGroupExpression, InstantExpression, KaladaCoreFunctionName, KaladaFunctionParameter, KaladaFunctionType, KaladaPrimitiveTypeName, KaladaType, KaladaV1Clock, KaladaV1Diagnostic, KaladaV1DiagnosticCode, KaladaV1DiagnosticContextFrame, KaladaV1EvaluationInputs, KaladaV1Expression, KaladaV1FunctionCapture, KaladaV1FunctionLimits, KaladaV1Limits, KaladaV1Options, KaladaV1Outcome, KaladaV1Program, KaladaV1ReferenceCodec, KaladaV1Resolution, KaladaV1Resolver, MatchArm, MatchExpression, NamedFunction, OptionExpression, ResultExpression, TemporalArithmeticExpression, TemporalComparisonExpression };