lib0 1.0.0-rc.6 → 1.0.0-rc.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.6",
+  "version": "1.0.0-rc.7",
   "description": "",
   "sideEffects": false,
   "type": "module",

package/src/delta/delta.js

@@ -127,10 +127,6 @@ export class TextOp extends list.ListNode {
     this._fingerprint = null
   }
 
-  get $type () {
-    return $textOp
-  }
-
   /**
    * @param {string} newVal
    */
@@ -227,10 +223,6 @@ export class InsertOp extends list.ListNode {
     this._fingerprint = null
   }
 
-  get $type () {
-    return $insertOp
-  }
-
   /**
    * @param {ArrayContent} newVal
    */
@@ -334,10 +326,6 @@ export class DeleteOp extends list.ListNode {
     this._fingerprint = null
   }
 
-  get $type () {
-    return $deleteOp
-  }
-
   /**
    * @return {'delete'}
    */
@@ -422,10 +410,6 @@ export class RetainOp extends list.ListNode {
     this._fingerprint = null
   }
 
-  get $type () {
-    return $retainOp
-  }
-
   /**
    * @return {'retain'}
    */
@@ -512,10 +496,6 @@ export class ModifyOp extends list.ListNode {
     this._fingerprint = null
   }
 
-  get $type () {
-    return $modifyOp
-  }
-
   /**
    * @return {'modify'}
    */
@@ -623,10 +603,6 @@ export class SetAttrOp {
     this._fingerprint = null
   }
 
-  get $type () {
-    return $setAttrOp
-  }
-
   /**
    * @return {'insert'}
    */
@@ -715,10 +691,6 @@ export class DeleteAttrOp {
     this._fingerprint = null
   }
 
-  get $type () {
-    return $deleteAttrOp
-  }
-
   /**
    * @type {'delete'}
    */
@@ -784,10 +756,6 @@ export class ModifyAttrOp {
     this._fingerprint = null
   }
 
-  get $type () {
-    return $modifyAttrOp
-  }
-
   /**
    * @type {'modify'}
    */
@@ -839,16 +807,16 @@ export class ModifyAttrOp {
   }
 }
 
-export const $insertOp = /** @type {s.Schema<InsertOp<any>>} */ (s.$type('insertOp'))
-export const $modifyOp = /** @type {s.Schema<ModifyOp>} */ (s.$type('modifyOp'))
-export const $textOp = /** @type {s.Schema<TextOp>} */ (s.$type('textOp'))
-export const $deleteOp = /** @type {s.Schema<DeleteOp<any>>} */ (s.$type('deleteOp'))
-export const $retainOp = /** @type {s.Schema<RetainOp>} */ (s.$type('retainOp'))
+export const $insertOp = /** @type {s.Schema<InsertOp<any>>} */ (InsertOp.prototype.$type = /** @type {s.Schema<InsertOp<any>>} */ (s.$type('d:insertOp', InsertOp)))
+export const $modifyOp = ModifyOp.prototype.$type = s.$type('d:modifyOp', ModifyOp)
+export const $textOp = TextOp.prototype.$type = s.$type('d:textOp', TextOp)
+export const $deleteOp = /** @type {s.Schema<DeleteOp<any>>} */ (DeleteOp.prototype.$type = s.$type('d:deleteOp', DeleteOp))
+export const $retainOp = RetainOp.prototype.$type = s.$type('d:retainOp', RetainOp)
 export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
 
-export const $setAttrOp = /** @type {s.Schema<SetAttrOp<any>>} */ (s.$type('setAttrOp'))
-export const $modifyAttrOp = /** @type {s.Schema<ModifyAttrOp<any,string|number>>} */ (s.$type('modifyAttrOp'))
-export const $deleteAttrOp = /** @type {s.Schema<DeleteAttrOp<any,string|number>>} */ (s.$type('deleteAttrOp'))
+export const $setAttrOp = /** @type {s.Schema<SetAttrOp<any>>} */ (SetAttrOp.prototype.$type =/** @type {s.Schema<SetAttrOp<any>>} */ (s.$type('d:setAttrOp', SetAttrOp)))
+export const $modifyAttrOp = /** @type {s.Schema<ModifyAttrOp<any>>} */ (ModifyAttrOp.prototype.$type = /** @type {s.Schema<ModifyAttrOp<any>>} */ (s.$type('d:modifyAttrOp', ModifyAttrOp)))
+export const $deleteAttrOp = /** @type {s.Schema<DeleteAttrOp<any>>} */ (DeleteAttrOp.prototype.$type = /** @type {s.Schema<DeleteAttrOp<any>>} */ (s.$type('d:deleteAttrOp', DeleteAttrOp)))
 export const $anyAttrOp = s.$union($setAttrOp, $deleteAttrOp, $modifyAttrOp)
 
 /**
@@ -1027,7 +995,6 @@ class DeltaData {
  * >}
  */
 export class Delta extends DeltaData {
-  get $type () { return $deltaAny }
   /**
    * @type {string}
    */
@@ -1374,7 +1341,7 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta>} NewContent
+   * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta|DeltaData<any,any,any,any>|DeltaBuilder>} NewContent
    * @param {NewContent} modify
    * @param {FormattingAttributes?} formatting
    * @param {Attribution?} attribution
@@ -1958,24 +1925,39 @@ export class $Delta extends s.Schema {
 }
 
 /**
- * @template {s.Schema<string>|string|Array<string>} [NodeNameSchema=s.Schema<any>]
- * @template {s.Schema<{ [key: string|number]: any }>|{ [key:string|number]:any }} [AttrsSchema=s.Schema<{}>]
- * @template {any} [ChildrenSchema=s.Schema<never>]
- * @template {boolean} [HasText=false]
- * @template {boolean} [RecursiveChildren=false]
- * @template {{ [k:string]:any }} [Formats={[k:string]:any}]
- * @param {object} opts
- * @param {NodeNameSchema?} [opts.name]
- * @param {AttrsSchema?} [opts.attrs] What key-value pairs are included.
- * @param {ChildrenSchema?} [opts.children] The type of content in `insertOp`
- * @param {HasText} [opts.text] Whether this delta contains text using `textOp`
- * @param {Formats} [opts.formats]
- * @param {RecursiveChildren} [opts.recursiveChildren]
- * @return {[s.ReadSchemaUnwrapped<NodeNameSchema>,s.ReadSchemaUnwrapped<AttrsSchema>,s.ReadSchemaUnwrapped<ChildrenSchema>] extends [infer NodeName, infer Attrs, infer Children] ? s.Schema<Delta<PrettifyDeltaConf<(import('../ts.js').TypeIsAny<NodeName, {}, { name: NodeName }> &
- *   ([keyof Attrs] extends [never] ? {} : { attrs: Attrs }) &
- *   ([Children] extends [never] ? {} : { children: Children }) &
- *   (HasText extends false ? {} : { text: HasText }) &
- *   (RecursiveChildren extends false ? {} : { recursiveChildren: RecursiveChildren })) extends infer DC extends DeltaConf ? DC : never>>> : never}
+ * @typedef {{
+ *   name?: s.Schema<string>|string|Array<string>,
+ *   attrs?: s.Schema<{ [key: string|number]: any }>|{ [key:string|number]:any },
+ *   children?: any,
+ *   text?: boolean,
+ *   recursiveChildren?: boolean,
+ *   formats?: { [k:string]: any }
+ * }} ReadableDeltaConf
+ */
+
+/**
+ * Transforms a ReadableDeltaConf (the input shape of `$delta(spec)`) to a DeltaConf.
+ * @template {ReadableDeltaConf} DConfSpec
+ * @typedef {[
+ *   DConfSpec extends {name: infer N} ? s.ReadSchemaUnwrapped<N> : any,
+ *   DConfSpec extends {attrs: infer A} ? s.ReadSchemaUnwrapped<A> : {},
+ *   DConfSpec extends {children: infer C} ? s.ReadSchemaUnwrapped<C> : never
+ * ] extends [infer NodeName, infer Attrs, infer Children]
+ *   ? PrettifyDeltaConf<(
+ *       import('../ts.js').TypeIsAny<NodeName, {}, { name: NodeName }> &
+ *       ([keyof Attrs] extends [never] ? {} : { attrs: Attrs }) &
+ *       ([Children] extends [never] ? {} : { children: Children }) &
+ *       (DConfSpec extends {text: true} ? { text: true } : {}) &
+ *       (DConfSpec extends {recursiveChildren: true} ? { recursiveChildren: true } : {})
+ *     ) extends infer DC extends DeltaConf ? DC : never>
+ *   : never
+ * } ReadDeltaConf
+ */
+
+/**
+ * @template {ReadableDeltaConf} [DeltaConf={}]
+ * @param {DeltaConf} opts
+ * @return {s.Schema<Delta<ReadDeltaConf<DeltaConf>>>}
  */
 export const $delta = ({ name, attrs, children, text, formats, recursiveChildren: recursive }) => /** @type {any} */ (new $Delta(
   /** @type {any} */ (name == null ? s.$any : s.$(name)),
@@ -1988,7 +1970,7 @@ export const $delta = ({ name, attrs, children, text, formats, recursiveChildren
 
 export const $$delta = /* @__PURE__ */s.$constructedBy($Delta)
 
-export const $deltaAny = /** @type {s.Schema<DeltaAny>} */ (/* @__PURE__ */s.$type('delta'))
+export const $deltaAny = /* @__PURE__ *//** @type {s.Schema<Delta<any>>} */ (Delta.prototype.$type = s.$type('d:delta', Delta))
 export const $deltaBuilderAny = /** @type {s.Schema<DeltaBuilderAny>} */ (/* @__PURE__ */s.$custom(o => $deltaAny.check(o) && !o.isDone))
 
 /**
@@ -2028,7 +2010,7 @@ export const mergeDeltas = (a, b) => {
  * @return {DeltaBuilder<Conf>}
  */
 export const random = (gen, $d, conf = {}) => {
-  let { source = null, minChildOps = 1, maxChildOps = 9 } = conf
+  const { source = null, minChildOps = 1, maxChildOps = 9 } = conf
   let sourceLen = source == null ? 0 : source.childCnt
   const { $name, $attrs, $children, hasText, $formats: $formats_ } = /** @type {$Delta<any>} */ (/** @type {any} */ ($d)).shape
   const d = s.$$any.check($name) ? create($deltaAny) : create(s.random(gen, $name), $deltaAny)
@@ -2225,7 +2207,6 @@ class _DiffStringWrapper {
   }
 }
 
-
 /*
  * Delta Diffing approach - optimized for performance and creating readable deltas
  *
@@ -2293,27 +2274,31 @@ export const diff = (d1, d2) => {
      */
     const cs2 = []
     // if right is null, then we already matched everything
-    while (left1 !== null && right1 !== null && left1 !== right1.next) {
-      if ($textOp.check(left1)) {
-        cs1.push(left1.insert)
-      } else if ($insertOp.check(left1)) {
-        cs1.push(...left1.insert.map(ins => typeof ins === 'string' ? new _DiffStringWrapper(ins) : ins))
-      } else {
-        error.unexpectedCase()
+    if (right1 != null) {
+      while (left1 !== null && left1 !== right1.next) {
+        if ($textOp.check(left1)) {
+          cs1.push(left1.insert)
+        } else if ($insertOp.check(left1)) {
+          cs1.push(...left1.insert.map(ins => typeof ins === 'string' ? new _DiffStringWrapper(ins) : ins))
+        } else {
+          error.unexpectedCase()
+        }
+        formattingNeedsDiff ||= left1.format != null
+        left1 = left1.next
       }
-      formattingNeedsDiff ||= left1.format != null
-      left1 = left1.next
     }
-    while (left2 !== null && right2 !== null && left2 !== right2.next) {
-      if ($textOp.check(left2)) {
-        cs2.push(left2.insert)
-      } else if ($insertOp.check(left2)) {
-        cs2.push(...left2.insert.map(ins => typeof ins === 'string' ? new _DiffStringWrapper(ins) : ins))
-      } else {
-        error.unexpectedCase()
+    if (right2 != null) {
+      while (left2 !== null && left2 !== right2.next) {
+        if ($textOp.check(left2)) {
+          cs2.push(left2.insert)
+        } else if ($insertOp.check(left2)) {
+          cs2.push(...left2.insert.map(ins => typeof ins === 'string' ? new _DiffStringWrapper(ins) : ins))
+        } else {
+          error.unexpectedCase()
+        }
+        formattingNeedsDiff ||= left2.format != null
+        left2 = left2.next
       }
-      formattingNeedsDiff ||= left2.format != null
-      left2 = left2.next
     }
     const changeset1 = [{
       index: commonPrefixOffset,

package/src/diff/patience.js

@@ -62,7 +62,7 @@ export const diffSplitBy = (a, b, regexp) => {
  *
  * @experimental
  */
-export const smartSplitRegex = /[^\p{L}\p{N}\p{Extended_Pictographic}\p{Emoji_Modifier}\u200D\uFE0F]/gu
+export const smartSplitRegex = /[^\p{L}\p{N}\p{Extended_Pictographic}\p{Emoji_Modifier}\u200D\uFE0F]/gu // eslint-disable-line no-misleading-character-class
 
 /**
  * Sensible default for diffing strings using patience (it's fast though).

package/src/schema.js

@@ -4,7 +4,6 @@
  * Simple & efficient schemas for your data.
  */
 
-import * as obj from './object.js'
 import * as arr from './array.js'
 import * as error from './error.js'
 import * as equalityTraits from './trait/equality.js'
@@ -14,6 +13,7 @@ import * as prng from './prng.js'
 import * as number from './number.js'
 import * as map from './map.js'
 import { global } from './environment.js'
+import * as object from './object.js'
 
 /**
  * @typedef {string|number|bigint|boolean|null|undefined|symbol} Primitive
@@ -109,8 +109,8 @@ const _extendsShapeHelper = (a, b) => {
     return arr.every(a, aitem =>
       arr.some(b, bitem => _extendsShapeHelper(aitem, bitem))
     )
-  } else if (obj.isObject(a)) {
-    return obj.every(a, (aitem, akey) =>
+  } else if (object.isObject(a)) {
+    return object.every(a, (aitem, akey) =>
       _extendsShapeHelper(aitem, b[akey])
     )
   }
@@ -129,11 +129,14 @@ export const extendsShape = (a, b) => {
   return /** @type {any} */ (a.constructor)._dilutes ? _extendsShapeHelper(bShape, aShape) : _extendsShapeHelper(aShape, bShape)
 }
 
+const schemaSymbol = Symbol.for('schema:Schema')
+
 /**
  * @template T
  * @implements {equalityTraits.EqualityTrait}
  */
 export class Schema {
+  get isSchema () { return schemaSymbol }
   // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
   /**
    * If true, the more things are added to the shape the more objects this schema will accept (e.g.
@@ -221,8 +224,6 @@ export class Schema {
    * "Always." - Snape, talking about type safety
    *
    * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
-   * Use this if you know that the type is of a specific type and you just want to convince the type
-   * system.
    *
    * Can be useful when defining lambdas: `s.lambda(s.$number, s.$number).expect((n) => n + 1)`
    *
@@ -235,6 +236,75 @@ export class Schema {
   }
 }
 
+/**
+ * @extends {Schema<any>}
+ */
+export class $Type extends Schema {
+  /**
+   * @param {string} name
+   */
+  constructor (name) {
+    super()
+    /**
+     * @type {string}
+     */
+    this.name = name
+    this.typeSymbol = Symbol('schema:' + name)
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is any}
+   */
+  check (o, err) {
+    const c = o != null && o.$type === this
+    /* c8 ignore next */
+    !c && err != null && err.extend(null, 'type check on', o?.constructor.name, 'failed')
+    return c
+  }
+}
+
+/**
+ * A shared gobal namespace to store schemas across lib0 installations
+ */
+const schemaStore = /* @__PURE__ */(() => {
+  const _ns = '_lib0@v1/$'
+  return (global[_ns] = (global[_ns] || new Map()))
+})()
+
+/**
+ * Define a schema for a type that can validate instances across duplicated module installations.
+ *
+ * You may only assign one "$type" to any class.
+ *
+ * The recommended way to assign a type to a class is by doing. While not strictly necessary - it ensures proper typing.
+ *
+ *   const $a = A.prototype.$type = s.$type(':a', A)
+ *
+ * Use $type if you need to validate duplicated classes from other (duplicate) installations of your
+ * js module. Don't use this only if needed and not as some "standard practice".
+ *
+ * It is good practice to define a $type property on the type constructor to enable efficient
+ * typechecks `myClassInstance.$type === $myClass`
+ *
+ * @template {new (...args:any[])=>any} T
+ * @param {string} uniqueName - a good name would be `{projectPrefix}:{ConstructorName}[@v{version}]`
+ * @param {T|{ [K:string|number|symbol]:any }|null} TypeConstructor
+ * @return {Schema<InstanceType<T>>}
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const $type = (uniqueName, TypeConstructor) => {
+  const type = map.setIfUndefined(schemaStore, uniqueName, () => new $Type(uniqueName))
+  if (TypeConstructor) {
+    /* c8 ignore next */
+    if (TypeConstructor.prototype && object.hasProperty(TypeConstructor.prototype, '$type')) { error.unexpectedCase() }
+    (TypeConstructor.prototype || TypeConstructor).$type = type
+  }
+  return /** @type {any} */ (type)
+}
+export const $$type = $Type.prototype.$type = $type('s:$type', $Type)
+
 /**
  * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} Constr
  * @typedef {Constr extends ((...args:any[]) => infer T) ? T : (Constr extends (new (...args:any[]) => any) ? InstanceType<Constr> : never)} Instance
@@ -261,6 +331,7 @@ export class $ConstructedBy extends Schema {
    * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
    */
   check (o, err = undefined) {
+    /* c8 ignore next */
     const c = o?.constructor === this.shape && (this._c == null || this._c(o))
     /* c8 ignore next */
     !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? 'Constructor match failed' : 'Check failed')
@@ -276,7 +347,7 @@ export class $ConstructedBy extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $constructedBy = (c, check = null) => new $ConstructedBy(c, check)
-export const $$constructedBy = $constructedBy($ConstructedBy)
+export const $$constructedBy = $type('s:$ConstructedBy', $ConstructedBy)
 
 /**
  * Check custom properties on any object. You may want to overwrite the generated Schema<any>.
@@ -314,46 +385,7 @@ export class $Custom extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $custom = (check) => new $Custom(check)
-export const $$custom = $constructedBy($Custom)
-
-/**
- * @extends {Schema<{$type: Schema<any>}>}
- */
-export class $Type extends Schema {
-  /**
-   * @param {any} o
-   * @param {ValidationError} err
-   * @return {o is any}
-   */
-  check (o, err) {
-    const c = o && (o.$type === this)
-    /* c8 ignore next */
-    !c && err?.extend(null, 'type check on', o?.constructor.name, 'failed')
-    return c
-  }
-}
-
-/**
- * A shared gobal namespace to store schemas across lib0 installations
- */
-const schemaStore = /* @__PURE__ */(() => {
-  const _ns = '_lib0@v1/$'
-  return (global[_ns] = (global[_ns] || new Map()))
-})()
-
-/**
- * Define a schema for a type that can validate instances across duplicated module installations.
- *
- * Use this if you need to validate duplicated classes from other (duplicate) installations of your
- * js module. Don't use this only if needed and not as some "standard practice".
- *
- * @param {string} uniqueName
- * @param {number} version
- * @return {Schema<{ $type: Schema<any> }>}
- */
-/* @__NO_SIDE_EFFECTS__ */
-export const $type = (uniqueName, version = 0) => map.setIfUndefined(schemaStore, `${uniqueName}@v${version}`, () => new $Type())
-export const $$type = $constructedBy($Type)
+export const $$custom = $type('s:$Custom', $Custom)
 
 /**
  * @template {Primitive} T
@@ -377,7 +409,7 @@ export class $Literal extends Schema {
   check (o, err) {
     const c = this.shape.some(a => a === o)
     /* c8 ignore next */
-    !c && err?.extend(null, this.shape.join(' | '), o.toString())
+    !c && err?.extend(null, this.shape.join(' | '), o + '')
     return c
   }
 }
@@ -389,7 +421,7 @@ export class $Literal extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $literal = (...literals) => new $Literal(literals)
-export const $$literal = $constructedBy($Literal)
+export const $$literal = $type('s:$Literal', $Literal)
 
 /**
  * @template {Array<string|Schema<string|number>>} Ts
@@ -428,7 +460,7 @@ const _schemaStringTemplateToRegex = s => {
   if ($$union.check(s)) {
     return s.shape.map(_schemaStringTemplateToRegex).flat(1)
   }
-  /* c8 ignore next 2 */
+  /* c8 ignore next 3 */
   // unexpected schema structure (only supports unions and string in literal types)
   error.unexpectedCase()
 }
@@ -455,7 +487,7 @@ export class $StringTemplate extends Schema {
   check (o, err) {
     const c = this._r.exec(o) != null
     /* c8 ignore next */
-    !c && err?.extend(null, this._r.toString(), o.toString(), 'String doesn\'t match string template.')
+    !c && err?.extend(null, this._r.toString(), o+'', 'String doesn\'t match string template.')
     return c
   }
 }
@@ -467,7 +499,7 @@ export class $StringTemplate extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $stringTemplate = (...literals) => new $StringTemplate(literals)
-export const $$stringTemplate = $constructedBy($StringTemplate)
+export const $$stringTemplate = $type('s:$StringTemplate', $StringTemplate)
 
 /**
  * @template {Schema<any>} S
@@ -494,7 +526,7 @@ export class $Optional extends Schema {
     return c
   }
 }
-export const $$optional = $constructedBy($Optional)
+export const $$optional = $type('s:$Optional', $Optional)
 
 /**
  * @extends Schema<never>
@@ -516,7 +548,7 @@ class $Never extends Schema {
  * @type {Schema<never>}
  */
 export const $never = /* @__PURE__ */new $Never()
-export const $$never = /* @__PURE__ */$constructedBy($Never)
+export const $$never = /* @__PURE__ */$type('s:$Never', $Never)
 
 /**
  * @template {{ [key: string|symbol|number]: Schema<any> }} S
@@ -561,8 +593,8 @@ export class $Object extends Schema {
       err?.extend(null, 'object', 'null')
       return false
     }
-    return obj.every(this.shape, (vv, vk) => {
-      const c = (this._isPartial && !obj.hasProperty(o, vk)) || vv.check(o[vk], err)
+    return object.every(this.shape, (vv, vk) => {
+      const c = (this._isPartial && !object.hasProperty(o, vk)) || vv.check(o[vk], err)
       !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], 'Object property does not match')
       return c
     })
@@ -581,7 +613,7 @@ export class $Object extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $object = def => /** @type {any} */ (new $Object(def))
-export const $$object = /* @__PURE__ */$constructedBy($Object)
+export const $$object = /* @__PURE__ */$type('s:$Object', $Object)
 
 /**
  * @template {{ [key:string|symbol|number]: any }} S
@@ -619,7 +651,7 @@ export class $Record extends Schema {
    * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
    */
   check (o, err) {
-    return o != null && obj.every(o, (vv, vk) => {
+    return o != null && 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')
@@ -637,7 +669,7 @@ export class $Record extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $record = (keys, values) => new $Record(keys, values)
-export const $$record = /* @__PURE__ */$constructedBy($Record)
+export const $$record = /* @__PURE__ */$type('s:$Record', $Record)
 
 /**
  * @template {Schema<any>[]} S
@@ -658,7 +690,7 @@ export class $Tuple extends Schema {
    * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
    */
   check (o, err) {
-    return o != null && obj.every(this.shape, (vv, vk) => {
+    return o != null && object.every(this.shape, (vv, vk) => {
       const c = /** @type {Schema<any>} */ (vv).check(o[vk], err)
       /* c8 ignore next */
       !c && err?.extend(vk.toString(), 'Tuple', typeof vv)
@@ -674,7 +706,7 @@ export class $Tuple extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $tuple = (...def) => new $Tuple(def)
-export const $$tuple = /* @__PURE__ */$constructedBy($Tuple)
+export const $$tuple = /* @__PURE__ */$type('s:$Tuple', $Tuple)
 
 /**
  * @template {Schema<any>} S
@@ -712,7 +744,7 @@ export class $Array extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $array = (...def) => new $Array(def)
-export const $$array = /* @__PURE__ */$constructedBy($Array)
+export const $$array = /* @__PURE__ */$type('s:$Array', $Array)
 /**
  * @type {Schema<Array<any>>}
  */
@@ -754,9 +786,9 @@ export class $InstanceOf extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $instanceOf = (c, check = null) => new $InstanceOf(c, check)
-export const $$instanceOf = /* @__PURE__ */$constructedBy($InstanceOf)
+export const $$instanceOf = /* @__PURE__ */$type('s:$InstanceOf', $InstanceOf)
 
-export const $$schema = /* @__PURE__ */$instanceOf(Schema)
+export const $$schema = /** @type {Schema<Schema<any>>} */ (Schema.prototype.$type = $custom(o => o?.isSchema === schemaSymbol))
 
 /**
  * @template {Schema<any>[]} Args
@@ -798,7 +830,7 @@ export class $Lambda extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $lambda = (...args) => new $Lambda(args.length > 0 ? args : [$void])
-export const $$lambda = /* @__PURE__ */$constructedBy($Lambda)
+export const $$lambda = /* @__PURE__ */$type('s:$Lambda', $Lambda)
 
 /**
  * @type {Schema<Function>}
@@ -842,7 +874,7 @@ export class $Intersection extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $intersect = (...def) => new $Intersection(def)
-export const $$intersect = /* @__PURE__ */$constructedBy($Intersection, o => o.shape.length > 0) // Intersection with length=0 is considered "any"
+export const $$intersect = /* @__PURE__ */$type('s:Intersection', $Intersection)
 
 /**
  * @template S
@@ -880,7 +912,7 @@ export const $union = (...schemas) => schemas.findIndex($s => $$union.check($s))
   : (schemas.length === 1
       ? schemas[0]
       : new $Union(schemas.map($)))
-export const $$union = /** @type {Schema<$Union<any>>} */ (/* @__PURE__ */$constructedBy($Union))
+export const $$union = /** @type {Schema<$Union<any>>} */ (/* @__PURE__ */$type('s:$Union', $Union))
 
 /**
  * @template {any} IN
@@ -925,15 +957,13 @@ export const $ = o => {
   } else if ($function.check(o)) {
     return /** @type {any} */ ($constructedBy(/** @type {any} */ (o)))
   }
-  /* c8 ignore next */
+  /* c8 ignore next 2 */
   error.unexpectedCase()
 }
 
 /* c8 ignore start */
 /**
  * Assert that a variable is of this specific type.
- * The assertion check is only performed in non-production environments.
- *
  * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
  */
 /* @__NO_SIDE_EFFECTS__ */
@@ -945,6 +975,13 @@ export const assert = (o, schema) => {
 }
 /* c8 ignore end */
 
+/**
+ * Assert that a variable is of this specific type.
+ * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const assertNoCheck = (_o, _schema) => { }
+
 /* @__NO_SIDE_EFFECTS__ */
 const _t = () => true
 /**
@@ -952,58 +989,58 @@ const _t = () => true
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $any = $custom(_t)
-export const $$any = /** @type {Schema<Schema<any>>} */ (/* @__PURE__ */$constructedBy($Custom, o => o.shape === _t))
+export const $$any = /** @type {Schema<Schema<any>>} */ (/* @__PURE__ */$type('s:$any', $any))
 
 /**
  * @type {Schema<bigint>}
  */
 export const $bigint = /* @__PURE__ */$custom(o => typeof o === 'bigint')
-export const $$bigint = /** @type {Schema<Schema<BigInt>>} */ (/* @__PURE__ */$custom(o => o === $bigint))
+export const $$bigint = /** @type {Schema<Schema<BigInt>>} */ (/* @__PURE__ */$type('s:$bigint', $bigint))
 
 /**
  * @type {Schema<symbol>}
  */
 export const $symbol = /* @__PURE__ */$custom(o => typeof o === 'symbol')
-export const $$symbol = /** @type {Schema<Schema<Symbol>>} */ (/* @__PURE__ */$custom(o => o === $symbol))
+export const $$symbol = /** @type {Schema<Schema<Symbol>>} */ (/* @__PURE__ */$type('s:$symbol', $symbol))
 
 /**
  * @type {Schema<number>}
  */
 export const $number = /* @__PURE__ */$custom(o => typeof o === 'number')
-export const $$number = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$custom(o => o === $number))
+export const $$number = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$type('s:$number', $number))
 
 /**
  * @type {Schema<string>}
  */
 export const $string = /* @__PURE__ */$custom(o => typeof o === 'string')
-export const $$string = /** @type {Schema<Schema<string>>} */ (/* @__PURE__ */$custom(o => o === $string))
+export const $$string = /** @type {Schema<Schema<string>>} */ (/* @__PURE__ */$type('s:$string', $string))
 
 /**
  * @type {Schema<boolean>}
  */
 export const $boolean = /* @__PURE__ */$custom(o => typeof o === 'boolean')
-export const $$boolean = /** @type {Schema<Schema<Boolean>>} */ (/* @__PURE__ */$custom(o => o === $boolean))
+export const $$boolean = /** @type {Schema<Schema<Boolean>>} */ (/* @__PURE__ */$type('s:$boolean', $boolean))
 
 /**
  * @type {Schema<undefined>}
  */
 export const $undefined = /* @__PURE__ */$literal(undefined)
-export const $$undefined = /** @type {Schema<Schema<undefined>>} */ (/* @__PURE__ */$constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === undefined))
+export const $$undefined = /** @type {Schema<Schema<undefined>>} */ (/* @__PURE__ */$type('s:$undefined', $undefined))
 
 /**
  * @type {Schema<void>}
  */
-export const $void = $literal(undefined)
+export const $void = $undefined
 export const $$void = /** @type {Schema<Schema<void>>} */ ($$undefined)
 
 export const $null = $literal(null)
-export const $$null = /** @type {Schema<Schema<null>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === null))
+export const $$null = /** @type {Schema<Schema<null>>} */ ($type('s:$null', $null))
 
 export const $uint8Array = $constructedBy(Uint8Array)
-export const $$uint8Array = /** @type {Schema<Schema<Uint8Array>>} */ ($constructedBy($ConstructedBy, o => o.shape === Uint8Array))
+export const $$uint8Array = /** @type {Schema<Schema<Uint8Array>>} */ ($type('s:$uint8Array', $uint8Array))
 
 export const $promise = $constructedBy(Promise)
-export const $$promise = /** @type {Schema<Schema<Uint8Array>>} */ ($constructedBy($ConstructedBy, o => o.shape === Promise))
+export const $$promise = /** @type {Schema<Schema<Uint8Array>>} */ ($type('s:$promise', $promise))
 
 /**
  * Primitive JavaScript types: immutable, non-object value that is stored and compared directly by
@@ -1038,6 +1075,16 @@ export const $json = /* @__PURE__ */(() => {
  * @typedef {{ if: Schema<In>, h: (o:In,state?:any)=>Out }} Pattern
  */
 
+/**
+ * @template {Pattern<any,any>} Ps
+ * @template S
+ * @typedef {import('./ts.js').UnionToIntersection<Ps extends Pattern<infer In, infer Out> ? [S] extends [undefined] ? (o: In) => Out : (o: In, state: S) => Out : never>
+ *   & ([S] extends [undefined]
+ *     ? (o: Ps extends Pattern<infer In, any> ? In : never) => (Ps extends Pattern<any, infer Out> ? Out : never)
+ *     : (o: Ps extends Pattern<infer In, any> ? In : never, state: S) => (Ps extends Pattern<any, infer Out> ? Out : never))
+ * } PatternMatcherFn
+ */
+
 const unhandledPatternError = 'Unhandled pattern'
 
 /**
@@ -1089,9 +1136,7 @@ export class PatternMatcher {
   }
 
   /**
-   * @return {(
-   *     Patterns extends Pattern<infer In, infer Out> ? (k: State extends undefined ? (o: In) => Out : (o: In, state: State) => Out) => void : never
-   *   ) extends (k: infer I) => void ? I : never}
+   * @return {PatternMatcherFn<Patterns, State>}
    */
   done () {
     // @ts-ignore
@@ -1121,10 +1166,11 @@ export const match = state => new PatternMatcher(/** @type {any} */ (state))
  *
  * @type {<T>(o:T,opts:any)=>ReadSchemaUnwrapped<T>}
  */
-const _random = /* @__PURE__ */ (() => match({ gen: /** @type {Schema<prng.PRNG>} */ ($any), fallback: $lambda($any,$any,$any).optional })
+const _random = /* @__PURE__ */ (() => match({ gen: /** @type {Schema<prng.PRNG>} */ ($any), fallback: $lambda($any, $any, $any).optional })
   .if($$number, (_o, { gen }) => prng.oneOf(gen, [-1, 0, 1, prng.int53(gen, number.MIN_SAFE_INTEGER, number.MAX_SAFE_INTEGER)]))
   .if($$string, (_o, { gen }) => prng.word(gen))
   .if($$boolean, (_o, { gen }) => prng.bool(gen))
+  .if($$undefined, (_o) => undefined)
   .if($$bigint, (_o, { gen }) => BigInt(prng.int53(gen, number.MIN_SAFE_INTEGER, number.MAX_SAFE_INTEGER)))
   .if($$union, (o, opts) => _random(prng.oneOf(opts.gen, o.shape), opts))
   .if($$object, (o, opts) => {

package/src/ts.js

@@ -45,6 +45,17 @@
  * @typedef {{[K in keyof OBJ as K extends keyof Renames ? Renames[K] : K extends Renames[keyof Renames] ? never : K]: OBJ[K]}} PropsRename
  */
 
+/**
+ * Convert a union type to an intersection type.
+ *
+ * @example
+ * // { a: string } & { b: number }
+ * type R = UnionToIntersection<{ a: string } | { b: number }>
+ *
+ * @template U
+ * @typedef {(U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never} UnionToIntersection
+ */
+
 /**
  * Merge two objects, keeping only keys present in both with intersected value types.
  * e.g. IntersectObjects<{a:string,b:string|number},{b:string,c:number}> = {b:string}

package/types/delta/delta.d.ts

@@ -64,7 +64,6 @@ export class TextOp extends list.ListNode {
      * @type {string?}
      */
     _fingerprint: string | null;
-    get $type(): s.Schema<TextOp>;
     /**
      * @param {string} newVal
      */
@@ -90,6 +89,7 @@ export class TextOp extends list.ListNode {
      * @return {TextOp}
      */
     clone(start?: number, end?: number): TextOp;
+    $type: s.Schema<TextOp>;
     /**
      * @param {TextOp} other
      */
@@ -124,7 +124,6 @@ export class InsertOp<ArrayContent extends unknown> extends list.ListNode {
      * @type {string?}
      */
     _fingerprint: string | null;
-    get $type(): s.Schema<InsertOp<any>>;
     /**
      * @param {ArrayContent} newVal
      */
@@ -155,6 +154,7 @@ export class InsertOp<ArrayContent extends unknown> extends list.ListNode {
      * @return {InsertOp<ArrayContent>}
      */
     clone(start?: number, end?: number): InsertOp<ArrayContent>;
+    $type: s.Schema<InsertOp<any>>;
     /**
      * @param {InsertOp<ArrayContent>} other
      */
@@ -175,7 +175,6 @@ export class DeleteOp<Conf extends DeltaConf = {}> extends list.ListNode {
      * @type {string|null}
      */
     _fingerprint: string | null;
-    get $type(): s.Schema<DeleteOp<any>>;
     /**
      * @return {'delete'}
      */
@@ -199,6 +198,7 @@ export class DeleteOp<Conf extends DeltaConf = {}> extends list.ListNode {
      * @return {DeleteOp}
      */
     clone(start?: number, end?: number): DeleteOp;
+    $type: s.Schema<DeleteOp<any>>;
     /**
      * @param {DeleteOp} other
      */
@@ -230,7 +230,6 @@ export class RetainOp extends list.ListNode {
      * @type {string|null}
      */
     _fingerprint: string | null;
-    get $type(): s.Schema<RetainOp>;
     /**
      * @return {'retain'}
      */
@@ -249,6 +248,7 @@ export class RetainOp extends list.ListNode {
      */
     toJSON(): DeltaListOpJSON;
     clone(start?: number, end?: number): RetainOp;
+    $type: s.Schema<RetainOp>;
     /**
      * @param {RetainOp} other
      */
@@ -285,7 +285,6 @@ export class ModifyOp<DTypes extends Delta = DeltaAny> extends list.ListNode {
      * @type {string|null}
      */
     _fingerprint: string | null;
-    get $type(): s.Schema<ModifyOp<DeltaAny>>;
     /**
      * @return {'modify'}
      */
@@ -311,6 +310,7 @@ export class ModifyOp<DTypes extends Delta = DeltaAny> extends list.ListNode {
      * @return {ModifyOp<DTypes>}
      */
     clone(): ModifyOp<DTypes>;
+    $type: s.Schema<ModifyOp<Delta<any>>>;
     /**
      * @param {ModifyOp<any>} other
      */
@@ -352,7 +352,6 @@ export class SetAttrOp<V extends unknown = any, K extends string | number = any>
      * @type {string|null}
      */
     _fingerprint: string | null;
-    get $type(): s.Schema<SetAttrOp<any, any>>;
     /**
      * @return {'insert'}
      */
@@ -374,6 +373,7 @@ export class SetAttrOp<V extends unknown = any, K extends string | number = any>
      * @return {SetAttrOp<V,K>}
      */
     clone(): SetAttrOp<V, K>;
+    $type: s.Schema<SetAttrOp<any, any>>;
     /**
      * @param {SetAttrOp<V>} other
      */
@@ -403,7 +403,6 @@ export class DeleteAttrOp<V = any, K extends string | number = string | number>
      * @type {string|null}
      */
     _fingerprint: string | null;
-    get $type(): s.Schema<DeleteAttrOp<any, string | number>>;
     /**
      * @type {'delete'}
      */
@@ -415,6 +414,7 @@ export class DeleteAttrOp<V = any, K extends string | number = string | number>
      */
     toJSON(): DeltaAttrOpJSON;
     clone(): DeleteAttrOp<V, K>;
+    $type: s.Schema<DeleteAttrOp<any, string | number>>;
     /**
      * @param {DeleteAttrOp<V>} other
      */
@@ -444,7 +444,6 @@ export class ModifyAttrOp<Modifier extends DeltaAny = DeltaAny, K extends string
      * @type {string|null}
      */
     _fingerprint: string | null;
-    get $type(): s.Schema<ModifyAttrOp<any, string | number>>;
     /**
      * @type {'modify'}
      */
@@ -462,21 +461,22 @@ export class ModifyAttrOp<Modifier extends DeltaAny = DeltaAny, K extends string
      * @return {ModifyAttrOp<Modifier,K>}
      */
     clone(): ModifyAttrOp<Modifier, K>;
+    $type: s.Schema<ModifyAttrOp<any, string>>;
     /**
      * @param {ModifyAttrOp<Modifier>} other
      */
     [equalityTrait.EqualityTraitSymbol](other: ModifyAttrOp<Modifier>): boolean;
 }
 export const $insertOp: s.Schema<InsertOp<any>>;
-export const $modifyOp: s.Schema<ModifyOp>;
+export const $modifyOp: s.Schema<ModifyOp<Delta<any>>>;
 export const $textOp: s.Schema<TextOp>;
 export const $deleteOp: s.Schema<DeleteOp<any>>;
 export const $retainOp: s.Schema<RetainOp>;
-export const $anyOp: s.Schema<TextOp | InsertOp<any> | DeleteOp<any> | ModifyOp<DeltaAny>>;
+export const $anyOp: s.Schema<TextOp | InsertOp<any> | DeleteOp<any> | ModifyOp<Delta<any>>>;
 export const $setAttrOp: s.Schema<SetAttrOp<any>>;
-export const $modifyAttrOp: s.Schema<ModifyAttrOp<any, string | number>>;
-export const $deleteAttrOp: s.Schema<DeleteAttrOp<any, string | number>>;
-export const $anyAttrOp: s.Schema<SetAttrOp<any, any> | DeleteAttrOp<any, string | number> | ModifyAttrOp<any, string | number>>;
+export const $modifyAttrOp: s.Schema<ModifyAttrOp<any>>;
+export const $deleteAttrOp: s.Schema<DeleteAttrOp<any>>;
+export const $anyAttrOp: s.Schema<SetAttrOp<any, any> | DeleteAttrOp<any, string | number> | ModifyAttrOp<any, string>>;
 export function $setAttrOpWith<Content extends fingerprintTrait.Fingerprintable>($content: s.Schema<Content>): s.Schema<SetAttrOp<Content>>;
 export function $insertOpWith<Content extends fingerprintTrait.Fingerprintable>($content: s.Schema<Content>): s.Schema<InsertOp<Content>>;
 export function $modifyOpWith<Modify extends DeltaAny>($content: s.Schema<Modify>): s.Schema<ModifyOp<Modify>>;
@@ -503,7 +503,6 @@ export class Delta<Conf extends DeltaConf = {}> extends DeltaData<DeltaConfGetNa
      * @param {s.Schema<Delta<any>>?} $schema
      */
     constructor(name: string | null, $schema: s.Schema<Delta<any>> | null);
-    get $type(): s.Schema<DeltaAny>;
     /**
      * @type {string}
      */
@@ -526,6 +525,7 @@ export class Delta<Conf extends DeltaConf = {}> extends DeltaData<DeltaConfGetNa
      * @return {Delta<Conf>}
      */
     done(markAsDone?: boolean): Delta<Conf>;
+    $type: s.Schema<Delta<any>>;
     [fingerprintTrait.FingerprintTraitSymbol](): string;
     /**
      * @param {any} other
@@ -590,13 +590,13 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
         text: true;
     })>, FixedConf>;
     /**
-     * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta>} NewContent
+     * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta|DeltaData<any,any,any,any>|DeltaBuilder>} NewContent
      * @param {NewContent} modify
      * @param {FormattingAttributes?} formatting
      * @param {Attribution?} attribution
      * @return {DeltaBuilder<DeltaConfOverwrite<Conf, {children: DeltaConfGetChildren<Conf>|NewContent}>, FixedConf>}
      */
-    modify<NewContent extends Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>, Delta>>(modify: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
+    modify<NewContent extends Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>, Delta | DeltaData<any, any, any, any> | DeltaBuilder>>(modify: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
         children: DeltaConfGetChildren<Conf> | NewContent;
     }>, FixedConf>;
     /**
@@ -729,34 +729,9 @@ export class $Delta<Conf extends DeltaConf> extends s.Schema<Delta<Conf>> {
         }>;
     };
 }
-export function $delta<NodeNameSchema extends s.Schema<string> | string | Array<string> = s.Schema<any>, AttrsSchema extends s.Schema<{
-    [key: string | number]: any;
-}> | {
-    [key: string | number]: any;
-} = s.Schema<{}>, ChildrenSchema extends unknown = s.Schema<never>, HasText extends boolean = false, RecursiveChildren extends boolean = false, Formats extends {
-    [k: string]: any;
-} = {
-    [k: string]: any;
-}>({ name, attrs, children, text, formats, recursiveChildren: recursive }: {
-    name?: NodeNameSchema | null | undefined;
-    attrs?: AttrsSchema | null | undefined;
-    children?: ChildrenSchema | null | undefined;
-    text?: HasText | undefined;
-    formats?: Formats | undefined;
-    recursiveChildren?: RecursiveChildren | undefined;
-}): [s.ReadSchemaUnwrapped<NodeNameSchema>, s.ReadSchemaUnwrapped<AttrsSchema>, s.ReadSchemaUnwrapped<ChildrenSchema>] extends [infer NodeName_1, infer Attrs_1, infer Children_1] ? s.Schema<Delta<PrettifyDeltaConf<(import("../ts.js").TypeIsAny<NodeName_1, {}, {
-    name: NodeName_1;
-}> & ([keyof Attrs_1] extends [never] ? {} : {
-    attrs: Attrs_1;
-}) & ([Children_1] extends [never] ? {} : {
-    children: Children_1;
-}) & (HasText extends false ? {} : {
-    text: HasText;
-}) & (RecursiveChildren extends false ? {} : {
-    recursiveChildren: RecursiveChildren;
-})) extends infer DC extends DeltaConf ? DC : never>>> : never;
+export function $delta<DeltaConf extends ReadableDeltaConf = {}>({ name, attrs, children, text, formats, recursiveChildren: recursive }: DeltaConf): s.Schema<Delta<ReadDeltaConf<DeltaConf>>>;
 export const $$delta: s.Schema<$Delta<DeltaConf>>;
-export const $deltaAny: s.Schema<DeltaAny>;
+export const $deltaAny: s.Schema<Delta<any>>;
 export const $deltaBuilderAny: s.Schema<DeltaBuilderAny>;
 export function mergeAttrs<T extends {
     [key: string]: any;
@@ -998,6 +973,44 @@ export type DeltaConfigGetRecursiveAttrs<Conf_1 extends DeltaConf> = Conf_1 exte
 export type _SanifyDelta<V> = V extends never ? never : (import("../ts.js").TypeIsAny<V, any, V extends Delta<infer Conf_1> ? Delta<Conf_1> : V>);
 export type PrettifyDeltaConf<Conf_1 extends DeltaConf> = import("../ts.js").Prettify<{ [K in keyof Conf_1]: K extends "attrs" ? import("../ts.js").Prettify<{ [KA in keyof Conf_1[K]]: _SanifyDelta<Conf_1[K][KA]>; }, 1> : (K extends "children" ? _SanifyDelta<Conf_1[K]> : Conf_1[K]); }, 1>;
 export type DeltaConfOverwrite<D1 extends DeltaConf, D2> = (import("../ts.js").TypeIsAny<D1, any, PrettifyDeltaConf<{ [K in (keyof D1 | keyof D2)]: K extends keyof D2 ? D2[K] : (K extends keyof D1 ? D1[K] : never); }>> & {}) extends infer DC extends DeltaConf ? DC : never;
+export type ReadableDeltaConf = {
+    name?: s.Schema<string> | string | Array<string>;
+    attrs?: s.Schema<{
+        [key: string | number]: any;
+    }> | {
+        [key: string | number]: any;
+    };
+    children?: any;
+    text?: boolean;
+    recursiveChildren?: boolean;
+    formats?: {
+        [k: string]: any;
+    };
+};
+/**
+ * Transforms a ReadableDeltaConf (the input shape of `$delta(spec)`) to a DeltaConf.
+ */
+export type ReadDeltaConf<DConfSpec extends ReadableDeltaConf> = [DConfSpec extends {
+    name: infer N;
+} ? s.ReadSchemaUnwrapped<N> : any, DConfSpec extends {
+    attrs: infer A;
+} ? s.ReadSchemaUnwrapped<A> : {}, DConfSpec extends {
+    children: infer C;
+} ? s.ReadSchemaUnwrapped<C> : never] extends [infer NodeName_1, infer Attrs_1, infer Children_1] ? PrettifyDeltaConf<(import("../ts.js").TypeIsAny<NodeName_1, {}, {
+    name: NodeName_1;
+}> & ([keyof Attrs_1] extends [never] ? {} : {
+    attrs: Attrs_1;
+}) & ([Children_1] extends [never] ? {} : {
+    children: Children_1;
+}) & (DConfSpec extends {
+    text: true;
+} ? {
+    text: true;
+} : {}) & (DConfSpec extends {
+    recursiveChildren: true;
+} ? {
+    recursiveChildren: true;
+} : {})) extends infer DC extends DeltaConf ? DC : never> : never;
 import * as s from '../schema.js';
 import * as list from '../list.js';
 import * as equalityTrait from '../trait/equality.js';

package/types/schema.d.ts

@@ -71,6 +71,7 @@ export class Schema<T> implements equalityTraits.EqualityTrait {
      * @protected
      */
     protected static _dilutes: boolean;
+    get isSchema(): symbol;
     /**
      * Overwrite this when necessary. By default, we only check the `shape` property which every shape
      * should have.
@@ -120,8 +121,6 @@ export class Schema<T> implements equalityTraits.EqualityTrait {
      * "Always." - Snape, talking about type safety
      *
      * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
-     * Use this if you know that the type is of a specific type and you just want to convince the type
-     * system.
      *
      * Can be useful when defining lambdas: `s.lambda(s.$number, s.$number).expect((n) => n + 1)`
      *
@@ -129,11 +128,37 @@ export class Schema<T> implements equalityTraits.EqualityTrait {
      * @return {o extends T ? T : never}
      */
     expect(o: T): T extends T ? T : never;
+    $type: Schema<Schema<any>>;
     /**
      * @param {object} other
      */
     [equalityTraits.EqualityTraitSymbol](other: object): boolean;
 }
+/**
+ * @extends {Schema<any>}
+ */
+export class $Type extends Schema<any> {
+    /**
+     * @param {string} name
+     */
+    constructor(name: string);
+    /**
+     * @type {string}
+     */
+    name: string;
+    typeSymbol: symbol;
+    /**
+     * @param {any} o
+     * @param {ValidationError} err
+     * @return {o is any}
+     */
+    check(o: any, err: ValidationError): o is any;
+    $type: Schema<$Type>;
+}
+export function $type<T extends new (...args: any[]) => any>(uniqueName: string, TypeConstructor: T | {
+    [K: string | number | symbol]: any;
+} | null): Schema<InstanceType<T>>;
+export const $$type: Schema<$Type>;
 /**
  * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} Constr
  * @typedef {Constr extends ((...args:any[]) => infer T) ? T : (Constr extends (new (...args:any[]) => any) ? InstanceType<Constr> : never)} Instance
@@ -182,24 +207,6 @@ export class $Custom extends Schema<any> {
 }
 export function $custom(check: (o: any) => boolean): Schema<any>;
 export const $$custom: Schema<$Custom>;
-/**
- * @extends {Schema<{$type: Schema<any>}>}
- */
-export class $Type extends Schema<{
-    $type: Schema<any>;
-}> {
-    constructor();
-    /**
-     * @param {any} o
-     * @param {ValidationError} err
-     * @return {o is any}
-     */
-    check(o: any, err: ValidationError): o is any;
-}
-export function $type(uniqueName: string, version?: number): Schema<{
-    $type: Schema<any>;
-}>;
-export const $$type: Schema<$Type>;
 /**
  * @template {Primitive} T
  * @extends {Schema<T>}
@@ -383,7 +390,7 @@ export class $InstanceOf<T> extends Schema<T> {
 }
 export function $instanceOf<T>(c: new (...args: any) => T, check?: ((o: T) => boolean) | null): Schema<T>;
 export const $$instanceOf: Schema<$InstanceOf<unknown>>;
-export const $$schema: Schema<Schema<unknown>>;
+export const $$schema: Schema<Schema<any>>;
 /**
  * @template {Schema<any>[]} Args
  * @typedef {(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>} _LArgsToLambdaDef
@@ -445,11 +452,14 @@ export const $$union: Schema<$Union<any>>;
 export function $<IN>(o: IN): Schema<import("./ts.js").TypeIsAny<IN, any, ReadSchemaUnwrapped<IN>>>;
 /**
  * Assert that a variable is of this specific type.
- * The assertion check is only performed in non-production environments.
- *
  * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
  */
 export const assert: <T>(o: any, schema: Schema<T>) => asserts o is T;
+/**
+ * Assert that a variable is of this specific type.
+ * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
+ */
+export const assertNoCheck: <T>(o: any, schema: Schema<T>) => asserts o is T;
 /**
  * @type {Schema<any>}
  */
@@ -546,13 +556,11 @@ export class PatternMatcher<State extends unknown = undefined, Patterns extends
     /**
      * @param {string} errorMessage
      */
-    error(errorMessage?: string): (Patterns | Pattern<any, never> extends infer T ? T extends Patterns | Pattern<any, never> ? T extends Pattern<infer In, infer Out> ? (k: State extends undefined ? (o: In) => Out : (o: In, state: State) => Out) => void : never : never : never) | ((k: State extends undefined ? (o: any) => never : (o: any, state: State) => never) => void) extends (k: infer I) => void ? I : never;
+    error(errorMessage?: string): PatternMatcherFn<Patterns | Pattern<any, never>, State>;
     /**
-     * @return {(
-     *     Patterns extends Pattern<infer In, infer Out> ? (k: State extends undefined ? (o: In) => Out : (o: In, state: State) => Out) => void : never
-     *   ) extends (k: infer I) => void ? I : never}
+     * @return {PatternMatcherFn<Patterns, State>}
      */
-    done(): (Patterns extends Pattern<infer In, infer Out> ? (k: State extends undefined ? (o: In) => Out : (o: In, state: State) => Out) => void : never) extends (k: infer I) => void ? I : never;
+    done(): PatternMatcherFn<Patterns, State>;
 }
 export function match<State = undefined>(state?: State): PatternMatcher<State extends undefined ? undefined : ReadSchemaUnwrapped<State>>;
 export function random<S>(gen: prng.PRNG, schema: S, fallback?: (gen: prng.PRNG, o: Schema<any>) => any): ReadSchemaUnwrapped<S>;
@@ -584,6 +592,7 @@ export type Pattern<In, Out> = {
     if: Schema<In>;
     h: (o: In, state?: any) => Out;
 };
+export type PatternMatcherFn<Ps extends Pattern<any, any>, S> = import("./ts.js").UnionToIntersection<Ps extends Pattern<infer In, infer Out> ? [S] extends [undefined] ? (o: In) => Out : (o: In, state: S) => Out : never> & ([S] extends [undefined] ? (o: Ps extends Pattern<infer In, any> ? In : never) => (Ps extends Pattern<any, infer Out> ? Out : never) : (o: Ps extends Pattern<infer In, any> ? In : never, state: S) => (Ps extends Pattern<any, infer Out> ? Out : never));
 import * as equalityTraits from './trait/equality.js';
 /**
  * @extends Schema<never>

package/types/ts.d.ts

@@ -19,6 +19,10 @@ export type KeyOf<Obj extends {
 export type PropsRename<OBJ extends { [K in string | number]: any; }, Renames extends {
     [K: string | number]: string | number;
 }> = { [K in keyof OBJ as K extends keyof Renames ? Renames[K] : K extends Renames[keyof Renames] ? never : K]: OBJ[K]; };
+/**
+ * Convert a union type to an intersection type.
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /**
  * Merge two objects, keeping only keys present in both with intersected value types.
  * e.g. IntersectObjects<{a:string,b:string|number},{b:string,c:number}> = {b:string}