@rybosome/tspice 0.0.7 → 0.0.8

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

@@ -0,0 +1,74 @@
+import { assertSpiceInt32 } from "#backend-contract";
+import { invariant } from "#core";
+const UINT32_MAX = 0xffff_ffff;
+// Opaque window handles are represented as branded numbers in the backend
+// contract, but we still validate them at runtime to keep error behavior
+// consistent across backends.
+function assertOpaqueHandle(handle, context) {
+    if (typeof handle !== "number" || !Number.isFinite(handle) || !Number.isInteger(handle)) {
+        throw new TypeError(`${context}: expected handle to be an integer number (got ${handle})`);
+    }
+    if (handle <= 0) {
+        throw new RangeError(`${context}: expected handle to be > 0 (got ${handle})`);
+    }
+    if (!Number.isSafeInteger(handle) || handle > UINT32_MAX) {
+        throw new RangeError(`${context}: expected handle to be a non-zero uint32 (got ${handle})`);
+    }
+}
+function assertFiniteNumber(value, context) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new RangeError(`${context}: expected a finite number (got ${value})`);
+    }
+}
+/** Create a {@link GeometryGfApi} implementation backed by the native Node addon. */
+export function createGeometryGfApi(native) {
+    return {
+        gfsstp: (step) => {
+            assertFiniteNumber(step, "gfsstp(step)");
+            native.gfsstp(step);
+        },
+        gfstep: (time) => {
+            assertFiniteNumber(time, "gfstep(time)");
+            const out = native.gfstep(time);
+            invariant(typeof out === "number" && Number.isFinite(out), "Expected gfstep() to return a finite number");
+            return out;
+        },
+        gfstol: (value) => {
+            assertFiniteNumber(value, "gfstol(value)");
+            native.gfstol(value);
+        },
+        gfrefn: (t1, t2, s1, s2) => {
+            assertFiniteNumber(t1, "gfrefn(t1)");
+            assertFiniteNumber(t2, "gfrefn(t2)");
+            const out = native.gfrefn(t1, t2, s1, s2);
+            invariant(typeof out === "number" && Number.isFinite(out), "Expected gfrefn() to return a finite number");
+            return out;
+        },
+        gfrepi: (window, begmss, endmss) => {
+            assertOpaqueHandle(window, "gfrepi(window)");
+            native.gfrepi(window, begmss, endmss);
+        },
+        gfrepf: () => {
+            native.gfrepf();
+        },
+        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)");
+            assertOpaqueHandle(cnfine, "gfsep(cnfine)");
+            assertOpaqueHandle(result, "gfsep(result)");
+            native.gfsep(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)");
+            assertOpaqueHandle(cnfine, "gfdist(cnfine)");
+            assertOpaqueHandle(result, "gfdist(result)");
+            native.gfdist(target, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, result);
+        },
+    };
+}
+//# sourceMappingURL=geometry-gf.js.map

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

@@ -1,4 +1,5 @@
 import type { GeometryApi } from "#backend-contract";
 import type { NativeAddon } from "../runtime/addon.js";
+/** Create a {@link GeometryApi} implementation backed by the native Node addon. */
 export declare function createGeometryApi(native: NativeAddon): GeometryApi;
 //# sourceMappingURL=geometry.d.ts.map

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

@@ -1,4 +1,12 @@
 import { invariant } from "#core";
+function assertFiniteNumberArrayFixed(value, expectedLength, label) {
+    invariant(Array.isArray(value) && value.length === expectedLength, `Expected ${label} to be a length-${expectedLength} array`);
+    for (let i = 0; i < expectedLength; i++) {
+        const v = value[i];
+        invariant(typeof v === "number" && Number.isFinite(v), `Expected ${label}[${i}] to be a finite number`);
+    }
+}
+/** Create a {@link GeometryApi} implementation backed by the native Node addon. */
 export function createGeometryApi(native) {
     return {
         subpnt: (method, target, et, fixref, abcorr, observer) => {
@@ -57,11 +65,65 @@ export function createGeometryApi(native) {
                 emissn: out.emissn,
             };
         },
+        illumg: (method, target, ilusrc, et, fixref, abcorr, observer, spoint) => {
+            const out = native.illumg(method, target, ilusrc, et, fixref, abcorr, observer, spoint);
+            invariant(out && typeof out === "object", "Expected illumg() to return an object");
+            invariant(typeof out.trgepc === "number", "Expected illumg().trgepc to be a number");
+            invariant(Array.isArray(out.srfvec) && out.srfvec.length === 3, "Expected illumg().srfvec to be a length-3 array");
+            invariant(typeof out.phase === "number", "Expected illumg().phase to be a number");
+            invariant(typeof out.incdnc === "number", "Expected illumg().incdnc to be a number");
+            invariant(typeof out.emissn === "number", "Expected illumg().emissn to be a number");
+            return {
+                trgepc: out.trgepc,
+                srfvec: out.srfvec,
+                phase: out.phase,
+                incdnc: out.incdnc,
+                emissn: out.emissn,
+            };
+        },
+        illumf: (method, target, ilusrc, et, fixref, abcorr, observer, spoint) => {
+            const out = native.illumf(method, target, ilusrc, et, fixref, abcorr, observer, spoint);
+            invariant(out && typeof out === "object", "Expected illumf() to return an object");
+            invariant(typeof out.trgepc === "number", "Expected illumf().trgepc to be a number");
+            invariant(Array.isArray(out.srfvec) && out.srfvec.length === 3, "Expected illumf().srfvec to be a length-3 array");
+            invariant(typeof out.phase === "number", "Expected illumf().phase to be a number");
+            invariant(typeof out.incdnc === "number", "Expected illumf().incdnc to be a number");
+            invariant(typeof out.emissn === "number", "Expected illumf().emissn to be a number");
+            invariant(typeof out.visibl === "boolean", "Expected illumf().visibl to be a boolean");
+            invariant(typeof out.lit === "boolean", "Expected illumf().lit to be a boolean");
+            return {
+                trgepc: out.trgepc,
+                srfvec: out.srfvec,
+                phase: out.phase,
+                incdnc: out.incdnc,
+                emissn: out.emissn,
+                visibl: out.visibl,
+                lit: out.lit,
+            };
+        },
         occult: (targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et) => {
             const out = native.occult(targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et);
             invariant(typeof out === "number", "Expected occult() to return a number");
             return out;
         },
+        nvc2pl: (normal, konst) => {
+            assertFiniteNumberArrayFixed(normal, 3, "nvc2pl(): normal");
+            invariant(typeof konst === "number" && Number.isFinite(konst), "Expected nvc2pl(): konst to be a finite number");
+            const out = native.nvc2pl(normal, konst);
+            assertFiniteNumberArrayFixed(out, 4, "nvc2pl(): result");
+            return out;
+        },
+        pl2nvc: (plane) => {
+            assertFiniteNumberArrayFixed(plane, 4, "pl2nvc(): plane");
+            const out = native.pl2nvc(plane);
+            invariant(out && typeof out === "object", "Expected pl2nvc() to return an object");
+            assertFiniteNumberArrayFixed(out.normal, 3, "pl2nvc(): normal");
+            invariant(typeof out.konst === "number" && Number.isFinite(out.konst), "Expected pl2nvc().konst to be a finite number");
+            return {
+                normal: out.normal,
+                konst: out.konst,
+            };
+        },
     };
 }
 //# sourceMappingURL=geometry.js.map

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

@@ -1,4 +1,5 @@
-import type { IdsNamesApi } from "#backend-contract";
+import { type IdsNamesApi } from "#backend-contract";
 import type { NativeAddon } from "../runtime/addon.js";
+/** Create an {@link IdsNamesApi} implementation backed by the native Node addon. */
 export declare function createIdsNamesApi(native: NativeAddon): IdsNamesApi;
 //# sourceMappingURL=ids-names.d.ts.map

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

@@ -1,4 +1,6 @@
+import {} from "#backend-contract";
 import { invariant } from "#core";
+/** Create an {@link IdsNamesApi} implementation backed by the native Node addon. */
 export function createIdsNamesApi(native) {
     return {
         bodn2c: (name) => {
@@ -17,6 +19,34 @@ export function createIdsNamesApi(native) {
             invariant(typeof out.name === "string", "Expected bodc2n().name to be a string");
             return { found: true, name: out.name };
         },
+        bodc2s: (code) => {
+            const out = native.bodc2s(code);
+            invariant(typeof out === "string", "Expected bodc2s() to return a string");
+            return out;
+        },
+        bods2c: (name) => {
+            const out = native.bods2c(name);
+            if (!out.found) {
+                return { found: false };
+            }
+            invariant(typeof out.code === "number", "Expected bods2c().code to be a number");
+            return { found: true, code: out.code };
+        },
+        boddef: (name, code) => {
+            native.boddef(name, code);
+        },
+        bodfnd: (body, item) => {
+            // `item` normalization is handled by the native addon.
+            const out = native.bodfnd(body, item);
+            invariant(typeof out === "boolean", "Expected bodfnd() to return a boolean");
+            return out;
+        },
+        bodvar: (body, item) => {
+            // `item` normalization is handled by the native addon.
+            const out = native.bodvar(body, item);
+            invariant(Array.isArray(out), "Expected bodvar() to return an array");
+            return out;
+        },
     };
 }
 //# sourceMappingURL=ids-names.js.map

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

@@ -0,0 +1,5 @@
+import type { KernelPoolApi } from "#backend-contract";
+import type { NativeAddon } from "../runtime/addon.js";
+/** Create a {@link KernelPoolApi} implementation backed by the native Node addon. */
+export declare function createKernelPoolApi(native: NativeAddon): KernelPoolApi;
+//# sourceMappingURL=kernel-pool.d.ts.map

package/backend-node/dist/domains/kernel-pool.js

@@ -0,0 +1,74 @@
+import { invariant } from "#core";
+/** Create a {@link KernelPoolApi} implementation backed by the native Node addon. */
+export function createKernelPoolApi(native) {
+    return {
+        gdpool: (name, start, room) => {
+            const out = native.gdpool(name, start, room);
+            if (!out.found) {
+                return { found: false };
+            }
+            invariant(Array.isArray(out.values), "Expected gdpool().values to be an array");
+            return { found: true, values: out.values };
+        },
+        gipool: (name, start, room) => {
+            const out = native.gipool(name, start, room);
+            if (!out.found) {
+                return { found: false };
+            }
+            invariant(Array.isArray(out.values), "Expected gipool().values to be an array");
+            return { found: true, values: out.values };
+        },
+        gcpool: (name, start, room) => {
+            const out = native.gcpool(name, start, room);
+            if (!out.found) {
+                return { found: false };
+            }
+            invariant(Array.isArray(out.values), "Expected gcpool().values to be an array");
+            return { found: true, values: out.values };
+        },
+        gnpool: (template, start, room) => {
+            const out = native.gnpool(template, start, room);
+            if (!out.found) {
+                return { found: false };
+            }
+            invariant(Array.isArray(out.values), "Expected gnpool().values to be an array");
+            return { found: true, values: out.values };
+        },
+        dtpool: (name) => {
+            const out = native.dtpool(name);
+            if (!out.found) {
+                return { found: false };
+            }
+            invariant(typeof out.n === "number", "Expected dtpool().n to be a number");
+            invariant(typeof out.type === "string", "Expected dtpool().type to be a string");
+            const t = out.type.trim();
+            if (t !== "C" && t !== "N") {
+                throw new Error(`dtpool(): unexpected type '${t}' for ${name}`);
+            }
+            return { found: true, n: out.n, type: t };
+        },
+        pdpool: (name, values) => {
+            native.pdpool(name, values);
+        },
+        pipool: (name, values) => {
+            native.pipool(name, values);
+        },
+        pcpool: (name, values) => {
+            native.pcpool(name, values);
+        },
+        swpool: (agent, names) => {
+            native.swpool(agent, names);
+        },
+        cvpool: (agent) => {
+            const out = native.cvpool(agent);
+            invariant(typeof out === "boolean", "Expected cvpool() to return a boolean");
+            return out;
+        },
+        expool: (name) => {
+            const out = native.expool(name);
+            invariant(typeof out === "boolean", "Expected expool() to return a boolean");
+            return out;
+        },
+    };
+}
+//# sourceMappingURL=kernel-pool.js.map

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

@@ -1,5 +1,6 @@
 import type { KernelsApi } from "#backend-contract";
 import type { NativeAddon } from "../runtime/addon.js";
 import type { KernelStager } from "../runtime/kernel-staging.js";
+/** Create a {@link KernelsApi} implementation backed by the native Node addon + kernel staging. */
 export declare function createKernelsApi(native: NativeAddon, stager: KernelStager): KernelsApi;
 //# sourceMappingURL=kernels.d.ts.map

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

@@ -1,5 +1,27 @@
+import { matchesKernelKind, nativeKindQueryOrNull, normalizeKindInput, } from "#backend-contract";
 import { invariant } from "#core";
+/** Create a {@link KernelsApi} implementation backed by the native Node addon + kernel staging. */
 export function createKernelsApi(native, stager) {
+    const kernelKindProbeFromNative = (result) => {
+        invariant(typeof result.file === "string", "Expected kdata().file to be a string");
+        invariant(typeof result.filtyp === "string", "Expected kdata().filtyp to be a string");
+        return {
+            file: stager.virtualizePathFromSpice(result.file),
+            filtyp: result.filtyp,
+        };
+    };
+    const kernelDataFromNative = (result) => {
+        invariant(typeof result.file === "string", "Expected kdata().file to be a string");
+        invariant(typeof result.filtyp === "string", "Expected kdata().filtyp to be a string");
+        invariant(typeof result.source === "string", "Expected kdata().source to be a string");
+        invariant(typeof result.handle === "number", "Expected kdata().handle to be a number");
+        return {
+            file: stager.virtualizePathFromSpice(result.file),
+            filtyp: result.filtyp,
+            source: stager.virtualizePathFromSpice(result.source),
+            handle: result.handle,
+        };
+    };
     return {
         furnsh: (kernel) => {
             stager.furnsh(kernel, native);
@@ -10,28 +32,93 @@ export function createKernelsApi(native, stager) {
         kclear: () => {
             stager.kclear(native);
         },
-        ktotal: (kind = "ALL") => {
-            const total = native.ktotal(kind);
-            invariant(typeof total === "number", "Expected native backend ktotal() to return a number");
-            return total;
-        },
-        kdata: (which, kind = "ALL") => {
-            const result = native.kdata(which, kind);
+        kinfo: (path) => {
+            const resolved = stager.resolvePathForSpice(path);
+            const result = native.kinfo(resolved);
             if (!result.found) {
                 return { found: false };
             }
-            invariant(typeof result.file === "string", "Expected kdata().file to be a string");
-            invariant(typeof result.filtyp === "string", "Expected kdata().filtyp to be a string");
-            invariant(typeof result.source === "string", "Expected kdata().source to be a string");
-            invariant(typeof result.handle === "number", "Expected kdata().handle to be a number");
+            invariant(typeof result.filtyp === "string", "Expected kinfo().filtyp to be a string");
+            invariant(typeof result.source === "string", "Expected kinfo().source to be a string");
+            invariant(typeof result.handle === "number", "Expected kinfo().handle to be a number");
             return {
                 found: true,
-                file: result.file,
                 filtyp: result.filtyp,
-                source: result.source,
+                source: stager.virtualizePathFromSpice(result.source),
                 handle: result.handle,
             };
         },
+        kxtrct: (keywd, terms, wordsq) => {
+            const result = native.kxtrct(keywd, terms, wordsq);
+            if (!result.found) {
+                return { found: false };
+            }
+            invariant(typeof result.wordsq === "string", "Expected kxtrct().wordsq to be a string");
+            invariant(typeof result.substr === "string", "Expected kxtrct().substr to be a string");
+            return { found: true, wordsq: result.wordsq, substr: result.substr };
+        },
+        kplfrm: (frmcls, idset) => {
+            native.kplfrm(frmcls, idset);
+        },
+        ktotal: (kind = "ALL") => {
+            const kinds = normalizeKindInput(kind);
+            const nativeQuery = nativeKindQueryOrNull(kinds);
+            if (nativeQuery != null) {
+                const total = native.ktotal(nativeQuery);
+                invariant(typeof total === "number", "Expected native backend ktotal() to return a number");
+                return total;
+            }
+            const requested = new Set(kinds);
+            const totalAll = native.ktotal("ALL");
+            invariant(typeof totalAll === "number", "Expected native backend ktotal() to return a number");
+            let count = 0;
+            for (let i = 0; i < totalAll; i++) {
+                const result = native.kdata(i, "ALL");
+                if (!result.found) {
+                    continue;
+                }
+                const probe = kernelKindProbeFromNative(result);
+                if (matchesKernelKind(requested, probe)) {
+                    count++;
+                }
+            }
+            return count;
+        },
+        kdata: (which, kind = "ALL") => {
+            if (which < 0) {
+                return { found: false };
+            }
+            const kinds = normalizeKindInput(kind);
+            const nativeQuery = nativeKindQueryOrNull(kinds);
+            if (nativeQuery != null) {
+                const result = native.kdata(which, nativeQuery);
+                if (!result.found) {
+                    return { found: false };
+                }
+                const kernel = kernelDataFromNative(result);
+                return { found: true, ...kernel };
+            }
+            const requested = new Set(kinds);
+            const totalAll = native.ktotal("ALL");
+            invariant(typeof totalAll === "number", "Expected native backend ktotal() to return a number");
+            let matchIndex = 0;
+            for (let i = 0; i < totalAll; i++) {
+                const result = native.kdata(i, "ALL");
+                if (!result.found) {
+                    continue;
+                }
+                const probe = kernelKindProbeFromNative(result);
+                if (!matchesKernelKind(requested, probe)) {
+                    continue;
+                }
+                if (matchIndex === which) {
+                    const kernel = kernelDataFromNative(result);
+                    return { found: true, ...kernel };
+                }
+                matchIndex++;
+            }
+            return { found: false };
+        },
     };
 }
 //# sourceMappingURL=kernels.js.map

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

@@ -1,4 +1,5 @@
 import type { TimeApi } from "#backend-contract";
 import type { NativeAddon } from "../runtime/addon.js";
+/** Create a {@link TimeApi} implementation backed by the native Node addon. */
 export declare function createTimeApi(native: NativeAddon): TimeApi;
 //# sourceMappingURL=time.d.ts.map

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

@@ -1,5 +1,28 @@
-import { invariant } from "#core";
+import { assertNever, invariant } from "#core";
+/** Create a {@link TimeApi} implementation backed by the native Node addon. */
 export function createTimeApi(native) {
+    function timdef(action, item, value) {
+        if (item.length === 0) {
+            throw new RangeError("timdef(): item must be a non-empty string");
+        }
+        switch (action) {
+            case "GET": {
+                const out = native.timdefGet(item);
+                invariant(typeof out === "string", "Expected timdef(GET) to return a string");
+                return out;
+            }
+            case "SET": {
+                invariant(typeof value === "string", "timdef(SET) requires a string value");
+                if (value.length === 0) {
+                    throw new RangeError("timdef(SET)(): value must be a non-empty string");
+                }
+                native.timdefSet(item, value);
+                return;
+            }
+            default:
+                return assertNever(action, "Unsupported timdef action");
+        }
+    }
     return {
         spiceVersion: () => {
             const version = native.spiceVersion();
@@ -21,6 +44,37 @@ export function createTimeApi(native) {
         timout: (et, picture) => {
             return native.timout(et, picture);
         },
+        deltet: (epoch, eptype) => {
+            invariant(eptype === "ET" || eptype === "UTC", `Unsupported deltet eptype: ${eptype}`);
+            const delta = native.deltet(epoch, eptype);
+            invariant(typeof delta === "number", "Expected deltet() to return a number");
+            return delta;
+        },
+        unitim: (epoch, insys, outsys) => {
+            const out = native.unitim(epoch, insys, outsys);
+            invariant(typeof out === "number", "Expected unitim() to return a number");
+            return out;
+        },
+        tparse: (timstr) => {
+            if (timstr.length === 0) {
+                throw new RangeError("tparse(): timstr must be a non-empty string");
+            }
+            const et = native.tparse(timstr);
+            invariant(typeof et === "number", "Expected tparse() to return a number");
+            return et;
+        },
+        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");
+            }
+            const out = native.tpictr(sample, pictur);
+            invariant(typeof out === "string", "Expected tpictr() to return a string");
+            return out;
+        },
+        timdef,
         scs2e: (sc, sclkch) => {
             const et = native.scs2e(sc, sclkch);
             invariant(typeof et === "number", "Expected scs2e() to return a number");
@@ -31,6 +85,26 @@ export function createTimeApi(native) {
             invariant(typeof out === "string", "Expected sce2s() to return a string");
             return out;
         },
+        scencd: (sc, sclkch) => {
+            const out = native.scencd(sc, sclkch);
+            invariant(typeof out === "number", "Expected scencd() to return a number");
+            return out;
+        },
+        scdecd: (sc, sclkdp) => {
+            const out = native.scdecd(sc, sclkdp);
+            invariant(typeof out === "string", "Expected scdecd() to return a string");
+            return out;
+        },
+        sct2e: (sc, sclkdp) => {
+            const out = native.sct2e(sc, sclkdp);
+            invariant(typeof out === "number", "Expected sct2e() to return a number");
+            return out;
+        },
+        sce2c: (sc, et) => {
+            const out = native.sce2c(sc, et);
+            invariant(typeof out === "number", "Expected sce2c() to return a number");
+            return out;
+        },
     };
 }
 //# sourceMappingURL=time.js.map

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

@@ -1,5 +1,7 @@
 import type { SpiceBackend } from "#backend-contract";
+/** Return the SPICE toolkit version exposed by the native Node addon. */
 export declare function spiceVersion(): string;
+/** Create a {@link SpiceBackend} implementation backed by the native Node addon. */
 export declare function createNodeBackend(): SpiceBackend & {
     kind: "node";
 };

package/backend-node/dist/index.js

@@ -2,33 +2,94 @@ import { invariant } from "#core";
 import { getNativeAddon } from "./native.js";
 import { getNodeBinding } from "./lowlevel/binding.js";
 import { createKernelStager } from "./runtime/kernel-staging.js";
+import { createVirtualOutputStager } from "./runtime/virtual-output-staging.js";
+import { createSpiceHandleRegistry } from "./runtime/spice-handles.js";
 import { createCoordsVectorsApi } from "./domains/coords-vectors.js";
 import { createEphemerisApi } from "./domains/ephemeris.js";
 import { createFramesApi } from "./domains/frames.js";
 import { createGeometryApi } from "./domains/geometry.js";
+import { createGeometryGfApi } from "./domains/geometry-gf.js";
 import { createIdsNamesApi } from "./domains/ids-names.js";
 import { createKernelsApi } from "./domains/kernels.js";
+import { createKernelPoolApi } from "./domains/kernel-pool.js";
 import { createTimeApi } from "./domains/time.js";
+import { createFileIoApi } from "./domains/file-io.js";
+import { createErrorApi } from "./domains/error.js";
+import { createCellsWindowsApi } from "./domains/cells-windows.js";
+import { createDskApi } from "./domains/dsk.js";
+import { createEkApi } from "./domains/ek.js";
+/** Return the SPICE toolkit version exposed by the native Node addon. */
 export function spiceVersion() {
     const version = getNativeAddon().spiceVersion();
     invariant(typeof version === "string", "Expected native backend spiceVersion() to return a string");
     return version;
 }
+/** Create a {@link SpiceBackend} implementation backed by the native Node addon. */
 export function createNodeBackend() {
     const native = getNodeBinding();
     const stager = createKernelStager();
+    const spiceHandles = createSpiceHandleRegistry();
+    const outputs = createVirtualOutputStager();
     const backend = {
         kind: "node",
         ...createTimeApi(native),
         ...createKernelsApi(native, stager),
+        ...createKernelPoolApi(native),
         ...createIdsNamesApi(native),
         ...createFramesApi(native),
-        ...createEphemerisApi(native),
+        ...createEphemerisApi(native, spiceHandles, stager, outputs),
         ...createGeometryApi(native),
+        ...createGeometryGfApi(native),
         ...createCoordsVectorsApi(native),
+        ...createFileIoApi(native, spiceHandles, outputs),
+        ...createErrorApi(native),
+        ...createCellsWindowsApi(native),
+        ...createEkApi(native, spiceHandles, stager),
+        ...createDskApi(native, spiceHandles),
     };
     // Internal testing hook (not part of the public backend contract).
     backend.__ktotalAll = () => native.__ktotalAll();
+    // Internal best-effort cleanup hook (not part of the public backend contract).
+    // Closes all currently-registered DAF/DAS/DLA/EK/SPK handles and throws an AggregateError if any closes fail.
+    Object.defineProperty(backend, "disposeAll", {
+        value: () => {
+            const errors = [];
+            const entries = spiceHandles.__entries?.() ?? [];
+            for (const [handle, entry] of entries) {
+                try {
+                    if (entry.kind === "SPK") {
+                        // Ensure VirtualOutputStager bookkeeping stays consistent.
+                        backend.spkcls(handle);
+                        continue;
+                    }
+                    if (entry.kind === "DAF") {
+                        spiceHandles.close(handle, ["DAF"], (e) => native.dafcls(e.nativeHandle), "disposeAll:dafcls");
+                    }
+                    else if (entry.kind === "EK") {
+                        spiceHandles.close(handle, ["EK"], (e) => native.ekcls(e.nativeHandle), "disposeAll:ekcls");
+                    }
+                    else {
+                        // In CSPICE, dascls_c closes both DAS and DLA handles (dlacls_c is an alias).
+                        spiceHandles.close(handle, ["DAS", "DLA"], (e) => native.dascls(e.nativeHandle), "disposeAll:dascls");
+                    }
+                }
+                catch (err) {
+                    errors.push(err);
+                }
+            }
+            // Best-effort cleanup for any staged virtual outputs.
+            try {
+                outputs.dispose();
+            }
+            catch (err) {
+                errors.push(err);
+            }
+            if (errors.length > 0) {
+                throw new AggregateError(errors, `disposeAll(): failed to close ${errors.length} handle(s)`);
+            }
+        },
+        enumerable: false,
+    });
     return backend;
 }
 //# sourceMappingURL=index.js.map

package/backend-node/dist/lowlevel/binding.d.ts

@@ -1,3 +1,6 @@
 import type { NativeAddon } from "../runtime/addon.js";
+/**
+ * Get the loaded native addon binding and assert it provides the expected entrypoints.
+ */
 export declare function getNodeBinding(): NativeAddon;
 //# sourceMappingURL=binding.d.ts.map