import type { RepositoryIdentity } from "@t3tools/contracts";import * as Cache from "effect/Cache";import * as Cause from "effect/Cause";import * as Context from "effect/Context";import * as Duration from "effect/Duration";import * as Effect from "effect/Effect";import * as Exit from "effect/Exit";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as PubSub from "effect/PubSub";import * as Queue from "effect/Queue";import * as Ref from "effect/Ref";import type * as Scope from "effect/Scope"; import * as ProjectFaviconResolver from "./ProjectFaviconResolver.ts";import * as RepositoryIdentityResolver from "./RepositoryIdentityResolver.ts"; const DEFAULT_CACHE_CAPACITY = 512;const DEFAULT_MAX_PENDING = 512;const DEFAULT_CONCURRENCY = 4;const DEFAULT_SUCCESS_TTL = Duration.minutes(1);const DEFAULT_FAILURE_TTL = Duration.seconds(5); export interface ProjectEnrichment {  readonly repositoryIdentity: RepositoryIdentity | null;  readonly faviconPath: string | null;  /** True when identity resolution completed successfully, including cached null. */  readonly repositoryIdentityResolved: boolean;} export interface ProjectEnrichmentChange {  readonly workspaceRoot: string;  readonly enrichment: ProjectEnrichment;  readonly repositoryIdentityResolved: boolean;} export interface ProjectEnrichmentServiceOptions {  readonly cacheCapacity?: number;  /** Maximum active and queued roots for each enrichment field. */  readonly maxPending?: number;  /** Worker concurrency for each enrichment field. */  readonly concurrency?: number;  readonly successTtl?: Duration.Input;  readonly failureTtl?: Duration.Input;} export class ProjectEnrichmentService extends Context.Service<  ProjectEnrichmentService,  {    /** Read resolved metadata without starting or awaiting filesystem work. */    readonly peek: (workspaceRoot: string) => Effect.Effect<ProjectEnrichment>;    /** Schedule missing metadata for bounded background resolution. */    readonly request: (workspaceRoot: string) => Effect.Effect<void>;    /** Read immediately available metadata and schedule anything missing. */    readonly getAvailable: (workspaceRoot: string) => Effect.Effect<ProjectEnrichment>;    /** Invalidate workspace-derived metadata. */    readonly invalidate: (workspaceRoots: Iterable<string>) => Effect.Effect<void>;    /** Subscribe to ephemeral completion notifications. */    readonly subscribeChanges: Effect.Effect<      PubSub.Subscription<ProjectEnrichmentChange>,      never,      Scope.Scope    >;  }>()("t3/project/ProjectEnrichmentService") {} function availableValue<A, E>(cached: Option.Option<Exit.Exit<A, E>>): A | null {  return Option.match(cached, {    onNone: () => null,    onSome: (exit) =>      Exit.match(exit, {        onFailure: () => null,        onSuccess: (value) => value,      }),  });} function isSuccessfullyResolved<A, E>(cached: Option.Option<Exit.Exit<A, E>>): boolean {  return Option.match(cached, {    onNone: () => false,    onSome: (exit) => Exit.isSuccess(exit),  });} interface EnrichmentWorkLane {  readonly pendingRoots: Ref.Ref<ReadonlySet<string>>;  readonly queue: Queue.Queue<string>;} export const make = Effect.fn("ProjectEnrichmentService.make")(function* (  options: ProjectEnrichmentServiceOptions = {},) {  const repositoryIdentityResolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;  const faviconResolver = yield* ProjectFaviconResolver.ProjectFaviconResolver;  const cacheCapacity = Math.max(1, options.cacheCapacity ?? DEFAULT_CACHE_CAPACITY);  const maxPending = Math.max(1, options.maxPending ?? DEFAULT_MAX_PENDING);  const concurrency = Math.max(1, options.concurrency ?? DEFAULT_CONCURRENCY);  const successTtl = options.successTtl ?? DEFAULT_SUCCESS_TTL;  const failureTtl = options.failureTtl ?? DEFAULT_FAILURE_TTL;   const repositoryIdentityCache = yield* Cache.makeWith(    (workspaceRoot: string) => Effect.exit(repositoryIdentityResolver.resolve(workspaceRoot)),    {      capacity: cacheCapacity,      timeToLive: Exit.match({        onFailure: () => failureTtl,        onSuccess: (result) => (Exit.isSuccess(result) ? successTtl : failureTtl),      }),    },  );  const faviconCache = yield* Cache.makeWith(    (workspaceRoot: string) => Effect.exit(faviconResolver.resolvePath(workspaceRoot)),    {      capacity: cacheCapacity,      timeToLive: Exit.match({        onFailure: () => failureTtl,        onSuccess: (result) => (Exit.isSuccess(result) ? successTtl : failureTtl),      }),    },  );  const makeWorkLane = Effect.gen(function* () {    const pendingRoots = yield* Ref.make<ReadonlySet<string>>(new Set());    const queue = yield* Effect.acquireRelease(Queue.dropping<string>(maxPending), (queue) =>      Queue.shutdown(queue),    );    return { pendingRoots, queue } satisfies EnrichmentWorkLane;  });  const repositoryIdentityLane = yield* makeWorkLane;  const faviconLane = yield* makeWorkLane;  const changes = yield* Effect.acquireRelease(    PubSub.sliding<ProjectEnrichmentChange>(256),    (pubsub) => PubSub.shutdown(pubsub),  );   const removePending = (lane: EnrichmentWorkLane, workspaceRoot: string) =>    Ref.update(lane.pendingRoots, (current) => {      if (!current.has(workspaceRoot)) return current;      const next = new Set(current);      next.delete(workspaceRoot);      return next;    });   const reservePending = (lane: EnrichmentWorkLane, workspaceRoot: string) =>    Ref.modify(lane.pendingRoots, (current) => {      if (current.has(workspaceRoot) || current.size >= maxPending) {        return [false, current] as const;      }      const next = new Set(current);      next.add(workspaceRoot);      return [true, next] as const;    });   const logFailure = <A, E>(    workspaceRoot: string,    field: "repositoryIdentity" | "faviconPath",    result: Exit.Exit<A, E>,  ) =>    Exit.isFailure(result)      ? Effect.logWarning("Failed to enrich optional project metadata", {          workspaceRoot,          field,          cause: Cause.pretty(result.cause),        })      : Effect.void;   const resolveRepositoryIdentity = Effect.fn("ProjectEnrichmentService.resolveRepositoryIdentity")(    function* (workspaceRoot: string) {      const repositoryIdentity = yield* Cache.get(repositoryIdentityCache, workspaceRoot);      yield* logFailure(workspaceRoot, "repositoryIdentity", repositoryIdentity);      const faviconPath = yield* Cache.getSuccess(faviconCache, workspaceRoot);      const repositoryIdentityResolved = Exit.isSuccess(repositoryIdentity);      yield* PubSub.publish(changes, {        workspaceRoot,        repositoryIdentityResolved,        enrichment: {          repositoryIdentity: availableValue(Option.some(repositoryIdentity)),          faviconPath: availableValue(faviconPath),          repositoryIdentityResolved,        },      });    },  );   const resolveFavicon = Effect.fn("ProjectEnrichmentService.resolveFavicon")(function* (    workspaceRoot: string,  ) {    const faviconPath = yield* Cache.get(faviconCache, workspaceRoot);    yield* logFailure(workspaceRoot, "faviconPath", faviconPath);  });   const startWorkers = (    lane: EnrichmentWorkLane,    resolve: (workspaceRoot: string) => Effect.Effect<void>,  ) => {    const worker = Queue.take(lane.queue).pipe(      Effect.flatMap((workspaceRoot) =>        resolve(workspaceRoot).pipe(Effect.ensuring(removePending(lane, workspaceRoot))),      ),      Effect.forever,    );    return Effect.forEach(Array.from({ length: concurrency }), () => Effect.forkScoped(worker), {      discard: true,    });  };  yield* Effect.all(    [      startWorkers(repositoryIdentityLane, resolveRepositoryIdentity),      startWorkers(faviconLane, resolveFavicon),    ],    { concurrency: "unbounded", discard: true },  );   const requestLane = Effect.fn("ProjectEnrichmentService.requestLane")(function* (    lane: EnrichmentWorkLane,    workspaceRoot: string,    field: "repositoryIdentity" | "faviconPath",  ) {    if (!(yield* reservePending(lane, workspaceRoot))) return;    if (!(yield* Queue.offer(lane.queue, workspaceRoot))) {      yield* removePending(lane, workspaceRoot);      yield* Effect.logWarning("Project metadata enrichment queue is full", {        workspaceRoot,        field,      });    }  });   const peek: ProjectEnrichmentService["Service"]["peek"] = Effect.fn(    "ProjectEnrichmentService.peek",  )(function* (workspaceRoot) {    const [repositoryIdentity, faviconPath] = yield* Effect.all(      [        Cache.getSuccess(repositoryIdentityCache, workspaceRoot),        Cache.getSuccess(faviconCache, workspaceRoot),      ] as const,      { concurrency: "unbounded" },    );    return {      repositoryIdentity: availableValue(repositoryIdentity),      faviconPath: availableValue(faviconPath),      repositoryIdentityResolved: isSuccessfullyResolved(repositoryIdentity),    };  });   const request: ProjectEnrichmentService["Service"]["request"] = Effect.fn(    "ProjectEnrichmentService.request",  )(function* (workspaceRoot) {    const [hasRepositoryIdentity, hasFaviconPath] = yield* Effect.all(      [Cache.has(repositoryIdentityCache, workspaceRoot), Cache.has(faviconCache, workspaceRoot)],      { concurrency: "unbounded" },    );    yield* Effect.all(      [        hasRepositoryIdentity          ? Effect.void          : requestLane(repositoryIdentityLane, workspaceRoot, "repositoryIdentity"),        hasFaviconPath ? Effect.void : requestLane(faviconLane, workspaceRoot, "faviconPath"),      ],      { concurrency: "unbounded", discard: true },    );  });   const getAvailable: ProjectEnrichmentService["Service"]["getAvailable"] = Effect.fn(    "ProjectEnrichmentService.getAvailable",  )(function* (workspaceRoot) {    const available = yield* peek(workspaceRoot);    yield* request(workspaceRoot);    return available;  });   const invalidate: ProjectEnrichmentService["Service"]["invalidate"] = Effect.fn(    "ProjectEnrichmentService.invalidate",  )(function* (workspaceRoots) {    yield* Effect.forEach(      new Set(workspaceRoots),      (workspaceRoot) =>        Effect.all(          [            Cache.invalidate(repositoryIdentityCache, workspaceRoot),            Cache.invalidate(faviconCache, workspaceRoot),          ],          { concurrency: "unbounded", discard: true },        ),      { discard: true },    );  });   return ProjectEnrichmentService.of({    peek,    request,    getAvailable,    invalidate,    subscribeChanges: PubSub.subscribe(changes),  });}); export const layer = Layer.effect(ProjectEnrichmentService, make());