import {  PluginCommand as PluginCommandSchema,  type PluginCommand,  type PluginCommandCatalog as PluginCommandCatalogSnapshot,  PluginCommandCatalogChangedError,  type PluginCommandInvocationResult,  PluginCommandInvocationError,  type PluginCommandInvokeInput,  PluginCommandNotFoundError,} from "@t3tools/contracts";import type {  Contribution,  PluginActivationContext,  PluginDefinition,  PluginRuntimeSnapshot,} from "@t3tools/plugin-runtime";import { PluginRuntime } from "@t3tools/plugin-runtime";import * as Context from "effect/Context";import * as Effect from "effect/Effect";import * as Exit from "effect/Exit";import * as Layer from "effect/Layer";import * as Schema from "effect/Schema";import * as Semaphore from "effect/Semaphore";import type * as Stream from "effect/Stream";import * as SubscriptionRef from "effect/SubscriptionRef"; const COMMAND_SLOT = "commands";const decodePluginCommand = Schema.decodeUnknownSync(PluginCommandSchema);const decodePluginCommandEffect = Schema.decodeUnknownEffect(PluginCommandSchema);const isContributionGenerationError = Schema.is(PluginRuntime.PluginContributionGenerationError);const isContributionNotFoundError = Schema.is(PluginRuntime.PluginContributionNotFoundError); const commandInputFromContribution = (entry: Contribution) => {  const data = typeof entry.data === "object" && entry.data !== null ? entry.data : {};  if (Object.hasOwn(data, "id") || Object.hasOwn(data, "label")) {    throw new TypeError("Plugin command metadata cannot override its registered id or label");  }  return { ...data, id: entry.id, label: entry.label };}; const validateCommandSnapshot = (snapshot: PluginRuntimeSnapshot): void => {  for (const entry of snapshot.contributions[COMMAND_SLOT] ?? []) {    decodePluginCommand(commandInputFromContribution(entry));  }}; export class PluginCommandExecutionError extends Schema.TaggedErrorClass<PluginCommandExecutionError>()(  "PluginCommandExecutionError",  { cause: Schema.Defect() },) {} type PluginCommandHandler = Effect.Effect<  PluginCommandInvocationResult,  PluginCommandExecutionError>; export class PluginCommandDefinitionError extends Schema.TaggedErrorClass<PluginCommandDefinitionError>()(  "PluginCommandDefinitionError",  { cause: Schema.Defect(), id: Schema.String },) {  override get message(): string {    return `Plugin command ${this.id} has invalid declarative metadata.`;  }} export interface PluginCommandRegistration {  readonly command: PluginCommand;  readonly handler: PluginCommandHandler;} export const registerPluginCommand = (  context: PluginActivationContext,  registration: PluginCommandRegistration,): void => {  const command = decodePluginCommand(registration.command);  const { description, surfaces } = command;  context.register(    COMMAND_SLOT,    {      id: command.id,      label: command.label,      data: {        ...(description === undefined ? {} : { description }),        surfaces,      },    },    registration.handler,  );}; const builtInPlugin: PluginDefinition = {  id: "t3.plugin-runtime.commands",  version: "1.0.0",  activate(context) {    registerPluginCommand(context, {      command: {        id: "t3.plugin-runtime.status",        label: "Check plugin runtime",        description: "Verify that the environment plugin runtime is responding.",        surfaces: ["web", "desktop", "mobile"],      },      handler: Effect.succeed({        message: "Plugin runtime is active.",        tone: "success",      }),    });  },}; const catalogFromRuntime = Effect.fn("PluginCommandCatalog.catalogFromRuntime")(function* (  runtime: PluginRuntime.PluginRuntime["Service"],) {  const snapshot = yield* runtime.contributions(COMMAND_SLOT);  const commands = yield* Effect.forEach(snapshot.entries, (entry) =>    decodePluginCommandEffect(commandInputFromContribution(entry)).pipe(      Effect.mapError((cause) => new PluginCommandDefinitionError({ cause, id: entry.id })),    ),  );  const frozenCommands = commands.map((command) =>    Object.freeze({ ...command, surfaces: Object.freeze([...command.surfaces]) }),  );  return Object.freeze({    commands: Object.freeze(frozenCommands),    generation: snapshot.generation,  }) satisfies PluginCommandCatalogSnapshot;}); export class PluginCommandCatalog extends Context.Service<  PluginCommandCatalog,  {    readonly list: Effect.Effect<PluginCommandCatalogSnapshot>;    readonly changes: Stream.Stream<PluginCommandCatalogSnapshot>;    readonly invoke: (      input: PluginCommandInvokeInput,    ) => Effect.Effect<      PluginCommandInvocationResult,      PluginCommandCatalogChangedError | PluginCommandInvocationError | PluginCommandNotFoundError    >;    readonly reconcile: (      definitions: ReadonlyArray<PluginDefinition>,    ) => Effect.Effect<      PluginCommandCatalogSnapshot,      PluginCommandDefinitionError | PluginRuntime.PluginRuntimeReconcileError    >;  }>()("t3/plugins/PluginCommandCatalog") {} export const make = Effect.gen(function* () {  const runtime = yield* PluginRuntime.PluginRuntime;  const state = yield* SubscriptionRef.make<PluginCommandCatalogSnapshot>({    commands: [],    generation: 0,  });  const reconcileSemaphore = yield* Semaphore.make(1);   const reconcile = Effect.fn("PluginCommandCatalog.reconcile")(    (definitions: ReadonlyArray<PluginDefinition>) =>      reconcileSemaphore.withPermits(1)(        Effect.uninterruptibleMask((restore) =>          Effect.gen(function* () {            const transitionExit = yield* Effect.exit(              restore(runtime.reconcile([builtInPlugin, ...definitions])),            );            const catalog = yield* catalogFromRuntime(runtime);            const previous = yield* SubscriptionRef.get(state);            const published =              previous.generation === catalog.generation                ? previous                : yield* SubscriptionRef.set(state, catalog).pipe(Effect.as(catalog));            if (Exit.isFailure(transitionExit)) {              return yield* Effect.failCause(transitionExit.cause);            }            return published;          }),        ),      ),  );   yield* reconcile([]);   const invoke = Effect.fn("PluginCommandCatalog.invoke")(function* (    input: PluginCommandInvokeInput,  ) {    return yield* runtime      .useContribution<        PluginCommandHandler,        PluginCommandInvocationResult,        PluginCommandExecutionError,        never      >(COMMAND_SLOT, input.id, input.generation, (handler) => handler)      .pipe(        Effect.mapError((error) => {          if (isContributionGenerationError(error)) {            return new PluginCommandCatalogChangedError({              actualGeneration: error.actual,              expectedGeneration: error.expected,            });          }          if (isContributionNotFoundError(error)) {            return new PluginCommandNotFoundError({ id: input.id });          }          return new PluginCommandInvocationError({            cause: error,            id: input.id,            message: "Plugin command failed.",          });        }),      );  });   return PluginCommandCatalog.of({    changes: SubscriptionRef.changes(state),    invoke,    list: SubscriptionRef.get(state),    reconcile,  });}); export const layer = Layer.effect(PluginCommandCatalog, make).pipe(  Layer.provide(PluginRuntime.layer({ validateSnapshot: validateCommandSnapshot })),);