@zenera/sandbox 0.0.0-stage → 1.1.57

package/dist/image.js

@@ -0,0 +1,210 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { SandboxError } from "./contract.js";
+import { runProcess } from "./process.js";
+// ---------------------------------------------------------------------------
+// The sandbox image
+//
+// `image:` names something to pull; `build:` names a Dockerfile to build. Both
+// end as an image a sandbox runs, and getting it there is the sandbox's job:
+// podman builds on this machine, a sandbox service builds wherever it builds.
+// What they share is the *identity* of a build — which files go in and what
+// they hash to — so a project names the same image on every backend.
+//
+// The tag is a function of what goes into the image, and it has to be: a
+// container's name hashes its image, so a tag that stayed put while the
+// Dockerfile changed would leave a `persist: true` container running last
+// week's filesystem, with nothing anywhere saying so. Hashing the context as
+// well as the Dockerfile means an edit to either yields a new tag, a new
+// container name, and a build — which is the only honest answer.
+// ---------------------------------------------------------------------------
+/** Where locally built images are tagged. Not scoped: a `/` or an `@` is not a legal tag. */
+export const LOCAL_IMAGE_REPO = 'localhost/zenera-sandbox';
+/**
+ * A build context is meant to be small — a Dockerfile and whatever it copies.
+ * Hashing a directory someone pointed at their whole home folder would hang
+ * before it was wrong, so it stops and says which key to narrow.
+ */
+export const MAX_CONTEXT_FILES = 2_000;
+/**
+ * The content address of a build: the Dockerfile, then every file the build can
+ * see, by path and by content, then its arguments.
+ *
+ * `.dockerignore` is not read. The engine honours it and this does not, so an
+ * ignored file that changes yields a new tag and a build that produces the same
+ * image — wasteful, never wrong, and the alternative is reimplementing a match
+ * syntax whose disagreements would be silent.
+ */
+export function buildIdentity(spec) {
+    const hash = createHash('sha256');
+    hash.update(readFileSync(spec.dockerfile));
+    const files = walk(spec.context);
+    for (const rel of files) {
+        // The separator is hashed as posix so the same tree tags the same on
+        // any host.
+        hash.update(`\0${rel.split(sep).join('/')}\0`);
+        hash.update(readFileSync(join(spec.context, rel)));
+    }
+    // Only when there are any, so a build without arguments keeps the tag it
+    // had before arguments existed.
+    const args = Object.entries(spec.args ?? {}).sort(([a], [b]) => a.localeCompare(b));
+    if (args.length > 0) {
+        hash.update(`\0args\0${JSON.stringify(args)}`);
+    }
+    return { hash: hash.digest('hex').slice(0, 12), files };
+}
+/** The tag a build is run under on this machine. */
+export function localImageTag(build) {
+    const id = 'hash' in build ? build : buildIdentity(build);
+    return `${LOCAL_IMAGE_REPO}:${id.hash}`;
+}
+/** Every file under `dir`, relative and sorted, so the digest is stable. */
+function walk(dir) {
+    const found = [];
+    const pending = [dir];
+    while (pending.length > 0) {
+        const at = pending.pop();
+        for (const entry of readdirSync(at, { withFileTypes: true })) {
+            const path = join(at, entry.name);
+            if (entry.isDirectory()) {
+                pending.push(path);
+            }
+            else if (entry.isFile()) {
+                found.push(relative(dir, path));
+            }
+        }
+        if (found.length > MAX_CONTEXT_FILES) {
+            throw new SandboxError(`sandbox.build.context: ${dir} holds more than ${MAX_CONTEXT_FILES} files`, 'point `context:` at the directory the build actually copies from');
+        }
+    }
+    return found.sort();
+}
+// ---------------------------------------------------------------------------
+// On this machine
+// ---------------------------------------------------------------------------
+/**
+ * A build that ran and failed, rather than an engine that could not be asked.
+ * Both stop a run, but only one of them is the project's fault: `zen check`
+ * reports a Dockerfile that does not build as an error, and a laptop without
+ * podman as a warning.
+ */
+export class ImageBuildError extends SandboxError {
+    constructor(message, hint) {
+        super(message, hint);
+        this.name = 'ImageBuildError';
+    }
+}
+/**
+ * Whether `err` is a failed build, by name rather than by class: a plugin
+ * that provides the sandbox may bring its own copy of this package, and its
+ * `ImageBuildError` is then a different class that means the same thing.
+ */
+export function isImageBuildError(err) {
+    return err instanceof Error && err.name === 'ImageBuildError';
+}
+/** Pulling is slow on purpose... */
+const PULL_MS = 600_000;
+/** ...and a build from a cold cache is slower still. */
+const BUILD_MS = 900_000;
+/**
+ * Images this process has already settled, per runner and per engine. A batch
+ * opens the same project dozens of times at once, and without this each one
+ * asks podman and the concurrent copies race each other to pull or build the
+ * very same image. Keyed by runner too, so a test's fake engine never inherits
+ * an answer the real one gave.
+ */
+const settled = new WeakMap();
+/**
+ * Puts the image on this machine's engine: nothing when it is already there,
+ * a build when the spec names a Dockerfile, a pull otherwise.
+ *
+ * Skipping a present build is safe in a way it would not be for an ordinary
+ * tag, because this one is a hash of the Dockerfile and its context: the image
+ * existing *means* the content is unchanged. What it does not cover is a moved
+ * base image — `podman build` reuses whatever `FROM node:24` resolved to last
+ * time — which is what `force` is for.
+ */
+export function ensurePodmanImage(target, host = {}, opts = {}) {
+    const engine = host.engine ?? 'podman';
+    const run = host.exec ?? runProcess;
+    let byKey = settled.get(run);
+    if (!byKey) {
+        byKey = new Map();
+        settled.set(run, byKey);
+    }
+    const key = `${engine}::${target.image}`;
+    const pending = byKey.get(key);
+    if (pending && !opts.force) {
+        return pending;
+    }
+    const attempt = obtain(engine, run, target, opts).catch((err) => {
+        // A failure is not a settled answer: the user may fix the Dockerfile
+        // and try again in the same process.
+        byKey.delete(key);
+        throw err;
+    });
+    byKey.set(key, attempt);
+    return attempt;
+}
+async function obtain(engine, run, target, opts) {
+    const say = (line) => opts.onProgress?.(line);
+    const slow = (label, work) => opts.slow ? opts.slow(label, work) : work;
+    const tail = (res) => {
+        for (const line of res.stderr.split('\n').slice(-3)) {
+            if (line.trim()) {
+                say(`  ${line.trim()}`);
+            }
+        }
+    };
+    if (!opts.force) {
+        const present = await run(engine, ['image', 'exists', target.image], {
+            timeoutMs: 30_000,
+        });
+        if (present.code === 0) {
+            return;
+        }
+    }
+    const build = target.build;
+    if (build) {
+        if (opts.allowBuild === false) {
+            throw new SandboxError(`the sandbox image ${target.image} is not built`, 'build it before running: `zen sandbox up` builds it on this machine');
+        }
+        say(`${opts.force ? 'rebuilding' : 'building'} the sandbox image from ${build.dockerfile}`);
+        say('  the agent runs its commands inside a container, so the image is needed first');
+        say('  this takes a few minutes; later runs reuse it');
+        const args = Object.entries(build.args ?? {}).flatMap(([k, v]) => [
+            '--build-arg',
+            `${k}=${v}`,
+        ]);
+        const built = await slow('building the sandbox image', run(engine, [
+            'build',
+            '--tag',
+            target.image,
+            '--file',
+            build.dockerfile,
+            ...args,
+            build.context,
+        ], { timeoutMs: BUILD_MS, signal: opts.signal }));
+        tail(built);
+        if (built.code !== 0) {
+            throw new ImageBuildError(`could not build ${build.dockerfile}`, last(built) || 'run the build by hand to see what the engine says');
+        }
+        return;
+    }
+    say(`pulling ${target.image} — this happens once`);
+    const pulled = await slow('pulling', run(engine, ['pull', target.image], { timeoutMs: PULL_MS, signal: opts.signal }));
+    tail(pulled);
+    if (pulled.code !== 0) {
+        throw new SandboxError(`could not pull ${target.image}`, first(pulled) || 'check the image name and your network');
+    }
+}
+function first(res) {
+    return (res.stderr.trim() || res.stdout.trim()).split('\n')[0] ?? '';
+}
+/** A build says what went wrong on its last line, not its first. */
+function last(res) {
+    const lines = (res.stderr.trim() || res.stdout.trim()).split('\n').filter((l) => l.trim());
+    return lines.slice(-2).join(' — ');
+}
+//# sourceMappingURL=image.js.map

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

@@ -0,0 +1,25 @@
+import { type FsDriver, type FsEntry, type FsStat } from './fs.ts';
+export declare class InMemoryFs implements FsDriver {
+    #private;
+    readonly path: import("path").PlatformPath;
+    /** Files to start with, by absolute path; their directories are made as needed. */
+    constructor(files?: Record<string, string | Uint8Array>);
+    /** An empty directory, with its parents. */
+    dir(at: string): this;
+    realpathSync(at: string): string;
+    stat(at: string): Promise<FsStat>;
+    readdir(at: string): Promise<FsEntry[]>;
+    readFile(at: string): Promise<Buffer>;
+    readHead(at: string, bytes: number): Promise<Buffer>;
+    writeFile(at: string, data: string | Uint8Array): Promise<void>;
+    mkdirp(at: string): Promise<void>;
+    rm(at: string, opts?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    copy(from: string, to: string, opts?: {
+        recursive?: boolean;
+    }): Promise<void>;
+}
+//# sourceMappingURL=in-memory-fs.d.ts.map

package/dist/in-memory-fs.js

@@ -0,0 +1,165 @@
+import { posix } from 'node:path';
+import { fsError } from "./fs.js";
+export class InMemoryFs {
+    path = posix;
+    #nodes = new Map([['/', { kind: 'dir' }]]);
+    /** Files to start with, by absolute path; their directories are made as needed. */
+    constructor(files = {}) {
+        for (const [at, data] of Object.entries(files)) {
+            this.#mkdirs(posix.dirname(this.#abs(at)));
+            this.#nodes.set(this.#abs(at), { kind: 'file', data: Buffer.from(data) });
+        }
+    }
+    /** An empty directory, with its parents. */
+    dir(at) {
+        this.#mkdirs(this.#abs(at));
+        return this;
+    }
+    realpathSync(at) {
+        const abs = this.#abs(at);
+        if (!this.#nodes.has(abs)) {
+            throw fsError('ENOENT', 'realpath', at);
+        }
+        return abs;
+    }
+    async stat(at) {
+        return info(this.#get(at, 'stat'));
+    }
+    async readdir(at) {
+        const abs = this.#abs(at);
+        if (this.#get(at, 'scandir').kind !== 'dir') {
+            throw fsError('ENOTDIR', 'scandir', at);
+        }
+        return this.#children(abs).map((child) => ({
+            name: posix.basename(child),
+            ...info(this.#nodes.get(child)),
+        }));
+    }
+    async readFile(at) {
+        const node = this.#get(at, 'open');
+        if (node.kind !== 'file') {
+            throw fsError('EISDIR', 'read', at);
+        }
+        return Buffer.from(node.data);
+    }
+    async readHead(at, bytes) {
+        return (await this.readFile(at)).subarray(0, bytes);
+    }
+    async writeFile(at, data) {
+        const abs = this.#abs(at);
+        this.#parent(abs, 'open');
+        if (this.#nodes.get(abs)?.kind === 'dir') {
+            throw fsError('EISDIR', 'open', at);
+        }
+        this.#nodes.set(abs, { kind: 'file', data: Buffer.from(data) });
+    }
+    async mkdirp(at) {
+        this.#mkdirs(this.#abs(at));
+    }
+    async rm(at, opts = {}) {
+        const abs = this.#abs(at);
+        const node = this.#nodes.get(abs);
+        if (!node) {
+            if (opts.force) {
+                return;
+            }
+            throw fsError('ENOENT', 'rm', at);
+        }
+        if (node.kind === 'dir') {
+            if (!opts.recursive) {
+                throw fsError('EISDIR', 'rm', at);
+            }
+            for (const key of this.#below(abs)) {
+                this.#nodes.delete(key);
+            }
+        }
+        this.#nodes.delete(abs);
+    }
+    async rename(from, to) {
+        const src = this.#abs(from);
+        const dst = this.#abs(to);
+        const node = this.#get(from, 'rename');
+        this.#parent(dst, 'rename');
+        const there = this.#nodes.get(dst);
+        if (there?.kind === 'dir' && this.#children(dst).length > 0) {
+            throw fsError('ENOTEMPTY', 'rename', to);
+        }
+        const moved = node.kind === 'dir' ? this.#below(src) : [];
+        this.#nodes.delete(dst);
+        this.#nodes.set(dst, node);
+        this.#nodes.delete(src);
+        for (const key of moved) {
+            this.#nodes.set(dst + key.slice(src.length), this.#nodes.get(key));
+            this.#nodes.delete(key);
+        }
+    }
+    async copy(from, to, opts = {}) {
+        const src = this.#abs(from);
+        const dst = this.#abs(to);
+        const node = this.#get(from, 'cp');
+        if (node.kind === 'dir' && !opts.recursive) {
+            throw fsError('EISDIR', 'cp', from);
+        }
+        this.#parent(dst, 'cp');
+        this.#nodes.set(dst, copyOf(node));
+        if (node.kind === 'dir') {
+            for (const key of this.#below(src)) {
+                this.#nodes.set(dst + key.slice(src.length), copyOf(this.#nodes.get(key)));
+            }
+        }
+    }
+    #abs(at) {
+        return posix.resolve('/', at);
+    }
+    #get(at, syscall) {
+        const node = this.#nodes.get(this.#abs(at));
+        if (!node) {
+            throw fsError('ENOENT', syscall, at);
+        }
+        return node;
+    }
+    /** The parent has to be there already, as it does for `node:fs` without `recursive`. */
+    #parent(abs, syscall) {
+        const up = this.#nodes.get(posix.dirname(abs));
+        if (!up) {
+            throw fsError('ENOENT', syscall, abs);
+        }
+        if (up.kind !== 'dir') {
+            throw fsError('ENOTDIR', syscall, abs);
+        }
+    }
+    #mkdirs(abs) {
+        if (abs === '/') {
+            return;
+        }
+        this.#mkdirs(posix.dirname(abs));
+        const node = this.#nodes.get(abs);
+        if (node?.kind === 'file') {
+            throw fsError('EEXIST', 'mkdir', abs);
+        }
+        if (!node) {
+            this.#nodes.set(abs, { kind: 'dir' });
+        }
+    }
+    #children(abs) {
+        const prefix = abs === '/' ? '/' : `${abs}/`;
+        return [...this.#nodes.keys()]
+            .filter((k) => k !== abs && k.startsWith(prefix) && !k.slice(prefix.length).includes('/'))
+            .sort();
+    }
+    #below(abs) {
+        return [...this.#nodes.keys()].filter((k) => k.startsWith(`${abs}/`));
+    }
+}
+function info(node) {
+    return {
+        size: node.kind === 'file' ? node.data.byteLength : 0,
+        isFile: () => node.kind === 'file',
+        isDirectory: () => node.kind === 'dir',
+        isSymbolicLink: () => false,
+    };
+}
+function copyOf(node) {
+    return node.kind === 'file' ? { kind: 'file', data: Buffer.from(node.data) } : { kind: 'dir' };
+}
+//# sourceMappingURL=in-memory-fs.js.map

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './contract.ts';
+export * from './fs.ts';
+export * from './image.ts';
+export * from './in-memory-fs.ts';
+export * from './limits.ts';
+export * from './mounts.ts';
+export * from './podman.ts';
+export * from './process.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,12 @@
+// The sandbox: where a session's commands run and the files they see. Depends
+// on Node alone, so a host, a sandbox service and the agent inside a container
+// can all stand on the same contract. Contract tests: `@zenera/sandbox/testing`.
+export * from "./contract.js";
+export * from "./fs.js";
+export * from "./image.js";
+export * from "./in-memory-fs.js";
+export * from "./limits.js";
+export * from "./mounts.js";
+export * from "./podman.js";
+export * from "./process.js";
+//# sourceMappingURL=index.js.map

package/dist/limits.d.ts

@@ -0,0 +1,19 @@
+import type { SandboxHardening, SandboxSpec } from './contract.ts';
+export interface SandboxLimits {
+    /** MiB */
+    memory: number;
+    /** fractional cores */
+    cpus: number;
+    hardening: SandboxHardening;
+    /** whether the numbers above were written down, or are this profile's defaults */
+    declared: boolean;
+}
+/**
+ * What a spec's ceilings come to, for a report that has no container to ask.
+ *
+ * It exists so `zen sandbox status` cannot disagree with what a run actually
+ * applies: the defaults are stated once, here and in `resolveSpec`, and
+ * nothing outside this module repeats them.
+ */
+export declare function sandboxLimits(spec?: Pick<SandboxSpec, 'cpus' | 'memory' | 'hardening'>): SandboxLimits;
+//# sourceMappingURL=limits.d.ts.map

package/dist/limits.js

@@ -0,0 +1,33 @@
+// ---------------------------------------------------------------------------
+// A sandbox's ceilings
+//
+// Stated once, here, so the sandbox that applies them and `zen sandbox status`
+// that reports them cannot disagree.
+// ---------------------------------------------------------------------------
+// Standard mode's resource ceilings. Even without the strict profile, an
+// unbounded container can exhaust host cores or memory during runaway builds.
+const DEFAULT_CPUS = 4;
+const DEFAULT_MEMORY = 4096;
+// Strict mode's own defaults. A limit that is only there when someone
+// remembered to write it down is not a limit, so the profile supplies one for
+// each of the four exhaustible things: cores, memory, processes and disk.
+const STRICT_CPUS = 2;
+const STRICT_MEMORY = 2048;
+/**
+ * What a spec's ceilings come to, for a report that has no container to ask.
+ *
+ * It exists so `zen sandbox status` cannot disagree with what a run actually
+ * applies: the defaults are stated once, here and in `resolveSpec`, and
+ * nothing outside this module repeats them.
+ */
+export function sandboxLimits(spec = {}) {
+    const hardening = spec.hardening ?? 'standard';
+    const strict = hardening === 'strict';
+    return {
+        memory: spec.memory ?? (strict ? STRICT_MEMORY : DEFAULT_MEMORY),
+        cpus: spec.cpus ?? (strict ? STRICT_CPUS : DEFAULT_CPUS),
+        hardening,
+        declared: spec.memory !== undefined || spec.cpus !== undefined,
+    };
+}
+//# sourceMappingURL=limits.js.map

package/dist/mounts.d.ts

@@ -0,0 +1,84 @@
+import type { FsDriver } from './fs.ts';
+/** Where the workspace appears in the agent's namespace, and the default cwd. */
+export declare const WORKSPACE_MOUNT = "/workspace";
+/** Where a project's `assets/` directory appears. */
+export declare const ASSETS_MOUNT = "/assets";
+/** ...and where its skill catalog does, so a skill's scripts can be run. */
+export declare const SKILLS_MOUNT = "/skills";
+export type MountSource = 
+/** the project's reference material, at `/assets` */
+{
+    kind: 'assets';
+}
+/** the skill catalog — one merged tree at `/skills`, however many folders it came from */
+ | {
+    kind: 'skills';
+}
+/** the container's private, persistent `$HOME` */
+ | {
+    kind: 'home';
+}
+/** one credential file, by the variable that names it */
+ | {
+    kind: 'credential';
+    name: string;
+};
+export interface Mount {
+    /** absolute host path; must already exist */
+    host: string;
+    /** absolute path the agent names it by, e.g. `/assets` */
+    at: string;
+    /**
+     * Say it. Unset, the file tools treat an extra tree as reference material
+     * and refuse to write it, while the sandbox binds it writable — the container's
+     * `$HOME` is the one mount that relies on that.
+     */
+    readOnly?: boolean;
+    /** what the tree is, for a backend that has to supply it rather than bind `host` */
+    source?: MountSource;
+}
+/**
+ * The trees a file tool reaches, and the names it reaches them by: the
+ * workspace, the name it is also mounted at, and the extra trees beside it.
+ * What `Sandbox.files` translates into the sandbox's own paths, and what the
+ * file tools in `@zenera/neo` take.
+ */
+export interface FilesView {
+    root: string;
+    /** refuse every mutating tool; `zen run --read-only` */
+    readOnly?: boolean;
+    /**
+     * An absolute path the root is *also* known by, because something else has
+     * mounted it there — the sandbox mounts the workspace at `/workspace`, so
+     * `run_command` returns compiler errors, stack traces and `pwd` output
+     * naming files under a prefix the file tools would otherwise refuse. Set
+     * it and both spellings reach the same file.
+     */
+    mount?: string;
+    /** further trees, each under its own name; read-only unless one says otherwise */
+    mounts?: readonly Mount[];
+    /**
+     * Where the bytes are; this machine's disk when unset. `root` and every
+     * mount's `host` are paths in this driver's namespace.
+     */
+    fs?: FsDriver;
+}
+/** A mount stated by what it is: no host path, nothing to bind. */
+export type LogicalMount = Required<Omit<Mount, 'host'>>;
+/**
+ * The mounts a supplying backend is asked for. The skill catalog arrives here
+ * as one bind per skill folder — podman cannot merge directories — and leaves
+ * as the single `/skills` tree it is to the agent. A mount nobody labelled is a
+ * host directory with no meaning elsewhere, so it is refused rather than
+ * silently dropped.
+ */
+export declare function logicalMounts(mounts: readonly Mount[]): LogicalMount[];
+/**
+ * The file tools' view for a sandbox that keeps its files with the container
+ * rather than reading host directories: the workspace is its mount point, and
+ * each tree is found where the container has it — so a path the model writes
+ * means one file to the tools and the shell. What a remote `Sandbox.files`
+ * returns; a podman one reads the host paths as they are.
+ */
+export declare function inSandboxPaths(opts: FilesView, fs: FsDriver): FilesView;
+//# sourceMappingURL=mounts.d.ts.map

package/dist/mounts.js

@@ -0,0 +1,63 @@
+// ---------------------------------------------------------------------------
+// The trees an agent can reach, and what each one is
+//
+// One directory is one mount, and the host hands the same array to the file
+// tools and to the sandbox so that both call it by the same name: a path a command
+// prints is a path `read_file` accepts.
+//
+// On `zen run` every tree is a host directory bound into the container, and
+// `host` is the whole story. A sandbox on another machine has no host path to
+// bind: it has to be told what the tree is — the project's assets, its skills —
+// and fetch that itself. So a mount carries both: `host` for a backend that
+// binds, `source` for one that supplies. Memory is not a mount: its files stay
+// with the graph and reach a sandbox only through `memory_copy_file`.
+// ---------------------------------------------------------------------------
+/** Where the workspace appears in the agent's namespace, and the default cwd. */
+export const WORKSPACE_MOUNT = '/workspace';
+/** Where a project's `assets/` directory appears. */
+export const ASSETS_MOUNT = '/assets';
+/** ...and where its skill catalog does, so a skill's scripts can be run. */
+export const SKILLS_MOUNT = '/skills';
+/**
+ * The mounts a supplying backend is asked for. The skill catalog arrives here
+ * as one bind per skill folder — podman cannot merge directories — and leaves
+ * as the single `/skills` tree it is to the agent. A mount nobody labelled is a
+ * host directory with no meaning elsewhere, so it is refused rather than
+ * silently dropped.
+ */
+export function logicalMounts(mounts) {
+    const out = [];
+    let skills = false;
+    for (const m of mounts) {
+        if (!m.source) {
+            throw new Error(`mount ${m.at} has no source, so only a local sandbox can provide it`);
+        }
+        if (m.source.kind === 'skills') {
+            if (!skills) {
+                out.push({ at: SKILLS_MOUNT, readOnly: true, source: m.source });
+                skills = true;
+            }
+            continue;
+        }
+        out.push({ at: m.at, readOnly: m.readOnly ?? false, source: m.source });
+    }
+    return out;
+}
+/**
+ * The file tools' view for a sandbox that keeps its files with the container
+ * rather than reading host directories: the workspace is its mount point, and
+ * each tree is found where the container has it — so a path the model writes
+ * means one file to the tools and the shell. What a remote `Sandbox.files`
+ * returns; a podman one reads the host paths as they are.
+ */
+export function inSandboxPaths(opts, fs) {
+    const mount = opts.mount ?? WORKSPACE_MOUNT;
+    return {
+        ...opts,
+        root: mount,
+        mount,
+        mounts: logicalMounts(opts.mounts ?? []).map((m) => ({ ...m, host: m.at })),
+        fs,
+    };
+}
+//# sourceMappingURL=mounts.js.map