@rybosome/tspice 0.0.3 → 0.0.8

package/backend-node/dist/lowlevel/binding.js

@@ -1,5 +1,8 @@
 import { invariant } from "#core";
 import { getNativeAddon } from "../runtime/addon.js";
+/**
+ * Get the loaded native addon binding and assert it provides the expected entrypoints.
+ */
 export function getNodeBinding() {
     const native = getNativeAddon();
     invariant(typeof native.furnsh === "function", "Expected native addon to export furnsh(path)");
@@ -7,9 +10,69 @@ export function getNodeBinding() {
     invariant(typeof native.kclear === "function", "Expected native addon to export kclear()");
     invariant(typeof native.ktotal === "function", "Expected native addon to export ktotal(kind?)");
     invariant(typeof native.kdata === "function", "Expected native addon to export kdata(which, kind?)");
+    invariant(typeof native.gdpool === "function", "Expected native addon to export gdpool(name, start, room)");
+    invariant(typeof native.gipool === "function", "Expected native addon to export gipool(name, start, room)");
+    invariant(typeof native.gcpool === "function", "Expected native addon to export gcpool(name, start, room)");
+    invariant(typeof native.gnpool === "function", "Expected native addon to export gnpool(template, start, room)");
+    invariant(typeof native.dtpool === "function", "Expected native addon to export dtpool(name)");
+    invariant(typeof native.pdpool === "function", "Expected native addon to export pdpool(name, values)");
+    invariant(typeof native.pipool === "function", "Expected native addon to export pipool(name, values)");
+    invariant(typeof native.pcpool === "function", "Expected native addon to export pcpool(name, values)");
+    invariant(typeof native.swpool === "function", "Expected native addon to export swpool(agent, names)");
+    invariant(typeof native.cvpool === "function", "Expected native addon to export cvpool(agent)");
+    invariant(typeof native.expool === "function", "Expected native addon to export expool(name)");
     invariant(typeof native.str2et === "function", "Expected native addon to export str2et(time)");
     invariant(typeof native.et2utc === "function", "Expected native addon to export et2utc(et, format, prec)");
     invariant(typeof native.timout === "function", "Expected native addon to export timout(et, picture)");
+    invariant(typeof native.deltet === "function", "Expected native addon to export deltet(epoch, eptype)");
+    invariant(typeof native.unitim === "function", "Expected native addon to export unitim(epoch, insys, outsys)");
+    invariant(typeof native.tparse === "function", "Expected native addon to export tparse(timstr)");
+    invariant(typeof native.tpictr === "function", "Expected native addon to export tpictr(sample, pictur)");
+    invariant(typeof native.timdefGet === "function", "Expected native addon to export timdefGet(item)");
+    invariant(typeof native.timdefSet === "function", "Expected native addon to export timdefSet(item, value)");
+    invariant(typeof native.failed === "function", "Expected native addon to export failed()");
+    invariant(typeof native.reset === "function", "Expected native addon to export reset()");
+    invariant(typeof native.getmsg === "function", "Expected native addon to export getmsg(which)");
+    invariant(typeof native.setmsg === "function", "Expected native addon to export setmsg(message)");
+    invariant(typeof native.sigerr === "function", "Expected native addon to export sigerr(short)");
+    invariant(typeof native.chkin === "function", "Expected native addon to export chkin(name)");
+    invariant(typeof native.chkout === "function", "Expected native addon to export chkout(name)");
+    invariant(typeof native.exists === "function", "Expected native addon to export exists(path)");
+    invariant(typeof native.getfat === "function", "Expected native addon to export getfat(path)");
+    invariant(typeof native.dafopr === "function", "Expected native addon to export dafopr(path)");
+    invariant(typeof native.dafcls === "function", "Expected native addon to export dafcls(handle)");
+    invariant(typeof native.dafbfs === "function", "Expected native addon to export dafbfs(handle)");
+    invariant(typeof native.daffna === "function", "Expected native addon to export daffna(handle)");
+    invariant(typeof native.dasopr === "function", "Expected native addon to export dasopr(path)");
+    invariant(typeof native.dascls === "function", "Expected native addon to export dascls(handle)");
+    invariant(typeof native.dlaopn === "function", "Expected native addon to export dlaopn(path, ftype, ifname, ncomch)");
+    invariant(typeof native.dlabfs === "function", "Expected native addon to export dlabfs(handle)");
+    invariant(typeof native.dlafns === "function", "Expected native addon to export dlafns(handle, descr)");
+    // --- EK ---
+    invariant(typeof native.ekopr === "function", "Expected native addon to export ekopr(path)");
+    invariant(typeof native.ekopw === "function", "Expected native addon to export ekopw(path)");
+    invariant(typeof native.ekopn === "function", "Expected native addon to export ekopn(path, ifname, ncomch)");
+    invariant(typeof native.ekcls === "function", "Expected native addon to export ekcls(handle)");
+    invariant(typeof native.ekntab === "function", "Expected native addon to export ekntab()");
+    invariant(typeof native.ektnam === "function", "Expected native addon to export ektnam(n)");
+    invariant(typeof native.eknseg === "function", "Expected native addon to export eknseg(handle)");
+    invariant(typeof native.ekfind === "function", "Expected native addon to export ekfind(query)");
+    invariant(typeof native.ekgc === "function", "Expected native addon to export ekgc(selidx, row, elment)");
+    invariant(typeof native.ekgd === "function", "Expected native addon to export ekgd(selidx, row, elment)");
+    invariant(typeof native.ekgi === "function", "Expected native addon to export ekgi(selidx, row, elment)");
+    invariant(typeof native.ekifld === "function", "Expected native addon to export ekifld(handle, tabnam, nrows, cnames, decls)");
+    invariant(typeof native.ekacli === "function", "Expected native addon to export ekacli(handle, segno, column, ivals, entszs, nlflgs, rcptrs)");
+    invariant(typeof native.ekacld === "function", "Expected native addon to export ekacld(handle, segno, column, dvals, entszs, nlflgs, rcptrs)");
+    invariant(typeof native.ekaclc === "function", "Expected native addon to export ekaclc(handle, segno, column, cvals, entszs, nlflgs, rcptrs)");
+    invariant(typeof native.ekffld === "function", "Expected native addon to export ekffld(handle, segno, rcptrs)");
+    // --- DSK writer ---
+    invariant(typeof native.dskopn === "function", "Expected native addon to export dskopn(path, ifname, ncomch)");
+    invariant(typeof native.dskmi2 === "function", "Expected native addon to export dskmi2(nv, vrtces, np, plates, finscl, corscl, worksz, voxpsz, voxlsz, makvtl, spxisz)");
+    invariant(typeof native.dskw02 === "function", "Expected native addon to export dskw02(handle, center, surfid, dclass, frame, corsys, corpar, mncor1, mxcor1, mncor2, mxcor2, mncor3, mxcor3, first, last, nv, vrtces, np, plates, spaixd, spaixi)");
+    invariant(typeof native.dskobj === "function", "Expected native addon to export dskobj(dsk, bodids)");
+    invariant(typeof native.dsksrf === "function", "Expected native addon to export dsksrf(dsk, bodyid, srfids)");
+    invariant(typeof native.dskgd === "function", "Expected native addon to export dskgd(handle, dladsc)");
+    invariant(typeof native.dskb02 === "function", "Expected native addon to export dskb02(handle, dladsc)");
     invariant(typeof native.bodn2c === "function", "Expected native addon to export bodn2c(name)");
     invariant(typeof native.bodc2n === "function", "Expected native addon to export bodc2n(code)");
     invariant(typeof native.namfrm === "function", "Expected native addon to export namfrm(name)");
@@ -18,6 +81,10 @@ export function getNodeBinding() {
     invariant(typeof native.cnmfrm === "function", "Expected native addon to export cnmfrm(centerName)");
     invariant(typeof native.scs2e === "function", "Expected native addon to export scs2e(sc, sclkch)");
     invariant(typeof native.sce2s === "function", "Expected native addon to export sce2s(sc, et)");
+    invariant(typeof native.scencd === "function", "Expected native addon to export scencd(sc, sclkch)");
+    invariant(typeof native.scdecd === "function", "Expected native addon to export scdecd(sc, sclkdp)");
+    invariant(typeof native.sct2e === "function", "Expected native addon to export sct2e(sc, sclkdp)");
+    invariant(typeof native.sce2c === "function", "Expected native addon to export sce2c(sc, et)");
     invariant(typeof native.ckgp === "function", "Expected native addon to export ckgp(inst, sclkdp, tol, ref)");
     invariant(typeof native.ckgpav === "function", "Expected native addon to export ckgpav(inst, sclkdp, tol, ref)");
     invariant(typeof native.pxform === "function", "Expected native addon to export pxform(from, to, et)");
@@ -32,13 +99,61 @@ export function getNodeBinding() {
     invariant(typeof native.vcrss === "function", "Expected native addon to export vcrss(a, b)");
     invariant(typeof native.mxv === "function", "Expected native addon to export mxv(m, v)");
     invariant(typeof native.mtxv === "function", "Expected native addon to export mtxv(m, v)");
+    invariant(typeof native.vadd === "function", "Expected native addon to export vadd(a, b)");
+    invariant(typeof native.vsub === "function", "Expected native addon to export vsub(a, b)");
+    invariant(typeof native.vminus === "function", "Expected native addon to export vminus(v)");
+    invariant(typeof native.vscl === "function", "Expected native addon to export vscl(s, v)");
+    invariant(typeof native.mxm === "function", "Expected native addon to export mxm(a, b)");
+    invariant(typeof native.rotate === "function", "Expected native addon to export rotate(angle, axis)");
+    invariant(typeof native.rotmat === "function", "Expected native addon to export rotmat(m, angle, axis)");
+    invariant(typeof native.axisar === "function", "Expected native addon to export axisar(axis, angle)");
+    invariant(typeof native.georec === "function", "Expected native addon to export georec(lon, lat, alt, re, f)");
+    invariant(typeof native.recgeo === "function", "Expected native addon to export recgeo(rect, re, f)");
+    invariant(typeof native.newIntCell === "function", "Expected native addon to export newIntCell(size)");
+    invariant(typeof native.newDoubleCell === "function", "Expected native addon to export newDoubleCell(size)");
+    invariant(typeof native.newCharCell === "function", "Expected native addon to export newCharCell(size, length)");
+    invariant(typeof native.newWindow === "function", "Expected native addon to export newWindow(maxIntervals)");
+    invariant(typeof native.freeCell === "function", "Expected native addon to export freeCell(cell)");
+    invariant(typeof native.freeWindow === "function", "Expected native addon to export freeWindow(window)");
+    invariant(typeof native.ssize === "function", "Expected native addon to export ssize(size, cell)");
+    invariant(typeof native.scard === "function", "Expected native addon to export scard(card, cell)");
+    invariant(typeof native.card === "function", "Expected native addon to export card(cell)");
+    invariant(typeof native.size === "function", "Expected native addon to export size(cell)");
+    invariant(typeof native.valid === "function", "Expected native addon to export valid(size, n, cell)");
+    invariant(typeof native.insrti === "function", "Expected native addon to export insrti(item, cell)");
+    invariant(typeof native.insrtd === "function", "Expected native addon to export insrtd(item, cell)");
+    invariant(typeof native.insrtc === "function", "Expected native addon to export insrtc(item, cell)");
+    invariant(typeof native.cellGeti === "function", "Expected native addon to export cellGeti(cell, index)");
+    invariant(typeof native.cellGetd === "function", "Expected native addon to export cellGetd(cell, index)");
+    invariant(typeof native.cellGetc === "function", "Expected native addon to export cellGetc(cell, index)");
+    invariant(typeof native.wninsd === "function", "Expected native addon to export wninsd(left, right, window)");
+    invariant(typeof native.wncard === "function", "Expected native addon to export wncard(window)");
+    invariant(typeof native.wnfetd === "function", "Expected native addon to export wnfetd(window, index)");
+    invariant(typeof native.wnvald === "function", "Expected native addon to export wnvald(size, n, window)");
     invariant(typeof native.spkezr === "function", "Expected native addon to export spkezr(target, et, ref, abcorr, observer)");
     invariant(typeof native.spkpos === "function", "Expected native addon to export spkpos(target, et, ref, abcorr, observer)");
+    invariant(typeof native.spkopn === "function", "Expected native addon to export spkopn(path, ifname, ncomch)");
+    invariant(typeof native.spkopa === "function", "Expected native addon to export spkopa(path)");
+    invariant(typeof native.spkw08 === "function", "Expected native addon to export spkw08(handle, body, center, frame, first, last, segid, degree, states, epoch1, step)");
+    invariant(typeof native.spkcls === "function", "Expected native addon to export spkcls(handle)");
     invariant(typeof native.subpnt === "function", "Expected native addon to export subpnt(method, target, et, fixref, abcorr, observer)");
     invariant(typeof native.subslr === "function", "Expected native addon to export subslr(method, target, et, fixref, abcorr, observer)");
+    invariant(typeof native.illumg === "function", "Expected native addon to export illumg(method, target, ilusrc, et, fixref, abcorr, observer, spoint)");
+    invariant(typeof native.illumf === "function", "Expected native addon to export illumf(method, target, ilusrc, et, fixref, abcorr, observer, spoint)");
+    invariant(typeof native.nvc2pl === "function", "Expected native addon to export nvc2pl(normal, konst)");
+    invariant(typeof native.pl2nvc === "function", "Expected native addon to export pl2nvc(plane)");
     invariant(typeof native.sincpt === "function", "Expected native addon to export sincpt(method, target, et, fixref, abcorr, observer, dref, dvec)");
     invariant(typeof native.ilumin === "function", "Expected native addon to export ilumin(method, target, et, fixref, abcorr, observer, spoint)");
     invariant(typeof native.occult === "function", "Expected native addon to export occult(targ1, shape1, frame1, targ2, shape2, frame2, abcorr, observer, et)");
+    // --- GF (Geometry Finder) ---
+    invariant(typeof native.gfsstp === "function", "Expected native addon to export gfsstp(step)");
+    invariant(typeof native.gfstep === "function", "Expected native addon to export gfstep(time)");
+    invariant(typeof native.gfstol === "function", "Expected native addon to export gfstol(value)");
+    invariant(typeof native.gfrefn === "function", "Expected native addon to export gfrefn(t1, t2, s1, s2)");
+    invariant(typeof native.gfrepi === "function", "Expected native addon to export gfrepi(window, begmss, endmss)");
+    invariant(typeof native.gfrepf === "function", "Expected native addon to export gfrepf()");
+    invariant(typeof native.gfsep === "function", "Expected native addon to export gfsep(targ1, shape1, frame1, targ2, shape2, frame2, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, result)");
+    invariant(typeof native.gfdist === "function", "Expected native addon to export gfdist(target, abcorr, obsrvr, relate, refval, adjust, step, nintvls, cnfine, result)");
     return native;
 }
 //# sourceMappingURL=binding.js.map

package/backend-node/dist/runtime/addon.d.ts

@@ -1,5 +1,13 @@
+import type { SpiceIntCell, SpiceWindow } from "#backend-contract";
 export type NativeAddon = {
     spiceVersion(): string;
+    failed(): boolean;
+    reset(): void;
+    getmsg(which: "SHORT" | "LONG" | "EXPLAIN"): string;
+    setmsg(message: string): void;
+    sigerr(short: string): void;
+    chkin(name: string): void;
+    chkout(name: string): void;
     furnsh(path: string): void;
     unload(path: string): void;
     kclear(): void;
@@ -11,9 +19,137 @@ export type NativeAddon = {
         source?: string;
         handle?: number;
     };
+    kinfo(path: string): {
+        found: boolean;
+        filtyp?: string;
+        source?: string;
+        handle?: number;
+    };
+    kxtrct(keywd: string, terms: readonly string[], wordsq: string): {
+        found: boolean;
+        wordsq?: string;
+        substr?: string;
+    };
+    kplfrm(frmcls: number, idset: number): void;
+    gdpool(name: string, start: number, room: number): {
+        found: boolean;
+        values?: number[];
+    };
+    gipool(name: string, start: number, room: number): {
+        found: boolean;
+        values?: number[];
+    };
+    gcpool(name: string, start: number, room: number): {
+        found: boolean;
+        values?: string[];
+    };
+    gnpool(template: string, start: number, room: number): {
+        found: boolean;
+        values?: string[];
+    };
+    dtpool(name: string): {
+        found: boolean;
+        n?: number;
+        type?: string;
+    };
+    pdpool(name: string, values: readonly number[]): void;
+    pipool(name: string, values: readonly number[]): void;
+    pcpool(name: string, values: readonly string[]): void;
+    swpool(agent: string, names: readonly string[]): void;
+    cvpool(agent: string): boolean;
+    expool(name: string): boolean;
     str2et(utc: string): number;
     et2utc(et: number, format: string, prec: number): string;
     timout(et: number, picture: string): string;
+    deltet(epoch: number, eptype: string): number;
+    unitim(epoch: number, insys: string, outsys: string): number;
+    tparse(timstr: string): number;
+    tpictr(sample: string, pictur: string): string;
+    timdefGet(item: string): string;
+    timdefSet(item: string, value: string): void;
+    exists(path: string): boolean;
+    getfat(path: string): {
+        arch: string;
+        type: string;
+    };
+    dafopr(path: string): number;
+    dafcls(handle: number): void;
+    dafbfs(handle: number): void;
+    daffna(handle: number): boolean;
+    dasopr(path: string): number;
+    dascls(handle: number): void;
+    dlaopn(path: string, ftype: string, ifname: string, ncomch: number): number;
+    dlabfs(handle: number): {
+        found: boolean;
+        descr?: Record<string, unknown>;
+    };
+    dlafns(handle: number, descr: Record<string, unknown>): {
+        found: boolean;
+        descr?: Record<string, unknown>;
+    };
+    dlacls(handle: number): void;
+    ekopr(path: string): number;
+    ekopw(path: string): number;
+    ekopn(path: string, ifname: string, ncomch: number): number;
+    ekcls(handle: number): void;
+    ekntab(): number;
+    ektnam(n: number): string;
+    eknseg(handle: number): number;
+    ekfind(query: string): {
+        ok: true;
+        nmrows: number;
+    } | {
+        ok: false;
+        errmsg: string;
+    };
+    ekgc(selidx: number, row: number, elment: number): {
+        found: false;
+    } | {
+        found: true;
+        isNull: true;
+    } | {
+        found: true;
+        isNull: false;
+        value: string;
+    };
+    ekgd(selidx: number, row: number, elment: number): {
+        found: false;
+    } | {
+        found: true;
+        isNull: true;
+    } | {
+        found: true;
+        isNull: false;
+        value: number;
+    };
+    ekgi(selidx: number, row: number, elment: number): {
+        found: false;
+    } | {
+        found: true;
+        isNull: true;
+    } | {
+        found: true;
+        isNull: false;
+        value: number;
+    };
+    ekifld(handle: number, tabnam: string, nrows: number, cnames: readonly string[], decls: readonly string[]): {
+        segno: number;
+        rcptrs: number[];
+    };
+    ekacli(handle: number, segno: number, column: string, ivals: readonly number[], entszs: readonly number[], nlflgs: readonly boolean[], rcptrs: readonly number[]): void;
+    ekacld(handle: number, segno: number, column: string, dvals: readonly number[], entszs: readonly number[], nlflgs: readonly boolean[], rcptrs: readonly number[]): void;
+    ekaclc(handle: number, segno: number, column: string, cvals: readonly string[], entszs: readonly number[], nlflgs: readonly boolean[], rcptrs: readonly number[]): void;
+    ekffld(handle: number, segno: number, rcptrs: readonly number[]): void;
+    dskopn(path: string, ifname: string, ncomch: number): number;
+    dskmi2(nv: number, vrtces: readonly number[], np: number, plates: readonly number[], finscl: number, corscl: number, worksz: number, voxpsz: number, voxlsz: number, makvtl: boolean, spxisz: number): {
+        spaixd: number[];
+        spaixi: number[];
+    };
+    dskw02(handle: number, center: number, surfid: number, dclass: number, frame: string, corsys: number, corpar: readonly number[], mncor1: number, mxcor1: number, mncor2: number, mxcor2: number, mncor3: number, mxcor3: number, first: number, last: number, nv: number, vrtces: readonly number[], np: number, plates: readonly number[], spaixd: readonly number[], spaixi: readonly number[]): void;
+    dskobj(dsk: string, bodidsCellHandle: number): void;
+    dsksrf(dsk: string, bodyid: number, srfidsCellHandle: number): void;
+    dskgd(handle: number, dladsc: Record<string, unknown>): Record<string, unknown>;
+    dskb02(handle: number, dladsc: Record<string, unknown>): Record<string, unknown>;
     bodn2c(name: string): {
         found: boolean;
         code?: number;
@@ -22,6 +158,14 @@ export type NativeAddon = {
         found: boolean;
         name?: string;
     };
+    bodc2s(code: number): string;
+    bods2c(name: string): {
+        found: boolean;
+        code?: number;
+    };
+    boddef(name: string, code: number): void;
+    bodfnd(body: number, item: string): boolean;
+    bodvar(body: number, item: string): number[];
     namfrm(name: string): {
         found: boolean;
         code?: number;
@@ -40,8 +184,24 @@ export type NativeAddon = {
         frcode?: number;
         frname?: string;
     };
+    frinfo(frameId: number): {
+        found: boolean;
+        center?: number;
+        frameClass?: number;
+        classId?: number;
+    };
+    ccifrm(frameClass: number, classId: number): {
+        found: boolean;
+        frcode?: number;
+        frname?: string;
+        center?: number;
+    };
     scs2e(sc: number, sclkch: string): number;
     sce2s(sc: number, et: number): string;
+    scencd(sc: number, sclkch: string): number;
+    scdecd(sc: number, sclkdp: number): string;
+    sct2e(sc: number, sclkdp: number): number;
+    sce2c(sc: number, et: number): number;
     ckgp(inst: number, sclkdp: number, tol: number, ref: string): {
         found: boolean;
         cmat?: number[];
@@ -53,6 +213,10 @@ export type NativeAddon = {
         av?: number[];
         clkout?: number;
     };
+    cklpf(ck: string): number;
+    ckupf(handle: number): void;
+    ckobj(ck: string, idsCellHandle: number): void;
+    ckcov(ck: string, idcode: number, needav: boolean, level: string, tol: number, timsys: string, coverWindowHandle: number): void;
     spkezr(target: string, et: number, ref: string, abcorr: string, obs: string): {
         state: number[];
         lt: number;
@@ -61,6 +225,67 @@ export type NativeAddon = {
         pos: number[];
         lt: number;
     };
+    spkez(target: number, et: number, ref: string, abcorr: string, obs: number): {
+        state: number[];
+        lt: number;
+    };
+    spkezp(target: number, et: number, ref: string, abcorr: string, obs: number): {
+        pos: number[];
+        lt: number;
+    };
+    spkgeo(target: number, et: number, ref: string, obs: number): {
+        state: number[];
+        lt: number;
+    };
+    spkgps(target: number, et: number, ref: string, obs: number): {
+        pos: number[];
+        lt: number;
+    };
+    illumg(method: string, target: string, ilusrc: string, et: number, fixref: string, abcorr: string, observer: string, spoint: number[]): {
+        trgepc: number;
+        srfvec: number[];
+        phase: number;
+        incdnc: number;
+        emissn: number;
+    };
+    illumf(method: string, target: string, ilusrc: string, et: number, fixref: string, abcorr: string, observer: string, spoint: number[]): {
+        trgepc: number;
+        srfvec: number[];
+        phase: number;
+        incdnc: number;
+        emissn: number;
+        visibl: boolean;
+        lit: boolean;
+    };
+    spkssb(target: number, et: number, ref: string): number[];
+    spkcov(spk: string, idcode: number, cover: SpiceWindow): void;
+    nvc2pl(normal: number[], konst: number): number[];
+    pl2nvc(plane: number[]): {
+        normal: number[];
+        konst: number;
+    };
+    spkobj(spk: string, ids: SpiceIntCell): void;
+    spksfs(body: number, et: number): {
+        found: boolean;
+        handle?: number;
+        descr?: number[];
+        ident?: string;
+    };
+    spkpds(body: number, center: number, frame: string, type: number, first: number, last: number): number[];
+    spkuds(descr: ReadonlyArray<number>): {
+        body: number;
+        center: number;
+        frame: number;
+        type: number;
+        first: number;
+        last: number;
+        baddr: number;
+        eaddr: number;
+    };
+    spkopn(path: string, ifname: string, ncomch: number): number;
+    spkopa(path: string): number;
+    spkcls(handle: number): void;
+    spkw08(handle: number, body: number, center: number, frame: string, first: number, last: number, segid: string, degree: number, states: readonly number[] | Float64Array, epoch1: number, step: number): void;
     subpnt(method: string, target: string, et: number, fixref: string, abcorr: string, observer: string): {
         spoint: number[];
         trgepc: number;
@@ -85,6 +310,14 @@ export type NativeAddon = {
         emissn: number;
     };
     occult(targ1: string, shape1: string, frame1: string, targ2: string, shape2: string, frame2: string, abcorr: string, observer: string, et: number): number;
+    gfsstp(step: number): void;
+    gfstep(time: number): number;
+    gfstol(value: number): void;
+    gfrefn(t1: number, t2: number, s1: boolean, s2: boolean): number;
+    gfrepi(window: SpiceWindow, begmss: string, endmss: string): void;
+    gfrepf(): void;
+    gfsep(targ1: string, shape1: string, frame1: string, targ2: string, shape2: string, frame2: string, abcorr: string, obsrvr: string, relate: string, refval: number, adjust: number, step: number, nintvls: number, cnfine: SpiceWindow, result: SpiceWindow): void;
+    gfdist(target: string, abcorr: string, obsrvr: string, relate: string, refval: number, adjust: number, step: number, nintvls: number, cnfine: SpiceWindow, result: SpiceWindow): void;
     pxform(from: string, to: string, et: number): number[];
     sxform(from: string, to: string, et: number): number[];
     reclat(rect: number[]): {
@@ -103,10 +336,48 @@ export type NativeAddon = {
     vhat(v: number[]): number[];
     vdot(a: number[], b: number[]): number;
     vcrss(a: number[], b: number[]): number[];
-    mxv(m: number[], v: number[]): number[];
-    mtxv(m: number[], v: number[]): number[];
+    mxv(m: readonly number[], v: readonly number[]): number[];
+    mtxv(m: readonly number[], v: readonly number[]): number[];
+    vadd(a: readonly number[], b: readonly number[]): number[];
+    vsub(a: readonly number[], b: readonly number[]): number[];
+    vminus(v: readonly number[]): number[];
+    vscl(s: number, v: readonly number[]): number[];
+    mxm(a: readonly number[], b: readonly number[]): number[];
+    rotate(angle: number, axis: number): number[];
+    rotmat(m: readonly number[], angle: number, axis: number): number[];
+    axisar(axis: readonly number[], angle: number): number[];
+    georec(lon: number, lat: number, alt: number, re: number, f: number): number[];
+    recgeo(rect: readonly number[], re: number, f: number): {
+        lon: number;
+        lat: number;
+        alt: number;
+    };
+    newIntCell(size: number): number;
+    newDoubleCell(size: number): number;
+    newCharCell(size: number, length: number): number;
+    newWindow(maxIntervals: number): number;
+    freeCell(cell: number): void;
+    freeWindow(window: number): void;
+    ssize(size: number, cell: number): void;
+    scard(card: number, cell: number): void;
+    card(cell: number): number;
+    size(cell: number): number;
+    valid(size: number, n: number, cell: number): void;
+    insrti(item: number, cell: number): void;
+    insrtd(item: number, cell: number): void;
+    insrtc(item: string, cell: number): void;
+    cellGeti(cell: number, index: number): number;
+    cellGetd(cell: number, index: number): number;
+    cellGetc(cell: number, index: number): string;
+    wninsd(left: number, right: number, window: number): void;
+    wncard(window: number): number;
+    wnfetd(window: number, index: number): number[];
+    wnvald(size: number, n: number, window: number): void;
     /** Internal test helper (not part of the backend contract). */
     __ktotalAll(): number;
 };
+/**
+ * Lazily load (and cache) the native Node addon implementing the SPICE backend.
+ */
 export declare function getNativeAddon(): NativeAddon;
 //# sourceMappingURL=addon.d.ts.map

package/backend-node/dist/runtime/addon.js

@@ -64,6 +64,9 @@ function tryGetPlatformBindingPath(require) {
         throw error;
     }
 }
+/**
+ * Lazily load (and cache) the native Node addon implementing the SPICE backend.
+ */
 export function getNativeAddon() {
     if (cachedAddon) {
         return cachedAddon;

package/backend-node/dist/runtime/kernel-staging.d.ts

@@ -4,6 +4,23 @@ export type KernelStager = {
     furnsh(kernel: KernelSource, native: NativeAddon): void;
     unload(path: string, native: NativeAddon): void;
     kclear(native: NativeAddon): void;
+    /**
+     * If `path` matches a byte-staged kernel, returns the resolved OS temp-file
+     * path. Otherwise returns a canonicalized virtual kernel identifier (or the
+     * original OS path).
+     */
+    resolvePath(path: string): string;
+    /**
+     * Map an input path to the path string CSPICE expects.
+     *
+     * - OS paths pass through unchanged.
+     * - virtual kernel ids canonicalize to `/kernels/...` and, if byte-staged,
+     *   resolve to a temp path.
+     */
+    resolvePathForSpice(path: string): string;
+    /** Map a staged temp path back to its virtual id (or passthrough). */
+    virtualizePathFromSpice(path: string): string;
 };
+/** Create a staging helper that maps virtual kernel IDs to OS temp files for the native backend. */
 export declare function createKernelStager(): KernelStager;
 //# sourceMappingURL=kernel-staging.d.ts.map

package/backend-node/dist/runtime/kernel-staging.js

@@ -2,9 +2,62 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
+import { normalizeVirtualKernelPath } from "#core";
+/** Create a staging helper that maps virtual kernel IDs to OS temp files for the native backend. */
 export function createKernelStager() {
     const tempByVirtualPath = new Map();
+    const virtualByTempPath = new Map();
     let tempKernelRootDir;
+    const VIRTUAL_KERNEL_ROOT = "/kernels/";
+    /**
+     * Canonicalize a virtual kernel identifier to the shared `/kernels/...` form.
+     *
+     * This is intentionally strict (no `..`) to keep byte-backed kernel staging
+     * safe and consistent with the WASM backend.
+     */
+    function canonicalVirtualKernelPath(input) {
+        return `/kernels/${normalizeVirtualKernelPath(input)}`;
+    }
+    function isVirtualKernelId(input) {
+        // Virtual kernel identifiers are explicit and POSIX-style.
+        //
+        // We *do not* treat arbitrary relative OS paths as virtual identifiers,
+        // since that would be surprising for Node consumers (e.g. `./naif0012.tls`).
+        return input.startsWith(VIRTUAL_KERNEL_ROOT) || input.startsWith("kernels/");
+    }
+    function tryCanonicalVirtualKernelPath(input) {
+        // Treat absolute OS paths as OS paths unless the caller explicitly opted
+        // into the virtual namespace.
+        if (path.isAbsolute(input) && !input.startsWith(VIRTUAL_KERNEL_ROOT)) {
+            return undefined;
+        }
+        // If this is a real on-disk absolute path, treat it as an OS path.
+        //
+        // This matters on POSIX because `/kernels/...` is a valid absolute path and
+        // could exist on disk; we only want to treat it as a virtual identifier
+        // when it doesn't resolve to a real file.
+        if (path.isAbsolute(input) && fs.existsSync(input)) {
+            return undefined;
+        }
+        try {
+            // Explicit virtual identifiers always participate.
+            if (isVirtualKernelId(input)) {
+                return canonicalVirtualKernelPath(input);
+            }
+            // For non-explicit relative paths, only treat as virtual if we already
+            // staged bytes for that id. This preserves `unload("naif0012.tls")` for
+            // byte-backed kernels without hijacking arbitrary on-disk relative paths.
+            if (!path.isAbsolute(input)) {
+                const canonical = canonicalVirtualKernelPath(input);
+                return tempByVirtualPath.has(canonical) ? canonical : undefined;
+            }
+            return undefined;
+        }
+        catch {
+            // Only treat as virtual if it normalizes successfully.
+            return undefined;
+        }
+    }
     function ensureTempKernelRootDir() {
         if (tempKernelRootDir) {
             return tempKernelRootDir;
@@ -23,24 +76,37 @@ export function createKernelStager() {
             }
         }
     }
+    function resolvePathForSpice(input) {
+        const canonical = tryCanonicalVirtualKernelPath(input);
+        if (!canonical) {
+            return input;
+        }
+        // If this is a valid virtual kernel path but it's not staged, return the
+        // canonical virtual identifier. This keeps the backend behavior stable
+        // regardless of whether callers use `kernels/foo.tm`, `/kernels/foo.tm`,
+        // or other equivalent virtual spellings.
+        return tempByVirtualPath.get(canonical) ?? canonical;
+    }
     return {
         furnsh: (_kernel, native) => {
             const kernel = _kernel;
             if (typeof kernel === "string") {
-                native.furnsh(kernel);
+                native.furnsh(resolvePathForSpice(kernel));
                 return;
             }
+            const virtualPath = canonicalVirtualKernelPath(kernel.path);
             // For byte-backed kernels, we write to a temp file and load via CSPICE.
             // We then remember the resolved temp path so `unload(kernel.path)` unloads
             // the correct file.
-            const existingTemp = tempByVirtualPath.get(kernel.path);
+            const existingTemp = tempByVirtualPath.get(virtualPath);
             if (existingTemp) {
                 native.unload(existingTemp);
-                tempByVirtualPath.delete(kernel.path);
+                tempByVirtualPath.delete(virtualPath);
+                virtualByTempPath.delete(existingTemp);
                 safeUnlink(existingTemp);
             }
             const rootDir = ensureTempKernelRootDir();
-            const fileName = path.basename(kernel.path) || "kernel";
+            const fileName = path.basename(virtualPath) || "kernel";
             const tempPath = path.join(rootDir, `${randomUUID()}-${fileName}`);
             fs.writeFileSync(tempPath, kernel.bytes);
             try {
@@ -50,13 +116,16 @@ export function createKernelStager() {
                 safeUnlink(tempPath);
                 throw error;
             }
-            tempByVirtualPath.set(kernel.path, tempPath);
+            tempByVirtualPath.set(virtualPath, tempPath);
+            virtualByTempPath.set(tempPath, virtualPath);
         },
         unload: (_path, native) => {
-            const resolved = tempByVirtualPath.get(_path);
+            const canonical = tryCanonicalVirtualKernelPath(_path);
+            const resolved = canonical ? tempByVirtualPath.get(canonical) : undefined;
             if (resolved) {
                 native.unload(resolved);
-                tempByVirtualPath.delete(_path);
+                tempByVirtualPath.delete(canonical);
+                virtualByTempPath.delete(resolved);
                 safeUnlink(resolved);
                 return;
             }
@@ -69,7 +138,11 @@ export function createKernelStager() {
                 safeUnlink(tempPath);
             }
             tempByVirtualPath.clear();
+            virtualByTempPath.clear();
         },
+        resolvePath: resolvePathForSpice,
+        resolvePathForSpice,
+        virtualizePathFromSpice: (p) => virtualByTempPath.get(p) ?? p,
     };
 }
 //# sourceMappingURL=kernel-staging.js.map

package/backend-node/dist/runtime/spice-handles.d.ts

@@ -0,0 +1,3 @@
+export type { SpiceHandleEntry, SpiceHandleKind, SpiceHandleRegistry, } from "#backend-contract";
+export { createSpiceHandleRegistry } from "#backend-contract";
+//# sourceMappingURL=spice-handles.d.ts.map