@rybosome/tspice 0.0.1 → 0.0.2-alpha

package/backend-wasm/dist/index.js

@@ -1,1505 +1,2 @@
-export const WASM_JS_FILENAME = "tspice_backend_wasm.js";
-export const WASM_BINARY_FILENAME = "tspice_backend_wasm.wasm";
-function writeUtf8CString(module, value) {
-    const encoder = new TextEncoder();
-    const encoded = encoder.encode(value);
-    const ptr = module._malloc(encoded.length + 1);
-    if (!ptr) {
-        throw new Error("WASM malloc failed");
-    }
-    module.HEAPU8.set(encoded, ptr);
-    module.HEAPU8[ptr + encoded.length] = 0;
-    return ptr;
-}
-function throwWasmSpiceError(module, errPtr, errMaxBytes, code) {
-    const message = module.UTF8ToString(errPtr, errMaxBytes).trim();
-    throw new Error(message || `CSPICE call failed with code ${code}`);
-}
-function tspiceCall0(module, fn) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    if (!errPtr) {
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        const result = fn(errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-    }
-    finally {
-        module._free(errPtr);
-    }
-}
-function tspiceCall1Path(module, fn, path) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const pathPtr = writeUtf8CString(module, path);
-    if (!errPtr || !pathPtr) {
-        if (pathPtr)
-            module._free(pathPtr);
-        if (errPtr)
-            module._free(errPtr);
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        const result = fn(pathPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-    }
-    finally {
-        module._free(pathPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallKtotal(module, kind) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const kindPtr = writeUtf8CString(module, kind);
-    const outCountPtr = module._malloc(4);
-    if (!errPtr || !kindPtr || !outCountPtr) {
-        if (outCountPtr)
-            module._free(outCountPtr);
-        if (kindPtr)
-            module._free(kindPtr);
-        if (errPtr)
-            module._free(errPtr);
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAP32[outCountPtr >> 2] = 0;
-        const result = module._tspice_ktotal(kindPtr, outCountPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.HEAP32[outCountPtr >> 2] ?? 0;
-    }
-    finally {
-        module._free(outCountPtr);
-        module._free(kindPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallKdata(module, which, kind) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const kindPtr = writeUtf8CString(module, kind);
-    const fileMaxBytes = 2048;
-    const filtypMaxBytes = 256;
-    const sourceMaxBytes = 2048;
-    const filePtr = module._malloc(fileMaxBytes);
-    const filtypPtr = module._malloc(filtypMaxBytes);
-    const sourcePtr = module._malloc(sourceMaxBytes);
-    const handlePtr = module._malloc(4);
-    const foundPtr = module._malloc(4);
-    if (!errPtr ||
-        !kindPtr ||
-        !filePtr ||
-        !filtypPtr ||
-        !sourcePtr ||
-        !handlePtr ||
-        !foundPtr) {
-        for (const ptr of [foundPtr, handlePtr, sourcePtr, filtypPtr, filePtr, kindPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAP32[handlePtr >> 2] = 0;
-        module.HEAP32[foundPtr >> 2] = 0;
-        const result = module._tspice_kdata(which, kindPtr, filePtr, fileMaxBytes, filtypPtr, filtypMaxBytes, sourcePtr, sourceMaxBytes, handlePtr, foundPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const found = (module.HEAP32[foundPtr >> 2] ?? 0) !== 0;
-        if (!found) {
-            return { found: false };
-        }
-        return {
-            found: true,
-            file: module.UTF8ToString(filePtr, fileMaxBytes).trim(),
-            filtyp: module.UTF8ToString(filtypPtr, filtypMaxBytes).trim(),
-            source: module.UTF8ToString(sourcePtr, sourceMaxBytes).trim(),
-            handle: module.HEAP32[handlePtr >> 2] ?? 0,
-        };
-    }
-    finally {
-        module._free(foundPtr);
-        module._free(handlePtr);
-        module._free(sourcePtr);
-        module._free(filtypPtr);
-        module._free(filePtr);
-        module._free(kindPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallStr2et(module, utc) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const utcPtr = writeUtf8CString(module, utc);
-    const outEtPtr = module._malloc(8);
-    if (!errPtr || !utcPtr || !outEtPtr) {
-        for (const ptr of [outEtPtr, utcPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64[outEtPtr >> 3] = 0;
-        const result = module._tspice_str2et(utcPtr, outEtPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.HEAPF64[outEtPtr >> 3] ?? 0;
-    }
-    finally {
-        module._free(outEtPtr);
-        module._free(utcPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallEt2utc(module, et, format, prec) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const formatPtr = writeUtf8CString(module, format);
-    // Buffer size includes terminating NUL.
-    const outMaxBytes = 2048;
-    const outPtr = module._malloc(outMaxBytes);
-    if (!errPtr || !formatPtr || !outPtr) {
-        for (const ptr of [outPtr, formatPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPU8[outPtr] = 0;
-        const result = module._tspice_et2utc(et, formatPtr, prec, outPtr, outMaxBytes, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.UTF8ToString(outPtr, outMaxBytes).trim();
-    }
-    finally {
-        module._free(outPtr);
-        module._free(formatPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallTimout(module, et, picture) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const picturePtr = writeUtf8CString(module, picture);
-    // Buffer size includes terminating NUL.
-    const outMaxBytes = 2048;
-    const outPtr = module._malloc(outMaxBytes);
-    if (!errPtr || !picturePtr || !outPtr) {
-        for (const ptr of [outPtr, picturePtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPU8[outPtr] = 0;
-        const result = module._tspice_timout(et, picturePtr, outPtr, outMaxBytes, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.UTF8ToString(outPtr, outMaxBytes).trim();
-    }
-    finally {
-        module._free(outPtr);
-        module._free(picturePtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallFoundInt(module, fn, arg) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const argPtr = writeUtf8CString(module, arg);
-    const outPtr = module._malloc(4);
-    const foundPtr = module._malloc(4);
-    if (!errPtr || !argPtr || !outPtr || !foundPtr) {
-        for (const ptr of [foundPtr, outPtr, argPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAP32[outPtr >> 2] = 0;
-        module.HEAP32[foundPtr >> 2] = 0;
-        const result = fn(argPtr, outPtr, foundPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const found = (module.HEAP32[foundPtr >> 2] ?? 0) !== 0;
-        if (!found) {
-            return { found: false };
-        }
-        return { found: true, value: module.HEAP32[outPtr >> 2] ?? 0 };
-    }
-    finally {
-        module._free(foundPtr);
-        module._free(outPtr);
-        module._free(argPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallFoundString(module, fn, code) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const outMaxBytes = 256;
-    const outPtr = module._malloc(outMaxBytes);
-    const foundPtr = module._malloc(4);
-    if (!errPtr || !outPtr || !foundPtr) {
-        for (const ptr of [foundPtr, outPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPU8[outPtr] = 0;
-        module.HEAP32[foundPtr >> 2] = 0;
-        const result = fn(code, outPtr, outMaxBytes, foundPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const found = (module.HEAP32[foundPtr >> 2] ?? 0) !== 0;
-        if (!found) {
-            return { found: false };
-        }
-        return { found: true, value: module.UTF8ToString(outPtr, outMaxBytes).trim() };
-    }
-    finally {
-        module._free(foundPtr);
-        module._free(outPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallCidfrm(module, fn, center) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const outNameMaxBytes = 256;
-    const outNamePtr = module._malloc(outNameMaxBytes);
-    const outCodePtr = module._malloc(4);
-    const foundPtr = module._malloc(4);
-    if (!errPtr || !outNamePtr || !outCodePtr || !foundPtr) {
-        for (const ptr of [foundPtr, outCodePtr, outNamePtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPU8[outNamePtr] = 0;
-        module.HEAP32[outCodePtr >> 2] = 0;
-        module.HEAP32[foundPtr >> 2] = 0;
-        const result = fn(center, outCodePtr, outNamePtr, outNameMaxBytes, foundPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const found = (module.HEAP32[foundPtr >> 2] ?? 0) !== 0;
-        if (!found) {
-            return { found: false };
-        }
-        return {
-            found: true,
-            frcode: module.HEAP32[outCodePtr >> 2] ?? 0,
-            frname: module.UTF8ToString(outNamePtr, outNameMaxBytes).trim(),
-        };
-    }
-    finally {
-        module._free(foundPtr);
-        module._free(outCodePtr);
-        module._free(outNamePtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallCnmfrm(module, fn, centerName) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const centerNamePtr = writeUtf8CString(module, centerName);
-    const outNameMaxBytes = 256;
-    const outNamePtr = module._malloc(outNameMaxBytes);
-    const outCodePtr = module._malloc(4);
-    const foundPtr = module._malloc(4);
-    if (!errPtr || !centerNamePtr || !outNamePtr || !outCodePtr || !foundPtr) {
-        for (const ptr of [foundPtr, outCodePtr, outNamePtr, centerNamePtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPU8[outNamePtr] = 0;
-        module.HEAP32[outCodePtr >> 2] = 0;
-        module.HEAP32[foundPtr >> 2] = 0;
-        const result = fn(centerNamePtr, outCodePtr, outNamePtr, outNameMaxBytes, foundPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const found = (module.HEAP32[foundPtr >> 2] ?? 0) !== 0;
-        if (!found) {
-            return { found: false };
-        }
-        return {
-            found: true,
-            frcode: module.HEAP32[outCodePtr >> 2] ?? 0,
-            frname: module.UTF8ToString(outNamePtr, outNameMaxBytes).trim(),
-        };
-    }
-    finally {
-        module._free(foundPtr);
-        module._free(outCodePtr);
-        module._free(outNamePtr);
-        module._free(centerNamePtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallScs2e(module, sc, sclkch) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const sclkchPtr = writeUtf8CString(module, sclkch);
-    const outEtPtr = module._malloc(8);
-    if (!errPtr || !sclkchPtr || !outEtPtr) {
-        for (const ptr of [outEtPtr, sclkchPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64[outEtPtr >> 3] = 0;
-        const result = module._tspice_scs2e(sc, sclkchPtr, outEtPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.HEAPF64[outEtPtr >> 3] ?? 0;
-    }
-    finally {
-        module._free(outEtPtr);
-        module._free(sclkchPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallSce2s(module, sc, et) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const outMaxBytes = 2048;
-    const outPtr = module._malloc(outMaxBytes);
-    if (!errPtr || !outPtr) {
-        for (const ptr of [outPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPU8[outPtr] = 0;
-        const result = module._tspice_sce2s(sc, et, outPtr, outMaxBytes, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.UTF8ToString(outPtr, outMaxBytes).trim();
-    }
-    finally {
-        module._free(outPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallCkgp(module, inst, sclkdp, tol, ref) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const refPtr = writeUtf8CString(module, ref);
-    const outCmatPtr = module._malloc(9 * 8);
-    const outClkoutPtr = module._malloc(8);
-    const foundPtr = module._malloc(4);
-    if (!errPtr || !refPtr || !outCmatPtr || !outClkoutPtr || !foundPtr) {
-        for (const ptr of [foundPtr, outClkoutPtr, outCmatPtr, refPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64[outClkoutPtr >> 3] = 0;
-        module.HEAP32[foundPtr >> 2] = 0;
-        const result = module._tspice_ckgp(inst, sclkdp, tol, refPtr, outCmatPtr, outClkoutPtr, foundPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const found = (module.HEAP32[foundPtr >> 2] ?? 0) !== 0;
-        if (!found) {
-            return { found: false };
-        }
-        const cmat = Array.from(module.HEAPF64.subarray(outCmatPtr >> 3, (outCmatPtr >> 3) + 9));
-        const clkout = module.HEAPF64[outClkoutPtr >> 3] ?? 0;
-        return { found: true, cmat, clkout };
-    }
-    finally {
-        module._free(foundPtr);
-        module._free(outClkoutPtr);
-        module._free(outCmatPtr);
-        module._free(refPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallCkgpav(module, inst, sclkdp, tol, ref) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const refPtr = writeUtf8CString(module, ref);
-    const outCmatPtr = module._malloc(9 * 8);
-    const outAvPtr = module._malloc(3 * 8);
-    const outClkoutPtr = module._malloc(8);
-    const foundPtr = module._malloc(4);
-    if (!errPtr || !refPtr || !outCmatPtr || !outAvPtr || !outClkoutPtr || !foundPtr) {
-        for (const ptr of [foundPtr, outClkoutPtr, outAvPtr, outCmatPtr, refPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64[outClkoutPtr >> 3] = 0;
-        module.HEAP32[foundPtr >> 2] = 0;
-        const result = module._tspice_ckgpav(inst, sclkdp, tol, refPtr, outCmatPtr, outAvPtr, outClkoutPtr, foundPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const found = (module.HEAP32[foundPtr >> 2] ?? 0) !== 0;
-        if (!found) {
-            return { found: false };
-        }
-        const cmat = Array.from(module.HEAPF64.subarray(outCmatPtr >> 3, (outCmatPtr >> 3) + 9));
-        const av = Array.from(module.HEAPF64.subarray(outAvPtr >> 3, (outAvPtr >> 3) + 3));
-        const clkout = module.HEAPF64[outClkoutPtr >> 3] ?? 0;
-        return { found: true, cmat, av, clkout };
-    }
-    finally {
-        module._free(foundPtr);
-        module._free(outClkoutPtr);
-        module._free(outAvPtr);
-        module._free(outCmatPtr);
-        module._free(refPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallPxform(module, from, to, et) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const fromPtr = writeUtf8CString(module, from);
-    const toPtr = writeUtf8CString(module, to);
-    const outPtr = module._malloc(9 * 8);
-    if (!errPtr || !fromPtr || !toPtr || !outPtr) {
-        for (const ptr of [outPtr, toPtr, fromPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        const result = module._tspice_pxform(fromPtr, toPtr, et, outPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const out = Array.from(module.HEAPF64.subarray(outPtr >> 3, (outPtr >> 3) + 9));
-        return out;
-    }
-    finally {
-        module._free(outPtr);
-        module._free(toPtr);
-        module._free(fromPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallSxform(module, from, to, et) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const fromPtr = writeUtf8CString(module, from);
-    const toPtr = writeUtf8CString(module, to);
-    const outPtr = module._malloc(36 * 8);
-    if (!errPtr || !fromPtr || !toPtr || !outPtr) {
-        for (const ptr of [outPtr, toPtr, fromPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        const result = module._tspice_sxform(fromPtr, toPtr, et, outPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const out = Array.from(module.HEAPF64.subarray(outPtr >> 3, (outPtr >> 3) + 36));
-        return out;
-    }
-    finally {
-        module._free(outPtr);
-        module._free(toPtr);
-        module._free(fromPtr);
-        module._free(errPtr);
-    }
-}
-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 };
-    }
-    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 };
-    }
-    finally {
-        module._free(outLtPtr);
-        module._free(outPosPtr);
-        module._free(obsPtr);
-        module._free(abcorrPtr);
-        module._free(refPtr);
-        module._free(targetPtr);
-        module._free(errPtr);
-    }
-}
-// --- Derived geometry primitives ---
-function tspiceCallSubpnt(module, method, target, et, fixref, abcorr, observer) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const methodPtr = writeUtf8CString(module, method);
-    const targetPtr = writeUtf8CString(module, target);
-    const fixrefPtr = writeUtf8CString(module, fixref);
-    const abcorrPtr = writeUtf8CString(module, abcorr);
-    const observerPtr = writeUtf8CString(module, observer);
-    const outSpointPtr = module._malloc(3 * 8);
-    const outTrgepcPtr = module._malloc(8);
-    const outSrfvecPtr = module._malloc(3 * 8);
-    if (!errPtr ||
-        !methodPtr ||
-        !targetPtr ||
-        !fixrefPtr ||
-        !abcorrPtr ||
-        !observerPtr ||
-        !outSpointPtr ||
-        !outTrgepcPtr ||
-        !outSrfvecPtr) {
-        for (const ptr of [
-            outSrfvecPtr,
-            outTrgepcPtr,
-            outSpointPtr,
-            observerPtr,
-            abcorrPtr,
-            fixrefPtr,
-            targetPtr,
-            methodPtr,
-            errPtr,
-        ]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64[outTrgepcPtr >> 3] = 0;
-        const result = module._tspice_subpnt(methodPtr, targetPtr, et, fixrefPtr, abcorrPtr, observerPtr, outSpointPtr, outTrgepcPtr, outSrfvecPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const spoint = Array.from(module.HEAPF64.subarray(outSpointPtr >> 3, (outSpointPtr >> 3) + 3));
-        const trgepc = module.HEAPF64[outTrgepcPtr >> 3] ?? 0;
-        const srfvec = Array.from(module.HEAPF64.subarray(outSrfvecPtr >> 3, (outSrfvecPtr >> 3) + 3));
-        return { spoint, trgepc, srfvec };
-    }
-    finally {
-        module._free(outSrfvecPtr);
-        module._free(outTrgepcPtr);
-        module._free(outSpointPtr);
-        module._free(observerPtr);
-        module._free(abcorrPtr);
-        module._free(fixrefPtr);
-        module._free(targetPtr);
-        module._free(methodPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallSubslr(module, method, target, et, fixref, abcorr, observer) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const methodPtr = writeUtf8CString(module, method);
-    const targetPtr = writeUtf8CString(module, target);
-    const fixrefPtr = writeUtf8CString(module, fixref);
-    const abcorrPtr = writeUtf8CString(module, abcorr);
-    const observerPtr = writeUtf8CString(module, observer);
-    const outSpointPtr = module._malloc(3 * 8);
-    const outTrgepcPtr = module._malloc(8);
-    const outSrfvecPtr = module._malloc(3 * 8);
-    if (!errPtr ||
-        !methodPtr ||
-        !targetPtr ||
-        !fixrefPtr ||
-        !abcorrPtr ||
-        !observerPtr ||
-        !outSpointPtr ||
-        !outTrgepcPtr ||
-        !outSrfvecPtr) {
-        for (const ptr of [
-            outSrfvecPtr,
-            outTrgepcPtr,
-            outSpointPtr,
-            observerPtr,
-            abcorrPtr,
-            fixrefPtr,
-            targetPtr,
-            methodPtr,
-            errPtr,
-        ]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64[outTrgepcPtr >> 3] = 0;
-        const result = module._tspice_subslr(methodPtr, targetPtr, et, fixrefPtr, abcorrPtr, observerPtr, outSpointPtr, outTrgepcPtr, outSrfvecPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const spoint = Array.from(module.HEAPF64.subarray(outSpointPtr >> 3, (outSpointPtr >> 3) + 3));
-        const trgepc = module.HEAPF64[outTrgepcPtr >> 3] ?? 0;
-        const srfvec = Array.from(module.HEAPF64.subarray(outSrfvecPtr >> 3, (outSrfvecPtr >> 3) + 3));
-        return { spoint, trgepc, srfvec };
-    }
-    finally {
-        module._free(outSrfvecPtr);
-        module._free(outTrgepcPtr);
-        module._free(outSpointPtr);
-        module._free(observerPtr);
-        module._free(abcorrPtr);
-        module._free(fixrefPtr);
-        module._free(targetPtr);
-        module._free(methodPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallSincpt(module, method, target, et, fixref, abcorr, observer, dref, dvec) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const methodPtr = writeUtf8CString(module, method);
-    const targetPtr = writeUtf8CString(module, target);
-    const fixrefPtr = writeUtf8CString(module, fixref);
-    const abcorrPtr = writeUtf8CString(module, abcorr);
-    const observerPtr = writeUtf8CString(module, observer);
-    const drefPtr = writeUtf8CString(module, dref);
-    const dvecPtr = module._malloc(3 * 8);
-    const outSpointPtr = module._malloc(3 * 8);
-    const outTrgepcPtr = module._malloc(8);
-    const outSrfvecPtr = module._malloc(3 * 8);
-    const outFoundPtr = module._malloc(4);
-    if (!errPtr ||
-        !methodPtr ||
-        !targetPtr ||
-        !fixrefPtr ||
-        !abcorrPtr ||
-        !observerPtr ||
-        !drefPtr ||
-        !dvecPtr ||
-        !outSpointPtr ||
-        !outTrgepcPtr ||
-        !outSrfvecPtr ||
-        !outFoundPtr) {
-        for (const ptr of [
-            outFoundPtr,
-            outSrfvecPtr,
-            outTrgepcPtr,
-            outSpointPtr,
-            dvecPtr,
-            drefPtr,
-            observerPtr,
-            abcorrPtr,
-            fixrefPtr,
-            targetPtr,
-            methodPtr,
-            errPtr,
-        ]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(dvec, dvecPtr >> 3);
-        module.HEAPF64[outTrgepcPtr >> 3] = 0;
-        module.HEAP32[outFoundPtr >> 2] = 0;
-        const result = module._tspice_sincpt(methodPtr, targetPtr, et, fixrefPtr, abcorrPtr, observerPtr, drefPtr, dvecPtr, outSpointPtr, outTrgepcPtr, outSrfvecPtr, outFoundPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const found = module.HEAP32[outFoundPtr >> 2] ?? 0;
-        if (!found) {
-            return { found: false };
-        }
-        const spoint = Array.from(module.HEAPF64.subarray(outSpointPtr >> 3, (outSpointPtr >> 3) + 3));
-        const trgepc = module.HEAPF64[outTrgepcPtr >> 3] ?? 0;
-        const srfvec = Array.from(module.HEAPF64.subarray(outSrfvecPtr >> 3, (outSrfvecPtr >> 3) + 3));
-        return { found: true, spoint, trgepc, srfvec };
-    }
-    finally {
-        module._free(outFoundPtr);
-        module._free(outSrfvecPtr);
-        module._free(outTrgepcPtr);
-        module._free(outSpointPtr);
-        module._free(dvecPtr);
-        module._free(drefPtr);
-        module._free(observerPtr);
-        module._free(abcorrPtr);
-        module._free(fixrefPtr);
-        module._free(targetPtr);
-        module._free(methodPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallIlumin(module, method, target, et, fixref, abcorr, observer, spoint) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const methodPtr = writeUtf8CString(module, method);
-    const targetPtr = writeUtf8CString(module, target);
-    const fixrefPtr = writeUtf8CString(module, fixref);
-    const abcorrPtr = writeUtf8CString(module, abcorr);
-    const observerPtr = writeUtf8CString(module, observer);
-    const spointPtr = module._malloc(3 * 8);
-    const outTrgepcPtr = module._malloc(8);
-    const outSrfvecPtr = module._malloc(3 * 8);
-    const outPhasePtr = module._malloc(8);
-    const outIncdncPtr = module._malloc(8);
-    const outEmissnPtr = module._malloc(8);
-    if (!errPtr ||
-        !methodPtr ||
-        !targetPtr ||
-        !fixrefPtr ||
-        !abcorrPtr ||
-        !observerPtr ||
-        !spointPtr ||
-        !outTrgepcPtr ||
-        !outSrfvecPtr ||
-        !outPhasePtr ||
-        !outIncdncPtr ||
-        !outEmissnPtr) {
-        for (const ptr of [
-            outEmissnPtr,
-            outIncdncPtr,
-            outPhasePtr,
-            outSrfvecPtr,
-            outTrgepcPtr,
-            spointPtr,
-            observerPtr,
-            abcorrPtr,
-            fixrefPtr,
-            targetPtr,
-            methodPtr,
-            errPtr,
-        ]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(spoint, spointPtr >> 3);
-        module.HEAPF64[outTrgepcPtr >> 3] = 0;
-        module.HEAPF64[outPhasePtr >> 3] = 0;
-        module.HEAPF64[outIncdncPtr >> 3] = 0;
-        module.HEAPF64[outEmissnPtr >> 3] = 0;
-        const result = module._tspice_ilumin(methodPtr, targetPtr, et, fixrefPtr, abcorrPtr, observerPtr, spointPtr, outTrgepcPtr, outSrfvecPtr, outPhasePtr, outIncdncPtr, outEmissnPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        const trgepc = module.HEAPF64[outTrgepcPtr >> 3] ?? 0;
-        const srfvec = Array.from(module.HEAPF64.subarray(outSrfvecPtr >> 3, (outSrfvecPtr >> 3) + 3));
-        const phase = module.HEAPF64[outPhasePtr >> 3] ?? 0;
-        const incdnc = module.HEAPF64[outIncdncPtr >> 3] ?? 0;
-        const emissn = module.HEAPF64[outEmissnPtr >> 3] ?? 0;
-        return { trgepc, srfvec, phase, incdnc, emissn };
-    }
-    finally {
-        module._free(outEmissnPtr);
-        module._free(outIncdncPtr);
-        module._free(outPhasePtr);
-        module._free(outSrfvecPtr);
-        module._free(outTrgepcPtr);
-        module._free(spointPtr);
-        module._free(observerPtr);
-        module._free(abcorrPtr);
-        module._free(fixrefPtr);
-        module._free(targetPtr);
-        module._free(methodPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallOccult(module, targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const targ1Ptr = writeUtf8CString(module, targ1);
-    const shape1Ptr = writeUtf8CString(module, shape1);
-    const frame1Ptr = writeUtf8CString(module, frame1);
-    const targ2Ptr = writeUtf8CString(module, targ2);
-    const shape2Ptr = writeUtf8CString(module, shape2);
-    const frame2Ptr = writeUtf8CString(module, frame2);
-    const abcorrPtr = writeUtf8CString(module, abcorr);
-    const observerPtr = writeUtf8CString(module, observer);
-    const outOcltidPtr = module._malloc(4);
-    if (!errPtr ||
-        !targ1Ptr ||
-        !shape1Ptr ||
-        !frame1Ptr ||
-        !targ2Ptr ||
-        !shape2Ptr ||
-        !frame2Ptr ||
-        !abcorrPtr ||
-        !observerPtr ||
-        !outOcltidPtr) {
-        for (const ptr of [
-            outOcltidPtr,
-            observerPtr,
-            abcorrPtr,
-            frame2Ptr,
-            shape2Ptr,
-            targ2Ptr,
-            frame1Ptr,
-            shape1Ptr,
-            targ1Ptr,
-            errPtr,
-        ]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAP32[outOcltidPtr >> 2] = 0;
-        const result = module._tspice_occult(targ1Ptr, shape1Ptr, frame1Ptr, targ2Ptr, shape2Ptr, frame2Ptr, abcorrPtr, observerPtr, et, outOcltidPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.HEAP32[outOcltidPtr >> 2] ?? 0;
-    }
-    finally {
-        module._free(outOcltidPtr);
-        module._free(observerPtr);
-        module._free(abcorrPtr);
-        module._free(frame2Ptr);
-        module._free(shape2Ptr);
-        module._free(targ2Ptr);
-        module._free(frame1Ptr);
-        module._free(shape1Ptr);
-        module._free(targ1Ptr);
-        module._free(errPtr);
-    }
-}
-// --- coordinate conversions + small vector/matrix helpers ---
-function tspiceCallReclat(module, rect) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const rectPtr = module._malloc(3 * 8);
-    const outRadiusPtr = module._malloc(8);
-    const outLonPtr = module._malloc(8);
-    const outLatPtr = module._malloc(8);
-    if (!errPtr || !rectPtr || !outRadiusPtr || !outLonPtr || !outLatPtr) {
-        for (const ptr of [outLatPtr, outLonPtr, outRadiusPtr, rectPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(rect, rectPtr >> 3);
-        module.HEAPF64[outRadiusPtr >> 3] = 0;
-        module.HEAPF64[outLonPtr >> 3] = 0;
-        module.HEAPF64[outLatPtr >> 3] = 0;
-        const result = module._tspice_reclat(rectPtr, outRadiusPtr, outLonPtr, outLatPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return {
-            radius: module.HEAPF64[outRadiusPtr >> 3] ?? 0,
-            lon: module.HEAPF64[outLonPtr >> 3] ?? 0,
-            lat: module.HEAPF64[outLatPtr >> 3] ?? 0,
-        };
-    }
-    finally {
-        module._free(outLatPtr);
-        module._free(outLonPtr);
-        module._free(outRadiusPtr);
-        module._free(rectPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallLatrec(module, radius, lon, lat) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const outRectPtr = module._malloc(3 * 8);
-    if (!errPtr || !outRectPtr) {
-        for (const ptr of [outRectPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set([0, 0, 0], outRectPtr >> 3);
-        const result = module._tspice_latrec(radius, lon, lat, outRectPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return Array.from(module.HEAPF64.subarray(outRectPtr >> 3, (outRectPtr >> 3) + 3));
-    }
-    finally {
-        module._free(outRectPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallRecsph(module, rect) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const rectPtr = module._malloc(3 * 8);
-    const outRadiusPtr = module._malloc(8);
-    const outColatPtr = module._malloc(8);
-    const outLonPtr = module._malloc(8);
-    if (!errPtr || !rectPtr || !outRadiusPtr || !outColatPtr || !outLonPtr) {
-        for (const ptr of [outLonPtr, outColatPtr, outRadiusPtr, rectPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(rect, rectPtr >> 3);
-        module.HEAPF64[outRadiusPtr >> 3] = 0;
-        module.HEAPF64[outColatPtr >> 3] = 0;
-        module.HEAPF64[outLonPtr >> 3] = 0;
-        const result = module._tspice_recsph(rectPtr, outRadiusPtr, outColatPtr, outLonPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return {
-            radius: module.HEAPF64[outRadiusPtr >> 3] ?? 0,
-            colat: module.HEAPF64[outColatPtr >> 3] ?? 0,
-            lon: module.HEAPF64[outLonPtr >> 3] ?? 0,
-        };
-    }
-    finally {
-        module._free(outLonPtr);
-        module._free(outColatPtr);
-        module._free(outRadiusPtr);
-        module._free(rectPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallSphrec(module, radius, colat, lon) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const outRectPtr = module._malloc(3 * 8);
-    if (!errPtr || !outRectPtr) {
-        for (const ptr of [outRectPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set([0, 0, 0], outRectPtr >> 3);
-        const result = module._tspice_sphrec(radius, colat, lon, outRectPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return Array.from(module.HEAPF64.subarray(outRectPtr >> 3, (outRectPtr >> 3) + 3));
-    }
-    finally {
-        module._free(outRectPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallVnorm(module, v) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const vPtr = module._malloc(3 * 8);
-    const outNormPtr = module._malloc(8);
-    if (!errPtr || !vPtr || !outNormPtr) {
-        for (const ptr of [outNormPtr, vPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(v, vPtr >> 3);
-        module.HEAPF64[outNormPtr >> 3] = 0;
-        const result = module._tspice_vnorm(vPtr, outNormPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.HEAPF64[outNormPtr >> 3] ?? 0;
-    }
-    finally {
-        module._free(outNormPtr);
-        module._free(vPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallVhat(module, v) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const vPtr = module._malloc(3 * 8);
-    const outPtr = module._malloc(3 * 8);
-    if (!errPtr || !vPtr || !outPtr) {
-        for (const ptr of [outPtr, vPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(v, vPtr >> 3);
-        module.HEAPF64.set([0, 0, 0], outPtr >> 3);
-        const result = module._tspice_vhat(vPtr, outPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return Array.from(module.HEAPF64.subarray(outPtr >> 3, (outPtr >> 3) + 3));
-    }
-    finally {
-        module._free(outPtr);
-        module._free(vPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallVdot(module, a, b) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const aPtr = module._malloc(3 * 8);
-    const bPtr = module._malloc(3 * 8);
-    const outDotPtr = module._malloc(8);
-    if (!errPtr || !aPtr || !bPtr || !outDotPtr) {
-        for (const ptr of [outDotPtr, bPtr, aPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(a, aPtr >> 3);
-        module.HEAPF64.set(b, bPtr >> 3);
-        module.HEAPF64[outDotPtr >> 3] = 0;
-        const result = module._tspice_vdot(aPtr, bPtr, outDotPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return module.HEAPF64[outDotPtr >> 3] ?? 0;
-    }
-    finally {
-        module._free(outDotPtr);
-        module._free(bPtr);
-        module._free(aPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallVcrss(module, a, b) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const aPtr = module._malloc(3 * 8);
-    const bPtr = module._malloc(3 * 8);
-    const outPtr = module._malloc(3 * 8);
-    if (!errPtr || !aPtr || !bPtr || !outPtr) {
-        for (const ptr of [outPtr, bPtr, aPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(a, aPtr >> 3);
-        module.HEAPF64.set(b, bPtr >> 3);
-        module.HEAPF64.set([0, 0, 0], outPtr >> 3);
-        const result = module._tspice_vcrss(aPtr, bPtr, outPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return Array.from(module.HEAPF64.subarray(outPtr >> 3, (outPtr >> 3) + 3));
-    }
-    finally {
-        module._free(outPtr);
-        module._free(bPtr);
-        module._free(aPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallMxv(module, m, v) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const mPtr = module._malloc(9 * 8);
-    const vPtr = module._malloc(3 * 8);
-    const outPtr = module._malloc(3 * 8);
-    if (!errPtr || !mPtr || !vPtr || !outPtr) {
-        for (const ptr of [outPtr, vPtr, mPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(m, mPtr >> 3);
-        module.HEAPF64.set(v, vPtr >> 3);
-        module.HEAPF64.set([0, 0, 0], outPtr >> 3);
-        const result = module._tspice_mxv(mPtr, vPtr, outPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return Array.from(module.HEAPF64.subarray(outPtr >> 3, (outPtr >> 3) + 3));
-    }
-    finally {
-        module._free(outPtr);
-        module._free(vPtr);
-        module._free(mPtr);
-        module._free(errPtr);
-    }
-}
-function tspiceCallMtxv(module, m, v) {
-    const errMaxBytes = 2048;
-    const errPtr = module._malloc(errMaxBytes);
-    const mPtr = module._malloc(9 * 8);
-    const vPtr = module._malloc(3 * 8);
-    const outPtr = module._malloc(3 * 8);
-    if (!errPtr || !mPtr || !vPtr || !outPtr) {
-        for (const ptr of [outPtr, vPtr, mPtr, errPtr]) {
-            if (ptr)
-                module._free(ptr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        module.HEAPF64.set(m, mPtr >> 3);
-        module.HEAPF64.set(v, vPtr >> 3);
-        module.HEAPF64.set([0, 0, 0], outPtr >> 3);
-        const result = module._tspice_mtxv(mPtr, vPtr, outPtr, errPtr, errMaxBytes);
-        if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
-        }
-        return Array.from(module.HEAPF64.subarray(outPtr >> 3, (outPtr >> 3) + 3));
-    }
-    finally {
-        module._free(outPtr);
-        module._free(vPtr);
-        module._free(mPtr);
-        module._free(errPtr);
-    }
-}
-function getToolkitVersion(module) {
-    const outMaxBytes = 256;
-    const errMaxBytes = 2048;
-    const outPtr = module._malloc(outMaxBytes);
-    const errPtr = module._malloc(errMaxBytes);
-    if (!outPtr || !errPtr) {
-        if (errPtr) {
-            module._free(errPtr);
-        }
-        if (outPtr) {
-            module._free(outPtr);
-        }
-        throw new Error("WASM malloc failed");
-    }
-    try {
-        const result = module._tspice_tkvrsn_toolkit(outPtr, outMaxBytes, errPtr, errMaxBytes);
-        if (result !== 0) {
-            const message = module.UTF8ToString(errPtr, errMaxBytes).trim();
-            throw new Error(message || `CSPICE call failed with code ${result}`);
-        }
-        return module.UTF8ToString(outPtr, outMaxBytes);
-    }
-    finally {
-        module._free(errPtr);
-        module._free(outPtr);
-    }
-}
-export async function createWasmBackend(options = {}) {
-    // NOTE: Keep this as a literal string so bundlers (Vite) don't generate a
-    // runtime glob map for *every* file in this directory (including *.d.ts.map),
-    // which can lead to JSON being imported as an ESM module.
-    const defaultWasmUrl = new URL("./tspice_backend_wasm.wasm", import.meta.url);
-    const wasmUrl = options.wasmUrl?.toString() ?? defaultWasmUrl.href;
-    let createEmscriptenModule;
-    try {
-        // NOTE: This must be a literal import path so bundlers like Vite don't
-        // rewrite the glue JS into an asset URL module (via `new URL(..., import.meta.url)`
-        // + `?url`) which breaks `import()`.
-        ({ default: createEmscriptenModule } = (await import("./tspice_backend_wasm.js")));
-    }
-    catch (error) {
-        throw new Error(`Failed to load tspice WASM glue (./${WASM_JS_FILENAME}): ${String(error)}`);
-    }
-    const wasmLocator = wasmUrl;
-    const isNodeRuntime = 
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    typeof process !== "undefined" &&
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        !!process.versions?.node;
-    // Node's built-in `fetch` can't load `file://...` URLs, so in Node we feed the
-    // bytes directly to Emscripten via `wasmBinary`.
-    const wasmBinary = isNodeRuntime && wasmUrl.startsWith("file://")
-        ? await (async () => {
-            const [{ readFile }, { fileURLToPath }] = await Promise.all([
-                import("node:fs/promises"),
-                import("node:url"),
-            ]);
-            const wasmPath = fileURLToPath(wasmUrl);
-            return readFile(wasmPath);
-        })()
-        : undefined;
-    let module;
-    try {
-        module = (await createEmscriptenModule({
-            locateFile(path, prefix) {
-                if (path === WASM_BINARY_FILENAME) {
-                    return wasmLocator;
-                }
-                return `${prefix}${path}`;
-            },
-            ...(wasmBinary ? { wasmBinary } : {}),
-        }));
-    }
-    catch (error) {
-        throw new Error(`Failed to initialize tspice WASM module (wasmUrl=${wasmUrl}): ${String(error)}`);
-    }
-    if (typeof module._tspice_tkvrsn_toolkit !== "function" ||
-        typeof module._malloc !== "function" ||
-        typeof module._free !== "function" ||
-        typeof module.UTF8ToString !== "function" ||
-        typeof module._tspice_furnsh !== "function" ||
-        typeof module._tspice_unload !== "function" ||
-        typeof module._tspice_kclear !== "function" ||
-        typeof module._tspice_ktotal !== "function" ||
-        typeof module._tspice_kdata !== "function" ||
-        typeof module._tspice_str2et !== "function" ||
-        typeof module._tspice_et2utc !== "function" ||
-        typeof module._tspice_timout !== "function" ||
-        typeof module._tspice_bodn2c !== "function" ||
-        typeof module._tspice_bodc2n !== "function" ||
-        typeof module._tspice_namfrm !== "function" ||
-        typeof module._tspice_frmnam !== "function" ||
-        typeof module._tspice_scs2e !== "function" ||
-        typeof module._tspice_sce2s !== "function" ||
-        typeof module._tspice_ckgp !== "function" ||
-        typeof module._tspice_ckgpav !== "function" ||
-        typeof module._tspice_pxform !== "function" ||
-        typeof module._tspice_sxform !== "function" ||
-        typeof module._tspice_spkezr !== "function" ||
-        typeof module._tspice_spkpos !== "function" ||
-        typeof module._tspice_reclat !== "function" ||
-        typeof module._tspice_latrec !== "function" ||
-        typeof module._tspice_recsph !== "function" ||
-        typeof module._tspice_sphrec !== "function" ||
-        typeof module._tspice_vnorm !== "function" ||
-        typeof module._tspice_vhat !== "function" ||
-        typeof module._tspice_vdot !== "function" ||
-        typeof module._tspice_vcrss !== "function" ||
-        typeof module._tspice_mxv !== "function" ||
-        typeof module._tspice_mtxv !== "function") {
-        throw new Error("WASM module is missing expected exports");
-    }
-    // The toolkit version is constant for the lifetime of a loaded module.
-    const toolkitVersion = getToolkitVersion(module);
-    function writeFile(path, data) {
-        const dir = path.split("/").slice(0, -1).join("/") || "/";
-        if (dir && dir !== "/") {
-            module.FS.mkdirTree(dir);
-        }
-        // Normalize to a tightly-sized, offset-0 view to avoid FS edge cases with Buffer pooling.
-        const bytes = data.byteOffset === 0 && data.byteLength === data.buffer.byteLength
-            ? data
-            : new Uint8Array(data);
-        module.FS.writeFile(path, bytes);
-    }
-    const backend = {
-        kind: "wasm",
-        spiceVersion: () => toolkitVersion,
-        tkvrsn: (item) => {
-            if (item !== "TOOLKIT") {
-                throw new Error(`Unsupported tkvrsn item: ${item}`);
-            }
-            return toolkitVersion;
-        },
-        furnsh(kernel) {
-            if (typeof kernel === "string") {
-                tspiceCall1Path(module, module._tspice_furnsh, kernel);
-                return;
-            }
-            writeFile(kernel.path, kernel.bytes);
-            tspiceCall1Path(module, module._tspice_furnsh, kernel.path);
-        },
-        unload(path) {
-            tspiceCall1Path(module, module._tspice_unload, path);
-        },
-        kclear() {
-            tspiceCall0(module, module._tspice_kclear);
-        },
-        ktotal(kind = "ALL") {
-            return tspiceCallKtotal(module, kind);
-        },
-        kdata(which, kind = "ALL") {
-            return tspiceCallKdata(module, which, kind);
-        },
-        str2et(utc) {
-            return tspiceCallStr2et(module, utc);
-        },
-        et2utc(et, format, prec) {
-            return tspiceCallEt2utc(module, et, format, prec);
-        },
-        timout(et, picture) {
-            return tspiceCallTimout(module, et, picture);
-        },
-        bodn2c(name) {
-            const out = tspiceCallFoundInt(module, module._tspice_bodn2c, name);
-            if (!out.found)
-                return { found: false };
-            return { found: true, code: out.value };
-        },
-        bodc2n(code) {
-            const out = tspiceCallFoundString(module, module._tspice_bodc2n, code);
-            if (!out.found)
-                return { found: false };
-            return { found: true, name: out.value };
-        },
-        namfrm(name) {
-            const out = tspiceCallFoundInt(module, module._tspice_namfrm, name);
-            if (!out.found)
-                return { found: false };
-            return { found: true, code: out.value };
-        },
-        frmnam(code) {
-            const out = tspiceCallFoundString(module, module._tspice_frmnam, code);
-            if (!out.found)
-                return { found: false };
-            return { found: true, name: out.value };
-        },
-        cidfrm(center) {
-            return tspiceCallCidfrm(module, module._tspice_cidfrm, center);
-        },
-        cnmfrm(centerName) {
-            return tspiceCallCnmfrm(module, module._tspice_cnmfrm, centerName);
-        },
-        scs2e(sc, sclkch) {
-            return tspiceCallScs2e(module, sc, sclkch);
-        },
-        sce2s(sc, et) {
-            return tspiceCallSce2s(module, sc, et);
-        },
-        ckgp(inst, sclkdp, tol, ref) {
-            return tspiceCallCkgp(module, inst, sclkdp, tol, ref);
-        },
-        ckgpav(inst, sclkdp, tol, ref) {
-            return tspiceCallCkgpav(module, inst, sclkdp, tol, ref);
-        },
-        spkezr(target, et, ref, abcorr, observer) {
-            return tspiceCallSpkezr(module, target, et, ref, abcorr, observer);
-        },
-        spkpos(target, et, ref, abcorr, observer) {
-            return tspiceCallSpkpos(module, target, et, ref, abcorr, observer);
-        },
-        subpnt(method, target, et, fixref, abcorr, observer) {
-            return tspiceCallSubpnt(module, method, target, et, fixref, abcorr, observer);
-        },
-        subslr(method, target, et, fixref, abcorr, observer) {
-            return tspiceCallSubslr(module, method, target, et, fixref, abcorr, observer);
-        },
-        sincpt(method, target, et, fixref, abcorr, observer, dref, dvec) {
-            return tspiceCallSincpt(module, method, target, et, fixref, abcorr, observer, dref, dvec);
-        },
-        ilumin(method, target, et, fixref, abcorr, observer, spoint) {
-            return tspiceCallIlumin(module, method, target, et, fixref, abcorr, observer, spoint);
-        },
-        occult(targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et) {
-            return tspiceCallOccult(module, targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et);
-        },
-        pxform(from, to, et) {
-            return tspiceCallPxform(module, from, to, et);
-        },
-        sxform(from, to, et) {
-            return tspiceCallSxform(module, from, to, et);
-        },
-        reclat: (rect) => tspiceCallReclat(module, rect),
-        latrec: (radius, lon, lat) => tspiceCallLatrec(module, radius, lon, lat),
-        recsph: (rect) => tspiceCallRecsph(module, rect),
-        sphrec: (radius, colat, lon) => tspiceCallSphrec(module, radius, colat, lon),
-        vnorm: (v) => tspiceCallVnorm(module, v),
-        vhat: (v) => tspiceCallVhat(module, v),
-        vdot: (a, b) => tspiceCallVdot(module, a, b),
-        vcrss: (a, b) => tspiceCallVcrss(module, a, b),
-        mxv: (m, v) => tspiceCallMxv(module, m, v),
-        mtxv: (m, v) => tspiceCallMtxv(module, m, v),
-        // WASM-only
-        writeFile,
-        loadKernel(path, data) {
-            const resolvedPath = path.startsWith("/") ? path : `/kernels/${path}`;
-            writeFile(resolvedPath, data);
-            tspiceCall1Path(module, module._tspice_furnsh, resolvedPath);
-        },
-    };
-    // Internal testing hook (not part of the public backend contract).
-    backend.__ktotalAll = () => backend.ktotal("ALL");
-    return backend;
-}
+export { WASM_BINARY_FILENAME, WASM_JS_FILENAME, createWasmBackend, } from "./runtime/create-backend.js";
 //# sourceMappingURL=index.js.map