@rsconcept/domain 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IRBorisov and Concept Portal contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# @rsconcept/domain
+
+Shared TypeScript domain layer for the [Concept Portal](https://portal.acconcept.ru) stack.
+
+This package implements the formal language **RSLang**, the schema model **RSForm**, the evaluation engine **RSEngine**, the operation-of-schemas model **OSS**, and supporting helpers (graphs, parsing utilities, concept-text grammemes). It is consumed both by the Portal frontend and by [`@rsconcept/rstool`](https://www.npmjs.com/package/@rsconcept/rstool).
+
+## Install
+
+```bash
+npm install @rsconcept/domain
+```
+
+## Subpath exports
+
+```ts
+import { RSLangAnalyzer, RSErrorCode } from '@rsconcept/domain/rslang';
+import { CstType, type RSForm } from '@rsconcept/domain/library/rsform';
+import { Graph } from '@rsconcept/domain/graph';
+import { buildTree, type AstNode } from '@rsconcept/domain/parsing';
+```
+
+The root entry (`@rsconcept/domain`) re-exports the most common names. Subpath imports are recommended for tree-shaking and to make dependency graphs explicit.
+
+## Contents
+
+| Subpath   | Surface                                                                                        |
+| --------- | ---------------------------------------------------------------------------------------------- |
+| `rslang`  | Lezer parser, semantic analyzer, evaluator, calculator, type system, value system, error codes |
+| `library` | `RSForm`, `RSModel`, `RSEngine`, OSS, library item metadata, structure planner                 |
+| `graph`   | Generic directed-graph utilities used for dependency tracking                                  |
+| `parsing` | Lezer AST helpers shared by all parsers                                                        |
+| `cctext`  | Russian/multilingual grammemes for concept-text references                                     |
+| `shared`  | `Branded<T>` types, FNV-1a hash, stub id generation                                            |
+
+## Build
+
+```bash
+npm run generate    # regenerates Lezer parser from rslang.grammar
+npm run build       # produces ./dist via tsup
+npm test            # vitest run
+npm run typecheck   # tsc --noEmit
+npm run lint        # ESLint (TypeScript; same core rules as frontend, no React)
+npm run lintFix     # ESLint --fix
+npm run format:check
+```
+
+After editing `src/rslang/parser/rslang.grammar`, always run `npm run generate` before committing.
+
+## Server-side mirrors
+
+Some helpers in this package are duplicated in the Concept Portal Django backend (`api_RSLanguage.py`, `graph.py`, `SemanticInfo.py`). Those Python mirrors implement a narrow subset for ORM-level operations and are maintained separately. Parsing and evaluation only run in TypeScript.
+
+## License
+
+MIT

package/dist/cctext/index.d.ts

@@ -0,0 +1 @@
+export { EntityReference, Grammeme, ReferenceType, SyntacticReference, TermContext, WordForm, supportedGrammemes } from './language.js';

package/dist/cctext/index.js

@@ -0,0 +1,42 @@
+// src/cctext/language.ts
+var Grammeme = {
+  // Число
+  sing: "sing",
+  plur: "plur",
+  // Падеж
+  nomn: "nomn",
+  gent: "gent",
+  datv: "datv",
+  accs: "accs",
+  ablt: "ablt",
+  loct: "loct"
+};
+var Case = [
+  Grammeme.nomn,
+  Grammeme.gent,
+  Grammeme.datv,
+  Grammeme.accs,
+  Grammeme.ablt,
+  Grammeme.loct
+];
+var Plurality = [Grammeme.sing, Grammeme.plur];
+var supportedGrammemes = [
+  Grammeme.sing,
+  Grammeme.plur,
+  Grammeme.nomn,
+  Grammeme.gent,
+  Grammeme.datv,
+  Grammeme.accs,
+  Grammeme.ablt,
+  Grammeme.loct
+];
+var ReferenceType = {
+  ENTITY: "entity",
+  SYNTACTIC: "syntax"
+};
+export {
+  Grammeme,
+  ReferenceType,
+  supportedGrammemes
+};
+//# sourceMappingURL=index.js.map

package/dist/cctext/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cctext/language.ts"],"sourcesContent":["/**\n * Module: Natural language model declarations.\n */\n\n/** Represents single unit of language Morphology. */\n// prettier-ignore\nexport const Grammeme = {\n  // Число\n  sing: 'sing', plur: 'plur',\n\n  // Падеж\n  nomn: 'nomn', gent: 'gent', datv: 'datv',\n  accs: 'accs', ablt: 'ablt', loct: 'loct',\n} as const;\nexport type Grammeme = (typeof Grammeme)[keyof typeof Grammeme];\n\n/** Represents case language concept. */\nexport const Case: Grammeme[] = [\n  Grammeme.nomn,\n  Grammeme.gent,\n  Grammeme.datv,\n  Grammeme.accs,\n  Grammeme.ablt,\n  Grammeme.loct\n] as const;\n\n/** Represents plurality language concept. */\nexport const Plurality: Grammeme[] = [Grammeme.sing, Grammeme.plur] as const;\n\n/** Represents specific wordform attached to {@link Grammeme}s. */\nexport interface WordForm {\n  text: string;\n  grams: Grammeme[];\n}\n\n/** Represents a term available for text reference resolution. */\nexport interface TermContextItem {\n  nominal: string;\n  forms?: WordForm[];\n}\n\n/** Represents term lookup context keyed by entity alias. */\nexport type TermContext = Record<string, TermContextItem>;\n\n/**\n * Represents list of {@link Grammeme}s available in reference construction.\n */\n// prettier-ignore\nexport const supportedGrammemes = [\n  Grammeme.sing, Grammeme.plur,\n  Grammeme.nomn, Grammeme.gent, Grammeme.datv,\n  Grammeme.accs, Grammeme.ablt, Grammeme.loct,\n] as const;\n\n// ====== Reference resolution =====\n\n/** Represents text reference type. */\nexport const ReferenceType = {\n  ENTITY: 'entity',\n  SYNTACTIC: 'syntax'\n} as const;\nexport type ReferenceType = (typeof ReferenceType)[keyof typeof ReferenceType];\n\n/** Represents entity reference payload. */\nexport interface EntityReference {\n  entity: string;\n  tags: Grammeme[];\n}\n\n/** Represents syntactic reference payload. */\nexport interface SyntacticReference {\n  offset: number;\n  nominal: string;\n}\n\n/** Represents abstract reference data. */\nexport interface IReference {\n  type: ReferenceType;\n  data: EntityReference | SyntacticReference;\n}\n"],"mappings":";AAMO,IAAM,WAAW;AAAA;AAAA,EAEtB,MAAM;AAAA,EAAQ,MAAM;AAAA;AAAA,EAGpB,MAAM;AAAA,EAAQ,MAAM;AAAA,EAAQ,MAAM;AAAA,EAClC,MAAM;AAAA,EAAQ,MAAM;AAAA,EAAQ,MAAM;AACpC;AAIO,IAAM,OAAmB;AAAA,EAC9B,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AACX;AAGO,IAAM,YAAwB,CAAC,SAAS,MAAM,SAAS,IAAI;AAqB3D,IAAM,qBAAqB;AAAA,EAChC,SAAS;AAAA,EAAM,SAAS;AAAA,EACxB,SAAS;AAAA,EAAM,SAAS;AAAA,EAAM,SAAS;AAAA,EACvC,SAAS;AAAA,EAAM,SAAS;AAAA,EAAM,SAAS;AACzC;AAKO,IAAM,gBAAgB;AAAA,EAC3B,QAAQ;AAAA,EACR,WAAW;AACb;","names":[]}

package/dist/cctext/language-api.d.ts

@@ -0,0 +1,43 @@
+import { EntityReference, Grammeme, IReference, SyntacticReference, TermContext, WordForm } from './language.js';
+
+/**
+ * Module: Natural language model API.
+ */
+
+/** Represents generated lexeme forms. */
+interface Lexeme {
+    items: {
+        text: string;
+        grams: string;
+    }[];
+}
+/** Equality comparator for {@link WordForm}. Compares a set of Grammemes attached to wordforms. */
+declare function wordFormEquals(left: WordForm, right: WordForm): boolean;
+/** Transforms {@link Grammeme} enumeration to {@link Grammeme}. */
+declare function parseGrammemes(termForm: string): Grammeme[];
+/** Generates all supported noun forms using nominal text for every form. */
+declare function generateNominalLexeme(data: {
+    text: string;
+}): Lexeme;
+/**
+ * Extracts {@link EntityReference} from string representation.
+ *
+ * @param text - Reference text in a valid pattern. Must fit format '\@\{GLOBAL_ID|GRAMMEMES\}'
+ */
+declare function parseEntityReference(text: string): EntityReference;
+/**
+ * Extracts {@link SyntacticReference} from string representation.
+ *
+ * @param text - Reference text in a valid pattern. Must fit format '\@\{OFFSET|NOMINAL_FORM\}'
+ */
+declare function parseSyntacticReference(text: string): SyntacticReference;
+/** Extracts a validated reference from string representation. */
+declare function parseReference(text: string): IReference | null;
+/** Extracts unique entity aliases referenced by text. */
+declare function extractEntities(text: string): string[];
+/** Resolves text references using nominal terms and optional manually edited forms. */
+declare function resolveTextReferences(text: string, context: TermContext): string;
+/** Transforms {@link IReference} to string representation. */
+declare function referenceToString(ref: IReference): string;
+
+export { type Lexeme, extractEntities, generateNominalLexeme, parseEntityReference, parseGrammemes, parseReference, parseSyntacticReference, referenceToString, resolveTextReferences, wordFormEquals };

package/dist/cctext/language-api.js

@@ -0,0 +1,252 @@
+// src/cctext/language.ts
+var Grammeme = {
+  // Число
+  sing: "sing",
+  plur: "plur",
+  // Падеж
+  nomn: "nomn",
+  gent: "gent",
+  datv: "datv",
+  accs: "accs",
+  ablt: "ablt",
+  loct: "loct"
+};
+var Case = [
+  Grammeme.nomn,
+  Grammeme.gent,
+  Grammeme.datv,
+  Grammeme.accs,
+  Grammeme.ablt,
+  Grammeme.loct
+];
+var Plurality = [Grammeme.sing, Grammeme.plur];
+var supportedGrammemes = [
+  Grammeme.sing,
+  Grammeme.plur,
+  Grammeme.nomn,
+  Grammeme.gent,
+  Grammeme.datv,
+  Grammeme.accs,
+  Grammeme.ablt,
+  Grammeme.loct
+];
+var ReferenceType = {
+  ENTITY: "entity",
+  SYNTACTIC: "syntax"
+};
+
+// src/cctext/language-api.ts
+var REFERENCE_PATTERN = /@{[^{}]*?}/g;
+var ENTITY_REFERENCE_PATTERN = /@{([^0-9\-][^}|{]*?)\|([^}|{]*?)}/g;
+function wordFormEquals(left, right) {
+  if (left.grams.length !== right.grams.length) {
+    return false;
+  }
+  for (let index = 0; index < left.grams.length; ++index) {
+    if (left.grams[index] !== right.grams[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function parseGrammemes(termForm) {
+  const result = [];
+  for (const chunk of termForm.split(",")) {
+    const gram = chunk.trim();
+    if (gram !== "") {
+      result.push(gram);
+    }
+  }
+  return result.sort(grammemeCompare);
+}
+function generateNominalLexeme(data) {
+  return {
+    items: Plurality.flatMap(
+      (plurality) => Case.map((gramCase) => ({
+        text: data.text,
+        grams: `${plurality},${gramCase}`
+      }))
+    )
+  };
+}
+function parseEntityReference(text) {
+  const ref = parseReference(text);
+  if (ref?.type !== ReferenceType.ENTITY) {
+    throw new Error(`Invalid entity reference: ${text}`);
+  }
+  return ref.data;
+}
+function parseSyntacticReference(text) {
+  const ref = parseReference(text);
+  if (ref?.type !== ReferenceType.SYNTACTIC) {
+    throw new Error(`Invalid syntactic reference: ${text}`);
+  }
+  return ref.data;
+}
+function parseReference(text) {
+  if (text.length < 4 || !text.startsWith("@{") || !text.endsWith("}")) {
+    return null;
+  }
+  const blocks = text.slice(2, text.length - 1).split("|").map((block) => block.trim());
+  if (blocks.length !== 2 || blocks[0] === "" || blocks[0].startsWith("0")) {
+    return null;
+  }
+  if (blocks[0].startsWith("-") || /^[1-9]/.test(blocks[0])) {
+    const offset = Number(blocks[0]);
+    if (!Number.isInteger(offset) || offset === 0 || blocks[1] === "") {
+      return null;
+    }
+    return {
+      type: ReferenceType.SYNTACTIC,
+      data: { offset, nominal: blocks[1] }
+    };
+  }
+  return {
+    type: ReferenceType.ENTITY,
+    data: { entity: blocks[0], tags: parseGrammemes(blocks[1].replaceAll(" ", "")) }
+  };
+}
+function extractEntities(text) {
+  const result = [];
+  for (const segment of text.matchAll(ENTITY_REFERENCE_PATTERN)) {
+    const entity = segment[1].trim();
+    if (!result.includes(entity)) {
+      result.push(entity);
+    }
+  }
+  return result;
+}
+function resolveTextReferences(text, context) {
+  const references = parseReferences(text);
+  if (references.length === 0) {
+    return text;
+  }
+  for (const ref of references) {
+    if (ref.ref.type === ReferenceType.ENTITY) {
+      ref.resolved = resolveEntity(ref.ref.data, context);
+    }
+  }
+  references.forEach((ref, index) => {
+    if (ref.ref.type === ReferenceType.SYNTACTIC) {
+      ref.resolved = resolveSyntactic(ref.ref.data, index, references);
+    }
+  });
+  let posInput = 0;
+  let output = "";
+  for (const ref of references) {
+    output += text.substring(posInput, ref.posInput.from);
+    output += ref.resolved;
+    posInput = ref.posInput.to;
+  }
+  output += text.substring(posInput);
+  return output;
+}
+function referenceToString(ref) {
+  switch (ref.type) {
+    case ReferenceType.ENTITY: {
+      const entity = ref.data;
+      return `@{${entity.entity}|${entity.tags.join(",")}}`;
+    }
+    case ReferenceType.SYNTACTIC: {
+      const syntactic = ref.data;
+      return `@{${syntactic.offset}|${syntactic.nominal}}`;
+    }
+  }
+}
+function grammemeCompare(left, right) {
+  const indexLeft = Object.values(Grammeme).findIndex((gram) => gram === left);
+  const indexRight = Object.values(Grammeme).findIndex((gram) => gram === right);
+  if (indexLeft === -1 && indexRight === -1) {
+    return left.localeCompare(right);
+  } else if (indexLeft === -1 && indexRight !== -1) {
+    return 1;
+  } else if (indexLeft !== -1 && indexRight === -1) {
+    return -1;
+  } else {
+    return indexLeft - indexRight;
+  }
+}
+function parseReferences(text) {
+  const result = [];
+  for (const segment of text.matchAll(REFERENCE_PATTERN)) {
+    const ref = parseReference(segment[0]);
+    if (ref) {
+      result.push({
+        ref,
+        resolved: "",
+        posInput: { from: segment.index ?? 0, to: (segment.index ?? 0) + segment[0].length }
+      });
+    }
+  }
+  return result;
+}
+function resolveEntity(ref, context) {
+  const entity = context[ref.entity];
+  if (!entity) {
+    return `!\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u0441\u0443\u0449\u043D\u043E\u0441\u0442\u044C: ${ref.entity}!`;
+  }
+  const resolved = getEntityForm(entity, ref.tags);
+  return resolved === "" ? `!\u041E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u0442\u0435\u0440\u043C\u0438\u043D: ${ref.entity}!` : resolved;
+}
+function getEntityForm(entity, grams) {
+  if (grams.length === 0) {
+    return entity.nominal;
+  }
+  const manual = entity.forms?.find((form) => matchGrams(grams, form.grams));
+  return manual?.text ?? entity.nominal;
+}
+function matchGrams(query, candidate) {
+  for (const gram of candidate) {
+    if (!query.includes(gram)) {
+      return false;
+    }
+  }
+  return true;
+}
+function resolveSyntactic(ref, index, references) {
+  const master = findSyntacticMaster(ref.offset, index, references);
+  if (!master) {
+    return `!\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u043E\u0435 \u0441\u043C\u0435\u0449\u0435\u043D\u0438\u0435: ${ref.offset}!`;
+  }
+  return ref.nominal;
+}
+function findSyntacticMaster(offset, index, references) {
+  if (offset > 0) {
+    let position = index + 1;
+    let left = offset;
+    while (position < references.length) {
+      if (references[position].ref.type === ReferenceType.ENTITY) {
+        if (left === 1) {
+          return references[position];
+        }
+        left -= 1;
+      }
+      position += 1;
+    }
+  } else {
+    let position = index - 1;
+    let left = offset;
+    while (position >= 0) {
+      if (references[position].ref.type === ReferenceType.ENTITY) {
+        if (left === -1) {
+          return references[position];
+        }
+        left += 1;
+      }
+      position -= 1;
+    }
+  }
+  return void 0;
+}
+export {
+  extractEntities,
+  generateNominalLexeme,
+  parseEntityReference,
+  parseGrammemes,
+  parseReference,
+  parseSyntacticReference,
+  referenceToString,
+  resolveTextReferences,
+  wordFormEquals
+};
+//# sourceMappingURL=language-api.js.map

package/dist/cctext/language-api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cctext/language.ts","../../src/cctext/language-api.ts"],"sourcesContent":["/**\n * Module: Natural language model declarations.\n */\n\n/** Represents single unit of language Morphology. */\n// prettier-ignore\nexport const Grammeme = {\n  // Число\n  sing: 'sing', plur: 'plur',\n\n  // Падеж\n  nomn: 'nomn', gent: 'gent', datv: 'datv',\n  accs: 'accs', ablt: 'ablt', loct: 'loct',\n} as const;\nexport type Grammeme = (typeof Grammeme)[keyof typeof Grammeme];\n\n/** Represents case language concept. */\nexport const Case: Grammeme[] = [\n  Grammeme.nomn,\n  Grammeme.gent,\n  Grammeme.datv,\n  Grammeme.accs,\n  Grammeme.ablt,\n  Grammeme.loct\n] as const;\n\n/** Represents plurality language concept. */\nexport const Plurality: Grammeme[] = [Grammeme.sing, Grammeme.plur] as const;\n\n/** Represents specific wordform attached to {@link Grammeme}s. */\nexport interface WordForm {\n  text: string;\n  grams: Grammeme[];\n}\n\n/** Represents a term available for text reference resolution. */\nexport interface TermContextItem {\n  nominal: string;\n  forms?: WordForm[];\n}\n\n/** Represents term lookup context keyed by entity alias. */\nexport type TermContext = Record<string, TermContextItem>;\n\n/**\n * Represents list of {@link Grammeme}s available in reference construction.\n */\n// prettier-ignore\nexport const supportedGrammemes = [\n  Grammeme.sing, Grammeme.plur,\n  Grammeme.nomn, Grammeme.gent, Grammeme.datv,\n  Grammeme.accs, Grammeme.ablt, Grammeme.loct,\n] as const;\n\n// ====== Reference resolution =====\n\n/** Represents text reference type. */\nexport const ReferenceType = {\n  ENTITY: 'entity',\n  SYNTACTIC: 'syntax'\n} as const;\nexport type ReferenceType = (typeof ReferenceType)[keyof typeof ReferenceType];\n\n/** Represents entity reference payload. */\nexport interface EntityReference {\n  entity: string;\n  tags: Grammeme[];\n}\n\n/** Represents syntactic reference payload. */\nexport interface SyntacticReference {\n  offset: number;\n  nominal: string;\n}\n\n/** Represents abstract reference data. */\nexport interface IReference {\n  type: ReferenceType;\n  data: EntityReference | SyntacticReference;\n}\n","/**\n * Module: Natural language model API.\n */\n\nimport {\n  Case,\n  type EntityReference,\n  Grammeme,\n  type IReference,\n  Plurality,\n  ReferenceType,\n  type SyntacticReference,\n  type TermContext,\n  type TermContextItem,\n  type WordForm\n} from './language';\n\ninterface Position {\n  from: number;\n  to: number;\n}\n\ninterface ResolvedReference {\n  ref: IReference;\n  resolved: string;\n  posInput: Position;\n}\n\nconst REFERENCE_PATTERN = /@{[^{}]*?}/g;\nconst ENTITY_REFERENCE_PATTERN = /@{([^0-9\\-][^}|{]*?)\\|([^}|{]*?)}/g;\n\n/** Represents generated lexeme forms. */\nexport interface Lexeme {\n  items: { text: string; grams: string }[];\n}\n\n/** Equality comparator for {@link WordForm}. Compares a set of Grammemes attached to wordforms. */\nexport function wordFormEquals(left: WordForm, right: WordForm): boolean {\n  if (left.grams.length !== right.grams.length) {\n    return false;\n  }\n  for (let index = 0; index < left.grams.length; ++index) {\n    if (left.grams[index] !== right.grams[index]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** Transforms {@link Grammeme} enumeration to {@link Grammeme}. */\nexport function parseGrammemes(termForm: string): Grammeme[] {\n  const result: Grammeme[] = [];\n  for (const chunk of termForm.split(',')) {\n    const gram = chunk.trim();\n    if (gram !== '') {\n      result.push(gram as Grammeme);\n    }\n  }\n  return result.sort(grammemeCompare);\n}\n\n/** Generates all supported noun forms using nominal text for every form. */\nexport function generateNominalLexeme(data: { text: string }): Lexeme {\n  return {\n    items: Plurality.flatMap(plurality =>\n      Case.map(gramCase => ({\n        text: data.text,\n        grams: `${plurality},${gramCase}`\n      }))\n    )\n  };\n}\n\n/**\n * Extracts {@link EntityReference} from string representation.\n *\n * @param text - Reference text in a valid pattern. Must fit format '\\@\\{GLOBAL_ID|GRAMMEMES\\}'\n */\nexport function parseEntityReference(text: string): EntityReference {\n  const ref = parseReference(text);\n  if (ref?.type !== ReferenceType.ENTITY) {\n    throw new Error(`Invalid entity reference: ${text}`);\n  }\n  return ref.data as EntityReference;\n}\n\n/**\n * Extracts {@link SyntacticReference} from string representation.\n *\n * @param text - Reference text in a valid pattern. Must fit format '\\@\\{OFFSET|NOMINAL_FORM\\}'\n */\nexport function parseSyntacticReference(text: string): SyntacticReference {\n  const ref = parseReference(text);\n  if (ref?.type !== ReferenceType.SYNTACTIC) {\n    throw new Error(`Invalid syntactic reference: ${text}`);\n  }\n  return ref.data as SyntacticReference;\n}\n\n/** Extracts a validated reference from string representation. */\nexport function parseReference(text: string): IReference | null {\n  if (text.length < 4 || !text.startsWith('@{') || !text.endsWith('}')) {\n    return null;\n  }\n\n  const blocks = text\n    .slice(2, text.length - 1)\n    .split('|')\n    .map(block => block.trim());\n  if (blocks.length !== 2 || blocks[0] === '' || blocks[0].startsWith('0')) {\n    return null;\n  }\n\n  if (blocks[0].startsWith('-') || /^[1-9]/.test(blocks[0])) {\n    const offset = Number(blocks[0]);\n    if (!Number.isInteger(offset) || offset === 0 || blocks[1] === '') {\n      return null;\n    }\n    return {\n      type: ReferenceType.SYNTACTIC,\n      data: { offset, nominal: blocks[1] }\n    };\n  }\n\n  return {\n    type: ReferenceType.ENTITY,\n    data: { entity: blocks[0], tags: parseGrammemes(blocks[1].replaceAll(' ', '')) }\n  };\n}\n\n/** Extracts unique entity aliases referenced by text. */\nexport function extractEntities(text: string): string[] {\n  const result: string[] = [];\n  for (const segment of text.matchAll(ENTITY_REFERENCE_PATTERN)) {\n    const entity = segment[1].trim();\n    if (!result.includes(entity)) {\n      result.push(entity);\n    }\n  }\n  return result;\n}\n\n/** Resolves text references using nominal terms and optional manually edited forms. */\nexport function resolveTextReferences(text: string, context: TermContext): string {\n  const references = parseReferences(text);\n  if (references.length === 0) {\n    return text;\n  }\n\n  for (const ref of references) {\n    if (ref.ref.type === ReferenceType.ENTITY) {\n      ref.resolved = resolveEntity(ref.ref.data as EntityReference, context);\n    }\n  }\n  references.forEach((ref, index) => {\n    if (ref.ref.type === ReferenceType.SYNTACTIC) {\n      ref.resolved = resolveSyntactic(ref.ref.data as SyntacticReference, index, references);\n    }\n  });\n\n  let posInput = 0;\n  let output = '';\n  for (const ref of references) {\n    output += text.substring(posInput, ref.posInput.from);\n    output += ref.resolved;\n    posInput = ref.posInput.to;\n  }\n  output += text.substring(posInput);\n  return output;\n}\n\n/** Transforms {@link IReference} to string representation. */\nexport function referenceToString(ref: IReference): string {\n  switch (ref.type) {\n    case ReferenceType.ENTITY: {\n      const entity = ref.data as EntityReference;\n      return `@{${entity.entity}|${entity.tags.join(',')}}`;\n    }\n    case ReferenceType.SYNTACTIC: {\n      const syntactic = ref.data as SyntacticReference;\n      return `@{${syntactic.offset}|${syntactic.nominal}}`;\n    }\n  }\n}\n\n// ===== Internals =======\n\n/** Compares {@link Grammeme} based on Grammeme enum and alpha order for strings. */\nfunction grammemeCompare(left: Grammeme, right: Grammeme): number {\n  const indexLeft = Object.values(Grammeme).findIndex(gram => gram === left);\n  const indexRight = Object.values(Grammeme).findIndex(gram => gram === right);\n  if (indexLeft === -1 && indexRight === -1) {\n    return left.localeCompare(right);\n  } else if (indexLeft === -1 && indexRight !== -1) {\n    return 1;\n  } else if (indexLeft !== -1 && indexRight === -1) {\n    return -1;\n  } else {\n    return indexLeft - indexRight;\n  }\n}\n\nfunction parseReferences(text: string): ResolvedReference[] {\n  const result: ResolvedReference[] = [];\n  for (const segment of text.matchAll(REFERENCE_PATTERN)) {\n    const ref = parseReference(segment[0]);\n    if (ref) {\n      result.push({\n        ref,\n        resolved: '',\n        posInput: { from: segment.index ?? 0, to: (segment.index ?? 0) + segment[0].length }\n      });\n    }\n  }\n  return result;\n}\n\nfunction resolveEntity(ref: EntityReference, context: TermContext): string {\n  const entity = context[ref.entity];\n  if (!entity) {\n    return `!Неизвестная сущность: ${ref.entity}!`;\n  }\n\n  const resolved = getEntityForm(entity, ref.tags);\n  return resolved === '' ? `!Отсутствует термин: ${ref.entity}!` : resolved;\n}\n\nfunction getEntityForm(entity: TermContextItem, grams: Grammeme[]): string {\n  if (grams.length === 0) {\n    return entity.nominal;\n  }\n\n  const manual = entity.forms?.find(form => matchGrams(grams, form.grams));\n  return manual?.text ?? entity.nominal;\n}\n\nfunction matchGrams(query: Grammeme[], candidate: Grammeme[]): boolean {\n  for (const gram of candidate) {\n    if (!query.includes(gram)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction resolveSyntactic(ref: SyntacticReference, index: number, references: ResolvedReference[]): string {\n  const master = findSyntacticMaster(ref.offset, index, references);\n  if (!master) {\n    return `!Некорректное смещение: ${ref.offset}!`;\n  }\n  return ref.nominal;\n}\n\nfunction findSyntacticMaster(\n  offset: number,\n  index: number,\n  references: ResolvedReference[]\n): ResolvedReference | undefined {\n  if (offset > 0) {\n    let position = index + 1;\n    let left = offset;\n    while (position < references.length) {\n      if (references[position].ref.type === ReferenceType.ENTITY) {\n        if (left === 1) {\n          return references[position];\n        }\n        left -= 1;\n      }\n      position += 1;\n    }\n  } else {\n    let position = index - 1;\n    let left = offset;\n    while (position >= 0) {\n      if (references[position].ref.type === ReferenceType.ENTITY) {\n        if (left === -1) {\n          return references[position];\n        }\n        left += 1;\n      }\n      position -= 1;\n    }\n  }\n  return undefined;\n}\n"],"mappings":"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","names":[]}

package/dist/cctext/language.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Module: Natural language model declarations.
+ */
+/** Represents single unit of language Morphology. */
+declare const Grammeme: {
+    readonly sing: "sing";
+    readonly plur: "plur";
+    readonly nomn: "nomn";
+    readonly gent: "gent";
+    readonly datv: "datv";
+    readonly accs: "accs";
+    readonly ablt: "ablt";
+    readonly loct: "loct";
+};
+type Grammeme = (typeof Grammeme)[keyof typeof Grammeme];
+/** Represents case language concept. */
+declare const Case: Grammeme[];
+/** Represents plurality language concept. */
+declare const Plurality: Grammeme[];
+/** Represents specific wordform attached to {@link Grammeme}s. */
+interface WordForm {
+    text: string;
+    grams: Grammeme[];
+}
+/** Represents a term available for text reference resolution. */
+interface TermContextItem {
+    nominal: string;
+    forms?: WordForm[];
+}
+/** Represents term lookup context keyed by entity alias. */
+type TermContext = Record<string, TermContextItem>;
+/**
+ * Represents list of {@link Grammeme}s available in reference construction.
+ */
+declare const supportedGrammemes: readonly ["sing", "plur", "nomn", "gent", "datv", "accs", "ablt", "loct"];
+/** Represents text reference type. */
+declare const ReferenceType: {
+    readonly ENTITY: "entity";
+    readonly SYNTACTIC: "syntax";
+};
+type ReferenceType = (typeof ReferenceType)[keyof typeof ReferenceType];
+/** Represents entity reference payload. */
+interface EntityReference {
+    entity: string;
+    tags: Grammeme[];
+}
+/** Represents syntactic reference payload. */
+interface SyntacticReference {
+    offset: number;
+    nominal: string;
+}
+/** Represents abstract reference data. */
+interface IReference {
+    type: ReferenceType;
+    data: EntityReference | SyntacticReference;
+}
+
+export { Case, type EntityReference, Grammeme, type IReference, Plurality, ReferenceType, type SyntacticReference, type TermContext, type TermContextItem, type WordForm, supportedGrammemes };

package/dist/cctext/language.js

@@ -0,0 +1,44 @@
+// src/cctext/language.ts
+var Grammeme = {
+  // Число
+  sing: "sing",
+  plur: "plur",
+  // Падеж
+  nomn: "nomn",
+  gent: "gent",
+  datv: "datv",
+  accs: "accs",
+  ablt: "ablt",
+  loct: "loct"
+};
+var Case = [
+  Grammeme.nomn,
+  Grammeme.gent,
+  Grammeme.datv,
+  Grammeme.accs,
+  Grammeme.ablt,
+  Grammeme.loct
+];
+var Plurality = [Grammeme.sing, Grammeme.plur];
+var supportedGrammemes = [
+  Grammeme.sing,
+  Grammeme.plur,
+  Grammeme.nomn,
+  Grammeme.gent,
+  Grammeme.datv,
+  Grammeme.accs,
+  Grammeme.ablt,
+  Grammeme.loct
+];
+var ReferenceType = {
+  ENTITY: "entity",
+  SYNTACTIC: "syntax"
+};
+export {
+  Case,
+  Grammeme,
+  Plurality,
+  ReferenceType,
+  supportedGrammemes
+};
+//# sourceMappingURL=language.js.map

package/dist/cctext/language.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cctext/language.ts"],"sourcesContent":["/**\n * Module: Natural language model declarations.\n */\n\n/** Represents single unit of language Morphology. */\n// prettier-ignore\nexport const Grammeme = {\n  // Число\n  sing: 'sing', plur: 'plur',\n\n  // Падеж\n  nomn: 'nomn', gent: 'gent', datv: 'datv',\n  accs: 'accs', ablt: 'ablt', loct: 'loct',\n} as const;\nexport type Grammeme = (typeof Grammeme)[keyof typeof Grammeme];\n\n/** Represents case language concept. */\nexport const Case: Grammeme[] = [\n  Grammeme.nomn,\n  Grammeme.gent,\n  Grammeme.datv,\n  Grammeme.accs,\n  Grammeme.ablt,\n  Grammeme.loct\n] as const;\n\n/** Represents plurality language concept. */\nexport const Plurality: Grammeme[] = [Grammeme.sing, Grammeme.plur] as const;\n\n/** Represents specific wordform attached to {@link Grammeme}s. */\nexport interface WordForm {\n  text: string;\n  grams: Grammeme[];\n}\n\n/** Represents a term available for text reference resolution. */\nexport interface TermContextItem {\n  nominal: string;\n  forms?: WordForm[];\n}\n\n/** Represents term lookup context keyed by entity alias. */\nexport type TermContext = Record<string, TermContextItem>;\n\n/**\n * Represents list of {@link Grammeme}s available in reference construction.\n */\n// prettier-ignore\nexport const supportedGrammemes = [\n  Grammeme.sing, Grammeme.plur,\n  Grammeme.nomn, Grammeme.gent, Grammeme.datv,\n  Grammeme.accs, Grammeme.ablt, Grammeme.loct,\n] as const;\n\n// ====== Reference resolution =====\n\n/** Represents text reference type. */\nexport const ReferenceType = {\n  ENTITY: 'entity',\n  SYNTACTIC: 'syntax'\n} as const;\nexport type ReferenceType = (typeof ReferenceType)[keyof typeof ReferenceType];\n\n/** Represents entity reference payload. */\nexport interface EntityReference {\n  entity: string;\n  tags: Grammeme[];\n}\n\n/** Represents syntactic reference payload. */\nexport interface SyntacticReference {\n  offset: number;\n  nominal: string;\n}\n\n/** Represents abstract reference data. */\nexport interface IReference {\n  type: ReferenceType;\n  data: EntityReference | SyntacticReference;\n}\n"],"mappings":";AAMO,IAAM,WAAW;AAAA;AAAA,EAEtB,MAAM;AAAA,EAAQ,MAAM;AAAA;AAAA,EAGpB,MAAM;AAAA,EAAQ,MAAM;AAAA,EAAQ,MAAM;AAAA,EAClC,MAAM;AAAA,EAAQ,MAAM;AAAA,EAAQ,MAAM;AACpC;AAIO,IAAM,OAAmB;AAAA,EAC9B,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AACX;AAGO,IAAM,YAAwB,CAAC,SAAS,MAAM,SAAS,IAAI;AAqB3D,IAAM,qBAAqB;AAAA,EAChC,SAAS;AAAA,EAAM,SAAS;AAAA,EACxB,SAAS;AAAA,EAAM,SAAS;AAAA,EAAM,SAAS;AAAA,EACvC,SAAS;AAAA,EAAM,SAAS;AAAA,EAAM,SAAS;AACzC;AAKO,IAAM,gBAAgB;AAAA,EAC3B,QAAQ;AAAA,EACR,WAAW;AACb;","names":[]}

package/dist/graph/graph.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Module: Custom graph data structure.
+ */
+/** Represents single node of a {@link Graph}, as implemented by storing outgoing and incoming connections. */
+declare class GraphNode<NodeID> {
+    /** Unique identifier of the node. */
+    id: NodeID;
+    /** List of outgoing nodes. */
+    outputs: NodeID[];
+    /** List of incoming nodes. */
+    inputs: NodeID[];
+    constructor(id: NodeID);
+    clone(): GraphNode<NodeID>;
+    addOutput(node: NodeID): void;
+    addInput(node: NodeID): void;
+    removeInput(target: NodeID): NodeID | null;
+    removeOutput(target: NodeID): NodeID | null;
+}
+/**
+ * Represents a Graph.
+ *
+ * This class is optimized for TermGraph use case and not supposed to be used as generic graph implementation.
+ */
+declare class Graph<NodeID = number> {
+    /** Map of nodes. */
+    nodes: Map<NodeID, GraphNode<NodeID>>;
+    constructor(arr?: NodeID[][]);
+    clone(): Graph<NodeID>;
+    at(target: NodeID): GraphNode<NodeID> | undefined;
+    addNode(target: NodeID): GraphNode<NodeID>;
+    hasNode(target: NodeID): boolean;
+    removeNode(target: NodeID): void;
+    foldNode(target: NodeID): void;
+    removeIsolated(): GraphNode<NodeID>[];
+    addEdge(source: NodeID, destination: NodeID): void;
+    removeEdge(source: NodeID, destination: NodeID): void;
+    hasEdge(source: NodeID, destination: NodeID): boolean;
+    isReachable(source: NodeID, destination: NodeID): boolean;
+    rootNodes(): NodeID[];
+    expandOutputs(origin: NodeID[]): NodeID[];
+    expandInputs(origin: NodeID[]): NodeID[];
+    expandAllOutputs(origin: NodeID[]): NodeID[];
+    expandAllInputs(origin: NodeID[]): NodeID[];
+    maximizePart(origin: NodeID[]): NodeID[];
+    topologicalOrder(): NodeID[];
+    /**
+     * 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: NodeID[]): NodeID[];
+    private buildTransitiveClosureForSort;
+    transitiveReduction(): void;
+    /**
+     * Finds a cycle in the graph.
+     *
+     * @returns {NodeID[] | null} The cycle if found, otherwise `null`.
+     * Uses non-recursive DFS.
+     */
+    findCycle(): NodeID[] | null;
+}
+
+export { Graph, GraphNode };