@kalada/host 0.1.0

package/dist/index.js

@@ -0,0 +1,2310 @@
+import { compileKaladaV1Program, decodeKaladaValue, encodeKaladaValue, isOption, isResult as isResult$1, isInstant, isDuration } from '@kalada/core';
+import { parseKaladaV1Expression, lowerKaladaV1Expression } from '@kalada/syntax';
+
+// src/compile-expression.ts
+
+// src/serializable.ts
+var DEFAULT_SERIALIZABLE_LIMITS = Object.freeze({
+  maxDepth: 32,
+  maxNodes: 1e4,
+  maxCollectionSize: 1e4,
+  maxStringLength: 1e5
+});
+function readOwnDataRecord(input, maximumKeys = 1e4) {
+  if (typeof input !== "object" || input === null) return shallowFailure("invalid-value");
+  const array = safelyReflect(() => Array.isArray(input));
+  if (!array.ok || array.value) return shallowFailure("invalid-value");
+  const prototype = safelyReflect(() => Object.getPrototypeOf(input));
+  if (!prototype.ok || prototype.value !== Object.prototype && prototype.value !== null) {
+    return shallowFailure("invalid-value");
+  }
+  const keys = safelyReflect(() => Reflect.ownKeys(input));
+  if (!keys.ok) return shallowFailure("invalid-value");
+  if (keys.value.length > maximumKeys) return shallowFailure("size-limit");
+  return readRecordDescriptors(input, keys.value);
+}
+function cloneSerializableData(input, limits = DEFAULT_SERIALIZABLE_LIMITS) {
+  const state = { limits, active: /* @__PURE__ */ new WeakSet(), nodes: 0 };
+  return cloneValue(input, Object.freeze([]), 0, state);
+}
+function cloneValue(input, path, depth, state) {
+  if (depth > state.limits.maxDepth) return failure("depth-limit", path);
+  if (typeof input === "string") return cloneString(input, path, state.limits);
+  if (input === null || typeof input === "boolean") return success(input);
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? success(input) : failure("invalid-value", path);
+  }
+  if (typeof input !== "object") return failure("invalid-value", path);
+  const array = safelyReflect(() => Array.isArray(input));
+  if (!array.ok) return failure("invalid-value", path);
+  if (state.active.has(input)) return failure("cycle", path);
+  state.nodes += 1;
+  if (state.nodes > state.limits.maxNodes) return failure("size-limit", path);
+  state.active.add(input);
+  const result = array.value ? cloneArray(input, path, depth, state) : cloneRecord(input, path, depth, state);
+  state.active.delete(input);
+  return result;
+}
+function cloneArray(input, path, depth, state) {
+  const lengthDescriptor = ownDescriptor(input, "length");
+  if (!lengthDescriptor.ok) return failure("invalid-value", path);
+  if (!lengthDescriptor.value || !("value" in lengthDescriptor.value)) {
+    return failure("accessor", path);
+  }
+  const length = lengthDescriptor.value.value;
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > state.limits.maxCollectionSize) {
+    return failure("size-limit", path);
+  }
+  const output = [];
+  for (let index = 0; index < length; index += 1) {
+    const descriptor = ownDescriptor(input, String(index));
+    const childPath = Object.freeze([...path, index]);
+    if (!descriptor.ok) return failure("invalid-value", childPath);
+    if (!descriptor.value || !("value" in descriptor.value)) return failure("accessor", childPath);
+    const cloned = cloneValue(descriptor.value.value, childPath, depth + 1, state);
+    if (!cloned.ok) return cloned;
+    output.push(cloned.value);
+  }
+  return success(Object.freeze(output));
+}
+function cloneRecord(input, path, depth, state) {
+  const inspected = readOwnDataRecord(input, state.limits.maxCollectionSize);
+  if (!inspected.ok) return failure(inspected.reason, path);
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(inspected.value)) {
+    const keyResult = cloneString(key, path, state.limits);
+    if (!keyResult.ok) return keyResult;
+    const childPath = Object.freeze([...path, key]);
+    const cloned = cloneValue(value, childPath, depth + 1, state);
+    if (!cloned.ok) return cloned;
+    output[key] = cloned.value;
+  }
+  return success(Object.freeze(output));
+}
+function readRecordDescriptors(input, keys) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string") return shallowFailure("invalid-value");
+    const descriptor = ownDescriptor(input, key);
+    if (!descriptor.ok) return shallowFailure("invalid-value");
+    if (!descriptor.value || !("value" in descriptor.value)) return shallowFailure("accessor");
+    output[key] = descriptor.value.value;
+  }
+  return Object.freeze({ ok: true, value: output });
+}
+function ownDescriptor(input, key) {
+  return safelyReflect(() => Object.getOwnPropertyDescriptor(input, key));
+}
+function safelyReflect(operation) {
+  try {
+    return { ok: true, value: operation() };
+  } catch {
+    return { ok: false };
+  }
+}
+function shallowFailure(reason) {
+  return Object.freeze({ ok: false, reason });
+}
+function cloneString(input, path, limits) {
+  return input.length <= limits.maxStringLength ? success(input) : failure("size-limit", path);
+}
+function success(value) {
+  return Object.freeze({ ok: true, value });
+}
+function failure(reason, path) {
+  return Object.freeze({ ok: false, reason, path: Object.freeze([...path]) });
+}
+
+// src/compile-options.ts
+var HOST_COMPILE_OPTIONS_CONTRACT = "kalada-host-compile-options-v1";
+var MAXIMUM = Object.freeze({
+  maxAstDepth: 256,
+  maxAstNodes: 1e5,
+  maxValueDepth: 256,
+  maxValueNodes: 1e5,
+  maxStringLength: 1e6,
+  maxReferenceLength: 1e5,
+  maxEvaluationSteps: 1e5,
+  maxFunctionParameters: 256,
+  maxFunctionGroupSize: 1024,
+  maxCapturesPerClosure: 256,
+  maxCapturedBindings: 1e5,
+  maxClosures: 1e5,
+  maxCallDepth: 4096,
+  maxContinuationFrames: 1e5,
+  maxCollectionLength: 1e5,
+  maxCollectionIterations: 1e5
+});
+function normalizeCompileOptions(input) {
+  if (input === void 0) return frozenOptions("default", Object.freeze({}));
+  const inspected = readOwnDataRecord(input, 2);
+  if (!inspected.ok || hasUnknownKeys(inspected.value, ["profile", "limits"])) return null;
+  const profile = inspected.value.profile ?? "default";
+  if (typeof profile !== "string" || profile.length === 0 || profile.length > 1e3) return null;
+  const limits = normalizeLimits(inspected.value.limits);
+  return limits ? frozenOptions(profile, limits) : null;
+}
+function normalizeLimits(input) {
+  if (input === void 0) return Object.freeze({});
+  const inspected = readOwnDataRecord(input, Object.keys(MAXIMUM).length);
+  if (!inspected.ok) return null;
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(inspected.value)) {
+    if (!Object.hasOwn(MAXIMUM, key) || !validLimit(key, value)) return null;
+    output[key] = value;
+  }
+  return Object.freeze(output);
+}
+function validLimit(key, value) {
+  return Number.isSafeInteger(value) && value >= 1 && value <= MAXIMUM[key];
+}
+function hasUnknownKeys(input, allowed) {
+  return Object.keys(input).some((key) => !allowed.includes(key));
+}
+function frozenOptions(profile, limits) {
+  return Object.freeze({ profile, limits });
+}
+
+// src/compiled-artifact.ts
+var constructionToken = Object.freeze({});
+var AuthenticCompiledExpression = class {
+  format = "kalada-host-compiled-expression-v1";
+  source;
+  parsed;
+  program;
+  sourceMap;
+  coreCompilation;
+  dependencies;
+  resultType;
+  compileProjectionFingerprint;
+  compileFingerprint;
+  #integrity;
+  constructor(token, input, core) {
+    if (token !== constructionToken) throw new TypeError("Invalid compiled artifact construction.");
+    this.source = input.source;
+    this.parsed = input.parsed;
+    this.program = input.program;
+    this.sourceMap = input.sourceMap;
+    this.coreCompilation = immutableCoreCompilation(core);
+    this.dependencies = this.coreCompilation.dependencies;
+    this.resultType = input.resultType;
+    this.compileProjectionFingerprint = input.compileProjectionFingerprint;
+    this.compileFingerprint = input.compileFingerprint;
+    this.#integrity = integrityRecord(this);
+    Object.freeze(this);
+  }
+  static authentic(input) {
+    if (typeof input !== "object" || input === null || !(#integrity in input)) return false;
+    return integrityMatches(input, input.#integrity);
+  }
+};
+Object.freeze(AuthenticCompiledExpression.authentic);
+Object.freeze(AuthenticCompiledExpression.prototype);
+Object.freeze(AuthenticCompiledExpression);
+function createCompiledArtifact(input, core) {
+  return new AuthenticCompiledExpression(constructionToken, input, core);
+}
+function isAuthenticCompiledExpression(input) {
+  return AuthenticCompiledExpression.authentic(input);
+}
+function immutableCoreCompilation(core) {
+  const evaluate = Object.freeze(
+    (resolve, inputs) => core.evaluate(resolve, inputs)
+  );
+  const evaluateWithClock = Object.freeze(
+    (resolve, clock) => core.evaluateWithClock(resolve, clock)
+  );
+  return Object.freeze({
+    program: core.program,
+    dependencies: core.dependencies,
+    functions: core.functions,
+    evaluate,
+    evaluateWithClock
+  });
+}
+function integrityRecord(input) {
+  return Object.freeze({
+    source: input.source,
+    parsed: input.parsed,
+    program: input.program,
+    sourceMap: input.sourceMap,
+    coreCompilation: input.coreCompilation,
+    dependencies: input.dependencies,
+    resultType: input.resultType,
+    compileProjectionFingerprint: input.compileProjectionFingerprint,
+    compileFingerprint: input.compileFingerprint
+  });
+}
+function integrityMatches(input, expected) {
+  if (!Object.isFrozen(input) || input.format !== "kalada-host-compiled-expression-v1")
+    return false;
+  return Object.entries(expected).every(
+    ([key, value]) => input[key] === value
+  );
+}
+
+// src/execution-diagnostics.ts
+var MESSAGES = Object.freeze({
+  HOST_PARSE_INVALID_SOURCE: "The expression source declaration is invalid.",
+  HOST_COMPILE_INVALID_OPTIONS: "The expression compile options are invalid.",
+  HOST_COMPILE_INVALID_PROJECTION: "The environment compile projection is invalid.",
+  HOST_LINK_INCOMPATIBLE_ENVIRONMENT: "The compiled expression is incompatible with the environment.",
+  HOST_LINK_MISSING_BINDING: "A compiled dependency is unavailable in the environment.",
+  HOST_LINK_INVALID_CAPABILITY: "A linked capability snapshot is invalid.",
+  HOST_LINK_ASYNC_UNSUPPORTED: "An asynchronous declaration is unsupported by synchronous execution.",
+  HOST_BINDING_MISSING: "A linked binding is not an own data property.",
+  HOST_BINDING_DECODE: "A linked binding could not be decoded synchronously.",
+  HOST_BINDING_CONVERSION: "A linked binding could not be converted synchronously.",
+  HOST_BINDING_SEMANTIC: "A linked binding is not a valid value of its semantic type."
+});
+function executionDiagnostic(code, phase, bindingPath, provenance) {
+  return Object.freeze({
+    code,
+    phase,
+    message: MESSAGES[code],
+    ...bindingPath ? { bindingPath: Object.freeze([...bindingPath]) } : {},
+    ...provenance ? { provenance: sanitizedProvenance(provenance) } : {}
+  });
+}
+function syntaxDiagnostics(diagnostics, source) {
+  return Object.freeze(
+    diagnostics.map(
+      (cause) => Object.freeze({
+        code: cause.code,
+        phase: cause.phase === "lower" ? "lower" : "parse",
+        message: cause.message,
+        source: sourceLocation(source, cause.range),
+        cause
+      })
+    )
+  );
+}
+function coreDiagnostic(phase, cause, source, sourceMap) {
+  const fallback = Object.freeze({ start: 0, end: source.text.length });
+  return Object.freeze({
+    code: cause.code,
+    phase,
+    message: cause.message,
+    source: sourceLocation(source, mappedRange(sourceMap, cause.path, fallback)),
+    cause
+  });
+}
+function mappedRange(entries, path, fallback) {
+  const exact = entries.filter((entry) => equalPath(entry.path, path)).sort(byNarrowest)[0];
+  if (exact) return exact.range;
+  for (let length = path.length - 1; length > 0; length -= 1) {
+    const found = entries.find(
+      (entry) => entry.role === "node" && equalPath(entry.path, path.slice(0, length))
+    );
+    if (found) return found.range;
+  }
+  return fallback;
+}
+function sourceLocation(source, range) {
+  return Object.freeze({
+    uri: source.uri,
+    range: Object.freeze({
+      start: positionAt(source.text, range.start),
+      end: positionAt(source.text, range.end)
+    })
+  });
+}
+function positionAt(source, offset) {
+  const prefix = source.slice(0, offset);
+  const lastBreak = prefix.lastIndexOf("\n");
+  return Object.freeze({
+    line: prefix.split("\n").length - 1,
+    character: offset - lastBreak - 1
+  });
+}
+function equalPath(left, right) {
+  return left.length === right.length && left.every((part, index) => part === right[index]);
+}
+function byNarrowest(left, right) {
+  return left.range.end - left.range.start - (right.range.end - right.range.start);
+}
+function sanitizedProvenance(input) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const key of ["providerId", "providerVersion", "source", "extractor", "override"]) {
+    const value = input[key];
+    if (value !== void 0) output[key] = value;
+  }
+  return Object.freeze(output);
+}
+
+// src/fingerprint.ts
+var HOST_COMPILE_FINGERPRINT_VERSION = "kalada-host-compile-fingerprint-v1";
+var HOST_LINK_FINGERPRINT_VERSION = "kalada-host-link-fingerprint-v1";
+function createFingerprint(marker, input) {
+  return `${marker}:sha256:${sha256(stableText(input))}`;
+}
+function stableText(input) {
+  if (input === null || typeof input === "boolean" || typeof input === "number") {
+    return JSON.stringify(input);
+  }
+  if (typeof input === "string") return JSON.stringify(input);
+  if (Array.isArray(input)) return `[${input.map(stableText).join(",")}]`;
+  if (typeof input !== "object") return JSON.stringify(String(input));
+  return stableRecord(input);
+}
+function stableRecord(input) {
+  return `{${Object.keys(input).sort().map((key) => `${JSON.stringify(key)}:${stableText(input[key])}`).join(",")}}`;
+}
+var ROUND_CONSTANTS = Object.freeze([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function sha256(input) {
+  const bytes = paddedBytes(new TextEncoder().encode(input));
+  const state = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  for (let offset = 0; offset < bytes.length; offset += 64) compress(bytes, offset, state);
+  return [...state].map((value) => value.toString(16).padStart(8, "0")).join("");
+}
+function paddedBytes(input) {
+  const length = Math.ceil((input.length + 9) / 64) * 64;
+  const output = new Uint8Array(length);
+  output.set(input);
+  output[input.length] = 128;
+  const bits = BigInt(input.length) * 8n;
+  for (let index = 0; index < 8; index += 1) {
+    output[length - 1 - index] = Number(bits >> BigInt(index * 8) & 0xffn);
+  }
+  return output;
+}
+function compress(bytes, offset, state) {
+  const words = new Uint32Array(64);
+  for (let index = 0; index < 16; index += 1) words[index] = readWord(bytes, offset + index * 4);
+  for (let index = 16; index < 64; index += 1) {
+    const first = words[index - 15];
+    const second = words[index - 2];
+    words[index] = add(
+      smallSigma0(first),
+      words[index - 16],
+      smallSigma1(second),
+      words[index - 7]
+    );
+  }
+  const working = [...state];
+  for (let index = 0; index < 64; index += 1) shaRound(working, words[index], index);
+  for (let index = 0; index < 8; index += 1) state[index] = add(state[index], working[index]);
+}
+function shaRound(working, word, index) {
+  const [a, b, c, d, e, f, g, h] = working;
+  const first = add(h, bigSigma1(e), e & f ^ ~e & g, ROUND_CONSTANTS[index], word);
+  const second = add(bigSigma0(a), a & b ^ a & c ^ b & c);
+  working[0] = add(first, second);
+  working[1] = a;
+  working[2] = b;
+  working[3] = c;
+  working[4] = add(d, first);
+  working[5] = e;
+  working[6] = f;
+  working[7] = g;
+}
+function readWord(bytes, offset) {
+  return bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3];
+}
+function add(...values) {
+  let result = 0;
+  for (const value of values) result = result + (value ?? 0) >>> 0;
+  return result;
+}
+function rotate(value, count) {
+  return value >>> count | value << 32 - count;
+}
+function smallSigma0(value) {
+  return rotate(value, 7) ^ rotate(value, 18) ^ value >>> 3;
+}
+function smallSigma1(value) {
+  return rotate(value, 17) ^ rotate(value, 19) ^ value >>> 10;
+}
+function bigSigma0(value) {
+  return rotate(value, 2) ^ rotate(value, 13) ^ rotate(value, 22);
+}
+function bigSigma1(value) {
+  return rotate(value, 6) ^ rotate(value, 11) ^ rotate(value, 25);
+}
+
+// src/input-readers.ts
+function readArray(input, maximum) {
+  const result = readArrayPrefix(input, maximum);
+  return result && !result.truncated ? result.items : null;
+}
+function readArrayPrefix(input, maximum) {
+  if (!Array.isArray(input)) return null;
+  try {
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(input, "length");
+    if (!lengthDescriptor || !("value" in lengthDescriptor)) return null;
+    const length = lengthDescriptor.value;
+    if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || !Number.isSafeInteger(maximum) || maximum < 0)
+      return null;
+    const output = [];
+    const readLength = Math.min(length, maximum);
+    for (let index = 0; index < readLength; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(input, String(index));
+      if (!descriptor || !("value" in descriptor)) return null;
+      output.push(descriptor.value);
+    }
+    return Object.freeze({ items: Object.freeze(output), truncated: length > maximum });
+  } catch {
+    return null;
+  }
+}
+function readStringArray(input, maximum) {
+  const items = readArray(input, maximum);
+  if (!items || items.some((item) => !validName(item))) return null;
+  return Object.freeze(items);
+}
+function validName(input) {
+  return typeof input === "string" && input.length > 0 && input.length <= 256;
+}
+
+// src/semantic-type.ts
+var primitiveNames = /* @__PURE__ */ new Set([
+  "null",
+  "boolean",
+  "number",
+  "string",
+  "json",
+  "Instant",
+  "Duration"
+]);
+function cloneSemanticType(input) {
+  if (input === "dynamic") return Object.freeze({ ok: true, value: "dynamic" });
+  const cloned = cloneSerializableData(input);
+  if (!cloned.ok || !isKaladaType(cloned.value, 0)) return Object.freeze({ ok: false });
+  return Object.freeze({ ok: true, value: cloned.value });
+}
+function readSemanticType(input) {
+  return cloneSemanticType(input);
+}
+function isKaladaType(input, depth) {
+  if (depth > 32) return false;
+  const inspected = readOwnDataRecord(input, 64);
+  if (!inspected.ok || typeof inspected.value.kind !== "string") return false;
+  const record = inspected.value;
+  if (record.kind === "primitive-type") return isPrimitive(record);
+  if (record.kind === "array-type") return isUnary(record, "element", depth);
+  if (record.kind === "option-type") return isUnary(record, "value", depth);
+  if (record.kind === "result-type") return isResult(record, depth);
+  if (record.kind === "function-type") return isFunction(record, depth);
+  return false;
+}
+function isPrimitive(record) {
+  return exactKeys(record, ["kind", "name"]) && primitiveNames.has(record.name);
+}
+function isUnary(record, field, depth) {
+  return exactKeys(record, ["kind", field]) && isKaladaType(record[field], depth + 1);
+}
+function isResult(record, depth) {
+  return exactKeys(record, ["kind", "ok", "error"]) && isKaladaType(record.ok, depth + 1) && isKaladaType(record.error, depth + 1);
+}
+function isFunction(record, depth) {
+  if (!exactKeys(record, ["kind", "parameters", "returns"])) return false;
+  if (!Array.isArray(record.parameters)) return false;
+  return record.parameters.every((parameter) => isKaladaType(parameter, depth + 1)) && isKaladaType(record.returns, depth + 1);
+}
+function exactKeys(record, expected) {
+  const keys = Object.keys(record);
+  return keys.length === expected.length && expected.every((key) => keys.includes(key));
+}
+
+// src/compile-expression.ts
+var DEFAULT_URI = "memory:///expression.kalada";
+var SYNTAX_CONTRACT = "kalada-syntax-lowering-result-v1";
+var CORE_CONTRACT = "kalada-core-compiled-program-v1";
+function parseExpression(source, options) {
+  const normalized = normalizeParseInput(source, options);
+  if (!normalized) return failed(executionDiagnostic("HOST_PARSE_INVALID_SOURCE", "parse"));
+  const syntax = parseKaladaV1Expression(source, normalized.syntax);
+  if (syntax.diagnostics.length > 0)
+    return failures(syntaxDiagnostics(syntax.diagnostics, normalized.source));
+  return success2(
+    Object.freeze({
+      format: "kalada-host-parsed-expression-v1",
+      source: normalized.source,
+      syntax,
+      parseFingerprintInput: normalized.fingerprintInput
+    })
+  );
+}
+function compileExpression(parsed, projection, options) {
+  const normalizedProjection = normalizeProjection(projection);
+  if (!normalizedProjection) {
+    return failed(executionDiagnostic("HOST_COMPILE_INVALID_PROJECTION", "compile"));
+  }
+  const normalizedOptions = normalizeCompileOptions(options);
+  if (!normalizedOptions)
+    return failed(executionDiagnostic("HOST_COMPILE_INVALID_OPTIONS", "compile"));
+  const references = Object.fromEntries(
+    normalizedProjection.bindings.map(({ id, name, semanticType }) => [
+      name,
+      Object.freeze({ reference: id, type: semanticType })
+    ])
+  );
+  const lower = lowerKaladaV1Expression(parsed.syntax, {
+    references,
+    coreOptions: { limits: normalizedOptions.limits }
+  });
+  if (!lower.ok) return failures(syntaxDiagnostics(lower.diagnostics, parsed.source));
+  const core = compileKaladaV1Program(lower.program, { limits: normalizedOptions.limits });
+  if (!core.ok) {
+    return failed(coreDiagnostic("compile", core.diagnostic, parsed.source, lower.sourceMap));
+  }
+  return success2(
+    compiledArtifact(parsed, normalizedProjection, normalizedOptions, lower, core.value)
+  );
+}
+function compiledArtifact(parsed, projection, options, lower, core) {
+  const projectionFingerprint = createFingerprint(projection.format, projection);
+  const compileFingerprint = createFingerprint(HOST_COMPILE_FINGERPRINT_VERSION, {
+    syntaxContract: SYNTAX_CONTRACT,
+    coreContract: CORE_CONTRACT,
+    compileOptionsContract: HOST_COMPILE_OPTIONS_CONTRACT,
+    source: parsed.source,
+    parseOptions: parsed.parseFingerprintInput,
+    profile: options.profile,
+    limits: options.limits,
+    projection,
+    program: lower.program
+  });
+  return createCompiledArtifact(
+    {
+      source: parsed.source,
+      parsed,
+      program: lower.program,
+      sourceMap: lower.sourceMap,
+      resultType: lower.resultType,
+      compileProjectionFingerprint: projectionFingerprint,
+      compileFingerprint
+    },
+    core
+  );
+}
+function normalizeParseInput(source, options) {
+  if (typeof source !== "string") return null;
+  if (options === void 0) return parseInput(source, DEFAULT_URI, void 0);
+  const inspected = readOwnDataRecord(options, 4);
+  if (!inspected.ok) return null;
+  const uri = inspected.value.sourceUri ?? DEFAULT_URI;
+  if (typeof uri !== "string" || uri.length === 0) return null;
+  if (inspected.value.syntax === void 0) return parseInput(source, uri, void 0);
+  const cloned = cloneSerializableData(inspected.value.syntax);
+  if (!cloned.ok) return null;
+  return parseInput(source, uri, cloned.value);
+}
+function parseInput(text, uri, syntax) {
+  const source = Object.freeze({ uri, text });
+  const fingerprintInput = Object.freeze({ uri, syntax: syntax ?? null });
+  return { source, syntax, fingerprintInput };
+}
+function normalizeProjection(input) {
+  const cloned = cloneSerializableData(input);
+  if (!cloned.ok) return null;
+  const value = cloned.value;
+  if (value.format !== "kalada-host-compile-projection-v1" || !Array.isArray(value.bindings)) {
+    return null;
+  }
+  const identities = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  const bindings = [];
+  for (const inputBinding of value.bindings) {
+    const inspected = readOwnDataRecord(inputBinding, 4);
+    if (!inspected.ok) return null;
+    const { id, name, semanticType } = inspected.value;
+    const semantic = cloneSemanticType(semanticType);
+    if (!validName(id) || !validName(name) || !semantic.ok) return null;
+    if (identities.has(id) || names.has(name)) return null;
+    identities.add(id);
+    names.add(name);
+    bindings.push(
+      Object.freeze({ id, name, semanticType: semantic.value })
+    );
+  }
+  return Object.freeze({
+    format: "kalada-host-compile-projection-v1",
+    bindings: Object.freeze(bindings)
+  });
+}
+function success2(value) {
+  return Object.freeze({ ok: true, value });
+}
+function failed(diagnostic) {
+  return failures([diagnostic]);
+}
+function failures(diagnostics) {
+  return Object.freeze({ ok: false, diagnostics: Object.freeze([...diagnostics]) });
+}
+
+// src/editor-admission.ts
+function calculateEditorGraphAdmission(request) {
+  const B = boundedCount(request.maxEdges);
+  const D = boundedCount(request.definitions);
+  const requestedChildren = boundedCount(request.children);
+  const V = boundedCount(request.resolutions);
+  const R = boundedCount(request.roots);
+  const Q = boundedCount(request.evidenceReserve ?? 0);
+  const fixed = D + V + R + Q;
+  const backboneAdmitted = fixed <= B;
+  const C = backboneAdmitted ? Math.min(requestedChildren, B - fixed) : 0;
+  const total = backboneAdmitted ? fixed + C : 0;
+  return Object.freeze({
+    model: Object.freeze({ B, D, C, V, R, Q }),
+    requestedChildren,
+    backboneAdmitted,
+    truncated: !backboneAdmitted || C < requestedChildren,
+    total,
+    remaining: B - total
+  });
+}
+function createEditorGraphEdgeMeter(maxEdges) {
+  const budget = boundedCount(maxEdges);
+  const counts = {
+    root: 0,
+    definition: 0,
+    child: 0,
+    resolution: 0
+  };
+  return Object.freeze({
+    claim(category) {
+      if (sumCounts(counts) >= budget) return false;
+      counts[category] += 1;
+      return true;
+    },
+    snapshot() {
+      const total = sumCounts(counts);
+      return Object.freeze({ budget, ...counts, total, remaining: budget - total });
+    }
+  });
+}
+function boundedCount(value) {
+  return Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+function sumCounts(counts) {
+  return counts.root + counts.definition + counts.child + counts.resolution;
+}
+
+// src/editor-cycle.ts
+function markReferenceCycles(nodes, references) {
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  for (const reference of references) {
+    const node = nodes[reference.index];
+    if (node?.kind !== "reference" || !node.target) continue;
+    if (!isReachable(byId, node.target.nodeId, node.id)) continue;
+    nodes[reference.index] = {
+      ...node,
+      target: cycleEdge(node.target)
+    };
+  }
+}
+function isReachable(nodes, start, target) {
+  const pending = [start];
+  const discovered = /* @__PURE__ */ new Set([start]);
+  while (pending.length > 0) {
+    const id = pending.pop();
+    if (!id) continue;
+    if (id === target) return true;
+    const node = nodes.get(id);
+    if (node) addUndiscovered(outgoingNodeIds(node), discovered, pending);
+  }
+  return false;
+}
+function addUndiscovered(next, discovered, pending) {
+  for (const id of next) {
+    if (discovered.has(id)) continue;
+    discovered.add(id);
+    pending.push(id);
+  }
+}
+function outgoingNodeIds(node) {
+  const relations = (node.relations ?? []).map(({ nodeId }) => nodeId);
+  if (node.kind === "object") {
+    return [
+      ...relations,
+      ...node.properties.map(({ nodeId }) => nodeId),
+      ...node.additionalProperties ? [node.additionalProperties.nodeId] : []
+    ];
+  }
+  if (node.kind === "array") return [...relations, node.element.nodeId];
+  if (node.kind === "tuple") {
+    return [
+      ...relations,
+      ...node.items.map(({ nodeId }) => nodeId),
+      ...node.rest ? [node.rest.nodeId] : []
+    ];
+  }
+  if (node.kind === "union") return [...relations, ...node.variants.map(({ nodeId }) => nodeId)];
+  if (node.kind === "intersection")
+    return [...relations, ...node.operands.map(({ nodeId }) => nodeId)];
+  if (node.kind === "record") return [...relations, node.key.nodeId, node.value.nodeId];
+  if (node.kind === "wrapper") return [...relations, node.inner.nodeId];
+  if (node.kind === "reference" && node.target) return [...relations, node.target.nodeId];
+  return relations;
+}
+function cycleEdge(edge2) {
+  return Object.freeze({ nodeId: edge2.nodeId, path: edge2.path, cycle: true });
+}
+
+// src/editor-node-builders.ts
+function withNodeEvidence(node, record, path, context) {
+  const relations = relationEdges(record.relations, path, context);
+  if (!relations) return unknownNode(node.id, path, "invalid-shape");
+  const annotations = optionalData(record.annotations);
+  const constraints = optionalData(record.constraints);
+  if (!annotations.ok || !constraints.ok) return unknownNode(node.id, path, "invalid-shape");
+  return {
+    ...node,
+    ...validText(record.sourceId) ? { sourceId: record.sourceId } : {},
+    ...annotations.value === void 0 ? {} : { annotations: annotations.value },
+    ...constraints.value === void 0 ? {} : { constraints: constraints.value },
+    relations: Object.freeze(relations)
+  };
+}
+function scalarNode(record, id, path) {
+  const names = [
+    "null",
+    "boolean",
+    "number",
+    "integer",
+    "string",
+    "undefined",
+    "void",
+    "bigint",
+    "symbol",
+    "date",
+    "NaN",
+    "json",
+    "instant",
+    "duration"
+  ];
+  if (typeof record.name !== "string" || !names.includes(record.name)) {
+    return unknownNode(id, path, "invalid-shape");
+  }
+  return { id, path, kind: "scalar", name: record.name, ...available() };
+}
+function declaredUnknownNode(record, id, path) {
+  const reason = typeof record.reason === "string" ? record.reason.slice(0, 256) : void 0;
+  const code = validUnknownCode(record.evidenceCode) ? record.evidenceCode : "unsupported-shape";
+  return {
+    ...unknownNode(id, path, code),
+    ...reason === void 0 ? {} : { reason }
+  };
+}
+function validUnknownCode(value) {
+  return [
+    "invalid-shape",
+    "unsupported-shape",
+    "depth-limit",
+    "node-limit",
+    "edge-limit",
+    "unresolved-reference"
+  ].includes(value);
+}
+function objectNode(record, id, path, context) {
+  const items = readArray(record.properties, context.maximumCollectionSize);
+  if (!items) return unknownNode(id, path, "invalid-shape");
+  const properties = [];
+  for (let index = 0; index < items.length; index += 1) {
+    const property = propertyEdge(items[index], index, path, context);
+    if (!property) return partialObjectNode(id, path, properties);
+    properties.push(property);
+  }
+  const additionalProperties = optionalChild(record.additionalProperties, [...path, "*"], context);
+  if (additionalProperties === null) return partialObjectNode(id, path, properties);
+  const requiredNames = stringList(record.requiredNames);
+  if (!requiredNames) return unknownNode(id, path, "invalid-shape");
+  const unknownKeys = validUnknownKeys(record.unknownKeys) ? record.unknownKeys : void 0;
+  return {
+    id,
+    path,
+    kind: "object",
+    properties: Object.freeze(properties),
+    requiredNames: Object.freeze(requiredNames),
+    ...additionalProperties ? { additionalProperties } : {},
+    ...unknownKeys ? { unknownKeys } : {},
+    ...available()
+  };
+}
+function propertyEdge(input, index, path, context) {
+  const inspected = readOwnDataRecord(input, 4);
+  const record = inspected.ok ? inspected.value : /* @__PURE__ */ Object.create(null);
+  const name = typeof record.name === "string" ? record.name : `<invalid:${index}>`;
+  const childPath = freezePath([...path, name]);
+  const child = context.child(record.shape, childPath);
+  const presence = readPresence(record);
+  return child ? Object.freeze({ ...child, name, required: presence === "required", presence }) : null;
+}
+function arrayNode(record, id, path, context) {
+  const element = context.child(record.element, freezePath([...path, "[]"]));
+  return element ? { id, path, kind: "array", element, ...available() } : unknownNode(id, path, "edge-limit");
+}
+function tupleNode(record, id, path, context) {
+  const sourceItems = readArray(record.items, context.maximumCollectionSize);
+  if (!sourceItems) return unknownNode(id, path, "invalid-shape");
+  const built = buildIndexedEdges(sourceItems, path, context);
+  if (!built.complete) return partialTupleNode(id, path, built.items);
+  const items = built.items;
+  if (record.rest === void 0) {
+    return { id, path, kind: "tuple", items: Object.freeze(items), ...available() };
+  }
+  const rest = context.child(record.rest, freezePath([...path, "..."]));
+  return rest ? { id, path, kind: "tuple", items: Object.freeze(items), rest, ...available() } : partialTupleNode(id, path, items);
+}
+function buildIndexedEdges(inputs, path, context) {
+  const items = [];
+  for (let index = 0; index < inputs.length; index += 1) {
+    const item = context.child(inputs[index], freezePath([...path, index]));
+    if (!item) return { complete: false, items };
+    items.push(item);
+  }
+  return { complete: true, items };
+}
+function unionNode(record, id, path, context) {
+  const inputs = readArray(record.variants, context.maximumCollectionSize);
+  if (!inputs) return unknownNode(id, path, "invalid-shape");
+  const variants = [];
+  for (let index = 0; index < inputs.length; index += 1) {
+    const variant = context.child(inputs[index], freezePath([...path, "$variant", index]));
+    if (!variant) return partialUnionNode(id, path, variants);
+    variants.push(variant);
+  }
+  const discriminator = optionalData(record.discriminator);
+  if (!discriminator.ok) return unknownNode(id, path, "invalid-shape");
+  return {
+    id,
+    path,
+    kind: "union",
+    variants: Object.freeze(variants),
+    ...validText(record.semantics) ? { semantics: record.semantics } : {},
+    ...discriminator.value === void 0 ? {} : { discriminator: discriminator.value },
+    ...available()
+  };
+}
+function unknownNode(id, path, code) {
+  return {
+    id,
+    path,
+    kind: "unknown",
+    availability: "unknown",
+    evidence: evidence(code, path),
+    relations: Object.freeze([])
+  };
+}
+function evidence(code, path) {
+  return Object.freeze([Object.freeze({ code, path })]);
+}
+function partialObjectNode(id, path, properties) {
+  return {
+    id,
+    path,
+    kind: "object",
+    properties: Object.freeze(properties),
+    requiredNames: Object.freeze([]),
+    ...unavailable("edge-limit", path)
+  };
+}
+function partialTupleNode(id, path, items) {
+  return {
+    id,
+    path,
+    kind: "tuple",
+    items: Object.freeze(items),
+    ...unavailable("edge-limit", path)
+  };
+}
+function partialUnionNode(id, path, variants) {
+  return {
+    id,
+    path,
+    kind: "union",
+    variants: Object.freeze(variants),
+    ...unavailable("edge-limit", path)
+  };
+}
+function available() {
+  return { availability: "available", evidence: Object.freeze([]), relations: Object.freeze([]) };
+}
+function unavailable(code, path) {
+  return {
+    availability: "unknown",
+    evidence: evidence(code, path),
+    relations: Object.freeze([])
+  };
+}
+function freezePath(path) {
+  return Object.freeze([...path]);
+}
+function readPresence(record) {
+  if (["required", "optional", "unknown"].includes(record.presence)) {
+    return record.presence;
+  }
+  return record.required === true ? "required" : "optional";
+}
+function optionalChild(value, path, context) {
+  return value === void 0 ? void 0 : context.child(value, freezePath(path));
+}
+function optionalData(value) {
+  if (value === void 0) return Object.freeze({ ok: true });
+  const cloned = cloneSerializableData(value);
+  return cloned.ok ? Object.freeze({ ok: true, value: cloned.value }) : Object.freeze({ ok: false });
+}
+function stringList(value) {
+  if (value === void 0) return [];
+  const items = readArray(value, 8192);
+  return items?.every((item) => typeof item === "string") ? items : null;
+}
+function validUnknownKeys(value) {
+  return ["strip", "reject", "passthrough", "schema", "unknown"].includes(value);
+}
+function validText(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 1024;
+}
+function relationEdges(input, path, context) {
+  if (input === void 0) return [];
+  const items = readArray(input, context.maximumCollectionSize);
+  if (!items) return null;
+  const output = [];
+  for (let index = 0; index < items.length; index += 1) {
+    const inspected = readOwnDataRecord(items[index], 4);
+    if (!inspected.ok || !validText(inspected.value.name)) return null;
+    const child = context.child(inspected.value.shape, freezePath([...path, "$relation", index]));
+    if (!child) return null;
+    const key = validText(inspected.value.key) ? inspected.value.key : void 0;
+    output.push(Object.freeze({ ...child, name: inspected.value.name, ...key ? { key } : {} }));
+  }
+  return output;
+}
+
+// src/editor-evidence-builders.ts
+var available2 = Object.freeze({
+  availability: "available",
+  evidence: Object.freeze([]),
+  relations: Object.freeze([])
+});
+function evidenceNode(record, id, path) {
+  if (record.kind === "literal") return dataNode("literal", "value", record, id, path);
+  if (record.kind === "enum") return enumNode(record, id, path);
+  if (record.kind === "never") return { id, path, kind: "never", ...available2 };
+  if (record.kind === "unconstrained") return unconstrainedNode(record, id, path);
+  if (record.kind === "opaque") return opaqueNode(record, id, path);
+  return null;
+}
+function compositeEvidenceNode(record, id, path, context) {
+  if (record.kind === "record") return recordNode(record, id, path, context);
+  if (record.kind === "intersection") return intersectionNode(record, id, path, context);
+  if (record.kind === "wrapper") return wrapperNode(record, id, path, context);
+  return null;
+}
+function dataNode(kind, field, record, id, path) {
+  const cloned = cloneSerializableData(record[field]);
+  return cloned.ok ? { id, path, kind, [field]: cloned.value, ...available2 } : unknownNode(id, path, "invalid-shape");
+}
+function enumNode(record, id, path) {
+  const cloned = cloneSerializableData(record.values);
+  if (!cloned.ok || !Array.isArray(cloned.value)) return unknownNode(id, path, "invalid-shape");
+  return { id, path, kind: "enum", values: cloned.value, ...available2 };
+}
+function unconstrainedNode(record, id, path) {
+  return record.domain === "json" || record.domain === "js" ? { id, path, kind: "unconstrained", domain: record.domain, ...available2 } : unknownNode(id, path, "invalid-shape");
+}
+function opaqueNode(record, id, path) {
+  return typeof record.reason === "string" ? { id, path, kind: "opaque", reason: record.reason.slice(0, 256), ...available2 } : unknownNode(id, path, "invalid-shape");
+}
+function recordNode(record, id, path, context) {
+  const key = context.child(record.key, Object.freeze([...path, "$key"]));
+  const value = context.child(record.value, Object.freeze([...path, "$value"]));
+  const exhaustive = record.exhaustive;
+  if (!key || !value || exhaustive !== true && exhaustive !== false && exhaustive !== "unknown") {
+    return unknownNode(id, path, "invalid-shape");
+  }
+  return { id, path, kind: "record", key, value, exhaustive, ...available2 };
+}
+function intersectionNode(record, id, path, context) {
+  const operands = childList(record.operands, path, "$operand", context);
+  return operands ? { id, path, kind: "intersection", operands: Object.freeze(operands), ...available2 } : unknownNode(id, path, "invalid-shape");
+}
+function wrapperNode(record, id, path, context) {
+  const inner = context.child(record.inner, Object.freeze([...path, "$inner"]));
+  if (!inner || typeof record.wrapper !== "string") return unknownNode(id, path, "invalid-shape");
+  const value = record.value === void 0 ? void 0 : cloneSerializableData(record.value);
+  if (value && !value.ok) return unknownNode(id, path, "invalid-shape");
+  return {
+    id,
+    path,
+    kind: "wrapper",
+    wrapper: record.wrapper.slice(0, 256),
+    inner,
+    ...value?.ok ? { value: value.value } : {},
+    ...available2
+  };
+}
+function childList(input, path, segment, context) {
+  const items = readArray(input, context.maximumCollectionSize);
+  if (!items) return null;
+  const output = [];
+  for (let index = 0; index < items.length; index += 1) {
+    const child = context.child(items[index], Object.freeze([...path, segment, index]));
+    if (!child) return null;
+    output.push(child);
+  }
+  return output;
+}
+
+// src/editor-input-validation.ts
+function validateEditorDocument(document) {
+  const state = { seen: /* @__PURE__ */ new WeakSet(), nodes: 0 };
+  if (!validateShape(document.root, 0, state)) return false;
+  const definitions = readArray(document.definitions ?? [], 2048);
+  if (!definitions) return false;
+  for (const definition of definitions) {
+    const inspected = readOwnDataRecord(definition, 3);
+    if (!inspected.ok || !validateShape(inspected.value.shape, 0, state)) return false;
+  }
+  return true;
+}
+function readEditorEvidence(value) {
+  const items = readArray(value, 8192) ?? [];
+  const allowed = [
+    "invalid-shape",
+    "unsupported-shape",
+    "depth-limit",
+    "node-limit",
+    "edge-limit",
+    "unresolved-reference"
+  ];
+  return items.filter(
+    (item) => typeof item === "string" && allowed.includes(item)
+  );
+}
+function validateShape(input, depth, state) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return false;
+  if (state.seen.has(input)) return true;
+  state.nodes += 1;
+  if (depth > 32 || state.nodes > 2048) return true;
+  state.seen.add(input);
+  const inspected = readOwnDataRecord(input, 8192);
+  if (!inspected.ok) return false;
+  const record = inspected.value;
+  if (!validateRelations(record.relations, depth, state)) return false;
+  if (record.kind === "object") return validateObject(record, depth, state);
+  if (record.kind === "array") return validateShape(record.element, depth + 1, state);
+  if (record.kind === "tuple") return validateTuple(record, depth, state);
+  if (record.kind === "union") return validateCollection(record.variants, depth, state);
+  if (record.kind === "intersection") return validateCollection(record.operands, depth, state);
+  if (record.kind === "record") {
+    return validateShape(record.key, depth + 1, state) && validateShape(record.value, depth + 1, state);
+  }
+  if (record.kind === "wrapper") return validateShape(record.inner, depth + 1, state);
+  return true;
+}
+function validateObject(record, depth, state) {
+  if (!validateProperties(record.properties, depth, state)) return false;
+  return record.additionalProperties === void 0 || validateShape(record.additionalProperties, depth + 1, state);
+}
+function validateRelations(input, depth, state) {
+  if (input === void 0) return true;
+  const relations = readArray(input, 8192);
+  if (!relations) return false;
+  for (const relation of relations) {
+    const inspected = readOwnDataRecord(relation, 4);
+    if (!inspected.ok || !validateShape(inspected.value.shape, depth + 1, state)) return false;
+  }
+  return true;
+}
+function validateProperties(input, depth, state) {
+  const properties = readArray(input, 8192);
+  if (!properties) return false;
+  for (const property of properties) {
+    const inspected = readOwnDataRecord(property, 4);
+    if (!inspected.ok || !validateShape(inspected.value.shape, depth + 1, state)) return false;
+  }
+  return true;
+}
+function validateTuple(record, depth, state) {
+  if (!validateCollection(record.items, depth, state)) return false;
+  return record.rest === void 0 || validateShape(record.rest, depth + 1, state);
+}
+function validateCollection(input, depth, state) {
+  const items = readArray(input, 8192);
+  if (!items) return false;
+  return items.every((item) => validateShape(item, depth + 1, state));
+}
+
+// src/editor-graph.ts
+var DEFAULT_EDITOR_GRAPH_LIMITS = Object.freeze({
+  maxDepth: 32,
+  maxNodes: 2048,
+  maxEdges: 8192
+});
+function createEditorGraph(inputs, requestedLimits = {}) {
+  let limits = DEFAULT_EDITOR_GRAPH_LIMITS;
+  try {
+    const normalized = normalizeLimits2(requestedLimits);
+    if (!normalized) return invalidGraph(limits);
+    limits = normalized;
+    return buildGraph(inputs, limits);
+  } catch {
+    return invalidGraph(limits);
+  }
+}
+function buildGraph(inputs, limits) {
+  const sourceDocuments = readArrayPrefix(inputs, limits.maxEdges + 1);
+  if (!sourceDocuments) return invalidGraph(limits, "invalid-shape");
+  const state = createState(limits);
+  const roots = [];
+  const definitions = [];
+  const targets = /* @__PURE__ */ new Map();
+  for (const input of sourceDocuments.items) {
+    const inspected = readGraphInput(input);
+    if (!inspected) return invalidGraph(limits, "invalid-shape");
+    addDocument(inspected, state, roots, definitions, targets);
+  }
+  if (sourceDocuments.truncated) recordEvidence("edge-limit", Object.freeze([]), state);
+  resolveReferences(state, targets);
+  markReferenceCycles(state.nodes, state.references);
+  const nodes = state.nodes.map((node) => Object.freeze(node));
+  return Object.freeze({
+    format: "kalada-editor-graph-v1",
+    nodeIdScope: "document-local",
+    limits,
+    roots: Object.freeze(roots),
+    nodes: Object.freeze(nodes),
+    definitions: Object.freeze(definitions),
+    evidence: Object.freeze(state.evidence),
+    admission: state.meter.snapshot()
+  });
+}
+function invalidGraph(limits, code = "invalid-shape") {
+  const path = Object.freeze([]);
+  const node = Object.freeze(unknownNode("n0", path, code));
+  const root = Object.freeze({ ...edge("n0", path, false), bindingId: "<invalid>" });
+  return Object.freeze({
+    format: "kalada-editor-graph-v1",
+    nodeIdScope: "document-local",
+    limits,
+    roots: Object.freeze([root]),
+    nodes: Object.freeze([node]),
+    definitions: Object.freeze([]),
+    evidence: evidence(code, path),
+    admission: createEditorGraphEdgeMeter(limits.maxEdges).snapshot()
+  });
+}
+function createState(limits) {
+  return {
+    limits,
+    nodes: [],
+    active: /* @__PURE__ */ new WeakMap(),
+    references: [],
+    evidence: [],
+    meter: createEditorGraphEdgeMeter(limits.maxEdges)
+  };
+}
+function addDocument(input, state, roots, definitions, targets) {
+  const path = freezePath2(input.path);
+  if (!claimEdge("root", path, state)) return;
+  const root = addNode(input.document.root, path, 0, input.bindingId, state);
+  roots.push(Object.freeze({ ...root, bindingId: input.bindingId }));
+  const bindingTargets = /* @__PURE__ */ new Map();
+  targets.set(input.bindingId, bindingTargets);
+  const sourceDefinitions = readArrayPrefix(
+    input.document.definitions ?? [],
+    state.limits.maxEdges + 1
+  );
+  if (!sourceDefinitions) {
+    recordEvidence("invalid-shape", path, state);
+    return;
+  }
+  for (const definition of sourceDefinitions.items) {
+    const inspected = readDefinition(definition);
+    if (!inspected) {
+      recordEvidence("invalid-shape", path, state);
+      continue;
+    }
+    addDefinition(input, inspected, state, definitions, bindingTargets);
+  }
+  if (sourceDefinitions.truncated) recordEvidence("edge-limit", path, state);
+  for (const code of input.document.evidence ?? []) recordEvidence(code, path, state);
+}
+function addDefinition(input, definition, state, definitions, targets) {
+  const path = freezePath2([...input.path, "$defs", definition.name]);
+  if (!claimEdge("definition", path, state)) return;
+  const edge2 = addNode(definition.shape, path, 0, input.bindingId, state);
+  const item = Object.freeze({
+    bindingId: input.bindingId,
+    name: definition.name,
+    nodeId: edge2.nodeId,
+    path
+  });
+  definitions.push(item);
+  if (!targets.has(definition.name)) targets.set(definition.name, edge2.nodeId);
+}
+function addNode(shape, path, depth, bindingId, state) {
+  if (depth > state.limits.maxDepth) return unknownEdge("depth-limit", path, state);
+  if (typeof shape !== "object" || shape === null || Array.isArray(shape)) {
+    return unknownEdge("invalid-shape", path, state);
+  }
+  const prior = state.active.get(shape);
+  if (prior) return edge(prior, path, true);
+  if (state.nodes.length >= state.limits.maxNodes - 1)
+    return unknownEdge("node-limit", path, state);
+  const id = `n${state.nodes.length}`;
+  state.active.set(shape, id);
+  const index = state.nodes.length;
+  state.nodes.push(unknownNode(id, path, "invalid-shape"));
+  state.nodes[index] = readNode(shape, id, path, depth, bindingId, state);
+  state.active.delete(shape);
+  return edge(id, path, false);
+}
+function readNode(shape, id, path, depth, bindingId, state) {
+  const inspected = readOwnDataRecord(shape, state.limits.maxEdges);
+  if (!inspected.ok) return unknownNode(id, path, "invalid-shape");
+  const record = inspected.value;
+  const context = nodeContext(depth, bindingId, state);
+  const node = buildNode(record, id, path, bindingId, state, context);
+  return withNodeEvidence(node, record, path, context);
+}
+function buildNode(record, id, path, bindingId, state, context) {
+  if (record.kind === "scalar") return scalarNode(record, id, path);
+  if (record.kind === "unknown") return declaredUnknownNode(record, id, path);
+  if (record.kind === "object") return objectNode(record, id, path, context);
+  if (record.kind === "array") return arrayNode(record, id, path, context);
+  if (record.kind === "tuple") return tupleNode(record, id, path, context);
+  if (record.kind === "union") return unionNode(record, id, path, context);
+  if (record.kind === "reference") return referenceNode(record, id, path, bindingId, state);
+  return evidenceNode(record, id, path) ?? compositeEvidenceNode(record, id, path, context) ?? unknownNode(id, path, "unsupported-shape");
+}
+function nodeContext(depth, bindingId, state) {
+  return {
+    maximumCollectionSize: state.limits.maxEdges + 1,
+    child: (shape, path) => childEdge(shape, path, depth, bindingId, state)
+  };
+}
+function referenceNode(record, id, path, bindingId, state) {
+  if (typeof record.definition !== "string" || record.definition.length === 0) {
+    return unknownNode(id, path, "invalid-shape");
+  }
+  const unresolved = typeof record.unresolved === "string" ? record.unresolved : void 0;
+  const node = {
+    id,
+    path,
+    kind: "reference",
+    definition: record.definition,
+    status: "unresolved",
+    availability: unresolved === void 0 ? "unknown" : "unavailable",
+    evidence: evidence("unresolved-reference", path),
+    relations: Object.freeze([]),
+    ...typeof record.reference === "string" ? { reference: record.reference } : {},
+    ...unresolved === void 0 ? {} : { unresolved }
+  };
+  state.references.push({ index: state.nodes.length - 1, bindingId });
+  return node;
+}
+function childEdge(shape, path, depth, bindingId, state) {
+  if (!claimEdge("child", path, state)) return null;
+  return addNode(shape, path, depth + 1, bindingId, state);
+}
+function unknownEdge(code, path, state) {
+  if (state.limitNodeIndex !== void 0) {
+    const index = state.limitNodeIndex;
+    appendUnknownEvidence(index, code, path, state);
+    return edge(`n${index}`, path, false);
+  }
+  const id = `n${state.nodes.length}`;
+  state.limitNodeIndex = state.nodes.length;
+  state.nodes.push(unknownNode(id, path, code));
+  return edge(id, path, false);
+}
+function appendUnknownEvidence(index, code, path, state) {
+  const node = state.nodes[index];
+  if (node?.kind !== "unknown" || node.evidence.length >= state.limits.maxEdges) return;
+  if (node.evidence.some((item2) => item2.code === code && samePath(item2.path, path))) return;
+  const item = Object.freeze({ code, path: freezePath2(path) });
+  state.nodes[index] = { ...node, evidence: Object.freeze([...node.evidence, item]) };
+}
+function resolveReferences(state, targets) {
+  for (const reference of state.references) {
+    const node = state.nodes[reference.index];
+    if (node?.kind !== "reference" || node.unresolved !== void 0) continue;
+    const target = targets.get(reference.bindingId)?.get(node.definition);
+    if (!target) continue;
+    if (!claimEdge("resolution", node.path, state)) {
+      state.nodes[reference.index] = {
+        ...node,
+        evidence: evidence("edge-limit", node.path)
+      };
+      continue;
+    }
+    state.nodes[reference.index] = {
+      ...node,
+      status: "resolved",
+      target: edge(target, node.path, false),
+      availability: "available",
+      evidence: Object.freeze([])
+    };
+  }
+}
+function edge(nodeId, path, cycle) {
+  return Object.freeze({ nodeId, path, cycle });
+}
+function claimEdge(category, path, state) {
+  if (!state.meter.claim(category)) {
+    recordEvidence("edge-limit", path, state);
+    return false;
+  }
+  return true;
+}
+function recordEvidence(code, path, state) {
+  if (state.evidence.length >= state.limits.maxEdges) return;
+  if (state.evidence.some((item) => item.code === code && samePath(item.path, path))) return;
+  state.evidence.push(Object.freeze({ code, path: freezePath2(path) }));
+}
+function samePath(left, right) {
+  return left.length === right.length && left.every((part, index) => part === right[index]);
+}
+function readGraphInput(input) {
+  const inspected = readOwnDataRecord(input, 4);
+  if (!inspected.ok || typeof inspected.value.bindingId !== "string") return null;
+  const path = readArray(inspected.value.path, 256);
+  const document = readOwnDataRecord(inspected.value.document, 4);
+  if (!path || !document.ok || document.value.root === void 0) return null;
+  if (!path.every((part) => typeof part === "string" || typeof part === "number")) return null;
+  return {
+    bindingId: inspected.value.bindingId,
+    path: freezePath2(path),
+    document: {
+      root: document.value.root,
+      definitions: document.value.definitions,
+      evidence: readEditorEvidence(document.value.evidence)
+    }
+  };
+}
+function readDefinition(input) {
+  const inspected = readOwnDataRecord(input, 3);
+  if (!inspected.ok || typeof inspected.value.name !== "string") return null;
+  return Object.freeze({ name: inspected.value.name, shape: inspected.value.shape });
+}
+function freezePath2(path) {
+  return Object.freeze([...path]);
+}
+function normalizeLimits2(input) {
+  const inspected = readOwnDataRecord(input, 3);
+  if (!inspected.ok) return null;
+  const record = inspected.value;
+  return Object.freeze({
+    maxDepth: positiveInteger(record.maxDepth, DEFAULT_EDITOR_GRAPH_LIMITS.maxDepth),
+    maxNodes: positiveInteger(record.maxNodes, DEFAULT_EDITOR_GRAPH_LIMITS.maxNodes),
+    maxEdges: positiveInteger(record.maxEdges, DEFAULT_EDITOR_GRAPH_LIMITS.maxEdges)
+  });
+}
+function positiveInteger(input, fallback) {
+  return typeof input === "number" && Number.isSafeInteger(input) && input > 0 ? input : fallback;
+}
+
+// src/editor-traversal.ts
+function traverseEditorGraph(graph, options = {}) {
+  const state = {
+    nodes: new Map(graph.nodes.map((node) => [node.id, node])),
+    steps: [],
+    active: /* @__PURE__ */ new Set(),
+    maxDepth: bounded(options.maxDepth, graph.limits.maxDepth),
+    maxVisits: bounded(options.maxVisits, graph.limits.maxEdges + graph.limits.maxNodes)
+  };
+  for (const root of graph.roots) {
+    walk(root, "root", 0, state);
+    if (state.steps.length >= state.maxVisits) break;
+  }
+  return Object.freeze(state.steps);
+}
+function walk(edge2, via, depth, state) {
+  if (depth > state.maxDepth || state.steps.length >= state.maxVisits) return;
+  const node = state.nodes.get(edge2.nodeId);
+  if (!node) return;
+  const cycle = state.active.has(edge2.nodeId);
+  state.steps.push(
+    Object.freeze({
+      nodeId: edge2.nodeId,
+      path: Object.freeze([...edge2.path]),
+      depth,
+      via,
+      cycle,
+      availability: node.availability
+    })
+  );
+  if (cycle || depth === state.maxDepth) return;
+  state.active.add(edge2.nodeId);
+  walkChildren(node, depth, state);
+  state.active.delete(edge2.nodeId);
+}
+function walkChildren(node, depth, state) {
+  for (const relation of node.relations ?? []) walk(relation, "relation", depth + 1, state);
+  if (node.kind === "object") {
+    for (const property of node.properties) walk(property, "property", depth + 1, state);
+    if (node.additionalProperties) {
+      walk(node.additionalProperties, "additional-property", depth + 1, state);
+    }
+    return;
+  }
+  if (node.kind === "array") {
+    walk(node.element, "element", depth + 1, state);
+    return;
+  }
+  if (node.kind === "tuple") {
+    walkTuple(node, depth, state);
+    return;
+  }
+  if (node.kind === "union") {
+    for (const variant of node.variants) walk(variant, "variant", depth + 1, state);
+    return;
+  }
+  walkComposite(node, depth, state);
+}
+function walkComposite(node, depth, state) {
+  if (node.kind === "intersection") {
+    for (const operand of node.operands) walk(operand, "operand", depth + 1, state);
+    return;
+  }
+  if (node.kind === "record") {
+    walk(node.key, "record-key", depth + 1, state);
+    walk(node.value, "record-value", depth + 1, state);
+    return;
+  }
+  if (node.kind === "wrapper") {
+    walk(node.inner, "wrapper", depth + 1, state);
+    return;
+  }
+  if (node.kind === "reference" && node.target) {
+    walk(node.target, "reference", depth + 1, state);
+  }
+}
+function walkTuple(node, depth, state) {
+  for (const item of node.items) walk(item, "item", depth + 1, state);
+  if (node.rest) walk(node.rest, "rest", depth + 1, state);
+}
+function bounded(input, fallback) {
+  if (typeof input !== "number" || !Number.isSafeInteger(input) || input < 0) return fallback;
+  return Math.min(input, fallback);
+}
+
+// src/capability-snapshot.ts
+var constructionToken2 = Object.freeze({});
+var AuthenticCapabilitySnapshot = class {
+  scope = "instance";
+  capabilities;
+  #environment;
+  constructor(token, environment, capabilities) {
+    if (token !== constructionToken2)
+      throw new TypeError("Invalid capability snapshot construction.");
+    this.#environment = environment;
+    this.capabilities = capabilities;
+    Object.freeze(this);
+  }
+  static compatible(input, environment) {
+    if (typeof input !== "object" || input === null || !(#environment in input)) return false;
+    if (input.#environment === environment) return true;
+    return cacheableEquivalent(input.#environment, environment);
+  }
+};
+Object.freeze(AuthenticCapabilitySnapshot.compatible);
+Object.freeze(AuthenticCapabilitySnapshot.prototype);
+Object.freeze(AuthenticCapabilitySnapshot);
+function createCapabilitySnapshot(environment, capabilities) {
+  return new AuthenticCapabilitySnapshot(constructionToken2, environment, capabilities);
+}
+function capabilitySnapshotMatches(snapshot, environment) {
+  return AuthenticCapabilitySnapshot.compatible(snapshot, environment);
+}
+function cacheableEquivalent(left, right) {
+  if (!left.cacheability.cacheable || !right.cacheability.cacheable) return false;
+  return JSON.stringify(left.provider.identity) === JSON.stringify(right.provider.identity) && JSON.stringify(left.capabilities) === JSON.stringify(right.capabilities);
+}
+function canonicalValue(input) {
+  try {
+    const value = decodeKaladaValue(encodeKaladaValue(input));
+    return Object.freeze({ ok: true, value });
+  } catch {
+    return Object.freeze({ ok: false });
+  }
+}
+function matchesSemanticType(value, expected) {
+  if (expected === "dynamic") return true;
+  return matchesKnownType(value, expected);
+}
+function matchesKnownType(value, expected) {
+  if (expected.kind === "primitive-type") return matchesPrimitive(value, expected.name);
+  if (expected.kind === "array-type") {
+    return Array.isArray(value) && value.every((item) => matchesKnownType(item, expected.element));
+  }
+  if (expected.kind === "option-type") {
+    return isOption(value) && (value.variant === "none" || matchesKnownType(value.value, expected.value));
+  }
+  if (expected.kind === "result-type") {
+    return isResult$1(value) && matchesKnownType(value.value, value.variant === "ok" ? expected.ok : expected.error);
+  }
+  return false;
+}
+function matchesPrimitive(value, name) {
+  if (name === "json") {
+    return !isOption(value) && !isResult$1(value) && !isInstant(value) && !isDuration(value);
+  }
+  if (name === "Instant") return isInstant(value);
+  if (name === "Duration") return isDuration(value);
+  if (name === "null") return value === null;
+  return typeof value === name;
+}
+function isThenableWithoutGet(input) {
+  if ((typeof input !== "object" || input === null) && typeof input !== "function") return false;
+  let current = input;
+  const visited = /* @__PURE__ */ new Set();
+  try {
+    while (current !== null && !visited.has(current)) {
+      visited.add(current);
+      const descriptor = Object.getOwnPropertyDescriptor(current, "then");
+      if (descriptor) return !("value" in descriptor) || typeof descriptor.value === "function";
+      current = Object.getPrototypeOf(current);
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+function readOwnValue(input, name) {
+  if ((typeof input !== "object" || input === null) && typeof input !== "function") {
+    return Object.freeze({ ok: false });
+  }
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(input, name);
+    if (!descriptor || !("value" in descriptor)) return Object.freeze({ ok: false });
+    return Object.freeze({ ok: true, value: descriptor.value });
+  } catch {
+    return Object.freeze({ ok: false });
+  }
+}
+
+// src/evaluate-expression.ts
+function evaluateLinked(compiled, slots, values) {
+  const bound = /* @__PURE__ */ new Map();
+  for (const slot of slots) {
+    const result = bindSlot(slot, values);
+    if (!result.ok) return result;
+    bound.set(slot.plan.bindingId, result.value);
+  }
+  const outcome = compiled.coreCompilation.evaluate(
+    (reference) => bound.has(reference) ? Object.freeze({ found: true, value: bound.get(reference) }) : Object.freeze({ found: false, reason: "missing" })
+  );
+  if (!outcome.ok) {
+    return failure2(
+      coreDiagnostic("evaluate", outcome.diagnostic, compiled.source, compiled.sourceMap)
+    );
+  }
+  return Object.freeze({ ok: true, value: outcome.value });
+}
+function bindSlot(slot, values) {
+  const input = readOwnValue(values, slot.plan.name);
+  if (!input.ok) return bindingFailure("HOST_BINDING_MISSING", slot);
+  const decoded = invokeValidator(slot, input.value);
+  if (!decoded.ok) return decoded;
+  const converted = invokeCodec(slot, decoded.value);
+  if (!converted.ok) return converted;
+  const canonical = canonicalValue(converted.value);
+  if (!canonical.ok || !matchesSemanticType(canonical.value, slot.plan.semanticType)) {
+    return bindingFailure("HOST_BINDING_SEMANTIC", slot);
+  }
+  return Object.freeze({ ok: true, value: canonical.value });
+}
+function invokeValidator(slot, value) {
+  if (!slot.validator) return Object.freeze({ ok: true, value });
+  try {
+    const output = slot.validator.decode(value);
+    return isThenableWithoutGet(output) ? bindingFailure("HOST_BINDING_DECODE", slot) : Object.freeze({ ok: true, value: output });
+  } catch {
+    return bindingFailure("HOST_BINDING_DECODE", slot);
+  }
+}
+function invokeCodec(slot, value) {
+  if (!slot.codec) return Object.freeze({ ok: true, value });
+  try {
+    const output = slot.codec.convert(value);
+    return isThenableWithoutGet(output) ? bindingFailure("HOST_BINDING_CONVERSION", slot) : Object.freeze({ ok: true, value: output });
+  } catch {
+    return bindingFailure("HOST_BINDING_CONVERSION", slot);
+  }
+}
+function bindingFailure(code, slot) {
+  return failure2(executionDiagnostic(code, "bind", slot.plan.path, slot.provenance));
+}
+function failure2(diagnostic) {
+  return Object.freeze({ ok: false, diagnostics: Object.freeze([diagnostic]) });
+}
+
+// src/link-expression.ts
+function linkExpression(compiled, environment, snapshot) {
+  try {
+    if (!isAuthenticCompiledExpression(compiled)) return incompatible();
+    if (!compatibleProjection(compiled, environment)) return incompatible();
+    if (!capabilitySnapshotMatches(snapshot, environment)) return invalidSnapshot();
+    if (environment.provider.mode === "async") return asyncUnsupported();
+    const slots = [];
+    for (const dependency of compiled.dependencies) {
+      const binding = environment.bindings.find(({ id }) => id === dependency);
+      if (!binding) return missingBinding();
+      const linked = linkSlot(binding, slots.length, snapshot);
+      if (!linked.ok) return linked.result;
+      slots.push(linked.slot);
+    }
+    return linkedArtifact(compiled, environment, slots);
+  } catch {
+    return incompatible();
+  }
+}
+function linkSlot(binding, index, snapshot) {
+  if (binding.validator?.mode === "async" || binding.codec?.mode === "async") {
+    return Object.freeze({ ok: false, result: asyncUnsupported(binding) });
+  }
+  const validator = resolveCapability(binding.validator, snapshot);
+  const codec = resolveCapability(binding.codec, snapshot);
+  if (validator === null || codec === null || validator && validator.kind !== "validator" || codec && codec.kind !== "codec") {
+    return Object.freeze({ ok: false, result: invalidCapability(binding) });
+  }
+  const plan = createPlan(binding, index);
+  return Object.freeze({
+    ok: true,
+    slot: Object.freeze({ plan, validator, codec, provenance: binding.provenance[0] })
+  });
+}
+function resolveCapability(declaration, snapshot) {
+  if (!declaration) return void 0;
+  if (snapshot.scope !== "instance") return null;
+  const descriptor = Object.getOwnPropertyDescriptor(snapshot.capabilities, declaration.handle);
+  if (!descriptor || !("value" in descriptor)) return null;
+  const live = descriptor.value;
+  if (!sameDeclaration(live, declaration)) return null;
+  if (live.kind === "validator" && typeof live.decode !== "function") return null;
+  if (live.kind === "codec" && typeof live.convert !== "function") return null;
+  return live;
+}
+function sameDeclaration(live, expected) {
+  return live.handle === expected.handle && live.kind === expected.kind && live.mode === expected.mode && live.capabilityId === expected.capabilityId && live.capabilityVersion === expected.capabilityVersion && live.configurationDigest === expected.configurationDigest && JSON.stringify(live.identity) === JSON.stringify(expected.identity);
+}
+function createPlan(binding, index) {
+  return Object.freeze({
+    index,
+    bindingId: binding.id,
+    name: binding.name,
+    path: Object.freeze([...binding.path]),
+    semanticType: binding.semanticType,
+    ...binding.validator ? { validator: binding.validator } : {},
+    ...binding.codec ? { codec: binding.codec } : {}
+  });
+}
+function linkedArtifact(compiled, environment, slots) {
+  const internal = Object.freeze([...slots]);
+  const linkPlan = Object.freeze(slots.map(({ plan }) => plan));
+  const linkFingerprint = reusable(environment) ? createFingerprint(
+    HOST_LINK_FINGERPRINT_VERSION,
+    linkFingerprintInput(compiled, environment, linkPlan)
+  ) : void 0;
+  const evaluate = Object.freeze((values) => evaluateLinked(compiled, internal, values));
+  const prepared = Object.freeze({
+    format: "kalada-host-prepared-expression-v1",
+    compiled,
+    environment,
+    linkPlan,
+    ...linkFingerprint ? { linkFingerprint } : {},
+    evaluate
+  });
+  return Object.freeze({ ok: true, value: prepared });
+}
+function compatibleProjection(compiled, environment) {
+  if (compiled.format !== "kalada-host-compiled-expression-v1") return false;
+  if (environment.format !== "kalada-host-environment-v1") return false;
+  return compiled.compileProjectionFingerprint === createFingerprint(environment.compileProjection.format, environment.compileProjection);
+}
+function reusable(environment) {
+  return environment.cacheability.cacheable;
+}
+function linkFingerprintInput(compiled, environment, linkPlan) {
+  return {
+    compileFingerprint: compiled.compileFingerprint,
+    provider: environment.provider.identity,
+    bindings: environment.bindings.map(({ id, name, path, editorShapeRoot, validator, codec }) => ({
+      id,
+      name,
+      path,
+      editorShapeRoot,
+      validator,
+      codec
+    })),
+    editorGraph: environment.editorGraph,
+    linkPlan
+  };
+}
+function incompatible() {
+  return failure3(executionDiagnostic("HOST_LINK_INCOMPATIBLE_ENVIRONMENT", "link"));
+}
+function missingBinding() {
+  return failure3(executionDiagnostic("HOST_LINK_MISSING_BINDING", "link"));
+}
+function invalidCapability(binding) {
+  return failure3(bindingDiagnostic("HOST_LINK_INVALID_CAPABILITY", binding));
+}
+function invalidSnapshot() {
+  return failure3(executionDiagnostic("HOST_LINK_INVALID_CAPABILITY", "link"));
+}
+function asyncUnsupported(binding) {
+  return failure3(
+    binding ? bindingDiagnostic("HOST_LINK_ASYNC_UNSUPPORTED", binding) : executionDiagnostic("HOST_LINK_ASYNC_UNSUPPORTED", "link")
+  );
+}
+function bindingDiagnostic(code, binding) {
+  return executionDiagnostic(code, "link", binding.path, binding.provenance[0]);
+}
+function failure3(diagnostic) {
+  return Object.freeze({ ok: false, diagnostics: Object.freeze([diagnostic]) });
+}
+
+// src/diagnostics.ts
+var messages = Object.freeze({
+  HOST_ENVIRONMENT_INVALID_PROVIDER: "The manual provider declaration is invalid.",
+  HOST_ENVIRONMENT_INVALID_IDENTITY: "A stable identity declaration is invalid.",
+  HOST_ENVIRONMENT_INVALID_CAPABILITY: "A capability declaration is invalid.",
+  HOST_ENVIRONMENT_DUPLICATE_CAPABILITY: "A capability handle is duplicated.",
+  HOST_ENVIRONMENT_INVALID_BINDING: "A binding declaration is invalid.",
+  HOST_ENVIRONMENT_DUPLICATE_BINDING: "A binding identity or path is duplicated.",
+  HOST_ENVIRONMENT_INVALID_SEMANTIC_TYPE: "A binding semantic projection is invalid.",
+  HOST_ENVIRONMENT_INVALID_METADATA: "Binding metadata is not bounded serializable data.",
+  HOST_ENVIRONMENT_INVALID_PROVENANCE: "Binding provenance is invalid.",
+  HOST_ENVIRONMENT_UNKNOWN_CAPABILITY: "A binding references an unavailable capability handle."
+});
+function environmentDiagnostic(code, bindingPath, provenance) {
+  const diagnostic = {
+    code,
+    phase: "environment",
+    message: messages[code],
+    ...bindingPath ? { bindingPath: Object.freeze([...bindingPath]) } : {},
+    ...provenance ? { provenance: sanitizeProvenance(provenance) } : {}
+  };
+  return Object.freeze(diagnostic);
+}
+function sanitizeProvenance(input) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const key of ["providerId", "providerVersion", "source", "extractor", "override"]) {
+    const value = input[key];
+    if (value !== void 0) output[key] = value;
+  }
+  return Object.freeze(output);
+}
+
+// src/binding-normalization.ts
+function normalizeBindings(input, capabilities, providerProvenance2) {
+  const state = {
+    bindings: [],
+    graphInputs: [],
+    diagnostics: [],
+    providerProvenance: providerProvenance2
+  };
+  const items = readArray(input, 1e4);
+  if (!items) {
+    state.diagnostics.push(environmentDiagnostic("HOST_ENVIRONMENT_INVALID_PROVIDER"));
+    return state;
+  }
+  const identities = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  for (const item of items) addBinding(item, capabilities, identities, names, paths, state);
+  return state;
+}
+function addBinding(input, capabilities, identities, names, paths, state) {
+  const inspected = readOwnDataRecord(input, 16);
+  if (!inspected.ok) {
+    bindingError(state, "HOST_ENVIRONMENT_INVALID_BINDING");
+    return;
+  }
+  const record = inspected.value;
+  const path = readStringArray(record.path, 64);
+  if (!validName(record.id) || !validName(record.name) || !path) {
+    bindingError(state, "HOST_ENVIRONMENT_INVALID_BINDING");
+    return;
+  }
+  if (identities.has(record.id) || names.has(record.name) || paths.has(JSON.stringify(path))) {
+    bindingError(state, "HOST_ENVIRONMENT_DUPLICATE_BINDING", path);
+    return;
+  }
+  identities.add(record.id);
+  names.add(record.name);
+  paths.add(JSON.stringify(path));
+  addValidBinding(record, path, capabilities, state);
+}
+function addValidBinding(record, path, capabilities, state) {
+  const semantic = cloneSemanticType(record.semanticType);
+  if (!semantic.ok) {
+    bindingError(state, "HOST_ENVIRONMENT_INVALID_SEMANTIC_TYPE", path);
+    return;
+  }
+  const metadata = normalizeMetadata(record.metadata, path, state);
+  if (!metadata.ok) return;
+  const provenance = normalizeProvenance(record.provenance, path, state);
+  if (!provenance) return;
+  const refs = resolveCapabilityRefs(record, capabilities, path, state);
+  if (!refs) return;
+  const editor = normalizeEditorDocument(record.editorShape, record.id, path, state);
+  if (editor === null) return;
+  state.bindings.push(makeBinding(record, path, semantic.value, metadata.value, provenance, refs));
+  if (editor) state.graphInputs.push(editor);
+}
+function makeBinding(record, path, semanticType, metadata, provenance, refs) {
+  return Object.freeze({
+    id: record.id,
+    name: record.name,
+    path,
+    semanticType,
+    ...refs,
+    ...metadata === void 0 ? {} : { metadata },
+    provenance
+  });
+}
+function normalizeMetadata(input, path, state) {
+  if (input === void 0) return { ok: true, value: void 0 };
+  const cloned = cloneSerializableData(input);
+  if (cloned.ok) return { ok: true, value: cloned.value };
+  bindingError(state, "HOST_ENVIRONMENT_INVALID_METADATA", path);
+  return { ok: false };
+}
+function normalizeProvenance(input, path, state) {
+  const base = state.providerProvenance;
+  if (input === void 0) return Object.freeze([base]);
+  const items = readArray(input, 256);
+  if (!items) return provenanceError(state, path);
+  const entries = [base];
+  for (const item of items) {
+    const entry = readProvenance(item);
+    if (!entry) return provenanceError(state, path);
+    entries.push(entry);
+  }
+  return Object.freeze(entries);
+}
+function readProvenance(input) {
+  const inspected = readOwnDataRecord(input, 8);
+  if (!inspected.ok || !validName(inspected.value.providerId)) return null;
+  const record = inspected.value;
+  const providerId = record.providerId;
+  for (const key of ["providerVersion", "source", "extractor", "override"]) {
+    if (record[key] !== void 0 && !validName(record[key])) return null;
+  }
+  return Object.freeze({
+    providerId,
+    ...record.providerVersion ? { providerVersion: record.providerVersion } : {},
+    ...record.source ? { source: record.source } : {},
+    ...record.extractor ? { extractor: record.extractor } : {},
+    ...record.override ? { override: record.override } : {}
+  });
+}
+function resolveCapabilityRefs(record, state, path, bindings) {
+  const validator = resolveCapability2(record.validatorHandle, "validator", state, path, bindings);
+  const codec = resolveCapability2(record.codecHandle, "codec", state, path, bindings);
+  return validator === null || codec === null ? null : { ...validator ? { validator } : {}, ...codec ? { codec } : {} };
+}
+function resolveCapability2(handle, kind, state, path, bindings) {
+  if (handle === void 0) return void 0;
+  if (!validName(handle)) return unknownCapability(bindings, path);
+  const found = state.declarations.find((item) => item.handle === handle && item.kind === kind);
+  return found ?? unknownCapability(bindings, path);
+}
+function normalizeEditorDocument(input, bindingId, path, state) {
+  if (input === void 0) return void 0;
+  const inspected = readOwnDataRecord(input, 4);
+  if (!inspected.ok || inspected.value.root === void 0) {
+    bindingError(state, "HOST_ENVIRONMENT_INVALID_BINDING", path);
+    return null;
+  }
+  const definitions = normalizeDefinitions(inspected.value.definitions);
+  const evidence2 = normalizeEditorEvidence(inspected.value.evidence);
+  if (definitions === null || evidence2 === null) {
+    bindingError(state, "HOST_ENVIRONMENT_INVALID_BINDING", path);
+    return null;
+  }
+  const document = {
+    root: inspected.value.root,
+    definitions,
+    evidence: evidence2
+  };
+  if (!validateEditorDocument(document)) {
+    bindingError(state, "HOST_ENVIRONMENT_INVALID_BINDING", path);
+    return null;
+  }
+  return { bindingId, path, document };
+}
+function normalizeEditorEvidence(input) {
+  if (input === void 0) return Object.freeze([]);
+  const items = readArray(input, 8192);
+  if (!items) return null;
+  const allowed = [
+    "invalid-shape",
+    "unsupported-shape",
+    "depth-limit",
+    "node-limit",
+    "edge-limit",
+    "unresolved-reference"
+  ];
+  return items.every((item) => typeof item === "string" && allowed.includes(item)) ? Object.freeze(items) : null;
+}
+function normalizeDefinitions(input) {
+  if (input === void 0) return Object.freeze([]);
+  const items = readArray(input, 2048);
+  if (!items) return null;
+  const output = [];
+  for (const item of items) {
+    const inspected = readOwnDataRecord(item, 4);
+    if (!inspected.ok || !validName(inspected.value.name)) return null;
+    output.push(
+      Object.freeze({ name: inspected.value.name, shape: inspected.value.shape })
+    );
+  }
+  return Object.freeze(output);
+}
+function bindingError(state, code, path) {
+  state.diagnostics.push(environmentDiagnostic(code, path, state.providerProvenance));
+}
+function provenanceError(state, path) {
+  bindingError(state, "HOST_ENVIRONMENT_INVALID_PROVENANCE", path);
+  return null;
+}
+function unknownCapability(state, path) {
+  bindingError(state, "HOST_ENVIRONMENT_UNKNOWN_CAPABILITY", path);
+  return null;
+}
+
+// src/identity.ts
+function normalizeIdentity(input) {
+  const inspected = readOwnDataRecord(input, 8);
+  if (!inspected.ok) return Object.freeze({ ok: false });
+  const record = inspected.value;
+  if (!validOptionalBoolean(record.cacheable)) return Object.freeze({ ok: false });
+  if (!validOptionalString(record.id) || !validOptionalString(record.version)) {
+    return Object.freeze({ ok: false });
+  }
+  if (!validOptionalString(record.configurationDigest)) return Object.freeze({ ok: false });
+  if (record.cacheable === false) return nonCacheable("explicitly-disabled");
+  if (!record.id || !record.version || !record.configurationDigest) {
+    return nonCacheable("missing-identity");
+  }
+  return Object.freeze({
+    ok: true,
+    value: Object.freeze({
+      cacheable: true,
+      id: record.id,
+      version: record.version,
+      configurationDigest: record.configurationDigest
+    })
+  });
+}
+function subordinateIdentity(identity, provider) {
+  if (!provider.cacheable && identity.cacheable) {
+    return Object.freeze({ cacheable: false, reason: "provider-not-cacheable" });
+  }
+  return identity;
+}
+function nonCacheable(reason) {
+  return Object.freeze({
+    ok: true,
+    value: Object.freeze({ cacheable: false, reason })
+  });
+}
+function validOptionalString(input) {
+  return input === void 0 || typeof input === "string" && input.length > 0 && input.length <= 256;
+}
+function validOptionalBoolean(input) {
+  return input === void 0 || typeof input === "boolean";
+}
+
+// src/capability-normalization.ts
+function normalizeCapabilities(input, provider) {
+  const state = { declarations: [], live: /* @__PURE__ */ Object.create(null), diagnostics: [] };
+  if (input === void 0) return state;
+  const items = readArray(input, 4096);
+  if (!items) {
+    state.diagnostics.push(environmentDiagnostic("HOST_ENVIRONMENT_INVALID_CAPABILITY"));
+    return state;
+  }
+  for (const item of items) addCapability(item, provider, state);
+  return state;
+}
+function addCapability(input, provider, state) {
+  const inspected = readOwnDataRecord(input, 12);
+  if (!inspected.ok || !validCapabilityFields(inspected.value)) {
+    state.diagnostics.push(environmentDiagnostic("HOST_ENVIRONMENT_INVALID_CAPABILITY"));
+    return;
+  }
+  const record = inspected.value;
+  if (state.live[record.handle]) {
+    state.diagnostics.push(environmentDiagnostic("HOST_ENVIRONMENT_DUPLICATE_CAPABILITY"));
+    return;
+  }
+  const identity = normalizeCapabilityIdentity(record);
+  if (!identity) {
+    state.diagnostics.push(environmentDiagnostic("HOST_ENVIRONMENT_INVALID_IDENTITY"));
+    return;
+  }
+  addLiveCapability(record, subordinateIdentity(identity, provider), state);
+}
+function normalizeCapabilityIdentity(record) {
+  const result = normalizeIdentity({
+    id: record.capabilityId,
+    version: record.capabilityVersion,
+    configurationDigest: record.configurationDigest,
+    cacheable: record.cacheable
+  });
+  return result.ok ? result.value : null;
+}
+function addLiveCapability(record, identity, state) {
+  const declaration = createDeclaration(record, identity);
+  const live = declaration.kind === "validator" ? Object.freeze({
+    ...declaration,
+    kind: "validator",
+    decode: record.decode
+  }) : Object.freeze({ ...declaration, kind: "codec", convert: record.convert });
+  state.declarations.push(declaration);
+  state.live[declaration.handle] = live;
+}
+function createDeclaration(record, identity) {
+  return Object.freeze({
+    handle: record.handle,
+    kind: record.kind,
+    mode: record.mode,
+    ...record.capabilityId ? { capabilityId: record.capabilityId } : {},
+    ...record.capabilityVersion ? { capabilityVersion: record.capabilityVersion } : {},
+    ...record.configurationDigest ? { configurationDigest: record.configurationDigest } : {},
+    identity
+  });
+}
+function validCapabilityFields(record) {
+  if (!validName(record.handle) || record.mode !== "sync" && record.mode !== "async")
+    return false;
+  if (record.kind === "validator") return typeof record.decode === "function";
+  if (record.kind === "codec") return typeof record.convert === "function";
+  return false;
+}
+
+// src/manual-provider.ts
+var manualProviderBrand = /* @__PURE__ */ Symbol("@kalada/host/manual-provider");
+function createManualProvider(input) {
+  const outcome = safelyNormalize(input);
+  return Object.freeze({
+    kind: "manual",
+    [manualProviderBrand]: true,
+    describe: () => outcome
+  });
+}
+function describeEnvironment(provider) {
+  try {
+    const candidate = provider;
+    if (candidate?.kind !== "manual" || candidate[manualProviderBrand] !== true) {
+      return providerFailure();
+    }
+    return candidate.describe();
+  } catch {
+    return providerFailure();
+  }
+}
+function normalizeManualEnvironment(input) {
+  return safelyNormalize(input);
+}
+function safelyNormalize(input) {
+  try {
+    return normalize(input);
+  } catch {
+    return providerFailure();
+  }
+}
+function normalize(input) {
+  const inspected = readOwnDataRecord(input, 16);
+  if (!inspected.ok) return providerFailure();
+  const record = inspected.value;
+  if (record.mode !== "sync" && record.mode !== "async") return providerFailure();
+  const providerIdentity = normalizeProviderIdentity(record);
+  if (!providerIdentity) return failure4("HOST_ENVIRONMENT_INVALID_IDENTITY");
+  const capabilities = normalizeCapabilities(record.capabilities, providerIdentity);
+  const bindings = normalizeBindings(record.bindings, capabilities, providerProvenance(record));
+  const diagnostics = [...capabilities.diagnostics, ...bindings.diagnostics];
+  if (diagnostics.length > 0) return failedDiagnostics(diagnostics);
+  return success3(record, providerIdentity, capabilities, bindings);
+}
+function normalizeProviderIdentity(record) {
+  const result = normalizeIdentity({
+    id: record.providerId,
+    version: record.providerVersion,
+    configurationDigest: record.configurationDigest,
+    cacheable: record.cacheable
+  });
+  return result.ok ? result.value : null;
+}
+function providerProvenance(record) {
+  return Object.freeze({
+    providerId: typeof record.providerId === "string" ? record.providerId : "manual",
+    ...typeof record.providerVersion === "string" ? { providerVersion: record.providerVersion } : {}
+  });
+}
+function success3(providerRecord, providerIdentity, capabilities, bindings) {
+  const graph = createEditorGraph(bindings.graphInputs);
+  const roots = new Map(graph.roots.map((root) => [root.bindingId, root.nodeId]));
+  const normalized = bindings.bindings.map(
+    (binding) => Object.freeze({
+      ...binding,
+      ...roots.has(binding.id) ? { editorShapeRoot: roots.get(binding.id) } : {}
+    })
+  );
+  const environment = Object.freeze({
+    format: "kalada-host-environment-v1",
+    provider: providerDeclaration(providerRecord, providerIdentity),
+    cacheability: environmentCacheability(providerIdentity, capabilities.declarations),
+    compileProjection: Object.freeze({
+      format: "kalada-host-compile-projection-v1",
+      bindings: Object.freeze(
+        normalized.map(({ id, name, semanticType }) => Object.freeze({ id, name, semanticType }))
+      )
+    }),
+    bindings: Object.freeze(normalized),
+    capabilities: Object.freeze(capabilities.declarations),
+    editorGraph: graph
+  });
+  const snapshot = createCapabilitySnapshot(environment, Object.freeze(capabilities.live));
+  return Object.freeze({
+    ok: true,
+    environment,
+    capabilitySnapshot: snapshot
+  });
+}
+function providerDeclaration(record, identity) {
+  return Object.freeze({
+    mode: record.mode,
+    ...record.providerId ? { providerId: record.providerId } : {},
+    ...record.providerVersion ? { providerVersion: record.providerVersion } : {},
+    ...record.configurationDigest ? { configurationDigest: record.configurationDigest } : {},
+    identity
+  });
+}
+function environmentCacheability(provider, capabilities) {
+  if (!provider.cacheable) return provider;
+  if (capabilities.some((item) => !item.identity.cacheable)) {
+    return Object.freeze({ cacheable: false, reason: "capability-not-cacheable" });
+  }
+  return provider;
+}
+function failedDiagnostics(diagnostics) {
+  return Object.freeze({ ok: false, diagnostics: Object.freeze(diagnostics) });
+}
+function failure4(code) {
+  return failedDiagnostics([environmentDiagnostic(code)]);
+}
+function providerFailure() {
+  return failure4("HOST_ENVIRONMENT_INVALID_PROVIDER");
+}
+
+// src/execution.ts
+function prepareExpression(source, provider, options) {
+  const described = describeEnvironment(provider);
+  if (!described.ok) return described;
+  const normalized = normalizeOptions(options);
+  if (!normalized) {
+    return Object.freeze({
+      ok: false,
+      diagnostics: Object.freeze([executionDiagnostic("HOST_COMPILE_INVALID_OPTIONS", "compile")])
+    });
+  }
+  const parsed = parseExpression(source, normalized.parse);
+  if (!parsed.ok) return parsed;
+  const compiled = compileExpression(
+    parsed.value,
+    described.environment.compileProjection,
+    normalized.compile
+  );
+  if (!compiled.ok) return compiled;
+  return linkExpression(compiled.value, described.environment, described.capabilitySnapshot);
+}
+function normalizeOptions(options) {
+  if (options === void 0) return Object.freeze({});
+  const inspected = readOwnDataRecord(options, 2);
+  if (!inspected.ok) return null;
+  return Object.freeze({
+    ...inspected.value.parse === void 0 ? {} : { parse: inspected.value.parse },
+    ...inspected.value.compile === void 0 ? {} : { compile: inspected.value.compile }
+  });
+}
+function evaluateExpression(source, provider, values, options) {
+  const prepared = prepareExpression(source, provider, options);
+  return prepared.ok ? prepared.value.evaluate(values) : prepared;
+}
+
+export { DEFAULT_EDITOR_GRAPH_LIMITS, DEFAULT_SERIALIZABLE_LIMITS, HOST_COMPILE_FINGERPRINT_VERSION, HOST_LINK_FINGERPRINT_VERSION, calculateEditorGraphAdmission, cloneSerializableData, compileExpression, createEditorGraph, createEditorGraphEdgeMeter, createManualProvider, describeEnvironment, evaluateExpression, linkExpression, normalizeManualEnvironment, parseExpression, prepareExpression, readSemanticType, traverseEditorGraph };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map