@zenera/sandbox 1.1.57 → 1.1.58

package/dist/fs.d.ts

@@ -13,12 +13,12 @@ export interface FsDriver {
     /** how this driver's paths are spelled: the host's for `localFs`, posix otherwise */
     readonly path: PlatformPath;
     /**
-     * The path with every symlink resolved; throws `ENOENT` when it does not
-     * exist. Synchronous because containment is decided synchronously. A
-     * driver whose files live elsewhere may answer lexically here, provided
-     * the far side refuses an escape on its own.
+     * Where a path really is: absolute, with every symlink in the part that
+     * exists resolved, and the part that does not exist yet appended as
+     * written — what a create needs, and what containment is decided on. A
+     * path through a file is `ENOTDIR`, as `realpath` says.
      */
-    realpathSync(path: string): string;
+    resolve(path: string): Promise<string>;
     stat(path: string): Promise<FsStat>;
     readdir(path: string): Promise<FsEntry[]>;
     readFile(path: string): Promise<Buffer>;

package/dist/fs.js

@@ -1,10 +1,25 @@
-import { realpathSync } from 'node:fs';
-import { cp, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { cp, mkdir, open, readFile, readdir, realpath, rename, rm, stat, writeFile, } from 'node:fs/promises';
 import path, {} from 'node:path';
 /** This machine's disk, through `node:fs`. */
 export const localFs = {
     path,
-    realpathSync: (p) => realpathSync(p),
+    async resolve(p) {
+        const missing = [];
+        let at = path.resolve(p);
+        for (;;) {
+            try {
+                return path.join(await realpath(at), ...missing.reverse());
+            }
+            catch (err) {
+                const up = path.dirname(at);
+                if (err.code !== 'ENOENT' || up === at) {
+                    throw err;
+                }
+                missing.push(path.basename(at));
+                at = up;
+            }
+        }
+    },
     stat: (p) => stat(p),
     readdir: (p) => readdir(p, { withFileTypes: true }),
     readFile: (p) => readFile(p),

package/dist/in-memory-fs.d.ts

@@ -6,7 +6,8 @@ export declare class InMemoryFs implements FsDriver {
     constructor(files?: Record<string, string | Uint8Array>);
     /** An empty directory, with its parents. */
     dir(at: string): this;
-    realpathSync(at: string): string;
+    /** No symlinks here, so only a path through a file needs saying anything about. */
+    resolve(at: string): Promise<string>;
     stat(at: string): Promise<FsStat>;
     readdir(at: string): Promise<FsEntry[]>;
     readFile(at: string): Promise<Buffer>;

package/dist/in-memory-fs.js

@@ -15,10 +15,15 @@ export class InMemoryFs {
         this.#mkdirs(this.#abs(at));
         return this;
     }
-    realpathSync(at) {
+    /** No symlinks here, so only a path through a file needs saying anything about. */
+    async resolve(at) {
         const abs = this.#abs(at);
-        if (!this.#nodes.has(abs)) {
-            throw fsError('ENOENT', 'realpath', at);
+        let probe = abs;
+        while (!this.#nodes.has(probe)) {
+            probe = posix.dirname(probe);
+        }
+        if (probe !== abs && this.#nodes.get(probe)?.kind === 'file') {
+            throw fsError('ENOTDIR', 'realpath', at);
         }
         return abs;
     }

package/dist/testing.js

@@ -52,8 +52,18 @@ export function describeFsDriver(name, make) {
                 code: 'ENOENT',
                 path: expect.stringContaining('ghost.txt'),
             });
-            expect(() => fs.realpathSync(at('ghost', 'deeper'))).toThrow(expect.objectContaining({ code: 'ENOENT' }));
-            expect(fs.realpathSync(at())).toBe(fs.realpathSync(at('.')));
+            expect(await fs.resolve(at('.'))).toBe(await fs.resolve(at()));
+        }));
+        it('resolves where a path really is, the part that does not exist yet included', withFs(async ({ fs }, at) => {
+            const root = await fs.resolve(at());
+            await fs.mkdirp(at('real', 'dir'));
+            expect(await fs.resolve(at('real', 'dir'))).toBe(fs.path.join(root, 'real', 'dir'));
+            expect(await fs.resolve(at('real', 'ghost', 'deeper.txt'))).toBe(fs.path.join(root, 'real', 'ghost', 'deeper.txt'));
+            expect(await fs.resolve(at('real', 'dir', '..', 'x'))).toBe(fs.path.join(root, 'real', 'x'));
+            await fs.writeFile(at('file.txt'), 'x');
+            await expect(fs.resolve(at('file.txt', 'under'))).rejects.toMatchObject({
+                code: 'ENOTDIR',
+            });
         }));
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/sandbox",
-    "version": "1.1.57",
+    "version": "1.1.58",
     "description": "Where an agent's commands run and the files they see: the Sandbox contract, a podman implementation, filesystem drivers and a contract test suite for other implementations.",
     "keywords": [
         "sandbox",