@rsconcept/rstool 1.7.0 → 1.9.0

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

@@ -1029,6 +1029,101 @@ describe('RSToolAgent modeling semantics', () => {
     expect(modelIssues.some(record => record.code === RSDiagnosticCode.modelAxiomFalse)).toBe(true);
   });
 
+  function buildGraphScratch(tool: RSToolAgent, sessionId: string) {
+    tool.applySchemaPatch(
+      {
+        items: [
+          { alias: 'X1' },
+          { alias: 'S1', definitionFormal: 'ℬ(X1×X1)' },
+          { alias: 'D1', definitionFormal: 'Pr2,1(S1)' },
+          { alias: 'D2', definitionFormal: 'S1\\D1' },
+          { alias: 'F1', definitionFormal: '[α∈X1] Pr2(Fi1[{α}](D2))' }
+        ]
+      },
+      sessionId
+    );
+  }
+
+  it('normalizes unsorted structure values before evaluation', async () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    buildGraphScratch(tool, session.sessionId);
+
+    await tool.setModelValues(
+      {
+        set: [
+          { target: 1, value: { 0: 'a', 1: 'b', 2: 'c' } },
+          {
+            target: 2,
+            value: [
+              [TUPLE_ID, 1, 2],
+              [TUPLE_ID, 0, 2],
+              [TUPLE_ID, 0, 1],
+              [TUPLE_ID, 1, 0],
+              [TUPLE_ID, 0, 1]
+            ]
+          }
+        ]
+      },
+      session.sessionId
+    );
+
+    const stored = tool.getModelState(session.sessionId).items.find(item => item.id === 2);
+    expect(stored?.value).toEqual([
+      [TUPLE_ID, 0, 1],
+      [TUPLE_ID, 0, 2],
+      [TUPLE_ID, 1, 0],
+      [TUPLE_ID, 1, 2]
+    ]);
+
+    // S1 \ inverse(S1): (0,1) and (1,0) cancel out
+    const result = tool.evaluate({ constituentId: 4 }, session.sessionId);
+    expect(result.status).toBe(EvalStatus.HAS_DATA);
+    expect(result.value).toEqual([
+      [TUPLE_ID, 0, 2],
+      [TUPLE_ID, 1, 2]
+    ]);
+  });
+
+  it('evaluates scratch expressions that reference derived constituents', async () => {
+    const tool = new RSToolAgent();
+    const session = tool.createSession();
+    buildGraphScratch(tool, session.sessionId);
+    await tool.setModelValues(
+      {
+        set: [
+          { target: 1, value: { 0: 'a', 1: 'b', 2: 'c' } },
+          {
+            target: 2,
+            value: [
+              [TUPLE_ID, 0, 1],
+              [TUPLE_ID, 0, 2],
+              [TUPLE_ID, 1, 0],
+              [TUPLE_ID, 1, 2]
+            ]
+          }
+        ]
+      },
+      session.sessionId
+    );
+
+    const direct = tool.evaluate({ expression: 'card(D2)', cstType: CstType.TERM }, session.sessionId);
+    expect(direct.success).toBe(true);
+    expect(direct.value).toBe(2);
+
+    // F1 body references D2, which must be computed before the call
+    const viaFunction = tool.evaluate(
+      { expression: 'card(red(I{F1[ξ] | ξ:∈Pr1(D2)}))', cstType: CstType.TERM },
+      session.sessionId
+    );
+    expect(viaFunction.success).toBe(true);
+    expect(viaFunction.value).toBe(1);
+
+    const logic = tool.evaluate({ expression: 'D2⊆S1', cstType: CstType.AXIOM }, session.sessionId);
+    expect(logic.success).toBe(true);
+    expect(logic.value).toBe(1);
+  });
+
   it('throws when evaluate input is incomplete', () => {
     const tool = new RSToolAgent();
     const session = tool.createSession();

package/src/models/tool-contract.ts

@@ -15,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.2.0';
+export const CONTRACT_VERSION = '3.3.0';
 
 /** Options for constructing an {@link RSToolAgent}. */
 export interface RSToolAgentOptions {

package/src/wrapper/client.test.ts

@@ -5,14 +5,53 @@ import { describe, expect, it } from 'vitest';
 import { CstType, EvalStatus, RSToolWrapperClient } from '../index';
 
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const tsxCli = fileURLToPath(import.meta.resolve('tsx/cli'));
+const wrapperEntry = resolve(packageRoot, 'src/wrapper/stdio-wrapper.ts');
 
 describe('RSToolWrapperClient integration', () => {
+  it('rejects readiness and calls when the wrapper command cannot start', async () => {
+    const client = new RSToolWrapperClient({
+      command: resolve(packageRoot, 'definitely-missing-rstool-wrapper-binary'),
+      args: [],
+      cwd: packageRoot
+    });
+    try {
+      await expect(client.waitUntilReady()).rejects.toThrow(/ENOENT/);
+      await expect(client.call('methods')).rejects.toThrow(/ENOENT/);
+    } finally {
+      await client.close();
+    }
+  }, 30_000);
+
+  it('rejects outstanding calls when the wrapper exits before responding', async () => {
+    const client = new RSToolWrapperClient({
+      command: process.execPath,
+      args: ['-e', 'process.stdin.resume(); setTimeout(() => process.exit(3), 200)'],
+      cwd: packageRoot
+    });
+    try {
+      await expect(client.call('methods')).rejects.toThrow(/exited before responding \(code 3/);
+    } finally {
+      await client.close();
+    }
+  }, 30_000);
+
+  it('starts the default npm wrapper without a shell', async () => {
+    const client = new RSToolWrapperClient({ cwd: packageRoot });
+    try {
+      await client.waitUntilReady();
+      const methods = await client.call<string[]>('methods');
+      expect(methods).toContain('applySchemaPatch');
+    } finally {
+      await client.close();
+    }
+  }, 30_000);
+
   it('runs createSession, patch, model, and evaluate over stdio', async () => {
     const client = new RSToolWrapperClient({
-      command: 'npx',
-      args: ['tsx', resolve(packageRoot, 'src/wrapper/stdio-wrapper.ts')],
-      cwd: packageRoot,
-      shell: true
+      command: process.execPath,
+      args: [tsxCli, wrapperEntry],
+      cwd: packageRoot
     });
 
     try {

package/src/wrapper/client.ts

@@ -1,4 +1,6 @@
 import { spawn, type ChildProcessByStdio } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import readline from 'node:readline';
 import { type Readable, type Writable } from 'node:stream';
 
@@ -16,14 +18,38 @@ export interface WrapperResponse<T = unknown> {
 
 /** Options for spawning the `rstool-wrapper` child process. */
 export interface RSToolWrapperClientOptions {
-  /** Executable to spawn. Default: `npm`. */
+  /** Executable to spawn. Default: `npm`. Passed as argv, not a shell string. */
   command?: string;
   /** Arguments passed to `command`. Default: `['run', 'wrapper']`. */
   args?: string[];
   /** Working directory for the child process. Default: `process.cwd()`. */
   cwd?: string;
-  /** Whether to run the command in a shell. Default: `true`. */
-  shell?: boolean;
+}
+
+/**
+ * Rewrite Windows npm/npx shims to `node <npm-cli.js>` so spawn() never needs a shell.
+ * Node 20+ refuses to exec `.cmd` files without `shell: true` (CVE-2024-27980).
+ */
+function resolveSpawn(command: string, args: string[]): { command: string; args: string[] } {
+  if (process.platform !== 'win32') {
+    return { command, args };
+  }
+  const base = (command.replaceAll('\\', '/').split('/').pop() ?? command).toLowerCase();
+  if (base === 'npm' || base === 'npm.cmd') {
+    return { command: process.execPath, args: [bundledNpmBin('npm-cli.js'), ...args] };
+  }
+  if (base === 'npx' || base === 'npx.cmd') {
+    return { command: process.execPath, args: [bundledNpmBin('npx-cli.js'), ...args] };
+  }
+  return { command, args };
+}
+
+function bundledNpmBin(bin: 'npm-cli.js' | 'npx-cli.js'): string {
+  const cli = join(dirname(process.execPath), 'node_modules', 'npm', 'bin', bin);
+  if (!existsSync(cli)) {
+    throw new Error(`Cannot resolve ${bin} next to Node at ${process.execPath}`);
+  }
+  return cli;
 }
 
 /**
@@ -34,16 +60,20 @@ export interface RSToolWrapperClientOptions {
 export class RSToolWrapperClient {
   private process: ChildProcessByStdio<Writable, Readable, null>;
   private input: readline.Interface;
-  private pending = new Map<string, (value: WrapperResponse) => void>();
+  private pending = new Map<string, PendingCall>();
   private requestCounter = 1;
+  /** Set once the child cannot start or has exited; every later request fails with this error. */
+  private failure: Error | null = null;
+  private closing = false;
 
   /**
    * @param options - Spawn configuration; defaults run `npm run wrapper` in the current directory.
    */
   public constructor(options: RSToolWrapperClientOptions = {}) {
-    this.process = spawn(options.command ?? 'npm', options.args ?? ['run', 'wrapper'], {
+    const resolved = resolveSpawn(options.command ?? 'npm', options.args ?? ['run', 'wrapper']);
+    this.process = spawn(resolved.command, resolved.args, {
       cwd: options.cwd ?? process.cwd(),
-      shell: options.shell ?? true,
+      windowsHide: true,
       stdio: ['pipe', 'pipe', 'inherit']
     });
     this.input = readline.createInterface({
@@ -51,9 +81,25 @@ export class RSToolWrapperClient {
       crlfDelay: Infinity
     });
     this.input.on('line', line => this.handleLine(line));
+
+    // Without these listeners a failed spawn (ENOENT, EACCES) or a broken stdin pipe
+    // surfaces as an uncaught exception instead of a rejected promise.
+    this.process.on('error', error => this.fail(error));
+    this.process.stdin.on('error', error => this.fail(error));
+    this.process.on('exit', (code, signal) => {
+      if (this.closing) {
+        this.fail(new Error('Wrapper closed'));
+        return;
+      }
+      this.fail(new Error(`Wrapper exited before responding (code ${code ?? 'null'}, signal ${signal ?? 'null'})`));
+    });
   }
 
-  /** Block until the wrapper emits its initial `{ ready: true }` event. */
+  /**
+   * Block until the wrapper emits its initial `{ ready: true }` event.
+   *
+   * @throws When the wrapper process cannot be started or exits before becoming ready.
+   */
   public async waitUntilReady(): Promise<void> {
     for (;;) {
       const line = await this.readOneEvent();
@@ -74,13 +120,16 @@ export class RSToolWrapperClient {
    *
    * @param method - Stdio method name (matches {@link RSToolAgentContract} operations).
    * @param params - Method parameters object.
-   * @throws When the wrapper responds with `ok: false`.
+   * @throws When the wrapper responds with `ok: false`, cannot be started, or exits before responding.
    */
   public async call<T>(method: string, params: unknown = {}): Promise<T> {
+    if (this.failure) {
+      throw this.failure;
+    }
     const id = String(this.requestCounter++);
     const payload = JSON.stringify({ id, method, params });
-    const responsePromise = new Promise<WrapperResponse>(resolve => {
-      this.pending.set(id, resolve);
+    const responsePromise = new Promise<WrapperResponse>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
     });
     this.process.stdin.write(`${payload}\n`);
     const response = await responsePromise;
@@ -92,14 +141,20 @@ export class RSToolWrapperClient {
 
   /** Close stdin and terminate the wrapper process. */
   public async close(): Promise<void> {
+    this.closing = true;
     this.input.close();
-    this.process.stdin.end();
-    if (!this.process.killed) {
+    if (!this.process.stdin.destroyed) {
+      this.process.stdin.end();
+    }
+    if (this.process.exitCode === null && !this.process.killed) {
       this.process.kill();
     }
   }
 
   private async readOneEvent(): Promise<string> {
+    if (this.failure) {
+      throw this.failure;
+    }
     return new Promise((resolve, reject) => {
       const onLine = (line: string) => {
         cleanup();
@@ -107,17 +162,36 @@ export class RSToolWrapperClient {
       };
       const onExit = () => {
         cleanup();
-        reject(new Error('Wrapper exited before ready'));
+        reject(this.failure ?? new Error('Wrapper exited before ready'));
+      };
+      const onError = (error: Error) => {
+        cleanup();
+        reject(error);
       };
       const cleanup = () => {
         this.input.off('line', onLine);
         this.process.off('exit', onExit);
+        this.process.off('error', onError);
       };
       this.input.on('line', onLine);
       this.process.on('exit', onExit);
+      this.process.on('error', onError);
     });
   }
 
+  /** Records the terminal failure and rejects every outstanding request. */
+  private fail(error: Error): void {
+    if (this.failure) {
+      return;
+    }
+    this.failure = error;
+    const outstanding = [...this.pending.values()];
+    this.pending.clear();
+    for (const entry of outstanding) {
+      entry.reject(error);
+    }
+  }
+
   private handleLine(line: string): void {
     let parsed: WrapperResponse;
     try {
@@ -129,11 +203,16 @@ export class RSToolWrapperClient {
       return;
     }
     const id = String(parsed.id);
-    const resolver = this.pending.get(id);
-    if (!resolver) {
+    const entry = this.pending.get(id);
+    if (!entry) {
       return;
     }
     this.pending.delete(id);
-    resolver(parsed);
+    entry.resolve(parsed);
   }
 }
+
+interface PendingCall {
+  resolve: (value: WrapperResponse) => void;
+  reject: (reason: Error) => void;
+}

package/src/wrapper/stdio-handler.test.ts

@@ -98,4 +98,47 @@ describe('handleStdioRequest', () => {
     expect((all.result as unknown[]).length).toBeGreaterThan(0);
     expect(filtered.result).toEqual(all.result);
   });
+
+  it('filters diagnostics by flat kind and severity params', async () => {
+    const sessionTool = new RSToolAgent();
+    const created = await handleStdioRequest(sessionTool, { id: 30, method: 'createSession' });
+    const sessionId = (created.result as { sessionId: string }).sessionId;
+    // X1 without convention → schema diagnostic; D1 with broken formula → expression diagnostic
+    await handleStdioRequest(sessionTool, {
+      id: 31,
+      method: 'applySchemaPatch',
+      params: {
+        sessionId,
+        mode: 'best_effort',
+        items: [{ alias: 'X1' }, { alias: 'D1', definitionFormal: 'Pr1(' }]
+      }
+    });
+
+    const all = await handleStdioRequest(sessionTool, { id: 32, method: 'listDiagnostics', params: { sessionId } });
+    const kinds = new Set((all.result as { kind: string }[]).map(item => item.kind));
+    expect(kinds.has('schema')).toBe(true);
+    expect(kinds.has('expression')).toBe(true);
+
+    const schemaOnly = await handleStdioRequest(sessionTool, {
+      id: 33,
+      method: 'listDiagnostics',
+      params: { sessionId, kind: 'schema' }
+    });
+    expect((schemaOnly.result as { kind: string }[]).every(item => item.kind === 'schema')).toBe(true);
+    expect((schemaOnly.result as unknown[]).length).toBeLessThan((all.result as unknown[]).length);
+
+    const warningsOnly = await handleStdioRequest(sessionTool, {
+      id: 34,
+      method: 'listDiagnostics',
+      params: { sessionId, severity: 'warning' }
+    });
+    expect((warningsOnly.result as { severity: string }[]).every(item => item.severity === 'warning')).toBe(true);
+
+    const legacy = await handleStdioRequest(sessionTool, {
+      id: 35,
+      method: 'listDiagnostics',
+      params: { sessionId, filters: { kind: 'schema' } }
+    });
+    expect(legacy.result).toEqual(schemaOnly.result);
+  });
 });

package/src/wrapper/stdio-handler.ts

@@ -1,3 +1,4 @@
+import type { ListDiagnosticsFilters } from '../models/diagnostic';
 import type { RSToolAgent } from '../models/rstool-agent';
 
 export interface StdioRequest {
@@ -63,6 +64,22 @@ function omitSessionId(input: Record<string, unknown>): Record<string, unknown>
   return rest;
 }
 
+/** Flat `constituentId` / `kind` / `severity` params; legacy nested `filters` object is still accepted. */
+function diagnosticsFilters(input: Record<string, unknown>): ListDiagnosticsFilters | undefined {
+  const source = { ...asObject(input.filters), ...omitSessionId(input) };
+  const filters: ListDiagnosticsFilters = {};
+  if (typeof source.constituentId === 'number') {
+    filters.constituentId = source.constituentId;
+  }
+  if (source.kind === 'expression' || source.kind === 'schema' || source.kind === 'model') {
+    filters.kind = source.kind;
+  }
+  if (source.severity === 'error' || source.severity === 'warning') {
+    filters.severity = source.severity;
+  }
+  return Object.keys(filters).length > 0 ? filters : undefined;
+}
+
 export async function handleStdioRequest(tool: RSToolAgent, request: StdioRequest): Promise<StdioResponse> {
   try {
     const params = asObject(request.params);
@@ -110,15 +127,12 @@ export async function handleStdioRequest(tool: RSToolAgent, request: StdioReques
             optionalSessionId(params)
           )
         };
-      case 'listDiagnostics': {
-        const constituentId = params.constituentId;
-        const filters = typeof constituentId === 'number' ? { constituentId } : (params.filters as never);
+      case 'listDiagnostics':
         return {
           id: request.id,
           ok: true,
-          result: tool.listDiagnostics(filters, optionalSessionId(params))
+          result: tool.listDiagnostics(diagnosticsFilters(params), optionalSessionId(params))
         };
-      }
       case 'analyzeExpression':
         return {
           id: request.id,

package/dist/diagnostic-assembly-B-6vIA5I.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostic-assembly-B-6vIA5I.js","names":[],"sources":["../src/mappers/diagnostic-assembly.ts"],"sourcesContent":["import {\n  type CstDiagnostic,\n  DiagnosticKind,\n  modelStatusCstDiagnostic,\n  RSDiagnosticCode\n} from '@rsconcept/domain/library';\nimport { type DiagnosticSourceFields } from '@rsconcept/domain/library/rsform-api';\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: DiagnosticSourceFields, 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: DiagnosticSourceFields): Diagnostic | null {\n  const base = modelStatusCstDiagnostic(status, cst.cst_type);\n  return base ? expandCstDiagnostic(cst, base) : null;\n}\n\nfunction expressionForCstDiagnostic(cst: DiagnosticSourceFields, 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    case RSDiagnosticCode.schemaDependencyCycle:\n    case RSDiagnosticCode.schemaFormalDuplicate:\n      return cst.definition_formal;\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,KAA6B,YAAuC;CACtG,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,KAAgD;CACxG,MAAM,OAAO,yBAAyB,QAAQ,IAAI,QAAQ;CAC1D,OAAO,OAAO,oBAAoB,KAAK,IAAI,IAAI;AACjD;AAEA,SAAS,2BAA2B,KAA6B,YAAmC;CAClG,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,KAAK,iBAAiB;EACtB,KAAK,iBAAiB,uBACpB,OAAO,IAAI;EACb,SACE,OAAO,IAAI;CACf;AACF"}