@rybosome/tspice 0.0.3 → 0.0.8

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

@@ -1,166 +1,222 @@
+import { assertNever } from "#core";
+import { WASM_ERR_MAX_BYTES, withAllocs, withMalloc } from "../codec/alloc.js";
 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");
-    }
+import { readFixedWidthCString, writeUtf8CString } from "../codec/strings.js";
+/**
+ * Max byte size for string outputs from CSPICE time calls (`et2utc_c`, `timout_c`).
+ *
+ * This intentionally differs from `WASM_ERR_MAX_BYTES`:
+ * - time formatting outputs can be much larger than error messages (esp. with long TIMOUT pictures)
+ * - we want a stable, explicit cap for output allocations
+ */
+const WASM_TIME_OUT_MAX_BYTES = 16 * 1024; // 16 KiB
+const WASM_TIME_SMALL_OUT_MAX_BYTES = 2048;
+/** Max byte size for SCLK string outputs (sce2s/scdecd). */
+const WASM_SCLK_OUT_MAX_BYTES = 2048;
+function withUtf8CString(module, value, fn) {
+    const ptr = writeUtf8CString(module, value);
     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;
+        return fn(ptr);
     }
     finally {
-        module._free(outEtPtr);
-        module._free(utcPtr);
-        module._free(errPtr);
+        module._free(ptr);
     }
 }
+function tspiceCallStr2et(module, utc) {
+    return withUtf8CString(module, utc, (utcPtr) => {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outEtPtr) => {
+            module.HEAPF64[outEtPtr >> 3] = 0;
+            const result = module._tspice_str2et(utcPtr, outEtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return module.HEAPF64[outEtPtr >> 3] ?? 0;
+        });
+    });
+}
 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 {
+    const outMaxBytes = WASM_TIME_OUT_MAX_BYTES;
+    return withUtf8CString(module, format, (formatPtr) => {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, outMaxBytes], (errPtr, outPtr) => {
+            module.HEAPU8[outPtr] = 0;
+            const result = module._tspice_et2utc(et, formatPtr, prec, outPtr, outMaxBytes, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return readFixedWidthCString(module, outPtr, outMaxBytes);
+        });
+    });
+}
+function tspiceCallTimout(module, et, picture) {
+    const outMaxBytes = WASM_TIME_OUT_MAX_BYTES;
+    return withUtf8CString(module, picture, (picturePtr) => {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, outMaxBytes], (errPtr, outPtr) => {
+            module.HEAPU8[outPtr] = 0;
+            const result = module._tspice_timout(et, picturePtr, outPtr, outMaxBytes, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return readFixedWidthCString(module, outPtr, outMaxBytes);
+        });
+    });
+}
+function tspiceCallDeltet(module, epoch, eptype) {
+    return withUtf8CString(module, eptype, (eptypePtr) => {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outDeltaPtr) => {
+            module.HEAPF64[outDeltaPtr >> 3] = 0;
+            const result = module._tspice_deltet(epoch, eptypePtr, outDeltaPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return module.HEAPF64[outDeltaPtr >> 3] ?? 0;
+        });
+    });
+}
+function tspiceCallUnitim(module, epoch, insys, outsys) {
+    return withUtf8CString(module, insys, (insysPtr) => {
+        return withUtf8CString(module, outsys, (outsysPtr) => {
+            return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outEpochPtr) => {
+                module.HEAPF64[outEpochPtr >> 3] = 0;
+                const result = module._tspice_unitim(epoch, insysPtr, outsysPtr, outEpochPtr, errPtr, WASM_ERR_MAX_BYTES);
+                if (result !== 0) {
+                    throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+                }
+                return module.HEAPF64[outEpochPtr >> 3] ?? 0;
+            });
+        });
+    });
+}
+function tspiceCallTparse(module, timstr) {
+    return withUtf8CString(module, timstr, (timstrPtr) => {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outEtPtr) => {
+            module.HEAPF64[outEtPtr >> 3] = 0;
+            const result = module._tspice_tparse(timstrPtr, outEtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return module.HEAPF64[outEtPtr >> 3] ?? 0;
+        });
+    });
+}
+function tspiceCallTpictr(module, sample, picturIn) {
+    const outMaxBytes = WASM_TIME_OUT_MAX_BYTES;
+    return withUtf8CString(module, sample, (samplePtr) => {
+        return withUtf8CString(module, picturIn, (picturInPtr) => {
+            return withAllocs(module, [WASM_ERR_MAX_BYTES, outMaxBytes], (errPtr, outPtr) => {
+                module.HEAPU8[outPtr] = 0;
+                const result = module._tspice_tpictr(samplePtr, picturInPtr, outPtr, outMaxBytes, errPtr, WASM_ERR_MAX_BYTES);
+                if (result !== 0) {
+                    throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+                }
+                return readFixedWidthCString(module, outPtr, outMaxBytes);
+            });
+        });
+    });
+}
+function tspiceCallTimdefGet(module, item) {
+    const outMaxBytes = WASM_TIME_SMALL_OUT_MAX_BYTES;
+    return withUtf8CString(module, item, (itemPtr) => {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, outMaxBytes], (errPtr, outPtr) => {
+            module.HEAPU8[outPtr] = 0;
+            const result = module._tspice_timdef_get(itemPtr, outPtr, outMaxBytes, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return readFixedWidthCString(module, outPtr, outMaxBytes);
+        });
+    });
+}
+function tspiceCallTimdefSet(module, item, value) {
+    withUtf8CString(module, item, (itemPtr) => {
+        withUtf8CString(module, value, (valuePtr) => {
+            withMalloc(module, WASM_ERR_MAX_BYTES, (errPtr) => {
+                const result = module._tspice_timdef_set(itemPtr, valuePtr, errPtr, WASM_ERR_MAX_BYTES);
+                if (result !== 0) {
+                    throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+                }
+            });
+        });
+    });
+}
+function tspiceCallScs2e(module, sc, sclkch) {
+    return withUtf8CString(module, sclkch, (sclkchPtr) => {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outEtPtr) => {
+            module.HEAPF64[outEtPtr >> 3] = 0;
+            const result = module._tspice_scs2e(sc, sclkchPtr, outEtPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return module.HEAPF64[outEtPtr >> 3] ?? 0;
+        });
+    });
+}
+function tspiceCallSce2s(module, sc, et) {
+    const outMaxBytes = WASM_SCLK_OUT_MAX_BYTES;
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, outMaxBytes], (errPtr, outPtr) => {
         module.HEAPU8[outPtr] = 0;
-        const result = module._tspice_et2utc(et, formatPtr, prec, outPtr, outMaxBytes, errPtr, errMaxBytes);
+        const result = module._tspice_sce2s(sc, et, outPtr, outMaxBytes, errPtr, WASM_ERR_MAX_BYTES);
         if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
         }
-        return module.UTF8ToString(outPtr, outMaxBytes).trim();
-    }
-    finally {
-        module._free(outPtr);
-        module._free(formatPtr);
-        module._free(errPtr);
-    }
+        return readFixedWidthCString(module, outPtr, outMaxBytes);
+    });
 }
-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 {
+function tspiceCallScencd(module, sc, sclkch) {
+    return withUtf8CString(module, sclkch, (sclkchPtr) => {
+        return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outSclkdpPtr) => {
+            module.HEAPF64[outSclkdpPtr >> 3] = 0;
+            const result = module._tspice_scencd(sc, sclkchPtr, outSclkdpPtr, errPtr, WASM_ERR_MAX_BYTES);
+            if (result !== 0) {
+                throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
+            }
+            return module.HEAPF64[outSclkdpPtr >> 3] ?? 0;
+        });
+    });
+}
+function tspiceCallScdecd(module, sc, sclkdp) {
+    const outMaxBytes = WASM_SCLK_OUT_MAX_BYTES;
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, outMaxBytes], (errPtr, outPtr) => {
         module.HEAPU8[outPtr] = 0;
-        const result = module._tspice_timout(et, picturePtr, outPtr, outMaxBytes, errPtr, errMaxBytes);
+        const result = module._tspice_scdecd(sc, sclkdp, outPtr, outMaxBytes, errPtr, WASM_ERR_MAX_BYTES);
         if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
         }
-        return module.UTF8ToString(outPtr, outMaxBytes).trim();
-    }
-    finally {
-        module._free(outPtr);
-        module._free(picturePtr);
-        module._free(errPtr);
-    }
+        return readFixedWidthCString(module, outPtr, outMaxBytes);
+    });
 }
-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 {
+function tspiceCallSct2e(module, sc, sclkdp) {
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outEtPtr) => {
         module.HEAPF64[outEtPtr >> 3] = 0;
-        const result = module._tspice_scs2e(sc, sclkchPtr, outEtPtr, errPtr, errMaxBytes);
+        const result = module._tspice_sct2e(sc, sclkdp, outEtPtr, errPtr, WASM_ERR_MAX_BYTES);
         if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, 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);
+function tspiceCallSce2c(module, sc, et) {
+    return withAllocs(module, [WASM_ERR_MAX_BYTES, 8], (errPtr, outSclkdpPtr) => {
+        module.HEAPF64[outSclkdpPtr >> 3] = 0;
+        const result = module._tspice_sce2c(sc, et, outSclkdpPtr, errPtr, WASM_ERR_MAX_BYTES);
         if (result !== 0) {
-            throwWasmSpiceError(module, errPtr, errMaxBytes, result);
+            throwWasmSpiceError(module, errPtr, WASM_ERR_MAX_BYTES, result);
         }
-        return module.UTF8ToString(outPtr, outMaxBytes).trim();
-    }
-    finally {
-        module._free(outPtr);
-        module._free(errPtr);
-    }
+        return module.HEAPF64[outSclkdpPtr >> 3] ?? 0;
+    });
 }
+/** Read the embedded CSPICE toolkit version string from the WASM module. */
 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);
+    return withAllocs(module, [outMaxBytes, WASM_ERR_MAX_BYTES], (outPtr, errPtr) => {
+        const result = module._tspice_tkvrsn_toolkit(outPtr, outMaxBytes, errPtr, WASM_ERR_MAX_BYTES);
         if (result !== 0) {
-            const message = module.UTF8ToString(errPtr, errMaxBytes).trim();
+            const message = module.UTF8ToString(errPtr, WASM_ERR_MAX_BYTES).trim();
             throw new Error(message || `CSPICE call failed with code ${result}`);
         }
         return module.UTF8ToString(outPtr, outMaxBytes);
-    }
-    finally {
-        module._free(errPtr);
-        module._free(outPtr);
-    }
+    });
 }
+/** Create a {@link TimeApi} implementation backed by a WASM Emscripten module. */
 export function createTimeApi(module, toolkitVersion) {
     return {
         spiceVersion: () => toolkitVersion,
@@ -170,11 +226,57 @@ export function createTimeApi(module, toolkitVersion) {
             }
             return toolkitVersion;
         },
+        timdef: (() => {
+            function timdef(action, item, value) {
+                if (item.length === 0) {
+                    throw new RangeError("timdef(): item must be a non-empty string");
+                }
+                switch (action) {
+                    case "GET": {
+                        return tspiceCallTimdefGet(module, item);
+                    }
+                    case "SET": {
+                        if (typeof value !== "string") {
+                            throw new TypeError("timdef(SET) requires a string value");
+                        }
+                        if (value.length === 0) {
+                            throw new RangeError("timdef(SET)(): value must be a non-empty string");
+                        }
+                        tspiceCallTimdefSet(module, item, value);
+                        return;
+                    }
+                    default:
+                        return assertNever(action, "Unsupported timdef action");
+                }
+            }
+            return timdef;
+        })(),
         str2et: (utc) => tspiceCallStr2et(module, utc),
         et2utc: (et, format, prec) => tspiceCallEt2utc(module, et, format, prec),
         timout: (et, picture) => tspiceCallTimout(module, et, picture),
+        deltet: (epoch, eptype) => tspiceCallDeltet(module, epoch, eptype),
+        unitim: (epoch, insys, outsys) => tspiceCallUnitim(module, epoch, insys, outsys),
+        tparse: (timstr) => {
+            if (timstr.length === 0) {
+                throw new RangeError("tparse(): timstr must be a non-empty string");
+            }
+            return tspiceCallTparse(module, timstr);
+        },
+        tpictr: (sample, pictur) => {
+            if (sample.length === 0) {
+                throw new RangeError("tpictr(): sample must be a non-empty string");
+            }
+            if (pictur.length === 0) {
+                throw new RangeError("tpictr(): pictur must be a non-empty string");
+            }
+            return tspiceCallTpictr(module, sample, pictur);
+        },
         scs2e: (sc, sclkch) => tspiceCallScs2e(module, sc, sclkch),
         sce2s: (sc, et) => tspiceCallSce2s(module, sc, et),
+        scencd: (sc, sclkch) => tspiceCallScencd(module, sc, sclkch),
+        scdecd: (sc, sclkdp) => tspiceCallScdecd(module, sc, sclkdp),
+        sct2e: (sc, sclkdp) => tspiceCallSct2e(module, sc, sclkdp),
+        sce2c: (sc, et) => tspiceCallSce2c(module, sc, et),
     };
 }
 //# sourceMappingURL=time.js.map

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

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