ts-data-forge 14.6.3 → 14.7.0

package/README.md

@@ -126,6 +126,7 @@ Additional helpers for common programming tasks.
 
 - **Type Casting** - `castMutable`, `castReadonly`
 - **Utilities** - `memoizeFunction`, `mapNullable`, `unknownToString`
+- **Panics** - `PanicError`, `isPanicError`, `createPanicError`: the error a programming-error stop throws (the `panic` / `unreachable` / `todo` functions live in ts-std-forge). A panic is marked by a `$$panic` property rather than by the error `name`, so an error keeps its own identity while being recognized as a panic; the `Result` / `AsyncResult` boundary functions rethrow one instead of turning it into `Err`.
 - **Conditionals** - `ifThen` for conditional operations
 
 ## Usage Examples
@@ -627,7 +628,7 @@ assert.deepStrictEqual(updatedState.items, ['newItem1', 'newItem2']);
 - **`json`**: Type-safe JSON parsing and stringification utilities.
 - **`collections`**: Immutable data structures like `IMap`, `ISet`, and `Queue` with full type safety.
 - **`iterator`**: Utilities for working with iterators and generators (e.g., `range`).
-- **`others`**: Miscellaneous utilities like `castMutable`, `castReadonly`, `ifThen`, `mapNullable`, `memoizeFunction`, `tuple`, `unknownToString`.
+- **`others`**: Miscellaneous utilities like `castMutable`, `castReadonly`, `ifThen`, `mapNullable`, `memoizeFunction`, `PanicError` / `isPanicError` / `createPanicError`, `tuple`, `unknownToString`.
 
 ## Key Benefits
 

package/dist/array/impl/array-utils-modification.mjs

@@ -1,6 +1,6 @@
 import { asPositiveUint32 } from '../../number/index.mjs';
 
-import { create } from './array-utils-creation.mjs';
+import { copy, create } from './array-utils-creation.mjs';
 export function set(...args) {
     switch (args.length) {
         case 3:

package/dist/array/impl/array-utils-transformation.mjs

@@ -1,8 +1,8 @@
 import { IMap } from '../../collections/index.mjs';
 
-import { asUint32, Uint32 } from '../../number/index.mjs';
+import { asPositiveUint32, asUint32, Uint32 } from '../../number/index.mjs';
 import { tp } from '../../others/index.mjs';
-import { seq } from './array-utils-creation.mjs';
+import { newArray, seq } from './array-utils-creation.mjs';
 import { isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';
 import { size } from './array-utils-size.mjs';
 export function map(...args) {

package/dist/expect-type.d.mts

@@ -1,71 +1,3 @@
-import { type TypeEq, type TypeExtends } from 'ts-type-forge';
-/**
- * Compile-time type assertion utility for TypeScript type testing.
- *
- * This function performs static type relationship checking at compile-time and
- * has no runtime effect. It is primarily used in test files to verify that
- * TypeScript's type inference and type relationships work as expected. The
- * function will cause TypeScript compilation errors if the specified type
- * relationship does not hold.
- *
- * ## Supported Type Relations
- *
- * ### Equality Relations
- *
- * - **`"="` (strict equality)**: Asserts that types `A` and `B` are exactly the
- *   same type. Uses TypeScript's internal type equality checking.
- * - **`"!="` (strict inequality)**: Asserts that types `A` and `B` are not
- *   exactly the same type.
- *
- * ### Assignability Relations
- *
- * - **`"~="` (mutual assignability)**: Asserts that `A` extends `B` AND `B`
- *   extends `A`. Types are structurally equivalent and mutually assignable.
- * - **`"<="` (subtype relation)**: Asserts that type `A` extends (is assignable
- *   to) type `B`. Type `A` is a subtype of `B`.
- * - **`">="` (supertype relation)**: Asserts that type `B` extends (is assignable
- *   to) type `A`. Type `A` is a supertype of `B`.
- *
- * ### Negative Assignability Relations
- *
- * - **`"!<="` (not subtype)**: Asserts that type `A` does NOT extend type `B`.
- * - **`"!>="` (not supertype)**: Asserts that type `B` does NOT extend type `A`.
- *
- * ## Type Parameter Constraints
- *
- * @since 1.0.0
- * @template A - The first type for comparison. Can be any TypeScript type
- *   including:
- *
- *   - Primitive types (string, number, boolean, etc.)
- *   - Object types and interfaces
- *   - Union and intersection types
- *   - Generic types and type parameters
- *   - Literal types and branded types
- *   - Function types and return types
- *
- * @template B - The second type for comparison. Same constraints as type `A`.
- * @param _relation - A string literal representing the expected type
- *   relationship. TypeScript's type system automatically infers and restricts
- *   the available operators based on the actual relationship between types `A`
- *   and `B`. If an invalid relationship is specified, TypeScript will show a
- *   compilation error.
- *
- *   Combine `expectType` with runtime assertions for comprehensive testing:
- *
- *   ## Important Notes
- *
- *   - **Compile-time only**: This function has no runtime behavior and will be
- *       optimized away.
- *   - **Type inference**: The available relation operators are automatically
- *       inferred by TypeScript based on the actual type relationship between
- *       `A` and `B`.
- *   - **Error feedback**: Invalid type relationships will cause clear TypeScript
- *       compilation errors.
- *   - **Test organization**: Typically used in `.test.mts` files alongside runtime
- *       assertions.
- *   - **Performance**: Has zero runtime overhead as it's purely a compile-time
- *       construct.
- */
-export declare const expectType: <A, B>(_relation: TypeEq<A, B> extends true ? '<=' | '=' | '>=' | '~=' : '!=' | (TypeExtends<A, B> extends true ? '<=' | (TypeExtends<B, A> extends true ? '>=' | '~=' : '!>=') : '!<=' | (TypeExtends<B, A> extends true ? '>=' : '!>='))) => void;
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { expectType } from 'ts-std-forge';
 //# sourceMappingURL=expect-type.d.mts.map

package/dist/expect-type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"expect-type.d.mts","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,aAClB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GACtB,IAAI,GACJ,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAC7D,KAAK,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,KACjE,IAAiB,CAAC"}
+{"version":3,"file":"expect-type.d.mts","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/expect-type.mjs

@@ -1,70 +1,3 @@
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-export const expectType = (_relation) => undefined;
+export { expectType } from 'ts-std-forge';
 //# sourceMappingURL=expect-type.mjs.map

package/dist/expect-type.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"expect-type.mjs","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,SAKkE,EAC5D,EAAE,CAAC,SAAS,CAAC"}
+{"version":3,"file":"expect-type.mjs","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/functional/index.d.mts

@@ -1,7 +1,12 @@
-export * from './async-result/index.mjs';
-export * from './match.mjs';
-export * from './optional/index.mjs';
-export * from './pipe.mjs';
-export * from './result/index.mjs';
-export * from './ternary-result/index.mjs';
+/**
+ * The algebraic data type core. The implementation lives in ts-std-forge
+ * since Sumi D-49 reversed the dependency between the two packages; what
+ * remains here is the re-export that keeps `import { Result } from
+ * 'ts-data-forge'` working. Both names denote the same declarations, so a
+ * value built through either package is the same type to both.
+ *
+ * New code should import these from `ts-std-forge` directly.
+ */
+export { AsyncResult, Optional, Result, TernaryResult, match, pipe, } from 'ts-std-forge';
+export type { Err, None, Ok, Pipe, Some, TernaryErr, TernaryOk, TernaryWarn, UnknownOptional, UnknownResult, UnknownTernaryResult, } from 'ts-std-forge';
 //# sourceMappingURL=index.d.mts.map

package/dist/functional/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/functional/index.mts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/functional/index.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,WAAW,EACX,QAAQ,EACR,MAAM,EACN,aAAa,EACb,KAAK,EACL,IAAI,GACL,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,GAAG,EACH,IAAI,EACJ,EAAE,EACF,IAAI,EACJ,IAAI,EACJ,UAAU,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,aAAa,EACb,oBAAoB,GACrB,MAAM,cAAc,CAAC"}

package/dist/functional/index.mjs

@@ -1,7 +1,11 @@
-export * from './async-result/index.mjs';
-export * from './match.mjs';
-export * from './optional/index.mjs';
-export * from './pipe.mjs';
-export * from './result/index.mjs';
-export * from './ternary-result/index.mjs';
+
+
+
+
+
+
+
+
+
+export { AsyncResult, Optional, Result, TernaryResult, match, pipe, } from 'ts-std-forge';
 //# sourceMappingURL=index.mjs.map

package/dist/functional/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/functional/index.mts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/functional/index.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,WAAW,EACX,QAAQ,EACR,MAAM,EACN,aAAa,EACb,KAAK,EACL,IAAI,GACL,MAAM,cAAc,CAAC"}

package/dist/guard/has-key.d.mts

@@ -1,52 +1,3 @@
-import { type ReadonlyRecord, type UnknownRecord } from 'ts-type-forge';
-/**
- * Type guard function that checks if an object has a specific key as its own
- * property.
- *
- * This function uses `Object.hasOwn()` to check if the given object has the
- * specified key as its own property (not inherited). It acts as a type guard
- * that narrows the type of the object to guarantee the key exists, enabling
- * type-safe property access.
- *
- * **Type Narrowing Behavior:**
- *
- * - When the guard returns `true`, TypeScript narrows the object type to include
- *   the checked key
- * - For union types, only union members that contain the key are preserved
- * - The key's value type is preserved from the original object type when possible
- *
- * @example
- *
- * ```ts
- * const maybeUser: Readonly<{ id?: number; name?: string }> = {
- *   id: 42,
- * } as const;
- *
- * if (hasKey(maybeUser, 'id')) {
- *   // `maybeUser` is now known to have an `id` property.
- *   assert.isTrue(maybeUser.id === 42);
- * } else {
- *   assert.fail();
- * }
- * ```
- *
- * @template R - The type of the input object, must extend UnknownRecord
- * @template K - The type of the key to check for, must extend PropertyKey
- *   (string | number | symbol)
- * @param obj - The object to check for the presence of the key
- * @param key - The key to check for in the object
- * @returns `true` if the object has the specified key as its own property,
- *   `false` otherwise. When `true`, TypeScript narrows the object type to
- *   guarantee the key exists.
- * @see {@link keyIsIn} - Similar function that narrows the key type instead of the object type
- */
-export declare const hasKey: <const R extends UnknownRecord, const K extends PropertyKey>(obj: R, key: K) => obj is HasKeyReturnType<R, K>;
-/**
- * @internal
- * When R is a union type (including the case with only one element), if any element in the union
- * contains K as a key, returns a type that narrows the union to only those elements that contain K as a key.
- * If none of the elements in the union contain K as a key, returns `ReadonlyRecord<K, unknown>`.
- * The result is made readonly.
- */
-export type HasKeyReturnType<R extends UnknownRecord, K extends PropertyKey> = R extends R ? K extends keyof R ? string extends keyof R ? ReadonlyRecord<K, R[keyof R]> & R : number extends keyof R ? ReadonlyRecord<K, R[keyof R]> & R : symbol extends keyof R ? ReadonlyRecord<K, R[keyof R]> & R : R : never : never;
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { hasKey, type HasKeyReturnType } from 'ts-std-forge';
 //# sourceMappingURL=has-key.d.mts.map

package/dist/guard/has-key.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"has-key.d.mts","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,CAAC,CAAC,SAAS,aAAa,EAC7B,KAAK,CAAC,CAAC,SAAS,WAAW,OAEtB,CAAC,OACD,CAAC,KACL,GAAG,IAAI,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAA4B,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,aAAa,EACvB,CAAC,SAAS,WAAW,IACnB,CAAC,SAAS,CAAC,GACX,CAAC,SAAS,MAAM,CAAC,GACf,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,CAAC,GACP,KAAK,GACP,KAAK,CAAC"}
+{"version":3,"file":"has-key.d.mts","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,MAAM,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/guard/has-key.mjs

@@ -1,43 +1,3 @@
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-export const hasKey = (obj, key) => Object.hasOwn(obj, key);
+export { hasKey } from 'ts-std-forge';
 //# sourceMappingURL=has-key.mjs.map

package/dist/guard/has-key.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"has-key.mjs","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAIpB,GAAM,EACN,GAAM,EACyB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC"}
+{"version":3,"file":"has-key.mjs","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,MAAM,EAAyB,MAAM,cAAc,CAAC"}

package/dist/guard/is-non-null-object.d.mts

@@ -1,35 +1,3 @@
-/**
- * Type guard that checks if a value is a non-null object.
- *
- * This function checks if a value has type `"object"` according to the `typeof`
- * operator and is not `null`. This includes all object types such as plain
- * objects, arrays, dates, regular expressions, and other object instances, but
- * excludes functions.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `object`
- * - Excludes `null`, `undefined`, and all primitive types
- * - Excludes functions (they have `typeof` === `"function"`, not `"object"`)
- * - Includes arrays, dates, regex, and other object instances
- *
- * **Note:** This function returns `true` for arrays. If you need
- * record-oriented narrowing that excludes arrays, use `isRecord()` instead.
- *
- * @example
- *
- * ```ts
- * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;
- *
- * const objects = mixed.filter(isNonNullObject);
- *
- * assert.deepStrictEqual(objects, [{ id: 1 }]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is an object and not `null`, `false` otherwise. When
- *   `true`, TypeScript narrows the type to `object`.
- * @see {@link isRecord} - For record-oriented type narrowing (excludes arrays)
- */
-export declare const isNonNullObject: (u: unknown) => u is object;
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { isNonNullObject } from 'ts-std-forge';
 //# sourceMappingURL=is-non-null-object.d.mts.map

package/dist/guard/is-non-null-object.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null-object.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,eAAO,MAAM,eAAe,MAAO,OAAO,KAAG,CAAC,IAAI,MACb,CAAC"}
+{"version":3,"file":"is-non-null-object.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/guard/is-non-null-object.mjs

@@ -1,36 +1,3 @@
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-export const isNonNullObject = (u) => typeof u === 'object' && u !== null;
+export { isNonNullObject } from 'ts-std-forge';
 //# sourceMappingURL=is-non-null-object.mjs.map

package/dist/guard/is-non-null-object.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null-object.mjs","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,kEAAkE;AAClE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAU,EAAe,EAAE,CACzD,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,CAAC"}
+{"version":3,"file":"is-non-null-object.mjs","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/guard/is-record.d.mts

@@ -1,90 +1,3 @@
-import { type MutableRecord, type UnknownRecord } from 'ts-type-forge';
-/**
- * Type guard that checks if a value is a record — a non-null, non-array
- * object — and narrows it to `UnknownRecord` (= `ReadonlyRecord<string,
- * unknown>`).
- *
- * This function is designed to be combined with {@link hasKey} to probe
- * values of type `unknown` (e.g. parsed JSON, caught errors, external data)
- * in a type-safe way: `if (isRecord(u) && hasKey(u, 'some-key')) { ... }`.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `UnknownRecord` (= `ReadonlyRecord<string, unknown>`)
- * - Excludes `null`, `undefined`, primitives, and functions
- * - Excludes arrays: arrays have no string index signature, so they are not
- *   assignable to `UnknownRecord`; admitting them at runtime would be
- *   inconsistent with the narrowed type
- * - Returns `true` for every other non-null object, including dictionary
- *   objects created with `Object.create(null)` and instances such as `Date`,
- *   `RegExp`, `Map`, `Set`, `Error`, and user-defined classes
- *
- * **Why non-plain objects are included:** since every property of
- * `UnknownRecord` is typed `unknown`, reading properties from any object
- * through this narrowing is type-safe, and `hasKey` (backed by
- * `Object.hasOwn`) answers own-property questions correctly on any object
- * (e.g. `Map` entries are not own properties, so `hasKey` correctly returns
- * `false` for them). Restricting the guard to plain objects would require
- * prototype checks that misjudge cross-realm objects and would prevent
- * probing useful instances such as `Error` subclasses.
- *
- * **Implementation:** `isNonNullObject(u) && !Array.isArray(u)`.
- *
- * @example
- *
- * ```ts
- * const entries: readonly unknown[] = [
- *   { id: 1 },
- *   [1, 2],
- *   'str',
- *   0,
- *   null,
- * ] as const;
- *
- * const records = entries.filter(isRecord);
- *
- * assert.deepStrictEqual(records, [{ id: 1 }]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `UnknownRecord`.
- * @see {@link isNonNullObject} - For checking any non-null object (includes arrays)
- * @see {@link hasKey} - For checking if a record has specific keys
- */
-export declare const isRecord: (u: unknown) => u is UnknownRecord;
-/**
- * Type guard that checks if a value is a mutable record.
- *
- * This function has the same runtime behavior as {@link isRecord} (non-null,
- * non-array object check), but narrows the type to `MutableRecord<string,
- * unknown>`, which is useful when you need to add or overwrite properties on
- * the narrowed object.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `MutableRecord<string, unknown>`
- * - Excludes `null`, `undefined`, primitives, functions, and arrays
- * - Returns `true` for every other non-null object (see {@link isRecord} for
- *   details on non-plain objects such as `Date`, `Map`, and `Set`)
- *
- * **Implementation:** This is a type alias for {@link isRecord}.
- *
- * @example
- *
- * ```ts
- * const obj: unknown = { foo: 1 } as const;
- *
- * if (isMutableRecord(obj)) {
- *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record
- * }
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `MutableRecord<string,
- *   unknown>`.
- * @see {@link isRecord} - For the underlying implementation and more details
- */
-export declare const isMutableRecord: (u: unknown) => u is MutableRecord<string, unknown>;
+/** Implemented in ts-std-forge since Sumi D-49; re-exported here. */
+export { isMutableRecord, isRecord } from 'ts-std-forge';
 //# sourceMappingURL=is-record.d.mts.map

package/dist/guard/is-record.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-record.d.mts","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,QAAQ,MAAO,OAAO,KAAG,CAAC,IAAI,aACF,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,eAAe,EAAE,CAC5B,CAAC,EAAE,OAAO,KACP,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,OAAO,CAAY,CAAC"}
+{"version":3,"file":"is-record.d.mts","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC"}

package/dist/guard/is-record.mjs

@@ -1,90 +1,3 @@
-import { isNonNullObject } from './is-non-null-object.mjs';
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-export const isRecord = (u) => isNonNullObject(u) && !Array.isArray(u);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-export const isMutableRecord = isRecord;
+export { isMutableRecord, isRecord } from 'ts-std-forge';
 //# sourceMappingURL=is-record.mjs.map

package/dist/guard/is-record.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-record.mjs","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAsB,EAAE,CACzD,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,eAAe,GAEe,QAAQ,CAAC"}
+{"version":3,"file":"is-record.mjs","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC"}