effect 4.0.0-rc.118 → 4.0.0

package/src/internal/effect.ts

@@ -1156,7 +1156,7 @@ const callbackOptions: <A, E = never, R = never>(
     this: Scheduler.Scheduler,
     resume: (effect: Effect.Effect<A, E, R>) => void,
     signal?: AbortSignal
-  ) => void | Effect.Effect<void, never, R>,
+  ) => void | Effect.Effect<void, E, R>,
   withSignal: boolean
 ) => Effect.Effect<A, E, R> = (function() {
   const Proto = makePrimitiveProto({
@@ -1214,7 +1214,7 @@ const asyncFinalizer: (
   },
   [contE](cause, _fiber) {
     return hasInterrupts(cause)
-      ? flatMap(this[args](), () => failCause(cause))
+      ? flatMap(combineFinalizerCause(exitFailCause(cause), this[args]()), () => failCause(cause))
       : failCause(cause)
   }
 })
@@ -1225,7 +1225,7 @@ export const callback = <A, E = never, R = never>(
     this: Scheduler.Scheduler,
     resume: (effect: Effect.Effect<A, E, R>) => void,
     signal: AbortSignal
-  ) => void | Effect.Effect<void, never, R>
+  ) => void | Effect.Effect<void, E, R>
 ): Effect.Effect<A, E, R> => callbackOptions(register as any, register.length >= 2)
 
 /** @internal */
@@ -1632,13 +1632,15 @@ export const raceAll = <Eff extends Effect.Effect<any, any, any>>(
   Effect.Error<Eff>,
   Effect.Services<Eff>
 > =>
-  withFiber((parent) =>
-    callback((resume) => {
+  withFiber((parent) => {
+    const fibers = new Set<Fiber.Fiber<any, any>>()
+    // Read fibers on exit to include losers forked after the race settles.
+    onExitUnsafe(parent, () => fibers.size === 0 ? undefined : fiberInterruptAll(fibers))
+    return callback((resume) => {
       const effects = Arr.fromIterable(all)
       const len = effects.length
       let doneCount = 0
       let done = false
-      const fibers = new Set<Fiber.Fiber<any, any>>()
       const failures: Array<Cause.Reason<any>> = []
       const onExit = (exit: Exit.Exit<any, any>, fiber: Fiber.Fiber<any, any>, i: number) => {
         doneCount++
@@ -1651,11 +1653,7 @@ export const raceAll = <Eff extends Effect.Effect<any, any, any>>(
         }
         const isWinner = !done
         done = true
-        resume(
-          fibers.size === 0
-            ? exit
-            : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit)
-        )
+        resume(exit)
         if (isWinner && options?.onWinner) {
           options.onWinner({ fiber, index: i, parentFiber: parent })
         }
@@ -1670,10 +1668,8 @@ export const raceAll = <Eff extends Effect.Effect<any, any, any>>(
         })
         if (done) break
       }
-
-      return fiberInterruptAll(fibers)
     })
-  )
+  })
 
 /** @internal */
 export const raceAllFirst = <Eff extends Effect.Effect<any, any, any>>(
@@ -1690,19 +1686,11 @@ export const raceAllFirst = <Eff extends Effect.Effect<any, any, any>>(
   Effect.Error<Eff>,
   Effect.Services<Eff>
 > =>
-  withFiber((parent) =>
-    callback((resume) => {
+  withFiber((parent) => {
+    const fibers = new Set<Fiber.Fiber<any, any>>()
+    onExitUnsafe(parent, () => fibers.size === 0 ? undefined : fiberInterruptAll(fibers))
+    return callback((resume) => {
       let done = false
-      const fibers = new Set<Fiber.Fiber<any, any>>()
-      const onExit = (exit: Exit.Exit<any, any>) => {
-        done = true
-        resume(
-          fibers.size === 0
-            ? exit
-            : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit)
-        )
-      }
-
       let i = 0
       for (const effect of all) {
         if (done) break
@@ -1712,16 +1700,15 @@ export const raceAllFirst = <Eff extends Effect.Effect<any, any, any>>(
         fiber.addObserver((exit) => {
           fibers.delete(fiber)
           const isWinner = !done
-          onExit(exit)
+          done = true
+          resume(exit)
           if (isWinner && options?.onWinner) {
             options.onWinner({ fiber, index, parentFiber: parent })
           }
         })
       }
-
-      return fiberInterruptAll(fibers)
     })
-  )
+  })
 
 /** @internal */
 export const race: {
@@ -4719,19 +4706,19 @@ export const partition: {
   <A, B, E, R>(
     f: (a: A, i: number) => Effect.Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
+  ): (elements: Iterable<A>) => Effect.Effect<[passes: Array<B>, fails: Array<E>], never, R>
   <A, B, E, R>(
     elements: Iterable<A>,
     f: (a: A, i: number) => Effect.Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
+  ): Effect.Effect<[passes: Array<B>, fails: Array<E>], never, R>
 } = dual(
   (args) => isIterable(args[0]) && !isEffect(args[0]),
   <A, B, E, R>(
     elements: Iterable<A>,
     f: (a: A, i: number) => Effect.Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R> =>
+  ): Effect.Effect<[passes: Array<B>, fails: Array<E>], never, R> =>
     map(
       forEach(elements, (a, i) => result(f(a, i)), options),
       (results) => Arr.partition(results, identity)
@@ -4820,11 +4807,11 @@ export const validate: {
   ): Effect.Effect<Array<B> | void, Arr.NonEmptyArray<E>, R> =>
     flatMap(
       partition(elements, f, { concurrency: options?.concurrency }),
-      ([excluded, satisfying]) => {
-        if (Arr.isArrayNonEmpty(excluded)) {
-          return fail(excluded)
+      ([passes, fails]) => {
+        if (Arr.isArrayNonEmpty(fails)) {
+          return fail(fails)
         }
-        return options?.discard ? void_ : succeed(satisfying)
+        return options?.discard ? void_ : succeed(passes)
       }
     )
 )
@@ -5085,7 +5072,6 @@ const iterateConcurrentImpl = <S, A, X, E, R, E2>(options: IterateOptions<S, A,
     let parentFiber: Fiber.Fiber<any, any> | undefined
     let fibers: Set<Fiber.Fiber<any, any>> | undefined
     let resume: ((effect: Effect.Effect<void, E | E2, R>) => void) | undefined
-    let interrupted = false
     let terminal: Exit.Exit<void, E | E2> | void
     let effect: Effect.Effect<X, E, R> | undefined
 
@@ -5093,9 +5079,8 @@ const iterateConcurrentImpl = <S, A, X, E, R, E2>(options: IterateOptions<S, A,
       const defect = exitDie(error)
       terminal = defect
       done = true
-      interrupted = true
       return fibers && fibers.size > 0
-        ? flatMap(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => defect)
+        ? flatMap(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => terminal ?? defect)
         : defect
     }
 
@@ -5105,12 +5090,9 @@ const iterateConcurrentImpl = <S, A, X, E, R, E2>(options: IterateOptions<S, A,
         const item = items[index]
         const eff = effect ?? onItem(state, item, index)
 
-        // fast case (already an exit)
         if (effectIsExit(eff)) {
           terminal = step(state, item, eff, index)
           if (terminal) break
-
-          // We have an effect, so enter "async" mode
         } else if (!parentFiber) {
           return callback((cb) => {
             parentFiber = getCurrentFiber()!
@@ -5125,15 +5107,15 @@ const iterateConcurrentImpl = <S, A, X, E, R, E2>(options: IterateOptions<S, A,
             }
             if (result) return cb(result)
             return suspend(() => {
-              terminal = exitVoid
-              interrupted = true
-              return fibers ? fiberInterruptAll(fibers) : void_
+              terminal ??= exitVoid
+              return flatMap(
+                fibers ? fiberInterruptAll(fibers) : void_,
+                () => terminal?._tag === "Failure" ? terminal : void_
+              )
             })
           })
-
-          // Fork the effect with concurrency > 1
         } else {
-          // Clear the temporary effect from capturing the parentFiber
+          // Clear the effect cached before the parent fiber was available.
           effect = undefined
 
           const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit")
@@ -5143,7 +5125,6 @@ const iterateConcurrentImpl = <S, A, X, E, R, E2>(options: IterateOptions<S, A,
             continue
           }
 
-          // Add the fiber to the Set
           fibers!.add(fiber)
 
           const currentIndex = index
@@ -5151,22 +5132,17 @@ const iterateConcurrentImpl = <S, A, X, E, R, E2>(options: IterateOptions<S, A,
             fibers!.delete(fiber)
             try {
               if (terminal) {
-                if (!interrupted && exit._tag === "Failure") {
-                  for (const reason of exit.cause.reasons) {
-                    if (reason._tag === "Interrupt") continue
-                    else if (terminal._tag === "Failure") {
-                      ;(terminal.cause.reasons as Array<any>).push(reason)
-                    } else {
-                      terminal = exitFailCause(causeFromReasons([reason]))
-                    }
+                if (exit._tag === "Failure") {
+                  const reasons = exit.cause.reasons.filter((reason) => reason._tag !== "Interrupt")
+                  if (reasons.length > 0) {
+                    const cause = causeFromReasons(reasons)
+                    terminal = exitFailCause(terminal._tag === "Failure" ? causeCombine(terminal.cause, cause) : cause)
                   }
                 }
               } else {
                 const result = step(state, item, exit, currentIndex)
                 if (result) {
-                  terminal = result._tag === "Failure"
-                    ? exitFailCause(causeFromReasons(result.cause.reasons.slice()))
-                    : result
+                  terminal = result
                   go()
                 }
               }
@@ -5182,7 +5158,6 @@ const iterateConcurrentImpl = <S, A, X, E, R, E2>(options: IterateOptions<S, A,
             }
           })
 
-          // Check if we have reached the concurrency limit
           if (fibers!.size < concurrency) continue
           paused = true
           index++

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/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)}`