lib0 1.0.0-rc.34 → 1.0.0-rc.36

package/dist/delta/delta.d.ts

@@ -58,7 +58,7 @@ export const $attribution: s.Schema<Attribution>;
  * @typedef {{ type: 'insert', value: any, attribution?: Attribution } | { type: 'delete', attribution?: Attribution } | { type: 'modify', value: DeltaJSON, attribution?: Attribution|null }} DeltaAttrOpJSON
  */
 /**
- * @typedef {TextOp|InsertOp<any>|DeleteOp|RetainOp|ModifyOp<any>} ChildrenOpAny
+ * @typedef {TextOp|InsertOp<any>|DeleteOp<any>|RetainOp|ModifyOp<any>} ChildrenOpAny
  */
 /**
  * @typedef {SetAttrOp<any>|DeleteAttrOp<any>|ModifyAttrOp} AttrOpAny
@@ -249,14 +249,14 @@ export class DeleteOp<Conf extends DeltaConf = {}> extends list.ListNode {
      * @param {number} [end]
      * @param {boolean} [_markAsDone] accepted for a uniform children-op `clone` signature; ignored (a
      * delete holds no nested content).
-     * @return {DeleteOp}
+     * @return {DeleteOp<any>}
      */
-    clone(start?: number, end?: number, _markAsDone?: boolean): DeleteOp;
+    clone(start?: number, end?: number, _markAsDone?: boolean): DeleteOp<any>;
     $type: s.Schema<DeleteOp<any>>;
     /**
-     * @param {DeleteOp} other
+     * @param {DeleteOp<any>} other
      */
-    [equalityTrait.EqualityTraitSymbol](other: DeleteOp): boolean;
+    [equalityTrait.EqualityTraitSymbol](other: DeleteOp<any>): boolean;
 }
 /**
  * @internal not part of the consumer API — a content op; build deltas via {@link create}/{@link DeltaBuilder}.
@@ -321,10 +321,10 @@ export class RetainOp extends list.ListNode {
 /**
  * Delta that can be applied on a YType Embed
  *
- * @template {Delta} [DTypes=DeltaAny]
+ * @template {Delta<any>} [DTypes=DeltaAny]
  * @internal not part of the consumer API — a content op; build deltas via {@link create}/{@link DeltaBuilder}.
  */
-export class ModifyOp<DTypes extends Delta = DeltaAny> extends list.ListNode {
+export class ModifyOp<DTypes extends Delta<any> = DeltaAny> extends list.ListNode {
     /**
      * @param {DTypes} delta
      * @param {Formats|null|undefined} format tri-state: `undefined` skip / `null` clear / object merge
@@ -530,9 +530,9 @@ export class ModifyAttrOp<Modifier extends DeltaAny = DeltaAny, K extends string
     get type(): "modify";
     get fingerprint(): string;
     /**
-     * @return {DeltaBuilder}
+     * @return {DeltaBuilder<any>}
      */
-    get _modValue(): DeltaBuilder;
+    get _modValue(): DeltaBuilder<any>;
     /**
      * @return {DeltaAttrOpJSON}
      */
@@ -737,13 +737,13 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
         text: true;
     })>, FixedConf>;
     /**
-     * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta|DeltaData<any,any,any,any>|DeltaBuilder>} NewContent
+     * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta<any>|DeltaData<any,any,any,any>|DeltaBuilder<any>>} NewContent
      * @param {NewContent} modify
      * @param {Formats?} [formatting] tri-state: omit/`undefined` skip, `null` clear, `{k:v}`/`{k:null}` set/remove
      * @param {Attribution?} [attribution] tri-state: omit/`undefined` skip, `null` clear, `{k:v}`/`{k:null}` set/remove
      * @return {DeltaBuilder<DeltaConfOverwrite<Conf, {children: DeltaConfGetChildren<Conf>|NewContent}>, FixedConf>}
      */
-    modify<NewContent extends Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>, Delta | DeltaData<any, any, any, any> | DeltaBuilder>>(modify: NewContent, formatting?: Formats | null, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
+    modify<NewContent extends Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>, Delta<any> | DeltaData<any, any, any, any> | DeltaBuilder<any>>>(modify: NewContent, formatting?: Formats | null, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
         children: DeltaConfGetChildren<Conf> | NewContent;
     }>, FixedConf>;
     /**
@@ -1009,45 +1009,35 @@ export function create<NodeName extends string | null, Attrs extends {
     [k: string | number]: any;
 } | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, children?: Children | undefined): DeltaBuilder<CondensedDeltaConf<NodeName, Attrs, Children>>;
 /**
- * @template {string|null} NodeName
- * @template {Array<any>|string} [Children=never]
- * @overload
- * @param {NodeName} nodeName
- * @param {...Array<Children>} children
- * @return {DeltaBuilder<CondensedDeltaConf<NodeName,null,Children>>}
- */
-export function from<NodeName extends string | null, Children extends Array<any> | string = never>(nodeName: NodeName, ...children: Array<Children>[]): DeltaBuilder<CondensedDeltaConf<NodeName, null, Children>>;
-/**
- * @template {Array<any>|string} [Children=never]
- * @overload
- * @param {...Array<Children>} children
- * @return {DeltaBuilder<CondensedDeltaConf<null,null,Children>>}
- */
-export function from<Children extends Array<any> | string = never>(...children: Array<Children>[]): DeltaBuilder<CondensedDeltaConf<null, null, Children>>;
-/**
- * @template {{[k:string|number]:any}|null} Attrs
- * @template {Array<any>|string} [Children=never]
- * @overload
- * @param {Attrs} attrs
- * @param {...Array<Children>} children
- * @return {DeltaBuilder<CondensedDeltaConf<null,Attrs,Children>>}
- */
-export function from<Attrs extends {
-    [k: string | number]: any;
-} | null, Children extends Array<any> | string = never>(attrs: Attrs, ...children: Array<Children>[]): DeltaBuilder<CondensedDeltaConf<null, Attrs, Children>>;
-/**
- * @template {string|null} NodeName
- * @template {{[k:string|number]:any}|null} Attrs
- * @template {Array<any>|string} [Children=never]
- * @overload
- * @param {NodeName} nodeName
- * @param {Attrs} attrs
- * @param {...Array<Children>} children
- * @return {DeltaBuilder<CondensedDeltaConf<NodeName,Attrs,Children>>}
- */
-export function from<NodeName extends string | null, Attrs extends {
-    [k: string | number]: any;
-} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, ...children: Array<Children>[]): DeltaBuilder<CondensedDeltaConf<NodeName, Attrs, Children>>;
+ * Build a delta from positional args: an optional node name, optional attrs, then any number of
+ * children (each either a string or an array of embeds) - see {@link create} for the fixed-arity
+ * condensed form.
+ *
+ * Typed as a set of call signatures instead of `@overload` tags, because a rest parameter can't be
+ * declared consistently in an `@overload` tag: the checker only turns `@param {...X} children`
+ * into `X[]` if the implementation's rest parameter has the same name, otherwise it takes `X` as
+ * the type of the whole rest array - while the declaration emit always writes `...children: X[]`.
+ * lib0's source check and the consumers of the emitted declarations hence saw different
+ * signatures. `Children` is the tuple of all children arguments, so that string and array children
+ * can be mixed (`Children[number]` is the union of them).
+ *
+ * @type {{
+ *   <NodeName extends string|null, Children extends Array<Array<any>|string> = []>(nodeName: NodeName, ...children: Children): DeltaBuilder<CondensedDeltaConf<NodeName,null,Children[number]>>,
+ *   <Children extends Array<Array<any>|string> = []>(...children: Children): DeltaBuilder<CondensedDeltaConf<null,null,Children[number]>>,
+ *   <Attrs extends {[k:string|number]:any}|null, Children extends Array<Array<any>|string> = []>(attrs: Attrs, ...children: Children): DeltaBuilder<CondensedDeltaConf<null,Attrs,Children[number]>>,
+ *   <NodeName extends string|null, Attrs extends {[k:string|number]:any}|null, Children extends Array<Array<any>|string> = []>(nodeName: NodeName, attrs: Attrs, ...children: Children): DeltaBuilder<CondensedDeltaConf<NodeName,Attrs,Children[number]>>
+ * }}
+ */
+export const from: {
+    <NodeName_1 extends string | null, Children_1 extends Array<Array<any> | string> = []>(nodeName: NodeName_1, ...children: Children_1): DeltaBuilder<CondensedDeltaConf<NodeName_1, null, Children_1[number]>>;
+    <Children_1 extends Array<Array<any> | string> = []>(...children: Children_1): DeltaBuilder<CondensedDeltaConf<null, null, Children_1[number]>>;
+    <Attrs_1 extends {
+        [k: string | number]: any;
+    } | null, Children_1 extends Array<Array<any> | string> = []>(attrs: Attrs_1, ...children: Children_1): DeltaBuilder<CondensedDeltaConf<null, Attrs_1, Children_1[number]>>;
+    <NodeName_1 extends string | null, Attrs_1 extends {
+        [k: string | number]: any;
+    } | null, Children_1 extends Array<Array<any> | string> = []>(nodeName: NodeName_1, attrs: Attrs_1, ...children: Children_1): DeltaBuilder<CondensedDeltaConf<NodeName_1, Attrs_1, Children_1[number]>>;
+};
 /**
  * Shorthand for `delta.create().insert(..)` — see {@link DeltaBuilder#insert}.
  *
@@ -1222,7 +1212,7 @@ export type DeltaAttrOpJSON = {
     value: DeltaJSON;
     attribution?: Attribution | null;
 };
-export type ChildrenOpAny = TextOp | InsertOp<any> | DeleteOp | RetainOp | ModifyOp<any>;
+export type ChildrenOpAny = TextOp | InsertOp<any> | DeleteOp<any> | RetainOp | ModifyOp<any>;
 export type AttrOpAny = SetAttrOp<any> | DeleteAttrOp<any> | ModifyAttrOp;
 export type _OpAny = ChildrenOpAny | AttrOpAny;
 export type AddToAttrs<Attrs_1 extends { [Key in string | number]: any; }, Key extends string | number, Val extends unknown> = { [K in (Key | keyof Attrs_1)]: (unknown extends Attrs_1[K] ? never : Attrs_1[K]) | (Key extends K ? Val : never); } & {};
@@ -1574,20 +1564,20 @@ declare class DeltaData<Name extends string, Attrs extends { [K in string | numb
     name: Name;
     $schema: s.Schema<Delta<any>> | null;
     /**
-     * @type {{ [K in keyof Attrs]?: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Attrs[K] extends Delta ? ModifyAttrOp<Extract<Attrs[K],Delta>,K> : never))) : never }
-     *       & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Delta extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K],Delta>,K> : never))) : never }[keyof Attrs]> }
+     * @type {{ [K in keyof Attrs]?: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Delta<any> extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K],Delta<any>>,K> : never))) : never }
+     *       & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Delta<any> extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K],Delta<any>>,K> : never))) : never }[keyof Attrs]> }
      * }
      */
-    attrs: { [K in keyof Attrs]?: K extends string | number ? (SetAttrOp<Attrs[K], K> | DeleteAttrOp<Attrs[K], K> | (Attrs[K] extends never ? never : (Attrs[K] extends Delta ? ModifyAttrOp<Extract<Attrs[K], Delta>, K> : never))) : never; } & {
-        [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string | number ? (SetAttrOp<Attrs[K], K> | DeleteAttrOp<Attrs[K], K> | (Attrs[K] extends never ? never : (Delta extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K], Delta>, K> : never))) : never; }[keyof Attrs]>;
+    attrs: { [K in keyof Attrs]?: K extends string | number ? (SetAttrOp<Attrs[K], K> | DeleteAttrOp<Attrs[K], K> | (Attrs[K] extends never ? never : (Delta<any> extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K], Delta<any>>, K> : never))) : never; } & {
+        [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string | number ? (SetAttrOp<Attrs[K], K> | DeleteAttrOp<Attrs[K], K> | (Attrs[K] extends never ? never : (Delta<any> extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K], Delta<any>>, K> : never))) : never; }[keyof Attrs]>;
     };
     /**
      * @type {list.List<
      *   | (Text extends true ? (RetainOp|TextOp|DeleteOp<any>) : never)
-     *   | (RetainOp|InsertOp<Children>|DeleteOp<any>|(Delta extends Children ? ModifyOp<Extract<Children,Delta>> : never))
+     *   | (RetainOp|InsertOp<Children>|DeleteOp<any>|(Delta<any> extends Children ? ModifyOp<Extract<Children,Delta<any>>> : never))
      * >}
      */
-    children: list.List<(Text extends true ? (RetainOp | TextOp | DeleteOp<any>) : never) | (RetainOp | InsertOp<Children> | DeleteOp<any> | (Delta extends Children ? ModifyOp<Extract<Children, Delta>> : never))>;
+    children: list.List<(Text extends true ? (RetainOp | TextOp | DeleteOp<any>) : never) | (RetainOp | InsertOp<Children> | DeleteOp<any> | (Delta<any> extends Children ? ModifyOp<Extract<Children, Delta<any>>> : never))>;
     /**
      * All child-ops sizes combined. Note that delete-ops also have a length
      */

package/dist/number.d.ts

@@ -4,6 +4,7 @@ export const LOWEST_INT32: number;
 export const HIGHEST_INT32: 2147483647;
 export const HIGHEST_UINT32: 4294967295;
 export const isInteger: (number: unknown) => boolean;
+export const isSafeInteger: (number: unknown) => boolean;
 export const isNaN: (number: unknown) => boolean;
 export const parseInt: (string: string, radix?: number) => number;
 export function countBits(n: number): number;

package/dist/schema.d.ts

@@ -480,17 +480,26 @@ export const $$symbol: Schema<Schema<Symbol>>;
 export const $number: Schema<number>;
 export const $$number: Schema<Schema<number>>;
 /**
- * A number without fractional component (`Number.isInteger`). The unwrapped type is still
- * `number` - JS has no separate integer type.
+ * A number without fractional component in the safe integer range (`Number.isSafeInteger`,
+ * i.e. `|n| <= 2^53 - 1`). The unwrapped type is still `number` - JS has no separate integer type.
+ *
+ * The range restriction guarantees that every `$int` is exactly representable as a 64-bit
+ * signed integer (`BigInt(n)` is lossless, databases can store it in an `int64` / `BIGINT` column).
+ * Values like `1e20` are integers to `Number.isInteger`, but they are neither exact (every float
+ * beyond 2^53 rounds to a multiple of a power of two) nor storable in 64 bits, so they are
+ * rejected. Use `$number` for unbounded floats and `$bigint` for arbitrary-precision integers.
  *
  * @type {Schema<number>}
  */
 export const $int: Schema<number>;
 export const $$int: Schema<Schema<number>>;
 /**
- * An unsigned integer: a number without fractional component that is `>= 0`. The unwrapped type is
+ * An unsigned integer: a `$int` that is `>= 0` (so `0 <= n <= 2^53 - 1`). The unwrapped type is
  * still `number` - JS has no separate integer type.
  *
+ * Like `$int`, every `$uint` is exactly representable as a 64-bit integer (signed or unsigned).
+ * See `$int` for why the range is restricted.
+ *
  * @type {Schema<number>}
  */
 export const $uint: Schema<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.34",
+  "version": "1.0.0-rc.36",
   "description": "isomorphic utility functions",
   "sideEffects": false,
   "type": "module",
@@ -341,7 +341,7 @@
   "scripts": {
     "clean": "rm -rf dist",
     "types": "rm -rf dist && tsc -p tsconfig.build.json",
-    "check-dist-types": "tsc -p tsconfig.dist-check.json",
+    "check-dist-types": "node ./dist-check/copy-tests.js && tsc -p tsconfig.dist-check.json",
     "dist": "npm run clean && npm run types && npm run check-dist-types",
     "debug": "npm run gentesthtml && node ./src/bin/0serve.js -o test.html",
     "test": "c8 --check-coverage --lines 97 --branches 96 --functions 94 --statements 97 node --unhandled-rejections=strict ./src/test.js",

package/src/delta/delta.js

@@ -116,7 +116,7 @@ export const $attribution = /* @__PURE__ */(() => s.$object({
  */
 
 /**
- * @typedef {TextOp|InsertOp<any>|DeleteOp|RetainOp|ModifyOp<any>} ChildrenOpAny
+ * @typedef {TextOp|InsertOp<any>|DeleteOp<any>|RetainOp|ModifyOp<any>} ChildrenOpAny
  */
 
 /**
@@ -635,7 +635,7 @@ export class DeleteOp extends list.ListNode {
   }
 
   /**
-   * @param {DeleteOp} other
+   * @param {DeleteOp<any>} other
    */
   [equalityTrait.EqualityTraitSymbol] (other) {
     return $deleteOp.check(other) && this.delete === other.delete
@@ -646,7 +646,7 @@ export class DeleteOp extends list.ListNode {
    * @param {number} [end]
    * @param {boolean} [_markAsDone] accepted for a uniform children-op `clone` signature; ignored (a
    * delete holds no nested content).
-   * @return {DeleteOp}
+   * @return {DeleteOp<any>}
    */
   clone (start = 0, end = this.delete, _markAsDone = true) {
     const cpy = new DeleteOp(end - start)
@@ -758,7 +758,7 @@ export class RetainOp extends list.ListNode {
 /**
  * Delta that can be applied on a YType Embed
  *
- * @template {Delta} [DTypes=DeltaAny]
+ * @template {Delta<any>} [DTypes=DeltaAny]
  * @internal not part of the consumer API — a content op; build deltas via {@link create}/{@link DeltaBuilder}.
  */
 export class ModifyOp extends list.ListNode {
@@ -1088,7 +1088,7 @@ export class ModifyAttrOp {
   }
 
   /**
-   * @return {DeltaBuilder}
+   * @return {DeltaBuilder<any>}
    */
   get _modValue () {
     return modValue(this)
@@ -1403,8 +1403,8 @@ class DeltaData {
     this.name = /** @type {Name} */ (name)
     this.$schema = $schema
     /**
-     * @type {{ [K in keyof Attrs]?: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Attrs[K] extends Delta ? ModifyAttrOp<Extract<Attrs[K],Delta>,K> : never))) : never }
-     *       & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Delta extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K],Delta>,K> : never))) : never }[keyof Attrs]> }
+     * @type {{ [K in keyof Attrs]?: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Delta<any> extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K],Delta<any>>,K> : never))) : never }
+     *       & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Delta<any> extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K],Delta<any>>,K> : never))) : never }[keyof Attrs]> }
      * }
      */
     this.attrs = /** @type {any} */ ({
@@ -1418,7 +1418,7 @@ class DeltaData {
     /**
      * @type {list.List<
      *   | (Text extends true ? (RetainOp|TextOp|DeleteOp<any>) : never)
-     *   | (RetainOp|InsertOp<Children>|DeleteOp<any>|(Delta extends Children ? ModifyOp<Extract<Children,Delta>> : never))
+     *   | (RetainOp|InsertOp<Children>|DeleteOp<any>|(Delta<any> extends Children ? ModifyOp<Extract<Children,Delta<any>>> : never))
      * >}
      */
     this.children = /** @type {any} */ (list.create())
@@ -2239,7 +2239,7 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta|DeltaData<any,any,any,any>|DeltaBuilder>} NewContent
+   * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta<any>|DeltaData<any,any,any,any>|DeltaBuilder<any>>} NewContent
    * @param {NewContent} modify
    * @param {Formats?} [formatting] tri-state: omit/`undefined` skip, `null` clear, `{k:v}`/`{k:null}` set/remove
    * @param {Attribution?} [attribution] tri-state: omit/`undefined` skip, `null` clear, `{k:v}`/`{k:null}` set/remove
@@ -3926,58 +3926,48 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
 }
 
 /**
- * @template {string|null} NodeName
- * @template {Array<any>|string} [Children=never]
- * @overload
- * @param {NodeName} nodeName
- * @param {...Array<Children>} children
- * @return {DeltaBuilder<CondensedDeltaConf<NodeName,null,Children>>}
- */
-/**
- * @template {Array<any>|string} [Children=never]
- * @overload
- * @param {...Array<Children>} children
- * @return {DeltaBuilder<CondensedDeltaConf<null,null,Children>>}
- */
-/**
- * @template {{[k:string|number]:any}|null} Attrs
- * @template {Array<any>|string} [Children=never]
- * @overload
- * @param {Attrs} attrs
- * @param {...Array<Children>} children
- * @return {DeltaBuilder<CondensedDeltaConf<null,Attrs,Children>>}
- */
-/**
- * @template {string|null} NodeName
- * @template {{[k:string|number]:any}|null} Attrs
- * @template {Array<any>|string} [Children=never]
- * @overload
- * @param {NodeName} nodeName
- * @param {Attrs} attrs
- * @param {...Array<Children>} children
- * @return {DeltaBuilder<CondensedDeltaConf<NodeName,Attrs,Children>>}
- */
-/**
- * `...X` (not `Array<X>`) is the rest-parameter form — `@param {Array<X>} args` declares a single
- * array-typed parameter, which makes the overloads above incompatible with this signature. TS only
- * cross-checks overloads against the implementation for function declarations, so it stayed silent.
+ * Returns `any` because the resulting conf is computed by the call signatures of {@link from} at
+ * the type level only - as in a ts overload implementation, the body can't be checked against
+ * each of them.
  *
- * @param {...(string|null|{[K:string|number]:any}|Array<any>)} args
- * @return {DeltaBuilder<{}>}
+ * @param {...any} args
+ * @return {any}
  */
-export const from = (...args) => {
+const _from = (...args) => {
   const hasName = s.$string.check(args[0])
   let i = hasName ? 1 : 0
   const d = create(hasName ? /** @type {string} */ (args[0]) : null)
   if (s.$objectAny.check(args[i])) {
-    d.setAttrs(/** @type {any} */ (args[i++]))
+    d.setAttrs(args[i++])
   }
   for (; i < args.length; i++) {
-    d.insert(/** @type {any} */ (args[i]))
+    d.insert(args[i])
   }
   return d
 }
 
+/**
+ * Build a delta from positional args: an optional node name, optional attrs, then any number of
+ * children (each either a string or an array of embeds) - see {@link create} for the fixed-arity
+ * condensed form.
+ *
+ * Typed as a set of call signatures instead of `@overload` tags, because a rest parameter can't be
+ * declared consistently in an `@overload` tag: the checker only turns `@param {...X} children`
+ * into `X[]` if the implementation's rest parameter has the same name, otherwise it takes `X` as
+ * the type of the whole rest array - while the declaration emit always writes `...children: X[]`.
+ * lib0's source check and the consumers of the emitted declarations hence saw different
+ * signatures. `Children` is the tuple of all children arguments, so that string and array children
+ * can be mixed (`Children[number]` is the union of them).
+ *
+ * @type {{
+ *   <NodeName extends string|null, Children extends Array<Array<any>|string> = []>(nodeName: NodeName, ...children: Children): DeltaBuilder<CondensedDeltaConf<NodeName,null,Children[number]>>,
+ *   <Children extends Array<Array<any>|string> = []>(...children: Children): DeltaBuilder<CondensedDeltaConf<null,null,Children[number]>>,
+ *   <Attrs extends {[k:string|number]:any}|null, Children extends Array<Array<any>|string> = []>(attrs: Attrs, ...children: Children): DeltaBuilder<CondensedDeltaConf<null,Attrs,Children[number]>>,
+ *   <NodeName extends string|null, Attrs extends {[k:string|number]:any}|null, Children extends Array<Array<any>|string> = []>(nodeName: NodeName, attrs: Attrs, ...children: Children): DeltaBuilder<CondensedDeltaConf<NodeName,Attrs,Children[number]>>
+ * }}
+ */
+export const from = _from
+
 /**
  * Shorthand for `delta.create().insert(..)` — see {@link DeltaBuilder#insert}.
  *

package/src/number.js

@@ -14,6 +14,7 @@ export const HIGHEST_INT32 = binary.BITS31
 export const HIGHEST_UINT32 = binary.BITS32
 
 export const isInteger = Number.isInteger
+export const isSafeInteger = Number.isSafeInteger
 export const isNaN = Number.isNaN
 export const parseInt = Number.parseInt
 

package/src/schema.js

@@ -670,7 +670,12 @@ export class $Record extends Schema {
    * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
    */
   check (o, err) {
-    return o != null && object.every(o, (vv, vk) => {
+    if (o === null || !object.isObject(o)) {
+      /* c8 ignore next */
+      err?.extend(null, 'Record', o === null ? 'null' : typeof o)
+      return false
+    }
+    return object.every(o, (vv, vk) => {
       const ck = this.shape.keys.check(vk, err)
       /* c8 ignore next */
       !ck && err?.extend(vk + '', 'Record', typeof o, ck ? 'Key doesn\'t match schema' : 'Value doesn\'t match value')
@@ -1028,21 +1033,30 @@ export const $number = /* @__PURE__ */$custom(o => typeof o === 'number')
 export const $$number = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$type('s:$number', $number))
 
 /**
- * A number without fractional component (`Number.isInteger`). The unwrapped type is still
- * `number` - JS has no separate integer type.
+ * A number without fractional component in the safe integer range (`Number.isSafeInteger`,
+ * i.e. `|n| <= 2^53 - 1`). The unwrapped type is still `number` - JS has no separate integer type.
+ *
+ * The range restriction guarantees that every `$int` is exactly representable as a 64-bit
+ * signed integer (`BigInt(n)` is lossless, databases can store it in an `int64` / `BIGINT` column).
+ * Values like `1e20` are integers to `Number.isInteger`, but they are neither exact (every float
+ * beyond 2^53 rounds to a multiple of a power of two) nor storable in 64 bits, so they are
+ * rejected. Use `$number` for unbounded floats and `$bigint` for arbitrary-precision integers.
  *
  * @type {Schema<number>}
  */
-export const $int = /* @__PURE__ */$custom(o => number.isInteger(o))
+export const $int = /* @__PURE__ */$custom(o => number.isSafeInteger(o))
 export const $$int = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$type('s:$int', $int))
 
 /**
- * An unsigned integer: a number without fractional component that is `>= 0`. The unwrapped type is
+ * An unsigned integer: a `$int` that is `>= 0` (so `0 <= n <= 2^53 - 1`). The unwrapped type is
  * still `number` - JS has no separate integer type.
  *
+ * Like `$int`, every `$uint` is exactly representable as a 64-bit integer (signed or unsigned).
+ * See `$int` for why the range is restricted.
+ *
  * @type {Schema<number>}
  */
-export const $uint = /* @__PURE__ */$custom(o => number.isInteger(o) && o >= 0)
+export const $uint = /* @__PURE__ */$custom(o => number.isSafeInteger(o) && o >= 0)
 export const $$uint = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$type('s:$uint', $uint))
 
 /**
@@ -1425,11 +1439,11 @@ const _createCoercer = ($s, cache) => {
   if (_isMeta($$int, $s) || _isMeta($$uint, $s)) {
     const min = _isMeta($$uint, $s) ? 0 : -Infinity
     return (o, path, ctx) => {
-      if (number.isInteger(o) && o >= min) return o
+      if (number.isSafeInteger(o) && o >= min) return o
       const t = typeof o
       if (t === 'boolean' || t === 'bigint' || (t === 'string' && o.trim() !== '')) {
         const n = Number(o)
-        if (number.isInteger(n) && n >= min) return n
+        if (number.isSafeInteger(n) && n >= min) return n
       }
       return _fail(ctx, path, o, expected)
     }