@kalada/core 0.2.0 → 0.4.0

package/README.md

@@ -13,9 +13,15 @@ third-party license declarations are reproduced in `THIRD_PARTY_NOTICES.md`.
 
 `@kalada/core/kalada-v1` is an additive, dependency-free native profile. It provides private
 WeakSet-branded `Option`/`Result` runtime values, explicit `kalada-value` v1 encoding, canonical
-program constructors and schemas, and a bounded compiler/evaluator. JSON values remain opaque:
-only `decodeKaladaValue` decodes an encoded envelope, and every JSON value is wrapped in a `Json`
-envelope so a discriminant-shaped object round-trips as ordinary JSON.
+program constructors and schemas, static function analysis, and a bounded compiler/evaluator.
+Typed functions are lexical values: they may capture bindings, be passed or returned, and call
+themselves or members of the same function group. Evaluation uses an iterative continuation
+machine, so recursion is bounded by configured limits rather than the JavaScript call stack.
+
+JSON values remain opaque. Only `decodeKaladaValue` decodes an encoded envelope, and every JSON
+value is wrapped in a `Json` envelope so a discriminant-shaped object round-trips as ordinary JSON.
+Callable values are evaluation-internal and cannot escape through a top-level result, an ADT, JSON,
+or the value codec.
 
 ```ts
 import { KaladaV1, compileKaladaV1Program } from "@kalada/core/kalada-v1";
@@ -28,6 +34,59 @@ const compiled = compileKaladaV1Program(KaladaV1.program(expression));
 const value = compiled.ok ? compiled.value.evaluate(() => ({ found: false })) : compiled;
 ```
 
+### Functions and collections
+
+Function parameters and returns use `KaladaV1.Type`. Calls validate arity and runtime values, and
+arguments are evaluated left-to-right. The collection functions are first-class callable values;
+callbacks receive `(element, zeroBasedIndex)`, preserve input order, and `some`/`every`
+short-circuit.
+
+```ts
+import { KaladaV1, compileKaladaV1Program } from "@kalada/core/kalada-v1";
+
+const json = KaladaV1.Type.primitive("json");
+const number = KaladaV1.Type.primitive("number");
+const indices = KaladaV1.call(KaladaV1.coreFunction("map"), [
+  KaladaV1.literal(["a", "b", "c"]),
+  KaladaV1.function(
+    [KaladaV1.parameter("element", json), KaladaV1.parameter("index", number)],
+    json,
+    KaladaV1.ref("index"),
+  ),
+]);
+const compiled = compileKaladaV1Program(KaladaV1.program(indices));
+const outcome = compiled.ok ? compiled.value.evaluate(() => ({ found: false })) : compiled;
+// outcome: { ok: true, value: [0, 1, 2] }
+```
+
+Named members of `KaladaV1.functionGroup` support direct and mutual recursion. Closures capture the
+definition scope, not the call scope. `analyzeKaladaV1Functions` exposes frozen capture metadata;
+`compileKaladaV1Program` also includes it in the compiled program's `functions` field.
+
+### Limits and failures
+
+`compileKaladaV1Program(program, { limits })` accepts partial overrides for AST/value/string,
+evaluation-step, function-parameter/group, capture, closure, call-depth, continuation, collection
+length, and cumulative collection-iteration limits. Defaults are exported as
+`DEFAULT_KALADA_V1_LIMITS` and `DEFAULT_KALADA_V1_FUNCTION_LIMITS`. Limits are inclusive and a
+failure returns a frozen diagnostic instead of throwing. Nested call diagnostics include at most
+the 32 innermost frozen context frames. A compiled program is reusable after any failure.
+
+Resolvers are synchronous and return `{ found: true, value }` or a missing/denied resolution.
+Thrown errors, promises, accessors, hostile proxies, cycles, sparse arrays, and non-JSON values are
+contained as diagnostics. `evaluateWithClock` samples its clock exactly once per evaluation.
+
+### Public entry points and non-goals
+
+- `@kalada/core` retains only the versioned program envelope and Kuery adapters.
+- `@kalada/core/kuery-v1` retains the Kuery 2.1 compatibility profile.
+- `@kalada/core/kalada-v1` owns the native factories, types, schemas, analysis, values, codec, and
+  compiler/evaluator.
+
+The profile has no parser, module loader, imports, I/O, effects, scheduling, host-language function
+interop, or async callbacks. Modules and imports are deferred to
+[#21](https://github.com/surikaterna/kalada/issues/21), not implicitly enabled by function values.
+
 Matches are limited to exactly two canonical arms: `some`, `none` for Option and `ok`, `err` for
 Result. There are no guards or fallthrough. Bindings are lexical: an initializer is evaluated in
 the outer scope, a body may shadow an outer binding, and only the selected match arm is evaluated.

package/dist/kalada-v1/canonical-input.cjs

@@ -0,0 +1,133 @@
+'use strict';
+
+var diagnostics_js = require('./diagnostics.js');
+var json_js = require('./json.js');
+
+function properties(input, path, allowed, requireExact = true) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  let keys;
+  try {
+    keys = Reflect.ownKeys(input);
+  } catch {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  const output = {};
+  for (const key of keys) {
+    if (typeof key !== "string" || !allowed.has(key)) {
+      throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", [...path, String(key)]);
+    }
+    try {
+      output[key] = json_js.dataValue(input, key);
+    } catch {
+      throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", [...path, key]);
+    }
+  }
+  if (requireExact && keys.length !== allowed.size) {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  return output;
+}
+function exact(raw, path, keys, optionalLast = false) {
+  const minimum = optionalLast ? keys.length - 1 : keys.length;
+  if (Object.keys(raw).length < minimum || Object.keys(raw).length > keys.length) {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  for (let index = 0; index < minimum; index += 1) {
+    const key = keys[index];
+    if (key !== void 0 && !(key in raw)) {
+      throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", [...path, key]);
+    }
+  }
+  for (const key of Object.keys(raw)) {
+    if (!keys.includes(key)) throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", [...path, key]);
+  }
+}
+function strictArray(input, path) {
+  let keys;
+  try {
+    keys = Reflect.ownKeys(input);
+  } catch {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  if (keys.length !== input.length + 1) throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  return Array.from({ length: input.length }, (_, index) => {
+    try {
+      return json_js.dataValue(input, String(index));
+    } catch {
+      throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", [...path, index]);
+    }
+  });
+}
+function safeJson(input, path, state) {
+  try {
+    const result = json_js.cloneJsonWithStats(input, {
+      maxDepth: state.limits.maxValueDepth,
+      maxNodes: state.limits.maxValueNodes - state.valueNodes,
+      maxStringLength: state.limits.maxStringLength
+    });
+    state.valueNodes += result.nodes;
+    return result.value;
+  } catch (error) {
+    if (error instanceof RangeError) throw new diagnostics_js.KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+}
+function inspectJson(input, path, state) {
+  try {
+    return json_js.cloneJson(input, {
+      maxDepth: state.limits.maxValueDepth,
+      maxNodes: state.limits.maxValueNodes,
+      maxStringLength: state.limits.maxStringLength
+    });
+  } catch (error) {
+    if (error instanceof RangeError) throw new diagnostics_js.KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+}
+function referenceLength(reference) {
+  return typeof reference === "string" ? [...reference].length : [...json_js.canonicalJsonIdentity(reference)].length;
+}
+function bindingName(input, path, limits) {
+  if (typeof input !== "string" || input.length === 0) {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  if ([...input].length > limits.maxReferenceLength) {
+    throw new diagnostics_js.KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+  }
+  return input;
+}
+function safeValidate(validate, input) {
+  try {
+    return validate(input) === true;
+  } catch {
+    return false;
+  }
+}
+function safeCanonicalize(canonicalize, input, path) {
+  try {
+    return canonicalize(input);
+  } catch {
+    throw new diagnostics_js.KaladaFailure("KALADA_INVALID_REFERENCE", path);
+  }
+}
+function count(path, depth, state) {
+  state.astNodes += 1;
+  if (depth > state.limits.maxAstDepth || state.astNodes > state.limits.maxAstNodes) {
+    throw new diagnostics_js.KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+  }
+}
+
+exports.bindingName = bindingName;
+exports.count = count;
+exports.exact = exact;
+exports.inspectJson = inspectJson;
+exports.properties = properties;
+exports.referenceLength = referenceLength;
+exports.safeCanonicalize = safeCanonicalize;
+exports.safeJson = safeJson;
+exports.safeValidate = safeValidate;
+exports.strictArray = strictArray;
+//# sourceMappingURL=canonical-input.cjs.map
+//# sourceMappingURL=canonical-input.cjs.map

package/dist/kalada-v1/canonical-input.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/canonical-input.ts"],"names":["KaladaFailure","dataValue","cloneJsonWithStats","cloneJson","canonicalJsonIdentity"],"mappings":"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","file":"canonical-input.cjs","sourcesContent":["import { KaladaFailure } from \"./diagnostics.js\";\nimport {\n  canonicalJsonIdentity,\n  cloneJson,\n  cloneJsonWithStats,\n  dataValue,\n  type JsonValue,\n} from \"./json.js\";\nimport type { ResolvedKaladaV1Limits } from \"./limits.js\";\nimport type { KaladaV1Limits, KaladaV1Options } from \"./types.js\";\n\nexport type Path = readonly (string | number)[];\nexport interface CanonicalState<R extends JsonValue> {\n  readonly limits: ResolvedKaladaV1Limits;\n  readonly options: KaladaV1Options<R>;\n  readonly active: WeakSet<object>;\n  astNodes: number;\n  valueNodes: number;\n}\n\nexport function properties(\n  input: unknown,\n  path: Path,\n  allowed: ReadonlySet<string>,\n  requireExact = true,\n): Record<string, unknown> {\n  if (typeof input !== \"object\" || input === null || Array.isArray(input)) {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  let keys: PropertyKey[];\n  try {\n    keys = Reflect.ownKeys(input);\n  } catch {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  const output: Record<string, unknown> = {};\n  for (const key of keys) {\n    if (typeof key !== \"string\" || !allowed.has(key)) {\n      throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, String(key)]);\n    }\n    try {\n      output[key] = dataValue(input, key);\n    } catch {\n      throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, key]);\n    }\n  }\n  if (requireExact && keys.length !== allowed.size) {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  return output;\n}\n\nexport function exact(\n  raw: Record<string, unknown>,\n  path: Path,\n  keys: readonly string[],\n  optionalLast = false,\n): void {\n  const minimum = optionalLast ? keys.length - 1 : keys.length;\n  if (Object.keys(raw).length < minimum || Object.keys(raw).length > keys.length) {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  for (let index = 0; index < minimum; index += 1) {\n    const key = keys[index];\n    if (key !== undefined && !(key in raw)) {\n      throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, key]);\n    }\n  }\n  for (const key of Object.keys(raw)) {\n    if (!keys.includes(key)) throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, key]);\n  }\n}\n\nexport function strictArray(input: unknown[], path: Path): unknown[] {\n  let keys: PropertyKey[];\n  try {\n    keys = Reflect.ownKeys(input);\n  } catch {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  if (keys.length !== input.length + 1) throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  return Array.from({ length: input.length }, (_, index) => {\n    try {\n      return dataValue(input, String(index));\n    } catch {\n      throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, index]);\n    }\n  });\n}\n\nexport function safeJson<R extends JsonValue>(\n  input: unknown,\n  path: Path,\n  state: CanonicalState<R>,\n): JsonValue {\n  try {\n    const result = cloneJsonWithStats(input, {\n      maxDepth: state.limits.maxValueDepth,\n      maxNodes: state.limits.maxValueNodes - state.valueNodes,\n      maxStringLength: state.limits.maxStringLength,\n    });\n    state.valueNodes += result.nodes;\n    return result.value;\n  } catch (error) {\n    if (error instanceof RangeError) throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n}\n\nexport function inspectJson<R extends JsonValue>(\n  input: unknown,\n  path: Path,\n  state: CanonicalState<R>,\n): JsonValue {\n  try {\n    return cloneJson(input, {\n      maxDepth: state.limits.maxValueDepth,\n      maxNodes: state.limits.maxValueNodes,\n      maxStringLength: state.limits.maxStringLength,\n    });\n  } catch (error) {\n    if (error instanceof RangeError) throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n}\n\nexport function referenceLength(reference: JsonValue): number {\n  return typeof reference === \"string\"\n    ? [...reference].length\n    : [...canonicalJsonIdentity(reference)].length;\n}\n\nexport function bindingName(input: unknown, path: Path, limits: KaladaV1Limits): string {\n  if (typeof input !== \"string\" || input.length === 0) {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  if ([...input].length > limits.maxReferenceLength) {\n    throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n  }\n  return input;\n}\n\nexport function safeValidate<R>(\n  validate: (input: unknown) => input is R,\n  input: unknown,\n): input is R {\n  try {\n    return validate(input) === true;\n  } catch {\n    return false;\n  }\n}\n\nexport function safeCanonicalize<R>(canonicalize: (input: R) => R, input: R, path: Path): R {\n  try {\n    return canonicalize(input);\n  } catch {\n    throw new KaladaFailure(\"KALADA_INVALID_REFERENCE\", path);\n  }\n}\n\nexport function count<R extends JsonValue>(\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n): void {\n  state.astNodes += 1;\n  if (depth > state.limits.maxAstDepth || state.astNodes > state.limits.maxAstNodes) {\n    throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n  }\n}\n"]}

package/dist/kalada-v1/canonical-input.d.cts

@@ -0,0 +1,26 @@
+import { JsonValue } from './json.cjs';
+import { ResolvedKaladaV1Limits } from './limits.cjs';
+import { KaladaV1Options, KaladaV1Limits } from './types.cjs';
+import './temporal.cjs';
+import './values.cjs';
+
+type Path = readonly (string | number)[];
+interface CanonicalState<R extends JsonValue> {
+    readonly limits: ResolvedKaladaV1Limits;
+    readonly options: KaladaV1Options<R>;
+    readonly active: WeakSet<object>;
+    astNodes: number;
+    valueNodes: number;
+}
+declare function properties(input: unknown, path: Path, allowed: ReadonlySet<string>, requireExact?: boolean): Record<string, unknown>;
+declare function exact(raw: Record<string, unknown>, path: Path, keys: readonly string[], optionalLast?: boolean): void;
+declare function strictArray(input: unknown[], path: Path): unknown[];
+declare function safeJson<R extends JsonValue>(input: unknown, path: Path, state: CanonicalState<R>): JsonValue;
+declare function inspectJson<R extends JsonValue>(input: unknown, path: Path, state: CanonicalState<R>): JsonValue;
+declare function referenceLength(reference: JsonValue): number;
+declare function bindingName(input: unknown, path: Path, limits: KaladaV1Limits): string;
+declare function safeValidate<R>(validate: (input: unknown) => input is R, input: unknown): input is R;
+declare function safeCanonicalize<R>(canonicalize: (input: R) => R, input: R, path: Path): R;
+declare function count<R extends JsonValue>(path: Path, depth: number, state: CanonicalState<R>): void;
+
+export { type CanonicalState, type Path, bindingName, count, exact, inspectJson, properties, referenceLength, safeCanonicalize, safeJson, safeValidate, strictArray };

package/dist/kalada-v1/canonical-input.d.ts

@@ -0,0 +1,26 @@
+import { JsonValue } from './json.js';
+import { ResolvedKaladaV1Limits } from './limits.js';
+import { KaladaV1Options, KaladaV1Limits } from './types.js';
+import './temporal.js';
+import './values.js';
+
+type Path = readonly (string | number)[];
+interface CanonicalState<R extends JsonValue> {
+    readonly limits: ResolvedKaladaV1Limits;
+    readonly options: KaladaV1Options<R>;
+    readonly active: WeakSet<object>;
+    astNodes: number;
+    valueNodes: number;
+}
+declare function properties(input: unknown, path: Path, allowed: ReadonlySet<string>, requireExact?: boolean): Record<string, unknown>;
+declare function exact(raw: Record<string, unknown>, path: Path, keys: readonly string[], optionalLast?: boolean): void;
+declare function strictArray(input: unknown[], path: Path): unknown[];
+declare function safeJson<R extends JsonValue>(input: unknown, path: Path, state: CanonicalState<R>): JsonValue;
+declare function inspectJson<R extends JsonValue>(input: unknown, path: Path, state: CanonicalState<R>): JsonValue;
+declare function referenceLength(reference: JsonValue): number;
+declare function bindingName(input: unknown, path: Path, limits: KaladaV1Limits): string;
+declare function safeValidate<R>(validate: (input: unknown) => input is R, input: unknown): input is R;
+declare function safeCanonicalize<R>(canonicalize: (input: R) => R, input: R, path: Path): R;
+declare function count<R extends JsonValue>(path: Path, depth: number, state: CanonicalState<R>): void;
+
+export { type CanonicalState, type Path, bindingName, count, exact, inspectJson, properties, referenceLength, safeCanonicalize, safeJson, safeValidate, strictArray };

package/dist/kalada-v1/canonical-input.js

@@ -0,0 +1,122 @@
+import { KaladaFailure } from './diagnostics.js';
+import { dataValue, cloneJsonWithStats, cloneJson, canonicalJsonIdentity } from './json.js';
+
+function properties(input, path, allowed, requireExact = true) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  let keys;
+  try {
+    keys = Reflect.ownKeys(input);
+  } catch {
+    throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  const output = {};
+  for (const key of keys) {
+    if (typeof key !== "string" || !allowed.has(key)) {
+      throw new KaladaFailure("KALADA_INVALID_INPUT", [...path, String(key)]);
+    }
+    try {
+      output[key] = dataValue(input, key);
+    } catch {
+      throw new KaladaFailure("KALADA_INVALID_INPUT", [...path, key]);
+    }
+  }
+  if (requireExact && keys.length !== allowed.size) {
+    throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  return output;
+}
+function exact(raw, path, keys, optionalLast = false) {
+  const minimum = optionalLast ? keys.length - 1 : keys.length;
+  if (Object.keys(raw).length < minimum || Object.keys(raw).length > keys.length) {
+    throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  for (let index = 0; index < minimum; index += 1) {
+    const key = keys[index];
+    if (key !== void 0 && !(key in raw)) {
+      throw new KaladaFailure("KALADA_INVALID_INPUT", [...path, key]);
+    }
+  }
+  for (const key of Object.keys(raw)) {
+    if (!keys.includes(key)) throw new KaladaFailure("KALADA_INVALID_INPUT", [...path, key]);
+  }
+}
+function strictArray(input, path) {
+  let keys;
+  try {
+    keys = Reflect.ownKeys(input);
+  } catch {
+    throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  if (keys.length !== input.length + 1) throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  return Array.from({ length: input.length }, (_, index) => {
+    try {
+      return dataValue(input, String(index));
+    } catch {
+      throw new KaladaFailure("KALADA_INVALID_INPUT", [...path, index]);
+    }
+  });
+}
+function safeJson(input, path, state) {
+  try {
+    const result = cloneJsonWithStats(input, {
+      maxDepth: state.limits.maxValueDepth,
+      maxNodes: state.limits.maxValueNodes - state.valueNodes,
+      maxStringLength: state.limits.maxStringLength
+    });
+    state.valueNodes += result.nodes;
+    return result.value;
+  } catch (error) {
+    if (error instanceof RangeError) throw new KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+    throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+}
+function inspectJson(input, path, state) {
+  try {
+    return cloneJson(input, {
+      maxDepth: state.limits.maxValueDepth,
+      maxNodes: state.limits.maxValueNodes,
+      maxStringLength: state.limits.maxStringLength
+    });
+  } catch (error) {
+    if (error instanceof RangeError) throw new KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+    throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+}
+function referenceLength(reference) {
+  return typeof reference === "string" ? [...reference].length : [...canonicalJsonIdentity(reference)].length;
+}
+function bindingName(input, path, limits) {
+  if (typeof input !== "string" || input.length === 0) {
+    throw new KaladaFailure("KALADA_INVALID_INPUT", path);
+  }
+  if ([...input].length > limits.maxReferenceLength) {
+    throw new KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+  }
+  return input;
+}
+function safeValidate(validate, input) {
+  try {
+    return validate(input) === true;
+  } catch {
+    return false;
+  }
+}
+function safeCanonicalize(canonicalize, input, path) {
+  try {
+    return canonicalize(input);
+  } catch {
+    throw new KaladaFailure("KALADA_INVALID_REFERENCE", path);
+  }
+}
+function count(path, depth, state) {
+  state.astNodes += 1;
+  if (depth > state.limits.maxAstDepth || state.astNodes > state.limits.maxAstNodes) {
+    throw new KaladaFailure("KALADA_LIMIT_EXCEEDED", path);
+  }
+}
+
+export { bindingName, count, exact, inspectJson, properties, referenceLength, safeCanonicalize, safeJson, safeValidate, strictArray };
+//# sourceMappingURL=canonical-input.js.map
+//# sourceMappingURL=canonical-input.js.map

package/dist/kalada-v1/canonical-input.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/kalada-v1/canonical-input.ts"],"names":[],"mappings":"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","file":"canonical-input.js","sourcesContent":["import { KaladaFailure } from \"./diagnostics.js\";\nimport {\n  canonicalJsonIdentity,\n  cloneJson,\n  cloneJsonWithStats,\n  dataValue,\n  type JsonValue,\n} from \"./json.js\";\nimport type { ResolvedKaladaV1Limits } from \"./limits.js\";\nimport type { KaladaV1Limits, KaladaV1Options } from \"./types.js\";\n\nexport type Path = readonly (string | number)[];\nexport interface CanonicalState<R extends JsonValue> {\n  readonly limits: ResolvedKaladaV1Limits;\n  readonly options: KaladaV1Options<R>;\n  readonly active: WeakSet<object>;\n  astNodes: number;\n  valueNodes: number;\n}\n\nexport function properties(\n  input: unknown,\n  path: Path,\n  allowed: ReadonlySet<string>,\n  requireExact = true,\n): Record<string, unknown> {\n  if (typeof input !== \"object\" || input === null || Array.isArray(input)) {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  let keys: PropertyKey[];\n  try {\n    keys = Reflect.ownKeys(input);\n  } catch {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  const output: Record<string, unknown> = {};\n  for (const key of keys) {\n    if (typeof key !== \"string\" || !allowed.has(key)) {\n      throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, String(key)]);\n    }\n    try {\n      output[key] = dataValue(input, key);\n    } catch {\n      throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, key]);\n    }\n  }\n  if (requireExact && keys.length !== allowed.size) {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  return output;\n}\n\nexport function exact(\n  raw: Record<string, unknown>,\n  path: Path,\n  keys: readonly string[],\n  optionalLast = false,\n): void {\n  const minimum = optionalLast ? keys.length - 1 : keys.length;\n  if (Object.keys(raw).length < minimum || Object.keys(raw).length > keys.length) {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  for (let index = 0; index < minimum; index += 1) {\n    const key = keys[index];\n    if (key !== undefined && !(key in raw)) {\n      throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, key]);\n    }\n  }\n  for (const key of Object.keys(raw)) {\n    if (!keys.includes(key)) throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, key]);\n  }\n}\n\nexport function strictArray(input: unknown[], path: Path): unknown[] {\n  let keys: PropertyKey[];\n  try {\n    keys = Reflect.ownKeys(input);\n  } catch {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  if (keys.length !== input.length + 1) throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  return Array.from({ length: input.length }, (_, index) => {\n    try {\n      return dataValue(input, String(index));\n    } catch {\n      throw new KaladaFailure(\"KALADA_INVALID_INPUT\", [...path, index]);\n    }\n  });\n}\n\nexport function safeJson<R extends JsonValue>(\n  input: unknown,\n  path: Path,\n  state: CanonicalState<R>,\n): JsonValue {\n  try {\n    const result = cloneJsonWithStats(input, {\n      maxDepth: state.limits.maxValueDepth,\n      maxNodes: state.limits.maxValueNodes - state.valueNodes,\n      maxStringLength: state.limits.maxStringLength,\n    });\n    state.valueNodes += result.nodes;\n    return result.value;\n  } catch (error) {\n    if (error instanceof RangeError) throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n}\n\nexport function inspectJson<R extends JsonValue>(\n  input: unknown,\n  path: Path,\n  state: CanonicalState<R>,\n): JsonValue {\n  try {\n    return cloneJson(input, {\n      maxDepth: state.limits.maxValueDepth,\n      maxNodes: state.limits.maxValueNodes,\n      maxStringLength: state.limits.maxStringLength,\n    });\n  } catch (error) {\n    if (error instanceof RangeError) throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n}\n\nexport function referenceLength(reference: JsonValue): number {\n  return typeof reference === \"string\"\n    ? [...reference].length\n    : [...canonicalJsonIdentity(reference)].length;\n}\n\nexport function bindingName(input: unknown, path: Path, limits: KaladaV1Limits): string {\n  if (typeof input !== \"string\" || input.length === 0) {\n    throw new KaladaFailure(\"KALADA_INVALID_INPUT\", path);\n  }\n  if ([...input].length > limits.maxReferenceLength) {\n    throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n  }\n  return input;\n}\n\nexport function safeValidate<R>(\n  validate: (input: unknown) => input is R,\n  input: unknown,\n): input is R {\n  try {\n    return validate(input) === true;\n  } catch {\n    return false;\n  }\n}\n\nexport function safeCanonicalize<R>(canonicalize: (input: R) => R, input: R, path: Path): R {\n  try {\n    return canonicalize(input);\n  } catch {\n    throw new KaladaFailure(\"KALADA_INVALID_REFERENCE\", path);\n  }\n}\n\nexport function count<R extends JsonValue>(\n  path: Path,\n  depth: number,\n  state: CanonicalState<R>,\n): void {\n  state.astNodes += 1;\n  if (depth > state.limits.maxAstDepth || state.astNodes > state.limits.maxAstNodes) {\n    throw new KaladaFailure(\"KALADA_LIMIT_EXCEEDED\", path);\n  }\n}\n"]}