diff --git a/.gitignore b/.gitignore
index c061465..342b5fa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,10 +4,11 @@ docs/.vitepress/cache
 docs/api
 docs/public/demo/playground
 docs/public/demo/simple-app
-docs/public/js/vtk.umd.js
-docs/public/js/viewer.umd.js
 docs/public/js/viewer.css
+docs/public/js/viewer.umd.js
+docs/public/js/vtk.umd.js
 examples/cpp/vtk
 examples/cpp/*/build
 dist
 scripts/__pycache__
+types/generated.d.ts
diff --git a/.prettierignore b/.prettierignore
new file mode 100644
index 0000000..410e6ac
--- /dev/null
+++ b/.prettierignore
@@ -0,0 +1,2 @@
+types/generated.d.ts
+**/vtk-wasm.gen.d.ts
diff --git a/bin/vtk-wasm.mjs b/bin/vtk-wasm.mjs
new file mode 100755
index 0000000..b1b4455
--- /dev/null
+++ b/bin/vtk-wasm.mjs
@@ -0,0 +1,534 @@
+#!/usr/bin/env node
+// @kitware/vtk-wasm command-line tool.
+//
+//   vtk-wasm gen-types --url <bundle .tar.gz> --out <file.d.ts>
+//   vtk-wasm gen-types --in  <dir of vtk*.json> --out <file.d.ts>
+//
+// `gen-types` emits a TypeScript module-augmentation file that makes
+// `session.vtk` fully typed for the exact VTK.wasm binary your app loads. Point
+// it at the same bundle you pass to `loadAsync({ url })`; the per-class serdes
+// manifests (`types/*.json`) emitted by VTK's vtkWrapSerDes and shipped
+// alongside the binary are the source of truth, so the generated types always
+// match your VTK version and arch.
+//
+// The manifests are architecture-specific: word-width types are already baked
+// to a concrete width by the VTK build, so they must come from the archive that
+// matches your target (wasm32 or wasm64). No target flag needed.
+//
+// The manifest schema (per class) is JSON-Schema flavored:
+//   { "title": "vtkActor", "inherits": "vtkProp3D",
+//     "properties": { "Opacity": { "type": "number" },
+//                     "Mapper":  { "$ref": "vtkMapper" } },
+//     "methods": {
+//       "GetMapper": { "parameters": {}, "returns": { "$ref": "vtkMapper" } },
+//       // `maySuspend: true` marks a method that yields to the browser event
+//       // loop (WebGPU/JSPI await); it is emitted as Promise<T>, all others T.
+//       "WaitForCompletion": { "parameters": {}, "returns": { "type": "null" }, "maySuspend": true }
+//     }
+//   }
+//
+// Methods are keyed by name in the manifest, so C++ overloads collapse to a
+// single surviving signature per class, and different classes in a hierarchy
+// may keep different survivors. Combined with C++ signature hiding and
+// covariant overrides, a child interface often redeclares an inherited member
+// with a signature that TypeScript's `extends` rejects. We therefore emit
+// `extends Omit<Parent, "redeclaredName" | ...>` so the child's declaration
+// simply replaces the parent's instead of being compared against it.
+//
+// The same collapse also breaks *structural* substitutability at use-sites: a
+// subclass (vtkPolyDataMapper) is often not assignable where its base
+// (vtkMapper) is expected, even though the C++ is-a relationship holds. C++ is
+// nominally typed, so we mirror that: every generated interface carries a
+// phantom `$brands` member listing its full ancestor chain, and every
+// class-typed parameter / settable-property position is typed as
+// `VtkRef<"vtkMapper">` (defined in types/base.d.ts) which means "anything
+// branded as a vtkMapper", instead of the structural interface. Return
+// positions keep the full structural interface for proper member typing.
+
+import { readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gunzipSync } from "node:zlib";
+
+// TS reserved words that cannot be used verbatim as parameter identifiers.
+const RESERVED = new Set([
+  "class",
+  "const",
+  "default",
+  "delete",
+  "extends",
+  "function",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "return",
+  "super",
+  "this",
+  "typeof",
+  "var",
+  "void",
+]);
+
+// Member names the proxy get-trap resolves before consulting C++ (see
+// src/core/proxy.js). Proxy plumbing is $-prefixed and can never collide with
+// C++ members ($ is not legal in C++ identifiers).
+const PLUMBING = new Set(["toJSON", "toString", "then"]);
+
+// ---------------------------------------------------------------------------
+// Command line
+// ---------------------------------------------------------------------------
+
+function usage(code = 1) {
+  process.stderr.write(
+    [
+      "usage:",
+      "  vtk-wasm gen-types --url <bundle .tar.gz>    --out <file.d.ts>",
+      "  vtk-wasm gen-types --in  <dir of vtk*.json>  --out <file.d.ts>",
+      "",
+      "options:",
+      "  --url <path|URL>   .tar.gz VTK.wasm bundle (local path or http(s) URL)",
+      "  --in  <dir>        local directory of vtk*.json manifests (repeatable)",
+      "  --out <file>       output .d.ts (default: ./vtk-wasm.gen.d.ts)",
+      "",
+    ].join("\n"),
+  );
+  process.exit(code);
+}
+
+function parseArgs(argv) {
+  if (argv[0] !== "gen-types") usage();
+  const opts = {
+    dirs: [],
+    url: null,
+    out: "vtk-wasm.gen.d.ts",
+  };
+  for (let i = 1; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--in") opts.dirs.push(argv[++i]);
+    else if (a === "--url") opts.url = argv[++i];
+    else if (a === "--out") opts.out = argv[++i];
+    else if (a === "-h" || a === "--help") usage(0);
+    else {
+      process.stderr.write(`unknown argument: ${a}\n`);
+      usage();
+    }
+  }
+  if (opts.dirs.length === 0 && !opts.url) usage();
+  if (opts.dirs.length > 0 && opts.url) {
+    process.stderr.write("provide either --in or --url, not both\n");
+    usage();
+  }
+  return opts;
+}
+
+// ---------------------------------------------------------------------------
+// Manifest loading
+// ---------------------------------------------------------------------------
+
+// Fetch the bundle bytes: http(s) URL via global fetch, otherwise a local path.
+async function readBundleAsync(urlOrPath) {
+  if (/^https?:\/\//.test(urlOrPath)) {
+    const res = await fetch(urlOrPath);
+    if (!res.ok) {
+      throw new Error(
+        `Could not fetch bundle from ${urlOrPath} - response status: ${res.status}`,
+      );
+    }
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  return new Uint8Array(readFileSync(urlOrPath));
+}
+
+// Gunzip when the buffer carries the gzip magic (0x1F 0x8B); otherwise assume
+// it is already a plain tar (mirrors src/core/gzipBundle.js).
+function maybeGunzip(bytes) {
+  if (bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b) {
+    return new Uint8Array(gunzipSync(bytes));
+  }
+  return bytes;
+}
+
+// Minimal POSIX/ustar tar reader: walk 512-byte records, read the file name
+// (bytes 0-99, NUL-terminated) and octal size (bytes 124-135), yield each
+// regular file's name and bytes. Stops at the terminating zero block. Only the
+// `types/vtk*.json` entries are needed, so exotic long-name/pax records (never
+// used for these short paths) are skipped as non-regular entries.
+function* readTar(buf) {
+  const decoder = new TextDecoder();
+  const readStr = (off, len) => {
+    let end = off;
+    while (end < off + len && buf[end] !== 0) end++;
+    return decoder.decode(buf.subarray(off, end));
+  };
+  let pos = 0;
+  while (pos + 512 <= buf.length) {
+    // A block of all zero bytes marks end-of-archive.
+    let allZero = true;
+    for (let i = 0; i < 512; i++) {
+      if (buf[pos + i] !== 0) {
+        allZero = false;
+        break;
+      }
+    }
+    if (allZero) break;
+
+    const name = readStr(pos, 100);
+    const sizeStr = readStr(pos + 124, 12).trim();
+    const size = parseInt(sizeStr, 8) || 0;
+    const typeFlag = buf[pos + 156];
+    const dataStart = pos + 512;
+    // Regular file: type flag '0' (0x30) or NUL (older tars).
+    if (typeFlag === 0x30 || typeFlag === 0) {
+      yield { name, data: buf.subarray(dataStart, dataStart + size) };
+    }
+    // Advance past the data, padded up to the next 512-byte boundary.
+    pos = dataStart + Math.ceil(size / 512) * 512;
+  }
+}
+
+// Pull the `types/vtk*.json` manifests out of a (possibly gzipped) tar bundle.
+function manifestsFromBundle(bytes) {
+  const decoder = new TextDecoder();
+  const byTitle = new Map();
+  for (const { name, data } of readTar(maybeGunzip(bytes))) {
+    if (!/(?:^|\/)types\/vtk[^/]+\.json$/.test(name.replace(/^\.\//, ""))) {
+      continue;
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(decoder.decode(data));
+    } catch {
+      process.stderr.write(`skipping ${name}: invalid JSON\n`);
+      continue;
+    }
+    if (!manifest.title) {
+      process.stderr.write(`skipping ${name}: no "title"\n`);
+      continue;
+    }
+    byTitle.set(manifest.title, manifest);
+  }
+  return byTitle;
+}
+
+// Read already-unpacked manifests from local directories.
+function manifestsFromDirs(dirs) {
+  const byTitle = new Map();
+  for (const dir of dirs) {
+    for (const name of readdirSync(dir)) {
+      if (!name.endsWith(".json")) continue;
+      const manifest = JSON.parse(readFileSync(join(dir, name), "utf8"));
+      if (!manifest.title) {
+        process.stderr.write(`skipping ${name}: no "title"\n`);
+        continue;
+      }
+      byTitle.set(manifest.title, manifest);
+    }
+  }
+  return byTitle;
+}
+
+// ---------------------------------------------------------------------------
+// Declaration emission
+// ---------------------------------------------------------------------------
+
+// First-letter lowercase — mirrors toJsName() in src/core/javaScriptCxxTranslators.js
+function toJsName(cxxName) {
+  return cxxName.charAt(0).toLowerCase() + cxxName.slice(1);
+}
+
+// Note: every non-identifier parameter name maps to "arg", so two such
+// parameters in one signature would collide. Not observed in any manifest.
+function safeParam(name) {
+  let p = name;
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(p)) p = "arg";
+  if (RESERVED.has(p)) p = `${p}_`;
+  return p;
+}
+
+function createTypeResolver(generatedNames) {
+  // When the manifest set contains vtkObject (any real VTK build), the
+  // generated interface is the true runtime shape and is the fallback for
+  // unresolved $refs; the hand-written base alias covers sparse manifest sets.
+  const fallback = generatedNames.has("vtkObject")
+    ? "vtkObject"
+    : "VtkObjectProxyBase";
+  // Concrete numeric `type` values emitted by VTK's serdes manifest. The
+  // manifest is architecture-specific: word-width C types (long, size_t,
+  // vtkIdType) are already baked to a concrete width by the VTK build (int32 on
+  // wasm32, int64 on wasm64), so no per-target resolution is needed here.
+  // JS Numbers hold every integer up to 2^53 exactly, so anything that fits in
+  // 32 bits (or an IEEE-754 float) maps to `number`; 64-bit integers exceed
+  // that range and map to `bigint`.
+  const NUMERIC = new Map([
+    ["Int8", "number"],
+    ["Int16", "number"],
+    ["Int32", "number"],
+    ["UInt8", "number"],
+    ["UInt16", "number"],
+    ["UInt32", "number"],
+    ["Float32", "number"],
+    ["Float64", "number"],
+    ["Int64", "bigint"],
+    ["UInt64", "bigint"],
+  ]);
+  // Resolve a class name to the interface that represents it.
+  function resolveClass(name) {
+    if (generatedNames.has(name)) return name;
+    return fallback; // covers base names and not-yet-generated refs
+  }
+  // Map a JSON-Schema fragment to a TypeScript type.
+  // `asReturn` makes the `null` type render as `void` (for Promise<void>).
+  function tsType(schema, asReturn = false) {
+    if (!schema) return "any";
+    if (schema.$ref) return resolveClass(schema.$ref);
+    if (NUMERIC.has(schema.type)) return NUMERIC.get(schema.type);
+    switch (schema.type) {
+      case "boolean":
+        return "boolean";
+      case "integer":
+      case "number":
+        return "number";
+      case "string":
+        return "string";
+      case "array":
+        return `${tsType(schema.items)}[]`;
+      case "object":
+        return fallback;
+      case "null":
+        return asReturn ? "void" : "null";
+      default:
+        return "any";
+    }
+  }
+  // Type for a parameter or settable-property position. Class references
+  // become nominal `VtkRef<"name">` handles (accepting any subclass via its
+  // `$brands` chain) because overload collapse makes subclasses structurally
+  // incompatible with their bases; everything else falls through to tsType.
+  function tsRefType(schema) {
+    if (schema?.$ref && generatedNames.has(schema.$ref)) {
+      return `VtkRef<${JSON.stringify(schema.$ref)}>`;
+    }
+    if (schema?.type === "array") {
+      return `${tsRefType(schema.items)}[]`;
+    }
+    return tsType(schema);
+  }
+  return { tsType, tsRefType };
+}
+
+// Precompute, per class, its own members (by JS name) and the union of member
+// names declared by its in-set ancestors — the inputs to the Omit computation.
+function buildMemberIndex(byTitle, names) {
+  const own = new Map();
+  for (const [title, manifest] of byTitle) {
+    const parent =
+      manifest.inherits && names.has(manifest.inherits)
+        ? manifest.inherits
+        : null; // missing or out-of-set parent → treat as root
+    const props = new Map();
+    for (const [cxxName, schema] of Object.entries(manifest.properties || {})) {
+      props.set(toJsName(cxxName), schema);
+    }
+    const methods = new Map();
+    for (const [cxxName, method] of Object.entries(manifest.methods || {})) {
+      const js = toJsName(cxxName);
+      // The proxy resolves plumbing first, then property getters, then
+      // synthesizes a method — so a method shadowed by either never runs.
+      if (PLUMBING.has(js) || props.has(js)) continue;
+      methods.set(js, method);
+    }
+    const mainNames = new Set(methods.keys());
+    for (const name of props.keys()) {
+      if (!PLUMBING.has(name)) mainNames.add(name);
+    }
+    own.set(title, { parent, props, methods, mainNames });
+  }
+
+  function makeInheritedLookup(pick) {
+    const cache = new Map();
+    function lookup(title, visiting = new Set()) {
+      if (cache.has(title)) return cache.get(title);
+      if (visiting.has(title)) {
+        process.stderr.write(`inheritance cycle at ${title}; treating as root\n`);
+        return new Set();
+      }
+      visiting.add(title);
+      const out = new Set();
+      const { parent } = own.get(title);
+      if (parent) {
+        for (const n of lookup(parent, visiting)) out.add(n);
+        for (const n of pick(own.get(parent))) out.add(n);
+      }
+      visiting.delete(title);
+      cache.set(title, out);
+      return out;
+    }
+    return lookup;
+  }
+
+  // In-set ancestor chain (root first, self last) — the `$brands` set that
+  // makes nominal VtkRef assignability mirror the C++ is-a relationship.
+  const chainCache = new Map();
+  function brandChain(title, visiting = new Set()) {
+    if (chainCache.has(title)) return chainCache.get(title);
+    if (visiting.has(title)) return [title]; // cycle already warned above
+    visiting.add(title);
+    const { parent } = own.get(title);
+    const chain = parent ? [...brandChain(parent, visiting), title] : [title];
+    visiting.delete(title);
+    chainCache.set(title, chain);
+    return chain;
+  }
+
+  return {
+    get: (title) => own.get(title),
+    inheritedMainNames: makeInheritedLookup((entry) => entry.mainNames),
+    inheritedPropNames: makeInheritedLookup((entry) => entry.props.keys()),
+    brandChain,
+  };
+}
+
+function emitClass(title, index, { tsType, tsRefType }) {
+  const { parent, props, methods, mainNames } = index.get(title);
+  const q = (n) => JSON.stringify(n);
+  const withOmit = (base, keys) =>
+    keys.length ? `Omit<${base}, ${keys.map(q).join(" | ")}>` : base;
+
+  const lines = [];
+
+  // Data properties interface (drives the `vtk.vtkXxx(args)` Partial). Kept
+  // complete — plumbing-colliding names are still settable through the
+  // constructor args, which go through wasm.set rather than the proxy.
+  const inheritedProps = index.inheritedPropNames(title);
+  const propOmits = [...props.keys()]
+    .filter((n) => inheritedProps.has(n))
+    .sort();
+  const propsParent = parent
+    ? `${parent}Properties`
+    : "VtkObjectPropertiesBase";
+  lines.push(
+    `export interface ${title}Properties extends ${withOmit(propsParent, propOmits)} {`,
+  );
+  for (const [js, schema] of props) {
+    const ro = schema.readOnly ? "readonly " : "";
+    // Write position (constructor args / $set): class-typed values accept any
+    // subclass through the nominal VtkRef handle.
+    lines.push(`  ${ro}${js}: ${tsRefType(schema)};`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+
+  // The proxy interface: single parent, own properties inlined (minus
+  // plumbing-shadowed ones), own methods appended. Any inherited name this
+  // class redeclares is Omitted from the parent so the redeclaration replaces
+  // it instead of being signature-compared against it.
+  const inheritedMain = index.inheritedMainNames(title);
+  const mainOmits = [...mainNames].filter((n) => inheritedMain.has(n)).sort();
+  const mainParent = parent ?? "VtkObjectProxyBase";
+  lines.push(
+    `export interface ${title} extends ${withOmit(mainParent, mainOmits)} {`,
+  );
+  // Phantom nominal brand: the full in-set ancestor chain. Never exists at
+  // runtime — proxies only reach consumers through generated signatures, so
+  // nothing ever has to construct it. A child's wider brand set is assignable
+  // to its parent's, so no Omit is needed for it.
+  const brands = index
+    .brandChain(title)
+    .map((n) => `${n}: true`)
+    .join("; ");
+  lines.push(`  readonly $brands: { ${brands} };`);
+  for (const [js, schema] of props) {
+    if (PLUMBING.has(js)) continue; // unreachable through the proxy
+    const ro = schema.readOnly ? "readonly " : "";
+    lines.push(`  ${ro}${js}: ${tsType(schema)};`);
+  }
+  for (const [js, method] of methods) {
+    const params = Object.entries(method.parameters || {})
+      .map(([pName, pSchema]) => `${safeParam(pName)}: ${tsRefType(pSchema)}`)
+      .join(", ");
+    const ret = tsType(method.returns, true);
+    // Only methods flagged `maySuspend` in the manifest suspend (WebGPU/JSPI
+    // await) and are dispatched through the Promise-returning invokeAsync
+    // binding; all others resolve synchronously and return T directly.
+    const retType = method.maySuspend ? `Promise<${ret}>` : ret;
+    lines.push(`  ${js}(${params}): ${retType};`);
+  }
+  lines.push(`}`);
+
+  return lines.join("\n");
+}
+
+function generate(byTitle) {
+  const names = new Set(byTitle.keys());
+  const resolver = createTypeResolver(names);
+  const index = buildMemberIndex(byTitle, names);
+  // Stable, deterministic output order.
+  const titles = [...names].sort();
+
+  // Module-augmentation output: `declare module "@kitware/vtk-wasm"` merges the
+  // per-class interfaces and the concrete `vtk.vtkXxx(...)` constructor
+  // signatures into the open interfaces hand-declared in types/base.d.ts.
+  // Names used inside the augmentation do NOT resolve against the target
+  // module's exports — they resolve against the generated file's scope — so the
+  // roots (VtkObjectProxyBase, VtkObjectPropertiesBase) and VtkRef must be
+  // imported explicitly. (An unresolved name there would silently become `any`
+  // in consumer projects with `skipLibCheck: true`, defeating all checking.)
+  const header = [
+    "// AUTO-GENERATED by `vtk-wasm gen-types` — DO NOT EDIT BY HAND.",
+    "// Regenerate against the same VTK.wasm bundle your app loads:",
+    "//   npx vtk-wasm gen-types --url <bundle .tar.gz> --out <this file>",
+    "// Ensure this file is included by your tsconfig `include`.",
+    "",
+    "import type {",
+    "  VtkRef,",
+    "  VtkObjectProxyBase,",
+    "  VtkObjectPropertiesBase,",
+    '} from "@kitware/vtk-wasm";',
+    "",
+    'declare module "@kitware/vtk-wasm" {',
+  ];
+
+  const blocks = titles.map((t) => emitClass(t, index, resolver));
+
+  const ns = [];
+  ns.push(
+    "/** The `vtk` namespace proxy: each method instantiates a VTK object. */",
+  );
+  ns.push("interface VtkNamespace {");
+  for (const t of titles) {
+    ns.push(`  ${t}(args?: Partial<${t}Properties>): ${t};`);
+  }
+  ns.push("}");
+
+  const body = `${blocks.join("\n\n")}\n\n${ns.join("\n")}`;
+  return `${header.join("\n")}\n${body}\n}\n`;
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const byTitle = opts.url
+    ? manifestsFromBundle(await readBundleAsync(opts.url))
+    : manifestsFromDirs(opts.dirs);
+
+  if (byTitle.size === 0) {
+    process.stderr.write(
+      `No vtk*.json manifests found in ${opts.url ?? opts.dirs.join(", ")}\n`,
+    );
+    process.exit(1);
+  }
+
+  writeFileSync(opts.out, generate(byTitle));
+  process.stdout.write(
+    `Generated types for ${byTitle.size} class(es) -> ${opts.out}\n` +
+      `Ensure this file is included by your tsconfig "include".\n`,
+  );
+}
+
+main().catch((err) => {
+  process.stderr.write(`${err?.stack || err}\n`);
+  process.exit(1);
+});
diff --git a/docs/.vitepress/config.mjs b/docs/.vitepress/config.mjs
index 66f5574..306b9de 100644
--- a/docs/.vitepress/config.mjs
+++ b/docs/.vitepress/config.mjs
@@ -89,97 +89,103 @@ export default withMermaid(defineConfig({
        function gtag(){dataLayer.push(arguments);}
        gtag('js', new Date());
        gtag('config', 'G-LLSX9WG6YK');`,
+      ],
+      // [
+      //   'script',
+      //   { defer: '', src: 'js/hero.js' }
+      // ]
     ],
-    // [
-    //   'script',
-    //   { defer: '', src: 'js/hero.js' }
-    // ]
-  ],
-  themeConfig: {
-    // https://vitepress.dev/reference/default-theme-config
-    logo: "/logo.svg",
-    siteTitle: false,
-    nav: [
-      { text: "Home", link: "/" },
-      { text: "News", link: "/news" },
-      { text: "API", link: "/api/" },
-      { text: "Guides", link: "/guide/" },
-      { text: "Roadmap",
-        items: [
-          { text: "Overview", link: "/roadmap/" },
-          { text: "Module Availability", link: "/roadmap/modules" },
-        ]
-      },
-      // { text: 'Use Cases', link: '/usecase/' },
-      {
-        text: "Resources",
-        items: [
-          // { text: 'Documentation', link: 'https://docs.paraview.org/en/latest/Catalyst/index.html' },
-          { text: "Blogs", link: "https://www.kitware.com/blog/" },
-          // { text: 'Discussions', link: 'https://discourse.paraview.org/c/in-situ-support' },
-          {
-            text: "Issue Tracker",
-            link: "https://gitlab.kitware.com/groups/vtk/-/issues",
-          },
-          { text: "Webinars", link: "https://www.kitware.com/webinars/" },
-          { text: "Services", link: "https://www.kitware.com/support" },
-        ],
-      },
-    ],
-
-    sidebar: {
-      "/guide/": [
-        {
-          text: "Introduction",
-          items: [{ text: "Getting started", link: "/guide/" }],
-        },
-        {
-          text: "For C++ developers",
-          items: [
-            { text: "Getting started", link: "/guide/cpp/" },
-            { text: "Building VTK", link: "/guide/cpp/setup" },
-            { text: "Embind", link: "/guide/cpp/embind" },
-          ],
-        },
-        {
-          text: "For JavaScript developers",
-          items: [
-            { text: "Loading VTK.wasm", link: "/guide/js/loading" },
-            { text: "Standalone Session", link: "/guide/js/standalone-session" },
-            { text: "Primer on VTK.wasm", link: "/guide/js/primer" },
-            { text: "Remote Session", link: "/guide/js/remote-session" },
-            { text: "Adding VTK.wasm to a Project", link: "/guide/js/integration" },
-          ],
-        },
+    themeConfig: {
+      // https://vitepress.dev/reference/default-theme-config
+      logo: "/logo.svg",
+      siteTitle: false,
+      nav: [
+        { text: "Home", link: "/" },
+        { text: "News", link: "/news" },
+        { text: "API", link: "/api/" },
+        { text: "Guides", link: "/guide/" },
         {
-          text: "For trame users",
+          text: "Roadmap",
           items: [
-            { text: "Getting started", link: "/guide/trame/" },
-            { text: "3D Widgets", link: "/guide/trame/widget" },
-            { text: "Method call", link: "/guide/trame/picking" },
+            { text: "Overview", link: "/roadmap/" },
+            { text: "Module Availability", link: "/roadmap/modules" },
           ],
         },
+        // { text: 'Use Cases', link: '/usecase/' },
         {
-          text: "As a data viewer",
+          text: "Resources",
           items: [
-            { text: "Getting started", link: "/guide/viewer/" },
-            { text: "Generating data", link: "/guide/viewer/data" },
+            // { text: 'Documentation', link: 'https://docs.paraview.org/en/latest/Catalyst/index.html' },
+            { text: "Blogs", link: "https://www.kitware.com/blog/" },
+            // { text: 'Discussions', link: 'https://discourse.paraview.org/c/in-situ-support' },
+            {
+              text: "Issue Tracker",
+              link: "https://gitlab.kitware.com/groups/vtk/-/issues",
+            },
+            { text: "Webinars", link: "https://www.kitware.com/webinars/" },
+            { text: "Services", link: "https://www.kitware.com/support" },
           ],
         },
       ],
-      "/api/": [
-        { text: "API Reference", link: "/api/" },
-        ...apiSidebar,
-      ],
-      "/roadmap/": [
-        { text: "Overview", link: "/roadmap/" },
-        { text: "Module Availability", link: "/roadmap/modules" },
+
+      sidebar: {
+        "/guide/": [
+          {
+            text: "Introduction",
+            items: [{ text: "Getting started", link: "/guide/" }],
+          },
+          {
+            text: "For C++ developers",
+            items: [
+              { text: "Getting started", link: "/guide/cpp/" },
+              { text: "Building VTK", link: "/guide/cpp/setup" },
+              { text: "Embind", link: "/guide/cpp/embind" },
+            ],
+          },
+          {
+            text: "For JavaScript developers",
+            items: [
+              { text: "Loading VTK.wasm", link: "/guide/js/loading" },
+              {
+                text: "Standalone Session",
+                link: "/guide/js/standalone-session",
+              },
+              { text: "Primer on VTK.wasm", link: "/guide/js/primer" },
+              { text: "Remote Session", link: "/guide/js/remote-session" },
+              { text: "TypeScript types", link: "/guide/js/typescript" },
+              {
+                text: "Adding VTK.wasm to a Project",
+                link: "/guide/js/integration",
+              },
+            ],
+          },
+          {
+            text: "For trame users",
+            items: [
+              { text: "Getting started", link: "/guide/trame/" },
+              { text: "3D Widgets", link: "/guide/trame/widget" },
+              { text: "Method call", link: "/guide/trame/picking" },
+            ],
+          },
+          {
+            text: "As a data viewer",
+            items: [
+              { text: "Getting started", link: "/guide/viewer/" },
+              { text: "Generating data", link: "/guide/viewer/data" },
+            ],
+          },
+        ],
+        "/api/": [{ text: "API Reference", link: "/api/" }, ...apiSidebar],
+        "/roadmap/": [
+          { text: "Overview", link: "/roadmap/" },
+          { text: "Module Availability", link: "/roadmap/modules" },
+        ],
+        "/usecase/": [{ text: "Examples", link: "/usecase/index" }],
+      },
+
+      socialLinks: [
+        { icon: "github", link: "https://github.com/Kitware/vtk-wasm" },
       ],
-      "/usecase/": [{ text: "Examples", link: "/usecase/index" }],
     },
-
-    socialLinks: [
-      { icon: 'github', link: 'https://github.com/Kitware/vtk-wasm' }
-    ]
-  },
-}));
+  }),
+);
diff --git a/docs/guide/js/primer.md b/docs/guide/js/primer.md
index c09ddc5..20a315f 100644
--- a/docs/guide/js/primer.md
+++ b/docs/guide/js/primer.md
@@ -69,30 +69,30 @@ Once you have an object, inspection usually comes next. Use `toString()` to invo
 const camera = vtk.vtkCamera();
 // directly calls C++ vtkObject::Print()
 console.log(camera.toString());
-console.log(camera.state);
+console.log(camera.$state);
 // console.log("Camera proxy: ", camera.proxy);</pre>
 </Playground>
 
-The second `console.log` prints `camera.state` instead of `camera` because objects created through the `vtk` namespace are returned as JavaScript `Proxy` instances. In browser developer tools, the `state` property provides the most useful serialized view of that proxy.
+The second `console.log` prints `camera.$state` instead of `camera` because objects created through the `vtk` namespace are returned as JavaScript `Proxy` instances. In browser developer tools, the `$state` property provides the most useful serialized view of that proxy. Proxy plumbing members are `$`-prefixed so they never shadow a C++ property or method of the same name.
 
 The full proxy structure looks like this. Uncomment the last line to inspect it in the developer console:
 
 ```js
-Proxy(Object) {id: 1, obj: {…}, set: ƒ, observe: ƒ, toJSON: ƒ, …}
+Proxy(Object) {$id: 1, $obj: {…}, $set: ƒ, $observe: ƒ, toJSON: ƒ, …}
 [[Handler]] : Object
-    get : get(d,h,O){return d[h]!==void 0?d[h]:d.userData[h]!==void 0?d.userData[h]:h==="then"?O:h==="state"?e.get?V(e.get(n)):(e.updateStateFromObject(n),V(e.getState(n))):h==="delete"?a:l[h]?l[h]():(d[h]=async(...Ee)=> {…}
+    get : get(d,h,O){return d[h]!==void 0?d[h]:d.$userData[h]!==void 0?d.$userData[h]:h==="then"?O:h==="$state"?e.get?V(e.get(n)):(e.updateStateFromObject(n),V(e.getState(n))):h==="$delete"?a:l[h]?l[h]():(d[h]=async(...Ee)=> {…}
     set : ƒ set(d,h,O)
     [[Prototype]] : Object
 [[Target]] : Object
-    id : 1
-    obj : {Id: 1}
-    observe : ƒ p(d,h)
-    set : ƒ S(d)
+    $id : 1
+    $obj : {Id: 1}
+    $observe : ƒ p(d,h)
+    $set : ƒ S(d)
     toJSON : ƒ b()
     toString : ƒ u()
-    unObserve : ƒ c(d)
-    unObserveAll : ƒ o()
-    userData : {}
+    $unObserve : ƒ c(d)
+    $unObserveAll : ƒ o()
+    $userData : {}
     [[Prototype]] : Object
 [[IsRevoked]] : false
 ```
@@ -123,7 +123,7 @@ console.log("New position: ", camera.position);</pre>
 
 ## Call functions on objects
 
-Member functions are also accessed with `.` notation. These calls return `Promise` objects, so use `await` when you need the resolved result.
+Member functions are also accessed with `.` notation, using camelCase names. Most calls execute synchronously and return their result directly. Methods marked `[[vtk::maysuspend]]` in VTK (for example `renderWindow.render()` on WebGPU/JSPI builds) return a `Promise` instead — `await` them. Awaiting a synchronous result is harmless, so `await` is always safe. Method names are validated against the method manifests shipped in the `.tar.gz` bundle (or a hosted `vtk-methods.json`); calling an unknown name throws a `TypeError`.
 
 <Playground console-min-height=100px>
     <textarea data-lang="html" style="display:none"><!doctype html>
@@ -196,7 +196,7 @@ When an object is no longer needed, call `delete()` to release its external Java
 <pre data-lang="js" style="display:none">
 const vtk = await vtkwasm.ready;
 let actor = vtk.vtkActor();
-actor.delete();
+actor.$delete();
 // console.log(actor.toString()) // prints (null)
 actor = null;
 </pre>
@@ -222,9 +222,9 @@ VTK provides array classes for typed data exchange. These arrays accept JavaScri
 <pre data-lang="js" style="display:none">
 const vtk = await vtkwasm.ready;
 const coordinates = vtk.vtkTypeFloat64Array();
-coordinates.number_of_components = 3;
-await coordinates.SetArray(new Float64Array([-1, -1, 0, 1, -1, 0]));
-console.log(await coordinates.GetTuple1(0));
+coordinates.numberOfComponents = 3;
+coordinates.setArray(new Float64Array([-1, -1, 0, 1, -1, 0]));
+console.log(coordinates.getTuple1(0));
 </pre>
 </Playground>
 
@@ -255,7 +255,7 @@ console.log(`Part name: ${actor.partName}`);
 
 ## Observers
 
-For interactive workflows, register event handlers with `observe()`. Remove a handler later by passing its returned tag to `object.unObserve()`.
+For interactive workflows, register event handlers with `$observe()`. Remove a handler later by passing its returned tag to `object.$unObserve()`.
 
 <Playground>
     <textarea data-lang="html" style="display:none"><!doctype html>
@@ -273,11 +273,11 @@ For interactive workflows, register event handlers with `observe()`. Remove a ha
 <pre data-lang="js" style="display:none">
 const vtk = await vtkwasm.ready;
 const actor = vtk.vtkActor();
-const tag = actor.observe('ModifiedEvent', () => { console.log("Actor modified"); });
+const tag = actor.$observe('ModifiedEvent', () => { console.log("Actor modified"); });
 actor.visibility = false;
 actor.visibility = true;
 actor.visibility = false;
-actor.unObserve(tag);
+actor.$unObserve(tag);
 actor.visibility = true;
 </pre>
 </Playground>
diff --git a/docs/guide/js/remote-session.md b/docs/guide/js/remote-session.md
index 799daa4..8d7182a 100644
--- a/docs/guide/js/remote-session.md
+++ b/docs/guide/js/remote-session.md
@@ -189,14 +189,14 @@ Once synchronized, inspect objects locally without another round trip via [`getS
 
 The server owns the scene's object lifecycle, so a remote session **cannot create or destroy objects** from the client. The `remote.vtk` namespace exists only to *control existing* objects: use [`getVtkObject`](/api/@kitware/vtk-wasm/classes/RemoteSession#getvtkobject) (or `remote.vtk.getVtkObject(id)`) to obtain a proxy for an object the server already created.
 
-Calling a constructor such as `remote.vtk.vtkActor()` or `proxy.delete()` is a no-op: it logs a warning to the console and returns `undefined` / `false` rather than mutating the scene. To add or remove objects, do it on the server and pull the change in with [`update`](#drive-updates).
+Calling a constructor such as `remote.vtk.vtkActor()` or `proxy.$delete()` is a no-op: it logs a warning to the console and returns `undefined` / `false` rather than mutating the scene. To add or remove objects, do it on the server and pull the change in with [`update`](#drive-updates).
 
 ```js
 const actor = remote.getVtkObject(actorId); // ✅ control an existing object
 actor.visibility = false;
 
 remote.vtk.vtkActor();                       // ⚠️ warns, returns undefined
-actor.delete();                              // ⚠️ warns, returns false
+actor.$delete();                             // ⚠️ warns, returns false
 ```
 
 ## Cleaning up
diff --git a/docs/guide/js/typescript.md b/docs/guide/js/typescript.md
new file mode 100644
index 0000000..1b81619
--- /dev/null
+++ b/docs/guide/js/typescript.md
@@ -0,0 +1,91 @@
+# TypeScript types
+
+`@kitware/vtk-wasm` ships hand-written types for the runtime and session API
+(`loadAsync`, `StandaloneSession`, the proxy plumbing, ...). The per-class VTK
+surface — every `session.vtk.vtkXxx(...)` constructor and the methods and
+properties on the objects it returns — is **generated on demand** from the exact
+VTK.wasm bundle your app loads.
+
+## Why generate locally?
+
+The wrapper's npm version is independent of the VTK version, and the per-class
+serdes manifests (`types/*.json`) that describe the type surface ship _with the
+VTK.wasm binary_ — they vary by VTK version and by architecture (wasm32 vs
+wasm64). Bundling a single snapshot in the package would type the wrong VTK for
+most users. Instead, a CLI derives the types from the binary you actually use,
+so they always match — releases, nightlies, and custom builds alike.
+
+## Generate the declarations
+
+Point the `vtk-wasm gen-types` CLI at the same bundle you pass to
+[`loadAsync`](./loading.md):
+
+```bash
+npx vtk-wasm gen-types \
+  --url https://.../vtk-9.5.1-wasm32.tar.gz \
+  --out src/vtk-wasm.gen.d.ts
+```
+
+`--url` accepts a `.tar.gz` bundle as a local path or an `http(s)` URL. If you
+already have the manifests unpacked, use `--in <dir>` (repeatable) instead. The
+default `--out` is `./vtk-wasm.gen.d.ts`.
+
+Make sure the output file is picked up by your `tsconfig.json` `include` (a file
+under `src/` usually is). That is all — no imports or configuration at your call
+sites:
+
+```ts
+import { loadAsync } from "@kitware/vtk-wasm";
+
+const runtime = await loadAsync({ url: "/vtk-9.5.1-wasm32.tar.gz" });
+const session = runtime.createStandaloneSession();
+
+const cone = session.vtk.vtkConeSource({ resolution: 32 }); // typed vtkConeSource
+cone.update(0);
+const output = cone.getOutput(); // typed vtkPolyData
+```
+
+Only methods VTK marks `maySuspend` return a `Promise` (their generated
+signature is `Promise<T>`); every other proxy method returns synchronously, so
+no `await` is needed.
+
+The generated file is a
+[module augmentation](https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation)
+(`declare module "@kitware/vtk-wasm" { ... }`) that merges a precise signature
+for every VTK class in your bundle into the open `VtkNamespace` interface.
+
+## Fallback without generated types
+
+If you skip generation, everything still compiles: `VtkNamespace` carries a loose
+index signature, so `session.vtk.vtkAnything(...)` type-checks and returns the
+base `vtkObject` — with the proxy plumbing (`$id`, `$set`, `$observe`, ...) fully
+typed. You lose per-class property/method checking until you generate.
+
+## Architecture note
+
+The manifests are architecture-specific: word-width C++ types are already baked
+to a concrete width by the VTK build (32-bit integers → `number`; 64-bit
+integers → `bigint`). The CLI is arch-agnostic — it simply reflects whatever
+bundle you feed it. If you ship both wasm32 and wasm64, generate against your
+**primary** architecture; the two differ only where 64-bit integer types appear.
+
+## A note on C++ overloads
+
+VTK's C++ overloads collapse to a single surviving signature per class in the
+serdes manifest, and signature hiding means a subclass sometimes redeclares an
+inherited method with an incompatible signature — so a subclass (e.g.
+`vtkPolyDataMapper`) is not always _structurally_ assignable to its base (e.g.
+`vtkMapper`).
+
+The generated types mirror C++'s **nominal** typing instead: every interface
+carries a phantom `$brands` member listing its full ancestor chain, and every
+class-typed parameter or settable property is typed `VtkRef<"vtkMapper">` —
+"anything branded as a vtkMapper". Passing a `vtkPolyDataMapper` where a
+`vtkMapper` is expected therefore just works, with no casts and no `$set`
+detour, while passing an unrelated class (say, a `vtkRenderer`) is still a
+compile error. Return values keep the full structural interface, so
+autocomplete on results is unaffected. `$brands` never exists at runtime.
+
+One limit: _direct assignment_ to a class-typed property on the main interface
+(`actor.mapper = mapper`) is still checked structurally. Set such properties
+through the constructor (`vtk.vtkActor({ mapper })`) or `$set` instead.
diff --git a/examples/js/wave-app-ts/.gitignore b/examples/js/wave-app-ts/.gitignore
new file mode 100644
index 0000000..08c7c5c
--- /dev/null
+++ b/examples/js/wave-app-ts/.gitignore
@@ -0,0 +1,9 @@
+node_modules
+dist
+package-lock.json
+
+# Copied in by `npm run copy:bundle` (a local, absolute build artifact).
+public/*.tar.gz
+
+# Emitted by `npm run gen:types` against the bundle above.
+src/vtk-wasm.gen.d.ts
diff --git a/examples/js/wave-app-ts/README.md b/examples/js/wave-app-ts/README.md
new file mode 100644
index 0000000..6008089
--- /dev/null
+++ b/examples/js/wave-app-ts/README.md
@@ -0,0 +1,42 @@
+# wave-app-ts
+
+A TypeScript + Vite demo that animates a procedural water surface with VTK.wasm
+and shows the end-to-end typed-`session.vtk` developer experience.
+
+## What it demonstrates
+
+- `npm run gen:types` runs the `vtk-wasm gen-types` CLI against the exact
+  VTK.wasm bundle the app loads. It writes `src/vtk-wasm.gen.d.ts`, a
+  `declare module "@kitware/vtk-wasm"` augmentation that makes every
+  `session.vtk.vtkXxx(...)` call precisely typed.
+- `tsc --noEmit` (run as part of `npm run build`) is the acceptance check that
+  the typed scene code compiles against the generated declarations.
+- `src/main.ts` builds a 200×200 quad grid with `vtkPlaneSource`, replaces its
+  point positions, normals and scalars with arrays this app allocated, and
+  rewrites all three every frame through zero-copy `TypedArray` views onto the
+  wasm heap — no per-frame allocation, no copies, no pipeline re-execution.
+  Normals are the analytic heightfield gradient, so the surface shades smoothly
+  without re-running `vtkPolyDataNormals` on 40k points per frame.
+
+## Local bundle dependency
+
+This app is intentionally **not** wired into the repository's `build:examples`
+CI chain: it depends on a local, absolute path to a VTK.wasm build artifact.
+
+The tarball in `public/` is what Vite serves and what `gen:types` generates the
+declarations from. Point both at whatever VTK.wasm `.tar.gz` you have (update
+the path in `package.json` and the `BUNDLE_URL` in `src/main.ts`).
+
+## Run
+
+```bash
+npm install
+npm run dev      # generates types, starts Vite
+```
+
+Open the printed URL; the animated surface renders with a live point/quad/fps
+readout in the overlay. Drag to orbit, scroll to zoom.
+
+```bash
+npm run build    # generates types + tsc --noEmit + vite build
+```
diff --git a/examples/js/wave-app-ts/index.html b/examples/js/wave-app-ts/index.html
new file mode 100644
index 0000000..602b78a
--- /dev/null
+++ b/examples/js/wave-app-ts/index.html
@@ -0,0 +1,72 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>VTK.wasm TypeScript wave example</title>
+    <style>
+      html,
+      body {
+        margin: 0;
+        height: 100%;
+        background: #05070f;
+        color: #e8eef8;
+        font: 14px/1.45 system-ui, -apple-system, "Segoe UI", sans-serif;
+      }
+      #app {
+        position: relative;
+        width: 100vw;
+        height: 100vh;
+      }
+      #app > canvas {
+        width: 100%;
+        height: 100%;
+        display: block;
+      }
+      #overlay {
+        position: absolute;
+        top: 20px;
+        left: 20px;
+        max-width: 22rem;
+        padding: 14px 18px;
+        border: 1px solid rgba(255, 255, 255, 0.14);
+        border-radius: 10px;
+        background: rgba(6, 12, 26, 0.55);
+        backdrop-filter: blur(8px);
+        pointer-events: none;
+      }
+      #overlay h1 {
+        margin: 0 0 6px;
+        font-size: 15px;
+        font-weight: 600;
+        letter-spacing: 0.02em;
+      }
+      #overlay p {
+        margin: 0;
+        font-size: 12.5px;
+        color: rgba(232, 238, 248, 0.7);
+      }
+      #stats {
+        margin-top: 10px;
+        font-variant-numeric: tabular-nums;
+        font-size: 12.5px;
+        color: #7fd8e8;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="app">
+      <canvas tabindex="-1" onclick="focus()"></canvas>
+      <div id="overlay">
+        <h1>Procedural wave surface</h1>
+        <p>
+          VTK.wasm owns the mesh; JavaScript rewrites its point positions,
+          normals and scalars every frame through zero-copy views onto the wasm
+          heap. Drag to orbit, scroll to zoom.
+        </p>
+        <div id="stats">warming up…</div>
+      </div>
+    </div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/examples/js/wave-app-ts/package.json b/examples/js/wave-app-ts/package.json
new file mode 100644
index 0000000..b802628
--- /dev/null
+++ b/examples/js/wave-app-ts/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "wave-app-ts",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "gen:types": "npx vtk-wasm gen-types --url public/vtk-9.7.20260811-wasm32-emscripten.tar.gz --out src/vtk-wasm.gen.d.ts",
+    "prepare:types": "npm run gen:types",
+    "typecheck": "tsc --noEmit",
+    "predev": "npm run prepare:types",
+    "dev": "vite",
+    "prebuild": "npm run prepare:types",
+    "build": "npm run typecheck && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@kitware/vtk-wasm": "file:../../.."
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "vite": "^6.3.5"
+  }
+}
diff --git a/examples/js/wave-app-ts/src/main.ts b/examples/js/wave-app-ts/src/main.ts
new file mode 100644
index 0000000..33bac50
--- /dev/null
+++ b/examples/js/wave-app-ts/src/main.ts
@@ -0,0 +1,291 @@
+import { loadAsync } from "@kitware/vtk-wasm";
+
+// This app loads the VTK.wasm bundle it was typed against. `session.vtk` is
+// fully typed because `npm run gen:types` ran `vtk-wasm gen-types` against the
+// same tarball and emitted `src/vtk-wasm.gen.d.ts`, a module-augmentation file
+// that gives every `vtk.vtkXxx(...)` a precise signature. The generated types
+// also tell you which calls are asynchronous: only methods VTK marks
+// `maySuspend` return a Promise (and need `await`); every other method returns
+// its value synchronously.
+//
+// The scene is a procedural water surface: VTK owns the mesh, JavaScript owns
+// the vertex data. Every frame the point positions, normals and scalars are
+// rewritten in place through zero-copy TypedArray views onto the wasm heap —
+// no per-frame allocation, no copies, no pipeline re-execution.
+const BUNDLE_URL = "/vtk-9.7.20260811-wasm32-emscripten.tar.gz";
+const CANVAS_SELECTOR = "#app > canvas";
+
+/** Quads per side of the surface: (RESOLUTION + 1)^2 points. */
+const RESOLUTION = 200;
+/** The surface spans [-EXTENT, EXTENT] in x and y. */
+const EXTENT = 1;
+
+/** Height range the color map is stretched over. */
+const HEIGHT_RANGE = [-0.24, 0.24] as const;
+
+/**
+ * Wave field: two ripple sources orbiting the origin, a directional swell and
+ * a little high-frequency chop. Evaluated per point per frame, together with
+ * its analytic gradient — a heightfield's exact normal is
+ * `normalize(-dh/dx, -dh/dy, 1)`, which is both cheaper and smoother than
+ * re-running vtkPolyDataNormals on 40k points every frame.
+ */
+const RIPPLE_AMPLITUDE = 0.12;
+const RIPPLE_WAVE_NUMBER = 9.0;
+const RIPPLE_FREQUENCY = 3.0;
+const RIPPLE_DECAY = 1.1;
+const ORBIT_RADIUS = 0.55;
+/** Normalizes `r e^(-Dr)` (peak at r = 1/D) to RIPPLE_AMPLITUDE. */
+const RIPPLE_ENVELOPE_SCALE = RIPPLE_AMPLITUDE * RIPPLE_DECAY * Math.E;
+
+/** Scratch tuple for `evaluateWave`, reused so the loop allocates nothing. */
+const wave = { height: 0, slopeX: 0, slopeY: 0 };
+
+function evaluateWave(x: number, y: number, time: number): void {
+  let height = 0;
+  let slopeX = 0;
+  let slopeY = 0;
+
+  // Two ripple sources drifting in opposite directions.
+  for (let source = 0; source < 2; source++) {
+    const angularSpeed = source === 0 ? 0.7 : -0.5;
+    const phase = source === 0 ? 0 : Math.PI;
+    const centerX = ORBIT_RADIUS * Math.cos(angularSpeed * time + phase);
+    const centerY = ORBIT_RADIUS * Math.sin(angularSpeed * time + phase);
+
+    const dx = x - centerX;
+    const dy = y - centerY;
+    const distance = Math.hypot(dx, dy);
+    if (distance < 1e-5) {
+      continue; // The gradient is undefined at the source; it contributes none.
+    }
+
+    const argument = RIPPLE_WAVE_NUMBER * distance - RIPPLE_FREQUENCY * time;
+    // r e^(-Dr), scaled so its maximum is exactly RIPPLE_AMPLITUDE. Rising out
+    // of zero at the source keeps the rings smooth instead of spiking there.
+    const decay = Math.exp(-RIPPLE_DECAY * distance);
+    const envelope = RIPPLE_ENVELOPE_SCALE * distance * decay;
+    const sine = Math.sin(argument);
+    const cosine = Math.cos(argument);
+
+    height += envelope * sine;
+    // d/dr [ E(r) sin(Kr - wt) ] = E'(r) sin + E(r) K cos, with
+    // E'(r) = S e^(-Dr) (1 - Dr), and dr/dx = dx/r.
+    const derivative =
+      RIPPLE_ENVELOPE_SCALE * decay * (1 - RIPPLE_DECAY * distance);
+    const radial =
+      (derivative * sine + envelope * RIPPLE_WAVE_NUMBER * cosine) / distance;
+    slopeX += radial * dx;
+    slopeY += radial * dy;
+  }
+
+  // A slow directional swell.
+  const swell = Math.sin(2.4 * x + 1.6 * y - 1.2 * time);
+  const swellSlope = 0.07 * Math.cos(2.4 * x + 1.6 * y - 1.2 * time);
+  height += 0.07 * swell;
+  slopeX += 2.4 * swellSlope;
+  slopeY += 1.6 * swellSlope;
+
+  // Fine chop, to keep the specular highlights alive.
+  const chopSlope = 0.035 * Math.cos(6.1 * x - 4.7 * y + 1.9 * time);
+  height += 0.035 * Math.sin(6.1 * x - 4.7 * y + 1.9 * time);
+  slopeX += 6.1 * chopSlope;
+  slopeY += -4.7 * chopSlope;
+
+  wave.height = height;
+  wave.slopeX = slopeX;
+  wave.slopeY = slopeY;
+}
+
+async function main(): Promise<void> {
+  const runtime = await loadAsync({ url: BUNDLE_URL });
+  const session = runtime.createStandaloneSession();
+  const { vtk, typedArrayInterface } = session;
+
+  // vtkPlaneSource is typed: the constructor only accepts real vtkPlaneSource
+  // properties, and its methods are checked (note `update` takes a port index —
+  // the surviving overload from VTK's serdes manifest). The plane is used for
+  // its *topology* only: a regular grid of quads whose points this app then
+  // takes ownership of.
+  const plane = vtk.vtkPlaneSource({
+    xResolution: RESOLUTION,
+    yResolution: RESOLUTION,
+    origin: [-EXTENT, -EXTENT, 0],
+    point1: [EXTENT, -EXTENT, 0],
+    point2: [-EXTENT, EXTENT, 0],
+  });
+  plane.update(0);
+
+  const surface = plane.getOutput();
+  const pointCount = (RESOLUTION + 1) * (RESOLUTION + 1);
+
+  // Hand VTK three arrays this app allocated. `toVTKAoSArray` picks the VTK
+  // array class from the TypedArray's own type (Float32Array ->
+  // vtkTypeFloat32Array), copies the values onto the wasm heap and hands that
+  // allocation to VTK, which frees it with the array. Because the class is
+  // known statically, the views taken back out below are typed Float32Array
+  // rather than the untyped TypedArray union.
+  // Seeded at t = 0 so the polydata's bounds already cover the wave's full
+  // height when the camera is reset below.
+  const positions = new Float32Array(3 * pointCount);
+  for (let j = 0, index = 0; j <= RESOLUTION; j++) {
+    const y = -EXTENT + (2 * EXTENT * j) / RESOLUTION;
+    for (let i = 0; i <= RESOLUTION; i++, index += 3) {
+      const x = -EXTENT + (2 * EXTENT * i) / RESOLUTION;
+      evaluateWave(x, y, 0);
+      positions[index] = x;
+      positions[index + 1] = y;
+      positions[index + 2] = wave.height;
+    }
+  }
+  const positionArray = typedArrayInterface.toVTKAoSArray(positions, 3, "Points");
+  const normalArray = typedArrayInterface.toVTKAoSArray(
+    new Float32Array(3 * pointCount),
+    3,
+    "Normals"
+  );
+  const heightArray = typedArrayInterface.toVTKAoSArray(
+    new Float32Array(pointCount),
+    1,
+    "Height"
+  );
+
+  // Replacing the points' data array keeps the plane's quads and swaps in
+  // memory this app can address directly.
+  surface.points.setData(positionArray);
+  surface.pointData.setNormals(normalArray);
+  surface.pointData.setScalars(heightArray);
+
+  // Deep water -> foam. Lab interpolation keeps the ramp perceptually even.
+  const colorMap = vtk.vtkColorTransferFunction();
+  colorMap.setColorSpaceToLab();
+  colorMap.addRGBPoint(-0.24, 0.02, 0.09, 0.26);
+  colorMap.addRGBPoint(-0.08, 0.05, 0.32, 0.56);
+  colorMap.addRGBPoint(0.04, 0.11, 0.62, 0.7);
+  colorMap.addRGBPoint(0.14, 0.53, 0.85, 0.72);
+  colorMap.addRGBPoint(0.24, 0.97, 0.96, 0.86);
+
+  // `setInputData` rather than `setInputConnection`: the pipeline has already
+  // produced its geometry, and nothing downstream should re-execute when the
+  // vertex data changes underneath it.
+  const mapper = vtk.vtkPolyDataMapper();
+  mapper.setInputData(surface);
+  mapper.setLookupTable(colorMap);
+  mapper.setScalarRange(HEIGHT_RANGE[0], HEIGHT_RANGE[1]);
+  mapper.setScalarModeToUsePointData();
+  mapper.scalarVisibilityOn();
+
+  const property = vtk.vtkProperty();
+  property.setInterpolationToPhong();
+  property.setAmbient(0.15);
+  property.setDiffuse(0.75);
+  property.setSpecular(0.55);
+  property.setSpecularPower(45);
+
+  // Class-typed constructor properties and method parameters are nominal
+  // `VtkRef<"...">` handles checked against the generated `$brands` ancestor
+  // chain — the C++ is-a relationship — so a vtkPolyDataMapper is a valid
+  // `mapper` and a vtkActor a valid `addActor` argument, no casts needed.
+  const actor = vtk.vtkActor({ mapper, property });
+
+  const renderer = vtk.vtkRenderer({
+    background: [0.02, 0.03, 0.08],
+    background2: [0.09, 0.13, 0.25],
+    gradientBackground: true,
+    twoSidedLighting: 1,
+  });
+  renderer.addActor(actor);
+
+  // Two scene lights (world coordinates, `lightType` 3): a warm key from the
+  // upper right and a cool fill from behind, so the crests read as water.
+  renderer.addLight(
+    vtk.vtkLight({
+      lightType: 3,
+      position: [2.2, -2.6, 3.2],
+      focalPoint: [0, 0, 0],
+      diffuseColor: [1.0, 0.95, 0.87],
+      specularColor: [1.0, 0.98, 0.92],
+      intensity: 1.0,
+    })
+  );
+  renderer.addLight(
+    vtk.vtkLight({
+      lightType: 3,
+      position: [-2.4, 2.2, 1.4],
+      focalPoint: [0, 0, 0],
+      diffuseColor: [0.42, 0.6, 0.95],
+      specularColor: [0.5, 0.7, 1.0],
+      intensity: 0.45,
+    })
+  );
+
+  const camera = renderer.getActiveCamera();
+  camera.setPosition(0, -2.9, 2.0);
+  camera.setFocalPoint(0, 0, 0);
+  camera.setViewUp(0, 0, 1);
+  renderer.resetCamera();
+  camera.zoom(1.25);
+
+  // Construct the concrete WASM render-window/interactor classes directly:
+  // unlike the generic vtkRenderWindow/vtkRenderWindowInteractor interfaces,
+  // they carry the `canvasSelector` property that binds them to the canvas.
+  const renderWindow = vtk.vtkWebAssemblyOpenGLRenderWindow({
+    canvasSelector: CANVAS_SELECTOR,
+  });
+  renderWindow.addRenderer(renderer);
+
+  const interactor = vtk.vtkWebAssemblyRenderWindowInteractor({
+    renderWindow,
+    canvasSelector: CANVAS_SELECTOR,
+  });
+  interactor.start();
+
+  const statsElement = document.querySelector<HTMLElement>("#stats");
+  let frames = 0;
+  let lastReport = performance.now();
+  const startTime = performance.now();
+
+  function animate(): void {
+    const time = (performance.now() - startTime) / 1000;
+
+    // Views alias the wasm heap and are invalidated whenever it grows, so take
+    // fresh ones per frame instead of caching them across renders.
+    const positionView = typedArrayInterface.toJSTypedArray(positionArray);
+    const normalView = typedArrayInterface.toJSTypedArray(normalArray);
+    const heightView = typedArrayInterface.toJSTypedArray(heightArray);
+
+    for (let point = 0, index = 0; point < pointCount; point++, index += 3) {
+      evaluateWave(positionView[index], positionView[index + 1], time);
+      positionView[index + 2] = wave.height;
+      heightView[point] = wave.height;
+
+      const length = Math.hypot(wave.slopeX, wave.slopeY, 1);
+      normalView[index] = -wave.slopeX / length;
+      normalView[index + 1] = -wave.slopeY / length;
+      normalView[index + 2] = 1 / length;
+    }
+
+    // Writes through a view are invisible to VTK until the array says so; the
+    // mapper re-uploads its VBO because the points' MTime moved.
+    positionArray.modified();
+    normalArray.modified();
+    heightArray.modified();
+    renderWindow.render();
+
+    frames++;
+    const now = performance.now();
+    if (statsElement && now - lastReport >= 500) {
+      const fps = (frames * 1000) / (now - lastReport);
+      statsElement.textContent =
+        `${pointCount.toLocaleString()} points · ` +
+        `${(RESOLUTION * RESOLUTION).toLocaleString()} quads · ` +
+        `${fps.toFixed(0)} fps`;
+      frames = 0;
+      lastReport = now;
+    }
+    requestAnimationFrame(animate);
+  }
+  requestAnimationFrame(animate);
+}
+
+main().catch((err) => console.error(err));
diff --git a/examples/js/wave-app-ts/tsconfig.json b/examples/js/wave-app-ts/tsconfig.json
new file mode 100644
index 0000000..351e17c
--- /dev/null
+++ b/examples/js/wave-app-ts/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": []
+  },
+  "include": ["src"]
+}
diff --git a/examples/trame/widget/clip_rendering.py b/examples/trame/widget/clip_rendering.py
index 465e174..3093d75 100644
--- a/examples/trame/widget/clip_rendering.py
+++ b/examples/trame/widget/clip_rendering.py
@@ -105,12 +105,12 @@ def _build_ui(self):
                 function setupWidget() {{
                     const widget = trame.refs.{self.ctx.wasm_view.ref_name}.getVtkObject({self.ctx.wasm_view.register_vtk_object(self.widget)});
                     const plane = trame.refs.{self.ctx.wasm_view.ref_name}.getVtkObject({self.ctx.wasm_view.register_vtk_object(self.plane)});
-                    widget.observe("InteractionEvent", () => {{
+                    widget.$observe("InteractionEvent", () => {{
                         plane.origin = widget.widgetRepresentation.origin;
                         plane.normal = widget.widgetRepresentation.normal;
                     }});
-                    console.log("widget", widget.id);
-                    console.log("plane", plane.id);
+                    console.log("widget", widget.$id);
+                    console.log("plane", plane.$id);
                 }}
                 window.setupWidget = setupWidget;
             """)
diff --git a/package-lock.json b/package-lock.json
index c380771..d123b66 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -27,6 +27,7 @@
         "typedoc": "^0.28.19",
         "typedoc-plugin-markdown": "^4.12.0",
         "typedoc-vitepress-theme": "^1.1.3",
+        "typescript": "^6.0.3",
         "vite": "^6.2.4",
         "vitepress": "^1.6.3",
         "vitepress-plugin-mermaid": "^2.0.17"
@@ -10519,7 +10520,6 @@
       "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/package.json b/package.json
index da794f6..78b0ce8 100644
--- a/package.json
+++ b/package.json
@@ -1,5 +1,6 @@
 {
   "name": "@kitware/vtk-wasm",
+  "type": "module",
   "version": "0.0.0",
   "description": "A WebAssembly port of the VTK library",
   "license": "Apache-2.0",
@@ -46,19 +47,35 @@
     "rimraf": "^6.0.1",
     "semantic-release": "25.0.2",
     "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
     "typedoc-plugin-markdown": "^4.12.0",
     "typedoc-vitepress-theme": "^1.1.3",
     "vite": "^6.2.4",
     "vitepress": "^1.6.3",
     "vitepress-plugin-mermaid": "^2.0.17"
   },
+  "types": "./types/index.d.ts",
+  "bin": {
+    "vtk-wasm": "bin/vtk-wasm.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
   "files": [
-    "dist/**/*"
+    "dist/**/*",
+    "types/**/*",
+    "bin/**"
   ],
   "exports": {
-    ".": "./dist/esm/index.mjs",
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/esm/index.mjs"
+    },
     "./style.css": "./dist/esm/vtk-wasm.css",
-    "./viewer": "./dist/esm/viewer.mjs",
+    "./viewer": {
+      "types": "./types/viewer.d.ts",
+      "default": "./dist/esm/viewer.mjs"
+    },
     "./viewer-umd.js": "./dist/umd/viewer.umd.js",
     "./vtk-umd.js": "./dist/umd/vtk.umd.js",
     "./viewer.css": "./dist/umd/viewer.css",
diff --git a/src/core/gzipBundle.js b/src/core/gzipBundle.js
index 10726ef..d80028b 100644
--- a/src/core/gzipBundle.js
+++ b/src/core/gzipBundle.js
@@ -30,11 +30,14 @@ export async function fetchGzipBundleAsync(url) {
 }
 
 /**
- * Extract the JavaScript and WebAssembly files from gzip bundle.
- * @param {ArrayBuffer} contents 
- * @param {object} config 
- * @param {string} wasmBaseName 
- * @returns {Promise<{js: {name: string, buffer: ArrayBufferLike}, wasm: {name: string, buffer: ArrayBufferLike}}>}
+ * Extract the JavaScript and WebAssembly files from gzip bundle, along with
+ * the per-class serdes manifests (`types/<vtkClass>.json`) when the bundle
+ * ships them. Manifests are returned as raw JSON text keyed by class name;
+ * they are parsed lazily by the method table.
+ * @param {ArrayBuffer} contents
+ * @param {object} config
+ * @param {string} wasmBaseName
+ * @returns {Promise<{js: {name: string, buffer: ArrayBufferLike}, wasm: {name: string, buffer: ArrayBufferLike}, manifests: Map<string, string> | null}>}
  */
 export async function extractFilesFromGzipBundleAsync(contents, config, wasmBaseName) {
   const files = await untar(contents);
@@ -49,8 +52,15 @@ export async function extractFilesFromGzipBundleAsync(contents, config, wasmBase
     const jsFile = files.find((file) => stripLeadingDotSlash(file.name) === jsFileMatch);
     const wasmFile = files.find((file) => stripLeadingDotSlash(file.name) === wasmFileMatch);
     if (jsFile !== undefined && wasmFile !== undefined) {
-      return { js: jsFile, wasm: wasmFile };
+      const decoder = new TextDecoder();
+      const manifests = new Map();
+      for (const file of files) {
+        const match = stripLeadingDotSlash(file.name).match(/(?:^|\/)types\/(vtk[^/]+)\.json$/);
+        if (match) {
+          manifests.set(match[1], decoder.decode(file.buffer));
+        }
+      }
+      return { js: jsFile, wasm: wasmFile, manifests: manifests.size > 0 ? manifests : null };
     }
   }
-  throw new Error(`Could not find expected wasm module files (any of ${tried.join(", ")}) in the gzip bundle`);
 }
diff --git a/src/core/methodTable.js b/src/core/methodTable.js
new file mode 100644
index 0000000..ea04cac
--- /dev/null
+++ b/src/core/methodTable.js
@@ -0,0 +1,125 @@
+import { toJsName } from "./javaScriptCxxTranslators";
+
+/**
+ * A method table resolves (className, jsMethodName) to the C++ method that the
+ * proxy may invoke, along with its `maySuspend` flag (methods hinted with
+ * `[[vtk::maysuspend]]` must be dispatched through the Promise-returning
+ * `invokeAsync` binding on JSPI-enabled builds).
+ *
+ * Two sources feed it:
+ *  - the per-class serdes manifests (`types/<vtkClass>.json`) shipped inside
+ *    the `.tar.gz` bundle, kept as raw strings and parsed lazily, and
+ *  - a merged index (`vtk-methods.json`) for loose-URL hosting where per-class
+ *    files cannot be read synchronously.
+ */
+
+/**
+ * Normalize one class's method info to `{ inherits, methods }` where
+ * `methods` maps camelCase JS names to `{ cxxName, maySuspend }`.
+ *
+ * Accepts either a full serdes manifest (`methods` values are schema objects
+ * with an optional `maySuspend` flag) or a merged-index entry (`methods`
+ * values are `0`/`1`).
+ */
+function normalizeEntry(entry) {
+  const methods = new Map();
+  for (const [cxxName, value] of Object.entries(entry.methods ?? {})) {
+    const maySuspend =
+      typeof value === "object" && value !== null
+        ? Boolean(value.maySuspend)
+        : Boolean(value);
+    methods.set(toJsName(cxxName), { cxxName, maySuspend });
+  }
+  return { inherits: entry.inherits || null, methods };
+}
+
+/**
+ * @param {(className: string) => object | null} getEntry - returns the raw
+ *        manifest / merged-index entry for a class, or null when unknown.
+ * @param {(className: string) => boolean} hasEntry
+ */
+function createTable(getEntry, hasEntry) {
+  const normalized = new Map();
+  function entryFor(className) {
+    if (!normalized.has(className)) {
+      const raw = getEntry(className);
+      normalized.set(className, raw ? normalizeEntry(raw) : null);
+    }
+    return normalized.get(className);
+  }
+
+  // className -> Map<jsName, {cxxName, maySuspend}> with inherited methods
+  // merged in (own declarations win over ancestors').
+  const resolved = new Map();
+  function methodsFor(className, visiting = new Set()) {
+    if (resolved.has(className)) {
+      return resolved.get(className);
+    }
+    if (visiting.has(className)) {
+      console.warn(`Inheritance cycle at ${className}; treating as root.`);
+      return new Map();
+    }
+    visiting.add(className);
+    const entry = entryFor(className);
+    const merged = new Map(
+      entry?.inherits ? methodsFor(entry.inherits, visiting) : undefined,
+    );
+    if (entry) {
+      for (const [jsName, method] of entry.methods) {
+        merged.set(jsName, method);
+      }
+    }
+    visiting.delete(className);
+    resolved.set(className, merged);
+    return merged;
+  }
+
+  return {
+    /** Whether the table knows anything about `className`. */
+    hasClass(className) {
+      return hasEntry(className);
+    },
+    /**
+     * @returns {{cxxName: string, maySuspend: boolean} | undefined} the method
+     *          named `jsName` on `className` or any of its ancestors.
+     */
+    lookup(className, jsName) {
+      return methodsFor(className).get(jsName);
+    },
+  };
+}
+
+/**
+ * Build a method table from per-class serdes manifests.
+ * @param {Map<string, string>} rawManifests - className -> raw JSON text of
+ *        `types/<className>.json`. Parsed lazily, one class at a time.
+ */
+export function createMethodTableFromManifests(rawManifests) {
+  return createTable(
+    (className) => {
+      const raw = rawManifests.get(className);
+      if (raw === undefined) {
+        return null;
+      }
+      try {
+        return JSON.parse(raw);
+      } catch (error) {
+        console.warn(`Could not parse manifest for ${className}:`, error);
+        return null;
+      }
+    },
+    (className) => rawManifests.has(className),
+  );
+}
+
+/**
+ * Build a method table from a merged index (`vtk-methods.json`):
+ * `{ className: { inherits?: string, methods: { CxxName: 0|1 } } }`.
+ * @param {object} index - the parsed JSON.
+ */
+export function createMethodTableFromMergedIndex(index) {
+  return createTable(
+    (className) => index[className] ?? null,
+    (className) => Object.hasOwn(index, className),
+  );
+}
diff --git a/src/core/proxy.js b/src/core/proxy.js
index e2ad4b2..e08de64 100644
--- a/src/core/proxy.js
+++ b/src/core/proxy.js
@@ -1,8 +1,7 @@
-import { toCxxName, toCxxKeys, toJsName, toJsKeys } from "./javaScriptCxxTranslators";
+import { toCxxKeys, toCxxName, toJsName, toJsKeys } from "./javaScriptCxxTranslators";
 
 
-export function createPropGetter(wasm, wrapMethods, vtkId) {
-  const fullState = wasm.get(vtkId);
+export function createPropGetter(wasm, wrapMethods, vtkId, fullState) {
   const getPropHandler = {};
   Object.keys(fullState).forEach((propName) => {
     // console.log("Prop key:", propName);
@@ -12,8 +11,7 @@ export function createPropGetter(wasm, wrapMethods, vtkId) {
   return getPropHandler;
 }
 
-function createPropSetter(wasm, wrapMethods, vtkId) {
-  const fullState = wasm.get(vtkId);
+function createPropSetter(wasm, wrapMethods, vtkId, fullState) {
   const setPropHandler = {};
   Object.keys(fullState).forEach((propName) => {
     setPropHandler[toJsName(propName)] = (value) =>
@@ -28,6 +26,7 @@ export function createVtkObjectProxy(
   idToRef,
   wrapMethods,
   vtkId,
+  methodTable,
 ) {
   // Reuse vtkProxy if already available
   if (idToRef.has(vtkId) && idToRef.get(vtkId).deref()) {
@@ -87,55 +86,98 @@ export function createVtkObjectProxy(
     return toJsKeys(wasm.get(vtkId));
   }
   // Extract properties and unCapitalize them & add setter
-  const propGetters = createPropGetter(wasm, wrapMethods, vtkId);
-  const propSetters = createPropSetter(wasm, wrapMethods, vtkId);
+  const fullState = wasm.get(vtkId);
+  const className = fullState?.ClassName;
+  const propGetters = createPropGetter(wasm, wrapMethods, vtkId, fullState);
+  const propSetters = createPropSetter(wasm, wrapMethods, vtkId, fullState);
 
-  // Create proxy for given vtk object
+  // Plumbing members are $-prefixed so they can never collide
+  // with C++ members ($ is not legal in C++ names);
+  // toJSON/toString stay unprefixed because JSON.stringify and string
+  // coercion look them up by exactly those names.
   const target = {
-    id: vtkId,
-    obj: { Id: vtkId },
-    set,
-    observe,
+    $id: vtkId,
+    $obj: { Id: vtkId },
+    $set: set,
+    $observe: observe,
     toJSON,
     toString,
-    unObserve,
-    unObserveAll,
-    userData: {},
+    $unObserve: unObserve,
+    $unObserveAll: unObserveAll,
+    $userData: {},
   };
   const vtkProxy = new Proxy(target, {
     get(target, prop, resolver) {
       if (target[prop] !== undefined) {
         return target[prop];
       }
-      if (target.userData[prop] !== undefined) {
-        return target.userData[prop];
+      if (target.$userData[prop] !== undefined) {
+        return target.$userData[prop];
       }
       if (prop === "then") {
         return resolver;
       }
-      if (prop === "state") {
+      if (prop === "$state") {
         return toJsKeys(wasm.get(vtkId));
       }
-      if (prop === "delete") {
+      if (prop === "$delete") {
         return deleteObject;
       }
+      if (typeof prop !== "string") {
+        // Symbols (Symbol.toPrimitive, Symbol.toStringTag, ...) are protocol
+        // probes, never VTK methods.
+        return undefined;
+      }
       if (propGetters[prop]) {
         return propGetters[prop]();
       }
-      // ideally we should have a json structure to check available methods
-      target[prop] = async (...args) => {
-        const cxxName = toCxxName(prop);
-        const decoratedArgs = wrapMethods.decorateArgs(args);
-        const result = await invokeFn(vtkId, cxxName, decoratedArgs);
-        return wrapMethods.decorateResult(result);
-      };
+      // Method dispatch: only names the method table validates are invoked.
+      if (!methodTable) {
+        // fallback for old wasm package that didn't ship method table.
+        target[prop] = async (...args) => {
+          const cxxName = toCxxName(prop);
+          const decoratedArgs = wrapMethods.decorateArgs(args);
+          const result = await invokeFn(vtkId, cxxName, decoratedArgs);
+          return wrapMethods.decorateResult(result);
+        };
+        return target[prop];
+        // Remove fallback and uncomment when we drop support for wasm package that do not have method table.
+        // throw new Error(
+        //   `Cannot access '${prop}' on ${className}: no method manifest is available. ` +
+        //     "Load from a .tar.gz bundle that contains types/*.json, or host " +
+        //     "vtk-methods.json next to the .mjs/.wasm files.",
+        // );
+      }
+      const method = methodTable.lookup(className, prop);
+      if (!method) {
+        throw new TypeError(
+          methodTable.hasClass(className)
+            ? `'${prop}' is not a property or method of ${className}.`
+            : `Unknown class ${className}: cannot resolve '${prop}'.`,
+        );
+      }
+      if (method.maySuspend && typeof wasm.invokeAsync === "function") {
+        // [[vtk::maysuspend]] methods run on a JSPI-suspendable stack and
+        // return a Promise; callers are expected to `await` them.
+        target[prop] = (...args) =>
+          wasm
+            .invokeAsync(vtkId, method.cxxName, wrapMethods.decorateArgs(args))
+            .then((result) => wrapMethods.decorateResult(result));
+      } else {
+        // Everything else (and every method on sync builds, where invokeAsync
+        // does not exist) resolves synchronously and returns the value.
+        target[prop] = (...args) =>
+          wrapMethods.decorateResult(
+            wasm.invoke(vtkId, method.cxxName, wrapMethods.decorateArgs(args)),
+          );
+      }
       return target[prop];
     },
     set(target, property, value) {
       if (propSetters[property]) {
         propSetters[property](value);
       } else {
-        target.userData[property] = value;
+        target.$userData[property] = value;
       }
       return true;
     },
@@ -148,7 +190,7 @@ export function createVtkObjectProxy(
   return vtkProxy;
 }
 
-export function createInstantiatorProxy(wasm, vtkProxyCache, idToRef) {
+export function createInstantiatorProxy(wasm, vtkProxyCache, idToRef, methodTable) {
   function isVtkObject(obj) {
     return vtkProxyCache.has(obj);
   }
@@ -157,7 +199,7 @@ export function createInstantiatorProxy(wasm, vtkProxyCache, idToRef) {
     const wrapped = {};
     Object.entries(kwargs).forEach(([k, v]) => {
       if (vtkProxyCache.has(v)) {
-        wrapped[k] = v.obj;
+        wrapped[k] = v.$obj;
       } else {
         wrapped[k] = v;
       }
@@ -166,7 +208,7 @@ export function createInstantiatorProxy(wasm, vtkProxyCache, idToRef) {
   }
 
   function decorateArgs(args) {
-    return args.map((v) => (vtkProxyCache.has(v) ? v.obj : v));
+    return args.map((v) => (vtkProxyCache.has(v) ? v.$obj : v));
   }
 
   const internalMethods = { isVtkObject, decorateKwargs, decorateArgs };
@@ -182,6 +224,7 @@ export function createInstantiatorProxy(wasm, vtkProxyCache, idToRef) {
         idToRef,
         internalMethods,
         result.Id,
+        methodTable,
       );
     }
     return result;
@@ -195,6 +238,7 @@ export function createInstantiatorProxy(wasm, vtkProxyCache, idToRef) {
       idToRef,
       internalMethods,
       obj_or_id.Id || obj_or_id,
+      methodTable,
     );
   }
 
@@ -215,6 +259,7 @@ export function createInstantiatorProxy(wasm, vtkProxyCache, idToRef) {
       idToRef,
       internalMethods,
       vtkId,
+      methodTable,
     );
   }
 
diff --git a/src/core/typedArrayInterface.js b/src/core/typedArrayInterface.js
new file mode 100644
index 0000000..d902df0
--- /dev/null
+++ b/src/core/typedArrayInterface.js
@@ -0,0 +1,287 @@
+/**
+ * Marshalling between JavaScript TypedArrays and the WebAssembly heap.
+ *
+ * Two layers, because they need different things:
+ *  - the *heap interface* only needs the Emscripten module, so it lives on the
+ *    runtime (`runtime.typedArrayInterface`) and deals in raw pointers;
+ *  - the *typed-array interface* also needs a `vtk` namespace to instantiate
+ *    C++ objects, so it lives on a session (`session.typedArrayInterface`) and
+ *    adds `toVTKAoSArray`/`toJSTypedArray` on top of the heap primitives.
+ */
+
+/**
+ * TypedArray constructor name -> the width-guaranteed VTK AoS array class whose
+ * element type matches exactly. The `vtkTypeXxx` classes are used rather than
+ * `vtkFloatArray`/`vtkIntArray`/... because their widths are fixed by name, the
+ * same guarantee a JavaScript TypedArray gives.
+ */
+const AOS_CLASS_NAMES = new Map([
+  ["Int8Array", "vtkTypeInt8Array"],
+  ["Uint8Array", "vtkTypeUInt8Array"],
+  ["Uint8ClampedArray", "vtkTypeUInt8Array"],
+  ["Int16Array", "vtkTypeInt16Array"],
+  ["Uint16Array", "vtkTypeUInt16Array"],
+  ["Int32Array", "vtkTypeInt32Array"],
+  ["Uint32Array", "vtkTypeUInt32Array"],
+  ["BigInt64Array", "vtkTypeInt64Array"],
+  ["BigUint64Array", "vtkTypeUInt64Array"],
+  ["Float32Array", "vtkTypeFloat32Array"],
+  ["Float64Array", "vtkTypeFloat64Array"],
+]);
+
+/**
+ * VTK data type enum (`vtkType.h`) -> how to read the bytes. Deliberately not a
+ * class-name table: `vtkIdTypeArray`, `vtkLongArray` and `vtkUnsignedLongArray`
+ * hold 32-bit values on wasm32 and 64-bit values on wasm64, so the width has to
+ * come from the array itself via `getDataTypeSize()`.
+ *
+ * VTK_BIT is absent on purpose — it packs 8 values per byte, so no TypedArray
+ * view describes it.
+ */
+const VTK_DATA_TYPE_KINDS = new Map([
+  [2, "signed"], // VTK_CHAR
+  [15, "signed"], // VTK_SIGNED_CHAR
+  [3, "unsigned"], // VTK_UNSIGNED_CHAR
+  [4, "signed"], // VTK_SHORT
+  [5, "unsigned"], // VTK_UNSIGNED_SHORT
+  [6, "signed"], // VTK_INT
+  [7, "unsigned"], // VTK_UNSIGNED_INT
+  [8, "signed"], // VTK_LONG
+  [9, "unsigned"], // VTK_UNSIGNED_LONG
+  [10, "float"], // VTK_FLOAT
+  [11, "float"], // VTK_DOUBLE
+  [12, "signed"], // VTK_ID_TYPE
+  [16, "signed"], // VTK_LONG_LONG
+  [17, "unsigned"], // VTK_UNSIGNED_LONG_LONG
+]);
+
+/** (kind, size in bytes) -> the TypedArray constructor over those bytes. */
+const TYPED_ARRAY_BY_KIND = {
+  signed: { 1: Int8Array, 2: Int16Array, 4: Int32Array, 8: BigInt64Array },
+  unsigned: {
+    1: Uint8Array,
+    2: Uint16Array,
+    4: Uint32Array,
+    8: BigUint64Array,
+  },
+  float: { 4: Float32Array, 8: Float64Array },
+};
+
+/** @returns {boolean} whether `value` is a numeric TypedArray (not a DataView). */
+function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+
+/**
+ * Create the pointer-level heap interface for an Emscripten module.
+ *
+ * Every view is built fresh from `module.HEAPU8.buffer` rather than cached:
+ * growing the heap replaces the underlying `ArrayBuffer` and detaches any view
+ * onto the old one.
+ *
+ * @param {object} module - the Emscripten module.
+ */
+export function createHeapInterface(module) {
+  // Under `-sMEMORY64` the heap is 64-bit addressable, so `_malloc` returns a
+  // BigInt and C++ `vtkIdType` parameters expect BigInt too. Probe once with a
+  // 1-byte allocation instead of guessing from the build configuration.
+  let bigIntPointers = null;
+  function usesBigIntPointers() {
+    if (bigIntPointers === null) {
+      const probe = module._malloc(1);
+      bigIntPointers = typeof probe === "bigint";
+      module._free(probe);
+    }
+    return bigIntPointers;
+  }
+
+  /** Pointers are byte offsets into the heap; JS needs them as Numbers. */
+  function byteOffsetOf(pointer) {
+    return typeof pointer === "bigint" ? Number(pointer) : pointer;
+  }
+
+  /**
+   * Coerce a count/length to the integer flavour this build's C++ signatures
+   * expect (`vtkIdType` is 64-bit under `-sMEMORY64`).
+   * @param {number} value
+   * @returns {number|bigint}
+   */
+  function toSizeType(value) {
+    return usesBigIntPointers() ? BigInt(value) : value;
+  }
+
+  /**
+   * `malloc` on the wasm heap. The caller owns the result and must pass it to
+   * {@link free}, or hand ownership to a C++ object that frees with `free()`.
+   * @param {number} byteLength
+   * @returns {number|bigint} pointer
+   */
+  function alloc(byteLength) {
+    const pointer = module._malloc(byteLength);
+    if (!pointer) {
+      throw new Error(
+        `Could not allocate ${byteLength} bytes on the WebAssembly heap.`,
+      );
+    }
+    return pointer;
+  }
+
+  /**
+   * `free` a pointer obtained from {@link alloc} or {@link copyToHeap}.
+   * @param {number|bigint} pointer
+   */
+  function free(pointer) {
+    module._free(pointer);
+  }
+
+  /**
+   * A TypedArray view onto heap memory. Zero-copy, and therefore only valid
+   * until the heap grows or the memory is freed — never hold on to one.
+   *
+   * @param {number|bigint} pointer
+   * @param {number} length - element count, not bytes.
+   * @param {Function} TypedArrayConstructor - e.g. `Float32Array`.
+   */
+  function viewAt(pointer, length, TypedArrayConstructor) {
+    return new TypedArrayConstructor(
+      module.HEAPU8.buffer,
+      byteOffsetOf(pointer),
+      length,
+    );
+  }
+
+  /**
+   * Allocate heap memory and copy `typedArray` into it.
+   * @param {ArrayBufferView} typedArray
+   * @returns {number|bigint} pointer to the copy; the caller owns it.
+   */
+  function copyToHeap(typedArray) {
+    if (!isTypedArray(typedArray)) {
+      throw new TypeError(
+        `Expected a TypedArray, received ${typeof typedArray}.`,
+      );
+    }
+    const pointer = alloc(typedArray.byteLength);
+    viewAt(pointer, typedArray.length, typedArray.constructor).set(typedArray);
+    return pointer;
+  }
+
+  /**
+   * Copy heap memory out into a new JavaScript-owned TypedArray. Unlike
+   * {@link viewAt} the result survives heap growth and frees.
+   *
+   * @param {number|bigint} pointer
+   * @param {number} length - element count, not bytes.
+   * @param {Function} TypedArrayConstructor - e.g. `Float32Array`.
+   */
+  function copyFromHeap(pointer, length, TypedArrayConstructor) {
+    return viewAt(pointer, length, TypedArrayConstructor).slice();
+  }
+
+  return {
+    usesBigIntPointers,
+    toSizeType,
+    alloc,
+    free,
+    viewAt,
+    copyToHeap,
+    copyFromHeap,
+  };
+}
+
+/**
+ * Extend a heap interface with the conversions that need to instantiate VTK
+ * objects. Used by the sessions; see {@link createHeapInterface}.
+ *
+ * @param {object} heap - from {@link createHeapInterface}.
+ * @param {object} vtk - the session's `vtk` namespace proxy.
+ */
+export function createTypedArrayInterface(heap, vtk) {
+  /**
+   * Copy a JavaScript TypedArray into a VTK array-of-structs data array.
+   *
+   * The heap allocation is handed to VTK (`SetArray` with `save` 0), which
+   * frees it with `free()` when the array is destroyed or reallocates — so
+   * there is nothing for the caller to release. The VTK class is chosen from
+   * the TypedArray's own type, so no widening or narrowing takes place.
+   *
+   * @param {ArrayBufferView} typedArray - source values, copied not aliased.
+   * @param {number} [numberOfComponents] - components per tuple (default 1).
+   * @param {string} [name] - the array's name (default "").
+   * @returns {object} a proxy for the new `vtkTypeXxxArray`.
+   */
+  function toVTKAoSArray(typedArray, numberOfComponents = 1, name = "") {
+    if (!isTypedArray(typedArray)) {
+      throw new TypeError(
+        `Expected a TypedArray, received ${typeof typedArray}.`,
+      );
+    }
+    const className = AOS_CLASS_NAMES.get(typedArray.constructor.name);
+    if (!className) {
+      throw new TypeError(
+        `${typedArray.constructor.name} has no VTK array-of-structs equivalent. ` +
+          `Supported: ${[...new Set(AOS_CLASS_NAMES.keys())].join(", ")}.`,
+      );
+    }
+    if (!Number.isInteger(numberOfComponents) || numberOfComponents < 1) {
+      throw new RangeError(
+        `numberOfComponents must be a positive integer, received ${numberOfComponents}.`,
+      );
+    }
+    if (typedArray.length % numberOfComponents !== 0) {
+      throw new RangeError(
+        `A ${typedArray.length}-element array does not divide into tuples of ${numberOfComponents}.`,
+      );
+    }
+
+    const pointer = heap.copyToHeap(typedArray);
+    try {
+      const array = vtk[className]({ numberOfComponents, name });
+      // `save` 0 transfers ownership of `pointer` to the VTK array.
+      array.setArray(pointer, heap.toSizeType(typedArray.length), 0);
+      return array;
+    } catch (error) {
+      // Ownership never reached C++, so the allocation is still ours to release.
+      heap.free(pointer);
+      throw error;
+    }
+  }
+
+  /**
+   * A TypedArray view onto a VTK data array's own memory. Zero-copy: writes
+   * through the view change the VTK array in place (call `modified()` after,
+   * so downstream filters and mappers notice).
+   *
+   * The view aliases the wasm heap, so it is invalidated by anything that grows
+   * the heap or reallocates the array — take a fresh one per use rather than
+   * caching it. Use `copyFromHeap` if you need a snapshot that outlives that.
+   *
+   * @param {object} vtkTypedArray - a `vtkDataArray` proxy.
+   * @returns {ArrayBufferView} view over `getNumberOfValues()` elements.
+   */
+  function toJSTypedArray(vtkTypedArray) {
+    const dataType = Number(vtkTypedArray.getDataType());
+    const kind = VTK_DATA_TYPE_KINDS.get(dataType);
+    // Ask the array how wide its values are: VTK_ID_TYPE and VTK_LONG are
+    // 32-bit on wasm32 and 64-bit on wasm64.
+    const size = Number(vtkTypedArray.getDataTypeSize());
+    const TypedArrayConstructor = kind
+      ? TYPED_ARRAY_BY_KIND[kind][size]
+      : undefined;
+    if (!TypedArrayConstructor) {
+      throw new TypeError(
+        `${vtkTypedArray.className} holds ${size}-byte values of VTK data type ` +
+          `${dataType}, which has no JavaScript TypedArray equivalent.`,
+      );
+    }
+    // `getPointer` takes a vtkIdType, which is BigInt on 64-bit builds, and
+    // `getNumberOfValues` returns one, which a TypedArray length must not be.
+    return heap.viewAt(
+      vtkTypedArray.getPointer(heap.toSizeType(0)),
+      Number(vtkTypedArray.getNumberOfValues()),
+      TypedArrayConstructor,
+    );
+  }
+
+  return { ...heap, toVTKAoSArray, toJSTypedArray };
+}
diff --git a/src/remoteSession.js b/src/remoteSession.js
index acc4bcd..a1aad2c 100644
--- a/src/remoteSession.js
+++ b/src/remoteSession.js
@@ -1,6 +1,7 @@
 import "./style.css";
 
 import { createInstantiatorProxy } from "./core/proxy";
+import { createHeapInterface, createTypedArrayInterface } from "./core/typedArrayInterface";
 import { addCanvasEventListeners, removeCanvasEventListeners } from "./core/canvasEventListeners";
 
 /**
@@ -15,12 +16,15 @@ export class RemoteSession {
   #disposed = false;
   #vtkProxyCache = null;
   #idToRef = null;
+  #typedArrayInterface = null;
 
   /**
    * @param {object} native - the C++ vtkRemoteSession instance.
    * @param {object} wasmModule - the Emscripten module the session belongs to.
+   * @param {object|null} [methodTable] - resolves method names and maySuspend
+   *        flags for the proxy (see src/core/methodTable.js).
    */
-  constructor(native, wasmModule) {
+  constructor(native, wasmModule, methodTable = null) {
     this.#native = native;
     this.#module = wasmModule;
     //
@@ -50,7 +54,7 @@ export class RemoteSession {
     // vtkObject proxy handling (create + getVtkObject + result wrapping)
     this.#vtkProxyCache = new WeakMap();
     this.#idToRef = new Map();
-    this.vtk = createInstantiatorProxy(native, this.#vtkProxyCache, this.#idToRef);
+    this.vtk = createInstantiatorProxy(native, this.#vtkProxyCache, this.#idToRef, methodTable);
 
     // Do not let server-side window sizes override the client canvas size.
     // skipProperty matches the state's leaf ClassName (the server's concrete render
@@ -81,6 +85,22 @@ export class RemoteSession {
     return this.#module;
   }
 
+  /**
+   * Marshalling between JavaScript TypedArrays and the wasm heap. Adds
+   * `toVTKAoSArray(typedArray, numberOfComponents, name)` — which creates the
+   * matching `vtkTypeXxxArray` in *this* session — to the pointer-level
+   * primitives of {@link VtkWasmRuntime#typedArrayInterface}.
+   */
+  get typedArrayInterface() {
+    if (!this.#typedArrayInterface) {
+      this.#typedArrayInterface = createTypedArrayInterface(
+        createHeapInterface(this.#module),
+        this.vtk,
+      );
+    }
+    return this.#typedArrayInterface;
+  }
+
   /** Start event loop on the render window. */
   startEventLoop(renderWindowId) {
     if (this.#native.startEventLoop(renderWindowId)) {
@@ -395,7 +415,7 @@ export class RemoteSession {
         // key. Until then, this code should not run. Instead, it relies
         // upon consumers having called the bindCanvas(renderWindowId, canvasOrId) method.
         // This issue is tracked in https://gitlab.kitware.com/vtk/vtk/-/work_items/20099
-        // const state = this.getVtkObject(vtkId).state;
+        // const state = this.getVtkObject(vtkId).$state;
         // const isRenderWindow =
         //   state?.className === "vtkRenderWindow" ||
         //   state?.superClassNames?.includes("vtkRenderWindow");
diff --git a/src/runtime.js b/src/runtime.js
index 10b573f..ed4a20d 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -1,4 +1,6 @@
 import { extractFilesFromGzipBundleAsync, fetchGzipBundleAsync } from "./core/gzipBundle";
+import { createMethodTableFromManifests, createMethodTableFromMergedIndex } from "./core/methodTable";
+import { createHeapInterface } from "./core/typedArrayInterface";
 import { createEmscriptenConfig, normalizeConfig, validateConfig } from "./core/configManager";
 import { DEFAULT_CONFIG, DEFAULT_WASM_BASE_NAME, DEFAULT_WASM_URL_IS_GZIP, MIME_TYPES } from "./core/constants";
 import { wasmModuleBaseNames } from "./core/wasmModuleNames";
@@ -84,19 +86,39 @@ async function importModuleFactoryAsync(moduleURL) {
 }
 
 /**
- * Resolve the glue module factory and the wasm binary descriptor (if any) for
- * the requested configuration. Returns `{ factory, wasmFile }`, where
- * `wasmFile` is non-null only when the binary had to be extracted from a gzip
- * bundle (so it can be handed to Emscripten).
+ * Fetch and parse the merged method index (`vtk-methods.json`) hosted next to
+ * loose `.mjs`/`.wasm` files. Returns a method table, or `null` when the file
+ * is absent or malformed (method calls will then throw with instructions).
+ */
+async function fetchMethodIndexAsync(url) {
+  const indexURL = `${url.replace(/\/+$/, "")}/vtk-methods.json`;
+  try {
+    const response = await fetch(indexURL);
+    if (!response.ok) {
+      return null;
+    }
+    return createMethodTableFromMergedIndex(await response.json());
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the glue module factory, the wasm binary descriptor (if any), and
+ * the method table for the requested configuration. `wasmFile` is non-null
+ * only when the binary had to be extracted from a gzip bundle (so it can be
+ * handed to Emscripten). `methodTable` is null when neither the bundle's
+ * `types/*.json` nor a hosted `vtk-methods.json` could be found.
  */
 async function loadModuleFactoryAsync(url, urlIsGzip, wasmBaseName, config) {
   if (urlIsGzip) {
     const gzipArrayBuffer = await fetchGzipBundleAsync(url);
-    const { js, wasm } = await extractFilesFromGzipBundleAsync(gzipArrayBuffer, config, wasmBaseName);
+    const { js, wasm, manifests } = await extractFilesFromGzipBundleAsync(gzipArrayBuffer, config, wasmBaseName);
     const javaScriptBlobURL = createBlobURL(exposeSpecialHTMLTargets(js.buffer), MIME_TYPES.JAVASCRIPT);
     try {
       const factory = await importModuleFactoryAsync(javaScriptBlobURL);
-      return { factory, wasmFile: wasm };
+      const methodTable = manifests ? createMethodTableFromManifests(manifests) : null;
+      return { factory, wasmFile: wasm, methodTable };
     } finally {
       // Safe to revoke now: the module is fully evaluated once import() resolves.
       disposeBlobURL(javaScriptBlobURL);
@@ -118,14 +140,14 @@ async function loadModuleFactoryAsync(url, urlIsGzip, wasmBaseName, config) {
     );
   }
   const factory = await importModuleFactoryAsync(scriptURL);
-  return { factory, wasmFile: null };
+  return { factory, wasmFile: null, methodTable: await fetchMethodIndexAsync(url) };
 }
 
 async function instantiateAsync(url, urlIsGzip, wasmBaseName, config, key) {
   try {
-    const { factory, wasmFile } = await loadModuleFactoryAsync(url, urlIsGzip, wasmBaseName, config);
+    const { factory, wasmFile, methodTable } = await loadModuleFactoryAsync(url, urlIsGzip, wasmBaseName, config);
     const module = await factory(createEmscriptenConfig(config, wasmFile));
-    const runtime = new VtkWasmRuntime(module, key);
+    const runtime = new VtkWasmRuntime(module, key, methodTable);
     RUNTIME_CACHE.set(key, runtime);
     return runtime;
   } finally {
@@ -181,11 +203,14 @@ export async function loadAsync(options = {}) {
 export class VtkWasmRuntime {
   #module = null;
   #key = null;
+  #methodTable = null;
   #disposed = false;
+  #heapInterface = null;
 
-  constructor(module, key) {
+  constructor(module, key, methodTable = null) {
     this.#module = module;
     this.#key = key;
+    this.#methodTable = methodTable;
   }
 
   /** The unique identifier for the wasm module that this runtime was created from.
@@ -199,6 +224,20 @@ export class VtkWasmRuntime {
     return this.#module;
   }
 
+  /**
+   * Pointer-level marshalling between JavaScript TypedArrays and the wasm heap:
+   * `alloc`, `free`, `copyToHeap`, `copyFromHeap`, `viewAt`. Creating VTK data
+   * arrays needs a session, so `toVTKAoSArray` lives on
+   * {@link StandaloneSession#typedArrayInterface} instead.
+   */
+  get heapInterface() {
+    this.#assertLive();
+    if (!this.#heapInterface) {
+      this.#heapInterface = createHeapInterface(this.#module);
+    }
+    return this.#heapInterface;
+  }
+
   /** @returns {boolean} whether this runtime executes methods asynchronously (JSPI). */
   isAsync() {
     return typeof this.#module?.isAsync === "function" && this.#module.isAsync();
@@ -210,7 +249,7 @@ export class VtkWasmRuntime {
    */
   createStandaloneSession() {
     this.#assertLive();
-    return new StandaloneSession(new this.#module.vtkStandaloneSession(), this.#module);
+    return new StandaloneSession(new this.#module.vtkStandaloneSession(), this.#module, this.#methodTable);
   }
 
   /**
@@ -219,7 +258,7 @@ export class VtkWasmRuntime {
    */
   createRemoteSession() {
     this.#assertLive();
-    return new RemoteSession(new this.#module.vtkRemoteSession(), this.#module);
+    return new RemoteSession(new this.#module.vtkRemoteSession(), this.#module, this.#methodTable);
   }
 
   /**
diff --git a/src/standaloneSession.js b/src/standaloneSession.js
index 875377d..0f55ce5 100644
--- a/src/standaloneSession.js
+++ b/src/standaloneSession.js
@@ -1,4 +1,5 @@
 import { createInstantiatorProxy } from "./core/proxy";
+import { createHeapInterface, createTypedArrayInterface } from "./core/typedArrayInterface";
 
 /**
  * An in-browser VTK session. Wraps a C++ `vtkStandaloneSession` and exposes the
@@ -12,19 +13,22 @@ export class StandaloneSession {
   #disposed = false;
   #vtkProxyCache = new WeakMap();
   #idToRef = new Map();
+  #typedArrayInterface = null;
 
   /**
    * @param {object} native - the C++ vtkStandaloneSession instance.
    * @param {object} module - the Emscripten module (for specialHTMLTargets access).
+   * @param {object|null} [methodTable] - resolves method names and maySuspend
+   *        flags for the proxy (see src/core/methodTable.js).
    */
-  constructor(native, module) {
+  constructor(native, module, methodTable = null) {
     this.#native = native;
     this.#module = module;
     /**
      * The `vtk` namespace: call `vtk.vtkActor({ ... })` to create objects.
      * @type {object}
      */
-    this.vtk = createInstantiatorProxy(native, this.#vtkProxyCache, this.#idToRef);
+    this.vtk = createInstantiatorProxy(native, this.#vtkProxyCache, this.#idToRef, methodTable);
   }
 
   /** The underlying C++ session. Escape hatch; prefer {@link StandaloneSession#vtk}. */
@@ -37,6 +41,22 @@ export class StandaloneSession {
     return this.#module;
   }
 
+  /**
+   * Marshalling between JavaScript TypedArrays and the wasm heap. Adds
+   * `toVTKAoSArray(typedArray, numberOfComponents, name)` — which creates the
+   * matching `vtkTypeXxxArray` in *this* session — to the pointer-level
+   * primitives of {@link VtkWasmRuntime#typedArrayInterface}.
+   */
+  get typedArrayInterface() {
+    if (!this.#typedArrayInterface) {
+      this.#typedArrayInterface = createTypedArrayInterface(
+        createHeapInterface(this.#module),
+        this.vtk,
+      );
+    }
+    return this.#typedArrayInterface;
+  }
+
   /**
    * Register `canvas` under `key` in `specialHTMLTargets` so it can be used as
    * a `canvasSelector` without requiring a DOM `id`. The key must start with `!`
diff --git a/tsconfig.json b/tsconfig.json
index 5ee229d..59fe3e9 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -7,7 +7,11 @@
     "target": "esnext",
     "moduleResolution": "bundler",
     "skipLibCheck": true,
-    "strict": false
+    "strict": false,
+    "lib": ["ESNext", "DOM"],
+    "paths": {
+      "@kitware/vtk-wasm": ["./types/index.d.ts"]
+    }
   },
-  "include": ["src"]
+  "include": ["src", "types"]
 }
diff --git a/types/base.d.ts b/types/base.d.ts
new file mode 100644
index 0000000..5dde415
--- /dev/null
+++ b/types/base.d.ts
@@ -0,0 +1,410 @@
+// Hand-written base types for @kitware/vtk-wasm.
+//
+// These describe the proxy plumbing and the public session/runtime API. The
+// per-class VTK interfaces and the concrete `vtk.vtkXxx(...)` constructor
+// signatures on `VtkNamespace` are added by module augmentation: run the
+// `vtk-wasm gen-types` CLI (see bin/vtk-wasm.mjs) against the same VTK.wasm
+// bundle your app loads, and it emits a
+// `declare module "@kitware/vtk-wasm"` file that merges the per-class members
+// into the open interfaces declared here. Without that generated file, the
+// loose index signature on `VtkNamespace` keeps untyped use compiling.
+
+/**
+ * Root of the generated `*Properties` chain. Every generated per-class
+ * `*Properties` interface ultimately extends this; `Partial<...Properties>` is
+ * what a `vtk.vtkXxx(args)` constructor call accepts. Kept separate from
+ * {@link vtkObjectProperties} (which the augmentation merges VTK's own
+ * `vtkObject` data properties into) so the two never form an inheritance cycle
+ * — VTK's `vtkObject` is a child of `vtkObjectBase`, not the absolute root.
+ */
+export interface VtkObjectPropertiesBase {}
+
+/**
+ * Open data-properties interface for VTK's `vtkObject`. The `vtk-wasm
+ * gen-types` augmentation merges `vtkObject`'s own data properties into it.
+ */
+export interface vtkObjectProperties extends VtkObjectPropertiesBase {}
+
+/**
+ * Nominal reference to a VTK class: accepts any object whose generated
+ * `$brands` set (its full ancestor chain) contains `K`. Class-typed
+ * parameters and settable properties in the generated declarations use
+ * `VtkRef<"vtkMapper">` rather than the structural `vtkMapper` interface,
+ * because C++ overload collapse makes subclasses structurally incompatible
+ * with their bases even though the C++ is-a relationship holds — this mirrors
+ * C++'s nominal typing instead. `$brands` is a phantom type-level member; it
+ * never exists at runtime.
+ */
+export type VtkRef<K extends string> = {
+  readonly $brands: { [P in K]: true };
+};
+
+/**
+ * Root of every VTK object proxy returned by the `vtk` namespace — carries the
+ * proxy plumbing shared by all objects. Every generated per-class interface
+ * ultimately extends this, so the plumbing lives here (on the absolute root)
+ * rather than on {@link vtkObject}, which the augmentation merges VTK's own
+ * `vtkObject` members into (and which is itself a child of `vtkObjectBase`).
+ *
+ * Data properties (camelCase) are read/written synchronously. Methods
+ * (camelCase) are forwarded to C++ and return their result synchronously,
+ * except methods marked `[[vtk::maysuspend]]` in VTK, which are dispatched
+ * through the Promise-returning `invokeAsync` binding on JSPI builds. Both are
+ * added to the per-class interfaces by the generated augmentation.
+ *
+ * Proxy plumbing members are `$`-prefixed so they can never collide with C++
+ * members (`$` is not legal in C++ identifiers). `toJSON`/`toString` stay
+ * unprefixed because `JSON.stringify` and string coercion look them up by
+ * exactly those names.
+ */
+export interface VtkObjectProxyBase extends VtkObjectPropertiesBase {
+  /** Numeric WASM object id. */
+  readonly $id: number;
+  /** `{ Id }` wrapper used when this object is passed to C++. */
+  readonly $obj: { Id: number };
+  /** Snapshot of the full object state, keys translated to camelCase. */
+  readonly $state: Record<string, unknown>;
+  /** Properties that are not recognized VTK properties are stored here. */
+  $userData: Record<string, unknown>;
+  /** Batch-set data properties (camelCase keys). */
+  $set(props: Partial<vtkObjectProperties> & Record<string, unknown>): void;
+  /**
+   * Register an observer for a VTK event. The callback receives the sender
+   * object's id and the event name (matching the C++
+   * `void(vtkObjectHandle sender, const char* eventName)` signature). Returns a
+   * tag usable with {@link VtkObjectProxyBase.$unObserve}.
+   */
+  $observe(
+    event: string,
+    callback: (sender: number, eventName: string) => void,
+  ): number;
+  /** Remove a single observer by its tag. */
+  $unObserve(tag: number): unknown;
+  /** Remove every observer registered through this proxy. */
+  $unObserveAll(): void;
+  /** Destroy the underlying C++ object. Returns whether it was destroyed. */
+  $delete(): boolean;
+  /** Full state as a plain object (camelCase keys). */
+  toJSON(): Record<string, unknown>;
+  /** C++ `PrintSelf` representation. */
+  toString(): string;
+}
+
+/**
+ * The base type for any VTK object proxy. This is the fallback return type of
+ * the loose {@link VtkNamespace} index signature, so untyped `vtk.vtkXxx(...)`
+ * use always resolves to something with the proxy plumbing typed. When the
+ * `vtk-wasm gen-types` augmentation is present it merges VTK's own `vtkObject`
+ * members into this interface.
+ */
+export interface vtkObject extends VtkObjectProxyBase {}
+
+/**
+ * Members of the `vtk` namespace proxy that are not VTK class constructors.
+ * The constructors themselves (`vtkActor`, `vtkRenderer`, ...) are added to
+ * {@link VtkNamespace} by the generated augmentation.
+ */
+export interface VtkNamespaceBase {
+  /**
+   * Re-wrap an existing object id (or `{ Id }`) as a proxy. The argument is
+   * required at runtime.
+   *
+   * The `?` and the `| object` widening are deliberate: they keep this member
+   * compatible with the loose `[vtkClassName: string]: (args?: object) => ...`
+   * index signature on {@link VtkNamespace} — an accurate
+   * `(idOrObj: number | { Id: number })` fails that check on both parameter
+   * arity (index callable with zero args) and parameter type.
+   */
+  getVtkObject(idOrObj?: number | { Id: number } | object): vtkObject;
+}
+
+/**
+ * The `vtk` namespace proxy: `vtk.vtkActor({ ... })` creates a C++ object and
+ * returns its proxy. This interface is the module-augmentation target — the
+ * `vtk-wasm gen-types` CLI emits a `declare module "@kitware/vtk-wasm"` file
+ * that merges a precisely-typed constructor for every VTK class in your bundle
+ * (e.g. `vtkActor(args?: Partial<vtkActorProperties>): vtkActor;`) into it.
+ *
+ * The loose index signature is the fallback when no generated file is present:
+ * any `vtk.vtkAnything(...)` call still compiles and returns the plumbing root
+ * {@link VtkObjectProxyBase}. Generated per-class constructors are narrower
+ * and take precedence over it. The index value type must be
+ * `VtkObjectProxyBase` (not {@link vtkObject}): C++ overload collapse leaves
+ * some generated classes structurally incompatible with `vtkObject`, but the
+ * `$`-prefixed plumbing root is never redeclared, so every generated
+ * constructor stays assignable to the signature.
+ */
+export interface VtkNamespace extends VtkNamespaceBase {
+  [vtkClassName: string]: (args?: object) => VtkObjectProxyBase;
+}
+
+/**
+ * A byte offset into the WebAssembly heap. Builds configured with `-sMEMORY64`
+ * address memory with 64-bit pointers, which reach JavaScript as `bigint`.
+ */
+export type WasmPointer = number | bigint;
+
+/** The numeric TypedArrays that can be marshalled to and from the wasm heap. */
+export type MarshallableTypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | BigInt64Array
+  | BigUint64Array
+  | Float32Array
+  | Float64Array;
+
+/**
+ * The width-guaranteed VTK array-of-structs class whose element type matches
+ * `T` exactly. `Uint8ClampedArray` shares `vtkTypeUInt8Array` with `Uint8Array`.
+ */
+export type VtkAoSArrayClassName<T extends MarshallableTypedArray> =
+  T extends Int8Array
+    ? "vtkTypeInt8Array"
+    : T extends Uint8ClampedArray
+      ? "vtkTypeUInt8Array"
+      : T extends Uint8Array
+        ? "vtkTypeUInt8Array"
+        : T extends Int16Array
+          ? "vtkTypeInt16Array"
+          : T extends Uint16Array
+            ? "vtkTypeUInt16Array"
+            : T extends Int32Array
+              ? "vtkTypeInt32Array"
+              : T extends Uint32Array
+                ? "vtkTypeUInt32Array"
+                : T extends BigInt64Array
+                  ? "vtkTypeInt64Array"
+                  : T extends BigUint64Array
+                    ? "vtkTypeUInt64Array"
+                    : T extends Float32Array
+                      ? "vtkTypeFloat32Array"
+                      : T extends Float64Array
+                        ? "vtkTypeFloat64Array"
+                        : never;
+
+/**
+ * The proxy type `toVTKAoSArray` returns for a given TypedArray. Resolves
+ * through {@link VtkNamespace}, so it is the precise generated interface when a
+ * `vtk-wasm gen-types` augmentation is present and {@link VtkObjectProxyBase}
+ * otherwise.
+ */
+export type VtkAoSArrayOf<T extends MarshallableTypedArray> = ReturnType<
+  VtkNamespace[VtkAoSArrayClassName<T>]
+>;
+
+/**
+ * The JavaScript TypedArray whose element type matches VTK array proxy `T`.
+ *
+ * Discriminates on the generated `$brands` ancestor chain, so the fixed-width
+ * aliases resolve through their concrete base — `vtkTypeFloat32Array` brands
+ * include `vtkFloatArray`, and both yield `Float32Array`.
+ *
+ * `vtkIdTypeArray`, `vtkLongArray` and `vtkUnsignedLongArray` are deliberately
+ * absent: they hold 32-bit values on wasm32 and 64-bit values on wasm64, so no
+ * single static type is correct for both. They fall through to the
+ * {@link MarshallableTypedArray} union and need narrowing at the call site;
+ * prefer the `vtkTypeInt32Array`/`vtkTypeInt64Array` aliases when the width
+ * matters. `vtkBitArray` is absent because it packs 8 values per byte.
+ */
+export type JSTypedArrayOf<T> = T extends { $brands: { vtkFloatArray: true } }
+  ? Float32Array
+  : T extends { $brands: { vtkDoubleArray: true } }
+    ? Float64Array
+    : T extends { $brands: { vtkCharArray: true } }
+      ? Int8Array
+      : T extends { $brands: { vtkSignedCharArray: true } }
+        ? Int8Array
+        : T extends { $brands: { vtkUnsignedCharArray: true } }
+          ? Uint8Array
+          : T extends { $brands: { vtkShortArray: true } }
+            ? Int16Array
+            : T extends { $brands: { vtkUnsignedShortArray: true } }
+              ? Uint16Array
+              : T extends { $brands: { vtkIntArray: true } }
+                ? Int32Array
+                : T extends { $brands: { vtkUnsignedIntArray: true } }
+                  ? Uint32Array
+                  : T extends { $brands: { vtkLongLongArray: true } }
+                    ? BigInt64Array
+                    : T extends { $brands: { vtkUnsignedLongLongArray: true } }
+                      ? BigUint64Array
+                      : MarshallableTypedArray;
+
+/**
+ * Pointer-level marshalling between JavaScript TypedArrays and the wasm heap.
+ * Available as {@link VtkWasmRuntime.typedArrayInterface}.
+ */
+export interface HeapInterface {
+  /** Whether this build addresses memory with 64-bit (BigInt) pointers. */
+  usesBigIntPointers(): boolean;
+  /** Coerce a count to the integer type this build's C++ signatures expect. */
+  toSizeType(value: number): WasmPointer;
+  /** `malloc`. The caller owns the result until it frees or transfers it. */
+  alloc(byteLength: number): WasmPointer;
+  /** `free` a pointer from {@link HeapInterface.alloc} or `copyToHeap`. */
+  free(pointer: WasmPointer): void;
+  /**
+   * A zero-copy view onto heap memory, valid only until the heap grows or the
+   * memory is freed. `length` counts elements, not bytes.
+   */
+  viewAt<T extends MarshallableTypedArray>(
+    pointer: WasmPointer,
+    length: number,
+    TypedArrayConstructor: new (
+      buffer: ArrayBufferLike,
+      byteOffset: number,
+      length: number,
+    ) => T,
+  ): T;
+  /** Allocate and copy `typedArray` onto the heap; the caller owns the copy. */
+  copyToHeap(typedArray: MarshallableTypedArray): WasmPointer;
+  /** Copy heap memory out into a new JavaScript-owned TypedArray. */
+  copyFromHeap<T extends MarshallableTypedArray>(
+    pointer: WasmPointer,
+    length: number,
+    TypedArrayConstructor: new (
+      buffer: ArrayBufferLike,
+      byteOffset: number,
+      length: number,
+    ) => T,
+  ): T;
+}
+
+/**
+ * {@link HeapInterface} plus the conversions that instantiate VTK objects, and
+ * therefore belong to a session rather than the runtime.
+ */
+export interface TypedArrayInterface extends HeapInterface {
+  /**
+   * Copy a TypedArray into a new VTK data array in this session. The VTK class
+   * follows from the TypedArray's own type, so no values are widened or
+   * narrowed. The heap allocation is handed to VTK, which frees it along with
+   * the array — the caller has nothing to release.
+   *
+   * @param typedArray - source values, copied rather than aliased.
+   * @param numberOfComponents - components per tuple; defaults to 1. Must
+   *        divide `typedArray.length`.
+   * @param name - the array's name; defaults to `""`.
+   */
+  toVTKAoSArray<T extends MarshallableTypedArray>(
+    typedArray: T,
+    numberOfComponents?: number,
+    name?: string,
+  ): VtkAoSArrayOf<T>;
+
+  /**
+   * A zero-copy TypedArray view onto a VTK data array's own memory. Writes
+   * through the view change the array in place — call `modified()` afterwards.
+   *
+   * The view aliases the wasm heap and is invalidated whenever the heap grows
+   * or the array reallocates, so take a fresh one per use instead of caching
+   * it. Use {@link HeapInterface.copyFromHeap} for a lasting snapshot.
+   */
+  toJSTypedArray<T extends VtkObjectProxyBase>(
+    vtkTypedArray: T,
+  ): JSTypedArrayOf<T>;
+}
+
+/** An in-browser VTK session wrapping a C++ `vtkStandaloneSession`. */
+export class StandaloneSession {
+  /** The `vtk` namespace: call `vtk.vtkActor({ ... })` to create objects. */
+  readonly vtk: VtkNamespace;
+  /** The underlying C++ session. Escape hatch; prefer {@link StandaloneSession.vtk}. */
+  readonly native: object;
+  readonly wasmModule: object;
+  /** Marshalling between TypedArrays and the wasm heap, bound to this session. */
+  readonly typedArrayInterface: TypedArrayInterface;
+  readonly disposed: boolean;
+  /**
+   * Register `canvas` under `key` in `specialHTMLTargets` so it can be used as
+   * a `canvasSelector` without a DOM `id`. `key` must start with `!`.
+   */
+  registerCanvas(key: string, canvas: HTMLCanvasElement): string;
+  /** Free the C++ session and all objects it owns. */
+  dispose(): void;
+  [Symbol.dispose](): void;
+}
+
+/** A server-driven VTK session wrapping a C++ `vtkRemoteSession`. */
+export class RemoteSession {
+  /** The `vtk` namespace proxy. */
+  readonly vtk: VtkNamespace;
+  readonly native: object;
+  readonly wasmModule: object;
+  /** Marshalling between TypedArrays and the wasm heap, bound to this session. */
+  readonly typedArrayInterface: TypedArrayInterface;
+  readonly disposed: Boolean;
+  bindNetwork(
+    fetchState: (vtkId: number) => unknown,
+    fetchHash: (hash: string) => unknown,
+    fetchStatus: (...args: any[]) => unknown,
+  ): void;
+  bindCanvas(
+    renderWindowId: number,
+    canvasOrId: HTMLCanvasElement | string,
+  ): void;
+  unbindCanvas(renderWindowId: number): void;
+  setSizeAsync(
+    renderWindowId: number,
+    width: number,
+    height: number,
+  ): Promise<void>;
+  startEventLoop(renderWindowId: number): void;
+  stopEventLoop(renderWindowId: number): void;
+  updateAsync(vtkId: number): Promise<void>;
+  fetchStateAsync(vtkId: number): Promise<unknown>;
+  fetchHashAsync(hash: string): Promise<unknown>;
+  getState(vtkId: number, useCache?: boolean): unknown;
+  getStateValue(valuePath: string, useCache?: boolean): unknown;
+  clearStateCache(): void;
+  addProgressCallback(callback: (...args: any[]) => void): void;
+  freeMemory(cacheSize?: number): void;
+}
+
+/** Options accepted by {@link loadAsync}. */
+export interface LoadOptions {
+  /** Directory URL or `.tar.gz` bundle URL hosting the VTK.wasm files. */
+  url?: string;
+  /** Base name of the `.mjs`/`.wasm` files (without extension). */
+  wasmBaseName?: string;
+  /** Rendering backend. */
+  rendering?: "webgl" | "webgpu";
+  /** Execution model. */
+  exec?: "sync" | "async";
+  [key: string]: unknown;
+}
+
+/** A loaded VTK.wasm runtime. Create sessions from it. */
+export class VtkWasmRuntime {
+  readonly disposed: boolean;
+  readonly id: string;
+  readonly module: object;
+  /**
+   * Pointer-level heap marshalling. Creating VTK arrays needs a session, so
+   * `toVTKAoSArray` lives on {@link StandaloneSession.typedArrayInterface}.
+   */
+  readonly typedArrayInterface: HeapInterface;
+  isAsync(): boolean;
+  createStandaloneSession(): StandaloneSession;
+  createRemoteSession(): RemoteSession;
+  dispose(): void;
+}
+
+/**
+ * Load (and cache) a VTK.wasm runtime.
+ */
+export function loadAsync(options?: LoadOptions): Promise<VtkWasmRuntime>;
+
+/**
+ * When the script tag has `id="vtk-wasm"`, resolves to the `vtk` namespace of
+ * the auto-created standalone session; otherwise `undefined`.
+ */
+export const ready: Promise<VtkNamespace> | undefined;
+
+/** The auto-load standalone session, set after {@link ready} resolves. */
+export const session: StandaloneSession | undefined;
diff --git a/types/index.d.ts b/types/index.d.ts
new file mode 100644
index 0000000..684da9f
--- /dev/null
+++ b/types/index.d.ts
@@ -0,0 +1,7 @@
+// Public type entry point for @kitware/vtk-wasm.
+//
+// Exports the hand-written runtime/session API and the open interfaces
+// (vtkObject, VtkNamespace, ...) that the `vtk-wasm gen-types` CLI augments
+// with per-class VTK members. See ./base.d.ts.
+
+export * from "./base.js";
diff --git a/types/viewer.d.ts b/types/viewer.d.ts
new file mode 100644
index 0000000..c954f16
--- /dev/null
+++ b/types/viewer.d.ts
@@ -0,0 +1,26 @@
+// Hand-written declarations for @kitware/vtk-wasm/viewer.
+
+import type { RemoteSession, LoadOptions } from "./base.js";
+
+/**
+ * Displays a serialized VTK scene (`.vtk-wasm` export) inside a container
+ * element using a remote session.
+ */
+export class ExportViewer {
+  constructor(containerSelector: string, remoting: RemoteSession);
+  /** Load and display a `.vtk-wasm` scene from the given URL. */
+  loadAsync(url: string): Promise<void>;
+  /** Resize observer that keeps the canvas sized to the container. */
+  readonly resizeObserver: ResizeObserver;
+}
+
+/**
+ * Convenience: load the WASM runtime, create a remote session, instantiate an
+ * {@link ExportViewer}, and load the scene — all in one call.
+ */
+export function createViewerAsync(
+  containerSelector: string,
+  dataURL: string,
+  wasmURL?: string,
+  wasmConfig?: LoadOptions,
+): Promise<ExportViewer>;
diff --git a/vite.config.js b/vite.config.js
index e6c93f4..78832ed 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -7,6 +7,14 @@ export default {
         viewer: "src/viewer.js",
       },
       formats: ["es"],
+      // "type": "module" flips Vite's default ES extension to .js; keep the
+      // published .mjs contract (package.json exports point at index.mjs).
+      fileName: (format, entryName) => `${entryName}.mjs`,
+    },
+    rollupOptions: {
+      output: {
+        chunkFileNames: "[name]-[hash].mjs",
+      },
     },
     assetsDir: ".",
     outDir: "./dist/esm",
diff --git a/vite.config.standalone.js b/vite.config.standalone.js
index efb0613..768a4eb 100644
--- a/vite.config.standalone.js
+++ b/vite.config.standalone.js
@@ -5,7 +5,10 @@ export default {
       entry: "src/index.js",
       formats: ["umd"],
       name: "vtkwasm",
-      fileName: "vtk",
+      // "type": "module" flips Vite's default UMD extension to .umd.cjs; keep
+      // the published vtk.umd.js name (script-tag consumers, exports map).
+      fileName: () => "vtk.umd.js",
+      cssFileName: "vtk",
     },
     assetsDir: ".",
     outDir: "./dist/umd",
diff --git a/vite.config.viewer.js b/vite.config.viewer.js
index 1178e42..069e358 100644
--- a/vite.config.viewer.js
+++ b/vite.config.viewer.js
@@ -5,7 +5,10 @@ export default {
       entry: "src/viewer.js",
       formats: ["umd"],
       name: "vtkWASMViewer",
-      fileName: "viewer",
+      // "type": "module" flips Vite's default UMD extension to .umd.cjs; keep
+      // the published viewer.umd.js name (script-tag consumers, exports map).
+      fileName: () => "viewer.umd.js",
+      cssFileName: "viewer",
     },
     assetsDir: ".",
     outDir: "./dist/umd",