@rybosome/tspice 0.0.1 → 0.0.2-alpha

package/backend-node/dist/native.js

@@ -1,102 +1,2 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-let cachedAddon;
-const ADDON_TARGET = "tspice_backend_node";
-const ADDON_FILE = `${ADDON_TARGET}.node`;
-const NATIVE_PLATFORM_PACKAGES = {
-    darwin: {
-        arm64: "@rybosome/tspice-native-darwin-arm64",
-        x64: "@rybosome/tspice-native-darwin-x64",
-    },
-    linux: {
-        x64: "@rybosome/tspice-native-linux-x64-gnu",
-    },
-};
-const BUILD_HINT = "Try rebuilding it: pnpm run fetch:cspice && pnpm -C packages/backend-node build:native. " +
-    "Or set TSPICE_CSPICE_DIR=/abs/path/to/cspice (containing include/ and lib/). " +
-    "Or set TSPICE_BACKEND_NODE_BINDING_PATH to an explicit .node path.";
-function getPackageRoot(importMetaUrl) {
-    // Works both in the monorepo layout (`.../backend-node/dist/native.js`) and
-    // in the published `dist-publish/` layout where this code is vendored into
-    // `@rybosome/tspice`.
-    return path.resolve(path.dirname(fileURLToPath(importMetaUrl)), "..");
-}
-function loadAddon(require, bindingPath) {
-    const resolved = path.resolve(bindingPath);
-    try {
-        return require(resolved);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const { arch, platform } = process;
-        throw new Error(`Failed to load tspice native backend at "${resolved}" for ${platform}-${arch}. ` +
-            `${BUILD_HINT} ` +
-            `Original error: ${errorMessage}`, { cause: error });
-    }
-}
-function tryGetPlatformBindingPath(require) {
-    const platform = process.platform;
-    const arch = process.arch;
-    const pkgName = NATIVE_PLATFORM_PACKAGES[platform]?.[arch];
-    if (!pkgName) {
-        return undefined;
-    }
-    try {
-        const mod = require(pkgName);
-        if (typeof mod === "string") {
-            return mod;
-        }
-        if (typeof mod === "object" &&
-            mod !== null &&
-            "bindingPath" in mod &&
-            typeof mod.bindingPath === "string") {
-            return mod.bindingPath;
-        }
-        return undefined;
-    }
-    catch (error) {
-        // If the platform package isn't installed, that's expected.
-        if (error?.code === "MODULE_NOT_FOUND") {
-            return undefined;
-        }
-        throw error;
-    }
-}
-export function getNativeAddon() {
-    if (cachedAddon) {
-        return cachedAddon;
-    }
-    const require = createRequire(import.meta.url);
-    const packageRoot = getPackageRoot(import.meta.url);
-    const override = process.env.TSPICE_BACKEND_NODE_BINDING_PATH;
-    if (override) {
-        const resolvedOverride = path.resolve(packageRoot, override);
-        if (!fs.existsSync(resolvedOverride)) {
-            const { arch, platform } = process;
-            throw new Error(`TSPICE_BACKEND_NODE_BINDING_PATH points to a non-existent file: ${resolvedOverride} (platform=${platform}, arch=${arch}). Ensure it points to a built ${ADDON_FILE}.`);
-        }
-        cachedAddon = loadAddon(require, resolvedOverride);
-        return cachedAddon;
-    }
-    const platformBindingPath = tryGetPlatformBindingPath(require);
-    if (platformBindingPath) {
-        cachedAddon = loadAddon(require, platformBindingPath);
-        return cachedAddon;
-    }
-    const candidates = [
-        path.join(packageRoot, "native", "build", "Release", ADDON_FILE),
-    ];
-    const existing = candidates.find((p) => fs.existsSync(p));
-    if (!existing) {
-        const { arch, platform } = process;
-        throw new Error(`Native addon ${ADDON_FILE} not found for ${platform}-${arch}. Looked for:\n` +
-            candidates.map((p) => `- ${p}`).join("\n") +
-            `\n\nIf you built a Debug addon locally, set TSPICE_BACKEND_NODE_BINDING_PATH to its path.` +
-            `\n\n${BUILD_HINT}`);
-    }
-    cachedAddon = loadAddon(require, existing);
-    return cachedAddon;
-}
+export { getNativeAddon } from "./runtime/addon.js";
 //# sourceMappingURL=native.js.map

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

@@ -0,0 +1,112 @@
+export type NativeAddon = {
+    spiceVersion(): string;
+    furnsh(path: string): void;
+    unload(path: string): void;
+    kclear(): void;
+    ktotal(kind?: string): number;
+    kdata(which: number, kind?: string): {
+        found: boolean;
+        file?: string;
+        filtyp?: string;
+        source?: string;
+        handle?: number;
+    };
+    str2et(utc: string): number;
+    et2utc(et: number, format: string, prec: number): string;
+    timout(et: number, picture: string): string;
+    bodn2c(name: string): {
+        found: boolean;
+        code?: number;
+    };
+    bodc2n(code: number): {
+        found: boolean;
+        name?: string;
+    };
+    namfrm(name: string): {
+        found: boolean;
+        code?: number;
+    };
+    frmnam(code: number): {
+        found: boolean;
+        name?: string;
+    };
+    cidfrm(center: number): {
+        found: boolean;
+        frcode?: number;
+        frname?: string;
+    };
+    cnmfrm(centerName: string): {
+        found: boolean;
+        frcode?: number;
+        frname?: string;
+    };
+    scs2e(sc: number, sclkch: string): number;
+    sce2s(sc: number, et: number): string;
+    ckgp(inst: number, sclkdp: number, tol: number, ref: string): {
+        found: boolean;
+        cmat?: number[];
+        clkout?: number;
+    };
+    ckgpav(inst: number, sclkdp: number, tol: number, ref: string): {
+        found: boolean;
+        cmat?: number[];
+        av?: number[];
+        clkout?: number;
+    };
+    spkezr(target: string, et: number, ref: string, abcorr: string, obs: string): {
+        state: number[];
+        lt: number;
+    };
+    spkpos(target: string, et: number, ref: string, abcorr: string, obs: string): {
+        pos: number[];
+        lt: number;
+    };
+    subpnt(method: string, target: string, et: number, fixref: string, abcorr: string, observer: string): {
+        spoint: number[];
+        trgepc: number;
+        srfvec: number[];
+    };
+    subslr(method: string, target: string, et: number, fixref: string, abcorr: string, observer: string): {
+        spoint: number[];
+        trgepc: number;
+        srfvec: number[];
+    };
+    sincpt(method: string, target: string, et: number, fixref: string, abcorr: string, observer: string, dref: string, dvec: number[]): {
+        found: boolean;
+        spoint?: number[];
+        trgepc?: number;
+        srfvec?: number[];
+    };
+    ilumin(method: string, target: string, et: number, fixref: string, abcorr: string, observer: string, spoint: number[]): {
+        trgepc: number;
+        srfvec: number[];
+        phase: number;
+        incdnc: number;
+        emissn: number;
+    };
+    occult(targ1: string, shape1: string, frame1: string, targ2: string, shape2: string, frame2: string, abcorr: string, observer: string, et: number): number;
+    pxform(from: string, to: string, et: number): number[];
+    sxform(from: string, to: string, et: number): number[];
+    reclat(rect: number[]): {
+        radius: number;
+        lon: number;
+        lat: number;
+    };
+    latrec(radius: number, lon: number, lat: number): number[];
+    recsph(rect: number[]): {
+        radius: number;
+        colat: number;
+        lon: number;
+    };
+    sphrec(radius: number, colat: number, lon: number): number[];
+    vnorm(v: number[]): number;
+    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[];
+    /** Internal test helper (not part of the backend contract). */
+    __ktotalAll(): number;
+};
+export declare function getNativeAddon(): NativeAddon;
+//# sourceMappingURL=addon.d.ts.map

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

@@ -0,0 +1,102 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+let cachedAddon;
+const ADDON_TARGET = "tspice_backend_node";
+const ADDON_FILE = `${ADDON_TARGET}.node`;
+const NATIVE_PLATFORM_PACKAGES = {
+    darwin: {
+        arm64: "@rybosome/tspice-native-darwin-arm64",
+        x64: "@rybosome/tspice-native-darwin-x64",
+    },
+    linux: {
+        x64: "@rybosome/tspice-native-linux-x64-gnu",
+    },
+};
+const BUILD_HINT = "Try rebuilding it: pnpm run fetch:cspice && pnpm -C packages/backend-node build:native. " +
+    "Or set TSPICE_CSPICE_DIR=/abs/path/to/cspice (containing include/ and lib/). " +
+    "Or set TSPICE_BACKEND_NODE_BINDING_PATH to an explicit .node path.";
+function getPackageRoot(importMetaUrl) {
+    // Works both in the monorepo layout (`.../backend-node/dist/runtime/addon.js`) and
+    // in the published `dist-publish/` layout where this code is vendored into
+    // `@rybosome/tspice`.
+    return path.resolve(path.dirname(fileURLToPath(importMetaUrl)), "..", "..");
+}
+function loadAddon(require, bindingPath) {
+    const resolved = path.resolve(bindingPath);
+    try {
+        return require(resolved);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const { arch, platform } = process;
+        throw new Error(`Failed to load tspice native backend at "${resolved}" for ${platform}-${arch}. ` +
+            `${BUILD_HINT} ` +
+            `Original error: ${errorMessage}`, { cause: error });
+    }
+}
+function tryGetPlatformBindingPath(require) {
+    const platform = process.platform;
+    const arch = process.arch;
+    const pkgName = NATIVE_PLATFORM_PACKAGES[platform]?.[arch];
+    if (!pkgName) {
+        return undefined;
+    }
+    try {
+        const mod = require(pkgName);
+        if (typeof mod === "string") {
+            return mod;
+        }
+        if (typeof mod === "object" &&
+            mod !== null &&
+            "bindingPath" in mod &&
+            typeof mod.bindingPath === "string") {
+            return mod.bindingPath;
+        }
+        return undefined;
+    }
+    catch (error) {
+        // If the platform package isn't installed, that's expected.
+        if (error?.code === "MODULE_NOT_FOUND") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function getNativeAddon() {
+    if (cachedAddon) {
+        return cachedAddon;
+    }
+    const require = createRequire(import.meta.url);
+    const packageRoot = getPackageRoot(import.meta.url);
+    const override = process.env.TSPICE_BACKEND_NODE_BINDING_PATH;
+    if (override) {
+        const resolvedOverride = path.resolve(packageRoot, override);
+        if (!fs.existsSync(resolvedOverride)) {
+            const { arch, platform } = process;
+            throw new Error(`TSPICE_BACKEND_NODE_BINDING_PATH points to a non-existent file: ${resolvedOverride} (platform=${platform}, arch=${arch}). Ensure it points to a built ${ADDON_FILE}.`);
+        }
+        cachedAddon = loadAddon(require, resolvedOverride);
+        return cachedAddon;
+    }
+    const platformBindingPath = tryGetPlatformBindingPath(require);
+    if (platformBindingPath) {
+        cachedAddon = loadAddon(require, platformBindingPath);
+        return cachedAddon;
+    }
+    const candidates = [
+        path.join(packageRoot, "native", "build", "Release", ADDON_FILE),
+    ];
+    const existing = candidates.find((p) => fs.existsSync(p));
+    if (!existing) {
+        const { arch, platform } = process;
+        throw new Error(`Native addon ${ADDON_FILE} not found for ${platform}-${arch}. Looked for:\n` +
+            candidates.map((p) => `- ${p}`).join("\n") +
+            `\n\nIf you built a Debug addon locally, set TSPICE_BACKEND_NODE_BINDING_PATH to its path.` +
+            `\n\n${BUILD_HINT}`);
+    }
+    cachedAddon = loadAddon(require, existing);
+    return cachedAddon;
+}
+//# sourceMappingURL=addon.js.map

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

@@ -0,0 +1,9 @@
+import type { KernelSource } from "#backend-contract";
+import type { NativeAddon } from "./addon.js";
+export type KernelStager = {
+    furnsh(kernel: KernelSource, native: NativeAddon): void;
+    unload(path: string, native: NativeAddon): void;
+    kclear(native: NativeAddon): void;
+};
+export declare function createKernelStager(): KernelStager;
+//# sourceMappingURL=kernel-staging.d.ts.map

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

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+export function createKernelStager() {
+    const tempByVirtualPath = new Map();
+    let tempKernelRootDir;
+    function ensureTempKernelRootDir() {
+        if (tempKernelRootDir) {
+            return tempKernelRootDir;
+        }
+        tempKernelRootDir = fs.mkdtempSync(path.join(os.tmpdir(), "tspice-kernels-"));
+        return tempKernelRootDir;
+    }
+    function safeUnlink(filePath) {
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch (error) {
+            // Best-effort cleanup.
+            if (error?.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return {
+        furnsh: (_kernel, native) => {
+            const kernel = _kernel;
+            if (typeof kernel === "string") {
+                native.furnsh(kernel);
+                return;
+            }
+            // 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);
+            if (existingTemp) {
+                native.unload(existingTemp);
+                tempByVirtualPath.delete(kernel.path);
+                safeUnlink(existingTemp);
+            }
+            const rootDir = ensureTempKernelRootDir();
+            const fileName = path.basename(kernel.path) || "kernel";
+            const tempPath = path.join(rootDir, `${randomUUID()}-${fileName}`);
+            fs.writeFileSync(tempPath, kernel.bytes);
+            try {
+                native.furnsh(tempPath);
+            }
+            catch (error) {
+                safeUnlink(tempPath);
+                throw error;
+            }
+            tempByVirtualPath.set(kernel.path, tempPath);
+        },
+        unload: (_path, native) => {
+            const resolved = tempByVirtualPath.get(_path);
+            if (resolved) {
+                native.unload(resolved);
+                tempByVirtualPath.delete(_path);
+                safeUnlink(resolved);
+                return;
+            }
+            native.unload(_path);
+        },
+        kclear: (native) => {
+            native.kclear();
+            // Clear any byte-backed kernels we staged to temp files.
+            for (const tempPath of tempByVirtualPath.values()) {
+                safeUnlink(tempPath);
+            }
+            tempByVirtualPath.clear();
+        },
+    };
+}
+//# sourceMappingURL=kernel-staging.js.map