@parcha/pi-durable-disk 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/hosts/daytona.js

@@ -15,11 +15,38 @@
 // in it, the commands a crashed incarnation detached included. The supervisor holds the API key; boxes never do.
 import { DEFAULT_MOUNT_ROOT, runPath } from "../claim.js";
 import { PdaError } from "../errors.js";
+import { attemptEnv } from "./attempt-env.js";
 import { LAUNCH_DIR } from "./daytona-launch.js";
 import { TERMINAL_EXITS } from "./local-host.js";
 export const DAYTONA_API_URL = "https://app.daytona.io/api";
 export const LABEL_FLEET = "pda-fleet";
 export const LABEL_RUN = "pda-run";
+/**
+ * Daytona's published list prices, as its pricing page gave them on `readOn`: billed per second, quoted per hour, for
+ * each vCPU, each GiB of memory and each GiB of disk. The page's footnote "Price per GiB after first 5 free" is applied
+ * to storage (disk) only: its placement is ambiguous and could be read as covering memory too, so this is a choice.
+ * The page lists GPU rates per GPU model; this driver does not map a box's GPU to a model, so a GPU box is unpriced.
+ */
+export const DAYTONA_LIST_PRICES = {
+    page: "https://www.daytona.io/pricing",
+    readOn: "2026-10-16",
+    vcpuPerHour: 0.0504,
+    memoryGiBPerHour: 0.0162,
+    diskGiBPerHour: 0.000108,
+    freeDiskGiB: 5,
+};
+/**
+ * A box's list price per second at DAYTONA_LIST_PRICES, from its size; null when its size is unknown or it has a GPU
+ * (priced per GPU model on the page, which this driver does not map).
+ */
+export function daytonaUsdPerSecond(size) {
+    const { cpu, memory, disk, gpu } = size;
+    const count = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+    if (!count(cpu) || !count(memory) || !count(disk) || (gpu !== undefined && gpu !== 0))
+        return null;
+    const p = DAYTONA_LIST_PRICES;
+    return (cpu * p.vcpuPerHour + memory * p.memoryGiBPerHour + Math.max(0, disk - p.freeDiskGiB) * p.diskGiBPerHour) / 3600;
+}
 export class DaytonaApiError extends PdaError {
     /** The HTTP status, null when no response arrived (network failure or timeout). */
     status;
@@ -255,13 +282,22 @@ export function daytonaHost(opts) {
             throw new DaytonaHostError("START_FAILED", `${what} in ${box.name} exited ${r.exitCode}: ${r.result.trim().split("\n").at(-1)?.slice(0, 300) ?? ""}`);
         return r;
     }
+    /** Each box this driver made, for its receipt: what Daytona said of it, when it was made, and when it ended. */
+    const made = new Map();
+    const ended = (id) => {
+        const m = made.get(id);
+        if (m && m.to === null)
+            m.to = new Date(now()).toISOString();
+    };
     return {
         fleet,
         mountRoot,
-        async start(ref, mountToken) {
+        kills: "box",
+        async start(ref, mountToken, attempt) {
             runPath(ref.id);
             if (!mountToken)
                 throw new DaytonaHostError("INVALID_ARGUMENT", "no mount token");
+            const extra = attemptEnv(attempt, (m) => new DaytonaHostError("INVALID_ARGUMENT", m));
             const t0 = now();
             const name = sandboxName(prefix, ref.id, t0);
             const body = {
@@ -276,8 +312,10 @@ export function daytonaHost(opts) {
                 ...(opts.network?.allowList ? { networkAllowList: opts.network.allowList } : {}),
             };
             let box = await createOrAdopt(body, ref.id);
+            made.set(box.id, { info: box, from: box.createdAt ?? new Date(t0).toISOString(), to: null });
             try {
                 box = await waitStarted(box, t0 + startTimeoutMs);
+                made.get(box.id).info = { ...made.get(box.id).info, ...box };
                 const prepared = now();
                 if (opts.prepare)
                     await opts.prepare(box, client);
@@ -285,7 +323,7 @@ export function daytonaHost(opts) {
                 const handle = { driver: "daytona", fleet, target: box.target ?? opts.target ?? null, sandboxId: box.id, name, mountpoint: `${mountRoot}/${runPath(ref.id)}` };
                 const spec = {
                     argv: [...command, "run", "--disk", ref.disk, "--region", ref.region, "--id", ref.id, "--mount-root", mountRoot, "--archil", archil, ...(opts.runArgs ?? []), "--token-stdin"],
-                    env: { ...opts.env, PDA_HOLDER: JSON.stringify(handle) },
+                    env: { ...opts.env, ...extra, PDA_HOLDER: JSON.stringify(handle) },
                     user,
                     group,
                     restart: opts.restart !== false,
@@ -305,7 +343,9 @@ export function daytonaHost(opts) {
                 return handle;
             }
             catch (err) {
+                // The box was made and is deleted now: its receipt ends here, deleted or not (a delete that failed is the sweep's).
                 await client.remove(box.id).catch(() => { });
+                ended(box.id);
                 if (err instanceof DaytonaHostError)
                     throw err;
                 throw new DaytonaHostError("START_FAILED", `starting an instance in ${name} failed: ${err.message}`, { cause: err });
@@ -321,8 +361,10 @@ export function daytonaHost(opts) {
             catch (err) {
                 throw new DaytonaHostError("DAYTONA_API_FAILED", `reading sandbox ${h.name}: ${err.message}`, { cause: err });
             }
-            if (!box)
+            if (!box) {
+                ended(h.sandboxId);
                 return "gone";
+            }
             // The label, not the id in a handle, decides whose box this is: a handle can never reach another fleet's box.
             if (box.labels?.[LABEL_FLEET] !== fleet)
                 return "unknown";
@@ -363,6 +405,53 @@ export function daytonaHost(opts) {
                     throw new DaytonaHostError("STOP_FAILED", `deleting sandbox ${h.name} failed: ${err.message}`, { cause: first });
                 }
             }
+            ended(id);
+        },
+        async kill(h) {
+            if (!mine(h))
+                return;
+            const id = h.sandboxId;
+            let box;
+            try {
+                box = await client.get(id);
+            }
+            catch (err) {
+                throw new DaytonaHostError("KILL_FAILED", `reading sandbox ${h.name} to confirm it is this fleet's: ${err.message}`, { cause: err });
+            }
+            if (box === null || box.labels?.[LABEL_FLEET] !== fleet)
+                return;
+            // The box goes with everything in it, the instance and its mount: no launcher stop, no drain.
+            try {
+                await client.remove(id);
+            }
+            catch (first) {
+                // A delete refused mid-transition: power the box off, then delete again.
+                await client.stop(id, true).catch(() => { });
+                try {
+                    await client.remove(id);
+                }
+                catch (err) {
+                    throw new DaytonaHostError("KILL_FAILED", `deleting sandbox ${h.name} failed: ${err.message}`, { cause: first });
+                }
+            }
+            ended(id);
+        },
+        box(h) {
+            if (!mine(h))
+                return null;
+            const m = made.get(h.sandboxId);
+            if (!m)
+                return null;
+            const { cpu, gpu, memory, disk } = m.info;
+            const usdPerSecond = daytonaUsdPerSecond(m.info);
+            const size = [cpu, memory, disk].every((n) => typeof n === "number") ? ` ${cpu} vCPU, ${memory} GiB memory, ${disk} GiB disk${gpu ? `, ${gpu} GPU` : ""}` : "";
+            return {
+                provider: "daytona",
+                kind: `sandbox${size}`,
+                from: m.from,
+                to: m.to,
+                ...(usdPerSecond === null ? {} : { usdPerSecond, source: DAYTONA_LIST_PRICES.page, priced: DAYTONA_LIST_PRICES.readOn }),
+            };
         },
     };
 }

package/dist/hosts/docker.d.ts

@@ -58,7 +58,7 @@ export interface DockerHostOptions {
     exec?: DockerRunner;
 }
 export declare class DockerHostError extends PdaError {
-    constructor(code: "INVALID_ARGUMENT" | "START_FAILED" | "STOP_FAILED" | "DOCKER_FAILED", message: string, options?: {
+    constructor(code: "INVALID_ARGUMENT" | "START_FAILED" | "STOP_FAILED" | "KILL_FAILED" | "DOCKER_FAILED", message: string, options?: {
         cause?: unknown;
     });
 }
@@ -95,7 +95,7 @@ export type ContainerInfo = {
     startedAt: string | null;
     finishedAt: string | null;
 };
-export declare function dockerHost(opts?: DockerHostOptions): HostDriver & {
+export declare function dockerHost(opts?: DockerHostOptions): HostDriver & Required<Pick<HostDriver, "kill" | "kills">> & {
     readonly fleet: string;
     readonly mountRoot: string;
     describe(handle: HostHandle): Promise<ContainerInfo | null>;

package/dist/hosts/docker.js

@@ -23,6 +23,7 @@ import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:p
 import { DEFAULT_MOUNT_ROOT, runPath } from "../claim.js";
 import { PdaError } from "../errors.js";
 import { LOCAL_PARK_THRESHOLD_MS } from "../park.js";
+import { attemptEnv } from "./attempt-env.js";
 export class DockerHostError extends PdaError {
     constructor(code, message, options = {}) {
         super(code, message, options);
@@ -191,8 +192,8 @@ export function dockerHost(opts = {}) {
         if (!ok(r) && !NO_SUCH.test(r.stderr))
             throw new DockerHostError("DOCKER_FAILED", `docker rm -f ${ref}: ${firstLine(r)}`);
     }
-    function createArgs(ref, name, attempt, holder, profile) {
-        const env = { ...opts.env, PDA_HOLDER: JSON.stringify(holder) };
+    function createArgs(ref, name, attempt, holder, profile, extra) {
+        const env = { ...opts.env, ...extra, PDA_HOLDER: JSON.stringify(holder) };
         const runFlags = [
             "run",
             "--disk", ref.disk,
@@ -228,10 +229,10 @@ export function dockerHost(opts = {}) {
             ...runFlags,
         ];
     }
-    async function create(ref, name, attempt, holder) {
+    async function create(ref, name, attempt, holder, extra) {
         const profile = await apparmor();
         for (let tries = 0;; tries++) {
-            const r = await run(createArgs(ref, name, attempt, holder, profile), { timeoutMs: 120_000 });
+            const r = await run(createArgs(ref, name, attempt, holder, profile, extra), { timeoutMs: 120_000 });
             if (ok(r))
                 return { id: r.stdout.trim().split("\n").at(-1).trim() };
             if (!IN_USE.test(r.stderr) || tries > 0)
@@ -270,6 +271,7 @@ export function dockerHost(opts = {}) {
     return {
         fleet,
         mountRoot,
+        kills: "box",
         async start(ref, token, attemptInfo) {
             runPath(ref.id);
             if (!opts.image)
@@ -277,11 +279,12 @@ export function dockerHost(opts = {}) {
             if (!token || /[\r\n]/.test(token))
                 throw new DockerHostError("INVALID_ARGUMENT", "no mount token, or one with a line break");
             const attempt = attemptInfo?.attempt ?? null;
+            const extra = attemptEnv(attemptInfo, (m) => new DockerHostError("INVALID_ARGUMENT", m));
             const name = `${prefix}${ref.id}-${diskKey(ref)}-${attempt === null ? `t${Date.now().toString(36)}` : `g${attempt}`}`;
             if (!NAME_SAFE.test(name))
                 throw new DockerHostError("INVALID_ARGUMENT", `container name ${name} is not safe`);
             const handle = { driver: "docker", fleet, daemon: await daemon(), name, mountpoint: posix.join(mountRoot, runPath(ref.id)), image: opts.image };
-            const made = await create(ref, name, attempt, handle);
+            const made = await create(ref, name, attempt, handle, extra);
             // An earlier start of this attempt made the container: the token given to this start was not used.
             if ("adopted" in made)
                 return { ...handle, adopted: true };
@@ -336,6 +339,20 @@ export function dockerHost(opts = {}) {
             if (await inspect(ref))
                 throw new DockerHostError("STOP_FAILED", `container ${ref} is still there after docker rm -f`);
         },
+        async kill(h) {
+            if (!(await mine(h)))
+                return;
+            const ref = target(h);
+            const found = await inspect(ref);
+            if (!found || found.labels["pda.fleet"] !== fleet)
+                return;
+            // SIGKILL, no stop timeout: the container dies with its mount (its own namespace), as on a power loss. It is left
+            // exited, not removed; the next start of the run removes it.
+            const r = await run(["kill", ref], { timeoutMs: 30_000 });
+            if (!ok(r) && !NO_SUCH.test(r.stderr) && (await inspect(ref).then((f) => f && containerStatus(f.state) === "running"))) {
+                throw new DockerHostError("KILL_FAILED", `docker kill ${ref}: ${firstLine(r)}`);
+            }
+        },
     };
 }
 /** The bind mount of the app's directory (read-only, its node_modules hidden) and the module's path inside the container. */

package/dist/hosts/local-host.d.ts

@@ -50,7 +50,7 @@ export interface LocalHostOptions {
     procMounts?: string;
 }
 export declare class LocalHostError extends PdaError {
-    constructor(code: "INVALID_ARGUMENT" | "START_FAILED" | "STOP_FAILED", message: string, options?: {
+    constructor(code: "INVALID_ARGUMENT" | "START_FAILED" | "STOP_FAILED" | "KILL_FAILED", message: string, options?: {
         cause?: unknown;
     });
 }
@@ -66,7 +66,7 @@ export declare function currentBootId(): string;
 export declare function parseShow(text: string): Record<string, string>;
 /** A unit's state as a host status: loaded and active (or restarting) is running; unloaded is gone. */
 export declare function unitStatus(show: Record<string, string>): HostStatus;
-export declare function localHost(opts?: LocalHostOptions): HostDriver & {
+export declare function localHost(opts?: LocalHostOptions): HostDriver & Required<Pick<HostDriver, "kill" | "kills">> & {
     readonly hostName: string;
     readonly mountRoot: string;
 };

package/dist/hosts/local-host.js

@@ -20,6 +20,7 @@ import { ARCHIL_SCOPED, DEAD_CONNECTION, DEFAULT_MOUNT_ROOT, runPath } from "../
 import { EXIT_FENCED, EXIT_HELD, PdaError } from "../errors.js";
 import { LOCAL_PARK_THRESHOLD_MS } from "../park.js";
 import { processTable, thisBoot } from "../process-table.js";
+import { attemptEnv } from "./attempt-env.js";
 export class LocalHostError extends PdaError {
     constructor(code, message, options = {}) {
         super(code, message, options);
@@ -161,13 +162,13 @@ export function localHost(opts = {}) {
             return rm(path, { force: true });
         await root(["/bin/rm", "-f", path]);
     }
-    async function startUnit(ref, token) {
+    async function startUnit(ref, token, extra) {
         const unit = `${prefix}${ref.id}-${Date.now().toString(36)}${Math.floor(Math.random() * 1296).toString(36).padStart(2, "0")}`;
         if (!UNIT_SAFE.test(unit))
             throw new LocalHostError("INVALID_ARGUMENT", `unit name ${unit} is not safe`);
         const mountpoint = mountpointOf(ref);
         const handle = { driver: "local", mode: "systemd", host: hostName, bootId, unit, mountpoint };
-        const env = { ...opts.env, PATH: SAFE_PATH, PDA_HOLDER: holderEnv(handle) };
+        const env = { ...opts.env, ...extra, PATH: SAFE_PATH, PDA_HOLDER: holderEnv(handle) };
         const path = tokenFile(unit);
         await writeTokenFile(path, token);
         let started = false;
@@ -202,7 +203,7 @@ export function localHost(opts = {}) {
             await (started ? emptyTokenFile(path) : removeFile(path)).catch(() => { });
         }
     }
-    async function startChild(ref, token) {
+    async function startChild(ref, token, extra) {
         const tag = `${prefix}${ref.id}-${Date.now().toString(36)}`;
         const mountpoint = mountpointOf(ref);
         const base = { driver: "local", mode: "child", host: hostName, bootId, mountpoint, tag };
@@ -211,7 +212,7 @@ export function localHost(opts = {}) {
             const { openSync } = await import("node:fs");
             out = openSync(join(opts.logDir, `${tag}.log`), "a", 0o600);
         }
-        const env = { ...opts.env, PATH: SAFE_PATH, LANG: "C.UTF-8", HOME: process.env.HOME ?? "/", PDA_HOLDER: holderEnv(base) };
+        const env = { ...opts.env, ...extra, PATH: SAFE_PATH, LANG: "C.UTF-8", HOME: process.env.HOME ?? "/", PDA_HOLDER: holderEnv(base) };
         const child = spawn(command[0], [...command.slice(1), ...runFlags(ref), "--token-stdin"], { detached: true, stdio: ["pipe", out, out], env });
         await new Promise((resolve, reject) => {
             child.once("spawn", resolve);
@@ -288,9 +289,11 @@ export function localHost(opts = {}) {
     return {
         hostName,
         mountRoot,
-        start(ref, token) {
+        kills: "process",
+        async start(ref, token, attempt) {
             runPath(ref.id);
-            return mode === "systemd" ? startUnit(ref, token) : startChild(ref, token);
+            const extra = attemptEnv(attempt, (m) => new LocalHostError("INVALID_ARGUMENT", m));
+            return mode === "systemd" ? startUnit(ref, token, extra) : startChild(ref, token, extra);
         },
         async status(h) {
             if (!mine(h))
@@ -347,6 +350,31 @@ export function localHost(opts = {}) {
             await root([SYSTEMCTL, "reset-failed", `${h.unit}.service`]);
             await removeFile(tokenFile(h.unit));
         },
+        async kill(h) {
+            if (!mine(h) || h.bootId !== bootId)
+                return;
+            if (h.mode === "child") {
+                const pid = Number(h.pid);
+                // As in stop: only a real process, and only the one the handle names (its start ticks).
+                if (!Number.isInteger(pid) || pid <= 1 || typeof h.startTicks !== "number" || procStartTicks(pid) !== h.startTicks)
+                    return;
+                try {
+                    process.kill(-pid, "SIGKILL");
+                }
+                catch {
+                    // gone already
+                }
+                return;
+            }
+            if (typeof h.unit !== "string" || !UNIT_SAFE.test(h.unit))
+                return;
+            // Every process of the unit's control group at once, the instance's commands included. Its FUSE daemon runs in a
+            // scope of its own and keeps the mount, as after an OOM kill; the unit restarts in place unless restart is off.
+            const r = await root([SYSTEMCTL, "kill", "--signal=SIGKILL", "--kill-whom=all", `${h.unit}.service`]);
+            if (!okRan(r) && unitStatus(await show(h.unit)) === "running") {
+                throw new LocalHostError("KILL_FAILED", `systemctl kill ${h.unit}: ${r.timedOut ? "timed out" : firstLine(r)}`);
+            }
+        },
     };
 }
 /**

package/dist/index.d.ts

@@ -1,13 +1,15 @@
 export { openDurableRun, RunError, StoreBehindSealError } from "./run.js";
-export type { BeforeResume, DurableRun, LeaseOptions, OpenDurableRunOptions, OpenRunLeaseOptions, OpenStep, ReleaseStep, RunClaim, RunEnv, RunErrorCode, RunLease, StoreHeadSource, StoreReads } from "./run.js";
+export type { AfterClaim, BeforeResume, DurableRun, LeaseOptions, OpenDurableRunOptions, OpenRunLeaseOptions, OpenStep, ReleaseStep, RunClaim, RunEnv, RunErrorCode, RunLease, RunSeed, RunSeedDir, StoreHeadSource, StoreReads } from "./run.js";
 export { localRun } from "./local-run.js";
 export type { LocalRun } from "./local-run.js";
-export { CLAIM_UNMOUNTED, openClaimDir, RunRecordError } from "./status.js";
+export { CLAIM_UNMOUNTED, openClaimDir, readLocalRunStatus, RunRecordError } from "./status.js";
 export type { ClaimDir, OpenClaimDirOptions, PersistRecord, RunHolder, RunRecord, RunStatus } from "./status.js";
 export { ArchilCodingTools, archilEnv, EnvClosedError, EnvError, markReadOnlySafe } from "./env.js";
 export type { ArchilEnvClaim, ArchilEnvFactory, ArchilEnvOptions, EnvErrorCode } from "./env.js";
 export { acquire, ARCHIL_SCOPED, revoke, takeOver } from "./claim.js";
 export type { AcquireOptions, ArchilHost, Claim, ControlApi, PathlessResolver, RunRef, Unmounted } from "./claim.js";
+export { readReleased, withClaim } from "./with-claim.js";
+export type { ClaimControl, HeldPath, WithClaimOptions } from "./with-claim.js";
 export { PathOutsideWorkError } from "./confine.js";
 export type { RefusalReason } from "./confine.js";
 export { ClaimError, FencedError, HeldError, PdaError } from "./errors.js";
@@ -16,15 +18,17 @@ export type { ArchilStore, Fence, FencedDatabase, Profile, StoreFencedError } fr
 export { AppError } from "./app.js";
 export type { AppContext, AppModule, AppOptions } from "./app.js";
 export { archilControl, deleteRunTree, ensureRunning, readRunStatus, SuperviseError } from "./supervise.js";
-export type { ArchilControl, CheckControl, CheckOptions, DiskClient, EnsureOptions, EnsureResult, HostDriver, HostHandle, HostStatus, Json, StartAttempt, StartReason, StonithOutcome, SuperviseErrorCode, SupervisorControl, TokenUser } from "./supervise.js";
+export type { ArchilControl, CheckControl, CheckOptions, DiskClient, EnsureOptions, EnsureResult, HostBox, HostDriver, HostHandle, HostStatus, Json, StartAttempt, StartReason, StonithOutcome, SuperviseErrorCode, SupervisorControl, TokenUser } from "./supervise.js";
 export { localHost, LocalHostError } from "./hosts/local-host.js";
 export type { LocalHostOptions, Ran, Runner } from "./hosts/local-host.js";
 export { dockerHost, DockerHostError } from "./hosts/docker.js";
 export type { ContainerInfo, DockerHostOptions, DockerRan, DockerRunner } from "./hosts/docker.js";
-export { DaytonaApiError, daytonaHost, DaytonaHostError, daytonaRest } from "./hosts/daytona.js";
+export { DAYTONA_LIST_PRICES, DaytonaApiError, daytonaHost, DaytonaHostError, daytonaRest, daytonaUsdPerSecond } from "./hosts/daytona.js";
 export type { CreateSandboxBody, DaytonaClient, DaytonaHostErrorCode, DaytonaHostOptions, DaytonaRestOptions, ExecResult, SandboxInfo } from "./hosts/daytona.js";
 export { requestRun, ServeConfigError, ServeError, serveRun } from "./serve.js";
 export type { RequestOptions, RunResponse, RunServer, ServeConfigErrorCode, ServeErrorCode, ServeOptions } from "./serve.js";
+export { archilPlace, localPlace, PlaceError } from "./place.js";
+export type { ArchilPlaceOptions, LocalPlaceOptions, Place, PlaceContext, PlaceErrorCode, PlaceExit, PlaceKill, PlaceOutcome, PlacePaths, PlaceRecordHome, PlaceRecovery, PlaceRunner, PlaceSignal, PlaceStatus, RecordControl, RunnerOrder } from "./place.js";
 export { busyState, drain, leaseParkTarget, watchParking } from "./park.js";
 export type { BusyState, DrainOptions, Parking, ParkOptions, ParkResult, ParkTarget } from "./park.js";
 export { fork, ForkError, forkLocal } from "./fork.js";

package/dist/index.js

@@ -4,9 +4,11 @@
 // The run: open it, on a disk or a local directory, with its environment, its claim and the errors it fails with.
 export { openDurableRun, RunError, StoreBehindSealError } from "./run.js";
 export { localRun } from "./local-run.js";
-export { CLAIM_UNMOUNTED, openClaimDir, RunRecordError } from "./status.js";
+export { CLAIM_UNMOUNTED, openClaimDir, readLocalRunStatus, RunRecordError } from "./status.js";
 export { ArchilCodingTools, archilEnv, EnvClosedError, EnvError, markReadOnlySafe } from "./env.js";
 export { acquire, ARCHIL_SCOPED, revoke, takeOver } from "./claim.js";
+// A short exclusive claim on any path of a disk, and a consistent S3 read of a released file (an agent home beside the runs).
+export { readReleased, withClaim } from "./with-claim.js";
 export { PathOutsideWorkError } from "./confine.js";
 export { ClaimError, FencedError, HeldError, PdaError } from "./errors.js";
 // The app contract: what `--app` names.
@@ -15,9 +17,11 @@ export { AppError } from "./app.js";
 export { archilControl, deleteRunTree, ensureRunning, readRunStatus, SuperviseError } from "./supervise.js";
 export { localHost, LocalHostError } from "./hosts/local-host.js";
 export { dockerHost, DockerHostError } from "./hosts/docker.js";
-export { DaytonaApiError, daytonaHost, DaytonaHostError, daytonaRest } from "./hosts/daytona.js";
+export { DAYTONA_LIST_PRICES, DaytonaApiError, daytonaHost, DaytonaHostError, daytonaRest, daytonaUsdPerSecond } from "./hosts/daytona.js";
 // Serve: one HTTP request runs one turn.
 export { requestRun, ServeConfigError, ServeError, serveRun } from "./serve.js";
+// Places: where a run lives for a supervisor that kills it and brings it back (agentrun's reference place seam).
+export { archilPlace, localPlace, PlaceError } from "./place.js";
 // Parking: an idle run gives its host back.
 export { busyState, drain, leaseParkTarget, watchParking } from "./park.js";
 // Fork: a new run from a run's committed state.

package/dist/lease.d.ts

@@ -1,5 +1,5 @@
 export { EXIT_DATAERR, EXIT_SOFTWARE, LeaseLapsedError, openRunLease, OWNER_LOCK, RunError, StoreBehindSealError, storeHead, STORE_FILE } from "./run.js";
-export type { LeaseOptions, OpenRunLeaseOptions, OpenStep, ReleaseStep, RunClaim, RunErrorCode, RunLease, StoreHeadSource } from "./run.js";
+export type { LeaseOptions, OpenRunLeaseOptions, OpenStep, ReleaseStep, RunClaim, RunErrorCode, RunLease, RunSeed, RunSeedDir, StoreHeadSource } from "./run.js";
 export * from "./errors.js";
 export { assertPragmas, Fence, FencedDatabase, openArchilStore, PROFILE_PRAGMAS, StoreBusyError, StoreFencedError, StorePragmaError } from "./store.js";
 export type { ArchilStore, OpenOptions, PragmaMismatch, Profile } from "./store.js";