import { it } from "@effect/vitest";import { describe, expect } from "vite-plus/test";import * as Cause from "effect/Cause";import * as Context from "effect/Context";import * as Effect from "effect/Effect";import * as Exit from "effect/Exit";import * as Fiber from "effect/Fiber";import * as Layer from "effect/Layer";import * as Scope from "effect/Scope"; import type {  PluginDefinition,  PluginRuntimeOptions,  PluginRuntimeSnapshot,} from "../src/contract.ts";import * as PluginRuntime from "../src/runtime.ts";import { defineRuntimeContract } from "./runtimeContract.ts"; const makeTestRuntime = (options: PluginRuntimeOptions = {}) => PluginRuntime.make(options); const makeEffectCallback = <A, E>() => {  let unsafeResume: (effect: Effect.Effect<A, E>) => void = () => {    throw new Error("effect callback has not started");  };  return {    await: Effect.callback<A, E>((resume) => {      unsafeResume = resume;    }),    resume: (effect: Effect.Effect<A, E>) => unsafeResume(effect),  } as const;}; defineRuntimeContract("plugin runtime", makeTestRuntime); describe("plugin runtime errors", () => {  it.effect("returns schema-tagged planning errors", () =>    Effect.scoped(      Effect.gen(function* () {        const runtime = yield* makeTestRuntime();        const duplicate = {          id: "acme.duplicate",          version: "1.0.0",          activate() {},        };         const error = yield* Effect.flip(runtime.reconcile([duplicate, duplicate]));         expect(error).toMatchObject({          _tag: "DuplicatePluginIdError",          pluginId: "acme.duplicate",        });        yield* runtime.dispose;      }),    ),  );}); describe("plugin runtime planner", () => {  it.effect("plans a deep acyclic dependency chain without using the call stack", () =>    Effect.scoped(      Effect.gen(function* () {        const runtime = yield* makeTestRuntime();        const pluginCount = 20_000;        const definitions: Array<PluginDefinition> = Array.from(          { length: pluginCount },          (_, index) => ({            id: `plugin-${index}`,            version: "1.0.0",            ...(index === 0 ? {} : { requires: [`capability-${index - 1}`] }),            provides: { [`capability-${index}`]: index },            activate() {},          }),        );         const snapshot = yield* runtime.reconcile(definitions.toReversed());         expect(snapshot.active).toHaveLength(pluginCount);        yield* runtime.dispose;      }),    ),  );}); describe("plugin runtime layer", () => {  it.effect("closes active plugin scopes when the layer is released", () =>    Effect.gen(function* () {      let disposed = false;      const lifecycle: Array<string> = [];       yield* PluginRuntime.PluginRuntime.use((runtime) =>        runtime.reconcile([          {            id: "acme.layer-owned",            version: "1.0.0",            activate(context) {              context.onDispose(() => {                disposed = true;              });            },          },        ]),      ).pipe(        Effect.provide(          PluginRuntime.layer({            onLifecycle: ({ phase, pluginId }) => lifecycle.push(`${phase}:${pluginId}`),          }),        ),      );       expect(disposed).toBe(true);      expect(lifecycle).toEqual(["activate:acme.layer-owned", "deactivate:acme.layer-owned"]);    }),  );   it.effect("serializes layer release with an in-flight reconcile", () =>    Effect.gen(function* () {      let markActivationStarted!: () => void;      const activationStarted = new Promise<void>((resolve) => {        markActivationStarted = resolve;      });      let releaseActivation!: () => void;      const activationGate = new Promise<void>((resolve) => {        releaseActivation = resolve;      });      const lifecycle: Array<string> = [];      const runtimeScope = yield* Scope.make("sequential");      const services = yield* Layer.buildWithScope(        PluginRuntime.layer({          onLifecycle: ({ phase, pluginId }) => lifecycle.push(`${phase}:${pluginId}`),        }),        runtimeScope,      );      const runtime = Context.get(services, PluginRuntime.PluginRuntime);      const reconcileFiber = yield* Effect.forkChild(        runtime.reconcile([          {            id: "acme.layer-release-race",            version: "1.0.0",            async activate() {              markActivationStarted();              await activationGate;            },          },        ]),      );      yield* Effect.callback<void>((resume) => {        void activationStarted.then(() => resume(Effect.void));      });       const layerRelease = yield* Effect.forkChild(Scope.close(runtimeScope, Exit.void));      yield* Effect.yieldNow;      expect(layerRelease.pollUnsafe()).toBeUndefined();       releaseActivation();      yield* Fiber.join(reconcileFiber);      yield* Fiber.join(layerRelease);      expect(lifecycle).toEqual([        "activate:acme.layer-release-race",        "deactivate:acme.layer-release-race",      ]);    }),  );}); describe("plugin runtime disposal", () => {  it.effect("retries scope cleanup after an interrupted dispose", () =>    Effect.scoped(      Effect.gen(function* () {        let markStarted!: () => void;        let releaseCleanup!: () => void;        const started = new Promise<void>((resolve) => {          markStarted = resolve;        });        const cleanupGate = new Promise<void>((resolve) => {          releaseCleanup = resolve;        });        const runtime = yield* makeTestRuntime();         yield* runtime.reconcile([          {            id: "acme.interrupted-dispose",            version: "1.0.0",            activate(context) {              context.onDispose(async () => {                markStarted();                await cleanupGate;              });            },          },        ]);         const firstDispose = yield* Effect.forkChild(runtime.dispose);        yield* Effect.callback<void>((resume) => {          void started.then(() => resume(Effect.void));        });        const interruption = yield* Effect.forkChild(Fiber.interrupt(firstDispose));        yield* Effect.yieldNow;         const retry = yield* Effect.forkChild(runtime.dispose);        yield* Effect.yieldNow;        expect(retry.pollUnsafe()).toBeUndefined();         releaseCleanup();        yield* Fiber.join(interruption);        yield* Fiber.join(retry);        expect(yield* runtime.snapshot).toEqual({          active: [],          blocked: {},          contributions: {},        });      }),    ),  );}); describe("plugin runtime interruption", () => {  it.effect("expires activation context when reconcile is interrupted", () =>    Effect.scoped(      Effect.gen(function* () {        let markActivationStarted!: () => void;        const activationStarted = new Promise<void>((resolve) => {          markActivationStarted = resolve;        });        let interruptCompleted = false;        let lateRegistrationSucceeded = false;        let lateFailure: unknown;        let earlyFinalizerRan = false;        let lateFinalizerRan = false;        let releaseActivation!: () => void;        const activationGate = new Promise<void>((resolve) => {          releaseActivation = resolve;        });        const runtime = yield* makeTestRuntime();        const nested = makeEffectCallback<Exit.Exit<PluginRuntimeSnapshot, unknown>, never>();        const nestedFiber = yield* Effect.forkChild(nested.await);        yield* Effect.yieldNow;        const reconcileFiber = yield* Effect.forkChild(          runtime.reconcile([            {              id: "acme.interrupted-activation",              version: "1.0.0",              async activate(context) {                context.onDispose(() => {                  earlyFinalizerRan = true;                });                markActivationStarted();                await activationGate;                try {                  context.onDispose(() => {                    lateFinalizerRan = true;                  });                  lateRegistrationSucceeded = true;                } catch (error) {                  lateFailure = error;                }                nested.resume(Effect.exit(runtime.reconcile([])));              },            },          ]),        );        yield* Effect.callback<void>((resume) => {          void activationStarted.then(() => resume(Effect.void));        });         const interruption = yield* Effect.forkChild(          Fiber.interrupt(reconcileFiber).pipe(            Effect.ensuring(Effect.sync(() => (interruptCompleted = true))),          ),        );        for (let attempt = 0; attempt < 10; attempt += 1) {          yield* Effect.yieldNow;        }        expect(interruptCompleted).toBe(true);         releaseActivation();        yield* Fiber.join(interruption);        yield* Effect.callback<void>((resume) => {          queueMicrotask(() => resume(Effect.void));        });        const nestedExit = yield* Fiber.join(nestedFiber);        yield* runtime.dispose;         expect(lateRegistrationSucceeded).toBe(false);        expect(lateFailure).toBeInstanceOf(Error);        expect(earlyFinalizerRan).toBe(true);        expect(lateFinalizerRan).toBe(false);        expect(Exit.isFailure(nestedExit)).toBe(true);        if (Exit.isFailure(nestedExit)) {          expect(Cause.squash(nestedExit.cause)).toMatchObject({            _tag: "PluginRuntimeReentrancyError",          });        }      }),    ),  );});