effect 4.0.0-beta.102 → 4.0.0-beta.103

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -214,8 +214,8 @@ function translateJsonSchemaMultiDocument(
   options?: SchemaRepresentation.FromJsonSchemaOptions,
   singleRoot = false
 ): SchemaRepresentation.MultiDocument {
-  const definitionCache = new Map<string, ImportedJsonSchemaRepresentation>()
-  const definitionsInProgress = new Set<string>()
+  const definitionCache = new Map<string, ImportedJsonSchemaRepresentation | null>()
+  const reachableDefinitions = new Map<string, Path>()
   const annotatedReferences: Array<{
     readonly reference: SchemaRepresentation.Reference
     readonly path: Path
@@ -227,16 +227,17 @@ function translateJsonSchemaMultiDocument(
     recursiveReferenceError?: string
   ): ImportedJsonSchemaRepresentation {
     const cached = definitionCache.get(key)
-    if (cached !== undefined) return cached
+    if (cached !== undefined) {
+      if (cached === null) {
+        throw errorWithPath(recursiveReferenceError ?? `Invalid reference ${key}`, [...path, "$ref"])
+      }
+      return cached
+    }
     if (!Object.hasOwn(document.definitions, key)) {
       throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
     }
-    if (definitionsInProgress.has(key)) {
-      throw errorWithPath(recursiveReferenceError ?? `Invalid reference ${key}`, [...path, "$ref"])
-    }
-    definitionsInProgress.add(key)
+    definitionCache.set(key, null)
     const representation = recur(document.definitions[key], ["definitions", key])
-    definitionsInProgress.delete(key)
     definitionCache.set(key, representation)
     return representation
   }
@@ -696,6 +697,7 @@ function translateJsonSchemaMultiDocument(
     if (typeof schema.$ref === "string") {
       const $ref = jsonSchemaReferenceKey(schema.$ref)
       if ($ref !== undefined) {
+        if (!reachableDefinitions.has($ref)) reachableDefinitions.set($ref, path)
         return { _tag: "Reference", $ref }
       }
     }
@@ -812,7 +814,7 @@ function translateJsonSchemaMultiDocument(
       addNumberCheck(checks, schema.minItems, "effect/schema/isMinLength", "minLength")
       addNumberCheck(checks, schema.maxItems, "effect/schema/isMaxLength", "maxLength")
     }
-    if (typeof schema.uniqueItems === "boolean") {
+    if (schema.uniqueItems === true) {
       checks.push(jsonSchemaFilter("effect/schema/isUnique", null))
     }
     return checks
@@ -890,12 +892,12 @@ function translateJsonSchemaMultiDocument(
   }
 
   const references: Record<string, Representation> = {}
-  for (const key of Object.keys(document.definitions)) {
-    InternalRecord.assignProperty(references, key, unknownJsonSchemas(translateDefinition(key, ["definitions", key])))
-  }
   const representations = document.schemas.map((schema, index) =>
     unknownJsonSchemas(recur(schema, singleRoot ? ["schema"] : ["schemas", index]))
   ) as [Representation, ...Array<Representation>]
+  for (const [key, path] of reachableDefinitions) {
+    InternalRecord.assignProperty(references, key, unknownJsonSchemas(translateDefinition(key, path)))
+  }
   for (const { reference, path } of annotatedReferences) {
     resolveReference(reference, path)
   }
@@ -952,6 +954,6 @@ export function fromJsonSchemaDocument(
 export function fromJsonSchemaMultiDocument(
   document: JsonSchema.MultiDocument<"draft-2020-12">,
   options?: SchemaRepresentation.FromJsonSchemaOptions
-): SchemaRepresentation.SchemaMultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   return fromRepresentations(translateJsonSchemaMultiDocument(document, options), jsonSchemaRevivers)
 }

package/src/internal/schema/fromRepresentation.ts

@@ -12,7 +12,7 @@ type Path = ReadonlyArray<string | number>
 export function fromRepresentations(
   document: SchemaRepresentation.MultiDocument,
   revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
-): SchemaRepresentation.SchemaMultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   return revivePersisted(document.representations, document.references, makeReviverMap(revivers), false)
 }
 
@@ -58,18 +58,17 @@ function revivePersisted(
   references: SchemaRepresentation.References,
   reviverMap: ReadonlyMap<string, SchemaRepresentation.AnyReviver>,
   singleRoot: boolean
-): SchemaRepresentation.SchemaMultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   const slots = new Map<string, ReferenceSlot>()
-  const referenceKeys = Object.keys(references)
-
-  for (const key of referenceKeys) {
-    slots.set(key, new ReferenceSlot(key))
-  }
 
   function resolveReference(key: string, path: Path): Schema.Top {
-    const slot = slots.get(key)
+    let slot = slots.get(key)
     if (slot === undefined) {
-      throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
+      if (!Object.hasOwn(references, key)) {
+        throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
+      }
+      slot = new ReferenceSlot(key)
+      slots.set(key, slot)
     }
     if (slot.body !== undefined) {
       return slot.body
@@ -320,15 +319,10 @@ function revivePersisted(
     }
   }
 
-  const definitions: Record<string, Schema.Top> = {}
-  for (const key of referenceKeys) {
-    InternalRecord.assignProperty(definitions, key, resolveReference(key, ["references", key]))
-  }
-
   const schemas = representations.map((representation, index) =>
     recur(representation, singleRoot ? ["representation"] : ["representations", index])
   ) as [Schema.Top, ...Array<Schema.Top>]
-  return { schemas, definitions }
+  return schemas
 }
 
 /** @internal */
@@ -341,5 +335,5 @@ export function fromRepresentation(
     document.references,
     makeReviverMap(revivers),
     true
-  ).schemas[0]
+  )[0]
 }

package/src/internal/schema/parser.ts

@@ -0,0 +1,22 @@
+import * as Exit from "../../Exit.ts"
+import * as Option from "../../Option.ts"
+import { args } from "../core.ts"
+
+export const missing = Symbol()
+
+export { args }
+
+export type Success<A, E = never> = Exit.Success<A, E> & { readonly [args]: A }
+
+export const succeed = Exit.succeed as <A>(value: A) => Success<A>
+
+export const missingExit = succeed(missing)
+
+// Shared success for a present input returned unchanged. It must be resolved
+// before crossing an asynchronous or transformation boundary.
+export const sameExit: Success<unknown> = succeed(missing)
+
+export const toOption = <A>(value: A): Option.Option<A> => value === missing ? Option.none() : Option.some(value as A)
+
+export const fromOptionExit = <A>(option: Option.Option<A>): Success<A | typeof missing> =>
+  option._tag === "None" ? missingExit : succeed(option.value)

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -1,4 +1,5 @@
 import * as Arr from "../../Array.ts"
+import * as Equal from "../../Equal.ts"
 import { escapeToken } from "../../JsonPointer.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
 import * as RegEx from "../../RegExp.ts"
@@ -142,12 +143,63 @@ function compileJsonSchema(
   options: Schema.ToJsonSchemaOptions | undefined
 ): JsonSchema.MultiDocument<"draft-2020-12"> {
   const definitions: Record<string, JsonSchema.JsonSchema> = {}
-  for (const key of Object.keys(references)) {
-    InternalRecord.assignProperty(definitions, key, recur(references[key], ["references", key]))
+  // null = compiling, string = canonical key, object = compiled schema
+  const definitionStates = new Map<string, JsonSchema.JsonSchema | string | null>()
+  const compiledRepresentations = new WeakMap<SchemaRepresentation.Representation, JsonSchema.JsonSchema>()
+  const fallbackDefinitions = new Map<string, Array<string>>()
+  const referenceKeys = Object.keys(references)
+  for (const key of referenceKeys) {
+    compileDefinition(key, ["references", key])
+  }
+  for (const key of referenceKeys) {
+    const compiled = definitionStates.get(key)!
+    if (typeof compiled !== "string") {
+      InternalRecord.assignProperty(definitions, key, compiled)
+    }
   }
   const schemas = Arr.map(representations, (representation, index) => recur(representation, rootPaths[index]))
   return { dialect: "draft-2020-12", schemas, definitions }
 
+  function compileDefinition(key: string, path: Path): string {
+    const compiled = definitionStates.get(key)
+    if (compiled !== undefined) return typeof compiled === "string" ? compiled : key
+    if (!Object.hasOwn(references, key)) {
+      throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"])
+    }
+
+    definitionStates.set(key, null)
+    const representation = references[key]
+    const schema = recur(representation, ["references", key])
+
+    const fallback = getIdentifierFallback(representation)
+    if (fallback !== undefined) {
+      const candidates = fallbackDefinitions.get(fallback)
+      const match = candidates?.find((candidate) => Equal.equals(definitionStates.get(candidate), schema))
+      if (match === undefined) {
+        if (candidates === undefined) fallbackDefinitions.set(fallback, [key])
+        else candidates.push(key)
+      } else {
+        definitionStates.set(key, match)
+        return match
+      }
+    }
+    definitionStates.set(key, schema)
+    return key
+  }
+
+  function getIdentifierFallback(
+    representation: SchemaRepresentation.Representation
+  ): string | undefined {
+    if (representation._tag === "Reference") return undefined
+    const annotations = representation.checks.length === 0
+      ? representation.annotations
+      : representation.checks[representation.checks.length - 1].annotations
+    return typeof annotations?.identifier !== "string" &&
+        typeof annotations?.[InternalAnnotations.IDENTIFIER_FALLBACK_KEY] === "string"
+      ? annotations[InternalAnnotations.IDENTIFIER_FALLBACK_KEY]
+      : undefined
+  }
+
   function annotationSchemas(
     representation: CheckRepresentationAnnotation | undefined,
     path: Path
@@ -183,11 +235,11 @@ function compileJsonSchema(
     path: Path
   ): JsonSchema.JsonSchema {
     if (representation._tag === "Reference") {
-      if (!Object.hasOwn(references, representation.$ref)) {
-        throw errorWithPath(`Invalid reference ${representation.$ref}`, [...path, "$ref"])
-      }
-      return { $ref: `#/$defs/${escapeToken(representation.$ref)}` }
+      const canonical = compileDefinition(representation.$ref, path)
+      return { $ref: `#/$defs/${escapeToken(canonical)}` }
     }
+    const cached = compiledRepresentations.get(representation)
+    if (cached !== undefined) return cached
 
     let output = on(representation, path)
     const ordinary = collectJsonSchemaAnnotations(representation.annotations, options)
@@ -201,6 +253,7 @@ function compileJsonSchema(
         output = appendJsonSchema(output, check)
       }
     }
+    compiledRepresentations.set(representation, output)
     return output
   }
 
@@ -370,6 +423,7 @@ function compileJsonSchema(
         if (!Object.hasOwn(references, parameter.$ref)) {
           throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path, "$ref"])
         }
+        compileDefinition(parameter.$ref, path)
         if (seenReferences.has(parameter.$ref)) return []
         const next = new Set(seenReferences).add(parameter.$ref)
         return getParameterPatterns(references[parameter.$ref], ["references", parameter.$ref], next)

package/src/internal/schema/toRepresentation.ts

@@ -17,7 +17,7 @@ export function toRepresentation(
 export function toRepresentations(
   asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
 ): SchemaRepresentation.MultiDocument {
-  return lowerASTs(asts, [])
+  return fromASTs(asts)
 }
 
 type CheckRepresentationAnnotation = SchemaRepresentation.CheckRepresentationAnnotation<
@@ -28,27 +28,6 @@ function annotationsField<A>(annotations: A | undefined): { readonly annotations
   return annotations === undefined ? undefined : { annotations }
 }
 
-/** @internal */
-export function fromSchemaMultiDocument(
-  document: SchemaRepresentation.SchemaMultiDocument
-): SchemaRepresentation.MultiDocument {
-  const definitions = Object.entries(document.definitions).map(([key, schema]) => {
-    const original = schema.ast
-    const encoded = SchemaAST.getLastEncoding(original)
-    const body = SchemaAST.isSuspend(encoded) ? encoded.thunk() : encoded
-    return { key, original, encoded, body }
-  })
-  const asts = Arr.map(document.schemas, (schema) => schema.ast)
-  return lowerASTs(asts, definitions)
-}
-
-interface ExternalDefinition {
-  readonly key: string
-  readonly original: SchemaAST.AST
-  readonly encoded: SchemaAST.AST
-  readonly body: SchemaAST.AST
-}
-
 // Preserve repeated structural nodes as references without adding noise for leaf nodes.
 function isShareable(ast: SchemaAST.AST): boolean {
   return SchemaAST.isArrays(ast) ||
@@ -58,86 +37,118 @@ function isShareable(ast: SchemaAST.AST): boolean {
 
 interface ReferenceIdentifier {
   readonly identifier: string
-  readonly isFallback: boolean
+  readonly fallback?: string | undefined
 }
 
-function resolveReferenceIdentifier(ast: SchemaAST.AST): ReferenceIdentifier | undefined {
-  const identifier = InternalAnnotations.resolveIdentifier(ast)
-  if (identifier !== undefined) return { identifier, isFallback: false }
-  const fallback = InternalAnnotations.resolveIdentifierFallback(ast)
-  return fallback === undefined ? undefined : { identifier: `${fallback}JsonEncoding`, isFallback: true }
+function resolveReferenceIdentifier(
+  input: SchemaAST.AST,
+  encoded: SchemaAST.AST
+): ReferenceIdentifier | undefined {
+  const identifier = InternalAnnotations.resolveIdentifier(encoded)
+  if (identifier !== undefined) return { identifier }
+  const fallback = (encoded !== input ? InternalAnnotations.resolveIdentifier(input) : undefined) ??
+    InternalAnnotations.resolveIdentifierFallback(encoded)
+  return fallback === undefined
+    ? undefined
+    : { identifier: `${fallback}Encoded`, fallback }
 }
 
-function hasSameReferenceOwner(self: SchemaAST.AST, that: SchemaAST.AST): boolean {
-  if (self === that) return true
-  const selfKeys = Reflect.ownKeys(self)
-  const thatKeys = Reflect.ownKeys(that)
-  if (selfKeys.length !== thatKeys.length) return false
-  for (const key of selfKeys) {
-    if (key !== "context" && (self as any)[key] !== (that as any)[key]) return false
-  }
-  return true
-}
-
-function lowerASTs(
-  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>],
-  externalDefinitions: ReadonlyArray<ExternalDefinition>
+function fromASTs(
+  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
 ): SchemaRepresentation.MultiDocument {
   const references: Record<string, SchemaRepresentation.Representation> = {}
-  const referenceMap = new Map<SchemaAST.AST, string>()
-  const fallbackReferences: Array<readonly [SchemaAST.AST, string]> = []
+  const anonymousReferences = new Map<SchemaAST.AST, string>()
   const referenceOwners = new Map<string, SchemaAST.AST>()
-  const externalReferences = new Set(externalDefinitions.map((definition) => definition.key))
+  const valueIds = new Map<unknown, number>()
+  const canonicalByKey = new Map<string, SchemaAST.AST>()
+  let nextValueId = 0
+  const buildingReferences = new Set<string>()
   const visiting = new Set<SchemaAST.AST>()
   const visited = new Set<SchemaAST.AST>()
   const shared = new Set<SchemaAST.AST>()
 
-  for (const definition of externalDefinitions) {
-    referenceOwners.set(definition.key, definition.body)
-    referenceMap.set(definition.original, definition.key)
-    referenceMap.set(definition.encoded, definition.key)
-  }
-
   for (const ast of asts) visit(ast)
-  for (const definition of externalDefinitions) visit(definition.body)
 
   const representations = Arr.map(asts, (ast) => recur(ast))
 
-  for (const definition of externalDefinitions) {
-    InternalRecord.assignProperty(references, definition.key, recur(definition.body, definition.key))
-  }
-
   return { representations, references }
 
-  function generateReference(prefix: string, owner: SchemaAST.AST): string {
+  function getReference(prefix: string, owner: SchemaAST.AST, separator = "_"): string {
     let candidate = prefix
     let suffix = 0
     while (referenceOwners.has(candidate)) {
-      candidate = `${prefix}${++suffix}`
+      if (referenceOwners.get(candidate) === owner) return candidate
+      candidate = `${prefix}${separator}${++suffix}`
     }
     referenceOwners.set(candidate, owner)
     return candidate
   }
 
+  function getValueId(value: unknown): number {
+    if (typeof value === "number" && globalThis.Number.isNaN(value)) {
+      return nextValueId++
+    }
+    const found = valueIds.get(value)
+    if (found !== undefined) return found
+    const id = nextValueId++
+    valueIds.set(value, id)
+    return id
+  }
+
+  function getIdentityKey(ast: SchemaAST.AST): string {
+    let identity = ast._tag
+    for (const [key, value] of Object.entries(ast)) {
+      if (key !== "_tag" && key !== "context") identity += `:${getValueId(value)}`
+    }
+    return identity
+  }
+
+  function getCanonicalAST(ast: SchemaAST.AST): SchemaAST.AST {
+    const key = getIdentityKey(ast)
+    const canonical = canonicalByKey.get(key)
+    if (canonical === undefined) {
+      canonicalByKey.set(key, ast)
+      return ast
+    }
+    return canonical
+  }
+
+  function annotateReference(
+    ast: SchemaAST.AST,
+    referenceIdentifier: ReferenceIdentifier,
+    reference: string
+  ): SchemaAST.AST {
+    const fallback = referenceIdentifier.fallback
+    if (fallback !== undefined) {
+      return InternalAnnotations.resolveIdentifierFallback(ast) === fallback
+        ? ast
+        : SchemaAST.annotate(ast, {
+          [InternalAnnotations.IDENTIFIER_FALLBACK_KEY]: fallback
+        })
+    }
+    return reference === referenceIdentifier.identifier
+      ? ast
+      : SchemaAST.annotate(ast, { identifier: reference })
+  }
+
+  function makeReference(reference: string, ast: SchemaAST.AST): SchemaRepresentation.Reference {
+    if (!Object.hasOwn(references, reference) && !buildingReferences.has(reference)) {
+      buildingReferences.add(reference)
+      const representation = on(ast)
+      buildingReferences.delete(reference)
+      InternalRecord.assignProperty(references, reference, representation)
+    }
+    return { _tag: "Reference", $ref: reference }
+  }
+
   function visit(input: SchemaAST.AST): void {
     const ast = SchemaAST.getLastEncoding(input)
-    if (visited.has(ast)) {
-      if (isShareable(ast)) shared.add(ast)
+    const owner = getCanonicalAST(ast)
+    if (visited.has(owner)) {
+      if (isShareable(ast)) shared.add(owner)
       return
     }
-    visited.add(ast)
-    const referenceIdentifier = resolveReferenceIdentifier(ast)
-    if (referenceIdentifier !== undefined && !referenceIdentifier.isFallback) {
-      const owner = referenceOwners.get(referenceIdentifier.identifier)
-      if (owner === undefined) {
-        referenceOwners.set(referenceIdentifier.identifier, ast)
-      } else if (
-        referenceMap.get(ast) !== referenceIdentifier.identifier &&
-        !hasSameReferenceOwner(owner, ast)
-      ) {
-        throw new Error(`Duplicate identifier: ${JSON.stringify(referenceIdentifier.identifier)}`)
-      }
-    }
+    visited.add(owner)
     visitChecks(ast.checks)
     switch (ast._tag) {
       case "Declaration":
@@ -165,49 +176,35 @@ function lowerASTs(
     })
   }
 
-  function recur(
-    ast: SchemaAST.AST,
-    ownedReference?: string
-  ): SchemaRepresentation.Representation {
-    const found = referenceMap.get(ast)
-    if (found !== undefined && found !== ownedReference) {
-      return { _tag: "Reference", $ref: found }
-    }
-
-    const projected = SchemaAST.getLastEncoding(ast)
-    if (projected !== ast) {
-      return recur(projected, ownedReference)
-    }
-
-    const referenceIdentifier = ownedReference === undefined ? resolveReferenceIdentifier(ast) : undefined
+  function recur(input: SchemaAST.AST): SchemaRepresentation.Representation {
+    const ast = SchemaAST.getLastEncoding(input)
+    const owner = getCanonicalAST(ast)
+    const referenceIdentifier = resolveReferenceIdentifier(input, ast)
     if (referenceIdentifier !== undefined) {
-      const reference = getReference(referenceIdentifier, ast)
-      referenceMap.set(ast, reference)
-      if (!Object.hasOwn(references, reference) && !externalReferences.has(reference)) {
-        InternalRecord.assignProperty(references, reference, on(ast))
-      }
-      return { _tag: "Reference", $ref: reference }
+      const reference = getReference(referenceIdentifier.identifier, owner)
+      return makeReference(reference, annotateReference(ast, referenceIdentifier, reference))
     }
 
-    if (ownedReference === undefined && shared.has(ast)) {
-      const reference = generateReference(`${ast._tag}_`, ast)
-      referenceMap.set(ast, reference)
-      InternalRecord.assignProperty(references, reference, on(ast))
-      return { _tag: "Reference", $ref: reference }
+    const found = anonymousReferences.get(owner)
+    if (found !== undefined) {
+      return { _tag: "Reference", $ref: found }
     }
 
-    if (visiting.has(ast)) {
-      const reference = generateReference(`${ast._tag}_`, ast)
-      referenceMap.set(ast, reference)
-      return { _tag: "Reference", $ref: reference }
+    const isShared = shared.has(owner)
+    if (isShared || visiting.has(owner)) {
+      const reference = getReference(`${ast._tag}_`, owner, "")
+      anonymousReferences.set(owner, reference)
+      return isShared
+        ? makeReference(reference, ast)
+        : { _tag: "Reference", $ref: reference }
     }
 
-    visiting.add(ast)
+    visiting.add(owner)
     const representation = on(ast)
-    visiting.delete(ast)
+    visiting.delete(owner)
 
-    const reference = referenceMap.get(ast)
-    if (reference !== undefined && reference !== ownedReference) {
+    const reference = anonymousReferences.get(owner)
+    if (reference !== undefined) {
       InternalRecord.assignProperty(references, reference, representation)
       return { _tag: "Reference", $ref: reference }
     }
@@ -215,18 +212,6 @@ function lowerASTs(
     return representation
   }
 
-  function getReference(referenceIdentifier: ReferenceIdentifier, ast: SchemaAST.AST): string {
-    if (!referenceIdentifier.isFallback) {
-      return referenceIdentifier.identifier
-    }
-    for (const [owner, reference] of fallbackReferences) {
-      if (hasSameReferenceOwner(owner, ast)) return reference
-    }
-    const reference = generateReference(referenceIdentifier.identifier, ast)
-    fallbackReferences.push([ast, reference])
-    return reference
-  }
-
   function on(ast: SchemaAST.AST): SchemaRepresentation.Representation {
     const checks = fromChecks(ast.checks)
     switch (ast._tag) {

package/src/internal/trie.ts

@@ -42,7 +42,7 @@ const TrieProto: TR.Trie<unknown> = {
     return hash
   },
   [Equal.symbol]<V>(this: TrieImpl<V>, that: unknown): boolean {
-    if (isTrie(that)) {
+    if (isTrie(that) && size(this) === size(that)) {
       const entries = Array.from(that)
       return Array.from(this).every((itemSelf, i) => {
         const itemThat = entries[i]
@@ -103,8 +103,8 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
         const value = node.value
         if (value !== undefined) {
           const key = keyString + node.key
-          if (this.filter(key, value)) {
-            return { done: false, value: this.f(key, value) }
+          if (this.filter(key, value.value)) {
+            return { done: false, value: this.f(key, value.value) }
           }
         }
       } else {
@@ -194,7 +194,7 @@ export const insert = dual<
       }
     } else {
       if (cIndex === key.length - 1) {
-        n.value = value
+        n.value = { value }
       } else if (n.mid === undefined) {
         dStack.push(0)
         n = { key: key[cIndex + 1], count }
@@ -403,7 +403,7 @@ export const get = dual<
         }
       } else {
         if (cIndex === key.length - 1) {
-          return Option.fromUndefinedOr(n.value)
+          return n.value === undefined ? Option.none() : Option.some(n.value.value)
         } else {
           if (n.mid === undefined) {
             return Option.none()
@@ -632,7 +632,7 @@ export const modify = dual<
     nStack[nStack.length - 1] = {
       key: updateNode.key,
       count: updateNode.count,
-      value: f(updateNode.value), // Update
+      value: { value: f(updateNode.value.value) }, // Update
       left: updateNode.left,
       mid: updateNode.mid,
       right: updateNode.right
@@ -693,10 +693,6 @@ export const longestPrefixOf = dual<
     let cIndex = 0
     while (cIndex < key.length) {
       const c = key[cIndex]
-      if (n.value !== undefined) {
-        longestPrefixNode = Option.some([key.slice(0, cIndex + 1), n.value])
-      }
-
       if (c > n.key) {
         if (n.right === undefined) {
           break
@@ -710,6 +706,9 @@ export const longestPrefixOf = dual<
           n = n.left
         }
       } else {
+        if (n.value !== undefined) {
+          longestPrefixNode = Option.some([key.slice(0, cIndex + 1), n.value.value])
+        }
         if (n.mid === undefined) {
           break
         } else {
@@ -726,7 +725,7 @@ export const longestPrefixOf = dual<
 interface Node<V> {
   key: string
   count: number
-  value?: V | undefined
+  value?: { readonly value: V } | undefined
   left?: Node<V> | undefined
   mid?: Node<V> | undefined
   right?: Node<V> | undefined