tutuca 0.9.39 → 0.9.41

package/skill/immutable-js/references/map.md

@@ -0,0 +1,300 @@
+`Map` is an unordered keyed collection of (key, value) pairs with O(log32 N) gets and persistent sets, implemented as a hash-array mapped trie. Unlike the native `Map`, key equality is determined by `Immutable.is` (value equality), so any value — including `NaN` and other Immutable collections — may be used as a key. JavaScript objects used as keys still rely on strict identity. Use `OrderedMap` when iteration order must follow insertion order; it shares Map's full API but is slower and uses more memory.
+
+```ts
+import { Map, OrderedMap, List } from 'immutable';
+```
+
+## Construction
+
+### Map
+
+```ts
+Map<K, V>(collection?: Iterable<readonly [K, V]>): Map<K, V>
+Map<V>(obj: { [key: string]: V }): Map<string, V>
+Map<R extends { [key in PropertyKey]: unknown }>(obj: R): MapOf<R>
+```
+
+Factory function (no `new`). Accepts another keyed collection, an iterable of `[K, V]` tuples, or a plain object. When given an object literal, the inferred type is the precise `MapOf<R>` (per-key value types).
+
+```ts
+Map({ key: 'value' });
+Map([['key', 'value']]);
+```
+
+JS object keys are always strings; Immutable Map keys are not coerced:
+
+```ts
+const m = Map({ 1: 'one' });
+m.get('1'); // => "one"
+m.get(1);   // => undefined
+```
+
+### Map.isMap
+
+```ts
+Map.isMap(maybeMap: unknown): maybeMap is Map<unknown, unknown>
+```
+
+### Keys are compared by value
+
+Any Immutable collection may be used as a key; equality is structural.
+
+```ts
+Map().set(List([1, 2]), 'x').get(List([1, 2])); // => 'x'
+```
+
+## Reading
+
+### get / has / includes
+
+```ts
+get(key: K): V | undefined
+get<NSV>(key: K, notSetValue: NSV): V | NSV
+has(key: K): boolean
+includes(value: V): boolean // alias: contains
+```
+
+`includes` checks values using `Immutable.is`.
+
+### first / last
+
+```ts
+first(): V | undefined
+last(): V | undefined
+```
+
+### find / findKey / findEntry
+
+```ts
+find(predicate: (value: V, key: K, iter: this) => boolean, context?: unknown): V | undefined
+findKey(predicate: (value: V, key: K, iter: this) => boolean, context?: unknown): K | undefined
+findEntry(predicate: (value: V, key: K, iter: this) => boolean, context?: unknown): [K, V] | undefined
+```
+
+### keyOf / lastKeyOf
+
+```ts
+keyOf(searchValue: V): K | undefined
+lastKeyOf(searchValue: V): K | undefined
+```
+
+### size
+
+```ts
+readonly size: number
+```
+
+## Persistent changes
+
+### set
+
+```ts
+set(key: K, value: V): Map<K, V>
+```
+
+Replaces the value if the key already exists. Safe in `withMutations`.
+
+### delete (alias `remove`)
+
+```ts
+delete(key: K): Map<K, V>
+```
+
+### deleteAll (alias `removeAll`)
+
+```ts
+deleteAll(keys: Iterable<K>): this
+```
+
+### clear
+
+```ts
+clear(): Map<K, V>
+```
+
+### update
+
+```ts
+update<R>(updater: (value: this) => R): R
+update(key: K, updater: (value: V | undefined) => V | undefined): Map<K, V>
+update(key: K, notSetValue: V, updater: (value: V) => V): Map<K, V>
+```
+
+Equivalent to `map.set(key, updater(map.get(key)))`. If the updater returns the same value, the original Map is returned. The no-key form chains a function over the whole Map.
+
+```ts
+Map({ key: 'value' }).update('key', v => v + v); // => Map { "key": "valuevalue" }
+```
+
+### merge (alias `concat`) / mergeWith / mergeDeep / mergeDeepWith
+
+```ts
+merge(...collections): Map<K, V>
+mergeWith(merger: (oldVal, newVal, key) => unknown, ...collections): Map<K, V>
+mergeDeep(...collections): Map<K, V>
+mergeDeepWith(merger: (oldVal, newVal, key) => unknown, ...collections): Map<K, V>
+```
+
+Shallow merges (`merge`/`mergeWith`) overwrite per key; deep variants recurse into compatible collections (keyed-with-keyed, indexed-with-indexed, set-with-set). Indexed/set collections at matching keys are combined via `concat`/`union` rather than recursed. See `deep-updates.md` for examples and gotchas.
+
+## Deep persistent changes
+
+### setIn
+
+```ts
+setIn(keyPath: Iterable<unknown>, value: unknown): Map<K, V>
+```
+
+Creates intermediate Maps for missing keys. Throws if a path segment exists but cannot be updated (e.g. a primitive or non-collection object). Plain JS objects/arrays nested inside are updated immutably.
+
+### deleteIn (alias `removeIn`)
+
+```ts
+deleteIn(keyPath: Iterable<unknown>): Map<K, V>
+```
+
+### updateIn
+
+```ts
+updateIn(keyPath: Iterable<unknown>, notSetValue: unknown, updater: (value) => unknown): Map<K, V>
+updateIn(keyPath: Iterable<unknown>, updater: (value) => unknown): Map<K, V>
+```
+
+Returns the same Map if the updater returns the same value. Missing path segments are created as Maps.
+
+### mergeIn / mergeDeepIn
+
+```ts
+mergeIn(keyPath: Iterable<unknown>, ...collections: Array<unknown>): Map<K, V>
+mergeDeepIn(keyPath: Iterable<unknown>, ...collections: Array<unknown>): Map<K, V>
+```
+
+Equivalent to `updateIn(keyPath, x => x.merge(...))` and `updateIn(keyPath, x => x.mergeDeep(...))`. See `deep-updates.md`.
+
+## Sequence algorithms
+
+### map / mapKeys / mapEntries
+
+```ts
+map<M>(mapper: (value: V, key: K, iter: this) => M, context?: unknown): Map<K, M>
+mapKeys<M>(mapper: (key: K, value: V, iter: this) => M, context?: unknown): Map<M, V>
+mapEntries<KM, VM>(
+  mapper: (entry: [K, V], index: number, iter: this) => [KM, VM] | undefined,
+  context?: unknown
+): Map<KM, VM>
+```
+
+If `mapEntries` returns `undefined` for an entry, the entry is filtered out; it always returns a new instance.
+
+### flatMap
+
+```ts
+flatMap<KM, VM>(
+  mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
+  context?: unknown
+): Map<KM, VM>
+```
+
+### filter / filterNot
+
+```ts
+filter(predicate: (value: V, key: K, iter: this) => boolean, context?: unknown): Map<K, V>
+filterNot(predicate: (value: V, key: K, iter: this) => boolean, context?: unknown): this
+```
+
+### flip / reverse
+
+```ts
+flip(): Map<V, K>
+reverse(): this
+```
+
+### sort / sortBy
+
+```ts
+sort(comparator?: Comparator<V>): this & OrderedMap<K, V>
+sortBy<C>(
+  comparatorValueMapper: (value: V, key: K, iter: this) => C,
+  comparator?: (a: C, b: C) => number
+): OrderedMap<K, V>
+```
+
+Both produce an `OrderedMap` (sort imposes order). Eager.
+
+### groupBy
+
+```ts
+groupBy<G>(grouper: (value: V, key: K, iter: this) => G, context?: unknown): Map<G, this>
+```
+
+### partition
+
+```ts
+partition(predicate: (value: V, key: K, iter: this) => boolean, context?: unknown): [Map<K, V>, Map<K, V>]
+```
+
+### concat
+
+Alias for `merge` — see Persistent changes.
+
+## Conversion
+
+```ts
+toArray(): Array<V> | Array<[K, V]>
+toObject(): { [key: string]: V }                                    // shallow, string keys
+toJS(): { [key in PropertyKey]: DeepCopy<V> } | Array<DeepCopy<V>>  // deep, string keys
+toJSON(): { [key in PropertyKey]: V } | Array<V>                    // shallow, no child conversion
+toSeq(): Seq<K, V>
+toKeyedSeq(): Seq.Keyed<K, V>
+asMutable(): this
+asImmutable(): this
+```
+
+`asMutable` always returns `this`; do not use mutable copies for equality. See `conversions.md`.
+
+## Mutation batching
+
+### withMutations
+
+```ts
+withMutations(mutator: (mutable: this) => unknown): Map<K, V>
+```
+
+Applies a batch of mutations to a temporary mutable copy, producing a single new immutable Map. Only methods documented as safe in `withMutations` (most setters/updaters) may be used inside.
+
+```ts
+Map().withMutations(m => { m.set('a', 1).set('b', 2).set('c', 3); });
+```
+
+### wasAltered
+
+```ts
+wasAltered(): boolean
+```
+
+True if this is a mutable copy (`asMutable`) that has been mutated.
+
+## OrderedMap
+
+`OrderedMap` has the same API as `Map` but iterates in insertion order. Setting an existing key keeps its original position rather than moving it to the end. It is more expensive than `Map` (`set` is amortized O(log32 N) but not stable) and uses more memory.
+
+```ts
+OrderedMap<K, V>(collection?: Iterable<[K, V]>): OrderedMap<K, V>
+OrderedMap<V>(obj: { [key: string]: V }): OrderedMap<string, V>
+
+OrderedMap.isOrderedMap(maybeOrderedMap): maybeOrderedMap is OrderedMap<unknown, unknown>
+```
+
+```ts
+Map({ a: 1, c: 3, b: 2 });        // iteration order undefined (often a, b, c)
+OrderedMap({ a: 1, c: 3, b: 2 }); // iterates a, c, b
+```
+
+`sort` and `sortBy` on a `Map` always return an `OrderedMap`.
+
+## See also
+
+- `collection.md` — `Collection.Keyed` shared API (`reduce`, `every`, `some`, `count`, `slice`, etc.)
+- `deep-updates.md` — patterns for `setIn`/`updateIn`/`mergeDeep`
+- `conversions.md` — `toJS`/`toJSON`/`asMutable`/`asImmutable` semantics
+- `predicates.md` — `isMap`, `isOrderedMap`, `isKeyed`

package/skill/immutable-js/references/predicates.md

@@ -0,0 +1,93 @@
+All `is*()` helpers are exported directly from `immutable` and most are TypeScript type guards (return `value is List<T>` etc.), so they narrow types in branches. Reach for them when accepting unknown input — typical entry-point checks after `fromJS()`, in serialization boundaries, or when an API accepts both Immutable and plain JS values.
+
+```ts
+import { isList, isMap, isCollection, isImmutable } from 'immutable';
+
+function size(x: unknown): number {
+  if (isCollection(x) || isImmutable(x)) return x.size;
+  return 0;
+}
+
+function asEntries(x: unknown) {
+  if (isKeyed(x)) return x.entrySeq();      // [k, v] pairs
+  if (isIndexed(x)) return x.map((v, i) => [i, v]);
+  return Seq.Keyed();
+}
+```
+
+The concrete predicates are also re-exposed as static methods on their constructors (`List.isList`, `Map.isMap`, `Seq.isSeq`, etc.) — identical behavior, pick whichever reads better at the call site.
+
+## Concrete-type predicates
+
+- `isList(v): v is List<unknown>`
+- `isMap(v): v is Map<unknown, unknown>` — also `true` for `OrderedMap`. Use `isOrderedMap` to distinguish.
+- `isOrderedMap(v): v is OrderedMap<unknown, unknown>`
+- `isSet(v): v is Set<unknown>` — also `true` for `OrderedSet`. Use `isOrderedSet` to distinguish.
+- `isOrderedSet(v): v is OrderedSet<unknown>`
+- `isStack(v): v is Stack<unknown>`
+- `isRecord(v): v is Record<object>` — Records are not Collections; `isCollection(record)` is `false`.
+- `isSeq(v): v is Seq.Indexed | Seq.Keyed | Seq.Set` — true for any lazy `Seq` subtype. Also exposed as `Seq.isSeq`.
+
+```ts
+isMap(Map())          // true
+isMap(OrderedMap())   // true
+isOrderedMap(Map())   // false
+isOrderedMap(OrderedMap()) // true
+```
+
+## Shape predicates
+
+Describe the role a value plays in iteration rather than its concrete class.
+
+- `isCollection(v): v is Collection<unknown, unknown>` — true for any Immutable collection (`List`, `Map`, `Set`, `Stack`, `Seq`, etc.). False for `Record`.
+- `isKeyed(v): v is Collection.Keyed<unknown, unknown>` — true for keyed collections (`Map`, `OrderedMap`, `Record`, `Seq.Keyed`); they iterate as `[k, v]` entries.
+- `isIndexed(v): v is Collection.Indexed<unknown>` — true for ordered indexed collections (`List`, `Stack`, `Seq.Indexed`); iterate by integer index.
+- `isAssociative(v): v is Collection.Keyed | Collection.Indexed` — true if the collection supports `get(key)` lookup, i.e. keyed OR indexed (everything except `Set`/`OrderedSet`/`Seq.Set`).
+- `isOrdered(v): v is OrderedCollection<unknown>` — true if iteration order is stable (`List`, `Stack`, `OrderedMap`, `OrderedSet`, `Seq.Indexed`, etc.). False for unsorted `Map`/`Set`.
+
+## isImmutable
+
+- `isImmutable(v): v is Collection<unknown, unknown>`
+- True for any Immutable collection or `Record`. Effectively `isCollection(v) || isRecord(v)` — the one-stop check for "did this come from Immutable.js?". Still returns `true` mid-`withMutations()`.
+
+## Quick reference matrix
+
+```
+              isCollection isKeyed isIndexed isAssociative isOrdered isImmutable
+List               yes                 yes        yes         yes        yes
+Map                yes      yes                   yes                    yes
+OrderedMap         yes      yes                   yes         yes        yes
+Set                yes                                                   yes
+OrderedSet         yes                                        yes        yes
+Stack              yes                 yes        yes         yes        yes
+Record             no       yes                   yes                    yes
+Seq.Keyed          yes      yes                   yes                    yes
+Seq.Indexed        yes                 yes        yes         yes        yes
+Seq.Set            yes                                                   yes
+```
+
+Notes:
+- `isOrdered` is unrelated to `Seq.Keyed` ordering: a `Seq.Keyed` built from an array of pairs will not pass `isOrdered` — only `OrderedMap` does for keyed shapes.
+- `isCollection` is `false` for `Record` even though `isImmutable` is `true`.
+- All concrete `is*` predicates imply `isCollection` except `isRecord`.
+- `isMap`/`isSet` are union checks; prefer `isOrderedMap`/`isOrderedSet` when iteration order matters.
+
+## Common patterns
+
+```ts
+// Idempotent fromJS-style normalization
+const toMap = (v: unknown) => isMap(v) ? v : Map(v as any);
+
+// Generic deep walker that handles plain JS and Immutable inputs
+function walk(v: unknown, fn: (leaf: unknown) => void): void {
+  if (isKeyed(v))      v.forEach(child => walk(child, fn));
+  else if (isIndexed(v)) v.forEach(child => walk(child, fn));
+  else fn(v);
+}
+```
+
+## See also
+
+- `list.md`, `map.md`, `set.md`, `stack.md`, `record.md`, `seq.md`
+- `equality.md` — `is()` / `isValueObject()` for value equality
+- `conversions.md` — `fromJS()` / `toJS()` boundaries where these checks are most useful

package/skill/immutable-js/references/range-repeat.md

@@ -0,0 +1,55 @@
+`Range()` and `Repeat()` are factory functions (no `new`) that produce a lazy `Seq.Indexed`. They are cheap to construct, can represent infinite sequences, and compose with every `Seq` method (`map`, `filter`, `take`, `slice`, `concat`, `reduce`, ...). Nothing is computed until the sequence is iterated or materialized via `toArray`/`toList`/etc.
+
+## Range
+
+```ts
+Range(start?: number, end?: number, step?: number): Seq.Indexed<number>
+```
+
+- `start` defaults to `0` (inclusive).
+- `end` defaults to `Infinity` (exclusive). When `end` is `Infinity`, you MUST bound the sequence with `take()` / `takeWhile()` / `slice()` before materializing, or iteration will never terminate.
+- `step` defaults to `1`. May be negative to count down. When `start === end`, the range is empty.
+
+```js
+Range(0, 5).toArray(); // => [0, 1, 2, 3, 4]
+Range(10, 30, 5).toArray(); // => [10, 15, 20, 25]
+Range(30, 10, -5).toArray(); // => [30, 25, 20, 15]
+```
+
+## Repeat
+
+```ts
+Repeat<T>(value: T, times?: number): Seq.Indexed<T>
+```
+
+- `times` defaults to `Infinity`. Same rule as `Range`: bound infinite repeats with `take()`/`slice()` before materializing.
+- `value` is held by reference; `Repeat` does not clone it.
+
+```js
+Repeat('x', 3).toArray(); // => ['x', 'x', 'x']
+```
+
+## Common patterns
+
+```js
+// Squares of 0..9 as a List
+Range(0, 10).map(n => n * n).toList();
+// => List [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+// Concatenate two finite repeats
+Repeat('a', 3).concat(Repeat('b', 2)).toArray();
+// => ['a', 'a', 'a', 'b', 'b']
+
+// Bound an infinite Range with take()
+Range().filter(n => n % 7 === 0).take(5).toArray();
+// => [0, 7, 14, 21, 28]
+
+// Build a List directly from a Range
+List(Range(0, 5)); // => List [0, 1, 2, 3, 4]
+```
+
+## See also
+
+- `seq.md` — the underlying lazy `Seq.Indexed` API and laziness rules.
+- `list.md` — materializing into a `List` (e.g. `List(Range(0, 5))`).
+- `conversions.md` — `toArray`, `toList`, `toSet`, and other terminal operations.

package/skill/immutable-js/references/record.md

@@ -0,0 +1,196 @@
+`Record` creates a class-like factory with a known shape and a default value for each key. Instances are immutable, compare by value with `.equals()`, and expose direct property access (`record.foo`) in addition to `.get('foo')`. Use a Record when modeling a "thing with a known set of fields" rather than a free-form `Map`. Records always have a value for the keys they define; setting an unknown key throws, and `delete` resets the key to its default rather than removing it. Record instances are also `Map`-like via `getIn`/`setIn`, `toSeq`, and iteration over `[key, value]` pairs.
+
+## Defining a Record class
+
+`Record(defaultValues, name?)` returns a `Record.Factory`. The optional `name` is used in `toString()` output and error messages.
+
+```js
+import { Record } from 'immutable';
+
+const Point = Record({ x: 0, y: 0 }, 'Point');
+const p = Point({ x: 3 });
+p.x;          // 3 (direct property access)
+p.get('y');   // 0 (default)
+p.toString(); // 'Point { "x": 3, "y": 0 }'
+
+Point({ x: 1, z: 9 }).get('z'); // undefined — undeclared keys are ignored
+```
+
+A Record class can be subclassed to add methods (instances must then be created with `new`):
+
+```js
+class ABRecord extends Record({ a: 1, b: 2 }) {
+  getAB() { return this.a + this.b; }
+}
+new ABRecord({ b: 3 }).getAB(); // 4
+```
+
+## Record.Factory (the constructor)
+
+```ts
+Record.Factory<TProps>(values?: Partial<TProps>): RecordOf<TProps>
+```
+
+Calling the factory creates an instance; calling with no argument yields all defaults. The factory is `instanceof`-compatible with the instances it produces.
+
+```js
+const Point = Record({ x: 0, y: 0 }, 'Point');
+Point();                          // all defaults
+Point({ x: 3 }) instanceof Point; // true
+Point.displayName;                // 'Point'
+```
+
+### Record.isRecord
+```ts
+Record.isRecord(maybeRecord: unknown): boolean
+```
+True if the argument is any Record instance.
+
+### Record.getDescriptiveName
+```ts
+Record.getDescriptiveName(record: RecordOf<TProps>): string
+```
+Returns the `name` passed to `Record(values, name)`, or `"Record"` if none was provided.
+
+## Instance: Reading
+
+### get
+```ts
+get<K>(key: K): TProps[K]
+get<T>(key: string, notSetValue: T): T
+```
+Returns the value for `key`, or the declared default. Direct property access (`record.field`) reads the same value.
+
+### has
+```ts
+has(key: string): boolean
+```
+True when `key` is one of the declared fields.
+
+### hasIn / getIn
+```ts
+hasIn(keyPath: Iterable<unknown>): boolean
+getIn(keyPath: Iterable<unknown>): unknown
+```
+Deep lookup along a key path through nested collections.
+
+### equals
+```ts
+equals(other: unknown): boolean
+```
+Value equality: same Record factory and equal values for every declared key.
+
+### hashCode
+```ts
+hashCode(): number
+```
+Hash consistent with `equals`, suitable for use as a `Map` key or `Set` member.
+
+### toSeq
+```ts
+toSeq(): Seq.Keyed<keyof TProps, TProps[keyof TProps]>
+```
+Keyed Seq view of the record's fields. Records are also iterable as `[key, value]` pairs.
+
+### toJS / toJSON / toObject
+```ts
+toJS(): DeepCopy<TProps>   // deep, recursively converts nested Immutable values
+toJSON(): TProps           // shallow plain object
+toObject(): TProps         // shallow plain object
+```
+`toJS` may not be overridden; override `toJSON` for custom serialization.
+
+## Instance: Persistent changes
+
+All persistent updates return a new Record of the same type. Setting or deleting a key not in the defaults throws.
+
+### set
+```ts
+set<K>(key: K, value: TProps[K]): this
+```
+```js
+Point({ x: 3 }).set('y', 4); // Point { x: 3, y: 4 }
+```
+
+### delete (alias remove)
+```ts
+delete<K>(key: K): this
+```
+Resets the key to its declared default — does not remove it from the shape.
+
+### clear
+```ts
+clear(): this
+```
+Returns an instance with every field reset to its default.
+
+### update
+```ts
+update<K>(key: K, updater: (value: TProps[K]) => TProps[K]): this
+```
+
+### merge / mergeDeep / mergeWith / mergeDeepWith
+```ts
+merge(...collections: Array<Partial<TProps>>): this
+mergeDeep(...collections: Array<Partial<TProps>>): this
+mergeWith(merger, ...collections): this
+mergeDeepWith(merger, ...collections): this
+```
+`merge` shallowly applies provided fields; `mergeDeep` recurses into nested Immutable values. The `*With` variants resolve conflicts via the supplied merger.
+
+### setIn / deleteIn / updateIn / mergeIn / mergeDeepIn
+```ts
+setIn(keyPath, value): this
+deleteIn(keyPath): this        // alias removeIn
+updateIn(keyPath, updater): this
+mergeIn(keyPath, ...collections): this
+mergeDeepIn(keyPath, ...collections): this
+```
+Deep variants that follow `keyPath` into nested collections.
+
+### withMutations / asMutable / asImmutable / wasAltered
+```ts
+withMutations(mutator: (mutable: this) => unknown): this
+asMutable(): this
+asImmutable(): this
+wasAltered(): boolean
+```
+Transient batching, mirroring `Map`. Only `set` may be used mutatively inside `withMutations`.
+
+## TypeScript notes
+
+Use `RecordFactory<TProps>` for the factory type and `RecordOf<TProps>` for instances. `RecordOf<T>` is `Record<T> & Readonly<T>`, which is what enables typed property access.
+
+```ts
+import { Record, type RecordFactory, type RecordOf } from 'immutable';
+
+type Point3DProps = { x: number; y: number; z: number };
+const defaults: Point3DProps = { x: 0, y: 0, z: 0 };
+
+const makePoint3D: RecordFactory<Point3DProps> = Record(defaults);
+export type Point3D = RecordOf<Point3DProps>;
+const p: Point3D = makePoint3D({ x: 10, y: 20, z: 30 });
+```
+
+When subclassing, do **not** use `RecordFactory`; apply the props type when extending instead:
+
+```ts
+class Person extends Record({ name: 'Aristotle', age: 2400 })<{ name: string; age: number }> {
+  getName(): string { return this.get('name'); }
+}
+```
+
+## Gotchas
+
+- Defaults are fixed at factory creation. New keys cannot be added later — `set`/`delete` of an unknown key throws.
+- `delete(key)` resets to the default; it does not remove the field from the shape.
+- `clear()` returns the all-defaults instance, not an empty one.
+- Records from different factories are never `equals`, even when they hold the same values.
+- Direct assignment (`record.field = ...`) throws; use `set`. Property access (`record.field`) is unsupported on IE8 — fall back to `get('field')` if targeting it.
+- `toJS` is final and cannot be overridden; override `toJSON` for custom serialization.
+
+## See also
+
+- `map.md` — when keys are dynamic or the shape isn't known up front.
+- `equality.md` — how `equals`/`hashCode` interact with Record identity.
+- `predicates.md` — `isRecord` and related type guards.