poe-code 12.0.2 → 12.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "12.0.2",
+  "version": "12.0.3",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,10 @@
     "./skills": {
       "types": "./dist/skills.d.ts",
       "import": "./dist/skills.js"
+    },
+    "./safe-fs": {
+      "types": "./packages/safe-fs/dist/index.d.ts",
+      "import": "./packages/safejs/dist/safe-fs.js"
     }
   },
   "workspaces": [
@@ -194,7 +198,8 @@
     "packages/toolcraft-openapi/dist",
     "packages/toolcraft-schema/dist",
     "packages/workspace-resolver/dist",
-    "packages/worktree/dist"
+    "packages/worktree/dist",
+    "packages/safe-fs/dist/**/*.d.ts"
   ],
   "engines": {
     "node": ">=18.18"
@@ -270,6 +275,7 @@
     "@poe-code/providers": "*",
     "@poe-code/py-poe-spawn": "*",
     "@poe-code/ralph": "*",
+    "@poe-code/safe-fs": "*",
     "@poe-code/safejs": "*",
     "@poe-code/superintendent": "*",
     "@poe-code/task-list": "*",

package/packages/package-lint/dist/bundle-policy.d.ts

@@ -0,0 +1,45 @@
+export declare const canonicalFs: {
+    readonly workspace: "../../safe-fs/dist/index.js";
+    readonly specifier: "poe-code/safe-fs";
+    readonly source: "packages/safe-fs/src/index.ts";
+    readonly runtime: "packages/safejs/dist/safe-fs.js";
+    readonly types: "packages/safe-fs/dist/index.d.ts";
+};
+export interface BundleMetafile {
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, {
+        entryPoint?: string;
+        imports?: {
+            path?: string;
+            external?: boolean;
+            kind?: string;
+        }[];
+        inputs?: Record<string, unknown>;
+        cssBundle?: string;
+    }>;
+    canonicalBundle?: {
+        entryPoints: string[];
+        metafile: BundleMetafile;
+    };
+}
+export interface BundleIssue {
+    external: string;
+    reason: string;
+}
+interface PackageManifest {
+    name: string;
+    exports?: unknown;
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+}
+export declare function findBundleIssues(manifest: PackageManifest, workspaceNames: ReadonlySet<string>, metafile: BundleMetafile, packedFiles: ReadonlySet<string>): BundleIssue[];
+export declare function collectPackageFiles(rootDir: string, entries: readonly string[], files: {
+    readdir(filename: string): Promise<{
+        name: string;
+        isDirectory(): boolean;
+    }[]>;
+    stat?(filename: string): Promise<{
+        isFile(): boolean;
+    }>;
+}): Promise<Set<string>>;
+export {};

package/packages/package-lint/dist/bundle-policy.js

@@ -0,0 +1,169 @@
+import { isBuiltin } from "node:module";
+import path from "node:path";
+export const canonicalFs = {
+    workspace: "@poe-code/safe-fs",
+    specifier: "poe-code/safe-fs",
+    source: "packages/safe-fs/src/index.ts",
+    runtime: "packages/safejs/dist/safe-fs.js",
+    types: "packages/safe-fs/dist/index.d.ts"
+};
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function packageName(specifier) {
+    if (!specifier ||
+        specifier.startsWith(".") ||
+        specifier.startsWith("/") ||
+        [...specifier].some((character) => character.charCodeAt(0) <= 32) ||
+        [":", "\\", "?", "#", "%"].some((character) => specifier.includes(character)))
+        return undefined;
+    const parts = specifier.split("/");
+    if (parts.some((part) => !part || part === "." || part === ".."))
+        return undefined;
+    if (specifier.startsWith("@")) {
+        if (parts.length < 2 || parts[0].length === 1)
+            return undefined;
+        return `${parts[0]}/${parts[1]}`;
+    }
+    return parts[0];
+}
+export function findBundleIssues(manifest, workspaceNames, metafile, packedFiles) {
+    const issues = [];
+    const exported = record(record(manifest.exports)["./safe-fs"]);
+    const imports = new Set(Object.values(metafile.outputs ?? {}).flatMap((output) => (output.imports ?? [])
+        .filter((dependency) => dependency.external)
+        .map((dependency) => dependency.path ?? "")));
+    const runtimeDependencies = new Set([
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...Object.keys(manifest.optionalDependencies ?? {})
+    ]);
+    for (const specifier of [...imports].sort()) {
+        if (isBuiltin(specifier))
+            continue;
+        if (specifier === canonicalFs.specifier && manifest.name === "poe-code")
+            continue;
+        const dependency = packageName(specifier);
+        const reason = !dependency
+            ? "invalid-external"
+            : dependency === manifest.name || workspaceNames.has(dependency)
+                ? "workspace-not-inlined"
+                : !runtimeDependencies.has(dependency)
+                    ? "undeclared-dependency"
+                    : undefined;
+        if (reason)
+            issues.push({ external: specifier, reason });
+    }
+    if (!metafile.canonicalBundle &&
+        !imports.has(canonicalFs.specifier) &&
+        !Object.keys(exported).length)
+        return issues;
+    const fail = (reason) => issues.push({ external: canonicalFs.specifier, reason });
+    if (manifest.name !== "poe-code" ||
+        exported.import !== `./${canonicalFs.runtime}` ||
+        exported.types !== `./${canonicalFs.types}` ||
+        Object.keys(exported).some((condition) => condition !== "import" && condition !== "types")) {
+        fail("invalid-canonical-export");
+    }
+    if (!packedFiles.has(canonicalFs.types))
+        fail("unpacked-canonical-types");
+    if ([...packedFiles].some((filename) => filename.startsWith("packages/safe-fs/dist/") &&
+        [".js", ".mjs", ".cjs"].some((extension) => filename.endsWith(extension))))
+        fail("duplicate-packed-runtime");
+    if (Object.keys(metafile.inputs ?? {}).some((input) => input.startsWith("packages/safe-fs/src/"))) {
+        fail("duplicate-canonical-runtime");
+    }
+    const canonical = metafile.canonicalBundle;
+    if (!canonical ||
+        !Array.isArray(canonical.entryPoints) ||
+        !canonical.entryPoints.includes(canonicalFs.source)) {
+        fail("missing-canonical-root");
+        return issues;
+    }
+    const outputs = canonical.metafile.outputs ?? {};
+    if (!Object.hasOwn(canonical.metafile.inputs ?? {}, canonicalFs.source))
+        fail("missing-canonical-source");
+    if (outputs[canonicalFs.runtime]?.entryPoint !== canonicalFs.source)
+        fail("invalid-canonical-root");
+    for (const entry of canonical.entryPoints) {
+        if (!Object.values(outputs).some((output) => output.entryPoint === entry))
+            fail("missing-declared-root");
+    }
+    const pending = [canonicalFs.runtime];
+    const visited = new Set();
+    while (pending.length) {
+        const filename = pending.pop();
+        if (visited.has(filename))
+            continue;
+        visited.add(filename);
+        if (!filename.startsWith("packages/safejs/dist/") ||
+            path.posix.normalize(filename) !== filename) {
+            fail("invalid-canonical-path");
+            continue;
+        }
+        const output = outputs[filename];
+        if (!output) {
+            fail("missing-canonical-output");
+            continue;
+        }
+        if (!packedFiles.has(filename))
+            fail("unpacked-canonical-output");
+        if (filename.endsWith(".js"))
+            pending.push(`${filename}.map`);
+        if (Object.keys(output.inputs ?? {}).some((input) => !input.startsWith("packages/safe-fs/src/")))
+            fail("foreign-canonical-input");
+        if (output.cssBundle)
+            pending.push(output.cssBundle);
+        for (const dependency of output.imports ?? []) {
+            if (dependency.external) {
+                if (!dependency.path || !isBuiltin(dependency.path))
+                    fail("external-canonical-dependency");
+            }
+            else if (dependency.path)
+                pending.push(dependency.path);
+            else
+                fail("missing-canonical-edge");
+        }
+    }
+    return issues;
+}
+export async function collectPackageFiles(rootDir, entries, files) {
+    const packed = new Set();
+    async function visit(filename, declarationsOnly) {
+        const absolute = path.join(rootDir, filename);
+        let children;
+        try {
+            children = await files.readdir(absolute);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT")
+                return;
+            if (code !== "ENOTDIR")
+                throw error;
+            if ((!declarationsOnly || filename.endsWith(".d.ts")) &&
+                (!files.stat || (await files.stat(absolute)).isFile()))
+                packed.add(filename);
+            return;
+        }
+        for (const child of children) {
+            const relative = path.posix.join(filename, child.name);
+            if (child.isDirectory())
+                await visit(relative, declarationsOnly);
+            else if (!declarationsOnly || child.name.endsWith(".d.ts"))
+                packed.add(relative);
+        }
+    }
+    for (const entry of entries) {
+        const declarationsOnly = entry.endsWith("/**/*.d.ts");
+        const directory = declarationsOnly ? entry.slice(0, -"/**/*.d.ts".length) : entry;
+        if (directory.includes("*") ||
+            directory.startsWith("/") ||
+            directory.split("/").includes("..")) {
+            throw new Error(`Unsupported package files entry: ${entry}`);
+        }
+        await visit(directory, declarationsOnly);
+    }
+    return packed;
+}

package/packages/package-lint/dist/model.d.ts

@@ -1,3 +1,4 @@
+import type { BundleMetafile } from "./bundle-policy.js";
 import { type PackageFileView, type PacklistProvider } from "./packlist.js";
 import { type RuntimeAssetDeclaration, type RuntimeFileAssetView } from "./runtime-files.js";
 import { type SourceImportView } from "./source-imports.js";
@@ -97,6 +98,8 @@ export interface BuildView {
     inlinedDirs: Set<string>;
     /** Bare specifiers left external by the bundle, reduced to package names. */
     externals: Set<string>;
+    externalImports: Set<string>;
+    metafile: BundleMetafile;
 }
 export interface Violation {
     rule: string;
@@ -133,16 +136,7 @@ export declare function loadWorkspace(fs: LintFs, rootDir: string, options?: {
 export declare function releaseTargetDirs(model: WorkspaceModel): Set<string>;
 /** A package genuinely reaches npm: it is a public npm package a release workflow publishes. */
 export declare function isGenuinelyPublished(model: WorkspaceModel, pkg: PackageInfo): boolean;
-export declare function parseMetafile(meta: {
-    inputs?: Record<string, unknown>;
-    outputs?: Record<string, {
-        imports?: {
-            path?: string;
-            external?: boolean;
-            kind?: string;
-        }[];
-    }>;
-}): BuildView;
+export declare function parseMetafile(meta: BundleMetafile): BuildView;
 export declare function loadBuildView(fs: LintFs, rootDir: string): Promise<BuildView | undefined>;
 /** All workspace packages plus the root package. */
 export declare function allPackages(model: WorkspaceModel): PackageInfo[];

package/packages/package-lint/dist/model.js

@@ -427,16 +427,18 @@ export function parseMetafile(meta) {
             inlinedDirs.add(dir);
     }
     const externals = new Set();
+    const externalImports = new Set();
     for (const output of Object.values(meta.outputs ?? {})) {
         for (const imp of output.imports ?? []) {
-            if (imp.external && imp.kind !== "dynamic-import" && typeof imp.path === "string") {
+            if (imp.external && typeof imp.path === "string") {
+                externalImports.add(imp.path);
                 const name = toPackageName(imp.path);
                 if (name)
                     externals.add(name);
             }
         }
     }
-    return { inlinedDirs, externals };
+    return { inlinedDirs, externals, externalImports, metafile: meta };
 }
 export async function loadBuildView(fs, rootDir) {
     let raw;

package/packages/package-lint/dist/packlist.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { collectPackageFiles } from "./bundle-policy.js";
 function toPosix(p) {
     return p.replaceAll("\\", "/");
 }
@@ -66,7 +67,10 @@ async function listFallbackPackFiles(fs, packageRoot) {
         return listAllFiles(fs, packageRoot);
     const files = new Set();
     for (const entry of allowlist) {
-        for (const listed of await listFilesEntry(fs, packageRoot, entry))
+        const listedFiles = entry.endsWith("/**/*.d.ts")
+            ? await collectPackageFiles(packageRoot, [entry], fs)
+            : await listFilesEntry(fs, packageRoot, entry);
+        for (const listed of listedFiles)
             files.add(listed);
     }
     return files;

package/packages/package-lint/dist/rules/bundle-self-contained.js

@@ -1,4 +1,4 @@
-import { isBuiltin } from "node:module";
+import { findBundleIssues } from "../bundle-policy.js";
 const id = "bundle-self-contained";
 function workspaceNames(model) {
     const names = new Set(model.packages.map((p) => p.name));
@@ -18,30 +18,16 @@ export const bundleSelfContained = {
             return [];
         const violations = [];
         const workspace = workspaceNames(model);
-        const rootDeps = new Set(Object.keys(model.root.dependencies));
-        for (const external of [...build.externals].sort()) {
-            if (workspace.has(external)) {
-                violations.push({
-                    rule: id,
-                    package: external,
-                    severity: "error",
-                    via: "bundle",
-                    detail: { external, reason: "workspace-not-inlined" },
-                    message: `workspace package ${external} is externalized by the bundle instead of inlined; it is unpublished and will not resolve at runtime`,
-                    fix: `Add a source alias for ${external} so the bundle inlines it.`
-                });
-            }
-            else if (!rootDeps.has(external) && !isBuiltin(external)) {
-                violations.push({
-                    rule: id,
-                    package: model.root.name,
-                    severity: "error",
-                    via: "bundle",
-                    detail: { external, reason: "undeclared-dependency" },
-                    message: `bundle externalizes ${external}, which is not declared in root dependencies`,
-                    fix: `Add ${external} to root "dependencies".`
-                });
-            }
+        for (const issue of findBundleIssues(model.root, workspace, build.metafile, model.packageFiles.get(".")?.files ?? new Set())) {
+            violations.push({
+                rule: id,
+                package: workspace.has(issue.external) ? issue.external : model.root.name,
+                severity: "error",
+                via: "bundle",
+                detail: { ...issue },
+                message: `bundle import ${issue.external} violates publication policy: ${issue.reason}`,
+                fix: "Inline private workspace code or supply the exact declared and packed canonical artifact; declare ordinary runtime dependencies."
+            });
         }
         return violations;
     }

package/packages/safe-fs/dist/contracts/abort.d.ts

@@ -0,0 +1,5 @@
+export interface AbortSignalScope {
+    readonly signal: AbortSignal;
+    dispose(): void;
+}
+export declare function composeAbortSignals(signals: readonly AbortSignal[]): AbortSignalScope;

package/packages/safe-fs/dist/contracts/cleanup.d.ts

@@ -0,0 +1 @@
+export declare function finishCleanup(cleanup: () => unknown, failed: boolean): Promise<void>;

package/packages/safe-fs/dist/contracts/errors.d.ts

@@ -0,0 +1,49 @@
+declare const descriptions: {
+    readonly EACCES: "permission denied";
+    readonly EAGAIN: "resource temporarily unavailable";
+    readonly EBADF: "bad file descriptor";
+    readonly EBUSY: "resource busy or locked";
+    readonly ECANCELED: "operation canceled";
+    readonly EEXIST: "file already exists";
+    readonly EFBIG: "file too large";
+    readonly EINTR: "interrupted system call";
+    readonly EINVAL: "invalid argument";
+    readonly EIO: "input/output error";
+    readonly EISDIR: "illegal operation on a directory";
+    readonly ELOOP: "too many symbolic links encountered";
+    readonly EMFILE: "too many open files";
+    readonly ENAMETOOLONG: "name too long";
+    readonly ENFILE: "file table overflow";
+    readonly ENOENT: "no such file or directory";
+    readonly ENOMEM: "not enough memory";
+    readonly ENOSPC: "no space left on device";
+    readonly ENOSYS: "function not implemented";
+    readonly ENOTDIR: "not a directory";
+    readonly ENOTEMPTY: "directory not empty";
+    readonly ENOTSUP: "operation not supported";
+    readonly EOPNOTSUPP: "operation not supported";
+    readonly EPERM: "operation not permitted";
+    readonly EPIPE: "broken pipe";
+    readonly EROFS: "read-only file system";
+    readonly ETIMEDOUT: "operation timed out";
+    readonly EXDEV: "cross-device link not permitted";
+};
+export type ErrnoCode = keyof typeof descriptions;
+export interface FsErrorOptions extends ErrorOptions {
+    readonly syscall?: string;
+    readonly path?: string;
+    readonly dest?: string;
+    readonly message?: string;
+}
+export declare class FsError extends Error {
+    readonly code: ErrnoCode;
+    readonly errno: number;
+    readonly syscall?: string;
+    readonly path?: string;
+    readonly dest?: string;
+    constructor(code: ErrnoCode, options?: FsErrorOptions);
+}
+export declare function isErrnoCode(code: unknown): code is ErrnoCode;
+export declare function isFsError(error: unknown, code?: ErrnoCode): error is FsError;
+export declare function toFsError(error: unknown, options?: FsErrorOptions): FsError;
+export {};

package/packages/safe-fs/dist/contracts/filesystem.d.ts

@@ -0,0 +1,96 @@
+import type { ByteSource } from "./io.js";
+export type FileType = "file" | "directory" | "symlink";
+export type EntryComparison = "same" | "distinct" | "unknown";
+export interface FileStat {
+    readonly type: FileType;
+    readonly size: number;
+    readonly allocatedBytes?: number;
+    readonly mode: number;
+    readonly mtimeMs: number;
+    readonly atimeMs: number;
+    readonly ctimeMs: number;
+    readonly birthtimeMs?: number;
+    readonly identityScope?: object | symbol;
+    readonly ino?: number;
+    readonly dev?: number;
+    readonly nlink?: number;
+    readonly uid?: number;
+    readonly gid?: number;
+}
+export interface DirectoryEntry {
+    readonly name: string;
+    readonly type: FileType;
+}
+export interface FileSystemCapabilities {
+    readonly readOnly?: boolean;
+    readonly symlinks?: boolean;
+    readonly hardlinks?: boolean;
+    readonly permissions?: boolean;
+    readonly timestamps?: boolean;
+    readonly atomicRename?: boolean;
+    readonly snapshotRmdir?: boolean;
+    readonly streamingRead?: boolean;
+    readonly streamingWrite?: boolean;
+    readonly [capability: string]: boolean | undefined;
+}
+export interface FsOptions {
+    readonly signal?: AbortSignal;
+}
+export interface ReadFileOptions extends FsOptions {
+    readonly maxBytes?: number;
+}
+export interface WriteFileOptions extends FsOptions {
+    readonly flag?: "w" | "wx" | "a" | "ax";
+    readonly mode?: number;
+}
+export interface AppendFileOptions extends FsOptions {
+    readonly mode?: number;
+}
+export interface MkdirOptions extends FsOptions {
+    readonly recursive?: boolean;
+    readonly mode?: number;
+}
+export interface RemoveOptions extends FsOptions {
+    readonly recursive?: boolean;
+    readonly force?: boolean;
+}
+export interface CopyFileOptions extends FsOptions {
+    readonly exclusive?: boolean;
+}
+export interface ReadStreamOptions extends FsOptions {
+    readonly start?: number;
+    readonly endExclusive?: number;
+    readonly chunkSize?: number;
+}
+export interface FileSystem {
+    readonly capabilities: FileSystemCapabilities;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    compareEntry?(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    rmdir?(path: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink?(path: string, options?: FsOptions): Promise<string>;
+    symlink?(target: string, path: string, options?: FsOptions): Promise<void>;
+    link?(existingPath: string, newPath: string, options?: FsOptions): Promise<void>;
+    chmod?(path: string, mode: number, options?: FsOptions): Promise<void>;
+    utimes?(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate?(path: string, length?: number, options?: FsOptions): Promise<void>;
+    readStream?(path: string, options?: ReadStreamOptions): ByteSource;
+    writeStream?(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+}
+export type FileSystemFactory = (options: Readonly<Record<string, unknown>>) => FileSystem | Promise<FileSystem>;
+export declare const ACCESS_MODES: Readonly<{
+    F_OK: 0;
+    R_OK: 4;
+    W_OK: 2;
+    X_OK: 1;
+}>;

package/packages/safe-fs/dist/contracts/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./errors.js";
+export * from "./filesystem.js";
+export * from "./io.js";
+export * from "./path.js";

package/packages/safe-fs/dist/contracts/io.d.ts

@@ -0,0 +1,8 @@
+export type ByteSource = AsyncIterable<Uint8Array>;
+export interface CollectOptions {
+    readonly maxBytes: number;
+    readonly signal?: AbortSignal;
+}
+export declare function toByteSource(input: string | Uint8Array): ByteSource;
+export declare function collectBytes(source: ByteSource, options: CollectOptions): Promise<Uint8Array>;
+export declare function readBytes(source: ByteSource, signal?: AbortSignal): AsyncGenerator<Uint8Array>;

package/packages/safe-fs/dist/contracts/path.d.ts

@@ -0,0 +1,13 @@
+import { posix } from "node:path";
+export declare const posixPath: typeof posix;
+export declare const basename: typeof posix.basename;
+export declare const dirname: typeof posix.dirname;
+export declare const extname: typeof posix.extname;
+export declare const joinPath: typeof posix.join;
+export declare const isAbsolutePath: typeof posix.isAbsolute;
+export declare function validatePath(path: string): void;
+export declare function resolvePath(cwd: string, ...paths: string[]): string;
+export declare function normalizePath(path: string, cwd?: string): string;
+export declare function relativePath(from: string, to: string): string;
+export declare function isPathWithin(root: string, path: string): boolean;
+export declare function assertPathWithin(root: string, path: string): string;

package/packages/safe-fs/dist/fs/memory/index.d.ts

@@ -0,0 +1,58 @@
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { ByteSource } from "../../contracts/io.js";
+export declare class MemoryFileSystem implements FileSystem {
+    readonly capabilities: Readonly<{
+        readOnly: false;
+        symlinks: true;
+        hardlinks: true;
+        permissions: true;
+        timestamps: true;
+        atomicRename: true;
+        streamingRead: true;
+        streamingWrite: true;
+    }>;
+    private readonly identityScope;
+    private nextInode;
+    private readonly root;
+    constructor();
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
+    private metadata;
+    private directory;
+    private fail;
+    private validatePath;
+    private permission;
+    private mode;
+    private integer;
+    private changed;
+    private resolve;
+    private file;
+    private entry;
+    private terminalDot;
+    private snapshot;
+    private bytes;
+    private allocate;
+    private openWrite;
+    private append;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, options?: FsOptions): Promise<string>;
+    symlink(target: string, path: string, options?: FsOptions): Promise<void>;
+    link(existingPath: string, newPath: string, options?: FsOptions): Promise<void>;
+    chmod(path: string, mode: number, options?: FsOptions): Promise<void>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
+    readStream(path: string, options?: ReadStreamOptions): ByteSource;
+    writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+}
+export declare function createMemoryFileSystem(): MemoryFileSystem;

package/packages/safe-fs/dist/fs/mount/comparison.d.ts

@@ -0,0 +1,18 @@
+import type { EntryComparison, FileStat, FileSystem, FsOptions } from "../../contracts/filesystem.js";
+export interface EntryLocation {
+    readonly filesystem: FileSystem;
+    readonly path: string;
+    readonly readOnly?: boolean;
+    readonly stat?: FileStat;
+}
+export interface EntryView extends EntryLocation {
+    readonly stat: FileStat;
+    readonly readOnly: boolean;
+}
+export type EntryViewResolver = (path: string, options: FsOptions) => Promise<EntryLocation>;
+export type EntryAuthority = (own: EntryView, peer: EntryView, options: FsOptions) => Promise<EntryComparison>;
+export declare function registerEntryView(filesystem: FileSystem, resolver: EntryViewResolver): void;
+export declare function registerEntryAuthority(filesystem: FileSystem, authority: EntryAuthority): void;
+export declare function resolveEntryView(filesystem: FileSystem, path: string, options?: FsOptions): Promise<EntryView>;
+export declare function compareResolvedEntries(own: EntryView, peer: EntryView, options?: FsOptions): Promise<EntryComparison>;
+export declare function compareEntries(filesystem: FileSystem, path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;

package/packages/safe-fs/dist/fs/mount/identity.d.ts

@@ -0,0 +1,2 @@
+import type { FileStat } from "../../contracts/filesystem.js";
+export declare function compareIdentity(left: FileStat | undefined, right: FileStat | undefined): "same" | "distinct" | "unknown";