@rybosome/tspice 0.0.7 → 0.0.8

package/backend-fake/dist/index.js

@@ -1,4 +1,4 @@
-import { brandMat3RowMajor } from "#backend-contract";
+import { assertGetmsgWhich, assertSpiceInt32, brandMat3RowMajor, kxtrctJs, matchesKernelKind, normalizeBodItem, normalizeKindInput, } from "#backend-contract";
 /**
  * A deterministic, pure-TS "toy" backend.
  *
@@ -129,6 +129,20 @@ function angleBetween(a, b) {
     const c = clamp(vdot(a, b) / (na * nb), -1, 1);
     return Math.acos(c);
 }
+function ellipsoidSurfaceNormal(spoint, radii) {
+    const [x, y, z] = spoint;
+    const [a, b, c] = radii;
+    // Gradient of x^2/a^2 + y^2/b^2 + z^2/c^2 = 1 is [x/a^2, y/b^2, z/c^2]
+    if (!Number.isFinite(a) || !Number.isFinite(b) || !Number.isFinite(c) || a === 0 || b === 0 || c === 0) {
+        // If we don't have radii, fall back to the sphere assumption.
+        return vhat(spoint);
+    }
+    return vhat([
+        x / (a * a),
+        y / (b * b),
+        z / (c * c),
+    ]);
+}
 function canonicalizeZero(n) {
     return Object.is(n, -0) ? 0 : n;
 }
@@ -180,6 +194,140 @@ function mmul3(a, b) {
         label: "fake.mmul3",
     });
 }
+function rotateRowMajor(angle, axis) {
+    // CSPICE reduces `iaxis` mod 3 (treating 0 as 3). Mirror that for parity.
+    if (!Number.isFinite(axis) || !Number.isInteger(axis)) {
+        throw new Error(`Fake backend: rotate(): invalid axis: ${axis} (expected a finite integer)`);
+    }
+    const iaxis = axis;
+    const reduced = ((iaxis % 3) + 3) % 3;
+    const spiceAxis = (reduced === 0 ? 3 : reduced);
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    switch (spiceAxis) {
+        case 1:
+            return brandMat3RowMajor([
+                1,
+                0,
+                0,
+                0,
+                canonicalizeZero(c),
+                canonicalizeZero(-s),
+                0,
+                canonicalizeZero(s),
+                canonicalizeZero(c),
+            ], { label: "fake.rotate" });
+        case 2:
+            return brandMat3RowMajor([
+                canonicalizeZero(c),
+                0,
+                canonicalizeZero(s),
+                0,
+                1,
+                0,
+                canonicalizeZero(-s),
+                0,
+                canonicalizeZero(c),
+            ], { label: "fake.rotate" });
+        case 3:
+            return brandMat3RowMajor([
+                canonicalizeZero(c),
+                canonicalizeZero(-s),
+                0,
+                canonicalizeZero(s),
+                canonicalizeZero(c),
+                0,
+                0,
+                0,
+                1,
+            ], { label: "fake.rotate" });
+        default: {
+            const _exhaustive = spiceAxis;
+            throw new Error(`Fake backend: rotate(): unreachable axis: ${String(_exhaustive)}`);
+        }
+    }
+}
+function axisAngleToRotationRowMajor(axis, angle) {
+    const u = vhat(axis);
+    const ux = u[0];
+    const uy = u[1];
+    const uz = u[2];
+    // Parity with CSPICE axisar_c: if axis is zero, return identity rotation.
+    if (ux === 0 && uy === 0 && uz === 0) {
+        return brandMat3RowMajor([1, 0, 0, 0, 1, 0, 0, 0, 1], { label: "fake.axisar" });
+    }
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    const t = 1 - c;
+    return brandMat3RowMajor([
+        canonicalizeZero(t * ux * ux + c),
+        canonicalizeZero(t * ux * uy - s * uz),
+        canonicalizeZero(t * ux * uz + s * uy),
+        canonicalizeZero(t * ux * uy + s * uz),
+        canonicalizeZero(t * uy * uy + c),
+        canonicalizeZero(t * uy * uz - s * ux),
+        canonicalizeZero(t * ux * uz - s * uy),
+        canonicalizeZero(t * uy * uz + s * ux),
+        canonicalizeZero(t * uz * uz + c),
+    ], { label: "fake.axisar" });
+}
+function georec(lon, lat, alt, re, f) {
+    // Match CSPICE validation semantics where feasible.
+    if (!Number.isFinite(re) || re <= 0) {
+        throw new Error(`Fake backend: georec(): invalid re: ${re} (expected > 0)`);
+    }
+    if (!Number.isFinite(f) || f >= 1) {
+        throw new Error(`Fake backend: georec(): invalid f: ${f} (expected < 1)`);
+    }
+    // Standard geodetic-to-rectangular conversion.
+    const rp = re * (1 - f);
+    const e2 = 1 - (rp * rp) / (re * re);
+    const slat = Math.sin(lat);
+    const clat = Math.cos(lat);
+    const slon = Math.sin(lon);
+    const clon = Math.cos(lon);
+    const n = re / Math.sqrt(1 - e2 * slat * slat);
+    const x = (n + alt) * clat * clon;
+    const y = (n + alt) * clat * slon;
+    const z = (n * (1 - e2) + alt) * slat;
+    return [x, y, z];
+}
+function recgeo(rect, re, f) {
+    // Match CSPICE validation semantics where feasible.
+    if (!Number.isFinite(re) || re <= 0) {
+        throw new Error(`Fake backend: recgeo(): invalid re: ${re} (expected > 0)`);
+    }
+    if (!Number.isFinite(f) || f >= 1) {
+        throw new Error(`Fake backend: recgeo(): invalid f: ${f} (expected < 1)`);
+    }
+    // Bowring's method (non-iterative) for rectangular to geodetic.
+    const x = rect[0];
+    const y = rect[1];
+    const z = rect[2];
+    const rp = re * (1 - f);
+    const e2 = 1 - (rp * rp) / (re * re);
+    const ep2 = (re * re - rp * rp) / (rp * rp);
+    const lon = Math.atan2(y, x);
+    const p = Math.sqrt(x * x + y * y);
+    // Handle poles / near-pole numerical stability.
+    // Avoid the general-case `alt = p / cos(lat) - n` path when `p` is tiny.
+    // (Near-pole cases are extremely sensitive as `cos(lat) -> 0`.)
+    const poleTol = 1e-14 * re;
+    if (p <= poleTol) {
+        const poleLon = 0;
+        const poleLat = z >= 0 ? Math.PI / 2 : -Math.PI / 2;
+        const poleAlt = Math.abs(z) - rp;
+        return { lon: poleLon, lat: poleLat, alt: poleAlt };
+    }
+    const theta = Math.atan2(z * re, p * rp);
+    const st = Math.sin(theta);
+    const ct = Math.cos(theta);
+    const lat = Math.atan2(z + ep2 * rp * st * st * st, p - e2 * re * ct * ct * ct);
+    const slat = Math.sin(lat);
+    const n = re / Math.sqrt(1 - e2 * slat * slat);
+    const alt = p / Math.cos(lat) - n;
+    return { lon, lat, alt };
+}
 function mtx3(m) {
     return brandMat3RowMajor([m[0], m[3], m[6], m[1], m[4], m[7], m[2], m[5], m[8]], { label: "fake.mtx3" });
 }
@@ -303,14 +451,18 @@ function formatUtcFromMs(ms, prec) {
     const padded = (frac + "000000000000").slice(0, clampedPrec);
     return `${head}.${padded}Z`;
 }
-function guessKernelKind(path) {
+function guessKernelKind(path, unknownExtension) {
     const lower = path.toLowerCase();
     if (lower.endsWith(".bsp"))
         return "SPK";
     if (lower.endsWith(".bc"))
         return "CK";
-    if (lower.endsWith(".tpc") || lower.endsWith(".pck"))
+    if (lower.endsWith(".bpc"))
         return "PCK";
+    if (lower.endsWith(".bds") || lower.endsWith(".dsk"))
+        return "DSK";
+    if (lower.endsWith(".tpc") || lower.endsWith(".pck"))
+        return "TEXT";
     if (lower.endsWith(".tls") || lower.endsWith(".lsk"))
         return "LSK";
     if (lower.endsWith(".tf") || lower.endsWith(".fk"))
@@ -319,9 +471,18 @@ function guessKernelKind(path) {
         return "IK";
     if (lower.endsWith(".tsc") || lower.endsWith(".sclk"))
         return "SCLK";
+    if (lower.endsWith(".ek"))
+        return "EK";
     if (lower.endsWith(".tm") || lower.endsWith(".meta"))
         return "META";
-    return "ALL";
+    // "ALL" is a query token, not a per-kernel kind.
+    if (unknownExtension === "assume-text") {
+        return "TEXT";
+    }
+    throw new RangeError(`Unsupported kernel extension (fake backend): ${path}`);
+}
+function assertNever(x, msg) {
+    throw new Error(msg);
 }
 function kernelFiltyp(kind) {
     // Keep this close to NAIF-style strings, but it doesn't need to be exact.
@@ -329,33 +490,234 @@ function kernelFiltyp(kind) {
         case "SPK":
         case "CK":
         case "PCK":
+        case "DSK":
+        case "EK":
+        case "META":
+        case "TEXT":
+            return kind;
         case "LSK":
         case "FK":
         case "IK":
         case "SCLK":
-        case "EK":
-        case "META":
-            return kind;
-        case "ALL":
-        default:
-            return "ALL";
+            return "TEXT";
+    }
+    // Compile-time exhaustiveness check: if a new KernelKind is added, TypeScript
+    // forces us to intentionally map it.
+    return assertNever(kind, `Unmapped KernelKind: ${kind}`);
+}
+function normalizeVirtualKernelIdOrNull(input) {
+    // Keep lookup semantics aligned with the WASM backend's virtual-id
+    // normalization (see core's `normalizeVirtualKernelPath`).
+    //
+    // Unlike the core helper, this is non-throwing: invalid inputs just don't
+    // match.
+    const raw = input.replace(/\\/g, "/").trim();
+    if (!raw) {
+        return null;
+    }
+    // Strip leading slashes so `/kernels/foo.tls` behaves like `kernels/foo.tls`.
+    let rel = raw.replace(/^\/+/, "");
+    // Strip leading `./` segments.
+    while (rel.startsWith("./")) {
+        rel = rel.slice(2);
+    }
+    // Strip a leading `kernels/` directory to keep user input flexible.
+    // Treat a bare `kernels` segment as equivalent to `kernels/`.
+    if (rel === "kernels") {
+        rel = "";
+    }
+    while (rel.startsWith("kernels/")) {
+        rel = rel.replace(/^kernels\/+/, "");
+    }
+    const segments = rel.split("/");
+    const out = [];
+    for (const seg of segments) {
+        if (!seg || seg === ".") {
+            continue;
+        }
+        if (seg === "..") {
+            return null;
+        }
+        out.push(seg);
+    }
+    if (out.length === 0) {
+        return null;
+    }
+    return out.join("/");
+}
+function assertPoolRange(fn, start, room) {
+    if (!Number.isFinite(start) || !Number.isInteger(start) || start < 0) {
+        throw new RangeError(`${fn}(): start must be an integer >= 0`);
+    }
+    if (!Number.isFinite(room) || !Number.isInteger(room) || room <= 0) {
+        throw new RangeError(`${fn}(): room must be an integer > 0`);
+    }
+}
+function assertNonEmptyString(fn, field, value) {
+    if (value.trim().length === 0) {
+        throw new RangeError(`${fn}(): ${field} must be a non-empty string`);
     }
 }
-export function createFakeBackend() {
+/**
+ * Create an in-memory fake backend implementing the {@link SpiceBackend} contract.
+ *
+ * Intended for tests and UI development without native/WASM backends.
+ */
+export function createFakeBackend(options = {}) {
     let nextHandle = 1;
+    let spiceFailed = false;
+    let spiceShort = "";
+    let spiceLong = "";
+    const traceStack = [];
     const kernels = [];
+    const unknownExtension = options.unknownExtension ?? "throw";
+    const kernelPool = new Map();
+    // boddef() mappings (CSPICE uses process-global state; keep it per-backend here).
+    const customNameToBodyCode = new Map();
+    const customBodyCodeToName = new Map();
+    // swpool/cvpool "agent" state.
+    const kernelPoolWatches = new Map();
+    const kernelPoolWatchesByName = new Map();
+    const unindexKernelPoolWatch = (agent, names) => {
+        for (const name of names) {
+            const agents = kernelPoolWatchesByName.get(name);
+            if (!agents)
+                continue;
+            agents.delete(agent);
+            if (agents.size === 0) {
+                kernelPoolWatchesByName.delete(name);
+            }
+        }
+    };
+    const indexKernelPoolWatch = (agent, names) => {
+        for (const name of names) {
+            let agents = kernelPoolWatchesByName.get(name);
+            if (!agents) {
+                agents = new Set();
+                kernelPoolWatchesByName.set(name, agents);
+            }
+            agents.add(agent);
+        }
+    };
+    const markKernelPoolUpdated = (name) => {
+        // Avoid an O(watches * names) scan by maintaining a reverse index.
+        const agents = kernelPoolWatchesByName.get(name);
+        if (!agents)
+            return;
+        for (const agent of agents) {
+            const watch = kernelPoolWatches.get(agent);
+            if (watch) {
+                watch.dirty = true;
+            }
+        }
+    };
+    const spiceCellUnsupported = "Fake backend does not support SpiceCell/SpiceWindow APIs (use wasm/node backend).";
     const getKernelsOfKind = (kind) => {
-        if (kind === "ALL")
-            return kernels;
-        return kernels.filter((k) => k.kind === kind);
+        const requested = new Set(normalizeKindInput(kind));
+        return kernels.filter((k) => matchesKernelKind(requested, k));
+    };
+    // Minimal state for timdef() GET/SET.
+    //
+    // The fake backend treats time systems deterministically and does not model
+    // leap seconds, so these defaults are mostly for parity with the contract
+    // and to support callers that expect timdef() to exist.
+    const DEFAULT_TIME_DEFAULTS = [
+        ["SYSTEM", "UTC"],
+        ["CALENDAR", "GREGORIAN"],
+        ["ZONE", "UTC"],
+    ];
+    const timeDefaults = new Map(DEFAULT_TIME_DEFAULTS);
+    function resetTimeDefaults() {
+        timeDefaults.clear();
+        for (const [k, v] of DEFAULT_TIME_DEFAULTS) {
+            timeDefaults.set(k, v);
+        }
+    }
+    function timdef(action, item, value) {
+        assertNonEmptyString("timdef", "item", item);
+        if (action === "GET") {
+            return timeDefaults.get(item) ?? "";
+        }
+        if (typeof value !== "string") {
+            throw new TypeError("timdef(SET) requires a string value");
+        }
+        // Match CSPICE `timdef_c`: empty (length 0) strings are invalid, but
+        // whitespace-only strings are allowed (e.g. ZONE can be "blank").
+        if (value.length === 0) {
+            throw new RangeError("timdef(SET): value must be a non-empty string");
+        }
+        timeDefaults.set(item, value);
+    }
+    const getBodyRadiiKm = (bodyId) => {
+        const key = `BODY${bodyId}_RADII`;
+        const entry = kernelPool.get(key);
+        if (entry?.type === "N" && entry.values.length >= 3) {
+            const a = entry.values[0];
+            const b = entry.values[1];
+            const c = entry.values[2];
+            if (typeof a === "number" &&
+                typeof b === "number" &&
+                typeof c === "number" &&
+                Number.isFinite(a) &&
+                Number.isFinite(b) &&
+                Number.isFinite(c)) {
+                return [a, b, c];
+            }
+        }
+        // Fall back to a spherical body when RADII isn't available.
+        const r = getBodyRadiusKm(bodyId);
+        return [r, r, r];
     };
-    return {
+    const backend = {
         kind: "fake",
         spiceVersion: () => FAKE_SPICE_VERSION,
+        failed: () => spiceFailed,
+        reset: () => {
+            spiceFailed = false;
+            spiceShort = "";
+            spiceLong = "";
+            traceStack.length = 0;
+            resetTimeDefaults();
+        },
+        getmsg: (which) => {
+            assertGetmsgWhich(which);
+            if (which === "SHORT")
+                return spiceShort;
+            if (which === "LONG")
+                return spiceLong;
+            // EXPLAIN
+            // CSPICE convention is typically:
+            //   setmsg(long)
+            //   sigerr(short)
+            // so we avoid overwriting the long message when signaling.
+            const trace = traceStack.length > 0 ? traceStack.join(" -> ") : "";
+            if (!spiceLong && !trace)
+                return "";
+            if (spiceLong && !trace)
+                return spiceLong;
+            if (!spiceLong && trace)
+                return `Trace: ${trace}`;
+            return `${spiceLong}\n\nTrace: ${trace}`;
+        },
+        setmsg: (message) => {
+            spiceLong = message;
+        },
+        sigerr: (short) => {
+            spiceFailed = true;
+            spiceShort = short;
+        },
+        chkin: (name) => {
+            traceStack.push(name);
+        },
+        chkout: (name) => {
+            const idx = traceStack.lastIndexOf(name);
+            if (idx >= 0)
+                traceStack.splice(idx, 1);
+        },
         furnsh: (kernel) => {
             const file = typeof kernel === "string" ? kernel : kernel.path;
             const source = typeof kernel === "string" ? file : "bytes";
-            const kind = guessKernelKind(file);
+            const kind = guessKernelKind(file, unknownExtension);
             const handle = nextHandle++;
             kernels.push({
                 file,
@@ -366,13 +728,42 @@ export function createFakeBackend() {
             });
         },
         unload: (path) => {
-            const idx = kernels.findIndex((k) => k.file === path);
+            const needle = normalizeVirtualKernelIdOrNull(path);
+            if (needle == null) {
+                return;
+            }
+            const idx = kernels.findIndex((k) => normalizeVirtualKernelIdOrNull(k.file) === needle);
             if (idx >= 0) {
                 kernels.splice(idx, 1);
             }
         },
         kclear: () => {
             kernels.length = 0;
+            kernelPool.clear();
+            kernelPoolWatches.clear();
+            kernelPoolWatchesByName.clear();
+        },
+        kinfo: (path) => {
+            const needle = normalizeVirtualKernelIdOrNull(path);
+            if (needle == null) {
+                return { found: false };
+            }
+            const k = kernels.find((k) => normalizeVirtualKernelIdOrNull(k.file) === needle);
+            if (!k) {
+                return { found: false };
+            }
+            return {
+                found: true,
+                filtyp: k.filtyp,
+                source: k.source,
+                handle: k.handle,
+            };
+        },
+        kxtrct: (keywd, terms, wordsq) => {
+            return kxtrctJs(keywd, terms, wordsq);
+        },
+        kplfrm: (_frmcls, _idset) => {
+            throw new Error(spiceCellUnsupported);
         },
         ktotal: (kind = "ALL") => {
             return getKernelsOfKind(kind).length;
@@ -390,6 +781,163 @@ export function createFakeBackend() {
                 handle: k.handle,
             };
         },
+        gdpool: (name, start, room) => {
+            assertNonEmptyString("gdpool", "name", name);
+            assertPoolRange("gdpool", start, room);
+            const start0 = start;
+            const room0 = room;
+            const entry = kernelPool.get(name);
+            if (!entry)
+                return { found: false };
+            if (entry.type !== "N") {
+                throw new Error(`Fake backend: gdpool only supports numeric variables (got ${entry.type})`);
+            }
+            return {
+                found: true,
+                values: entry.values.slice(start0, start0 + room0),
+            };
+        },
+        gipool: (name, start, room) => {
+            assertNonEmptyString("gipool", "name", name);
+            assertPoolRange("gipool", start, room);
+            const start0 = start;
+            const room0 = room;
+            const entry = kernelPool.get(name);
+            if (!entry)
+                return { found: false };
+            if (entry.type !== "N") {
+                throw new Error(`Fake backend: gipool only supports numeric variables (got ${entry.type})`);
+            }
+            return {
+                found: true,
+                values: entry.values.slice(start0, start0 + room0).map((v, i) => {
+                    assertSpiceInt32(v, `gipool(): values[${start0 + i}]`);
+                    return v;
+                }),
+            };
+        },
+        gcpool: (name, start, room) => {
+            assertNonEmptyString("gcpool", "name", name);
+            assertPoolRange("gcpool", start, room);
+            const start0 = start;
+            const room0 = room;
+            const entry = kernelPool.get(name);
+            if (!entry)
+                return { found: false };
+            if (entry.type !== "C") {
+                throw new Error(`Fake backend: gcpool only supports character variables (got ${entry.type})`);
+            }
+            return {
+                found: true,
+                values: entry.values.slice(start0, start0 + room0),
+            };
+        },
+        gnpool: (template, start, room) => {
+            assertNonEmptyString("gnpool", "template", template);
+            assertPoolRange("gnpool", start, room);
+            const start0 = start;
+            const room0 = room;
+            const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\[\]\\]/g, "\\$&");
+            // Support escaping wildcard characters via backslash:
+            // - `\*` matches a literal `*`
+            // - `\%` matches a literal `%`
+            let reSrc = "^";
+            for (let i = 0; i < template.length; i++) {
+                const ch = template[i];
+                if (ch === "\\") {
+                    const next = template[i + 1];
+                    if (next !== undefined) {
+                        reSrc += escapeRegex(next);
+                        i++;
+                    }
+                    else {
+                        reSrc += "\\\\";
+                    }
+                    continue;
+                }
+                if (ch === "*") {
+                    reSrc += ".*";
+                    continue;
+                }
+                if (ch === "%") {
+                    reSrc += ".";
+                    continue;
+                }
+                reSrc += escapeRegex(ch);
+            }
+            reSrc += "$";
+            const re = new RegExp(reSrc);
+            const matches = Array.from(kernelPool.keys()).filter((k) => re.test(k)).sort();
+            if (matches.length === 0) {
+                return { found: false };
+            }
+            return {
+                found: true,
+                values: matches.slice(start0, start0 + room0),
+            };
+        },
+        dtpool: (name) => {
+            assertNonEmptyString("dtpool", "name", name);
+            const entry = kernelPool.get(name);
+            if (!entry)
+                return { found: false };
+            return {
+                found: true,
+                n: entry.values.length,
+                type: entry.type,
+            };
+        },
+        pdpool: (name, values) => {
+            assertNonEmptyString("pdpool", "name", name);
+            for (let i = 0; i < values.length; i++) {
+                const v = values[i];
+                if (!Number.isFinite(v)) {
+                    throw new RangeError(`pdpool(): values[${i}] must be a finite number (got ${String(v)})`);
+                }
+            }
+            kernelPool.set(name, { type: "N", values: [...values] });
+            markKernelPoolUpdated(name);
+        },
+        pipool: (name, values) => {
+            assertNonEmptyString("pipool", "name", name);
+            for (let i = 0; i < values.length; i++) {
+                assertSpiceInt32(values[i], `pipool(): values[${i}]`);
+            }
+            kernelPool.set(name, { type: "N", values: [...values] });
+            markKernelPoolUpdated(name);
+        },
+        pcpool: (name, values) => {
+            assertNonEmptyString("pcpool", "name", name);
+            kernelPool.set(name, { type: "C", values: [...values] });
+            markKernelPoolUpdated(name);
+        },
+        swpool: (agent, names) => {
+            assertNonEmptyString("swpool", "agent", agent);
+            for (let i = 0; i < names.length; i++) {
+                assertNonEmptyString("swpool", `names[${i}]`, names[i]);
+            }
+            // CSPICE guarantees the next cvpool(agent) returns true.
+            const prev = kernelPoolWatches.get(agent);
+            if (prev) {
+                unindexKernelPoolWatch(agent, prev.names);
+            }
+            kernelPoolWatches.set(agent, { names: [...names], dirty: true });
+            indexKernelPoolWatch(agent, names);
+        },
+        cvpool: (agent) => {
+            assertNonEmptyString("cvpool", "agent", agent);
+            const watch = kernelPoolWatches.get(agent);
+            if (!watch)
+                return false;
+            const dirty = watch.dirty;
+            watch.dirty = false;
+            return dirty;
+        },
+        expool: (name) => {
+            assertNonEmptyString("expool", "name", name);
+            const entry = kernelPool.get(name);
+            return entry?.type === "N";
+        },
         tkvrsn: (item) => {
             if (item !== "TOOLKIT") {
                 throw new Error(`Fake backend: unsupported tkvrsn item: ${String(item)}`);
@@ -415,19 +963,102 @@ export function createFakeBackend() {
             const ms = J2000_UTC_MS + et * 1000;
             return formatUtcFromMs(ms, 3);
         },
+        deltet: (_epoch, _eptype) => {
+            // Deterministic stub: the fake backend ignores leap seconds, so ET and
+            // UTC are treated as identical.
+            return 0;
+        },
+        unitim: (epoch, _insys, _outsys) => {
+            // Deterministic stub: treat all input/output systems as identical.
+            return epoch;
+        },
+        tparse: (timstr) => {
+            // Deterministic stub: match `str2et` semantics in the fake backend.
+            if (!isIso8601OrRfc3339Utcish(timstr)) {
+                throw new Error(`Fake backend: tparse() only supports ISO-8601/RFC3339 timestamps (got ${JSON.stringify(timstr)})`);
+            }
+            const ms = Date.parse(timstr);
+            if (!Number.isFinite(ms)) {
+                throw new Error(`Fake backend: failed to parse time: ${JSON.stringify(timstr)}`);
+            }
+            return (ms - J2000_UTC_MS) / 1000;
+        },
+        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");
+            }
+            // Picture transformation is out of scope for the fake backend.
+            return pictur;
+        },
+        timdef,
         bodn2c: (name) => {
             const trimmed = normalizeName(name);
+            const custom = customNameToBodyCode.get(trimmed) ??
+                customNameToBodyCode.get(trimmed.toLowerCase());
+            if (custom !== undefined)
+                return { found: true, code: custom };
             const id = NAME_TO_ID.get(trimmed) ?? NAME_TO_ID.get(trimmed.toLowerCase());
             if (id === undefined)
                 return { found: false };
             return { found: true, code: id };
         },
         bodc2n: (code) => {
+            const custom = customBodyCodeToName.get(code);
+            if (custom !== undefined)
+                return { found: true, name: custom };
             const meta = ID_TO_BODY.get(code);
             if (!meta)
                 return { found: false };
             return { found: true, name: meta.name };
         },
+        bodc2s: (code) => {
+            const custom = customBodyCodeToName.get(code);
+            if (custom !== undefined)
+                return custom;
+            const meta = ID_TO_BODY.get(code);
+            if (meta)
+                return meta.name;
+            return String(code);
+        },
+        bods2c: (name) => {
+            const trimmed = normalizeName(name);
+            // Accept numeric IDs as strings.
+            if (/^-?\d+$/.test(trimmed)) {
+                return { found: true, code: Number(trimmed) };
+            }
+            const custom = customNameToBodyCode.get(trimmed) ??
+                customNameToBodyCode.get(trimmed.toLowerCase());
+            if (custom !== undefined)
+                return { found: true, code: custom };
+            const id = NAME_TO_ID.get(trimmed) ?? NAME_TO_ID.get(trimmed.toLowerCase());
+            if (id === undefined)
+                return { found: false };
+            return { found: true, code: id };
+        },
+        boddef: (name, code) => {
+            const trimmed = normalizeName(name);
+            customNameToBodyCode.set(trimmed, code);
+            customNameToBodyCode.set(trimmed.toLowerCase(), code);
+            customBodyCodeToName.set(code, trimmed);
+        },
+        bodfnd: (body, item) => {
+            const key = `BODY${body}_${normalizeBodItem(item)}`;
+            const entry = kernelPool.get(key);
+            return entry !== undefined;
+        },
+        bodvar: (body, item) => {
+            const key = `BODY${body}_${normalizeBodItem(item)}`;
+            const entry = kernelPool.get(key);
+            if (!entry || entry.type !== "N") {
+                // Align with the backend contract: missing / non-numeric pool vars are a normal miss.
+                // Callers that need strict presence checks can use `bodfnd()`.
+                return [];
+            }
+            return [...entry.values];
+        },
         namfrm: (name) => {
             const trimmed = normalizeName(name);
             const code = FRAME_NAME_TO_CODE.get(trimmed) ?? FRAME_NAME_TO_CODE.get(trimmed.toLowerCase());
@@ -460,6 +1091,21 @@ export function createFakeBackend() {
                     ? { found: true, frcode: FRAME_CODES.IAU_MOON, frname: "IAU_MOON" }
                     : { found: false });
         },
+        frinfo: (frameId) => {
+            if (frameId === FRAME_CODES.J2000) {
+                return { found: true, center: 0, frameClass: 1, classId: frameId };
+            }
+            return { found: false };
+        },
+        ccifrm: (frameClass, classId) => {
+            if (frameClass === 1) {
+                const frname = FRAME_CODE_TO_NAME.get(classId);
+                if (!frname)
+                    return { found: false };
+                return { found: true, frcode: classId, frname, center: 0 };
+            }
+            return { found: false };
+        },
         scs2e: (_sc, sclkch) => {
             // Minimal deterministic stub: treat the string as a number of seconds.
             const n = Number(sclkch);
@@ -469,12 +1115,41 @@ export function createFakeBackend() {
             // Minimal deterministic stub.
             return String(et);
         },
+        scencd: (_sc, sclkch) => {
+            // Minimal deterministic stub: treat the string as a number of ticks.
+            const n = Number(sclkch);
+            return Number.isFinite(n) ? n : 0;
+        },
+        scdecd: (_sc, sclkdp) => {
+            // Minimal deterministic stub.
+            return String(sclkdp);
+        },
+        sct2e: (_sc, sclkdp) => {
+            // Minimal deterministic stub.
+            return sclkdp;
+        },
+        sce2c: (_sc, et) => {
+            // Minimal deterministic stub.
+            return et;
+        },
         ckgp: (_inst, _sclkdp, _tol, _ref) => {
             return { found: false };
         },
         ckgpav: (_inst, _sclkdp, _tol, _ref) => {
             return { found: false };
         },
+        cklpf: (_ck) => {
+            throw new Error("Fake backend: cklpf() is not implemented");
+        },
+        ckupf: (_handle) => {
+            throw new Error("Fake backend: ckupf() is not implemented");
+        },
+        ckobj: (_ck, _ids) => {
+            throw new Error("Fake backend: ckobj() is not implemented");
+        },
+        ckcov: (_ck, _idcode, _needav, _level, _tol, _timsys, _cover) => {
+            throw new Error("Fake backend: ckcov() is not implemented");
+        },
         pxform: (from, to, et) => {
             const f = parseFrameName(from);
             const t = parseFrameName(to);
@@ -513,6 +1188,197 @@ export function createFakeBackend() {
                 lt: 0,
             };
         },
+        spkez: (target, et, ref, abcorr, observer) => {
+            void abcorr;
+            assertSpiceInt32(target, "spkez(target)");
+            assertSpiceInt32(observer, "spkez(observer)");
+            const stateJ2000 = getRelativeStateInJ2000(String(target), String(observer), et);
+            const outFrame = parseFrameName(ref);
+            const state = outFrame === "J2000" ? stateJ2000 : applyStateTransform("J2000", outFrame, et, stateJ2000);
+            return { state, lt: 0 };
+        },
+        spkezp: (target, et, ref, abcorr, observer) => {
+            void abcorr;
+            assertSpiceInt32(target, "spkezp(target)");
+            assertSpiceInt32(observer, "spkezp(observer)");
+            const stateJ2000 = getRelativeStateInJ2000(String(target), String(observer), et);
+            const outFrame = parseFrameName(ref);
+            const state = outFrame === "J2000" ? stateJ2000 : applyStateTransform("J2000", outFrame, et, stateJ2000);
+            return {
+                pos: [state[0], state[1], state[2]],
+                lt: 0,
+            };
+        },
+        spkgeo: (target, et, ref, observer) => {
+            assertSpiceInt32(target, "spkgeo(target)");
+            assertSpiceInt32(observer, "spkgeo(observer)");
+            const stateJ2000 = getRelativeStateInJ2000(String(target), String(observer), et);
+            const outFrame = parseFrameName(ref);
+            const state = outFrame === "J2000" ? stateJ2000 : applyStateTransform("J2000", outFrame, et, stateJ2000);
+            return { state, lt: 0 };
+        },
+        spkgps: (target, et, ref, observer) => {
+            assertSpiceInt32(target, "spkgps(target)");
+            assertSpiceInt32(observer, "spkgps(observer)");
+            const stateJ2000 = getRelativeStateInJ2000(String(target), String(observer), et);
+            const outFrame = parseFrameName(ref);
+            const state = outFrame === "J2000" ? stateJ2000 : applyStateTransform("J2000", outFrame, et, stateJ2000);
+            return {
+                pos: [state[0], state[1], state[2]],
+                lt: 0,
+            };
+        },
+        spkssb: (target, et, ref) => {
+            assertSpiceInt32(target, "spkssb(target)");
+            const abs = getAbsoluteStateInJ2000(target, et);
+            const stateJ2000 = [
+                abs.posKm[0],
+                abs.posKm[1],
+                abs.posKm[2],
+                abs.velKmPerSec[0],
+                abs.velKmPerSec[1],
+                abs.velKmPerSec[2],
+            ];
+            const outFrame = parseFrameName(ref);
+            return outFrame === "J2000" ? stateJ2000 : applyStateTransform("J2000", outFrame, et, stateJ2000);
+        },
+        spkcov: (_spk, idcode, _cover) => {
+            assertSpiceInt32(idcode, "spkcov(idcode)");
+            throw new Error(spiceCellUnsupported);
+        },
+        spkobj: (_spk, _ids) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        illumg: (_method, target, ilusrc, et, fixref, abcorr, observer, spoint) => {
+            void abcorr;
+            const frame = parseFrameName(fixref);
+            const inv = rotZRowMajor(FRAME_SPIN_RATE_RAD_PER_SEC[frame] * et);
+            const spointJ = frame === "J2000" ? spoint : mxv(inv, spoint);
+            const srcState = getRelativeStateInJ2000(ilusrc, target, et);
+            const srcPosJ = [srcState[0], srcState[1], srcState[2]];
+            const obsState = getRelativeStateInJ2000(observer, target, et);
+            const obsPosJ = [obsState[0], obsState[1], obsState[2]];
+            // Vectors from surface point.
+            const srfToSrcJ = vsub(srcPosJ, spointJ);
+            const srfToObsJ = vsub(obsPosJ, spointJ);
+            const targetId = parseBodyRef(target);
+            const normalF = ellipsoidSurfaceNormal(spoint, getBodyRadiiKm(targetId));
+            const normalJ = frame === "J2000" ? normalF : mxv(inv, normalF);
+            const phase = angleBetween(srfToSrcJ, srfToObsJ);
+            const incdnc = angleBetween(normalJ, srfToSrcJ);
+            const emissn = angleBetween(normalJ, srfToObsJ);
+            const srfvecJ = vsub(spointJ, obsPosJ);
+            const srfvec = frame === "J2000" ? srfvecJ : mxv(rotZRowMajor(-FRAME_SPIN_RATE_RAD_PER_SEC[frame] * et), srfvecJ);
+            return {
+                trgepc: et,
+                srfvec,
+                phase,
+                incdnc,
+                emissn,
+            };
+        },
+        illumf: (_method, target, ilusrc, et, fixref, abcorr, observer, spoint) => {
+            void abcorr;
+            const frame = parseFrameName(fixref);
+            const inv = rotZRowMajor(FRAME_SPIN_RATE_RAD_PER_SEC[frame] * et);
+            const spointJ = frame === "J2000" ? spoint : mxv(inv, spoint);
+            const srcState = getRelativeStateInJ2000(ilusrc, target, et);
+            const srcPosJ = [srcState[0], srcState[1], srcState[2]];
+            const obsState = getRelativeStateInJ2000(observer, target, et);
+            const obsPosJ = [obsState[0], obsState[1], obsState[2]];
+            // Vectors from surface point.
+            const srfToSrcJ = vsub(srcPosJ, spointJ);
+            const srfToObsJ = vsub(obsPosJ, spointJ);
+            const targetId = parseBodyRef(target);
+            const normalF = ellipsoidSurfaceNormal(spoint, getBodyRadiiKm(targetId));
+            const normalJ = frame === "J2000" ? normalF : mxv(inv, normalF);
+            const phase = angleBetween(srfToSrcJ, srfToObsJ);
+            const incdnc = angleBetween(normalJ, srfToSrcJ);
+            const emissn = angleBetween(normalJ, srfToObsJ);
+            const srfvecJ = vsub(spointJ, obsPosJ);
+            const srfvec = frame === "J2000" ? srfvecJ : mxv(rotZRowMajor(-FRAME_SPIN_RATE_RAD_PER_SEC[frame] * et), srfvecJ);
+            const out = {
+                trgepc: et,
+                srfvec,
+                phase,
+                incdnc,
+                emissn,
+            };
+            // NOTE: This fake backend defines:
+            // - visibl: point is visible if emission angle is <= 90deg
+            // - lit: point is lit if incidence angle is <= 90deg
+            const visibl = out.emissn <= Math.PI / 2;
+            const lit = out.incdnc <= Math.PI / 2;
+            return { ...out, visibl, lit };
+        },
+        spksfs: (body, et) => {
+            assertSpiceInt32(body, "spksfs(body)");
+            void et;
+            return { found: false };
+        },
+        spkpds: (_body, _center, _frame, _type, _first, _last) => {
+            throw new Error("Fake backend: spkpds() is not implemented");
+        },
+        spkuds: (_descr) => {
+            throw new Error("Fake backend: spkuds() is not implemented");
+        },
+        nvc2pl: (normal, konst) => {
+            if (!Array.isArray(normal) || normal.length !== 3) {
+                throw new TypeError("nvc2pl(normal, konst): normal must be a length-3 number[]");
+            }
+            for (let i = 0; i < 3; i++) {
+                const v = normal[i];
+                if (typeof v !== "number") {
+                    throw new TypeError(`nvc2pl(normal, konst): normal[${i}] must be a number`);
+                }
+                if (!Number.isFinite(v)) {
+                    throw new RangeError(`nvc2pl(normal, konst): normal[${i}] must be a finite number`);
+                }
+            }
+            if (typeof konst !== "number") {
+                throw new TypeError("nvc2pl(normal, konst): konst must be a number");
+            }
+            if (!Number.isFinite(konst)) {
+                throw new RangeError("nvc2pl(normal, konst): konst must be a finite number");
+            }
+            return [normal[0], normal[1], normal[2], konst];
+        },
+        pl2nvc: (plane) => {
+            if (!Array.isArray(plane) || plane.length !== 4) {
+                throw new TypeError("pl2nvc(plane): plane must be a length-4 number[]");
+            }
+            for (let i = 0; i < 4; i++) {
+                const v = plane[i];
+                if (typeof v !== "number") {
+                    throw new TypeError(`pl2nvc(plane): plane[${i}] must be a number`);
+                }
+                if (!Number.isFinite(v)) {
+                    throw new RangeError(`pl2nvc(plane): plane[${i}] must be a finite number`);
+                }
+            }
+            const n = [plane[0], plane[1], plane[2]];
+            const mag = vnorm(n);
+            if (mag === 0) {
+                throw new RangeError("pl2nvc(plane): plane is degenerate (normal must be non-zero)");
+            }
+            return {
+                normal: vscale(1 / mag, n),
+                konst: plane[3] / mag,
+            };
+        },
+        // --- SPK writers (not implemented in fake backend) ---
+        spkopn: (_file, _ifname, _ncomch) => {
+            throw new Error("Fake backend: spkopn() is not implemented");
+        },
+        spkopa: (_file) => {
+            throw new Error("Fake backend: spkopa() is not implemented");
+        },
+        spkcls: (_handle) => {
+            throw new Error("Fake backend: spkcls() is not implemented");
+        },
+        spkw08: (_handle, _body, _center, _frame, _first, _last, _segid, _degree, _states, _epoch1, _step) => {
+            throw new Error("Fake backend: spkw08() is not implemented");
+        },
         subpnt: (_method, target, et, fixref, abcorr, observer) => {
             void abcorr;
             const targetId = parseBodyRef(target);
@@ -556,7 +1422,9 @@ export function createFakeBackend() {
             // Vectors from surface point.
             const srfToSunJ = vsub(sunPosJ, spointJ);
             const srfToObsJ = vsub(obsPosJ, spointJ);
-            const normalJ = vhat(spointJ);
+            const targetId = parseBodyRef(target);
+            const normalF = ellipsoidSurfaceNormal(spoint, getBodyRadiiKm(targetId));
+            const normalJ = frame === "J2000" ? normalF : mxv(inv, normalF);
             const phase = angleBetween(srfToSunJ, srfToObsJ);
             const incdnc = angleBetween(normalJ, srfToSunJ);
             const emissn = angleBetween(normalJ, srfToObsJ);
@@ -575,6 +1443,211 @@ export function createFakeBackend() {
             // Deterministic stub: 0 => "no occultation".
             return 0;
         },
+        // --- GF (Geometry Finder) (not implemented in fake backend) ---
+        gfsstp: (_step) => {
+            throw new Error("Fake backend: gfsstp() is not implemented");
+        },
+        gfstep: (_time) => {
+            throw new Error("Fake backend: gfstep() is not implemented");
+        },
+        gfstol: (_value) => {
+            throw new Error("Fake backend: gfstol() is not implemented");
+        },
+        gfrefn: (_t1, _t2, _s1, _s2) => {
+            throw new Error("Fake backend: gfrefn() is not implemented");
+        },
+        gfrepi: (_window, _begmss, _endmss) => {
+            throw new Error("Fake backend: gfrepi() is not implemented");
+        },
+        gfrepf: () => {
+            throw new Error("Fake backend: gfrepf() is not implemented");
+        },
+        gfsep: (_targ1, _shape1, _frame1, _targ2, _shape2, _frame2, _abcorr, _obsrvr, _relate, _refval, _adjust, _step, _nintvls, _cnfine, _result) => {
+            throw new Error("Fake backend: gfsep() is not implemented");
+        },
+        gfdist: (_target, _abcorr, _obsrvr, _relate, _refval, _adjust, _step, _nintvls, _cnfine, _result) => {
+            throw new Error("Fake backend: gfdist() is not implemented");
+        },
+        // --- file i/o primitives (not implemented in fake backend) ---
+        exists: (_path) => {
+            throw new Error("Fake backend: exists() is not implemented");
+        },
+        getfat: (_path) => {
+            throw new Error("Fake backend: getfat() is not implemented");
+        },
+        readVirtualOutput: (_output) => {
+            throw new Error("Fake backend: readVirtualOutput() is not implemented");
+        },
+        dafopr: (_path) => {
+            throw new Error("Fake backend: dafopr() is not implemented");
+        },
+        dafcls: (_handle) => {
+            throw new Error("Fake backend: dafcls() is not implemented");
+        },
+        dafbfs: (_handle) => {
+            throw new Error("Fake backend: dafbfs() is not implemented");
+        },
+        daffna: (_handle) => {
+            throw new Error("Fake backend: daffna() is not implemented");
+        },
+        dasopr: (_path) => {
+            throw new Error("Fake backend: dasopr() is not implemented");
+        },
+        dascls: (_handle) => {
+            throw new Error("Fake backend: dascls() is not implemented");
+        },
+        dlaopn: (_path, _ftype, _ifname, _ncomch) => {
+            throw new Error("Fake backend: dlaopn() is not implemented");
+        },
+        dlabfs: (_handle) => {
+            throw new Error("Fake backend: dlabfs() is not implemented");
+        },
+        dlafns: (_handle, _descr) => {
+            throw new Error("Fake backend: dlafns() is not implemented");
+        },
+        dlacls: (_handle) => {
+            throw new Error("Fake backend: dlacls() is not implemented");
+        },
+        // --- EK (not implemented in fake backend) ---
+        ekopr: (_path) => {
+            throw new Error("Fake backend: ekopr() is not implemented");
+        },
+        ekopw: (_path) => {
+            throw new Error("Fake backend: ekopw() is not implemented");
+        },
+        ekopn: (_path, _ifname, _ncomch) => {
+            throw new Error("Fake backend: ekopn() is not implemented");
+        },
+        ekcls: (_handle) => {
+            throw new Error("Fake backend: ekcls() is not implemented");
+        },
+        ekntab: () => {
+            throw new Error("Fake backend: ekntab() is not implemented");
+        },
+        ektnam: (_n) => {
+            throw new Error("Fake backend: ektnam() is not implemented");
+        },
+        eknseg: (_handle) => {
+            throw new Error("Fake backend: eknseg() is not implemented");
+        },
+        // --- EK query/data ops (not implemented in fake backend) ---
+        ekfind: (_query) => {
+            throw new Error("Fake backend: ekfind() is not implemented");
+        },
+        ekgc: (_selidx, _row, _elment) => {
+            throw new Error("Fake backend: ekgc() is not implemented");
+        },
+        ekgd: (_selidx, _row, _elment) => {
+            throw new Error("Fake backend: ekgd() is not implemented");
+        },
+        ekgi: (_selidx, _row, _elment) => {
+            throw new Error("Fake backend: ekgi() is not implemented");
+        },
+        ekifld: (_handle, _tabnam, _nrows, _cnames, _decls) => {
+            throw new Error("Fake backend: ekifld() is not implemented");
+        },
+        ekacli: (_handle, _segno, _column, _ivals, _entszs, _nlflgs, _rcptrs) => {
+            throw new Error("Fake backend: ekacli() is not implemented");
+        },
+        ekacld: (_handle, _segno, _column, _dvals, _entszs, _nlflgs, _rcptrs) => {
+            throw new Error("Fake backend: ekacld() is not implemented");
+        },
+        ekaclc: (_handle, _segno, _column, _cvals, _entszs, _nlflgs, _rcptrs) => {
+            throw new Error("Fake backend: ekaclc() is not implemented");
+        },
+        ekffld: (_handle, _segno, _rcptrs) => {
+            throw new Error("Fake backend: ekffld() is not implemented");
+        },
+        // --- DSK writer (not implemented in fake backend) ---
+        dskopn: (_path, _ifname, _ncomch) => {
+            throw new Error("Fake backend: dskopn() is not implemented");
+        },
+        dskmi2: (_nv, _vrtces, _np, _plates, _finscl, _corscl, _worksz, _voxpsz, _voxlsz, _makvtl, _spxisz) => {
+            throw new Error("Fake backend: dskmi2() is not implemented");
+        },
+        dskw02: (_handle, _center, _surfid, _dclass, _frame, _corsys, _corpar, _mncor1, _mxcor1, _mncor2, _mxcor2, _mncor3, _mxcor3, _first, _last, _nv, _vrtces, _np, _plates, _spaixd, _spaixi) => {
+            throw new Error("Fake backend: dskw02() is not implemented");
+        },
+        // -- DSK ----------------------------------------------------------------
+        dskobj: (_dsk, _bodids) => {
+            throw new Error("Fake backend: dskobj() is not implemented");
+        },
+        dsksrf: (_dsk, _bodyid, _srfids) => {
+            throw new Error("Fake backend: dsksrf() is not implemented");
+        },
+        dskgd: (_handle, _dladsc) => {
+            throw new Error("Fake backend: dskgd() is not implemented");
+        },
+        dskb02: (_handle, _dladsc) => {
+            throw new Error("Fake backend: dskb02() is not implemented");
+        },
+        // -- Cells + windows -----------------------------------------------------
+        //
+        // The fake backend is intentionally minimal and does not attempt to
+        // simulate CSPICE cell/window semantics.
+        newIntCell: (_size) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        newDoubleCell: (_size) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        newCharCell: (_size, _length) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        newWindow: (_maxIntervals) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        freeCell: (_cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        freeWindow: (_window) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        ssize: (_size, _cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        scard: (_card, _cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        card: (_cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        size: (_cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        valid: (_size, _n, _cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        insrti: (_item, _cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        insrtd: (_item, _cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        insrtc: (_item, _cell) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        cellGeti: (_cell, _index) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        cellGetd: (_cell, _index) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        cellGetc: (_cell, _index) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        wninsd: (_left, _right, _window) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        wncard: (_window) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        wnfetd: (_window, _index) => {
+            throw new Error(spiceCellUnsupported);
+        },
+        wnvald: (_size, _n, _window) => {
+            throw new Error(spiceCellUnsupported);
+        },
         reclat: (rect) => {
             const x = rect[0];
             const y = rect[1];
@@ -616,6 +1689,18 @@ export function createFakeBackend() {
         vcrss: (a, b) => vcrss(a, b),
         mxv: (m, v) => mxv(m, v),
         mtxv: (m, v) => mtxv(m, v),
+        vadd: (a, b) => vadd(a, b),
+        vsub: (a, b) => vsub(a, b),
+        vminus: (v) => vscale(-1, v),
+        vscl: (s, v) => vscale(s, v),
+        mxm: (a, b) => mmul3(a, b),
+        rotate: (angle, axis) => rotateRowMajor(angle, axis),
+        // CSPICE rotmat_c left-multiplies: mout = rotate(angle, axis) * m
+        rotmat: (m, angle, axis) => mmul3(rotateRowMajor(angle, axis), m),
+        axisar: (axis, angle) => axisAngleToRotationRowMajor(axis, angle),
+        georec: (lon, lat, alt, re, f) => georec(lon, lat, alt, re, f),
+        recgeo: (rect, re, f) => recgeo(rect, re, f),
     };
+    return backend;
 }
 //# sourceMappingURL=index.js.map