@openclaw/fs-safe 0.1.0 → 0.1.2

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.0",
+  "version": "0.1.2",
   "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",
@@ -95,10 +96,12 @@
   "scripts": {
     "benchmark": "node scripts/benchmark.mjs",
     "build": "tsc -p tsconfig.json",
+    "lint:file-size": "node scripts/check-file-size.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 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"}

package/dist/boundary-file-read.js

@@ -1,129 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { resolveBoundaryPath, resolveBoundaryPathSync, } from "./boundary-path.js";
-import { openVerifiedFileSync, } from "./safe-open-sync.js";
-export function canUseBoundaryFileOpen(ioFs) {
-    return (typeof ioFs.openSync === "function" &&
-        typeof ioFs.closeSync === "function" &&
-        typeof ioFs.fstatSync === "function" &&
-        typeof ioFs.lstatSync === "function" &&
-        typeof ioFs.realpathSync === "function" &&
-        typeof ioFs.readFileSync === "function" &&
-        typeof ioFs.constants === "object" &&
-        ioFs.constants !== null);
-}
-export function openBoundaryFileSync(params) {
-    const ioFs = params.ioFs ?? fs;
-    const resolved = resolveBoundaryFilePathGeneric({
-        absolutePath: params.absolutePath,
-        resolve: (absolutePath) => resolveBoundaryPathSync({
-            absolutePath,
-            rootPath: params.rootPath,
-            rootCanonicalPath: params.rootRealPath,
-            boundaryLabel: params.boundaryLabel,
-            skipLexicalRootCheck: params.skipLexicalRootCheck,
-        }),
-    });
-    if (resolved instanceof Promise) {
-        return toBoundaryValidationError(new Error("Unexpected async boundary resolution"));
-    }
-    return finalizeBoundaryFileOpen({
-        resolved,
-        maxBytes: params.maxBytes,
-        rejectHardlinks: params.rejectHardlinks,
-        allowedType: params.allowedType,
-        ioFs,
-    });
-}
-export function matchBoundaryFileOpenFailure(failure, handlers) {
-    switch (failure.reason) {
-        case "path":
-            return handlers.path ? handlers.path(failure) : handlers.fallback(failure);
-        case "validation":
-            return handlers.validation ? handlers.validation(failure) : handlers.fallback(failure);
-        case "io":
-            return handlers.io ? handlers.io(failure) : handlers.fallback(failure);
-    }
-    return handlers.fallback(failure);
-}
-function openBoundaryFileResolved(params) {
-    const opened = openVerifiedFileSync({
-        filePath: params.absolutePath,
-        resolvedPath: params.resolvedPath,
-        rejectHardlinks: params.rejectHardlinks ?? true,
-        maxBytes: params.maxBytes,
-        allowedType: params.allowedType,
-        ioFs: params.ioFs,
-    });
-    if (!opened.ok) {
-        return opened;
-    }
-    return {
-        ok: true,
-        path: opened.path,
-        fd: opened.fd,
-        stat: opened.stat,
-        rootRealPath: params.rootRealPath,
-    };
-}
-function finalizeBoundaryFileOpen(params) {
-    if ("ok" in params.resolved) {
-        return params.resolved;
-    }
-    return openBoundaryFileResolved({
-        absolutePath: params.resolved.absolutePath,
-        resolvedPath: params.resolved.resolvedPath,
-        rootRealPath: params.resolved.rootRealPath,
-        maxBytes: params.maxBytes,
-        rejectHardlinks: params.rejectHardlinks,
-        allowedType: params.allowedType,
-        ioFs: params.ioFs,
-    });
-}
-export async function openBoundaryFile(params) {
-    const ioFs = params.ioFs ?? fs;
-    const maybeResolved = resolveBoundaryFilePathGeneric({
-        absolutePath: params.absolutePath,
-        resolve: (absolutePath) => resolveBoundaryPath({
-            absolutePath,
-            rootPath: params.rootPath,
-            rootCanonicalPath: params.rootRealPath,
-            boundaryLabel: params.boundaryLabel,
-            policy: params.aliasPolicy,
-            skipLexicalRootCheck: params.skipLexicalRootCheck,
-        }),
-    });
-    const resolved = maybeResolved instanceof Promise ? await maybeResolved : maybeResolved;
-    return finalizeBoundaryFileOpen({
-        resolved,
-        maxBytes: params.maxBytes,
-        rejectHardlinks: params.rejectHardlinks,
-        allowedType: params.allowedType,
-        ioFs,
-    });
-}
-function toBoundaryValidationError(error) {
-    return { ok: false, reason: "validation", error };
-}
-function mapResolvedBoundaryPath(absolutePath, resolved) {
-    return {
-        absolutePath,
-        resolvedPath: resolved.canonicalPath,
-        rootRealPath: resolved.rootCanonicalPath,
-    };
-}
-function resolveBoundaryFilePathGeneric(params) {
-    const absolutePath = path.resolve(params.absolutePath);
-    try {
-        const resolved = params.resolve(absolutePath);
-        if (resolved instanceof Promise) {
-            return resolved
-                .then((value) => mapResolvedBoundaryPath(absolutePath, value))
-                .catch((error) => toBoundaryValidationError(error));
-        }
-        return mapResolvedBoundaryPath(absolutePath, resolved);
-    }
-    catch (error) {
-        return toBoundaryValidationError(error);
-    }
-}

package/dist/boundary-path.d.ts

@@ -1,39 +0,0 @@
-type BoundaryPathIntent = "read" | "write" | "create" | "delete" | "stat";
-export type BoundaryPathAliasPolicy = {
-    allowFinalSymlinkForUnlink?: boolean;
-    allowFinalHardlinkForUnlink?: boolean;
-};
-export declare const BOUNDARY_PATH_ALIAS_POLICIES: {
-    readonly strict: Readonly<{
-        allowFinalSymlinkForUnlink: false;
-        allowFinalHardlinkForUnlink: false;
-    }>;
-    readonly unlinkTarget: Readonly<{
-        allowFinalSymlinkForUnlink: true;
-        allowFinalHardlinkForUnlink: true;
-    }>;
-};
-type ResolveBoundaryPathParams = {
-    absolutePath: string;
-    rootPath: string;
-    boundaryLabel: string;
-    intent?: BoundaryPathIntent;
-    policy?: BoundaryPathAliasPolicy;
-    skipLexicalRootCheck?: boolean;
-    rootCanonicalPath?: string;
-};
-type ResolvedBoundaryPathKind = "missing" | "file" | "directory" | "symlink" | "other";
-export type ResolvedBoundaryPath = {
-    absolutePath: string;
-    canonicalPath: string;
-    rootPath: string;
-    rootCanonicalPath: string;
-    relativePath: string;
-    exists: boolean;
-    kind: ResolvedBoundaryPathKind;
-};
-export declare function resolveBoundaryPath(params: ResolveBoundaryPathParams): Promise<ResolvedBoundaryPath>;
-export declare function resolveBoundaryPathSync(params: ResolveBoundaryPathParams): ResolvedBoundaryPath;
-export declare function resolvePathViaExistingAncestorSync(targetPath: string): string;
-export {};
-//# sourceMappingURL=boundary-path.d.ts.map

package/dist/boundary-path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"boundary-path.d.ts","sourceRoot":"","sources":["../src/boundary-path.ts"],"names":[],"mappings":"AAMA,KAAK,kBAAkB,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1E,MAAM,MAAM,uBAAuB,GAAG;IACpC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;CAS/B,CAAC;AAEX,KAAK,yBAAyB,GAAG;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,wBAAwB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEvF,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,wBAAwB,CAAC;CAChC,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,oBAAoB,CAAC,CA+B/B;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,yBAAyB,GAAG,oBAAoB,CA+B/F;AAmkBD,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA6B7E"}