@rybosome/tspice 0.0.7 → 0.0.8

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

@@ -24,9 +24,16 @@ function isFiniteNumber(x) {
     return typeof x === "number" && Number.isFinite(x);
 }
 function isTypedArrayView(x) {
-    // `ArrayBuffer.isView()` is true for TypedArrays *and* DataView.
-    // We accept TypedArray views but explicitly reject DataView.
-    return ArrayBuffer.isView(x) && !(x instanceof DataView);
+    // We intentionally only accept numeric TypedArrays (not BigInt views, not DataView).
+    return (x instanceof Int8Array ||
+        x instanceof Uint8Array ||
+        x instanceof Uint8ClampedArray ||
+        x instanceof Int16Array ||
+        x instanceof Uint16Array ||
+        x instanceof Int32Array ||
+        x instanceof Uint32Array ||
+        x instanceof Float32Array ||
+        x instanceof Float64Array);
 }
 function isLength9ArrayLike(x) {
     return (x !== null &&
@@ -37,11 +44,11 @@ function isLength9ArrayLike(x) {
         x.length === 9);
 }
 /**
-* 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 function assertMat3ArrayLike9(value, options) {
     const label = options?.label ?? "Mat3";
     if (value instanceof DataView) {
@@ -57,6 +64,22 @@ export function assertMat3ArrayLike9(value, options) {
         }
     }
 }
+/**
+ * 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 function isMat3ArrayLike9(value) {
+    if (value instanceof DataView)
+        return false;
+    if (!isLength9ArrayLike(value))
+        return false;
+    for (let i = 0; i < 9; i++) {
+        if (!isFiniteNumber(value[i]))
+            return false;
+    }
+    return true;
+}
 function tryDefineBrand(target, brand) {
     try {
         // Non-enumerable to avoid surprising JSON/stringification behavior.
@@ -82,11 +105,11 @@ function maybeFreeze(value, mode) {
     }
 }
 /**
-* Validate + brand a value as a row-major Mat3.
-*
-* Used at backend boundaries (node/wasm/fake) to avoid ad-hoc `as Mat3RowMajor`
-* casts.
-*/
+ * Validate + brand a value as a row-major Mat3.
+ *
+ * Used at backend boundaries (node/wasm/fake) to avoid ad-hoc `as Mat3RowMajor`
+ * casts.
+ */
 export function brandMat3RowMajor(value, options) {
     const label = options?.label ?? "Mat3RowMajor";
     const freeze = options?.freeze ?? DEFAULT_FREEZE_MODE;
@@ -97,8 +120,8 @@ export function brandMat3RowMajor(value, options) {
     return maybeFreeze(arr, freeze);
 }
 /**
-* Validate + brand a value as a column-major Mat3.
-*/
+ * Validate + brand a value as a column-major Mat3.
+ */
 export function brandMat3ColMajor(value, options) {
     const label = options?.label ?? "Mat3ColMajor";
     const freeze = options?.freeze ?? DEFAULT_FREEZE_MODE;
@@ -108,12 +131,18 @@ export function brandMat3ColMajor(value, options) {
     tryDefineBrand(arr, MAT3_COL_MAJOR_BRAND);
     return maybeFreeze(arr, freeze);
 }
-export function isMat3RowMajor(value) {
+/**
+ * Brand-only check: verifies that a value was produced by `brandMat3RowMajor()`.
+ */
+export function isBrandedMat3RowMajor(value) {
     if (!isLength9ArrayLike(value))
         return false;
     return Boolean(value[MAT3_ROW_MAJOR_BRAND]);
 }
-export function isMat3ColMajor(value) {
+/**
+ * Brand-only check: verifies that a value was produced by `brandMat3ColMajor()`.
+ */
+export function isBrandedMat3ColMajor(value) {
     if (!isLength9ArrayLike(value))
         return false;
     return Boolean(value[MAT3_COL_MAJOR_BRAND]);

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

@@ -0,0 +1,34 @@
+import type { Mat6RowMajor } from "./types.js";
+type FreezeMode = "never" | "dev" | "always";
+export type BrandMat6Options = {
+    /**
+     * Used for error messages (e.g. `"sxform()"`).
+     *
+     * Defaults to `"Mat6RowMajor"`.
+     */
+    readonly label?: string;
+    /**
+     * If set, freeze branded matrices to prevent mutation at runtime.
+     *
+     * Defaults to `"dev"`.
+     */
+    readonly freeze?: FreezeMode;
+};
+/** Runtime validation that an input is a length-36 array-like of finite numbers. */
+export declare function assertMat6ArrayLike36(value: unknown, options?: {
+    readonly label?: string;
+}): asserts value is ArrayLike<number>;
+/**
+ * Structural check: accepts number[] and numeric TypedArrays (excludes DataView).
+ *
+ * This does **not** assert/require that the value is branded as a row-major Mat6.
+ */
+export declare function isMat6ArrayLike36(value: unknown): value is ArrayLike<number>;
+/** Validate + brand a value as a row-major 6x6 matrix. */
+export declare function brandMat6RowMajor(value: unknown, options?: BrandMat6Options): Mat6RowMajor;
+/**
+ * Brand-only check: verifies that a value was produced by `brandMat6RowMajor()`.
+ */
+export declare function isBrandedMat6RowMajor(value: unknown): value is Mat6RowMajor;
+export {};
+//# sourceMappingURL=mat6.d.ts.map

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

@@ -0,0 +1,116 @@
+const DEFAULT_FREEZE_MODE = "dev";
+// Runtime-only brand (module-private).
+const MAT6_ROW_MAJOR_BRAND = Symbol("Mat6RowMajor");
+function isDevEnv() {
+    // Safe in non-node runtimes.
+    return typeof process !== "undefined" && process?.env?.NODE_ENV !== "production";
+}
+function shouldFreeze(mode) {
+    switch (mode) {
+        case "never":
+            return false;
+        case "always":
+            return true;
+        case "dev":
+            return isDevEnv();
+    }
+}
+function isFiniteNumber(x) {
+    return typeof x === "number" && Number.isFinite(x);
+}
+function isTypedArrayView(x) {
+    // We intentionally only accept numeric TypedArrays (not BigInt views, not DataView).
+    return (x instanceof Int8Array ||
+        x instanceof Uint8Array ||
+        x instanceof Uint8ClampedArray ||
+        x instanceof Int16Array ||
+        x instanceof Uint16Array ||
+        x instanceof Int32Array ||
+        x instanceof Uint32Array ||
+        x instanceof Float32Array ||
+        x instanceof Float64Array);
+}
+function isLength36ArrayLike(x) {
+    return (x !== null &&
+        typeof x === "object" &&
+        (Array.isArray(x) || isTypedArrayView(x)) &&
+        typeof x.length === "number" &&
+        x.length === 36);
+}
+function formatMat6Error(label, detail) {
+    return `${label}: expected a length-36 array of finite numbers (${detail})`;
+}
+/** Runtime validation that an input is a length-36 array-like of finite numbers. */
+export function assertMat6ArrayLike36(value, options) {
+    const label = options?.label ?? "Mat6";
+    if (value instanceof DataView) {
+        throw new Error(`${label}: DataView is not a supported Mat6 input (use a TypedArray or number[]).`);
+    }
+    if (!isLength36ArrayLike(value)) {
+        throw new Error(formatMat6Error(label, "wrong shape"));
+    }
+    for (let i = 0; i < 36; i++) {
+        const v = value[i];
+        if (!isFiniteNumber(v)) {
+            throw new Error(formatMat6Error(label, `index ${i} was ${String(v)}`));
+        }
+    }
+}
+/**
+ * Structural check: accepts number[] and numeric TypedArrays (excludes DataView).
+ *
+ * This does **not** assert/require that the value is branded as a row-major Mat6.
+ */
+export function isMat6ArrayLike36(value) {
+    if (value instanceof DataView)
+        return false;
+    if (!isLength36ArrayLike(value))
+        return false;
+    for (let i = 0; i < 36; i++) {
+        if (!isFiniteNumber(value[i]))
+            return false;
+    }
+    return true;
+}
+function tryDefineBrand(target, brand) {
+    try {
+        // Non-enumerable to avoid surprising JSON/stringification behavior.
+        Object.defineProperty(target, brand, {
+            value: true,
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+    }
+    catch {
+        // Best-effort.
+    }
+}
+function maybeFreeze(value, mode) {
+    if (!shouldFreeze(mode))
+        return value;
+    try {
+        return Object.freeze(value);
+    }
+    catch {
+        return value;
+    }
+}
+/** Validate + brand a value as a row-major 6x6 matrix. */
+export function brandMat6RowMajor(value, options) {
+    const label = options?.label ?? "Mat6RowMajor";
+    const freeze = options?.freeze ?? DEFAULT_FREEZE_MODE;
+    assertMat6ArrayLike36(value, { label });
+    const arr = Array.from(value);
+    tryDefineBrand(arr, MAT6_ROW_MAJOR_BRAND);
+    return maybeFreeze(arr, freeze);
+}
+/**
+ * Brand-only check: verifies that a value was produced by `brandMat6RowMajor()`.
+ */
+export function isBrandedMat6RowMajor(value) {
+    if (!isLength36ArrayLike(value))
+        return false;
+    return Boolean(value[MAT6_ROW_MAJOR_BRAND]);
+}
+//# sourceMappingURL=mat6.js.map

package/backend-contract/dist/shared/spice-handles.d.ts

@@ -0,0 +1,20 @@
+import type { SpiceHandle } from "./types.js";
+export type SpiceHandleKind = "DAF" | "DAS" | "DLA" | "SPK" | "EK";
+export type SpiceHandleEntry = {
+    kind: SpiceHandleKind;
+    nativeHandle: number;
+};
+export type SpiceHandleRegistry = {
+    register: (kind: SpiceHandleKind, nativeHandle: number) => SpiceHandle;
+    lookup: (handle: SpiceHandle, expected: readonly SpiceHandleKind[], context: string) => SpiceHandleEntry;
+    close: (handle: SpiceHandle, expected: readonly SpiceHandleKind[], closeNative: (entry: SpiceHandleEntry) => void, context: string) => void;
+    size: () => number;
+    __entries?: () => ReadonlyArray<readonly [SpiceHandle, SpiceHandleEntry]>;
+};
+/**
+ * Create an in-memory registry for opaque {@link SpiceHandle} values.
+ *
+ * Used by backends to map stable JS handles to backend-native integer handles.
+ */
+export declare function createSpiceHandleRegistry(): SpiceHandleRegistry;
+//# sourceMappingURL=spice-handles.d.ts.map

package/backend-contract/dist/shared/spice-handles.js

@@ -0,0 +1,82 @@
+import { SPICE_INT32_MAX, SPICE_INT32_MIN } from "./spice-int.js";
+import { SpiceBackendContractError } from "./errors.js";
+function asHandleId(handle, context) {
+    const id = handle;
+    if (typeof id !== "number" || !Number.isFinite(id) || !Number.isInteger(id)) {
+        throw new TypeError(`${context}: expected a SpiceHandle to be an integer number`);
+    }
+    if (id <= 0) {
+        throw new RangeError(`${context}: expected a SpiceHandle to be > 0 (got ${id})`);
+    }
+    if (!Number.isSafeInteger(id)) {
+        throw new RangeError(`${context}: expected a SpiceHandle to be a safe integer (got ${id})`);
+    }
+    return id;
+}
+function asSpiceHandle(handleId) {
+    return handleId;
+}
+/**
+ * Create an in-memory registry for opaque {@link SpiceHandle} values.
+ *
+ * Used by backends to map stable JS handles to backend-native integer handles.
+ */
+export function createSpiceHandleRegistry() {
+    let nextHandleId = 1;
+    const handles = new Map();
+    function register(kind, nativeHandle) {
+        if (typeof nativeHandle !== "number" ||
+            !Number.isInteger(nativeHandle) ||
+            nativeHandle < SPICE_INT32_MIN ||
+            nativeHandle > SPICE_INT32_MAX) {
+            throw new SpiceBackendContractError(`backend contract violation: expected backend to return a 32-bit signed integer handle for ${kind} (got ${nativeHandle})`);
+        }
+        if (nextHandleId >= Number.MAX_SAFE_INTEGER) {
+            throw new SpiceBackendContractError(`backend contract violation: SpiceHandle ID overflow (nextHandleId=${nextHandleId})`);
+        }
+        // Defensive: never reuse/collide IDs even if `nextHandleId` gets out of sync.
+        while (handles.has(nextHandleId)) {
+            nextHandleId++;
+            if (nextHandleId >= Number.MAX_SAFE_INTEGER) {
+                throw new SpiceBackendContractError(`backend contract violation: SpiceHandle ID overflow (nextHandleId=${nextHandleId})`);
+            }
+        }
+        const handleId = nextHandleId++;
+        handles.set(handleId, { kind, nativeHandle });
+        return asSpiceHandle(handleId);
+    }
+    function lookup(handle, expected, context) {
+        const handleId = asHandleId(handle, `${context}: lookup(handle)`);
+        const entry = handles.get(handleId);
+        if (!entry) {
+            throw new RangeError(`${context}: invalid or closed SpiceHandle ${handleId}`);
+        }
+        if (!expected.includes(entry.kind)) {
+            throw new TypeError(`${context}: SpiceHandle ${handleId} has kind ${entry.kind}, expected ${expected.join(" or ")}`);
+        }
+        return entry;
+    }
+    function close(handle, expected, closeNative, context) {
+        const handleId = asHandleId(handle, `${context}: close(handle)`);
+        const entry = handles.get(handleId);
+        if (!entry) {
+            throw new RangeError(`${context}: invalid or closed SpiceHandle ${handleId}`);
+        }
+        if (!expected.includes(entry.kind)) {
+            throw new TypeError(`${context}: SpiceHandle ${handleId} has kind ${entry.kind}, expected ${expected.join(" or ")}`);
+        }
+        // Close-once semantics: only forget the handle after the native close succeeds.
+        closeNative(entry);
+        handles.delete(handleId);
+    }
+    return {
+        register,
+        lookup,
+        close,
+        size: () => handles.size,
+        // Internal hook used by the Node backend to best-effort dispose all open handles.
+        // Not part of the public backend contract.
+        __entries: () => Array.from(handles.entries()).map(([handleId, entry]) => [asSpiceHandle(handleId), entry]),
+    };
+}
+//# sourceMappingURL=spice-handles.js.map

package/backend-contract/dist/shared/spice-int.d.ts

@@ -0,0 +1,32 @@
+export declare const SPICE_INT32_MIN = -2147483648;
+export declare const SPICE_INT32_MAX = 2147483647;
+export type AssertSpiceInt32Options = {
+    /** If provided, enforce `value >= min`. */
+    min?: number;
+    /** If provided, enforce `value <= max`. */
+    max?: number;
+};
+/**
+ * Runtime validation for values that will cross the JS → native boundary as a
+ * CSPICE `SpiceInt`.
+ *
+ * What this checks:
+ * - `value` is a **safe integer** (no fractional values, no `NaN`, no `Infinity`).
+ * - `value` is within the **signed 32-bit** range.
+ * - Optional extra bounds (`opts.min` / `opts.max`).
+ *
+ * What this does *not* check:
+ * - That the value is valid for a specific CSPICE call (e.g. an index being in
+ *   range for a particular cell/window).
+ * - That the host platform's `SpiceInt` is 32-bit. (Many CSPICE builds use a
+ *   wider integer type.) We intentionally validate to 32-bit because:
+ *   - the Node addon reads numbers via `Int32Value()`, and
+ *   - the WASM backend consumes values as `i32`.
+ *
+ * If callers pass values outside the 32-bit range, JS → native conversion would
+ * otherwise wrap/truncate.
+ */
+export declare function assertSpiceInt32(value: number, label: string, opts?: AssertSpiceInt32Options): asserts value is number;
+/** Assert that a value is a non-negative signed 32-bit integer. */
+export declare function assertSpiceInt32NonNegative(value: number, label: string): asserts value is number;
+//# sourceMappingURL=spice-int.d.ts.map

package/backend-contract/dist/shared/spice-int.js

@@ -0,0 +1,41 @@
+export const SPICE_INT32_MIN = -0x80000000; // -2147483648
+export const SPICE_INT32_MAX = 0x7fffffff; //  2147483647
+/**
+ * Runtime validation for values that will cross the JS → native boundary as a
+ * CSPICE `SpiceInt`.
+ *
+ * What this checks:
+ * - `value` is a **safe integer** (no fractional values, no `NaN`, no `Infinity`).
+ * - `value` is within the **signed 32-bit** range.
+ * - Optional extra bounds (`opts.min` / `opts.max`).
+ *
+ * What this does *not* check:
+ * - That the value is valid for a specific CSPICE call (e.g. an index being in
+ *   range for a particular cell/window).
+ * - That the host platform's `SpiceInt` is 32-bit. (Many CSPICE builds use a
+ *   wider integer type.) We intentionally validate to 32-bit because:
+ *   - the Node addon reads numbers via `Int32Value()`, and
+ *   - the WASM backend consumes values as `i32`.
+ *
+ * If callers pass values outside the 32-bit range, JS → native conversion would
+ * otherwise wrap/truncate.
+ */
+export function assertSpiceInt32(value, label, opts = {}) {
+    if (!Number.isSafeInteger(value)) {
+        throw new TypeError(`${label} must be a safe integer`);
+    }
+    if (value < SPICE_INT32_MIN || value > SPICE_INT32_MAX) {
+        throw new RangeError(`${label} must be a 32-bit signed integer`);
+    }
+    if (opts.min !== undefined && value < opts.min) {
+        throw new RangeError(`${label} must be >= ${opts.min}`);
+    }
+    if (opts.max !== undefined && value > opts.max) {
+        throw new RangeError(`${label} must be <= ${opts.max}`);
+    }
+}
+/** Assert that a value is a non-negative signed 32-bit integer. */
+export function assertSpiceInt32NonNegative(value, label) {
+    assertSpiceInt32(value, label, { min: 0 });
+}
+//# sourceMappingURL=spice-int.js.map

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

@@ -2,22 +2,104 @@ export type KernelSource = string | {
     path: string;
     bytes: Uint8Array;
 };
+/**
+ * Virtual output reference used by writer APIs.
+ *
+ * Lifecycle:
+ * - A `VirtualOutput` is only guaranteed to be readable via `readVirtualOutput()`
+ *   **after** the writer handle has been closed (e.g. `spkcls(handle)` for SPKs).
+ * - Backends may reject reads for outputs they did not create via a writer API.
+ *   `readVirtualOutput()` is not intended to be a generic filesystem read.
+ *
+ * Backend notes:
+ * - WASM: `path` is treated as a *virtual* identifier under the backend's
+ *   virtual filesystem (currently rooted at `/kernels`).
+ * - Node: implementations may stage virtual outputs to a temp file and allow
+ *   reading bytes back via `readVirtualOutput()`.
+ */
+export type VirtualOutput = {
+    kind: "virtual-output";
+    path: string;
+};
 /** Kernel types used by summary/introspection APIs. */
-export type KernelKind = "ALL" | "SPK" | "CK" | "PCK" | "LSK" | "FK" | "IK" | "SCLK" | "EK" | "META";
+export type KernelKind = "ALL" | "SPK" | "CK" | "PCK" | "DSK" | "TEXT" | "LSK" | "FK" | "IK" | "SCLK" | "EK" | "META";
+/**
+ * Optional-return convention for lookups where "not found" is a normal outcome.
+ *
+ * Conventions:
+ * - Return `{ found: false }` when the underlying value simply doesn't exist
+ *   (e.g. name-to-code lookups for names that aren't present in loaded kernels).
+ * - Throw for invalid arguments, SPICE errors, and other exceptional failures.
+ * - When `found: true`, extra fields are present on the returned object.
+ */
 export type Found<T> = {
     found: false;
 } | ({
     found: true;
 } & T);
+/** Convenience alias for the most common Found payload shape. */
+export type FoundValue<T> = Found<{
+    value: T;
+}>;
+export type FoundString = FoundValue<string>;
+export type FoundInt = FoundValue<number>;
+export type FoundDouble = FoundValue<number>;
+/** Extract the payload type of a `Found<...>` result. */
+export type FoundPayload<T> = T extends Found<infer P> ? P : never;
 export type KernelData = {
     file: string;
     filtyp: string;
     source: string;
     handle: number;
 };
+/** Result payload for `kinfo()`. */
+export type KernelInfo = {
+    filtyp: string;
+    source: string;
+    handle: number;
+};
 /** SPICE aberration correction string accepted by `spkezr`/`spkpos`. */
 export type AbCorr = "NONE" | "LT" | "LT+S" | "CN" | "CN+S" | "XLT" | "XLT+S" | "XCN" | "XCN+S";
 export type SpiceVector3 = [number, number, number];
+/**
+ * A plane encoded as `[normalX, normalY, normalZ, constant]`.
+ *
+ * This matches CSPICE's `SpicePlane` ABI layout (`normal[3]` + `constant`).
+ */
+export type SpicePlane = [number, number, number, number];
+declare const __spiceHandleBrand: unique symbol;
+/** Opaque numeric handle returned by low-level SPICE file APIs (DAF/DAS/DLA). */
+export type SpiceHandle = number & {
+    readonly [__spiceHandleBrand]: true;
+};
+declare const __vec3Brand: unique symbol;
+export type Vec3 = readonly [number, number, number] & {
+    readonly [__vec3Brand]: true;
+};
+declare const __vec6Brand: unique symbol;
+export type Vec6 = readonly [number, number, number, number, number, number] & {
+    readonly [__vec6Brand]: true;
+};
+/**
+ * A string returned from (or destined for) a fixed-width output buffer of length `Max`.
+ *
+ * This is a **type-only** brand used for clarity/documentation. It does not perform any
+ * runtime validation, and it does not guarantee the string length.
+ */
+declare const __fixedStringMaxBrand: unique symbol;
+export type FixedString<Max extends number> = string & {
+    readonly [__fixedStringMaxBrand]: Max;
+};
+/**
+ * Result wrapper for APIs that return an array of strings.
+ *
+ * `truncated` is backend-dependent and should only be set to `true` when the backend can
+ * *detect* truncation (for example: when reading fixed-width output buffers).
+ */
+export interface StringArrayResult {
+    values: string[];
+    truncated: boolean;
+}
 /**
  * 3x3 matrix encoded as a length-9 array in **row-major** order.
  *
@@ -94,6 +176,15 @@ export type SpiceMatrix6x6 = [
     number,
     number
 ];
+/**
+ * 6x6 matrix encoded as a length-36 array in **row-major** order.
+ *
+ * Row-major layout: `[m00,m01,...,m05, m10,m11,...,m15, ..., m50,...,m55]`.
+ */
+declare const __mat6RowMajorBrand: unique symbol;
+export type Mat6RowMajor = Readonly<SpiceMatrix6x6> & {
+    readonly [__mat6RowMajorBrand]: true;
+};
 export type SpiceStateVector = [
     number,
     number,
@@ -130,5 +221,19 @@ export type IluminResult = {
     /** Emission angle at `spoint`, radians. */
     emissn: number;
 };
+/** Result payload for `illumg()`. */
+export type IllumgResult = IluminResult;
+/** Result payload for `illumf()`. */
+export type IllumfResult = IluminResult & {
+    /** True if `spoint` is visible to `obsrvr`. */
+    visibl: boolean;
+    /** True if `spoint` is lit by `ilusrc`. */
+    lit: boolean;
+};
+/** Result payload for `pl2nvc()`. */
+export type Pl2nvcResult = {
+    normal: SpiceVector3;
+    konst: number;
+};
 export {};
 //# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,54 @@
+import type { Vec3, Vec6 } from "./types.js";
+type FreezeMode = "never" | "dev" | "always";
+export type BrandVecOptions = {
+    /**
+     * Used for error messages (e.g. `"spkezr()"`).
+     *
+     * Defaults to `"Vec"`.
+     */
+    readonly label?: string;
+    /**
+     * If set, freeze branded values to prevent mutation at runtime.
+     *
+     * Defaults to `"dev"`.
+     */
+    readonly freeze?: FreezeMode;
+};
+/** Assert that a value is an array-like Vec3 (length 3) of finite numbers. */
+export declare function assertVec3ArrayLike3(value: unknown, options?: {
+    readonly label?: string;
+}): asserts value is ArrayLike<number>;
+/** Assert that a value is an array-like Vec6 (length 6) of finite numbers. */
+export declare function assertVec6ArrayLike6(value: unknown, options?: {
+    readonly label?: string;
+}): asserts value is ArrayLike<number>;
+/** Validate and brand a value as a {@link Vec3}. */
+export declare function brandVec3(value: unknown, options?: BrandVecOptions): Vec3;
+/** Validate and brand a value as a {@link Vec6}. */
+export declare function brandVec6(value: unknown, options?: BrandVecOptions): Vec6;
+/**
+ * Structural check: accepts number[] and numeric TypedArrays (excludes DataView).
+ *
+ * This does **not** assert/require that the value is branded as a `Vec3`.
+ */
+export declare function isVec3ArrayLike3(value: unknown): value is ArrayLike<number>;
+/**
+ * Structural check: accepts number[] and numeric TypedArrays (excludes DataView).
+ *
+ * This does **not** assert/require that the value is branded as a `Vec6`.
+ */
+export declare function isVec6ArrayLike6(value: unknown): value is ArrayLike<number>;
+/**
+ * Brand-only check: verifies that a value was produced by `brandVec3()`.
+ *
+ * Note: this intentionally rejects structurally-valid TypedArrays.
+ */
+export declare function isBrandedVec3(value: unknown): value is Vec3;
+/**
+ * Brand-only check: verifies that a value was produced by `brandVec6()`.
+ *
+ * Note: this intentionally rejects structurally-valid TypedArrays.
+ */
+export declare function isBrandedVec6(value: unknown): value is Vec6;
+export {};
+//# sourceMappingURL=vec.d.ts.map