@sanity/cli-build 0.1.1 → 0.2.1

package/dist/_exports/_internal/build.d.ts

@@ -0,0 +1,2418 @@
+import { CliConfig } from "@sanity/cli-core";
+import { ConfigEnv } from "vite";
+import { Debugger } from "debug";
+import { DefinedTelemetryTrace } from "@sanity/telemetry";
+import { FSWatcher } from "chokidar";
+import { InlineConfig } from "vite";
+import { NodePath } from "@babel/core";
+import { NodePath as NodePath_2 } from "@babel/traverse";
+import { Output } from "@sanity/cli-core";
+import { Plugin as Plugin_2 } from "vite";
+import { Scope } from "@babel/traverse";
+import * as t from "@babel/types";
+import { UserViteConfig } from "@sanity/cli-core";
+import { z } from "zod";
+
+declare type AliasingEffect =
+  | {
+      kind: "Freeze";
+      value: Place;
+      reason: ValueReason;
+    }
+  | {
+      kind: "Mutate";
+      value: Place;
+      reason?: MutationReason | null;
+    }
+  | {
+      kind: "MutateConditionally";
+      value: Place;
+    }
+  | {
+      kind: "MutateTransitive";
+      value: Place;
+    }
+  | {
+      kind: "MutateTransitiveConditionally";
+      value: Place;
+    }
+  | {
+      kind: "Capture";
+      from: Place;
+      into: Place;
+    }
+  | {
+      kind: "Alias";
+      from: Place;
+      into: Place;
+    }
+  | {
+      kind: "MaybeAlias";
+      from: Place;
+      into: Place;
+    }
+  | {
+      kind: "Assign";
+      from: Place;
+      into: Place;
+    }
+  | {
+      kind: "Create";
+      into: Place;
+      value: ValueKind;
+      reason: ValueReason;
+    }
+  | {
+      kind: "CreateFrom";
+      from: Place;
+      into: Place;
+    }
+  | {
+      kind: "ImmutableCapture";
+      from: Place;
+      into: Place;
+    }
+  | {
+      kind: "Apply";
+      receiver: Place;
+      function: Place;
+      mutatesFunction: boolean;
+      args: Array<Place | SpreadPattern | Hole>;
+      into: Place;
+      signature: FunctionSignature | null;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "CreateFunction";
+      captures: Array<Place>;
+      function: FunctionExpression | ObjectMethod;
+      into: Place;
+    }
+  | {
+      kind: "MutateFrozen";
+      place: Place;
+      error: CompilerDiagnostic;
+    }
+  | {
+      kind: "MutateGlobal";
+      place: Place;
+      error: CompilerDiagnostic;
+    }
+  | {
+      kind: "Impure";
+      place: Place;
+      error: CompilerDiagnostic;
+    }
+  | {
+      kind: "Render";
+      place: Place;
+    };
+
+declare type AliasingSignature = {
+  receiver: IdentifierId;
+  params: Array<IdentifierId>;
+  rest: IdentifierId | null;
+  returns: IdentifierId;
+  effects: Array<AliasingEffect>;
+  temporaries: Array<Place>;
+};
+
+export declare const AppBuildTrace: DefinedTelemetryTrace<
+  {
+    outputSize: number;
+  },
+  void
+>;
+
+declare type ArrayExpression = {
+  kind: "ArrayExpression";
+  elements: Array<Place | SpreadPattern | Hole>;
+  loc: SourceLocation;
+};
+
+declare type ArrayPattern = {
+  kind: "ArrayPattern";
+  items: Array<Place | SpreadPattern | Hole>;
+};
+
+declare type AutoDepsDecorationsEvent = {
+  kind: "AutoDepsDecorations";
+  fnLoc: t.SourceLocation;
+  decorations: Array<t.SourceLocation>;
+};
+
+declare type AutoDepsEligibleEvent = {
+  kind: "AutoDepsEligible";
+  fnLoc: t.SourceLocation;
+  depArrayLoc: t.SourceLocation;
+};
+
+declare type BabelFn =
+  | NodePath<t.FunctionDeclaration>
+  | NodePath<t.FunctionExpression>
+  | NodePath<t.ArrowFunctionExpression>;
+
+declare type BasicBlock = {
+  kind: BlockKind;
+  id: BlockId;
+  instructions: Array<Instruction>;
+  terminal: Terminal;
+  preds: Set<BlockId>;
+  phis: Set<Phi>;
+};
+
+declare type BlockId = number & {
+  [opaqueBlockId]: "BlockId";
+};
+
+declare type BlockKind = "block" | "value" | "loop" | "sequence" | "catch";
+
+declare type BranchTerminal = {
+  kind: "branch";
+  test: Place;
+  consequent: BlockId;
+  alternate: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+  fallthrough: BlockId;
+};
+
+export declare const buildDebug: Debugger;
+
+/**
+ * Builds the ESM browser compatible versions of the vendor packages
+ * specified in VENDOR_IMPORTS. Returns the `imports` object of an import map.
+ */
+export declare function buildVendorDependencies({
+  basePath,
+  cwd,
+  isApp,
+  outputDir,
+}: VendorBuildOptions): Promise<Record<string, string>>;
+
+declare type BuiltinTag = {
+  kind: "BuiltinTag";
+  name: string;
+  loc: SourceLocation;
+};
+
+declare type BuiltInType = PrimitiveType | FunctionType | ObjectType;
+
+declare type CallExpression = {
+  kind: "CallExpression";
+  callee: Place;
+  args: Array<Place | SpreadPattern>;
+  loc: SourceLocation;
+  typeArguments?: Array<t.FlowType>;
+};
+
+declare type Case = {
+  test: Place | null;
+  block: BlockId;
+};
+
+export declare function checkStudioDependencyVersions(
+  workDir: string,
+  output: Output,
+  {
+    packages,
+  }?: {
+    packages?: TrackedPackage[];
+  },
+): Promise<void>;
+
+declare type CodegenFunction = {
+  type: "CodegenFunction";
+  id: t.Identifier | null;
+  nameHint: string | null;
+  params: t.FunctionDeclaration["params"];
+  body: t.BlockStatement;
+  generator: boolean;
+  async: boolean;
+  loc: SourceLocation;
+  memoSlotsUsed: number;
+  memoBlocks: number;
+  memoValues: number;
+  prunedMemoBlocks: number;
+  prunedMemoValues: number;
+  outlined: Array<{
+    fn: CodegenFunction;
+    type: ReactFunctionType | null;
+  }>;
+  hasInferredEffect: boolean;
+  inferredEffectLocations: Set<SourceLocation>;
+  hasFireRewrite: boolean;
+};
+
+declare type CompilationMode = z.infer<typeof CompilationModeSchema>;
+
+declare const CompilationModeSchema: z.ZodEnum<{
+  syntax: "syntax";
+  infer: "infer";
+  annotation: "annotation";
+  all: "all";
+}>;
+
+declare type CompileDiagnosticEvent = {
+  kind: "CompileDiagnostic";
+  fnLoc: t.SourceLocation | null;
+  detail: Omit<Omit<CompilerErrorDetailOptions, "severity">, "suggestions">;
+};
+
+declare type CompileErrorEvent = {
+  kind: "CompileError";
+  fnLoc: t.SourceLocation | null;
+  detail: CompilerErrorDetail | CompilerDiagnostic;
+};
+
+declare class CompilerDiagnostic {
+  options: CompilerDiagnosticOptions;
+  constructor(options: CompilerDiagnosticOptions);
+  static create(
+    options: Omit<CompilerDiagnosticOptions, "details">,
+  ): CompilerDiagnostic;
+  get reason(): CompilerDiagnosticOptions["reason"];
+  get description(): CompilerDiagnosticOptions["description"];
+  get severity(): ErrorSeverity;
+  get suggestions(): CompilerDiagnosticOptions["suggestions"];
+  get category(): ErrorCategory;
+  withDetails(...details: Array<CompilerDiagnosticDetail>): CompilerDiagnostic;
+  primaryLocation(): SourceLocation | null;
+  printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
+  toString(): string;
+}
+
+declare type CompilerDiagnosticDetail =
+  | {
+      kind: "error";
+      loc: SourceLocation | null;
+      message: string | null;
+    }
+  | {
+      kind: "hint";
+      message: string;
+    };
+
+declare type CompilerDiagnosticOptions = {
+  category: ErrorCategory;
+  reason: string;
+  description: string | null;
+  details: Array<CompilerDiagnosticDetail>;
+  suggestions?: Array<CompilerSuggestion> | null | undefined;
+};
+
+declare class CompilerError extends Error {
+  details: Array<CompilerErrorDetail | CompilerDiagnostic>;
+  disabledDetails: Array<CompilerErrorDetail | CompilerDiagnostic>;
+  printedMessage: string | null;
+  static invariant(
+    condition: unknown,
+    options: Omit<CompilerDiagnosticOptions, "category">,
+  ): asserts condition;
+  static throwDiagnostic(options: CompilerDiagnosticOptions): never;
+  static throwTodo(
+    options: Omit<CompilerErrorDetailOptions, "category">,
+  ): never;
+  static throwInvalidJS(
+    options: Omit<CompilerErrorDetailOptions, "category">,
+  ): never;
+  static throwInvalidReact(options: CompilerErrorDetailOptions): never;
+  static throwInvalidConfig(
+    options: Omit<CompilerErrorDetailOptions, "category">,
+  ): never;
+  static throw(options: CompilerErrorDetailOptions): never;
+  constructor(...args: Array<any>);
+  get message(): string;
+  set message(_message: string);
+  toString(): string;
+  withPrintedMessage(
+    source: string,
+    options: PrintErrorMessageOptions,
+  ): CompilerError;
+  printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
+  merge(other: CompilerError): void;
+  pushDiagnostic(diagnostic: CompilerDiagnostic): void;
+  push(options: CompilerErrorDetailOptions): CompilerErrorDetail;
+  pushErrorDetail(detail: CompilerErrorDetail): CompilerErrorDetail;
+  hasAnyErrors(): boolean;
+  asResult(): Result<void, CompilerError>;
+  hasErrors(): boolean;
+  hasWarning(): boolean;
+  hasHints(): boolean;
+}
+
+declare class CompilerErrorDetail {
+  options: CompilerErrorDetailOptions;
+  constructor(options: CompilerErrorDetailOptions);
+  get reason(): CompilerErrorDetailOptions["reason"];
+  get description(): CompilerErrorDetailOptions["description"];
+  get severity(): ErrorSeverity;
+  get loc(): CompilerErrorDetailOptions["loc"];
+  get suggestions(): CompilerErrorDetailOptions["suggestions"];
+  get category(): ErrorCategory;
+  primaryLocation(): SourceLocation | null;
+  printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
+  toString(): string;
+}
+
+declare type CompilerErrorDetailOptions = {
+  category: ErrorCategory;
+  reason: string;
+  description?: string | null | undefined;
+  loc: SourceLocation | null;
+  suggestions?: Array<CompilerSuggestion> | null | undefined;
+};
+
+declare type CompilerMode = "all_features" | "no_inferred_memo";
+
+declare type CompilerPipelineValue =
+  | {
+      kind: "ast";
+      name: string;
+      value: CodegenFunction;
+    }
+  | {
+      kind: "hir";
+      name: string;
+      value: HIRFunction;
+    }
+  | {
+      kind: "reactive";
+      name: string;
+      value: ReactiveFunction;
+    }
+  | {
+      kind: "debug";
+      name: string;
+      value: string;
+    };
+
+declare type CompilerReactTarget = z.infer<typeof CompilerReactTargetSchema>;
+
+declare const CompilerReactTargetSchema: z.ZodUnion<
+  readonly [
+    z.ZodLiteral<"17">,
+    z.ZodLiteral<"18">,
+    z.ZodLiteral<"19">,
+    z.ZodObject<
+      {
+        kind: z.ZodLiteral<"donotuse_meta_internal">;
+        runtimeModule: z.ZodDefault<z.ZodString>;
+      },
+      z.core.$strip
+    >,
+  ]
+>;
+
+declare type CompilerSuggestion =
+  | {
+      op:
+        | CompilerSuggestionOperation.InsertAfter
+        | CompilerSuggestionOperation.InsertBefore
+        | CompilerSuggestionOperation.Replace;
+      range: [number, number];
+      description: string;
+      text: string;
+    }
+  | {
+      op: CompilerSuggestionOperation.Remove;
+      range: [number, number];
+      description: string;
+    };
+
+declare enum CompilerSuggestionOperation {
+  InsertBefore = 0,
+  InsertAfter = 1,
+  Remove = 2,
+  Replace = 3,
+}
+
+declare type CompileSkipEvent = {
+  kind: "CompileSkip";
+  fnLoc: t.SourceLocation | null;
+  reason: string;
+  loc: t.SourceLocation | null;
+};
+
+declare type CompileSuccessEvent = {
+  kind: "CompileSuccess";
+  fnLoc: t.SourceLocation | null;
+  fnName: string | null;
+  memoSlots: number;
+  memoBlocks: number;
+  memoValues: number;
+  prunedMemoBlocks: number;
+  prunedMemoValues: number;
+};
+
+declare type ComponentType<T> = {
+  kind: "Component";
+  props: Map<string, T>;
+  children: null | T;
+};
+
+declare type ConcreteType<T> =
+  | {
+      kind: "Enum";
+    }
+  | {
+      kind: "Mixed";
+    }
+  | {
+      kind: "Number";
+    }
+  | {
+      kind: "String";
+    }
+  | {
+      kind: "Boolean";
+    }
+  | {
+      kind: "Void";
+    }
+  | {
+      kind: "Nullable";
+      type: T;
+    }
+  | {
+      kind: "Array";
+      element: T;
+    }
+  | {
+      kind: "Set";
+      element: T;
+    }
+  | {
+      kind: "Map";
+      key: T;
+      value: T;
+    }
+  | {
+      kind: "Function";
+      typeParameters: null | Array<TypeParameter<T>>;
+      params: Array<T>;
+      returnType: T;
+    }
+  | ComponentType<T>
+  | {
+      kind: "Generic";
+      id: TypeParameterId;
+      bound: T;
+    }
+  | {
+      kind: "Object";
+      id: NominalId;
+      members: Map<string, ResolvedType>;
+    }
+  | {
+      kind: "Tuple";
+      id: NominalId;
+      members: Array<T>;
+    }
+  | {
+      kind: "Structural";
+      id: LinearId;
+    }
+  | {
+      kind: "Union";
+      members: Array<T>;
+    }
+  | {
+      kind: "Instance";
+      name: string;
+      members: Map<string, ResolvedType>;
+    };
+
+/**
+ * Copies a directory from one location to another
+ *
+ * @internal
+ *
+ * @param srcDir - Source directory
+ * @param destDir - Destination directory
+ * @param skipExisting - Skip existing files
+ */
+export declare function copyDir(
+  srcDir: string,
+  destDir: string,
+  skipExisting?: boolean,
+): Promise<void>;
+
+declare type CustomOptOutDirective = z.infer<
+  typeof CustomOptOutDirectiveSchema
+>;
+
+declare const CustomOptOutDirectiveSchema: z.ZodDefault<
+  z.ZodNullable<z.ZodArray<z.ZodString>>
+>;
+
+declare type DeclarationId = number & {
+  [opageDeclarationId]: "DeclarationId";
+};
+
+declare type DependencyPath = Array<DependencyPathEntry>;
+
+declare type DependencyPathEntry = {
+  property: PropertyLiteral;
+  optional: boolean;
+};
+
+declare type Destructure = {
+  kind: "Destructure";
+  lvalue: LValuePattern;
+  value: Place;
+  loc: SourceLocation;
+};
+
+declare type DoWhileTerminal = {
+  kind: "do-while";
+  loop: BlockId;
+  test: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type DynamicGatingOptions = z.infer<typeof DynamicGatingOptionsSchema>;
+
+declare const DynamicGatingOptionsSchema: z.ZodObject<
+  {
+    source: z.ZodString;
+  },
+  z.core.$strip
+>;
+
+declare enum Effect {
+  Unknown = "<unknown>",
+  Freeze = "freeze",
+  Read = "read",
+  Capture = "capture",
+  ConditionallyMutateIterator = "mutate-iterator?",
+  ConditionallyMutate = "mutate?",
+  Mutate = "mutate",
+  Store = "store",
+}
+
+declare class Environment {
+  #private;
+  logger: Logger | null;
+  filename: string | null;
+  code: string | null;
+  config: EnvironmentConfig;
+  fnType: ReactFunctionType;
+  compilerMode: CompilerMode;
+  programContext: ProgramContext;
+  hasFireRewrite: boolean;
+  hasInferredEffect: boolean;
+  inferredEffectLocations: Set<SourceLocation>;
+  parentFunction: NodePath_2<t.Function>;
+  constructor(
+    scope: Scope,
+    fnType: ReactFunctionType,
+    compilerMode: CompilerMode,
+    config: EnvironmentConfig,
+    contextIdentifiers: Set<t.Identifier>,
+    parentFunction: NodePath_2<t.Function>,
+    logger: Logger | null,
+    filename: string | null,
+    code: string | null,
+    programContext: ProgramContext,
+  );
+  get typeContext(): FlowTypeEnv;
+  get isInferredMemoEnabled(): boolean;
+  get nextIdentifierId(): IdentifierId;
+  get nextBlockId(): BlockId;
+  get nextScopeId(): ScopeId;
+  get scope(): Scope;
+  logErrors(errors: Result<void, CompilerError>): void;
+  isContextIdentifier(node: t.Identifier): boolean;
+  isHoistedIdentifier(node: t.Identifier): boolean;
+  generateGloballyUniqueIdentifierName(
+    name: string | null,
+  ): ValidatedIdentifier;
+  outlineFunction(fn: HIRFunction, type: ReactFunctionType | null): void;
+  getOutlinedFunctions(): Array<{
+    fn: HIRFunction;
+    type: ReactFunctionType | null;
+  }>;
+  getGlobalDeclaration(
+    binding: NonLocalBinding,
+    loc: SourceLocation,
+  ): Global_2 | null;
+  static knownReactModules: ReadonlyArray<string>;
+  getFallthroughPropertyType(
+    receiver: Type,
+    _property: Type,
+  ): BuiltInType | PolyType | null;
+  getPropertyType(
+    receiver: Type,
+    property: string | number,
+  ): BuiltInType | PolyType | null;
+  getFunctionSignature(type: FunctionType): FunctionSignature | null;
+  addHoistedIdentifier(node: t.Identifier): void;
+}
+
+declare type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;
+
+declare const EnvironmentConfigSchema: z.ZodObject<
+  {
+    customHooks: z.ZodDefault<
+      z.ZodMap<
+        z.ZodString,
+        z.ZodObject<
+          {
+            effectKind: z.ZodEnum<typeof Effect>;
+            valueKind: z.ZodEnum<typeof ValueKind>;
+            noAlias: z.ZodDefault<z.ZodBoolean>;
+            transitiveMixedData: z.ZodDefault<z.ZodBoolean>;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+    moduleTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodAny>>;
+    customMacros: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodArray<
+          z.ZodUnion<
+            readonly [
+              z.ZodString,
+              z.ZodTuple<
+                [
+                  z.ZodString,
+                  z.ZodArray<
+                    z.ZodUnion<
+                      readonly [
+                        z.ZodObject<
+                          {
+                            type: z.ZodLiteral<"wildcard">;
+                          },
+                          z.core.$strip
+                        >,
+                        z.ZodObject<
+                          {
+                            type: z.ZodLiteral<"name">;
+                            name: z.ZodString;
+                          },
+                          z.core.$strip
+                        >,
+                      ]
+                    >
+                  >,
+                ],
+                null
+              >,
+            ]
+          >
+        >
+      >
+    >;
+    enableResetCacheOnSourceFileChanges: z.ZodDefault<
+      z.ZodNullable<z.ZodBoolean>
+    >;
+    enablePreserveExistingMemoizationGuarantees: z.ZodDefault<z.ZodBoolean>;
+    validatePreserveExistingMemoizationGuarantees: z.ZodDefault<z.ZodBoolean>;
+    enablePreserveExistingManualUseMemo: z.ZodDefault<z.ZodBoolean>;
+    enableForest: z.ZodDefault<z.ZodBoolean>;
+    enableUseTypeAnnotations: z.ZodDefault<z.ZodBoolean>;
+    flowTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodAny>>;
+    enableOptionalDependencies: z.ZodDefault<z.ZodBoolean>;
+    enableFire: z.ZodDefault<z.ZodBoolean>;
+    enableNameAnonymousFunctions: z.ZodDefault<z.ZodBoolean>;
+    inferEffectDependencies: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodArray<
+          z.ZodObject<
+            {
+              function: z.ZodObject<
+                {
+                  source: z.ZodString;
+                  importSpecifierName: z.ZodString;
+                },
+                z.core.$strip
+              >;
+              autodepsIndex: z.ZodNumber;
+            },
+            z.core.$strip
+          >
+        >
+      >
+    >;
+    inlineJsxTransform: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            elementSymbol: z.ZodUnion<
+              readonly [
+                z.ZodLiteral<"react.element">,
+                z.ZodLiteral<"react.transitional.element">,
+              ]
+            >;
+            globalDevVar: z.ZodString;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+    validateHooksUsage: z.ZodDefault<z.ZodBoolean>;
+    validateRefAccessDuringRender: z.ZodDefault<z.ZodBoolean>;
+    validateNoSetStateInRender: z.ZodDefault<z.ZodBoolean>;
+    validateNoSetStateInEffects: z.ZodDefault<z.ZodBoolean>;
+    validateNoDerivedComputationsInEffects: z.ZodDefault<z.ZodBoolean>;
+    validateNoJSXInTryStatements: z.ZodDefault<z.ZodBoolean>;
+    validateStaticComponents: z.ZodDefault<z.ZodBoolean>;
+    validateMemoizedEffectDependencies: z.ZodDefault<z.ZodBoolean>;
+    validateNoCapitalizedCalls: z.ZodDefault<
+      z.ZodNullable<z.ZodArray<z.ZodString>>
+    >;
+    validateBlocklistedImports: z.ZodDefault<
+      z.ZodNullable<z.ZodArray<z.ZodString>>
+    >;
+    validateNoImpureFunctionsInRender: z.ZodDefault<z.ZodBoolean>;
+    validateNoFreezingKnownMutableFunctions: z.ZodDefault<z.ZodBoolean>;
+    enableAssumeHooksFollowRulesOfReact: z.ZodDefault<z.ZodBoolean>;
+    enableTransitivelyFreezeFunctionExpressions: z.ZodDefault<z.ZodBoolean>;
+    enableEmitFreeze: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            source: z.ZodString;
+            importSpecifierName: z.ZodString;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+    enableEmitHookGuards: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            source: z.ZodString;
+            importSpecifierName: z.ZodString;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+    enableInstructionReordering: z.ZodDefault<z.ZodBoolean>;
+    enableFunctionOutlining: z.ZodDefault<z.ZodBoolean>;
+    enableJsxOutlining: z.ZodDefault<z.ZodBoolean>;
+    enableEmitInstrumentForget: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            fn: z.ZodObject<
+              {
+                source: z.ZodString;
+                importSpecifierName: z.ZodString;
+              },
+              z.core.$strip
+            >;
+            gating: z.ZodNullable<
+              z.ZodObject<
+                {
+                  source: z.ZodString;
+                  importSpecifierName: z.ZodString;
+                },
+                z.core.$strip
+              >
+            >;
+            globalGating: z.ZodNullable<z.ZodString>;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+    assertValidMutableRanges: z.ZodDefault<z.ZodBoolean>;
+    enableChangeVariableCodegen: z.ZodDefault<z.ZodBoolean>;
+    enableMemoizationComments: z.ZodDefault<z.ZodBoolean>;
+    throwUnknownException__testonly: z.ZodDefault<z.ZodBoolean>;
+    enableTreatFunctionDepsAsConditional: z.ZodDefault<z.ZodBoolean>;
+    disableMemoizationForDebugging: z.ZodDefault<z.ZodBoolean>;
+    enableChangeDetectionForDebugging: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            source: z.ZodString;
+            importSpecifierName: z.ZodString;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+    enableCustomTypeDefinitionForReanimated: z.ZodDefault<z.ZodBoolean>;
+    hookPattern: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    enableTreatRefLikeIdentifiersAsRefs: z.ZodDefault<z.ZodBoolean>;
+    enableTreatSetIdentifiersAsStateSetters: z.ZodDefault<z.ZodBoolean>;
+    lowerContextAccess: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            source: z.ZodString;
+            importSpecifierName: z.ZodString;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+    validateNoVoidUseMemo: z.ZodDefault<z.ZodBoolean>;
+    validateNoDynamicallyCreatedComponentsOrHooks: z.ZodDefault<z.ZodBoolean>;
+    enableAllowSetStateFromRefsInEffects: z.ZodDefault<z.ZodBoolean>;
+  },
+  z.core.$strip
+>;
+
+declare class ErrImpl<E> implements Result<never, E> {
+  #private;
+  constructor(val: E);
+  map<U>(_fn: (val: never) => U): Result<U, E>;
+  mapErr<F>(fn: (val: E) => F): Result<never, F>;
+  mapOr<U>(fallback: U, _fn: (val: never) => U): U;
+  mapOrElse<U>(fallback: () => U, _fn: (val: never) => U): U;
+  andThen<U>(_fn: (val: never) => Result<U, E>): Result<U, E>;
+  and<U>(_res: Result<U, E>): Result<U, E>;
+  or(res: Result<never, E>): Result<never, E>;
+  orElse<F>(fn: (val: E) => ErrImpl<F>): Result<never, F>;
+  isOk(): this is OkImpl<never>;
+  isErr(): this is ErrImpl<E>;
+  expect(msg: string): never;
+  expectErr(_msg: string): E;
+  unwrap(): never;
+  unwrapOr<T>(fallback: T): T;
+  unwrapOrElse<T>(fallback: (val: E) => T): T;
+  unwrapErr(): E;
+}
+
+declare enum ErrorCategory {
+  Hooks = "Hooks",
+  CapitalizedCalls = "CapitalizedCalls",
+  StaticComponents = "StaticComponents",
+  UseMemo = "UseMemo",
+  Factories = "Factories",
+  PreserveManualMemo = "PreserveManualMemo",
+  IncompatibleLibrary = "IncompatibleLibrary",
+  Immutability = "Immutability",
+  Globals = "Globals",
+  Refs = "Refs",
+  EffectDependencies = "EffectDependencies",
+  EffectSetState = "EffectSetState",
+  EffectDerivationsOfState = "EffectDerivationsOfState",
+  ErrorBoundaries = "ErrorBoundaries",
+  Purity = "Purity",
+  RenderSetState = "RenderSetState",
+  Invariant = "Invariant",
+  Todo = "Todo",
+  Syntax = "Syntax",
+  UnsupportedSyntax = "UnsupportedSyntax",
+  Config = "Config",
+  Gating = "Gating",
+  Suppression = "Suppression",
+  AutomaticEffectDependencies = "AutomaticEffectDependencies",
+  Fire = "Fire",
+  FBT = "FBT",
+}
+
+declare enum ErrorSeverity {
+  Error = "Error",
+  Warning = "Warning",
+  Hint = "Hint",
+  Off = "Off",
+}
+
+/**
+ * Merge user-provided Vite configuration object or function
+ *
+ * @param defaultConfig - Default configuration object
+ * @param userConfig - User-provided configuration object or function
+ * @returns Merged configuration
+ * @internal
+ */
+export declare function extendViteConfigWithUserConfig(
+  env: ConfigEnv,
+  defaultConfig: InlineConfig,
+  userConfig: UserViteConfig,
+): Promise<InlineConfig>;
+
+declare type ExternalFunction = z.infer<typeof ExternalFunctionSchema>;
+
+declare const ExternalFunctionSchema: z.ZodObject<
+  {
+    source: z.ZodString;
+    importSpecifierName: z.ZodString;
+  },
+  z.core.$strip
+>;
+
+/**
+ * Ensure Sanity entry chunk is always loaded
+ *
+ * @param config - User-modified configuration
+ * @returns Merged configuration
+ * @internal
+ */
+export declare function finalizeViteConfig(
+  config: InlineConfig,
+): Promise<InlineConfig>;
+
+declare type FinishMemoize = {
+  kind: "FinishMemoize";
+  manualMemoId: number;
+  decl: Place;
+  pruned?: true;
+  loc: SourceLocation;
+};
+
+declare class FlowTypeEnv implements ITypeEnv {
+  #private;
+  moduleEnv: Map<string, ResolvedType>;
+  init(env: Environment, source: string): void;
+  setType(identifier: Identifier, type: ResolvedType): void;
+  getType(identifier: Identifier): ResolvedType;
+  getTypeOrNull(identifier: Identifier): ResolvedType | null;
+  getTypeByLoc(loc: SourceLocation): ResolvedType | null;
+  nextNominalId(): NominalId;
+  nextTypeParameterId(): TypeParameterId;
+  addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;
+  resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;
+  pushGeneric(name: string, generic: TypeParameter<ResolvedType>): void;
+  popGeneric(name: string): void;
+  getGeneric(name: string): null | TypeParameter<ResolvedType>;
+}
+
+declare type ForInTerminal = {
+  kind: "for-in";
+  loc: SourceLocation;
+  init: BlockId;
+  loop: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+};
+
+declare type ForOfTerminal = {
+  kind: "for-of";
+  loc: SourceLocation;
+  init: BlockId;
+  test: BlockId;
+  loop: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+};
+
+declare type ForTerminal = {
+  kind: "for";
+  loc: SourceLocation;
+  init: BlockId;
+  test: BlockId;
+  update: BlockId | null;
+  loop: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+};
+
+declare type FunctionExpression = {
+  kind: "FunctionExpression";
+  name: ValidIdentifierName | null;
+  nameHint: string | null;
+  loweredFunc: LoweredFunction;
+  type:
+    | "ArrowFunctionExpression"
+    | "FunctionExpression"
+    | "FunctionDeclaration";
+  loc: SourceLocation;
+};
+
+declare type FunctionSignature = {
+  positionalParams: Array<Effect>;
+  restParam: Effect | null;
+  returnType: BuiltInType | PolyType;
+  returnValueKind: ValueKind;
+  returnValueReason?: ValueReason;
+  calleeEffect: Effect;
+  hookKind: HookKind | null;
+  noAlias?: boolean;
+  mutableOnlyIfOperandsAreMutable?: boolean;
+  impure?: boolean;
+  knownIncompatible?: string | null | undefined;
+  canonicalName?: string;
+  aliasing?: AliasingSignature | null | undefined;
+};
+
+declare type FunctionType = {
+  kind: "Function";
+  shapeId: string | null;
+  return: Type;
+  isConstructor: boolean;
+};
+
+declare const GeneratedSource: unique symbol;
+
+/**
+ * Get a configuration object for Vite based on the passed options
+ *
+ * @internal Only meant for consumption inside of Sanity modules, do not depend on this externally
+ */
+export declare function getViteConfig(
+  options: ViteOptions,
+): Promise<InlineConfig>;
+
+declare type Global_2 = BuiltInType | PolyType;
+
+declare type GotoTerminal = {
+  kind: "goto";
+  block: BlockId;
+  variant: GotoVariant;
+  id: InstructionId;
+  loc: SourceLocation;
+  fallthrough?: never;
+};
+
+declare enum GotoVariant {
+  Break = "Break",
+  Continue = "Continue",
+  Try = "Try",
+}
+
+declare type HIR = {
+  entry: BlockId;
+  blocks: Map<BlockId, BasicBlock>;
+};
+
+declare type HIRFunction = {
+  loc: SourceLocation;
+  id: ValidIdentifierName | null;
+  nameHint: string | null;
+  fnType: ReactFunctionType;
+  env: Environment;
+  params: Array<Place | SpreadPattern>;
+  returnTypeAnnotation: t.FlowType | t.TSType | null;
+  returns: Place;
+  context: Array<Place>;
+  body: HIR;
+  generator: boolean;
+  async: boolean;
+  directives: Array<string>;
+  aliasingEffects: Array<AliasingEffect> | null;
+};
+
+declare type Hole = {
+  kind: "Hole";
+};
+
+declare type HookKind =
+  | "useContext"
+  | "useState"
+  | "useActionState"
+  | "useReducer"
+  | "useRef"
+  | "useEffect"
+  | "useLayoutEffect"
+  | "useInsertionEffect"
+  | "useMemo"
+  | "useCallback"
+  | "useTransition"
+  | "useImperativeHandle"
+  | "useEffectEvent"
+  | "Custom";
+
+declare type Identifier = {
+  id: IdentifierId;
+  declarationId: DeclarationId;
+  name: IdentifierName | null;
+  mutableRange: MutableRange;
+  scope: ReactiveScope | null;
+  type: Type;
+  loc: SourceLocation;
+};
+
+declare type IdentifierId = number & {
+  [opaqueIdentifierId]: "IdentifierId";
+};
+
+declare type IdentifierName = ValidatedIdentifier | PromotedIdentifier;
+
+declare type IfTerminal = {
+  kind: "if";
+  test: Place;
+  consequent: BlockId;
+  alternate: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type Instruction = {
+  id: InstructionId;
+  lvalue: Place;
+  value: InstructionValue;
+  loc: SourceLocation;
+  effects: Array<AliasingEffect> | null;
+};
+
+declare type InstructionId = number & {
+  [opaqueInstructionId]: "IdentifierId";
+};
+
+declare enum InstructionKind {
+  Const = "Const",
+  Let = "Let",
+  Reassign = "Reassign",
+  Catch = "Catch",
+  HoistedConst = "HoistedConst",
+  HoistedLet = "HoistedLet",
+  HoistedFunction = "HoistedFunction",
+  Function = "Function",
+}
+
+declare type InstructionValue =
+  | LoadLocal
+  | LoadContext
+  | {
+      kind: "DeclareLocal";
+      lvalue: LValue;
+      type: t.FlowType | t.TSType | null;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "DeclareContext";
+      lvalue: {
+        kind:
+          | InstructionKind.Let
+          | InstructionKind.HoistedConst
+          | InstructionKind.HoistedLet
+          | InstructionKind.HoistedFunction;
+        place: Place;
+      };
+      loc: SourceLocation;
+    }
+  | StoreLocal
+  | {
+      kind: "StoreContext";
+      lvalue: {
+        kind:
+          | InstructionKind.Reassign
+          | InstructionKind.Const
+          | InstructionKind.Let
+          | InstructionKind.Function;
+        place: Place;
+      };
+      value: Place;
+      loc: SourceLocation;
+    }
+  | Destructure
+  | {
+      kind: "Primitive";
+      value: number | boolean | string | null | undefined;
+      loc: SourceLocation;
+    }
+  | JSXText
+  | {
+      kind: "BinaryExpression";
+      operator: Exclude<t.BinaryExpression["operator"], "|>">;
+      left: Place;
+      right: Place;
+      loc: SourceLocation;
+    }
+  | NewExpression
+  | CallExpression
+  | MethodCall
+  | {
+      kind: "UnaryExpression";
+      operator: Exclude<t.UnaryExpression["operator"], "throw" | "delete">;
+      value: Place;
+      loc: SourceLocation;
+    }
+  | ({
+      kind: "TypeCastExpression";
+      value: Place;
+      type: Type;
+      loc: SourceLocation;
+    } & (
+      | {
+          typeAnnotation: t.FlowType;
+          typeAnnotationKind: "cast";
+        }
+      | {
+          typeAnnotation: t.TSType;
+          typeAnnotationKind: "as" | "satisfies";
+        }
+    ))
+  | JsxExpression
+  | {
+      kind: "ObjectExpression";
+      properties: Array<ObjectProperty | SpreadPattern>;
+      loc: SourceLocation;
+    }
+  | ObjectMethod
+  | ArrayExpression
+  | {
+      kind: "JsxFragment";
+      children: Array<Place>;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "RegExpLiteral";
+      pattern: string;
+      flags: string;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "MetaProperty";
+      meta: string;
+      property: string;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "PropertyStore";
+      object: Place;
+      property: PropertyLiteral;
+      value: Place;
+      loc: SourceLocation;
+    }
+  | PropertyLoad
+  | {
+      kind: "PropertyDelete";
+      object: Place;
+      property: PropertyLiteral;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "ComputedStore";
+      object: Place;
+      property: Place;
+      value: Place;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "ComputedLoad";
+      object: Place;
+      property: Place;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "ComputedDelete";
+      object: Place;
+      property: Place;
+      loc: SourceLocation;
+    }
+  | LoadGlobal
+  | StoreGlobal
+  | FunctionExpression
+  | {
+      kind: "TaggedTemplateExpression";
+      tag: Place;
+      value: {
+        raw: string;
+        cooked?: string;
+      };
+      loc: SourceLocation;
+    }
+  | {
+      kind: "TemplateLiteral";
+      subexprs: Array<Place>;
+      quasis: Array<{
+        raw: string;
+        cooked?: string;
+      }>;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "Await";
+      value: Place;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "GetIterator";
+      collection: Place;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "IteratorNext";
+      iterator: Place;
+      collection: Place;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "NextPropertyOf";
+      value: Place;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "PrefixUpdate";
+      lvalue: Place;
+      operation: t.UpdateExpression["operator"];
+      value: Place;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "PostfixUpdate";
+      lvalue: Place;
+      operation: t.UpdateExpression["operator"];
+      value: Place;
+      loc: SourceLocation;
+    }
+  | {
+      kind: "Debugger";
+      loc: SourceLocation;
+    }
+  | StartMemoize
+  | FinishMemoize
+  | {
+      kind: "UnsupportedNode";
+      node: t.Node;
+      loc: SourceLocation;
+    };
+
+declare interface ITypeEnv {
+  popGeneric(name: string): void;
+  getGeneric(name: string): null | TypeParameter<ResolvedType>;
+  pushGeneric(
+    name: string,
+    binding: {
+      name: string;
+      id: TypeParameterId;
+      bound: ResolvedType;
+    },
+  ): void;
+  getType(id: Identifier): ResolvedType;
+  getTypeOrNull(id: Identifier): ResolvedType | null;
+  setType(id: Identifier, type: ResolvedType): void;
+  nextNominalId(): NominalId;
+  nextTypeParameterId(): TypeParameterId;
+  moduleEnv: Map<string, ResolvedType>;
+  addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;
+  resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;
+}
+
+declare type JsxAttribute =
+  | {
+      kind: "JsxSpreadAttribute";
+      argument: Place;
+    }
+  | {
+      kind: "JsxAttribute";
+      name: string;
+      place: Place;
+    };
+
+declare type JsxExpression = {
+  kind: "JsxExpression";
+  tag: Place | BuiltinTag;
+  props: Array<JsxAttribute>;
+  children: Array<Place> | null;
+  loc: SourceLocation;
+  openingLoc: SourceLocation;
+  closingLoc: SourceLocation;
+};
+
+declare type JSXText = {
+  kind: "JSXText";
+  value: string;
+  loc: SourceLocation;
+};
+
+declare type LabelTerminal = {
+  kind: "label";
+  block: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type LinearId = number & {
+  [opaqueLinearId]: "LinearId";
+};
+
+declare type LoadContext = {
+  kind: "LoadContext";
+  place: Place;
+  loc: SourceLocation;
+};
+
+declare type LoadGlobal = {
+  kind: "LoadGlobal";
+  binding: NonLocalBinding;
+  loc: SourceLocation;
+};
+
+declare type LoadLocal = {
+  kind: "LoadLocal";
+  place: Place;
+  loc: SourceLocation;
+};
+
+declare type Logger = {
+  logEvent: (filename: string | null, event: LoggerEvent) => void;
+  debugLogIRs?: (value: CompilerPipelineValue) => void;
+};
+
+declare type LoggerEvent =
+  | CompileSuccessEvent
+  | CompileErrorEvent
+  | CompileDiagnosticEvent
+  | CompileSkipEvent
+  | PipelineErrorEvent
+  | TimingEvent
+  | AutoDepsDecorationsEvent
+  | AutoDepsEligibleEvent;
+
+declare type LogicalTerminal = {
+  kind: "logical";
+  operator: t.LogicalExpression["operator"];
+  test: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type LoweredFunction = {
+  func: HIRFunction;
+};
+
+declare type LValue = {
+  place: Place;
+  kind: InstructionKind;
+};
+
+declare type LValuePattern = {
+  pattern: Pattern;
+  kind: InstructionKind;
+};
+
+declare type ManualMemoDependency = {
+  root:
+    | {
+        kind: "NamedLocal";
+        value: Place;
+      }
+    | {
+        kind: "Global";
+        identifierName: string;
+      };
+  path: DependencyPath;
+};
+
+declare type MaybeThrowTerminal = {
+  kind: "maybe-throw";
+  continuation: BlockId;
+  handler: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+  fallthrough?: never;
+  effects: Array<AliasingEffect> | null;
+};
+
+declare type MethodCall = {
+  kind: "MethodCall";
+  receiver: Place;
+  property: Place;
+  args: Array<Place | SpreadPattern>;
+  loc: SourceLocation;
+};
+
+declare type MutableRange = {
+  start: InstructionId;
+  end: InstructionId;
+};
+
+declare type MutationReason = {
+  kind: "AssignCurrentProperty";
+};
+
+declare type NewExpression = {
+  kind: "NewExpression";
+  callee: Place;
+  args: Array<Place | SpreadPattern>;
+  loc: SourceLocation;
+};
+
+declare type NominalId = number & {
+  [opaqueNominalId]: "NominalId";
+};
+
+declare type NonLocalBinding =
+  | {
+      kind: "ImportDefault";
+      name: string;
+      module: string;
+    }
+  | {
+      kind: "ImportNamespace";
+      name: string;
+      module: string;
+    }
+  | NonLocalImportSpecifier
+  | {
+      kind: "ModuleLocal";
+      name: string;
+    }
+  | {
+      kind: "Global";
+      name: string;
+    };
+
+declare type NonLocalImportSpecifier = {
+  kind: "ImportSpecifier";
+  name: string;
+  module: string;
+  imported: string;
+};
+
+declare type ObjectMethod$1 = {
+  kind: "ObjectMethod";
+};
+
+declare type ObjectMethod = {
+  kind: "ObjectMethod";
+  loc: SourceLocation;
+  loweredFunc: LoweredFunction;
+};
+
+declare type ObjectPattern = {
+  kind: "ObjectPattern";
+  properties: Array<ObjectProperty | SpreadPattern>;
+};
+
+declare type ObjectProperty = {
+  kind: "ObjectProperty";
+  key: ObjectPropertyKey;
+  type: "property" | "method";
+  place: Place;
+};
+
+declare type ObjectPropertyKey =
+  | {
+      kind: "string";
+      name: string;
+    }
+  | {
+      kind: "identifier";
+      name: string;
+    }
+  | {
+      kind: "computed";
+      name: Place;
+    }
+  | {
+      kind: "number";
+      name: number;
+    };
+
+declare type ObjectType = {
+  kind: "Object";
+  shapeId: string | null;
+};
+
+declare class OkImpl<T> implements Result<T, never> {
+  #private;
+  constructor(val: T);
+  map<U>(fn: (val: T) => U): Result<U, never>;
+  mapErr<F>(_fn: (val: never) => F): Result<T, F>;
+  mapOr<U>(_fallback: U, fn: (val: T) => U): U;
+  mapOrElse<U>(_fallback: () => U, fn: (val: T) => U): U;
+  andThen<U>(fn: (val: T) => Result<U, never>): Result<U, never>;
+  and<U>(res: Result<U, never>): Result<U, never>;
+  or(_res: Result<T, never>): Result<T, never>;
+  orElse<F>(_fn: (val: never) => Result<T, F>): Result<T, F>;
+  isOk(): this is OkImpl<T>;
+  isErr(): this is ErrImpl<never>;
+  expect(_msg: string): T;
+  expectErr(msg: string): never;
+  unwrap(): T;
+  unwrapOr(_fallback: T): T;
+  unwrapOrElse(_fallback: (val: never) => T): T;
+  unwrapErr(): never;
+}
+
+declare const opageDeclarationId: unique symbol;
+
+declare const opaqueBlockId: unique symbol;
+
+declare const opaqueIdentifierId: unique symbol;
+
+declare const opaqueInstructionId: unique symbol;
+
+declare const opaqueLinearId: unique symbol;
+
+declare const opaqueNominalId: unique symbol;
+
+declare const opaquePropertyLiteral: unique symbol;
+
+declare const opaqueScopeId: unique symbol;
+
+declare const opaqueTypeId: unique symbol;
+
+declare const opaqueTypeParameterId: unique symbol;
+
+declare const opaqueValidIdentifierName: unique symbol;
+
+declare type OptionalTerminal = {
+  kind: "optional";
+  optional: boolean;
+  test: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type PanicThresholdOptions = z.infer<
+  typeof PanicThresholdOptionsSchema
+>;
+
+declare const PanicThresholdOptionsSchema: z.ZodEnum<{
+  none: "none";
+  all_errors: "all_errors";
+  critical_errors: "critical_errors";
+}>;
+
+declare type ParsedPluginOptions = Required<
+  Omit<PluginOptions, "environment">
+> & {
+  environment: EnvironmentConfig;
+};
+
+declare type Pattern = ArrayPattern | ObjectPattern;
+
+declare type Phi = {
+  kind: "Phi";
+  place: Place;
+  operands: Map<BlockId, Place>;
+};
+
+declare type PhiType = {
+  kind: "Phi";
+  operands: Array<Type>;
+};
+
+declare type PipelineErrorEvent = {
+  kind: "PipelineError";
+  fnLoc: t.SourceLocation | null;
+  data: string;
+};
+
+declare type Place = {
+  kind: "Identifier";
+  identifier: Identifier;
+  effect: Effect;
+  reactive: boolean;
+  loc: SourceLocation;
+};
+
+declare type Platform = "client" | "server" | "shared";
+
+declare type PluginOptions = Partial<{
+  environment: Partial<EnvironmentConfig>;
+  logger: Logger | null;
+  gating: ExternalFunction | null;
+  dynamicGating: DynamicGatingOptions | null;
+  panicThreshold: PanicThresholdOptions;
+  noEmit: boolean;
+  compilationMode: CompilationMode;
+  eslintSuppressionRules: Array<string> | null | undefined;
+  flowSuppressions: boolean;
+  ignoreUseNoForget: boolean;
+  customOptOutDirectives: CustomOptOutDirective;
+  sources: Array<string> | ((filename: string) => boolean) | null;
+  enableReanimatedCheck: boolean;
+  target: CompilerReactTarget;
+}>;
+
+declare type PolyType = {
+  kind: "Poly";
+};
+
+declare type PrimitiveType = {
+  kind: "Primitive";
+};
+
+declare type PrintErrorMessageOptions = {
+  eslint: boolean;
+};
+
+declare class ProgramContext {
+  scope: Scope;
+  opts: ParsedPluginOptions;
+  filename: string | null;
+  code: string | null;
+  reactRuntimeModule: string;
+  suppressions: Array<SuppressionRange>;
+  hasModuleScopeOptOut: boolean;
+  alreadyCompiled: WeakSet<object> | Set<object>;
+  knownReferencedNames: Set<string>;
+  imports: Map<string, Map<string, NonLocalImportSpecifier>>;
+  retryErrors: Array<{
+    fn: BabelFn;
+    error: CompilerError;
+  }>;
+  inferredEffectLocations: Set<t.SourceLocation>;
+  constructor({
+    program,
+    suppressions,
+    opts,
+    filename,
+    code,
+    hasModuleScopeOptOut,
+  }: ProgramContextOptions);
+  isHookName(name: string): boolean;
+  hasReference(name: string): boolean;
+  newUid(name: string): string;
+  addMemoCacheImport(): NonLocalImportSpecifier;
+  addImportSpecifier(
+    { source: module, importSpecifierName: specifier }: ExternalFunction,
+    nameHint?: string,
+  ): NonLocalImportSpecifier;
+  addNewReference(name: string): void;
+  assertGlobalBinding(
+    name: string,
+    localScope?: Scope,
+  ): Result<void, CompilerError>;
+  logEvent(event: LoggerEvent): void;
+}
+
+declare type ProgramContextOptions = {
+  program: NodePath<t.Program>;
+  suppressions: Array<SuppressionRange>;
+  opts: ParsedPluginOptions;
+  filename: string | null;
+  code: string | null;
+  hasModuleScopeOptOut: boolean;
+};
+
+declare type PromotedIdentifier = {
+  kind: "promoted";
+  value: string;
+};
+
+declare type PropertyLiteral = (string | number) & {
+  [opaquePropertyLiteral]: "PropertyLiteral";
+};
+
+declare type PropertyLoad = {
+  kind: "PropertyLoad";
+  object: Place;
+  property: PropertyLiteral;
+  loc: SourceLocation;
+};
+
+declare type PropType = {
+  kind: "Property";
+  objectType: Type;
+  objectName: string;
+  propertyName:
+    | {
+        kind: "literal";
+        value: PropertyLiteral;
+      }
+    | {
+        kind: "computed";
+        value: Type;
+      };
+};
+
+declare type PrunedReactiveScopeBlock = {
+  kind: "pruned-scope";
+  scope: ReactiveScope;
+  instructions: ReactiveBlock;
+};
+
+declare type PrunedScopeTerminal = {
+  kind: "pruned-scope";
+  fallthrough: BlockId;
+  block: BlockId;
+  scope: ReactiveScope;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactFunctionType = "Component" | "Hook" | "Other";
+
+declare type ReactiveBlock = Array<ReactiveStatement>;
+
+declare type ReactiveBreakTerminal = {
+  kind: "break";
+  target: BlockId;
+  id: InstructionId;
+  targetKind: ReactiveTerminalTargetKind;
+  loc: SourceLocation;
+};
+
+declare type ReactiveContinueTerminal = {
+  kind: "continue";
+  target: BlockId;
+  id: InstructionId;
+  targetKind: ReactiveTerminalTargetKind;
+  loc: SourceLocation;
+};
+
+declare type ReactiveDoWhileTerminal = {
+  kind: "do-while";
+  loop: ReactiveBlock;
+  test: ReactiveValue;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveForInTerminal = {
+  kind: "for-in";
+  init: ReactiveValue;
+  loop: ReactiveBlock;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveForOfTerminal = {
+  kind: "for-of";
+  init: ReactiveValue;
+  test: ReactiveValue;
+  loop: ReactiveBlock;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveForTerminal = {
+  kind: "for";
+  init: ReactiveValue;
+  test: ReactiveValue;
+  update: ReactiveValue | null;
+  loop: ReactiveBlock;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveFunction = {
+  loc: SourceLocation;
+  id: ValidIdentifierName | null;
+  nameHint: string | null;
+  params: Array<Place | SpreadPattern>;
+  generator: boolean;
+  async: boolean;
+  body: ReactiveBlock;
+  env: Environment;
+  directives: Array<string>;
+};
+
+declare type ReactiveIfTerminal = {
+  kind: "if";
+  test: Place;
+  consequent: ReactiveBlock;
+  alternate: ReactiveBlock | null;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveInstruction = {
+  id: InstructionId;
+  lvalue: Place | null;
+  value: ReactiveValue;
+  effects?: Array<AliasingEffect> | null;
+  loc: SourceLocation;
+};
+
+declare type ReactiveInstructionStatement = {
+  kind: "instruction";
+  instruction: ReactiveInstruction;
+};
+
+declare type ReactiveLabelTerminal = {
+  kind: "label";
+  block: ReactiveBlock;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveLogicalValue = {
+  kind: "LogicalExpression";
+  operator: t.LogicalExpression["operator"];
+  left: ReactiveValue;
+  right: ReactiveValue;
+  loc: SourceLocation;
+};
+
+declare type ReactiveOptionalCallValue = {
+  kind: "OptionalExpression";
+  id: InstructionId;
+  value: ReactiveValue;
+  optional: boolean;
+  loc: SourceLocation;
+};
+
+declare type ReactiveReturnTerminal = {
+  kind: "return";
+  value: Place;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveScope = {
+  id: ScopeId;
+  range: MutableRange;
+  dependencies: ReactiveScopeDependencies;
+  declarations: Map<IdentifierId, ReactiveScopeDeclaration>;
+  reassignments: Set<Identifier>;
+  earlyReturnValue: {
+    value: Identifier;
+    loc: SourceLocation;
+    label: BlockId;
+  } | null;
+  merged: Set<ScopeId>;
+  loc: SourceLocation;
+};
+
+declare type ReactiveScopeBlock = {
+  kind: "scope";
+  scope: ReactiveScope;
+  instructions: ReactiveBlock;
+};
+
+declare type ReactiveScopeDeclaration = {
+  identifier: Identifier;
+  scope: ReactiveScope;
+};
+
+declare type ReactiveScopeDependencies = Set<ReactiveScopeDependency>;
+
+declare type ReactiveScopeDependency = {
+  identifier: Identifier;
+  reactive: boolean;
+  path: DependencyPath;
+};
+
+declare type ReactiveScopeTerminal = {
+  kind: "scope";
+  fallthrough: BlockId;
+  block: BlockId;
+  scope: ReactiveScope;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveSequenceValue = {
+  kind: "SequenceExpression";
+  instructions: Array<ReactiveInstruction>;
+  id: InstructionId;
+  value: ReactiveValue;
+  loc: SourceLocation;
+};
+
+declare type ReactiveStatement =
+  | ReactiveInstructionStatement
+  | ReactiveTerminalStatement
+  | ReactiveScopeBlock
+  | PrunedReactiveScopeBlock;
+
+declare type ReactiveSwitchTerminal = {
+  kind: "switch";
+  test: Place;
+  cases: Array<{
+    test: Place | null;
+    block: ReactiveBlock | void;
+  }>;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveTerminal =
+  | ReactiveBreakTerminal
+  | ReactiveContinueTerminal
+  | ReactiveReturnTerminal
+  | ReactiveThrowTerminal
+  | ReactiveSwitchTerminal
+  | ReactiveDoWhileTerminal
+  | ReactiveWhileTerminal
+  | ReactiveForTerminal
+  | ReactiveForOfTerminal
+  | ReactiveForInTerminal
+  | ReactiveIfTerminal
+  | ReactiveLabelTerminal
+  | ReactiveTryTerminal;
+
+declare type ReactiveTerminalStatement<
+  Tterminal extends ReactiveTerminal = ReactiveTerminal,
+> = {
+  kind: "terminal";
+  terminal: Tterminal;
+  label: {
+    id: BlockId;
+    implicit: boolean;
+  } | null;
+};
+
+declare type ReactiveTerminalTargetKind = "implicit" | "labeled" | "unlabeled";
+
+declare type ReactiveTernaryValue = {
+  kind: "ConditionalExpression";
+  test: ReactiveValue;
+  consequent: ReactiveValue;
+  alternate: ReactiveValue;
+  loc: SourceLocation;
+};
+
+declare type ReactiveThrowTerminal = {
+  kind: "throw";
+  value: Place;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveTryTerminal = {
+  kind: "try";
+  block: ReactiveBlock;
+  handlerBinding: Place | null;
+  handler: ReactiveBlock;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ReactiveValue =
+  | InstructionValue
+  | ReactiveLogicalValue
+  | ReactiveSequenceValue
+  | ReactiveTernaryValue
+  | ReactiveOptionalCallValue;
+
+declare type ReactiveWhileTerminal = {
+  kind: "while";
+  test: ReactiveValue;
+  loop: ReactiveBlock;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ResolvedType = {
+  kind: "Concrete";
+  type: ConcreteType<ResolvedType>;
+  platform: Platform;
+};
+
+declare interface Result<T, E> {
+  map<U>(fn: (val: T) => U): Result<U, E>;
+  mapErr<F>(fn: (val: E) => F): Result<T, F>;
+  mapOr<U>(fallback: U, fn: (val: T) => U): U;
+  mapOrElse<U>(fallback: () => U, fn: (val: T) => U): U;
+  andThen<U>(fn: (val: T) => Result<U, E>): Result<U, E>;
+  and<U>(res: Result<U, E>): Result<U, E>;
+  or(res: Result<T, E>): Result<T, E>;
+  orElse<F>(fn: (val: E) => Result<T, F>): Result<T, F>;
+  isOk(): this is OkImpl<T>;
+  isErr(): this is ErrImpl<E>;
+  expect(msg: string): T;
+  expectErr(msg: string): E;
+  unwrap(): T;
+  unwrapOr(fallback: T): T;
+  unwrapOrElse(fallback: (val: E) => T): T;
+  unwrapErr(): E;
+}
+
+declare type ReturnTerminal = {
+  kind: "return";
+  returnVariant: ReturnVariant;
+  loc: SourceLocation;
+  value: Place;
+  id: InstructionId;
+  fallthrough?: never;
+  effects: Array<AliasingEffect> | null;
+};
+
+declare type ReturnVariant = "Void" | "Implicit" | "Explicit";
+
+declare interface RuntimeOptions {
+  cwd: string;
+  reactStrictMode: boolean;
+  watch: boolean;
+  appTitle?: string;
+  basePath?: string;
+  entry?: string;
+  isApp?: boolean;
+}
+
+declare type ScopeId = number & {
+  [opaqueScopeId]: "ScopeId";
+};
+
+declare type SequenceTerminal = {
+  kind: "sequence";
+  block: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type SourceLocation = t.SourceLocation | typeof GeneratedSource;
+
+declare type SpreadPattern = {
+  kind: "Spread";
+  place: Place;
+};
+
+declare type StartMemoize = {
+  kind: "StartMemoize";
+  manualMemoId: number;
+  deps: Array<ManualMemoDependency> | null;
+  loc: SourceLocation;
+};
+
+declare type StoreGlobal = {
+  kind: "StoreGlobal";
+  name: string;
+  value: Place;
+  loc: SourceLocation;
+};
+
+declare type StoreLocal = {
+  kind: "StoreLocal";
+  lvalue: LValue;
+  value: Place;
+  type: t.FlowType | t.TSType | null;
+  loc: SourceLocation;
+};
+
+export declare const StudioBuildTrace: DefinedTelemetryTrace<
+  {
+    outputSize: number;
+  },
+  void
+>;
+
+declare type SuppressionRange = {
+  disableComment: t.Comment;
+  enableComment: t.Comment | null;
+  source: SuppressionSource;
+};
+
+declare type SuppressionSource = "Eslint" | "Flow";
+
+declare type SwitchTerminal = {
+  kind: "switch";
+  test: Place;
+  cases: Array<Case>;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type Terminal =
+  | UnsupportedTerminal
+  | UnreachableTerminal
+  | ThrowTerminal
+  | ReturnTerminal
+  | GotoTerminal
+  | IfTerminal
+  | BranchTerminal
+  | SwitchTerminal
+  | ForTerminal
+  | ForOfTerminal
+  | ForInTerminal
+  | DoWhileTerminal
+  | WhileTerminal
+  | LogicalTerminal
+  | TernaryTerminal
+  | OptionalTerminal
+  | LabelTerminal
+  | SequenceTerminal
+  | MaybeThrowTerminal
+  | TryTerminal
+  | ReactiveScopeTerminal
+  | PrunedScopeTerminal;
+
+declare type TernaryTerminal = {
+  kind: "ternary";
+  test: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type ThrowTerminal = {
+  kind: "throw";
+  value: Place;
+  id: InstructionId;
+  loc: SourceLocation;
+  fallthrough?: never;
+};
+
+declare type TimingEvent = {
+  kind: "Timing";
+  measurement: PerformanceMeasure;
+};
+
+declare interface TrackedPackage {
+  deprecatedBelow: string | null;
+  name: string;
+  supported: string[];
+}
+
+declare type TryTerminal = {
+  kind: "try";
+  block: BlockId;
+  handlerBinding: Place | null;
+  handler: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+  loc: SourceLocation;
+};
+
+declare type Type =
+  | BuiltInType
+  | PhiType
+  | TypeVar
+  | PolyType
+  | PropType
+  | ObjectMethod$1;
+
+declare type TypeId = number & {
+  [opaqueTypeId]: "IdentifierId";
+};
+
+declare type TypeParameter<T> = {
+  name: string;
+  id: TypeParameterId;
+  bound: T;
+};
+
+declare type TypeParameterId = number & {
+  [opaqueTypeParameterId]: "TypeParameterId";
+};
+
+declare type TypeVar = {
+  kind: "Type";
+  id: TypeId;
+};
+
+declare type UnreachableTerminal = {
+  kind: "unreachable";
+  id: InstructionId;
+  loc: SourceLocation;
+  fallthrough?: never;
+};
+
+declare type UnsupportedTerminal = {
+  kind: "unsupported";
+  id: InstructionId;
+  loc: SourceLocation;
+  fallthrough?: never;
+};
+
+declare type ValidatedIdentifier = {
+  kind: "named";
+  value: ValidIdentifierName;
+};
+
+declare type ValidIdentifierName = string & {
+  [opaqueValidIdentifierName]: "ValidIdentifierName";
+};
+
+declare enum ValueKind {
+  MaybeFrozen = "maybefrozen",
+  Frozen = "frozen",
+  Primitive = "primitive",
+  Global = "global",
+  Mutable = "mutable",
+  Context = "context",
+}
+
+declare enum ValueReason {
+  Global = "global",
+  JsxCaptured = "jsx-captured",
+  HookCaptured = "hook-captured",
+  HookReturn = "hook-return",
+  Effect = "effect",
+  KnownReturnSignature = "known-return-signature",
+  Context = "context",
+  State = "state",
+  ReducerState = "reducer-state",
+  ReactiveFunctionArgument = "reactive-function-argument",
+  Other = "other",
+}
+
+declare interface VendorBuildOptions {
+  basePath: string;
+  cwd: string;
+  isApp: boolean;
+  outputDir: string;
+}
+
+declare interface ViteOptions {
+  /**
+   * Root path of the studio/sanity app
+   */
+  cwd: string;
+  /**
+   * Returns the environment variables to be injected into the config.
+   */
+  getEnvironmentVariables(): Record<string, string>;
+  /**
+   * Mode to run vite in - eg development or production
+   */
+  mode: "development" | "production";
+  reactCompiler: PluginOptions | undefined;
+  /**
+   * Additional plugins when configured, eg. typegen
+   */
+  additionalPlugins?: Plugin_2[];
+  /**
+   * CSS URLs for auto-updated packages (loaded via module server)
+   */
+  autoUpdatesCssUrls?: string[];
+  /**
+   * Base path (eg under where to serve the app - `/studio` or similar)
+   * Will be normalized to ensure it starts and ends with a `/`
+   */
+  basePath?: string;
+  importMap?: {
+    imports?: Record<string, string>;
+  };
+  isApp?: boolean;
+  /**
+   * Whether or not to minify the output (only used in `mode: 'production'`)
+   */
+  minify?: boolean;
+  /**
+   * Output directory (eg where to place the built files, if any)
+   */
+  outputDir?: string;
+  /**
+   * Schema extraction configuration
+   */
+  schemaExtraction?: CliConfig["schemaExtraction"];
+  /**
+   * HTTP development server configuration
+   */
+  server?: {
+    host?: string;
+    port?: number;
+  };
+  /**
+   * Whether or not to enable source maps
+   */
+  sourceMap?: boolean;
+}
+
+declare type WhileTerminal = {
+  kind: "while";
+  loc: SourceLocation;
+  test: BlockId;
+  loop: BlockId;
+  fallthrough: BlockId;
+  id: InstructionId;
+};
+
+/**
+ * @internal
+ */
+export declare function writeFavicons(
+  basePath: string,
+  destDir: string,
+): Promise<void>;
+
+/**
+ * Generates the `.sanity/runtime` directory, and optionally watches for custom
+ * document files, rebuilding when they change
+ *
+ * @param options - Current working directory (Sanity root dir), and whether or not to watch
+ * @returns A watcher instance if watch is enabled, undefined otherwise
+ * @internal
+ */
+export declare function writeSanityRuntime(
+  options: RuntimeOptions,
+): Promise<FSWatcher | undefined>;
+
+export {};