@rybosome/tspice 0.0.1 → 0.0.2-alpha

package/backend-wasm/dist/domains/coords-vectors.js

@@ -0,0 +1,312 @@
+import { throwWasmSpiceError } from "../codec/errors.js";
+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);
+    }
+}
+export function createCoordsVectorsApi(module) {
+    return {
+        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),
+    };
+}
+//# sourceMappingURL=coords-vectors.js.map

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

@@ -0,0 +1,4 @@
+import type { EphemerisApi } from "#backend-contract";
+import type { EmscriptenModule } from "../lowlevel/exports.js";
+export declare function createEphemerisApi(module: EmscriptenModule): EphemerisApi;
+//# sourceMappingURL=ephemeris.d.ts.map

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

@@ -0,0 +1,81 @@
+import { throwWasmSpiceError } from "../codec/errors.js";
+import { writeUtf8CString } from "../codec/strings.js";
+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);
+    }
+}
+export function createEphemerisApi(module) {
+    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),
+    };
+}
+//# sourceMappingURL=ephemeris.js.map

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

@@ -0,0 +1,4 @@
+import type { FramesApi } from "#backend-contract";
+import type { EmscriptenModule } from "../lowlevel/exports.js";
+export declare function createFramesApi(module: EmscriptenModule): FramesApi;
+//# sourceMappingURL=frames.d.ts.map

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

@@ -0,0 +1,239 @@
+import { tspiceCallFoundInt, tspiceCallFoundString } from "../codec/found.js";
+import { throwWasmSpiceError } from "../codec/errors.js";
+import { writeUtf8CString } from "../codec/strings.js";
+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 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);
+    }
+}
+export function createFramesApi(module) {
+    return {
+        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) => tspiceCallCidfrm(module, module._tspice_cidfrm, center),
+        cnmfrm: (centerName) => tspiceCallCnmfrm(module, module._tspice_cnmfrm, centerName),
+        ckgp: (inst, sclkdp, tol, ref) => tspiceCallCkgp(module, inst, sclkdp, tol, ref),
+        ckgpav: (inst, sclkdp, tol, ref) => tspiceCallCkgpav(module, inst, sclkdp, tol, ref),
+        pxform: (from, to, et) => tspiceCallPxform(module, from, to, et),
+        sxform: (from, to, et) => tspiceCallSxform(module, from, to, et),
+    };
+}
+//# sourceMappingURL=frames.js.map

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

@@ -0,0 +1,4 @@
+import type { GeometryApi } from "#backend-contract";
+import type { EmscriptenModule } from "../lowlevel/exports.js";
+export declare function createGeometryApi(module: EmscriptenModule): GeometryApi;
+//# sourceMappingURL=geometry.d.ts.map