jj-octo 0.2.0 → 0.2.2

package/dist/jj-octo.js

@@ -925,6 +925,32 @@ class Fail extends ReasonBase {
   }
 }
 var causeFromReasons = (reasons) => new CauseImpl(reasons);
+var dedupeReasons = (self, that) => {
+  const buckets = new Map;
+  const out = [];
+  for (const reason of self.concat(that)) {
+    const hash2 = hash(reason);
+    const bucket = buckets.get(hash2);
+    if (bucket === undefined) {
+      buckets.set(hash2, [reason]);
+    } else if (bucket.some((previous) => equals(previous, reason))) {
+      continue;
+    } else {
+      bucket.push(reason);
+    }
+    out.push(reason);
+  }
+  return out;
+};
+var causeCombine = /* @__PURE__ */ dual(2, (self, that) => {
+  if (self.reasons.length === 0) {
+    return that;
+  } else if (that.reasons.length === 0) {
+    return self;
+  }
+  const newCause = new CauseImpl(dedupeReasons(self.reasons, that.reasons));
+  return equals(self, newCause) ? self : newCause;
+});
 var causeEmpty = /* @__PURE__ */ new CauseImpl([]);
 var causeFail = (error) => new CauseImpl([new Fail(error)]);
 
@@ -1039,8 +1065,18 @@ var exitFailCause = /* @__PURE__ */ makeExit({
       annotated = true;
     }
     let cont = fiber.getCont(contE);
-    while (fiber.interruptible && fiber._interruptedCause && cont) {
-      cont = fiber.getCont(contE);
+    const interruptedCause = fiber._interruptedCause;
+    if (interruptedCause && fiber.interruptible) {
+      let skippedHandler = false;
+      while (cont && fiber.interruptible) {
+        skippedHandler ||= identifier in cont;
+        cont = fiber.getCont(contE);
+      }
+      if (skippedHandler) {
+        cause = causeFromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"));
+      }
+      cause = causeCombine(cause, interruptedCause);
+      annotated = true;
     }
     return cont ? cont[contE](cause, fiber, annotated ? undefined : this) : fiber.yieldWith(annotated ? exitFailCause(cause) : this);
   }
@@ -2365,32 +2401,6 @@ var causeFilterInterruptors = (self) => {
   return interruptors ? succeed2(interruptors) : fail2(self);
 };
 var hasInterruptsOnly = (self) => self.reasons.length > 0 && self.reasons.every(isInterruptReason);
-var dedupeReasons = (self, that) => {
-  const buckets = new Map;
-  const out = [];
-  for (const reason of self.concat(that)) {
-    const hash2 = hash(reason);
-    const bucket = buckets.get(hash2);
-    if (bucket === undefined) {
-      buckets.set(hash2, [reason]);
-    } else if (bucket.some((previous) => equals(previous, reason))) {
-      continue;
-    } else {
-      bucket.push(reason);
-    }
-    out.push(reason);
-  }
-  return out;
-};
-var causeCombine = /* @__PURE__ */ dual(2, (self, that) => {
-  if (self.reasons.length === 0) {
-    return that;
-  } else if (that.reasons.length === 0) {
-    return self;
-  }
-  const newCause = new CauseImpl(dedupeReasons(self.reasons, that.reasons));
-  return equals(self, newCause) ? self : newCause;
-});
 var causeMap = /* @__PURE__ */ dual(2, (self, f) => {
   let hasFail = false;
   const failures = self.reasons.map((failure) => {
@@ -2577,6 +2587,14 @@ var fiberVariance = {
 var fiberIdStore = {
   id: 0
 };
+var AsyncResource = /* @__PURE__ */ (() => {
+  try {
+    return globalThis.process?.getBuiltinModule?.("node:async_hooks")?.AsyncResource;
+  } catch {
+    return;
+  }
+})();
+var captureAsyncContext = () => AsyncResource === undefined ? undefined : new AsyncResource("effect/Fiber");
 var getCurrentFiber = () => globalThis[currentFiberTypeId];
 
 class FiberImpl {
@@ -2594,6 +2612,7 @@ class FiberImpl {
     this._running = false;
     this._deferredInterrupt = false;
     this._parent = undefined;
+    this._asyncContext = undefined;
     this.cache.runtimeMetrics?.recordFiberStart(this.context);
   }
   get [FiberTypeId]() {
@@ -2651,6 +2670,10 @@ class FiberImpl {
   evaluate(effect) {
     if (this._exit) {
       return;
+    } else if (this._asyncContext !== undefined) {
+      const asyncContext = this._asyncContext;
+      this._asyncContext = undefined;
+      return asyncContext.runInAsyncScope(this.evaluate, this, effect);
     } else if (this._yielded !== undefined) {
       const yielded = this._yielded;
       this._yielded = undefined;
@@ -2658,6 +2681,7 @@ class FiberImpl {
     }
     const exit = this.runLoop(effect);
     if (exit === Yield) {
+      this._asyncContext = captureAsyncContext();
       return;
     }
     const interruptChildren = fiberMiddleware.interruptChildren && fiberMiddleware.interruptChildren(this);
@@ -2850,6 +2874,16 @@ var fiberAwaitAll = (self) => callback((resume) => {
   loop();
   return sync(() => cancel?.());
 });
+var fiberJoin = (self) => {
+  const impl = self;
+  if (impl._exit)
+    return impl._exit;
+  return callback((resume) => {
+    if (impl._exit)
+      return resume(impl._exit);
+    return sync(self.addObserver(resume));
+  });
+};
 var fiberInterrupt = (self) => withFiber((fiber) => fiberInterruptAs(self, fiber.id));
 var fiberInterruptAs = /* @__PURE__ */ dual((args) => hasProperty(args[0], FiberTypeId), (self, fiberId, annotations) => withFiber((parent) => {
   let ann = fiberStackAnnotations(parent);
@@ -2902,7 +2936,6 @@ var yieldNowWith = /* @__PURE__ */ makePrimitive({
   }
 });
 var yieldNow = /* @__PURE__ */ yieldNowWith(0);
-var succeedNone = /* @__PURE__ */ succeed3(/* @__PURE__ */ none2());
 var failCauseSync = (evaluate) => suspend(() => failCause(evaluate()));
 var die = (defect) => exitDie(defect);
 var failSync = (error) => suspend(() => fail3(error()));
@@ -2925,17 +2958,17 @@ var tryPromise = (options) => {
   const f = typeof options === "function" ? options : options.try;
   const catcher = typeof options === "function" ? (cause) => new UnknownError(cause, "An error occurred in Effect.tryPromise") : options.catch;
   return callbackOptions(function(resume, signal) {
-    const failWithCatch = (cause) => {
+    const failWithCatch = (cause) => suspend(() => {
       try {
-        resume(fail3(internalCall(() => catcher(cause))));
+        return fail3(internalCall(() => catcher(cause)));
       } catch (err) {
-        resume(die(err));
+        return die(err);
       }
-    };
+    });
     try {
-      f(signal).then((a) => resume(succeed3(a)), failWithCatch);
+      f(signal).then((a) => resume(succeed3(a)), (e) => resume(failWithCatch(e)));
     } catch (err) {
-      failWithCatch(err);
+      resume(failWithCatch(err));
     }
   }, f.length !== 0);
 };
@@ -2992,7 +3025,7 @@ var asyncFinalizer = /* @__PURE__ */ makePrimitive({
     }
   },
   [contE](cause, _fiber) {
-    return hasInterrupts(cause) ? flatMap2(this[args](), () => failCause(cause)) : failCause(cause);
+    return hasInterrupts(cause) ? flatMap2(combineFinalizerCause(exitFailCause(cause), this[args]()), () => failCause(cause)) : failCause(cause);
   }
 });
 var callback = (register) => callbackOptions(register, register.length >= 2);
@@ -3137,39 +3170,37 @@ var tapCont = function(value) {
 var tapEffectCont = function(value) {
   return new ContImpl(this.payload, succeedPayload, value);
 };
-var asSome = (self) => map5(self, some2);
 var andThen = /* @__PURE__ */ dual(2, (self, f) => new ContImpl(self, isEffect(f) ? returnPayload : andThenCont, f));
 var tap = /* @__PURE__ */ dual(2, (self, f) => new ContImpl(self, isEffect(f) ? tapEffectCont : tapCont, f));
 var asVoid = (self) => new ContImpl(self, returnPayload, exitVoid);
-var raceAllFirst = (all, options) => withFiber((parent) => callback((resume) => {
-  let done = false;
+var raceAllFirst = (all, options) => withFiber((parent) => {
   const fibers = new Set;
-  const onExit = (exit) => {
-    done = true;
-    resume(fibers.size === 0 ? exit : flatMap2(uninterruptible(fiberInterruptAll(fibers)), () => exit));
-  };
-  let i = 0;
-  for (const effect of all) {
-    if (done)
-      break;
-    const index = i++;
-    const fiber = forkUnsafe(parent, effect, true, true, false);
-    fibers.add(fiber);
-    fiber.addObserver((exit) => {
-      fibers.delete(fiber);
-      const isWinner = !done;
-      onExit(exit);
-      if (isWinner && options?.onWinner) {
-        options.onWinner({
-          fiber,
-          index,
-          parentFiber: parent
-        });
-      }
-    });
-  }
-  return fiberInterruptAll(fibers);
-}));
+  onExitUnsafe(parent, () => fibers.size === 0 ? undefined : fiberInterruptAll(fibers));
+  return callback((resume) => {
+    let done = false;
+    let i = 0;
+    for (const effect of all) {
+      if (done)
+        break;
+      const index = i++;
+      const fiber = forkUnsafe(parent, effect, true, true, false);
+      fibers.add(fiber);
+      fiber.addObserver((exit) => {
+        fibers.delete(fiber);
+        const isWinner = !done;
+        done = true;
+        resume(exit);
+        if (isWinner && options?.onWinner) {
+          options.onWinner({
+            fiber,
+            index,
+            parentFiber: parent
+          });
+        }
+      });
+    }
+  });
+});
 var raceFirst = /* @__PURE__ */ dual((args) => isEffect(args[1]), (self, that, options) => raceAllFirst([self, that], options));
 var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => new ContImpl(self, andThenCont, f));
 var effectIsExit = (effect) => effect[ExitTypeId] !== undefined;
@@ -3198,6 +3229,7 @@ var exitInterrupt = (fiberId) => exitFailCause(causeInterrupt(fiberId));
 var exitIsSuccess = (self) => self._tag === "Success";
 var exitIsFailure = (self) => self._tag === "Failure";
 var exitFilterCause = (self) => self._tag === "Failure" ? succeed2(self.cause) : fail2(self);
+var exitHasInterrupts = (self) => self._tag === "Failure" && hasInterrupts(self.cause);
 var exitVoid = /* @__PURE__ */ exitSucceed(undefined);
 var exitMap = /* @__PURE__ */ dual(2, (self, f) => self._tag === "Success" ? exitSucceed(f(self.value)) : self);
 var exitMapError = /* @__PURE__ */ dual(2, (self, f) => {
@@ -3609,24 +3641,50 @@ var onErrorFilter = /* @__PURE__ */ dual(3, (self, filter, f) => onExit(self, (e
   return isFailure2(result) ? void_ : f(result.success, exit.cause);
 }));
 var onInterrupt = /* @__PURE__ */ dual(2, (self, finalizer) => onErrorFilter(causeFilterInterruptors, finalizer)(self));
-var cached = (self) => sync(() => {
-  const latch = makeLatchUnsafe(false);
-  let started = false;
+var infiniteTTL = /* @__PURE__ */ constant(Infinity);
+var makeCachedUnsafe = (self, ttlMillis) => {
+  let expiresAt = 0;
   let exit;
-  const wait = flatMap2(latch.await, () => exit);
-  return withFiber((fiber) => {
-    if (exit !== undefined)
+  let current;
+  const join = (fiber, run) => {
+    run.awaiters++;
+    onExitUnsafe(fiber, () => {
+      if (--run.awaiters > 0 || current !== run)
+        return;
+      current = undefined;
+      return fiberInterrupt(run.fiber);
+    });
+    return fiberJoin(run.fiber);
+  };
+  return [withFiber((fiber) => {
+    if (current !== undefined)
+      return join(fiber, current);
+    if (exit !== undefined && (expiresAt === Infinity || fiber.getRef(ClockRef).currentTimeMillisUnsafe() < expiresAt)) {
       return exit;
-    if (started)
-      return wait;
-    started = true;
-    onExitUnsafe(fiber, (result) => sync(() => {
-      exit = result;
-      latch.openUnsafe();
-    }));
-    return self;
-  });
-});
+    }
+    exit = undefined;
+    const clock = fiber.getRef(ClockRef);
+    const run = {
+      fiber: undefined,
+      awaiters: 0
+    };
+    current = run;
+    run.fiber = forkUnsafe(fiber, onExitPrimitive(self, (exit_) => {
+      if (current !== run)
+        return;
+      current = undefined;
+      if (exitHasInterrupts(exit_))
+        return;
+      const duration = ttlMillis(exit_);
+      expiresAt = duration === Infinity ? Infinity : clock.currentTimeMillisUnsafe() + duration;
+      exit = exit_;
+    }), true, true);
+    return run.fiber._exit ?? join(fiber, run);
+  }), sync(() => {
+    exit = undefined;
+  })];
+};
+var cached = (self) => sync(() => makeCachedUnsafe(self, infiniteTTL)[0]);
 var interrupt = /* @__PURE__ */ withFiber((fiber) => failCause(causeInterrupt(fiber.id)));
 var uninterruptible = (self) => withFiber((fiber) => {
   if (!fiber.interruptible)
@@ -3769,15 +3827,13 @@ var iterateConcurrentImpl = (options) => {
     let parentFiber;
     let fibers;
     let resume;
-    let interrupted = false;
     let terminal;
     let effect;
     const failDefect = (error) => {
       const defect = exitDie(error);
       terminal = defect;
       done = true;
-      interrupted = true;
-      return fibers && fibers.size > 0 ? flatMap2(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => defect) : defect;
+      return fibers && fibers.size > 0 ? flatMap2(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => terminal ?? defect) : defect;
     };
     const go = () => {
       let paused = false;
@@ -3803,9 +3859,8 @@ var iterateConcurrentImpl = (options) => {
             if (result)
               return cb(result);
             return suspend(() => {
-              terminal = exitVoid;
-              interrupted = true;
-              return fibers ? fiberInterruptAll(fibers) : void_;
+              terminal ??= exitVoid;
+              return flatMap2(fibers ? fiberInterruptAll(fibers) : void_, () => terminal?._tag === "Failure" ? terminal : void_);
             });
           });
         } else {
@@ -3823,21 +3878,17 @@ var iterateConcurrentImpl = (options) => {
             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.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();
                 }
               }
@@ -3900,6 +3951,7 @@ var forkUnsafe = (parent, effect, immediate = false, daemon = false, uninterrupt
   if (immediate) {
     child.evaluate(effect);
   } else {
+    child._asyncContext = captureAsyncContext();
     parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect), 0);
   }
   if (!daemon && !child._exit) {
@@ -5179,7 +5231,9 @@ var systemError = (options) => new PlatformError(new SystemError(options));
 var badArgument = (options) => new PlatformError(new BadArgument(options));
 
 // node_modules/effect/dist/Fiber.js
+var join = fiberJoin;
 var interrupt3 = fiberInterrupt;
+var getCurrent = getCurrentFiber;
 var runIn = fiberRunIn;
 
 // node_modules/effect/dist/Latch.js
@@ -5429,8 +5483,10 @@ var releaseTakers = (self) => {
     return;
   }
   for (const taker of self.state.takers) {
+    if (!taker.ready())
+      continue;
     self.state.takers.delete(taker);
-    taker(exitVoid);
+    taker.resume(exitVoid);
     if (self.messages.length === 0) {
       break;
     }
@@ -5464,10 +5520,14 @@ var awaitTake = (self, ready) => callback((resume) => {
     return resume(self.state.exit);
   if (ready())
     return resume(exitVoid);
-  self.state.takers.add(resume);
+  const taker = {
+    ready,
+    resume
+  };
+  self.state.takers.add(taker);
   return sync(() => {
     if (self.state._tag !== "Done")
-      self.state.takers.delete(resume);
+      self.state.takers.delete(taker);
   });
 });
 var offerOrWait = (self, message) => callback((resume) => offerUnsafe(self, message) ? resume(exitTrue) : waitToOffer(self, {
@@ -5545,7 +5605,7 @@ var finalize = (self, exit) => {
     exit
   };
   for (const taker of openState.takers) {
-    taker(exit);
+    taker.resume(exit);
   }
   openState.takers.clear();
   for (const awaiter of openState.awaiters) {
@@ -5554,109 +5614,6 @@ var finalize = (self, exit) => {
   openState.awaiters.clear();
 };
 
-// node_modules/effect/dist/Semaphore.js
-var makeUnsafe5 = (permits) => new SemaphoreImpl(permits);
-var waitForPermits = (self, n, effect) => callback((resume) => {
-  if (self.free >= n)
-    return resume(effect);
-  const observer = () => {
-    if (self.free < n)
-      return;
-    self.waiters.delete(observer);
-    resume(effect);
-  };
-  self.waiters.add(observer);
-  return sync(() => {
-    self.waiters.delete(observer);
-  });
-});
-
-class SemaphoreImpl {
-  waiters = /* @__PURE__ */ new Set;
-  taken = 0;
-  permits;
-  constructor(permits) {
-    this.permits = permits;
-  }
-  get free() {
-    return this.permits - this.taken;
-  }
-  take(n) {
-    const take = suspend(() => {
-      if (this.free < n) {
-        return waitForPermits(this, n, take);
-      }
-      this.taken += n;
-      return succeed3(n);
-    });
-    return take;
-  }
-  takeIfAvailable(n) {
-    return suspend(() => {
-      if (this.free < n)
-        return succeed3(false);
-      this.taken += n;
-      return succeed3(true);
-    });
-  }
-  releaseUnsafe(fiber, n) {
-    this.taken -= n;
-    if (this.waiters.size > 0) {
-      fiber.currentDispatcher.scheduleTask(() => {
-        for (const observer of this.waiters) {
-          if (this.free <= 0)
-            break;
-          observer();
-        }
-      }, 0);
-    }
-    return this.free;
-  }
-  resize(permits) {
-    return withFiber((fiber) => {
-      this.permits = permits;
-      if (this.free < 0)
-        return void_;
-      this.releaseUnsafe(fiber, 0);
-      return void_;
-    });
-  }
-  release(n) {
-    return withFiber((fiber) => succeed3(this.releaseUnsafe(fiber, n)));
-  }
-  get releaseAll() {
-    return withFiber((fiber) => succeed3(this.releaseUnsafe(fiber, this.taken)));
-  }
-  withPermits(n) {
-    return (self) => uninterruptibleMask((restore) => {
-      const acquire = suspend(() => {
-        if (this.free < n) {
-          const wait = waitForPermits(this, n, void_);
-          return flatMap2(restore(wait), () => acquire);
-        }
-        this.taken += n;
-        return onExitPrimitive(restore(self), () => {
-          this.releaseUnsafe(getCurrentFiber(), n);
-          return;
-        }, true);
-      });
-      return acquire;
-    });
-  }
-  withPermit = /* @__PURE__ */ this.withPermits(1);
-  withPermitsIfAvailable(n) {
-    return (self) => uninterruptibleMask((restore) => {
-      if (this.free < n)
-        return succeedNone;
-      this.taken += n;
-      return onExitPrimitive(restore(asSome(self)), () => {
-        this.releaseUnsafe(getCurrentFiber(), n);
-        return;
-      }, true);
-    });
-  }
-}
-
 // node_modules/effect/dist/Channel.js
 var TypeId11 = "~effect/Channel";
 var isChannel = (u) => hasProperty(u, TypeId11);
@@ -5941,7 +5898,6 @@ class RcRefImpl {
     return pipeArguments(this, arguments);
   }
   state = stateEmpty;
-  semaphore = /* @__PURE__ */ makeUnsafe5(1);
   acquire;
   context;
   scope;
@@ -5958,9 +5914,13 @@ var make10 = (options) => withFiber2((fiber) => {
   const scope = get(context, Scope);
   const ref = new RcRefImpl(options.acquire, context, scope, options.idleTimeToLive !== undefined ? fromInputUnsafe(options.idleTimeToLive) : undefined);
   return as2(addFinalizerExit(scope, () => {
-    const close2 = ref.state._tag === "Acquired" ? close(ref.state.scope, void_2) : void_3;
+    const state = ref.state;
     ref.state = stateClosed;
-    return close2;
+    if (state._tag === "Acquired")
+      return close(state.scope, void_2);
+    if (state._tag === "Acquiring")
+      return interrupt3(state.fiber);
+    return void_3;
   }), ref);
 });
 var getState = (self, restore) => {
@@ -5973,31 +5933,57 @@ var getState = (self, restore) => {
       state.refCount++;
       return state.fiber ? as2(interrupt3(state.fiber), state) : succeed6(state);
     }
+    case "Acquiring": {
+      const state = self.state;
+      state.awaiters++;
+      return awaitAcquiring(self, state, restore);
+    }
     case "Empty": {
-      return self.semaphore.withPermit(suspend2(() => {
-        if (self.state._tag !== "Empty") {
-          return getState(self, restore);
+      const acquiring = {
+        _tag: "Acquiring",
+        fiber: undefined,
+        awaiters: 1,
+        acquired: undefined
+      };
+      self.state = acquiring;
+      const scope = makeUnsafe3();
+      const acquire = provideContext2(self.acquire, add(self.context, Scope, scope)).pipe(flatMap4((value) => {
+        if (self.state !== acquiring) {
+          return interrupt2;
         }
-        const scope = makeUnsafe3();
-        return restore(provideContext2(self.acquire, add(self.context, Scope, scope))).pipe(flatMap4((value) => {
-          if (self.state._tag === "Closed") {
-            return interrupt2;
-          }
-          const state = {
-            _tag: "Acquired",
-            value,
-            scope,
-            fiber: undefined,
-            refCount: 1,
-            invalidated: false
-          };
-          self.state = state;
-          return succeed6(state);
-        }), onExit2((exit) => isFailure3(exit) ? close(scope, exit) : void_3));
+        const state = {
+          _tag: "Acquired",
+          value,
+          scope,
+          fiber: undefined,
+          refCount: acquiring.awaiters,
+          invalidated: false
+        };
+        self.state = state;
+        acquiring.acquired = state;
+        return succeed6(state);
+      }), onExit2((exit) => {
+        if (isSuccess3(exit))
+          return void_3;
+        if (self.state === acquiring)
+          self.state = stateEmpty;
+        return close(scope, exit);
       }));
+      acquiring.fiber = runForkWith2(getCurrent().context)(acquire);
+      return awaitAcquiring(self, acquiring, restore);
     }
   }
 };
+var awaitAcquiring = (self, acquiring, restore) => onExit2(restore(join(acquiring.fiber)), (exit) => {
+  const acquired = acquiring.acquired;
+  if (acquired !== undefined) {
+    return isFailure3(exit) ? release(self, acquired) : void_3;
+  }
+  if (--acquiring.awaiters > 0 || self.state !== acquiring)
+    return void_3;
+  self.state = stateEmpty;
+  return interrupt3(acquiring.fiber);
+});
 var get2 = (self_) => {
   const self = self_;
   return uninterruptibleMask2((restore) => flatMap4(scope2, (scope) => flatMap4(getState(self, restore), (state) => as2(addFinalizerExit(scope, () => release(self, state)), state.value))));
@@ -6671,13 +6657,9 @@ var posixImpl = /* @__PURE__ */ Path.of({
 function resolve2(ast) {
   return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;
 }
-function resolveAt(key) {
-  return (ast) => resolve2(ast)?.[key];
-}
 var STRUCTURAL_ANNOTATION_KEY = "~structural";
 var SENTINELS_ANNOTATION_KEY = "~sentinels";
 var CONSTRUCTOR_ANNOTATION_KEY = "~constructor";
-var resolveBrands = /* @__PURE__ */ resolveAt("brands");
 var getExpected = /* @__PURE__ */ memoize((ast) => {
   const identifier = resolve2(ast)?.identifier;
   if (typeof identifier === "string")
@@ -8103,7 +8085,7 @@ var candidateIndexCache = /* @__PURE__ */ new WeakMap;
 var emptyCandidates = /* @__PURE__ */ Object.freeze([]);
 var getRuntimeType = (input) => input === null ? "null" : Array.isArray(input) ? "array" : typeof input;
 var hasPropertySignature = (input, key) => key === "__proto__" ? Object.hasOwn(input, key) : (key in input);
-function getIndex(types) {
+function getCandidateIndex(types) {
   let index = candidateIndexCache.get(types);
   if (index)
     return index;
@@ -8112,6 +8094,7 @@ function getIndex(types) {
   let otherwise;
   let literalCandidates;
   let onlyLiterals = true;
+  const literalOf = [];
   for (let i = 0;i < types.length; i++) {
     const a = types[i];
     const encoded = toCandidate(a);
@@ -8120,10 +8103,11 @@ function getIndex(types) {
     if (isLiteral(encoded) || isUniqueSymbol(encoded)) {
       literalCandidates ??= new Map;
       const literal = isLiteral(encoded) ? encoded.literal : encoded.symbol;
+      literalOf[i] = literal;
       let arr = literalCandidates.get(literal);
       if (!arr)
         literalCandidates.set(literal, arr = []);
-      arr.push(a);
+      arr.push(i);
     } else {
       onlyLiterals = false;
     }
@@ -8152,23 +8136,24 @@ function getIndex(types) {
     }
   }
   const fallbacks = {};
-  const getFallback = (type) => fallbacks[type] ??= Object.freeze((otherwise?.[type] ?? emptyCandidates).map((i) => types[i]));
+  const getFallback = (type) => fallbacks[type] ??= Object.freeze(otherwise?.[type] ?? emptyCandidates);
   if (onlyLiterals && literalCandidates) {
     literalCandidates.forEach(Object.freeze);
     index = (input) => literalCandidates.get(input) ?? emptyCandidates;
   } else if (bySentinel?.size === 1 && !otherwise) {
     const [key, [byValue]] = bySentinel.entries().next().value;
-    const candidates = byValue;
+    const candidates = new Map;
     for (const [literal, indexes] of byValue) {
-      candidates.set(literal, Object.freeze(Array.from(indexes, (index) => types[index])));
+      candidates.set(literal, Object.freeze(Array.from(indexes)));
     }
+    const all = Object.freeze(types.map((_, i) => i));
     index = (input, isConstructor) => {
       if (isObjectKeyword(input)) {
         const value = hasPropertySignature(input, key) ? input[key] : undefined;
         if (value !== undefined)
           return candidates.get(value) ?? emptyCandidates;
         if (isConstructor)
-          return types;
+          return all;
       }
       return emptyCandidates;
     };
@@ -8227,26 +8212,17 @@ function getIndex(types) {
           }
         }
       }
-      return Array.from(selected).sort((a, b) => a - b).map((i) => types[i]);
+      return Array.from(selected).sort((a, b) => a - b);
     };
   } else {
     index = (input) => {
       const fallback = getFallback(getRuntimeType(input));
-      return literalCandidates ? fallback.filter(filterLiterals(input)) : fallback;
+      return literalCandidates ? fallback.filter((i) => literalOf[i] === undefined || literalOf[i] === input) : fallback;
     };
   }
   candidateIndexCache.set(types, index);
   return index;
 }
-function filterLiterals(input) {
-  return (ast) => {
-    const encoded = toCandidate(ast);
-    return encoded._tag === "Literal" ? encoded.literal === input : encoded._tag === "UniqueSymbol" ? encoded.symbol === input : true;
-  };
-}
-function getCandidates(input, types, isConstructor = false) {
-  return getIndex(types)(input, isConstructor);
-}
 var Union = class extends ASTNodeImpl {
   _tag = "Union";
   types;
@@ -8260,42 +8236,25 @@ var Union = class extends ASTNodeImpl {
   }
   getParser(compile, compileField) {
     const ast = this;
+    const isConstructor = compileField !== undefined;
+    const parsers = [];
+    const parser = (i) => parsers[i] ??= compile(ast.types[i]);
+    let index;
     return (input, options) => {
       if (input === missing) {
         return missingExit;
       }
-      const candidates = getCandidates(input, ast.types, compileField !== undefined);
+      const candidates = (index ??= getCandidateIndex(ast.types))(input, isConstructor);
       if (candidates.length === 0) {
         return fail6(new AnyOf(ast, [], input, options));
       }
       if (candidates.length === 1) {
-        const result = compile(candidates[0])(input, options);
+        const result = parser(candidates[0])(input, options);
         if (result._tag === "Success")
           return result;
-        return effectIsExit(result) ? failSingleUnionCandidate(ast, result.cause, input, options) : catchCause2(result, (cause) => failSingleUnionCandidate(ast, cause, input, options));
+        return effectIsExit(result) ? failSingleUnionCandidate(ast, result.cause, input, options) : catchSingleUnionCandidate(ast, result, input, options);
       }
-      const state = {
-        ast,
-        compile,
-        input,
-        out: undefined,
-        successes: ast.options?.mode === "oneOf" ? [] : undefined,
-        issues: undefined,
-        options
-      };
-      const eff = parseUnion(state, candidates);
-      if (!eff) {
-        if (state.out)
-          return state.out;
-        return fail6(new AnyOf(ast, state.issues ?? [], input, options));
-      }
-      return flatMapEager2(eff, (_) => {
-        if (state.out === sameExit)
-          return succeed6(input);
-        if (state.out)
-          return state.out;
-        return fail6(new AnyOf(ast, state.issues ?? [], input, options));
-      });
+      return parseUnionCandidates(ast, parser, candidates, input, options);
     };
   }
   _rebuild(recur, checks, encodingChecks) {
@@ -8351,12 +8310,41 @@ function failSingleUnionCandidate(ast, cause, input, options) {
     return failCause2(cause);
   return fail5(new AnyOf(ast, [issue], input, options));
 }
+function catchSingleUnionCandidate(ast, result, input, options) {
+  return catchCause2(result, (cause) => failSingleUnionCandidate(ast, cause, input, options));
+}
+function parseUnionCandidates(ast, parser, candidates, input, options) {
+  const state = {
+    ast,
+    parser,
+    input,
+    out: undefined,
+    successes: ast.options?.mode === "oneOf" ? [] : undefined,
+    issues: undefined,
+    options
+  };
+  const eff = parseUnion(state, candidates);
+  if (!eff) {
+    if (state.out)
+      return state.out;
+    return fail6(new AnyOf(ast, state.issues ?? [], input, options));
+  }
+  return resumeUnion(eff, state);
+}
+function resumeUnion(eff, state) {
+  return flatMapEager2(eff, (_) => {
+    if (state.out === sameExit)
+      return succeed6(state.input);
+    if (state.out)
+      return state.out;
+    return fail6(new AnyOf(state.ast, state.issues ?? [], state.input, state.options));
+  });
+}
 var parseUnion = /* @__PURE__ */ iterateEager()({
-  onItem(s, ast) {
-    const parser = s.compile(ast);
-    return parser(s.input, s.options);
+  onItem(s, i) {
+    return s.parser(i)(s.input, s.options);
   },
-  step(s, candidate, exit) {
+  step(s, i, exit) {
     if (exit._tag === "Failure") {
       const issue = getSchemaIssue(exit.cause);
       if (issue === undefined) {
@@ -8368,12 +8356,12 @@ var parseUnion = /* @__PURE__ */ iterateEager()({
         s.issues = [issue];
     } else {
       if (s.out && s.successes) {
-        s.successes.push(candidate);
+        s.successes.push(s.ast.types[i]);
         return fail5(new OneOf(s.ast, s.successes, s.input, s.options));
       }
       s.out = exit;
       if (s.successes) {
-        s.successes.push(candidate);
+        s.successes.push(s.ast.types[i]);
       } else {
         return void_2;
       }
@@ -8476,33 +8464,42 @@ function isPattern(regExp, annotations) {
     ...annotations
   });
 }
-function copy(ast) {
-  return Object.assign(Object.create(Object.getPrototypeOf(ast)), ast);
+var bodyOwners = /* @__PURE__ */ new WeakMap;
+function copy(ast, changes) {
+  const out = Object.assign(Object.create(Object.getPrototypeOf(ast)), ast, changes);
+  if (Reflect.ownKeys(changes).every((key) => key === "context" || key === "encoding")) {
+    bodyOwners.set(out, getContextOwner(ast));
+  }
+  return out;
 }
-var contextOwners = /* @__PURE__ */ new WeakMap;
 function getContextOwner(ast) {
-  return contextOwners.get(ast) ?? ast;
+  const existing = bodyOwners.get(ast);
+  if (existing !== undefined)
+    return existing;
+  if (ast.encoding === undefined)
+    return ast;
+  const owner = Object.assign(Object.create(Object.getPrototypeOf(ast)), ast, {
+    encoding: undefined
+  });
+  bodyOwners.set(ast, owner);
+  return owner;
 }
 function replaceEncoding(ast, encoding) {
-  if (ast.encoding === encoding) {
-    return ast;
-  }
-  const out = copy(ast);
-  out.encoding = encoding;
-  return out;
+  return ast.encoding === encoding ? ast : copy(ast, {
+    encoding
+  });
 }
 function replaceContext(ast, context) {
   if (ast.context === context) {
     return ast;
   }
   const owner = getContextOwner(ast);
-  if (owner.context === context) {
+  if (owner.context === context && owner.encoding === ast.encoding) {
     return owner;
   }
-  const out = copy(ast);
-  out.context = context;
-  contextOwners.set(out, owner);
-  return out;
+  return copy(ast, {
+    context
+  });
 }
 function getLastEncoding(ast) {
   return ast.encoding ? getLastEncoding(ast.encoding[ast.encoding.length - 1].to) : ast;
@@ -8512,12 +8509,12 @@ function annotate(ast, annotations) {
     const last = ast.checks[ast.checks.length - 1];
     return replaceChecks(ast, append(ast.checks.slice(0, -1), last.annotate(annotations)));
   }
-  const out = copy(ast);
-  out.annotations = {
-    ...ast.annotations,
-    ...annotations
-  };
-  return out;
+  return copy(ast, {
+    annotations: {
+      ...ast.annotations,
+      ...annotations
+    }
+  });
 }
 function replaceChecks(ast, checks) {
   if (ast._tag === "Suspend" && checks) {
@@ -8526,9 +8523,9 @@ function replaceChecks(ast, checks) {
   if (ast.checks === checks) {
     return ast;
   }
-  const out = copy(ast);
-  out.checks = checks;
-  return out;
+  return copy(ast, {
+    checks
+  });
 }
 function appendChecks(ast, checks) {
   return replaceChecks(ast, combineChecks(ast.checks, checks));
@@ -8569,13 +8566,6 @@ function appendTransformation(from, transformation, to) {
   const link = new Link(from, transformation);
   return replaceEncoding(to, to.encoding ? [...to.encoding, link] : [link]);
 }
-function brand(ast, brand) {
-  const existing = resolveBrands(ast);
-  const brands = existing ? [...existing, brand] : [brand];
-  return annotate(ast, {
-    brands
-  });
-}
 function mapOrSame(as, f) {
   let out;
   for (let i = 0;i < as.length; i++) {
@@ -8628,19 +8618,33 @@ function extractStructuralChecks(checks) {
   const out = checks.flatMap(extract);
   return isArrayNonEmpty2(out) ? out : undefined;
 }
+function canPreserveEncodingChecks(ast) {
+  let preserve = true;
+  function visit(child) {
+    preserve = preserve && !child.encoding && !isSuspend(child);
+    if (preserve && "recur" in child)
+      child.recur(visit);
+    return child;
+  }
+  if ("recur" in ast)
+    ast.recur(visit);
+  return preserve;
+}
 var toType = /* @__PURE__ */ memoizeIdempotent((ast) => {
-  const out = ast;
-  const type = out.recur?.(toType) ?? out;
-  const encodingChecks = type.encodingChecks;
-  if (encodingChecks) {
-    const checks = type === ast ? encodingChecks : isArrays(type) || isObjects(type) || isDeclaration(type) && type.typeParameters.length > 0 ? extractStructuralChecks(encodingChecks) : undefined;
-    const copyOfType = copy(type);
-    copyOfType.encoding = undefined;
-    copyOfType.encodingChecks = undefined;
-    copyOfType.checks = combineChecks(type.checks, checks);
-    return copyOfType;
-  }
-  return type.encoding ? replaceEncoding(type, undefined) : type;
+  const owner = getContextOwner(ast);
+  if (owner !== ast) {
+    const type = toType(owner);
+    return type === owner && ast.encoding === undefined ? ast : replaceContext(type, ast.context);
+  }
+  const type = "recur" in ast ? ast.recur(toType) : ast;
+  if ("encodingChecks" in type && type.encodingChecks) {
+    const checks = canPreserveEncodingChecks(ast) ? type.encodingChecks : isArrays(type) || isObjects(type) || isDeclaration(type) && type.typeParameters.length > 0 ? extractStructuralChecks(type.encodingChecks) : undefined;
+    return copy(type, {
+      encodingChecks: undefined,
+      checks: combineChecks(type.checks, checks)
+    });
+  }
+  return type;
 });
 var toEncoded = /* @__PURE__ */ memoizeIdempotent((ast) => {
   return toType(flip2(ast));
@@ -8664,8 +8668,12 @@ var flip2 = /* @__PURE__ */ memoize((ast) => {
   if (ast.encoding) {
     return flipEncoding(ast, ast.encoding);
   }
-  const out = ast;
-  return out.flip?.(flip2) ?? out.recur?.(flip2) ?? out;
+  const owner = getContextOwner(ast);
+  if (owner !== ast) {
+    const flipped = flip2(owner);
+    return flipped === owner ? ast : replaceContext(flipped, ast.context);
+  }
+  return "flip" in ast ? ast.flip(flip2) : ("recur" in ast) ? ast.recur(flip2) : ast;
 });
 function containsUndefined(ast) {
   switch (ast._tag) {
@@ -9548,7 +9556,7 @@ var make15 = /* @__PURE__ */ gen2(function* () {
           if (exited) {
             const [code] = yield* _await(exitSignal);
             if (code !== 0 && isNotNull(code)) {
-              yield* ignore2(killProcessGroup(cmd, childProcess, cmd.options.killSignal ?? "SIGTERM"));
+              yield* ignore2(terminateProcessGroup(cmd, childProcess, exitSignal, cmd.options));
             } else if (isReferenced && process.platform !== "win32" && cmd.options.detached !== false) {
               yield* ignore2(terminateProcessGroup(cmd, childProcess, exitSignal, cmd.options));
             }
@@ -11302,19 +11310,7 @@ function validateCanonicalObjectPropertyNames(ast) {
 }
 function makeReorder(getPriority) {
   return (types) => {
-    const indexMap = new Map;
-    for (let i = 0;i < types.length; i++) {
-      indexMap.set(toEncoded(types[i]), i);
-    }
-    const sortedTypes = [...types].sort((a, b) => {
-      a = toEncoded(a);
-      b = toEncoded(b);
-      const pa = getPriority(a);
-      const pb = getPriority(b);
-      if (pa !== pb)
-        return pa - pb;
-      return indexMap.get(a) - indexMap.get(b);
-    });
+    const sortedTypes = [...types].sort((a, b) => getPriority(toEncoded(a)) - getPriority(toEncoded(b)));
     const orderChanged = sortedTypes.some((ast, index) => ast !== types[index]);
     if (!orderChanged)
       return types;
@@ -11597,8 +11593,8 @@ function Literals(literals) {
 }
 var NullOr = /* @__PURE__ */ lambda((self) => Union2([self, Null2]));
 var UndefinedOr = /* @__PURE__ */ lambda((self) => Union2([self, Undefined2]));
-function brand2(identifier) {
-  return (schema) => make24(brand(schema.ast, identifier), {
+function brand(identifier) {
+  return (schema) => make24(schema.ast, {
     schema,
     identifier
   });
@@ -18116,7 +18112,7 @@ var layer14 = /* @__PURE__ */ layerMergedContext(/* @__PURE__ */ succeed6(fetch)
 // package.json
 var package_default = {
   name: "jj-octo",
-  version: "0.2.0",
+  version: "0.2.2",
   description: "A jj subcommand for working with GitHub that supports stacking",
   license: "MIT",
   repository: {
@@ -18146,11 +18142,11 @@ var package_default = {
     test: "bun test ./src"
   },
   devDependencies: {
-    "@effect/platform-bun": "4.0.0-rc.118",
+    "@effect/platform-bun": "4.0.1",
     "@octokit/openapi-types": "29.0.1",
     "@tsconfig/strictest": "2.0.8",
     "@types/bun": "1.4.2",
-    effect: "4.0.0-rc.118",
+    effect: "4.0.1",
     oxfmt: "0.71.0",
     oxlint: "1.86.0",
     "oxlint-tsgolint": "7.0.2003",
@@ -18452,8 +18448,8 @@ var responseOf = () => (schema) => schema;
 var bodyOf = (body) => bodyJsonUnsafe(body);
 
 // src/clients/github/types.ts
-var PullRequestNumberSchema = Number6.pipe(brand2("PullRequestNumber"));
-var StackNumberSchema = Number6.pipe(brand2("StackNumber"));
+var PullRequestNumberSchema = Number6.pipe(brand("PullRequestNumber"));
+var StackNumberSchema = Number6.pipe(brand("StackNumber"));
 
 // src/clients/github/client.ts
 class GitHubFailed extends TaggedError2("GitHubFailed") {
@@ -18870,6 +18866,7 @@ var rebaseStack = (root, required) => gen2(function* () {
   const [name = root] = yield* changesIn(root);
   const changes = yield* changeIdsAt(stack);
   const conflicted = yield* changeIdsAt(`conflicts() & (${stack})`);
+  const conflictedCommits = yield* commitsAt("conflicts() & mutable()");
   const [operation = ""] = lines2(yield* jj.read([
     "operation",
     "log",
@@ -18880,21 +18877,29 @@ var rebaseStack = (root, required) => gen2(function* () {
     String.raw`id ++ "\n"`
   ]));
   yield* jj.run(["rebase", "--source", root, "--destination", "trunk()", "--skip-emptied"]);
-  const rebased = ["none()", ...changes.map((change) => `present(${change})`)].join(" | ");
-  const conflictedNow = yield* changeIdsAt(`conflicts() & (${rebased})`);
+  const rebased = ["none()", ...changes.map((change) => `change_id(${change})`)].join(" | ");
+  const untouched = ["none()", ...conflictedCommits].join(" | ");
+  const conflictedNow = yield* changeIdsAt(`(conflicts() & (${rebased})) ~ (${untouched})`);
   const mayRestore = !changes.some((change) => required.includes(change));
   if (mayRestore && conflictedNow.some((change) => !conflicted.includes(change))) {
     yield* jj.run(["operation", "restore", operation]);
     yield* error(`left "${name}" and the changes on it where they were: they conflict with the trunk`);
   }
 });
-var sync4 = (required = []) => gen2(function* () {
+var sync4 = (required = [], mergedChanges = []) => gen2(function* () {
   const jj = yield* Jj;
   const before = yield* bookmarksBeforeFetch;
   yield* jj.run(["git", "fetch"]);
+  for (const { bookmark } of mergedChanges) {
+    yield* jj.run(["bookmark", "forget", "--include-remotes", `exact:${bookmark}`]);
+  }
+  if (mergedChanges.length > 0) {
+    const revset = mergedChanges.map(({ changeId }) => `change_id(${changeId})`).join(" | ");
+    yield* jj.run(["abandon", `(${revset}) & mutable()`]);
+  }
   const fetched = yield* bookmarkTargets;
   const notCombined = [];
-  for (const bookmark of before) {
+  for (const bookmark of before.filter(({ name }) => mergedChanges.every((change) => change.bookmark !== name))) {
     if (!(yield* combine4(bookmark, fetched.get(bookmark.name)?.origin))) {
       notCombined.push(bookmark.name);
     }
@@ -18972,7 +18977,7 @@ var merge5 = (revision) => gen2(function* () {
     yield* error("queued to merge; run `jj gh sync` once it has");
   } else {
     yield* error(`merged up to #${pullRequest.number}`);
-    yield* sync4(stackChanges);
+    yield* sync4(stackChanges, changes);
     for (const bookmark of above) {
       if ((yield* commitsAt(bookmarkRevset(bookmark))).length > 0) {
         yield* republish(bookmarkRevset(bookmark));
@@ -18981,7 +18986,7 @@ var merge5 = (revision) => gen2(function* () {
     }
   }
 });
-var mergeCommand = make30("merge", { revision: revisionFlag("The top change to merge") }, ({ revision }) => asUserError(merge5(revision).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Merge the pull requests of a change and the ones below it", "Squash-merges them, and prints which before it does. An empty working copy means the change below it. Fails before merging if any of the changes has edits that aren't pushed.", "A pull request in a GitHub stack is merged together with the pull requests below it. Either all of them merge or none does. A pull request outside a stack is merged alone, and only if its base is the trunk.", "Then syncs, as `jj gh sync` does, and pushes what is left of the change's stack again, up to the highest branch already on GitHub. Unlike `jj gh sync`, it rebases that stack even where it conflicts with the trunk, and the conflict is recorded in the change.", "If GitHub queues the merge instead, nothing is synced. Run `jj gh sync` once it has merged."));
+var mergeCommand = make30("merge", { revision: revisionFlag("The top change to merge") }, ({ revision }) => asUserError(merge5(revision).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Merge the pull requests of a change and the ones below it", "Squash-merges them, and prints which before it does. An empty working copy means the change below it. Fails before merging if any of the changes has edits that aren't pushed.", "A pull request in a GitHub stack is merged together with the pull requests below it. Either all of them merge or none does. A pull request outside a stack is merged alone, and only if its base is the trunk.", "Then syncs, as `jj gh sync` does, and pushes what is left of the change's stack again, up to the highest branch already on GitHub. Unlike `jj gh sync`, it abandons the merged changes and forgets their bookmarks, rather than relying on each coming out empty on the trunk, which one doesn't where a change merged above it edited the same lines. It also rebases the rest of the stack even where it conflicts with the trunk, and the conflict is recorded in the change.", "If GitHub queues the merge instead, nothing is synced. Run `jj gh sync` once it has merged."));
 
 // src/cli/gh/submit.ts
 var submitCommand = make30("submit", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jj-octo",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A jj subcommand for working with GitHub that supports stacking",
   "license": "MIT",
   "repository": {
@@ -30,11 +30,11 @@
     "test": "bun test ./src"
   },
   "devDependencies": {
-    "@effect/platform-bun": "4.0.0-rc.118",
+    "@effect/platform-bun": "4.0.1",
     "@octokit/openapi-types": "29.0.1",
     "@tsconfig/strictest": "2.0.8",
     "@types/bun": "1.4.2",
-    "effect": "4.0.0-rc.118",
+    "effect": "4.0.1",
     "oxfmt": "0.71.0",
     "oxlint": "1.86.0",
     "oxlint-tsgolint": "7.0.2003",