Function loadSharedHandle

apps/local/src/executor.ts:265–297

()

let sharedHandleLifecycle: Promise<void> = Promise.resolve();

const loadSharedHandle = (): Promise<ExecutorHandle> => {
  if (sharedHandlePromise) {
    return sharedHandlePromise;
  }

  // Capture the lifecycle tail at call time so creation stays ordered behind
  // in-flight dispose
  const lifecycle = sharedHandleLifecycle;

  // Identity token the heal closure compares against. Using a `let` declared
  // up front avoids any reference-before-init ambiguity in the closure.
  let slot: Promise<ExecutorHandle>;

  const acquire = Effect.tryPromise({
    try: () => lifecycle.then(() => createExecutorHandle()),
    catch: (cause) => new SharedHandleCreateError({ cause }),
  }).pipe(
    // Self-heal: a failed creation must not poison the memo. Clear the slot on
    // any non-success outcome so the next getExecutor() retries, but only if a
    // dispose/reload hasn't already swapped in a newer promise (identity guard).
    Effect.onError(() =>
      Effect.sync(() => {
        if (sharedHandlePromise === slot) {
          sharedHandlePromise = null;
        }
      }),
    ),
  );

  slot = Effect.runPromise(acquire);
  sharedHandlePromise = slot;
  return slot;
};

export const getExecutor = () => loadSharedHandle().then((handle) => handle.executor);
export const getExecutorBundle = () => loadSharedHandle();