@rsconcept/rstool 1.5.0 → 1.7.0

package/src/models/agent-workflow.ts

@@ -35,6 +35,59 @@ export interface ApplySchemaPatchInput {
   commitMessage?: string;
 }
 
+/** Result of {@link RSToolAgent.restoreOrder}. */
+export interface RestoreOrderResult {
+  /** Constituent ids in the restored declaration order. */
+  orderedIds: number[];
+  /** Aliases in the same order as {@link orderedIds}. */
+  orderedAliases: string[];
+}
+
+/** One row of an identification (substitution) table, by alias. */
+export interface SynthesisSubstitution {
+  /** Alias of the constituenta being replaced (deleted). */
+  original: string;
+  /** Alias of the surviving constituenta. */
+  substitution: string;
+}
+
+/** Input for {@link RSToolAgent.synthesize}. */
+export interface SynthesizeInput {
+  /** Session whose constituents are merged into the receiver. */
+  sourceSessionId: string;
+  /**
+   * Optional subset of source aliases to import.
+   * Omit or pass an empty array to import all source constituents.
+   */
+  items?: string[];
+  /**
+   * Identification table: one endpoint is a source alias, the other a receiver alias
+   * (same rules as Portal schema embedding / «Встраивание схемы»).
+   */
+  substitutions?: SynthesisSubstitution[];
+  /** When set, a revision is recorded after a successful synthesis. */
+  commitMessage?: string;
+}
+
+/** Result of {@link RSToolAgent.synthesize}. */
+export interface SynthesizeResult {
+  session: SessionHandle;
+  summary: SessionSummary;
+  /** False when some constituents failed re-analysis after embedding (best-effort). */
+  success: boolean;
+  /** Drafts that failed analysis after embedding; empty when {@link success} is true. */
+  failed: Array<{ draft: ConstituentaDraft; diagnostics: Diagnostic[] }>;
+  /** Source constituent id → inserted id in the receiver (before substitutions). */
+  idMap: Record<number, number>;
+  /** Alias remapping applied to imported constituents. */
+  aliasMapping: Record<string, string>;
+  /** Ids removed by substitutions. */
+  deletedIds: number[];
+  /** Ids of constituents inserted from the source (may include later-deleted ones). */
+  insertedIds: number[];
+  revision?: SessionRevision;
+}
+
 /** Compact view of one constituent in a session summary. */
 export interface SessionSummaryItem {
   id: number;

package/src/models/index.ts

@@ -2,20 +2,17 @@ export {
   type AgentConstituentaPatch,
   type ApplySchemaPatchInput,
   type ApplySchemaPatchResult,
+  type RestoreOrderResult,
   type SessionStateDetail,
   type SessionStateResult,
   type SessionSummary,
-  type SessionSummaryItem
+  type SessionSummaryItem,
+  type SynthesisSubstitution,
+  type SynthesizeInput,
+  type SynthesizeResult
 } from './agent-workflow';
 export { type AnalysisResult, type AnalyzeExpressionInput } from './analysis';
-export {
-  CstType,
-  EvalStatus,
-  RSErrorCode,
-  ValueClass,
-  type BasicBinding,
-  type RSToolValue
-} from './common';
+export { CstType, EvalStatus, RSErrorCode, ValueClass, type BasicBinding, type RSToolValue } from './common';
 export { type ApplyConstituentsMode, type ConstituentaDraft, type ConstituentaState } from './constituenta';
 export {
   type CstDiagnostic,

package/src/models/rstool-agent.test.ts

@@ -877,6 +877,27 @@ describe('RSToolAgent import and export', () => {
     expect(exported.items.map(item => item.alias)).toEqual(['D1', 'S1', 'C1', 'X1']);
   });
 
+  it('restoreOrder reorders by formal topology and kernel priority', () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession({ title: 'Restore', alias: 'RO' });
+    tool.applySchemaPatch(
+      {
+        items: [
+          { alias: 'D1', cstType: CstType.TERM, definitionFormal: 'Pr1(S1)\\X1' },
+          { alias: 'S1', cstType: CstType.STRUCTURED, definitionFormal: 'ℬ(X1×X1)' },
+          { alias: 'A2', cstType: CstType.AXIOM, definitionFormal: 'P1[S1]' },
+          { alias: 'P1', cstType: CstType.PREDICATE, definitionFormal: '[α∈ℬ(R1)] card(α)=0' },
+          { alias: 'X1', cstType: CstType.BASE, definitionFormal: '' }
+        ]
+      },
+      session.sessionId
+    );
+
+    const result = tool.restoreOrder(session.sessionId);
+    expect(result.orderedAliases.slice(0, 5)).toEqual(['X1', 'P1', 'S1', 'A2', 'D1']);
+    expect(fullState(tool, session.sessionId).items.map(item => item.alias)).toEqual(result.orderedAliases);
+  });
+
   it('round-trips portal schema export and import', () => {
     const tool = new RSToolAgent();
     const session = tool.createSession({ title: 'Round trip', alias: 'RT' });
@@ -1034,4 +1055,66 @@ describe('RSToolAgent modeling semantics', () => {
       tool.setModelValues({ set: [{ target: 1, value: [1, 2, 3] as never }] }, session.sessionId)
     ).rejects.toThrow(/Invalid basic binding/);
   });
+
+  it('synthesize merges source session and remaps aliases', () => {
+    const tool = new RSToolAgent();
+    const receiver = tool.createSession({ title: 'Receiver' });
+    tool.applySchemaPatch({ items: [{ alias: 'X1' }] }, receiver.sessionId);
+
+    const source = tool.createSession({ title: 'Source' });
+    tool.applySchemaPatch(
+      {
+        items: [
+          { alias: 'X1', term: 'person' },
+          { alias: 'S1', definitionFormal: 'ℬ(X1)' }
+        ]
+      },
+      source.sessionId
+    );
+
+    tool.setCurrentSession(receiver.sessionId);
+    const result = tool.synthesize({
+      sourceSessionId: source.sessionId,
+      commitMessage: 'merge source'
+    });
+
+    expect(result.summary.itemCount).toBe(3);
+    expect(result.success).toBe(true);
+    expect(result.failed).toEqual([]);
+    expect(result.aliasMapping).toEqual({ X1: 'X2', S1: 'S1' });
+    const state = tool.getSessionState('full', receiver.sessionId) as {
+      items: Array<{ alias: string; definitionFormal: string }>;
+    };
+    expect(state.items.map(item => item.alias)).toEqual(['X1', 'X2', 'S1']);
+    expect(state.items.find(item => item.alias === 'S1')?.definitionFormal).toBe('ℬ(X2)');
+    expect(result.revision?.message).toBe('merge source');
+  });
+
+  it('synthesize applies identification table', () => {
+    const tool = new RSToolAgent();
+    const receiver = tool.createSession();
+    tool.applySchemaPatch({ items: [{ alias: 'X1', term: 'keep' }] }, receiver.sessionId);
+
+    const source = tool.createSession();
+    tool.applySchemaPatch({ items: [{ alias: 'X1', term: 'drop' }] }, source.sessionId);
+
+    tool.setCurrentSession(receiver.sessionId);
+    const result = tool.synthesize({
+      sourceSessionId: source.sessionId,
+      substitutions: [{ original: 'X1', substitution: 'X1' }]
+    });
+
+    expect(result.summary.itemCount).toBe(1);
+    expect(result.success).toBe(true);
+    expect(result.deletedIds).toHaveLength(1);
+    const state = tool.getSessionState('full', receiver.sessionId) as { items: Array<{ alias: string; term: string }> };
+    expect(state.items[0].alias).toBe('X1');
+    expect(state.items[0].term).toBe('keep');
+  });
+
+  it('synthesize rejects same source and receiver session', () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    expect(() => tool.synthesize({ sourceSessionId: session.sessionId }, session.sessionId)).toThrow(/must differ/);
+  });
 });

package/src/models/rstool-agent.ts

@@ -1,3 +1,9 @@
+import {
+  inlineSynthesis,
+  restoreConstituentOrder,
+  type SynthesizableFields
+} from '@rsconcept/domain/library/rsform-api';
+import { type Substitution } from '@rsconcept/domain/library/rsform';
 import {
   portalDetailsToDrafts,
   portalDetailsToSessionSeed,
@@ -13,9 +19,12 @@ import {
   type AgentConstituentaPatch,
   type ApplySchemaPatchInput,
   type ApplySchemaPatchResult,
+  type RestoreOrderResult,
   type SessionStateDetail,
   type SessionStateResult,
-  type SessionSummary
+  type SessionSummary,
+  type SynthesizeInput,
+  type SynthesizeResult
 } from './agent-workflow';
 import { type AnalysisResult, type AnalyzeExpressionInput } from './analysis';
 import { CstType } from './common';
@@ -303,6 +312,162 @@ export class RSToolAgent implements RSToolAgentContract {
     return result;
   }
 
+  /** @inheritdoc */
+  public restoreOrder(sessionId?: string): RestoreOrderResult {
+    const id = this.resolveSessionId(sessionId);
+    const envelope = this.sessions.get(id);
+    const orderable = envelope.state.items.map(item => ({
+      id: item.id,
+      alias: item.alias,
+      cst_type: item.cstType,
+      definition_formal: item.definitionFormal
+    }));
+    const ordered = restoreConstituentOrder(orderable);
+    const byId = new Map(envelope.state.items.map(item => [item.id, item]));
+    envelope.state.items = ordered.map(item => byId.get(item.id)!);
+    envelope.state.updatedAt = new Date().toISOString();
+    this.sessions.replaceState(id, envelope.state);
+    return {
+      orderedIds: ordered.map(item => item.id),
+      orderedAliases: ordered.map(item => item.alias)
+    };
+  }
+
+  /** @inheritdoc */
+  public synthesize(input: SynthesizeInput, sessionId?: string): SynthesizeResult {
+    const receiverHandle = sessionId
+      ? { sessionId: this.resolveSessionId(sessionId), contractVersion: this.contractVersion }
+      : this.ensureSession();
+    const receiverId = receiverHandle.sessionId;
+    const sourceId = this.resolveSessionId(input.sourceSessionId);
+
+    if (sourceId === receiverId) {
+      throw new Error('synthesize: sourceSessionId must differ from the receiver session');
+    }
+
+    const receiverEnvelope = this.sessions.get(receiverId);
+    const sourceEnvelope = this.sessions.get(sourceId);
+    const snapshot = this.sessions.snapshot(receiverId);
+
+    try {
+      const sourceItems = this.selectSourceItems(sourceEnvelope.state.items, input.items);
+      const substitutions = this.resolveSynthesisSubstitutions(
+        receiverEnvelope.state.items,
+        sourceItems,
+        input.substitutions ?? []
+      );
+
+      const nextId = receiverEnvelope.state.items.reduce((max, item) => Math.max(max, item.id), 0) + 1;
+      const result = inlineSynthesis({
+        receiverItems: receiverEnvelope.state.items.map(toSynthesizableSessionItem),
+        sourceItems: sourceItems.map(toSynthesizableSessionItem),
+        substitutions,
+        nextId
+      });
+
+      const drafts: ConstituentaDraft[] = result.items.map(item => ({
+        id: item.id,
+        alias: item.alias,
+        cstType: item.cst_type,
+        definitionFormal: item.definition_formal,
+        term: item.term_resolved || item.term_raw,
+        definitionText: item.definition_resolved || item.definition_raw,
+        convention: item.convention
+      }));
+
+      receiverEnvelope.state.items = [];
+      receiverEnvelope.state.model = {
+        items: receiverEnvelope.state.model.items.filter(value => !result.deletedIds.has(value.id))
+      };
+      this.sessions.replaceState(receiverId, receiverEnvelope.state);
+
+      const applied = this.applyConstituents({ drafts, mode: 'best_effort' }, receiverId);
+
+      const revision = input.commitMessage ? this.commitStep(input.commitMessage, receiverId) : undefined;
+      return {
+        session: receiverHandle,
+        summary: this.buildSessionSummary(receiverId),
+        success: applied.success,
+        failed: applied.failed,
+        idMap: result.idMap,
+        aliasMapping: result.aliasMapping,
+        deletedIds: [...result.deletedIds],
+        insertedIds: result.insertedIds,
+        revision
+      };
+    } catch (error) {
+      this.sessions.restore(receiverId, snapshot);
+      throw error;
+    }
+  }
+
+  private selectSourceItems(sourceItems: ConstituentaState[], aliases?: string[]): ConstituentaState[] {
+    if (!aliases || aliases.length === 0) {
+      return [...sourceItems];
+    }
+    const byAlias = new Map(sourceItems.map(item => [item.alias, item]));
+    const selected: ConstituentaState[] = [];
+    for (const alias of aliases) {
+      const item = byAlias.get(alias);
+      if (!item) {
+        throw new Error(`synthesize: unknown source alias "${alias}"`);
+      }
+      selected.push(item);
+    }
+    return selected;
+  }
+
+  private resolveSynthesisSubstitutions(
+    receiverItems: ConstituentaState[],
+    sourceItems: ConstituentaState[],
+    substitutions: SynthesizeInput['substitutions']
+  ): Substitution[] {
+    if (!substitutions || substitutions.length === 0) {
+      return [];
+    }
+
+    const receiverByAlias = new Map(receiverItems.map(item => [item.alias, item]));
+    const sourceByAlias = new Map(sourceItems.map(item => [item.alias, item]));
+    const deletedKeys = new Set<string>();
+    const resolved: Substitution[] = [];
+
+    for (const row of substitutions) {
+      const originalSource = sourceByAlias.get(row.original);
+      const originalReceiver = receiverByAlias.get(row.original);
+      const substitutionSource = sourceByAlias.get(row.substitution);
+      const substitutionReceiver = receiverByAlias.get(row.substitution);
+
+      let originalId: number;
+      let substitutionId: number;
+      let originalKey: string;
+
+      // Prefer source→receiver when both sides share the same alias (typical base identification).
+      // Session ids are independent, so do not compare numeric ids across sessions.
+      if (originalSource && substitutionReceiver) {
+        originalId = originalSource.id;
+        substitutionId = substitutionReceiver.id;
+        originalKey = `s:${originalId}`;
+      } else if (originalReceiver && substitutionSource) {
+        originalId = originalReceiver.id;
+        substitutionId = substitutionSource.id;
+        originalKey = `r:${originalId}`;
+      } else {
+        throw new Error(
+          `synthesize: substitution "${row.original}" → "${row.substitution}" must pair one source alias with one receiver alias`
+        );
+      }
+
+      if (deletedKeys.has(originalKey)) {
+        throw new Error(`synthesize: constituenta "${row.original}" is substituted more than once`);
+      }
+      deletedKeys.add(originalKey);
+
+      resolved.push({ original: originalId, substitution: substitutionId });
+    }
+
+    return resolved;
+  }
+
   private addOrUpdateConstituenta(
     input: AddOrUpdateConstituentaInput,
     sessionId?: string
@@ -528,3 +693,19 @@ export class RSToolAgent implements RSToolAgentContract {
     ]);
   }
 }
+
+function toSynthesizableSessionItem(item: ConstituentaState): SynthesizableFields & { convention: string } {
+  return {
+    id: item.id,
+    alias: item.alias,
+    cst_type: item.cstType,
+    definition_formal: item.definitionFormal,
+    typification_manual: '',
+    term_raw: item.term,
+    term_resolved: item.term,
+    term_forms: [],
+    definition_raw: item.definitionText,
+    definition_resolved: item.definitionText,
+    convention: item.convention
+  };
+}

package/src/models/tool-contract.ts

@@ -1,8 +1,11 @@
 import {
   type ApplySchemaPatchInput,
   type ApplySchemaPatchResult,
+  type RestoreOrderResult,
   type SessionStateDetail,
-  type SessionStateResult
+  type SessionStateResult,
+  type SynthesizeInput,
+  type SynthesizeResult
 } from './agent-workflow';
 import { type AnalysisResult, type AnalyzeExpressionInput } from './analysis';
 import { type Diagnostic, type ListDiagnosticsFilters } from './diagnostic';
@@ -12,7 +15,7 @@ import { type RecalculateModelResult, type SessionModelState, type SetModelValue
 import { type SessionHandle, type SessionRevision, type SessionState } from './session';
 
 /** Agent-visible contract version; bump on breaking API changes. */
-export const CONTRACT_VERSION = '3.0.0';
+export const CONTRACT_VERSION = '3.2.0';
 
 /** Options for constructing an {@link RSToolAgent}. */
 export interface RSToolAgentOptions {
@@ -85,4 +88,16 @@ export interface RSToolAgentContract {
 
   /** Recompute derived model values for all constituents. */
   recalculateModel(sessionId?: string): RecalculateModelResult;
+
+  /**
+   * Restore declaration order: formal topology, semantic clusters when ready,
+   * otherwise stable against type/kernel preferred ranks.
+   */
+  restoreOrder(sessionId?: string): RestoreOrderResult;
+
+  /**
+   * Synthesis by embedding: merge constituents from another session into the receiver,
+   * then apply an identification table.
+   */
+  synthesize(input: SynthesizeInput, sessionId?: string): SynthesizeResult;
 }

package/src/wrapper/stdio-handler.ts

@@ -33,7 +33,9 @@ export const STDIO_METHODS = [
   'setModelValues',
   'getModelState',
   'evaluate',
-  'recalculateModel'
+  'recalculateModel',
+  'restoreOrder',
+  'synthesize'
 ] as const;
 
 function asObject(value: unknown): Record<string, unknown> {
@@ -171,6 +173,18 @@ export async function handleStdioRequest(tool: RSToolAgent, request: StdioReques
           ok: true,
           result: tool.recalculateModel(optionalSessionId(params))
         };
+      case 'restoreOrder':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.restoreOrder(optionalSessionId(params))
+        };
+      case 'synthesize':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.synthesize(omitSessionId(params) as never, optionalSessionId(params))
+        };
       default:
         return {
           id: request.id ?? null,

package/dist/agent-workflow-D22FeODL.d.ts

@@ -1,64 +0,0 @@
-import { a as Diagnostic } from "./diagnostic-C6TRoBgt.js";
-import { n as CstType } from "./common-D6TFl6l_.js";
-import { a as ApplyConstituentsResult, i as ApplyConstituentsMode, o as ConstituentaDraft } from "./constituenta-QY5w1x91.js";
-import { n as SessionRevision, r as SessionState, t as SessionHandle } from "./session-CI4rLYby.js";
-
-//#region src/models/agent-workflow.d.ts
-/** Level of detail returned by {@link RSToolAgent.getSessionState}. */
-type SessionStateDetail = 'summary' | 'full';
-/** Result of `getSessionState`: compact summary or full cloned session state. */
-type SessionStateResult = SessionSummary | SessionState;
-/**
- * Partial constituent update used in {@link ApplySchemaPatchInput}.
- *
- * `alias` is required; other fields are merged with any existing constituent
- * or inferred from the alias prefix when omitted.
- */
-interface AgentConstituentaPatch extends Omit<Partial<ConstituentaDraft>, 'alias'> {
-  alias: string;
-}
-/** Input for {@link RSToolAgent.applySchemaPatch}. */
-interface ApplySchemaPatchInput {
-  /** Metadata used only when a new session is created for this patch. */
-  initial?: {
-    alias?: string;
-    title?: string;
-    comment?: string;
-  };
-  /** Constituent patches to apply in dependency order. */
-  items: AgentConstituentaPatch[];
-  /** atomic: rollback on first failure; best_effort applies valid drafts. Default: atomic. */
-  mode?: ApplyConstituentsMode;
-  /** When set, a revision is recorded after a successful patch. */
-  commitMessage?: string;
-}
-/** Compact view of one constituent in a session summary. */
-interface SessionSummaryItem {
-  id: number;
-  alias: string;
-  cstType: CstType;
-  analysisSuccess: boolean;
-}
-/** Compact session overview returned by default from `getSessionState`. */
-interface SessionSummary {
-  sessionId: string;
-  contractVersion: string;
-  alias: string;
-  title: string;
-  comment: string;
-  itemCount: number;
-  modelItemCount: number;
-  diagnosticsCount: number;
-  items: SessionSummaryItem[];
-  diagnostics: Diagnostic[];
-  lastRevision?: SessionRevision;
-}
-/** Result of {@link RSToolAgent.applySchemaPatch}. */
-interface ApplySchemaPatchResult extends ApplyConstituentsResult {
-  session: SessionHandle;
-  summary: SessionSummary;
-  revision?: SessionRevision;
-}
-//#endregion
-export { SessionStateResult as a, SessionStateDetail as i, ApplySchemaPatchInput as n, SessionSummary as o, ApplySchemaPatchResult as r, SessionSummaryItem as s, AgentConstituentaPatch as t };
-//# sourceMappingURL=agent-workflow-D22FeODL.d.ts.map

package/dist/diagnostic-assembly-DRunIcKQ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostic-assembly-DRunIcKQ.js","names":[],"sources":["../src/mappers/diagnostic-assembly.ts"],"sourcesContent":["import {\n  type Constituenta,\n  type CstDiagnostic,\n  DiagnosticKind,\n  modelStatusCstDiagnostic,\n  RSDiagnosticCode\n} from '@rsconcept/domain/library';\nimport { EvalStatus } from '@rsconcept/domain/library/rsmodel';\nimport { isCritical, RSErrorCode, type RSErrorDescription } from '@rsconcept/domain/rslang/error';\n\nexport { DiagnosticKind, RSDiagnosticCode };\n\n/** Severity of a {@link Diagnostic}. */\nexport type DiagnosticSeverity = 'error' | 'warning';\n\n/** Agent-facing diagnostic with redundant fields for autonomous repair. */\nexport interface Diagnostic extends CstDiagnostic {\n  name: string;\n  severity: DiagnosticSeverity;\n  constituentId?: number;\n  alias?: string;\n  expression: string;\n  from: number;\n  to: number;\n}\n\n/** Context for attributing a {@link Diagnostic} to a constituent. */\nexport interface DiagnosticTarget {\n  constituentId?: number;\n  alias?: string;\n}\n\nconst DIAGNOSTIC_NAMES: ReadonlyMap<number, string> = new Map([\n  ...Object.entries(RSErrorCode).map(([name, code]) => [code, name] as const),\n  ...Object.entries(RSDiagnosticCode).map(([name, code]) => [code, name] as const)\n]);\n\nexport function getDiagnosticName(code: number): string {\n  return DIAGNOSTIC_NAMES.get(code) ?? `0x${code.toString(16).toUpperCase()}`;\n}\n\nexport function getDiagnosticSeverity(code: number): DiagnosticSeverity {\n  return isCritical(code as RSErrorCode) ? 'error' : 'warning';\n}\n\nexport function expandCstDiagnostic(cst: Constituenta, diagnostic: CstDiagnostic): Diagnostic {\n  const expression = expressionForCstDiagnostic(cst, diagnostic);\n  return {\n    ...diagnostic,\n    name: getDiagnosticName(diagnostic.code),\n    severity: getDiagnosticSeverity(diagnostic.code),\n    constituentId: cst.id,\n    alias: cst.alias,\n    expression,\n    from: 0,\n    to: diagnostic.kind === DiagnosticKind.MODEL ? 0 : Math.max(expression.length, 1)\n  };\n}\n\nexport function expressionDiagnostic(\n  error: RSErrorDescription,\n  expression: string,\n  target?: DiagnosticTarget\n): Diagnostic {\n  return {\n    kind: DiagnosticKind.EXPRESSION,\n    code: error.code,\n    name: getDiagnosticName(error.code),\n    severity: getDiagnosticSeverity(error.code),\n    constituentId: target?.constituentId,\n    alias: target?.alias,\n    expression,\n    from: error.from,\n    to: error.to,\n    ...(error.params ? { params: error.params } : {})\n  };\n}\n\nexport function modelStatusDiagnostic(status: EvalStatus, cst: Constituenta): Diagnostic | null {\n  const base = modelStatusCstDiagnostic(status, cst.cst_type);\n  return base ? expandCstDiagnostic(cst, base) : null;\n}\n\nfunction expressionForCstDiagnostic(cst: Constituenta, diagnostic: CstDiagnostic): string {\n  switch (diagnostic.code) {\n    case RSDiagnosticCode.schemaHomonym:\n    case RSDiagnosticCode.schemaMissingTerm:\n      return cst.term_resolved;\n    case RSDiagnosticCode.schemaMissingConvention:\n      return cst.convention;\n    case RSDiagnosticCode.schemaTypeMismatch:\n      return cst.typification_manual;\n    default:\n      return cst.definition_formal;\n  }\n}\n"],"mappings":";;;AAgCA,MAAM,mBAAgD,IAAI,IAAI,CAC5D,GAAG,OAAO,QAAQ,WAAW,CAAC,CAAC,KAAK,CAAC,MAAM,UAAU,CAAC,MAAM,IAAI,CAAU,GAC1E,GAAG,OAAO,QAAQ,gBAAgB,CAAC,CAAC,KAAK,CAAC,MAAM,UAAU,CAAC,MAAM,IAAI,CAAU,CACjF,CAAC;AAED,SAAgB,kBAAkB,MAAsB;CACtD,OAAO,iBAAiB,IAAI,IAAI,KAAK,KAAK,KAAK,SAAS,EAAE,CAAC,CAAC,YAAY;AAC1E;AAEA,SAAgB,sBAAsB,MAAkC;CACtE,OAAO,WAAW,IAAmB,IAAI,UAAU;AACrD;AAEA,SAAgB,oBAAoB,KAAmB,YAAuC;CAC5F,MAAM,aAAa,2BAA2B,KAAK,UAAU;CAC7D,OAAO;EACL,GAAG;EACH,MAAM,kBAAkB,WAAW,IAAI;EACvC,UAAU,sBAAsB,WAAW,IAAI;EAC/C,eAAe,IAAI;EACnB,OAAO,IAAI;EACX;EACA,MAAM;EACN,IAAI,WAAW,SAAS,eAAe,QAAQ,IAAI,KAAK,IAAI,WAAW,QAAQ,CAAC;CAClF;AACF;AAEA,SAAgB,qBACd,OACA,YACA,QACY;CACZ,OAAO;EACL,MAAM,eAAe;EACrB,MAAM,MAAM;EACZ,MAAM,kBAAkB,MAAM,IAAI;EAClC,UAAU,sBAAsB,MAAM,IAAI;EAC1C,eAAe,QAAQ;EACvB,OAAO,QAAQ;EACf;EACA,MAAM,MAAM;EACZ,IAAI,MAAM;EACV,GAAI,MAAM,SAAS,EAAE,QAAQ,MAAM,OAAO,IAAI,CAAC;CACjD;AACF;AAEA,SAAgB,sBAAsB,QAAoB,KAAsC;CAC9F,MAAM,OAAO,yBAAyB,QAAQ,IAAI,QAAQ;CAC1D,OAAO,OAAO,oBAAoB,KAAK,IAAI,IAAI;AACjD;AAEA,SAAS,2BAA2B,KAAmB,YAAmC;CACxF,QAAQ,WAAW,MAAnB;EACE,KAAK,iBAAiB;EACtB,KAAK,iBAAiB,mBACpB,OAAO,IAAI;EACb,KAAK,iBAAiB,yBACpB,OAAO,IAAI;EACb,KAAK,iBAAiB,oBACpB,OAAO,IAAI;EACb,SACE,OAAO,IAAI;CACf;AACF"}