Function armableFailingProvider

packages/core/sdk/src/executor.test.ts:1332–1364

()

 *  plainly-forked integration read's scheduler tick, so the read this test
 *  wants hanging would never start at all. */
const armableFailingProvider = () => {
  const store = new Map<string, string>();
  let failWith: string | undefined;
  const provider: CredentialProvider = {
    key: ProviderKey.make("memory"),
    writable: true,
    get: (id) =>
      Effect.suspend(() => {
        if (failWith === undefined) return Effect.succeed(store.get(String(id)) ?? null);
        const message = failWith;
        // Two chained ticks, not one: the credential read launches BEFORE
        // the speculative integration fork is even scheduled (dominant-first
        // is structural), so a failure delivered on the very next tick would
        // interrupt that fork before it ever issued its read. The extra tick
        // lets the speculative read genuinely start — and hang — first, so
        // the test exercises "failure surfaces while the read hangs" rather
        // than "failure surfaces before the read exists".
        return Effect.promise(
          () =>
            new Promise<void>((resolve) => {
              setImmediate(() => setImmediate(resolve));
            }),
        ).pipe(Effect.andThen(Effect.fail(new StorageError({ message, cause: undefined }))));
      }),
    set: (id, value) => Effect.sync(() => void store.set(String(id), value)),
  };
  return {
    provider,
    failNow: (message: string) => {
      failWith = message;
    },
  };
};

describe("speculative read abandonment", () => {
  it.effect("unknown-tool error surfaces while the speculative reads hang forever", () =>