@rybosome/tspice 0.0.7 → 0.0.8

package/backend-contract/dist/domains/kernels-utils.js

@@ -0,0 +1,265 @@
+const SUPPORTED_QUERY_KIND_TOKENS = [
+    "ALL",
+    "SPK",
+    "CK",
+    "PCK",
+    "DSK",
+    "TEXT",
+    "LSK",
+    "FK",
+    "IK",
+    "SCLK",
+    "EK",
+    "META",
+];
+const SUPPORTED_QUERY_KIND_SET = new Set(SUPPORTED_QUERY_KIND_TOKENS);
+// `KernelData.filtyp` values are a subset of supported query tokens.
+// In particular, `"ALL"` is valid as an input selector but should never be treated as a
+// meaningful kernel-side `filtyp`.
+const SUPPORTED_FILTYPE_TOKENS = SUPPORTED_QUERY_KIND_TOKENS.filter((k) => k !== "ALL");
+const SUPPORTED_FILTYPE_SET = new Set(SUPPORTED_FILTYPE_TOKENS);
+const TEXT_SUBTYPE_SET = new Set(["LSK", "FK", "IK", "SCLK"]);
+const NATIVE_KIND_QUERY_ALLOWLIST = new Set([
+    "ALL",
+    "SPK",
+    "CK",
+    "PCK",
+    "DSK",
+    "TEXT",
+    "EK",
+    "META",
+]);
+function normalizeKindTokenOrThrow(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        throw new RangeError("Kernel kind must be a non-empty token");
+    }
+    const upper = trimmed.toUpperCase();
+    if (!SUPPORTED_QUERY_KIND_SET.has(upper)) {
+        throw new RangeError(`Unknown kernel kind: ${trimmed}. Expected one of: ${SUPPORTED_QUERY_KIND_TOKENS.join(", ")}`);
+    }
+    return upper;
+}
+function extLower(path) {
+    // Handle both POSIX and Windows separators.
+    const base = path.split(/[/\\]/).pop() ?? path;
+    const idx = base.lastIndexOf(".");
+    if (idx < 0) {
+        return "";
+    }
+    return base.slice(idx).toLowerCase();
+}
+/**
+ * Best-effort inference of TEXT-kernel subtypes from the kernel "file" identifier.
+ *
+ * SPICE reports many text kernels as `filtyp: "TEXT"` even when they're logically
+ * subtypes like LSK/FK/IK/SCLK.
+ *
+ * We infer subtypes from common NAIF filename extensions, but this is inherently
+ * best-effort:
+ * - some backends expose *virtual* identifiers that aren't real filesystem paths
+ * - identifiers can be extension-less (or use non-standard extensions)
+ *
+ * In those cases, this returns "TEXT".
+ */
+function guessTextKernelSubtype(path) {
+    switch (extLower(path)) {
+        case ".tls":
+        case ".lsk":
+            return "LSK";
+        case ".tf":
+        case ".fk":
+            return "FK";
+        case ".ti":
+        case ".ik":
+            return "IK";
+        case ".tsc":
+        case ".sclk":
+            return "SCLK";
+        default:
+            return "TEXT";
+    }
+}
+/** Normalize a `ktotal/kdata` kind input into a canonical, non-empty kernel kind list. */
+export function normalizeKindInput(kind) {
+    if (kind == null) {
+        return ["ALL"];
+    }
+    const rawTokens = [];
+    if (Array.isArray(kind)) {
+        if (kind.length === 0) {
+            throw new RangeError("Kernel kind array must not be empty");
+        }
+        rawTokens.push(...kind.map((k) => String(k)));
+    }
+    else {
+        // Allow CSPICE-style multi-kind strings.
+        const raw = String(kind);
+        if (/\s/.test(raw)) {
+            for (const part of raw.trim().split(/\s+/)) {
+                if (part)
+                    rawTokens.push(part);
+            }
+        }
+        else {
+            rawTokens.push(raw);
+        }
+    }
+    if (rawTokens.length === 0) {
+        throw new RangeError("Kernel kind must not be empty");
+    }
+    // Normalize + deduplicate while preserving first-seen order.
+    const seen = new Set();
+    let normalized = [];
+    for (const raw of rawTokens) {
+        const k = normalizeKindTokenOrThrow(raw);
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        normalized.push(k);
+    }
+    // Canonicalize ALL as an override: if ALL is present alongside other tokens,
+    // downstream callers should treat it as requesting all kinds.
+    if (normalized.length > 1 && normalized.includes("ALL")) {
+        return ["ALL"];
+    }
+    // Canonicalize away TEXT subtypes when TEXT is present. Subtype tokens only
+    // matter when TEXT is absent (and we must infer subtypes from `kernel.file`).
+    if (normalized.includes("TEXT")) {
+        normalized = normalized.filter((k) => !TEXT_SUBTYPE_SET.has(k));
+    }
+    return normalized;
+}
+/**
+ * Returns a representable native kind-query string (e.g. `"SPK CK"`) or null.
+ *
+ * This is used by backends to decide whether they can forward a kind filter to
+ * their underlying CSPICE implementation, or whether they must fall back to
+ * querying `ALL` and filtering in JS.
+ *
+ * NOTE: `kinds` is expected to be normalized (via {@link normalizeKindInput}).
+ * If non-normalized input slips through (e.g. empty arrays or `ALL` mixed with
+ * other tokens), this function is defensive and returns null.
+ */
+export function nativeKindQueryOrNull(kinds) {
+    // Defensive: callers are expected to pass normalized kinds, but this is an
+    // exported helper and should not throw on incidental misuse.
+    if (kinds.length === 0)
+        return null;
+    if (kinds.length === 1 && kinds[0] === "ALL")
+        return "ALL";
+    // If someone bypasses normalization and includes ALL alongside other tokens,
+    // treat it as non-forwardable.
+    if (kinds.includes("ALL"))
+        return null;
+    for (const k of kinds) {
+        if (!NATIVE_KIND_QUERY_ALLOWLIST.has(k))
+            return null;
+    }
+    return kinds.join(" ");
+}
+function normalizeRequestedKindSetIfNeeded(requestedRaw) {
+    for (const raw of requestedRaw) {
+        const trimmed = raw.trim();
+        if (!trimmed || trimmed !== raw || trimmed.toUpperCase() !== trimmed) {
+            // Normalize the query (trim + uppercase) while filtering out empty tokens.
+            const normalized = new Set();
+            for (const k of requestedRaw) {
+                const token = k.trim();
+                if (token)
+                    normalized.add(token.toUpperCase());
+            }
+            return normalized;
+        }
+    }
+    return requestedRaw;
+}
+/**
+ * Return whether a kernel matches the requested kind filter.
+ *
+ * Requested kind tokens are treated as trim + case-insensitive. Empty tokens are ignored.
+ *
+ * NOTE: Unlike {@link normalizeKindInput}, this helper is intentionally lenient:
+ * unknown requested tokens are treated as non-matching (and do not throw).
+ * Unknown/unsupported `kernel.filtyp` values never match (unless `requested` includes `ALL`).
+ *
+ * TEXT-kernel subtypes (LSK/FK/IK/SCLK): SPICE reports these as `filtyp: "TEXT"`.
+ * When callers request a subtype, we infer it from the `kernel.file` identifier's
+ * filename extension (best-effort). If the identifier is virtual or extension-less,
+ * subtype matching may fall back to "TEXT".
+ */
+export function matchesKernelKind(requestedRaw, kernel) {
+    // Normalize the requested set internally so callers can't accidentally pass
+    // untrimmed / non-canonical tokens (e.g. "spk", " ALL ").
+    //
+    // Most call-sites already pass canonical kinds (e.g. via normalizeKindInput),
+    // so we avoid allocating a new set unless normalization is needed.
+    const requested = normalizeRequestedKindSetIfNeeded(requestedRaw);
+    if (requested.size === 0) {
+        return false;
+    }
+    if (requested.has("ALL")) {
+        return true;
+    }
+    const filtyp = kernel.filtyp.trim().toUpperCase();
+    if (filtyp.length === 0) {
+        return false;
+    }
+    if (filtyp === "TEXT") {
+        if (requested.has("TEXT")) {
+            return true;
+        }
+        const file = kernel.file.trim();
+        const subtype = guessTextKernelSubtype(file);
+        return requested.has(subtype);
+    }
+    // Some backends may choose to surface TEXT subtypes directly.
+    // Treat those as text kernels for matching purposes.
+    if (TEXT_SUBTYPE_SET.has(filtyp)) {
+        return requested.has("TEXT") || requested.has(filtyp);
+    }
+    // Contract-level strictness: unknown `filtyp` values never match.
+    if (!SUPPORTED_FILTYPE_SET.has(filtyp)) {
+        return false;
+    }
+    return requested.has(filtyp);
+}
+/**
+ * JS implementation of CSPICE `kxtrct`.
+ *
+ * Notes on return values:
+ * - `substr` is right-trimmed (`trimEnd()`).
+ * - `wordsq` has the extracted words removed, but otherwise preserves whitespace
+ *   from the original input (so it may start with blanks).
+ */
+export function kxtrctJs(keywd, terms, wordsq) {
+    const key = keywd.trim();
+    if (key.length === 0) {
+        throw new RangeError("kxtrct keywd must be a non-empty string");
+    }
+    const termSet = new Set(terms.map((t) => t.trim()).filter(Boolean));
+    const words = [...wordsq.matchAll(/\S+/g)].map((m) => {
+        const text = m[0];
+        const start = m.index ?? 0;
+        return { text, start, end: start + text.length - 1 };
+    });
+    const keyIndex = words.findIndex((w) => w.text === key);
+    if (keyIndex < 0) {
+        return { found: false };
+    }
+    let termIndex = -1;
+    for (let i = keyIndex + 1; i < words.length; i++) {
+        if (termSet.has(words[i].text)) {
+            termIndex = i;
+            break;
+        }
+    }
+    const startSub = words[keyIndex + 1]?.start;
+    const endSub = termIndex >= 0 ? words[termIndex].start : wordsq.length;
+    const substr = startSub == null ? "" : wordsq.slice(startSub, endSub).trimEnd();
+    const removalStart = words[keyIndex].start;
+    const removalEnd = termIndex >= 0 ? words[(termIndex - 1)].end + 1 : wordsq.length;
+    const newWordsq = wordsq.slice(0, removalStart) + wordsq.slice(removalEnd);
+    return { found: true, wordsq: newWordsq, substr };
+}
+//# sourceMappingURL=kernels-utils.js.map

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

@@ -1,4 +1,26 @@
-import type { Found, KernelData, KernelKind, KernelSource } from "../shared/types.js";
+/**
+ * Contract conventions:
+ * - Inputs are validated at the backend boundary. This package provides shared runtime helpers
+ *   (e.g. `normalizeKindInput`) that backends can reuse and that throw `RangeError` on invalid tokens.
+ * - Methods throw on invalid arguments or SPICE errors.
+ * - Lookups that may legitimately miss return `Found<T>` (`{ found: false }`) instead of throwing.
+ */
+import type { Found, KernelData, KernelInfo, KernelKind, KernelSource } from "../shared/types.js";
+import type { SpiceIntCell } from "./cells-windows.js";
+/**
+ * Kernel kind selector used by `ktotal()` / `kdata()`.
+ *
+ * Supports:
+ * - a single `KernelKind`
+ * - an array of `KernelKind` (treated as an OR query)
+ * - a CSPICE-style multi-kind string (whitespace-separated, e.g. `"SPK CK"`)
+ *
+ * Tokens are validated case-insensitively and normalized to canonical uppercase.
+ * Unknown/empty tokens throw `RangeError`.
+ * An empty array (`[]`) is invalid and throws `RangeError`.
+ */
+export type KernelKindInput = KernelKind | readonly KernelKind[] | string;
+/** Backend contract for kernel management and kernel metadata queries. */
 export interface KernelsApi {
     /**
      * Load a SPICE kernel.
@@ -14,9 +36,23 @@ export interface KernelsApi {
     unload(path: string): void;
     /** Clear all loaded kernels. */
     kclear(): void;
+    /** Retrieve information about a currently loaded kernel by filename. */
+    kinfo(path: string): Found<KernelInfo>;
+    /**
+     * Extract a substring from a word sequence.
+     *
+     * This is a string-parsing utility (used by some NAIF kernels and tooling).
+     * It does **not** extract kernel bytes.
+     */
+    kxtrct(keywd: string, terms: readonly string[], wordsq: string): Found<{
+        wordsq: string;
+        substr: string;
+    }>;
+    /** Return kernel-pool frame IDs for the given frame class. */
+    kplfrm(frmcls: number, idset: SpiceIntCell): void;
     /** Count loaded kernels of a given kind. */
-    ktotal(kind?: KernelKind): number;
+    ktotal(kind?: KernelKindInput): number;
     /** Retrieve kernel metadata at position `which` for a given kind. */
-    kdata(which: number, kind?: KernelKind): Found<KernelData>;
+    kdata(which: number, kind?: KernelKindInput): Found<KernelData>;
 }
 //# sourceMappingURL=kernels.d.ts.map

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

@@ -1,4 +1,11 @@
+/**
+ * Contract conventions:
+ * - Inputs are assumed validated at the backend boundary; the contract itself is primarily type-level.
+ * - Methods throw on invalid arguments or SPICE errors.
+ * - Lookups that may legitimately miss return `Found<T>` (`{ found: false }`) instead of throwing.
+ */
 export interface TimeApi {
+    /** Return the underlying SPICE toolkit version string. */
     spiceVersion(): string;
     /**
      * Thin wrapper over the SPICE primitive `tkvrsn()`.
@@ -16,9 +23,104 @@ export interface TimeApi {
      * Wrapper around CSPICE `timout_c`.
      */
     timout(et: number, picture: string): string;
+    /**
+     * Return the difference ET - UTC at a given epoch.
+     *
+     * Kernel prerequisites:
+     * - Requires an LSK (leapseconds) kernel to be loaded.
+     *
+     * Wrapper around CSPICE `deltet_c`.
+     */
+    deltet(epoch: number, eptype: "ET" | "UTC"): number;
+    /**
+     * Convert a time epoch from one system to another.
+     *
+     * Kernel prerequisites:
+     * - Requires an LSK (leapseconds) kernel to be loaded.
+     *
+     * Wrapper around CSPICE `unitim_c`.
+     */
+    unitim(epoch: number, insys: string, outsys: string): number;
+    /**
+     * Parse a UTC time string to **UTC seconds past J2000**.
+     *
+     * This uses SPICE's "formal calendar" (fixed 86400-second days) and does **not**
+     * account for leap seconds.
+     *
+     * Limitations:
+     * - UTC-only: `timstr` must not include time system labels (e.g. `TDB`) or
+     *   time zone designators/offsets (e.g. `PDT`, `UTC+05:00`).
+     *
+     * Kernel prerequisites:
+     * - None.
+     *
+     * Wrapper around CSPICE `tparse_c`.
+     */
+    tparse(timstr: string): number;
+    /**
+     * Transform a NAIF time picture to match a sample time string.
+     *
+     * Statefulness: this is affected by TIMDEF defaults (SYSTEM/CALENDAR/ZONE),
+     * since `sample` is interpreted under the current TIMDEF state.
+     *
+     * Kernel prerequisites:
+     * - None.
+     *
+     * Wrapper around CSPICE `tpictr_c`.
+     */
+    tpictr(sample: string, pictur: string): string;
+    /**
+     * Get or set time conversion defaults.
+     *
+     * Kernel prerequisites:
+     * - None.
+     *
+     * Wrapper around CSPICE `timdef_c`.
+     */
+    timdef(action: "GET", item: string): string;
+    /** Set a time conversion default (see `timdef_c`). */
+    timdef(action: "SET", item: string, value: string): void;
     /** Convert an encoded SCLK string to ET seconds past J2000. */
     scs2e(sc: number, sclkch: string): number;
     /** Convert ET seconds past J2000 to an encoded SCLK string. */
     sce2s(sc: number, et: number): string;
+    /**
+     * Encode an SCLK string into "ticks".
+     *
+     * Kernel prerequisites:
+     * - Requires an SCLK kernel to be loaded.
+     *
+     * Wrapper around CSPICE `scencd_c`.
+     */
+    scencd(sc: number, sclkch: string): number;
+    /**
+     * Decode SCLK "ticks" into an SCLK string.
+     *
+     * Kernel prerequisites:
+     * - Requires an SCLK kernel to be loaded.
+     *
+     * Wrapper around CSPICE `scdecd_c`.
+     */
+    scdecd(sc: number, sclkdp: number): string;
+    /**
+     * Convert SCLK "ticks" to ET seconds past J2000.
+     *
+     * Kernel prerequisites:
+     * - Requires an SCLK kernel to be loaded.
+     * - Often requires an LSK (leapseconds) kernel as well (see NAIF docs).
+     *
+     * Wrapper around CSPICE `sct2e_c`.
+     */
+    sct2e(sc: number, sclkdp: number): number;
+    /**
+     * Convert ET seconds past J2000 to SCLK "ticks".
+     *
+     * Kernel prerequisites:
+     * - Requires an SCLK kernel to be loaded.
+     * - Often requires an LSK (leapseconds) kernel as well (see NAIF docs).
+     *
+     * Wrapper around CSPICE `sce2c_c`.
+     */
+    sce2c(sc: number, et: number): number;
 }
 //# sourceMappingURL=time.d.ts.map

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

@@ -1,22 +1,50 @@
-export type { AbCorr, Found, IluminResult, KernelData, KernelKind, KernelSource, Mat3ColMajor, Mat3RowMajor, SpiceMatrix6x6, SpiceStateVector, SpiceVector3, SpkezrResult, SpkposResult, SubPointResult, } from "./shared/types.js";
+export type { AbCorr, FixedString, Found, FoundDouble, FoundInt, FoundPayload, FoundString, FoundValue, IllumfResult, IllumgResult, IluminResult, KernelData, KernelInfo, KernelKind, KernelSource, VirtualOutput, Mat6RowMajor, Mat3ColMajor, Mat3RowMajor, Pl2nvcResult, SpiceHandle, SpiceMatrix6x6, SpicePlane, SpiceStateVector, SpiceVector3, SpkezrResult, SpkposResult, StringArrayResult, SubPointResult, Vec3, Vec6, } from "./shared/types.js";
 export type { BrandMat3Options } from "./shared/mat3.js";
-export { assertMat3ArrayLike9, brandMat3ColMajor, brandMat3RowMajor, isMat3ColMajor, isMat3RowMajor, } from "./shared/mat3.js";
+export { assertMat3ArrayLike9, isMat3ArrayLike9, brandMat3ColMajor, brandMat3RowMajor, isBrandedMat3ColMajor, isBrandedMat3RowMajor, } from "./shared/mat3.js";
+export type { BrandVecOptions } from "./shared/vec.js";
+export { assertVec3ArrayLike3, assertVec6ArrayLike6, isVec3ArrayLike3, isVec6ArrayLike6, brandVec3, brandVec6, isBrandedVec3, isBrandedVec6, } from "./shared/vec.js";
+export type { BrandMat6Options } from "./shared/mat6.js";
+export { assertMat6ArrayLike36, isMat6ArrayLike36, brandMat6RowMajor, isBrandedMat6RowMajor, } from "./shared/mat6.js";
+export { SPICE_INT32_MIN, SPICE_INT32_MAX, assertSpiceInt32, assertSpiceInt32NonNegative, } from "./shared/spice-int.js";
+export type { SpiceHandleEntry, SpiceHandleKind, SpiceHandleRegistry } from "./shared/spice-handles.js";
+export { createSpiceHandleRegistry } from "./shared/spice-handles.js";
+export { SpiceBackendContractError } from "./shared/errors.js";
+export type { KernelKindInput, KernelsApi } from "./domains/kernels.js";
 export * from "./domains/kernels.js";
+export * from "./domains/kernel-pool.js";
+export * from "./domains/ek.js";
+export * from "./domains/kernels-utils.js";
 export * from "./domains/time.js";
 export * from "./domains/ids-names.js";
+export * from "./domains/ids-names-normalize.js";
 export * from "./domains/frames.js";
 export * from "./domains/ephemeris.js";
 export * from "./domains/geometry.js";
+export * from "./domains/geometry-gf.js";
 export * from "./domains/coords-vectors.js";
+export * from "./domains/file-io.js";
+export * from "./domains/error.js";
+export * from "./domains/cells-windows.js";
+export * from "./domains/dsk.js";
 import type { KernelsApi } from "./domains/kernels.js";
+import type { KernelPoolApi } from "./domains/kernel-pool.js";
+import type { EkApi } from "./domains/ek.js";
 import type { TimeApi } from "./domains/time.js";
 import type { IdsNamesApi } from "./domains/ids-names.js";
 import type { FramesApi } from "./domains/frames.js";
 import type { EphemerisApi } from "./domains/ephemeris.js";
 import type { GeometryApi } from "./domains/geometry.js";
+import type { GeometryGfApi } from "./domains/geometry-gf.js";
 import type { CoordsVectorsApi } from "./domains/coords-vectors.js";
+import type { FileIoApi } from "./domains/file-io.js";
+import type { ErrorApi } from "./domains/error.js";
+import type { CellsWindowsApi } from "./domains/cells-windows.js";
+import type { DskApi } from "./domains/dsk.js";
 export type SpiceBackendKind = "node" | "wasm" | "fake";
-export interface SpiceBackend extends TimeApi, KernelsApi, IdsNamesApi, FramesApi, EphemerisApi, GeometryApi, CoordsVectorsApi {
+/**
+ * Unified backend contract (composition of all domain APIs).
+ */
+export interface SpiceBackend extends TimeApi, KernelsApi, KernelPoolApi, EkApi, IdsNamesApi, FramesApi, EphemerisApi, GeometryApi, GeometryGfApi, CoordsVectorsApi, FileIoApi, ErrorApi, CellsWindowsApi, DskApi {
     /** Which backend implementation is in use. */
     readonly kind: SpiceBackendKind;
 }

package/backend-contract/dist/index.js

@@ -1,9 +1,23 @@
-export { assertMat3ArrayLike9, brandMat3ColMajor, brandMat3RowMajor, isMat3ColMajor, isMat3RowMajor, } from "./shared/mat3.js";
+export { assertMat3ArrayLike9, isMat3ArrayLike9, brandMat3ColMajor, brandMat3RowMajor, isBrandedMat3ColMajor, isBrandedMat3RowMajor, } from "./shared/mat3.js";
+export { assertVec3ArrayLike3, assertVec6ArrayLike6, isVec3ArrayLike3, isVec6ArrayLike6, brandVec3, brandVec6, isBrandedVec3, isBrandedVec6, } from "./shared/vec.js";
+export { assertMat6ArrayLike36, isMat6ArrayLike36, brandMat6RowMajor, isBrandedMat6RowMajor, } from "./shared/mat6.js";
+export { SPICE_INT32_MIN, SPICE_INT32_MAX, assertSpiceInt32, assertSpiceInt32NonNegative, } from "./shared/spice-int.js";
+export { createSpiceHandleRegistry } from "./shared/spice-handles.js";
+export { SpiceBackendContractError } from "./shared/errors.js";
 export * from "./domains/kernels.js";
+export * from "./domains/kernel-pool.js";
+export * from "./domains/ek.js";
+export * from "./domains/kernels-utils.js";
 export * from "./domains/time.js";
 export * from "./domains/ids-names.js";
+export * from "./domains/ids-names-normalize.js";
 export * from "./domains/frames.js";
 export * from "./domains/ephemeris.js";
 export * from "./domains/geometry.js";
+export * from "./domains/geometry-gf.js";
 export * from "./domains/coords-vectors.js";
+export * from "./domains/file-io.js";
+export * from "./domains/error.js";
+export * from "./domains/cells-windows.js";
+export * from "./domains/dsk.js";
 //# sourceMappingURL=index.js.map

package/backend-contract/dist/shared/errors.d.ts

@@ -0,0 +1,6 @@
+/** Error thrown when a backend violates a contract invariant or postcondition. */
+export declare class SpiceBackendContractError extends Error {
+    name: string;
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/backend-contract/dist/shared/errors.js

@@ -0,0 +1,8 @@
+/** Error thrown when a backend violates a contract invariant or postcondition. */
+export class SpiceBackendContractError extends Error {
+    name = "SpiceBackendContractError";
+    constructor(message) {
+        super(message);
+    }
+}
+//# sourceMappingURL=errors.js.map

package/backend-contract/dist/shared/mat3.d.ts

@@ -15,26 +15,38 @@ export type BrandMat3Options = {
     readonly freeze?: FreezeMode;
 };
 /**
-* Runtime validation that an input is a length-9 array-like of finite numbers.
-*
-* This is intentionally layout-agnostic; it is used by both row-major and
-* column-major branded types.
-*/
+ * Runtime validation that an input is a length-9 array-like of finite numbers.
+ *
+ * This is intentionally layout-agnostic; it is used by both row-major and
+ * column-major branded types.
+ */
 export declare function assertMat3ArrayLike9(value: unknown, options?: {
     readonly label?: string;
 }): asserts value is ArrayLike<number>;
 /**
-* Validate + brand a value as a row-major Mat3.
-*
-* Used at backend boundaries (node/wasm/fake) to avoid ad-hoc `as Mat3RowMajor`
-* casts.
-*/
+ * Structural check: accepts number[] and numeric TypedArrays (excludes DataView).
+ *
+ * This does **not** assert/require that the value is branded as a row/col-major Mat3.
+ */
+export declare function isMat3ArrayLike9(value: unknown): value is ArrayLike<number>;
+/**
+ * Validate + brand a value as a row-major Mat3.
+ *
+ * Used at backend boundaries (node/wasm/fake) to avoid ad-hoc `as Mat3RowMajor`
+ * casts.
+ */
 export declare function brandMat3RowMajor(value: unknown, options?: BrandMat3Options): Mat3RowMajor;
 /**
-* Validate + brand a value as a column-major Mat3.
-*/
+ * Validate + brand a value as a column-major Mat3.
+ */
 export declare function brandMat3ColMajor(value: unknown, options?: BrandMat3Options): Mat3ColMajor;
-export declare function isMat3RowMajor(value: unknown): value is Mat3RowMajor;
-export declare function isMat3ColMajor(value: unknown): value is Mat3ColMajor;
+/**
+ * Brand-only check: verifies that a value was produced by `brandMat3RowMajor()`.
+ */
+export declare function isBrandedMat3RowMajor(value: unknown): value is Mat3RowMajor;
+/**
+ * Brand-only check: verifies that a value was produced by `brandMat3ColMajor()`.
+ */
+export declare function isBrandedMat3ColMajor(value: unknown): value is Mat3ColMajor;
 export {};
 //# sourceMappingURL=mat3.d.ts.map