Runtime guarantees

const host = Symbol as SymbolConstructor & { readonly customMatcher?: symbol }
if (host.customMatcher === undefined) {
  Object.defineProperty(host, "customMatcher", { value: Symbol.for("Symbol.customMatcher") })
}
const actualMatcherKey = host.customMatcher!

// Native iterator completion witness: VIP-2, VIP-31
import { Effect, Exit } from "effect"
 
const problem = { label: "source" }, closeProblem = { label: "close" }
const box = { get value(): number { throw problem } }
for (const phase of ["advance", "default", "exhausted"] as const) {
  const trace: string[] = []
  const input: Iterable<number | undefined> = {
    [Symbol.iterator]() {
      return {
        next(): IteratorResult<number | undefined> {
          if (phase === "advance") throw problem
          if (phase === "exhausted") return { done: true, value: undefined }
          return { done: false, value: undefined }
        },
        return(): IteratorResult<number | undefined> {
          trace.push("close")
          throw closeProblem
        },
      }
    },
  }
  const exit = Effect.runSyncExit(Effect.gen(function* () {
    const [value = box.value] = input
    return value
  }))
  if (!Exit.isFailure(exit) || exit.cause.reasons.length !== 1 ||
      exit.cause.reasons[0]._tag !== "Die" || exit.cause.reasons[0].defect !== problem ||
      trace.join() !== (phase === "default" ? "close" : "")) throw new Error("native iterator completion changed")
}

// Coldness witness: VIP-1, VIP-2, VIP-31
import { Effect, Exit } from "effect"
 
const trace: string[] = []
function parameter() { trace.push("parameter"); return 7 }
function program(value = parameter()) {
  return Effect.gen(function* () { trace.push("body"); return value })
}
const p = program()
const called = trace.slice()
if (called.includes("body")) throw new Error("body ran during construction")
if (called.join() !== "parameter") throw new Error("call-time default changed")
const first = Effect.runSyncExit(p)
const second = Effect.runSyncExit(p)
if (!Exit.isSuccess(first) || first.value !== 7 ||
    !Exit.isSuccess(second) || second.value !== 7) throw new Error("Exit changed")
if (trace.join() !== "parameter,body,body") throw new Error("body did not rerun")

// compiler-gap: pending VIP-7
const timeout = new Cause.TimeoutError()
const matched = match (timeout) {
  when Cause.TimeoutError(let e): e;
  default: undefined;
}

import { Cause } from "effect"
 
const timeout = new Cause.TimeoutError()
const matched = Cause.isTimeoutError(timeout) ? timeout : undefined
if (matched !== timeout) throw new Error("extractor changed")
// A matching _tag alone does not satisfy the retained module guard.
if (Cause.isTimeoutError({ _tag: "TimeoutError" })) throw new Error("tag-only match")

// compiler-gap: pending VIP-7
const isText = (x: unknown): x is string => typeof x === "string"
const textMatch = match ("ok" as unknown) { when isText: true; default: false; }

// The pinned matcher call supplies the hint; a predicate may ignore it.
const isText = (x: unknown, _hint?: { matchType: "boolean" }): x is string => typeof x === "string"
const subject: unknown = "ok"
const textMatch = isText(subject, { matchType: "boolean" }) ? true : false
if (!textMatch) throw new Error("predicate match lost")

// compiler-gap: pending VIP-7
import { Foreign, real, fake } from "./foreign.ts"
effect function classify(x: unknown) {
  return match (x) { when Foreign: "yes"; default: "no"; }
}
// classify(real) succeeds with "no"; classify(fake) succeeds with "yes".

import { Effect } from "effect"
 
// foreign.ts: untouched TypeScript objects, without construction instrumentation.
export class Foreign {}
export const real = new Foreign()
Object.setPrototypeOf(real, null)
export const fake: unknown = Object.create(Foreign.prototype)
 
function classify(x: unknown) {
  return Effect.gen(function* () { return x instanceof Foreign ? "yes" : "no" })
}
if (Effect.runSync(classify(real)) !== "no") throw new Error("prototype change ignored")
if (Effect.runSync(classify(fake)) !== "yes") throw new Error("prototype match lost")

// compiler-gap: pending VIP-7
const arrayMatch = match ([]) { when Array: true; default: false; }
const errorMatch = match (new TypeError("bad")) { when TypeError: true; default: false; }

import { Effect } from "effect"
 
const arrayMatch = Array.isArray([])
const errorMatch = new TypeError("bad") instanceof TypeError
if (!Effect.runSync(Effect.succeed(arrayMatch && errorMatch))) throw new Error("built-in match lost")

// compiler-gap: pending VIP-22
effect function binding() {
  let x = 0
  const read = () => x
  uninterruptible { x = 1 }
  return read()                     // 1: the block assigns the function's x
}

import { Effect } from "effect"
 
function binding() {
  return Effect.gen(function* () {
    let x = 0
    const read = () => x
    yield* Effect.uninterruptibleMask(($restore) => Effect.gen(function* () { x = 1 }))
    return read()
  })
}
if (Effect.runSync(binding()) !== 1) throw new Error("binding changed")

// compiler-gap: pending VIP-7
class Point { constructor(readonly x: number) {} }
const point: unknown = new Point(7)
// when Point(let x): is EK0704; use the class test and object pattern:
const coordinate = match (point) { when Point and { x: let x }: x; default: 0; }

class Point { constructor(readonly x: number) {} }
const point: unknown = new Point(7)
const coordinate = point instanceof Point && "x" in point ? point.x : 0
if (coordinate !== 7) throw new Error("class test lost")

// compiler-gap: pending VIP-2
effect function defaults() {
  const { x = do { try succeed(7) } } = {}
  const { y = do { return x } } = {}
  return 0
}

import { Effect } from "effect"
 
function defaults() {
  return Effect.gen(function* () {
    const { x = yield* Effect.succeed(7) } = {} as { x?: number }
    const { y } = {} as { y?: number }
    if (y === undefined) return x   // the source's default returns from the function
    return 0
  })
}
if (Effect.runSync(defaults()) !== 7) throw new Error("default left its activation")

// compiler-gap: pending VIP-2
effect function eager(x = do { return null }) { return 1 }
// eager() is an Effect that succeeds with null, built when eager() is called

import { Effect } from "effect"
 
let built = 0
function eager(x: unknown = undefined): Effect.Effect<number | null> {
  if (x === undefined) { built++; return Effect.succeed(null) }   // runs at the call, before the generator
  return Effect.gen(function* () { return 1 })
}
const e = eager()
if (built !== 1) throw new Error("parameter default became cold")
if (Effect.runSync(e) !== null) throw new Error("default return lost")
if (Effect.runSync(eager(0)) !== 1) throw new Error("body changed")

// Concurrent producer witness: VIP-19, VIP-21, VIP-31
import { Deferred, Effect, Exit, Queue, Stream } from "effect"
 
const inspect = Effect.gen(function* () {
  const started: number[] = []
  const ready = yield* Deferred.make<void>()
  const stream = Stream.callback<number>(queue => Effect.gen(function* () {
    yield* Effect.forEach([1, 2, 3, 4, 5, 6, 7, 8], n => Effect.gen(function* () {
      started.push(n)
      if (started.length === 8) yield* Deferred.succeed(ready, undefined)
      yield* Queue.offer(queue, n)
    }), { concurrency: "unbounded", discard: true })
  }).pipe(Effect.andThen(Queue.end(queue))), { bufferSize: 1, strategy: "suspend" })
  let consumed = 0
  yield* Stream.runForEachWhile(stream, () => Effect.gen(function* () {
    consumed++
    yield* Deferred.await(ready)
    return false
  }))
  return { started: started.length, consumed }
})
const outcome = await Effect.runPromiseExit(Effect.timeout(inspect, "2 seconds"))
if (!Exit.isSuccess(outcome)) throw new Error("concurrent producer stalled")
if (outcome.value.started !== 8 || outcome.value.consumed !== 1) {
  throw new Error("concurrent producer lead changed")
}

// compiler-gap: pending VIP-34
// openFile is the plain helper in the shared TypeScript fixture below.
import { openFile } from "./resource.ts"
effect function unsafe(defect = false) {
  using f = openFile()               // warning: use acquireDisposable inside scoped
  if (defect) try die("boom")         // defect: disposer is also skipped
  throw "bad"                        // typed failure: disposer is skipped
}
effect function safe() {
  return try scoped(effect {
    const f = try acquireDisposable(sync(() => openFile()))
    throw "bad"                      // typed failure: scope disposes f
  })
}

import { Effect, Exit } from "effect"
 
export const trace: string[] = []
/** @throws {never} */
export function openFile(): Disposable {
  return { [Symbol.dispose]() { trace.push("dispose") } }
}
function unsafe(defect = false) {
  return Effect.gen(function* () {
    using f = openFile()
    if (defect) yield* Effect.die("boom")
    return yield* Effect.fail("bad")
  })
}
function safe() {
  return Effect.gen(function* () {
    return yield* Effect.scoped(Effect.gen(function* () {
      const f = yield* Effect.acquireDisposable(Effect.sync(() => openFile()))
      return yield* Effect.fail("bad")
    }))
  })
}
// Run separately: both fail with "bad"; unsafe leaves trace empty, safe appends "dispose".
const unsafeExit = Effect.runSyncExit(unsafe())
const unsafeTrace = trace.slice()     // []
trace.length = 0
const safeExit = Effect.runSyncExit(safe())
const safeTrace = trace.slice()       // ["dispose"]
trace.length = 0
const defectExit = Effect.runSyncExit(unsafe(true))
const defectTrace = trace.slice()     // []
if (!Exit.isFailure(unsafeExit) || !Exit.isFailure(safeExit)) throw new Error("expected failures")
if (!Exit.isFailure(defectExit) || defectTrace.length !== 0) throw new Error("defect disposal changed")
if (unsafeTrace.length !== 0 || safeTrace.join() !== "dispose") throw new Error("disposal changed")

// compiler-gap: pending VIP-2, VIP-12
effect function normalObservation() { return do { provide observed { 7 } } }
effect function returnObservation() { provide observed { return 7 } }

import { Effect, Layer } from "effect"
 
const released: unknown[] = []
const observed = Layer.effectDiscard(Effect.addFinalizer(exit => Effect.sync(() => { released.push(exit) })))
function normalObservation() {
  return Effect.gen(function* () {
    let value = 0
    yield* Effect.provide(Effect.gen(function* () { value = 7 }), observed)
    return value
  })
}
function returnObservation() {
  return Effect.provide(Effect.gen(function* () { return 7 }), observed)
}
// Both outer Exits are Success(7); their layer-finalizer Exits are
// Success(undefined) and Success(7), respectively.

// Source-field witness: VIP-31
import { Effect, Exit } from "effect"
 
const first = Effect.runSyncExit(Effect.succeed({ $fiber: 1, ["__proto__"]: 7 }))
const second = Effect.runSyncExit(Effect.succeed({ $fiber: 2, ["__proto__"]: 8 }))
if (!Exit.isSuccess(first) || !Exit.isSuccess(second)) throw new Error("expected successful records")
if (first.value.$fiber !== 1 || second.value.$fiber !== 2 ||
    first.value["__proto__"] !== 7 || second.value["__proto__"] !== 8 ||
    !Object.hasOwn(first.value, "__proto__") || !Object.hasOwn(second.value, "__proto__")) {
  throw new Error("source fields changed")
}
// Success({ $fiber: 1, ["__proto__"]: 7 }) differs from Success({ $fiber: 2, ["__proto__"]: 8 }).

// compiler-gap: pending VIP-5
effect function unchecked(value: any) { return try value }
// unchecked(5) defects with TypeError; unchecked([]) succeeds with undefined.

// Unchecked delegation witness: VIP-5, VIP-31
import { Effect, Exit } from "effect"
 
function unchecked(value: any): Effect.Effect<unknown> {
  return Effect.gen(function* (): Generator<Effect.Effect<unknown>, unknown, unknown> { return yield* value })
}
for (const value of [5, undefined, Promise.resolve(5)]) {
  const result = Effect.runSyncExit(unchecked(value))
  if (!Exit.isFailure(result) || result.cause.reasons.length !== 1) throw new Error("expected one defect")
  const reason = result.cause.reasons[0]
  if (reason._tag !== "Die" || !(reason.defect instanceof TypeError)) throw new Error("native delegation error lost")
}
for (const [value, expected] of [
  [[], undefined],
  [(function* () { return 7 })(), 7],
  [(function* () { return yield* Effect.succeed(8) })(), 8]
]) {
  const result = Effect.runSyncExit(unchecked(value))
  if (!Exit.isSuccess(result) || result.value !== expected) throw new Error("unchecked iterable completion changed")
}
if (await (5 as any) !== 5) throw new Error("native await identity changed")

// compiler-gap: pending VIP-19
effect function visit(items: Iterable<number>) {
  for concurrent(2) (const item of items) {
    if (item === 1) throw "bad"
  }
}
// A finite non-array input is fully pulled before item Effects start; the Exit fails with "bad".

// Iterable lifecycle witness: VIP-19, VIP-31, VIP-32
import { Effect, Exit } from "effect"
 
function observe(concurrency: number | "unbounded") {
  const trace: string[] = []
  function* items() {
    try {
      for (let item = 0; item < 5; item++) { trace.push("pull:" + item); yield item }
    } finally { trace.push("close") }
  }
  const iterator = items()
  const result = Effect.runSyncExit(Effect.forEach(iterator, item => Effect.gen(function* () {
    trace.push("item:" + item)
    if (item === 1) return yield* Effect.fail("bad")
  }), { concurrency, discard: true }))
  const observed = trace.slice()
  iterator.return() // test-owned cleanup, after recording the native traversal
  if (!Exit.isFailure(result) || result.cause.reasons[0]?._tag !== "Fail" ||
      result.cause.reasons[0].error !== "bad") throw new Error("item failure changed")
  return observed
}
for (const limit of [0, -1, 0.5, 1]) {
  if (observe(limit).join() !== "pull:0,item:0,pull:1,item:1") throw new Error("incremental pulling or closing changed")
}
for (const limit of [2, 2.5, "unbounded"] as const) {
  const trace = observe(limit)
  if (trace.slice(0, 6).join() !== "pull:0,pull:1,pull:2,pull:3,pull:4,close") throw new Error("parallel materialization changed")
  if (trace[6] !== "item:0") throw new Error("item started before materialization")
}
let iteratorCalls = 0
const array = [1, 2]
Object.defineProperty(array, Symbol.iterator, { value: function* () { iteratorCalls++; yield 99 } })
function visit(concurrency: number) {
  const seen: number[] = []
  Effect.runSync(Effect.forEach(array, item => Effect.sync(() => { seen.push(item) }), { concurrency, discard: true }))
  return seen.join()
}
if (visit(1) !== "99" || iteratorCalls !== 1) throw new Error("sequential array iterator changed")
iteratorCalls = 0
if (visit(2) !== "1,2" || iteratorCalls !== 0) throw new Error("parallel array reuse changed")

// compiler-gap: pending VIP-20
effect function consume(items: Stream.Stream<number>) {
  for try (const item of items) { fork work(item) }
  try parentWork() // plain children may still run while this consuming fiber continues
}

// Stream consuming-fiber witness: VIP-17, VIP-20, VIP-31
import { Deferred, Effect, Exit, Fiber, Stream } from "effect"
 
const trace: string[] = []
const result = await Effect.runPromiseExit(Effect.gen(function* () {
  const started = yield* Deferred.make<void>()
  const release = yield* Deferred.make<void>()
  const children: Array<Fiber.Fiber<void>> = []
  yield* Stream.runForEachWhile(Stream.make(1), () => Effect.gen(function* () {
    children.push(yield* Effect.forkChild(Effect.gen(function* () {
      yield* Deferred.succeed(started, undefined)
      yield* Deferred.await(release)
      trace.push("child")
    })))
    yield* Deferred.await(started)
    trace.push("item")
    return true
  }))
  trace.push("loop")
  yield* Deferred.succeed(release, undefined)
  yield* Fiber.join(children[0])
  trace.push("joined")
}))
if (!Exit.isSuccess(result) || trace.join() !== "item,loop,child,joined") throw new Error("consuming-fiber ownership changed")

// Producer Scope witness: VIP-21, VIP-31, VIP-32
import { Effect, Exit, Queue, Scope, Stream } from "effect"
 
let starts = 0, closes = 0
const body: Effect.Effect<void, never, Scope.Scope> = Effect.gen(function* () {
  starts++
  yield* Effect.addFinalizer(() => Effect.sync(() => { closes++ }))
  yield* Effect.forkScoped(Effect.never)
})
const values: Stream.Stream<number> = Stream.callback<number>(queue => body.pipe(
  Effect.andThen(Queue.offer(queue, 1)),
  Effect.andThen(Queue.end(queue))
), { bufferSize: 1, strategy: "suspend" })
if (starts !== 0 || closes !== 0) throw new Error("producer started at construction")
for (let run = 1; run <= 2; run++) {
  const result = await Effect.runPromiseExit(Stream.runCollect(values))
  if (!Exit.isSuccess(result) || result.value.join() !== "1") throw new Error("producer Exit changed")
  if (starts !== run || closes !== run) throw new Error("callback Scope was not fresh or finalized")
}