effect 4.0.0-rc.118 → 4.0.1

package/src/internal/rcRef.ts

@@ -7,17 +7,26 @@ import { identity } from "../Function.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import type * as RcRef from "../RcRef.ts"
 import * as Scope from "../Scope.ts"
-import * as Semaphore from "../Semaphore.ts"
 
 const TypeId = "~effect/RcRef"
 
-type State<A> = State.Empty | State.Acquired<A> | State.Closed
+type State<A> = State.Empty | State.Acquiring<A> | State.Acquired<A> | State.Closed
 
 declare namespace State {
   interface Empty {
     readonly _tag: "Empty"
   }
 
+  interface Acquiring<A> {
+    readonly _tag: "Acquiring"
+    // Assigned as soon as the acquisition is forked.
+    fiber: Fiber.Fiber<Acquired<A>, unknown>
+    awaiters: number
+    // Set once references are allocated to the waiters, which can happen
+    // before the acquisition fiber exits.
+    acquired: Acquired<A> | undefined
+  }
+
   interface Acquired<A> {
     readonly _tag: "Acquired"
     readonly value: A
@@ -48,7 +57,6 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
   }
 
   state: State<A> = stateEmpty
-  readonly semaphore = Semaphore.makeUnsafe(1)
   readonly acquire: Effect.Effect<A, E>
   readonly context: Context.Context<never>
   readonly scope: Scope.Scope
@@ -85,11 +93,11 @@ export const make = <A, E, R>(options: {
     )
     return Effect.as(
       Scope.addFinalizerExit(scope, () => {
-        const close = ref.state._tag === "Acquired"
-          ? Scope.close(ref.state.scope, Exit.void)
-          : Effect.void
+        const state = ref.state
         ref.state = stateClosed
-        return close
+        if (state._tag === "Acquired") return Scope.close(state.scope, Exit.void)
+        if (state._tag === "Acquiring") return Fiber.interrupt(state.fiber)
+        return Effect.void
       }),
       ref
     )
@@ -110,40 +118,82 @@ const getState = <A, E>(
         ? Effect.as(Fiber.interrupt(state.fiber), state)
         : Effect.succeed(state)
     }
+    case "Acquiring": {
+      const state = self.state
+      state.awaiters++
+      return awaitAcquiring(self, state, restore)
+    }
     case "Empty": {
-      return self.semaphore.withPermit(
-        Effect.suspend(() => {
-          if (self.state._tag !== "Empty") {
-            return getState(self, restore)
+      // The caller that starts the acquisition counts as its first awaiter.
+      const acquiring: State.Acquiring<A> = {
+        _tag: "Acquiring",
+        fiber: undefined as any,
+        awaiters: 1,
+        acquired: undefined
+      }
+      self.state = acquiring
+      const scope = Scope.makeUnsafe()
+      // Acquire on a detached fiber so the acquisition is shared by every
+      // caller and only interrupted once all of them have been interrupted.
+      const acquire = Effect.provideContext(
+        self.acquire as Effect.Effect<A, E>,
+        Context.add(self.context, Scope.Scope, scope)
+      ).pipe(
+        Effect.flatMap((value) => {
+          // The ref was closed, or the acquisition was abandoned.
+          if (self.state !== acquiring) {
+            return Effect.interrupt
+          }
+          const state: State.Acquired<A> = {
+            _tag: "Acquired",
+            value,
+            scope,
+            fiber: undefined,
+            // Every caller still waiting holds a reference.
+            refCount: acquiring.awaiters,
+            invalidated: false
           }
-          const scope = Scope.makeUnsafe()
-          return restore(Effect.provideContext(
-            self.acquire as Effect.Effect<A, E>,
-            Context.add(self.context, Scope.Scope, scope)
-          )).pipe(
-            Effect.flatMap((value) => {
-              if (self.state._tag === "Closed") {
-                return Effect.interrupt
-              }
-              const state: State.Acquired<A> = {
-                _tag: "Acquired",
-                value,
-                scope,
-                fiber: undefined,
-                refCount: 1,
-                invalidated: false
-              }
-              self.state = state
-              return Effect.succeed(state)
-            }),
-            Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)
-          )
+          self.state = state
+          acquiring.acquired = state
+          return Effect.succeed(state)
+        }),
+        Effect.onExit((exit) => {
+          if (Exit.isSuccess(exit)) return Effect.void
+          if (self.state === acquiring) self.state = stateEmpty
+          return Scope.close(scope, exit)
         })
       )
+      acquiring.fiber = Effect.runForkWith(Fiber.getCurrent()!.context)(acquire)
+      return awaitAcquiring(self, acquiring, restore)
     }
   }
 }
 
+const awaitAcquiring = <A, E>(
+  self: RcRefImpl<A, E>,
+  acquiring: State.Acquiring<A>,
+  restore: <AX, EX, RX>(effect: Effect.Effect<AX, EX, RX>) => Effect.Effect<AX, EX, RX>
+): Effect.Effect<State.Acquired<A>, E> =>
+  Effect.onExit(
+    restore(Fiber.join(acquiring.fiber)) as Effect.Effect<State.Acquired<A>, E>,
+    (exit) => {
+      const acquired = acquiring.acquired
+      if (acquired !== undefined) {
+        // The acquisition counted this caller as a reference, possibly before
+        // its fiber exited. Release it if the caller was interrupted before it
+        // could register its finalizer.
+        return Exit.isFailure(exit) ? release(self, acquired) : Effect.void
+      }
+      // Abandon the acquisition once every caller has left, unless it already
+      // failed (a failed acquisition allocated no references).
+      if (--acquiring.awaiters > 0 || self.state !== acquiring) return Effect.void
+      // Detach it first so new callers start a fresh acquisition instead of
+      // joining one that is being interrupted.
+      self.state = stateEmpty
+      return Fiber.interrupt(acquiring.fiber)
+    }
+  )
+
 /** @internal */
 export const get = <A, E>(self_: RcRef.RcRef<A, E>): Effect.Effect<A, E, Scope.Scope> => {
   const self = self_ as RcRefImpl<A, E>

package/src/internal/schema/annotations.ts

@@ -50,9 +50,6 @@ export const resolveTitle = resolveAt<string>("title")
 /** @internal */
 export const resolveDescription = resolveAt<string>("description")
 
-/** @internal */
-export const resolveBrands = resolveAt<ReadonlyArray<string>>("brands")
-
 /** @internal */
 export const getExpected = memoize((ast: SchemaAST.AST): string => {
   const identifier = resolve(ast)?.identifier
@@ -60,18 +57,12 @@ export const getExpected = memoize((ast: SchemaAST.AST): string => {
   return ast.getExpected(getExpected)
 })
 
-/** @internal */
-export function collectBrands(annotations: Schema.Annotations.Annotations | undefined): ReadonlyArray<string> {
-  return annotations !== undefined && Array.isArray(annotations.brands) ? annotations.brands : []
-}
-
 /** @internal */
 export const annotationExcludedKeys = new Set([
   SENTINELS_ANNOTATION_KEY,
   STRUCTURAL_ANNOTATION_KEY,
   "representation",
   "arbitraryConstraint",
-  "brands",
   "toJsonSchema",
   "toCode",
   "toEquivalence",

package/src/internal/schema/codegen.ts

@@ -22,13 +22,21 @@ type Facts = {
   supported: boolean
   outputFree: boolean
   makeSafe: boolean
+  hasOneOf: boolean
   nodes: number
   height: number
 }
 
 const factsCache = new WeakMap<SchemaAST.AST, Facts>()
 
-const unsupportedFacts: Facts = { supported: false, outputFree: false, makeSafe: false, nodes: 1, height: 0 }
+const unsupportedFacts: Facts = {
+  supported: false,
+  outputFree: false,
+  makeSafe: false,
+  hasOneOf: false,
+  nodes: 1,
+  height: 0
+}
 
 const isMakeSafeNode = (ast: SchemaAST.AST): boolean =>
   ast._tag !== "Union" && ast._tag !== "Declaration" && ast._tag !== "Suspend" &&
@@ -59,6 +67,7 @@ const addChild = (
       }
       if (!childFacts.outputFree) facts.outputFree = false
       if (!childFacts.makeSafe) facts.makeSafe = false
+      if (childFacts.hasOneOf) facts.hasOneOf = true
       facts.nodes += childFacts.nodes
       if (childFacts.height >= facts.height) facts.height = childFacts.height + 1
       return true
@@ -89,13 +98,25 @@ const getFacts = (
     return budget.remaining < 0 || depth + cached.height > maxGeneratedDepth ? undefined : cached
   }
   if (--budget.remaining < 0 || depth > maxGeneratedDepth) return undefined
-  const facts: Facts = { supported: true, outputFree: true, makeSafe: true, nodes: 1, height: 0 }
+  const facts: Facts = {
+    supported: true,
+    outputFree: true,
+    makeSafe: true,
+    hasOneOf: ast._tag === "Union" && ast.options?.mode === "oneOf",
+    nodes: 1,
+    height: 0
+  }
   const next = depth + 1
   switch (ast._tag) {
     case "TemplateLiteral":
       for (const part of ast.parts) {
         if (!addChild(facts, part, next, budget)) return stop(ast, facts)
       }
+      // matchPart only segments the input; the tuple parser enforces oneOf.
+      if (facts.hasOneOf) {
+        facts.supported = false
+        return stop(ast, facts)
+      }
       break
     case "Arrays":
       for (const element of ast.elements) {
@@ -297,12 +318,10 @@ const emitUnionHelper = (ast: SchemaAST.Union, emitter: Emitter, operation: Oper
   if (cached !== undefined) return cached
   const name = `u${emitter.next++}`
   emitter.unionHelpers.set(ast, name)
-  const entries = ast.types.map((type, index) =>
-    `[${constant(emitter, type, `${path}.types[${index}]`)},${
-      emitDecoderHelper(type, emitter, operation, `${path}.types[${index}]`)
-    }]`
+  const decoders = ast.types.map((type, index) =>
+    emitDecoderHelper(type, emitter, operation, `${path}.types[${index}]`)
   )
-  emitter.initializers.push(`const ${name}=new Map([${entries.join(",")}])`)
+  emitter.initializers.push(`const ${name}=[${decoders.join(",")}]`)
   return name
 }
 
@@ -607,20 +626,22 @@ const emitBase = (
       const decoder = variable(emitter)
       const types = constant(emitter, ast.types, `${path}.types`)
       const decoders = emitUnionHelper(ast, emitter, operation, path)
+      const select = variable(emitter)
+      emitter.initializers.push(`const ${select}=U(${types})`)
       statements.push(
-        `const ${candidates}=U(${input},${types})`,
+        `const ${candidates}=${select}(${input},false)`,
         `let ${output}=${invalid},${candidate},${decoder}`
       )
       if (ast.options?.mode !== "oneOf") {
         statements.push(
-          `for(let ${index}=0;${index}<${candidates}.length;${index}++){${decoder}=${decoders}.get(${candidates}[${index}]);${candidate}=${decoder}(${input},o);if(${candidate}!==${invalid}){${output}=${candidate};break}}`
+          `for(let ${index}=0;${index}<${candidates}.length;${index}++){${decoder}=${decoders}[${candidates}[${index}]];${candidate}=${decoder}(${input},o);if(${candidate}!==${invalid}){${output}=${candidate};break}}`
         )
         statements.push(`if(${output}===${invalid})return ${invalid}`)
       } else {
         const successes = variable(emitter)
         statements.push(`let ${successes}=0`)
         statements.push(
-          `for(let ${index}=0;${index}<${candidates}.length;${index}++){${decoder}=${decoders}.get(${candidates}[${index}]);${candidate}=${decoder}(${input},o);if(${candidate}!==${invalid}){if(++${successes}>1)return ${invalid};${output}=${candidate}}}`
+          `for(let ${index}=0;${index}<${candidates}.length;${index}++){${decoder}=${decoders}[${candidates}[${index}]];${candidate}=${decoder}(${input},o);if(${candidate}!==${invalid}){if(++${successes}>1)return ${invalid};${output}=${candidate}}}`
         )
         statements.push(`if(${successes}!==1)return ${invalid}`)
       }
@@ -664,7 +685,7 @@ const emitOperation = (ast: SchemaAST.AST, operation: Operation, path = "ast"):
   const bindings = {
     K: "getCheckIssues",
     T: "matchesTemplateLiteral",
-    U: "getCandidates",
+    U: "getCandidateIndex",
     G: "getIndexSignatureKeys",
     D: "defaultParseOptions",
     E: "hasExcessProperties"
@@ -761,17 +782,13 @@ const inlineTypePredicate = (ast: SchemaAST.AST, input: string, path: string): s
     case "BigInt":
       return `typeof ${input}==="bigint"`
     case "TemplateLiteral":
-      return `R.matchesTemplateLiteral(${path},${input},o)`
+      // Its parser reports structured issues, not an InvalidType failure.
+      return undefined
     default:
       return undefined
   }
 }
 
-const inlineIdentityPredicate = (ast: SchemaAST.AST, input: string, path: string): string | undefined =>
-  ast.checks === undefined && getEncodingChecks(ast) === undefined
-    ? inlineTypePredicate(ast, input, path)
-    : undefined
-
 const emitEncoding = (ast: SchemaAST.AST): string | undefined => {
   const links = ast.encoding
   if (links?.length !== 1 || getEncodingChecks(ast) !== undefined) return undefined
@@ -779,7 +796,6 @@ const emitEncoding = (ast: SchemaAST.AST): string | undefined => {
   const transformation = link.transformation
   if (
     link.to.encoding !== undefined ||
-    link.to.checks !== undefined ||
     getEncodingChecks(link.to) !== undefined ||
     transformation._tag !== "Transformation" ||
     transformation.decode._tag !== "Transform"
@@ -790,10 +806,14 @@ const emitEncoding = (ast: SchemaAST.AST): string | undefined => {
   const target = inlineTypePredicate(ast, "value", "ast")
   if (source === undefined || target === undefined) return undefined
   const success = ast.checks === undefined ? "R.succeed(value)" : "R.check(ast,value,o)"
-  return `const transform=ast.encoding[0].transformation.decode.transform;return function(i,o){try{
+  const sourceChecks = link.to.checks === undefined
+    ? ""
+    : "const issues=R.getCheckIssues(from,i,false,o);" +
+      "if(issues!==void 0)return R.invalidEncodingChecks(ast,i,issues,o);"
+  return `const transform=ast.encoding[0].transformation.decode.transform,from=ast.encoding[0].to;return function(i,o){try{
     if(i===R.missing)return R.missingExit;
     if(!(${source}))return R.invalidEncoding(ast,1,i,i,o);
-    const value=transform(i);
+    ${sourceChecks}const value=transform(i);
     if(value===R.missing)return R.missingExit;
     if(!(${target}))return R.invalidEncoding(ast,0,i,value,o);
     return ${success}
@@ -804,10 +824,13 @@ const canInlineEncoding = (ast: SchemaAST.AST): ast is SchemaAST.AST & { readonl
   ast.encoding !== undefined &&
   ast.checks === undefined &&
   getEncodingChecks(ast) === undefined &&
-  inlineIdentityPredicate(ast, "v", "ast") !== undefined &&
-  ast.encoding.every((link) =>
+  inlineTypePredicate(ast, "v", "ast") !== undefined &&
+  ast.encoding.every((link, index, links) =>
     link.to.encoding === undefined &&
-    inlineIdentityPredicate(link.to, "v", "ast") !== undefined &&
+    getEncodingChecks(link.to) === undefined &&
+    // Only the initial source may have checks; they run before any transformation.
+    (link.to.checks === undefined || index === links.length - 1) &&
+    inlineTypePredicate(link.to, "v", "ast") !== undefined &&
     link.transformation._tag === "Transformation" &&
     (link.transformation.decode._tag === "Passthrough" || link.transformation.decode._tag === "Transform")
   )
@@ -818,8 +841,18 @@ const inlinePropertyHandler =
 const emitObject = (ast: SchemaAST.Objects): string => {
   const initializers: Array<string> = []
   const transforms = new Map<object, string>()
+  const bindTransform = (transform: object, path: string): string => {
+    let name = transforms.get(transform)
+    if (name === undefined) {
+      name = `t${transforms.size}`
+      transforms.set(transform, name)
+      initializers.push(`const ${name}=${path}`)
+    }
+    return name
+  }
   let usesInlinePropertyHandler = false
   let usesInlinePropertyFailure = false
+  let usesInlineSourceFailure = false
   const lazyProperties = ast.propertySignatures.every((property) =>
     typeof property.name !== "symbol" && canInlineEncoding(property.type)
   )
@@ -845,51 +878,60 @@ const emitObject = (ast: SchemaAST.Objects): string => {
       const descriptor = lazyProperties ? `p(${index})` : `p${index}`
       const handleInline = `t=handle(state,${index},${descriptor},h${index},v${index},r);if(t)return t`
       const links = property.type.encoding
+      const sourceAst = links[links.length - 1].to
       const sourcePath = `${propertyPath}.encoding[${links.length - 1}].to`
-      const source = inlineIdentityPredicate(links[links.length - 1].to, `v${index}`, sourcePath)!
+      const source = inlineTypePredicate(sourceAst, `v${index}`, sourcePath)!
+      const sourceChecks = sourceAst.checks !== undefined
+      if (sourceChecks) initializers.push(`const s${index}=${sourcePath}`)
+      const checkSource = sourceChecks ? `const c${index}=R.getCheckIssues(s${index},v${index},false,o);` : ""
       // Share cold diagnostics without adding a call to the successful path.
       if (lazyProperties && links.length === 1 && property.name !== "__proto__") {
         usesInlinePropertyFailure = true
         const transformation = links[0].transformation
         let decoded = `v${index}`
         if (transformation._tag === "Transformation" && transformation.decode._tag === "Transform") {
-          let transform = transforms.get(transformation.decode.transform)
-          if (transform === undefined) {
-            transform = `t${transforms.size}`
-            transforms.set(transformation.decode.transform, transform)
-            initializers.push(`const ${transform}=${propertyPath}.encoding[0].transformation.decode.transform`)
-          }
+          const transform = bindTransform(
+            transformation.decode.transform,
+            `${propertyPath}.encoding[0].transformation.decode.transform`
+          )
           decoded = `${transform}(v${index})`
         }
-        const predicate = inlineIdentityPredicate(property.type, `x${index}`, propertyPath)!
+        const predicate = inlineTypePredicate(property.type, `x${index}`, propertyPath)!
+        let run = `const x${index}=${decoded};` +
+          `if(x${index}!==R.missing&&(${predicate})){out[${key}]=x${index}}` +
+          `else{t=invalid(state,${index},h${index},v${index},x${index},o);if(t)return t}`
+        if (sourceChecks) {
+          usesInlineSourceFailure = true
+          run = `${checkSource}if(c${index}===void 0){${run}}` +
+            `else{t=invalidSource(state,${index},h${index},v${index},c${index},o);if(t)return t}`
+        }
         statements.push(
           `const h${index}=${present},v${index}=h${index}?i[${key}]:R.missing`,
-          `if(v${index}!==R.missing&&(${source})){const x${index}=${decoded};` +
-            `if(x${index}!==R.missing&&(${predicate})){out[${key}]=x${index}}` +
-            `else{t=invalid(state,${index},h${index},v${index},x${index},o);if(t)return t}}` +
+          `if(v${index}!==R.missing&&(${source})){${run}}` +
             `else{t=fallbackProperty(state,${index},h${index},v${index},o);if(t)return t}`
         )
         return
       }
       const fast: Array<string> = [`let x${index}=v${index};r=void 0;l${index}:{`]
+      if (sourceChecks) {
+        fast.push(
+          `${checkSource}if(c${index}!==void 0){r=R.invalidEncodingChecks(${descriptor}.type,v${index},c${index},o);break l${index}}`
+        )
+      }
       for (let linkIndex = links.length - 1; linkIndex >= 0; linkIndex--) {
         const transformation = links[linkIndex].transformation
         if (transformation._tag === "Transformation" && transformation.decode._tag === "Transform") {
-          let transform = transforms.get(transformation.decode.transform)
-          if (transform === undefined) {
-            transform = `t${transforms.size}`
-            transforms.set(transformation.decode.transform, transform)
-            initializers.push(
-              `const ${transform}=${propertyPath}.encoding[${linkIndex}].transformation.decode.transform`
-            )
-          }
+          const transform = bindTransform(
+            transformation.decode.transform,
+            `${propertyPath}.encoding[${linkIndex}].transformation.decode.transform`
+          )
           fast.push(`x${index}=${transform}(x${index})`)
         }
         const targetPath = linkIndex === 0
           ? propertyPath
           : `${propertyPath}.encoding[${linkIndex - 1}].to`
         const target = linkIndex === 0 ? property.type : links[linkIndex - 1].to
-        const predicate = inlineIdentityPredicate(target, `x${index}`, targetPath)!
+        const predicate = inlineTypePredicate(target, `x${index}`, targetPath)!
         fast.push(
           `if(x${index}===R.missing){r=R.missingExit;break l${index}}else if(!(${predicate})){r=R.invalidEncoding(${descriptor}.type,${linkIndex},v${index},x${index},o);break l${index}}`
         )
@@ -924,6 +966,11 @@ const emitObject = (ast: SchemaAST.Objects): string => {
       "const fallbackProperty=(state,index,present,input,o)=>{const property=p(index);return handle(state,index,property,present,input,property.parser(input,o))}"
     )
   }
+  if (usesInlineSourceFailure) {
+    initializers.push(
+      "const invalidSource=(state,index,present,input,issues,o)=>{const property=p(index);return handle(state,index,property,present,input,R.invalidEncodingChecks(property.type,input,issues,o))}"
+    )
+  }
   return `function({ast,getProperties,fallback,resume,step}){${initializers.join(";")};return function(i,o){try{${
     statements.join(";")
   }}catch(e){return R.die(e)}}}`

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -1067,13 +1067,15 @@ function translateJsonSchemaMultiDocument(
         )
       case "ignore":
         return undefined
-      case "apply":
+      case "apply": {
+        let regex: RegExp
         try {
-          globalThis.RegExp(pattern, jsonSchemaPatternFlags)
+          regex = globalThis.RegExp(pattern, jsonSchemaPatternFlags)
         } catch {
           throw errorWithPath("Cannot import pattern using ECMAScript Unicode mode.", path)
         }
-        return jsonSchemaFilter("effect/schema/isPattern", { source: pattern, flags: jsonSchemaPatternFlags })
+        return jsonSchemaFilter("effect/schema/isPattern", { source: regex.source, flags: regex.flags })
+      }
     }
   }
 

package/src/internal/schema/toCodeDocument.ts

@@ -297,31 +297,6 @@ export function toCodeDocument(
     return representation?.schemas?.map((schema, index) => recur(schema, [...path, "schemas", index])) ?? []
   }
 
-  function checkBrands(
-    check: SchemaRepresentation.Check
-  ): ReadonlyArray<string> {
-    const own = InternalAnnotations.collectBrands(check.annotations)
-    if (
-      check._tag === "FilterGroup" &&
-      check.annotations?.toCode === undefined
-    ) {
-      return [...own, ...check.checks.flatMap(checkBrands)]
-    }
-    return own
-  }
-
-  function runtimeBrands(brands: ReadonlyArray<string>): string {
-    return brands.length === 0
-      ? ""
-      : `.pipe(${brands.map((brand) => `Schema.brand(${format(brand)})`).join(", ")})`
-  }
-
-  function typeBrands(brands: ReadonlyArray<string>): string {
-    if (brands.length === 0) return ""
-    addImport(`import type * as Brand from "effect/Brand"`)
-    return brands.map((brand) => ` & Brand.Brand<${format(brand)}>`).join("")
-  }
-
   function runtimeAnnotate(
     annotations: Schema.Annotations.Annotations | undefined,
     method: "annotate" | "annotateKey" = "annotate"
@@ -361,25 +336,19 @@ export function toCodeDocument(
   function applyNode(
     base: SchemaRepresentation.Code,
     representation: Exclude<SchemaRepresentation.Representation, SchemaRepresentation.Reference>,
-    path: Path,
-    includeTypeBrands: boolean = true
+    path: Path
   ): SchemaRepresentation.Code {
-    const nodeBrands = InternalAnnotations.collectBrands(representation.annotations)
-    let runtime = base.runtime + runtimeAnnotate(representation.annotations) + runtimeBrands(nodeBrands)
-    let Type = base.Type + (includeTypeBrands ? typeBrands(nodeBrands) : "")
+    let runtime = base.runtime + runtimeAnnotate(representation.annotations)
     for (let index = 0; index < representation.checks.length; index++) {
       const check = representation.checks[index]
-      const brands = checkBrands(check)
-      runtime += `.check(${compileCheck(check, [...path, "checks", index])})${runtimeBrands(brands)}`
-      if (includeTypeBrands) Type += typeBrands(brands)
+      runtime += `.check(${compileCheck(check, [...path, "checks", index])})`
     }
-    return makeCode(runtime, Type)
+    return makeCode(runtime, base.Type)
   }
 
   function recur(
     representation: SchemaRepresentation.Representation,
-    path: Path,
-    includeTypeBrands: boolean = true
+    path: Path
   ): SchemaRepresentation.Code {
     if (representation._tag === "Reference") {
       if (!Object.hasOwn(document.references, representation.$ref)) {
@@ -392,18 +361,14 @@ export function toCodeDocument(
       ) {
         return makeCode(`Schema.suspend((): Schema.Codec<${identifier}> => ${identifier})`, identifier)
       }
-      const Type = includeTypeBrands
-        ? identifier
-        : recur(document.references[representation.$ref], ["references", representation.$ref], false).Type
-      return makeCode(identifier, Type)
+      return makeCode(identifier, identifier)
     }
-    return applyNode(on(representation, path, includeTypeBrands), representation, path, includeTypeBrands)
+    return applyNode(on(representation, path), representation, path)
   }
 
   function on(
     representation: Exclude<SchemaRepresentation.Representation, SchemaRepresentation.Reference>,
-    path: Path,
-    includeTypeBrands: boolean
+    path: Path
   ): SchemaRepresentation.Code {
     switch (representation._tag) {
       case "Declaration": {
@@ -473,7 +438,7 @@ export function toCodeDocument(
         return makeCode(`Schema.Enum(${identifier})`, identifier)
       }
       case "TemplateLiteral": {
-        const parts = representation.parts.map((part, index) => recur(part, [...path, "parts", index], false))
+        const parts = representation.parts.map((part, index) => recur(part, [...path, "parts", index]))
         const Type = `\`${parts.map((part) => `\${${part.Type}}`).join("")}\``
         return makeCode(`Schema.TemplateLiteral([${parts.map((part) => part.runtime).join(", ")}])`, Type)
       }
@@ -576,9 +541,7 @@ export function toCodeDocument(
             ? makeCode(`Schema.Literal(${literals[0]})`, literals[0])
             : makeCode(`Schema.Literals([${literals.join(", ")}])`, literals.join(" | "))
         }
-        const types = representation.types.map((type, index) =>
-          recur(type, [...path, "types", index], includeTypeBrands)
-        )
+        const types = representation.types.map((type, index) => recur(type, [...path, "types", index]))
         const options = representation.options === undefined
           ? ""
           : `, ${unionOptionsRuntime(representation.options)}`

package/src/internal/schema/toCodec.ts

@@ -33,22 +33,9 @@ function validateCanonicalObjectPropertyNames(ast: SchemaAST.Objects): void {
 
 function makeReorder(getPriority: (ast: SchemaAST.AST) => number) {
   return (types: ReadonlyArray<SchemaAST.AST>): ReadonlyArray<SchemaAST.AST> => {
-    // Create a map of original indices for O(1) lookup
-    const indexMap = new Map<SchemaAST.AST, number>()
-    for (let i = 0; i < types.length; i++) {
-      indexMap.set(SchemaAST.toEncoded(types[i]), i)
-    }
-
-    // Create a sorted copy of the types array
-    const sortedTypes = [...types].sort((a, b) => {
-      a = SchemaAST.toEncoded(a)
-      b = SchemaAST.toEncoded(b)
-      const pa = getPriority(a)
-      const pb = getPriority(b)
-      if (pa !== pb) return pa - pb
-      // If priorities are equal, maintain original order (stable sort)
-      return indexMap.get(a)! - indexMap.get(b)!
-    })
+    const sortedTypes = [...types].sort((a, b) =>
+      getPriority(SchemaAST.toEncoded(a)) - getPriority(SchemaAST.toEncoded(b))
+    )
 
     // Check if order changed by comparing arrays
     const orderChanged = sortedTypes.some((ast, index) => ast !== types[index])

package/src/internal/schema/toEquivalence.ts

@@ -136,13 +136,12 @@ function recur(ast: SchemaAST.AST): Equivalence.Equivalence<any> {
     }
     case "Union": {
       const types = SchemaAST.toType(ast).types
-      const compiled = new Map(
-        types.map((candidate, i) => [candidate, [SchemaParser._is(candidate), recur(ast.types[i])] as const] as const)
-      )
+      const index = SchemaAST.getCandidateIndex(types)
+      const compiled = types.map((candidate, i) => [SchemaParser._is(candidate), recur(ast.types[i])] as const)
       return Equivalence.make((a, b) => {
-        const candidates = SchemaAST.getCandidates(a, types)
+        const candidates = index(a, false)
         for (let i = 0; i < candidates.length; i++) {
-          const [is, equivalence] = compiled.get(candidates[i])!
+          const [is, equivalence] = compiled[candidates[i]]
           if (is(a) && is(b)) {
             return equivalence(a, b)
           }

package/src/internal/schema/toFormatter.ts

@@ -217,14 +217,12 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
       }
       case "Union": {
         const types = SchemaAST.toType(ast).types
-        const getCandidates = (value: any) => SchemaAST.getCandidates(value, types)
-        const compiled = new Map(
-          types.map((candidate, i) => [candidate, [SchemaParser._is(candidate), recur(ast.types[i])] as const] as const)
-        )
+        const index = SchemaAST.getCandidateIndex(types)
+        const compiled = types.map((candidate, i) => [SchemaParser._is(candidate), recur(ast.types[i])] as const)
         return (value) => {
-          const candidates = getCandidates(value)
+          const candidates = index(value, false)
           for (let i = 0; i < candidates.length; i++) {
-            const [is, formatter] = compiled.get(candidates[i])!
+            const [is, formatter] = compiled[candidates[i]]
             if (is(value)) {
               return formatter(value)
             }