@kalada/core 0.2.0 → 0.4.0

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

@@ -0,0 +1,38 @@
+import { KaladaFailure } from './diagnostics.js';
+import { EvaluationFrame, EvaluationTask, Path } from './evaluation-frames.js';
+import { JsonValue } from './json.js';
+import { ResolvedKaladaV1Limits } from './limits.js';
+import { RuntimeValue, RuntimeEnvironment } from './runtime-values.js';
+import { InstantValue } from './temporal.js';
+import { KaladaV1Resolver, KaladaV1FunctionCapture, KaladaV1DiagnosticContextFrame, KaladaV1Expression } from './types.js';
+import './values.js';
+
+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 };

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

@@ -0,0 +1,81 @@
+import { KaladaFailure } from './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 KaladaFailure(code, path);
+}
+function pathKey(path) {
+  return JSON.stringify(path);
+}
+
+export { captureMap, charge, copyCaptures, deliver, diagnosticContext, ensureCapacity, evaluate, fail, push, reserveClosure, reserveCollectionIteration, unwind };
+//# sourceMappingURL=evaluation-state.js.map
+//# sourceMappingURL=evaluation-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/evaluation-state.ts"],"names":[],"mappings":"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","file":"evaluation-state.js","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/factories.cjs

@@ -30,6 +30,34 @@ const err = (value) => ({
 });
 const arm = (variant, body, name) => ({ variant, ...name === void 0 ? {} : { binding: name }, body });
 const match = (type, value, arms) => ({ kind: "match", type, value, arms });
+const instant = (milliseconds) => ({
+  kind: "instant",
+  milliseconds
+});
+const duration = (milliseconds) => ({
+  kind: "duration",
+  milliseconds
+});
+const currentInstant = () => ({
+  kind: "current-instant"
+});
+const temporalArithmetic = (operator, left, right) => ({ kind: "temporal-arithmetic", operator, left, right });
+const temporalComparison = (operator, left, right) => ({ kind: "temporal-comparison", operator, left, right });
+const functionExpression = (parameters, returns, body) => Object.freeze({ kind: "function", parameters: Object.freeze([...parameters]), returns, body });
+const call = (callee, args) => Object.freeze({ kind: "call", callee, arguments: Object.freeze([...args]) });
+const functionGroup = (functions, body) => Object.freeze({ kind: "function-group", functions: Object.freeze([...functions]), body });
+const coreFunction = (name) => Object.freeze({ kind: "core-function", name });
+const parameter = (name, type) => Object.freeze({ name, type });
+const namedFunction = (name, parameters, returns, body) => Object.freeze({ name, parameters: Object.freeze([...parameters]), returns, body });
+const primitiveType = (name) => Object.freeze({ kind: "primitive-type", name });
+const optionType = (value) => Object.freeze({ kind: "option-type", value });
+const resultType = (ok2, error) => Object.freeze({
+  kind: "result-type",
+  ok: ok2,
+  error
+});
+const arrayType = (element) => Object.freeze({ kind: "array-type", element });
+const functionType = (parameters, returns) => Object.freeze({ kind: "function-type", parameters: Object.freeze([...parameters]), returns });
 const KaladaV1 = Object.freeze({
   literal,
   ref,
@@ -38,6 +66,24 @@ const KaladaV1 = Object.freeze({
   Result: Object.freeze({ ok, err }),
   arm,
   match,
+  instant,
+  duration,
+  currentInstant,
+  temporalArithmetic,
+  temporalComparison,
+  function: functionExpression,
+  call,
+  functionGroup,
+  coreFunction,
+  parameter,
+  namedFunction,
+  Type: Object.freeze({
+    primitive: primitiveType,
+    option: optionType,
+    result: resultType,
+    array: arrayType,
+    function: functionType
+  }),
   program(expression) {
     return { format: "kalada-program", version: 1, profile: "kalada-v1", expression };
   }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/kalada-v1/factories.ts"],"names":[],"mappings":";;AAGA,MAAM,OAAA,GAAU,CAA+B,KAAA,MAA6C;AAAA,EAC1F,IAAA,EAAM,SAAA;AAAA,EACN;AACF,CAAA,CAAA;AACA,MAAM,GAAA,GAAM,CAA+B,KAAA,MAAqC;AAAA,EAC9E,IAAA,EAAM,KAAA;AAAA,EACN,GAAA,EAAK;AACP,CAAA,CAAA;AACA,MAAM,OAAA,GAAU,CACd,IAAA,EACA,KAAA,EACA,IAAA,MAC2B,EAAE,IAAA,EAAM,SAAA,EAAW,IAAA,EAAM,KAAA,EAAO,IAAA,EAAK,CAAA;AAClE,MAAM,IAAA,GAAO,CAAsB,KAAA,MAAyD;AAAA,EAC1F,IAAA,EAAM,QAAA;AAAA,EACN,OAAA,EAAS,MAAA;AAAA,EACT;AACF,CAAA,CAAA;AACA,MAAM,OAAO,OAA4D;AAAA,EACvE,IAAA,EAAM,QAAA;AAAA,EACN,OAAA,EAAS;AACX,CAAA,CAAA;AACA,MAAM,EAAA,GAAK,CAAsB,KAAA,MAAyD;AAAA,EACxF,IAAA,EAAM,QAAA;AAAA,EACN,OAAA,EAAS,IAAA;AAAA,EACT;AACF,CAAA,CAAA;AACA,MAAM,GAAA,GAAM,CAAsB,KAAA,MAAyD;AAAA,EACzF,IAAA,EAAM,QAAA;AAAA,EACN,OAAA,EAAS,KAAA;AAAA,EACT;AACF,CAAA,CAAA;AACA,MAAM,MAAM,CACV,OAAA,EACA,IAAA,EACA,IAAA,MACiB,EAAE,OAAA,EAAS,GAAI,IAAA,KAAS,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,IAAA,IAAS,IAAA,EAAK,CAAA;AACrF,MAAM,KAAA,GAAQ,CACZ,IAAA,EACA,KAAA,EACA,IAAA,MAC2B,EAAE,IAAA,EAAM,OAAA,EAAS,IAAA,EAAM,KAAA,EAAO,IAAA,EAAK,CAAA;AAEzD,MAAM,QAAA,GAAW,OAAO,MAAA,CAAO;AAAA,EACpC,OAAA;AAAA,EACA,GAAA;AAAA,EACA,OAAA;AAAA,EACA,QAAQ,MAAA,CAAO,MAAA,CAAO,EAAE,IAAA,EAAM,MAAM,CAAA;AAAA,EACpC,QAAQ,MAAA,CAAO,MAAA,CAAO,EAAE,EAAA,EAAI,KAAK,CAAA;AAAA,EACjC,GAAA;AAAA,EACA,KAAA;AAAA,EACA,QAAsC,UAAA,EAAuD;AAC3F,IAAA,OAAO,EAAE,MAAA,EAAQ,gBAAA,EAAkB,SAAS,CAAA,EAAG,OAAA,EAAS,aAAa,UAAA,EAAW;AAAA,EAClF;AACF,CAAC","file":"factories.cjs","sourcesContent":["import type { JsonValue } from \"./json.js\";\nimport type { KaladaV1Expression, KaladaV1Program, MatchArm } from \"./types.js\";\n\nconst literal = <R extends JsonValue = string>(value: JsonValue): KaladaV1Expression<R> => ({\n  kind: \"literal\",\n  value,\n});\nconst ref = <R extends JsonValue = string>(value: R): KaladaV1Expression<R> => ({\n  kind: \"ref\",\n  ref: value,\n});\nconst binding = <R extends JsonValue>(\n  name: string,\n  value: KaladaV1Expression<R>,\n  body: KaladaV1Expression<R>,\n): KaladaV1Expression<R> => ({ kind: \"binding\", name, value, body });\nconst some = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"option\",\n  variant: \"some\",\n  value,\n});\nconst none = <R extends JsonValue = string>(): KaladaV1Expression<R> => ({\n  kind: \"option\",\n  variant: \"none\",\n});\nconst ok = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"result\",\n  variant: \"ok\",\n  value,\n});\nconst err = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"result\",\n  variant: \"err\",\n  value,\n});\nconst arm = <R extends JsonValue>(\n  variant: MatchArm<R>[\"variant\"],\n  body: KaladaV1Expression<R>,\n  name?: string,\n): MatchArm<R> => ({ variant, ...(name === undefined ? {} : { binding: name }), body });\nconst match = <R extends JsonValue>(\n  type: \"Option\" | \"Result\",\n  value: KaladaV1Expression<R>,\n  arms: readonly MatchArm<R>[],\n): KaladaV1Expression<R> => ({ kind: \"match\", type, value, arms });\n\nexport const KaladaV1 = Object.freeze({\n  literal,\n  ref,\n  binding,\n  Option: Object.freeze({ some, none }),\n  Result: Object.freeze({ ok, err }),\n  arm,\n  match,\n  program<R extends JsonValue = string>(expression: KaladaV1Expression<R>): KaladaV1Program<R> {\n    return { format: \"kalada-program\", version: 1, profile: \"kalada-v1\", expression };\n  },\n});\n"]}
+{"version":3,"sources":["../../src/kalada-v1/factories.ts"],"names":["ok"],"mappings":"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","file":"factories.cjs","sourcesContent":["import type { JsonValue } from \"./json.js\";\nimport type {\n  KaladaCoreFunctionName,\n  KaladaFunctionParameter,\n  KaladaType,\n  KaladaV1Expression,\n  KaladaV1Program,\n  MatchArm,\n  NamedFunction,\n} from \"./types.js\";\n\nconst literal = <R extends JsonValue = string>(value: JsonValue): KaladaV1Expression<R> => ({\n  kind: \"literal\",\n  value,\n});\nconst ref = <R extends JsonValue = string>(value: R): KaladaV1Expression<R> => ({\n  kind: \"ref\",\n  ref: value,\n});\nconst binding = <R extends JsonValue>(\n  name: string,\n  value: KaladaV1Expression<R>,\n  body: KaladaV1Expression<R>,\n): KaladaV1Expression<R> => ({ kind: \"binding\", name, value, body });\nconst some = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"option\",\n  variant: \"some\",\n  value,\n});\nconst none = <R extends JsonValue = string>(): KaladaV1Expression<R> => ({\n  kind: \"option\",\n  variant: \"none\",\n});\nconst ok = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"result\",\n  variant: \"ok\",\n  value,\n});\nconst err = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"result\",\n  variant: \"err\",\n  value,\n});\nconst arm = <R extends JsonValue>(\n  variant: MatchArm<R>[\"variant\"],\n  body: KaladaV1Expression<R>,\n  name?: string,\n): MatchArm<R> => ({ variant, ...(name === undefined ? {} : { binding: name }), body });\nconst match = <R extends JsonValue>(\n  type: \"Option\" | \"Result\",\n  value: KaladaV1Expression<R>,\n  arms: readonly MatchArm<R>[],\n): KaladaV1Expression<R> => ({ kind: \"match\", type, value, arms });\nconst instant = <R extends JsonValue = string>(milliseconds: number): KaladaV1Expression<R> => ({\n  kind: \"instant\",\n  milliseconds,\n});\nconst duration = <R extends JsonValue = string>(milliseconds: number): KaladaV1Expression<R> => ({\n  kind: \"duration\",\n  milliseconds,\n});\nconst currentInstant = <R extends JsonValue = string>(): KaladaV1Expression<R> => ({\n  kind: \"current-instant\",\n});\nconst temporalArithmetic = <R extends JsonValue>(\n  operator: \"add\" | \"subtract\",\n  left: KaladaV1Expression<R>,\n  right: KaladaV1Expression<R>,\n): KaladaV1Expression<R> => ({ kind: \"temporal-arithmetic\", operator, left, right });\nconst temporalComparison = <R extends JsonValue>(\n  operator: Extract<KaladaV1Expression<R>, { kind: \"temporal-comparison\" }>[\"operator\"],\n  left: KaladaV1Expression<R>,\n  right: KaladaV1Expression<R>,\n): KaladaV1Expression<R> => ({ kind: \"temporal-comparison\", operator, left, right });\nconst functionExpression = <R extends JsonValue>(\n  parameters: readonly KaladaFunctionParameter[],\n  returns: KaladaType,\n  body: KaladaV1Expression<R>,\n): KaladaV1Expression<R> =>\n  Object.freeze({ kind: \"function\", parameters: Object.freeze([...parameters]), returns, body });\nconst call = <R extends JsonValue>(\n  callee: KaladaV1Expression<R>,\n  args: readonly KaladaV1Expression<R>[],\n): KaladaV1Expression<R> =>\n  Object.freeze({ kind: \"call\", callee, arguments: Object.freeze([...args]) });\nconst functionGroup = <R extends JsonValue>(\n  functions: readonly NamedFunction<R>[],\n  body: KaladaV1Expression<R>,\n): KaladaV1Expression<R> =>\n  Object.freeze({ kind: \"function-group\", functions: Object.freeze([...functions]), body });\nconst coreFunction = <R extends JsonValue = string>(\n  name: KaladaCoreFunctionName,\n): KaladaV1Expression<R> => Object.freeze({ kind: \"core-function\", name });\nconst parameter = (name: string, type: KaladaType): KaladaFunctionParameter =>\n  Object.freeze({ name, type });\nconst namedFunction = <R extends JsonValue>(\n  name: string,\n  parameters: readonly KaladaFunctionParameter[],\n  returns: KaladaType,\n  body: KaladaV1Expression<R>,\n): NamedFunction<R> =>\n  Object.freeze({ name, parameters: Object.freeze([...parameters]), returns, body });\nconst primitiveType = (name: Extract<KaladaType, { kind: \"primitive-type\" }>[\"name\"]): KaladaType =>\n  Object.freeze({ kind: \"primitive-type\", name });\nconst optionType = (value: KaladaType): KaladaType => Object.freeze({ kind: \"option-type\", value });\nconst resultType = (ok: KaladaType, error: KaladaType): KaladaType =>\n  Object.freeze({\n    kind: \"result-type\",\n    ok,\n    error,\n  });\nconst arrayType = (element: KaladaType): KaladaType =>\n  Object.freeze({ kind: \"array-type\", element });\nconst functionType = (parameters: readonly KaladaType[], returns: KaladaType): KaladaType =>\n  Object.freeze({ kind: \"function-type\", parameters: Object.freeze([...parameters]), returns });\n\nexport const KaladaV1 = Object.freeze({\n  literal,\n  ref,\n  binding,\n  Option: Object.freeze({ some, none }),\n  Result: Object.freeze({ ok, err }),\n  arm,\n  match,\n  instant,\n  duration,\n  currentInstant,\n  temporalArithmetic,\n  temporalComparison,\n  function: functionExpression,\n  call,\n  functionGroup,\n  coreFunction,\n  parameter,\n  namedFunction,\n  Type: Object.freeze({\n    primitive: primitiveType,\n    option: optionType,\n    result: resultType,\n    array: arrayType,\n    function: functionType,\n  }),\n  program<R extends JsonValue = string>(expression: KaladaV1Expression<R>): KaladaV1Program<R> {\n    return { format: \"kalada-program\", version: 1, profile: \"kalada-v1\", expression };\n  },\n});\n"]}

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

@@ -1,5 +1,6 @@
 import { JsonValue } from './json.cjs';
-import { KaladaV1Expression, MatchArm, KaladaV1Program } from './types.cjs';
+import { KaladaV1Expression, MatchArm, KaladaFunctionParameter, KaladaType, NamedFunction, KaladaCoreFunctionName, KaladaV1Program } from './types.cjs';
+import './temporal.cjs';
 import './values.cjs';
 
 declare const KaladaV1: Readonly<{
@@ -16,6 +17,28 @@ declare const KaladaV1: Readonly<{
     }>;
     arm: <R extends JsonValue>(variant: MatchArm<R>["variant"], body: KaladaV1Expression<R>, name?: string) => MatchArm<R>;
     match: <R extends JsonValue>(type: "Option" | "Result", value: KaladaV1Expression<R>, arms: readonly MatchArm<R>[]) => KaladaV1Expression<R>;
+    instant: <R extends JsonValue = string>(milliseconds: number) => KaladaV1Expression<R>;
+    duration: <R extends JsonValue = string>(milliseconds: number) => KaladaV1Expression<R>;
+    currentInstant: <R extends JsonValue = string>() => KaladaV1Expression<R>;
+    temporalArithmetic: <R extends JsonValue>(operator: "add" | "subtract", left: KaladaV1Expression<R>, right: KaladaV1Expression<R>) => KaladaV1Expression<R>;
+    temporalComparison: <R extends JsonValue>(operator: Extract<KaladaV1Expression<R>, {
+        kind: "temporal-comparison";
+    }>["operator"], left: KaladaV1Expression<R>, right: KaladaV1Expression<R>) => KaladaV1Expression<R>;
+    function: <R extends JsonValue>(parameters: readonly KaladaFunctionParameter[], returns: KaladaType, body: KaladaV1Expression<R>) => KaladaV1Expression<R>;
+    call: <R extends JsonValue>(callee: KaladaV1Expression<R>, args: readonly KaladaV1Expression<R>[]) => KaladaV1Expression<R>;
+    functionGroup: <R extends JsonValue>(functions: readonly NamedFunction<R>[], body: KaladaV1Expression<R>) => KaladaV1Expression<R>;
+    coreFunction: <R extends JsonValue = string>(name: KaladaCoreFunctionName) => KaladaV1Expression<R>;
+    parameter: (name: string, type: KaladaType) => KaladaFunctionParameter;
+    namedFunction: <R extends JsonValue>(name: string, parameters: readonly KaladaFunctionParameter[], returns: KaladaType, body: KaladaV1Expression<R>) => NamedFunction<R>;
+    Type: Readonly<{
+        primitive: (name: Extract<KaladaType, {
+            kind: "primitive-type";
+        }>["name"]) => KaladaType;
+        option: (value: KaladaType) => KaladaType;
+        result: (ok: KaladaType, error: KaladaType) => KaladaType;
+        array: (element: KaladaType) => KaladaType;
+        function: (parameters: readonly KaladaType[], returns: KaladaType) => KaladaType;
+    }>;
     program<R extends JsonValue = string>(expression: KaladaV1Expression<R>): KaladaV1Program<R>;
 }>;
 

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

@@ -1,5 +1,6 @@
 import { JsonValue } from './json.js';
-import { KaladaV1Expression, MatchArm, KaladaV1Program } from './types.js';
+import { KaladaV1Expression, MatchArm, KaladaFunctionParameter, KaladaType, NamedFunction, KaladaCoreFunctionName, KaladaV1Program } from './types.js';
+import './temporal.js';
 import './values.js';
 
 declare const KaladaV1: Readonly<{
@@ -16,6 +17,28 @@ declare const KaladaV1: Readonly<{
     }>;
     arm: <R extends JsonValue>(variant: MatchArm<R>["variant"], body: KaladaV1Expression<R>, name?: string) => MatchArm<R>;
     match: <R extends JsonValue>(type: "Option" | "Result", value: KaladaV1Expression<R>, arms: readonly MatchArm<R>[]) => KaladaV1Expression<R>;
+    instant: <R extends JsonValue = string>(milliseconds: number) => KaladaV1Expression<R>;
+    duration: <R extends JsonValue = string>(milliseconds: number) => KaladaV1Expression<R>;
+    currentInstant: <R extends JsonValue = string>() => KaladaV1Expression<R>;
+    temporalArithmetic: <R extends JsonValue>(operator: "add" | "subtract", left: KaladaV1Expression<R>, right: KaladaV1Expression<R>) => KaladaV1Expression<R>;
+    temporalComparison: <R extends JsonValue>(operator: Extract<KaladaV1Expression<R>, {
+        kind: "temporal-comparison";
+    }>["operator"], left: KaladaV1Expression<R>, right: KaladaV1Expression<R>) => KaladaV1Expression<R>;
+    function: <R extends JsonValue>(parameters: readonly KaladaFunctionParameter[], returns: KaladaType, body: KaladaV1Expression<R>) => KaladaV1Expression<R>;
+    call: <R extends JsonValue>(callee: KaladaV1Expression<R>, args: readonly KaladaV1Expression<R>[]) => KaladaV1Expression<R>;
+    functionGroup: <R extends JsonValue>(functions: readonly NamedFunction<R>[], body: KaladaV1Expression<R>) => KaladaV1Expression<R>;
+    coreFunction: <R extends JsonValue = string>(name: KaladaCoreFunctionName) => KaladaV1Expression<R>;
+    parameter: (name: string, type: KaladaType) => KaladaFunctionParameter;
+    namedFunction: <R extends JsonValue>(name: string, parameters: readonly KaladaFunctionParameter[], returns: KaladaType, body: KaladaV1Expression<R>) => NamedFunction<R>;
+    Type: Readonly<{
+        primitive: (name: Extract<KaladaType, {
+            kind: "primitive-type";
+        }>["name"]) => KaladaType;
+        option: (value: KaladaType) => KaladaType;
+        result: (ok: KaladaType, error: KaladaType) => KaladaType;
+        array: (element: KaladaType) => KaladaType;
+        function: (parameters: readonly KaladaType[], returns: KaladaType) => KaladaType;
+    }>;
     program<R extends JsonValue = string>(expression: KaladaV1Expression<R>): KaladaV1Program<R>;
 }>;
 

package/dist/kalada-v1/factories.js

@@ -28,6 +28,34 @@ const err = (value) => ({
 });
 const arm = (variant, body, name) => ({ variant, ...name === void 0 ? {} : { binding: name }, body });
 const match = (type, value, arms) => ({ kind: "match", type, value, arms });
+const instant = (milliseconds) => ({
+  kind: "instant",
+  milliseconds
+});
+const duration = (milliseconds) => ({
+  kind: "duration",
+  milliseconds
+});
+const currentInstant = () => ({
+  kind: "current-instant"
+});
+const temporalArithmetic = (operator, left, right) => ({ kind: "temporal-arithmetic", operator, left, right });
+const temporalComparison = (operator, left, right) => ({ kind: "temporal-comparison", operator, left, right });
+const functionExpression = (parameters, returns, body) => Object.freeze({ kind: "function", parameters: Object.freeze([...parameters]), returns, body });
+const call = (callee, args) => Object.freeze({ kind: "call", callee, arguments: Object.freeze([...args]) });
+const functionGroup = (functions, body) => Object.freeze({ kind: "function-group", functions: Object.freeze([...functions]), body });
+const coreFunction = (name) => Object.freeze({ kind: "core-function", name });
+const parameter = (name, type) => Object.freeze({ name, type });
+const namedFunction = (name, parameters, returns, body) => Object.freeze({ name, parameters: Object.freeze([...parameters]), returns, body });
+const primitiveType = (name) => Object.freeze({ kind: "primitive-type", name });
+const optionType = (value) => Object.freeze({ kind: "option-type", value });
+const resultType = (ok2, error) => Object.freeze({
+  kind: "result-type",
+  ok: ok2,
+  error
+});
+const arrayType = (element) => Object.freeze({ kind: "array-type", element });
+const functionType = (parameters, returns) => Object.freeze({ kind: "function-type", parameters: Object.freeze([...parameters]), returns });
 const KaladaV1 = Object.freeze({
   literal,
   ref,
@@ -36,6 +64,24 @@ const KaladaV1 = Object.freeze({
   Result: Object.freeze({ ok, err }),
   arm,
   match,
+  instant,
+  duration,
+  currentInstant,
+  temporalArithmetic,
+  temporalComparison,
+  function: functionExpression,
+  call,
+  functionGroup,
+  coreFunction,
+  parameter,
+  namedFunction,
+  Type: Object.freeze({
+    primitive: primitiveType,
+    option: optionType,
+    result: resultType,
+    array: arrayType,
+    function: functionType
+  }),
   program(expression) {
     return { format: "kalada-program", version: 1, profile: "kalada-v1", expression };
   }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/kalada-v1/factories.ts"],"names":[],"mappings":"AAGA,MAAM,OAAA,GAAU,CAA+B,KAAA,MAA6C;AAAA,EAC1F,IAAA,EAAM,SAAA;AAAA,EACN;AACF,CAAA,CAAA;AACA,MAAM,GAAA,GAAM,CAA+B,KAAA,MAAqC;AAAA,EAC9E,IAAA,EAAM,KAAA;AAAA,EACN,GAAA,EAAK;AACP,CAAA,CAAA;AACA,MAAM,OAAA,GAAU,CACd,IAAA,EACA,KAAA,EACA,IAAA,MAC2B,EAAE,IAAA,EAAM,SAAA,EAAW,IAAA,EAAM,KAAA,EAAO,IAAA,EAAK,CAAA;AAClE,MAAM,IAAA,GAAO,CAAsB,KAAA,MAAyD;AAAA,EAC1F,IAAA,EAAM,QAAA;AAAA,EACN,OAAA,EAAS,MAAA;AAAA,EACT;AACF,CAAA,CAAA;AACA,MAAM,OAAO,OAA4D;AAAA,EACvE,IAAA,EAAM,QAAA;AAAA,EACN,OAAA,EAAS;AACX,CAAA,CAAA;AACA,MAAM,EAAA,GAAK,CAAsB,KAAA,MAAyD;AAAA,EACxF,IAAA,EAAM,QAAA;AAAA,EACN,OAAA,EAAS,IAAA;AAAA,EACT;AACF,CAAA,CAAA;AACA,MAAM,GAAA,GAAM,CAAsB,KAAA,MAAyD;AAAA,EACzF,IAAA,EAAM,QAAA;AAAA,EACN,OAAA,EAAS,KAAA;AAAA,EACT;AACF,CAAA,CAAA;AACA,MAAM,MAAM,CACV,OAAA,EACA,IAAA,EACA,IAAA,MACiB,EAAE,OAAA,EAAS,GAAI,IAAA,KAAS,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,IAAA,IAAS,IAAA,EAAK,CAAA;AACrF,MAAM,KAAA,GAAQ,CACZ,IAAA,EACA,KAAA,EACA,IAAA,MAC2B,EAAE,IAAA,EAAM,OAAA,EAAS,IAAA,EAAM,KAAA,EAAO,IAAA,EAAK,CAAA;AAEzD,MAAM,QAAA,GAAW,OAAO,MAAA,CAAO;AAAA,EACpC,OAAA;AAAA,EACA,GAAA;AAAA,EACA,OAAA;AAAA,EACA,QAAQ,MAAA,CAAO,MAAA,CAAO,EAAE,IAAA,EAAM,MAAM,CAAA;AAAA,EACpC,QAAQ,MAAA,CAAO,MAAA,CAAO,EAAE,EAAA,EAAI,KAAK,CAAA;AAAA,EACjC,GAAA;AAAA,EACA,KAAA;AAAA,EACA,QAAsC,UAAA,EAAuD;AAC3F,IAAA,OAAO,EAAE,MAAA,EAAQ,gBAAA,EAAkB,SAAS,CAAA,EAAG,OAAA,EAAS,aAAa,UAAA,EAAW;AAAA,EAClF;AACF,CAAC","file":"factories.js","sourcesContent":["import type { JsonValue } from \"./json.js\";\nimport type { KaladaV1Expression, KaladaV1Program, MatchArm } from \"./types.js\";\n\nconst literal = <R extends JsonValue = string>(value: JsonValue): KaladaV1Expression<R> => ({\n  kind: \"literal\",\n  value,\n});\nconst ref = <R extends JsonValue = string>(value: R): KaladaV1Expression<R> => ({\n  kind: \"ref\",\n  ref: value,\n});\nconst binding = <R extends JsonValue>(\n  name: string,\n  value: KaladaV1Expression<R>,\n  body: KaladaV1Expression<R>,\n): KaladaV1Expression<R> => ({ kind: \"binding\", name, value, body });\nconst some = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"option\",\n  variant: \"some\",\n  value,\n});\nconst none = <R extends JsonValue = string>(): KaladaV1Expression<R> => ({\n  kind: \"option\",\n  variant: \"none\",\n});\nconst ok = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"result\",\n  variant: \"ok\",\n  value,\n});\nconst err = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"result\",\n  variant: \"err\",\n  value,\n});\nconst arm = <R extends JsonValue>(\n  variant: MatchArm<R>[\"variant\"],\n  body: KaladaV1Expression<R>,\n  name?: string,\n): MatchArm<R> => ({ variant, ...(name === undefined ? {} : { binding: name }), body });\nconst match = <R extends JsonValue>(\n  type: \"Option\" | \"Result\",\n  value: KaladaV1Expression<R>,\n  arms: readonly MatchArm<R>[],\n): KaladaV1Expression<R> => ({ kind: \"match\", type, value, arms });\n\nexport const KaladaV1 = Object.freeze({\n  literal,\n  ref,\n  binding,\n  Option: Object.freeze({ some, none }),\n  Result: Object.freeze({ ok, err }),\n  arm,\n  match,\n  program<R extends JsonValue = string>(expression: KaladaV1Expression<R>): KaladaV1Program<R> {\n    return { format: \"kalada-program\", version: 1, profile: \"kalada-v1\", expression };\n  },\n});\n"]}
+{"version":3,"sources":["../../src/kalada-v1/factories.ts"],"names":["ok"],"mappings":"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","file":"factories.js","sourcesContent":["import type { JsonValue } from \"./json.js\";\nimport type {\n  KaladaCoreFunctionName,\n  KaladaFunctionParameter,\n  KaladaType,\n  KaladaV1Expression,\n  KaladaV1Program,\n  MatchArm,\n  NamedFunction,\n} from \"./types.js\";\n\nconst literal = <R extends JsonValue = string>(value: JsonValue): KaladaV1Expression<R> => ({\n  kind: \"literal\",\n  value,\n});\nconst ref = <R extends JsonValue = string>(value: R): KaladaV1Expression<R> => ({\n  kind: \"ref\",\n  ref: value,\n});\nconst binding = <R extends JsonValue>(\n  name: string,\n  value: KaladaV1Expression<R>,\n  body: KaladaV1Expression<R>,\n): KaladaV1Expression<R> => ({ kind: \"binding\", name, value, body });\nconst some = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"option\",\n  variant: \"some\",\n  value,\n});\nconst none = <R extends JsonValue = string>(): KaladaV1Expression<R> => ({\n  kind: \"option\",\n  variant: \"none\",\n});\nconst ok = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"result\",\n  variant: \"ok\",\n  value,\n});\nconst err = <R extends JsonValue>(value: KaladaV1Expression<R>): KaladaV1Expression<R> => ({\n  kind: \"result\",\n  variant: \"err\",\n  value,\n});\nconst arm = <R extends JsonValue>(\n  variant: MatchArm<R>[\"variant\"],\n  body: KaladaV1Expression<R>,\n  name?: string,\n): MatchArm<R> => ({ variant, ...(name === undefined ? {} : { binding: name }), body });\nconst match = <R extends JsonValue>(\n  type: \"Option\" | \"Result\",\n  value: KaladaV1Expression<R>,\n  arms: readonly MatchArm<R>[],\n): KaladaV1Expression<R> => ({ kind: \"match\", type, value, arms });\nconst instant = <R extends JsonValue = string>(milliseconds: number): KaladaV1Expression<R> => ({\n  kind: \"instant\",\n  milliseconds,\n});\nconst duration = <R extends JsonValue = string>(milliseconds: number): KaladaV1Expression<R> => ({\n  kind: \"duration\",\n  milliseconds,\n});\nconst currentInstant = <R extends JsonValue = string>(): KaladaV1Expression<R> => ({\n  kind: \"current-instant\",\n});\nconst temporalArithmetic = <R extends JsonValue>(\n  operator: \"add\" | \"subtract\",\n  left: KaladaV1Expression<R>,\n  right: KaladaV1Expression<R>,\n): KaladaV1Expression<R> => ({ kind: \"temporal-arithmetic\", operator, left, right });\nconst temporalComparison = <R extends JsonValue>(\n  operator: Extract<KaladaV1Expression<R>, { kind: \"temporal-comparison\" }>[\"operator\"],\n  left: KaladaV1Expression<R>,\n  right: KaladaV1Expression<R>,\n): KaladaV1Expression<R> => ({ kind: \"temporal-comparison\", operator, left, right });\nconst functionExpression = <R extends JsonValue>(\n  parameters: readonly KaladaFunctionParameter[],\n  returns: KaladaType,\n  body: KaladaV1Expression<R>,\n): KaladaV1Expression<R> =>\n  Object.freeze({ kind: \"function\", parameters: Object.freeze([...parameters]), returns, body });\nconst call = <R extends JsonValue>(\n  callee: KaladaV1Expression<R>,\n  args: readonly KaladaV1Expression<R>[],\n): KaladaV1Expression<R> =>\n  Object.freeze({ kind: \"call\", callee, arguments: Object.freeze([...args]) });\nconst functionGroup = <R extends JsonValue>(\n  functions: readonly NamedFunction<R>[],\n  body: KaladaV1Expression<R>,\n): KaladaV1Expression<R> =>\n  Object.freeze({ kind: \"function-group\", functions: Object.freeze([...functions]), body });\nconst coreFunction = <R extends JsonValue = string>(\n  name: KaladaCoreFunctionName,\n): KaladaV1Expression<R> => Object.freeze({ kind: \"core-function\", name });\nconst parameter = (name: string, type: KaladaType): KaladaFunctionParameter =>\n  Object.freeze({ name, type });\nconst namedFunction = <R extends JsonValue>(\n  name: string,\n  parameters: readonly KaladaFunctionParameter[],\n  returns: KaladaType,\n  body: KaladaV1Expression<R>,\n): NamedFunction<R> =>\n  Object.freeze({ name, parameters: Object.freeze([...parameters]), returns, body });\nconst primitiveType = (name: Extract<KaladaType, { kind: \"primitive-type\" }>[\"name\"]): KaladaType =>\n  Object.freeze({ kind: \"primitive-type\", name });\nconst optionType = (value: KaladaType): KaladaType => Object.freeze({ kind: \"option-type\", value });\nconst resultType = (ok: KaladaType, error: KaladaType): KaladaType =>\n  Object.freeze({\n    kind: \"result-type\",\n    ok,\n    error,\n  });\nconst arrayType = (element: KaladaType): KaladaType =>\n  Object.freeze({ kind: \"array-type\", element });\nconst functionType = (parameters: readonly KaladaType[], returns: KaladaType): KaladaType =>\n  Object.freeze({ kind: \"function-type\", parameters: Object.freeze([...parameters]), returns });\n\nexport const KaladaV1 = Object.freeze({\n  literal,\n  ref,\n  binding,\n  Option: Object.freeze({ some, none }),\n  Result: Object.freeze({ ok, err }),\n  arm,\n  match,\n  instant,\n  duration,\n  currentInstant,\n  temporalArithmetic,\n  temporalComparison,\n  function: functionExpression,\n  call,\n  functionGroup,\n  coreFunction,\n  parameter,\n  namedFunction,\n  Type: Object.freeze({\n    primitive: primitiveType,\n    option: optionType,\n    result: resultType,\n    array: arrayType,\n    function: functionType,\n  }),\n  program<R extends JsonValue = string>(expression: KaladaV1Expression<R>): KaladaV1Program<R> {\n    return { format: \"kalada-program\", version: 1, profile: \"kalada-v1\", expression };\n  },\n});\n"]}

package/dist/kalada-v1/function-contracts.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+var canonicalInput_js = require('./canonical-input.js');
+var diagnostics_js = require('./diagnostics.js');
+
+const TYPE_KEYS = /* @__PURE__ */ new Set([
+  "kind",
+  "name",
+  "value",
+  "ok",
+  "error",
+  "element",
+  "parameters",
+  "returns"
+]);
+const PRIMITIVES = /* @__PURE__ */ new Set(["null", "boolean", "number", "string", "json", "Instant", "Duration"]);
+function canonicalFunction(raw, path, depth, state, read) {
+  canonicalInput_js.exact(raw, path, ["kind", "parameters", "returns", "body"]);
+  const parameters = canonicalParameters(raw.parameters, [...path, "parameters"], depth + 1, state);
+  const returns = canonicalType(raw.returns, [...path, "returns"], depth + 1, state);
+  const body = read(raw.body, [...path, "body"], depth + 1, state);
+  return Object.freeze({ kind: "function", parameters, returns, body });
+}
+function canonicalCall(raw, path, depth, state, read) {
+  canonicalInput_js.exact(raw, path, ["kind", "callee", "arguments"]);
+  const callee = read(raw.callee, [...path, "callee"], depth + 1, state);
+  const args = array(raw.arguments, [...path, "arguments"]);
+  const output = args.map(
+    (item, index) => read(item, [...path, "arguments", index], depth + 1, state)
+  );
+  return Object.freeze({ kind: "call", callee, arguments: Object.freeze(output) });
+}
+function canonicalGroup(raw, path, depth, state, read) {
+  canonicalInput_js.exact(raw, path, ["kind", "functions", "body"]);
+  const entries = array(raw.functions, [...path, "functions"]);
+  if (entries.length > state.limits.maxFunctionGroupSize) limit([...path, "functions"]);
+  const names = /* @__PURE__ */ new Set();
+  const functions = entries.map((item, index) => {
+    const member = canonicalMember(item, [...path, "functions", index], depth + 1, state, read);
+    if (names.has(member.name)) duplicate([...path, "functions", index, "name"]);
+    names.add(member.name);
+    return member;
+  });
+  const body = read(raw.body, [...path, "body"], depth + 1, state);
+  return Object.freeze({ kind: "function-group", functions: Object.freeze(functions), body });
+}
+function canonicalCoreFunction(raw, path) {
+  canonicalInput_js.exact(raw, path, ["kind", "name"]);
+  if (raw.name !== "map" && raw.name !== "filter" && raw.name !== "some" && raw.name !== "every") {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", [...path, "name"]);
+  }
+  return Object.freeze({ kind: "core-function", name: raw.name });
+}
+function canonicalType(input, path, depth, state) {
+  canonicalInput_js.count(path, depth, state);
+  if (typeof input !== "object" || input === null || state.active.has(input)) {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_FUNCTION_TYPE", path);
+  }
+  state.active.add(input);
+  try {
+    const raw = canonicalInput_js.properties(input, path, TYPE_KEYS, false);
+    if (raw.kind === "primitive-type") return primitiveType(raw, path);
+    if (raw.kind === "option-type")
+      return unaryType(raw, path, depth, state, "option-type", "value");
+    if (raw.kind === "array-type")
+      return unaryType(raw, path, depth, state, "array-type", "element");
+    if (raw.kind === "result-type") return resultType(raw, path, depth, state);
+    if (raw.kind === "function-type") return functionType(raw, path, depth, state);
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_FUNCTION_TYPE", [...path, "kind"]);
+  } finally {
+    state.active.delete(input);
+  }
+}
+function canonicalMember(input, path, depth, state, read) {
+  canonicalInput_js.count(path, depth, state);
+  const raw = canonicalInput_js.properties(input, path, /* @__PURE__ */ new Set(["name", "parameters", "returns", "body"]));
+  const name = canonicalInput_js.bindingName(raw.name, [...path, "name"], state.limits);
+  const parameters = canonicalParameters(raw.parameters, [...path, "parameters"], depth + 1, state);
+  const returns = canonicalType(raw.returns, [...path, "returns"], depth + 1, state);
+  const body = read(raw.body, [...path, "body"], depth + 1, state);
+  return Object.freeze({ name, parameters, returns, body });
+}
+function canonicalParameters(input, path, depth, state) {
+  const entries = array(input, path);
+  if (entries.length > state.limits.maxFunctionParameters) limit(path);
+  const names = /* @__PURE__ */ new Set();
+  const output = entries.map((item, index) => {
+    const itemPath = [...path, index];
+    canonicalInput_js.count(itemPath, depth, state);
+    const raw = canonicalInput_js.properties(item, itemPath, /* @__PURE__ */ new Set(["name", "type"]));
+    const name = canonicalInput_js.bindingName(raw.name, [...itemPath, "name"], state.limits);
+    if (names.has(name)) duplicate([...itemPath, "name"]);
+    names.add(name);
+    return Object.freeze({
+      name,
+      type: canonicalType(raw.type, [...itemPath, "type"], depth + 1, state)
+    });
+  });
+  return Object.freeze(output);
+}
+function functionType(raw, path, depth, state) {
+  canonicalInput_js.exact(raw, path, ["kind", "parameters", "returns"]);
+  const entries = array(raw.parameters, [...path, "parameters"]);
+  if (entries.length > state.limits.maxFunctionParameters) limit([...path, "parameters"]);
+  const parameters = entries.map(
+    (item, index) => canonicalType(item, [...path, "parameters", index], depth + 1, state)
+  );
+  const returns = canonicalType(raw.returns, [...path, "returns"], depth + 1, state);
+  return Object.freeze({ kind: "function-type", parameters: Object.freeze(parameters), returns });
+}
+function primitiveType(raw, path) {
+  canonicalInput_js.exact(raw, path, ["kind", "name"]);
+  if (typeof raw.name !== "string" || !PRIMITIVES.has(raw.name)) {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_FUNCTION_TYPE", [...path, "name"]);
+  }
+  return Object.freeze({ kind: "primitive-type", name: raw.name });
+}
+function unaryType(raw, path, depth, state, kind, key) {
+  canonicalInput_js.exact(raw, path, ["kind", key]);
+  return Object.freeze({
+    kind,
+    [key]: canonicalType(raw[key], [...path, key], depth + 1, state)
+  });
+}
+function resultType(raw, path, depth, state) {
+  canonicalInput_js.exact(raw, path, ["kind", "ok", "error"]);
+  return Object.freeze({
+    kind: "result-type",
+    ok: canonicalType(raw.ok, [...path, "ok"], depth + 1, state),
+    error: canonicalType(raw.error, [...path, "error"], depth + 1, state)
+  });
+}
+function array(input, path) {
+  if (!Array.isArray(input)) throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  return canonicalInput_js.strictArray(input, path);
+}
+function limit(path) {
+  throw new diagnostics_js.KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+}
+function duplicate(path) {
+  throw new diagnostics_js.KaladaFailure("KALADA_DUPLICATE_BINDING", path);
+}
+
+exports.canonicalCall = canonicalCall;
+exports.canonicalCoreFunction = canonicalCoreFunction;
+exports.canonicalFunction = canonicalFunction;
+exports.canonicalGroup = canonicalGroup;
+exports.canonicalType = canonicalType;
+//# sourceMappingURL=function-contracts.cjs.map
+//# sourceMappingURL=function-contracts.cjs.map

package/dist/kalada-v1/function-contracts.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/function-contracts.ts"],"names":["exact","KaladaFailure","count","properties","bindingName","strictArray"],"mappings":"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","file":"function-contracts.cjs","sourcesContent":["import {\n  bindingName,\n  type CanonicalState,\n  count,\n  exact,\n  type Path,\n  properties,\n  strictArray,\n} from \"./canonical-input.js\";\nimport { KaladaFailure } from \"./diagnostics.js\";\nimport type { JsonValue } from \"./json.js\";\nimport type {\n  CallExpression,\n  CoreFunctionExpression,\n  FunctionExpression,\n  FunctionGroupExpression,\n  KaladaFunctionParameter,\n  KaladaType,\n  KaladaV1Expression,\n  NamedFunction,\n} from \"./types.js\";\n\ntype NodeReader<R extends JsonValue> = (\n  input: unknown,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n) => KaladaV1Expression<R>;\n\nconst TYPE_KEYS = new Set([\n  \"kind\",\n  \"name\",\n  \"value\",\n  \"ok\",\n  \"error\",\n  \"element\",\n  \"parameters\",\n  \"returns\",\n]);\nconst PRIMITIVES = new Set([\"null\", \"boolean\", \"number\", \"string\", \"json\", \"Instant\", \"Duration\"]);\n\nexport function canonicalFunction<R extends JsonValue>(\n  raw: Record<string, unknown>,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n  read: NodeReader<R>,\n): FunctionExpression<R> {\n  exact(raw, path, [\"kind\", \"parameters\", \"returns\", \"body\"]);\n  const parameters = canonicalParameters(raw.parameters, [...path, \"parameters\"], depth + 1, state);\n  const returns = canonicalType(raw.returns, [...path, \"returns\"], depth + 1, state);\n  const body = read(raw.body, [...path, \"body\"], depth + 1, state);\n  return Object.freeze({ kind: \"function\", parameters, returns, body });\n}\n\nexport function canonicalCall<R extends JsonValue>(\n  raw: Record<string, unknown>,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n  read: NodeReader<R>,\n): CallExpression<R> {\n  exact(raw, path, [\"kind\", \"callee\", \"arguments\"]);\n  const callee = read(raw.callee, [...path, \"callee\"], depth + 1, state);\n  const args = array(raw.arguments, [...path, \"arguments\"]);\n  const output = args.map((item, index) =>\n    read(item, [...path, \"arguments\", index], depth + 1, state),\n  );\n  return Object.freeze({ kind: \"call\", callee, arguments: Object.freeze(output) });\n}\n\nexport function canonicalGroup<R extends JsonValue>(\n  raw: Record<string, unknown>,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n  read: NodeReader<R>,\n): FunctionGroupExpression<R> {\n  exact(raw, path, [\"kind\", \"functions\", \"body\"]);\n  const entries = array(raw.functions, [...path, \"functions\"]);\n  if (entries.length > state.limits.maxFunctionGroupSize) limit([...path, \"functions\"]);\n  const names = new Set<string>();\n  const functions = entries.map((item, index) => {\n    const member = canonicalMember(item, [...path, \"functions\", index], depth + 1, state, read);\n    if (names.has(member.name)) duplicate([...path, \"functions\", index, \"name\"]);\n    names.add(member.name);\n    return member;\n  });\n  const body = read(raw.body, [...path, \"body\"], depth + 1, state);\n  return Object.freeze({ kind: \"function-group\", functions: Object.freeze(functions), body });\n}\n\nexport function canonicalCoreFunction(\n  raw: Record<string, unknown>,\n  path: Path,\n): CoreFunctionExpression {\n  exact(raw, path, [\"kind\", \"name\"]);\n  if (raw.name !== \"map\" && raw.name !== \"filter\" && raw.name !== \"some\" && raw.name !== \"every\") {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, \"name\"]);\n  }\n  return Object.freeze({ kind: \"core-function\", name: raw.name });\n}\n\nexport function canonicalType<R extends JsonValue>(\n  input: unknown,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n): KaladaType {\n  count(path, depth, state);\n  if (typeof input !== \"object\" || input === null || state.active.has(input)) {\n    throw new KaladaFailure(\"KALADA_INVALID_FUNCTION_TYPE\", path);\n  }\n  state.active.add(input);\n  try {\n    const raw = properties(input, path, TYPE_KEYS, false);\n    if (raw.kind === \"primitive-type\") return primitiveType(raw, path);\n    if (raw.kind === \"option-type\")\n      return unaryType(raw, path, depth, state, \"option-type\", \"value\");\n    if (raw.kind === \"array-type\")\n      return unaryType(raw, path, depth, state, \"array-type\", \"element\");\n    if (raw.kind === \"result-type\") return resultType(raw, path, depth, state);\n    if (raw.kind === \"function-type\") return functionType(raw, path, depth, state);\n    throw new KaladaFailure(\"KALADA_INVALID_FUNCTION_TYPE\", [...path, \"kind\"]);\n  } finally {\n    state.active.delete(input);\n  }\n}\n\nfunction canonicalMember<R extends JsonValue>(\n  input: unknown,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n  read: NodeReader<R>,\n): NamedFunction<R> {\n  count(path, depth, state);\n  const raw = properties(input, path, new Set([\"name\", \"parameters\", \"returns\", \"body\"]));\n  const name = bindingName(raw.name, [...path, \"name\"], state.limits);\n  const parameters = canonicalParameters(raw.parameters, [...path, \"parameters\"], depth + 1, state);\n  const returns = canonicalType(raw.returns, [...path, \"returns\"], depth + 1, state);\n  const body = read(raw.body, [...path, \"body\"], depth + 1, state);\n  return Object.freeze({ name, parameters, returns, body });\n}\n\nfunction canonicalParameters<R extends JsonValue>(\n  input: unknown,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n): readonly KaladaFunctionParameter[] {\n  const entries = array(input, path);\n  if (entries.length > state.limits.maxFunctionParameters) limit(path);\n  const names = new Set<string>();\n  const output = entries.map((item, index) => {\n    const itemPath = [...path, index];\n    count(itemPath, depth, state);\n    const raw = properties(item, itemPath, new Set([\"name\", \"type\"]));\n    const name = bindingName(raw.name, [...itemPath, \"name\"], state.limits);\n    if (names.has(name)) duplicate([...itemPath, \"name\"]);\n    names.add(name);\n    return Object.freeze({\n      name,\n      type: canonicalType(raw.type, [...itemPath, \"type\"], depth + 1, state),\n    });\n  });\n  return Object.freeze(output);\n}\n\nfunction functionType<R extends JsonValue>(\n  raw: Record<string, unknown>,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n): KaladaType {\n  exact(raw, path, [\"kind\", \"parameters\", \"returns\"]);\n  const entries = array(raw.parameters, [...path, \"parameters\"]);\n  if (entries.length > state.limits.maxFunctionParameters) limit([...path, \"parameters\"]);\n  const parameters = entries.map((item, index) =>\n    canonicalType(item, [...path, \"parameters\", index], depth + 1, state),\n  );\n  const returns = canonicalType(raw.returns, [...path, \"returns\"], depth + 1, state);\n  return Object.freeze({ kind: \"function-type\", parameters: Object.freeze(parameters), returns });\n}\n\nfunction primitiveType(raw: Record<string, unknown>, path: Path): KaladaType {\n  exact(raw, path, [\"kind\", \"name\"]);\n  if (typeof raw.name !== \"string\" || !PRIMITIVES.has(raw.name)) {\n    throw new KaladaFailure(\"KALADA_INVALID_FUNCTION_TYPE\", [...path, \"name\"]);\n  }\n  return Object.freeze({ kind: \"primitive-type\", name: raw.name }) as KaladaType;\n}\n\nfunction unaryType<R extends JsonValue>(\n  raw: Record<string, unknown>,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n  kind: \"option-type\" | \"array-type\",\n  key: \"value\" | \"element\",\n): KaladaType {\n  exact(raw, path, [\"kind\", key]);\n  return Object.freeze({\n    kind,\n    [key]: canonicalType(raw[key], [...path, key], depth + 1, state),\n  }) as KaladaType;\n}\n\nfunction resultType<R extends JsonValue>(\n  raw: Record<string, unknown>,\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n): KaladaType {\n  exact(raw, path, [\"kind\", \"ok\", \"error\"]);\n  return Object.freeze({\n    kind: \"result-type\",\n    ok: canonicalType(raw.ok, [...path, \"ok\"], depth + 1, state),\n    error: canonicalType(raw.error, [...path, \"error\"], depth + 1, state),\n  });\n}\n\nfunction array(input: unknown, path: Path): unknown[] {\n  if (!Array.isArray(input)) throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  return strictArray(input, path);\n}\n\nfunction limit(path: Path): never {\n  throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n}\nfunction duplicate(path: Path): never {\n  throw new KaladaFailure(\"KALADA_DUPLICATE_BINDING\", path);\n}\n"]}

package/dist/kalada-v1/function-contracts.d.cts

@@ -0,0 +1,15 @@
+import { Path, CanonicalState } from './canonical-input.cjs';
+import { JsonValue } from './json.cjs';
+import { KaladaV1Expression, CallExpression, CoreFunctionExpression, FunctionExpression, FunctionGroupExpression, KaladaType } from './types.cjs';
+import './limits.cjs';
+import './temporal.cjs';
+import './values.cjs';
+
+type NodeReader<R extends JsonValue> = (input: unknown, path: Path, depth: number, state: CanonicalState<R>) => KaladaV1Expression<R>;
+declare function canonicalFunction<R extends JsonValue>(raw: Record<string, unknown>, path: Path, depth: number, state: CanonicalState<R>, read: NodeReader<R>): FunctionExpression<R>;
+declare function canonicalCall<R extends JsonValue>(raw: Record<string, unknown>, path: Path, depth: number, state: CanonicalState<R>, read: NodeReader<R>): CallExpression<R>;
+declare function canonicalGroup<R extends JsonValue>(raw: Record<string, unknown>, path: Path, depth: number, state: CanonicalState<R>, read: NodeReader<R>): FunctionGroupExpression<R>;
+declare function canonicalCoreFunction(raw: Record<string, unknown>, path: Path): CoreFunctionExpression;
+declare function canonicalType<R extends JsonValue>(input: unknown, path: Path, depth: number, state: CanonicalState<R>): KaladaType;
+
+export { canonicalCall, canonicalCoreFunction, canonicalFunction, canonicalGroup, canonicalType };

package/dist/kalada-v1/function-contracts.d.ts

@@ -0,0 +1,15 @@
+import { Path, CanonicalState } from './canonical-input.js';
+import { JsonValue } from './json.js';
+import { KaladaV1Expression, CallExpression, CoreFunctionExpression, FunctionExpression, FunctionGroupExpression, KaladaType } from './types.js';
+import './limits.js';
+import './temporal.js';
+import './values.js';
+
+type NodeReader<R extends JsonValue> = (input: unknown, path: Path, depth: number, state: CanonicalState<R>) => KaladaV1Expression<R>;
+declare function canonicalFunction<R extends JsonValue>(raw: Record<string, unknown>, path: Path, depth: number, state: CanonicalState<R>, read: NodeReader<R>): FunctionExpression<R>;
+declare function canonicalCall<R extends JsonValue>(raw: Record<string, unknown>, path: Path, depth: number, state: CanonicalState<R>, read: NodeReader<R>): CallExpression<R>;
+declare function canonicalGroup<R extends JsonValue>(raw: Record<string, unknown>, path: Path, depth: number, state: CanonicalState<R>, read: NodeReader<R>): FunctionGroupExpression<R>;
+declare function canonicalCoreFunction(raw: Record<string, unknown>, path: Path): CoreFunctionExpression;
+declare function canonicalType<R extends JsonValue>(input: unknown, path: Path, depth: number, state: CanonicalState<R>): KaladaType;
+
+export { canonicalCall, canonicalCoreFunction, canonicalFunction, canonicalGroup, canonicalType };