@mcmcjs/stan-wasm 0.0.0

package/dist/sampler-4wflmHRA.d.cts

@@ -0,0 +1,76 @@
+type SamplingOpts = {
+    num_chains: number;
+    num_warmup: number;
+    num_samples: number;
+    init_radius: number;
+    seed?: number;
+};
+type StanVariableInputs = Record<string, unknown>;
+type SampleConfig = SamplingOpts & {
+    data: string | StanVariableInputs;
+    inits?: string | StanVariableInputs | StanVariableInputs[];
+    refresh?: number;
+};
+type Progress = {
+    chain: number;
+    iteration: number;
+    totalIterations: number;
+    percent: number;
+    warmup: boolean;
+};
+type ConsoleMessage = {
+    text: string;
+    level: "log" | "error";
+};
+type StanRun = {
+    draws: number[][];
+    paramNames: string[];
+    computeTimeSec: number;
+    consoleMessages: ConsoleMessage[];
+    sampleConfig: SampleConfig;
+};
+type SamplerEvent = {
+    type: "progress";
+    report: Progress;
+} | {
+    type: "done";
+    run: StanRun;
+} | {
+    type: "error";
+    error: string;
+};
+type SamplerListener = (event: SamplerEvent) => void;
+type CompileStatus = "idle" | "compiling" | "ready" | "error";
+type SampleStatus = "idle" | "loading" | "sampling" | "done" | "error";
+type SamplerState = {
+    compileStatus: CompileStatus;
+    sampleStatus: SampleStatus;
+    compileError: string | null;
+    sampleError: string | null;
+    progress: Progress | null;
+    latestRun: StanRun | null;
+    consoleMessages: ConsoleMessage[];
+    modelId: string | null;
+    mainJsUrl: string | null;
+};
+type CompileResult = {
+    modelId: string;
+    mainJsUrl: string;
+};
+
+interface StanSamplerOptions {
+    compileServerUrl: string;
+    passcode?: string;
+    workerUrl?: string | URL;
+}
+declare class StanSampler {
+    #private;
+    constructor(opts: StanSamplerOptions);
+    get isReady(): boolean;
+    get lastCompile(): CompileResult | null;
+    compile(stanCode: string, signal?: AbortSignal): Promise<CompileResult>;
+    sample(config: SampleConfig, listener?: SamplerListener): Promise<StanRun>;
+    cancel(): void;
+}
+
+export { type CompileResult as C, type Progress as P, type SampleConfig as S, type CompileStatus as a, type ConsoleMessage as b, type SampleStatus as c, type SamplerEvent as d, type SamplerListener as e, type SamplerState as f, type SamplingOpts as g, type StanRun as h, StanSampler as i, type StanSamplerOptions as j, type StanVariableInputs as k };

package/dist/sampler-4wflmHRA.d.ts

@@ -0,0 +1,76 @@
+type SamplingOpts = {
+    num_chains: number;
+    num_warmup: number;
+    num_samples: number;
+    init_radius: number;
+    seed?: number;
+};
+type StanVariableInputs = Record<string, unknown>;
+type SampleConfig = SamplingOpts & {
+    data: string | StanVariableInputs;
+    inits?: string | StanVariableInputs | StanVariableInputs[];
+    refresh?: number;
+};
+type Progress = {
+    chain: number;
+    iteration: number;
+    totalIterations: number;
+    percent: number;
+    warmup: boolean;
+};
+type ConsoleMessage = {
+    text: string;
+    level: "log" | "error";
+};
+type StanRun = {
+    draws: number[][];
+    paramNames: string[];
+    computeTimeSec: number;
+    consoleMessages: ConsoleMessage[];
+    sampleConfig: SampleConfig;
+};
+type SamplerEvent = {
+    type: "progress";
+    report: Progress;
+} | {
+    type: "done";
+    run: StanRun;
+} | {
+    type: "error";
+    error: string;
+};
+type SamplerListener = (event: SamplerEvent) => void;
+type CompileStatus = "idle" | "compiling" | "ready" | "error";
+type SampleStatus = "idle" | "loading" | "sampling" | "done" | "error";
+type SamplerState = {
+    compileStatus: CompileStatus;
+    sampleStatus: SampleStatus;
+    compileError: string | null;
+    sampleError: string | null;
+    progress: Progress | null;
+    latestRun: StanRun | null;
+    consoleMessages: ConsoleMessage[];
+    modelId: string | null;
+    mainJsUrl: string | null;
+};
+type CompileResult = {
+    modelId: string;
+    mainJsUrl: string;
+};
+
+interface StanSamplerOptions {
+    compileServerUrl: string;
+    passcode?: string;
+    workerUrl?: string | URL;
+}
+declare class StanSampler {
+    #private;
+    constructor(opts: StanSamplerOptions);
+    get isReady(): boolean;
+    get lastCompile(): CompileResult | null;
+    compile(stanCode: string, signal?: AbortSignal): Promise<CompileResult>;
+    sample(config: SampleConfig, listener?: SamplerListener): Promise<StanRun>;
+    cancel(): void;
+}
+
+export { type CompileResult as C, type Progress as P, type SampleConfig as S, type CompileStatus as a, type ConsoleMessage as b, type SampleStatus as c, type SamplerEvent as d, type SamplerListener as e, type SamplerState as f, type SamplingOpts as g, type StanRun as h, StanSampler as i, type StanSamplerOptions as j, type StanVariableInputs as k };

package/dist/worker.js

@@ -0,0 +1,360 @@
+// ../../node_modules/.pnpm/tinystan@0.3.3/node_modules/tinystan/dist/util.mjs
+var prepareStanJSON = (obj) => {
+  if (typeof obj === "string") return obj;
+  else return JSON.stringify(obj);
+};
+
+// ../../node_modules/.pnpm/tinystan@0.3.3/node_modules/tinystan/dist/index.mjs
+var HMC_SAMPLER_VARIABLES = [
+  "lp__",
+  "accept_stat__",
+  "stepsize__",
+  "treedepth__",
+  "n_leapfrog__",
+  "divergent__",
+  "energy__"
+];
+var PATHFINDER_VARIABLES = [
+  "lp_approx__",
+  "lp__",
+  "path__"
+];
+var { NULL, PTR_SIZE, defaultSamplerParams, defaultPathfinderParams } = {
+  NULL: 0,
+  PTR_SIZE: 4,
+  defaultSamplerParams: {
+    data: "",
+    num_chains: 4,
+    inits: "",
+    seed: null,
+    id: 1,
+    init_radius: 2,
+    num_warmup: 1e3,
+    num_samples: 1e3,
+    metric: 2,
+    save_inv_metric: false,
+    init_inv_metric: null,
+    adapt: true,
+    delta: 0.8,
+    gamma: 0.05,
+    kappa: 0.75,
+    t0: 10,
+    init_buffer: 75,
+    term_buffer: 50,
+    window: 25,
+    save_warmup: false,
+    stepsize: 1,
+    stepsize_jitter: 0,
+    max_depth: 10,
+    refresh: 100,
+    num_threads: -1
+  },
+  defaultPathfinderParams: {
+    data: "",
+    num_paths: 4,
+    inits: "",
+    seed: null,
+    id: 1,
+    init_radius: 2,
+    num_draws: 1e3,
+    max_history_size: 5,
+    init_alpha: 1e-3,
+    tol_obj: 1e-12,
+    tol_rel_obj: 1e4,
+    tol_grad: 1e-8,
+    tol_rel_grad: 1e7,
+    tol_param: 1e-8,
+    num_iterations: 1e3,
+    num_elbo_draws: 25,
+    num_multi_draws: 1e3,
+    calculate_lp: true,
+    psis_resample: true,
+    refresh: 100,
+    num_threads: -1
+  }
+};
+var src_default = class StanModel {
+  m;
+  printErrorCallback;
+  sep;
+  constructor(m, pc) {
+    this.m = m;
+    this.printErrorCallback = pc;
+    this.sep = String.fromCharCode(m._tinystan_separator_char());
+  }
+  /**
+  * Load a StanModel from a WASM module.
+  *
+  * @param {Function} createModule A function that resolves to a WASM module. This is
+  * much like the one Emscripten creates for you with `-sMODULARIZE`.
+  * @param {PrintCallback | null} printCallback A callback that will be called
+  * with any print statements from Stan. If null, this will default to `console.log`.
+  * @returns {Promise<StanModel>} A promise that resolves to a `StanModel`
+  */
+  static async load(createModule, printCallback = null, printErrorCallback = null) {
+    printErrorCallback = printErrorCallback ?? printCallback;
+    return new StanModel(await createModule({
+      print: printCallback,
+      printErr: printErrorCallback
+    }), printErrorCallback);
+  }
+  encodeString(s) {
+    const len = this.m.lengthBytesUTF8(s) + 1;
+    const ptr = this.m._malloc(len);
+    this.m.stringToUTF8(s, ptr, len);
+    return ptr;
+  }
+  handleError(rc, err_ptr) {
+    if (rc == 0) {
+      this.m._free(err_ptr);
+      return;
+    }
+    const err = this.m.getValue(err_ptr, "*");
+    const err_msg_ptr = this.m._tinystan_get_error_message(err);
+    const err_msg = "Exception from Stan:\n" + this.m.UTF8ToString(err_msg_ptr);
+    this.m._tinystan_destroy_error(err);
+    this.m._free(err_ptr);
+    this.printErrorCallback?.(err_msg);
+    throw new Error(err_msg);
+  }
+  encodeInits(inits) {
+    if (Array.isArray(inits)) return this.encodeString(inits.map((i) => prepareStanJSON(i)).join(this.sep));
+    else return this.encodeString(prepareStanJSON(inits));
+  }
+  /** @ignore
+  * withModel serves as something akin to a context manager in
+  * Python. It accepts the arguments needed to construct a model
+  * (data and seed) and a callback.
+  *
+  * The callback takes in the model and a deferredFree function.
+  * The memory for the allocated model and any pointers which are "registered"
+  * by calling deferredFree will be cleaned up when the callback completes,
+  * regardless of if this is a normal return or an exception.
+  *
+  * The result of the callback is then returned or re-thrown.
+  */
+  withModel(data, seed, f) {
+    const data_ptr = this.encodeString(prepareStanJSON(data));
+    const err_ptr = this.m._malloc(PTR_SIZE);
+    const model2 = this.m._tinystan_create_model(data_ptr, seed, NULL, err_ptr);
+    this.m._free(data_ptr);
+    this.handleError(model2 === 0, err_ptr);
+    const ptrs = [];
+    const deferredFree = (p) => ptrs.push(p);
+    try {
+      return f(model2, deferredFree);
+    } finally {
+      ptrs.forEach((p) => this.m._free(p));
+      this.m._tinystan_destroy_model(model2);
+    }
+  }
+  /**
+  * Sample using NUTS-HMC.
+  * @param {SamplerParams} p A (partially-specified) `SamplerParams` object.
+  * If a property is not specified, the default value will be used.
+  * @returns {StanDraws} A StanDraws object containing the parameter names and the draws
+  */
+  sample(p) {
+    const { data, num_chains, inits, seed, id, init_radius, num_warmup, num_samples, metric, save_inv_metric, adapt, delta, gamma, kappa, t0, init_buffer, term_buffer, window, save_warmup, stepsize, stepsize_jitter, max_depth, refresh, num_threads } = {
+      ...defaultSamplerParams,
+      ...p
+    };
+    if (num_chains < 1) throw new Error("num_chains must be at least 1");
+    if (num_warmup < 0) throw new Error("num_warmup must be non-negative");
+    if (num_samples < 1) throw new Error("num_samples must be at least 1");
+    const seed_ = seed ?? Math.floor(Math.random() * Math.pow(2, 32));
+    return this.withModel(data, seed_, (model2, deferredFree) => {
+      const rawParamNames = this.m.UTF8ToString(this.m._tinystan_model_param_names(model2));
+      const paramNames = HMC_SAMPLER_VARIABLES.concat(rawParamNames.split(","));
+      const n_params = paramNames.length;
+      const free_params = this.m._tinystan_model_num_free_params(model2);
+      const init_inv_metric_ptr = NULL;
+      let inv_metric_out = NULL;
+      let stepsize_out = NULL;
+      if (adapt) {
+        stepsize_out = this.m._malloc(num_chains * Float64Array.BYTES_PER_ELEMENT);
+        if (save_inv_metric) if (metric === 1) inv_metric_out = this.m._malloc(num_chains * free_params * free_params * Float64Array.BYTES_PER_ELEMENT);
+        else inv_metric_out = this.m._malloc(num_chains * free_params * Float64Array.BYTES_PER_ELEMENT);
+      }
+      deferredFree(stepsize_out);
+      deferredFree(inv_metric_out);
+      const inits_ptr = this.encodeInits(inits);
+      deferredFree(inits_ptr);
+      const n_draws = num_chains * (save_warmup ? num_samples + num_warmup : num_samples);
+      const n_out = n_draws * n_params;
+      const out_ptr = this.m._malloc(n_out * Float64Array.BYTES_PER_ELEMENT);
+      deferredFree(out_ptr);
+      const err_ptr = this.m._malloc(PTR_SIZE);
+      const result = this.m._tinystan_sample(model2, num_chains, inits_ptr, seed_, id, init_radius, num_warmup, num_samples, metric.valueOf(), init_inv_metric_ptr, adapt ? 1 : 0, delta, gamma, kappa, t0, init_buffer, term_buffer, window, save_warmup ? 1 : 0, stepsize, stepsize_jitter, max_depth, refresh, num_threads, out_ptr, n_out, stepsize_out, inv_metric_out, err_ptr);
+      this.handleError(result, err_ptr);
+      const out_buffer = this.m.HEAPF64.subarray(out_ptr / Float64Array.BYTES_PER_ELEMENT, out_ptr / Float64Array.BYTES_PER_ELEMENT + n_out);
+      const draws = Array.from({ length: n_params }, (_, i) => Array.from({ length: n_draws }, (_2, j) => out_buffer[i + n_params * j]));
+      let stepsizes;
+      let inv_metric_array;
+      if (adapt) {
+        const stepsize_buffer = this.m.HEAPF64.subarray(stepsize_out / Float64Array.BYTES_PER_ELEMENT, stepsize_out / Float64Array.BYTES_PER_ELEMENT + num_chains);
+        stepsizes = Array.from({ length: num_chains }, (_, i) => stepsize_buffer[i]);
+        if (save_inv_metric) if (metric === 1) {
+          const inv_metric_buffer = this.m.HEAPF64.subarray(inv_metric_out / Float64Array.BYTES_PER_ELEMENT, inv_metric_out / Float64Array.BYTES_PER_ELEMENT + num_chains * free_params * free_params);
+          inv_metric_array = Array.from({ length: num_chains }, (_, i) => Array.from({ length: free_params }, (_2, j) => Array.from({ length: free_params }, (_3, k) => inv_metric_buffer[i * free_params * free_params + j * free_params + k])));
+        } else {
+          const inv_metric_buffer = this.m.HEAPF64.subarray(inv_metric_out / Float64Array.BYTES_PER_ELEMENT, inv_metric_out / Float64Array.BYTES_PER_ELEMENT + num_chains * free_params);
+          inv_metric_array = Array.from({ length: num_chains }, (_, i) => Array.from({ length: free_params }, (_2, j) => inv_metric_buffer[i * free_params + j]));
+        }
+      }
+      return {
+        paramNames,
+        draws,
+        inv_metric: inv_metric_array,
+        stepsize: stepsizes
+      };
+    });
+  }
+  /**
+  * Approximate the posterior using Pathfinder.
+  * @param {PathfinderParams} p A (partially-specified) `PathfinderParams` object.
+  * If a property is not specified, the default value will be used.
+  * @returns {StanDraws} A StanDraws object containing the parameter names and the
+  * approximate draws
+  */
+  pathfinder(p) {
+    const { data, num_paths, inits, seed, id, init_radius, num_draws, max_history_size, init_alpha, tol_obj, tol_rel_obj, tol_grad, tol_rel_grad, tol_param, num_iterations, num_elbo_draws, num_multi_draws, calculate_lp, psis_resample, refresh, num_threads } = {
+      ...defaultPathfinderParams,
+      ...p
+    };
+    if (num_paths < 1) throw new Error("num_paths must be at least 1");
+    if (num_draws < 1) throw new Error("num_draws must be at least 1");
+    if (num_multi_draws < 1) throw new Error("num_multi_draws must be at least 1");
+    const output_rows = calculate_lp && psis_resample ? num_multi_draws : num_draws * num_paths;
+    const seed_ = seed !== null ? seed : Math.floor(Math.random() * Math.pow(2, 32));
+    return this.withModel(data, seed_, (model2, deferredFree) => {
+      const rawParamNames = this.m.UTF8ToString(this.m._tinystan_model_param_names(model2));
+      const paramNames = PATHFINDER_VARIABLES.concat(rawParamNames.split(","));
+      const n_params = paramNames.length;
+      if (this.m._tinystan_model_num_free_params(model2) === 0) throw new Error("Model has no parameters.");
+      const inits_ptr = this.encodeInits(inits);
+      deferredFree(inits_ptr);
+      const n_out = output_rows * n_params;
+      const out = this.m._malloc(n_out * Float64Array.BYTES_PER_ELEMENT);
+      deferredFree(out);
+      const err_ptr = this.m._malloc(PTR_SIZE);
+      const result = this.m._tinystan_pathfinder(model2, num_paths, inits_ptr, seed_, id, init_radius, num_draws, max_history_size, init_alpha, tol_obj, tol_rel_obj, tol_grad, tol_rel_grad, tol_param, num_iterations, num_elbo_draws, num_multi_draws, calculate_lp ? 1 : 0, psis_resample ? 1 : 0, refresh, num_threads, out, n_out, err_ptr);
+      this.handleError(result, err_ptr);
+      const out_buffer = this.m.HEAPF64.subarray(out / Float64Array.BYTES_PER_ELEMENT, out / Float64Array.BYTES_PER_ELEMENT + n_out);
+      return {
+        paramNames,
+        draws: Array.from({ length: n_params }, (_, i) => Array.from({ length: output_rows }, (_2, j) => out_buffer[i + n_params * j]))
+      };
+    });
+  }
+  /**
+  * Get the version of the Stan library being used.
+  * @returns {string} The version of the Stan library being used,
+  * in the form "major.minor.patch"
+  */
+  stanVersion() {
+    const major = this.m._malloc(4);
+    const minor = this.m._malloc(4);
+    const patch = this.m._malloc(4);
+    this.m._tinystan_stan_version(major, minor, patch);
+    const version = this.m.getValue(major, "i32") + "." + this.m.getValue(minor, "i32") + "." + this.m.getValue(patch, "i32");
+    this.m._free(major);
+    this.m._free(minor);
+    this.m._free(patch);
+    return version;
+  }
+};
+
+// src/worker.ts
+var postReply = (message) => self.postMessage(message);
+var model = null;
+var consoleMessages = [];
+var parseProgress = (msg) => {
+  let normalized = msg;
+  if (normalized.startsWith("Iteration:")) {
+    normalized = `Chain [1] ${normalized}`;
+  }
+  normalized = normalized.replace(/\[|\]/g, "");
+  const parts = normalized.split(/\s+/);
+  const chain = Number.parseInt(parts[1] ?? "0", 10);
+  const iteration = Number.parseInt(parts[3] ?? "0", 10);
+  const totalIterations = Number.parseInt(parts[5] ?? "0", 10);
+  const percentRaw = parts[6] ?? "0%";
+  const percent = Number.parseInt(percentRaw.slice(0, -1), 10);
+  const warmup = parts[7] === "(Warmup)";
+  return { chain, iteration, totalIterations, percent, warmup };
+};
+var progressPrintCallback = (msg) => {
+  if (!msg) return;
+  consoleMessages.push({ text: msg, level: "log" });
+  if (msg.includes("Iteration:")) {
+    postReply({ kind: "progress" /* Progress */, report: parseProgress(msg) });
+  }
+};
+var errorPrintCallback = (msg) => {
+  consoleMessages.push({ text: msg, level: "error" });
+};
+var normalizeInits = (raw) => {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw === "string") return raw;
+  return raw;
+};
+self.onmessage = async (event) => {
+  const data = event.data;
+  if (!data || typeof data !== "object" || !("kind" in data)) return;
+  switch (data.kind) {
+    case "load" /* Load */: {
+      try {
+        const mod = await import(
+          /* @vite-ignore */
+          data.url
+        );
+        model = await src_default.load(mod.default, progressPrintCallback, errorPrintCallback);
+        const stanVersion = typeof model.stanVersion === "function" ? model.stanVersion() : "unknown";
+        postReply({ kind: "modelLoaded" /* ModelLoaded */, stanVersion });
+      } catch (err) {
+        postReply({
+          kind: "modelLoadError" /* ModelLoadError */,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      break;
+    }
+    case "sample" /* Sample */: {
+      if (!model) {
+        postReply({
+          kind: "stanReturn" /* StanReturn */,
+          error: "Model not loaded \u2014 call compile() and await it before sample()"
+        });
+        return;
+      }
+      consoleMessages = [];
+      try {
+        const cfg = data.sampleConfig;
+        const inits = normalizeInits(cfg.inits);
+        const tinystanArgs = { ...cfg };
+        if (inits === void 0) {
+          delete tinystanArgs.inits;
+        } else {
+          tinystanArgs.inits = inits;
+        }
+        const { paramNames, draws } = model.sample(tinystanArgs);
+        postReply({
+          kind: "stanReturn" /* StanReturn */,
+          error: null,
+          draws,
+          paramNames,
+          consoleMessages,
+          sampleConfig: cfg
+        });
+      } catch (err) {
+        postReply({
+          kind: "stanReturn" /* StanReturn */,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      break;
+    }
+  }
+};
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../node_modules/.pnpm/tinystan@0.3.3/node_modules/tinystan/src/util.ts","../../../node_modules/.pnpm/tinystan@0.3.3/node_modules/tinystan/src/constants.ts","../../../node_modules/.pnpm/tinystan@0.3.3/node_modules/tinystan/src/model.ts","../../../node_modules/.pnpm/tinystan@0.3.3/node_modules/tinystan/src/index.ts","../src/worker.ts"],"sourcesContent":["import { PrintCallback, StanVariableInputs } from \"./types\";\n\n// Stan expects a JSON object (\"{ ... }\") at the top level.\n// If the input is already a string, e.g. it came from a textarea,\n// we just return it as is.\nexport const prepareStanJSON = (obj: string | StanVariableInputs): string => {\n  if (typeof obj === \"string\") {\n    return obj;\n  } else {\n    return JSON.stringify(obj);\n  }\n};\n\n// A printCallback that \"soaks up\" all the printed text.\nexport const printCallbackSponge = (): {\n  printCallback: PrintCallback;\n  getStdout: () => string;\n  clearStdout: () => void;\n} => {\n  const stdoutHolder = { text: \"\" };\n  const printCallback = (...args: unknown[]) => {\n    const text = args.join(\" \");\n    stdoutHolder.text = stdoutHolder.text + text + \"\\n\";\n  };\n\n  const getStdout = () => stdoutHolder.text;\n  const clearStdout = () => (stdoutHolder.text = \"\");\n\n  return { printCallback, getStdout, clearStdout };\n};\n","import { SamplerParams, PathfinderParams, HMCMetric } from \"./types\";\n\nexport const HMC_SAMPLER_VARIABLES = [\n  \"lp__\",\n  \"accept_stat__\",\n  \"stepsize__\",\n  \"treedepth__\",\n  \"n_leapfrog__\",\n  \"divergent__\",\n  \"energy__\",\n];\nexport const PATHFINDER_VARIABLES = [\"lp_approx__\", \"lp__\", \"path__\"];\n\n// NULL can be any pointer type\nconst NULL = 0 as any;\nconst PTR_SIZE = 4;\n\nconst defaultSamplerParams: SamplerParams = {\n  data: \"\",\n  num_chains: 4,\n  inits: \"\",\n  seed: null,\n  id: 1,\n  init_radius: 2,\n  num_warmup: 1000,\n  num_samples: 1000,\n  metric: HMCMetric.DIAGONAL,\n  save_inv_metric: false,\n  init_inv_metric: null, // currently unused\n  adapt: true,\n  delta: 0.8,\n  gamma: 0.05,\n  kappa: 0.75,\n  t0: 10,\n  init_buffer: 75,\n  term_buffer: 50,\n  window: 25,\n  save_warmup: false,\n  stepsize: 1,\n  stepsize_jitter: 0,\n  max_depth: 10,\n  refresh: 100,\n  num_threads: -1,\n};\nconst defaultPathfinderParams: PathfinderParams = {\n  data: \"\",\n  num_paths: 4,\n  inits: \"\",\n  seed: null,\n  id: 1,\n  init_radius: 2,\n  num_draws: 1000,\n  max_history_size: 5,\n  init_alpha: 0.001,\n  tol_obj: 1e-12,\n  tol_rel_obj: 10000,\n  tol_grad: 1e-8,\n  tol_rel_grad: 10000000,\n  tol_param: 1e-8,\n  num_iterations: 1000,\n  num_elbo_draws: 25,\n  num_multi_draws: 1000,\n  calculate_lp: true,\n  psis_resample: true,\n  refresh: 100,\n  num_threads: -1,\n};\n\nexport const internalConstants = {\n  NULL,\n  PTR_SIZE,\n  defaultSamplerParams,\n  defaultPathfinderParams,\n};\n","import { prepareStanJSON } from \"./util\";\nimport {\n  HMC_SAMPLER_VARIABLES,\n  PATHFINDER_VARIABLES,\n  internalConstants,\n} from \"./constants\";\nconst { NULL, PTR_SIZE, defaultSamplerParams, defaultPathfinderParams } =\n  internalConstants;\n\nimport { HMCMetric } from \"./types\";\nimport type {\n  SamplerParams,\n  PathfinderParams,\n  StanVariableInputs,\n  PrintCallback,\n  StanDraws,\n  internalTypes,\n} from \"./types\";\ntype WasmModule = internalTypes[\"WasmModule\"];\ntype ptr = internalTypes[\"ptr\"];\ntype model_ptr = internalTypes[\"model_ptr\"];\ntype error_ptr = internalTypes[\"error_ptr\"];\ntype cstr = internalTypes[\"cstr\"];\n\n/**\n * StanModel is a class that wraps the WASM module and provides a\n * higher-level interface to the Stan library, abstracting away things\n * like memory management and error handling.\n */\nexport default class StanModel {\n  private m: WasmModule;\n  private printErrorCallback: PrintCallback | null;\n  // used to send multiple JSON values in one string\n  private sep: string;\n\n  private constructor(m: WasmModule, pc: PrintCallback | null) {\n    this.m = m;\n    this.printErrorCallback = pc;\n    this.sep = String.fromCharCode(m._tinystan_separator_char());\n  }\n\n  /**\n   * Load a StanModel from a WASM module.\n   *\n   * @param {Function} createModule A function that resolves to a WASM module. This is\n   * much like the one Emscripten creates for you with `-sMODULARIZE`.\n   * @param {PrintCallback | null} printCallback A callback that will be called\n   * with any print statements from Stan. If null, this will default to `console.log`.\n   * @returns {Promise<StanModel>} A promise that resolves to a `StanModel`\n   */\n  public static async load(\n    createModule: (moduleArg?: object) => Promise<object>,\n    printCallback: PrintCallback | null = null,\n    printErrorCallback: PrintCallback | null = null,\n  ): Promise<StanModel> {\n    // Create the initial object which will have the rest of the WASM\n    // functions attached to it\n    // See https://emscripten.org/docs/api_reference/module.html\n    printErrorCallback = printErrorCallback ?? printCallback;\n    const prototype = { print: printCallback, printErr: printErrorCallback };\n\n    const module = await createModule(prototype);\n    return new StanModel(module as WasmModule, printErrorCallback);\n  }\n\n  private encodeString(s: string): cstr {\n    const len = this.m.lengthBytesUTF8(s) + 1;\n    const ptr = this.m._malloc(len) as unknown as cstr;\n    this.m.stringToUTF8(s, ptr, len);\n    return ptr;\n  }\n\n  private handleError(rc: number | boolean, err_ptr: ptr): void {\n    if (rc == 0) {\n      this.m._free(err_ptr);\n      return;\n    }\n\n    const err = this.m.getValue(err_ptr, \"*\") as error_ptr;\n    const err_msg_ptr = this.m._tinystan_get_error_message(err);\n    const err_msg = \"Exception from Stan:\\n\" + this.m.UTF8ToString(err_msg_ptr);\n    this.m._tinystan_destroy_error(err);\n    this.m._free(err_ptr);\n    this.printErrorCallback?.(err_msg);\n    throw new Error(err_msg);\n  }\n\n  private encodeInits(\n    inits: string | StanVariableInputs | string[] | StanVariableInputs[],\n  ): cstr {\n    if (Array.isArray(inits)) {\n      return this.encodeString(\n        inits.map(i => prepareStanJSON(i)).join(this.sep),\n      );\n    } else {\n      return this.encodeString(prepareStanJSON(inits));\n    }\n  }\n\n  /** @ignore\n   * withModel serves as something akin to a context manager in\n   * Python. It accepts the arguments needed to construct a model\n   * (data and seed) and a callback.\n   *\n   * The callback takes in the model and a deferredFree function.\n   * The memory for the allocated model and any pointers which are \"registered\"\n   * by calling deferredFree will be cleaned up when the callback completes,\n   * regardless of if this is a normal return or an exception.\n   *\n   * The result of the callback is then returned or re-thrown.\n   */\n  private withModel<T>(\n    data: string | StanVariableInputs,\n    seed: number,\n    f: (model: model_ptr, deferredFree: (p: ptr | cstr) => void) => T,\n  ): T {\n    const data_ptr = this.encodeString(prepareStanJSON(data));\n    const err_ptr = this.m._malloc(PTR_SIZE);\n    const model = this.m._tinystan_create_model(data_ptr, seed, NULL, err_ptr);\n    this.m._free(data_ptr);\n\n    this.handleError(model === 0, err_ptr);\n\n    const ptrs: (ptr | cstr)[] = [];\n    const deferredFree = (p: ptr | cstr) => ptrs.push(p);\n\n    try {\n      return f(model, deferredFree);\n    } finally {\n      ptrs.forEach(p => this.m._free(p));\n      this.m._tinystan_destroy_model(model);\n    }\n  }\n\n  /**\n   * Sample using NUTS-HMC.\n   * @param {SamplerParams} p A (partially-specified) `SamplerParams` object.\n   * If a property is not specified, the default value will be used.\n   * @returns {StanDraws} A StanDraws object containing the parameter names and the draws\n   */\n  public sample(p: Partial<SamplerParams>): StanDraws {\n    const {\n      data,\n      num_chains,\n      inits,\n      seed,\n      id,\n      init_radius,\n      num_warmup,\n      num_samples,\n      metric,\n      save_inv_metric,\n      adapt,\n      delta,\n      gamma,\n      kappa,\n      t0,\n      init_buffer,\n      term_buffer,\n      window,\n      save_warmup,\n      stepsize,\n      stepsize_jitter,\n      max_depth,\n      refresh,\n      num_threads,\n    } = { ...defaultSamplerParams, ...p };\n\n    if (num_chains < 1) {\n      throw new Error(\"num_chains must be at least 1\");\n    }\n    if (num_warmup < 0) {\n      throw new Error(\"num_warmup must be non-negative\");\n    }\n    if (num_samples < 1) {\n      throw new Error(\"num_samples must be at least 1\");\n    }\n\n    const seed_ = seed ?? Math.floor(Math.random() * Math.pow(2, 32));\n\n    return this.withModel(data, seed_, (model, deferredFree) => {\n      // Get the parameter names\n      const rawParamNames = this.m.UTF8ToString(\n        this.m._tinystan_model_param_names(model),\n      );\n      const paramNames = HMC_SAMPLER_VARIABLES.concat(rawParamNames.split(\",\"));\n\n      const n_params = paramNames.length;\n\n      const free_params = this.m._tinystan_model_num_free_params(model);\n\n      // TODO: allow init_inv_metric to be specified\n      const init_inv_metric_ptr = NULL;\n\n      let inv_metric_out = NULL;\n      let stepsize_out = NULL;\n\n      if (adapt) {\n        stepsize_out = this.m._malloc(\n          num_chains * Float64Array.BYTES_PER_ELEMENT,\n        );\n        if (save_inv_metric) {\n          if (metric === HMCMetric.DENSE)\n            inv_metric_out = this.m._malloc(\n              num_chains *\n                free_params *\n                free_params *\n                Float64Array.BYTES_PER_ELEMENT,\n            );\n          else\n            inv_metric_out = this.m._malloc(\n              num_chains * free_params * Float64Array.BYTES_PER_ELEMENT,\n            );\n        }\n      }\n      deferredFree(stepsize_out);\n      deferredFree(inv_metric_out);\n\n      const inits_ptr = this.encodeInits(inits);\n      deferredFree(inits_ptr);\n\n      const n_draws =\n        num_chains * (save_warmup ? num_samples + num_warmup : num_samples);\n      const n_out = n_draws * n_params;\n\n      // Allocate memory for the output\n      const out_ptr = this.m._malloc(n_out * Float64Array.BYTES_PER_ELEMENT);\n      deferredFree(out_ptr);\n\n      const err_ptr = this.m._malloc(PTR_SIZE);\n\n      // Sample from the model\n      const result = this.m._tinystan_sample(\n        model,\n        num_chains,\n        inits_ptr,\n        seed_,\n        id,\n        init_radius,\n        num_warmup,\n        num_samples,\n        metric.valueOf(),\n        init_inv_metric_ptr,\n        adapt ? 1 : 0,\n        delta,\n        gamma,\n        kappa,\n        t0,\n        init_buffer,\n        term_buffer,\n        window,\n        save_warmup ? 1 : 0,\n        stepsize,\n        stepsize_jitter,\n        max_depth,\n        refresh,\n        num_threads,\n        out_ptr,\n        n_out,\n        stepsize_out,\n        inv_metric_out,\n        err_ptr,\n      );\n\n      this.handleError(result, err_ptr);\n\n      const out_buffer = this.m.HEAPF64.subarray(\n        out_ptr / Float64Array.BYTES_PER_ELEMENT,\n        out_ptr / Float64Array.BYTES_PER_ELEMENT + n_out,\n      );\n\n      // copy out parameters of interest\n      const draws: number[][] = Array.from({ length: n_params }, (_, i) =>\n        Array.from({ length: n_draws }, (_, j) => out_buffer[i + n_params * j]),\n      );\n\n      let stepsizes: number[] | undefined;\n      let inv_metric_array: number[][] | number[][][] | undefined;\n      if (adapt) {\n        const stepsize_buffer = this.m.HEAPF64.subarray(\n          stepsize_out / Float64Array.BYTES_PER_ELEMENT,\n          stepsize_out / Float64Array.BYTES_PER_ELEMENT + num_chains,\n        );\n        stepsizes = Array.from(\n          { length: num_chains },\n          (_, i) => stepsize_buffer[i],\n        );\n        if (save_inv_metric) {\n          if (metric === HMCMetric.DENSE) {\n            const inv_metric_buffer = this.m.HEAPF64.subarray(\n              inv_metric_out / Float64Array.BYTES_PER_ELEMENT,\n              inv_metric_out / Float64Array.BYTES_PER_ELEMENT +\n                num_chains * free_params * free_params,\n            );\n\n            inv_metric_array = Array.from({ length: num_chains }, (_, i) =>\n              Array.from({ length: free_params }, (_, j) =>\n                Array.from(\n                  { length: free_params },\n                  (_, k) =>\n                    inv_metric_buffer[\n                      i * free_params * free_params + j * free_params + k\n                    ],\n                ),\n              ),\n            );\n          } else {\n            const inv_metric_buffer = this.m.HEAPF64.subarray(\n              inv_metric_out / Float64Array.BYTES_PER_ELEMENT,\n              inv_metric_out / Float64Array.BYTES_PER_ELEMENT +\n                num_chains * free_params,\n            );\n            inv_metric_array = Array.from({ length: num_chains }, (_, i) =>\n              Array.from(\n                { length: free_params },\n                (_, j) => inv_metric_buffer[i * free_params + j],\n              ),\n            );\n          }\n        }\n      }\n\n      return {\n        paramNames,\n        draws,\n        inv_metric: inv_metric_array,\n        stepsize: stepsizes,\n      };\n    });\n  }\n\n  /**\n   * Approximate the posterior using Pathfinder.\n   * @param {PathfinderParams} p A (partially-specified) `PathfinderParams` object.\n   * If a property is not specified, the default value will be used.\n   * @returns {StanDraws} A StanDraws object containing the parameter names and the\n   * approximate draws\n   */\n  public pathfinder(p: Partial<PathfinderParams>): StanDraws {\n    const {\n      data,\n      num_paths,\n      inits,\n      seed,\n      id,\n      init_radius,\n      num_draws,\n      max_history_size,\n      init_alpha,\n      tol_obj,\n      tol_rel_obj,\n      tol_grad,\n      tol_rel_grad,\n      tol_param,\n      num_iterations,\n      num_elbo_draws,\n      num_multi_draws,\n      calculate_lp,\n      psis_resample,\n      refresh,\n      num_threads,\n    } = { ...defaultPathfinderParams, ...p };\n\n    if (num_paths < 1) {\n      throw new Error(\"num_paths must be at least 1\");\n    }\n    if (num_draws < 1) {\n      throw new Error(\"num_draws must be at least 1\");\n    }\n    if (num_multi_draws < 1) {\n      throw new Error(\"num_multi_draws must be at least 1\");\n    }\n\n    const output_rows =\n      calculate_lp && psis_resample ? num_multi_draws : num_draws * num_paths;\n\n    const seed_ =\n      seed !== null ? seed : Math.floor(Math.random() * Math.pow(2, 32));\n\n    return this.withModel(data, seed_, (model, deferredFree) => {\n      const rawParamNames = this.m.UTF8ToString(\n        this.m._tinystan_model_param_names(model),\n      );\n      const paramNames = PATHFINDER_VARIABLES.concat(rawParamNames.split(\",\"));\n\n      const n_params = paramNames.length;\n\n      const free_params = this.m._tinystan_model_num_free_params(model);\n      if (free_params === 0) {\n        throw new Error(\"Model has no parameters.\");\n      }\n\n      const inits_ptr = this.encodeInits(inits);\n      deferredFree(inits_ptr);\n\n      const n_out = output_rows * n_params;\n      const out = this.m._malloc(n_out * Float64Array.BYTES_PER_ELEMENT);\n      deferredFree(out);\n      const err_ptr = this.m._malloc(PTR_SIZE);\n\n      const result = this.m._tinystan_pathfinder(\n        model,\n        num_paths,\n        inits_ptr,\n        seed_,\n        id,\n        init_radius,\n        num_draws,\n        max_history_size,\n        init_alpha,\n        tol_obj,\n        tol_rel_obj,\n        tol_grad,\n        tol_rel_grad,\n        tol_param,\n        num_iterations,\n        num_elbo_draws,\n        num_multi_draws,\n        calculate_lp ? 1 : 0,\n        psis_resample ? 1 : 0,\n        refresh,\n        num_threads,\n        out,\n        n_out,\n        err_ptr,\n      );\n      this.handleError(result, err_ptr);\n\n      const out_buffer = this.m.HEAPF64.subarray(\n        out / Float64Array.BYTES_PER_ELEMENT,\n        out / Float64Array.BYTES_PER_ELEMENT + n_out,\n      );\n\n      const draws: number[][] = Array.from({ length: n_params }, (_, i) =>\n        Array.from(\n          { length: output_rows },\n          (_, j) => out_buffer[i + n_params * j],\n        ),\n      );\n\n      return { paramNames, draws };\n    });\n  }\n\n  /**\n   * Get the version of the Stan library being used.\n   * @returns {string} The version of the Stan library being used,\n   * in the form \"major.minor.patch\"\n   */\n  public stanVersion(): string {\n    const major = this.m._malloc(4);\n    const minor = this.m._malloc(4);\n    const patch = this.m._malloc(4);\n    this.m._tinystan_stan_version(major, minor, patch);\n    const version =\n      this.m.getValue(major, \"i32\") +\n      \".\" +\n      this.m.getValue(minor, \"i32\") +\n      \".\" +\n      this.m.getValue(patch, \"i32\");\n    this.m._free(major);\n    this.m._free(minor);\n    this.m._free(patch);\n    return version;\n  }\n}\n","import type {\n  StanDraws,\n  SamplerParams,\n  PathfinderParams,\n  PrintCallback,\n  StanVariableInputs,\n} from \"./types\";\nexport type {\n  StanDraws,\n  SamplerParams,\n  PathfinderParams,\n  PrintCallback,\n  StanVariableInputs,\n};\n\nimport StanModel from \"./model\";\nexport default StanModel;\n","/// <reference lib=\"webworker\" />\n\nimport StanModel from \"tinystan\";\nimport {\n  type ConsoleMessage,\n  type Progress,\n  WorkerReply,\n  type WorkerReplyMessage,\n  WorkerRequest,\n  type WorkerRequestMessage,\n} from \"./types\";\n\ndeclare const self: DedicatedWorkerGlobalScope;\n\nconst postReply = (message: WorkerReplyMessage) => self.postMessage(message);\n\nlet model: StanModel | null = null;\nlet consoleMessages: ConsoleMessage[] = [];\n\nconst parseProgress = (msg: string): Progress => {\n  let normalized = msg;\n  if (normalized.startsWith(\"Iteration:\")) {\n    normalized = `Chain [1] ${normalized}`;\n  }\n  normalized = normalized.replace(/\\[|\\]/g, \"\");\n  const parts = normalized.split(/\\s+/);\n  const chain = Number.parseInt(parts[1] ?? \"0\", 10);\n  const iteration = Number.parseInt(parts[3] ?? \"0\", 10);\n  const totalIterations = Number.parseInt(parts[5] ?? \"0\", 10);\n  const percentRaw = parts[6] ?? \"0%\";\n  const percent = Number.parseInt(percentRaw.slice(0, -1), 10);\n  const warmup = parts[7] === \"(Warmup)\";\n  return { chain, iteration, totalIterations, percent, warmup };\n};\n\nconst progressPrintCallback = (msg: string) => {\n  if (!msg) return;\n  consoleMessages.push({ text: msg, level: \"log\" });\n  if (msg.includes(\"Iteration:\")) {\n    postReply({ kind: WorkerReply.Progress, report: parseProgress(msg) });\n  }\n};\n\nconst errorPrintCallback = (msg: string) => {\n  consoleMessages.push({ text: msg, level: \"error\" });\n};\n\nconst normalizeInits = (\n  raw: unknown,\n): string | Record<string, unknown> | Record<string, unknown>[] | undefined => {\n  if (raw === undefined || raw === null) return undefined;\n  if (typeof raw === \"string\") return raw;\n  return raw as Record<string, unknown> | Record<string, unknown>[];\n};\n\nself.onmessage = async (event: MessageEvent<WorkerRequestMessage>) => {\n  const data = event.data;\n  if (!data || typeof data !== \"object\" || !(\"kind\" in data)) return;\n\n  switch (data.kind) {\n    case WorkerRequest.Load: {\n      try {\n        const mod = await import(/* @vite-ignore */ data.url);\n        model = await StanModel.load(mod.default, progressPrintCallback, errorPrintCallback);\n        const stanVersion =\n          typeof model.stanVersion === \"function\" ? model.stanVersion() : \"unknown\";\n        postReply({ kind: WorkerReply.ModelLoaded, stanVersion });\n      } catch (err) {\n        postReply({\n          kind: WorkerReply.ModelLoadError,\n          error: err instanceof Error ? err.message : String(err),\n        });\n      }\n      break;\n    }\n\n    case WorkerRequest.Sample: {\n      if (!model) {\n        postReply({\n          kind: WorkerReply.StanReturn,\n          error: \"Model not loaded — call compile() and await it before sample()\",\n        });\n        return;\n      }\n      consoleMessages = [];\n      try {\n        const cfg = data.sampleConfig;\n        const inits = normalizeInits(cfg.inits);\n        const tinystanArgs: Record<string, unknown> = { ...cfg };\n        if (inits === undefined) {\n          delete tinystanArgs.inits;\n        } else {\n          tinystanArgs.inits = inits;\n        }\n        const { paramNames, draws } = model.sample(tinystanArgs);\n        postReply({\n          kind: WorkerReply.StanReturn,\n          error: null,\n          draws,\n          paramNames,\n          consoleMessages,\n          sampleConfig: cfg,\n        });\n      } catch (err) {\n        postReply({\n          kind: WorkerReply.StanReturn,\n          error: err instanceof Error ? err.message : String(err),\n        });\n      }\n      break;\n    }\n  }\n};\n"],"mappings":"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","names":["model","_"]}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@mcmcjs/stan-wasm",
+  "version": "0.0.0",
+  "description": "Run Stan models in the browser: a WebAssembly sampling runtime with a typed compile-server client and an optional React adapter.",
+  "keywords": [
+    "mcmc",
+    "bayesian",
+    "inference",
+    "stan",
+    "wasm",
+    "webassembly",
+    "sampler"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Shravan Goswami",
+    "email": "contact@shravangoswami.com",
+    "url": "https://shravangoswami.com"
+  },
+  "homepage": "https://github.com/mcmcjs/mcmcjs/tree/main/packages/stan-wasm#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mcmcjs/mcmcjs.git",
+    "directory": "packages/stan-wasm"
+  },
+  "bugs": {
+    "url": "https://github.com/mcmcjs/mcmcjs/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js",
+      "require": "./dist/react/index.cjs"
+    },
+    "./worker": {
+      "import": "./dist/worker.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "tinystan": "^0.3.2"
+  },
+  "peerDependencies": {
+    "react": ">=18 <20"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "react": "^18.3.0"
+  }
+}