llmsim 0.0.0-stage → 0.8.0

package/README.md

@@ -1,3 +1,62 @@
-# Temporary Holding Version
+# llmsim (Node.js / TypeScript)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+In-process [llmsim](https://github.com/chaliy/llmsim) server for Node.js and
+TypeScript tests: a fast LLM API simulator for the OpenAI (Chat Completions,
+Responses, Images), Anthropic Messages, and OpenResponses APIs. No model, no
+network, no API key. The server is the same Rust code as the `llmsim` CLI,
+shipped as a prebuilt native addon (Linux x64/arm64, macOS, Windows x64).
+
+```bash
+npm install --save-dev llmsim
+```
+
+## Usage
+
+```ts
+import OpenAI from "openai";
+import { Server } from "llmsim";
+
+const sim = await Server.start({ generator: "echo", latency: "instant" });
+try {
+  const client = new OpenAI({ baseURL: sim.openaiBaseUrl, apiKey: "unused" });
+  const reply = await client.chat.completions.create({
+    model: "gpt-5",
+    messages: [{ role: "user", content: "hello" }],
+  });
+  console.log(reply.choices[0].message.content); // "Echo: hello"
+  console.log(sim.stats().total_requests); // 1
+} finally {
+  await sim.stop();
+}
+```
+
+Anthropic: `new Anthropic({ baseURL: sim.anthropicBaseUrl, apiKey: "unused" })`.
+
+`Server` implements `Symbol.asyncDispose`, so `await using sim = await Server.start()`
+works where explicit resource management is available.
+
+## Options
+
+`Server.start(options)` accepts the same settings as the `llmsim serve` TOML
+file. Sources merge in this order, later wins: `configFile` or `toml`, then
+`config` (an object shaped like the TOML), then the shortcut options.
+
+| Option | Meaning |
+|---|---|
+| `host`, `port` | Bind address. Defaults `127.0.0.1` and `0` (a free port) |
+| `generator` | `lorem` (default), `echo`, `random`, `sequence`, `fixed:<text>` |
+| `targetTokens` | Target response length |
+| `latency` | Named profile: `instant`, `fast`, `gpt5`, `claude-sonnet`, ... |
+| `script` | Scripted-mode file (exact replies, tool calls, per turn) |
+| `scenarios` | Load-test scenario file or directory |
+
+```ts
+await Server.start({ config: { errors: { rate_limit_rate: 0.2 } } });
+await Server.start({ configFile: "llmsim.toml", port: 8080 });
+```
+
+Properties: `url`, `port`, `host`, `openaiBaseUrl`, `anthropicBaseUrl`,
+`openresponsesBaseUrl`, `config`, `isRunning`. Methods: `stats()`, `stop()`.
+Also exported: `startServer(options)`, `resolveConfig(options)`, `version`.
+
+Full docs: <https://github.com/chaliy/llmsim/blob/main/docs/bindings.md>

package/index.cjs

@@ -0,0 +1,841 @@
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('fs')
+let nativeBinding = null
+// Which artifact actually loaded. The WASI fallback chain overwrites it with
+// the flavor it resolved; the late native retry below leaves it alone because
+// it only runs while no WASI candidate has been loaded. The take-over check
+// after the load-failure block can also set it.
+let __napiLoadedBindingTarget = 'native'
+// What this loader's own `requireNative()` calls returned. The check after
+// the load-failure block compares it with `nativeBinding` to tell a binding
+// this loader loaded from one that code outside it put in its place.
+let __napiRequiredNativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (process.report && typeof process.report.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      const overrideBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH)
+      // The override may be a generated WASI loader, which already reports its
+      // own flavor. Adopt it: `module.exports` aliases this object, so claiming
+      // 'native' would both misreport the artifact and overwrite the loader's
+      // marker through the alias.
+      __napiLoadedBindingTarget =
+        overrideBinding && typeof overrideBinding.__napiBindingTarget === 'string'
+          ? overrideBinding.__napiBindingTarget
+          : 'native'
+      return overrideBinding
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./llmsim.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-android-arm64')
+        const bindingPackageVersion = require('llmsim-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./llmsim.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-android-arm-eabi')
+        const bindingPackageVersion = require('llmsim-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if ((process.config && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
+        try {
+          return require('./llmsim.win32-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-win32-x64-gnu')
+          const bindingPackageVersion = require('llmsim-win32-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./llmsim.win32-x64-msvc.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-win32-x64-msvc')
+          const bindingPackageVersion = require('llmsim-win32-x64-msvc/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./llmsim.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-win32-ia32-msvc')
+        const bindingPackageVersion = require('llmsim-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./llmsim.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-win32-arm64-msvc')
+        const bindingPackageVersion = require('llmsim-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./llmsim.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('llmsim-darwin-universal')
+      const bindingPackageVersion = require('llmsim-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./llmsim.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-darwin-x64')
+        const bindingPackageVersion = require('llmsim-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./llmsim.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-darwin-arm64')
+        const bindingPackageVersion = require('llmsim-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./llmsim.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-freebsd-x64')
+        const bindingPackageVersion = require('llmsim-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./llmsim.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-freebsd-arm64')
+        const bindingPackageVersion = require('llmsim-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./llmsim.freebsd-ppc64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-freebsd-ppc64')
+        const bindingPackageVersion = require('llmsim-freebsd-ppc64/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./llmsim.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-x64-musl')
+          const bindingPackageVersion = require('llmsim-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./llmsim.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-x64-gnu')
+          const bindingPackageVersion = require('llmsim-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./llmsim.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-arm64-musl')
+          const bindingPackageVersion = require('llmsim-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./llmsim.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-arm64-gnu')
+          const bindingPackageVersion = require('llmsim-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./llmsim.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-arm-musleabihf')
+          const bindingPackageVersion = require('llmsim-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./llmsim.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('llmsim-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./llmsim.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-loong64-musl')
+          const bindingPackageVersion = require('llmsim-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./llmsim.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-loong64-gnu')
+          const bindingPackageVersion = require('llmsim-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./llmsim.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-riscv64-musl')
+          const bindingPackageVersion = require('llmsim-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./llmsim.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('llmsim-linux-riscv64-gnu')
+          const bindingPackageVersion = require('llmsim-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./llmsim.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-linux-ppc64-gnu')
+        const bindingPackageVersion = require('llmsim-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./llmsim.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-linux-s390x-gnu')
+        const bindingPackageVersion = require('llmsim-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./llmsim.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-openharmony-arm64')
+        const bindingPackageVersion = require('llmsim-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./llmsim.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-openharmony-x64')
+        const bindingPackageVersion = require('llmsim-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./llmsim.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('llmsim-openharmony-arm')
+        const bindingPackageVersion = require('llmsim-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+function createLoadErrorChain(errors) {
+  return errors.reduce((previous, current) => {
+    let message
+    try {
+      message =
+        current && typeof current.message === 'string'
+          ? current.message
+          : String(current)
+    } catch {
+      message = 'Unknown error'
+    }
+    const error = new Error(message)
+    error.cause = previous
+    return error
+  }, null)
+}
+
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → prefer WASI, but retain native as a lazy fallback
+//   'error'                  → require WASI without initializing a native fallback
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+//
+// NAPI_RS_WASI_FLAVOR selects one exact generated flavor and implies strict
+// WASI loading. It never crosses into another flavor or falls back to native.
+const __napiWasiFlavors = ['wasm32-wasi']
+const __napiWasiFlavor = process.env.NAPI_RS_WASI_FLAVOR
+const __napiWasiFlavorRequested =
+  typeof __napiWasiFlavor === 'string' && __napiWasiFlavor.length > 0
+if (
+  __napiWasiFlavorRequested &&
+  __napiWasiFlavors.indexOf(__napiWasiFlavor) === -1
+) {
+  throw new Error(
+    'Unsupported WASI flavor "' +
+      __napiWasiFlavor +
+      '". Available flavors: ' +
+      __napiWasiFlavors.join(', '),
+  )
+}
+const forceWasiError = process.env.NAPI_RS_FORCE_WASI === 'error'
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' ||
+  forceWasiError ||
+  __napiWasiFlavorRequested
+
+if (!forceWasi) {
+  nativeBinding = requireNative()
+  __napiRequiredNativeBinding = nativeBinding
+}
+
+if (!nativeBinding || forceWasi) {
+  let wasiBinding = null
+  let wasiBindingLoaded = false
+  const wasiBindingErrors = []
+  const __napiWasiResolveCandidate = (specifier, isPackage, localArtifacts) => {
+    try {
+      require.resolve(specifier)
+    } catch (resolveError) {
+      if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+        throw resolveError
+      }
+      if (isPackage) {
+        try {
+          require.resolve(specifier + '/package.json')
+        } catch (packageError) {
+          if (packageError && packageError.code === 'MODULE_NOT_FOUND') {
+            return resolveError
+          }
+          // An exports restriction proves the package exists even when its
+          // package.json is not public. Preserve the root resolution failure.
+          throw resolveError
+        }
+        // The package exists but its main/export target is broken.
+        throw resolveError
+      }
+      return resolveError
+    }
+    if (localArtifacts) {
+      let artifactError = null
+      for (let i = 0; i < localArtifacts.length; i++) {
+        try {
+          require.resolve(localArtifacts[i])
+          return null
+        } catch (resolveError) {
+          if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+            throw resolveError
+          }
+          artifactError = resolveError
+        }
+      }
+      return artifactError
+    }
+    return null
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === 'wasm32-wasi')) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('./llmsim.wasi.cjs', false, ['./llmsim.wasm32-wasi.debug.wasm', './llmsim.wasm32-wasi.wasm'])
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        wasiBinding = require('./llmsim.wasi.cjs')
+        nativeBinding = wasiBinding
+        __napiLoadedBindingTarget = 'wasm32-wasi'
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === 'wasm32-wasi')) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('llmsim-wasm32-wasi', true, undefined)
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        if (process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          const bindingPackageVersion = require('llmsim-wasm32-wasi/package.json').version
+          if (bindingPackageVersion !== '0.8.0') {
+            throw new Error(`WASI binding package version mismatch, expected 0.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+        }
+        wasiBinding = require('llmsim-wasm32-wasi')
+        nativeBinding = wasiBinding
+        __napiLoadedBindingTarget = 'wasm32-wasi'
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (
+    !wasiBindingLoaded &&
+    forceWasi &&
+    !forceWasiError &&
+    !__napiWasiFlavorRequested
+  ) {
+    nativeBinding = requireNative()
+    __napiRequiredNativeBinding = nativeBinding
+  }
+  if ((forceWasiError || __napiWasiFlavorRequested) && !wasiBindingLoaded) {
+    const error = new Error(
+      __napiWasiFlavorRequested
+        ? 'WASI binding for flavor "' + __napiWasiFlavor + '" not found'
+        : 'WASI binding not found and NAPI_RS_FORCE_WASI is set to error',
+    )
+    error.cause = createLoadErrorChain(wasiBindingErrors)
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    const error = new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+    )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = createLoadErrorChain(loadErrors)
+    throw error
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+// A package can patch its own fallback in front of the load-failure check
+// above, e.g. a WebContainer download through `napi-postinstall/fallback`.
+// That fallback swaps `nativeBinding` for a generated WASI loader, which has
+// already stamped its own flavor, while the target above still says 'native'.
+// Take that flavor over, or the CommonJS stamp throws a conflict and the ESM
+// export reports the wrong artifact. Three limits keep the conflict check:
+// - only a binding this loader did not load itself, so a native addon whose
+//   `#[napi(module_exports)]` hook claims the name is still rejected;
+// - only an own data property, read through its descriptor, so no addon
+//   getter runs here, and it must read back the same, as the stamp reads it;
+// - only a flavor in `__napiWasiFlavors`, the ones this loader's own WASI
+//   chain can report ('wasm32-wasi' for a package without a WASI target).
+// This is metadata and never fails a load: a throwing Proxy trap keeps 'native'.
+if (
+  __napiLoadedBindingTarget === 'native' &&
+  nativeBinding !== __napiRequiredNativeBinding
+) {
+  try {
+    const __napiBindingTargetDescriptor = Object.getOwnPropertyDescriptor(
+      nativeBinding,
+      '__napiBindingTarget',
+    )
+    if (
+      __napiBindingTargetDescriptor &&
+      __napiWasiFlavors.indexOf(__napiBindingTargetDescriptor.value) !== -1 &&
+      nativeBinding.__napiBindingTarget === __napiBindingTargetDescriptor.value
+    ) {
+      __napiLoadedBindingTarget = __napiBindingTargetDescriptor.value
+    }
+  } catch {
+    // keep 'native'
+  }
+}
+
+function __napiStampBindingTarget(exportsObject, target) {
+  if (
+    Object.prototype.hasOwnProperty.call(exportsObject, '__napiBindingTarget')
+  ) {
+    if (exportsObject.__napiBindingTarget === target) {
+      // Already ours: the root entry aliases the object it loaded, so a WASI
+      // fallback candidate — or a `NAPI_RS_NATIVE_LIBRARY_PATH` override that
+      // is a generated loader — arrives already stamped with this same value.
+      return target
+    }
+    const error = new Error(
+      '`__napiBindingTarget` is reserved by the generated binding loader, but the loaded binding already exports it. Rename the export, e.g. #[napi(js_name = "...")].',
+    )
+    error.code = 'ERR_NAPI_BINDING_TARGET_CONFLICT'
+    throw error
+  }
+  if (!Object.isExtensible(exportsObject)) {
+    // A `#[napi(module_exports)]` hook may seal or freeze this object
+    // (`Object::seal` / `Object::freeze`). Reporting the artifact is metadata,
+    // never a reason to fail an otherwise successful load, so the stamp is
+    // skipped. What a consumer still sees then follows the entry point: the
+    // browser and deferred loaders declare `__napiBindingTarget` at module
+    // level and go on reporting it, while the CommonJS entries hand back this
+    // very object as `module.exports`, so there the value is absent.
+    return target
+  }
+  try {
+    // [[Define]], not [[Set]]: an ordinary assignment walks the prototype
+    // chain, so an inherited accessor could swallow the value or throw and
+    // fail an otherwise successful load. The descriptor is what a successful
+    // assignment would have produced.
+    Object.defineProperty(exportsObject, '__napiBindingTarget', {
+      configurable: true,
+      enumerable: true,
+      value: target,
+      writable: true,
+    })
+  } catch {
+    // Same rule as the non-extensible skip above: reporting the artifact is
+    // metadata, never a reason to fail an otherwise successful load. An exotic
+    // object (a Proxy whose defineProperty trap refuses) is skipped, not
+    // thrown over.
+  }
+  // The CommonJS loaders assign this return value so `cjs-module-lexer` — and
+  // therefore Node's CJS -> ESM named export detection — can see
+  // `__napiBindingTarget` statically.
+  return target
+}
+// Stamp before the alias, not after. The guard only reads `nativeBinding`
+// (`hasOwnProperty` plus a comparison), which is safe against any addon
+// accessor; an assignment is not, because a `#[napi(module_exports)]` hook can
+// expose a getter reporting this very value and a setter that throws. So the
+// assignment lands on the loader's own `module.exports`, still the original
+// object here, and the alias below replaces it.
+//
+// The assignment is what keeps the marker a statically visible CommonJS export:
+// `cjs-module-lexer` is Node's CJS -> ESM named export detection, it cannot see
+// a bare call, and the later `module.exports = nativeBinding` does not undo the
+// detection. The assignment itself always succeeds — its target is this
+// loader's own, still extensible `module.exports` — and the alias below then
+// discards the value it wrote. What a consumer reads is whatever the guard put
+// on `nativeBinding`, so on a frozen binding, where the guard skips, the
+// linked import resolves to `undefined`.
+module.exports.__napiBindingTarget = __napiStampBindingTarget(nativeBinding, __napiLoadedBindingTarget)
+module.exports = nativeBinding
+module.exports.NativeServer = nativeBinding.NativeServer
+module.exports.nativeVersion = nativeBinding.nativeVersion
+module.exports.resolveConfigNative = nativeBinding.resolveConfigNative
+module.exports.startServerNative = nativeBinding.startServerNative

package/index.d.cts

@@ -0,0 +1,39 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+
+/**
+ * Which binding artifact the generated loader actually loaded: `'native'` for
+ * a native addon, otherwise the `platformArchABI` of the WASI flavor. Every
+ * flavor napi-rs can build is listed, because `NAPI_RS_NATIVE_LIBRARY_PATH`
+ * can point the loader at a WASI artifact this package does not build itself.
+ */
+export declare const __napiBindingTarget: 'native' | 'wasm32-wasi' | 'wasm32-wasip1'
+
+/** A running llmsim server. Create with `startServer()`. */
+export declare class NativeServer {
+  /** Base URL, e.g. `http://127.0.0.1:41234`. */
+  get url(): string
+  get host(): string
+  /** The bound port (the real one when port 0 was requested). */
+  get port(): number
+  get isRunning(): boolean
+  /** Server statistics as a JSON string (same shape as `GET /llmsim/stats`). */
+  statsJson(): string
+  /** Gracefully stop the server and wait for it to finish. Idempotent. */
+  stop(): Promise<void>
+}
+
+/** Version of the native addon (matches the npm package version). */
+export declare function nativeVersion(): string
+
+/**
+ * Parse and validate a config (TOML text plus JSON overrides) without
+ * starting a server. Returns the effective config as JSON.
+ */
+export declare function resolveConfigNative(toml?: string | undefined | null, overridesJson?: string | undefined | null): string
+
+/**
+ * Start a server. `toml` is a full config file's text; `overridesJson` is a
+ * JSON object deep-merged on top. Resolves once the port is bound.
+ */
+export declare function startServerNative(toml?: string | undefined | null, overridesJson?: string | undefined | null): Promise<NativeServer>

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "llmsim",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.0",
+  "description": "In-process LLM API simulator (OpenAI, Anthropic, OpenResponses) for tests and load testing",
+  "type": "module",
+  "main": "wrapper.js",
+  "types": "wrapper.d.ts",
+  "exports": {
+    ".": {
+      "types": "./wrapper.d.ts",
+      "default": "./wrapper.js"
+    }
+  },
+  "author": "Mykhailo Chalyi <mike@chaliy.name>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chaliy/llmsim.git",
+    "directory": "crates/llmsim-js"
+  },
+  "homepage": "https://github.com/chaliy/llmsim",
+  "bugs": "https://github.com/chaliy/llmsim/issues",
+  "keywords": [
+    "llm",
+    "openai",
+    "anthropic",
+    "simulator",
+    "mock",
+    "testing"
+  ],
+  "napi": {
+    "binaryName": "llmsim",
+    "targets": [
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc"
+    ]
+  },
+  "files": [
+    "wrapper.js",
+    "wrapper.d.ts",
+    "index.cjs",
+    "index.d.cts",
+    "llmsim.*.node"
+  ],
+  "scripts": {
+    "build": "npm run build:napi && npm run build:ts",
+    "build:napi": "napi build --platform --release --js index.cjs --dts index.d.cts",
+    "build:debug": "napi build --platform --js index.cjs --dts index.d.cts && npm run build:ts",
+    "build:ts": "tsc",
+    "test": "node --test __test__/*.test.mjs",
+    "type-check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.40.0",
+    "@napi-rs/cli": "^3.9.0",
+    "@types/node": "^22.0.0",
+    "openai": "^6.45.0",
+    "typescript": "^5.9.0"
+  },
+  "engines": {
+    "node": ">= 18"
+  }
+}

package/wrapper.d.ts

@@ -0,0 +1,110 @@
+/** Config shaped like the `llmsim serve` TOML file. Unknown keys are ignored. */
+export interface LlmSimConfig {
+    server?: {
+        host?: string;
+        port?: number;
+        max_websocket_connections?: number;
+    };
+    latency?: {
+        profile?: string;
+        ttft_mean_ms?: number;
+        ttft_stddev_ms?: number;
+        tbt_mean_ms?: number;
+        tbt_stddev_ms?: number;
+    };
+    response?: {
+        generator?: string;
+        target_tokens?: number;
+        script_path?: string;
+        scenarios_path?: string;
+    };
+    errors?: {
+        rate_limit_rate?: number;
+        server_error_rate?: number;
+        timeout_rate?: number;
+        timeout_after_ms?: number;
+    };
+    models?: {
+        available?: string[];
+    };
+    [section: string]: unknown;
+}
+export interface ServerOptions {
+    /** Object shaped like the TOML config, e.g. `{ errors: { rate_limit_rate: 0.1 } }`. */
+    config?: LlmSimConfig;
+    /** TOML config text. */
+    toml?: string;
+    /** Path to a TOML config file. */
+    configFile?: string;
+    /** Bind address. Default `127.0.0.1`. */
+    host?: string;
+    /** Bind port. Default `0` (pick a free port). */
+    port?: number;
+    /** `lorem`, `echo`, `random`, `sequence` or `fixed:<text>`. */
+    generator?: string;
+    /** Target response length in tokens. */
+    targetTokens?: number;
+    /** Named latency profile: `instant`, `fast`, `gpt5`, `claude-sonnet`, ... */
+    latency?: string;
+    /** Path to a scripted-mode YAML/JSON file. */
+    script?: string;
+    /** Path to a scenarios file or directory. */
+    scenarios?: string;
+}
+/** Counters reported by `GET /llmsim/stats`. */
+export interface Stats {
+    uptime_secs: number;
+    total_requests: number;
+    active_requests: number;
+    streaming_requests: number;
+    non_streaming_requests: number;
+    completions_requests: number;
+    responses_requests: number;
+    websocket_requests: number;
+    messages_requests: number;
+    image_requests: number;
+    systemone_requests: number;
+    active_websocket_connections: number;
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    total_errors: number;
+    rate_limit_errors: number;
+    server_errors: number;
+    timeout_errors: number;
+    requests_per_second: number;
+    avg_latency_ms: number;
+    min_latency_ms: number | null;
+    max_latency_ms: number | null;
+    model_requests: Record<string, number>;
+}
+/** Version of the native addon. */
+export declare const version: string;
+/** Validate options and return the effective config without starting a server. */
+export declare function resolveConfig(options?: ServerOptions): LlmSimConfig;
+/** An llmsim HTTP server running inside this process. */
+export declare class Server implements AsyncDisposable {
+    #private;
+    readonly config: LlmSimConfig;
+    private constructor();
+    /** Bind and start serving. Resolves once the port is bound. */
+    static start(options?: ServerOptions): Promise<Server>;
+    /** Base URL, e.g. `http://127.0.0.1:41234`. */
+    get url(): string;
+    get host(): string;
+    get port(): number;
+    get isRunning(): boolean;
+    /** `baseURL` for the `openai` SDK. */
+    get openaiBaseUrl(): string;
+    /** `baseURL` for `@anthropic-ai/sdk` (the SDK appends `/v1`). */
+    get anthropicBaseUrl(): string;
+    /** Base URL for OpenResponses clients. */
+    get openresponsesBaseUrl(): string;
+    /** Request, token, and latency counters. Throws once stopped. */
+    stats(): Stats;
+    /** Gracefully stop the server. Idempotent. */
+    stop(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/** Shorthand for `Server.start(options)`. */
+export declare function startServer(options?: ServerOptions): Promise<Server>;

package/wrapper.js

@@ -0,0 +1,112 @@
+// In-process llmsim server for Node.js / TypeScript tests.
+//
+// Decisions:
+// - The native addon (`index.cjs`, generated by napi) is CommonJS; this ESM
+//   wrapper loads it with createRequire so the package stays `type: module`.
+// - Option sources merge in a fixed order, later wins: configFile/toml,
+//   config, shortcut options. Same order as the Python package.
+// - Defaults bind 127.0.0.1 on port 0 (a free port) so parallel test workers
+//   never collide.
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const native = require("./index.cjs");
+/** Version of the native addon. */
+export const version = native.nativeVersion();
+function isPlain(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function merge(base, overrides) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(overrides)) {
+        const current = out[key];
+        out[key] = isPlain(value) && isPlain(current) ? merge(current, value) : value;
+    }
+    return out;
+}
+function toNative(options) {
+    if (options.toml !== undefined && options.configFile !== undefined) {
+        throw new TypeError("pass either toml or configFile, not both");
+    }
+    const toml = options.configFile !== undefined ? readFileSync(options.configFile, "utf8") : options.toml;
+    let overrides = {
+        server: { host: options.host ?? "127.0.0.1", port: options.port ?? 0 },
+    };
+    if (options.config)
+        overrides = merge(overrides, options.config);
+    const response = {};
+    if (options.generator !== undefined)
+        response.generator = options.generator;
+    if (options.targetTokens !== undefined)
+        response.target_tokens = options.targetTokens;
+    if (options.script !== undefined)
+        response.script_path = options.script;
+    if (options.scenarios !== undefined)
+        response.scenarios_path = options.scenarios;
+    if (Object.keys(response).length > 0)
+        overrides = merge(overrides, { response });
+    if (options.latency !== undefined) {
+        overrides = merge(overrides, { latency: { profile: options.latency } });
+    }
+    return { toml, overrides: JSON.stringify(overrides) };
+}
+/** Validate options and return the effective config without starting a server. */
+export function resolveConfig(options = {}) {
+    const { toml, overrides } = toNative(options);
+    return JSON.parse(native.resolveConfigNative(toml, overrides));
+}
+/** An llmsim HTTP server running inside this process. */
+export class Server {
+    #native;
+    config;
+    constructor(nativeServer, config) {
+        this.#native = nativeServer;
+        this.config = config;
+    }
+    /** Bind and start serving. Resolves once the port is bound. */
+    static async start(options = {}) {
+        const { toml, overrides } = toNative(options);
+        const config = JSON.parse(native.resolveConfigNative(toml, overrides));
+        return new Server(await native.startServerNative(toml, overrides), config);
+    }
+    /** Base URL, e.g. `http://127.0.0.1:41234`. */
+    get url() {
+        return this.#native.url;
+    }
+    get host() {
+        return this.#native.host;
+    }
+    get port() {
+        return this.#native.port;
+    }
+    get isRunning() {
+        return this.#native.isRunning;
+    }
+    /** `baseURL` for the `openai` SDK. */
+    get openaiBaseUrl() {
+        return `${this.url}/openai/v1`;
+    }
+    /** `baseURL` for `@anthropic-ai/sdk` (the SDK appends `/v1`). */
+    get anthropicBaseUrl() {
+        return `${this.url}/anthropic`;
+    }
+    /** Base URL for OpenResponses clients. */
+    get openresponsesBaseUrl() {
+        return `${this.url}/openresponses/v1`;
+    }
+    /** Request, token, and latency counters. Throws once stopped. */
+    stats() {
+        return JSON.parse(this.#native.statsJson());
+    }
+    /** Gracefully stop the server. Idempotent. */
+    async stop() {
+        await this.#native.stop();
+    }
+    async [Symbol.asyncDispose]() {
+        await this.stop();
+    }
+}
+/** Shorthand for `Server.start(options)`. */
+export function startServer(options = {}) {
+    return Server.start(options);
+}