@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/studio/src/pages/service-detail-state.ts

@@ -0,0 +1,234 @@
+import { fetchJson } from "../hooks/use-api";
+
+export interface ServiceDetailModelInfo {
+  readonly id: string;
+  readonly name?: string;
+}
+
+export interface ServiceDetailDetectedConfig {
+  readonly apiFormat?: "chat" | "responses";
+  readonly stream?: boolean;
+  readonly baseUrl?: string;
+  readonly modelsSource?: "api" | "fallback";
+}
+
+export type ServiceDetailConnectionStatus =
+  | { state: "idle" }
+  | { state: "testing" }
+  | { state: "connected"; models: ServiceDetailModelInfo[] }
+  | { state: "error"; message: string }
+  | { state: "saving" }
+  | { state: "saved" };
+
+type JsonFetcher = typeof fetchJson;
+
+export interface ServiceProbeResponse {
+  readonly ok: boolean;
+  readonly models?: ServiceDetailModelInfo[];
+  readonly selectedModel?: string;
+  readonly detected?: ServiceDetailDetectedConfig;
+  readonly error?: string;
+}
+
+export interface ServiceDetailVerifiedProbe {
+  readonly apiKey: string;
+  readonly baseUrl: string;
+  readonly apiFormat: "chat" | "responses";
+  readonly stream: boolean;
+  readonly models: ServiceDetailModelInfo[];
+  readonly selectedModel?: string;
+  readonly detected?: ServiceDetailDetectedConfig;
+}
+
+export async function probeServiceForDetail(
+  serviceId: string,
+  body: {
+    readonly apiKey: string;
+    readonly apiFormat: "chat" | "responses";
+    readonly stream: boolean;
+    readonly baseUrl?: string;
+  },
+  deps?: { readonly fetchJsonImpl?: JsonFetcher },
+): Promise<ServiceProbeResponse> {
+  const fetchJsonImpl = deps?.fetchJsonImpl ?? fetchJson;
+  return await fetchJsonImpl<ServiceProbeResponse>(
+    `/services/${encodeURIComponent(serviceId)}/test`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+}
+
+export async function rehydrateServiceConnectionStatus(args: {
+  readonly effectiveServiceId: string;
+  readonly shouldVerify: boolean;
+  readonly isCustom: boolean;
+  readonly baseUrl: string;
+  readonly apiFormat: "chat" | "responses";
+  readonly stream: boolean;
+  readonly fetchJsonImpl?: JsonFetcher;
+}): Promise<{
+  readonly apiKey: string;
+  readonly status: ServiceDetailConnectionStatus;
+  readonly detectedModel: string;
+  readonly detectedConfig: ServiceDetailDetectedConfig | null;
+}> {
+  const fetchJsonImpl = args.fetchJsonImpl ?? fetchJson;
+  const secret = await fetchJsonImpl<{ apiKey?: string }>(
+    `/services/${encodeURIComponent(args.effectiveServiceId)}/secret`,
+  );
+  const apiKey = String(secret.apiKey ?? "");
+
+  return {
+    apiKey,
+    status: { state: "idle" },
+    detectedModel: "",
+    detectedConfig: null,
+  };
+}
+
+export function matchServiceConfigEntryForDetail(
+  entries: ReadonlyArray<Record<string, unknown>>,
+  serviceId: string,
+): Record<string, unknown> | undefined {
+  return entries.find((entry) => {
+    if (typeof entry.service !== "string") return false;
+    if (serviceId.startsWith("custom:")) {
+      return entry.service === "custom" && `custom:${String(entry.name ?? "")}` === serviceId;
+    }
+    if (serviceId === "custom") return false;
+    return entry.service === serviceId;
+  });
+}
+
+export async function saveServiceConfig(args: {
+  readonly effectiveServiceId: string;
+  readonly serviceId: string;
+  readonly isCustom: boolean;
+  readonly resolvedCustomName: string;
+  readonly apiKey: string;
+  readonly baseUrl: string;
+  readonly apiFormat: "chat" | "responses";
+  readonly stream: boolean;
+  readonly temperature: string;
+  readonly detectedModel: string;
+  readonly verifiedProbe?: ServiceDetailVerifiedProbe | null;
+  readonly fetchJsonImpl?: JsonFetcher;
+}): Promise<{
+  readonly status: ServiceDetailConnectionStatus;
+  readonly detectedModel: string;
+  readonly detectedConfig: ServiceDetailDetectedConfig | null;
+}> {
+  const fetchJsonImpl = args.fetchJsonImpl ?? fetchJson;
+  const trimmedKey = args.apiKey.trim();
+  const trimmedBaseUrl = args.baseUrl.trim();
+
+  if (!trimmedKey && !args.isCustom) {
+    return {
+      status: { state: "error", message: "请先输入 API Key" },
+      detectedModel: "",
+      detectedConfig: null,
+    };
+  }
+  if (args.isCustom && !trimmedBaseUrl) {
+    return {
+      status: { state: "error", message: "请先填写 Base URL" },
+      detectedModel: "",
+      detectedConfig: null,
+    };
+  }
+
+  const verifiedBaseUrl = args.isCustom ? trimmedBaseUrl : "";
+  const verified = args.verifiedProbe;
+  const canReuseVerifiedProbe = Boolean(
+    verified
+      && verified.apiKey === trimmedKey
+      && verified.baseUrl === verifiedBaseUrl
+      && verified.apiFormat === args.apiFormat
+      && verified.stream === args.stream,
+  );
+
+  let probe: ServiceProbeResponse;
+  if (canReuseVerifiedProbe && verified) {
+    probe = {
+      ok: true,
+      models: verified.models,
+      selectedModel: verified.selectedModel,
+      detected: verified.detected,
+    };
+  } else {
+    try {
+      probe = await probeServiceForDetail(args.effectiveServiceId, {
+        apiKey: trimmedKey,
+        apiFormat: args.apiFormat,
+        stream: args.stream,
+        ...(args.isCustom ? { baseUrl: trimmedBaseUrl } : {}),
+      }, { fetchJsonImpl });
+    } catch (error) {
+      return {
+        status: { state: "error", message: error instanceof Error ? error.message : "连接失败" },
+        detectedModel: "",
+        detectedConfig: null,
+      };
+    }
+  }
+
+  if (!probe.ok) {
+    return {
+      status: { state: "error", message: probe.error ?? "连接失败" },
+      detectedModel: "",
+      detectedConfig: null,
+    };
+  }
+
+  const detectedModel = probe.selectedModel ?? args.detectedModel;
+  const detectedConfig = probe.detected ?? null;
+  const savedApiFormat = detectedConfig?.apiFormat ?? args.apiFormat;
+  const savedStream = typeof detectedConfig?.stream === "boolean" ? detectedConfig.stream : args.stream;
+  const savedBaseUrl = args.isCustom ? (detectedConfig?.baseUrl ?? trimmedBaseUrl) : undefined;
+
+  await fetchJsonImpl(`/services/${encodeURIComponent(args.effectiveServiceId)}/secret`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ apiKey: trimmedKey }),
+  });
+
+  await fetchJsonImpl("/services/config", {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      service: args.effectiveServiceId,
+      ...(detectedModel ? { defaultModel: detectedModel } : {}),
+      services: [
+        {
+          service: args.isCustom ? "custom" : args.serviceId,
+          temperature: parseFloat(args.temperature),
+          apiFormat: savedApiFormat,
+          stream: savedStream,
+          ...(args.isCustom ? {
+            name: args.resolvedCustomName,
+            baseUrl: savedBaseUrl,
+          } : {}),
+        },
+      ],
+    }),
+  });
+
+  return {
+    status: { state: "connected", models: probe.models ?? [] },
+    detectedModel,
+    detectedConfig,
+  };
+}
+
+export async function deleteServiceConfig(
+  serviceId: string,
+  deps?: { readonly fetchJsonImpl?: JsonFetcher },
+): Promise<void> {
+  const fetchJsonImpl = deps?.fetchJsonImpl ?? fetchJson;
+  await fetchJsonImpl(`/services/${encodeURIComponent(serviceId)}`, {
+    method: "DELETE",
+  });
+}

package/inkos/packages/studio/src/pages/style-manager-state.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { buildStyleStatusNotice } from "./StyleManager";
+
+describe("buildStyleStatusNotice", () => {
+  it("surfaces analyze errors even when no profile is available yet", () => {
+    expect(buildStyleStatusNotice("Error: analyze failed", "")).toEqual({
+      tone: "error",
+      message: "Error: analyze failed",
+    });
+  });
+
+  it("falls back to import status when there is no analyze error", () => {
+    expect(buildStyleStatusNotice("", "Style guide imported successfully!")).toEqual({
+      tone: "success",
+      message: "Style guide imported successfully!",
+    });
+  });
+
+  it("returns null when there is nothing to show", () => {
+    expect(buildStyleStatusNotice("", "")).toBeNull();
+  });
+});

package/inkos/packages/studio/src/pages/truth-files-state.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { deriveFilePresentation, SHIM_AUTHORITATIVE_PATH } from "./TruthFiles";
+
+describe("deriveFilePresentation", () => {
+  it("allows editing for non-legacy outline files", () => {
+    const result = deriveFilePresentation("outline/story_frame.md", {
+      content: "# frame",
+      legacy: false,
+    });
+    expect(result.legacy).toBe(false);
+    expect(result.canEdit).toBe(true);
+    expect(result.authoritativePath).toBeNull();
+  });
+
+  it("allows editing when legacy flag is absent", () => {
+    const result = deriveFilePresentation("outline/volume_map.md", {
+      content: "map",
+    });
+    expect(result.canEdit).toBe(true);
+    expect(result.legacy).toBe(false);
+  });
+
+  it("blocks editing and surfaces authoritative path when legacy: true", () => {
+    const result = deriveFilePresentation("book_rules.md", {
+      content: "# Legacy shim",
+      legacy: true,
+    });
+    expect(result.legacy).toBe(true);
+    expect(result.canEdit).toBe(false);
+    expect(result.authoritativePath).toBe("outline/story_frame.md");
+  });
+
+  it("blocks editing for story_bible.md shim and links to story_frame.md", () => {
+    const result = deriveFilePresentation("story_bible.md", {
+      content: "# bible shim",
+      legacy: true,
+    });
+    expect(result.legacy).toBe(true);
+    expect(result.canEdit).toBe(false);
+    expect(result.authoritativePath).toBe("outline/story_frame.md");
+  });
+
+  it("blocks editing when no file is selected", () => {
+    const result = deriveFilePresentation(null, undefined);
+    expect(result.canEdit).toBe(false);
+  });
+
+  it("blocks editing when file has no content (e.g. 404)", () => {
+    const result = deriveFilePresentation("outline/story_frame.md", {
+      content: null,
+    });
+    expect(result.canEdit).toBe(false);
+  });
+});
+
+describe("SHIM_AUTHORITATIVE_PATH", () => {
+  it("maps every shim file to its outline replacement", () => {
+    expect(SHIM_AUTHORITATIVE_PATH["story_bible.md"]).toBe("outline/story_frame.md");
+    expect(SHIM_AUTHORITATIVE_PATH["book_rules.md"]).toBe("outline/story_frame.md");
+  });
+});

package/inkos/packages/studio/src/shared/contracts.ts

@@ -0,0 +1,143 @@
+/**
+ * Shared TypeScript contracts for Studio API/UI communication.
+ * Ported from PR #96 (Te9ui1a) — prevents client/server type drift.
+ */
+
+// --- Health ---
+
+export interface HealthStatus {
+  readonly status: "ok";
+  readonly projectRoot: string;
+  readonly projectConfigFound: boolean;
+  readonly envFound: boolean;
+  readonly projectEnvFound: boolean;
+  readonly globalConfigFound: boolean;
+  readonly bookCount: number;
+  readonly provider: string | null;
+  readonly model: string | null;
+}
+
+// --- Books ---
+
+export interface BookSummary {
+  readonly id: string;
+  readonly title: string;
+  readonly status: string;
+  readonly platform: string;
+  readonly genre: string;
+  readonly targetChapters: number;
+  readonly chapters: number;
+  readonly chapterCount: number;
+  readonly lastChapterNumber: number;
+  readonly totalWords: number;
+  readonly approvedChapters: number;
+  readonly pendingReview: number;
+  readonly pendingReviewChapters: number;
+  readonly failedReview: number;
+  readonly failedChapters: number;
+  readonly recentRunStatus?: string | null;
+  readonly updatedAt: string;
+}
+
+export interface BookDetail extends BookSummary {
+  readonly createdAt: string;
+  readonly chapterWordCount: number;
+  readonly language: "zh" | "en" | null;
+}
+
+// --- Chapters ---
+
+export interface ChapterSummary {
+  readonly number: number;
+  readonly title: string;
+  readonly status: string;
+  readonly wordCount: number;
+  readonly auditIssueCount: number;
+  readonly updatedAt: string;
+  readonly fileName: string | null;
+}
+
+export interface ChapterDetail extends ChapterSummary {
+  readonly auditIssues: ReadonlyArray<string>;
+  readonly reviewNote?: string;
+  readonly content: string;
+}
+
+export interface SaveChapterPayload {
+  readonly content: string;
+}
+
+// --- Truth Files ---
+
+export interface TruthFileSummary {
+  readonly name: string;
+  readonly label: string;
+  readonly exists: boolean;
+  readonly path: string;
+  readonly optional: boolean;
+  readonly available: boolean;
+}
+
+export interface TruthFileDetail extends TruthFileSummary {
+  readonly content: string | null;
+}
+
+// --- Review ---
+
+export interface ReviewActionPayload {
+  readonly chapterNumber: number;
+  readonly reason?: string;
+}
+
+// --- Runs ---
+
+export type RunAction = "draft" | "audit" | "revise" | "write-next";
+
+export type RunStatus = "queued" | "running" | "succeeded" | "failed";
+
+export interface RunLogEntry {
+  readonly timestamp: string;
+  readonly level: "info" | "warn" | "error";
+  readonly message: string;
+}
+
+export interface RunActionPayload {
+  readonly chapterNumber?: number;
+}
+
+export interface StudioRun {
+  readonly id: string;
+  readonly bookId: string;
+  readonly chapter: number | null;
+  readonly chapterNumber: number | null;
+  readonly action: RunAction;
+  readonly status: RunStatus;
+  readonly stage: string;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly startedAt: string | null;
+  readonly finishedAt: string | null;
+  readonly logs: ReadonlyArray<RunLogEntry>;
+  readonly result?: unknown;
+  readonly error?: string;
+}
+
+export interface RunStreamEvent {
+  readonly type: "snapshot" | "status" | "stage" | "log";
+  readonly runId: string;
+  readonly run?: StudioRun;
+  readonly status?: RunStatus;
+  readonly stage?: string;
+  readonly log?: RunLogEntry;
+  readonly result?: unknown;
+  readonly error?: string;
+}
+
+// --- API Error Response ---
+
+export interface ApiErrorResponse {
+  readonly error: {
+    readonly code: string;
+    readonly message: string;
+  };
+}

package/inkos/packages/studio/src/store/chat/__tests__/message-parts.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect } from "vitest";
+import { buildPartsFromEvents, type StreamEvent } from "../parts-builder";
+
+describe("buildPartsFromEvents", () => {
+  it("produces thinking → text parts from basic conversation", () => {
+    const parts = buildPartsFromEvents([
+      { type: "thinking:start" },
+      { type: "thinking:delta", text: "Let me think..." },
+      { type: "thinking:end" },
+      { type: "draft:delta", text: "Here is " },
+      { type: "draft:delta", text: "the answer." },
+    ]);
+
+    expect(parts).toEqual([
+      { type: "thinking", content: "Let me think...", streaming: false },
+      { type: "text", content: "Here is the answer." },
+    ]);
+  });
+
+  it("interleaves text and tool calls chronologically", () => {
+    const parts = buildPartsFromEvents([
+      { type: "draft:delta", text: "Let me read the file..." },
+      { type: "tool:start", id: "t1", tool: "read" },
+      { type: "tool:end", id: "t1", result: "file content" },
+      { type: "draft:delta", text: "Here is the analysis." },
+    ]);
+
+    expect(parts).toHaveLength(3);
+    expect(parts[0]).toEqual({ type: "text", content: "Let me read the file..." });
+    expect(parts[1].type).toBe("tool");
+    if (parts[1].type === "tool") {
+      expect(parts[1].execution.tool).toBe("read");
+      expect(parts[1].execution.status).toBe("completed");
+    }
+    expect(parts[2]).toEqual({ type: "text", content: "Here is the analysis." });
+  });
+
+  it("moves pre-tool text to thinking when tool starts", () => {
+    const parts = buildPartsFromEvents([
+      { type: "thinking:start" },
+      { type: "thinking:delta", text: "Reasoning here" },
+      { type: "thinking:end" },
+      { type: "draft:delta", text: "I will call writer now" },
+      { type: "tool:start", id: "t1", tool: "sub_agent", agent: "writer", stages: ["准备章节输入", "撰写章节草稿"] },
+      { type: "log:stage", stageName: "准备章节输入" },
+      { type: "log:stage", stageName: "撰写章节草稿" },
+      { type: "tool:end", id: "t1" },
+      { type: "draft:delta", text: "Chapter written." },
+    ]);
+
+    // Pre-tool text "I will call writer now" should become thinking, not a text part
+    expect(parts[0].type).toBe("thinking");
+    if (parts[0].type === "thinking") {
+      expect(parts[0].content).toContain("Reasoning here");
+      expect(parts[0].content).toContain("I will call writer now");
+    }
+    expect(parts[1].type).toBe("tool");
+    if (parts[1].type === "tool") {
+      expect(parts[1].execution.agent).toBe("writer");
+      expect(parts[1].execution.stages).toHaveLength(2);
+      expect(parts[1].execution.stages![0].status).toBe("completed");
+      expect(parts[1].execution.stages![1].status).toBe("completed");
+    }
+    expect(parts[2]).toEqual({ type: "text", content: "Chapter written." });
+  });
+
+  it("handles multiple tool calls in sequence", () => {
+    const parts = buildPartsFromEvents([
+      { type: "tool:start", id: "t1", tool: "read" },
+      { type: "tool:end", id: "t1" },
+      { type: "tool:start", id: "t2", tool: "grep" },
+      { type: "tool:end", id: "t2" },
+      { type: "tool:start", id: "t3", tool: "sub_agent", agent: "writer", stages: ["准备章节输入"] },
+      { type: "tool:end", id: "t3" },
+      { type: "draft:delta", text: "Done." },
+    ]);
+
+    expect(parts).toHaveLength(4);
+    expect(parts[0].type).toBe("tool"); // read
+    expect(parts[1].type).toBe("tool"); // grep
+    expect(parts[2].type).toBe("tool"); // writer
+    expect(parts[3]).toEqual({ type: "text", content: "Done." });
+  });
+
+  it("tracks pipeline stages and progress on running tool", () => {
+    const parts = buildPartsFromEvents([
+      { type: "tool:start", id: "t1", tool: "sub_agent", agent: "writer", stages: ["步骤1", "步骤2"] },
+      { type: "log:stage", stageName: "步骤1" },
+      { type: "llm:progress", status: "thinking", elapsedMs: 5000, totalChars: 0, chineseChars: 0 },
+    ]);
+
+    expect(parts).toHaveLength(1);
+    expect(parts[0].type).toBe("tool");
+    if (parts[0].type === "tool") {
+      const exec = parts[0].execution;
+      expect(exec.status).toBe("running");
+      expect(exec.stages![0].status).toBe("active");
+      expect(exec.stages![0].progress?.status).toBe("thinking");
+      expect(exec.stages![1].status).toBe("pending");
+    }
+  });
+
+  it("handles multi-turn thinking (append, not overwrite)", () => {
+    const parts = buildPartsFromEvents([
+      { type: "thinking:start" },
+      { type: "thinking:delta", text: "First thought" },
+      { type: "thinking:end" },
+      { type: "tool:start", id: "t1", tool: "read" },
+      { type: "tool:end", id: "t1" },
+      { type: "thinking:start" },
+      { type: "thinking:delta", text: "Second thought" },
+      { type: "thinking:end" },
+      { type: "draft:delta", text: "Final answer" },
+    ]);
+
+    // Two thinking parts, tool in between, then text
+    const thinkingParts = parts.filter(p => p.type === "thinking");
+    expect(thinkingParts).toHaveLength(2);
+    expect(thinkingParts[0].type === "thinking" && thinkingParts[0].content).toBe("First thought");
+    expect(thinkingParts[1].type === "thinking" && thinkingParts[1].content).toBe("Second thought");
+    expect(parts.map(p => p.type)).toEqual(["thinking", "tool", "thinking", "text"]);
+  });
+
+  it("marks tool error correctly", () => {
+    const parts = buildPartsFromEvents([
+      { type: "tool:start", id: "t1", tool: "sub_agent", agent: "writer" },
+      { type: "tool:end", id: "t1", isError: true, result: "timeout" },
+    ]);
+
+    expect(parts[0].type).toBe("tool");
+    if (parts[0].type === "tool") {
+      expect(parts[0].execution.status).toBe("error");
+      expect(parts[0].execution.error).toBe("timeout");
+    }
+  });
+
+  it("preserves structured tool details for generated artifacts", () => {
+    const details = {
+      kind: "short_fiction_created",
+      storyId: "demo",
+      coverImagePath: "shorts/demo/final/cover.png",
+    };
+    const parts = buildPartsFromEvents([
+      { type: "tool:start", id: "t1", tool: "short_fiction_run" },
+      { type: "tool:end", id: "t1", result: "Short fiction completed.", details },
+    ]);
+
+    expect(parts[0].type).toBe("tool");
+    if (parts[0].type === "tool") {
+      expect(parts[0].execution.details).toEqual(details);
+    }
+  });
+
+  it("localizes known tool errors", () => {
+    const parts = buildPartsFromEvents([
+      { type: "tool:start", id: "t1", tool: "sub_agent", agent: "writer" },
+      {
+        type: "tool:end",
+        id: "t1",
+        isError: true,
+        result: "Latest chapter 1 is state-degraded. Repair state or rewrite that chapter before continuing.",
+      },
+    ]);
+
+    expect(parts[0].type).toBe("tool");
+    if (parts[0].type === "tool") {
+      expect(parts[0].execution.error).toBe(
+        "最新第 1 章处于状态降级（state-degraded）。继续写下一章前，请先修复状态，或重写这一章。",
+      );
+    }
+  });
+});

package/inkos/packages/studio/src/store/chat/index.ts

@@ -0,0 +1,3 @@
+export { useChatStore } from "./store";
+export { chatSelectors } from "./selectors";
+export type { ChatStore, Message, ToolCall, BookSummary } from "./types";

package/inkos/packages/studio/src/store/chat/initialState.ts

@@ -0,0 +1,8 @@
+import type { ChatState } from "./types";
+import { initialMessageState } from "./slices/message/initialState";
+import { initialCreateState } from "./slices/create/initialState";
+
+export const initialChatState: ChatState = {
+  ...initialMessageState,
+  ...initialCreateState,
+};

package/inkos/packages/studio/src/store/chat/message-policy.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { shouldRefreshSidebarForTool } from "./message-policy";
+
+describe("shouldRefreshSidebarForTool", () => {
+  it("does not refresh for read-only tools", () => {
+    expect(shouldRefreshSidebarForTool("read")).toBe(false);
+    expect(shouldRefreshSidebarForTool("grep")).toBe(false);
+    expect(shouldRefreshSidebarForTool("ls")).toBe(false);
+  });
+
+  it("refreshes for mutating and unknown tools", () => {
+    expect(shouldRefreshSidebarForTool("edit")).toBe(true);
+    expect(shouldRefreshSidebarForTool("sub_agent")).toBe(true);
+    expect(shouldRefreshSidebarForTool("some_future_tool")).toBe(true);
+  });
+});

package/inkos/packages/studio/src/store/chat/message-policy.ts

@@ -0,0 +1,5 @@
+const READ_ONLY_TOOLS = new Set(["read", "grep", "ls"]);
+
+export function shouldRefreshSidebarForTool(toolName: string): boolean {
+  return !READ_ONLY_TOOLS.has(toolName);
+}