@ontrails/core 1.0.0-beta.15 → 1.0.0-beta.16

package/src/validate-topo.ts

@@ -1,20 +1,30 @@
 /**
  * Structural validation for a Topo graph.
  *
- * Checks trail crossing references, example input validity, event origin
- * references, and output schema completeness. Returns a Result with all
- * issues collected into a single ValidationError.
+ * Checks trail crossing references, example input validity, signal origin
+ * references, activation source kinds, and output schema completeness. Returns
+ * a Result with all issues collected into a single ValidationError.
  */
 
+import type { ActivationSchemaIssue } from './activation-source-compatibility.js';
+import { getActivationSourceInputCompatibilityIssues } from './activation-source-compatibility.js';
+import {
+  activationSourceDeclarationSignature,
+  activationSourceKey,
+} from './activation-source-projection.js';
 import type { AnyContour } from './contour.js';
 import { getContourReferences } from './contour.js';
 import { ValidationError } from './errors.js';
+import type { ActivationEntry } from './activation-source.js';
+import { isKnownActivationSourceKind } from './activation-source.js';
 import { isDraftId } from './draft.js';
 import type { AnySignal } from './signal.js';
+import { validateScheduleSource } from './schedule.js';
 import { Result } from './result.js';
 import type { Topo } from './topo.js';
 import type { AnyTrail } from './trail.js';
 import { validateInput } from './validation.js';
+import { validateWebhookSource } from './webhook.js';
 
 // ---------------------------------------------------------------------------
 // Issue shape
@@ -24,8 +34,14 @@ export interface TopoIssue {
   readonly trailId: string;
   readonly rule: string;
   readonly message: string;
+  readonly inputPath?: readonly (string | number)[];
+  readonly schemaIssues?: readonly TopoSchemaIssue[];
+  readonly sourceId?: string;
+  readonly sourceKind?: string;
 }
 
+export type TopoSchemaIssue = ActivationSchemaIssue;
+
 // ---------------------------------------------------------------------------
 // Validators
 // ---------------------------------------------------------------------------
@@ -205,6 +221,193 @@ const checkSignalOrigins = (
   return issues;
 };
 
+const checkSignalReferences = (
+  trails: ReadonlyMap<string, AnyTrail>,
+  signals: ReadonlyMap<string, AnySignal>
+): TopoIssue[] => {
+  const issues: TopoIssue[] = [];
+
+  for (const [id, trail] of trails) {
+    for (const signalId of trail.fires ?? []) {
+      if (!signals.has(signalId) && !isDraftId(signalId)) {
+        issues.push({
+          message: `Trail fires signal "${signalId}" which is not in the topo`,
+          rule: 'signal-fire-exists',
+          trailId: id,
+        });
+      }
+    }
+
+    for (const signalId of trail.on ?? []) {
+      if (!signals.has(signalId) && !isDraftId(signalId)) {
+        issues.push({
+          message: `Trail declares on signal "${signalId}" which is not in the topo`,
+          rule: 'signal-on-exists',
+          trailId: id,
+        });
+      }
+    }
+  }
+
+  return issues;
+};
+
+const checkActivationSources = (
+  trails: ReadonlyMap<string, AnyTrail>
+): TopoIssue[] => {
+  const issues: TopoIssue[] = [];
+  const sourceDeclarations = new Map<
+    string,
+    {
+      readonly signature: string;
+      readonly trailId: string;
+    }
+  >();
+  const trailSourceEdges = new Set<string>();
+
+  for (const [id, trail] of trails) {
+    for (const activation of trail.activationSources ?? []) {
+      if (!isKnownActivationSourceKind(activation.source.kind)) {
+        issues.push({
+          message: `Trail declares on source "${activation.source.id}" with unsupported source kind "${activation.source.kind}"`,
+          rule: 'activation-source-kind-known',
+          trailId: id,
+        });
+        continue;
+      }
+
+      const sourceKey = activationSourceKey(activation.source);
+      const edgeKey = `${id}\0${sourceKey}`;
+      if (trailSourceEdges.has(edgeKey)) {
+        issues.push({
+          message: `Trail declares activation source "${activation.source.id}" (${activation.source.kind}) more than once. Keep one source-to-trail activation edge, or split distinct activation behavior into distinct source ids.`,
+          rule: 'activation-source-edge-unique',
+          sourceId: activation.source.id,
+          sourceKind: activation.source.kind,
+          trailId: id,
+        });
+      } else {
+        trailSourceEdges.add(edgeKey);
+      }
+
+      if (!isDraftId(activation.source.id)) {
+        const signature = activationSourceDeclarationSignature(
+          activation.source
+        );
+        const previous = sourceDeclarations.get(sourceKey);
+        if (previous === undefined) {
+          sourceDeclarations.set(sourceKey, { signature, trailId: id });
+        } else if (previous.signature !== signature) {
+          issues.push({
+            message: `Activation source "${activation.source.id}" (${activation.source.kind}) is declared with conflicting source options by trails "${previous.trailId}" and "${id}". Use one canonical source declaration per source id, or give distinct source configurations distinct ids.`,
+            rule: 'activation-source-definition-unique',
+            sourceId: activation.source.id,
+            sourceKind: activation.source.kind,
+            trailId: id,
+          });
+        }
+      }
+
+      const scheduleIssues = validateScheduleSource(activation.source);
+      for (const issue of scheduleIssues) {
+        issues.push({
+          inputPath: [issue.field],
+          message: `Trail declares schedule source "${activation.source.id}" with invalid ${issue.field}: ${issue.message}`,
+          rule: 'activation-schedule-valid',
+          schemaIssues: [
+            { code: issue.field, message: issue.message, path: [issue.field] },
+          ],
+          sourceId: activation.source.id,
+          sourceKind: activation.source.kind,
+          trailId: id,
+        });
+      }
+
+      const webhookIssues = validateWebhookSource(activation.source);
+      for (const issue of webhookIssues) {
+        issues.push({
+          inputPath: [issue.field],
+          message: `Trail declares webhook source "${activation.source.id}" with invalid ${issue.field}: ${issue.message}`,
+          rule: 'activation-webhook-valid',
+          schemaIssues: [
+            { code: issue.field, message: issue.message, path: [issue.field] },
+          ],
+          sourceId: activation.source.id,
+          sourceKind: activation.source.kind,
+          trailId: id,
+        });
+      }
+    }
+  }
+
+  return issues;
+};
+
+const issuePathText = (path: readonly (string | number)[]): string =>
+  path.length > 0 ? path.join('.') : '<root>';
+
+const createSourceCompatibilityIssue = (
+  trailId: string,
+  activation: ActivationEntry,
+  schemaIssues: readonly TopoSchemaIssue[]
+): TopoIssue => {
+  const [firstIssue] = schemaIssues;
+  const inputPath = firstIssue?.path ?? Object.freeze([]);
+  return {
+    inputPath,
+    message: `Activation source "${activation.source.id}" (${activation.source.kind}) does not satisfy trail input at ${issuePathText(inputPath)}: ${firstIssue?.message ?? 'source payload is incompatible with trail input'}`,
+    rule: 'activation-source-input-compatible',
+    schemaIssues,
+    sourceId: activation.source.id,
+    sourceKind: activation.source.kind,
+    trailId,
+  };
+};
+
+const checkSourcePayloadCompatibility = (
+  trail: AnyTrail,
+  activation: ActivationEntry,
+  signals: ReadonlyMap<string, AnySignal>
+): TopoIssue | undefined => {
+  if (
+    !isKnownActivationSourceKind(activation.source.kind) ||
+    isDraftId(activation.source.id)
+  ) {
+    return undefined;
+  }
+
+  const schemaIssues = getActivationSourceInputCompatibilityIssues(
+    trail.input,
+    activation.source,
+    signals
+  );
+  if (!schemaIssues) {
+    return undefined;
+  }
+
+  return schemaIssues.length > 0
+    ? createSourceCompatibilityIssue(trail.id, activation, schemaIssues)
+    : undefined;
+};
+
+const checkActivationSourceInputCompatibility = (
+  trails: ReadonlyMap<string, AnyTrail>,
+  signals: ReadonlyMap<string, AnySignal>
+): TopoIssue[] => {
+  const issues: TopoIssue[] = [];
+
+  for (const trail of trails.values()) {
+    for (const activation of trail.activationSources ?? []) {
+      const issue = checkSourcePayloadCompatibility(trail, activation, signals);
+      if (issue) {
+        issues.push(issue);
+      }
+    }
+  }
+
+  return issues;
+};
+
 const checkContourReferences = (
   contours: ReadonlyMap<string, AnyContour>,
   topo: Topo
@@ -233,8 +436,9 @@ const checkContourReferences = (
 /**
  * Validate the structural integrity of a Topo graph.
  *
- * Checks crossing references, example inputs, event origins, and output
- * schema presence. Returns `Result.ok()` when no issues are found, or
+ * Checks crossing references, example inputs, signal origins, activation
+ * source kinds, and output schema presence. Returns `Result.ok()` when no
+ * issues are found, or
  * `Result.err(ValidationError)` with all issues in the error context.
  */
 export const validateTopo = (topo: Topo): Result<void, ValidationError> => {
@@ -244,6 +448,9 @@ export const validateTopo = (topo: Topo): Result<void, ValidationError> => {
     ...checkContourReferences(topo.contours, topo),
     ...checkExamples(topo.trails),
     ...checkSignalOrigins(topo.signals, topo),
+    ...checkSignalReferences(topo.trails, topo.signals),
+    ...checkActivationSources(topo.trails),
+    ...checkActivationSourceInputCompatibility(topo.trails, topo.signals),
   ];
 
   if (issues.length === 0) {

package/src/validation.ts

@@ -7,6 +7,7 @@
 
 import type { z } from 'zod';
 
+import { BLOB_REF_SCHEMA_META_KEY, blobRefJsonSchema } from './blob-ref.js';
 import { ValidationError } from './errors.js';
 import { Result } from './result.js';
 
@@ -31,10 +32,57 @@ type JsonSchemaConverter = (schema: z.ZodType) => JsonSchema;
 // ---------------------------------------------------------------------------
 
 const isOptionalLike = (s: ZodInternals): boolean => {
-  const defType = s._zod.def['type'] as string;
+  let current = s;
+  const seen = new Set<ZodInternals>();
+  while (
+    current._zod.def['type'] === 'readonly' &&
+    !seen.has(current) &&
+    current._zod.def['innerType'] !== undefined
+  ) {
+    seen.add(current);
+    current = current._zod.def['innerType'] as ZodInternals;
+  }
+  const defType = current._zod.def['type'] as string;
   return defType === 'optional' || defType === 'default';
 };
 
+const getSchemaMeta = (
+  schema: z.ZodType
+): Readonly<Record<string, unknown>> | undefined => {
+  const maybeMeta = (schema as unknown as { meta?: () => unknown }).meta;
+  if (typeof maybeMeta !== 'function') {
+    return undefined;
+  }
+  const meta = maybeMeta.call(schema);
+  return typeof meta === 'object' && meta !== null
+    ? (meta as Readonly<Record<string, unknown>>)
+    : undefined;
+};
+
+const getSchemaJsonSchemaOverride = (
+  schema: z.ZodType
+): JsonSchema | undefined => {
+  const meta = getSchemaMeta(schema);
+  if (meta?.[BLOB_REF_SCHEMA_META_KEY] === true) {
+    const override: JsonSchema = {
+      properties: Object.fromEntries(
+        Object.entries(blobRefJsonSchema.properties).map(([key, value]) => [
+          key,
+          { ...value },
+        ])
+      ),
+      required: [...blobRefJsonSchema.required],
+      type: blobRefJsonSchema.type,
+    };
+    const { description } = schema as unknown as ZodInternals;
+    if (description) {
+      override['description'] = description;
+    }
+    return override;
+  }
+  return undefined;
+};
+
 // ---------------------------------------------------------------------------
 // Issue formatting
 // ---------------------------------------------------------------------------
@@ -132,6 +180,11 @@ const resolveDefault = (def: Record<string, unknown>): unknown => {
 export const zodToJsonSchema: JsonSchemaConverter = (
   schema: z.ZodType
 ): JsonSchema => {
+  const jsonSchemaOverride = getSchemaJsonSchemaOverride(schema);
+  if (jsonSchemaOverride !== undefined) {
+    return jsonSchemaOverride;
+  }
+
   const s = schema as unknown as ZodInternals;
 
   const collectObjectFields = (shape: Record<string, ZodInternals>) => {
@@ -197,6 +250,10 @@ export const zodToJsonSchema: JsonSchemaConverter = (
       const inner = value._zod.def['innerType'] as unknown as z.ZodType;
       return zodToJsonSchema(inner);
     },
+    readonly: (value) => {
+      const inner = value._zod.def['innerType'] as unknown as z.ZodType;
+      return zodToJsonSchema(inner);
+    },
     string: () => ({ type: 'string' }),
     union: (value) => {
       const options = value._zod.def['options'] as unknown as z.ZodType[];

package/src/webhook.ts

@@ -0,0 +1,276 @@
+import type {
+  ActivationSource,
+  ActivationSourceMeta,
+  ActivationSourceParse,
+} from './activation-source.js';
+import { InternalError, ValidationError } from './errors.js';
+import { Result } from './result.js';
+
+export const webhookMethods = Object.freeze([
+  'DELETE',
+  'GET',
+  'PATCH',
+  'POST',
+  'PUT',
+] as const);
+
+export type WebhookMethod = (typeof webhookMethods)[number];
+export type WebhookMethodInput = WebhookMethod | Lowercase<WebhookMethod>;
+
+export type WebhookVerifyHeaders = Readonly<
+  Record<string, readonly string[] | string | undefined>
+>;
+
+export interface WebhookVerifyRequest {
+  readonly body: ArrayBuffer | Uint8Array | string;
+  readonly headers: WebhookVerifyHeaders;
+  readonly method: string;
+  readonly path: string;
+}
+
+export type WebhookVerify = (
+  request: WebhookVerifyRequest
+) => Promise<Result<void, Error>> | Result<void, Error>;
+
+export interface WebhookSpec<TOutput = unknown> {
+  readonly meta?: ActivationSourceMeta | undefined;
+  readonly method?: WebhookMethodInput | undefined;
+  readonly parse: ActivationSourceParse<TOutput>;
+  readonly path: string;
+  readonly payload?: ActivationSource['payload'] | undefined;
+  readonly verify?: WebhookVerify | undefined;
+}
+
+export interface WebhookSource<TOutput = unknown> extends ActivationSource {
+  readonly kind: 'webhook';
+  readonly meta?: ActivationSourceMeta | undefined;
+  readonly method: WebhookMethod;
+  readonly parse: ActivationSourceParse<TOutput>;
+  readonly path: string;
+  readonly payload?: ActivationSource['payload'] | undefined;
+  readonly verify?: WebhookVerify | undefined;
+}
+
+export interface WebhookValidationIssue {
+  readonly field: 'method' | 'parse' | 'path' | 'verify';
+  readonly message: string;
+}
+
+const DEFAULT_WEBHOOK_METHOD = 'POST' as const;
+
+const normalizeMethod = (
+  method: WebhookMethodInput | string | undefined
+): string => (method ?? DEFAULT_WEBHOOK_METHOD).trim().toUpperCase();
+
+const normalizePath = (path: string): string => path.trim();
+
+const isWebhookMethod = (method: string): method is WebhookMethod =>
+  (webhookMethods as readonly string[]).includes(method);
+
+const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const isZodSchema = (value: unknown): boolean =>
+  isObjectRecord(value) && typeof value['safeParse'] === 'function';
+
+const validateMethod = (
+  method: WebhookMethodInput | string | undefined
+): WebhookValidationIssue[] => {
+  const normalized = normalizeMethod(method);
+  return isWebhookMethod(normalized)
+    ? []
+    : [
+        {
+          field: 'method',
+          message: `Webhook method must be one of ${webhookMethods.join(', ')}`,
+        },
+      ];
+};
+
+const validatePath = (path: unknown): WebhookValidationIssue[] => {
+  if (typeof path !== 'string' || path.trim().length === 0) {
+    return [
+      {
+        field: 'path',
+        message: 'Webhook path must be a non-empty absolute path',
+      },
+    ];
+  }
+
+  const normalized = normalizePath(path);
+  return normalized.startsWith('/')
+    ? []
+    : [
+        {
+          field: 'path',
+          message: 'Webhook path must start with "/"',
+        },
+      ];
+};
+
+const validateRequiredParse = (parse: unknown): WebhookValidationIssue[] =>
+  parse === undefined
+    ? [
+        {
+          field: 'parse',
+          message: 'Webhook sources must define parse',
+        },
+      ]
+    : [];
+
+const validateParseShape = (parse: unknown): WebhookValidationIssue[] => {
+  if (parse === undefined || isZodSchema(parse)) {
+    return [];
+  }
+  if (isObjectRecord(parse) && isZodSchema(parse['output'])) {
+    return [];
+  }
+  return [
+    {
+      field: 'parse',
+      message: 'Webhook parse must be a Zod schema or define parse.output',
+    },
+  ];
+};
+
+const validateVerify = (verify: unknown): WebhookValidationIssue[] =>
+  verify === undefined || typeof verify === 'function'
+    ? []
+    : [
+        {
+          field: 'verify',
+          message: 'Webhook verify must be a function when provided',
+        },
+      ];
+
+const webhookIssuesMessage = (
+  id: string,
+  issues: readonly WebhookValidationIssue[]
+): string =>
+  `webhook("${id}") is invalid: ${issues.map((issue) => `${issue.field}: ${issue.message}`).join('; ')}`;
+
+const assertWebhookSpec = <TOutput>(
+  id: string,
+  spec: WebhookSpec<TOutput>
+): {
+  readonly method: WebhookMethod;
+  readonly path: string;
+} => {
+  const issues = [
+    ...validateMethod(spec.method),
+    ...validatePath(spec.path),
+    ...validateRequiredParse(spec.parse),
+    ...validateParseShape(spec.parse),
+    ...validateVerify(spec.verify),
+  ];
+
+  if (issues.length > 0) {
+    throw new ValidationError(webhookIssuesMessage(id, issues), {
+      context: { issues },
+    });
+  }
+
+  return {
+    method: normalizeMethod(spec.method) as WebhookMethod,
+    path: normalizePath(spec.path),
+  };
+};
+
+export const validateWebhookSource = (
+  source: ActivationSource
+): readonly WebhookValidationIssue[] => {
+  if (source.kind !== 'webhook') {
+    return [];
+  }
+
+  return [
+    ...validateMethod(source.method),
+    ...validatePath(source.path),
+    ...validateRequiredParse(source.parse),
+    ...validateParseShape(source.parse),
+    ...validateVerify(source.verify),
+  ];
+};
+
+const errorFromUnknown = (error: unknown): Error =>
+  error instanceof Error ? error : new Error(String(error));
+
+export const getWebhookHeaders = (
+  request: Pick<WebhookVerifyRequest, 'headers'>,
+  name: string
+): readonly string[] => {
+  const normalized = name.toLowerCase();
+  const matches: string[] = [];
+  for (const [headerName, value] of Object.entries(request.headers)) {
+    if (headerName.toLowerCase() !== normalized) {
+      continue;
+    }
+    if (value === undefined) {
+      continue;
+    }
+    if (typeof value === 'string') {
+      matches.push(value);
+    } else {
+      matches.push(...value);
+    }
+  }
+  return matches;
+};
+
+export const getWebhookHeader = (
+  request: Pick<WebhookVerifyRequest, 'headers'>,
+  name: string
+): string | undefined => {
+  const [first] = getWebhookHeaders(request, name);
+  return first;
+};
+
+export const verifyWebhookRequest = async (
+  source: Pick<WebhookSource, 'id' | 'verify'>,
+  request: WebhookVerifyRequest
+): Promise<Result<void, Error>> => {
+  if (source.verify === undefined) {
+    return Result.ok();
+  }
+
+  try {
+    return await source.verify(request);
+  } catch (error) {
+    const cause = errorFromUnknown(error);
+    return Result.err(
+      new InternalError(`Webhook source "${source.id}" verification threw`, {
+        cause,
+      })
+    );
+  }
+};
+
+export function webhook<TOutput>(
+  id: string,
+  spec: WebhookSpec<TOutput>
+): WebhookSource<TOutput>;
+export function webhook<TOutput>(
+  spec: WebhookSpec<TOutput> & { readonly id: string }
+): WebhookSource<TOutput>;
+export function webhook<TOutput>(
+  idOrSpec: string | (WebhookSpec<TOutput> & { readonly id: string }),
+  maybeSpec?: WebhookSpec<TOutput>
+): WebhookSource<TOutput> {
+  const id = typeof idOrSpec === 'string' ? idOrSpec : idOrSpec.id;
+  // oxlint-disable-next-line no-non-null-assertion -- overload guarantees maybeSpec when idOrSpec is string
+  const spec = typeof idOrSpec === 'string' ? maybeSpec! : idOrSpec;
+  const normalized = assertWebhookSpec(id, spec);
+
+  return Object.freeze({
+    id,
+    kind: 'webhook' as const,
+    method: normalized.method,
+    parse: spec.parse,
+    path: normalized.path,
+    ...(spec.meta === undefined
+      ? {}
+      : { meta: Object.freeze({ ...spec.meta }) }),
+    ...(spec.payload === undefined ? {} : { payload: spec.payload }),
+    ...(spec.verify === undefined ? {} : { verify: spec.verify }),
+  });
+}

package/src/{internal/zod-wrappers.ts → zod-wrappers.ts}

@@ -15,8 +15,6 @@
  * would be redundant at best and would produce an `OptionalOptional<T>` shape
  * in edge cases at worst. `nullable` wrappers are preserved because nullability
  * is a semantic constraint that `.partial()` does not reintroduce.
- *
- * @internal
  */
 
 import type { z } from 'zod';
@@ -35,8 +33,6 @@ const readInnerType = (schema: z.ZodType): z.ZodType =>
  * (`default`, `optional`, `nullable`), drops defaults, drops `optional` (the
  * downstream `.partial()` reintroduces it across the whole shape), and
  * preserves `nullable` so explicit nullability survives.
- *
- * @internal
  */
 export const stripDefaultWrappers = (schema: z.ZodType): z.ZodType => {
   let current = schema;
@@ -61,8 +57,6 @@ const asObjectSchema = (schema: z.ZodType): AnyObjectSchema =>
  * Apply {@link stripDefaultWrappers} to every field in a Zod object shape and
  * return the resulting shape record. Callers typically feed the result to
  * `.extend()` + `.partial()`.
- *
- * @internal
  */
 export const stripDefaultsFromShape = (
   schema: z.ZodType

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 66ms on 99 files with 93 rules using 24 threads.

package/.turbo/turbo-typecheck.log

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

package/dist/blob-ref.d.ts

@@ -1,20 +0,0 @@
-/**
- * BlobRef — a frozen reference to binary data for @ontrails/core.
- */
-/** Immutable reference to a blob of binary data. */
-export interface BlobRef {
-    readonly name: string;
-    readonly mimeType: string;
-    readonly size: number;
-    readonly data: Uint8Array | ReadableStream<Uint8Array>;
-}
-/** Creates a frozen BlobRef. */
-export declare const createBlobRef: (options: {
-    name: string;
-    mimeType: string;
-    size: number;
-    data: Uint8Array | ReadableStream<Uint8Array>;
-}) => BlobRef;
-/** Type guard for BlobRef-shaped values. */
-export declare const isBlobRef: (value: unknown) => value is BlobRef;
-//# sourceMappingURL=blob-ref.d.ts.map

package/dist/blob-ref.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blob-ref.d.ts","sourceRoot":"","sources":["../src/blob-ref.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,oDAAoD;AACpD,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC;CACxD;AAED,gCAAgC;AAChC,eAAO,MAAM,aAAa,GAAI,SAAS;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC;CAC/C,KAAG,OAMA,CAAC;AAEL,4CAA4C;AAC5C,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OAWnD,CAAC"}