@rybosome/tspice 0.0.3 → 0.0.8

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

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

package/backend-wasm/dist/domains/geometry-gf.js

@@ -0,0 +1,178 @@
+import { assertSpiceInt32 } from "#backend-contract";
+import { withAllocs, withMalloc, WASM_ERR_MAX_BYTES } from "../codec/alloc.js";
+import { throwWasmSpiceError } from "../codec/errors.js";
+import { writeUtf8CString } from "../codec/strings.js";
+import { assertWasmOwnedWindowHandle } from "./cells-windows.js";
+function assertFiniteNumber(value, context) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new RangeError(`${context}: expected a finite number (got ${value})`);
+    }
+}
+function tspiceCallGfsstp(module, step) {
+    withMalloc(module, WASM_ERR_MAX_BYTES, (errPtr) => {
+        const result = module._tspice_gfsstp(step, errPtr, WASM_ERR_MAX_BYTES);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+        }
+    });
+}
+function tspiceCallGfstep(module, time) {
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outStepPtr) => {
+        module.HEAPF64[outStepPtr >> 3] = 0;
+        const result = module._tspice_gfstep(time, outStepPtr, errPtr, WASM_ERR_MAX_BYTES);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+        }
+        const out = module.HEAPF64[outStepPtr >> 3];
+        assertFiniteNumber(out, "gfstep(): return value");
+        return out;
+    });
+}
+function tspiceCallGfstol(module, value) {
+    withMalloc(module, WASM_ERR_MAX_BYTES, (errPtr) => {
+        const result = module._tspice_gfstol(value, errPtr, WASM_ERR_MAX_BYTES);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+        }
+    });
+}
+function tspiceCallGfrefn(module, t1, t2, s1, s2) {
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outTPtr) => {
+        module.HEAPF64[outTPtr >> 3] = 0;
+        const result = module._tspice_gfrefn(t1, t2, s1 ? 1 : 0, s2 ? 1 : 0, outTPtr, errPtr, WASM_ERR_MAX_BYTES);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+        }
+        const out = module.HEAPF64[outTPtr >> 3];
+        assertFiniteNumber(out, "gfrefn(): return value");
+        return out;
+    });
+}
+function tspiceCallGfrepi(module, window, begmss, endmss) {
+    withMalloc(module, WASM_ERR_MAX_BYTES, (errPtr) => {
+        const begmssPtr = writeUtf8CString(module, begmss);
+        const endmssPtr = writeUtf8CString(module, endmss);
+        if (!begmssPtr || !endmssPtr) {
+            if (endmssPtr)
+                module._free(endmssPtr);
+            if (begmssPtr)
+                module._free(begmssPtr);
+            throw new Error("WASM malloc failed");
+        }
+        try {
+            const result = module._tspice_gfrepi(window, begmssPtr, endmssPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+        }
+        finally {
+            module._free(endmssPtr);
+            module._free(begmssPtr);
+        }
+    });
+}
+function tspiceCallGfrepf(module) {
+    withMalloc(module, WASM_ERR_MAX_BYTES, (errPtr) => {
+        const result = module._tspice_gfrepf(errPtr, WASM_ERR_MAX_BYTES);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+        }
+    });
+}
+function tspiceCallGfsep(module, targ1, shape1, frame1, targ2, shape2, frame2, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, resultWindow) {
+    withMalloc(module, WASM_ERR_MAX_BYTES, (errPtr) => {
+        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 obsrvrPtr = writeUtf8CString(module, obsrvr);
+        const relatePtr = writeUtf8CString(module, relate);
+        if (!targ1Ptr || !shape1Ptr || !frame1Ptr || !targ2Ptr || !shape2Ptr || !frame2Ptr || !abcorrPtr || !obsrvrPtr || !relatePtr) {
+            for (const ptr of [relatePtr, obsrvrPtr, abcorrPtr, frame2Ptr, shape2Ptr, targ2Ptr, frame1Ptr, shape1Ptr, targ1Ptr]) {
+                if (ptr)
+                    module._free(ptr);
+            }
+            throw new Error("WASM malloc failed");
+        }
+        try {
+            const out = module._tspice_gfsep(targ1Ptr, shape1Ptr, frame1Ptr, targ2Ptr, shape2Ptr, frame2Ptr, abcorrPtr, obsrvrPtr, relatePtr, refval, adjust, step, nintvls, cnfine, resultWindow, errPtr, WASM_ERR_MAX_BYTES);
+            if (out !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, out);
+            }
+        }
+        finally {
+            module._free(relatePtr);
+            module._free(obsrvrPtr);
+            module._free(abcorrPtr);
+            module._free(frame2Ptr);
+            module._free(shape2Ptr);
+            module._free(targ2Ptr);
+            module._free(frame1Ptr);
+            module._free(shape1Ptr);
+            module._free(targ1Ptr);
+        }
+    });
+}
+function tspiceCallGfdist(module, target, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, resultWindow) {
+    withMalloc(module, WASM_ERR_MAX_BYTES, (errPtr) => {
+        const targetPtr = writeUtf8CString(module, target);
+        const abcorrPtr = writeUtf8CString(module, abcorr);
+        const obsrvrPtr = writeUtf8CString(module, obsrvr);
+        const relatePtr = writeUtf8CString(module, relate);
+        if (!targetPtr || !abcorrPtr || !obsrvrPtr || !relatePtr) {
+            for (const ptr of [relatePtr, obsrvrPtr, abcorrPtr, targetPtr]) {
+                if (ptr)
+                    module._free(ptr);
+            }
+            throw new Error("WASM malloc failed");
+        }
+        try {
+            const out = module._tspice_gfdist(targetPtr, abcorrPtr, obsrvrPtr, relatePtr, refval, adjust, step, nintvls, cnfine, resultWindow, errPtr, WASM_ERR_MAX_BYTES);
+            if (out !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, out);
+            }
+        }
+        finally {
+            module._free(relatePtr);
+            module._free(obsrvrPtr);
+            module._free(abcorrPtr);
+            module._free(targetPtr);
+        }
+    });
+}
+/** Create a {@link GeometryGfApi} implementation backed by a WASM Emscripten module. */
+export function createGeometryGfApi(module) {
+    return {
+        gfsstp: (step) => tspiceCallGfsstp(module, step),
+        gfstep: (time) => tspiceCallGfstep(module, time),
+        gfstol: (value) => tspiceCallGfstol(module, value),
+        gfrefn: (t1, t2, s1, s2) => tspiceCallGfrefn(module, t1, t2, s1, s2),
+        gfrepi: (window, begmss, endmss) => {
+            assertWasmOwnedWindowHandle(module, window, "gfrepi(window)");
+            tspiceCallGfrepi(module, window, begmss, endmss);
+        },
+        gfrepf: () => tspiceCallGfrepf(module),
+        gfsep: (targ1, shape1, frame1, targ2, shape2, frame2, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, result) => {
+            assertSpiceInt32(nintvls, "gfsep(nintvls)", { min: 1 });
+            assertFiniteNumber(refval, "gfsep(refval)");
+            assertFiniteNumber(adjust, "gfsep(adjust)");
+            assertFiniteNumber(step, "gfsep(step)");
+            assertWasmOwnedWindowHandle(module, cnfine, "gfsep(cnfine)");
+            assertWasmOwnedWindowHandle(module, result, "gfsep(result)");
+            tspiceCallGfsep(module, targ1, shape1, frame1, targ2, shape2, frame2, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, result);
+        },
+        gfdist: (target, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, result) => {
+            assertSpiceInt32(nintvls, "gfdist(nintvls)", { min: 1 });
+            assertFiniteNumber(refval, "gfdist(refval)");
+            assertFiniteNumber(adjust, "gfdist(adjust)");
+            assertFiniteNumber(step, "gfdist(step)");
+            assertWasmOwnedWindowHandle(module, cnfine, "gfdist(cnfine)");
+            assertWasmOwnedWindowHandle(module, result, "gfdist(result)");
+            tspiceCallGfdist(module, target, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, result);
+        },
+    };
+}
+//# sourceMappingURL=geometry-gf.js.map

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

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

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

@@ -188,6 +188,181 @@ function tspiceCallIlumin(module, method, target, et, fixref, abcorr, observer,
         module._free(errPtr);
     }
 }
+function tspiceCallIllumg(module, method, target, ilusrc, et, fixref, abcorr, observer, spoint) {
+    const errMaxBytes = 2048;
+    const errPtr = module._malloc(errMaxBytes);
+    const methodPtr = writeUtf8CString(module, method);
+    const targetPtr = writeUtf8CString(module, target);
+    const ilusrcPtr = writeUtf8CString(module, ilusrc);
+    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 || !ilusrcPtr || !fixrefPtr || !abcorrPtr || !observerPtr || !spointPtr || !outTrgepcPtr || !outSrfvecPtr || !outPhasePtr || !outIncdncPtr || !outEmissnPtr) {
+        for (const ptr of [outEmissnPtr, outIncdncPtr, outPhasePtr, outSrfvecPtr, outTrgepcPtr, spointPtr, observerPtr, abcorrPtr, fixrefPtr, ilusrcPtr, 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_illumg(methodPtr, targetPtr, ilusrcPtr, 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(ilusrcPtr);
+        module._free(targetPtr);
+        module._free(methodPtr);
+        module._free(errPtr);
+    }
+}
+function tspiceCallIllumf(module, method, target, ilusrc, et, fixref, abcorr, observer, spoint) {
+    const errMaxBytes = 2048;
+    const errPtr = module._malloc(errMaxBytes);
+    const methodPtr = writeUtf8CString(module, method);
+    const targetPtr = writeUtf8CString(module, target);
+    const ilusrcPtr = writeUtf8CString(module, ilusrc);
+    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);
+    const outVisiblPtr = module._malloc(4);
+    const outLitPtr = module._malloc(4);
+    if (!errPtr || !methodPtr || !targetPtr || !ilusrcPtr || !fixrefPtr || !abcorrPtr || !observerPtr || !spointPtr || !outTrgepcPtr || !outSrfvecPtr || !outPhasePtr || !outIncdncPtr || !outEmissnPtr || !outVisiblPtr || !outLitPtr) {
+        for (const ptr of [outLitPtr, outVisiblPtr, outEmissnPtr, outIncdncPtr, outPhasePtr, outSrfvecPtr, outTrgepcPtr, spointPtr, observerPtr, abcorrPtr, fixrefPtr, ilusrcPtr, 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;
+        module.HEAP32[outVisiblPtr >> 2] = 0;
+        module.HEAP32[outLitPtr >> 2] = 0;
+        const result = module._tspice_illumf(methodPtr, targetPtr, ilusrcPtr, et, fixrefPtr, abcorrPtr, observerPtr, spointPtr, outTrgepcPtr, outSrfvecPtr, outPhasePtr, outIncdncPtr, outEmissnPtr, outVisiblPtr, outLitPtr, 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;
+        const visibl = module.HEAP32[outVisiblPtr >> 2] ?? 0;
+        const lit = module.HEAP32[outLitPtr >> 2] ?? 0;
+        return { trgepc, srfvec, phase, incdnc, emissn, visibl: Boolean(visibl), lit: Boolean(lit) };
+    }
+    finally {
+        module._free(outLitPtr);
+        module._free(outVisiblPtr);
+        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(ilusrcPtr);
+        module._free(targetPtr);
+        module._free(methodPtr);
+        module._free(errPtr);
+    }
+}
+function tspiceCallNvc2pl(module, normal, konst) {
+    const errMaxBytes = 2048;
+    const errPtr = module._malloc(errMaxBytes);
+    const normalPtr = module._malloc(3 * 8);
+    const outPlanePtr = module._malloc(4 * 8);
+    if (!errPtr || !normalPtr || !outPlanePtr) {
+        for (const ptr of [outPlanePtr, normalPtr, errPtr]) {
+            if (ptr)
+                module._free(ptr);
+        }
+        throw new Error("WASM malloc failed");
+    }
+    try {
+        module.HEAPF64.set(normal, normalPtr >> 3);
+        const result = module._tspice_nvc2pl(normalPtr, konst, outPlanePtr, errPtr, errMaxBytes);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+        }
+        return Array.from(module.HEAPF64.subarray(outPlanePtr >> 3, (outPlanePtr >> 3) + 4));
+    }
+    finally {
+        module._free(outPlanePtr);
+        module._free(normalPtr);
+        module._free(errPtr);
+    }
+}
+function tspiceCallPl2nvc(module, plane) {
+    const errMaxBytes = 2048;
+    const errPtr = module._malloc(errMaxBytes);
+    const planePtr = module._malloc(4 * 8);
+    const outNormalPtr = module._malloc(3 * 8);
+    const outKonstPtr = module._malloc(8);
+    if (!errPtr || !planePtr || !outNormalPtr || !outKonstPtr) {
+        for (const ptr of [outKonstPtr, outNormalPtr, planePtr, errPtr]) {
+            if (ptr)
+                module._free(ptr);
+        }
+        throw new Error("WASM malloc failed");
+    }
+    try {
+        module.HEAPF64.set(plane, planePtr >> 3);
+        module.HEAPF64[outKonstPtr >> 3] = 0;
+        const result = module._tspice_pl2nvc(planePtr, outNormalPtr, outKonstPtr, errPtr, errMaxBytes);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+        }
+        const normal = Array.from(module.HEAPF64.subarray(outNormalPtr >> 3, (outNormalPtr >> 3) + 3));
+        const konst = module.HEAPF64[outKonstPtr >> 3] ?? 0;
+        return { normal, konst };
+    }
+    finally {
+        module._free(outKonstPtr);
+        module._free(outNormalPtr);
+        module._free(planePtr);
+        module._free(errPtr);
+    }
+}
 function tspiceCallOccult(module, targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et) {
     const errMaxBytes = 2048;
     const errPtr = module._malloc(errMaxBytes);
@@ -228,13 +403,48 @@ function tspiceCallOccult(module, targ1, shape1, frame1, targ2, shape2, frame2,
         module._free(errPtr);
     }
 }
+function assertFiniteNumberArrayFixed(value, expectedLength, label) {
+    if (!Array.isArray(value) || value.length !== expectedLength) {
+        throw new TypeError(`${label}: expected a length-${expectedLength} array`);
+    }
+    for (let i = 0; i < expectedLength; i++) {
+        const v = value[i];
+        if (typeof v !== "number") {
+            throw new TypeError(`${label}[${i}]: expected a number`);
+        }
+        if (!Number.isFinite(v)) {
+            throw new RangeError(`${label}[${i}]: expected a finite number`);
+        }
+    }
+}
+/** Create a {@link GeometryApi} implementation backed by a WASM Emscripten module. */
 export function createGeometryApi(module) {
     return {
         subpnt: (method, target, et, fixref, abcorr, observer) => tspiceCallSubpnt(module, method, target, et, fixref, abcorr, observer),
         subslr: (method, target, et, fixref, abcorr, observer) => tspiceCallSubslr(module, method, target, et, fixref, abcorr, observer),
         sincpt: (method, target, et, fixref, abcorr, observer, dref, dvec) => tspiceCallSincpt(module, method, target, et, fixref, abcorr, observer, dref, dvec),
         ilumin: (method, target, et, fixref, abcorr, observer, spoint) => tspiceCallIlumin(module, method, target, et, fixref, abcorr, observer, spoint),
+        illumg: (method, target, ilusrc, et, fixref, abcorr, observer, spoint) => tspiceCallIllumg(module, method, target, ilusrc, et, fixref, abcorr, observer, spoint),
+        illumf: (method, target, ilusrc, et, fixref, abcorr, observer, spoint) => tspiceCallIllumf(module, method, target, ilusrc, et, fixref, abcorr, observer, spoint),
         occult: (targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et) => tspiceCallOccult(module, targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et),
+        nvc2pl: (normal, konst) => {
+            assertFiniteNumberArrayFixed(normal, 3, "nvc2pl(): normal");
+            if (!Number.isFinite(konst)) {
+                throw new RangeError("nvc2pl(): konst must be a finite number");
+            }
+            const out = tspiceCallNvc2pl(module, normal, konst);
+            assertFiniteNumberArrayFixed(out, 4, "nvc2pl(): result");
+            return out;
+        },
+        pl2nvc: (plane) => {
+            assertFiniteNumberArrayFixed(plane, 4, "pl2nvc(): plane");
+            const out = tspiceCallPl2nvc(module, plane);
+            assertFiniteNumberArrayFixed(out.normal, 3, "pl2nvc(): normal");
+            if (!Number.isFinite(out.konst)) {
+                throw new RangeError("pl2nvc(): konst must be a finite number");
+            }
+            return out;
+        },
     };
 }
 //# sourceMappingURL=geometry.js.map

package/backend-wasm/dist/domains/ids-names.d.ts

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

package/backend-wasm/dist/domains/ids-names.js

@@ -1,4 +1,83 @@
+import { normalizeBodItem } from "#backend-contract";
+import { WASM_ERR_MAX_BYTES, withAllocs } from "../codec/alloc.js";
+import { throwWasmSpiceError } from "../codec/errors.js";
+import { readFixedWidthCString, writeUtf8CString } from "../codec/strings.js";
 import { tspiceCallFoundInt, tspiceCallFoundString } from "../codec/found.js";
+const BODY_NAME_MAX_BYTES = 256;
+const BODY_CONST_MAX_VALUES = 1024;
+function tspiceCallBodc2s(module, code) {
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, BODY_NAME_MAX_BYTES], (errPtr, outPtr) => {
+        module.HEAPU8[outPtr] = 0;
+        const result = module._tspice_bodc2s(code, outPtr, BODY_NAME_MAX_BYTES, errPtr, WASM_ERR_MAX_BYTES);
+        if (result !== 0) {
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+        }
+        return readFixedWidthCString(module, outPtr, BODY_NAME_MAX_BYTES);
+    });
+}
+function tspiceCallBoddef(module, name, code) {
+    const namePtr = writeUtf8CString(module, name);
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES], (errPtr) => {
+            const result = module._tspice_boddef(namePtr, code, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+        });
+    }
+    finally {
+        module._free(namePtr);
+    }
+}
+function tspiceCallBodfnd(module, body, item) {
+    // `bodfnd_c()` is an existence check: it returns true even when the pool var
+    // exists but is character-typed ('C') vs numeric ('N').
+    //
+    // IMPORTANT: NAIF `expool_c()` only reports numeric ('N') variables, so use
+    // `dtpool_c()` to check for existence regardless of type.
+    const bodyI = body | 0;
+    const poolVar = `BODY${bodyI}_${item}`;
+    const poolVarPtr = writeUtf8CString(module, poolVar);
+    const outTypeMaxBytes = 2;
+    try {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 4, 4, outTypeMaxBytes], (errPtr, foundPtr, outNPtr, outTypePtr) => {
+            module.HEAP32[foundPtr >> 2] = 0;
+            module.HEAP32[outNPtr >> 2] = 0;
+            module.HEAPU8[outTypePtr] = 0;
+            const result = module._tspice_dtpool(poolVarPtr, foundPtr, outNPtr, outTypePtr, outTypeMaxBytes, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return (module.HEAP32[foundPtr >> 2] ?? 0) !== 0;
+        });
+    }
+    finally {
+        module._free(poolVarPtr);
+    }
+}
+function tspiceCallBodvar(module, body, item) {
+    const itemPtr = writeUtf8CString(module, item);
+    const maxn = BODY_CONST_MAX_VALUES;
+    try {
+        const valuesBytes = Math.max(8, maxn * 8);
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 4, valuesBytes + 7], (errPtr, outDimPtr, rawValuesPtr) => {
+            module.HEAP32[outDimPtr >> 2] = 0;
+            // Ensure 8-byte alignment for `HEAPF64` reads.
+            const valuesPtr = (rawValuesPtr + 7) & ~7;
+            const result = module._tspice_bodvar(body, itemPtr, maxn, outDimPtr, valuesPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            const dimRaw = module.HEAP32[outDimPtr >> 2] ?? 0;
+            const dim = Math.min(maxn, Math.max(0, dimRaw));
+            return Array.from(module.HEAPF64.subarray(valuesPtr >> 3, (valuesPtr >> 3) + dim));
+        });
+    }
+    finally {
+        module._free(itemPtr);
+    }
+}
+/** Create an {@link IdsNamesApi} implementation backed by a WASM Emscripten module. */
 export function createIdsNamesApi(module) {
     return {
         bodn2c: (name) => {
@@ -13,6 +92,16 @@ export function createIdsNamesApi(module) {
                 return { found: false };
             return { found: true, name: out.value };
         },
+        bodc2s: (code) => tspiceCallBodc2s(module, code),
+        bods2c: (name) => {
+            const out = tspiceCallFoundInt(module, module._tspice_bods2c, name);
+            if (!out.found)
+                return { found: false };
+            return { found: true, code: out.value };
+        },
+        boddef: (name, code) => tspiceCallBoddef(module, name, code),
+        bodfnd: (body, item) => tspiceCallBodfnd(module, body, normalizeBodItem(item)),
+        bodvar: (body, item) => tspiceCallBodvar(module, body, normalizeBodItem(item)),
     };
 }
 //# sourceMappingURL=ids-names.js.map

package/backend-wasm/dist/domains/kernel-pool.d.ts

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