@rybosome/tspice 0.0.1 → 0.0.2-alpha

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

@@ -0,0 +1,240 @@
+import { throwWasmSpiceError } from "../codec/errors.js";
+import { writeUtf8CString } from "../codec/strings.js";
+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);
+    }
+}
+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),
+        occult: (targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et) => tspiceCallOccult(module, targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et),
+    };
+}
+//# sourceMappingURL=geometry.js.map

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

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

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

@@ -0,0 +1,18 @@
+import { tspiceCallFoundInt, tspiceCallFoundString } from "../codec/found.js";
+export function createIdsNamesApi(module) {
+    return {
+        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 };
+        },
+    };
+}
+//# sourceMappingURL=ids-names.js.map

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

@@ -0,0 +1,5 @@
+import type { KernelsApi } from "#backend-contract";
+import type { EmscriptenModule } from "../lowlevel/exports.js";
+import type { WasmFsApi } from "../runtime/fs.js";
+export declare function createKernelsApi(module: EmscriptenModule, fs: WasmFsApi): KernelsApi;
+//# sourceMappingURL=kernels.d.ts.map

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

@@ -0,0 +1,97 @@
+import { tspiceCall0, tspiceCall1Path } from "../codec/calls.js";
+import { throwWasmSpiceError } from "../codec/errors.js";
+import { writeUtf8CString } from "../codec/strings.js";
+import { writeKernelSource } from "../runtime/fs.js";
+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);
+    }
+}
+export function createKernelsApi(module, fs) {
+    return {
+        furnsh: (kernel) => {
+            const path = writeKernelSource(module, fs, kernel);
+            tspiceCall1Path(module, module._tspice_furnsh, path);
+        },
+        unload: (path) => {
+            tspiceCall1Path(module, module._tspice_unload, path);
+        },
+        kclear: () => {
+            tspiceCall0(module, module._tspice_kclear);
+        },
+        ktotal: (kind = "ALL") => tspiceCallKtotal(module, kind),
+        kdata: (which, kind = "ALL") => tspiceCallKdata(module, which, kind),
+    };
+}
+//# sourceMappingURL=kernels.js.map

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

@@ -0,0 +1,5 @@
+import type { TimeApi } from "#backend-contract";
+import type { EmscriptenModule } from "../lowlevel/exports.js";
+export declare function getToolkitVersion(module: EmscriptenModule): string;
+export declare function createTimeApi(module: EmscriptenModule, toolkitVersion: string): TimeApi;
+//# sourceMappingURL=time.d.ts.map

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

@@ -0,0 +1,180 @@
+import { throwWasmSpiceError } from "../codec/errors.js";
+import { writeUtf8CString } from "../codec/strings.js";
+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 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);
+    // Buffer size includes terminating NUL.
+    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);
+    }
+}
+export 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 function createTimeApi(module, toolkitVersion) {
+    return {
+        spiceVersion: () => toolkitVersion,
+        tkvrsn: (item) => {
+            if (item !== "TOOLKIT") {
+                throw new Error(`Unsupported tkvrsn item: ${item}`);
+            }
+            return toolkitVersion;
+        },
+        str2et: (utc) => tspiceCallStr2et(module, utc),
+        et2utc: (et, format, prec) => tspiceCallEt2utc(module, et, format, prec),
+        timout: (et, picture) => tspiceCallTimout(module, et, picture),
+        scs2e: (sc, sclkch) => tspiceCallScs2e(module, sc, sclkch),
+        sce2s: (sc, et) => tspiceCallSce2s(module, sc, et),
+    };
+}
+//# sourceMappingURL=time.js.map

package/backend-wasm/dist/index.d.ts

@@ -1,8 +1,3 @@
-import type { SpiceBackendWasm } from "#backend-contract";
-export type CreateWasmBackendOptions = {
-    wasmUrl?: string | URL;
-};
-export declare const WASM_JS_FILENAME: "tspice_backend_wasm.js";
-export declare const WASM_BINARY_FILENAME: "tspice_backend_wasm.wasm";
-export declare function createWasmBackend(options?: CreateWasmBackendOptions): Promise<SpiceBackendWasm>;
+export { WASM_BINARY_FILENAME, WASM_JS_FILENAME, createWasmBackend, } from "./runtime/create-backend.js";
+export type { CreateWasmBackendOptions } from "./runtime/create-backend.js";
 //# sourceMappingURL=index.d.ts.map