import { it } from "@effect/vitest";import { describe, expect } from "vite-plus/test";import * as Effect from "effect/Effect";import * as Exit from "effect/Exit";import * as Fiber from "effect/Fiber";import * as Option from "effect/Option";import * as Stream from "effect/Stream"; import type { PluginDefinition } from "@t3tools/plugin-runtime"; import * as PluginCommandCatalog from "./PluginCommandCatalog.ts"; const testPlugin = (input: {  readonly fail?: boolean;  readonly message: string;  readonly onDispose?: () => void | Promise<void>;  readonly version: string;}): PluginDefinition => ({  id: "acme.command-plugin",  version: input.version,  activate(context) {    if (input.fail === true) throw new Error("activation failed");    if (input.onDispose !== undefined) context.onDispose(input.onDispose);    PluginCommandCatalog.registerPluginCommand(context, {      command: {        id: "acme.hello",        label: "Say hello",        description: "Return a greeting from the trusted test plugin.",        surfaces: ["web", "desktop", "mobile"],      },      handler: Effect.succeed({ message: input.message, tone: "success" }),    });  },}); describe("plugin command catalog", () => {  it.effect("lists and invokes the trusted built-in command", () =>    Effect.gen(function* () {      const catalog = yield* PluginCommandCatalog.PluginCommandCatalog;      const listed = yield* catalog.list;      const streamed = yield* Stream.runHead(catalog.changes);       expect(listed.commands.map((command) => command.id)).toContain("t3.plugin-runtime.status");      expect(Object.isFrozen(listed)).toBe(true);      expect(Object.isFrozen(listed.commands)).toBe(true);      expect(Object.isFrozen(listed.commands[0])).toBe(true);      expect(Object.isFrozen(listed.commands[0]?.surfaces)).toBe(true);      expect(Option.getOrNull(streamed)).toEqual(listed);      expect(        yield* catalog.invoke({          generation: listed.generation,          id: "t3.plugin-runtime.status",        }),      ).toEqual({ message: "Plugin runtime is active.", tone: "success" });    }).pipe(Effect.provide(PluginCommandCatalog.layer)),  );   it.effect("keeps the committed command and handler when replacement activation fails", () =>    Effect.gen(function* () {      const catalog = yield* PluginCommandCatalog.PluginCommandCatalog;      const first = yield* catalog.reconcile([        testPlugin({ message: "hello one", version: "1.0.0" }),      ]);      const failed = yield* Effect.exit(        catalog.reconcile([testPlugin({ fail: true, message: "hello two", version: "2.0.0" })]),      );       expect(Exit.isFailure(failed)).toBe(true);      expect(yield* catalog.list).toEqual(first);      expect(yield* catalog.invoke({ generation: first.generation, id: "acme.hello" })).toEqual({        message: "hello one",        tone: "success",      });    }).pipe(Effect.provide(PluginCommandCatalog.layer)),  );   it.effect("does not republish an unchanged command catalog", () =>    Effect.gen(function* () {      const catalog = yield* PluginCommandCatalog.PluginCommandCatalog;      const definition = testPlugin({ message: "hello one", version: "1.0.0" });       const first = yield* catalog.reconcile([definition]);      const second = yield* catalog.reconcile([definition]);       expect(second).toBe(first);    }).pipe(Effect.provide(PluginCommandCatalog.layer)),  );   it.effect("rolls back invalid command metadata before publishing a generation", () =>    Effect.gen(function* () {      const catalog = yield* PluginCommandCatalog.PluginCommandCatalog;      const first = yield* catalog.list;      const invalid: PluginDefinition = {        id: "acme.invalid-command-plugin",        version: "1.0.0",        activate(context) {          context.register(            "commands",            {              id: "acme.invalid",              label: "Invalid command",              data: { surfaces: ["server"] },            },            Effect.succeed({ message: "invalid", tone: "success" as const }),          );        },      };       const failed = yield* Effect.exit(catalog.reconcile([invalid]));       const shadowedIdentity: PluginDefinition = {        id: "acme.shadowed-command-plugin",        version: "1.0.0",        activate(context) {          context.register(            "commands",            {              id: "acme.registered",              label: "Registered command",              data: {                id: "acme.advertised",                label: "Advertised command",                surfaces: ["web"],              },            },            Effect.succeed({ message: "shadowed", tone: "success" as const }),          );        },      };      const shadowed = yield* Effect.exit(catalog.reconcile([shadowedIdentity]));       expect(Exit.isFailure(failed)).toBe(true);      expect(Exit.isFailure(shadowed)).toBe(true);      expect(yield* catalog.list).toBe(first);      expect(        yield* catalog.invoke({          generation: first.generation,          id: "t3.plugin-runtime.status",        }),      ).toEqual({ message: "Plugin runtime is active.", tone: "success" });    }).pipe(Effect.provide(PluginCommandCatalog.layer)),  );   it.effect("serializes runtime reconciliation through catalog publication", () =>    Effect.gen(function* () {      const catalog = yield* PluginCommandCatalog.PluginCommandCatalog;      let markActivationStarted!: () => void;      let releaseActivation!: () => void;      let markSecondActivationStarted!: () => void;      const activationStarted = new Promise<void>((resolve) => {        markActivationStarted = resolve;      });      const activationGate = new Promise<void>((resolve) => {        releaseActivation = resolve;      });      const secondActivationStarted = new Promise<void>((resolve) => {        markSecondActivationStarted = resolve;      });      const firstPlugin: PluginDefinition = {        id: "acme.first-command-plugin",        version: "1.0.0",        activate(context) {          markActivationStarted();          return activationGate.then(() => {            PluginCommandCatalog.registerPluginCommand(context, {              command: { id: "acme.first", label: "First", surfaces: ["web"] },              handler: Effect.succeed({ message: "first", tone: "success" }),            });          });        },      };      const secondPlugin: PluginDefinition = {        id: "acme.second-command-plugin",        version: "1.0.0",        activate(context) {          markSecondActivationStarted();          PluginCommandCatalog.registerPluginCommand(context, {            command: { id: "acme.second", label: "Second", surfaces: ["web"] },            handler: Effect.succeed({ message: "second", tone: "success" }),          });        },      };       const firstFiber = yield* Effect.forkChild(catalog.reconcile([firstPlugin]));      yield* Effect.promise(() => activationStarted);      const secondFiber = yield* Effect.forkChild(catalog.reconcile([secondPlugin]));      yield* Effect.yieldNow;      releaseActivation();       const first = yield* Fiber.join(firstFiber);      yield* Effect.promise(() => secondActivationStarted);      const generationSeenBySecondActivation = (yield* catalog.list).generation;      const second = yield* Fiber.join(secondFiber);      expect(generationSeenBySecondActivation).toBe(first.generation);      expect(yield* catalog.list).toBe(second);    }).pipe(Effect.provide(PluginCommandCatalog.layer)),  );   it.effect("publishes a committed runtime generation before reporting interruption", () =>    Effect.gen(function* () {      const catalog = yield* PluginCommandCatalog.PluginCommandCatalog;      let markRetirementStarted!: () => void;      let releaseRetirement!: () => void;      const retirementStarted = new Promise<void>((resolve) => {        markRetirementStarted = resolve;      });      const retirementGate = new Promise<void>((resolve) => {        releaseRetirement = resolve;      });      const first = yield* catalog.reconcile([        testPlugin({          message: "hello one",          onDispose: async () => {            markRetirementStarted();            await retirementGate;          },          version: "1.0.0",        }),      ]);      const replacement = yield* Effect.forkChild(        catalog.reconcile([testPlugin({ message: "hello two", version: "2.0.0" })]),      );      yield* Effect.promise(() => retirementStarted);      const interruption = yield* Effect.forkChild(Fiber.interrupt(replacement));      yield* Effect.yieldNow;      releaseRetirement();      yield* Fiber.join(interruption);       const second = yield* catalog.list;      expect(second.generation).toBe(first.generation + 1);      expect(yield* catalog.invoke({ generation: second.generation, id: "acme.hello" })).toEqual({        message: "hello two",        tone: "success",      });    }).pipe(Effect.provide(PluginCommandCatalog.layer)),  );});