@procedures/client 0.3.0 → 0.5.0

package/src/procedures/core/meta.ts

@@ -14,6 +14,7 @@ import {
   parseProcedureJson,
   stringifyProcedureJson,
   isAnyProcedureRef,
+  isProcedureRef,
   isOutputRef,
   isPlainObject,
   resolveOutputRef,
@@ -58,18 +59,37 @@ const ImportOutputSchema = z.looseObject({
 
 type ImportProcedure = Procedure<ImportInput, ImportOutput, { description: string; tags: string[] }>;
 
+/**
+ * This function gives true for the runtime form of a procedure reference whose path is a list of
+ * texts. `client.import` accepts only such a value at the top level.
+ */
+function isImportableRef(value: unknown): boolean {
+  if (!isProcedureRef(value)) return false;
+  const path = (value as { path?: unknown }).path;
+  return Array.isArray(path) && path.length > 0 && path.every((segment) => typeof segment === "string");
+}
+
 const importProcedure: ImportProcedure = defineProcedure({
   path: ["import"],
   input: ImportInputSchema,
   output: ImportOutputSchema,
   metadata: {
-    description: "Parse procedure aggregation from JSON string",
+    description:
+      "Parse a procedure reference ({ $proc, input }) from JSON text. Other JSON, for example a number or a list, gives success false.",
     tags: ["core", "meta"],
   },
   handler: async (input: ImportInput): Promise<ImportOutput> => {
     try {
       if (input.json) {
         const procedure = parseProcedureJson(input.json);
+        // Before, each JSON value gave success true, for example 42 (catalog test, roadmap R29)
+        if (!isImportableRef(procedure)) {
+          return {
+            procedure: null,
+            success: false,
+            error: "The JSON is not a procedure reference. A reference is an object whose $proc is a list of texts.",
+          };
+        }
         return { procedure, success: true };
       }
       if (input.path) {
@@ -107,8 +127,19 @@ interface ExportInput {
   pretty?: boolean | undefined;
 }
 
+/**
+ * This function gives a schema of a required value: undefined has no JSON text, so the input
+ * schema refuses it with `VALIDATION_ERROR`. Before, the call failed with
+ * `OUTPUT_VALIDATION_ERROR` (catalog test, roadmap R29).
+ */
+const definedValue = (description: string) =>
+  z
+    .unknown()
+    .refine((value) => value !== undefined, { message: "The value is missing: undefined has no JSON text" })
+    .describe(description);
+
 const ExportInputSchema = z.object({
-  procedure: z.unknown().optional().describe("Procedure reference to serialize"),
+  procedure: definedValue("The procedure reference to serialize. The procedure refuses a missing value (undefined) with VALIDATION_ERROR, because undefined has no JSON text."),
   pretty: z.boolean().optional().describe("Pretty print JSON output"),
 });
 
@@ -134,13 +165,15 @@ const exportProcedure: ExportProcedure = defineProcedure({
   input: ExportInputSchema,
   output: ExportOutputSchema,
   metadata: {
-    description: "Serialize procedure aggregation to JSON string",
+    description: "Serialize a procedure reference to JSON text. It refuses a missing procedure (undefined) with VALIDATION_ERROR.",
     // The refs of the input are data: exec() must not run them (deep dive CORE-5)
     tags: ["core", "meta", RAW_INPUT_TAG],
   },
   handler: async (input: ExportInput): Promise<ExportOutput> => {
     try {
-      const json = stringifyProcedureJson(input.procedure, input.pretty ? 2 : undefined);
+      const json = stringifyProcedureJson(input.procedure, input.pretty ? 2 : undefined) as string | undefined;
+      // A function or a symbol has no JSON text either: an error result, not an invalid output
+      if (json === undefined) return { json: "", success: false, error: "The procedure has no JSON text" };
       return { json, success: true };
     } catch (error) {
       return {
@@ -268,7 +301,7 @@ interface StringifyJsonInput {
 }
 
 const StringifyJsonInputSchema = z.object({
-  value: z.unknown().optional().describe("Value to stringify"),
+  value: definedValue("The value to write as JSON. The procedure refuses a missing value (undefined) with VALIDATION_ERROR, because undefined has no JSON text."),
   pretty: z.boolean().optional().describe("Pretty print with indentation"),
   indent: z.union([z.number(), z.string()]).optional().describe("Custom indentation (number of spaces or string)"),
 });
@@ -280,13 +313,16 @@ const stringifyJsonProcedure: StringifyJsonProcedure = defineProcedure({
   input: StringifyJsonInputSchema,
   output: stringOutput("The JSON text"),
   metadata: {
-    description: "Stringify value to JSON (with procedure ref support)",
+    description: "Stringify value to JSON (with procedure ref support). It refuses a missing value (undefined) with VALIDATION_ERROR.",
     // The refs of the input are data: exec() must not run them (deep dive CORE-5)
     tags: ["core", "meta", RAW_INPUT_TAG],
   },
   handler: async (input: StringifyJsonInput): Promise<string> => {
     const indent = input.pretty ? (input.indent ?? 2) : input.indent;
-    return stringifyProcedureJson(input.value, indent as number);
+    const json = stringifyProcedureJson(input.value, indent as number) as string | undefined;
+    // A function or a symbol has no JSON text either: a clear error, not an invalid output
+    if (json === undefined) throw new Error("The value has no JSON text");
+    return json;
   },
 });
 

package/src/procedures/core/type.ts

@@ -10,6 +10,7 @@ import { anyOutput, booleanOutput, stringOutput } from "./outputs.js";
 import { defineProcedure, namespace } from "../define.js";
 import type { AnyProcedure, Procedure } from "../types.js";
 import { PURE_EFFECTS, withEffects } from "../effects.js";
+import { isPlainObject } from "../ref.js";
 
 // =============================================================================
 // Typeof Procedure
@@ -168,11 +169,12 @@ const isObjectProcedure: IsObjectProcedure = defineProcedure({
   input: IsObjectInputSchema,
   output: booleanOutput("True for a plain object"),
   metadata: {
-    description: "Check if value is a plain object (not array, not null)",
+    description: "Check if value is a plain object (not array, not null, not a Date or another class instance)",
     tags: ["core", "type"],
   },
   handler: async (input: IsObjectInput): Promise<boolean> => {
-    return typeof input.value === "object" && input.value !== null && !Array.isArray(input.value);
+    // Before, a Date or a Map gave true (catalog test, roadmap R29)
+    return isPlainObject(input.value);
   },
 });
 

package/src/procedures/discovery.ts

@@ -1,13 +1,11 @@
 /**
  * Procedure Registration Helpers
  *
- * Manual registration helpers for procedures. For compile-time auto-discovery,
- * use the CLI: `npx client-registry discover`
+ * These helpers add procedures to the global registry.
  *
- * Libraries that depend on client should:
- * 1. Add `"client": { "procedures": "./dist/register.js" }` to package.json
- * 2. Create a register.ts that uses createAndRegister()
- * 3. Consumers run `npx client-registry discover` to generate imports
+ * A package with procedures declares `"client": { "procedures": "./dist/register.js" }` in its
+ * `package.json`. Its `src/register.ts` registers its module. `mark` finds the packages by the
+ * `client.procedures` field, and an app imports the `/register` entry of each package that it uses.
  */
 
 import { PROCEDURE_REGISTRY } from "./registry.js";

package/src/procedures/invoke.ts

@@ -68,8 +68,10 @@ export type InvocationErrorCode =
  *   of `@procedures/fs`).
  * - `host-not-allowed`: the input has a URL whose host the host does not allow, or a redirect goes
  *   to such a host (`createHttpModule({ allow })` of `@procedures/http`).
+ * - `topic-not-allowed`: the `allow` function of an `EventPublisher` refuses a topic of a
+ *   subscription (`documentation/EVENTS.md`).
  */
-export type ForbiddenReason = CapabilityRefusalReason | "outside-root" | "host-not-allowed";
+export type ForbiddenReason = CapabilityRefusalReason | "outside-root" | "host-not-allowed" | "topic-not-allowed";
 
 /** An error of the invocation itself. An error that the handler throws passes through unchanged. */
 export class InvocationError extends Error {
@@ -79,7 +81,7 @@ export class InvocationError extends Error {
   readonly retryable: boolean = false;
   /**
    * The reason of a `FORBIDDEN` error: `effects-undeclared`, `effects-exceeded`, `clearance`,
-   * `deadline`, `outside-root` or `host-not-allowed`.
+   * `deadline`, `outside-root`, `host-not-allowed` or `topic-not-allowed`.
    */
   readonly reason: ForbiddenReason | undefined;
 

package/src/procedures/ref.ts

@@ -22,7 +22,8 @@
  * - `"$never"`: Never execute during hydration, pass as pure data (with its whole subtree)
  * - `"$parent"`: Defer to parent procedure (pass as data)
  * - `"someName"`: Defer to the runner that gives this name in its `contextStack`
- *   (`dag.traverse` gives "dag.traverse", `core.catch` gives "catch")
+ *   (`dag.traverse` gives "dag.traverse". `client.tryCatch` gives no name: it is control flow,
+ *   and it runs its `try` and `catch` operands itself.)
  *
  * A deferred ref is data at every depth: hydration of the input that holds it does not run it.
  * The procedure that receives it runs it later (deep dive CORE-11).
@@ -681,7 +682,8 @@ export interface HydrateOptions {
 
   /**
    * The context names of the runner. A ref with `$when: "<name>"` runs only when this list has
-   * the name. A runner such as `core.catch` gives its own name here when it hydrates its operand.
+   * the name. A runner such as `dag.traverse` gives its own name here when it hydrates its operand.
+   * (Control flow such as `client.tryCatch` runs its operands itself and gives no name.)
    */
   contextStack?: string[] | undefined;
 

package/src/protocol.ts

@@ -46,12 +46,14 @@ export type ProtocolErrorCode =
   | "TIMEOUT"
   | "UNAVAILABLE"
   | "CONNECTION_CLOSED"
-  | "CONNECTION_NOT_FOUND";
+  | "CONNECTION_NOT_FOUND"
+  | "TOPIC_NOT_FOUND";
 
 /**
  * The error codes of the protocol, on each face (HTTP, WebSocket, MCP, local). An error that a
- * handler throws with its own `code` keeps it. Such a code is not in this list, and HTTP gives it
- * the status 500.
+ * handler throws with its own `code` keeps it, for a value and for a stream (`errorCodeOf`). The
+ * HTTP status follows the code: the status of this list, the status of `ERROR_REGISTRY` for
+ * another known code, or 500.
  */
 export const ERROR_CODES: Readonly<Record<ProtocolErrorCode, ErrorCodeInfo>> = {
   NOT_FOUND: { http: 404, retryable: false, meaning: "No procedure has the path, or the host does not expose it" },
@@ -75,6 +77,7 @@ export const ERROR_CODES: Readonly<Record<ProtocolErrorCode, ErrorCodeInfo>> = {
   UNAVAILABLE: { http: 503, retryable: true, meaning: "The server cannot take the call now: it stops, or it is busy" },
   CONNECTION_CLOSED: { http: 503, retryable: true, meaning: "The connection closed before the call left" },
   CONNECTION_NOT_FOUND: { http: 404, retryable: false, meaning: "The server has no connection with this id" },
+  TOPIC_NOT_FOUND: { http: 404, retryable: false, meaning: "The topic rule of the host has no topic with this name" },
 };
 
 /** True when a code is an error code of the protocol. */
@@ -82,6 +85,16 @@ export function isProtocolErrorCode(code: unknown): code is ProtocolErrorCode {
   return typeof code === "string" && Object.prototype.hasOwnProperty.call(ERROR_CODES, code);
 }
 
+/**
+ * The code of an error that a handler or an invocation throws, on each face: its own code when
+ * it is a string, or `HANDLER_ERROR`. An invocation error has a code of this list. Before, a
+ * value lost the own code of a handler error, and a stream kept it (roadmap R30).
+ */
+export function errorCodeOf(error: unknown): string {
+  const code = (error as { code?: unknown } | null | undefined)?.code;
+  return typeof code === "string" ? code : "HANDLER_ERROR";
+}
+
 /** The HTTP status of an error code, or undefined for a code that is not in the list. */
 export function httpStatusOf(code: unknown): number | undefined {
   return isProtocolErrorCode(code) ? ERROR_CODES[code].http : undefined;

package/src/server/host-policy.ts

@@ -14,6 +14,8 @@
  * - `token`, `browser`: the checks of the network transports (`client-server` applies them).
  * - `capability`, `readOnly`, `clearanceOrder`, `resources`, `admitItem`: the capability of each
  *   call and what the host gives for it (CAPABILITIES-2026-10).
+ * - `events`: the remote events of the host (`documentation/EVENTS.md`). The server pins
+ *   `events.subscribe` with this topic rule, and its procedures get the bus as `ctx.bus`.
  */
 
 import type { Capability, ClearanceOrder, ProcedurePath, ResourcesOf } from "../procedures/types.js";
@@ -24,6 +26,7 @@ import { timeoutInterceptor } from "../procedures/interceptors.js";
 import type { BrowserGuardOptions } from "./browser-guard.js";
 import type { ProcedureRegistry } from "../procedures/registry.js";
 import type { ProcedureServerOptions } from "./procedure-server.js";
+import type { EventPublisherOptions } from "../events/publisher.js";
 import { toMs, type Duration } from "../duration.js";
 
 /** The procedures of a host that are tools: namespaces (first path segments), less some keys. */
@@ -86,6 +89,12 @@ export interface HostPolicyOptions {
   resources?: ((invocation: Invocation) => ResourcesOf) | undefined;
   /** The filter of the output that leaves the host. */
   admitItem?: AdmitItem | undefined;
+  /**
+   * The remote events of the host (`documentation/EVENTS.md`): the topic rule, with an optional
+   * bus, `allow` function and buffer. The default bus is the global bus, which is also the default
+   * `ctx.bus`. Without this option, the host does not serve `events.subscribe`.
+   */
+  events?: EventPublisherOptions | undefined;
 }
 
 /** What a host lets its callers do. */
@@ -100,6 +109,8 @@ export interface HostPolicy {
   readonly clearanceOrder: ClearanceOrder | undefined;
   readonly resources: ((invocation: Invocation) => ResourcesOf) | undefined;
   readonly admitItem: AdmitItem | undefined;
+  /** The remote events: each server of the policy makes its own publisher from these options. */
+  readonly events: EventPublisherOptions | undefined;
 }
 
 /** The capability function of a policy: the capability of the options, narrowed by `readOnly`. */
@@ -145,6 +156,7 @@ export function hostPolicy(options: HostPolicyOptions = {}): HostPolicy {
     clearanceOrder: options.clearanceOrder,
     resources: options.resources,
     admitItem: options.admitItem,
+    events: options.events,
   };
 }
 
@@ -162,5 +174,7 @@ export function procedureServerOptions(policy: HostPolicy, registry?: ProcedureR
     ...(policy.clearanceOrder ? { clearanceOrder: policy.clearanceOrder } : {}),
     ...(policy.resources ? { resources: policy.resources } : {}),
     ...(policy.admitItem ? { admitItem: policy.admitItem } : {}),
+    // The remote events: the server makes its publisher and pins events.subscribe (EVENTS.md)
+    ...(policy.events ? { events: policy.events } : {}),
   };
 }

package/src/server/procedure-server.ts

@@ -24,6 +24,9 @@ import { IdempotencyCache, idempotencyKeyOf, isRepeatable, type IdempotencyOptio
 import { optionalMs, type Duration } from "../duration.js";
 import type { CollectionStorage } from "../procedures/collection/storage.js";
 import { TIMER_DEFAULTS } from "../timers.js";
+import { errorCodeOf } from "../protocol.js";
+import { EventPublisher, type EventPublisherOptions } from "../events/publisher.js";
+import { getGlobalEventBus } from "../events/bus.js";
 
 // =============================================================================
 // Types
@@ -118,6 +121,14 @@ export interface ProcedureServerOptions extends ServerOptions {
    * `request.principal`.
    */
   authenticate?: ((request: ServerRequest<unknown>) => Principal | undefined | Promise<Principal | undefined>) | undefined;
+
+  /**
+   * The remote events of the server (`documentation/EVENTS.md`): a bus and its topic rule, or an
+   * `EventPublisher`. The server pins the procedure `events.subscribe`, outside its registry, so a
+   * peer can subscribe to the topics. The procedures of the server get this bus as `ctx.bus`.
+   * `stop()` ends each subscription first, with `UNAVAILABLE`.
+   */
+  events?: EventPublisherOptions | EventPublisher | undefined;
 }
 
 /**
@@ -198,7 +209,8 @@ function withRequestTimeout(
 
 /**
  * The error response of a failed invocation. An invocation error keeps its code
- * (VALIDATION_ERROR, NOT_EXPOSED, ABORTED and so on). An error of the handler is HANDLER_ERROR.
+ * (VALIDATION_ERROR, NOT_EXPOSED, ABORTED and so on). An error of the handler keeps its own code
+ * when it is a string, as for a stream (`WIRE-PROTOCOL.md`). Without a code, it is HANDLER_ERROR.
  */
 export function errorResponse(id: string, error: unknown): ServerResponse<unknown> {
   // An error that says it is retryable stays retryable: before, every error lost the flag
@@ -214,7 +226,7 @@ export function errorResponse(id: string, error: unknown): ServerResponse<unknow
     id,
     status: {
       type: "error",
-      code: error instanceof InvocationError ? error.code : "HANDLER_ERROR",
+      code: errorCodeOf(error),
       message: error instanceof Error ? error.message : String(error),
       retryable: typeof retryable === "boolean" ? retryable : false,
     },
@@ -286,6 +298,8 @@ export class ProcedureServer extends Server implements RepositoryProvider {
   private readonly authenticate: ProcedureServerOptions["authenticate"];
   /** The functions that `stop()` waits on: each one runs when no call is in flight */
   private idleWaiters: Array<() => void> = [];
+  /** The publisher of the remote events, from the option `events`, or undefined. */
+  readonly publisher: EventPublisher | undefined;
 
   constructor(options: ProcedureServerOptions = {}) {
     super(options);
@@ -303,6 +317,9 @@ export class ProcedureServer extends Server implements RepositoryProvider {
     this.idempotency = options.idempotency === false ? undefined : new IdempotencyCache(options.idempotency ?? {});
     this.token = options.token;
     this.authenticate = options.authenticate;
+    // The remote events: the server pins events.subscribe, as it pins host.health (EVENTS.md)
+    this.publisher = options.events instanceof EventPublisher ? options.events : options.events ? new EventPublisher(options.events) : undefined;
+    if (this.publisher) this.registerProcedure(this.publisher.procedure);
 
     // Configure collections
     if (options.collections) {
@@ -643,6 +660,8 @@ export class ProcedureServer extends Server implements RepositoryProvider {
         clearanceOrder,
         resources,
         admitItem,
+        // The bus of the remote events is the bus of the procedures (EVENTS.md)
+        ...(this.publisher ? { bus: this.publisher.bus } : {}),
       });
       if (output.kind === "stream") {
         // The faces that collect a stream read this mark (roadmap R15)
@@ -721,23 +740,41 @@ export class ProcedureServer extends Server implements RepositoryProvider {
   }
 
   /**
-   * Close all storage backends.
+   * This function publishes an event on the bus of the server: the bus of the option `events`, or
+   * the global bus. Each subscription of the topic gets it (`documentation/EVENTS.md`).
+   *
+   * @param topic - The topic: a channel of the bus
+   * @param data - The data of the event. It crosses the wire as JSON.
+   */
+  publish<T>(topic: string, data: T): void {
+    (this.publisher?.bus ?? getGlobalEventBus()).emit(topic, data);
+  }
+
+  /**
+   * This method closes each storage one time, also a storage of two collections, and removes the
+   * storages from the server. A closed storage rejects each operation, so the server does not keep
+   * it. Before a new `start()`, give the storages again with `useStorage()`.
    */
   async closeStorages(): Promise<void> {
-    const closePromises = Array.from(this.storages.values()).map((s) =>
-      s.close()
-    );
-    await Promise.all(closePromises);
+    const storages = new Set(this.storages.values());
+    this.storages.clear();
+    const results = await Promise.allSettled(Array.from(storages, (storage) => storage.close()));
+    const failed = results.find((result): result is PromiseRejectedResult => result.status === "rejected");
+    if (failed) throw failed.reason;
   }
 
   /**
-   * Stop server and close storages.
+   * This method stops the server, then closes the storages and removes them (`closeStorages()`).
+   * The server can start again, with new storages from `useStorage()`. Before, a server that
+   * started again used the closed storages.
    */
   override async stop(options: StopOptions = {}): Promise<void> {
     const graceMs = optionalMs(options.grace, "grace") ?? TIMER_DEFAULTS.server.stopGraceMs;
     // A graceful stop: new calls get UNAVAILABLE, and the calls in flight have the grace time
     // to end (roadmap R14). Before, the transports aborted every call at once.
     this.draining = true;
+    // A subscription has no end: it ends now, with a retryable UNAVAILABLE (EVENTS.md)
+    this.publisher?.end();
     if (graceMs > 0 && this.inFlight > 0) {
       await new Promise<void>((resolve) => {
         const timer = setTimeout(resolve, graceMs);

package/dist/procedures/cli/announce.d.ts

@@ -1,67 +0,0 @@
-/**
- * Procedure Announcement (Self-Registration)
- *
- * When a package with procedures is installed, it "announces" itself
- * by writing to a registry file at the root of the project.
- *
- * This enables true bottom-up propagation:
- * - Each package with procedures has `"postinstall": "client-registry announce"`
- * - On install, it walks up to find the root and registers itself
- * - `client-registry discover` reads this registry instead of scanning
- *
- * The registry file (.client-registry.json) accumulates entries from
- * all packages as they're installed, making discovery instant.
- */
-export interface AnnounceOptions {
-    /** Be verbose about what's happening */
-    verbose: boolean;
-    /** The folder to start from (default: the current folder) */
-    cwd?: string | undefined;
-    /**
-     * Add `client-registry announce` to the postinstall script of the package that depends on this one.
-     * This edits a package.json that belongs to the consumer, so it happens only when asked
-     * (`client-registry announce --propagate`). Default: false.
-     */
-    propagate?: boolean | undefined;
-}
-interface RegistryEntry {
-    /** Path to procedures file relative to package */
-    proceduresPath: string;
-    /** When this entry was added */
-    registeredAt: string;
-    /** Package version */
-    version?: string;
-}
-interface Registry {
-    /** Schema version for future compatibility */
-    schemaVersion: 1;
-    /** Map of package name to registry entry */
-    packages: Record<string, RegistryEntry>;
-}
-declare const REGISTRY_FILENAME = ".client-registry.json";
-/**
- * Announce this package's procedures to the project registry.
- *
- * Called from a package's postinstall script to register its procedures.
- *
- * With `propagate: true` (`client-registry announce --propagate`), it also adds the postinstall script
- * to the package that depends on this one, for transitive discovery:
- * - When client is installed in package D, client's postinstall adds postinstall to D
- * - When D is installed in C, D's postinstall adds postinstall to C
- * - When C is installed in B, C's postinstall adds postinstall to B
- *
- * The propagation edits the package.json of the consumer, so it happens only when asked.
- * Without it, each package that has its own postinstall script still registers itself.
- */
-export declare function announce(options: AnnounceOptions): Promise<void>;
-/**
- * Remove this package from the registry (for uninstall).
- */
-export declare function unannounce(options: AnnounceOptions): Promise<void>;
-/**
- * Get the registry for use by discover command.
- */
-export declare function getRegistry(rootDir: string): Promise<Registry>;
-export { REGISTRY_FILENAME };
-export type { Registry, RegistryEntry };
-//# sourceMappingURL=announce.d.ts.map

package/dist/procedures/cli/announce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"announce.d.ts","sourceRoot":"","sources":["../../../src/procedures/cli/announce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AASH,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,6DAA6D;IAC7D,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACjC;AAED,UAAU,aAAa;IACrB,kDAAkD;IAClD,cAAc,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,QAAQ;IAChB,8CAA8C;IAC9C,aAAa,EAAE,CAAC,CAAC;IACjB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACzC;AAkFD,QAAA,MAAM,iBAAiB,0BAA0B,CAAC;AA0GlD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BtE;AAiKD;;GAEG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBxE;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAEpE;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC7B,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAC"}