@unicity-astrid/sdk 0.1.0

package/README.md

@@ -0,0 +1,120 @@
+# @unicity-astrid/sdk
+
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/License-MIT%20OR%20Apache--2.0-blue.svg)](../../LICENSE-MIT)
+[![Node: >=20](https://img.shields.io/badge/Node-%3E%3D20-blue)](https://nodejs.org)
+[![TypeScript: 5.2+](https://img.shields.io/badge/TypeScript-5.2%2B-blue)](https://www.typescriptlang.org)
+
+**The system library for Astrid OS user space, in JavaScript / TypeScript.**
+
+Sibling of [`astrid-sdk`](https://github.com/unicity-astrid/sdk-rust) (Rust). Same host ABI, same WIT contract, same `.capsule` archive shape — the kernel can't tell which language built the binary. Where the Rust SDK mirrors `std`, this one mirrors Node + WHATWG. Same semantics, idiom translated.
+
+## Where it fits
+
+```text
+Capsule code (TypeScript or JavaScript)
+    |
+  @unicity-astrid/sdk           typed modules: fs, net, ipc, kv, http, ...
+    |
+  WIT-imported bindings    "astrid:<domain>/host@1.0.0" + "astrid:io/*@1.0.0" (ComponentizeJS-generated)
+    |
+  Kernel                   capability checks, VFS, IPC bus, audit
+```
+
+The SDK never reaches the network, filesystem, or any external service directly. Every operation is a WIT host call into the kernel. The kernel decides whether to allow it.
+
+## Module layout
+
+| Module | Rust SDK | Node / WHATWG idiom |
+|---|---|---|
+| `fs` | `astrid_sdk::fs` (mirrors `std::fs`) | `node:fs/promises` shape: `readFile`/`writeFile`/`mkdir`/`stat` (returns `Stats` with `isFile()`/`isDirectory()`/`mtimeMs`)/`readdir`/`opendir` (AsyncIterable) |
+| `net` | `astrid_sdk::net` (mirrors `std::sync::mpsc`) | mpsc-shaped errors (`RecvError` / `TryRecvError::{Empty,Closed}` / `SendError`) + `Symbol.asyncIterator` streams |
+| `process` | `astrid_sdk::process` | `child_process.spawn`-shaped: `spawn(cmd, args) → ProcessResult`, `spawnBackground` returns `BackgroundProcessHandle` with `readLogs`/`kill` |
+| `env` | `astrid_sdk::env` (mirrors `std::env`) | `env.get(key)`, `CONFIG_SOCKET_PATH` constant |
+| `time` | `astrid_sdk::time` | `now() → Date`, `nowMs() → bigint` |
+| `log` | `astrid_sdk::log` (mirrors `log` crate) | `log.{trace,debug,info,warn,error}`. **No** `globalThis.console` shadowing — the engine may already wire it. |
+| `ipc` | `astrid_sdk::ipc` | `publish`/`publishJson`; `subscribe(topic)` returns a `Subscription` with `.poll()`/`.recv(timeoutMs)` (full parity, surfaces `lagged`/`dropped`) AND `Symbol.asyncIterator` for convenience |
+| `kv` | `astrid_sdk::kv` | Map-shape async: `get<T>(key)`/`set<T>`/`has`/`del`/`listKeys`/`clearPrefix`; raw byte variants for non-JSON payloads |
+| `http` | `astrid_sdk::http` (mirrors reqwest) | Builder `Request.get/post/header/json/setBody` + `send` / `streamStart`; plus a WHATWG `fetch` polyfill that routes through the same host imports for capability-gated network access |
+| `runtime` | `astrid_sdk::runtime` | `signalReady()`, `caller() → CallerContext`, `socketPath()` |
+| `capabilities` | `astrid_sdk::capabilities` | `check(sourceUuid, capability) → boolean` |
+| `elicit` | `astrid_sdk::elicit` | `secret`/`hasSecret`/`text`/`textWithDefault`/`select`/`array` (install/upgrade only) |
+| `identity` | `astrid_sdk::identity` | `resolve`/`link`/`unlink`/`createUser`/`listLinks` |
+| `approval` | `astrid_sdk::approval` | `request(action, resource) → boolean` |
+| `uplink` | `astrid_sdk::uplink` | `register(name, platform, profile) → UplinkId`, `send(id, userId, content) → boolean` |
+| `interceptors` | `astrid_sdk::interceptors` | `bindings()` / `poll(bindings, handler)` — usually unneeded; `@interceptor` decorator handles dispatch |
+
+## Decorators (replaces `#[capsule]` macro)
+
+| Rust attribute | TypeScript decorator |
+|---|---|
+| `#[capsule]` on impl block | `@capsule` on class |
+| `#[astrid::tool("name")]` | `@tool("name", { mutable?, description?, inputSchema? })` |
+| `#[astrid::interceptor("topic")]` | `@interceptor("topic", { mutable? })` |
+| `#[astrid::command("name")]` | `@command("name", { mutable? })` |
+| `#[astrid::install]` | `@install` |
+| `#[astrid::upgrade]` | `@upgrade` |
+| `#[astrid::run]` | `@run` |
+
+TypeScript 5.2+ standard decorators (TC39 Stage 3). No `experimentalDecorators` flag — default behaviour.
+
+## Quick start
+
+```bash
+npm install @unicity-astrid/sdk
+npm install --save-dev @unicity-astrid/build typescript
+```
+
+```typescript
+import { capsule, tool, install, log, kv } from "@unicity-astrid/sdk";
+
+@capsule
+export class MyCapsule {
+  greetings = 0;
+
+  @tool("greet", { mutable: true })
+  greet({ name }: { name: string }): { message: string; count: number } {
+    this.greetings++;
+    log.info(`greeting ${name} (#${this.greetings})`);
+    return { message: `Hello, ${name}!`, count: this.greetings };
+  }
+
+  @install
+  onInstall(): void {
+    log.info("my-capsule installed");
+  }
+}
+```
+
+`astrid build` (from the Rust kernel CLI) detects `package.json + Capsule.toml`, shells out to the `@unicity-astrid/build` Node orchestrator, and emits a `.capsule` archive packaged identically to a Rust capsule's.
+
+## Error model: throw, don't `Result`
+
+The Rust SDK returns `Result<T, SysError>`. This SDK **throws** a `SysError extends Error` with a `code` discriminant (`"HostError"` / `"JsonError"` / `"ApiError"`). Fighting JS to add Rust-shaped errors would be the opposite of "feels native". Same semantics, idiom-correct.
+
+## Async model
+
+The Rust SDK is synchronous because WASM exports are synchronous. The JS SDK is async (`await fs.readFile(...)`) because that's what Node developers expect. ComponentizeJS's syncify makes awaits backed by host imports settle synchronously at the WASM boundary. Use `await` freely inside `@tool` / `@interceptor` / `@run` handlers — the engine settles them before the host returns.
+
+`@run` handlers that loop forever (`while (true) { await ipc.recv(...) }`) block the WIT `run` export until the loop exits, matching the Rust SDK's daemon-style capsules exactly.
+
+## `tool_describe` and `tool_execute_<name>`
+
+The bridge auto-generates the `tool_describe` aggregated schema payload (lazy, cached) on first invocation, matching what `schemars::schema_for!` produces from Rust capsules. Tool input schemas come from the decorator's `inputSchema` option or, at build time, from `ts-json-schema-generator` walking the parameter types. Schemas may differ in subtle ways from Rust's `schemars` output (e.g. `Option<T>` vs `T | undefined` representation) — acceptable for LLM tool-calling, monitored via a conformance test.
+
+`tool_execute_<name>` dispatch handles `mutable: true` tools by loading `__state` from KV before the call and persisting after on success, matching the Rust macro's behaviour exactly. Result is published to `tool.v1.execute.<name>.result` via IPC.
+
+## Subpath exports
+
+| Import | Contents |
+|---|---|
+| `@unicity-astrid/sdk` | Public API barrel |
+| `@unicity-astrid/sdk/runtime` | Internal registry + bridge — exposed for advanced authors only |
+| `@unicity-astrid/sdk/contracts` | Auto-generated TS types from `astrid-contracts.wit` (`Message`, `ToolCall`, `GenerateRequest`, `StreamEvent`, etc.) |
+
+## Status
+
+Alpha. End-to-end build + install + kernel-lifecycle execution proven. See `../../notes/phase-{0,1,2,3-install}.md`.
+
+## License
+
+Dual MIT/Apache-2.0. See [LICENSE-MIT](../../LICENSE-MIT) and [LICENSE-APACHE](../../LICENSE-APACHE).

package/dist/approval.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Human-in-the-loop approval. Mirrors `astrid_sdk::approval`.
+ *
+ * The capsule declares the action and target resource. The kernel classifies
+ * risk, checks any pre-approved allowances, and either auto-approves or
+ * prompts the frontend user. The capsule sees the specific decision class
+ * (one-shot / session / always / allowance-hit / denied), not just
+ * approved/denied — UI can communicate WHY (e.g. "stored as always-approve")
+ * for transparency.
+ */
+import { type ApprovalDecision } from "astrid:approval/host@1.0.0";
+export type { ApprovalDecision } from "astrid:approval/host@1.0.0";
+/**
+ * Request approval for a sensitive action. Returns `true` if approved (any
+ * approval variant), `false` if denied. Blocks until the user responds or
+ * the request times out (60s).
+ *
+ * For the specific decision class, use {@link requestDecision}.
+ */
+export declare function request(action: string, resource: string): boolean;
+/** Request approval and return the specific decision class. */
+export declare function requestDecision(action: string, resource: string): ApprovalDecision;
+//# sourceMappingURL=approval.d.ts.map

package/dist/approval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval.d.ts","sourceRoot":"","sources":["../src/approval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,4BAA4B,CAAC;AAGpC,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGjE;AAED,+DAA+D;AAC/D,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAKlF"}

package/dist/approval.js

@@ -0,0 +1,29 @@
+/**
+ * Human-in-the-loop approval. Mirrors `astrid_sdk::approval`.
+ *
+ * The capsule declares the action and target resource. The kernel classifies
+ * risk, checks any pre-approved allowances, and either auto-approves or
+ * prompts the frontend user. The capsule sees the specific decision class
+ * (one-shot / session / always / allowance-hit / denied), not just
+ * approved/denied — UI can communicate WHY (e.g. "stored as always-approve")
+ * for transparency.
+ */
+import { requestApproval as hostRequestApproval, } from "astrid:approval/host@1.0.0";
+import { callHost } from "./errors.js";
+/**
+ * Request approval for a sensitive action. Returns `true` if approved (any
+ * approval variant), `false` if denied. Blocks until the user responds or
+ * the request times out (60s).
+ *
+ * For the specific decision class, use {@link requestDecision}.
+ */
+export function request(action, resource) {
+    const decision = requestDecision(action, resource);
+    return decision !== "denied";
+}
+/** Request approval and return the specific decision class. */
+export function requestDecision(action, resource) {
+    const resp = callHost(`approval.request(${JSON.stringify(action)})`, () => hostRequestApproval({ action, targetResource: resource }));
+    return resp.decision;
+}
+//# sourceMappingURL=approval.js.map

package/dist/approval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval.js","sourceRoot":"","sources":["../src/approval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,eAAe,IAAI,mBAAmB,GAEvC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAIvC;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAC,MAAc,EAAE,QAAgB;IACtD,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACnD,OAAO,QAAQ,KAAK,QAAQ,CAAC;AAC/B,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,eAAe,CAAC,MAAc,EAAE,QAAgB;IAC9D,MAAM,IAAI,GAAG,QAAQ,CAAC,oBAAoB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,CACxE,mBAAmB,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,CAC1D,CAAC;IACF,OAAO,IAAI,CAAC,QAAQ,CAAC;AACvB,CAAC"}

package/dist/capabilities.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cross-capsule capability queries. Mirrors `astrid_sdk::capabilities`.
+ *
+ * Allows a capsule to check whether another capsule (identified by its IPC
+ * session UUID) has a specific manifest capability. Used by the prompt
+ * builder to enforce `allow_prompt_injection` gating, for example.
+ *
+ * Fail-closed: returns `false` for unknown UUIDs, unknown capabilities, or
+ * registry-unavailable conditions (the host returns `registry-unavailable`,
+ * which `callHost` raises as a SysError — capsule code that wants to swallow
+ * registry outages should wrap the call).
+ */
+export declare function check(sourceUuid: string, capability: string): boolean;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,wBAAgB,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAKrE"}

package/dist/capabilities.js

@@ -0,0 +1,19 @@
+/**
+ * Cross-capsule capability queries. Mirrors `astrid_sdk::capabilities`.
+ *
+ * Allows a capsule to check whether another capsule (identified by its IPC
+ * session UUID) has a specific manifest capability. Used by the prompt
+ * builder to enforce `allow_prompt_injection` gating, for example.
+ *
+ * Fail-closed: returns `false` for unknown UUIDs, unknown capabilities, or
+ * registry-unavailable conditions (the host returns `registry-unavailable`,
+ * which `callHost` raises as a SysError — capsule code that wants to swallow
+ * registry outages should wrap the call).
+ */
+import { checkCapsuleCapability } from "astrid:sys/host@1.0.0";
+import { callHost } from "./errors.js";
+export function check(sourceUuid, capability) {
+    const resp = callHost(`capabilities.check(${JSON.stringify(capability)})`, () => checkCapsuleCapability({ sourceUuid, capability }));
+    return resp.allowed;
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,MAAM,UAAU,KAAK,CAAC,UAAkB,EAAE,UAAkB;IAC1D,MAAM,IAAI,GAAG,QAAQ,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,CAC9E,sBAAsB,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,CACnD,CAAC;IACF,OAAO,IAAI,CAAC,OAAO,CAAC;AACtB,CAAC"}

package/dist/capsule.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Capsule + lifecycle decorators. Mirrors `#[capsule]` / `#[astrid::install]`
+ * / `#[astrid::upgrade]` from the Rust SDK.
+ *
+ * TypeScript standard decorators (TC39 Stage 3 / TS 5.0+). Class-method
+ * decorators are the most stable subset of the spec; we deliberately use
+ * only that subset to minimize churn risk.
+ */
+import { type CapsuleConstructor } from "./runtime/registry.js";
+/**
+ * Class decorator marking the entry-point of the capsule. The decorated
+ * class must have a no-arg constructor (state defaults via field initializers).
+ *
+ * Exactly one `@capsule` class per compiled WASM module.
+ */
+export declare function capsule<T extends CapsuleConstructor>(target: T, _context: ClassDecoratorContext<T>): T;
+/**
+ * Method decorator marking the first-time install lifecycle hook. The
+ * method receives no arguments and may be async. It runs once before any
+ * tool dispatch.
+ */
+export declare function install<This extends object>(_value: (this: This) => unknown, context: ClassMethodDecoratorContext<This, (this: This) => unknown>): void;
+/**
+ * Method decorator marking the upgrade lifecycle hook. The method receives
+ * the previous version string and may be async.
+ */
+export declare function upgrade<This extends object>(_value: (this: This, prevVersion: string) => unknown, context: ClassMethodDecoratorContext<This, (this: This, prevVersion: string) => unknown>): void;
+/**
+ * Method decorator marking the long-running background loop. The method
+ * receives no arguments, may be async, and is expected NEVER to return
+ * (it is the capsule's daemon loop). Mirror of `#[astrid::run]`.
+ *
+ * Capsules that declare `@run` are "runnable" capsules: the kernel
+ * spawns them as background tasks and the WIT `run` export blocks until
+ * the loop exits. Capsules without `@run` are hook-driven and the `run`
+ * export is a no-op.
+ */
+export declare function run<This extends object>(_value: (this: This) => unknown, context: ClassMethodDecoratorContext<This, (this: This) => unknown>): void;
+//# sourceMappingURL=capsule.d.ts.map

package/dist/capsule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capsule.d.ts","sourceRoot":"","sources":["../src/capsule.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,KAAK,kBAAkB,EAMxB,MAAM,uBAAuB,CAAC;AAE/B;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,kBAAkB,EAClD,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,qBAAqB,CAAC,CAAC,CAAC,GACjC,CAAC,CAIH;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,SAAS,MAAM,EACzC,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,EAC/B,OAAO,EAAE,2BAA2B,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,GAClE,IAAI,CAQN;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,SAAS,MAAM,EACzC,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,EACpD,OAAO,EAAE,2BAA2B,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,GACvF,IAAI,CAQN;AAED;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,IAAI,SAAS,MAAM,EACrC,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,EAC/B,OAAO,EAAE,2BAA2B,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,GAClE,IAAI,CAQN"}

package/dist/capsule.js

@@ -0,0 +1,67 @@
+/**
+ * Capsule + lifecycle decorators. Mirrors `#[capsule]` / `#[astrid::install]`
+ * / `#[astrid::upgrade]` from the Rust SDK.
+ *
+ * TypeScript standard decorators (TC39 Stage 3 / TS 5.0+). Class-method
+ * decorators are the most stable subset of the spec; we deliberately use
+ * only that subset to minimize churn risk.
+ */
+import { registerCapsule, recordInstall, recordUpgrade, recordRun, adoptPending, } from "./runtime/registry.js";
+/**
+ * Class decorator marking the entry-point of the capsule. The decorated
+ * class must have a no-arg constructor (state defaults via field initializers).
+ *
+ * Exactly one `@capsule` class per compiled WASM module.
+ */
+export function capsule(target, _context) {
+    registerCapsule(target);
+    adoptPending(target);
+    return target;
+}
+/**
+ * Method decorator marking the first-time install lifecycle hook. The
+ * method receives no arguments and may be async. It runs once before any
+ * tool dispatch.
+ */
+export function install(_value, context) {
+    if (context.private || context.static) {
+        throw new Error("@install must be applied to a public instance method.");
+    }
+    context.addInitializer(function () {
+        const ctor = this.constructor;
+        recordInstall(ctor, String(context.name));
+    });
+}
+/**
+ * Method decorator marking the upgrade lifecycle hook. The method receives
+ * the previous version string and may be async.
+ */
+export function upgrade(_value, context) {
+    if (context.private || context.static) {
+        throw new Error("@upgrade must be applied to a public instance method.");
+    }
+    context.addInitializer(function () {
+        const ctor = this.constructor;
+        recordUpgrade(ctor, String(context.name));
+    });
+}
+/**
+ * Method decorator marking the long-running background loop. The method
+ * receives no arguments, may be async, and is expected NEVER to return
+ * (it is the capsule's daemon loop). Mirror of `#[astrid::run]`.
+ *
+ * Capsules that declare `@run` are "runnable" capsules: the kernel
+ * spawns them as background tasks and the WIT `run` export blocks until
+ * the loop exits. Capsules without `@run` are hook-driven and the `run`
+ * export is a no-op.
+ */
+export function run(_value, context) {
+    if (context.private || context.static) {
+        throw new Error("@run must be applied to a public instance method.");
+    }
+    context.addInitializer(function () {
+        const ctor = this.constructor;
+        recordRun(ctor, String(context.name));
+    });
+}
+//# sourceMappingURL=capsule.js.map

package/dist/capsule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capsule.js","sourceRoot":"","sources":["../src/capsule.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEL,eAAe,EACf,aAAa,EACb,aAAa,EACb,SAAS,EACT,YAAY,GACb,MAAM,uBAAuB,CAAC;AAE/B;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CACrB,MAAS,EACT,QAAkC;IAElC,eAAe,CAAC,MAAM,CAAC,CAAC;IACxB,YAAY,CAAC,MAAM,CAAC,CAAC;IACrB,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,OAAO,CACrB,MAA+B,EAC/B,OAAmE;IAEnE,IAAI,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,CAAC,cAAc,CAAC;QACrB,MAAM,IAAI,GAAI,IAAe,CAAC,WAAiC,CAAC;QAChE,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,OAAO,CACrB,MAAoD,EACpD,OAAwF;IAExF,IAAI,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,CAAC,cAAc,CAAC;QACrB,MAAM,IAAI,GAAI,IAAe,CAAC,WAAiC,CAAC;QAChE,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,GAAG,CACjB,MAA+B,EAC/B,OAAmE;IAEnE,IAAI,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IACD,OAAO,CAAC,cAAc,CAAC;QACrB,MAAM,IAAI,GAAI,IAAe,CAAC,WAAiC,CAAC;QAChE,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC"}