@ontrails/testing 1.0.0-beta.2 → 1.0.0-beta.21

package/src/surface-parity.ts

@@ -0,0 +1,389 @@
+/**
+ * Example-driven parity checks across shipped surfaces.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { deriveCliPath, filterSurfaceTrails } from '@ontrails/core';
+import type {
+  ResourceOverrideMap,
+  Topo,
+  Trail,
+  TrailContext,
+  TrailExample,
+} from '@ontrails/core';
+import { deriveHttpInputSource, deriveHttpMethod } from '@ontrails/http';
+import type { HttpMethod } from '@ontrails/http';
+import { MCP_TOOL_ERROR_META_KEY, deriveToolName } from '@ontrails/mcp';
+
+import type { TestAllEstablishedOptions } from './all-established.js';
+import {
+  createMockResources,
+  defaultCreatePermit,
+  mergeResourceOverrides,
+  mergeTestContext,
+} from './context.js';
+import { deriveTrailExamples } from './effective-examples.js';
+import { createCliHarness } from './harness-cli.js';
+import type { CliHarnessResult } from './harness-cli.js';
+import { createHttpHarness } from './harness-http.js';
+import type { HttpHarnessResult } from './harness-http.js';
+import { createMcpHarness } from './harness-mcp.js';
+import type { McpHarnessResult } from './harness-mcp.js';
+
+type ParityTrail = Trail<unknown, unknown, unknown>;
+
+export type SurfaceParitySurface = 'cli' | 'mcp' | 'http';
+
+export interface SurfaceParityExclusion {
+  /** Optional example name. Omit to exclude every example for the trail. */
+  readonly example?: string | undefined;
+  /** Human-readable reason shown in the skipped test name. */
+  readonly reason: string;
+  /** Trail ID to exclude. */
+  readonly trailId: string;
+}
+
+export interface SurfaceParityOptions extends TestAllEstablishedOptions {
+  readonly createResources?:
+    | (() => ResourceOverrideMap | Promise<ResourceOverrideMap>)
+    | undefined;
+  readonly exclusions?: readonly SurfaceParityExclusion[] | undefined;
+}
+
+export type NormalizedSurfaceParityResult =
+  | {
+      readonly ok: true;
+      readonly value: unknown;
+    }
+  | {
+      readonly error: {
+        readonly category: string;
+        readonly code: string;
+      };
+      readonly ok: false;
+    };
+
+export interface SurfaceParityComparison {
+  readonly cli: NormalizedSurfaceParityResult;
+  readonly http: NormalizedSurfaceParityResult;
+  readonly mcp: NormalizedSurfaceParityResult;
+}
+
+const httpPathForTrail = (trailId: string): string =>
+  `/${trailId.replaceAll('.', '/')}`;
+
+const escapeWhitespaceForCliToken = (value: string): string =>
+  value.replaceAll(/\s/gu, (char) => {
+    let escaped = '';
+
+    for (let index = 0; index < char.length; index += 1) {
+      const codePoint = char.codePointAt(index);
+
+      if (codePoint !== undefined) {
+        escaped += `\\u${codePoint.toString(16).padStart(4, '0')}`;
+      }
+    }
+
+    return escaped;
+  });
+
+const cliCommandForExample = (
+  trail: ParityTrail,
+  example: TrailExample<unknown, unknown>
+): string => {
+  const path = deriveCliPath(trail.id).join(' ');
+  const inputJson = escapeWhitespaceForCliToken(
+    JSON.stringify(example.input ?? {})
+  );
+  return `${path} --input-json ${inputJson} --output json`;
+};
+
+const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const readTextContent = (content: unknown): string | undefined => {
+  if (!Array.isArray(content)) {
+    return undefined;
+  }
+  const firstText = content.find(
+    (item): item is { readonly text: string; readonly type: string } =>
+      isObjectRecord(item) &&
+      item['type'] === 'text' &&
+      typeof item['text'] === 'string'
+  );
+  return firstText?.text;
+};
+
+const parseJsonText = (text: string | undefined): unknown => {
+  if (text === undefined) {
+    return undefined;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+
+const structuredContentValue = (
+  structuredContent: Record<string, unknown> | undefined
+): unknown => {
+  if (structuredContent === undefined) {
+    return undefined;
+  }
+  const keys = Object.keys(structuredContent);
+  return keys.length === 1 && keys[0] === 'data'
+    ? structuredContent['data']
+    : structuredContent;
+};
+
+const normalizeCliResult = (
+  result: CliHarnessResult
+): NormalizedSurfaceParityResult =>
+  result.exitCode === 0
+    ? { ok: true, value: result.json }
+    : {
+        error: {
+          category: result.error?.category ?? 'internal',
+          code: result.error?.code ?? 'InternalError',
+        },
+        ok: false,
+      };
+
+const normalizeHttpResult = (
+  result: HttpHarnessResult
+): NormalizedSurfaceParityResult =>
+  result.ok
+    ? { ok: true, value: result.data }
+    : {
+        error: {
+          category: result.error?.category ?? 'internal',
+          code: result.error?.code ?? 'InternalError',
+        },
+        ok: false,
+      };
+
+const readMcpError = (
+  result: McpHarnessResult
+): { readonly category: string; readonly code: string } => {
+  const errorMeta = result.meta?.[MCP_TOOL_ERROR_META_KEY];
+  if (isObjectRecord(errorMeta)) {
+    return {
+      category:
+        typeof errorMeta['category'] === 'string'
+          ? errorMeta['category']
+          : 'internal',
+      code:
+        typeof errorMeta['name'] === 'string'
+          ? errorMeta['name']
+          : 'InternalError',
+    };
+  }
+  return { category: 'internal', code: 'InternalError' };
+};
+
+const normalizeMcpResult = (
+  result: McpHarnessResult
+): NormalizedSurfaceParityResult =>
+  result.isError
+    ? { error: readMcpError(result), ok: false }
+    : {
+        ok: true,
+        value:
+          result.structuredContent === undefined
+            ? parseJsonText(readTextContent(result.content))
+            : structuredContentValue(result.structuredContent),
+      };
+
+const applyAutoPermit = (
+  ctx: TrailContext,
+  trail: ParityTrail,
+  options: SurfaceParityOptions
+): TrailContext => {
+  if (options.strictPermits || ctx.permit !== undefined) {
+    return ctx;
+  }
+  const permit = (options.createPermit ?? defaultCreatePermit)(trail);
+  return permit === undefined ? ctx : { ...ctx, permit };
+};
+
+const createInvocationContext = async (
+  app: Topo,
+  trail: ParityTrail,
+  options: SurfaceParityOptions
+) => {
+  const autoResources =
+    options.createResources === undefined
+      ? await createMockResources(app)
+      : await options.createResources();
+  const resources = mergeResourceOverrides(
+    autoResources,
+    options.ctx,
+    options.resources
+  );
+  const ctx = applyAutoPermit(mergeTestContext(options.ctx), trail, options);
+  return { ctx, resources };
+};
+
+const mergeSurfaceContext = (
+  ctx: TrailContext,
+  surfaceCtx: Partial<TrailContext> | undefined
+): TrailContext =>
+  surfaceCtx === undefined ? ctx : mergeTestContext({ ...ctx, ...surfaceCtx });
+
+const runCliExample = async (
+  app: Topo,
+  trail: ParityTrail,
+  example: TrailExample<unknown, unknown>,
+  options: SurfaceParityOptions
+): Promise<NormalizedSurfaceParityResult> => {
+  const { ctx, resources } = await createInvocationContext(app, trail, options);
+  const cliOptions = options.cli;
+  const harness = createCliHarness({
+    graph: app,
+    ...cliOptions,
+    ctx: mergeSurfaceContext(ctx, cliOptions?.ctx),
+    resources,
+  });
+  return normalizeCliResult(
+    await harness.run(cliCommandForExample(trail, example))
+  );
+};
+
+const runMcpExample = async (
+  app: Topo,
+  trail: ParityTrail,
+  example: TrailExample<unknown, unknown>,
+  options: SurfaceParityOptions
+): Promise<NormalizedSurfaceParityResult> => {
+  const { ctx, resources } = await createInvocationContext(app, trail, options);
+  const mcpOptions = options.mcp;
+  const harness = createMcpHarness({
+    graph: app,
+    ...mcpOptions,
+    createContext: async () =>
+      mergeSurfaceContext(ctx, await mcpOptions?.createContext?.()),
+    resources,
+  });
+  const toolName = deriveToolName(app.name, trail.id);
+  return normalizeMcpResult(
+    await harness.callTool(
+      toolName,
+      isObjectRecord(example.input) ? example.input : {}
+    )
+  );
+};
+
+const httpRequestForExample = (
+  method: HttpMethod,
+  trailId: string,
+  example: TrailExample<unknown, unknown>
+) => {
+  const input = isObjectRecord(example.input) ? example.input : {};
+  return deriveHttpInputSource(method) === 'query'
+    ? { method, path: httpPathForTrail(trailId), query: input }
+    : { body: input, method, path: httpPathForTrail(trailId) };
+};
+
+const runHttpExample = async (
+  app: Topo,
+  trail: ParityTrail,
+  example: TrailExample<unknown, unknown>,
+  options: SurfaceParityOptions
+): Promise<NormalizedSurfaceParityResult> => {
+  const { ctx, resources } = await createInvocationContext(app, trail, options);
+  const httpOptions = options.http;
+  const harness = createHttpHarness({
+    graph: app,
+    ...httpOptions,
+    ctx: mergeSurfaceContext(ctx, httpOptions?.ctx),
+    resources,
+  });
+  const method = deriveHttpMethod(trail.intent);
+  return normalizeHttpResult(
+    await harness.request(httpRequestForExample(method, trail.id, example))
+  );
+};
+
+export const runSurfaceParityExample = async (
+  app: Topo,
+  trail: ParityTrail,
+  example: TrailExample<unknown, unknown>,
+  options: SurfaceParityOptions = {}
+): Promise<SurfaceParityComparison> => {
+  // CLI harness output capture is process-scoped, so keep surface execution
+  // ordered even though MCP and HTTP do not share that constraint.
+  const cli = await runCliExample(app, trail, example, options);
+  const mcp = await runMcpExample(app, trail, example, options);
+  const http = await runHttpExample(app, trail, example, options);
+  return { cli, http, mcp };
+};
+
+const findExclusion = (
+  exclusions: readonly SurfaceParityExclusion[] | undefined,
+  trail: ParityTrail,
+  example: TrailExample<unknown, unknown>
+): SurfaceParityExclusion | undefined =>
+  exclusions?.find(
+    (exclusion) =>
+      exclusion.trailId === trail.id &&
+      (exclusion.example === undefined || exclusion.example === example.name)
+  );
+
+const parityTrails = (app: Topo): readonly ParityTrail[] =>
+  filterSurfaceTrails(app.list()).filter(
+    (trail) => deriveTrailExamples(trail).length > 0
+  );
+
+/**
+ * Register example-driven parity tests for CLI, MCP, and HTTP.
+ *
+ * @example
+ * ```ts
+ * import { testSurfaceParity } from '@ontrails/testing/surface-parity';
+ * import { graph } from '../src/app.js';
+ *
+ * testSurfaceParity(graph);
+ * ```
+ */
+export const testSurfaceParity = (
+  app: Topo,
+  optionsOrFactory?:
+    | SurfaceParityOptions
+    | (() => SurfaceParityOptions | undefined)
+): void => {
+  const resolveOptions =
+    typeof optionsOrFactory === 'function'
+      ? optionsOrFactory
+      : () => optionsOrFactory;
+
+  describe('surface parity', () => {
+    for (const trail of parityTrails(app)) {
+      describe(trail.id, () => {
+        for (const example of deriveTrailExamples(trail)) {
+          const options = resolveOptions() ?? {};
+          const exclusion = findExclusion(options.exclusions, trail, example);
+          const testName = `example: ${example.name}`;
+          if (exclusion !== undefined) {
+            test.skip(`${testName} (excluded: ${exclusion.reason})`, () => {
+              throw new Error('Skipped parity exclusion should not execute');
+            });
+            continue;
+          }
+
+          test(testName, async () => {
+            const comparison = await runSurfaceParityExample(
+              app,
+              trail,
+              example,
+              resolveOptions() ?? {}
+            );
+            expect(comparison.mcp).toEqual(comparison.cli);
+            expect(comparison.http).toEqual(comparison.cli);
+          });
+        }
+      });
+    }
+  });
+};

package/src/trail.ts

@@ -82,7 +82,7 @@ const runScenario = async (
   }
   const validatedInput = expectOk(validated);
 
-  const result = await trailDef.implementation(validatedInput, testCtx);
+  const result = await trailDef.blaze(validatedInput, testCtx);
   assertScenarioResult(result, scenario, trailDef);
 };
 

package/src/types.ts

@@ -2,8 +2,8 @@
  * Shared types for @ontrails/testing.
  */
 
-import type { Logger, Topo } from '@ontrails/core';
-import type { LogLevel, LogRecord } from '@ontrails/logging';
+import type { AnyTrail, Logger, TraceFn } from '@ontrails/core';
+import type { LogLevel, LogRecord } from '@ontrails/observe';
 
 // ---------------------------------------------------------------------------
 // Test Scenario (for testTrail)
@@ -26,16 +26,16 @@ export interface TestScenario {
 }
 
 // ---------------------------------------------------------------------------
-// Hike Scenario (for testHike)
+// Compose Scenario (for testComposes)
 // ---------------------------------------------------------------------------
 
-/** A test scenario for a hike's composition graph. */
-export interface HikeScenario extends TestScenario {
-  /** Assert these trail IDs were followed, in order. */
-  readonly expectFollowed?: readonly string[] | undefined;
-  /** Assert follow counts per trail ID. */
-  readonly expectFollowedCount?: Readonly<Record<string, number>> | undefined;
-  /** Inject failure from a followed trail's example by description. */
+/** A test scenario for a trail's composing graph. */
+export interface ComposeScenario extends TestScenario {
+  /** Assert these trail IDs were composed, in order. */
+  readonly expectComposed?: readonly string[] | undefined;
+  /** Assert composing counts per trail ID. */
+  readonly expectComposedCount?: Readonly<Record<string, number>> | undefined;
+  /** Inject failure from a composed trail's example by description. */
   readonly injectFromExample?: Readonly<Record<string, string>> | undefined;
 }
 
@@ -65,53 +65,25 @@ export interface TestTrailContextOptions {
   readonly env?: Record<string, string> | undefined;
   readonly logger?: Logger | undefined;
   readonly requestId?: string | undefined;
-  readonly signal?: AbortSignal | undefined;
+  readonly abortSignal?: AbortSignal | undefined;
+  readonly trace?: TraceFn | undefined;
 }
 
 // ---------------------------------------------------------------------------
-// CLI Harness
+// Scenario (for composition testing)
 // ---------------------------------------------------------------------------
 
-/** Options for creating a CLI harness. */
-export interface CliHarnessOptions {
-  readonly app: Topo;
+/** Marker for compose-step references in scenario inputs. */
+export interface RefToken {
+  readonly __ref: true;
+  readonly path: string;
 }
 
-/** A test harness for CLI commands. */
-export interface CliHarness {
-  /** Execute a CLI command string and capture output. */
-  run(command: string): Promise<CliHarnessResult>;
-}
-
-/** The result of a CLI harness command execution. */
-export interface CliHarnessResult {
-  readonly exitCode: number;
-  /** Parsed JSON output if --output json was used. */
-  readonly json?: unknown | undefined;
-  readonly stderr: string;
-  readonly stdout: string;
-}
-
-// ---------------------------------------------------------------------------
-// MCP Harness
-// ---------------------------------------------------------------------------
-
-/** Options for creating an MCP harness. */
-export interface McpHarnessOptions {
-  readonly app: Topo;
-}
-
-/** A test harness for MCP tools. */
-export interface McpHarness {
-  /** Call an MCP tool by name with arguments. */
-  callTool(
-    name: string,
-    args: Record<string, unknown>
-  ): Promise<McpHarnessResult>;
-}
-
-/** The result of an MCP harness tool invocation. */
-export interface McpHarnessResult {
-  readonly content: unknown;
-  readonly isError: boolean;
+/** A single step in a scenario. */
+export interface ScenarioStep {
+  readonly compose: AnyTrail;
+  readonly input: Record<string, unknown>;
+  readonly as?: string | undefined;
+  readonly expected?: unknown | undefined;
+  readonly expectedMatch?: unknown | undefined;
 }

package/.turbo/turbo-build.log

@@ -1 +0,0 @@
-$ tsc -b

package/.turbo/turbo-lint.log

@@ -1,3 +0,0 @@
-$ oxlint ./src
-Found 0 warnings and 0 errors.
-Finished in 27ms on 20 files with 93 rules using 24 threads.

package/.turbo/turbo-typecheck.log

@@ -1 +0,0 @@
-$ tsc --noEmit

package/dist/all.d.ts

@@ -1,30 +0,0 @@
-/**
- * testAll — single-line governance suite for any Topo.
- *
- * Wraps topo validation, example execution, contract checks, and detour
- * verification into one describe block.
- */
-import type { Topo, TrailContext } from '@ontrails/core';
-/**
- * Run the full governance test suite for a Topo.
- *
- * Generates a `governance` describe block containing:
- * - Structural validation via `validateTopo`
- * - Example execution via `testExamples`
- * - Output contract checks via `testContracts`
- * - Detour target verification via `testDetours`
- *
- * Accepts either a static context or a factory function that produces a
- * fresh context per test (useful when the context contains mutable state
- * like an in-memory store).
- *
- * @example
- * ```ts
- * import { testAll } from '@ontrails/testing';
- * import { app } from '../src/app.js';
- *
- * testAll(app);
- * ```
- */
-export declare const testAll: (topo: Topo, ctxOrFactory?: Partial<TrailContext> | (() => Partial<TrailContext>)) => void;
-//# sourceMappingURL=all.d.ts.map

package/dist/all.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../src/all.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAOzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,OAAO,GAClB,MAAM,IAAI,EACV,eAAe,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,OAAO,CAAC,YAAY,CAAC,CAAC,KACnE,IAcF,CAAC"}

package/dist/all.js

@@ -1,47 +0,0 @@
-/**
- * testAll — single-line governance suite for any Topo.
- *
- * Wraps topo validation, example execution, contract checks, and detour
- * verification into one describe block.
- */
-import { describe, expect, test } from 'bun:test';
-import { validateTopo } from '@ontrails/core';
-import { testContracts } from './contracts.js';
-import { testDetours } from './detours.js';
-import { testExamples } from './examples.js';
-/**
- * Run the full governance test suite for a Topo.
- *
- * Generates a `governance` describe block containing:
- * - Structural validation via `validateTopo`
- * - Example execution via `testExamples`
- * - Output contract checks via `testContracts`
- * - Detour target verification via `testDetours`
- *
- * Accepts either a static context or a factory function that produces a
- * fresh context per test (useful when the context contains mutable state
- * like an in-memory store).
- *
- * @example
- * ```ts
- * import { testAll } from '@ontrails/testing';
- * import { app } from '../src/app.js';
- *
- * testAll(app);
- * ```
- */
-export const testAll = (topo, ctxOrFactory) => {
-    describe('governance', () => {
-        test('topo validates', () => {
-            const result = validateTopo(topo);
-            expect(result.isOk()).toBe(true);
-        });
-        // oxlint-disable-next-line jest/require-hook -- these generate describe/test blocks, not setup code
-        testExamples(topo, ctxOrFactory);
-        // oxlint-disable-next-line jest/require-hook -- these generate describe/test blocks, not setup code
-        testContracts(topo, ctxOrFactory);
-        // oxlint-disable-next-line jest/require-hook -- these generate describe/test blocks, not setup code
-        testDetours(topo);
-    });
-};
-//# sourceMappingURL=all.js.map

package/dist/all.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"all.js","sourceRoot":"","sources":["../src/all.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGlD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,IAAU,EACV,YAAoE,EAC9D,EAAE;IACR,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;QAC1B,IAAI,CAAC,gBAAgB,EAAE,GAAG,EAAE;YAC1B,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;YAClC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,oGAAoG;QACpG,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QACjC,oGAAoG;QACpG,aAAa,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAClC,oGAAoG;QACpG,WAAW,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/assertions.d.ts

@@ -1,49 +0,0 @@
-/**
- * Progressive assertion logic for example-driven testing.
- *
- * Three tiers:
- * 1. Full match — example has `expected` output
- * 2. Schema-only — no expected output, no error
- * 3. Error match — example declares an error class name
- */
-import type { Result } from '@ontrails/core';
-import type { z } from 'zod';
-/**
- * Assert that a Result is Ok and return its value.
- *
- * Eliminates the `if (result.isOk())` / `as unknown as` dance in tests.
- *
- * @example
- * ```typescript
- * const value = expectOk(result);
- * expect(value.name).toBe('Alice');
- * ```
- */
-export declare const expectOk: <T, E>(result: Result<T, E>) => T;
-/**
- * Assert that a Result is Err and return its error.
- *
- * Eliminates the `if (result.isErr())` / `as unknown as` dance in tests.
- *
- * @example
- * ```typescript
- * const error = expectErr(result);
- * expect(error).toBeInstanceOf(ValidationError);
- * ```
- */
-export declare const expectErr: <T, E>(result: Result<T, E>) => E;
-/**
- * Assert that the result is ok and its value deep-equals the expected output.
- */
-export declare const assertFullMatch: (result: Result<unknown, Error>, expected: unknown) => void;
-/**
- * Assert that the result is ok and, if an output schema is provided,
- * the value parses against it.
- */
-export declare const assertSchemaMatch: (result: Result<unknown, Error>, outputSchema: z.ZodType | undefined) => void;
-/**
- * Assert that the result is an error of the specified type, with optional
- * message substring matching.
- */
-export declare const assertErrorMatch: (result: Result<unknown, Error>, expectedError: new (...args: never[]) => Error, expectedMessage?: string) => void;
-//# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAM7B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAGrD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAGtD,CAAC;AAMF;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,QAAQ,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,EAC9B,UAAU,OAAO,KAChB,IAGF,CAAC;AAMF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,EAC9B,cAAc,CAAC,CAAC,OAAO,GAAG,SAAS,KAClC,IAUF,CAAC;AAMF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,EAC9B,eAAe,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,KAAK,EAC9C,kBAAkB,MAAM,KACvB,IAMF,CAAC"}