smolmachines 1.29.1 → 1.31.5

package/dist/binding.d.ts

@@ -182,6 +182,13 @@ export interface VmResourcesConfig {
   gpu?: boolean
   /** GPU VRAM in MiB (default: engine default when GPU is enabled). */
   gpuVramMib?: number
+  /**
+   * Disk durability: `"full"` (default), a guest flush waits for the host's
+   * disk; or `"deferred"`, guest writes reach the host's disk on the host's
+   * schedule, so fsync-heavy work (database commits) runs much faster and a
+   * host crash can lose recent writes.
+   */
+  diskDurability?: string
   /**
    * Run the guest's unmodified CUDA/PyTorch code on the host's NVIDIA GPU by
    * remoting CUDA calls over vsock (distinct from `gpu`, which is Vulkan; no
@@ -427,6 +434,11 @@ export declare class NapiMachine {
   forkBatch(names: Array<string>, ports?: Array<PortMappingConfig> | undefined | null, parallel?: number | undefined | null, freezeSource?: boolean | undefined | null): Promise<Array<NapiMachine>>
   /** Execute a command directly in the VM (not in a container). */
   exec(command: Array<string>, options?: ExecOptions | undefined | null): Promise<ExecResult>
+  /**
+   * Start a command without waiting for it and return its guest pid. It
+   * keeps running after this returns; it takes no stdin and no timeout.
+   */
+  execBackground(command: Array<string>, options?: ExecOptions | undefined | null): Promise<number>
   /**
    * Pull an OCI image and run a command inside it.
    *

package/dist/native.d.ts

@@ -42,6 +42,7 @@ export interface NativeResources {
     overlayGib?: number | undefined;
     gpu?: boolean | undefined;
     gpuVramMib?: number | undefined;
+    diskDurability?: "full" | "deferred" | undefined;
     cuda?: boolean | undefined;
     networkBackend?: string | undefined;
 }
@@ -145,6 +146,7 @@ export interface NapiMachine {
     fork(name: string, ports?: NativePortMapping[], checkpointable?: boolean, freezeSource?: boolean): Promise<NapiMachine>;
     forkBatch(names: string[], ports?: NativePortMapping[], parallel?: number, freezeSource?: boolean): Promise<NapiMachine[]>;
     exec(command: string[], options?: NativeExecOptions): Promise<NativeExecResult>;
+    execBackground(command: string[], options?: NativeExecOptions): Promise<number>;
     run(image: string, command: string[], options?: NativeExecOptions): Promise<NativeExecResult>;
     pullImage(image: string): Promise<NativeImageInfo>;
     listImages(): Promise<NativeImageInfo[]>;

package/dist/transport.js

@@ -319,6 +319,7 @@ function toNativeConfig(name, config) {
                 overlayGib: config.resources?.overlayGb,
                 gpu: config.resources?.gpu,
                 gpuVramMib: config.resources?.gpuVramMib,
+                diskDurability: config.resources?.diskDurability,
                 cuda: config.resources?.cuda,
                 networkBackend: config.resources?.networkBackend,
             }
@@ -425,6 +426,8 @@ class LocalTransport {
         return null;
     }
     async exec(command, opts) {
+        if (opts?.background)
+            return this.execBackground(command, opts);
         if (opts?.signal)
             return collectExec(this.execStream(command, opts), opts.signal);
         try {
@@ -434,6 +437,21 @@ class LocalTransport {
             throw (0, errors_1.wrapNativeError)(e);
         }
     }
+    /** Start a command and return at once, as the cloud does: its pid in `pid`
+     *  and as `pid=<n>` on stdout. */
+    async execBackground(command, opts) {
+        if (opts.signal) {
+            throw new errors_1.InvalidConfigError("a background command cannot be cancelled; kill its pid instead");
+        }
+        let pid;
+        try {
+            pid = await this.inner.execBackground(command, toNativeExecOptions(opts));
+        }
+        catch (e) {
+            throw (0, errors_1.wrapNativeError)(e);
+        }
+        return { pid, exitCode: 0, stdout: `pid=${pid}\n`, stderr: "" };
+    }
     async run(image, command, opts) {
         if (opts?.signal) {
             throw new errors_1.NotSupportedError("signal is not supported by run(); use exec on an image machine.");
@@ -1809,6 +1827,9 @@ async function makeTransport(config, conn) {
                     ? { memoryMb: config.resources.memoryMb }
                     : {}),
                 diskGb: config.resources?.storageGb ?? null,
+                ...(config.resources?.diskDurability !== undefined
+                    ? { diskDurability: config.resources.diskDurability }
+                    : {}),
             },
             ...(config.resources?.allowCidrs?.length ||
                 config.resources?.allowHosts?.length

package/dist/types.d.ts

@@ -41,6 +41,14 @@ export interface ResourceSpec {
     gpu?: boolean;
     /** GPU VRAM in MiB (default: engine default when GPU is enabled). Local target only. */
     gpuVramMib?: number;
+    /**
+     * Disk durability. `"full"` (default): a guest `fsync` waits for the host's
+     * disk. `"deferred"`: guest writes reach the host's disk on the host's
+     * schedule, so fsync-heavy work such as database commits runs far faster
+     * (Postgres commits about 19x on Linux), and a crash of the host, not of the
+     * machine, can lose the most recent writes. Local and cloud targets.
+     */
+    diskDurability?: "full" | "deferred";
     /**
      * Run the guest's unmodified CUDA/PyTorch code on the host's NVIDIA GPU by
      * remoting CUDA Driver-API calls over vsock (distinct from `gpu`, which is
@@ -395,8 +403,9 @@ export interface ExecOptions {
      *  Ignored (both families, as before) on older control planes and on the
      *  local target. */
     output?: "text" | "b64" | "both";
-    /** Cloud only: start the command detached and return at once with its
-     *  `pid`, leaving it running (a dev server, an agent) after the call ends. */
+    /** Start the command detached and return at once with its `pid`, leaving
+     *  it running (a dev server, an agent) after the call ends. It takes no
+     *  stdin and no timeout. */
     background?: boolean;
 }
 /** Result of a command execution. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smolmachines",
-  "version": "1.29.1",
+  "version": "1.31.5",
   "description": "Embed isolated microVM sandboxes directly in your code — no server to run.",
   "license": "Apache-2.0",
   "author": "smol-machines",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.0"
   },
   "optionalDependencies": {
-    "smolmachines-darwin-arm64": "1.29.1",
-    "smolmachines-linux-x64-gnu": "1.29.1",
-    "smolmachines-linux-arm64-gnu": "1.29.1"
+    "smolmachines-darwin-arm64": "1.31.5",
+    "smolmachines-linux-x64-gnu": "1.31.5",
+    "smolmachines-linux-arm64-gnu": "1.31.5"
   }
 }