effect 4.0.0-beta.84 → 4.0.0-beta.86

package/src/SchemaAST.ts

@@ -25,7 +25,6 @@ import * as InternalSchemaCause from "./internal/schema/cause.ts"
 import * as Option from "./Option.ts"
 import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
-import * as RegEx from "./RegExp.ts"
 import * as Result from "./Result.ts"
 import type * as Schema from "./Schema.ts"
 import * as SchemaGetter from "./SchemaGetter.ts"
@@ -679,19 +678,19 @@ export class Declaration extends Base {
       return Effect.mapEager(run(oinput.value, this, options), Option.some)
     }
   }
-  private rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
+  private _rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
     const tps = mapOrSame(this.typeParameters, recur)
-    return tps === this.typeParameters ?
+    return tps === this.typeParameters && checks === this.checks && encodingChecks === this.encodingChecks ?
       this :
       new Declaration(tps, this.run, this.annotations, checks, undefined, this.context, encodingChecks)
   }
   /** @internal */
   recur(recur: (ast: AST) => AST) {
-    return this.rebuild(recur, this.checks, this.encodingChecks)
+    return this._rebuild(recur, this.checks, this.encodingChecks)
   }
   /** @internal */
   flip(recur: (ast: AST) => AST) {
-    return this.rebuild(recur, this.encodingChecks, this.checks)
+    return this._rebuild(recur, this.encodingChecks, this.checks)
   }
   /** @internal */
   getExpected(): string {
@@ -1066,11 +1065,12 @@ function isTemplateLiteralPart(ast: AST): ast is TemplateLiteralPart {
     case "String":
     case "Number":
     case "BigInt":
+      return true
     case "Literal":
     case "TemplateLiteral":
-      return true
+      return ast.checks === undefined
     case "Union":
-      return ast.types.every(isTemplateLiteralPart)
+      return ast.checks === undefined && ast.types.every(isTemplateLiteralPart)
     default:
       return false
   }
@@ -1082,8 +1082,7 @@ function isTemplateLiteralPart(ast: AST): ast is TemplateLiteralPart {
  *
  * **Details**
  *
- * `parts` is an array of AST nodes; each part contributes to the
- * template literal pattern. A regex is derived from the parts to validate
+ * `parts` is an array of AST nodes; each part contributes to matching
  * strings at runtime.
  *
  * @see {@link isTemplateLiteral}
@@ -1130,19 +1129,22 @@ export class TemplateLiteral extends Base {
     return "string"
   }
   /** @internal */
+  matchPart(s: string, options: ParseOptions): string | undefined {
+    return segmentTemplateLiteralParts(this.encodedParts, s, options) === undefined ? undefined : s
+  }
+  /** @internal */
   asTemplateLiteralParser(): Arrays {
-    const tuple = new Arrays(false, this.parts.map(templateLiteralPartFromString), [])
-    const regExp = getTemplateLiteralRegExp(this)
+    const tuple = new Arrays(false, this.parts.map(partFromString), [])
     return decodeTo(
       string,
       tuple,
       new SchemaTransformation.Transformation(
-        SchemaGetter.transformOrFail((s: string) => {
-          const match = regExp.exec(s)
-          if (match) return Effect.succeed(match.slice(1, this.parts.length + 1))
+        SchemaGetter.transformOrFail((s: string, options) => {
+          const segments = segmentTemplateLiteralParts(this.encodedParts, s, options)
+          if (segments !== undefined) return Effect.succeed(segments)
           return Effect.fail(
             new SchemaIssue.InvalidValue(Option.some(s), {
-              message: `Expected a value matching ${regExp.source}, got ${format(s)}`
+              message: `Expected a string matching template literal parts, got ${format(s)}`
             })
           )
         }),
@@ -1248,6 +1250,10 @@ export class Literal extends Base {
     return fromConst(this, this.literal)
   }
   /** @internal */
+  matchPart(s: string, _options: ParseOptions): LiteralValue | undefined {
+    return s === globalThis.String(this.literal) ? this.literal : undefined
+  }
+  /** @internal */
   toCodecJson(): AST {
     return typeof this.literal === "bigint" ? literalToString(this) : this
   }
@@ -1290,6 +1296,10 @@ export class String extends Base {
     return fromRefinement(this, Predicate.isString)
   }
   /** @internal */
+  matchPart(s: string, options: ParseOptions): string | undefined {
+    return applyTemplateLiteralPartChecks(this, s, options)
+  }
+  /** @internal */
   getExpected(): string {
     return "string"
   }
@@ -1336,6 +1346,19 @@ export class Number extends Base {
     return fromRefinement(this, Predicate.isNumber)
   }
   /** @internal */
+  matchKey(s: string, options: ParseOptions): number | undefined {
+    return this._match(isStringNumberRegExp, s, options)
+  }
+  /** @internal */
+  matchPart(s: string, options: ParseOptions): number | undefined {
+    return this._match(isStringFiniteRegExp, s, options)
+  }
+  private _match(regexp: RegExp, s: string, options: ParseOptions): number | undefined {
+    return regexp.test(s)
+      ? applyTemplateLiteralPartChecks(this, globalThis.Number(s), options)
+      : undefined
+  }
+  /** @internal */
   toCodecJson(): AST {
     if (this.checks && (hasCheck(this.checks, "isFinite") || hasCheck(this.checks, "isInt"))) {
       return this
@@ -1445,6 +1468,10 @@ export class Symbol extends Base {
     return fromRefinement(this, Predicate.isSymbol)
   }
   /** @internal */
+  matchKey(s: symbol, options: ParseOptions): symbol | undefined {
+    return applyTemplateLiteralPartChecks(this, s, options)
+  }
+  /** @internal */
   toCodecStringTree(): AST {
     return replaceEncoding(this, [symbolToString])
   }
@@ -1494,6 +1521,12 @@ export class BigInt extends Base {
     return fromRefinement(this, Predicate.isBigInt)
   }
   /** @internal */
+  matchPart(s: string, options: ParseOptions): bigint | undefined {
+    return isStringBigIntRegExp.test(s)
+      ? applyTemplateLiteralPartChecks(this, globalThis.BigInt(s), options)
+      : undefined
+  }
+  /** @internal */
   toCodecStringTree(): AST {
     return replaceEncoding(this, [bigIntToString])
   }
@@ -1668,10 +1701,11 @@ export class Arrays extends Base {
       return Option.some(state.output)
     })
   }
-  private rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
+  private _rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
     const elements = mapOrSame(this.elements, recur)
     const rest = mapOrSame(this.rest, recur)
-    return elements === this.elements && rest === this.rest ?
+    return elements === this.elements && rest === this.rest && checks === this.checks &&
+        encodingChecks === this.encodingChecks ?
       this :
       new Arrays(
         this.isMutable,
@@ -1686,11 +1720,11 @@ export class Arrays extends Base {
   }
   /** @internal */
   recur(recur: (ast: AST) => AST) {
-    return this.rebuild(recur, this.checks, this.encodingChecks)
+    return this._rebuild(recur, this.checks, this.encodingChecks)
   }
   /** @internal */
   flip(recur: (ast: AST) => AST) {
-    return this.rebuild(recur, this.encodingChecks, this.checks)
+    return this._rebuild(recur, this.encodingChecks, this.checks)
   }
   /** @internal */
   getExpected(): string {
@@ -1783,33 +1817,36 @@ const wrapPropertyKeyIssue = (
  */
 export const FINITE_PATTERN = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?"
 
-const isNumberStringRegExp = new globalThis.RegExp(`(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)`)
-
 /**
  * Returns the object keys that match the index signature parameter schema.
  * @internal
  */
 export function getIndexSignatureKeys(
   input: { readonly [x: PropertyKey]: unknown },
-  parameter: AST
+  parameter: IndexSignatureParameter,
+  options: ParseOptions = defaultParseOptions
 ): ReadonlyArray<PropertyKey> {
-  const encoded = toEncoded(parameter)
-  switch (encoded._tag) {
-    case "String":
-      return Object.keys(input)
-    case "TemplateLiteral": {
-      const regExp = getTemplateLiteralRegExp(encoded)
-      return Object.keys(input).filter((k) => regExp.test(k))
+  let stringKeys: ReadonlyArray<string> | undefined
+  let symbolKeys: ReadonlyArray<symbol> | undefined
+
+  function go(parameter: AST): ReadonlyArray<PropertyKey> {
+    switch (parameter._tag) {
+      case "String":
+      case "TemplateLiteral":
+        return (stringKeys ??= Object.keys(input)).filter((k) => parameter.matchPart(k, options) !== undefined)
+      case "Number":
+        return (stringKeys ??= Object.keys(input)).filter((k) => parameter.matchKey(k, options) !== undefined)
+      case "Symbol":
+        return (symbolKeys ??= Object.getOwnPropertySymbols(input)).filter((k) =>
+          parameter.matchKey(k, options) !== undefined
+        )
+      case "Union":
+        return [...new Set(parameter.types.flatMap(go))]
+      default:
+        return []
     }
-    case "Symbol":
-      return Object.getOwnPropertySymbols(input)
-    case "Number":
-      return Object.keys(input).filter((k) => isNumberStringRegExp.test(k))
-    case "Union":
-      return [...new Set(encoded.types.flatMap((t) => getIndexSignatureKeys(input, t)))]
-    default:
-      return []
   }
+  return go(parameterFromPropertyKey(toEncoded(parameter)))
 }
 
 /**
@@ -1869,6 +1906,31 @@ export class KeyValueCombiner {
   }
 }
 
+type IndexSignatureParameter =
+  | String
+  | Number
+  | Symbol
+  | TemplateLiteral
+  | Union<IndexSignatureParameter>
+
+function isIndexSignatureParameterSide(ast: AST): ast is IndexSignatureParameter {
+  switch (ast._tag) {
+    case "String":
+    case "Number":
+    case "Symbol":
+    case "TemplateLiteral":
+      return true
+    case "Union":
+      return ast.types.every(isIndexSignatureParameterSide)
+    default:
+      return false
+  }
+}
+
+function isIndexSignatureParameter(ast: AST): ast is IndexSignatureParameter {
+  return isIndexSignatureParameterSide(ast) && isIndexSignatureParameterSide(toEncoded(ast))
+}
+
 /**
  * Represents an index signature entry within an {@link Objects} node.
  *
@@ -1895,7 +1957,7 @@ export class KeyValueCombiner {
  * @since 3.10.0
  */
 export class IndexSignature {
-  readonly parameter: AST
+  readonly parameter: IndexSignatureParameter
   readonly type: AST
   readonly merge: KeyValueCombiner | undefined
 
@@ -1904,6 +1966,9 @@ export class IndexSignature {
     type: AST,
     merge: KeyValueCombiner | undefined
   ) {
+    if (!isIndexSignatureParameter(parameter)) {
+      throw new Error(`Invalid index signature parameter ${parameter._tag}`)
+    }
     this.parameter = parameter
     this.type = type
     this.merge = merge
@@ -2026,7 +2091,7 @@ export class Objects extends Base {
           s,
           [key, is]
         ) {
-          const parserKey = recur(indexSignatureParameterFromString(is.parameter))
+          const parserKey = recur(parameterFromPropertyKey(is.parameter))
           const effKey = parserKey(Option.some(key), s.options)
           const exitKey = (effectIsExit(effKey) ? effKey : yield* Effect.exit(effKey)) as Exit.Exit<
             Option.Option<PropertyKey>,
@@ -2133,7 +2198,7 @@ export class Objects extends Base {
         const keyPairs = Arr.empty<[PropertyKey, IndexSignature]>()
         for (let i = 0; i < indexCount; i++) {
           const is = ast.indexSignatures[i]
-          const keys = getIndexSignatureKeys(input, is.parameter)
+          const keys = getIndexSignatureKeys(input, is.parameter, options)
           for (let j = 0; j < keys.length; j++) {
             const key = keys[j]
             keyPairs.push([key, is])
@@ -2160,8 +2225,9 @@ export class Objects extends Base {
       return Option.some(out)
     })
   }
-  private rebuild(
+  private _rebuild(
     recur: (ast: AST) => AST,
+    recurParameter: (ast: AST) => AST,
     flipMerge: boolean,
     checks: Checks | undefined,
     encodingChecks: Checks | undefined
@@ -2172,7 +2238,7 @@ export class Objects extends Base {
     })
 
     const indexes = mapOrSame(this.indexSignatures, (is) => {
-      const p = recur(is.parameter)
+      const p = recurParameter(is.parameter)
       const t = recur(is.type)
       const merge = flipMerge ? is.merge?.flip() : is.merge
       return p === is.parameter && t === is.type && merge === is.merge
@@ -2180,7 +2246,8 @@ export class Objects extends Base {
         : new IndexSignature(p, t, merge)
     })
 
-    return props === this.propertySignatures && indexes === this.indexSignatures
+    return props === this.propertySignatures && indexes === this.indexSignatures && checks === this.checks &&
+        encodingChecks === this.encodingChecks
       ? this
       : new Objects(
         props,
@@ -2194,11 +2261,11 @@ export class Objects extends Base {
   }
   /** @internal */
   flip(recur: (ast: AST) => AST): AST {
-    return this.rebuild(recur, true, this.encodingChecks, this.checks)
+    return this._rebuild(recur, recur, true, this.encodingChecks, this.checks)
   }
   /** @internal */
-  recur(recur: (ast: AST) => AST): AST {
-    return this.rebuild(recur, false, this.checks, this.encodingChecks)
+  recur(recur: (ast: AST) => AST, recurParameter: (ast: AST) => AST = recur): AST {
+    return this._rebuild(recur, recurParameter, false, this.checks, this.encodingChecks)
   }
   /** @internal */
   getExpected(): string {
@@ -2257,14 +2324,10 @@ const parseProperties = iterateEager<{
   }
 })
 
-function mergeChecks(checks: Checks | undefined, b: AST): Checks | undefined {
-  if (!checks) {
-    return b.checks
-  }
-  if (!b.checks) {
-    return checks
-  }
-  return [...checks, ...b.checks]
+function combineChecks(a: Checks | undefined, b: Checks | undefined): Checks | undefined {
+  if (!a) return b
+  if (!b) return a
+  return [...a, ...b]
 }
 
 /** @internal */
@@ -2284,7 +2347,7 @@ export function struct<Fields extends Schema.Struct.Fields>(
 }
 
 /** @internal */
-export function getAST<S extends Schema.Top>(self: S): S["ast"] {
+export function getAST<S extends { readonly ast: AST }>(self: S): S["ast"] {
   return self.ast
 }
 
@@ -2297,7 +2360,7 @@ export function tuple<Elements extends Schema.Tuple.Elements>(
 }
 
 /** @internal */
-export function union<Members extends ReadonlyArray<Schema.Top>>(
+export function union<Members extends ReadonlyArray<{ readonly ast: AST }>>(
   members: Members,
   mode: "anyOf" | "oneOf",
   checks: Checks | undefined
@@ -2313,10 +2376,10 @@ export function structWithRest(ast: Objects, records: ReadonlyArray<Objects>): O
   let propertySignatures = ast.propertySignatures
   let indexSignatures = ast.indexSignatures
   let checks = ast.checks
-  for (const r of records) {
-    propertySignatures = propertySignatures.concat(r.propertySignatures)
-    indexSignatures = indexSignatures.concat(r.indexSignatures)
-    checks = mergeChecks(checks, r)
+  for (const record of records) {
+    propertySignatures = propertySignatures.concat(record.propertySignatures)
+    indexSignatures = indexSignatures.concat(record.indexSignatures)
+    checks = combineChecks(checks, record.checks)
   }
   return new Objects(propertySignatures, indexSignatures, undefined, checks)
 }
@@ -2598,19 +2661,27 @@ export class Union<A extends AST = AST> extends Base {
       })
     }
   }
-  private rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
+  private _rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
     const types = mapOrSame(this.types, recur)
-    return types === this.types ?
+    return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ?
       this :
       new Union(types, this.mode, this.annotations, checks, undefined, this.context, encodingChecks)
   }
   /** @internal */
   recur(recur: (ast: AST) => AST) {
-    return this.rebuild(recur, this.checks, this.encodingChecks)
+    return this._rebuild(recur, this.checks, this.encodingChecks)
   }
   /** @internal */
   flip(recur: (ast: AST) => AST) {
-    return this.rebuild(recur, this.encodingChecks, this.checks)
+    return this._rebuild(recur, this.encodingChecks, this.checks)
+  }
+  /** @internal */
+  matchPart(s: string, options: ParseOptions): LiteralValue | undefined {
+    for (const type of this.types) {
+      const out = (type as TemplateLiteralPart).matchPart(s, options)
+      if (out !== undefined) return out
+    }
+    return undefined
   }
   /** @internal */
   getExpected(getExpected: (ast: AST) => string): string {
@@ -2791,19 +2862,6 @@ export class Suspend extends Base {
   }
 }
 
-/** @internal */
-export function getEncodingChecks(ast: AST): Checks | undefined {
-  switch (ast._tag) {
-    case "Declaration":
-    case "Arrays":
-    case "Objects":
-    case "Union":
-      return ast.encodingChecks
-    default:
-      return undefined
-  }
-}
-
 // -----------------------------------------------------------------------------
 // Checks
 // -----------------------------------------------------------------------------
@@ -3052,8 +3110,8 @@ export function replaceChecks<A extends AST>(ast: A, checks: Checks | undefined)
 }
 
 /** @internal */
-export function appendChecks<A extends AST>(ast: A, checks: Checks): A {
-  return replaceChecks(ast, ast.checks ? [...ast.checks, ...checks] : checks)
+export function appendChecks<A extends AST>(ast: A, checks: Checks | undefined): A {
+  return replaceChecks(ast, combineChecks(ast.checks, checks))
 }
 
 function updateLastLink(encoding: Encoding, f: (ast: AST) => AST): Encoding {
@@ -3071,6 +3129,14 @@ export function applyToLastLink(f: (ast: AST) => AST) {
   return <A extends AST>(ast: A): A => ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, f)) : ast
 }
 
+/** @internal */
+export function applyToSelfOrLastLinkEncoding(f: (ast: AST) => AST) {
+  function out(ast: AST): AST {
+    return ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, out)) : f(ast)
+  }
+  return memoize(out)
+}
+
 /** @internal */
 export function middlewareDecoding(
   ast: AST,
@@ -3222,39 +3288,31 @@ function parseParameter(ast: AST): {
   literals: ReadonlyArray<PropertyKey>
   parameters: ReadonlyArray<AST>
 } {
-  switch (ast._tag) {
-    case "Literal":
-      return {
-        literals: Predicate.isPropertyKey(ast.literal) ? [ast.literal] : [],
-        parameters: []
-      }
-    case "UniqueSymbol":
-      return {
-        literals: [ast.symbol],
-        parameters: []
-      }
-    case "String":
-    case "Number":
-    case "Symbol":
-    case "TemplateLiteral":
-      return {
-        literals: [],
-        parameters: [ast]
-      }
-    case "Union": {
-      const out: {
-        literals: ReadonlyArray<PropertyKey>
-        parameters: ReadonlyArray<AST>
-      } = { literals: [], parameters: [] }
-      for (let i = 0; i < ast.types.length; i++) {
-        const parsed = parseParameter(ast.types[i])
-        out.literals = out.literals.concat(parsed.literals)
-        out.parameters = out.parameters.concat(parsed.parameters)
-      }
-      return out
+  const literals: Array<PropertyKey> = []
+  const parameters: Array<AST> = []
+  function go(ast: AST) {
+    switch (ast._tag) {
+      case "Literal":
+        if (Predicate.isPropertyKey(ast.literal)) {
+          literals.push(ast.literal)
+        }
+        return
+      case "UniqueSymbol":
+        literals.push(ast.symbol)
+        return
+      case "Never":
+        return
+      case "Union":
+        for (let i = 0; i < ast.types.length; i++) {
+          go(ast.types[i])
+        }
+        return
+      default:
+        parameters.push(ast)
     }
   }
-  return { literals: [], parameters: [] }
+  go(ast)
+  return { literals, parameters }
 }
 
 /** @internal */
@@ -3323,9 +3381,13 @@ export const toType = memoize(<A extends AST>(ast: A): A => {
   }
   const out: any = ast
   const type = out.recur?.(toType) ?? out
-  if (getEncodingChecks(type)) {
+  const encodingChecks = type.encodingChecks
+  if (encodingChecks) {
     return modifyOwnPropertyDescriptors(type, (d) => {
       d.encodingChecks.value = undefined
+      if (type === ast) {
+        d.checks.value = combineChecks(type.checks, encodingChecks)
+      }
     })
   }
   return type
@@ -3416,45 +3478,6 @@ export function containsUndefined(ast: AST): boolean {
   }
 }
 
-function getTemplateLiteralSource(ast: TemplateLiteral, top: boolean): string {
-  return ast.encodedParts.map((part) =>
-    handleTemplateLiteralASTPartParens(part, getTemplateLiteralASTPartPattern(part), top)
-  ).join("")
-}
-
-/** @internal */
-export const getTemplateLiteralRegExp = memoize((ast: TemplateLiteral): RegExp => {
-  return new globalThis.RegExp(`^${getTemplateLiteralSource(ast, true)}$`)
-})
-
-function getTemplateLiteralASTPartPattern(part: TemplateLiteralPart): string {
-  switch (part._tag) {
-    case "Literal":
-      return RegEx.escape(globalThis.String(part.literal))
-    case "String":
-      return STRING_PATTERN
-    case "Number":
-      return FINITE_PATTERN
-    case "BigInt":
-      return BIGINT_PATTERN
-    case "TemplateLiteral":
-      return getTemplateLiteralSource(part, false)
-    case "Union":
-      return part.types.map(getTemplateLiteralASTPartPattern).join("|")
-  }
-}
-
-function handleTemplateLiteralASTPartParens(part: TemplateLiteralPart, s: string, top: boolean): string {
-  if (isUnion(part)) {
-    if (!top) {
-      return `(?:${s})`
-    }
-  } else if (!top) {
-    return s
-  }
-  return `(${s})`
-}
-
 function fromConst<const T>(
   ast: AST,
   value: T
@@ -3484,6 +3507,52 @@ function fromRefinement<T>(
   }
 }
 
+function applyTemplateLiteralPartChecks<A>(ast: AST, value: A, options: ParseOptions): A | undefined {
+  if (options?.disableChecks || ast.checks === undefined) return value
+  const issues: Array<SchemaIssue.Issue> = []
+  collectIssues(ast.checks, value, issues, ast, options)
+  return issues.length === 0 ? value : undefined
+}
+
+function segmentTemplateLiteralParts(
+  parts: ReadonlyArray<TemplateLiteralPart>,
+  input: string,
+  options: ParseOptions
+): Array<string> | undefined {
+  const out = new Array<string>(parts.length)
+  const failures = new Set<string>()
+  function go(i: number, pos: number): boolean {
+    if (i === parts.length) return pos === input.length
+    const key = `${i}/${pos}`
+    if (failures.has(key)) return false
+    const part = parts[i]
+    if (i === parts.length - 1) {
+      const s = input.slice(pos)
+      if (part.matchPart(s, options) !== undefined) {
+        out[i] = s
+        return true
+      }
+    } else if (part._tag === "Literal") {
+      const s = globalThis.String(part.literal)
+      if (input.startsWith(s, pos) && go(i + 1, pos + s.length)) {
+        out[i] = s
+        return true
+      }
+    } else {
+      for (let end = input.length; end >= pos; end--) {
+        const s = input.slice(pos, end)
+        if (part.matchPart(s, options) !== undefined && go(i + 1, end)) {
+          out[i] = s
+          return true
+        }
+      }
+    }
+    failures.add(key)
+    return false
+  }
+  return go(0, 0) ? out : undefined
+}
+
 /** @internal */
 export const enumsToLiterals = memoize((ast: Enum): Union<Literal> => {
   return new Union(
@@ -3492,38 +3561,40 @@ export const enumsToLiterals = memoize((ast: Enum): Union<Literal> => {
   )
 })
 
-/** @internal */
-export function toCodec(f: (ast: AST) => AST) {
-  function out(ast: AST): AST {
-    return ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, out)) : f(ast)
-  }
-  return memoize(out)
-}
-
-const indexSignatureParameterFromString = toCodec((ast) => {
+const parameterFromPropertyKey = applyToSelfOrLastLinkEncoding((ast) => {
   switch (ast._tag) {
     default:
       return ast
     case "Number":
       return ast.toCodecStringTree()
     case "Union":
-      return ast.recur(indexSignatureParameterFromString)
+      return ast.recur(parameterFromPropertyKey)
   }
 })
 
-const templateLiteralPartFromString = toCodec((ast) => {
+/** @internal */
+export const parameterFromString = applyToSelfOrLastLinkEncoding((ast) => {
   switch (ast._tag) {
     default:
       return ast
-    case "String":
-    case "TemplateLiteral":
+    case "Symbol":
+    case "UniqueSymbol":
+      return ast.toCodecStringTree()
+    case "Union":
+      return ast.recur(parameterFromString)
+  }
+})
+
+const partFromString = applyToSelfOrLastLinkEncoding((ast) => {
+  switch (ast._tag) {
+    default:
       return ast
-    case "BigInt":
     case "Number":
     case "Literal":
+    case "BigInt":
       return ast.toCodecStringTree()
     case "Union":
-      return ast.recur(templateLiteralPartFromString)
+      return ast.recur(partFromString)
   }
 })
 
@@ -3535,6 +3606,8 @@ export const STRING_PATTERN = "[\\s\\S]*?"
 
 const isStringFiniteRegExp = new globalThis.RegExp(`^${FINITE_PATTERN}$`)
 
+const isStringNumberRegExp = new globalThis.RegExp(`(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)`)
+
 /** @internal */
 export function isStringFinite(annotations?: Schema.Annotations.Filter) {
   return isPattern(
@@ -3890,10 +3963,7 @@ const StringTree = new Declaration(
     isStringTree(input) ?
       Effect.succeed(input) :
       Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input))),
-  {
-    expected: "StringTree",
-    toCodecStringTree: () => new Link(unknown, SchemaTransformation.passthrough())
-  }
+  { expected: "StringTree" }
 )
 
 /** @internal */