@rybosome/tspice 0.0.3 → 0.0.8

package/backend-wasm/dist/domains/ephemeris.js

@@ -1,81 +1,440 @@
+import { assertSpiceInt32 } from "#backend-contract";
+import { WASM_ERR_MAX_BYTES, withAllocs } from "../codec/alloc.js";
 import { throwWasmSpiceError } from "../codec/errors.js";
-import { writeUtf8CString } from "../codec/strings.js";
+import { readFixedWidthCString, writeUtf8CString } from "../codec/strings.js";
+import { resolveKernelPath } from "../runtime/fs.js";
+const I32_MAX = 2147483647;
+function isVirtualOutput(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.kind === "virtual-output" &&
+        typeof value.path === "string");
+}
+// SPK writer file semantics in the WASM backend:
+//
+// - `string` inputs are treated as *virtual kernel ids*, not raw Emscripten FS
+//   absolute paths. We route them through `resolveKernelPath()` to normalize
+//   into the `/kernels/...` namespace and to fail fast on accidental OS
+//   paths/URLs.
+// - `VirtualOutput.path` is also a virtual id (not a raw absolute FS path) and
+//   is resolved the same way.
+//
+// This keeps the writer APIs consistent with `furnsh(string)` and
+// `readVirtualOutput()`.
+function resolveSpkPath(file, context) {
+    if (typeof file === "string") {
+        return resolveKernelPath(file);
+    }
+    if (!isVirtualOutput(file)) {
+        throw new Error(`${context}: expected VirtualOutput {kind:'virtual-output', path:string}`);
+    }
+    return resolveKernelPath(file.path);
+}
+function ensureParentDir(module, filePath) {
+    const dir = filePath.split("/").slice(0, -1).join("/") || "/";
+    if (dir && dir !== "/") {
+        module.FS.mkdirTree(dir);
+    }
+}
+function callVoidHandle(module, fn, handle) {
+    withAllocs(module, [WASM_ERR_MAX_BYTES], (errPtr) => {
+        const code = fn(handle, errPtr, WASM_ERR_MAX_BYTES);
+        if (code !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, code);
+        }
+    });
+}
+function tspiceCallSpkopn(module, path, ifname, ncomch) {
+    const pathPtr = writeUtf8CString(module, path);
+    const ifnamePtr = writeUtf8CString(module, ifname);
+    try {
+        return withAllocs(module, [4, WASM_ERR_MAX_BYTES], (outHandlePtr, errPtr) => {
+            module.HEAP32[outHandlePtr >> 2] = 0;
+            const code = module._tspice_spkopn(pathPtr, ifnamePtr, ncomch, outHandlePtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (code !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, code);
+            }
+            return module.HEAP32[outHandlePtr >> 2] ?? 0;
+        });
+    }
+    finally {
+        module._free(ifnamePtr);
+        module._free(pathPtr);
+    }
+}
+function tspiceCallSpkopa(module, path) {
+    const pathPtr = writeUtf8CString(module, path);
+    try {
+        return withAllocs(module, [4, WASM_ERR_MAX_BYTES], (outHandlePtr, errPtr) => {
+            module.HEAP32[outHandlePtr >> 2] = 0;
+            const code = module._tspice_spkopa(pathPtr, outHandlePtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (code !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, code);
+            }
+            return module.HEAP32[outHandlePtr >> 2] ?? 0;
+        });
+    }
+    finally {
+        module._free(pathPtr);
+    }
+}
+function tspiceCallSpkw08(module, nativeHandle, body, center, frame, first, last, segid, degree, states, epoch1, step) {
+    const framePtr = writeUtf8CString(module, frame);
+    const segidPtr = writeUtf8CString(module, segid);
+    try {
+        const n = states.length / 6;
+        if (!Number.isSafeInteger(n) || n <= 0 || n * 6 !== states.length) {
+            throw new Error("tspiceCallSpkw08(states): expected states.length to be a non-zero multiple of 6");
+        }
+        if (n > I32_MAX) {
+            throw new Error(`tspiceCallSpkw08(states): expected n to be a 32-bit signed integer (got n=${n})`);
+        }
+        if (states.length > I32_MAX) {
+            throw new Error(`tspiceCallSpkw08(states): expected states.length to be a 32-bit signed integer (got states.length=${states.length})`);
+        }
+        const statesBytes = n * 6 * 8;
+        // Allocate states bytes with padding to ensure 8-byte alignment.
+        withAllocs(module, [WASM_ERR_MAX_BYTES, statesBytes + 7], (errPtr, rawStatesPtr) => {
+            const statesPtr = (rawStatesPtr + 7) & ~7;
+            if (states.length > 0) {
+                module.HEAPF64.set(states, statesPtr >> 3);
+            }
+            const code = module._tspice_spkw08_v2(nativeHandle, body, center, framePtr, first, last, segidPtr, degree, n, statesPtr, states.length, epoch1, step, errPtr, WASM_ERR_MAX_BYTES);
+            if (code !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, code);
+            }
+        });
+    }
+    finally {
+        module._free(segidPtr);
+        module._free(framePtr);
+    }
+}
 function tspiceCallSpkezr(module, target, et, ref, abcorr, obs) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
     const targetPtr = writeUtf8CString(module, target);
     const refPtr = writeUtf8CString(module, ref);
     const abcorrPtr = writeUtf8CString(module, abcorr);
     const obsPtr = writeUtf8CString(module, obs);
-    const outStatePtr = module._malloc(6 * 8);
-    const outLtPtr = module._malloc(8);
-    if (!errPtr || !targetPtr || !refPtr || !abcorrPtr || !obsPtr || !outStatePtr || !outLtPtr) {
-        for (const ptr of [outLtPtr, outStatePtr, obsPtr, abcorrPtr, refPtr, targetPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
     try {
-        module.HEAPF64[outLtPtr >> 3] = 0;
-        const result = module._tspice_spkezr(targetPtr, et, refPtr, abcorrPtr, obsPtr, outStatePtr, outLtPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const state = Array.from(module.HEAPF64.subarray(outStatePtr >> 3, (outStatePtr >> 3) + 6));
-        const lt = module.HEAPF64[outLtPtr >> 3] ?? 0;
-        return { state, lt };
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 6 * 8, 8], (errPtr, outStatePtr, outLtPtr) => {
+            module.HEAPF64[outLtPtr >> 3] = 0;
+            const result = module._tspice_spkezr(targetPtr, et, refPtr, abcorrPtr, obsPtr, outStatePtr, outLtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            const state = Array.from(module.HEAPF64.subarray(outStatePtr >> 3, (outStatePtr >> 3) + 6));
+            const lt = module.HEAPF64[outLtPtr >> 3] ?? 0;
+            return { state, lt };
+        });
     }
     finally {
-        module._free(outLtPtr);
-        module._free(outStatePtr);
         module._free(obsPtr);
         module._free(abcorrPtr);
         module._free(refPtr);
         module._free(targetPtr);
-        module._free(errPtr);
     }
 }
 function tspiceCallSpkpos(module, target, et, ref, abcorr, obs) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
     const targetPtr = writeUtf8CString(module, target);
     const refPtr = writeUtf8CString(module, ref);
     const abcorrPtr = writeUtf8CString(module, abcorr);
     const obsPtr = writeUtf8CString(module, obs);
-    const outPosPtr = module._malloc(3 * 8);
-    const outLtPtr = module._malloc(8);
-    if (!errPtr || !targetPtr || !refPtr || !abcorrPtr || !obsPtr || !outPosPtr || !outLtPtr) {
-        for (const ptr of [outLtPtr, outPosPtr, obsPtr, abcorrPtr, refPtr, targetPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
     try {
-        module.HEAPF64[outLtPtr >> 3] = 0;
-        const result = module._tspice_spkpos(targetPtr, et, refPtr, abcorrPtr, obsPtr, outPosPtr, outLtPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const pos = Array.from(module.HEAPF64.subarray(outPosPtr >> 3, (outPosPtr >> 3) + 3));
-        const lt = module.HEAPF64[outLtPtr >> 3] ?? 0;
-        return { pos, lt };
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 3 * 8, 8], (errPtr, outPosPtr, outLtPtr) => {
+            module.HEAPF64[outLtPtr >> 3] = 0;
+            const result = module._tspice_spkpos(targetPtr, et, refPtr, abcorrPtr, obsPtr, outPosPtr, outLtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            const pos = Array.from(module.HEAPF64.subarray(outPosPtr >> 3, (outPosPtr >> 3) + 3));
+            const lt = module.HEAPF64[outLtPtr >> 3] ?? 0;
+            return { pos, lt };
+        });
     }
     finally {
-        module._free(outLtPtr);
-        module._free(outPosPtr);
         module._free(obsPtr);
         module._free(abcorrPtr);
         module._free(refPtr);
         module._free(targetPtr);
-        module._free(errPtr);
     }
 }
-export function createEphemerisApi(module) {
+function tspiceCallSpkez(module, target, et, ref, abcorr, observer) {
+    assertSpiceInt32(target, "spkez(target)");
+    assertSpiceInt32(observer, "spkez(observer)");
+    const refPtr = writeUtf8CString(module, ref);
+    const abcorrPtr = writeUtf8CString(module, abcorr);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 6 * 8, 8], (errPtr, outStatePtr, outLtPtr) => {
+            module.HEAPF64[outLtPtr >> 3] = 0;
+            const result = module._tspice_spkez(target, et, refPtr, abcorrPtr, observer, outStatePtr, outLtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            const state = Array.from(module.HEAPF64.subarray(outStatePtr >> 3, (outStatePtr >> 3) + 6));
+            const lt = module.HEAPF64[outLtPtr >> 3] ?? 0;
+            return { state, lt };
+        });
+    }
+    finally {
+        module._free(abcorrPtr);
+        module._free(refPtr);
+    }
+}
+function tspiceCallSpkezp(module, target, et, ref, abcorr, observer) {
+    assertSpiceInt32(target, "spkezp(target)");
+    assertSpiceInt32(observer, "spkezp(observer)");
+    const refPtr = writeUtf8CString(module, ref);
+    const abcorrPtr = writeUtf8CString(module, abcorr);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 3 * 8, 8], (errPtr, outPosPtr, outLtPtr) => {
+            module.HEAPF64[outLtPtr >> 3] = 0;
+            const result = module._tspice_spkezp(target, et, refPtr, abcorrPtr, observer, outPosPtr, outLtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            const pos = Array.from(module.HEAPF64.subarray(outPosPtr >> 3, (outPosPtr >> 3) + 3));
+            const lt = module.HEAPF64[outLtPtr >> 3] ?? 0;
+            return { pos, lt };
+        });
+    }
+    finally {
+        module._free(abcorrPtr);
+        module._free(refPtr);
+    }
+}
+function tspiceCallSpkgeo(module, target, et, ref, observer) {
+    assertSpiceInt32(target, "spkgeo(target)");
+    assertSpiceInt32(observer, "spkgeo(observer)");
+    const refPtr = writeUtf8CString(module, ref);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 6 * 8, 8], (errPtr, outStatePtr, outLtPtr) => {
+            module.HEAPF64[outLtPtr >> 3] = 0;
+            const result = module._tspice_spkgeo(target, et, refPtr, observer, outStatePtr, outLtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            const state = Array.from(module.HEAPF64.subarray(outStatePtr >> 3, (outStatePtr >> 3) + 6));
+            const lt = module.HEAPF64[outLtPtr >> 3] ?? 0;
+            return { state, lt };
+        });
+    }
+    finally {
+        module._free(refPtr);
+    }
+}
+function tspiceCallSpkgps(module, target, et, ref, observer) {
+    assertSpiceInt32(target, "spkgps(target)");
+    assertSpiceInt32(observer, "spkgps(observer)");
+    const refPtr = writeUtf8CString(module, ref);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 3 * 8, 8], (errPtr, outPosPtr, outLtPtr) => {
+            module.HEAPF64[outLtPtr >> 3] = 0;
+            const result = module._tspice_spkgps(target, et, refPtr, observer, outPosPtr, outLtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            const pos = Array.from(module.HEAPF64.subarray(outPosPtr >> 3, (outPosPtr >> 3) + 3));
+            const lt = module.HEAPF64[outLtPtr >> 3] ?? 0;
+            return { pos, lt };
+        });
+    }
+    finally {
+        module._free(refPtr);
+    }
+}
+function tspiceCallSpkssb(module, target, et, ref) {
+    assertSpiceInt32(target, "spkssb(target)");
+    const refPtr = writeUtf8CString(module, ref);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 6 * 8], (errPtr, outStatePtr) => {
+            const result = module._tspice_spkssb(target, et, refPtr, outStatePtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return Array.from(module.HEAPF64.subarray(outStatePtr >> 3, (outStatePtr >> 3) + 6));
+        });
+    }
+    finally {
+        module._free(refPtr);
+    }
+}
+function tspiceCallSpkcov(module, spk, idcode, cover) {
+    assertSpiceInt32(idcode, "spkcov(idcode)");
+    const resolvedSpk = resolveKernelPath(spk);
+    const spkPtr = writeUtf8CString(module, resolvedSpk);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES], (errPtr) => {
+            const result = module._tspice_spkcov(spkPtr, idcode, cover, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+        });
+    }
+    finally {
+        module._free(spkPtr);
+    }
+}
+function tspiceCallSpkobj(module, spk, ids) {
+    const resolvedSpk = resolveKernelPath(spk);
+    const spkPtr = writeUtf8CString(module, resolvedSpk);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES], (errPtr) => {
+            const result = module._tspice_spkobj(spkPtr, ids, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+        });
+    }
+    finally {
+        module._free(spkPtr);
+    }
+}
+function tspiceCallSpksfs(module, body, et) {
+    assertSpiceInt32(body, "spksfs(body)");
+    // SIDLEN=40 + NUL.
+    const identMaxBytes = 41;
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, 4, 5 * 8, identMaxBytes, 4], (errPtr, outHandlePtr, outDescrPtr, outIdentPtr, outFoundPtr) => {
+        module.HEAP32[outHandlePtr >> 2] = 0;
+        module.HEAP32[outFoundPtr >> 2] = 0;
+        module.HEAPU8[outIdentPtr] = 0;
+        const result = module._tspice_spksfs(body, et, outHandlePtr, outDescrPtr, outIdentPtr, identMaxBytes, outFoundPtr, errPtr, WASM_ERR_MAX_BYTES);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+        }
+        const found = (module.HEAP32[outFoundPtr >> 2] ?? 0) !== 0;
+        if (!found) {
+            return { found: false };
+        }
+        const handle = module.HEAP32[outHandlePtr >> 2] ?? 0;
+        const descr = Array.from(module.HEAPF64.subarray(outDescrPtr >> 3, (outDescrPtr >> 3) + 5));
+        const ident = readFixedWidthCString(module, outIdentPtr, identMaxBytes);
+        return {
+            found: true,
+            handle,
+            descr,
+            ident,
+        };
+    });
+}
+function tspiceCallSpkpds(module, body, center, frame, type, first, last) {
+    assertSpiceInt32(body, "spkpds(body)");
+    assertSpiceInt32(center, "spkpds(center)");
+    assertSpiceInt32(type, "spkpds(type)");
+    const framePtr = writeUtf8CString(module, frame);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 5 * 8], (errPtr, outDescrPtr) => {
+            const result = module._tspice_spkpds(body, center, framePtr, type, first, last, outDescrPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return Array.from(module.HEAPF64.subarray(outDescrPtr >> 3, (outDescrPtr >> 3) + 5));
+        });
+    }
+    finally {
+        module._free(framePtr);
+    }
+}
+function tspiceCallSpkuds(module, descr) {
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, 5 * 8, 4, 4, 4, 4, 8, 8, 4, 4], (errPtr, descrPtr, outBodyPtr, outCenterPtr, outFramePtr, outTypePtr, outFirstPtr, outLastPtr, outBaddrPtr, outEaddrPtr) => {
+        const base = descrPtr >> 3;
+        for (let i = 0; i < 5; i++) {
+            module.HEAPF64[base + i] = descr[i] ?? 0;
+        }
+        module.HEAP32[outBodyPtr >> 2] = 0;
+        module.HEAP32[outCenterPtr >> 2] = 0;
+        module.HEAP32[outFramePtr >> 2] = 0;
+        module.HEAP32[outTypePtr >> 2] = 0;
+        module.HEAPF64[outFirstPtr >> 3] = 0;
+        module.HEAPF64[outLastPtr >> 3] = 0;
+        module.HEAP32[outBaddrPtr >> 2] = 0;
+        module.HEAP32[outEaddrPtr >> 2] = 0;
+        const result = module._tspice_spkuds(descrPtr, outBodyPtr, outCenterPtr, outFramePtr, outTypePtr, outFirstPtr, outLastPtr, outBaddrPtr, outEaddrPtr, errPtr, WASM_ERR_MAX_BYTES);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+        }
+        return {
+            body: module.HEAP32[outBodyPtr >> 2] ?? 0,
+            center: module.HEAP32[outCenterPtr >> 2] ?? 0,
+            frame: module.HEAP32[outFramePtr >> 2] ?? 0,
+            type: module.HEAP32[outTypePtr >> 2] ?? 0,
+            first: module.HEAPF64[outFirstPtr >> 3] ?? 0,
+            last: module.HEAPF64[outLastPtr >> 3] ?? 0,
+            baddr: module.HEAP32[outBaddrPtr >> 2] ?? 0,
+            eaddr: module.HEAP32[outEaddrPtr >> 2] ?? 0,
+        };
+    });
+}
+/** Create an {@link EphemerisApi} implementation backed by a WASM Emscripten module. */
+export function createEphemerisApi(module, handles, virtualOutputs) {
+    const virtualOutputPathByHandle = new Map();
     return {
         spkezr: (target, et, ref, abcorr, observer) => tspiceCallSpkezr(module, target, et, ref, abcorr, observer),
         spkpos: (target, et, ref, abcorr, observer) => tspiceCallSpkpos(module, target, et, ref, abcorr, observer),
+        spkez: (target, et, ref, abcorr, observer) => tspiceCallSpkez(module, target, et, ref, abcorr, observer),
+        spkezp: (target, et, ref, abcorr, observer) => tspiceCallSpkezp(module, target, et, ref, abcorr, observer),
+        spkgeo: (target, et, ref, observer) => tspiceCallSpkgeo(module, target, et, ref, observer),
+        spkgps: (target, et, ref, observer) => tspiceCallSpkgps(module, target, et, ref, observer),
+        spkssb: (target, et, ref) => tspiceCallSpkssb(module, target, et, ref),
+        spkcov: (spk, idcode, cover) => tspiceCallSpkcov(module, spk, idcode, cover),
+        spkobj: (spk, ids) => tspiceCallSpkobj(module, spk, ids),
+        spksfs: (body, et) => tspiceCallSpksfs(module, body, et),
+        spkpds: (body, center, frame, type, first, last) => tspiceCallSpkpds(module, body, center, frame, type, first, last),
+        spkuds: (descr) => tspiceCallSpkuds(module, descr),
+        // --- SPK writers -------------------------------------------------------
+        spkopn: (file, ifname, ncomch) => {
+            const resolved = resolveSpkPath(file, "spkopn(file)");
+            ensureParentDir(module, resolved);
+            const nativeHandle = tspiceCallSpkopn(module, resolved, ifname, ncomch);
+            const handle = handles.register("SPK", nativeHandle);
+            if (typeof file !== "string") {
+                // `resolveSpkPath` already validated, but be defensive: callers can cast.
+                if (!isVirtualOutput(file)) {
+                    throw new Error("spkopn(file): expected VirtualOutput {kind:'virtual-output', path:string}");
+                }
+                virtualOutputs.markOpen(resolved);
+                virtualOutputPathByHandle.set(handle, resolved);
+            }
+            return handle;
+        },
+        spkopa: (file) => {
+            const resolved = resolveSpkPath(file, "spkopa(file)");
+            ensureParentDir(module, resolved);
+            const nativeHandle = tspiceCallSpkopa(module, resolved);
+            const handle = handles.register("SPK", nativeHandle);
+            if (typeof file !== "string") {
+                if (!isVirtualOutput(file)) {
+                    throw new Error("spkopa(file): expected VirtualOutput {kind:'virtual-output', path:string}");
+                }
+                virtualOutputs.markOpen(resolved);
+                virtualOutputPathByHandle.set(handle, resolved);
+            }
+            return handle;
+        },
+        spkcls: (handle) => {
+            const resolved = virtualOutputPathByHandle.get(handle);
+            handles.close(handle, ["SPK"], (entry) => callVoidHandle(module, module._tspice_spkcls, entry.nativeHandle), "spkcls");
+            if (resolved) {
+                virtualOutputs.markClosed(resolved);
+                virtualOutputPathByHandle.delete(handle);
+            }
+        },
+        spkw08: (handle, body, center, frame, first, last, segid, degree, states, epoch1, step) => {
+            if (!Array.isArray(states) && !(states instanceof Float64Array)) {
+                throw new Error("spkw08(states): expected number[] or Float64Array");
+            }
+            if (states.length === 0 || states.length % 6 !== 0) {
+                throw new Error("spkw08(): expected states.length to be a non-zero multiple of 6");
+            }
+            const n = states.length / 6;
+            if (!Number.isSafeInteger(n) || n <= 0 || n > I32_MAX) {
+                throw new Error(`spkw08(): expected states.length/6 to be a 32-bit signed integer (got n=${n})`);
+            }
+            if (states.length > I32_MAX) {
+                throw new Error(`spkw08(): expected states.length to be a 32-bit signed integer (got states.length=${states.length})`);
+            }
+            const nativeHandle = handles.lookup(handle, ["SPK"], "spkw08").nativeHandle;
+            tspiceCallSpkw08(module, nativeHandle, body, center, frame, first, last, segid, degree, states, epoch1, step);
+        },
     };
 }
 //# sourceMappingURL=ephemeris.js.map

package/backend-wasm/dist/domains/error.d.ts

@@ -0,0 +1,5 @@
+import { type ErrorApi } from "#backend-contract";
+import type { EmscriptenModule } from "../lowlevel/exports.js";
+/** Create an {@link ErrorApi} implementation backed by a WASM Emscripten module. */
+export declare function createErrorApi(module: EmscriptenModule): ErrorApi;
+//# sourceMappingURL=error.d.ts.map

package/backend-wasm/dist/domains/error.js

@@ -0,0 +1,109 @@
+import { assertGetmsgWhich } from "#backend-contract";
+import { WASM_ERR_MAX_BYTES, withMalloc, withAllocs } from "../codec/alloc.js";
+import { throwWasmSpiceError } from "../codec/errors.js";
+import { writeUtf8CString } from "../codec/strings.js";
+/** Create an {@link ErrorApi} implementation backed by a WASM Emscripten module. */
+export function createErrorApi(module) {
+    return {
+        failed: () => {
+            const errMaxBytes = WASM_ERR_MAX_BYTES;
+            return withAllocs(module, [4, errMaxBytes], (outFailedPtr, errPtr) => {
+                module.HEAP32[outFailedPtr >> 2] = 0;
+                const result = module._tspice_failed(outFailedPtr, errPtr, errMaxBytes);
+                if (result !== 0) {
+                    throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+                }
+                return (module.HEAP32[outFailedPtr >> 2] ?? 0) !== 0;
+            });
+        },
+        reset: () => {
+            const errMaxBytes = WASM_ERR_MAX_BYTES;
+            withMalloc(module, errMaxBytes, (errPtr) => {
+                const result = module._tspice_reset(errPtr, errMaxBytes);
+                if (result !== 0) {
+                    throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+                }
+            });
+        },
+        getmsg: (which) => {
+            assertGetmsgWhich(which);
+            const errMaxBytes = WASM_ERR_MAX_BYTES;
+            const outMaxBytes = WASM_ERR_MAX_BYTES;
+            const whichPtr = writeUtf8CString(module, which);
+            try {
+                return withAllocs(module, [outMaxBytes, errMaxBytes], (outPtr, errPtr) => {
+                    module.HEAPU8[outPtr] = 0;
+                    const result = module._tspice_getmsg(whichPtr, outPtr, outMaxBytes, errPtr, errMaxBytes);
+                    if (result !== 0) {
+                        throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+                    }
+                    return module.UTF8ToString(outPtr, outMaxBytes).trim();
+                });
+            }
+            finally {
+                module._free(whichPtr);
+            }
+        },
+        setmsg: (message) => {
+            const errMaxBytes = WASM_ERR_MAX_BYTES;
+            const messagePtr = writeUtf8CString(module, message);
+            try {
+                withMalloc(module, errMaxBytes, (errPtr) => {
+                    const result = module._tspice_setmsg(messagePtr, errPtr, errMaxBytes);
+                    if (result !== 0) {
+                        throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+                    }
+                });
+            }
+            finally {
+                module._free(messagePtr);
+            }
+        },
+        sigerr: (short) => {
+            const errMaxBytes = WASM_ERR_MAX_BYTES;
+            const shortPtr = writeUtf8CString(module, short);
+            try {
+                withMalloc(module, errMaxBytes, (errPtr) => {
+                    const result = module._tspice_sigerr(shortPtr, errPtr, errMaxBytes);
+                    if (result !== 0) {
+                        throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+                    }
+                });
+            }
+            finally {
+                module._free(shortPtr);
+            }
+        },
+        chkin: (name) => {
+            const errMaxBytes = WASM_ERR_MAX_BYTES;
+            const namePtr = writeUtf8CString(module, name);
+            try {
+                withMalloc(module, errMaxBytes, (errPtr) => {
+                    const result = module._tspice_chkin(namePtr, errPtr, errMaxBytes);
+                    if (result !== 0) {
+                        throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+                    }
+                });
+            }
+            finally {
+                module._free(namePtr);
+            }
+        },
+        chkout: (name) => {
+            const errMaxBytes = WASM_ERR_MAX_BYTES;
+            const namePtr = writeUtf8CString(module, name);
+            try {
+                withMalloc(module, errMaxBytes, (errPtr) => {
+                    const result = module._tspice_chkout(namePtr, errPtr, errMaxBytes);
+                    if (result !== 0) {
+                        throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+                    }
+                });
+            }
+            finally {
+                module._free(namePtr);
+            }
+        },
+    };
+}
+//# sourceMappingURL=error.js.map

package/backend-wasm/dist/domains/file-io.d.ts

@@ -0,0 +1,7 @@
+import type { FileIoApi } from "#backend-contract";
+import type { EmscriptenModule } from "../lowlevel/exports.js";
+import type { SpiceHandleRegistry } from "../runtime/spice-handles.js";
+import type { VirtualOutputRegistry } from "../runtime/virtual-outputs.js";
+/** Create a {@link FileIoApi} implementation backed by a WASM Emscripten module. */
+export declare function createFileIoApi(module: EmscriptenModule, handles: SpiceHandleRegistry, virtualOutputs: VirtualOutputRegistry): FileIoApi;
+//# sourceMappingURL=file-io.d.ts.map