@kalada/adapter-scheman 0.1.0

package/dist/index.js

@@ -0,0 +1,1308 @@
+import { describeEnvironment, createManualProvider, calculateEditorGraphAdmission, readSemanticType } from '@kalada/host';
+
+// src/adapter.ts
+
+// src/analysis-limits.ts
+var DEFAULT_SCHEMAN_ANALYSIS_LIMITS = Object.freeze({
+  maxNodes: 2048,
+  maxEdges: 8192,
+  maxTypeDepth: 32
+});
+function resolveAnalysisLimits(requested) {
+  return Object.freeze({
+    maxNodes: bounded(requested?.maxNodes, DEFAULT_SCHEMAN_ANALYSIS_LIMITS.maxNodes),
+    maxEdges: bounded(requested?.maxEdges, DEFAULT_SCHEMAN_ANALYSIS_LIMITS.maxEdges),
+    maxTypeDepth: bounded(requested?.maxTypeDepth, DEFAULT_SCHEMAN_ANALYSIS_LIMITS.maxTypeDepth)
+  });
+}
+function bounded(value, maximum) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) return maximum;
+  return Math.min(value, maximum);
+}
+
+// src/capability-wrappers.ts
+function decodeStandardSchema(validator, value) {
+  const standard = validator["~standard"];
+  const outcome = standard.validate(value);
+  if (isThenableWithoutGet(outcome)) return outcome;
+  const issues = readDataSlot(outcome, "issues");
+  if (issues.found && issues.value !== void 0)
+    throw new Error("Standard Schema validation failed");
+  const decoded = readDataSlot(outcome, "value");
+  if (!decoded.found) throw new Error("Standard Schema returned an invalid outcome");
+  return decoded.value;
+}
+function convertWithFinalPolicy(codec, policy, value) {
+  const output = codec.convert(value);
+  if (isThenableWithoutGet(output)) return output;
+  if (policy === "safe-integer-and-kalada-type" && !isSafeInteger(output)) {
+    throw new Error("Codec output violates final conversion policy");
+  }
+  return output;
+}
+function isSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function readDataSlot(input, key) {
+  if ((typeof input !== "object" || input === null) && typeof input !== "function") {
+    return Object.freeze({ found: false });
+  }
+  let current = input;
+  const seen = /* @__PURE__ */ new Set();
+  try {
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const descriptor = Object.getOwnPropertyDescriptor(current, key);
+      if (descriptor) {
+        return "value" in descriptor ? Object.freeze({ found: true, value: descriptor.value }) : Object.freeze({ found: false });
+      }
+      current = Object.getPrototypeOf(current);
+    }
+  } catch {
+    return Object.freeze({ found: false });
+  }
+  return Object.freeze({ found: false });
+}
+function isThenableWithoutGet(input) {
+  if ((typeof input !== "object" || input === null) && typeof input !== "function") return false;
+  let current = input;
+  const seen = /* @__PURE__ */ new Set();
+  try {
+    while (current && !seen.has(current)) {
+      seen.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;
+  }
+}
+
+// src/local-reference.ts
+function eligibleLocalReference(nodeId, node, document) {
+  if (!node.target || node.unresolved || !node.reference.startsWith("#")) return false;
+  if (!document.nodes[node.target.nodeId]) return false;
+  return !document.diagnostics.some(
+    (diagnostic) => blockedReferenceCode(diagnostic.code) && (diagnostic.nodeId === nodeId || diagnostic.nodeId === node.target?.nodeId)
+  );
+}
+function blockedReferenceCode(code) {
+  return code === "JSON_RESOURCE_REBASE_UNSUPPORTED" || code === "JSON_UNRESOLVED_REFERENCE" || code === "JSON_INVALID_REFERENCE";
+}
+
+// src/editor-edge-budget.ts
+var EditorAdmissionBudget = class {
+  definitions;
+  maximum;
+  rootResolution;
+  reserve;
+  admittedSourceEdges = 0;
+  children = 0;
+  evidenceUsed = false;
+  resolutions = 0;
+  truncated = false;
+  closed = false;
+  constructor(maximum, definitions, rootBounded) {
+    this.maximum = maximum;
+    this.definitions = definitions;
+    this.rootResolution = rootBounded ? 0 : 1;
+    this.reserve = rootBounded ? 0 : 1;
+  }
+  claimChild(reference3, selected) {
+    const local = selected.has(reference3.nodeId);
+    if (!this.canAdmit(1, local ? 1 : 0)) return false;
+    this.children += 1;
+    this.resolutions += local ? 1 : 0;
+    this.admittedSourceEdges += 1;
+    return true;
+  }
+  claimChildren(references, selected) {
+    const resolutions = references.filter((item) => selected.has(item.nodeId)).length;
+    if (!this.canAdmit(references.length, resolutions)) return false;
+    this.children += references.length;
+    this.resolutions += resolutions;
+    this.admittedSourceEdges += references.length;
+    return true;
+  }
+  claimDefinitionReference() {
+    if (!this.canAdmit(0, 1)) return false;
+    this.resolutions += 1;
+    this.admittedSourceEdges += 1;
+    return true;
+  }
+  evidenceEdge(_sourceId) {
+    this.truncated = true;
+    this.closed = true;
+    if (this.evidenceUsed || this.reserve === 0) return null;
+    this.evidenceUsed = true;
+    return null;
+  }
+  limitNode(sourceId) {
+    this.truncated = true;
+    this.closed = true;
+    return edgeLimitShape(sourceId);
+  }
+  admission() {
+    return calculateEditorGraphAdmission({
+      maxEdges: this.maximum,
+      roots: 1,
+      definitions: this.definitions,
+      children: this.children,
+      resolutions: this.rootResolution + this.resolutions,
+      evidenceReserve: this.reserve
+    });
+  }
+  get exhausted() {
+    return this.closed;
+  }
+  canAdmit(children, resolutions) {
+    if (this.closed) return false;
+    const admission = calculateEditorGraphAdmission({
+      maxEdges: this.maximum,
+      roots: 1,
+      definitions: this.definitions,
+      children: this.children + children,
+      resolutions: this.rootResolution + this.resolutions + resolutions,
+      evidenceReserve: this.reserve
+    });
+    if (admission.backboneAdmitted && !admission.truncated) return true;
+    this.truncated = true;
+    this.closed = true;
+    return false;
+  }
+};
+var RequiredNamesBudget = class {
+  maximumPerObject;
+  total;
+  retained = 0;
+  constructor(document, selected, maximum) {
+    this.maximumPerObject = maximum;
+    this.total = selectedRequiredNames(document, selected);
+  }
+  retain(values) {
+    const retained = values.slice(0, this.maximumPerObject);
+    this.retained += retained.length;
+    return retained;
+  }
+  requiresEvidence(node) {
+    return node.kind === "object" && node.required.length > this.maximumPerObject;
+  }
+  summary() {
+    return Object.freeze({
+      retained: this.retained,
+      total: this.total,
+      truncated: this.retained < this.total
+    });
+  }
+};
+function selectEditorNodes(document, maximumNodes, maximumEdges) {
+  if (maximumEdges < 4) {
+    return Object.freeze({ ids: /* @__PURE__ */ new Set(), rootBounded: true, truncated: true });
+  }
+  const maximum = Math.min(maximumNodes, maximumEdges - 3);
+  const ids = /* @__PURE__ */ new Set();
+  let truncated = false;
+  const add = (nodeId) => {
+    if (ids.has(nodeId) || !Object.hasOwn(document.nodes, nodeId)) return;
+    if (ids.size < maximum) ids.add(nodeId);
+    else truncated = true;
+  };
+  add(document.root.input.nodeId);
+  add(document.root.output.nodeId);
+  for (const definition of document.definitions) add(definition.node.nodeId);
+  for (const nodeId in document.nodes) {
+    if (!Object.hasOwn(document.nodes, nodeId)) continue;
+    add(nodeId);
+  }
+  return Object.freeze({ ids, rootBounded: false, truncated });
+}
+function countSourceEditorEdges(document, selected) {
+  let total = 0;
+  for (const nodeId of selected) {
+    const node = document.nodes[nodeId];
+    if (!node) continue;
+    total += nodeSourceEdges(nodeId, node, document);
+  }
+  return total;
+}
+function selectedRequiredNames(document, selected) {
+  let total = 0;
+  for (const nodeId of selected) {
+    const node = document.nodes[nodeId];
+    if (node?.kind === "object") total += node.required.length;
+  }
+  return total;
+}
+function nodeSourceEdges(nodeId, node, document) {
+  let total = applicatorEdgeCount(node);
+  if (node.kind === "object") total += node.properties.length + (node.additionalProperties ? 1 : 0);
+  if (node.kind === "array") total += 1;
+  if (node.kind === "tuple") total += node.items.length + (node.rest ? 1 : 0);
+  if (node.kind === "record") total += 2;
+  if (node.kind === "union") total += node.alternatives.length;
+  if (node.kind === "intersection") total += node.operands.length;
+  if (node.kind === "wrapper") total += 1;
+  if (node.kind === "ref" && eligibleLocalReference(nodeId, node, document)) total += 1;
+  return total;
+}
+function applicatorEdgeCount(node) {
+  const applicators = node.applicators;
+  if (!applicators) return 0;
+  let total = 0;
+  for (const name of ["if", "then", "else", "not", "contains", "propertyNames"]) {
+    if (applicators[name]) total += 1;
+  }
+  return total + Object.keys(applicators.patternProperties ?? {}).length + Object.keys(applicators.dependentSchemas ?? {}).length;
+}
+function edgeLimitShape(sourceId) {
+  return {
+    kind: "unknown",
+    reason: `bounded-edge:${sourceId}`,
+    evidenceCode: "edge-limit",
+    sourceId
+  };
+}
+
+// src/editor-relations.ts
+function nodeEvidence(nodeId, node, selected, budget, requiredNames) {
+  const relations = applicatorRelations(nodeId, node.applicators, selected, budget);
+  const required = requiredNames.requiresEvidence(node) ? requiredNamesLimitRelation(nodeId, budget) : [];
+  return {
+    sourceId: nodeId,
+    ...node.metadata === void 0 ? {} : { annotations: node.metadata },
+    ...node.constraints === void 0 ? {} : { constraints: node.constraints },
+    relations: Object.freeze([...relations, ...required])
+  };
+}
+function applicatorRelations(nodeId, applicators, selected, budget) {
+  if (!applicators) return Object.freeze([]);
+  const output = [];
+  for (const name of ["if", "then", "else", "not", "contains", "propertyNames"]) {
+    const target = applicators[name];
+    if (!target) continue;
+    const shape = edgeReference(target, `${nodeId}.${name}`, selected, budget);
+    if (!shape) break;
+    output.push({ name, shape });
+    if (isEdgeLimit(shape)) return Object.freeze(output);
+  }
+  if (addKeyedRelations(
+    nodeId,
+    "patternProperties",
+    applicators.patternProperties,
+    output,
+    selected,
+    budget
+  )) {
+    return Object.freeze(output);
+  }
+  addKeyedRelations(
+    nodeId,
+    "dependentSchemas",
+    applicators.dependentSchemas,
+    output,
+    selected,
+    budget
+  );
+  return Object.freeze(output);
+}
+function addKeyedRelations(nodeId, name, input, output, selected, budget) {
+  for (const [key, target] of Object.entries(input ?? {})) {
+    const shape = edgeReference(target, `${nodeId}.${name}.${key}`, selected, budget);
+    if (!shape) return true;
+    output.push({ name, key, shape });
+    if (isEdgeLimit(shape)) return true;
+  }
+  return false;
+}
+function requiredNamesLimitRelation(nodeId, budget) {
+  const shape = budget.evidenceEdge(`${nodeId}.requiredNames`);
+  return shape ? [{ name: "requiredNames", shape }] : [];
+}
+function edgeReference(value, source, selected, budget) {
+  if (budget.claimChild(value, selected)) return reference(value.nodeId, selected);
+  return budget.evidenceEdge(source);
+}
+function reference(definition, selected) {
+  if (selected.has(definition)) return { kind: "reference", definition };
+  return {
+    kind: "unknown",
+    reason: `bounded:${definition}`,
+    evidenceCode: "node-limit",
+    sourceId: definition
+  };
+}
+function isEdgeLimit(shape) {
+  return shape.kind === "unknown" && shape.evidenceCode === "edge-limit";
+}
+
+// src/editor-document.ts
+function schemanEditorDocument(source, limits) {
+  const selection = selectEditorNodes(source, limits.maxNodes, limits.maxEdges);
+  const requiredNames = new RequiredNamesBudget(source, selection.ids, limits.maxEdges);
+  const sourceEdgeTotal = countSourceEditorEdges(source, selection.ids);
+  const budget = new EditorAdmissionBudget(
+    limits.maxEdges,
+    selection.ids.size,
+    selection.rootBounded
+  );
+  const converted = convertDefinitions(source, selection.ids, budget, requiredNames);
+  const definitions = prioritizedDefinitions(source, selection.ids, converted);
+  const requiredNamesSummary = requiredNames.summary();
+  const sourceEdges = Object.freeze({
+    retained: budget.admittedSourceEdges,
+    total: sourceEdgeTotal,
+    truncated: budget.admittedSourceEdges < sourceEdgeTotal
+  });
+  const evidence = [];
+  if (sourceEdges.truncated || requiredNamesSummary.truncated) evidence.push("edge-limit");
+  if (selection.truncated) evidence.push("node-limit");
+  return Object.freeze({
+    admission: budget.admission(),
+    document: Object.freeze({
+      root: selection.rootBounded ? budget.limitNode(source.root.input.nodeId) : reference2(source.root.input.nodeId, selection.ids),
+      definitions: Object.freeze(definitions),
+      evidence: Object.freeze(evidence)
+    }),
+    retainedNodes: definitions.length,
+    retainedEdges: budget.admittedSourceEdges,
+    sourceEdges,
+    nodeTruncated: selection.truncated,
+    edgeTruncated: sourceEdges.truncated,
+    requiredNames: requiredNamesSummary,
+    truncated: selection.truncated || sourceEdges.truncated || requiredNamesSummary.truncated
+  });
+}
+function convertDefinitions(source, selected, budget, requiredNames) {
+  const converted = /* @__PURE__ */ new Map();
+  for (const nodeId of selected) {
+    const node = source.nodes[nodeId];
+    if (node)
+      converted.set(nodeId, convertNode(nodeId, node, source, selected, budget, requiredNames));
+  }
+  return converted;
+}
+function prioritizedDefinitions(source, selected, converted) {
+  const ids = [source.root.input.nodeId, ...Object.keys(source.nodes)];
+  const emitted = /* @__PURE__ */ new Set();
+  const definitions = [];
+  for (const nodeId of ids) {
+    if (emitted.has(nodeId) || !selected.has(nodeId)) continue;
+    const shape = converted.get(nodeId);
+    if (!shape) continue;
+    emitted.add(nodeId);
+    definitions.push(Object.freeze({ name: nodeId, shape }));
+  }
+  return definitions;
+}
+function convertNode(nodeId, node, document, selected, budget, requiredNames) {
+  if (budget.exhausted) return budget.limitNode(nodeId);
+  const shape = convertStructure(nodeId, node, document, selected, budget, requiredNames);
+  const evidence = nodeEvidence(nodeId, node, selected, budget, requiredNames);
+  return { ...shape, ...evidence };
+}
+function convertStructure(nodeId, node, document, selected, budget, requiredNames) {
+  const simple = simpleShape(node);
+  if (simple) return simple;
+  if (node.kind === "object") return objectShape(nodeId, node, selected, budget, requiredNames);
+  if (node.kind === "array") return singleChildShape("array", nodeId, node.items, selected, budget);
+  if (node.kind === "tuple") return tupleShape(nodeId, node, selected, budget);
+  if (node.kind === "record") return recordShape(nodeId, node, selected, budget);
+  if (node.kind === "union") return unionShape(nodeId, node, selected, budget);
+  if (node.kind === "intersection") {
+    return {
+      kind: "intersection",
+      operands: boundedReferences(node.operands, `${nodeId}.operand`, selected, budget)
+    };
+  }
+  if (node.kind === "ref") return referenceShape(nodeId, node, document, selected, budget);
+  if (node.kind === "wrapper") {
+    const inner = edgeReference2(node.inner, `${nodeId}.inner`, selected, budget);
+    return inner ? {
+      kind: "wrapper",
+      wrapper: node.wrapper,
+      inner,
+      ...node.value === void 0 ? {} : { value: node.value }
+    } : budget.limitNode(nodeId);
+  }
+  return { kind: "unknown", reason: `unsupported:${nodeId}` };
+}
+function simpleShape(node) {
+  if (node.kind === "unknown") return { kind: "unknown", reason: node.reason };
+  if (node.kind === "opaque") return { kind: "opaque", reason: node.reason };
+  if (node.kind === "unconstrained") return { kind: "unconstrained", domain: node.domain };
+  if (node.kind === "never") return { kind: "never" };
+  if (node.kind === "primitive") return { kind: "scalar", name: node.type };
+  if (node.kind === "literal") return { kind: "literal", value: node.value };
+  if (node.kind === "enum") return { kind: "enum", values: node.values };
+  return void 0;
+}
+function objectShape(nodeId, node, selected, budget, requiredNames) {
+  const properties = [];
+  let limited = false;
+  for (const property of node.properties) {
+    const shape = edgeReference2(
+      property.node,
+      `${nodeId}.property.${property.name}`,
+      selected,
+      budget
+    );
+    if (!shape) break;
+    properties.push({
+      name: property.name,
+      required: property.presence === "required",
+      presence: property.presence,
+      shape
+    });
+    if (isEdgeLimit2(shape)) {
+      limited = true;
+      break;
+    }
+  }
+  const additional = limited ? null : optionalEdgeReference(node.additionalProperties, `${nodeId}.additional`, selected, budget);
+  return {
+    kind: "object",
+    properties,
+    requiredNames: requiredNames.retain(node.required),
+    unknownKeys: node.unknownKeys,
+    ...additional ? { additionalProperties: additional } : {}
+  };
+}
+function tupleShape(nodeId, node, selected, budget) {
+  const items = boundedReferences(node.items, `${nodeId}.item`, selected, budget);
+  const rest = isEdgeLimit2(items.at(-1)) ? null : optionalEdgeReference(node.rest, `${nodeId}.rest`, selected, budget);
+  return { kind: "tuple", items, ...rest ? { rest } : {} };
+}
+function recordShape(nodeId, node, selected, budget) {
+  if (!budget.claimChildren([node.key, node.value], selected)) return budget.limitNode(nodeId);
+  return {
+    kind: "record",
+    key: reference2(node.key.nodeId, selected),
+    value: reference2(node.value.nodeId, selected),
+    exhaustive: node.exhaustive
+  };
+}
+function unionShape(nodeId, node, selected, budget) {
+  return {
+    kind: "union",
+    variants: boundedReferences(node.alternatives, `${nodeId}.variant`, selected, budget),
+    semantics: node.semantics,
+    ...node.discriminator === void 0 ? {} : { discriminator: node.discriminator }
+  };
+}
+function singleChildShape(kind, nodeId, value, selected, budget) {
+  const element = edgeReference2(value, `${nodeId}.items`, selected, budget);
+  return element ? { kind, element } : budget.limitNode(nodeId);
+}
+function referenceShape(nodeId, node, document, selected, budget) {
+  if (!eligibleLocalReference(nodeId, node, document)) {
+    return {
+      kind: "reference",
+      definition: `unsupported:${nodeId}`,
+      reference: node.reference,
+      unresolved: node.unresolved ?? "non-local-reference"
+    };
+  }
+  const target = node.target?.nodeId;
+  if (!selected.has(target)) {
+    return {
+      kind: "unknown",
+      reason: `bounded-reference:${node.reference}`,
+      evidenceCode: "node-limit"
+    };
+  }
+  if (!budget.claimDefinitionReference()) return budget.limitNode(nodeId);
+  return { kind: "reference", definition: target, reference: node.reference };
+}
+function boundedReferences(values, source, selected, budget) {
+  const output = [];
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (!value) continue;
+    const shape = edgeReference2(value, `${source}.${String(index)}`, selected, budget);
+    if (!shape) break;
+    output.push(shape);
+    if (isEdgeLimit2(shape)) break;
+  }
+  return output;
+}
+function optionalEdgeReference(value, source, selected, budget) {
+  return value ? edgeReference2(value, source, selected, budget) : null;
+}
+function edgeReference2(value, source, selected, budget) {
+  if (budget.claimChild(value, selected)) return reference2(value.nodeId, selected);
+  return budget.evidenceEdge(source);
+}
+function isEdgeLimit2(shape) {
+  return shape?.kind === "unknown" && shape.evidenceCode === "edge-limit";
+}
+function reference2(definition, selected) {
+  if (selected.has(definition)) return { kind: "reference", definition };
+  return {
+    kind: "unknown",
+    reason: `bounded:${definition}`,
+    evidenceCode: "node-limit",
+    sourceId: definition
+  };
+}
+
+// src/editor-invariants.ts
+function validNormalizedEditorGraph(graph, bindingId, intendedSourceId) {
+  if (!graph.admission || graph.admission.total > graph.admission.budget) return false;
+  const root = graph.roots.find((item) => item.bindingId === bindingId);
+  if (!root) return false;
+  const rootNode = nodeById(graph, root.nodeId);
+  if (!rootNode || !validRootNode(graph, rootNode, intendedSourceId)) return false;
+  return graph.nodes.every(validReferenceBoundary);
+}
+function validRootNode(graph, root, intendedSourceId) {
+  if (intentionalBoundedUnknown(root)) return true;
+  if (root.kind !== "reference" || root.status !== "resolved" || !root.target) return false;
+  const target = nodeById(graph, root.target.nodeId);
+  return Boolean(
+    target && (target.sourceId === intendedSourceId || intentionalBoundedUnknown(target))
+  );
+}
+function validReferenceBoundary(node) {
+  if (node.kind !== "reference") return true;
+  if (node.unresolved !== void 0) {
+    return node.status === "unresolved" && node.availability === "unavailable" && !node.target;
+  }
+  if (node.reference !== void 0 && !node.reference.startsWith("#")) return true;
+  return node.status === "resolved";
+}
+function intentionalBoundedUnknown(node) {
+  return node.kind === "unknown" && node.evidence.some((item) => item.code === "edge-limit" || item.code === "node-limit");
+}
+function nodeById(graph, nodeId) {
+  return graph.nodes.find((node) => node.id === nodeId);
+}
+function resolveProfile(options, conservative) {
+  try {
+    return resolveProfileSafely(options, conservative);
+  } catch {
+    return failed("SCHEMAN_ADAPTER_PROFILE_MALFORMED", "<unavailable>");
+  }
+}
+function resolveProfileSafely(options, conservative) {
+  const nodeId = options.document.root.output.nodeId;
+  const node = options.document.nodes[nodeId];
+  if (!node) return failed("SCHEMAN_ADAPTER_UNRESOLVED_ROOT", nodeId);
+  const local = readNodeProfile(node, nodeId);
+  if (!local.ok) return local;
+  const override = options.binding.override ? readPayload(options.binding.override, false, nodeId) : Object.freeze({ ok: true, value: void 0 });
+  if (!override.ok) return override;
+  const selected = override.value ?? local.value;
+  const source = override.value ? "override" : local.value ? "x-kalada" : "conservative";
+  if (!selected) return success({ type: conservative, source, finalValidation: "kalada-type" });
+  const compatibility = checkCompatibility(selected, conservative, node, options, nodeId);
+  if (!compatibility.ok) return compatibility;
+  return success({
+    ...selected,
+    source,
+    finalValidation: selected.lossy === "safe-integer-bigint-to-number" ? "safe-integer-and-kalada-type" : "kalada-type"
+  });
+}
+function readNodeProfile(node, nodeId) {
+  const metadata = optionalRecord(node.metadata);
+  const constraints = optionalRecord(node.constraints);
+  if (!metadata.ok || !constraints.ok) return failed("SCHEMAN_ADAPTER_PROFILE_MALFORMED", nodeId);
+  const direct = ownSlot(metadata.value, "x-kalada");
+  const extensions = nestedRecord(metadata.value, "extensions");
+  const annotations = nestedRecord(metadata.value, "annotations");
+  if (!extensions.ok || !annotations.ok) return failed("SCHEMAN_ADAPTER_PROFILE_MALFORMED", nodeId);
+  const extension = ownSlot(extensions.value, "x-kalada");
+  const annotation = ownSlot(annotations.value, "x-kalada");
+  const constrained = ownSlot(constraints.value, "x-kalada");
+  if (annotation.present || constrained.present || direct.present && extension.present) {
+    return failed("SCHEMAN_ADAPTER_PROFILE_CONFLICT", nodeId);
+  }
+  const payload = direct.present ? direct : extension;
+  if (!payload.present) return Object.freeze({ ok: true });
+  return readPayload(payload.value, true, nodeId);
+}
+function readPayload(input, versioned, nodeId) {
+  const inspected = ownRecord(input);
+  const allowed = versioned ? ["version", "type", "codec", "lossy"] : ["type", "codec", "lossy"];
+  if (!inspected.ok) return failed("SCHEMAN_ADAPTER_PROFILE_MALFORMED", nodeId);
+  const record = inspected.value;
+  if (!exactAllowedKeys(inspected, allowed) || versioned && record.version !== 1) {
+    return failed("SCHEMAN_ADAPTER_PROFILE_MALFORMED", nodeId);
+  }
+  const type = readSemanticType(record.type);
+  const codec = readBoundedText(record.codec);
+  const lossy = readLossPolicy(record.lossy);
+  if (!type.ok || codec === null || lossy === null) {
+    return failed("SCHEMAN_ADAPTER_PROFILE_MALFORMED", nodeId);
+  }
+  return success({
+    type: type.value,
+    ...codec ? { codec } : {},
+    ...lossy ? { lossy } : {},
+    source: versioned ? "x-kalada" : "override",
+    finalValidation: "kalada-type"
+  });
+}
+function checkCompatibility(profile, conservative, node, options, nodeId) {
+  const conversion = !sameType(profile.type, conservative) || profile.lossy !== void 0;
+  if (conversion && !profile.codec) return failed("SCHEMAN_ADAPTER_CODEC_REQUIRED", nodeId);
+  if (profile.lossy && !validLossPolicy(profile, node)) {
+    return failed("SCHEMAN_ADAPTER_PROFILE_INCOMPATIBLE", nodeId);
+  }
+  if (profile.codec && !matchingCodec(profile.codec, options)) {
+    return failed("SCHEMAN_ADAPTER_CODEC_MISMATCH", nodeId);
+  }
+  return success(profile);
+}
+function validLossPolicy(profile, node) {
+  if (profile.lossy === "safe-integer-bigint-to-number") {
+    return node.kind === "primitive" && node.type === "bigint" && isPrimitive(profile.type, "number");
+  }
+  if (profile.lossy === "heterogeneous-union-to-json") {
+    return node.kind === "union" && isPrimitive(profile.type, "json");
+  }
+  return true;
+}
+function matchingCodec(id, options) {
+  const codec = options.codec;
+  return Boolean(
+    codec && codec.id === id && codec.mode === options.mode && codec.capabilityVersion.length > 0 && codec.configurationDigest.length > 0
+  );
+}
+function isPrimitive(type, name) {
+  return type !== "dynamic" && type.kind === "primitive-type" && type.name === name;
+}
+function sameType(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function readBoundedText(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "string" && value.length > 0 && value.length <= 256 ? value : null;
+}
+function readLossPolicy(value) {
+  if (value === void 0) return void 0;
+  return value === "safe-integer-bigint-to-number" || value === "heterogeneous-union-to-json" ? value : null;
+}
+function exactAllowedKeys(record, allowed) {
+  return record.keys.includes("type") && record.keys.every((key) => allowed.includes(key));
+}
+function ownRecord(input) {
+  if (typeof input !== "object" || input === null) return Object.freeze({ ok: false });
+  const reflected = reflectRecord(input);
+  if (!reflected) return Object.freeze({ ok: false });
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const key of reflected.keys) output[key] = reflected.descriptors[key]?.value;
+  return Object.freeze({
+    ok: true,
+    value: Object.freeze(output),
+    keys: Object.freeze(reflected.keys)
+  });
+}
+function reflectRecord(input) {
+  try {
+    if (Array.isArray(input)) return null;
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== null && prototype !== Object.prototype) return null;
+    const ownKeys = Reflect.ownKeys(input);
+    if (ownKeys.some((key) => typeof key !== "string")) return null;
+    const keys = ownKeys;
+    const descriptors = /* @__PURE__ */ Object.create(null);
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(input, key);
+      if (!descriptor || !("value" in descriptor)) return null;
+      descriptors[key] = descriptor;
+    }
+    return { keys, descriptors };
+  } catch {
+    return null;
+  }
+}
+function optionalRecord(input) {
+  if (input === void 0 || isProfileFreeOwnedValue(input)) return Object.freeze({ ok: true });
+  const record = ownRecord(input);
+  return record.ok ? Object.freeze({ ok: true, value: record }) : Object.freeze({ ok: false });
+}
+function isProfileFreeOwnedValue(input) {
+  if (input === null || typeof input === "string" || typeof input === "boolean") return true;
+  if (typeof input === "number") return Number.isFinite(input);
+  return Array.isArray(input);
+}
+function nestedRecord(parent, key) {
+  const slot = ownSlot(parent, key);
+  return slot.present ? optionalRecord(slot.value) : Object.freeze({ ok: true });
+}
+function ownSlot(record, key) {
+  if (!record?.keys.includes(key)) return Object.freeze({ present: false });
+  return Object.freeze({ present: true, value: record.value[key] });
+}
+function success(value) {
+  return Object.freeze({ ok: true, value: Object.freeze(value) });
+}
+function failed(code, nodeId) {
+  return Object.freeze({
+    ok: false,
+    diagnostics: Object.freeze([
+      Object.freeze({ code, severity: "error", side: "output", sourcePointer: "", nodeId })
+    ])
+  });
+}
+
+// src/semantic-mapping.ts
+var primitive = (name) => Object.freeze({ kind: "primitive-type", name });
+function projectOutput(document, limits) {
+  const rootId = document.root.output.nodeId;
+  const graph = collectGraph(rootId, document, limits);
+  if (graph.bounded) return boundedProjection(rootId);
+  const safe = jsonSafety(graph, document);
+  const states = projectionStates(graph, safe, document, limits.maxTypeDepth);
+  const type = states.get(rootId)?.type ?? "dynamic";
+  return Object.freeze({ type, diagnostics: projectionDiagnostics(type, rootId) });
+}
+function collectGraph(rootId, document, limits) {
+  const nodes = /* @__PURE__ */ new Map();
+  const pending = [rootId];
+  let edges = 0;
+  let bounded2 = false;
+  while (pending.length > 0) {
+    const nodeId = pending.pop();
+    if (!nodeId || nodes.has(nodeId)) continue;
+    if (nodes.size >= limits.maxNodes) {
+      bounded2 = true;
+      break;
+    }
+    const node = document.nodes[nodeId];
+    if (!node) continue;
+    nodes.set(nodeId, node);
+    const children = projectionChildren(nodeId, node, document);
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      edges += 1;
+      if (edges > limits.maxEdges) {
+        bounded2 = true;
+        break;
+      }
+      pending.push(children[index]);
+    }
+    if (bounded2) break;
+  }
+  return Object.freeze({ nodes, bounded: bounded2 });
+}
+function projectionChildren(nodeId, node, document) {
+  if (hasApplicators(node)) return [];
+  if (node.kind === "object") {
+    return [
+      ...node.properties.map((property) => property.node.nodeId),
+      ...node.additionalProperties ? [node.additionalProperties.nodeId] : []
+    ];
+  }
+  if (node.kind === "array") return [node.items.nodeId];
+  if (node.kind === "tuple") return refs([...node.items, ...node.rest ? [node.rest] : []]);
+  if (node.kind === "record") return [node.key.nodeId, node.value.nodeId];
+  if (node.kind === "union") return refs(node.alternatives);
+  if (node.kind === "intersection") return refs(node.operands);
+  if (node.kind === "wrapper") return [node.inner.nodeId];
+  if (node.kind === "ref" && eligibleLocalReference(nodeId, node, document)) {
+    return [node.target?.nodeId];
+  }
+  return [];
+}
+function jsonSafety(graph, document) {
+  const safe = /* @__PURE__ */ new Map();
+  const stringKeys = stringKeyDomains(graph, document);
+  for (const [nodeId, node] of graph.nodes) safe.set(nodeId, jsonCandidate(nodeId, node, document));
+  for (let pass = 0; pass < graph.nodes.size; pass += 1) {
+    let changed = false;
+    for (const [nodeId, node] of graph.nodes) {
+      if (!safe.get(nodeId) || jsonDependenciesSafe(nodeId, node, safe, stringKeys, document))
+        continue;
+      safe.set(nodeId, false);
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return safe;
+}
+function jsonCandidate(nodeId, node, document) {
+  if (hasApplicators(node)) return false;
+  if (node.kind === "primitive") {
+    return ["null", "boolean", "number", "integer", "string"].includes(node.type);
+  }
+  if (node.kind === "literal") return isJsonValue(node.value);
+  if (node.kind === "enum") return node.values.every(isJsonValue);
+  if (node.kind === "unconstrained") return node.domain === "json";
+  if (node.kind === "ref") return eligibleLocalReference(nodeId, node, document);
+  if (node.kind === "wrapper") return node.wrapper === "readonly" || node.wrapper === "brand";
+  return ["object", "array", "tuple", "record", "union", "intersection"].includes(node.kind);
+}
+function jsonDependenciesSafe(nodeId, node, safe, stringKeys, document) {
+  if (node.kind === "object") return objectDependenciesSafe(node, safe);
+  if (node.kind === "array") return safe.get(node.items.nodeId) === true;
+  if (node.kind === "tuple")
+    return refsSafe([...node.items, ...node.rest ? [node.rest] : []], safe);
+  if (node.kind === "record") {
+    return stringKeys.get(node.key.nodeId) === true && safe.get(node.value.nodeId) === true;
+  }
+  if (node.kind === "union") return refsSafe(node.alternatives, safe);
+  if (node.kind === "intersection") return refsSafe(node.operands, safe);
+  if (node.kind === "wrapper") return safe.get(node.inner.nodeId) === true;
+  if (node.kind === "ref" && eligibleLocalReference(nodeId, node, document)) {
+    return safe.get(node.target?.nodeId) === true;
+  }
+  return true;
+}
+function objectDependenciesSafe(node, safe) {
+  if (!node.properties.every((property) => safe.get(property.node.nodeId) === true)) return false;
+  const additionalSafe = node.additionalProperties ? safe.get(node.additionalProperties.nodeId) === true : false;
+  if (node.unknownKeys === "schema") return additionalSafe;
+  if (node.unknownKeys === "passthrough" || node.unknownKeys === "unknown") return additionalSafe;
+  return !node.additionalProperties || additionalSafe;
+}
+function stringKeyDomains(graph, document) {
+  const output = /* @__PURE__ */ new Map();
+  for (const [nodeId, node] of graph.nodes) output.set(nodeId, directStringDomain(node));
+  for (let pass = 0; pass < graph.nodes.size; pass += 1) {
+    let changed = false;
+    for (const [nodeId, node] of graph.nodes) {
+      if (output.get(nodeId) || !derivedStringDomain(nodeId, node, output, document)) continue;
+      output.set(nodeId, true);
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return output;
+}
+function directStringDomain(node) {
+  if (node.kind === "primitive") return node.type === "string";
+  if (node.kind === "literal") return typeof node.value === "string";
+  return node.kind === "enum" && node.values.length > 0 && node.values.every((item) => typeof item === "string");
+}
+function derivedStringDomain(nodeId, node, domains, document) {
+  if (node.kind === "wrapper" && (node.wrapper === "readonly" || node.wrapper === "brand")) {
+    return domains.get(node.inner.nodeId) === true;
+  }
+  if (node.kind === "ref" && eligibleLocalReference(nodeId, node, document)) {
+    return domains.get(node.target?.nodeId) === true;
+  }
+  if (node.kind === "union") return node.alternatives.every((ref) => domains.get(ref.nodeId));
+  if (node.kind === "intersection") return node.operands.every((ref) => domains.get(ref.nodeId));
+  return false;
+}
+function projectionStates(graph, safe, document, maxDepth) {
+  const states = /* @__PURE__ */ new Map();
+  for (const [nodeId, node] of graph.nodes) {
+    const direct = directProjection(node, safe.get(nodeId) === true);
+    if (direct) states.set(nodeId, direct);
+  }
+  for (let pass = 0; pass < graph.nodes.size; pass += 1) {
+    let changed = false;
+    for (const [nodeId, node] of graph.nodes) {
+      if (states.has(nodeId)) continue;
+      const derived = derivedProjection(nodeId, node, states, document, maxDepth);
+      if (!derived) continue;
+      states.set(nodeId, derived);
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return states;
+}
+function directProjection(node, jsonSafe) {
+  if (hasApplicators(node)) return null;
+  if (node.kind === "primitive") return state(primitiveProjection(node.type));
+  if (node.kind === "literal") return state(literalProjection(node.value));
+  if (node.kind === "enum") return state(enumProjection(node.values));
+  if (node.kind === "unconstrained" && node.domain === "json") return state(primitive("json"));
+  if (["object", "record", "tuple"].includes(node.kind) && jsonSafe)
+    return state(primitive("json"));
+  return null;
+}
+function derivedProjection(nodeId, node, states, document, maxDepth) {
+  if (node.kind === "array") return arrayState(states.get(node.items.nodeId), maxDepth);
+  if (node.kind === "union") return sharedState(node.alternatives, states);
+  if (node.kind === "intersection") return sharedState(node.operands, states);
+  if (node.kind === "wrapper" && (node.wrapper === "readonly" || node.wrapper === "brand")) {
+    return states.get(node.inner.nodeId) ?? null;
+  }
+  if (node.kind === "ref" && eligibleLocalReference(nodeId, node, document)) {
+    return states.get(node.target?.nodeId) ?? null;
+  }
+  return null;
+}
+function primitiveProjection(type) {
+  if (type === "null" || type === "boolean" || type === "string") return primitive(type);
+  return type === "number" || type === "integer" ? primitive("number") : "dynamic";
+}
+function literalProjection(value) {
+  const domain = primitiveDomain(value);
+  return domain ? primitive(domain) : "dynamic";
+}
+function enumProjection(values) {
+  const domains = new Set(values.map(primitiveDomain));
+  const [domain] = domains;
+  return domains.size === 1 && domain ? primitive(domain) : "dynamic";
+}
+function arrayState(element, maxDepth) {
+  if (!element || element.type === "dynamic" || element.depth >= maxDepth) return null;
+  return Object.freeze({
+    type: Object.freeze({ kind: "array-type", element: element.type }),
+    depth: element.depth + 1
+  });
+}
+function sharedState(refs2, states) {
+  const values = refs2.map((ref) => states.get(ref.nodeId));
+  const first = values[0];
+  if (!first || first.type === "dynamic" || values.some((item) => !item)) return null;
+  return values.every((item) => sameType2(item?.type, first.type)) ? first : null;
+}
+function state(type) {
+  return type === "dynamic" ? null : Object.freeze({ type, depth: 0 });
+}
+function refsSafe(values, safe) {
+  return values.every((ref) => safe.get(ref.nodeId) === true);
+}
+function refs(values) {
+  return values.map((value) => value.nodeId);
+}
+function primitiveDomain(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "string") return "string";
+  return typeof value === "number" && Number.isFinite(value) ? "number" : null;
+}
+function isJsonValue(input) {
+  const pending = [input];
+  let visits = 0;
+  while (pending.length > 0) {
+    const value = pending.pop();
+    visits += 1;
+    if (visits > 1e4) return false;
+    if (primitiveDomain(value)) continue;
+    if (Array.isArray(value)) {
+      pending.push(...value);
+      continue;
+    }
+    if (typeof value !== "object" || value === null) return false;
+    pending.push(...Object.values(value));
+  }
+  return true;
+}
+function hasApplicators(node) {
+  const value = node.applicators;
+  if (!value) return false;
+  if (value.if || value.then || value.else || value.not || value.contains || value.propertyNames)
+    return true;
+  return Object.keys(value.patternProperties ?? {}).length > 0 || Object.keys(value.dependentSchemas ?? {}).length > 0;
+}
+function sameType2(left, right) {
+  return left !== void 0 && JSON.stringify(left) === JSON.stringify(right);
+}
+function projectionDiagnostics(type, nodeId) {
+  if (type !== "dynamic") return Object.freeze([]);
+  return Object.freeze([
+    warning("SCHEMAN_ADAPTER_UNSUPPORTED_EVIDENCE", nodeId),
+    warning("SCHEMAN_ADAPTER_DYNAMIC_PROJECTION", nodeId)
+  ]);
+}
+function boundedProjection(nodeId) {
+  return Object.freeze({
+    type: "dynamic",
+    diagnostics: Object.freeze([
+      warning("SCHEMAN_ADAPTER_ANALYSIS_LIMIT", nodeId),
+      warning("SCHEMAN_ADAPTER_DYNAMIC_PROJECTION", nodeId)
+    ])
+  });
+}
+function warning(code, nodeId) {
+  return Object.freeze({ code, severity: "warning", side: "output", sourcePointer: "", nodeId });
+}
+
+// src/adapter.ts
+var validatorHandle = "scheman-validator";
+var codecHandle = "scheman-codec";
+var maximumSourceRecords = 512;
+function adaptSchemanDocument(options) {
+  const document = options.document;
+  const invalid = validateDocument(document);
+  if (invalid) return failure(invalid);
+  const limits = resolveAnalysisLimits(options.analysisLimits);
+  const projection = projectOutput(document, limits);
+  const profile = resolveProfile(options, projection.type);
+  if (!profile.ok) return Object.freeze({ ok: false, diagnostics: profile.diagnostics });
+  const editor = schemanEditorDocument(document, limits);
+  const sourceEvidence = boundedSourceEvidence(
+    document,
+    Math.min(limits.maxNodes, maximumSourceRecords)
+  );
+  const described = describeEnvironment(
+    adapterProvider(options, document, profile.value, limits, editor, sourceEvidence)
+  );
+  if (!described.ok) return failure(adapterFailure("SCHEMAN_ADAPTER_INVALID_DOCUMENT"));
+  if (!validNormalizedEditorGraph(
+    described.environment.editorGraph,
+    options.binding.id,
+    document.root.input.nodeId
+  )) {
+    return failure(adapterFailure("SCHEMAN_ADAPTER_INVALID_DOCUMENT"));
+  }
+  return Object.freeze({
+    ok: true,
+    environment: described.environment,
+    capabilitySnapshot: described.capabilitySnapshot,
+    diagnostics: Object.freeze([
+      ...sourceDiagnostics(sourceEvidence.diagnostics.values),
+      ...projection.diagnostics,
+      ...sourceLimitDiagnostics(sourceEvidence, editor)
+    ]),
+    ...options.validator ? { retainedValidator: options.validator.validator } : {}
+  });
+}
+function adapterProvider(options, document, profile, limits, editor, sourceEvidence) {
+  return createManualProvider({
+    mode: options.mode,
+    providerId: options.providerId,
+    providerVersion: options.providerVersion,
+    configurationDigest: options.configurationDigest,
+    cacheable: options.cacheable,
+    capabilities: configuredCapabilities(options, profile),
+    bindings: [
+      {
+        id: options.binding.id,
+        name: options.binding.name,
+        path: options.binding.path,
+        semanticType: profile.type,
+        editorShape: editor.document,
+        ...options.validator ? { validatorHandle } : {},
+        ...profile.codec ? { codecHandle } : {},
+        metadata: environmentMetadata(document, profile, limits, editor, sourceEvidence),
+        provenance: [schemanProvenance(document)]
+      }
+    ]
+  });
+}
+function validateDocument(document) {
+  if (document.formatVersion !== 1) return adapterFailure("SCHEMAN_ADAPTER_FORMAT_VERSION");
+  if (!document.root?.input?.nodeId || !document.root?.output?.nodeId) {
+    return adapterFailure("SCHEMAN_ADAPTER_INVALID_DOCUMENT");
+  }
+  if (!document.nodes[document.root.input.nodeId] || !document.nodes[document.root.output.nodeId]) {
+    return adapterFailure("SCHEMAN_ADAPTER_UNRESOLVED_ROOT");
+  }
+  return void 0;
+}
+function configuredCapabilities(options, profile) {
+  const capabilities = [];
+  if (options.validator) capabilities.push(validatorCapability(options.validator));
+  const codec = options.codec;
+  if (codec) {
+    capabilities.push({
+      handle: codecHandle,
+      kind: "codec",
+      mode: codec.mode,
+      capabilityId: codec.id,
+      capabilityVersion: codec.capabilityVersion,
+      configurationDigest: codec.configurationDigest,
+      cacheable: codec.cacheable,
+      convert: (value) => convertWithFinalPolicy(codec, profile.finalValidation, value)
+    });
+  }
+  return capabilities;
+}
+function validatorCapability(config) {
+  return {
+    handle: validatorHandle,
+    kind: "validator",
+    mode: config.mode,
+    capabilityId: config.capabilityId,
+    capabilityVersion: config.capabilityVersion,
+    configurationDigest: config.configurationDigest,
+    cacheable: config.cacheable,
+    decode: (value) => decodeStandardSchema(config.validator, value)
+  };
+}
+function environmentMetadata(document, profile, limits, editor, sourceEvidence) {
+  const sourceRetention = sourceRetentionMetadata(document, editor, sourceEvidence);
+  return {
+    scheman: {
+      formatVersion: document.formatVersion,
+      nodeIdScope: "document-local",
+      roots: { input: document.root.input.nodeId, output: document.root.output.nodeId },
+      capabilities: document.capabilities,
+      definitions: sourceEvidence.definitions.values,
+      diagnostics: sourceEvidence.diagnostics.values,
+      metadata: document.metadata,
+      bounded: {
+        limits,
+        retainedNodes: editor.retainedNodes,
+        retainedEdges: editor.retainedEdges,
+        nodes: {
+          retained: editor.retainedNodes,
+          total: Object.keys(document.nodes).length,
+          truncated: editor.nodeTruncated
+        },
+        edges: editor.sourceEdges,
+        requiredNames: editor.requiredNames,
+        definitions: sourceEvidence.definitions.summary,
+        diagnostics: sourceEvidence.diagnostics.summary,
+        sourceRetention,
+        hostAdmissionPlan: editor.admission,
+        truncated: editor.nodeTruncated || editor.edgeTruncated || editor.requiredNames.truncated || sourceEvidence.definitions.summary.truncated || sourceEvidence.diagnostics.summary.truncated
+      }
+    },
+    policy: profile
+  };
+}
+function sourceRetentionMetadata(document, editor, sourceEvidence) {
+  return {
+    nodes: {
+      retained: editor.retainedNodes,
+      total: Object.keys(document.nodes).length,
+      truncated: editor.nodeTruncated
+    },
+    edges: editor.sourceEdges,
+    requiredNames: editor.requiredNames,
+    definitions: sourceEvidence.definitions.summary,
+    diagnostics: sourceEvidence.diagnostics.summary
+  };
+}
+function schemanProvenance(document) {
+  const metadata = document.metadata;
+  return Object.freeze({
+    providerId: "@scheman/core",
+    providerVersion: "2.0.0",
+    ...typeof metadata.provider === "string" ? { extractor: metadata.provider } : {}
+  });
+}
+function sourceDiagnostics(diagnostics) {
+  return diagnostics.map((diagnostic) => wrapSourceDiagnostic(diagnostic));
+}
+function boundedSourceEvidence(document, maximum) {
+  return {
+    definitions: boundedRecords(document.definitions, maximum),
+    diagnostics: boundedRecords(document.diagnostics, maximum)
+  };
+}
+function boundedRecords(values, maximum) {
+  const retained = values.slice(0, maximum);
+  return {
+    values: retained,
+    summary: {
+      retained: retained.length,
+      total: values.length,
+      truncated: retained.length < values.length
+    }
+  };
+}
+function sourceLimitDiagnostics(evidence, editor) {
+  const sourcePointer = limitSourcePointer(evidence, editor);
+  if (!sourcePointer) return Object.freeze([]);
+  const diagnostic = Object.freeze({
+    code: "SCHEMAN_ADAPTER_ANALYSIS_LIMIT",
+    severity: "warning",
+    side: "output",
+    sourcePointer
+  });
+  return Object.freeze([diagnostic]);
+}
+function limitSourcePointer(evidence, editor) {
+  if (evidence.definitions.summary.truncated) return "/definitions";
+  if (evidence.diagnostics.summary.truncated) return "/diagnostics";
+  if (editor.requiredNames.truncated) return "/nodes/*/required";
+  return void 0;
+}
+function wrapSourceDiagnostic(diagnostic) {
+  return Object.freeze({
+    code: diagnostic.code,
+    severity: diagnostic.severity,
+    side: diagnostic.side,
+    sourcePointer: diagnostic.sourcePointer,
+    ...diagnostic.nodeId ? { nodeId: diagnostic.nodeId } : {},
+    provenance: Object.freeze({ providerId: "@scheman/core", formatVersion: "1" })
+  });
+}
+function adapterFailure(code) {
+  return Object.freeze({ code, severity: "error", side: "output", sourcePointer: "" });
+}
+function failure(diagnostic) {
+  return Object.freeze({ ok: false, diagnostics: Object.freeze([diagnostic]) });
+}
+
+// src/mapping-table.ts
+var SCHEMAN_SEMANTIC_MAPPING = Object.freeze([
+  { scheman: "primitive:null|boolean|string", projection: "same primitive", condition: "always" },
+  {
+    scheman: "primitive:number|integer",
+    projection: "number",
+    condition: "always; constraints retained"
+  },
+  {
+    scheman: "literal|enum",
+    projection: "single primitive domain",
+    condition: "all values share one supported domain"
+  },
+  { scheman: "array", projection: "array-type", condition: "item projection is concrete" },
+  {
+    scheman: "object|record|tuple",
+    projection: "json",
+    condition: "entire reachable graph is JSON-safe"
+  },
+  {
+    scheman: "union|intersection",
+    projection: "shared concrete type",
+    condition: "every operand agrees"
+  },
+  { scheman: "ref", projection: "target projection", condition: "same-document target resolves" },
+  {
+    scheman: "wrapper:readonly|brand",
+    projection: "inner projection",
+    condition: "wrapper is non-transforming"
+  },
+  { scheman: "unconstrained:json", projection: "json", condition: "JSON domain is explicit" },
+  {
+    scheman: "unknown|opaque|never|unconstrained:js",
+    projection: "dynamic",
+    condition: "unless explicitly overridden"
+  },
+  {
+    scheman: "primitive:undefined|void|bigint|symbol|date|NaN",
+    projection: "dynamic",
+    condition: "unless explicitly overridden"
+  },
+  {
+    scheman: "wrapper:optional|nullable|default|catch|pipeline|effect|coerce",
+    projection: "dynamic",
+    condition: "unless explicitly overridden"
+  }
+]);
+var SCHEMAN_MAPPING_FIXTURE_MATRIX = Object.freeze([
+  ["primitive-null", "null"],
+  ["primitive-boolean", "boolean"],
+  ["primitive-string", "string"],
+  ["primitive-number", "number"],
+  ["primitive-integer", "number"],
+  ["literal-primitive", "primitive-domain"],
+  ["enum-single-domain", "primitive-domain"],
+  ["enum-mixed-domain", "dynamic"],
+  ["array-concrete-item", "array-type"],
+  ["array-dynamic-item", "dynamic"],
+  ["json-safe-object-record-tuple", "json"],
+  ["homogeneous-union-intersection", "shared-concrete"],
+  ["heterogeneous-union", "dynamic"],
+  ["resolved-local-ref", "target"],
+  ["unresolved-or-external-ref", "dynamic"],
+  ["readonly-or-brand-wrapper", "inner"],
+  ["json-unconstrained", "json"],
+  ["unknown-opaque-never-js-unconstrained", "dynamic"],
+  ["undefined-void-bigint-symbol-date-nan", "dynamic"],
+  ["optional-nullable-default-catch-effect-pipeline-coerce", "dynamic"],
+  ["unsupported-applicator", "dynamic"]
+]);
+
+// src/index.ts
+var DENY_SCHEMAN_EXECUTION_PERMISSIONS = Object.freeze({
+  zod: Object.freeze({ shape: false, lazy: false, metadata: false }),
+  standardJson: false
+});
+
+export { DEFAULT_SCHEMAN_ANALYSIS_LIMITS, DENY_SCHEMAN_EXECUTION_PERMISSIONS, SCHEMAN_MAPPING_FIXTURE_MATRIX, SCHEMAN_SEMANTIC_MAPPING, adaptSchemanDocument };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map