@rsconcept/domain 1.0.0 → 1.2.0

package/dist/library/oss-api.js

@@ -1,1105 +1,267 @@
-// src/graph/graph.ts
-var GraphNode = class _GraphNode {
-  /** Unique identifier of the node. */
-  id;
-  /** List of outgoing nodes. */
-  outputs;
-  /** List of incoming nodes. */
-  inputs;
-  constructor(id) {
-    this.id = id;
-    this.outputs = [];
-    this.inputs = [];
-  }
-  clone() {
-    const result = new _GraphNode(this.id);
-    result.outputs = [...this.outputs];
-    result.inputs = [...this.inputs];
-    return result;
-  }
-  addOutput(node) {
-    this.outputs.push(node);
-  }
-  addInput(node) {
-    this.inputs.push(node);
-  }
-  removeInput(target) {
-    const index = this.inputs.findIndex((node) => node === target);
-    return index > -1 ? this.inputs.splice(index, 1)[0] : null;
-  }
-  removeOutput(target) {
-    const index = this.outputs.findIndex((node) => node === target);
-    return index > -1 ? this.outputs.splice(index, 1)[0] : null;
-  }
-};
-var Graph = class _Graph {
-  /** Map of nodes. */
-  nodes = /* @__PURE__ */ new Map();
-  constructor(arr) {
-    if (!arr) {
-      return;
-    }
-    arr.forEach((edge) => {
-      if (edge.length === 1) {
-        this.addNode(edge[0]);
-      } else {
-        this.addEdge(edge[0], edge[1]);
-      }
-    });
-  }
-  clone() {
-    const result = new _Graph();
-    this.nodes.forEach((node) => result.nodes.set(node.id, node.clone()));
-    return result;
-  }
-  at(target) {
-    return this.nodes.get(target);
-  }
-  addNode(target) {
-    let node = this.nodes.get(target);
-    if (!node) {
-      node = new GraphNode(target);
-      this.nodes.set(target, node);
-    }
-    return node;
-  }
-  hasNode(target) {
-    return !!this.nodes.get(target);
-  }
-  removeNode(target) {
-    this.nodes.forEach((node) => {
-      node.removeInput(target);
-      node.removeOutput(target);
-    });
-    this.nodes.delete(target);
-  }
-  foldNode(target) {
-    const nodeToRemove = this.nodes.get(target);
-    if (!nodeToRemove) {
-      return;
-    }
-    nodeToRemove.inputs.forEach((input) => {
-      nodeToRemove.outputs.forEach((output) => {
-        this.addEdge(input, output);
-      });
-    });
-    this.removeNode(target);
-  }
-  removeIsolated() {
-    const result = [];
-    this.nodes.forEach((node) => {
-      if (node.outputs.length === 0 && node.inputs.length === 0) {
-        result.push(node);
-        this.nodes.delete(node.id);
-      }
-    });
-    return result;
-  }
-  addEdge(source, destination) {
-    if (this.hasEdge(source, destination)) {
-      return;
-    }
-    const sourceNode = this.addNode(source);
-    const destinationNode = this.addNode(destination);
-    sourceNode.addOutput(destinationNode.id);
-    destinationNode.addInput(sourceNode.id);
-  }
-  removeEdge(source, destination) {
-    const sourceNode = this.nodes.get(source);
-    const destinationNode = this.nodes.get(destination);
-    if (sourceNode && destinationNode) {
-      sourceNode.removeOutput(destination);
-      destinationNode.removeInput(source);
-    }
-  }
-  hasEdge(source, destination) {
-    const sourceNode = this.nodes.get(source);
-    if (!sourceNode) {
-      return false;
-    }
-    return !!sourceNode.outputs.find((id) => id === destination);
-  }
-  isReachable(source, destination) {
-    return this.expandAllOutputs([source]).includes(destination);
-  }
-  rootNodes() {
-    return [...this.nodes.keys()].filter((id) => !this.nodes.get(id)?.inputs.length);
-  }
-  expandOutputs(origin) {
-    const result = [];
-    origin.forEach((id) => {
-      const node = this.nodes.get(id);
-      if (node) {
-        node.outputs.forEach((child) => {
-          if (!origin.includes(child) && !result.includes(child)) {
-            result.push(child);
-          }
-        });
-      }
-    });
-    return result;
-  }
-  expandInputs(origin) {
-    const result = [];
-    origin.forEach((id) => {
-      const node = this.nodes.get(id);
-      if (node) {
-        node.inputs.forEach((child) => {
-          if (!origin.includes(child) && !result.includes(child)) {
-            result.push(child);
-          }
-        });
-      }
-    });
-    return result;
-  }
-  expandAllOutputs(origin) {
-    const result = this.expandOutputs(origin);
-    if (result.length === 0) {
-      return [];
-    }
-    const marked = /* @__PURE__ */ new Map();
-    origin.forEach((id) => marked.set(id, true));
-    let position = 0;
-    while (position < result.length) {
-      const node = this.nodes.get(result[position]);
-      if (node && !marked.get(node.id)) {
-        marked.set(node.id, true);
-        node.outputs.forEach((child) => {
-          if (!marked.get(child) && !result.find((id) => id === child)) {
-            result.push(child);
-          }
-        });
-      }
-      position += 1;
-    }
-    return result;
-  }
-  expandAllInputs(origin) {
-    const result = this.expandInputs(origin);
-    if (result.length === 0) {
-      return [];
-    }
-    const marked = /* @__PURE__ */ new Map();
-    origin.forEach((id) => marked.set(id, true));
-    let position = 0;
-    while (position < result.length) {
-      const node = this.nodes.get(result[position]);
-      if (node && !marked.get(node.id)) {
-        marked.set(node.id, true);
-        node.inputs.forEach((child) => {
-          if (!marked.get(child) && !result.find((id) => id === child)) {
-            result.push(child);
-          }
-        });
-      }
-      position += 1;
-    }
-    return result;
-  }
-  maximizePart(origin) {
-    const outputs = this.expandAllOutputs(origin);
-    const result = [...origin];
-    this.topologicalOrder().filter((id) => outputs.includes(id)).forEach((id) => {
-      const node = this.nodes.get(id);
-      if (node?.inputs.every((parent) => result.includes(parent))) {
-        result.push(id);
-      }
-    });
-    return result;
-  }
-  topologicalOrder() {
-    const result = [];
-    const marked = /* @__PURE__ */ new Set();
-    const nodeStack = [];
-    this.nodes.forEach((node) => {
-      if (marked.has(node.id)) {
-        return;
-      }
-      nodeStack.push(node.id);
-      while (nodeStack.length > 0) {
-        const item = nodeStack[nodeStack.length - 1];
-        if (marked.has(item)) {
-          if (!result.find((id) => id === item)) {
-            result.push(item);
-          }
-          nodeStack.pop();
-        } else {
-          marked.add(item);
-          const itemNode = this.nodes.get(item);
-          if (itemNode && itemNode.outputs.length > 0) {
-            itemNode.outputs.forEach((child) => {
-              if (!marked.has(child)) {
-                nodeStack.push(child);
-              }
-            });
-          }
-        }
-      }
-    });
-    return result.reverse();
-  }
-  /**
-   * Stably reorders the given node ids so that, for this DAG, no node appears before a transitive
-   * successor (edges: source → dependent; {@link GraphNode.outputs} lists dependents).
-   */
-  sortStable(target) {
-    if (target.length <= 1) {
-      return [...target];
-    }
-    const reachable = this.buildTransitiveClosureForSort();
-    const testSet = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const nodeId of [...target].reverse()) {
-      const nodeReachable = reachable.get(nodeId) ?? /* @__PURE__ */ new Set();
-      const needMove = testSet.has(nodeId);
-      for (const childId of nodeReachable) {
-        testSet.add(childId);
-      }
-      if (!needMove) {
-        result.push(nodeId);
-        continue;
-      }
-      let inserted = false;
-      for (let index = 0; index < result.length; index++) {
-        const parent = result[index];
-        const parentReachable = reachable.get(parent) ?? /* @__PURE__ */ new Set();
-        if (nodeReachable.has(parent)) {
-          if (parentReachable.has(nodeId)) {
-            result.push(nodeId);
-          } else {
-            result.splice(index, 0, nodeId);
-          }
-          inserted = true;
-          break;
-        }
-      }
-      if (!inserted) {
-        result.push(nodeId);
-      }
-    }
-    result.reverse();
-    return result;
-  }
-  buildTransitiveClosureForSort() {
-    const closure = /* @__PURE__ */ new Map();
-    for (const node of this.nodes.values()) {
-      closure.set(node.id, new Set(node.outputs));
-    }
-    const order = this.topologicalOrder();
-    for (const nodeId of [...order].reverse()) {
-      const node = this.at(nodeId);
-      if (!node) {
-        continue;
-      }
-      const nodeClosure = closure.get(nodeId) ?? /* @__PURE__ */ new Set();
-      for (const parentId of node.inputs) {
-        const parentClosure = closure.get(parentId) ?? /* @__PURE__ */ new Set();
-        for (const childId of nodeClosure) {
-          parentClosure.add(childId);
-        }
-        closure.set(parentId, parentClosure);
-      }
-    }
-    return closure;
-  }
-  transitiveReduction() {
-    const order = this.topologicalOrder();
-    const marked = /* @__PURE__ */ new Map();
-    order.forEach((nodeID) => {
-      if (marked.get(nodeID)) {
-        return;
-      }
-      const stack = [];
-      stack.push({ id: nodeID, parents: [] });
-      while (stack.length > 0) {
-        const item = stack.splice(0, 1)[0];
-        const node = this.nodes.get(item.id);
-        if (node) {
-          node.outputs.forEach((child) => {
-            item.parents.forEach((parent) => this.removeEdge(parent, child));
-            stack.push({ id: child, parents: [item.id, ...item.parents] });
-          });
-        }
-        marked.set(item.id, true);
-      }
-    });
-  }
-  /**
-   * Finds a cycle in the graph.
-   *
-   * @returns {NodeID[] | null} The cycle if found, otherwise `null`.
-   * Uses non-recursive DFS.
-   */
-  findCycle() {
-    const visited = /* @__PURE__ */ new Set();
-    const nodeStack = /* @__PURE__ */ new Set();
-    const parents = /* @__PURE__ */ new Map();
-    for (const nodeId of this.nodes.keys()) {
-      if (visited.has(nodeId)) {
-        continue;
-      }
-      const callStack = [];
-      callStack.push({ nodeId, parentId: null });
-      while (callStack.length > 0) {
-        const { nodeId: nodeId2, parentId } = callStack[callStack.length - 1];
-        if (visited.has(nodeId2)) {
-          nodeStack.delete(nodeId2);
-          callStack.pop();
-          continue;
-        }
-        visited.add(nodeId2);
-        nodeStack.add(nodeId2);
-        if (parentId !== null) {
-          parents.set(nodeId2, parentId);
-        }
-        const currentNode = this.nodes.get(nodeId2);
-        for (const child of currentNode.outputs) {
-          if (!visited.has(child)) {
-            callStack.push({ nodeId: child, parentId: nodeId2 });
-            continue;
-          }
-          if (!nodeStack.has(child)) {
-            continue;
-          }
-          const cycle = [];
-          let current = nodeId2;
-          cycle.push(child);
-          while (current !== child) {
-            cycle.push(current);
-            current = parents.get(current);
-          }
-          cycle.push(child);
-          cycle.reverse();
-          return cycle;
-        }
-      }
-    }
-    return null;
-  }
-};
-
-// src/parsing/ast.ts
-var TOKEN_ERROR = 0;
-
-// src/rslang/parser/token.ts
-var TokenID = {
-  // Global, local IDs and literals
-  ERROR: TOKEN_ERROR,
-  ID_LOCAL: 258,
-  ID_GLOBAL: 259,
-  ID_FUNCTION: 260,
-  ID_PREDICATE: 261,
-  ID_RADICAL: 262,
-  LIT_INTEGER: 263,
-  LIT_WHOLE_NUMBERS: 264,
-  LIT_EMPTYSET: 265,
-  // Arithmetic
-  PLUS: 266,
-  MINUS: 267,
-  MULTIPLY: 268,
-  // Integer predicate symbols
-  GREATER: 269,
-  LESSER: 270,
-  GREATER_OR_EQ: 271,
-  LESSER_OR_EQ: 272,
-  // Equality comparison
-  EQUAL: 273,
-  NOTEQUAL: 274,
-  // Logic predicate symbols
-  QUANTOR_UNIVERSAL: 275,
-  QUANTOR_EXISTS: 276,
-  LOGIC_NOT: 277,
-  LOGIC_EQUIVALENT: 278,
-  LOGIC_IMPLICATION: 279,
-  LOGIC_OR: 280,
-  LOGIC_AND: 281,
-  // Set theory predicate symbols
-  SET_IN: 282,
-  SET_NOT_IN: 283,
-  SUBSET: 284,
-  SUBSET_OR_EQ: 285,
-  NOT_SUBSET: 286,
-  // Set theory operators
-  DECART: 287,
-  SET_UNION: 288,
-  SET_INTERSECTION: 289,
-  SET_MINUS: 290,
-  SET_SYMMETRIC_MINUS: 291,
-  BOOLEAN: 292,
-  // Structure operations
-  BIGPR: 293,
-  SMALLPR: 294,
-  FILTER: 295,
-  CARD: 296,
-  BOOL: 297,
-  DEBOOL: 298,
-  REDUCE: 299,
-  // Term constructions prefixes
-  DECLARATIVE: 300,
-  RECURSIVE: 301,
-  IMPERATIVE: 302,
-  ITERATE: 303,
-  ASSIGN: 304,
-  // Punctuation
-  PUNCTUATION_DEFINE: 305,
-  PUNCTUATION_STRUCT: 306,
-  PUNCTUATION_PL: 307,
-  PUNCTUATION_PR: 308,
-  PUNCTUATION_CL: 309,
-  PUNCTUATION_CR: 310,
-  PUNCTUATION_SL: 311,
-  PUNCTUATION_SR: 312,
-  PUNCTUATION_BAR: 313,
-  PUNCTUATION_COMMA: 314,
-  PUNCTUATION_SEMICOLON: 315,
-  // ======= Non-terminal tokens =========
-  NT_ENUM_DECL: 316,
-  NT_TUPLE: 317,
-  NT_ENUMERATION: 318,
-  NT_TUPLE_DECL: 319,
-  NT_ARG_DECL: 320,
-  NT_FUNC_DEFINITION: 321,
-  NT_ARGUMENTS: 322,
-  NT_FUNC_CALL: 323,
-  NT_DECLARATIVE_EXPR: 324,
-  NT_IMPERATIVE_EXPR: 325,
-  NT_RECURSIVE_FULL: 326,
-  NT_RECURSIVE_SHORT: 327,
-  // ======= Helper tokens ========
-  INTERRUPT: 328,
-  END: 329
-};
-
-// src/rslang/api.ts
-var GLOBALS_REGEXP = /[XCSADFPTN]\d+/g;
-var TYPIFICATION_SET = /^ℬ+\([ℬ\(((X|C)\d+|Z)\)×]*\)$/g;
-function isSetTypification(text) {
-  return !!text.match(TYPIFICATION_SET);
-}
-function applyAliasMapping(target, mapping) {
-  return applyPattern(target, mapping, GLOBALS_REGEXP);
-}
-function applyTypificationMapping(target, mapping) {
-  const modified = applyAliasMapping(target, mapping);
-  if (modified === target) {
-    return target;
-  }
-  const deleteBrackets = [];
-  const positions = [];
-  const booleans = [];
-  let boolCount = 0;
-  let stackSize = 0;
-  for (let i = 0; i < modified.length; i++) {
-    const char = modified[i];
-    if (char === "\u212C") {
-      boolCount++;
-      continue;
-    }
-    if (char === "(") {
-      stackSize++;
-      positions.push(i);
-      booleans.push(boolCount);
-    }
-    boolCount = 0;
-    if (char === ")") {
-      if (i < modified.length - 1 && modified[i + 1] === ")" && stackSize > 1 && positions[stackSize - 2] + booleans[stackSize - 1] + 1 === positions[stackSize - 1]) {
-        deleteBrackets.push(i);
-        deleteBrackets.push(positions[stackSize - 2]);
-      }
-      if (i === modified.length - 1 && stackSize === 1 && positions[0] === 0) {
-        deleteBrackets.push(i);
-        deleteBrackets.push(positions[0]);
-      }
-      stackSize--;
-      positions.pop();
-      booleans.pop();
-    }
-  }
-  let result = "";
-  for (let i = 0; i < modified.length; i++) {
-    if (!deleteBrackets.includes(i)) {
-      result += modified[i];
-    }
-  }
-  return result;
-}
-function applyPattern(text, mapping, pattern) {
-  if (text === "" || pattern === null) {
-    return text;
-  }
-  let posInput = 0;
-  let output = "";
-  const patternMatches = text.matchAll(pattern);
-  for (const segment of patternMatches) {
-    const entity = segment[0];
-    const start = segment.index ?? 0;
-    if (entity in mapping) {
-      output += text.substring(posInput, start);
-      output += mapping[entity];
-      posInput = start + segment[0].length;
-    }
-  }
-  output += text.substring(posInput);
-  return output;
-}
-
-// src/rslang/semantic/typification.ts
-var TypeID = {
-  anyTypification: 1,
-  integer: 2,
-  basic: 3,
-  tuple: 4,
-  collection: 5,
-  logic: 6,
-  function: 7,
-  predicate: 8
-};
-var TypeClass = {
-  logic: 1,
-  typification: 2,
-  function: 3,
-  predicate: 4
-};
-var LogicT = { typeID: TypeID.logic };
-var IntegerT = {
-  typeID: TypeID.integer,
-  isOrdered: true,
-  isArithmetic: true,
-  isIntegerCompatible: true
-};
-var AnyTypificationT = { typeID: TypeID.anyTypification };
-var EmptySetT = bool(AnyTypificationT);
-function bool(base) {
-  return { typeID: TypeID.collection, base };
-}
-
-// src/rslang/labels.ts
-var INTEGER_TYPE_NAME = "Z";
-var ANY_TYPE_NAME = "R0";
-var LOGIC_TYPE_NAME = "Logic";
-var labelTokenRecord = {
-  [TokenID.DECART]: "\xD7",
-  [TokenID.PUNCTUATION_PL]: "( )",
-  [TokenID.PUNCTUATION_SL]: "[ ]",
-  [TokenID.QUANTOR_UNIVERSAL]: "\u2200",
-  [TokenID.QUANTOR_EXISTS]: "\u2203",
-  [TokenID.LOGIC_NOT]: "\xAC",
-  [TokenID.LOGIC_AND]: "&",
-  [TokenID.LOGIC_OR]: "\u2228",
-  [TokenID.LOGIC_IMPLICATION]: "\u21D2",
-  [TokenID.LOGIC_EQUIVALENT]: "\u21D4",
-  [TokenID.LIT_EMPTYSET]: "\u2205",
-  [TokenID.LIT_WHOLE_NUMBERS]: "Z",
-  [TokenID.MULTIPLY]: "*",
-  [TokenID.EQUAL]: "=",
-  [TokenID.NOTEQUAL]: "\u2260",
-  [TokenID.GREATER_OR_EQ]: "\u2265",
-  [TokenID.LESSER_OR_EQ]: "\u2264",
-  [TokenID.SET_IN]: "\u2208",
-  [TokenID.SET_NOT_IN]: "\u2209",
-  [TokenID.SUBSET_OR_EQ]: "\u2286",
-  [TokenID.SUBSET]: "\u2282",
-  [TokenID.NOT_SUBSET]: "\u2284",
-  [TokenID.SET_INTERSECTION]: "\u2229",
-  [TokenID.SET_UNION]: "\u222A",
-  [TokenID.SET_MINUS]: "\\",
-  [TokenID.SET_SYMMETRIC_MINUS]: "\u2206",
-  [TokenID.BOOLEAN]: "\u212C()",
-  [TokenID.NT_DECLARATIVE_EXPR]: "D{}",
-  [TokenID.NT_IMPERATIVE_EXPR]: "I{}",
-  [TokenID.NT_RECURSIVE_FULL]: "R{}",
-  [TokenID.BIGPR]: "Pr1()",
-  [TokenID.SMALLPR]: "pr1()",
-  [TokenID.FILTER]: "Fi1[]()",
-  [TokenID.REDUCE]: "red()",
-  [TokenID.CARD]: "card()",
-  [TokenID.BOOL]: "bool()",
-  [TokenID.DEBOOL]: "debool()",
-  [TokenID.ASSIGN]: ":=",
-  [TokenID.ITERATE]: ":\u2208"
-};
-function labelType(type) {
-  if (!type) {
-    return "N/A";
-  }
-  switch (type.typeID) {
-    case TypeID.anyTypification:
-      return ANY_TYPE_NAME;
-    case TypeID.integer:
-      return INTEGER_TYPE_NAME;
-    case TypeID.basic:
-      return type.baseID;
-    case TypeID.tuple:
-      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)).join("\xD7");
-    case TypeID.collection:
-      return type.base.typeID === TypeID.collection ? `\u212C${labelType(type.base)}` : `\u212C(${labelType(type.base)})`;
-    case TypeID.logic:
-      return LOGIC_TYPE_NAME;
-    case TypeID.predicate:
-    case TypeID.function:
-      const argsText = type.args.map((arg) => labelType(arg.type)).join(", ");
-      return `[${argsText}] \u2192 ${labelType(type.result)}`;
-  }
-}
-
-// src/rslang/semantic/typification-api.ts
-var TypeIDToClass = {
-  [TypeID.anyTypification]: TypeClass.typification,
-  [TypeID.integer]: TypeClass.typification,
-  [TypeID.basic]: TypeClass.typification,
-  [TypeID.tuple]: TypeClass.typification,
-  [TypeID.collection]: TypeClass.typification,
-  [TypeID.logic]: TypeClass.logic,
-  [TypeID.function]: TypeClass.function,
-  [TypeID.predicate]: TypeClass.predicate
-};
-function extractBases(target) {
-  return new Set(extractBasesImpl(target));
-}
-function extractBasesImpl(target) {
-  switch (target.typeID) {
-    case TypeID.basic:
-      return [target.baseID];
-    case TypeID.collection:
-      return extractBasesImpl(target.base);
-    case TypeID.tuple:
-      return target.factors.reduce((result2, factor) => result2.concat(extractBasesImpl(factor)), []);
-    case TypeID.function:
-      const result = extractBasesImpl(target.result);
-      return target.args.reduce((result2, arg) => result2.concat(extractBasesImpl(arg.type)), result);
-    case TypeID.predicate:
-      return target.args.reduce((result2, arg) => result2.concat(extractBasesImpl(arg.type)), []);
-    default:
-      return [];
-  }
-}
-
-// src/library/oss.ts
-var NodeType = {
-  OPERATION: 1,
-  BLOCK: 2
-};
-var SubstitutionErrorType = {
-  invalidIDs: 0,
-  incorrectCst: 1,
-  invalidClasses: 2,
-  invalidBasic: 3,
-  invalidConstant: 4,
-  typificationCycle: 5,
-  baseSubstitutionNotSet: 6,
-  unequalTypification: 7,
-  unequalExpressions: 8,
-  unequalArgsCount: 9,
-  unequalArgs: 10,
-  invalidNominal: 11
-};
-
-// src/library/rsform.ts
-var CstType = {
-  NOMINAL: "nominal",
-  BASE: "basic",
-  STRUCTURED: "structure",
-  TERM: "term",
-  AXIOM: "axiom",
-  FUNCTION: "function",
-  PREDICATE: "predicate",
-  CONSTANT: "constant",
-  STATEMENT: "statement"
-};
-var CstClass = {
-  NOMINAL: "nominal",
-  BASIC: "basic",
-  DERIVED: "derived",
-  STATEMENT: "statement",
-  TEMPLATE: "template"
-};
-
-// src/library/oss-api.ts
-var STARTING_SUB_INDEX = 900;
+import { Graph } from "../graph/graph.js";
+import { NodeType, SubstitutionErrorType } from "./oss.js";
+import { labelType } from "../rslang/labels.js";
+import { extractBases } from "../rslang/semantic/typification-api.js";
+import { CstClass, CstType } from "./rsform.js";
+import { applyAliasMapping, applyTypificationMapping, isSetTypification } from "../rslang/api.js";
+import "../graph/index.js";
+//#region src/library/oss-api.ts
+/**
+* Module: API for OperationSystem.
+*/
+const STARTING_SUB_INDEX = 900;
 function constructNodeID(type, itemID) {
-  return type === NodeType.OPERATION ? "o" + String(itemID) : "b" + String(itemID);
+	return type === NodeType.OPERATION ? "o" + String(itemID) : "b" + String(itemID);
 }
+/** Sorts library items relevant for the specified {@link OperationSchema}. */
 function sortItemsForOSS(oss, items) {
-  const result = items.filter((item) => item.location === oss.location);
-  for (const item of items) {
-    if (item.visible && item.owner === oss.owner && !result.includes(item)) {
-      result.push(item);
-    }
-  }
-  for (const item of items) {
-    if (item.visible && !result.includes(item)) {
-      result.push(item);
-    }
-  }
-  for (const item of items) {
-    if (!result.includes(item)) {
-      result.push(item);
-    }
-  }
-  return result;
+	const result = items.filter((item) => item.location === oss.location);
+	for (const item of items) if (item.visible && item.owner === oss.owner && !result.includes(item)) result.push(item);
+	for (const item of items) if (item.visible && !result.includes(item)) result.push(item);
+	for (const item of items) if (!result.includes(item)) result.push(item);
+	return result;
 }
+/** Validator for Substitution table. */
 var SubstitutionValidator = class {
-  errors = [];
-  suggestions = [];
-  schemas;
-  substitutions;
-  constituents = /* @__PURE__ */ new Set();
-  originals = /* @__PURE__ */ new Set();
-  mapping = /* @__PURE__ */ new Map();
-  cstByID = /* @__PURE__ */ new Map();
-  schemaByID = /* @__PURE__ */ new Map();
-  schemaByCst = /* @__PURE__ */ new Map();
-  constructor(schemas, substitutions) {
-    this.schemas = schemas;
-    this.substitutions = substitutions;
-    if (schemas.length === 0 || substitutions.length === 0) {
-      return;
-    }
-    for (const schema of schemas) {
-      this.schemaByID.set(schema.id, schema);
-      this.mapping.set(schema.id, {});
-      for (const item of schema.items) {
-        this.cstByID.set(item.id, item);
-        this.schemaByCst.set(item.id, schema);
-      }
-    }
-    let index = STARTING_SUB_INDEX;
-    for (const item of substitutions) {
-      this.constituents.add(item.original);
-      this.constituents.add(item.substitution);
-      this.originals.add(item.original);
-      const original = this.cstByID.get(item.original);
-      const substitution = this.cstByID.get(item.substitution);
-      if (!original || !substitution) {
-        return;
-      }
-      index++;
-      const newAlias = `${substitution.alias[0]}${index}`;
-      this.mapping.get(original.schema)[original.alias] = newAlias;
-      this.mapping.get(substitution.schema)[substitution.alias] = newAlias;
-    }
-  }
-  validate() {
-    this.errors = [];
-    this.suggestions = [];
-    this.calculateSuggestions();
-    if (this.substitutions.length === 0) {
-      return true;
-    }
-    if (!this.checkTypes()) {
-      return false;
-    }
-    if (!this.checkCycles()) {
-      return false;
-    }
-    if (!this.checkSubstitutions()) {
-      return false;
-    }
-    return true;
-  }
-  calculateSuggestions() {
-    const candidates = /* @__PURE__ */ new Map();
-    const minors = /* @__PURE__ */ new Set();
-    const schemaByCst = /* @__PURE__ */ new Map();
-    for (const schema of this.schemas) {
-      for (const cst of schema.items) {
-        if (this.originals.has(cst.id)) {
-          continue;
-        }
-        if (cst.cst_class === CstClass.BASIC || cst.definition_formal.length === 0) {
-          continue;
-        }
-        const inputs = schema.graph.at(cst.id).inputs;
-        if (inputs.some((id) => !this.constituents.has(id))) {
-          continue;
-        }
-        if (inputs.some((id) => this.originals.has(id))) {
-          minors.add(cst.id);
-        }
-        candidates.set(cst.id, applyAliasMapping(cst.definition_formal, this.mapping.get(schema.id)).replace(" ", ""));
-        schemaByCst.set(cst.id, schema);
-      }
-    }
-    for (const [key1, value1] of candidates) {
-      for (const [key2, value2] of candidates) {
-        if (key1 >= key2) {
-          continue;
-        }
-        if (schemaByCst.get(key1) === schemaByCst.get(key2)) {
-          continue;
-        }
-        if (value1 != value2) {
-          continue;
-        }
-        if (minors.has(key2)) {
-          this.suggestions.push({
-            original: key2,
-            substitution: key1
-          });
-        } else {
-          this.suggestions.push({
-            original: key1,
-            substitution: key2
-          });
-        }
-      }
-    }
-  }
-  checkTypes() {
-    for (const item of this.substitutions) {
-      const original = this.cstByID.get(item.original);
-      const substitution = this.cstByID.get(item.substitution);
-      if (!original || !substitution) {
-        return this.reportError(SubstitutionErrorType.invalidIDs, []);
-      }
-      if (substitution.analysis && original.analysis && (!original.analysis.success || !substitution.analysis.success)) {
-        return this.reportError(SubstitutionErrorType.incorrectCst, [substitution.alias, original.alias]);
-      }
-      switch (substitution.cst_type) {
-        case CstType.NOMINAL: {
-          if (original.cst_type !== CstType.NOMINAL) {
-            return this.reportError(SubstitutionErrorType.invalidNominal, [substitution.alias, original.alias]);
-          }
-          break;
-        }
-        case CstType.BASE: {
-          if (original.cst_type !== CstType.BASE && original.cst_type !== CstType.CONSTANT && original.cst_type !== CstType.NOMINAL) {
-            return this.reportError(SubstitutionErrorType.invalidBasic, [substitution.alias, original.alias]);
-          }
-          break;
-        }
-        case CstType.CONSTANT: {
-          if (original.cst_type !== CstType.CONSTANT) {
-            return this.reportError(SubstitutionErrorType.invalidConstant, [substitution.alias, original.alias]);
-          }
-          break;
-        }
-        case CstType.AXIOM:
-        case CstType.STATEMENT: {
-          if (original.cst_type !== CstType.AXIOM && original.cst_type !== CstType.STATEMENT) {
-            return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
-          }
-          break;
-        }
-        case CstType.FUNCTION: {
-          if (original.cst_type !== CstType.FUNCTION) {
-            return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
-          }
-          break;
-        }
-        case CstType.PREDICATE: {
-          if (original.cst_type !== CstType.PREDICATE) {
-            return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
-          }
-          break;
-        }
-        case CstType.TERM:
-        case CstType.STRUCTURED: {
-          if (original.cst_type !== CstType.TERM && original.cst_type !== CstType.STRUCTURED && original.cst_type !== CstType.BASE) {
-            return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
-          }
-          break;
-        }
-      }
-    }
-    return true;
-  }
-  checkCycles() {
-    const graph = new Graph();
-    for (const schema of this.schemas) {
-      for (const cst of schema.items) {
-        if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT) {
-          graph.addNode(cst.id);
-        }
-      }
-    }
-    for (const item of this.substitutions) {
-      const original = this.cstByID.get(item.original);
-      const substitution = this.cstByID.get(item.substitution);
-      for (const cst of [original, substitution]) {
-        if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT) {
-          continue;
-        }
-        graph.addNode(cst.id);
-        if (cst.effectiveType === null) {
-          continue;
-        }
-        const parents = extractBases(cst.effectiveType);
-        if (parents.size === 0) {
-          continue;
-        }
-        const schema = this.schemaByID.get(cst.schema);
-        for (const alias of parents) {
-          const parent = schema.cstByAlias.get(alias);
-          if (parent) {
-            graph.addEdge(parent.id, cst.id);
-          }
-        }
-      }
-      graph.addEdge(substitution.id, original.id);
-    }
-    const cycle = graph.findCycle();
-    if (cycle !== null) {
-      const cycleMsg = cycle.map((id) => {
-        const cst = this.cstByID.get(id);
-        const schema = this.schemaByID.get(cst.schema);
-        return `[${schema.alias}]-${cst.alias}`;
-      }).join(", ");
-      return this.reportError(SubstitutionErrorType.typificationCycle, [cycleMsg]);
-    }
-    return true;
-  }
-  checkSubstitutions() {
-    const baseMappings = this.prepareBaseMappings();
-    const typeMappings = this.calculateSubstituteMappings(baseMappings);
-    if (typeMappings === null) {
-      return false;
-    }
-    for (const item of this.substitutions) {
-      const original = this.cstByID.get(item.original);
-      if (original.cst_type === CstType.BASE || original.cst_type === CstType.CONSTANT || original.cst_type === CstType.NOMINAL) {
-        continue;
-      }
-      const substitution = this.cstByID.get(item.substitution);
-      if (original.cst_type === substitution.cst_type && original.cst_class !== CstClass.BASIC) {
-        if (!this.checkEqual(original, substitution)) {
-          this.reportError(SubstitutionErrorType.unequalExpressions, [substitution.alias, original.alias]);
-        }
-      }
-      if (original.analysis.success !== substitution.analysis.success) {
-        return this.reportError(SubstitutionErrorType.unequalTypification, [substitution.alias, original.alias]);
-      }
-      if (!original.analysis.success || !substitution.analysis.success) {
-        continue;
-      }
-      const originalType = applyTypificationMapping(
-        applyAliasMapping(labelType(original.effectiveType), baseMappings.get(original.schema)),
-        typeMappings
-      );
-      const substitutionType = applyTypificationMapping(
-        applyAliasMapping(labelType(substitution.effectiveType), baseMappings.get(substitution.schema)),
-        typeMappings
-      );
-      if (originalType !== substitutionType) {
-        return this.reportError(SubstitutionErrorType.unequalTypification, [substitution.alias, original.alias]);
-      }
-    }
-    return true;
-  }
-  prepareBaseMappings() {
-    const result = /* @__PURE__ */ new Map();
-    let baseCount = 0;
-    let constCount = 0;
-    for (const schema of this.schemas) {
-      const mapping = {};
-      for (const cst of schema.items) {
-        if (cst.cst_type === CstType.BASE) {
-          baseCount++;
-          mapping[cst.alias] = `X${baseCount}`;
-        } else if (cst.cst_type === CstType.CONSTANT) {
-          constCount++;
-          mapping[cst.alias] = `C${constCount}`;
-        }
-        result.set(schema.id, mapping);
-      }
-    }
-    return result;
-  }
-  calculateSubstituteMappings(baseMappings) {
-    const result = {};
-    const processed = /* @__PURE__ */ new Set();
-    for (const item of this.substitutions) {
-      const original = this.cstByID.get(item.original);
-      if (original.cst_type !== CstType.BASE && original.cst_type !== CstType.CONSTANT) {
-        continue;
-      }
-      const originalAlias = baseMappings.get(original.schema)[original.alias];
-      const substitution = this.cstByID.get(item.substitution);
-      let substitutionText = "";
-      if (substitution.cst_type === original.cst_type || !substitution.effectiveType) {
-        substitutionText = baseMappings.get(substitution.schema)[substitution.alias];
-      } else {
-        const typeText = labelType(substitution.effectiveType);
-        substitutionText = applyAliasMapping(typeText, baseMappings.get(substitution.schema));
-        substitutionText = applyTypificationMapping(substitutionText, result);
-        if (!isSetTypification(substitutionText)) {
-          this.reportError(SubstitutionErrorType.baseSubstitutionNotSet, [substitution.alias, typeText]);
-          return null;
-        }
-        if (substitutionText.includes("\xD7") || substitutionText.startsWith("\u212C\u212C")) {
-          substitutionText = substitutionText.slice(1);
-        } else {
-          substitutionText = substitutionText.slice(2, -1);
-        }
-      }
-      for (const prevAlias of processed) {
-        result[prevAlias] = applyTypificationMapping(result[prevAlias], { [originalAlias]: substitutionText });
-      }
-      result[originalAlias] = substitutionText;
-      processed.add(originalAlias);
-    }
-    return result;
-  }
-  checkEqual(left, right) {
-    const schema1 = this.schemaByID.get(left.schema);
-    const inputs1 = schema1.graph.at(left.id).inputs;
-    if (inputs1.some((id) => !this.constituents.has(id))) {
-      return false;
-    }
-    const schema2 = this.schemaByID.get(right.schema);
-    const inputs2 = schema2.graph.at(right.id).inputs;
-    if (inputs2.some((id) => !this.constituents.has(id))) {
-      return false;
-    }
-    const expression1 = applyAliasMapping(left.definition_formal, this.mapping.get(schema1.id));
-    const expression2 = applyAliasMapping(right.definition_formal, this.mapping.get(schema2.id));
-    return expression1.replace(" ", "") === expression2.replace(" ", "");
-  }
-  reportError(errorType, params) {
-    this.errors.push({
-      errorType,
-      params
-    });
-    return false;
-  }
+	errors = [];
+	suggestions = [];
+	schemas;
+	substitutions;
+	constituents = /* @__PURE__ */ new Set();
+	originals = /* @__PURE__ */ new Set();
+	mapping = /* @__PURE__ */ new Map();
+	cstByID = /* @__PURE__ */ new Map();
+	schemaByID = /* @__PURE__ */ new Map();
+	schemaByCst = /* @__PURE__ */ new Map();
+	constructor(schemas, substitutions) {
+		this.schemas = schemas;
+		this.substitutions = substitutions;
+		if (schemas.length === 0) return;
+		for (const schema of schemas) {
+			this.schemaByID.set(schema.id, schema);
+			this.mapping.set(schema.id, {});
+			for (const item of schema.items) {
+				this.cstByID.set(item.id, item);
+				this.schemaByCst.set(item.id, schema);
+			}
+		}
+		if (substitutions.length === 0) return;
+		let index = STARTING_SUB_INDEX;
+		for (const item of substitutions) {
+			this.constituents.add(item.original);
+			this.constituents.add(item.substitution);
+			this.originals.add(item.original);
+			const original = this.cstByID.get(item.original);
+			const substitution = this.cstByID.get(item.substitution);
+			if (!original || !substitution) return;
+			index++;
+			const newAlias = `${substitution.alias[0]}${index}`;
+			this.mapping.get(original.schema)[original.alias] = newAlias;
+			this.mapping.get(substitution.schema)[substitution.alias] = newAlias;
+		}
+	}
+	validate() {
+		this.errors = [];
+		this.suggestions = [];
+		this.calculateSuggestions();
+		if (this.substitutions.length === 0) return true;
+		if (!this.checkTypes()) return false;
+		if (!this.checkCycles()) return false;
+		if (!this.checkSubstitutions()) return false;
+		return true;
+	}
+	calculateSuggestions() {
+		const candidates = /* @__PURE__ */ new Map();
+		const minors = /* @__PURE__ */ new Set();
+		const schemaByCst = /* @__PURE__ */ new Map();
+		for (const schema of this.schemas) for (const cst of schema.items) {
+			if (this.originals.has(cst.id)) continue;
+			if (cst.cst_class === CstClass.BASIC || cst.definition_formal.length === 0) continue;
+			const inputs = schema.graph.at(cst.id).inputs;
+			if (inputs.some((id) => !this.constituents.has(id))) continue;
+			if (inputs.some((id) => this.originals.has(id))) minors.add(cst.id);
+			candidates.set(cst.id, applyAliasMapping(cst.definition_formal, this.mapping.get(schema.id)).replace(" ", ""));
+			schemaByCst.set(cst.id, schema);
+		}
+		for (const [key1, value1] of candidates) for (const [key2, value2] of candidates) {
+			if (key1 >= key2) continue;
+			if (schemaByCst.get(key1) === schemaByCst.get(key2)) continue;
+			if (value1 != value2) continue;
+			if (minors.has(key2)) this.suggestions.push({
+				original: key2,
+				substitution: key1
+			});
+			else this.suggestions.push({
+				original: key1,
+				substitution: key2
+			});
+		}
+	}
+	checkTypes() {
+		for (const item of this.substitutions) {
+			const original = this.cstByID.get(item.original);
+			const substitution = this.cstByID.get(item.substitution);
+			if (!original || !substitution) return this.reportError(SubstitutionErrorType.invalidIDs, []);
+			if (substitution.analysis && original.analysis && (!original.analysis.success || !substitution.analysis.success)) return this.reportError(SubstitutionErrorType.incorrectCst, [substitution.alias, original.alias]);
+			switch (substitution.cst_type) {
+				case CstType.NOMINAL:
+					if (original.cst_type !== CstType.NOMINAL) return this.reportError(SubstitutionErrorType.invalidNominal, [substitution.alias, original.alias]);
+					break;
+				case CstType.BASE:
+					if (original.cst_type !== CstType.BASE && original.cst_type !== CstType.CONSTANT && original.cst_type !== CstType.NOMINAL) return this.reportError(SubstitutionErrorType.invalidBasic, [substitution.alias, original.alias]);
+					break;
+				case CstType.CONSTANT:
+					if (original.cst_type !== CstType.CONSTANT) return this.reportError(SubstitutionErrorType.invalidConstant, [substitution.alias, original.alias]);
+					break;
+				case CstType.AXIOM:
+				case CstType.STATEMENT:
+					if (original.cst_type !== CstType.AXIOM && original.cst_type !== CstType.STATEMENT) return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
+					break;
+				case CstType.FUNCTION:
+					if (original.cst_type !== CstType.FUNCTION) return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
+					break;
+				case CstType.PREDICATE:
+					if (original.cst_type !== CstType.PREDICATE) return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
+					break;
+				case CstType.TERM:
+				case CstType.STRUCTURED:
+					if (original.cst_type !== CstType.TERM && original.cst_type !== CstType.STRUCTURED && original.cst_type !== CstType.BASE) return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
+					break;
+			}
+		}
+		return true;
+	}
+	checkCycles() {
+		const graph = new Graph();
+		for (const schema of this.schemas) for (const cst of schema.items) if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT) graph.addNode(cst.id);
+		for (const item of this.substitutions) {
+			const original = this.cstByID.get(item.original);
+			const substitution = this.cstByID.get(item.substitution);
+			for (const cst of [original, substitution]) {
+				if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT) continue;
+				graph.addNode(cst.id);
+				if (cst.effectiveType === null) continue;
+				const parents = extractBases(cst.effectiveType);
+				if (parents.size === 0) continue;
+				const schema = this.schemaByID.get(cst.schema);
+				for (const alias of parents) {
+					const parent = schema.cstByAlias.get(alias);
+					if (parent) graph.addEdge(parent.id, cst.id);
+				}
+			}
+			graph.addEdge(substitution.id, original.id);
+		}
+		const cycle = graph.findCycle();
+		if (cycle !== null) {
+			const cycleMsg = cycle.map((id) => {
+				const cst = this.cstByID.get(id);
+				return `[${this.schemaByID.get(cst.schema).alias}]-${cst.alias}`;
+			}).join(", ");
+			return this.reportError(SubstitutionErrorType.typificationCycle, [cycleMsg]);
+		}
+		return true;
+	}
+	checkSubstitutions() {
+		const baseMappings = this.prepareBaseMappings();
+		const typeMappings = this.calculateSubstituteMappings(baseMappings);
+		if (typeMappings === null) return false;
+		for (const item of this.substitutions) {
+			const original = this.cstByID.get(item.original);
+			if (original.cst_type === CstType.BASE || original.cst_type === CstType.CONSTANT || original.cst_type === CstType.NOMINAL) continue;
+			const substitution = this.cstByID.get(item.substitution);
+			if (original.cst_type === substitution.cst_type && original.cst_class !== CstClass.BASIC) {
+				if (!this.checkEqual(original, substitution)) this.reportError(SubstitutionErrorType.unequalExpressions, [substitution.alias, original.alias]);
+			}
+			if (original.analysis.success !== substitution.analysis.success) return this.reportError(SubstitutionErrorType.unequalTypification, [substitution.alias, original.alias]);
+			if (!original.analysis.success || !substitution.analysis.success) continue;
+			if (applyTypificationMapping(applyAliasMapping(labelType(original.effectiveType), baseMappings.get(original.schema)), typeMappings) !== applyTypificationMapping(applyAliasMapping(labelType(substitution.effectiveType), baseMappings.get(substitution.schema)), typeMappings)) return this.reportError(SubstitutionErrorType.unequalTypification, [substitution.alias, original.alias]);
+		}
+		return true;
+	}
+	prepareBaseMappings() {
+		const result = /* @__PURE__ */ new Map();
+		let baseCount = 0;
+		let constCount = 0;
+		for (const schema of this.schemas) {
+			const mapping = {};
+			for (const cst of schema.items) {
+				if (cst.cst_type === CstType.BASE) {
+					baseCount++;
+					mapping[cst.alias] = `X${baseCount}`;
+				} else if (cst.cst_type === CstType.CONSTANT) {
+					constCount++;
+					mapping[cst.alias] = `C${constCount}`;
+				}
+				result.set(schema.id, mapping);
+			}
+		}
+		return result;
+	}
+	calculateSubstituteMappings(baseMappings) {
+		const result = {};
+		const processed = /* @__PURE__ */ new Set();
+		for (const item of this.substitutions) {
+			const original = this.cstByID.get(item.original);
+			if (original.cst_type !== CstType.BASE && original.cst_type !== CstType.CONSTANT) continue;
+			const originalAlias = baseMappings.get(original.schema)[original.alias];
+			const substitution = this.cstByID.get(item.substitution);
+			let substitutionText = "";
+			if (substitution.cst_type === original.cst_type || !substitution.effectiveType) substitutionText = baseMappings.get(substitution.schema)[substitution.alias];
+			else {
+				const typeText = labelType(substitution.effectiveType);
+				substitutionText = applyAliasMapping(typeText, baseMappings.get(substitution.schema));
+				substitutionText = applyTypificationMapping(substitutionText, result);
+				if (!isSetTypification(substitutionText)) {
+					this.reportError(SubstitutionErrorType.baseSubstitutionNotSet, [substitution.alias, typeText]);
+					return null;
+				}
+				if (substitutionText.includes("×") || substitutionText.startsWith("ℬℬ")) substitutionText = substitutionText.slice(1);
+				else substitutionText = substitutionText.slice(2, -1);
+			}
+			for (const prevAlias of processed) result[prevAlias] = applyTypificationMapping(result[prevAlias], { [originalAlias]: substitutionText });
+			result[originalAlias] = substitutionText;
+			processed.add(originalAlias);
+		}
+		return result;
+	}
+	checkEqual(left, right) {
+		const schema1 = this.schemaByID.get(left.schema);
+		if (schema1.graph.at(left.id).inputs.some((id) => !this.constituents.has(id))) return false;
+		const schema2 = this.schemaByID.get(right.schema);
+		if (schema2.graph.at(right.id).inputs.some((id) => !this.constituents.has(id))) return false;
+		const expression1 = applyAliasMapping(left.definition_formal, this.mapping.get(schema1.id));
+		const expression2 = applyAliasMapping(right.definition_formal, this.mapping.get(schema2.id));
+		return expression1.replace(" ", "") === expression2.replace(" ", "");
+	}
+	reportError(errorType, params) {
+		this.errors.push({
+			errorType,
+			params
+		});
+		return false;
+	}
 };
+/** Filter relocate candidates from gives schema. */
 function getRelocateCandidates(source, destination, schema, oss) {
-  const destinationSchema = oss.operationByID.get(destination)?.result;
-  if (!destinationSchema) {
-    return [];
-  }
-  const node = oss.graph.at(source);
-  if (!node) {
-    return [];
-  }
-  if (node.outputs.includes(destination)) {
-    return schema.items;
-  }
-  const addedCst = schema.items.filter((item) => !item.is_inherited).map((cst) => cst.id);
-  const unreachableBases = [];
-  for (const cst of schema.items.filter((item) => item.is_inherited)) {
-    if (cst.parent_schema == destinationSchema) {
-      continue;
-    }
-    const parent = schema.inheritance.find((item) => item.child === cst.id && item.child_source === cst.schema)?.parent;
-    if (parent) {
-      const original = oss.substitutions.find((sub) => sub.substitution === parent)?.original;
-      if (original) {
-        continue;
-      }
-    }
-    unreachableBases.push(cst.id);
-  }
-  const unreachable = schema.graph.expandAllOutputs(unreachableBases);
-  return schema.items.filter(
-    (cst) => cst.parent_schema === destinationSchema || addedCst.includes(cst.id) && !unreachable.includes(cst.id)
-  );
+	const destinationSchema = oss.operationByID.get(destination)?.result;
+	if (!destinationSchema) return [];
+	const node = oss.graph.at(source);
+	if (!node) return [];
+	if (node.outputs.includes(destination)) return schema.items;
+	const addedCst = schema.items.filter((item) => !item.is_inherited).map((cst) => cst.id);
+	const unreachableBases = [];
+	for (const cst of schema.items.filter((item) => item.is_inherited)) {
+		if (cst.parent_schema == destinationSchema) continue;
+		const parent = schema.inheritance.find((item) => item.child === cst.id && item.child_source === cst.schema)?.parent;
+		if (parent) {
+			if (oss.substitutions.find((sub) => sub.substitution === parent)?.original) continue;
+		}
+		unreachableBases.push(cst.id);
+	}
+	const unreachable = schema.graph.expandAllOutputs(unreachableBases);
+	return schema.items.filter((cst) => cst.parent_schema === destinationSchema || addedCst.includes(cst.id) && !unreachable.includes(cst.id));
 }
-export {
-  SubstitutionValidator,
-  constructNodeID,
-  getRelocateCandidates,
-  sortItemsForOSS
-};
+//#endregion
+export { SubstitutionValidator, constructNodeID, getRelocateCandidates, sortItemsForOSS };
+
 //# sourceMappingURL=oss-api.js.map