@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/core-server/index.d.ts

@@ -0,0 +1,2200 @@
+import { B as ServerServiceRegistration, G as ServiceInstanceOf, H as ServiceDescriptor, K as ServiceRegistrationOptions, M as QueryCtx, N as QueryDefinition, O as OperationDescriptor, P as QueryFunctions, R as RuntimeService, U as ServiceId, V as ServiceDefinition, W as ServiceInstance, Y as ServiceSummary, b as CommandDefinition, j as Query, o as ToolsetGetService, v as Command, y as CommandCtx, z as SchemaDescriptor } from "../chunk-BCoJQE-f.js";
+import { Co as StoryDocsProviderPreset, Cs as ImportParser, Ds as FileChangeEvent, Ec as Tag, Es as ChangeDetectionAdapter, Fc as TestProviderStoreEvent, Nc as TestProviderStateByProviderId, Os as ModuleResolveConfig, Pc as TestProviderStoreById, So as StoryDocsProviderInput, Ss as ImportEdge, St as StatusTypeId, Tc as defineService, Ts as ParseFileArgs, Uc as UniversalStore, Vc as MockUniversalStore, Yo as Options$1, _c as DocsAccess, _t as Status$1, bo as StoryDocsPayload, bt as StatusStoreByTypeId$1, dc as PreviewStoriesOutput, fc as StoryIndexAccess, gc as SourceWithUrl, hc as createDocsToolset, jc as TestProviderId, lc as registerToolset, lo as ModuleGraphServiceState, mc as reviewToolset, pc as createStoriesToolset, pt as StorybookError, vc as ResolvedDocsEntry, ws as ImportParserContext, wt as StatusesByStoryIdAndTypeId$1, xt as StatusStoreEvent, yc as emptyManifests, yt as StatusStore } from "../chunk-C2p5r3Vt.js";
+import { n as registerService, t as getService$1 } from "../chunk-CwQKNaYL.js";
+import { ArgTypes, SBType } from "@aussieljk/forkbook/internal/csf";
+import { Channel, ChannelLike } from "@aussieljk/forkbook/internal/channels";
+import { Builder, BuilderOptions, CLIOptions, DocsAnchor, DocsIndexEntry, DocsOptions, IndexEntry, IndexInputStats, Indexer, LoadOptions, Manifests, NormalizedStoriesSpecifier, Options, Path, Presets, Status, StatusStoreByTypeId, StatusValue, StoryIndex, StoryIndexEntry, StorybookConfigRaw } from "@aussieljk/forkbook/internal/types";
+import * as v from "valibot";
+import { getPreviewBodyTemplate, getPreviewHeadTemplate, loadAllPresets } from "@aussieljk/forkbook/internal/common";
+import { EventType } from "@aussieljk/forkbook/internal/telemetry";
+import { watch } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { WebSocketServer } from "ws";
+import { IncomingMessage } from "node:http";
+
+//#region .dts-emit/code/core/src/core-server/build-static.d.ts
+type BuildStaticStandaloneOptions = CLIOptions & LoadOptions & BuilderOptions & {
+  outputDir: string;
+};
+declare function buildStaticStandalone(options: BuildStaticStandaloneOptions): Promise<void>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/build-dev.d.ts
+declare function buildDevStandalone(options: CLIOptions & LoadOptions & BuilderOptions & {
+  storybookVersion?: string;
+}): Promise<{
+  port: number;
+  address: string;
+  networkAddress: string;
+}>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/build-index.d.ts
+type BuildIndexOptions = CLIOptions & LoadOptions & BuilderOptions;
+declare const buildIndex: (options: BuildIndexOptions) => Promise<import("@aussieljk/forkbook/internal/types").StoryIndex>;
+declare const buildIndexStandalone: (options: BuildIndexOptions & {
+  outputFile: string;
+}) => Promise<void>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/withTelemetry.d.ts
+type TelemetryOptions = {
+  cliOptions: CLIOptions;
+  presetOptions?: Parameters<typeof loadAllPresets>[0];
+  printError?: (err: any) => void;
+  skipPrompt?: boolean;
+  eventType?: EventType;
+  fallbackTelemetryState?: boolean;
+};
+type ErrorLevel = 'none' | 'error' | 'full';
+declare function getErrorLevel({
+  cliOptions,
+  presetOptions,
+  skipPrompt,
+  eventType
+}: TelemetryOptions): Promise<ErrorLevel>;
+declare function sendTelemetryError(_error: unknown, eventType: EventType, options: TelemetryOptions, blocking?: boolean, parent?: StorybookError): Promise<void>;
+declare function withTelemetry<T>(eventType: EventType, options: TelemetryOptions, run: () => Promise<T>): Promise<T | undefined>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/standalone.d.ts
+declare function build$1(options?: any, frameworkOptions?: any): Promise<void | {
+  port: number;
+  address: string;
+  networkAddress: string;
+}>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/server-statics.d.ts
+declare const mapStaticDir: (staticDir: NonNullable<StorybookConfigRaw['staticDirs']>[number], configDir: string) => {
+  staticDir: string;
+  staticPath: string;
+  targetDir: string;
+  targetEndpoint: string;
+};
+//#endregion
+//#region ../../node_modules/tsconfig-paths/lib/filesystem.d.ts
+/**
+ * A function that json from a file
+ */
+interface ReadJsonSync {
+  (packageJsonPath: string): any | undefined;
+}
+//#endregion
+//#region ../../node_modules/tsconfig-paths/lib/match-path-sync.d.ts
+/**
+ * Function that can match a path
+ */
+interface MatchPath {
+  (requestedModule: string, readJson?: ReadJsonSync, fileExists?: (name: string) => boolean, extensions?: ReadonlyArray<string>): string | undefined;
+}
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/IndexingError.d.ts
+declare class IndexingError extends Error {
+  importPaths: string[];
+  constructor(message: string, importPaths: string[], stack?: string);
+  pathsString(): string;
+  toString(): string;
+}
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/summarizeStats.d.ts
+type IndexStatsSummary = Record<keyof IndexInputStats, number>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/StoryIndexGenerator.d.ts
+type StoryIndexEntryWithExtra = StoryIndexEntry & {
+  extra: {
+    metaId?: string;
+    stats: IndexInputStats;
+  };
+};
+/** A .mdx file will produce a docs entry */
+type DocsCacheEntry = DocsIndexEntry;
+/** A `_.stories._` file will produce a list of stories and possibly a docs entry */
+type StoriesCacheEntry = {
+  entries: (StoryIndexEntryWithExtra | DocsIndexEntry)[];
+  dependents: Path[];
+  type: 'stories';
+};
+type ErrorEntry = {
+  type: 'error';
+  err: IndexingError;
+};
+type CacheEntry = false | StoriesCacheEntry | DocsCacheEntry | ErrorEntry;
+type SpecifierStoriesCache = Record<Path, CacheEntry>;
+type StoryIndexGeneratorOptions = {
+  workingDir: Path;
+  configDir: Path;
+  indexers: Indexer[];
+  docs: DocsOptions;
+  build?: StorybookConfigRaw['build'];
+  features?: StorybookConfigRaw['features'];
+  storySorts?: StorybookConfigRaw['storySorts'];
+};
+/**
+ * The StoryIndexGenerator extracts stories and docs entries for each file matching (one or more)
+ * stories "specifiers", as defined in main.js.
+ *
+ * The output is a set of entries (see above for the types).
+ *
+ * Each file is treated as a stories or a (modern) docs file.
+ *
+ * A stories file is indexed by an indexer (passed in), which produces a list of stories.
+ *
+ * - If the stories have the `parameters.docsOnly` setting, they are disregarded.
+ * - If the stories have `autodocs` enabled, a docs entry is added pointing to the story file.
+ *
+ * A (modern) docs (.mdx) file is indexed, a docs entry is added.
+ *
+ * In the preview, a docs entry with the `autodocs` tag will be rendered as a CSF file that exports
+ * an MDX template on the `docs.page` parameter, whereas other docs entries are rendered as MDX
+ * files directly.
+ *
+ * The entries are "uniq"-ed and sorted. Stories entries are preferred to docs entries and MDX docs
+ * entries are preferred to CSF templates (with warnings).
+ */
+declare class StoryIndexGenerator {
+  readonly specifiers: NormalizedStoriesSpecifier[];
+  readonly options: StoryIndexGeneratorOptions;
+  private specifierToCache;
+  /** Cache for findMatchingFiles results */
+  private static findMatchingFilesCache;
+  private lastIndex?;
+  private lastStats?;
+  private lastError?;
+  private invalidationListeners;
+  constructor(specifiers: NormalizedStoriesSpecifier[], options: StoryIndexGeneratorOptions);
+  /** Generate a cache key for findMatchingFiles */
+  private static getFindMatchingFilesCacheKey;
+  /** Clear the findMatchingFiles cache */
+  static clearFindMatchingFilesCache(): void;
+  static findMatchingFiles(specifier: NormalizedStoriesSpecifier, workingDir: Path, ignoreWarnings?: boolean): Promise<SpecifierStoriesCache>;
+  static findMatchingFilesForSpecifiers(specifiers: NormalizedStoriesSpecifier[], workingDir: Path, ignoreWarnings?: boolean): Promise<Array<readonly [NormalizedStoriesSpecifier, SpecifierStoriesCache]>>;
+  initialize(): Promise<void>;
+  /** Run the updater function over all the empty cache entries */
+  updateExtracted(updater: (specifier: NormalizedStoriesSpecifier, absolutePath: Path, existingEntry: CacheEntry) => Promise<CacheEntry>, overwrite?: boolean): Promise<void>;
+  isDocsMdx(absolutePath: Path): boolean;
+  ensureExtracted({
+    projectTags
+  }: {
+    projectTags?: Tag[];
+  }): Promise<{
+    entries: (IndexEntry | ErrorEntry)[];
+    stats: IndexStatsSummary;
+  }>;
+  findDependencies(absoluteImports: Path[]): StoriesCacheEntry[];
+  /**
+   * Try to find the component path from a raw import string and return it in the same format as
+   * `importPath`. Respect tsconfig paths if available.
+   *
+   * If no such file exists, assume that the import is from a package and return the raw
+   */
+  resolveComponentPath(rawComponentPath: Path, absolutePath: Path, matchPath: MatchPath | undefined): string;
+  extractStories(specifier: NormalizedStoriesSpecifier, absolutePath: Path, projectTags?: Tag[]): Promise<StoriesCacheEntry | DocsCacheEntry>;
+  extractDocs(specifier: NormalizedStoriesSpecifier, absolutePath: Path, projectTags?: Tag[]): Promise<false | DocsIndexEntry>;
+  chooseDuplicate(firstEntry: IndexEntry, secondEntry: IndexEntry, projectTags: Tag[]): IndexEntry;
+  sortStories(entries: StoryIndex['entries'], storySortParameter: any): Promise<Record<string, IndexEntry>>;
+  getIndex(): Promise<StoryIndex>;
+  getIndexAndStats(): Promise<{
+    storyIndex: StoryIndex;
+    stats: IndexStatsSummary;
+  }>;
+  invalidateAll(): void;
+  invalidate(importPath: Path, removed: boolean): void;
+  onInvalidated(listener: () => void): () => void;
+  getPreviewCode(): Promise<string | undefined>;
+  getProjectTags(previewCode?: string): string[];
+  static storyFileNames(specifierToCache: Map<NormalizedStoriesSpecifier, SpecifierStoriesCache>): string[];
+}
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/get-stories-paths-from-config.d.ts
+/**
+ * Resolves story file paths from a main config's `stories` field without evaluating story files.
+ *
+ * @example
+ *
+ * ```typescript
+ * const storiesPaths = await getStoriesPathsFromConfig({
+ *   stories: ['src\/**\/*.stories.tsx'],
+ *   configDir: '/path/to/.forkbook',
+ *   workingDir: '/path/to/project',
+ * });
+ * ```
+ */
+declare const getStoriesPathsFromConfig: ({
+  stories,
+  configDir,
+  workingDir
+}: {
+  stories: StorybookConfigRaw['stories'];
+  configDir: string;
+  workingDir: string;
+}) => Promise<string[]>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/get-dummy-args-from-argtypes.d.ts
+type ComponentArgTypesInfo = {
+  required: boolean;
+  type: SBType;
+};
+type ComponentArgTypesData = {
+  props?: Record<string, ComponentArgTypesInfo>;
+};
+//#endregion
+//#region .dts-emit/code/core/src/core-server/load.d.ts
+declare function loadStorybook(options: CLIOptions & LoadOptions & BuilderOptions & {
+  storybookVersion?: string;
+  previewConfigPath?: string;
+  /**
+   * The channel handed to every preset. Callers that prepared state on a channel of their own
+   * (the `forkbook tools` CLI prepares the UniversalStore singleton on one) must pass it here,
+   * so addon hooks that answer requests over `options.channel` share the caller's bus.
+   */
+  channel?: Channel;
+}): Promise<Options>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/analyze-mdx.d.ts
+type MdxAnalysisResult = {
+  title: string | undefined;
+  of: string | undefined;
+  name: string | undefined;
+  id: string | undefined;
+  summary: string | undefined;
+  isTemplate: boolean;
+  metaTags?: string[];
+  imports: string[];
+  anchors?: DocsAnchor[];
+};
+declare const analyzeMdx: (code: string) => Promise<MdxAnalysisResult>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/manifests/mdx-manifest.d.ts
+/**
+ * Canonical contract for the MDX docs open service.
+ *
+ * The service implementation lives in `@aussieljk/forkbook/addon-docs`, but the data contract (service id,
+ * on-disk/`$ref` layout, payload shapes, and the consumer query handle) lives here in core so the
+ * addon that produces it and the core manifest writer that consumes it share one source of truth.
+ * Mirrors the docgen service contract under `shared/open-service/services/docgen/`.
+ */
+/** A JSON Reference (`{ $ref }`) pointing at a value in another manifest document. */
+type JsonRef = {
+  $ref: string;
+};
+/** Open-service id for the MDX docs service (also the on-disk directory under `services/`). */
+declare const MDX_SERVICE_ID = "addon-docs/mdx";
+/** Free-form error captured while reading or analyzing an MDX doc. */
+interface MdxError {
+  name: string;
+  message: string;
+}
+/**
+ * One MDX doc, both as stored in the service and as resolved from a manifest `$ref`.
+ *
+ * `summary` shares `content`'s optionality: it is derived from the doc when available (an explicit
+ * `Meta` summary, falling back to text extracted from the content) and omitted otherwise.
+ */
+interface MdxDocPayload {
+  id: string;
+  name: string;
+  path: string;
+  title: string;
+  content?: string;
+  summary?: string;
+  error?: MdxError;
+  mdx?: never;
+}
+/** Per-component MDX payload: every doc grouped under a single component (or standalone) id. */
+interface MdxPayload {
+  id: string;
+  name: string;
+  docs: Record<string, MdxDocPayload>;
+}
+/** Shallow docs index row: id, name, optional summary, and a `$ref` to the full MDX payload. */
+interface DocsManifestRefEntry {
+  id: string;
+  name: string;
+  summary?: string;
+  mdx: JsonRef;
+  path?: never;
+  title?: never;
+  content?: never;
+  error?: never;
+}
+/** A docs manifest entry is either an inline payload or a shallow `$ref` row. */
+type DocsManifestEntry = MdxDocPayload | DocsManifestRefEntry;
+/** Minimal consumer handle for reading every MDX payload from the live service (dev). */
+interface MdxServiceContract {
+  queries: {
+    mdxForAllComponents: {
+      loaded: () => Promise<Record<string, MdxPayload>>;
+    };
+  };
+}
+/** Relative path segment for one component's static snapshot file (`<id>.json`). */
+declare function mdxQueryStaticPath(id: string): string;
+/** Logical static-store key: `addon-docs/mdx/<id>.json`. */
+declare function mdxStaticStorePath(id: string): string;
+/** `$ref` target for one doc, relative to the `manifests/` directory. */
+declare function mdxManifestRef(componentId: string, docId: string): string;
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/service-registry.d.ts
+/** Returns one summary entry per registered service — the lowest-cost discovery endpoint. */
+declare function listServices(): Promise<ServiceSummary[]>;
+/** Returns the schema-backed descriptor for one registered service. */
+declare function describeService(serviceId: ServiceId): Promise<ServiceDescriptor>;
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/services/story-docs/provider.d.ts
+interface WorkerGatedStoryDocsProviderOptions {
+  /** Name shown in the debug log when a story file cannot be read, such as `Vue`. */
+  label: string;
+  /** Absolute path of the docgen worker module that must be registered for this provider to run. */
+  docgenWorker: string;
+  /** Story files this provider reads. Defaults to CSF story files. */
+  storyFileTest?: RegExp;
+  /** Reads one story file; `undefined` hands the story to the next provider. */
+  build: (input: StoryDocsProviderInput) => Promise<StoryDocsPayload | undefined>;
+}
+/**
+ * Create an `experimental_storyDocsProvider` preset that only runs when the renderer's docgen worker
+ * is registered, and merges its payload over the next provider's.
+ *
+ * A story file the provider cannot read falls back to the next provider and is logged at debug level.
+ */
+declare function createWorkerGatedStoryDocsProvider({
+  label,
+  docgenWorker,
+  storyFileTest,
+  build
+}: WorkerGatedStoryDocsProviderOptions): StoryDocsProviderPreset;
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/toolsets/stories/story-input.d.ts
+/**
+ * Shared story selector used by the stories and test APIs.
+ *
+ * Prefer `{ storyId }` unless the caller already has a concrete story-file path and export name.
+ */
+declare const storyInputSchema: v.UnionSchema<[v.ObjectSchema<{
+  readonly props: v.SchemaWithPipe<readonly [v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>, v.DescriptionAction<{
+    [x: string]: any;
+  } | undefined, "Optional custom props to pass to the story for rendering. Use this when you don't want to render the default story,\nbut you want to customize some args or other props.\nYou can look up the component's documentation using the get-storybook-story-instructions tool to see what props are available.">]>;
+  readonly globals: v.SchemaWithPipe<readonly [v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>, v.DescriptionAction<{
+    [x: string]: any;
+  } | undefined, "Optional Forkbook globals to set for the story preview. Globals are used for things like theme, locale, viewport, and other cross-cutting concerns.\nCommon globals include 'theme' (e.g., 'dark', 'light'), 'locale' (e.g., 'en', 'fr'), and 'backgrounds' (e.g., { value: '#000' }).">]>;
+  readonly exportName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "The export name of the story from the story file.\nUse this path-based shape only when you're already editing a .stories.* file and know the export names in that file.\nIf you do not already have story file context, prefer the storyId shape instead of searching files.">]>;
+  readonly explicitStoryName: v.SchemaWithPipe<readonly [v.OptionalSchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string | undefined, "If the story has an explicit name set via the \"name\" property, that is different from the export name, provide it here.\nOtherwise don't set this.">]>;
+  readonly absoluteStoryPath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Absolute path to the story file. Use together with exportName only when story file context is already available.">]>;
+}, undefined>, v.ObjectSchema<{
+  readonly props: v.SchemaWithPipe<readonly [v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>, v.DescriptionAction<{
+    [x: string]: any;
+  } | undefined, "Optional custom props to pass to the story for rendering. Use this when you don't want to render the default story,\nbut you want to customize some args or other props.\nYou can look up the component's documentation using the get-storybook-story-instructions tool to see what props are available.">]>;
+  readonly globals: v.SchemaWithPipe<readonly [v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>, v.DescriptionAction<{
+    [x: string]: any;
+  } | undefined, "Optional Forkbook globals to set for the story preview. Globals are used for things like theme, locale, viewport, and other cross-cutting concerns.\nCommon globals include 'theme' (e.g., 'dark', 'light'), 'locale' (e.g., 'en', 'fr'), and 'backgrounds' (e.g., { value: '#000' }).">]>;
+  readonly storyId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, `The full Forkbook story ID (for example "button--primary").
+Prefer this shape whenever you are not already working in a specific story file.
+Use IDs discovered from ${string} (withStoryIds=true) or ${string}.`>]>;
+}, undefined>], undefined>;
+declare const storyInputArraySchema: v.ArraySchema<v.UnionSchema<[v.ObjectSchema<{
+  readonly props: v.SchemaWithPipe<readonly [v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>, v.DescriptionAction<{
+    [x: string]: any;
+  } | undefined, "Optional custom props to pass to the story for rendering. Use this when you don't want to render the default story,\nbut you want to customize some args or other props.\nYou can look up the component's documentation using the get-storybook-story-instructions tool to see what props are available.">]>;
+  readonly globals: v.SchemaWithPipe<readonly [v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>, v.DescriptionAction<{
+    [x: string]: any;
+  } | undefined, "Optional Forkbook globals to set for the story preview. Globals are used for things like theme, locale, viewport, and other cross-cutting concerns.\nCommon globals include 'theme' (e.g., 'dark', 'light'), 'locale' (e.g., 'en', 'fr'), and 'backgrounds' (e.g., { value: '#000' }).">]>;
+  readonly exportName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "The export name of the story from the story file.\nUse this path-based shape only when you're already editing a .stories.* file and know the export names in that file.\nIf you do not already have story file context, prefer the storyId shape instead of searching files.">]>;
+  readonly explicitStoryName: v.SchemaWithPipe<readonly [v.OptionalSchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string | undefined, "If the story has an explicit name set via the \"name\" property, that is different from the export name, provide it here.\nOtherwise don't set this.">]>;
+  readonly absoluteStoryPath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Absolute path to the story file. Use together with exportName only when story file context is already available.">]>;
+}, undefined>, v.ObjectSchema<{
+  readonly props: v.SchemaWithPipe<readonly [v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>, v.DescriptionAction<{
+    [x: string]: any;
+  } | undefined, "Optional custom props to pass to the story for rendering. Use this when you don't want to render the default story,\nbut you want to customize some args or other props.\nYou can look up the component's documentation using the get-storybook-story-instructions tool to see what props are available.">]>;
+  readonly globals: v.SchemaWithPipe<readonly [v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>, v.DescriptionAction<{
+    [x: string]: any;
+  } | undefined, "Optional Forkbook globals to set for the story preview. Globals are used for things like theme, locale, viewport, and other cross-cutting concerns.\nCommon globals include 'theme' (e.g., 'dark', 'light'), 'locale' (e.g., 'en', 'fr'), and 'backgrounds' (e.g., { value: '#000' }).">]>;
+  readonly storyId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, `The full Forkbook story ID (for example "button--primary").
+Prefer this shape whenever you are not already working in a specific story file.
+Use IDs discovered from ${string} (withStoryIds=true) or ${string}.`>]>;
+}, undefined>], undefined>, undefined>;
+type StoryInput = v.InferOutput<typeof storyInputSchema>;
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/toolsets/stories/find-story-ids.d.ts
+interface FoundStory {
+  /** The matched index entry — carrying it proves the id exists in the index. */
+  entry: IndexEntry;
+  input: StoryInput;
+}
+interface NotFoundStory {
+  input: StoryInput;
+  errorMessage: string;
+}
+type FindStoryIdsResult = FoundStory | NotFoundStory;
+/**
+ * Finds story IDs in the story index that match the given story inputs.
+ *
+ * Returns per-input lookup results in the same order as `stories`.
+ */
+declare function findStoryIds(index: StoryIndex, stories: StoryInput[]): FindStoryIdsResult[];
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/toolsets/docs/access-service.d.ts
+type ServiceDocsAccessOptions = {
+  storyIndex: {
+    getIndex: () => Promise<StoryIndex>;
+  };
+  getService: ToolsetGetService;
+};
+declare function createServiceDocsAccess({
+  storyIndex,
+  getService
+}: ServiceDocsAccessOptions): DocsAccess;
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/toolsets/docs/access-manifest.d.ts
+/** The manifests as they leave core's manifest builder, before any shape is assumed. */
+type RawManifests = {
+  components?: unknown;
+  docs?: unknown;
+};
+type ManifestDocsAccessOptions = {
+  getManifests: () => Promise<RawManifests>;
+};
+declare function createManifestDocsAccess({
+  getManifests
+}: ManifestDocsAccessOptions): DocsAccess;
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/toolsets/docs/access-local.d.ts
+type LocalDocsAccessOptions = {
+  storyIndex: {
+    getIndex: () => Promise<StoryIndex>;
+  }; /** Reads the live inline manifests, e.g. core-server's `loadManifests`. */
+  getManifests: () => Promise<RawManifests>;
+};
+declare function createLocalDocsAccess({
+  storyIndex,
+  getManifests
+}: LocalDocsAccessOptions): DocsAccess;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/manifests/manifests.d.ts
+/**
+ * Loads the live manifests, the same way the dev-server manifest routes do.
+ *
+ * Exposed for the docs toolset, which reads manifest data in-process instead of fetching its own
+ * server over loopback HTTP.
+ */
+declare function loadManifests(presets: Presets): Promise<Manifests>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/get-refs-from-config.d.ts
+/**
+ * Reads the composed Storybooks from the project's `refs` as docs sources, in config order.
+ *
+ * Only the configured `refs` count, not auto-refs from package dependencies; a function-form
+ * `refs` receives an empty object instead of them. Disabled refs and refs without a string `url`
+ * are dropped, and so is a ref keyed `local`, the id reserved for this Forkbook's own source. Ids
+ * and titles are normalised the way the manager does for the sidebar, so a source id matches the
+ * ref id in Forkbook URLs. No network access.
+ *
+ * A `refs` config that throws yields no sources and a warning, because this also runs for tools
+ * that load the config without the manager, such as the Vitest plugin and the tools CLI.
+ */
+declare function getRefsFromConfig(options: Options): Promise<SourceWithUrl[]>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/stores/status.d.ts
+declare function createServerStatusStore(leader: boolean): {
+  getStatusStoreByTypeId: (typeId: StatusTypeId) => StatusStoreByTypeId$1;
+  fullStatusStore: StatusStore & {
+    selectStatuses: (statuses: Status$1[]) => void;
+    typeId: undefined;
+  };
+  universalStatusStore: UniversalStore<StatusesByStoryIdAndTypeId$1, StatusStoreEvent>;
+};
+type StatusStoreBundle = ReturnType<typeof createServerStatusStore>;
+declare const getStatusStoreByTypeId: StatusStoreBundle['getStatusStoreByTypeId'];
+declare const fullStatusStore: StatusStoreBundle['fullStatusStore'];
+declare const universalStatusStore: StatusStoreBundle['universalStatusStore'];
+//#endregion
+//#region .dts-emit/code/core/src/core-server/change-detection/errors.d.ts
+declare class ChangeDetectionUnavailableError extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+declare class ChangeDetectionFailureError extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region .dts-emit/code/core/src/core-server/change-detection/readiness.d.ts
+type ChangeDetectionReadiness = {
+  status: 'ready';
+} | {
+  status: 'unavailable';
+  reason: string;
+  error?: Error;
+} | {
+  status: 'error';
+  error: Error;
+};
+type ChangeDetectionHost = () => void | Promise<void>;
+/**
+ * Install a one-shot starter the first {@link getChangeDetectionReadiness} call runs. The CLI uses
+ * this so git/status scanning does not start at bootstrap; the dev server starts the service itself
+ * and never installs a host.
+ */
+declare function setChangeDetectionHost(next?: ChangeDetectionHost): void;
+declare function getChangeDetectionReadiness(): Promise<ChangeDetectionReadiness>;
+declare function resetChangeDetectionReadiness(): void;
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/services/module-graph/definition.d.ts
+declare const moduleGraphServiceDef: ServiceDefinition<ModuleGraphServiceState, {
+  readonly status: QueryDefinition<ModuleGraphServiceState, v.UndefinedSchema<undefined>, v.VariantSchema<"value", [v.ObjectSchema<{
+    readonly value: v.LiteralSchema<"booting", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly value: v.LiteralSchema<"ready", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly value: v.LiteralSchema<"error", undefined>;
+    readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+  }, undefined>, v.ObjectSchema<{
+    readonly value: v.LiteralSchema<"unavailable", undefined>;
+    readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+    readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+  }, undefined>], undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"status\" has internal: true but must be prefixed with \"_\"";
+  } | {
+    internal?: false;
+  });
+  readonly changeDetectionReadiness: QueryDefinition<ModuleGraphServiceState, v.UndefinedSchema<undefined>, v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"pending", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"ready", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"unavailable", undefined>;
+    readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+    readonly error: v.OptionalSchema<v.ObjectSchema<{
+      readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+    }, undefined>, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"error", undefined>;
+    readonly error: v.ObjectSchema<{
+      readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+    }, undefined>;
+  }, undefined>], undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"changeDetectionReadiness\" has internal: true but must be prefixed with \"_\"";
+  } | {
+    internal?: false;
+  });
+  readonly graphRevision: QueryDefinition<ModuleGraphServiceState, v.OptionalSchema<v.ObjectSchema<{
+    readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+  }, undefined>, undefined>, v.NumberSchema<undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"graphRevision\" has internal: true but must be prefixed with \"_\"";
+  } | {
+    internal?: false;
+  });
+  readonly graphChangedAt: QueryDefinition<ModuleGraphServiceState, v.UndefinedSchema<undefined>, v.NumberSchema<undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"graphChangedAt\" has internal: true but must be prefixed with \"_\"";
+  } | {
+    internal?: false;
+  });
+  readonly fileActivityRevision: QueryDefinition<ModuleGraphServiceState, v.UndefinedSchema<undefined>, v.NumberSchema<undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"fileActivityRevision\" has internal: true but must be prefixed with \"_\"";
+  } | {
+    internal?: false;
+  });
+  readonly latestStoryChanges: QueryDefinition<ModuleGraphServiceState, v.UndefinedSchema<undefined>, v.ObjectSchema<{
+    readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+    readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+  }, undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"latestStoryChanges\" has internal: true but must be prefixed with \"_\"";
+  } | {
+    internal?: false;
+  });
+} & {
+  readonly status: {
+    output: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+  };
+  readonly changeDetectionReadiness: {
+    output: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  };
+  readonly graphRevision: {
+    output: v.NumberSchema<undefined>;
+  };
+  readonly graphChangedAt: {
+    output: v.NumberSchema<undefined>;
+  };
+  readonly fileActivityRevision: {
+    output: v.NumberSchema<undefined>;
+  };
+  readonly latestStoryChanges: {
+    output: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  };
+}, {
+  readonly _applyGraphSnapshot: CommandDefinition<ModuleGraphServiceState, v.ObjectSchema<{
+    readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+      [x: string]: {
+        [x: string]: number;
+      };
+    }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+  }, undefined>, v.VoidSchema<undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"_applyGraphSnapshot\" is prefixed with \"_\" and must set internal: true";
+  } | {
+    internal: true;
+  });
+  readonly _applyGraphUpdate: CommandDefinition<ModuleGraphServiceState, v.ObjectSchema<{
+    readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+    readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+  }, undefined>, v.VoidSchema<undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"_applyGraphUpdate\" is prefixed with \"_\" and must set internal: true";
+  } | {
+    internal: true;
+  });
+  readonly _setStatus: CommandDefinition<ModuleGraphServiceState, v.VariantSchema<"value", [v.ObjectSchema<{
+    readonly value: v.LiteralSchema<"booting", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly value: v.LiteralSchema<"ready", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly value: v.LiteralSchema<"error", undefined>;
+    readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+  }, undefined>, v.ObjectSchema<{
+    readonly value: v.LiteralSchema<"unavailable", undefined>;
+    readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+    readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+  }, undefined>], undefined>, v.VoidSchema<undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"_setStatus\" is prefixed with \"_\" and must set internal: true";
+  } | {
+    internal: true;
+  });
+  readonly _waitForSettledEngine: CommandDefinition<ModuleGraphServiceState, v.UndefinedSchema<undefined>, v.VoidSchema<undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"_waitForSettledEngine\" is prefixed with \"_\" and must set internal: true";
+  } | {
+    internal: true;
+  });
+  readonly _waitForChangeDetectionReadiness: CommandDefinition<ModuleGraphServiceState, v.UndefinedSchema<undefined>, v.VariantSchema<"status", [v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"pending", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"ready", undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"unavailable", undefined>;
+    readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+    readonly error: v.OptionalSchema<v.ObjectSchema<{
+      readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+    }, undefined>, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly status: v.LiteralSchema<"error", undefined>;
+    readonly error: v.ObjectSchema<{
+      readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+    }, undefined>;
+  }, undefined>], undefined>, {
+    readonly _applyGraphSnapshot: v.ObjectSchema<{
+      readonly storiesByFile: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Breadth-first-search depth: the shortest number of import edges between the source file and this story file.">]>, undefined>, undefined>, v.DescriptionAction<{
+        [x: string]: {
+          [x: string]: number;
+        };
+      }, "Complete relative reverse index keyed by story-index-style source file paths. Values map affected story-index-style story file paths to breadth-first-search depths.">]>;
+    }, undefined>;
+    readonly _applyGraphUpdate: v.ObjectSchema<{
+      readonly bumpedStoryFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story files whose graph changed, using story-index-style relative paths. Each listed file has its version incremented.">]>;
+      readonly changedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "When (unix ms) the change was made. Defaults to now when unknown.">]>, undefined>;
+    }, undefined>;
+    readonly _setStatus: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly _waitForSettledEngine: v.UndefinedSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.UndefinedSchema<undefined>;
+  }, {
+    readonly _applyGraphSnapshot: v.VoidSchema<undefined>;
+    readonly _applyGraphUpdate: v.VoidSchema<undefined>;
+    readonly _setStatus: v.VoidSchema<undefined>;
+    readonly _waitForSettledEngine: v.VoidSchema<undefined>;
+    readonly _waitForChangeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  }, QueryFunctions<{
+    readonly status: v.UndefinedSchema<undefined>;
+    readonly changeDetectionReadiness: v.UndefinedSchema<undefined>;
+    readonly graphRevision: v.OptionalSchema<v.ObjectSchema<{
+      readonly storyFiles: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Story file to scope the watch to. Accepts absolute paths, story-index-style relative paths with `./`, or relative paths without `./`. Pass an empty array to watch nothing (returns 0).">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly graphChangedAt: v.UndefinedSchema<undefined>;
+    readonly fileActivityRevision: v.UndefinedSchema<undefined>;
+    readonly latestStoryChanges: v.UndefinedSchema<undefined>;
+  }, {
+    readonly status: v.VariantSchema<"value", [v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"booting", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"error", undefined>;
+      readonly error: v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Serializable error describing why the module graph failed unexpectedly.">]>;
+    }, undefined>, v.ObjectSchema<{
+      readonly value: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable reason why the current builder/runtime cannot provide module graph functionality.">]>;
+      readonly error: v.OptionalSchema<v.SchemaWithPipe<readonly [v.GenericSchema, v.DescriptionAction<unknown, "Optional serializable error reported by the builder adapter.">]>, undefined>;
+    }, undefined>], undefined>;
+    readonly changeDetectionReadiness: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly graphRevision: v.NumberSchema<undefined>;
+    readonly graphChangedAt: v.NumberSchema<undefined>;
+    readonly fileActivityRevision: v.NumberSchema<undefined>;
+    readonly latestStoryChanges: v.ObjectSchema<{
+      readonly revision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Graph revision number for this latest story change set.">]>;
+      readonly storyFiles: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "A story-index-style relative path such as `./src/Button.stories.tsx`.">]>, undefined>, v.DescriptionAction<string[], "Story-index-relative story files touched by the latest module graph change set.">]>;
+    }, undefined>;
+  }>> & ({
+    __internal_naming_error: "Operation \"_waitForChangeDetectionReadiness\" is prefixed with \"_\" and must set internal: true";
+  } | {
+    internal: true;
+  });
+} & {
+  readonly _applyGraphSnapshot: {
+    output: v.VoidSchema<undefined>;
+  };
+  readonly _applyGraphUpdate: {
+    output: v.VoidSchema<undefined>;
+  };
+  readonly _setStatus: {
+    output: v.VoidSchema<undefined>;
+  };
+  readonly _waitForSettledEngine: {
+    output: v.VoidSchema<undefined>;
+  };
+  readonly _waitForChangeDetectionReadiness: {
+    output: v.VariantSchema<"status", [v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"pending", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"ready", undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"unavailable", undefined>;
+      readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why change detection cannot publish statuses, such as no git.">]>;
+      readonly error: v.OptionalSchema<v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Optional diagnostic from the provider that marked scanning unavailable.">]>;
+      }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly status: v.LiteralSchema<"error", undefined>;
+      readonly error: v.ObjectSchema<{
+        readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Human-readable scan failure message.">]>;
+      }, undefined>;
+    }, undefined>], undefined>;
+  };
+}, "core/module-graph">;
+type ModuleGraphService = ServiceInstanceOf<typeof moduleGraphServiceDef>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/change-detection/GitDiffProvider.d.ts
+interface GitDiffResult {
+  changed: Set<string>;
+  new: Set<string>;
+}
+type GitStateChangeCallback = () => void;
+type GitFileSystem = {
+  watch: typeof watch;
+  readFile: typeof readFile;
+  stat: typeof stat;
+};
+declare class GitDiffProvider {
+  private readonly cwd;
+  private readonly fileSystem;
+  private repoRoot;
+  private gitStateCallback;
+  private branchWatcher;
+  private headWatcher;
+  private packedRefsWatcher;
+  private watchingInitialized;
+  private watchingStopped;
+  constructor(cwd?: string, fileSystem?: GitFileSystem);
+  getRepoRoot(): Promise<string>;
+  getChangedFiles(): Promise<GitDiffResult>;
+  getHeadCommit(): Promise<string>;
+  isWorkingTreeClean(): Promise<boolean>;
+  onGitStateChange(callback: GitStateChangeCallback): void;
+  private initializeWatching;
+  private attachWatcher;
+  private configureBranchWatcher;
+  private reconfigureBranchWatcher;
+  dispose(): void;
+  private stopWatching;
+  private getGitDir;
+  private readHeadRef;
+  private runGitCommand;
+  private isEnoentError;
+  private toGitError;
+}
+//#endregion
+//#region .dts-emit/code/core/src/core-server/change-detection/IndexBaselineService.d.ts
+type BaselineCache = {
+  get: <T = unknown>(key: string) => Promise<T | undefined>;
+  set: <T = unknown>(key: string, value: T) => Promise<void>;
+};
+declare class IndexBaselineService {
+  private readonly options;
+  private baselineEntryIds;
+  private initializePromise;
+  private syncInFlight;
+  private cache;
+  constructor(options: {
+    storyIndexGeneratorPromise: Promise<StoryIndexGenerator>;
+    gitDiffProvider: GitDiffProvider;
+    onBaselineUpdated: () => void;
+    cache?: BaselineCache;
+  });
+  start(): Promise<void>;
+  getBaselineEntryIds(): Promise<Set<string>>;
+  handleGitStateChange(): Promise<void>;
+  private initialize;
+  private refreshBaseline;
+}
+//#endregion
+//#region .dts-emit/code/core/src/core-server/change-detection/change-detection-service.d.ts
+/**
+ * Publishes change-detection story statuses to the status store. It resolves git-changed files,
+ * maps them to affected stories through the `core/module-graph` open service, and emits
+ * `modified`/`affected`/`new` statuses (plus index-baseline `new` entries).
+ */
+declare class ChangeDetectionService {
+  private readonly options;
+  private disposed;
+  private debounceTimer;
+  private scanInFlight;
+  private rerunAfterCurrentScan;
+  private readinessResolved;
+  private statusPipelineStarted;
+  private previousStatuses;
+  private gitDiffProvider;
+  private indexBaselineService;
+  private unsubscribeModuleGraphStatus;
+  private unsubscribeFileActivity;
+  private readonly workingDir;
+  private readonly debounceMs;
+  constructor(options: {
+    storyIndexGeneratorPromise: Promise<StoryIndexGenerator>;
+    statusStore: StatusStoreByTypeId;
+    gitDiffProvider?: GitDiffProvider;
+    indexBaselineService?: IndexBaselineService;
+    workingDir?: string;
+    debounceMs?: number;
+  });
+  private getModuleGraph;
+  private getModuleGraphIndex;
+  private onGraphReady;
+  private onGraphChange;
+  private onGraphError;
+  private onGraphUnavailable;
+  private onModuleGraphStatus;
+  start(): void;
+  /**
+   * Wires the git-diff-driven status pipeline. Runs once the dependency graph is ready (so the
+   * initial scan and every git-state-change scan read a populated reverse index).
+   */
+  private startStatusPipeline;
+  dispose(): Promise<void>;
+  private scheduleScan;
+  private scan;
+  private buildStatuses;
+  private getGitDiffProvider;
+  private getIndexBaselineService;
+  private applyStatusStorePatch;
+  private resolveReadiness;
+}
+//#endregion
+//#region .dts-emit/code/core/src/shared/open-service/services/module-graph/server.d.ts
+declare function resolveChangeDetectionAdapter(adapter: ChangeDetectionAdapter | null | undefined): void;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/get-builders.d.ts
+declare function getBuilders({
+  presets
+}: Options): Promise<Builder<unknown>[]>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/getHostValidationMiddleware.d.ts
+type HostValidationOptions = {
+  host?: string;
+  allowedHosts?: string[] | true;
+  localAddress?: string;
+  networkAddress?: string;
+};
+/**
+ * Validates a host (Host header–shaped string, e.g. "localhost:6006") against known local/network
+ * addresses and allowed hosts. Callers must pass host-shaped input; normalize from an origin URL
+ * (e.g. new URL(origin).host) before invoking if needed.
+ *
+ * `localhost`, its subdomains and `127.0.0.1` are always allowed. Any other IP address is
+ * allowed only when it is an address of this machine, the `--host` value, or listed in
+ * `allowedHosts`. Hostnames must be listed in `allowedHosts`, unless they are the `--host` value.
+ *
+ * @param host - The host to validate (hostname or "hostname:port").
+ * @param options - The builder options.
+ * @returns `true` if the host is valid, `false` otherwise.
+ */
+declare const isValidHost: (host: string | undefined, options: HostValidationOptions) => boolean;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/get-server-channel.d.ts
+/**
+ * Prepare the UniversalStore singleton for a server realm without a dev server (the `storybook
+ * tools` CLI). Leader stores only become ready — and accept writes — once prepared, which the dev
+ * server does above with its live channel; a headless realm has no followers to synchronize, so a
+ * transport-less channel is correct. The channel is returned so the caller can hand the same bus
+ * to configuration loading: stores only hear events on the channel they were prepared with, and
+ * addon responders (addon-vitest's test runner among them) relay child-process store events onto
+ * the channel their preset hooks received. Lives here (not in the CLI) so the preparation call
+ * stays next to the class it configures instead of reaching through an internal static from
+ * another entry, which the published type declarations strip.
+ */
+declare function prepareHeadlessUniversalStores(): Channel;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/apply-services-preset-once.d.ts
+declare global {
+  var FORKBOOK_SERVICES_PRESET_PROMISE: Promise<void> | undefined;
+}
+/**
+ * Applies the 'services' preset, but only once, as the services must not be registered multiple times.
+ *
+ * This is to ensure that we don't apply the preset multiple times in dev mode, which can lead to issues with the telemetry service and other services that are meant to be singletons.
+ */
+/** Clears the one-shot so a later configuration load can apply the `services` preset again. */
+declare function resetServicesPresetOnce(): void;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/stores/test-provider.d.ts
+declare function createServerTestProviderStore(leader: boolean): {
+  getTestProviderStoreById: (testProviderId: TestProviderId) => TestProviderStoreById;
+  fullTestProviderStore: {
+    settingsChanged: () => void;
+    onRunAll: (listener: () => void) => () => void;
+    onClearAll: (listener: () => void) => () => void;
+  } & {
+    getFullState: UniversalStore<TestProviderStateByProviderId, TestProviderStoreEvent>['getState'];
+    setFullState: UniversalStore<TestProviderStateByProviderId, TestProviderStoreEvent>['setState'];
+    onSettingsChanged: (listener: (testProviderId: TestProviderId) => void) => () => void;
+    runAll: () => void;
+    clearAll: () => void;
+  };
+  universalTestProviderStore: UniversalStore<TestProviderStateByProviderId, TestProviderStoreEvent>;
+};
+type TestProviderStoreBundle = ReturnType<typeof createServerTestProviderStore>;
+declare const getTestProviderStoreById: TestProviderStoreBundle['getTestProviderStoreById'];
+declare const fullTestProviderStore: TestProviderStoreBundle['fullTestProviderStore'];
+declare const universalTestProviderStore: TestProviderStoreBundle['universalTestProviderStore'];
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/ghost-stories/get-candidates.d.ts
+declare function getComponentCandidates({
+  sampleSize,
+  globPattern,
+  cwd
+}?: {
+  sampleSize?: number;
+  globPattern?: string; /** Working directory for glob. Defaults to process.cwd(). */
+  cwd?: string;
+}): Promise<{
+  candidates: string[];
+  error?: string;
+  globMatchCount: number;
+  analyzedCount?: number;
+  avgComplexity?: number;
+}>;
+//#endregion
+//#region .dts-emit/code/core/src/shared/utils/test-result-types.d.ts
+interface StoryTestResult {
+  storyId: string;
+  status: 'PASS' | 'FAIL' | 'PENDING';
+  error?: string;
+  stack?: string;
+  /** Whether the story rendered to an empty/invisible DOM element */
+  emptyRender?: boolean;
+}
+/**
+ * A `StoryTestResult` augmented with the timestamp at which it was recorded.
+ * Used by the agent self-healing flow to persist the most recent outcome
+ * per story across runs (in cache only — never sent in telemetry).
+ */
+interface StoryTestResultHistoryEntry extends StoryTestResult {
+  timestamp: number;
+}
+type StoryTestResultHistory = Record<string, StoryTestResultHistoryEntry>;
+interface CategorizedError {
+  category: string;
+  count: number;
+  uniqueCount: number;
+  matchedDependencies: string[];
+}
+/**
+ * Outcome of the `CssCheck` story — a story (id suffix `--css-check`)
+ * whose `play` asserts a component-specific computed style via
+ * `getComputedStyle`. Distinguishes "component mounted" from "the
+ * user's CSS actually loaded".
+ *
+ * - `'pass'`    — a `CssCheck` story ran and passed.
+ * - `'fail'`    — a `CssCheck` story ran and failed.
+ * - `'not-run'` — no pass/fail signal available: either no `CssCheck`
+ *                 story is in the suite, or the story existed but was
+ *                 not executed (skipped, pending, todo, filtered out).
+ *
+ * Only the three-valued enum is emitted — no storyId or component
+ * name — so no user-authored data enters telemetry.
+ */
+type CssCheckOutcome = 'pass' | 'fail' | 'not-run';
+interface TestRunAnalysis {
+  /** Stats for the current run (only stories executed in this run). */
+  total: number;
+  passed: number;
+  passedButEmptyRender: number;
+  successRate: number;
+  successRateWithoutEmptyRender: number;
+  uniqueErrorCount: number;
+  categorizedErrors: Record<string, CategorizedError>;
+  cssCheck: CssCheckOutcome;
+  /**
+   * Stats accumulated across runs: for every story we've ever seen, we
+   * keep the most recent outcome (by timestamp). Only emitted by the
+   * agent self-healing flow, which is the only consumer that persists
+   * a per-story history in the Forkbook cache.
+   */
+  cumulativeTotal?: number;
+  cumulativePassed?: number;
+  cumulativePassedButEmptyRender?: number;
+  cumulativeSuccessRate?: number;
+  cumulativeSuccessRateWithoutEmptyRender?: number;
+  cumulativeUniqueErrorCount?: number;
+  cumulativeCategorizedErrors?: Record<string, CategorizedError>;
+  cumulativeCssCheck?: CssCheckOutcome;
+}
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/ghost-stories/types.d.ts
+interface TestRunSummary {
+  duration?: number;
+  summary?: TestRunAnalysis;
+  runError?: string;
+}
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/ghost-stories/run-story-tests.d.ts
+/**
+ * Run ghost stories: execute vitest on component file paths to auto-generate
+ * and test stories that don't exist on disk.
+ *
+ * @param componentFilePaths - Absolute paths to component files to test.
+ * @param options.cwd - Working directory for vitest. Defaults to process.cwd().
+ */
+declare function runStoryTests(componentFilePaths: string[], options?: {
+  cwd?: string;
+  ghostRun?: boolean;
+}): Promise<TestRunSummary>;
+//#endregion
+//#region .dts-emit/code/core/src/core-server/utils/server-address.d.ts
+interface PortOptions {
+  exactPort?: boolean;
+}
+declare const getServerPort: (port?: number, {
+  exactPort
+}?: PortOptions) => Promise<number>;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/availability.d.ts
+interface ToolAvailability {
+  /** The `core/module-graph` open service is registered/resolvable. Gates `stories-find-by-component`. */
+  moduleGraphSupported: boolean;
+  /** Component-manifest feature is on AND manifests were found. Gates the `docs` toolset. */
+  docsEnabled: boolean;
+  /**
+   * Docs gate for the `forkbook tools` CLI channel, which reads manifests in-process and so only
+   * needs manifests to be producible — not the `componentsManifest` opt-in that gates MCP.
+   */
+  docsEnabledForCli: boolean;
+  /** Any component manifests were found (drives the docs "why disabled" copy). */
+  docsHasManifests: boolean;
+  /** The component-manifest feature flag is enabled (drives the docs "why disabled" copy). */
+  docsFeatureEnabled: boolean;
+  /**
+   * `@aussieljk/forkbook/addon-vitest` is enabled (not merely installed), matching the condition under
+   * which it registers the `test` toolset. Gates the `test` toolset (`test-run`).
+   */
+  testSupported: boolean;
+  /** `@aussieljk/forkbook/addon-a11y` is enabled. Gates the accessibility sub-feature of `test-run`. */
+  a11yEnabled: boolean;
+  /** `docgenServer` mode: read manifest data in-process from the open services. */
+  docgenServer: boolean;
+}
+/**
+ * Composed Storybooks with component manifests can back docs tools even when the
+ * local Forkbook has no component manifest. Use this before feeding
+ * availability into the shared tool registry.
+ */
+declare function getEffectiveToolAvailability(availability: ToolAvailability, {
+  multiSource
+}?: {
+  multiSource?: boolean;
+}): ToolAvailability;
+/**
+ * True iff the `core/module-graph` open service is registered in this process — reflects
+ * registration rather than mere runtime presence so tool gating/badging can't drift from the
+ * service the dev server actually resolves (a builder may ship change detection but not
+ * register the service, e.g. without change detection wired up).
+ */
+declare function isModuleGraphSupported(): Promise<boolean>;
+/**
+ * Single source of truth for the runtime gates that decide whether each tool is
+ * registered (and how the landing page badges it).
+ *
+ * Every dynamic gate lives here — the dependency graph, the component manifest
+ * (docs), addon-vitest (test) and the accessibility sub-feature — so the MCP
+ * server (which registers the tools) and the browser landing page (which shows
+ * enabled/disabled badges) can never drift apart. Add new gates here rather
+ * than computing them ad-hoc at a call site.
+ */
+declare function getToolAvailability(options: Options$1): Promise<ToolAvailability>;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/addon-a11y.d.ts
+/**
+ * Check if @aussieljk/forkbook/addon-a11y is enabled in the Forkbook configuration.
+ */
+declare function isAddonA11yEnabled(options: Options$1): Promise<boolean>;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/addon-vitest.d.ts
+/**
+ * Whether `@aussieljk/forkbook/addon-vitest` is enabled in this project.
+ *
+ * Reads the `isAddonVitestEnabled` marker that addon's preset exports, so this is true exactly
+ * when its presets loaded — the same condition under which its `services` hook registers the
+ * `test` toolset. Installed-but-not-enabled (a hoisted monorepo dependency, or an addon removed
+ * from `main.ts` without uninstalling) must read false: the toolset never registers there, so
+ * offering the tool would make every test call fail.
+ */
+declare function isAddonVitestEnabled(options: Options$1): Promise<boolean>;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/inputs.d.ts
+type SkillInputs = ToolAvailability & {
+  framework: string;
+  renderer?: string; /** The preview file imports `definePreview`, the entry point of CSF Factories. */
+  csfFactories: boolean; /** Path of the preview file relative to the working directory; a default name when there is none. */
+  previewFile: string; /** The preview file, or `main` when there is none, is TypeScript. */
+  typescript: boolean;
+};
+/**
+ * The one probing path for skill-content assembly: everything the pure builders need, resolved
+ * from the target Forkbook's presets. Both the skills CLI and addon-mcp fill builder inputs from
+ * this, so the two channels cannot drift.
+ */
+declare function resolveSkillInputs(options: Options$1): Promise<SkillInputs>;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/manifest-status.d.ts
+type ManifestFeatures = {
+  componentsManifest?: boolean;
+  experimentalComponentsManifest?: boolean;
+  docgenServer?: boolean;
+};
+type ManifestStatus = {
+  available: boolean;
+  hasManifests: boolean;
+  hasFeatureFlag: boolean;
+  /**
+   * `docgenServer` mode: the split/ref manifest format served from the
+   * open services. In dev, `/manifests/*.json` is 404'd by core, so the addon reads
+   * manifest data in-process instead of fetching it.
+   */
+  docgenServer: boolean;
+};
+declare const getManifestStatus: (options: Options$1) => Promise<ManifestStatus>;
+//#endregion
+//#region .dts-emit/code/core/src/shared/utils/analyze-test-results.d.ts
+/**
+ * Analyze a list of story test results and produce a TestRunAnalysis with pass/fail counts, success
+ * rates, empty render detection, and categorized errors.
+ *
+ * @param results Story results from the current run.
+ * @param cumulativeResults Optional aggregated results across runs (latest outcome per story).
+ *   Only the agent self-healing flow tracks history and passes this; when omitted no
+ *   `cumulative*` fields are emitted.
+ */
+declare function analyzeTestResults(results: StoryTestResult[], cumulativeResults?: StoryTestResult[]): TestRunAnalysis;
+//#endregion
+//#region .dts-emit/code/core/src/shared/utils/to-story-test-result.d.ts
+interface VitestLikeReport {
+  type: string;
+  result?: {
+    emptyRender?: boolean;
+  } | unknown;
+}
+interface VitestLikeError {
+  message?: string;
+  stack?: string;
+}
+interface VitestLikeInput {
+  storyId: string | undefined;
+  /** Raw vitest status, e.g. 'passed' | 'failed' | 'skipped' | 'pending' | 'running' | ... */
+  statusRaw: string | undefined;
+  errors?: readonly VitestLikeError[];
+  reports?: readonly VitestLikeReport[];
+}
+/**
+ * Convert a Vitest-like input (either a JSON reporter assertion or a runtime TestCase) into a
+ * StoryTestResult. Returns null when the input has no storyId — callers can use this to skip
+ * non-story tests.
+ */
+declare function toStoryTestResult(input: VitestLikeInput): StoryTestResult | null;
+//#endregion
+export { BuildIndexOptions, BuildStaticStandaloneOptions, type ChangeDetectionAdapter, ChangeDetectionFailureError, ChangeDetectionService, ChangeDetectionUnavailableError, type Command, type CommandCtx, type CommandDefinition, type ComponentArgTypesData, type DocsAccess, type DocsManifestEntry, type DocsManifestRefEntry, type ChangeDetectionReadiness as Experimental_ChangeDetectionReadiness, type FileChangeEvent, type FoundStory, type HostValidationOptions, type ImportEdge, type ImportParser, type ImportParserContext, type JsonRef, MDX_SERVICE_ID, type ManifestFeatures, type ManifestStatus, type MdxDocPayload, type MdxError, type MdxPayload, type MdxServiceContract, type ModuleGraphService, type ModuleResolveConfig, type NotFoundStory, type OperationDescriptor, type ParseFileArgs, type PreviewStoriesOutput, type Query, type QueryCtx, type QueryDefinition, type ResolvedDocsEntry, type RuntimeService, type SchemaDescriptor, type ServerServiceRegistration, type ServiceDefinition, type ServiceDescriptor, type ServiceInstance, type ServiceRegistrationOptions, type ServiceSummary, type SkillInputs, type StoryIndexAccess, StoryIndexGenerator, type StoryInput, type StoryTestResult, type StoryTestResultHistory, type StoryTestResultHistoryEntry, Tag, type ToolAvailability, type WorkerGatedStoryDocsProviderOptions, analyzeMdx, analyzeTestResults, build$1 as build, buildDevStandalone, buildIndex, buildIndexStandalone, buildStaticStandalone, createDocsToolset, createLocalDocsAccess, createManifestDocsAccess, createServiceDocsAccess, createStoriesToolset, createWorkerGatedStoryDocsProvider, describeService, emptyManifests, MockUniversalStore as experimental_MockUniversalStore, defineService as experimental_defineService, getChangeDetectionReadiness as experimental_getChangeDetectionReadiness, getStatusStoreByTypeId as experimental_getStatusStore, getTestProviderStoreById as experimental_getTestProviderStore, loadStorybook as experimental_loadStorybook, registerService as experimental_registerService, resetChangeDetectionReadiness as experimental_resetChangeDetectionReadiness, resetServicesPresetOnce as experimental_resetServicesPresetOnce, setChangeDetectionHost as experimental_setChangeDetectionHost, findStoryIds, getBuilders, getComponentCandidates, getEffectiveToolAvailability, getErrorLevel, getManifestStatus, getPreviewBodyTemplate, getPreviewHeadTemplate, getRefsFromConfig, getServerPort, getService$1 as getService, getStoriesPathsFromConfig, getToolAvailability, UniversalStore as internal_UniversalStore, fullStatusStore as internal_fullStatusStore, fullTestProviderStore as internal_fullTestProviderStore, universalStatusStore as internal_universalStatusStore, universalTestProviderStore as internal_universalTestProviderStore, isAddonA11yEnabled, isAddonVitestEnabled, isModuleGraphSupported, isValidHost, listServices, loadManifests, mapStaticDir, mdxManifestRef, mdxQueryStaticPath, mdxStaticStorePath, type moduleGraphServiceDef, prepareHeadlessUniversalStores, registerToolset, resolveChangeDetectionAdapter, resolveSkillInputs, reviewToolset, runStoryTests, sendTelemetryError, storyInputArraySchema, toStoryTestResult, withTelemetry };