@openclaw/fs-safe 0.1.1 → 0.2.0

package/docs/types.md

@@ -0,0 +1,155 @@
+# Types
+
+The types most callers reach for. Shared data shapes are exported from `@openclaw/fs-safe/types`; method-specific option/result types live next to their subpath.
+
+```ts
+import type {
+  BasePathOptions,
+  DirEntry,
+  FastPathMode,
+  PathStat,
+  SafeEncoding,
+} from "@openclaw/fs-safe/types";
+```
+
+## `PathStat`
+
+```ts
+type PathStat = {
+  kind: "file" | "directory" | "symlink" | "fifo" | "socket" | "blockDevice" | "characterDevice" | "unknown";
+  size: number;       // bytes
+  mtimeMs: number;    // milliseconds since epoch
+  mode: number;       // POSIX mode bits
+  nlink: number;      // hardlink count
+};
+```
+
+The shape returned by `Root.stat()`. A trimmed view of `node:fs.Stats` — only the fields the boundary cares about. Use `kind` instead of inspecting the various `is*` methods on a Node `Stats` object; it covers every case in one switchable string.
+
+## `DirEntry`
+
+```ts
+type DirEntry = PathStat & {
+  name: string;       // base name within the listed directory
+};
+```
+
+Returned by `Root.list(rel, { withFileTypes: true })`. Includes the same `kind`/`size`/etc as `PathStat`, plus the entry's `name`.
+
+## `BasePathOptions`
+
+```ts
+type BasePathOptions = {
+  fastPathMode?: FastPathMode;
+};
+
+type FastPathMode = "auto" | "never" | "require";
+```
+
+Options shared by helpers that can take a "fast path" (use cheaper syscalls when the input is already absolute and clearly inside scope). The default is `"auto"` — let the helper pick. Force `"never"` in tests if you want to exercise the slow path. Force `"require"` if you need to assert that the fast path is taken (the helper throws if it can't).
+
+Most callers don't need to touch this.
+
+## `SafeEncoding`
+
+```ts
+type SafeEncoding = BufferEncoding | null;
+```
+
+Used by helpers that accept either an encoding (returning a string) or `null` (returning a `Buffer`). The Node `BufferEncoding` type is widened to include `null` for "give me bytes."
+
+## `OpenResult` / `ReadResult`
+
+Returned by `Root.open()` and `Root.read()`:
+
+```ts
+type OpenResult = {
+  handle: import("node:fs/promises").FileHandle;
+  realPath: string;
+  stat: import("node:fs").Stats;
+};
+
+type ReadResult = {
+  buffer: Buffer;
+  realPath: string;
+  stat: import("node:fs").Stats;
+};
+```
+
+`realPath` is the canonical real path the read or open landed on, after symlink resolution; `stat` is the verified `fstat` result.
+
+## `RootDefaults` / `RootOptions`
+
+```ts
+type RootDefaults = {
+  hardlinks?: "reject" | "allow";
+  maxBytes?: number;
+  mkdir?: boolean;
+  mode?: number;
+  nonBlockingRead?: boolean;
+  symlinks?: "reject" | "follow-within-root";
+};
+
+type RootOptions = {
+  rootDir: string;
+  defaults?: RootDefaults;
+};
+```
+
+`RootDefaults` is what `root(rootDir, defaults)` accepts. See [`root()`](root.md) for the per-method options that override these.
+
+## `RootReadOptions` / `RootWriteOptions` / `RootCopyOptions`
+
+```ts
+type RootReadOptions = Pick<RootDefaults, "hardlinks" | "maxBytes" | "nonBlockingRead" | "symlinks">;
+type RootWriteOptions = Pick<RootDefaults, "mkdir" | "mode"> & {
+  encoding?: BufferEncoding;
+  overwrite?: boolean;
+};
+type RootCopyOptions = Pick<RootDefaults, "maxBytes" | "mkdir" | "mode"> & {
+  sourceHardlinks?: "reject" | "allow";
+};
+type RootOpenWritableOptions = Pick<RootDefaults, "mkdir" | "mode"> & {
+  writeMode?: "replace" | "append" | "update";
+};
+type RootWriteJsonOptions = RootWriteOptions & {
+  replacer?: Parameters<typeof JSON.stringify>[1];
+  space?: Parameters<typeof JSON.stringify>[2];
+  trailingNewline?: boolean;
+};
+type RootAppendOptions = RootWriteOptions & {
+  prependNewlineIfNeeded?: boolean;
+};
+```
+
+Per-method option shapes. Each picks the `RootDefaults` keys that apply, plus method-specific extras.
+
+## `SymlinkPolicy` / `HardlinkPolicy`
+
+```ts
+type SymlinkPolicy = "reject" | "follow-within-root";
+type HardlinkPolicy = "reject" | "allow";
+```
+
+The two policy unions you'll see throughout. `"reject"` is conservative; `"follow-within-root"` allows symlinks whose final target is still inside the root; `"allow"` (hardlinks only) is permissive. Defaults for both symlinks and hardlinks are `"reject"`; switch hardlinks to `"allow"` only when you intentionally accept hardlink aliases.
+
+## `FsSafeErrorCode` / `FsSafeErrorCategory`
+
+```ts
+type FsSafeErrorCode =
+  | "already-exists" | "hardlink" | "helper-failed" | "helper-unavailable"
+  | "insecure-permissions" | "invalid-path" | "not-empty" | "not-file"
+  | "not-found" | "not-owned" | "not-removable" | "outside-workspace"
+  | "path-alias" | "path-mismatch" | "permission-unverified"
+  | "symlink" | "timeout" | "too-large" | "unsupported-platform";
+```
+
+Closed union you switch on. See the [Errors](errors.md) reference for what each one means.
+
+`FsSafeError.category` is `"policy"` for unsafe input/target-state failures and `"operational"` for environment/runtime failures.
+
+## See also
+
+- [`root()`](root.md) — how `RootDefaults` and `Root*Options` are used.
+- [Errors](errors.md) — the closed code union in context.
+- [Reading](reading.md), [Writing](writing.md) — option shapes per verb.

package/docs/walk.md

@@ -0,0 +1,63 @@
+# Directory walking
+
+`walkDirectory()` and `walkDirectorySync()` provide budget-bounded directory scans for callers that would otherwise hand-roll recursive `readdir()` loops. The bounds are `maxDepth` and `maxEntries`; this helper does not create a security boundary. Use [`root()`](root.md) when the path itself is caller-influenced.
+
+```ts
+import { walkDirectory } from "@openclaw/fs-safe/walk";
+
+const scan = await walkDirectory("/safe/workspace", {
+  maxDepth: 3,
+  maxEntries: 10_000,
+  symlinks: "skip",
+  include: (entry) => entry.kind === "file",
+  descend: (entry) => entry.name !== ".git",
+});
+
+if (scan.truncated) {
+  throw new Error("workspace scan exceeded entry budget");
+}
+```
+
+## Result
+
+```ts
+type WalkDirectoryResult = {
+  entries: WalkDirectoryEntry[];
+  scannedEntryCount: number;
+  truncated: boolean;
+};
+
+type WalkDirectoryEntry = {
+  name: string;
+  path: string;
+  relativePath: string;
+  depth: number;
+  kind: "file" | "directory" | "symlink" | "other";
+  dirent: import("node:fs").Dirent;
+};
+```
+
+`depth` starts at `1` for direct children of `rootDir`. `relativePath` is always relative to the supplied root. `scannedEntryCount` counts directory entries examined, including entries filtered out by `include`.
+
+## Options
+
+```ts
+type WalkDirectoryOptions = {
+  maxDepth?: number;
+  maxEntries?: number;
+  symlinks?: "skip" | "follow" | "include";
+  include?: (entry: WalkDirectoryEntry) => boolean;
+  descend?: (entry: WalkDirectoryEntry) => boolean;
+};
+```
+
+`symlinks` defaults to `"skip"`. `"include"` returns symlink entries without following them. `"follow"` resolves symlinks with `stat()` and may descend into linked directories, so use it only when that is intentional. Already-visited real directories are skipped so symlink cycles do not recurse forever.
+
+`include` controls which entries are returned. `descend` controls which directory entries are traversed. A skipped directory can still be returned if `include` accepts it.
+
+Unreadable directories are skipped. This makes the helper suitable for best-effort inventories and pruning jobs; use a stricter root-bounded operation when every entry must be accounted for.
+
+## See also
+
+- [`fileStore`](file-store.md) — managed stores use bounded walking for pruning.
+- [Path scopes](path-scope.md) — boundary checks for known absolute paths.

package/docs/writing.md

@@ -0,0 +1,222 @@
+# Writing
+
+The `Root` handle exposes a tight set of write verbs. Each one is atomic at the destination — no half-written intermediate state — and goes through the same boundary checks as reads.
+
+```ts
+await fs.write("state.json", body);
+await fs.create("seed.json", initial);   // throws if exists
+await fs.writeJson("config.json", state);
+await fs.append("logs/today.log", line);
+await fs.copyIn("inbox/upload.bin", "/tmp/upload.bin");
+await fs.move("notes/draft.md", "notes/published.md");
+await fs.remove("logs/yesterday.log");
+await fs.mkdir("snapshots/2026/05");
+```
+
+## What every write does
+
+1. Resolve the relative target against the canonical root and reject anything that escapes (`outside-workspace`).
+2. If `mkdir: true`, create missing parent directories with the parent fd pinned.
+3. Open the parent directory by fd. Subsequent rename/unlink uses the parent fd, not the path string, so a parent-directory symlink swap mid-call cannot divert the write.
+4. Write data to a sibling temp file in the same directory.
+5. Atomically rename the temp file over the destination.
+6. Stat the resulting fd and verify identity.
+
+A failure at any point either leaves the destination at its previous contents or surfaces an `FsSafeError` — never a partially-written file at the destination path.
+
+## Write verbs
+
+### `fs.write(rel, data, options?)`
+
+Overwrite or create. Always atomic.
+
+```ts
+await fs.write("state/last-run.json", JSON.stringify(run));
+await fs.write("notes/today.txt", "hello\n", { encoding: "utf8" });
+```
+
+`data` accepts `string | Buffer`. `options` are `{ encoding?: BufferEncoding; mkdir?: boolean; mode?: number; overwrite?: boolean }`. `mode` sets the file's POSIX mode; if omitted, falls back to the `mode` from `RootDefaults` and then to umask. `overwrite` defaults to `true`; set it to `false` for the same no-clobber behavior as `create()`.
+
+### `fs.create(rel, data, options?)`
+
+Don't-clobber variant of `write()`. Throws `already-exists` if the target is there.
+
+```ts
+try {
+  await fs.create("config/seed.json", initial);
+} catch (err) {
+  if (err instanceof FsSafeError && err.code !== "already-exists") throw err;
+}
+```
+
+### `fs.writeJson(rel, value, options?)`
+
+`JSON.stringify(value, replacer, space)` + atomic write. Adds a trailing newline by default.
+
+```ts
+await fs.writeJson("config.json", state, { space: 2 });
+await fs.writeJson("compact.json", state, { trailingNewline: false });
+```
+
+Options:
+
+```ts
+type RootWriteJsonOptions = {
+  encoding?: BufferEncoding;
+  mkdir?: boolean;
+  mode?: number;
+  replacer?: (this: any, key: string, value: any) => any | (number | string)[];
+  space?: number | string;
+  trailingNewline?: boolean; // default true
+};
+```
+
+`createJson(rel, value, options?)` is the don't-clobber variant.
+
+### `fs.append(rel, data, options?)`
+
+Open in append mode, write, close. Honors `mkdir` for the parent directory. Pass `prependNewlineIfNeeded: true` to insert a `\n` if the file does not already end in one.
+
+```ts
+await fs.append("logs/today.log", `[${ts}] ${line}\n`);
+await fs.append("notes/scratch.md", "* new bullet", { prependNewlineIfNeeded: true });
+```
+
+For high-volume logging, consider [`openWritable`](#openwritable) and a long-lived append handle.
+
+### `fs.copyIn(rel, sourceAbsPath, options?)`
+
+Bring a file from outside the root into the root, atomically. The source path must be absolute. The library streams the source through the boundary, writes to a sibling temp, and renames over the destination.
+
+```ts
+await fs.copyIn("inbox/upload.bin", "/tmp/incoming.bin", {
+  maxBytes: 64 * 1024 * 1024,
+});
+```
+
+Options: `{ encoding?, mkdir?, maxBytes?, sourceHardlinks? }`. Use `sourceHardlinks: "reject"` to refuse if the source itself is a hardlinked alias.
+
+### `fs.move(from, to, options?)`
+
+Rename one path inside the root to another. Defaults to no clobber:
+
+```ts
+await fs.move("incoming/foo.txt", "archive/foo.txt");
+await fs.move("incoming/foo.txt", "archive/foo.txt", { overwrite: true });
+```
+
+Both `from` and `to` are bounded; `..` in either is rejected.
+
+### `fs.remove(rel)`
+
+Unlink a file or `rmdir` an empty directory. Non-empty directories throw `not-empty`. For atomic directory replacement, use [`replaceDirectoryAtomic`](atomic.md#replacedirectoryatomic).
+
+```ts
+await fs.remove("logs/yesterday.log");
+await fs.remove("snapshots/empty-dir"); // ok
+await fs.remove("snapshots/full-dir");  // throws not-empty
+```
+
+### `fs.mkdir(rel)`
+
+`mkdir -p`. Creates missing parents.
+
+```ts
+await fs.mkdir("snapshots/2026/05");
+```
+
+### `fs.ensureRoot()`
+
+Treats `""` / `"."` as the root itself. Useful when a generic helper computes a relative directory and might end up at the root.
+
+```ts
+const targetRel = path.relative(fs.rootReal, candidateAbs); // could be "" if candidateAbs === root
+await fs.ensureRoot(); // accepts "" without throwing
+```
+
+## `openWritable()` for streaming
+
+When `write` doesn't fit (very large outputs, slow producers), open a writable handle:
+
+```ts
+const opened = await fs.openWritable("logs/current.log", { writeMode: "append" });
+try {
+  for await (const chunk of source) {
+    await opened.handle.appendFile(chunk);
+  }
+} finally {
+  await opened.handle.close();
+}
+```
+
+Options: `{ mkdir?, mode?, writeMode? }`, where `writeMode` is `"replace"` (default), `"append"`, or `"update"`. `replace` truncates existing files; `update` keeps existing contents. Streaming writes go directly to the destination — there is no atomic-rename step. If you need both streaming and atomicity, write to a sibling temp yourself and rename when done; the [`atomic`](atomic.md) helpers can do this for you.
+
+## Write defaults vs per-call options
+
+Set `mkdir: true` once on `root()`; pass text encodings per call when needed:
+
+```ts
+const fs = await root("/srv/workspace", {
+  mkdir: true,
+});
+
+await fs.write("notes/today.txt", "ascii", { encoding: "utf8" });
+await fs.write("data/blob.bin", buffer);     // mkdir true, no encoding because data is Buffer
+await fs.write("data/blob.bin", buffer, { mkdir: false }); // override
+```
+
+## Errors you'll catch
+
+| Code | When |
+|---|---|
+| `outside-workspace` | Target resolves outside the root. |
+| `already-exists` | `create()` / `createJson()` / `move({ overwrite: false })` hit an existing target. |
+| `not-found` | Parent does not exist and `mkdir` is false. |
+| `not-empty` | `remove()` on a non-empty directory. |
+| `not-removable` | `remove()` could not unlink/rmdir (typically permissions or device busy). |
+| `path-mismatch` | Post-write fd identity check did not match. Almost always a parallel writer. |
+| `too-large` | `copyIn()` source exceeded `maxBytes`. |
+| `symlink` | A path component is a symlink and policy is `reject`. |
+| `hardlink` | `sourceHardlinks: "reject"` saw `nlink > 1`. |
+
+Full list in [Errors](errors.md).
+
+## Common patterns
+
+### Replace if changed
+
+```ts
+const next = JSON.stringify(state);
+const prev = await fs.readText("state.json").catch(() => "");
+if (prev !== next) await fs.write("state.json", next);
+```
+
+### Stage many writes, then commit
+
+```ts
+const stagingDir = "snapshots/incoming";
+await fs.mkdir(stagingDir);
+for (const file of files) await fs.write(`${stagingDir}/${file.name}`, file.body);
+await fs.move(stagingDir, "snapshots/2026-05-05", { overwrite: true });
+```
+
+For a true commit-or-rollback over a *directory*, use [`replaceDirectoryAtomic`](atomic.md#replacedirectoryatomic).
+
+### Rotate logs
+
+```ts
+const today = `logs/${formatDate(new Date())}.log`;
+try {
+  await fs.create(today, "");
+} catch (err) {
+  if (!(err instanceof FsSafeError) || err.code !== "already-exists") throw err;
+}
+await fs.append(today, line);
+```
+
+## See also
+
+- [Atomic writes](atomic.md) — the lower-level `replaceFileAtomic` and friends.
+- [JSON files](json.md) — standalone JSON helpers without going through `root()`.
+- [Reading](reading.md) — companion read API.
+- [Errors](errors.md) — every code, when it fires.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/fs-safe",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Capability-style filesystem roots for Node.js apps that handle untrusted relative paths.",
   "license": "MIT",
   "repository": {
@@ -11,6 +11,7 @@
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "dist/**/*.d.ts.map",
+    "docs/**/*.md",
     "README.md",
     "CHANGELOG.md",
     "SECURITY.md",
@@ -35,6 +36,10 @@
       "types": "./dist/path.d.ts",
       "default": "./dist/path.js"
     },
+    "./output": {
+      "types": "./dist/output.d.ts",
+      "default": "./dist/output.js"
+    },
     "./advanced": {
       "types": "./dist/advanced.d.ts",
       "default": "./dist/advanced.js"
@@ -95,10 +100,13 @@
   "scripts": {
     "benchmark": "node scripts/benchmark.mjs",
     "build": "tsc -p tsconfig.json",
+    "lint:file-size": "node scripts/check-file-size.mjs",
+    "lint:fs-boundary": "node scripts/check-fs-boundary-primitives.mjs",
     "prepack": "node scripts/prepack-build.mjs",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "check": "pnpm build && pnpm test",
+    "test:security": "vitest run test/fs-safe.test.ts test/openclaw-read-bypass-parity.test.ts test/openclaw-write-bypass-parity.test.ts test/additional-bypass-parity.test.ts test/adversarial-boundary-payloads.test.ts",
+    "check": "pnpm lint:file-size && pnpm lint:fs-boundary && pnpm build && pnpm test",
     "docs:site": "node scripts/build-docs-site.mjs"
   },
   "optionalDependencies": {

package/dist/archive-utils.d.ts

@@ -1,3 +0,0 @@
-export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T>;
-export declare function fileExists(filePath: string): Promise<boolean>;
-//# sourceMappingURL=archive-utils.d.ts.map

package/dist/archive-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"archive-utils.d.ts","sourceRoot":"","sources":["../src/archive-utils.ts"],"names":[],"mappings":"AAEA,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,CAAC,CAAC,CAiBZ;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOnE"}

package/dist/archive-utils.js

@@ -1,26 +0,0 @@
-import fs from "node:fs/promises";
-export async function withTimeout(promise, timeoutMs, label) {
-    let timeoutId;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject) => {
-                timeoutId = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-        }
-    }
-}
-export async function fileExists(filePath) {
-    try {
-        await fs.stat(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/boundary-file-read.d.ts

@@ -1,44 +0,0 @@
-import fs from "node:fs";
-import type { PathAliasPolicy } from "./path-alias-guards.js";
-import { type SafeOpenSyncAllowedType, type SafeOpenSyncFailureReason } from "./safe-open-sync.js";
-type BoundaryReadFs = Pick<typeof fs, "closeSync" | "constants" | "fstatSync" | "lstatSync" | "openSync" | "readFileSync" | "realpathSync">;
-export type BoundaryFileOpenFailureReason = SafeOpenSyncFailureReason | "validation";
-export type BoundaryFileOpenResult = {
-    ok: true;
-    path: string;
-    fd: number;
-    stat: fs.Stats;
-    rootRealPath: string;
-} | {
-    ok: false;
-    reason: BoundaryFileOpenFailureReason;
-    error?: unknown;
-};
-export type BoundaryFileOpenFailure = Extract<BoundaryFileOpenResult, {
-    ok: false;
-}>;
-export type OpenBoundaryFileSyncParams = {
-    absolutePath: string;
-    rootPath: string;
-    boundaryLabel: string;
-    rootRealPath?: string;
-    maxBytes?: number;
-    rejectHardlinks?: boolean;
-    allowedType?: SafeOpenSyncAllowedType;
-    skipLexicalRootCheck?: boolean;
-    ioFs?: BoundaryReadFs;
-};
-export type OpenBoundaryFileParams = OpenBoundaryFileSyncParams & {
-    aliasPolicy?: PathAliasPolicy;
-};
-export declare function canUseBoundaryFileOpen(ioFs: typeof fs): boolean;
-export declare function openBoundaryFileSync(params: OpenBoundaryFileSyncParams): BoundaryFileOpenResult;
-export declare function matchBoundaryFileOpenFailure<T>(failure: BoundaryFileOpenFailure, handlers: {
-    path?: (failure: BoundaryFileOpenFailure) => T;
-    validation?: (failure: BoundaryFileOpenFailure) => T;
-    io?: (failure: BoundaryFileOpenFailure) => T;
-    fallback: (failure: BoundaryFileOpenFailure) => T;
-}): T;
-export declare function openBoundaryFile(params: OpenBoundaryFileParams): Promise<BoundaryFileOpenResult>;
-export {};
-//# sourceMappingURL=boundary-file-read.d.ts.map

package/dist/boundary-file-read.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"boundary-file-read.d.ts","sourceRoot":"","sources":["../src/boundary-file-read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AAOzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC/B,MAAM,qBAAqB,CAAC;AAE7B,KAAK,cAAc,GAAG,IAAI,CACxB,OAAO,EAAE,EACP,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,UAAU,GACV,cAAc,GACd,cAAc,CACjB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,yBAAyB,GAAG,YAAY,CAAC;AAErF,MAAM,MAAM,sBAAsB,GAC9B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,6BAA6B,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE1E,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,EAAE;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAErF,MAAM,MAAM,0BAA0B,GAAG;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,uBAAuB,CAAC;IACtC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,0BAA0B,GAAG;IAChE,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B,CAAC;AAQF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAW/D;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,0BAA0B,GAAG,sBAAsB,CAuB/F;AAED,wBAAgB,4BAA4B,CAAC,CAAC,EAC5C,OAAO,EAAE,uBAAuB,EAChC,QAAQ,EAAE;IACR,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,CAAC,CAAC;IAC/C,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,CAAC,CAAC;IACrD,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,CAAC,CAAC;IAC7C,QAAQ,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,CAAC,CAAC;CACnD,GACA,CAAC,CAUH;AAoDD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,sBAAsB,CAAC,CAsBjC"}