@sanity/assist 2.0.5 → 3.0.1

package/dist/index.mjs

@@ -0,0 +1,4158 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { SyncIcon, DocumentIcon, LinkIcon, ImageIcon, BlockContentIcon, OlistIcon, BlockquoteIcon, StringIcon, ArrowLeftIcon, PlayIcon, SparklesIcon, SearchIcon, ErrorOutlineIcon, CheckmarkCircleIcon, CloseCircleIcon, ClockIcon, RetryIcon, ArrowRightIcon, CloseIcon, CheckmarkIcon, icons, TokenIcon, DocumentTextIcon, ThListIcon, CodeIcon, ComposeIcon, LockIcon, TranslateIcon, ControlsIcon } from "@sanity/icons";
+import { Card, Stack, Box, Button, Spinner, Flex, Label, focusFirstDescendant, Text, useToast, Dialog, Tooltip, TextArea, Container, Autocomplete, Breadcrumbs, useClickOutside, Popover, useLayer, useGlobalKeyDown, Badge, useTheme, rgba, Checkbox, Radio, ThemeProvider, ErrorBoundary, MenuButton, Menu, MenuItem, Switch } from "@sanity/ui";
+import { useState, useRef, useEffect, useMemo, useCallback, createContext, useContext, useId, createElement, useReducer, forwardRef } from "react";
+import { useClient, isArraySchemaType, typed, useSchema, isKeySegment, isDocumentSchemaType, pathToString, useDocumentStore, useDocumentPresence, createPatchChannel, FormBuilder, fromMutationPatches, isObjectSchemaType, stringToPath, useCurrentUser, set, useFormCallbacks, FormCallbacksProvider, FormInput, PatchEvent, setIfMissing, insert, useEditState, FormFieldHeaderText, unset, StatusButton, PresenceOverlay, VirtualizerScrollInstanceProvider, useColorSchemeValue, ObjectInputMember, isArrayOfObjectsSchemaType, defineType, defineField, defineArrayMember, getPublishedId, useSyncState, definePlugin } from "sanity";
+import isEqual from "react-fast-compare";
+import { mergeMap, share, take, filter, distinctUntilChanged, catchError, tap } from "rxjs/operators";
+import { throwError, of, partition, merge, switchMap, delay, defer } from "rxjs";
+import { exhaustMapToWithTrailing } from "rxjs-exhaustmap-with-trailing";
+import { extractWithPath } from "@sanity/mutator";
+import { minutesToMilliseconds, formatDistanceToNow, isAfter, addSeconds } from "date-fns";
+import { useDocumentPane, usePaneRouter, DocumentInspectorHeader, DocumentPaneProvider } from "sanity/structure";
+import { styled, keyframes } from "styled-components";
+import get from "lodash/get.js";
+const fetch = (client, query, params, options2) => defer(
+  () => (
+    // getVersionedClient(options.apiVersion)
+    client.observable.fetch(query, params, {
+      tag: options2.tag,
+      filterResponse: !0
+    })
+  )
+), listen = (client, query, params, options2) => defer(
+  () => (
+    // getVersionedClient(options.apiVersion)
+    client.listen(query, params, {
+      events: ["welcome", "mutation", "reconnect"],
+      includeResult: !1,
+      visibility: "query",
+      tag: options2.tag
+    })
+  )
+);
+function isWelcomeEvent(event) {
+  return event.type === "welcome";
+}
+const listenQuery = (client, query, params = {}, options2 = {}) => {
+  const fetchQuery = typeof query == "string" ? query : query.fetch, listenerQuery = typeof query == "string" ? query : query.listen, fetchOnce$ = fetch(client, fetchQuery, params, options2), events$ = listen(client, listenerQuery, params, options2).pipe(
+    mergeMap((ev, i) => i === 0 && !isWelcomeEvent(ev) ? throwError(
+      new Error(
+        ev.type === "reconnect" ? "Could not establish EventSource connection" : `Received unexpected type of first event "${ev.type}"`
+      )
+    ) : of(ev)),
+    share()
+  ), [welcome$, mutationAndReconnect$] = partition(events$, isWelcomeEvent), isRelevantEvent = (event) => !options2.transitions || event.type !== "mutation" ? !0 : options2.transitions.includes(event.transition);
+  return merge(
+    welcome$.pipe(take(1)),
+    mutationAndReconnect$.pipe(
+      filter(isRelevantEvent),
+      switchMap((event) => merge(of(event), of(event).pipe(delay(options2.throttleTime || 1e3))))
+    )
+  ).pipe(exhaustMapToWithTrailing(fetchOnce$));
+}, DEFAULT_PARAMS = {}, DEFAULT_OPTIONS = { apiVersion: "v2022-05-09" };
+function useListeningQuery(query, params = DEFAULT_PARAMS, options2 = DEFAULT_OPTIONS) {
+  const [loading, setLoading] = useState(!0), [error, setError] = useState(!1), [data, setData] = useState(null), subscription = useRef(null), client = useClient({ apiVersion: "v2022-05-09" });
+  return useEffect(() => (query && (subscription.current = listenQuery(client, query, params, options2).pipe(
+    distinctUntilChanged(isEqual),
+    catchError((err) => (console.error(err), setError(err), setLoading(!1), setData(null), err))
+  ).subscribe((documents) => {
+    setData((current) => isEqual(current, documents) ? current : documents), setLoading(!1), setError(!1);
+  })), () => subscription.current ? subscription.current.unsubscribe() : void 0), [query, params, options2, client]), { loading, error, data };
+}
+const assistDocumentIdPrefix = "sanity.assist.schemaType.", assistDocumentStatusIdPrefix = "sanity.assist.status.", assistSchemaIdPrefix = "sanity.assist.schema.", assistDocumentTypeName = "sanity.assist.schemaType.annotations", assistFieldTypeName = "sanity.assist.schemaType.field", instructionTypeName = "sanity.assist.instruction", promptTypeName = "sanity.assist.instruction.prompt", userInputTypeName = "sanity.assist.instruction.userInput", instructionContextTypeName = "sanity.assist.instruction.context", fieldReferenceTypeName = "sanity.assist.instruction.fieldRef", contextDocumentTypeName = "assist.instruction.context", assistTasksStatusTypeName = "sanity.assist.task.status", instructionTaskTypeName = "sanity.assist.instructionTask", fieldPresenceTypeName = "sanity.assist.instructionTask.presence", assistSerializedTypeName = "sanity.assist.serialized.type", assistSerializedFieldTypeName = "sanity.assist.serialized.field", outputFieldTypeName = "sanity.assist.output.field", outputTypeTypeName = "sanity.assist.output.type", fieldPathParam = "pathKey", instructionParam = "instruction", documentRootKey = "<document>";
+function isPortableTextArray(type) {
+  return type.of.find((t) => isType(t, "block"));
+}
+function isType(schemaType, typeName) {
+  return schemaType.name === typeName ? !0 : schemaType.type ? isType(schemaType.type, typeName) : !1;
+}
+function isImage(schemaType) {
+  return isType(schemaType, "image");
+}
+function getDescriptionFieldOption(schemaType) {
+  var _a, _b;
+  return schemaType ? ((_b = (_a = schemaType.options) == null ? void 0 : _a.aiAssist) == null ? void 0 : _b.imageDescriptionField) || getDescriptionFieldOption(schemaType.type) : void 0;
+}
+function getImageInstructionFieldOption(schemaType) {
+  var _a, _b;
+  return schemaType ? ((_b = (_a = schemaType.options) == null ? void 0 : _a.aiAssist) == null ? void 0 : _b.imageInstructionField) || getImageInstructionFieldOption(schemaType.type) : void 0;
+}
+function isSchemaAssistEnabled(type) {
+  var _a, _b;
+  return !((_b = (_a = type.options) == null ? void 0 : _a.aiAssist) != null && _b.exclude);
+}
+function isAssistSupported(type) {
+  return !isSchemaAssistEnabled(type) || isDisabled(type) ? !1 : type.jsonType === "array" ? !type.of.every((t) => isDisabled(t)) : type.jsonType === "object" ? !type.fields.every((field) => isDisabled(field.type)) : !0;
+}
+function isDisabled(type) {
+  return !isSchemaAssistEnabled(type) || isUnsupportedType(type);
+}
+function isUnsupportedType(type) {
+  var _a, _b;
+  return type.jsonType === "number" || type.name === "sanity.imageCrop" || type.name === "sanity.imageHotspot" || isType(type, "reference") && !((_b = (_a = type == null ? void 0 : type.options) == null ? void 0 : _a.aiAssist) != null && _b.embeddingsIndex) || isType(type, "crossDatasetReference") || isType(type, "slug") || isType(type, "url") || isType(type, "date") || isType(type, "datetime") || isType(type, "file");
+}
+const hiddenTypes = [
+  "any",
+  "array",
+  "block",
+  "boolean",
+  "crossDatasetReference",
+  "date",
+  "datetime",
+  "document",
+  "email",
+  "file",
+  "image",
+  "number",
+  "object",
+  "reference",
+  "span",
+  "string",
+  "text",
+  "url",
+  "slug",
+  "geopoint",
+  "sanity.assetSourceData",
+  "sanity.imageAsset",
+  "sanity.fileAsset",
+  "sanity.imageCrop",
+  "sanity.imageHotspot",
+  "sanity.imageMetadata",
+  "sanity.imageDimensions",
+  "sanity.imagePalette",
+  "sanity.imagePaletteSwatch",
+  assistSerializedTypeName,
+  assistSerializedFieldTypeName,
+  "sanity-agent.job.document"
+], inlineTypes = ["document", "object", "image", "file"];
+function serializeSchema(schema, options2) {
+  const list = schema.getTypeNames().filter((t) => !(hiddenTypes.includes(t) || t.startsWith("sanity."))).map((t) => schema.get(t)).filter((t) => !!t).map((t) => getSchemaStub(t, schema, options2)).filter((t) => !("to" in t && t.to && !t.to.length || "of" in t && t.of && !t.of.length || "fields" in t && t.fields && !t.fields.length));
+  return list.sort((a, b) => {
+    var _a, _b;
+    return ((_a = a == null ? void 0 : a.name) != null ? _a : "").localeCompare((_b = b == null ? void 0 : b.name) != null ? _b : "");
+  }), list;
+}
+function getSchemaStub(schemaType, schema, options2) {
+  var _a;
+  if (!((_a = schemaType.type) != null && _a.name))
+    throw console.error("Missing type name", schemaType.type), new Error("Type is missing name!");
+  const baseSchema = {
+    // we dont need type or id when we send using POST, so leave these out to save bandwidth
+    ...options2 != null && options2.leanFormat ? {} : { _id: `${assistSchemaIdPrefix}${schemaType.name}`, _type: assistSerializedTypeName },
+    name: schemaType.name,
+    title: schemaType.title,
+    type: schemaType.type.name,
+    ...getBaseFields(schema, schemaType, schemaType.type.name, options2)
+  };
+  return removeUndef(baseSchema);
+}
+function getBaseFields(schema, type, typeName, options2) {
+  var _a, _b, _c, _d, _e, _f;
+  const schemaOptions = removeUndef({
+    imagePromptField: (_b = (_a = type.options) == null ? void 0 : _a.aiAssist) == null ? void 0 : _b.imageInstructionField,
+    embeddingsIndex: (_d = (_c = type.options) == null ? void 0 : _c.aiAssist) == null ? void 0 : _d.embeddingsIndex
+  });
+  return removeUndef({
+    options: Object.keys(schemaOptions).length ? schemaOptions : void 0,
+    values: Array.isArray((_e = type == null ? void 0 : type.options) == null ? void 0 : _e.list) ? (_f = type == null ? void 0 : type.options) == null ? void 0 : _f.list.map(
+      (v) => {
+        var _a2;
+        return typeof v == "string" ? v : (_a2 = v.value) != null ? _a2 : `${v.title}`;
+      }
+    ) : void 0,
+    of: "of" in type && typeName === "array" ? arrayOf(type, schema, options2) : void 0,
+    to: "to" in type && typeName === "reference" ? refToTypeNames(type) : void 0,
+    fields: "fields" in type && inlineTypes.includes(typeName) ? serializeFields(schema, type, options2) : void 0,
+    annotations: typeName === "block" && "fields" in type ? serializeAnnotations(type, schema, options2) : void 0,
+    inlineOf: typeName === "block" && "fields" in type ? serializeInlineOf(type, schema, options2) : void 0,
+    hidden: typeof type.hidden == "function" ? "function" : type.hidden ? !0 : void 0,
+    readOnly: typeof type.readOnly == "function" ? "function" : type.readOnly ? !0 : void 0
+  });
+}
+function serializeFields(schema, schemaType, options2) {
+  return (schemaType.fieldsets ? schemaType.fieldsets.flatMap(
+    (fs) => fs.single ? fs.field : fs.fields.map((f) => ({
+      ...f,
+      type: {
+        ...f.type,
+        // if fieldset is (conditionally) hidden, the field must be considered the same way
+        // ie, if the field does not show up in conditionalMembers, it is hidden
+        // regardless of weather or not it is the field function or the fieldset function that hides it
+        hidden: typeof fs.hidden == "function" ? fs.hidden : fs.hidden ? !0 : f.type.hidden
+      }
+    }))
+  ) : schemaType.fields).filter((f) => {
+    var _a, _b;
+    return !["sanity.imageHotspot", "sanity.imageCrop"].includes((_b = (_a = f.type) == null ? void 0 : _a.name) != null ? _b : "");
+  }).filter((f) => isAssistSupported(f.type)).map((field) => serializeMember(schema, field.type, field.name, options2));
+}
+function serializeMember(schema, type, name, options2) {
+  var _a, _b;
+  const typeName = schema.get(type == null ? void 0 : type.name) ? type.name : (_b = (_a = type.type) == null ? void 0 : _a.name) != null ? _b : "";
+  return removeUndef({
+    ...options2 != null && options2.leanFormat ? {} : { _type: assistSerializedFieldTypeName },
+    name,
+    type: typeName,
+    title: type.title,
+    ...getBaseFields(schema, type, typeName, options2)
+  });
+}
+function serializeInlineOf(blockSchemaType, schema, options2) {
+  const childrenField = blockSchemaType.fields.find((f) => f.name === "children"), childrenType = childrenField == null ? void 0 : childrenField.type;
+  if (!(!childrenType || !isArraySchemaType(childrenType)))
+    return arrayOf(
+      {
+        ...childrenType,
+        of: childrenType.of.filter((t) => !isType(t, "span"))
+      },
+      schema,
+      options2
+    );
+}
+function serializeAnnotations(blockSchemaType, schema, options2) {
+  const markDefs = blockSchemaType.fields.find((f) => f.name === "markDefs"), marksType = markDefs == null ? void 0 : markDefs.type;
+  if (!(!marksType || !isArraySchemaType(marksType)))
+    return arrayOf(marksType, schema, options2);
+}
+function arrayOf(arrayType, schema, options2) {
+  return arrayType.of.filter((type) => isAssistSupported(type)).map((t) => serializeMember(schema, t, t.name, options2));
+}
+function refToTypeNames(type) {
+  return type.to.map((t) => ({
+    type: typed(t.name)
+  }));
+}
+function removeUndef(obj) {
+  return Object.keys(obj).forEach((key) => obj[key] === void 0 ? delete obj[key] : {}), obj;
+}
+const NO_DATA = [], defaultTitle = "Sync schema";
+function SchemaTypeTool() {
+  const schema = useSchema(), client = useClient({ apiVersion: "2023-01-01" }), [saving, setSaving] = useState(!1), [syncTitle, setSyncTitle] = useState(defaultTitle), { data } = useListeningQuery("*[_type==$type] | order(_type)", {
+    type: assistSerializedTypeName
+  }), types = useMemo(() => serializeSchema(schema), [schema]), storeTypes = useCallback(() => {
+    setSaving(!0);
+    let canSave = !0;
+    async function store() {
+      setSyncTitle(`Syncing 0/${types.length}`);
+      const transaction = client.transaction();
+      for (let i = 0; i < types.length && canSave; i++) {
+        const type = types[i];
+        await transaction.createOrReplace(type), i > 0 && i % 50 === 0 && (await transaction.commit(), transaction.reset(), setSyncTitle(`Syncing ${i}/${types.length}`));
+      }
+      await transaction.commit();
+    }
+    return store().catch(console.error).finally(() => {
+      setSaving(!1), setSyncTitle(defaultTitle);
+    }), () => {
+      canSave = !1, setSaving(!1), setSyncTitle(defaultTitle);
+    };
+  }, [types, client, setSaving, setSyncTitle]);
+  return /* @__PURE__ */ jsx(Card, { padding: 4, overflow: "auto", style: { height: "calc(100vh - 81px)" }, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        icon: saving ? /* @__PURE__ */ jsx(Spinner, { style: { marginTop: 5 } }) : SyncIcon,
+        text: syncTitle,
+        disabled: saving,
+        onClick: storeTypes
+      }
+    ) }),
+    /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+      /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+        /* @__PURE__ */ jsx(Label, { children: "Studio schema" }),
+        /* @__PURE__ */ jsx("ul", { children: types.map((type) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(SchemaEntry, { schemaStub: type }) }, type.name)) })
+      ] }),
+      /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+        /* @__PURE__ */ jsx(Label, { children: "Stored schema" }),
+        /* @__PURE__ */ jsx("ul", { children: (data != null ? data : NO_DATA).map((type) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(SchemaEntry, { schemaStub: type }) }, type.name)) })
+      ] })
+    ] })
+  ] }) });
+}
+function SchemaEntry({ schemaStub }) {
+  const out = useMemo(() => JSON.stringify(schemaStub, null, 2), [schemaStub]);
+  return /* @__PURE__ */ jsx("pre", { children: out });
+}
+const MAX_DEPTH$1 = 6;
+function getDocumentMembersFlat(doc, schemaType) {
+  return isDocumentSchemaType(schemaType) ? extractPaths(doc, schemaType, [], MAX_DEPTH$1) : (console.error("Schema type is not a document"), []);
+}
+function extractPaths(doc, schemaType, path, maxDepth2) {
+  return path.length >= maxDepth2 ? [] : schemaType.fields.reduce((acc, field) => {
+    var _a, _b;
+    const fieldPath = [...path, field.name], fieldSchema = field.type, { value } = (_a = extractWithPath(pathToString(fieldPath), doc)[0]) != null ? _a : {};
+    if (!value)
+      return acc;
+    const thisFieldWithPath = {
+      path: fieldPath,
+      name: field.name,
+      schemaType: fieldSchema,
+      value
+    };
+    if (fieldSchema.jsonType === "object") {
+      const innerFields = extractPaths(doc, fieldSchema, fieldPath, maxDepth2);
+      return [...acc, thisFieldWithPath, ...innerFields];
+    } else if (fieldSchema.jsonType === "array" && fieldSchema.of.length && fieldSchema.of.some((item) => "fields" in item)) {
+      const { value: arrayValue } = (_b = extractWithPath(pathToString(fieldPath), doc)[0]) != null ? _b : {};
+      let arrayPaths = [];
+      if (arrayValue != null && arrayValue.length)
+        for (const item of arrayValue) {
+          const itemPath = [...fieldPath, { _key: item._key }];
+          let itemSchema = fieldSchema.of.find((t) => t.name === item._type);
+          if (item._type || (itemSchema = fieldSchema.of[0], console.warn(
+            "Array item is missing _type - using the first defined type in the array.of schema",
+            {
+              itemPath,
+              item,
+              itemSchema
+            }
+          )), item._key && itemSchema) {
+            const innerFields = extractPaths(
+              doc,
+              itemSchema,
+              itemPath,
+              maxDepth2
+            ), arrayMember = {
+              path: itemPath,
+              name: item._key,
+              schemaType: itemSchema,
+              value: item
+            };
+            arrayPaths = [...arrayPaths, arrayMember, ...innerFields];
+          }
+        }
+      return [...acc, thisFieldWithPath, ...arrayPaths];
+    }
+    return [...acc, thisFieldWithPath];
+  }, []);
+}
+const defaultLanguageOutputs = function(member, enclosingType, translateFromLanguageId, translateToLanguageIds) {
+  if (member.schemaType.jsonType === "object" && member.schemaType.name.startsWith("internationalizedArray")) {
+    const pathEnd = member.path.slice(-1);
+    return (isKeySegment(pathEnd[0]) ? pathEnd[0]._key : null) === translateFromLanguageId ? translateToLanguageIds.map((translateToId) => ({
+      id: translateToId,
+      outputPath: [...member.path.slice(0, -1), { _key: translateToId }]
+    })) : void 0;
+  }
+  if (enclosingType.jsonType === "object" && enclosingType.name.startsWith("locale"))
+    return translateFromLanguageId === member.name ? translateToLanguageIds.map((translateToId) => ({
+      id: translateToId,
+      outputPath: [...member.path.slice(0, -1), translateToId]
+    })) : void 0;
+};
+function getFieldLanguageMap(documentSchema, documentMembers, translateFromLanguageId, outputLanguageIds, langFn) {
+  var _a, _b, _c;
+  const translationMaps = [];
+  for (const member of documentMembers) {
+    const parentPath = member.path.slice(0, -1), enclosingType = (_b = (_a = documentMembers.find((m) => pathToString(m.path) === pathToString(parentPath))) == null ? void 0 : _a.schemaType) != null ? _b : documentSchema, translations = (_c = langFn(
+      member,
+      enclosingType,
+      translateFromLanguageId,
+      outputLanguageIds
+    )) == null ? void 0 : _c.filter((translation) => translation.id !== translateFromLanguageId);
+    translations && translationMaps.push({
+      inputLanguageId: translateFromLanguageId,
+      inputPath: member.path,
+      outputs: translations
+    });
+  }
+  return translationMaps;
+}
+const releaseAnnouncementUrl = "https://www.sanity.io/blog/sanity-ai-assist-announcement?utm_source=sanity-assist-plugin&utm_medium=organic_social&utm_campaign=ai-assist&utm_content=", instructionGuideUrl = "https://sanity.io/guides/getting-started-with-ai-assist-instructions?utm_source=sanity-assist-plugin&utm_medium=organic_social&utm_campaign=ai-assist&utm_content=", giveFeedbackUrl = "https://forms.gle/Kwz7CThxGeA2GiEU8", salesUrl = "https://www.sanity.io/contact/sales?utm_source=sanity-assist-plugin&utm_medium=organic_social&utm_campaign=ai-assist&utm_content=", packageName = "@sanity/assist", pluginTitle = "Sanity AI Assist", pluginTitleShort = "AI Assist", maxHistoryVisibilityMs = minutesToMilliseconds(30), assistFormId = "assist", preventDefault = (ev) => ev.preventDefault();
+function DocumentForm(props) {
+  var _a;
+  const {
+    collapsedFieldSets,
+    collapsedPaths,
+    displayed: value,
+    documentId,
+    documentType,
+    editState,
+    formState,
+    onBlur,
+    onChange,
+    onFocus,
+    onPathOpen,
+    onSetActiveFieldGroup,
+    onSetCollapsedFieldSet,
+    onSetCollapsedPath,
+    ready,
+    validation
+  } = useDocumentPane(), documentStore = useDocumentStore(), presence = useDocumentPresence(documentId), patchChannel = useMemo(() => createPatchChannel(), []), isLocked = (_a = editState == null ? void 0 : editState.transactionSyncLock) == null ? void 0 : _a.enabled;
+  useEffect(() => {
+    const sub = documentStore.pair.documentEvents(documentId, documentType).pipe(
+      tap((event) => {
+        event.type === "mutation" && patchChannel.publish(prepareMutationEvent(event)), event.type === "rebase" && patchChannel.publish(prepareRebaseEvent(event));
+      })
+    ).subscribe();
+    return () => {
+      sub.unsubscribe();
+    };
+  }, [documentId, documentStore, documentType, patchChannel]);
+  const hasRev = !!(value != null && value._rev);
+  useEffect(() => {
+    hasRev && patchChannel.publish({
+      type: "mutation",
+      patches: [],
+      snapshot: value
+    });
+  }, [hasRev]);
+  const formRef = useRef(null);
+  return useEffect(() => {
+    focusFirstDescendant(formRef.current);
+  }, []), isLocked ? /* @__PURE__ */ jsx(Box, { as: "form", ...props, ref: formRef, children: /* @__PURE__ */ jsx(
+    Flex,
+    {
+      align: "center",
+      direction: "column",
+      height: "fill",
+      justify: "center",
+      padding: 3,
+      sizing: "border",
+      children: /* @__PURE__ */ jsx(Text, { size: 1, children: "Please hold tight while the document is synced. This usually happens right after the document has been published, and it shouldn\u2019t take more than a few seconds" })
+    }
+  ) }) : /* @__PURE__ */ jsx(Box, { as: "form", ...props, onSubmit: preventDefault, ref: formRef, children: ready ? formState === null ? /* @__PURE__ */ jsx(
+    Flex,
+    {
+      align: "center",
+      direction: "column",
+      height: "fill",
+      justify: "center",
+      padding: 3,
+      sizing: "border",
+      children: /* @__PURE__ */ jsx(Text, { size: 1, children: "This form is hidden" })
+    }
+  ) : /* @__PURE__ */ jsx(
+    FormBuilder,
+    {
+      __internal_patchChannel: patchChannel,
+      collapsedFieldSets,
+      collapsedPaths,
+      focusPath: formState.focusPath,
+      changed: formState.changed,
+      focused: formState.focused,
+      groups: formState.groups,
+      id: assistFormId,
+      members: formState.members,
+      onChange,
+      onFieldGroupSelect: onSetActiveFieldGroup,
+      onPathBlur: onBlur,
+      onPathFocus: onFocus,
+      onPathOpen,
+      onSetFieldSetCollapsed: onSetCollapsedFieldSet,
+      onSetPathCollapsed: onSetCollapsedPath,
+      presence,
+      readOnly: formState.readOnly,
+      schemaType: formState.schemaType,
+      validation,
+      value: formState.value
+    }
+  ) : /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      align: "center",
+      direction: "column",
+      height: "fill",
+      justify: "center",
+      padding: 3,
+      sizing: "border",
+      children: [
+        /* @__PURE__ */ jsx(Spinner, { muted: !0 }),
+        /* @__PURE__ */ jsx(Box, { marginTop: 3, children: /* @__PURE__ */ jsx(Text, { align: "center", muted: !0, size: 1, children: "Loading document" }) })
+      ]
+    }
+  ) });
+}
+function prepareMutationEvent(event) {
+  const patches = event.mutations.map((mut) => mut.patch).filter(Boolean);
+  return {
+    type: "mutation",
+    snapshot: event.document,
+    patches: fromMutationPatches(event.origin, patches)
+  };
+}
+function prepareRebaseEvent(event) {
+  const remotePatches = event.remoteMutations.map((mut) => mut.patch).filter(Boolean), localPatches = event.localMutations.map((mut) => mut.patch).filter(Boolean);
+  return {
+    type: "rebase",
+    snapshot: event.document,
+    patches: fromMutationPatches("remote", remotePatches).concat(
+      fromMutationPatches("local", localPatches)
+    )
+  };
+}
+const SelectedFieldContext = createContext(void 0), SelectedFieldContextProvider = SelectedFieldContext.Provider, maxDepth = 6;
+function getTypeIcon(schemaType) {
+  let t = schemaType;
+  for (; t; ) {
+    if (t.icon)
+      return t.icon;
+    t = t.type;
+  }
+  return isType(schemaType, "slug") ? LinkIcon : isType(schemaType, "image") ? ImageIcon : schemaType.jsonType === "array" && isPortableTextArray(schemaType) ? BlockContentIcon : schemaType.jsonType === "array" ? OlistIcon : schemaType.jsonType === "object" ? BlockquoteIcon : schemaType.jsonType === "string" ? StringIcon : DocumentIcon;
+}
+function getFieldRefsWithDocument(schemaType) {
+  var _a;
+  const fields = getFieldRefs(schemaType);
+  return [
+    {
+      key: documentRootKey,
+      icon: (_a = schemaType.icon) != null ? _a : DocumentIcon,
+      title: "The entire document",
+      path: [],
+      schemaType
+    },
+    ...fields
+  ];
+}
+function getFieldRefs(schemaType, parent, depth = 0) {
+  return depth >= maxDepth ? [] : schemaType.fields.filter((f) => !f.name.startsWith("_")).flatMap((field) => {
+    var _a;
+    const path = parent ? [...parent.path, field.name] : [field.name], title = (_a = field.type.title) != null ? _a : field.name, fieldRef = {
+      key: patchableKey(pathToString(path)),
+      path,
+      title: parent ? [parent.title, title].join(" / ") : title,
+      schemaType: field.type,
+      icon: getTypeIcon(field.type)
+    }, fields = field.type.jsonType === "object" ? getFieldRefs(field.type, fieldRef, depth + 1) : [], syntheticFields = field.type.jsonType === "array" ? getSyntheticFields(field.type, fieldRef, depth + 1) : [];
+    return isAssistSupported(field.type) ? [fieldRef, ...fields, ...syntheticFields] : [...fields, ...syntheticFields];
+  });
+}
+function getSyntheticFields(schemaType, parent, depth = 0) {
+  return depth >= maxDepth ? [] : schemaType.of.filter((itemType) => !isType(itemType, "block")).flatMap((itemType) => {
+    var _a;
+    const segment = { _key: itemType.name }, title = (_a = itemType.title) != null ? _a : itemType.name, path = parent ? [...parent.path, segment] : [segment], fieldRef = {
+      key: patchableKey(pathToString(path)),
+      path,
+      title: parent ? [parent.title, title].join(" / ") : title,
+      schemaType: itemType,
+      icon: getTypeIcon(itemType),
+      synthetic: !0
+    }, fields = itemType.jsonType === "object" ? getFieldRefs(itemType, fieldRef, depth + 1) : [];
+    return isAssistSupported(itemType) ? [fieldRef, ...fields] : fields;
+  });
+}
+function getTypePath(doc, pathString) {
+  if (!pathString)
+    return;
+  const path = stringToPath(pathString), currentPath = [];
+  let valid = !0;
+  const syntheticPath = path.map((segment) => {
+    if (currentPath.push(segment), isKeySegment(segment)) {
+      const match = extractWithPath(pathToString(currentPath), doc)[0], value = match == null ? void 0 : match.value;
+      if (match && value && typeof value == "object" && "_type" in value)
+        return { _key: value._type };
+      valid = !1;
+    }
+    return segment;
+  });
+  return valid ? patchableKey(pathToString(syntheticPath)) : void 0;
+}
+function patchableKey(pathKey) {
+  return pathKey.replace(/[=]=/g, ":").replace(/[[\]]/g, "|").replace(/"/g, "");
+}
+function useTypePath(doc, pathString) {
+  return useMemo(() => getTypePath(doc, pathString), [doc, pathString]);
+}
+function useSelectedField(documentSchemaType, path) {
+  const selectableFields = useMemo(
+    () => documentSchemaType && isObjectSchemaType(documentSchemaType) ? getFieldRefsWithDocument(documentSchemaType) : [],
+    [documentSchemaType]
+  );
+  return useMemo(() => path ? selectableFields == null ? void 0 : selectableFields.find((f) => f.key === path) : void 0, [selectableFields, path]);
+}
+function getFieldTitle(field) {
+  var _a, _b, _c;
+  const schemaType = field == null ? void 0 : field.schemaType;
+  return (_c = (_b = (_a = field == null ? void 0 : field.title) != null ? _a : schemaType == null ? void 0 : schemaType.title) != null ? _b : schemaType == null ? void 0 : schemaType.name) != null ? _c : "Untitled";
+}
+function useAiPaneRouter() {
+  const paneRouter = usePaneRouter();
+  return useMemo(
+    () => {
+      var _a;
+      return { ...paneRouter, params: (_a = paneRouter.params) != null ? _a : {} };
+    },
+    [paneRouter]
+  );
+}
+const basePath = "/assist/tasks/instruction";
+function canUseAssist(status) {
+  return (status == null ? void 0 : status.enabled) && status.initialized && status.validToken;
+}
+function useApiClient(customApiClient) {
+  const client = useClient({ apiVersion: "2023-06-05" });
+  return useMemo(
+    () => customApiClient ? customApiClient(client) : client,
+    [client, customApiClient]
+  );
+}
+function useTranslate(apiClient) {
+  const [loading, setLoading] = useState(!1), user = useCurrentUser(), schema = useSchema(), types = useMemo(() => serializeSchema(schema, { leanFormat: !0 }), [schema]), toast = useToast(), translate = useCallback(
+    ({
+      documentId,
+      languagePath,
+      translatePath,
+      fieldLanguageMap,
+      conditionalMembers
+    }) => (setLoading(!0), apiClient.request({
+      method: "POST",
+      url: `/assist/tasks/translate/${apiClient.config().dataset}?projectId=${apiClient.config().projectId}`,
+      body: {
+        documentId,
+        types,
+        languagePath,
+        fieldLanguageMap,
+        conditionalMembers,
+        translatePath: translatePath.length === 0 ? documentRootKey : pathToString(translatePath),
+        userId: user == null ? void 0 : user.id
+      }
+    }).catch((e) => {
+      throw toast.push({
+        status: "error",
+        title: "Translate failed",
+        description: e.message
+      }), setLoading(!1), e;
+    }).finally(() => {
+      setTimeout(() => {
+        setLoading(!1);
+      }, 2e3);
+    })),
+    [setLoading, apiClient, toast, user, types]
+  );
+  return useMemo(
+    () => ({
+      translate,
+      loading
+    }),
+    [translate, loading]
+  );
+}
+function useGenerateCaption(apiClient) {
+  const [loading, setLoading] = useState(!1), user = useCurrentUser(), schema = useSchema(), types = useMemo(() => serializeSchema(schema, { leanFormat: !0 }), [schema]), toast = useToast(), generateCaption = useCallback(
+    ({ path, documentId }) => (setLoading(!0), apiClient.request({
+      method: "POST",
+      url: `/assist/tasks/generate-caption/${apiClient.config().dataset}?projectId=${apiClient.config().projectId}`,
+      body: {
+        path,
+        documentId,
+        types,
+        userId: user == null ? void 0 : user.id
+      }
+    }).catch((e) => {
+      throw toast.push({
+        status: "error",
+        title: "Generate image description failed",
+        description: e.message
+      }), setLoading(!1), e;
+    }).finally(() => {
+      setTimeout(() => {
+        setLoading(!1);
+      }, 2e3);
+    })),
+    [setLoading, apiClient, toast, user, types]
+  );
+  return useMemo(
+    () => ({
+      generateCaption,
+      loading
+    }),
+    [generateCaption, loading]
+  );
+}
+function useGenerateImage(apiClient) {
+  const [loading, setLoading] = useState(!1), user = useCurrentUser(), schema = useSchema(), types = useMemo(() => serializeSchema(schema, { leanFormat: !0 }), [schema]), toast = useToast(), generateImage = useCallback(
+    ({ path, documentId }) => (setLoading(!0), apiClient.request({
+      method: "POST",
+      url: `/assist/tasks/generate-image/${apiClient.config().dataset}?projectId=${apiClient.config().projectId}`,
+      body: {
+        path,
+        documentId,
+        types,
+        userId: user == null ? void 0 : user.id
+      }
+    }).catch((e) => {
+      throw toast.push({
+        status: "error",
+        title: "Generate image from prompt failed",
+        description: e.message
+      }), setLoading(!1), e;
+    }).finally(() => {
+      setTimeout(() => {
+        setLoading(!1);
+      }, 2e3);
+    })),
+    [setLoading, apiClient, toast, user, types]
+  );
+  return useMemo(
+    () => ({
+      generateImage,
+      loading
+    }),
+    [generateImage, loading]
+  );
+}
+function useGetInstructStatus(apiClient) {
+  const [loading, setLoading] = useState(!0), getInstructStatus = useCallback(async () => {
+    setLoading(!0);
+    const projectId = apiClient.config().projectId;
+    try {
+      return await apiClient.request({
+        method: "GET",
+        url: `${basePath}/${apiClient.config().dataset}/status?projectId=${projectId}`
+      });
+    } finally {
+      setLoading(!1);
+    }
+  }, [setLoading, apiClient]);
+  return {
+    loading,
+    getInstructStatus
+  };
+}
+function useInitInstruct(apiClient) {
+  const [loading, setLoading] = useState(!1), initInstruct = useCallback(() => (setLoading(!0), apiClient.request({
+    method: "GET",
+    url: `${basePath}/${apiClient.config().dataset}/init?projectId=${apiClient.config().projectId}`
+  }).finally(() => {
+    setLoading(!1);
+  })), [setLoading, apiClient]);
+  return {
+    loading,
+    initInstruct
+  };
+}
+function useRunInstructionApi(apiClient) {
+  const toast = useToast(), [loading, setLoading] = useState(!1), user = useCurrentUser(), schema = useSchema(), types = useMemo(() => serializeSchema(schema, { leanFormat: !0 }), [schema]), runInstruction = useCallback(
+    (request) => (setLoading(!0), apiClient.request({
+      method: "POST",
+      url: `${basePath}/${apiClient.config().dataset}?projectId=${apiClient.config().projectId}`,
+      body: {
+        ...request,
+        types,
+        userId: user == null ? void 0 : user.id
+      }
+    }).catch((e) => {
+      throw toast.push({
+        status: "error",
+        title: "Instruction failed",
+        description: e.message
+      }), e;
+    }).finally(() => {
+      setLoading(!1);
+    })),
+    [apiClient, types, user, toast]
+  );
+  return useMemo(
+    () => ({
+      runInstruction,
+      loading
+    }),
+    [runInstruction, loading]
+  );
+}
+const AiAssistanceConfigContext = createContext({});
+function useAiAssistanceConfig() {
+  const context = useContext(AiAssistanceConfigContext);
+  if (!context)
+    throw new Error("Missing AiAssistanceConfigContext");
+  return context;
+}
+function AiAssistanceConfigProvider(props) {
+  var _a;
+  const [status, setStatus] = useState(), [error, setError] = useState(), apiClient = useApiClient((_a = props.config) == null ? void 0 : _a.__customApiClient), { getInstructStatus, loading: statusLoading } = useGetInstructStatus(apiClient), { initInstruct, loading: initLoading } = useInitInstruct(apiClient);
+  useEffect(() => {
+    getInstructStatus().then((s) => setStatus(s)).catch((e) => {
+      console.error(e), setError(e);
+    });
+  }, [getInstructStatus]);
+  const init = useCallback(async () => {
+    setError(void 0);
+    try {
+      await initInstruct();
+      const status2 = await getInstructStatus();
+      setStatus(status2);
+    } catch (e) {
+      console.error("Failed to init ai assistance", e), setError(e);
+    }
+  }, [initInstruct, getInstructStatus, setStatus]), { config, children } = props, context = useMemo(() => ({
+    config,
+    status,
+    statusLoading,
+    init,
+    initLoading,
+    error
+  }), [config, status, init, statusLoading, initLoading, error]);
+  return /* @__PURE__ */ jsx(AiAssistanceConfigContext.Provider, { value: context, children });
+}
+const aiDocPrefixPattern = new RegExp(`^${assistDocumentIdPrefix}`);
+function publicId(id) {
+  return id.replace("drafts.", "");
+}
+function assistDocumentId(documentType) {
+  return `${assistDocumentIdPrefix}${documentType}`;
+}
+function documentTypeFromAiDocumentId(id) {
+  return id.replace(aiDocPrefixPattern, "");
+}
+function assistTasksStatusId(documentId) {
+  return `${assistDocumentStatusIdPrefix}${publicId(documentId)}`;
+}
+const aiInspectorId = "ai-assistance";
+function BackToInstructionListLink() {
+  const { openInspector } = useDocumentPane(), goBack = useCallback(
+    () => openInspector(aiInspectorId, { [instructionParam]: void 0 }),
+    [openInspector]
+  );
+  return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+    Button,
+    {
+      as: "a",
+      fontSize: 1,
+      icon: ArrowLeftIcon,
+      mode: "bleed",
+      padding: 1,
+      space: 2,
+      onClick: goBack,
+      text: "  Instructions",
+      textAlign: "left"
+    }
+  ) });
+}
+const EMPTY_FIELDS = [], TypePathContext = createContext(void 0);
+function AssistDocumentForm(props) {
+  return props.readOnly ? /* @__PURE__ */ jsx(Card, { border: !0, tone: "caution", padding: 2, children: /* @__PURE__ */ jsx(Text, { size: 1, children: " You do not have sufficient permissions to manage instructions." }) }) : /* @__PURE__ */ jsx(AssistDocumentFormEditable, { ...props });
+}
+function AssistDocumentFormEditable(props) {
+  const { onChange } = props, value = props.value, id = value == null ? void 0 : value._id, fields = value == null ? void 0 : value.fields, targetDocumentType = useMemo(() => {
+    if (id)
+      return documentTypeFromAiDocumentId(id);
+  }, [id]), { params, setParams } = useAiPaneRouter(), pathKey = params[fieldPathParam], typePath = useContext(TypePathContext), instruction2 = params[instructionParam], activeKey = useMemo(() => {
+    var _a;
+    if (typePath)
+      return (_a = (fields != null ? fields : EMPTY_FIELDS).find((f) => f.path === typePath)) == null ? void 0 : _a._key;
+  }, [fields, typePath]), activePath = useMemo(() => {
+    if (!activeKey)
+      return;
+    const base = ["fields", { _key: activeKey }];
+    return instruction2 ? [...base, "instructions", { _key: instruction2 }] : base;
+  }, [activeKey, instruction2]), schema = useSchema(), documentSchema = useMemo(() => {
+    if (targetDocumentType)
+      return schema.get(targetDocumentType);
+  }, [schema, targetDocumentType]), fieldSchema = useSelectedSchema(pathKey, documentSchema), context = useMemo(
+    () => ({
+      documentSchema,
+      fieldSchema: fieldSchema != null ? fieldSchema : documentSchema
+    }),
+    [fieldSchema, documentSchema]
+  ), title = value == null ? void 0 : value.title;
+  useEffect(() => {
+    var _a;
+    !title && documentSchema && !(id != null && id.startsWith("drafts.")) && onChange(set((_a = documentSchema.title) != null ? _a : documentSchema.name, ["title"]));
+  }, [title, documentSchema, onChange, id]);
+  const { onPathOpen, ...formCallbacks } = useFormCallbacks(), newCallbacks = useMemo(
+    () => ({
+      ...formCallbacks,
+      onPathOpen: (path) => {
+        var _a;
+        !instruction2 && path.length === 4 && path[2] === "instructions" ? (setParams(
+          typed({
+            ...params,
+            [instructionParam]: (_a = path[3]) == null ? void 0 : _a._key
+          })
+        ), onPathOpen([])) : setTimeout(() => onPathOpen(path), 0);
+      }
+    }),
+    [formCallbacks, onPathOpen, params, setParams, instruction2]
+  );
+  return useEffect(() => {
+    activePath && !instruction2 && onPathOpen([]);
+  }, [activePath, instruction2, onPathOpen]), /* @__PURE__ */ jsx(SelectedFieldContextProvider, { value: context, children: /* @__PURE__ */ jsxs(Stack, { space: 5, children: [
+    /* @__PURE__ */ jsx(
+      FieldsInitializer,
+      {
+        pathKey: typePath,
+        activePath,
+        fields,
+        documentSchema,
+        onChange
+      },
+      typePath
+    ),
+    instruction2 && /* @__PURE__ */ jsx(BackToInstructionListLink, {}),
+    activePath && /* @__PURE__ */ jsx(FormCallbacksProvider, { ...newCallbacks, children: /* @__PURE__ */ jsx("div", { style: { lineHeight: "1.25em" }, children: /* @__PURE__ */ jsx(FormInput, { ...props, absolutePath: activePath }) }) }),
+    !activePath && props.renderDefault(props)
+  ] }) });
+}
+function useSelectedSchema(fieldPath, documentSchema) {
+  return useMemo(() => {
+    if (!fieldPath)
+      return;
+    if (fieldPath === documentRootKey)
+      return documentSchema;
+    const path = stringToPath(fieldPath);
+    let currentSchema = documentSchema;
+    for (let i = 0; i < path.length; i++) {
+      const segment = path[i], field = currentSchema == null ? void 0 : currentSchema.fields.find((f) => f.name === segment);
+      if (!field)
+        return;
+      if (i === path.length - 1)
+        return field.type;
+      if (field.type.jsonType !== "object")
+        return;
+      currentSchema = field.type;
+    }
+    return currentSchema;
+  }, [documentSchema, fieldPath]);
+}
+function FieldsInitializer({
+  pathKey,
+  activePath,
+  fields,
+  documentSchema,
+  onChange
+}) {
+  const {
+    config: { __presets: presets }
+  } = useAiAssistanceConfig(), existingField = fields == null ? void 0 : fields.find((f) => f._key === pathKey), documentPresets = !!(documentSchema != null && documentSchema.name) && (presets == null ? void 0 : presets[documentSchema == null ? void 0 : documentSchema.name]), missingPresetInstructions = useMemo(() => {
+    var _a, _b;
+    if (!documentPresets || !pathKey)
+      return;
+    const existingInstructions = existingField == null ? void 0 : existingField.instructions, presetField = (_a = documentPresets.fields) == null ? void 0 : _a.find((f) => f.path === pathKey);
+    return (_b = presetField == null ? void 0 : presetField.instructions) == null ? void 0 : _b.filter(
+      (i) => !(existingInstructions != null && existingInstructions.some((ei) => ei._key === i._key))
+    );
+  }, [documentPresets, pathKey, existingField]), initialized = useRef(!1);
+  return useEffect(() => {
+    var _a;
+    if (initialized.current || !pathKey || existingField && !(missingPresetInstructions != null && missingPresetInstructions.length))
+      return;
+    let event = PatchEvent.from([setIfMissing([], ["fields"])]);
+    existingField || (event = event.append(
+      insert(
+        [
+          typed({
+            _key: pathKey,
+            _type: assistFieldTypeName,
+            path: pathKey,
+            instructions: []
+          })
+        ],
+        "after",
+        ["fields", -1]
+      )
+    )), (_a = existingField == null ? void 0 : existingField.instructions) != null && _a.length || (event = event.append([setIfMissing([], ["fields", { _key: pathKey }, "instructions"])])), missingPresetInstructions != null && missingPresetInstructions.length && (event = event.append(
+      insert(
+        missingPresetInstructions.map(
+          (preset) => {
+            var _a2;
+            return {
+              ...preset,
+              _type: "sanity.assist.instruction",
+              prompt: (_a2 = preset.prompt) == null ? void 0 : _a2.map((p) => ({ markDefs: [], ...p }))
+            };
+          }
+        ),
+        "after",
+        ["fields", { _key: pathKey }, "instructions", -1]
+      )
+    )), onChange(event), initialized.current = !0;
+  }, [activePath, onChange, pathKey, existingField, missingPresetInstructions]), null;
+}
+function useDocumentState(id, docType) {
+  const state = useEditState(id, docType);
+  return state.draft || state.published;
+}
+function useStudioAssistDocument({
+  documentId,
+  schemaType,
+  initDoc
+}) {
+  const documentTypeName = schemaType.name, currentUser = useCurrentUser(), assistDocument = useDocumentState(
+    assistDocumentId(documentTypeName),
+    assistDocumentTypeName
+  ), assistTasksStatus = useDocumentState(
+    assistTasksStatusId(documentId != null ? documentId : ""),
+    assistTasksStatusTypeName
+  ), client = useClient({ apiVersion: "2023-01-01" });
+  return useEffect(() => {
+    !assistDocument && initDoc && client.createIfNotExists({
+      _id: assistDocumentId(documentTypeName),
+      _type: assistDocumentTypeName
+    }).catch(() => {
+    });
+  }, [client, assistDocument, documentTypeName, initDoc]), useMemo(() => {
+    var _a, _b;
+    if (!assistDocument)
+      return;
+    const tasks = (_a = assistTasksStatus == null ? void 0 : assistTasksStatus.tasks) != null ? _a : [], fields = ((_b = assistDocument == null ? void 0 : assistDocument.fields) != null ? _b : []).map((assistField) => {
+      var _a2;
+      return {
+        ...assistField,
+        tasks: tasks.filter((task) => task.path === assistField.path),
+        instructions: (_a2 = assistField.instructions) == null ? void 0 : _a2.filter((p) => !p.userId || p.userId === (currentUser == null ? void 0 : currentUser.id)).map((instruction2) => asStudioInstruction(instruction2, tasks))
+      };
+    });
+    return typed({
+      ...assistDocument,
+      tasks: tasks == null ? void 0 : tasks.map((task) => {
+        var _a2, _b2;
+        const instruction2 = (_b2 = (_a2 = fields.find((f) => f.path === task.path)) == null ? void 0 : _a2.instructions) == null ? void 0 : _b2.find((i) => i._key === task.instructionKey);
+        return {
+          ...task,
+          instruction: instruction2
+        };
+      }),
+      fields
+    });
+  }, [assistDocument, assistTasksStatus, currentUser]);
+}
+function asStudioInstruction(instruction2, run) {
+  return {
+    ...instruction2,
+    tasks: run.filter((task) => task.instructionKey === instruction2._key).filter(
+      (task) => task.started && (/* @__PURE__ */ new Date()).getTime() - new Date(task.started).getTime() < maxHistoryVisibilityMs
+    )
+  };
+}
+function usePathKey(path) {
+  return useMemo(() => getPathKey(path), [path]);
+}
+function getPathKey(path) {
+  return path.length ? Array.isArray(path) ? pathToString(path) : path : documentRootKey;
+}
+function getInstructionTitle(instruction2) {
+  var _a;
+  return (_a = instruction2 == null ? void 0 : instruction2.title) != null ? _a : "Untitled";
+}
+const NO_INPUT = {}, RunInstructionContext = createContext({
+  runInstruction: () => {
+  },
+  instructionLoading: !1
+});
+function useRunInstruction() {
+  return useContext(RunInstructionContext);
+}
+function isUserInputBlock(block) {
+  return block._type === userInputTypeName;
+}
+function RunInstructionProvider(props) {
+  var _a;
+  const { config } = useAiAssistanceConfig(), apiClient = useApiClient(config == null ? void 0 : config.__customApiClient), { runInstruction: runInstructionRequest, loading } = useRunInstructionApi(apiClient), id = useId(), [inputs, setInputs] = useState(NO_INPUT), [runRequest, setRunRequest] = useState(), runInstruction = useCallback(
+    (req) => {
+      var _a2;
+      if (loading)
+        return;
+      const { instruction: instruction2, ...request } = req, instructionKey = instruction2._key, userInputBlocks = (_a2 = instruction2 == null ? void 0 : instruction2.prompt) == null ? void 0 : _a2.flatMap(
+        (block) => block._type === "block" ? block.children.filter(isUserInputBlock) : [block]
+      ).filter(isUserInputBlock);
+      if (!(userInputBlocks != null && userInputBlocks.length)) {
+        runInstructionRequest({
+          ...request,
+          instructionKey,
+          userTexts: void 0
+        });
+        return;
+      }
+      setRunRequest({
+        ...req,
+        userInputBlocks
+      });
+    },
+    [runInstructionRequest, loading]
+  ), close = useCallback(() => {
+    setRunRequest(void 0), setInputs(NO_INPUT);
+  }, []), runWithInput = useCallback(() => {
+    if (runRequest) {
+      const { instruction: instruction2, userTexts, ...request } = runRequest;
+      runInstructionRequest({
+        ...request,
+        instructionKey: instruction2._key,
+        userTexts: Object.entries(inputs).map(([key, value]) => ({
+          blockKey: key,
+          userInput: value
+        }))
+      });
+    }
+    close();
+  }, [close, runInstructionRequest, runRequest, inputs]), open = !!runRequest, runDisabled = useMemo(
+    () => {
+      var _a2, _b;
+      return ((_b = (_a2 = runRequest == null ? void 0 : runRequest.userInputBlocks) == null ? void 0 : _a2.length) != null ? _b : 0) > Object.entries(inputs).filter(([, value]) => !!value).length;
+    },
+    [runRequest == null ? void 0 : runRequest.userInputBlocks, inputs]
+  ), runButton = /* @__PURE__ */ jsx(
+    Button,
+    {
+      text: "Run instruction",
+      onClick: runWithInput,
+      tone: "primary",
+      icon: PlayIcon,
+      style: { width: "100%" },
+      disabled: runDisabled
+    }
+  ), contextValue = useMemo(
+    () => ({ runInstruction, instructionLoading: loading }),
+    [runInstruction, loading]
+  );
+  return /* @__PURE__ */ jsxs(RunInstructionContext.Provider, { value: contextValue, children: [
+    open ? /* @__PURE__ */ jsx(
+      Dialog,
+      {
+        id,
+        open,
+        onClose: close,
+        width: 1,
+        header: getInstructionTitle(runRequest == null ? void 0 : runRequest.instruction),
+        footer: /* @__PURE__ */ jsx(Flex, { justify: "space-between", padding: 2, flex: 1, children: runDisabled ? /* @__PURE__ */ jsx(
+          Tooltip,
+          {
+            content: /* @__PURE__ */ jsx(Flex, { padding: 2, children: /* @__PURE__ */ jsx(Text, { children: "Unable to run instruction. All fields must have a value." }) }),
+            placement: "top",
+            children: /* @__PURE__ */ jsx(Flex, { flex: 1, children: runButton })
+          }
+        ) : runButton }),
+        children: /* @__PURE__ */ jsx(Stack, { padding: 4, space: 2, children: (_a = runRequest == null ? void 0 : runRequest.userInputBlocks) == null ? void 0 : _a.map((block, i) => /* @__PURE__ */ jsx(
+          UserInput,
+          {
+            block,
+            autoFocus: i === 0,
+            inputs,
+            setInputs
+          },
+          block._key
+        )) })
+      }
+    ) : null,
+    props.children
+  ] });
+}
+function UserInput(props) {
+  var _a;
+  const { block, autoFocus, setInputs, inputs } = props, key = block._key, textAreaRef = useRef(null), onChange = useCallback(
+    (e) => {
+      setInputs((current) => {
+        var _a2;
+        return {
+          ...current,
+          [key]: ((_a2 = e.currentTarget) != null ? _a2 : e.target).value
+        };
+      });
+    },
+    [key, setInputs]
+  ), value = useMemo(() => inputs[key], [inputs, key]);
+  return useEffect(() => {
+    autoFocus && setTimeout(() => {
+      var _a2;
+      return (_a2 = textAreaRef.current) == null ? void 0 : _a2.focus();
+    }, 0);
+  }, [autoFocus]), /* @__PURE__ */ jsxs(Stack, { padding: 2, space: 3, children: [
+    /* @__PURE__ */ jsx(
+      FormFieldHeaderText,
+      {
+        title: (_a = block == null ? void 0 : block.message) != null ? _a : "Provide more context",
+        description: block.description
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      TextArea,
+      {
+        ref: textAreaRef,
+        rows: 4,
+        value,
+        onChange,
+        style: { resize: "vertical" }
+      }
+    )
+  ] });
+}
+function isDocAssistable(documentSchemaType, published, draft) {
+  return !!(documentSchemaType.liveEdit ? published : draft);
+}
+function getAssistableDocId(documentSchemaType, documentId) {
+  const baseId = publicId(documentId);
+  return documentSchemaType.liveEdit ? baseId : `drafts.${baseId}`;
+}
+function useRequestRunInstruction(args) {
+  const { runInstruction, instructionLoading } = useRunInstruction(), requestRunInstruction = useDraftDelayedTask({
+    ...args,
+    task: runInstruction
+  });
+  return {
+    instructionLoading,
+    requestRunInstruction
+  };
+}
+function useDraftDelayedTask(args) {
+  const { documentOnChange, isDocAssistable: isDocAssistable2, task } = args, [queuedArgs, setQueuedArgs] = useState(void 0);
+  return useEffect(() => {
+    queuedArgs && isDocAssistable2 && (task(queuedArgs), setQueuedArgs(void 0));
+  }, [queuedArgs, isDocAssistable2, task]), useCallback(
+    (taskArgs) => {
+      documentOnChange(PatchEvent.from([unset(["_force_document_creation"])])), setQueuedArgs(taskArgs);
+    },
+    [setQueuedArgs, documentOnChange]
+  );
+}
+const MAX_DEPTH = 8;
+function getConditionalMembers(docState) {
+  return [{
+    path: "",
+    hidden: !1,
+    readOnly: !!docState.readOnly,
+    conditional: typeof docState.schemaType.hidden == "function"
+  }, ...extractConditionalPaths(docState, MAX_DEPTH)].filter((v) => v.conditional).map(({ conditional, ...state }) => ({ ...state }));
+}
+function isConditional(schemaType) {
+  return typeof schemaType.hidden == "function" || typeof schemaType.readOnly == "function";
+}
+function conditionalState(memberState) {
+  return {
+    path: pathToString(memberState.path),
+    readOnly: !!memberState.readOnly,
+    hidden: !1,
+    // if its in members, its not hidden
+    conditional: isConditional(memberState.schemaType)
+  };
+}
+function extractConditionalPaths(node, maxDepth2) {
+  return node.path.length >= maxDepth2 ? [] : node.members.reduce((acc, member) => {
+    var _a, _b;
+    if (member.kind === "error")
+      return acc;
+    if (member.kind === "field") {
+      const schemaType = member.field.schemaType;
+      if (schemaType.jsonType === "object") {
+        const innerFields = member.field.readOnly ? [] : extractConditionalPaths(member.field, maxDepth2);
+        return [...acc, conditionalState(member.field), ...innerFields];
+      } else if (schemaType.jsonType === "array") {
+        const array = member.field;
+        let arrayPaths = [];
+        const isObjectsArray = array.members.some(
+          (m) => m.kind === "item" && isObjectSchemaType(m.item.schemaType)
+        );
+        if (!array.readOnly)
+          for (const arrayMember of array.members) {
+            if (arrayMember.kind === "error")
+              continue;
+            const innerFields = isObjectsArray && !arrayMember.item.readOnly ? extractConditionalPaths(arrayMember.item, maxDepth2) : [];
+            arrayPaths = [...arrayPaths, conditionalState(arrayMember.item), ...innerFields];
+          }
+        return [...acc, conditionalState(array), ...arrayPaths];
+      }
+      return [...acc, conditionalState(member.field)];
+    } else if (member.kind === "fieldSet") {
+      const conditionalFieldset = !!((_b = (_a = node.schemaType) == null ? void 0 : _a.fieldsets) != null && _b.some(
+        (f) => !f.single && f.name === member.fieldSet.name && typeof f.hidden == "function"
+      )), innerFields = extractConditionalPaths(member.fieldSet, maxDepth2).map((f) => ({
+        ...f,
+        // if fieldset is conditional, visible fields must also be considered conditional
+        conditional: conditionalFieldset != null ? conditionalFieldset : f.conditional
+      }));
+      return [...acc, ...innerFields];
+    }
+    return acc;
+  }, []);
+}
+const SparklesIllustration = styled(SparklesIcon)({
+  fontSize: "3.125em",
+  "& path": {
+    strokeWidth: "0.6px !important"
+  }
+});
+function InspectorOnboarding(props) {
+  const { onDismiss } = props;
+  return /* @__PURE__ */ jsx(Box, { padding: 4, children: /* @__PURE__ */ jsx(Container, { width: 0, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+    /* @__PURE__ */ jsx("div", { style: { textAlign: "center" }, children: /* @__PURE__ */ jsx(SparklesIllustration, {}) }),
+    /* @__PURE__ */ jsx(Text, { align: "center", size: 1, children: "Create reusable AI instructions that can be applied across all documents of a certain type." }),
+    /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, justify: "center", children: [
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          as: "a",
+          href: releaseAnnouncementUrl,
+          rel: "noreferrer",
+          target: "_blank",
+          fontSize: 1,
+          mode: "default",
+          onClick: onDismiss,
+          padding: 2,
+          text: "Learn more",
+          tone: "primary"
+        }
+      ),
+      /* @__PURE__ */ jsx(Button, { fontSize: 1, mode: "bleed", onClick: onDismiss, padding: 2, text: "Dismiss" })
+    ] })
+  ] }) }) });
+}
+const inspectorOnboardingKey = "sanityStudio:assist:inspector:onboarding:dismissed", fieldOnboardingKey = "sanityStudio:assist:field:onboarding:dismissed";
+function isFeatureOnboardingDismissed(featureKey) {
+  return typeof localStorage > "u" ? !1 : localStorage.getItem(featureKey) === "true";
+}
+function dismissFeatureOnboarding(featureKey) {
+  typeof localStorage > "u" || localStorage.setItem(featureKey, "true");
+}
+function useOnboardingFeature(featureKey) {
+  const [showOnboarding, setShowOnboarding] = useState(
+    () => !isFeatureOnboardingDismissed(featureKey)
+  ), dismissOnboarding = useCallback(() => {
+    setShowOnboarding(!1), dismissFeatureOnboarding(featureKey);
+  }, [setShowOnboarding, featureKey]);
+  return { showOnboarding, dismissOnboarding };
+}
+function FieldAutocomplete(props) {
+  const { id, schemaType, fieldPath, onSelect, includeDocument, filter: filter2 } = props, fieldRefs = useMemo(() => includeDocument ? getFieldRefsWithDocument(schemaType) : getFieldRefs(schemaType), [schemaType, includeDocument]), currentField = useMemo(
+    () => fieldRefs.find((f) => f.key === fieldPath),
+    [fieldPath, fieldRefs]
+  ), autocompleteOptions = useMemo(
+    () => fieldRefs.filter((field) => filter2 ? filter2(field) : !0).filter((f) => !isType(f.schemaType, "reference")).map((field) => ({ value: field.key, field })),
+    [fieldRefs, filter2]
+  ), renderOption = useCallback((option) => {
+    const { value, field } = option;
+    return value ? isType(field.schemaType, "document") ? /* @__PURE__ */ jsx(Card, { as: "button", padding: 3, radius: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: "The entire document" }) }) : /* @__PURE__ */ jsx(Card, { as: "button", padding: 3, radius: 1, children: /* @__PURE__ */ jsxs(Flex, { gap: 3, children: [
+      /* @__PURE__ */ jsx(Text, { size: 1, children: createElement(field.icon) }),
+      /* @__PURE__ */ jsx(FieldTitle, { field })
+    ] }) }) : /* @__PURE__ */ jsx(Card, { as: "button", padding: 3, radius: 1, children: /* @__PURE__ */ jsx(Text, { accent: !0, size: 1, children: option.value }) });
+  }, []), renderValue = useCallback((value, option) => {
+    var _a;
+    return (_a = option == null ? void 0 : option.field.title) != null ? _a : value;
+  }, []), filterOption = useCallback((query, option) => {
+    var _a, _b, _c;
+    const lQuery = query.toLowerCase();
+    return ((_a = option == null ? void 0 : option.value) == null ? void 0 : _a.toLowerCase().includes(lQuery)) || ((_c = (_b = option == null ? void 0 : option.field) == null ? void 0 : _b.title) == null ? void 0 : _c.toLowerCase().includes(lQuery));
+  }, []);
+  return /* @__PURE__ */ jsx(
+    Autocomplete,
+    {
+      fontSize: 1,
+      icon: currentField ? currentField.icon : SearchIcon,
+      onChange: onSelect,
+      openButton: !0,
+      id,
+      options: autocompleteOptions,
+      placeholder: "Search for a field",
+      radius: 2,
+      renderOption,
+      renderValue,
+      value: currentField == null ? void 0 : currentField.key,
+      filterOption
+    }
+  );
+}
+function FieldTitle(props) {
+  const splitTitle = props.field.title.split("/");
+  return /* @__PURE__ */ jsx(Box, { flex: "none", children: /* @__PURE__ */ jsxs(
+    Breadcrumbs,
+    {
+      style: {
+        display: "flex",
+        flexWrap: "wrap",
+        alignItems: "center",
+        marginTop: "-4px"
+      },
+      separator: /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: "/" }) }),
+      space: 1,
+      children: [
+        splitTitle.slice(0, splitTitle.length - 1).map((pt, i) => (
+          // eslint-disable-next-line react/no-array-index-key
+          /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: pt.trim() }) }, i)
+        )),
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: splitTitle[splitTitle.length - 1] }) })
+      ]
+    }
+  ) });
+}
+function useInterval(ms) {
+  const [tick, update] = useReducer((n) => n + 1, 0);
+  return useEffect(() => {
+    const i = setInterval(update, ms);
+    return () => clearInterval(i);
+  }, [ms]), tick;
+}
+function TimeAgo({ date }) {
+  useInterval(1e3);
+  const timeSince = formatDistanceToNow(date ? new Date(date) : /* @__PURE__ */ new Date());
+  return /* @__PURE__ */ jsxs("span", { title: timeSince, children: [
+    timeSince,
+    " ago"
+  ] });
+}
+const rotate = keyframes`
+  0% {
+    transform: rotate(0);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+`, SyncSpinningIcon = styled(SyncIcon)`
+  animation: ${rotate} 1s linear infinite;
+`, TASK_CONFIG = {
+  aborted: {
+    title: "Canceled",
+    icon: CloseCircleIcon,
+    tone: "transparent"
+  },
+  error: {
+    title: "Error",
+    icon: ErrorOutlineIcon,
+    tone: "critical"
+  },
+  success: {
+    title: "Completed",
+    icon: CheckmarkCircleIcon,
+    tone: "positive"
+  },
+  timeout: {
+    title: "Timeout",
+    icon: ClockIcon,
+    tone: "caution"
+  }
+};
+function InstructionTaskHistoryButton(props) {
+  const { tasks, instructions, documentId, showTitles } = props, client = useClient({ apiVersion: "2023-01-01" }), cancelRun = useCallback(
+    (taskKey) => {
+      if (!documentId)
+        return;
+      const statusDocId = assistTasksStatusId(documentId), basePath2 = `${typed("tasks")}[_key=="${taskKey}"]`;
+      client.patch(statusDocId).set({
+        [`${basePath2}.${typed("ended")}`]: (/* @__PURE__ */ new Date()).toISOString(),
+        [`${basePath2}.${typed("reason")}`]: typed("aborted")
+      }).commit().catch(console.error);
+    },
+    [client, documentId]
+  ), titledTasks = useMemo(() => {
+    var _a;
+    const t = (_a = tasks == null ? void 0 : tasks.filter(
+      (task) => task.started && (/* @__PURE__ */ new Date()).getTime() - new Date(task.started).getTime() < maxHistoryVisibilityMs
+    ).map((task) => {
+      var _a2;
+      const instruction2 = instructions == null ? void 0 : instructions.find((i) => i._key === task.instructionKey);
+      return {
+        ...task,
+        title: showTitles ? (_a2 = task.title) != null ? _a2 : getInstructionTitle(instruction2) : void 0,
+        cancel: () => cancelRun(task._key)
+      };
+    })) != null ? _a : [];
+    return t.sort((a, b) => {
+      var _a2, _b;
+      return new Date((_a2 = b.started) != null ? _a2 : "").getTime() - new Date((_b = a.started) != null ? _b : "").getTime();
+    }), t;
+  }, [tasks, instructions, cancelRun, showTitles]), isRunning = useMemo(() => titledTasks.some((r) => !r.ended), [titledTasks]), hasErrors = useMemo(
+    () => titledTasks.some((r) => r.reason === "error" || r.reason === "timeout"),
+    [titledTasks]
+  ), [open, setOpen] = useState(!1), toggleOpen = useCallback(() => setOpen((v) => !v), []), [button, setButton] = useState(null), [popover, setPopover] = useState(null), handleClickOutside = useCallback(() => {
+    setOpen(!1);
+  }, []);
+  useClickOutside(handleClickOutside, [button, popover]);
+  const handleEscape = useCallback(() => {
+    setOpen(!1), button == null || button.focus();
+  }, [button]);
+  return /* @__PURE__ */ jsx(
+    Popover,
+    {
+      constrainSize: !0,
+      content: /* @__PURE__ */ jsx(TaskList, { onEscape: handleEscape, tasks: titledTasks }),
+      open: open && !!(titledTasks != null && titledTasks.length),
+      placement: "top",
+      portal: !0,
+      ref: setPopover,
+      width: 0,
+      children: /* @__PURE__ */ jsx(
+        TaskStatusButton,
+        {
+          disabled: !(titledTasks != null && titledTasks.length),
+          hasErrors,
+          isRunning,
+          onClick: toggleOpen,
+          ref: setButton,
+          selected: open
+        }
+      )
+    }
+  );
+}
+const TASK_STATUS_BUTTON_TOOLTIP_PROPS = {
+  placement: "top"
+}, TaskStatusButton = forwardRef(function(props, ref) {
+  const { disabled, hasErrors, isRunning, onClick, selected } = props;
+  return /* @__PURE__ */ jsx(
+    StatusButton,
+    {
+      label: `${pluginTitle} status`,
+      icon: isRunning ? SyncSpinningIcon : hasErrors ? ErrorOutlineIcon : CheckmarkCircleIcon,
+      mode: "bleed",
+      onClick,
+      tone: hasErrors ? "critical" : void 0,
+      disabled,
+      ref,
+      selected,
+      tooltipProps: TASK_STATUS_BUTTON_TOOLTIP_PROPS
+    }
+  );
+});
+function TaskList(props) {
+  const { onEscape, tasks } = props, { isTopLayer } = useLayer();
+  return useGlobalKeyDown(
+    useCallback(
+      (event) => {
+        isTopLayer && event.key === "Escape" && onEscape();
+      },
+      [isTopLayer, onEscape]
+    )
+  ), /* @__PURE__ */ jsx(Stack, { padding: 1, space: 1, children: tasks.map((task) => /* @__PURE__ */ jsx(TaskItem, { task }, task._key)) });
+}
+function TaskItem(props) {
+  var _a;
+  const { task } = props, taskType = task.reason && TASK_CONFIG[task.reason];
+  return /* @__PURE__ */ jsx(Card, { radius: 2, tone: taskType && (taskType == null ? void 0 : taskType.tone), children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 1, children: [
+    /* @__PURE__ */ jsxs(Flex, { align: "flex-start", flex: 1, gap: 3, padding: 3, children: [
+      /* @__PURE__ */ jsx(Box, { flex: "none", children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+        taskType && createElement(taskType.icon),
+        !task.reason && /* @__PURE__ */ jsx(Spinner, {})
+      ] }) }),
+      /* @__PURE__ */ jsxs(Stack, { flex: 1, space: 2, children: [
+        /* @__PURE__ */ jsxs(Text, { size: 1, weight: "medium", children: [
+          taskType ? taskType.title : "Running",
+          task.title && /* @__PURE__ */ jsxs(Fragment, { children: [
+            ": ",
+            task.title
+          ] })
+        ] }),
+        task.message ? /* @__PURE__ */ jsx(Text, { size: 1, children: task.message }) : null,
+        /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: /* @__PURE__ */ jsx(TimeAgo, { date: (_a = task.ended) != null ? _a : task.started }) })
+      ] })
+    ] }),
+    !task.ended && /* @__PURE__ */ jsx(Box, { flex: "none", padding: 1, children: /* @__PURE__ */ jsx(Button, { fontSize: 1, mode: "bleed", onClick: task.cancel, text: "Cancel" }) })
+  ] }) });
+}
+const CardWithShadowBelow = styled(Card)`
+  position: relative;
+
+  &:after {
+    content: '';
+    display: block;
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: -1px;
+    border-bottom: 1px solid var(--card-border-color);
+    opacity: 0.5;
+    z-index: 100;
+  }
+`, CardWithShadowAbove = styled(Card)`
+  position: relative;
+
+  &:after {
+    content: '';
+    display: block;
+    position: absolute;
+    left: 0;
+    right: 0;
+    top: -1px;
+    border-top: 1px solid var(--card-border-color);
+    opacity: 0.5;
+    z-index: 100;
+  }
+`;
+function AssistInspectorWrapper(props) {
+  const context = useAiAssistanceConfig();
+  if (context.statusLoading)
+    return /* @__PURE__ */ jsx(Flex, { align: "center", height: "fill", justify: "center", padding: 4, sizing: "border", children: /* @__PURE__ */ jsxs(Stack, { space: 3, style: { textAlign: "center" }, children: [
+      /* @__PURE__ */ jsx(Spinner, { muted: !0 }),
+      /* @__PURE__ */ jsxs(Text, { muted: !0, size: 1, children: [
+        "Loading ",
+        pluginTitle,
+        "..."
+      ] })
+    ] }) });
+  const status = context.status;
+  return status != null && status.enabled ? !(status != null && status.initialized) || !status.validToken ? /* @__PURE__ */ jsxs(Flex, { direction: "column", height: "fill", children: [
+    /* @__PURE__ */ jsx(
+      DocumentInspectorHeader,
+      {
+        closeButtonLabel: "Close",
+        onClose: props.onClose,
+        title: pluginTitle
+      }
+    ),
+    /* @__PURE__ */ jsxs(Stack, { padding: 4, space: 3, children: [
+      context.error ? /* @__PURE__ */ jsxs(Text, { size: 1, weight: "semibold", children: [
+        "Failed to start ",
+        pluginTitle
+      ] }) : null,
+      !context.error && !(status != null && status.initialized) ? /* @__PURE__ */ jsxs(Text, { size: 1, weight: "semibold", children: [
+        pluginTitle,
+        " is not enabled"
+      ] }) : null,
+      !context.error && status != null && status.initialized && !status.validToken ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: "Invalid token" }),
+        /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: "The token used by the AI Assistant is not valid and has to be regenerated." })
+      ] }) : null,
+      context.error && /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: "Something went wrong. See console for details." }),
+      !context.error && !(status != null && status.initialized) && /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+        "Please enable ",
+        pluginTitle,
+        "."
+      ] }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          fontSize: 1,
+          icon: context.initLoading ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Spinner, {}) }) : context.error ? RetryIcon : void 0,
+          text: context.error ? "Retry" : status != null && status.initialized && !status.validToken ? `Restore ${pluginTitle}` : `Enable ${pluginTitle} now`,
+          tone: "primary",
+          onClick: context.init,
+          disabled: context.initLoading
+        }
+      )
+    ] })
+  ] }) : /* @__PURE__ */ jsx(AssistInspector, { ...props }) : /* @__PURE__ */ jsxs(Flex, { direction: "column", height: "fill", children: [
+    /* @__PURE__ */ jsx(
+      DocumentInspectorHeader,
+      {
+        closeButtonLabel: "Close",
+        onClose: props.onClose,
+        title: pluginTitle
+      }
+    ),
+    /* @__PURE__ */ jsxs(Stack, { flex: 1, overflow: "auto", padding: 4, space: 3, children: [
+      /* @__PURE__ */ jsxs(Text, { as: "p", size: 1, weight: "semibold", children: [
+        pluginTitle,
+        " is not available"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { as: "p", muted: !0, size: 1, children: [
+        "Please get in touch with a Sanity account manager or",
+        " ",
+        /* @__PURE__ */ jsx("a", { href: salesUrl, target: "_blank", rel: "noreferrer", children: "contact our sales team" }),
+        " ",
+        "to get started with ",
+        pluginTitle,
+        ".",
+        " ",
+        /* @__PURE__ */ jsx("a", { href: releaseAnnouncementUrl, target: "_blank", rel: "noreferrer", children: "Learn more \u2192" })
+      ] })
+    ] })
+  ] });
+}
+function AssistInspector(props) {
+  var _a, _b;
+  const { params } = useAiPaneRouter(), boundary = useRef(null), pathKey = params == null ? void 0 : params[fieldPathParam], instructionKey = params == null ? void 0 : params[instructionParam], documentPane = useDocumentPane(), {
+    documentId,
+    documentType,
+    value: docValue,
+    schemaType,
+    onChange: documentOnChange,
+    formState
+  } = documentPane, { published, draft } = useEditState(documentId, documentType, "low"), formStateRef = useRef(formState);
+  formStateRef.current = formState;
+  const assistableDocId = getAssistableDocId(schemaType, documentId), { instructionLoading, requestRunInstruction } = useRequestRunInstruction({
+    documentOnChange,
+    isDocAssistable: isDocAssistable(schemaType, published, draft)
+  }), typePath = useTypePath(docValue, pathKey != null ? pathKey : ""), selectedField = useSelectedField(schemaType, typePath), aiDocId = assistDocumentId(documentType), assistDocument = useStudioAssistDocument({ documentId, schemaType, initDoc: !0 }), assistField = (_a = assistDocument == null ? void 0 : assistDocument.fields) == null ? void 0 : _a.find((f) => f.path === typePath), instruction2 = (_b = assistField == null ? void 0 : assistField.instructions) == null ? void 0 : _b.find((i) => i._key === instructionKey), tasks = useMemo(
+    () => {
+      var _a2;
+      return (_a2 = assistDocument == null ? void 0 : assistDocument.tasks) == null ? void 0 : _a2.filter((i) => !instructionKey || i.instructionKey === instructionKey);
+    },
+    [assistDocument == null ? void 0 : assistDocument.tasks, instructionKey]
+  ), instructions = useMemo(
+    () => {
+      var _a2;
+      return (_a2 = assistDocument == null ? void 0 : assistDocument.fields) == null ? void 0 : _a2.flatMap((f) => {
+        var _a3;
+        return (_a3 = f.instructions) != null ? _a3 : [];
+      });
+    },
+    [assistDocument == null ? void 0 : assistDocument.fields]
+  ), promptValue = instruction2 == null ? void 0 : instruction2.prompt, isEmptyPrompt = useMemo(() => {
+    var _a2, _b2;
+    if (!(promptValue != null && promptValue.length))
+      return !0;
+    const firstBlock = promptValue[0], children = firstBlock == null ? void 0 : firstBlock.children;
+    return promptValue.length == 1 && (children == null ? void 0 : children.length) === 1 && !((_b2 = (_a2 = children == null ? void 0 : children[0]) == null ? void 0 : _a2.text) != null && _b2.length);
+  }, [promptValue]), paneNode = useMemo(
+    () => ({
+      type: "document",
+      id: aiDocId,
+      title: pluginTitle,
+      options: {
+        id: aiDocId,
+        type: assistDocumentTypeName
+      }
+    }),
+    [aiDocId]
+  ), runCurrentInstruction = useCallback(
+    () => instruction2 && pathKey && typePath && requestRunInstruction({
+      documentId: assistableDocId,
+      path: pathKey,
+      typePath,
+      assistDocumentId: assistDocumentId(documentType),
+      instruction: instruction2,
+      conditionalMembers: formStateRef.current ? getConditionalMembers(formStateRef.current) : []
+    }),
+    [pathKey, instruction2, typePath, documentType, assistableDocId, requestRunInstruction]
+  ), Region = useCallback((_props) => /* @__PURE__ */ jsx("div", { ..._props, style: { height: "100%", flex: 1, overflow: "auto" } }), []);
+  return !documentId || !schemaType || schemaType.jsonType !== "object" ? /* @__PURE__ */ jsx(Card, { flex: 1, padding: 4, children: /* @__PURE__ */ jsx(Text, { children: "Document not ready yet." }) }) : /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      ref: boundary,
+      direction: "column",
+      height: "fill",
+      overflow: "hidden",
+      sizing: "border",
+      style: { lineHeight: 0 },
+      children: [
+        /* @__PURE__ */ jsx(
+          AiInspectorHeader,
+          {
+            onClose: props.onClose,
+            field: selectedField,
+            fieldTitle: getFieldTitle(selectedField)
+          }
+        ),
+        /* @__PURE__ */ jsx(Card, { as: Region, flex: 1, overflow: "auto", children: /* @__PURE__ */ jsxs(Flex, { direction: "column", style: { minHeight: "100%" }, children: [
+          /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsx(PresenceOverlay, { children: /* @__PURE__ */ jsx(Box, { padding: 4, children: selectedField && /* @__PURE__ */ jsx(TypePathContext.Provider, { value: typePath, children: /* @__PURE__ */ jsx(
+            VirtualizerScrollInstanceProvider,
+            {
+              scrollElement: boundary.current,
+              containerElement: boundary,
+              children: /* @__PURE__ */ jsx(
+                DocumentPaneProvider,
+                {
+                  paneKey: documentPane.paneKey,
+                  index: documentPane.index,
+                  itemId: "ai",
+                  pane: paneNode,
+                  children: /* @__PURE__ */ jsx(DocumentForm, {})
+                }
+              )
+            }
+          ) }) }) }) }),
+          /* @__PURE__ */ jsx(Box, { flex: "none", padding: 4, children: /* @__PURE__ */ jsxs(Text, { muted: !0, size: 1, children: [
+            "How is Sanity AI Assist working for you?",
+            " ",
+            /* @__PURE__ */ jsxs(
+              "a",
+              {
+                href: giveFeedbackUrl,
+                target: "_blank",
+                rel: "noreferrer",
+                style: { whiteSpace: "nowrap" },
+                children: [
+                  "Let us know ",
+                  /* @__PURE__ */ jsx(ArrowRightIcon, {})
+                ]
+              }
+            )
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ jsx(CardWithShadowAbove, { flex: "none", paddingX: 4, paddingY: 3, style: { justifySelf: "flex-end" }, children: /* @__PURE__ */ jsxs(Flex, { gap: 2, flex: 1, justify: "flex-end", children: [
+          (schemaType == null ? void 0 : schemaType.name) && pathKey && instructionKey && /* @__PURE__ */ jsx(Stack, { flex: 1, children: /* @__PURE__ */ jsx(
+            Button,
+            {
+              mode: "ghost",
+              disabled: isEmptyPrompt || instructionLoading,
+              fontSize: 1,
+              icon: instructionLoading ? /* @__PURE__ */ jsx(Spinner, {}) : PlayIcon,
+              onClick: runCurrentInstruction,
+              padding: 3,
+              text: "Run instruction"
+            }
+          ) }),
+          /* @__PURE__ */ jsx(
+            InstructionTaskHistoryButton,
+            {
+              documentId: assistableDocId,
+              tasks,
+              instructions,
+              showTitles: !instructionKey
+            }
+          )
+        ] }) })
+      ]
+    }
+  );
+}
+function AiInspectorHeader(props) {
+  const { onClose, field, fieldTitle } = props, { showOnboarding, dismissOnboarding } = useOnboardingFeature(inspectorOnboardingKey);
+  return /* @__PURE__ */ jsxs(CardWithShadowBelow, { flex: "none", padding: 2, children: [
+    /* @__PURE__ */ jsxs(Flex, { flex: 1, align: "center", children: [
+      /* @__PURE__ */ jsx(Flex, { flex: 1, padding: 3, gap: 2, align: "center", children: /* @__PURE__ */ jsxs(Flex, { gap: 1, align: "center", wrap: "wrap", style: { marginTop: "-4px" }, children: [
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: "AI instructions for" }) }),
+        /* @__PURE__ */ jsx(Card, { radius: 2, border: !0, padding: 1, marginTop: 1, children: field ? /* @__PURE__ */ jsx(FieldTitle, { field }) : /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: fieldTitle }) })
+      ] }) }),
+      /* @__PURE__ */ jsx(Box, { flex: "none", children: /* @__PURE__ */ jsx(Button, { fontSize: 1, icon: CloseIcon, mode: "bleed", onClick: onClose }) })
+    ] }),
+    showOnboarding && /* @__PURE__ */ jsx(InspectorOnboarding, { onDismiss: dismissOnboarding })
+  ] });
+}
+const assistInspector = {
+  name: aiInspectorId,
+  useMenuItem: () => ({
+    icon: SparklesIcon,
+    title: pluginTitle,
+    hidden: !0,
+    showAsAction: !1
+  }),
+  component: AssistInspectorWrapper,
+  onClose({ params }) {
+    return {
+      params: typed({
+        ...params,
+        [fieldPathParam]: void 0,
+        [instructionParam]: void 0
+      })
+    };
+  }
+};
+function AssistFeatureBadge() {
+  return /* @__PURE__ */ jsx(Badge, { fontSize: 0, style: { margin: "-2px 0" }, tone: "primary", children: "Beta" });
+}
+function AssistOnboardingPopover(props) {
+  const { dismiss } = props;
+  return /* @__PURE__ */ jsx(
+    Popover,
+    {
+      content: /* @__PURE__ */ jsx(AssistIntroCard, { dismiss }),
+      open: !0,
+      portal: !0,
+      placeholder: "bottom",
+      tone: "default",
+      width: 0,
+      children: /* @__PURE__ */ jsx(Card, { radius: 2, shadow: 2, style: { padding: 2, lineHeight: 0 }, children: /* @__PURE__ */ jsx(Button, { disabled: !0, fontSize: 1, icon: SparklesIcon, mode: "bleed", padding: 2 }) })
+    }
+  );
+}
+function AssistIntroCard(props) {
+  const buttonRef = useRef(null);
+  return /* @__PURE__ */ jsxs(Stack, { as: "section", padding: 3, space: 3, children: [
+    /* @__PURE__ */ jsxs(Stack, { padding: 2, space: 4, children: [
+      /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", children: [
+        /* @__PURE__ */ jsx(Text, { as: "h1", size: 1, weight: "semibold", children: pluginTitle }),
+        /* @__PURE__ */ jsx("div", { "aria-hidden": !0, style: { margin: "-3px 0", lineHeight: 0 }, children: /* @__PURE__ */ jsx(AssistFeatureBadge, {}) })
+      ] }),
+      /* @__PURE__ */ jsx(Stack, { space: 3, children: /* @__PURE__ */ jsxs(Text, { as: "p", muted: !0, size: 1, children: [
+        "Manage reusable AI instructions to boost your content creation and reduce amount of repetitive chores.",
+        " ",
+        /* @__PURE__ */ jsxs("a", { href: releaseAnnouncementUrl, target: "_blank", rel: "noreferrer", children: [
+          "Learn more ",
+          /* @__PURE__ */ jsx(ArrowRightIcon, {})
+        ] })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        fontSize: 1,
+        icon: CheckmarkIcon,
+        onClick: props.dismiss,
+        padding: 3,
+        ref: buttonRef,
+        text: "Ok, good to know!",
+        tone: "primary"
+      }
+    )
+  ] });
+}
+const FirstAssistedPathContext = createContext(void 0);
+function FirstAssistedPathProvider(props) {
+  const { members } = props, firstAssistedPath = useMemo(() => {
+    const firstAssisted = members.find(
+      (member) => member.kind === "field" && isAssistSupported(member.field.schemaType)
+    );
+    return firstAssisted != null && firstAssisted.field.path ? pathToString(firstAssisted == null ? void 0 : firstAssisted.field.path) : void 0;
+  }, [members]);
+  return /* @__PURE__ */ jsx(FirstAssistedPathContext.Provider, { value: firstAssistedPath, children: props.children });
+}
+const fadeIn = keyframes`
+  0% {
+    opacity: 0;
+    transform: scale(0.75);
+  }
+  40% {
+    opacity: 0;
+    transform: scale(0.75);
+  }
+  100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+`, FadeInDiv = styled.div`
+  animation-name: ${fadeIn};
+  animation-timing-function: ease-in-out;
+`, FadeInContent = forwardRef(function({
+  children,
+  durationMs = 250
+}, ref) {
+  return /* @__PURE__ */ jsx(FadeInDiv, { ref, style: { animationDuration: `${durationMs}ms` }, children });
+}), purple = {
+  50: {
+    title: "Purple 50",
+    hex: "#f8f5ff"
+  },
+  100: {
+    title: "Purple 100",
+    hex: "#f1ebff"
+  },
+  200: {
+    title: "Purple 200",
+    hex: "#ece1fe"
+  },
+  300: {
+    title: "Purple 300",
+    hex: "#ccb1fc"
+  },
+  400: {
+    title: "Purple 400",
+    hex: "#b087f7"
+  },
+  500: {
+    title: "Purple 500",
+    hex: "#8f57ef"
+  },
+  600: {
+    title: "Purple 600",
+    hex: "#721fe5"
+  },
+  700: {
+    title: "Purple 700",
+    hex: "#4c1a9e"
+  },
+  800: {
+    title: "Purple 800",
+    hex: "#2f1862"
+  },
+  900: {
+    title: "Purple 900",
+    hex: "#23173f"
+  },
+  950: {
+    title: "Purple 950",
+    hex: "#181128"
+  }
+}, Root = styled.span`
+  display: block;
+  width: 25px;
+  height: 25px;
+  position: relative;
+`, dash = keyframes`
+  0% {
+    transform: rotate(0);
+  }
+  100% {
+    transform: rotate(43deg);
+  }
+`, Outline = styled.svg`
+  display: block;
+  position: absolute;
+  top: 0;
+  left: 0;
+
+  & > circle {
+    stroke: var(--ai-avatar-stroke-color);
+    stroke-width: 1.5px;
+    stroke-linecap: round;
+    transform-origin: center;
+    animation: ${dash} 500ms ease-in-out infinite;
+    transition: stroke-dasharray 200ms ease-in-out;
+
+    stroke-dasharray: 2.34px 0;
+
+    [data-state='active'] > & {
+      stroke-dasharray: 2px 2.34px;
+    }
+  }
+`, IconDisc = styled.span`
+  background: var(--ai-avatar-disc-color);
+  color: white;
+  width: 21px;
+  height: 21px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 10.5px;
+  position: absolute;
+  top: 2px;
+  left: 2px;
+`;
+function AssistAvatar(props) {
+  const { state = "present" } = props, scheme = useColorSchemeValue(), style = useMemo(() => scheme === "dark" ? {
+    "--ai-avatar-stroke-color": purple[400].hex,
+    "--ai-avatar-disc-color": purple[600].hex
+  } : {
+    "--ai-avatar-stroke-color": purple[500].hex,
+    "--ai-avatar-disc-color": purple[600].hex
+  }, [scheme]);
+  return /* @__PURE__ */ jsxs(Root, { "data-state": state, style, children: [
+    /* @__PURE__ */ jsx(
+      Outline,
+      {
+        width: "25",
+        height: "25",
+        viewBox: "0 0 25 25",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        children: /* @__PURE__ */ jsx("circle", { cx: "12.5", cy: "12.5", r: "11.75" })
+      }
+    ),
+    /* @__PURE__ */ jsx(IconDisc, { children: /* @__PURE__ */ jsx(Text, { as: "span", size: 0, style: { color: "inherit" }, children: /* @__PURE__ */ jsx(SparklesIcon, { style: { color: "inherit" } }) }) })
+  ] });
+}
+function AiFieldPresence(props) {
+  return /* @__PURE__ */ jsx(Card, { style: { position: "relative", background: "transparent" }, contentEditable: !1, children: /* @__PURE__ */ jsx(
+    Tooltip,
+    {
+      placement: "left",
+      content: /* @__PURE__ */ jsx(Card, { padding: 3, border: !0, children: /* @__PURE__ */ jsx(Flex, { align: "center", children: /* @__PURE__ */ jsx(Text, { size: 1, children: "Running instruction..." }) }) }),
+      children: /* @__PURE__ */ jsx(FadeInContent, { durationMs: 300, children: /* @__PURE__ */ jsx(AssistAvatar, { state: "active" }) })
+    }
+  ) });
+}
+const AssistDocumentContext = createContext(
+  void 0
+);
+function useAssistDocumentContext() {
+  const context = useContext(AssistDocumentContext);
+  if (!context)
+    throw new Error("AssistDocumentContext value is missing");
+  return context;
+}
+const NO_PRESENCE = [];
+function useAssistPresence(path, showFocusWithin) {
+  const context = useAssistDocumentContext(), assistDocument = context && "assistDocument" in context ? context.assistDocument : void 0, tasks = assistDocument == null ? void 0 : assistDocument.tasks;
+  return useMemo(() => {
+    var _a, _b;
+    const activePresence = (_b = (_a = tasks == null ? void 0 : tasks.filter((task) => !task.ended)) == null ? void 0 : _a.flatMap((task) => {
+      var _a2;
+      return (_a2 = task.presence) != null ? _a2 : [];
+    })) == null ? void 0 : _b.filter(
+      (p) => p.started && (/* @__PURE__ */ new Date()).getTime() - new Date(p.started).getTime() < maxHistoryVisibilityMs
+    ).filter((presence) => {
+      if (!presence.path || !path.length)
+        return !1;
+      const statusPath = stringToPath(presence.path);
+      return !showFocusWithin && statusPath.length !== path.length ? !1 : path.every((pathSegment, i) => {
+        const statusSegment = statusPath[i];
+        return typeof pathSegment == "string" ? pathSegment === statusSegment : isKeySegment(pathSegment) && isKeySegment(statusSegment) ? pathSegment._key === statusSegment._key : !1;
+      });
+    });
+    return activePresence != null && activePresence.length ? activePresence.map((status) => aiPresence(status, path)) : NO_PRESENCE;
+  }, [showFocusWithin, tasks, path]);
+}
+function aiPresence(presence, path, title) {
+  var _a;
+  return {
+    user: {
+      id: `sanity-assistant_${presence._key}`,
+      displayName: pluginTitle
+    },
+    path,
+    sessionId: "not-available",
+    lastActiveAt: (_a = presence == null ? void 0 : presence.started) != null ? _a : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function AssistFieldWrapper(props) {
+  const { schemaType } = props;
+  return !useMemo(() => isAssistSupported(schemaType), [schemaType]) || schemaType.name.startsWith("sanity.") || schemaType.name === contextDocumentTypeName ? props.renderDefault(props) : !isType(props.schemaType, "document") && props.inputId !== "root" && props.inputId !== assistFormId ? /* @__PURE__ */ jsx(AssistField, { ...props, children: props.children }) : props.renderDefault(props);
+}
+function AssistField(props) {
+  const { path } = props, isPortableText = useMemo(
+    () => !!(isArraySchemaType(props.schemaType) && isPortableTextArray(props.schemaType)),
+    [props.schemaType]
+  ), presence = useAssistPresence(props.path, isPortableText), firstAssistedPath = useContext(FirstAssistedPathContext), isFirstAssisted = useMemo(
+    () => pathToString(path) === firstAssistedPath,
+    [path, firstAssistedPath]
+  ), { showOnboarding, dismissOnboarding } = useOnboardingFeature(fieldOnboardingKey), singlePresence = presence[0], actions = /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", justify: "space-between", children: [
+    singlePresence && /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(AiFieldPresence, { presence: singlePresence }) }),
+    isFirstAssisted && showOnboarding && /* @__PURE__ */ jsx(AssistOnboardingPopover, { dismiss: dismissOnboarding })
+  ] });
+  return props.renderDefault({
+    ...props,
+    // When showing the onboarding, prevent default field actions from being rendered
+    actions: isFirstAssisted && showOnboarding ? [] : props.actions,
+    // Render presence (and possibly onboarding) in the internal slot (between presence and the field actions)
+    // eslint-disable-next-line camelcase
+    __internal_slot: actions
+  });
+}
+function hasOverflowScroll(el) {
+  const overflow = getComputedStyle(el).overflow;
+  return overflow.includes("auto") || overflow.includes("hidden") || overflow.includes("scroll");
+}
+function useRegionRects() {
+  const ref = useRef(null), [relativeBoundsRect, setRelativeBoundsRect] = useState(null), [relativeElementRect, setRelativeElementRect] = useState(null), [boundsScroll, setBoundsScroll] = useState({ x: 0, y: 0 }), [scroll, setScroll] = useState({ x: 0, y: 0 }), boundsScrollXRef = useRef(0), boundsScrollYRef = useRef(0), elementScrollXRef = useRef(0), elementScrollYRef = useRef(0);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el)
+      return;
+    const scrollParents = [];
+    let parent = el.parentElement;
+    for (; parent && parent !== document.body; )
+      hasOverflowScroll(parent) && scrollParents.push(parent), parent = parent.parentElement;
+    function handleResize() {
+      const scrollParent = scrollParents[0], boundsRect = (scrollParent == null ? void 0 : scrollParent.getBoundingClientRect()) || {
+        x: 0,
+        y: 0,
+        width: window.innerWidth,
+        height: window.innerHeight
+      }, domRect = el.getBoundingClientRect();
+      setRelativeBoundsRect({
+        x: boundsRect.x + boundsScrollXRef.current,
+        y: boundsRect.y + boundsScrollYRef.current,
+        w: boundsRect.width,
+        h: boundsRect.height
+      }), setRelativeElementRect({
+        x: domRect.x + elementScrollXRef.current,
+        y: domRect.y + elementScrollYRef.current,
+        w: domRect.width,
+        h: domRect.height
+      });
+    }
+    function handleScroll() {
+      let scrollX = window.scrollX, scrollY = window.scrollY;
+      for (const scrollParent2 of scrollParents)
+        scrollX += scrollParent2.scrollLeft, scrollY += scrollParent2.scrollTop;
+      const scrollParent = scrollParents[0];
+      boundsScrollXRef.current = scrollX - ((scrollParent == null ? void 0 : scrollParent.scrollLeft) || window.scrollX), boundsScrollYRef.current = scrollY - ((scrollParent == null ? void 0 : scrollParent.scrollTop) || window.scrollY), setBoundsScroll({
+        x: boundsScrollXRef.current,
+        y: boundsScrollYRef.current
+      }), elementScrollXRef.current = scrollX, elementScrollYRef.current = scrollY, setScroll({ x: scrollX, y: scrollY });
+    }
+    window.addEventListener("scroll", handleScroll, { passive: !0 });
+    const ro = new ResizeObserver(handleResize);
+    ro.observe(el);
+    for (const scrollParent of scrollParents)
+      scrollParent.addEventListener("scroll", handleScroll, { passive: !0 }), ro.observe(scrollParent);
+    return handleScroll(), () => {
+      ro.unobserve(el);
+      for (const scrollParent of scrollParents)
+        ro.unobserve(scrollParent), scrollParent.removeEventListener("scroll", handleScroll);
+      ro.disconnect(), window.removeEventListener("scroll", handleScroll);
+    };
+  }, []);
+  const bounds = useMemo(
+    () => relativeBoundsRect && {
+      x: relativeBoundsRect.x - boundsScroll.x,
+      y: relativeBoundsRect.y - boundsScroll.y,
+      w: relativeBoundsRect.w,
+      h: relativeBoundsRect.h
+    },
+    [relativeBoundsRect, boundsScroll]
+  ), element = useMemo(
+    () => relativeElementRect && {
+      x: relativeElementRect.x - scroll.x,
+      y: relativeElementRect.y - scroll.y,
+      w: relativeElementRect.w,
+      h: relativeElementRect.h
+    },
+    [relativeElementRect, scroll]
+  );
+  return { bounds, element, ref };
+}
+function ConnectorRegion(props) {
+  const { children, onRectsChange, ...restProps } = props, { bounds, element, ref } = useRegionRects();
+  return useEffect(() => {
+    onRectsChange == null || onRectsChange(bounds && element ? { bounds, element } : null);
+  }, [bounds, element, onRectsChange]), /* @__PURE__ */ jsx("div", { ...restProps, ref, children });
+}
+const ConnectorsStoreContext = createContext(null);
+function useConnectorsStore() {
+  const store = useContext(ConnectorsStoreContext);
+  if (!store)
+    throw new Error("Missing connectors store context");
+  return store;
+}
+function ConnectFromRegion(props) {
+  const { children, _key: key, zIndex, ...restProps } = props, store = useConnectorsStore(), [rects, setRects] = useState(null);
+  return useEffect(() => store.from.subscribe(key, { zIndex }), [key, store, zIndex]), useEffect(() => {
+    rects && store.from.next(key, rects);
+  }, [key, rects, store]), /* @__PURE__ */ jsx(ConnectorRegion, { ...restProps, onRectsChange: setRects, children });
+}
+function createConnectorsStore() {
+  const configKeys = [], fieldKeys = [], channels = {
+    from: /* @__PURE__ */ new Map(),
+    to: /* @__PURE__ */ new Map()
+  }, payloads = {
+    from: /* @__PURE__ */ new Map(),
+    to: /* @__PURE__ */ new Map()
+  }, observers = [];
+  function notifyObservers() {
+    const connectors = [];
+    for (const key of configKeys) {
+      const toRects = channels.to.get(key), toPayload = payloads.from.get(key), fromRects = channels.from.get(key), fromPayload = payloads.from.get(key);
+      toRects && fromRects && connectors.push({
+        key,
+        from: { ...fromRects, payload: fromPayload },
+        to: { ...toRects, payload: toPayload }
+      });
+    }
+    for (const observer of observers)
+      observer(connectors);
+  }
+  return {
+    to: {
+      subscribe(key, payload) {
+        return channels.to.set(key, null), payloads.to.set(key, payload), configKeys.push(key), () => {
+          channels.to.delete(key), payloads.to.delete(key);
+          const idx = configKeys.indexOf(key);
+          idx > -1 && configKeys.splice(idx, 1), notifyObservers();
+        };
+      },
+      next(key, rects) {
+        channels.to.set(key, rects), fieldKeys.includes(key) && notifyObservers();
+      }
+    },
+    connectors: {
+      subscribe(observer) {
+        return observers.push(observer), () => {
+          const idx = observers.indexOf(observer);
+          idx > -1 && observers.splice(idx, 1);
+        };
+      }
+    },
+    from: {
+      subscribe(key, payload) {
+        return channels.from.set(key, null), payloads.from.set(key, payload), fieldKeys.push(key), () => {
+          channels.from.delete(key), payloads.from.delete(key);
+          const idx = fieldKeys.indexOf(key);
+          idx > -1 && fieldKeys.splice(idx, 1), notifyObservers();
+        };
+      },
+      next(key, rects) {
+        channels.from.set(key, rects), configKeys.includes(key) && notifyObservers();
+      }
+    }
+  };
+}
+function ConnectorsProvider(props) {
+  const { children, onConnectorsChange } = props, store = useMemo(() => createConnectorsStore(), []);
+  return useEffect(
+    () => onConnectorsChange && store.connectors.subscribe(onConnectorsChange),
+    [onConnectorsChange, store]
+  ), /* @__PURE__ */ jsx(ConnectorsStoreContext.Provider, { value: store, children });
+}
+function getConnectorLinePoint(options2, rect, bounds) {
+  const centerY = rect.y + rect.h / 2, isAbove = rect.y + rect.h < bounds.y + options2.arrow.marginY, isBelow = rect.y > bounds.y + bounds.h - options2.arrow.marginY;
+  return {
+    bounds,
+    x: rect.x,
+    y: centerY,
+    centerY,
+    startY: rect.y + options2.path.marginY,
+    endY: rect.y + rect.h - options2.path.marginY,
+    isAbove,
+    isBelow,
+    outOfBounds: isAbove || isBelow
+  };
+}
+function mapConnectorToLine(options2, connector) {
+  const fromBounds = {
+    y: connector.from.bounds.y + options2.arrow.threshold,
+    // bottom: connector.from.bounds.y + connector.from.bounds.h - options.arrow.threshold,
+    x: connector.from.bounds.x,
+    // right: connector.from.bounds.x + connector.from.bounds.w,
+    w: connector.from.bounds.w,
+    h: connector.from.bounds.h - options2.arrow.threshold * 2
+  }, from = getConnectorLinePoint(options2, connector.from.element, fromBounds);
+  from.x = connector.from.element.x + connector.from.element.w;
+  const fromBottom = fromBounds.y + fromBounds.h, toBounds = {
+    y: connector.to.bounds.y + options2.arrow.threshold,
+    // bottom: connector.to.bounds.y + connector.to.bounds.h - options.arrow.threshold,
+    x: connector.to.bounds.x,
+    // right: connector.to.bounds.x + connector.to.bounds.w,
+    w: connector.to.bounds.w,
+    h: connector.to.bounds.h - options2.arrow.threshold * 2
+  }, toBottom = toBounds.y + toBounds.h, to = getConnectorLinePoint(options2, connector.to.element, toBounds), maxStartY = Math.max(to.startY, from.startY);
+  return from.y = Math.min(maxStartY, from.endY), from.y < toBounds.y ? from.y = Math.min(toBounds.y, from.endY) : from.y > toBottom && (from.y = Math.max(toBottom, from.startY)), to.y = Math.min(maxStartY, to.endY), to.y < fromBounds.y ? to.y = Math.min(fromBounds.y, to.endY) : to.y > fromBottom && (to.y = Math.max(fromBottom, to.startY)), from.y = Math.min(Math.max(from.y, fromBounds.y), fromBottom), to.y = Math.min(Math.max(to.y, toBounds.y), toBottom), { from, to };
+}
+function arrowPath(options2, x, y, dir) {
+  return [
+    `M ${x - options2.arrow.size} ${y - options2.arrow.size * dir} `,
+    `L ${x} ${y}`,
+    `L ${x + options2.arrow.size} ${y - options2.arrow.size * dir}`
+  ].join("");
+}
+function moveTo(x, y) {
+  return `M${x} ${y}`;
+}
+function lineTo(x, y) {
+  return `L${x} ${y}`;
+}
+function join(strings, delim = "") {
+  return strings.join(delim);
+}
+function quadCurve(x1, y1, x, y) {
+  return `Q${x1} ${y1} ${x} ${y}`;
+}
+function drawConnectorPath(options2, line) {
+  const { cornerRadius } = options2.path, { from, to } = line, { x: fromX, y: fromY } = from, { x: _toX, y: toY } = to, toX = _toX - 1, dividerX = to.bounds.x + options2.divider.offsetX, fromPathX = from.isAbove || from.isBelow ? fromX + options2.arrow.marginX : fromX, r0 = Math.min(cornerRadius, Math.abs(fromPathX - dividerX) / 2), r1 = Math.min(cornerRadius, Math.abs(fromY - toY) / 2), cmds = [];
+  return from.isAbove ? cmds.push(
+    moveTo(
+      fromX + options2.arrow.marginX,
+      fromY - options2.arrow.threshold + options2.arrow.marginY
+    ),
+    lineTo(fromX + options2.arrow.marginX, fromY - r0),
+    quadCurve(fromX + options2.arrow.marginX, fromY, fromX + options2.arrow.marginX + r0, fromY)
+  ) : from.isBelow ? cmds.push(
+    moveTo(
+      fromX + options2.arrow.marginX,
+      fromY + options2.arrow.threshold - options2.arrow.marginY
+    ),
+    lineTo(fromX + options2.arrow.marginX, fromY + r0),
+    quadCurve(fromX + options2.arrow.marginX, fromY, fromX + options2.arrow.marginX + r0, fromY)
+  ) : cmds.push(moveTo(fromX, fromY)), to.isAbove ? fromY < to.bounds.y ? cmds.push(
+    lineTo(dividerX - r1, fromY),
+    quadCurve(dividerX, fromY, dividerX, fromY + r1),
+    lineTo(dividerX, toY - r1),
+    quadCurve(dividerX, toY, dividerX + r1, toY),
+    lineTo(dividerX - cornerRadius, toY),
+    quadCurve(dividerX, toY, dividerX, toY - cornerRadius),
+    lineTo(dividerX, toY - options2.arrow.threshold + options2.arrow.marginY)
+  ) : cmds.push(
+    lineTo(dividerX - cornerRadius, fromY),
+    quadCurve(dividerX, fromY, dividerX, fromY - cornerRadius),
+    lineTo(dividerX, toY - options2.arrow.threshold + options2.arrow.marginY)
+  ) : to.isBelow ? fromY > to.bounds.y + to.bounds.h ? cmds.push(
+    lineTo(dividerX - options2.arrow.marginX - r1, fromY),
+    quadCurve(
+      dividerX - options2.arrow.marginX,
+      fromY,
+      dividerX - options2.arrow.marginX,
+      fromY - r1
+    ),
+    lineTo(dividerX - options2.arrow.marginX, toY + r1),
+    quadCurve(
+      dividerX - options2.arrow.marginX,
+      toY,
+      dividerX - options2.arrow.marginX + r1,
+      toY
+    ),
+    lineTo(dividerX - cornerRadius, toY),
+    quadCurve(dividerX, toY, dividerX, toY + cornerRadius),
+    lineTo(dividerX, toY + options2.arrow.threshold - options2.arrow.marginY)
+  ) : cmds.push(
+    lineTo(dividerX - cornerRadius, fromY),
+    quadCurve(dividerX, fromY, dividerX, fromY + cornerRadius),
+    lineTo(dividerX, toY + options2.arrow.threshold - options2.arrow.marginY)
+  ) : fromY < toY ? cmds.push(
+    lineTo(dividerX - r0, fromY),
+    quadCurve(dividerX, fromY, dividerX, fromY + r1),
+    lineTo(dividerX, toY - r1),
+    quadCurve(dividerX, toY, dividerX + r1, toY),
+    lineTo(toX, toY)
+  ) : cmds.push(
+    lineTo(dividerX - Math.min(r0, r1), fromY),
+    quadCurve(dividerX, fromY, dividerX, fromY - Math.min(r0, r1)),
+    lineTo(dividerX, toY + r1),
+    quadCurve(dividerX, toY, dividerX + r1, toY),
+    lineTo(toX, toY)
+  ), join(cmds);
+}
+function ConnectorPath(props) {
+  const { from, options: options2, to } = props, { strokeWidth } = options2.path, theme = useTheme(), line = useMemo(() => mapConnectorToLine(options2, { from, to }), [from, options2, to]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: drawConnectorPath(options2, line),
+        stroke: theme.sanity.color.base.bg,
+        strokeWidth: strokeWidth + 4
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: drawConnectorPath(options2, line),
+        stroke: rgba(theme.sanity.color.base.border, 0.5),
+        strokeWidth
+      }
+    ),
+    line.from.isAbove && /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: arrowPath(
+          options2,
+          line.from.x + options2.arrow.marginX,
+          line.from.bounds.y - options2.arrow.threshold + options2.arrow.marginY,
+          -1
+        ),
+        stroke: theme.sanity.color.base.border,
+        strokeWidth
+      }
+    ),
+    line.from.isBelow && /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: arrowPath(
+          options2,
+          line.from.x + options2.arrow.marginX,
+          line.from.bounds.y + line.from.bounds.h + options2.arrow.threshold - options2.arrow.marginY,
+          1
+        ),
+        stroke: theme.sanity.color.base.border,
+        strokeWidth
+      }
+    )
+  ] });
+}
+const DEBUG = !1, options = {
+  arrow: {
+    marginX: 10.5,
+    marginY: 5,
+    size: 4,
+    threshold: 16.5
+  },
+  divider: {
+    offsetX: -10.5
+  },
+  path: {
+    cornerRadius: 3,
+    marginY: 10.5,
+    strokeWidth: 1
+  }
+};
+function AssistConnectorsOverlay(props) {
+  const { connectors } = props, [, setRedraw] = useState(!1);
+  return useEffect(() => {
+    setRedraw(!0);
+  }, []), /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "svg",
+      {
+        fill: "none",
+        width: window.innerWidth,
+        height: window.innerHeight,
+        style: {
+          position: "absolute",
+          top: 0,
+          left: 0,
+          width: "100%",
+          height: "100%",
+          pointerEvents: "none",
+          zIndex: 150
+          // zIndex,
+        },
+        children: connectors.map((connector) => /* @__PURE__ */ jsx(
+          ConnectorPath,
+          {
+            from: connector.from,
+            options,
+            to: connector.to
+          },
+          connector.key
+        ))
+      }
+    ),
+    DEBUG
+  ] });
+}
+const getLanguageParams = (select, document2) => {
+  if (!select || !document2)
+    return {};
+  const selection = select || {}, selectedValue = {};
+  for (const [key, path] of Object.entries(selection)) {
+    let value = get(document2, path);
+    Array.isArray(value) && (value = value.filter(
+      (item) => typeof item == "object" ? (item == null ? void 0 : item._type) !== "reference" || "_ref" in item : !0
+    )), selectedValue[key] = value;
+  }
+  return selectedValue;
+}, toFieldLanguagesKeyPrefix = "sanityStudio:assist:field-languages:from:";
+function getPreferredToFieldLanguages(fromLanguageId) {
+  if (typeof localStorage > "u")
+    return [];
+  const value = localStorage.getItem(`${toFieldLanguagesKeyPrefix}${fromLanguageId}`);
+  return value ? JSON.parse(value) : [];
+}
+function setPreferredToFieldLanguages(fromLanguageId, languageIds) {
+  typeof localStorage > "u" || localStorage.setItem(`${toFieldLanguagesKeyPrefix}${fromLanguageId}`, JSON.stringify(languageIds));
+}
+const FieldTranslationContext = createContext({
+  openFieldTranslation: () => {
+  },
+  translationLoading: !1
+});
+function useFieldTranslation() {
+  return useContext(FieldTranslationContext);
+}
+function hasValuesToTranslate(fieldLanguageMaps, fromLanguage, basePath2) {
+  return fieldLanguageMaps == null ? void 0 : fieldLanguageMaps.some(
+    (map) => map.inputLanguageId === (fromLanguage == null ? void 0 : fromLanguage.id) && map.inputPath && pathToString(map.inputPath).startsWith(pathToString(basePath2))
+  );
+}
+function FieldTranslationProvider(props) {
+  var _a, _b, _c;
+  const { config: assistConfig } = useAiAssistanceConfig(), apiClient = useApiClient(assistConfig.__customApiClient), config = (_a = assistConfig.translate) == null ? void 0 : _a.field, { translate: runTranslate } = useTranslate(apiClient), [dialogOpen, setDialogOpen] = useState(!1), [fieldTranslationParams, setFieldTranslationParams] = useState(), [languages, setLanguages] = useState(), [fromLanguage, setFromLanguage] = useState(void 0), [toLanguages, setToLanguages] = useState(void 0), [fieldLanguageMaps, setFieldLanguageMaps] = useState(), close = useCallback(() => {
+    setDialogOpen(!1), setLanguages(void 0), setFieldTranslationParams(void 0);
+  }, []), languageClient = useClient({ apiVersion: (_b = config == null ? void 0 : config.apiVersion) != null ? _b : "2022-11-27" }), documentId = (_c = fieldTranslationParams == null ? void 0 : fieldTranslationParams.document) == null ? void 0 : _c._id, id = useId(), selectFromLanguage = useCallback(
+    (from, languages2, params) => {
+      var _a2, _b2;
+      const { document: document2, documentSchema } = params != null ? params : {};
+      if (setFromLanguage(from), !document2 || !documentSchema || !params || !languages2) {
+        setFieldLanguageMaps(void 0);
+        return;
+      }
+      const preferred = getPreferredToFieldLanguages(from.id), allToLanguages = languages2.filter((l) => l.id !== (from == null ? void 0 : from.id)), filteredToLanguages = allToLanguages.filter(
+        (l) => !preferred.length || preferred.includes(l.id)
+      );
+      setToLanguages(filteredToLanguages);
+      const fromId = from == null ? void 0 : from.id, allToIds = (_a2 = allToLanguages == null ? void 0 : allToLanguages.map((l) => l.id)) != null ? _a2 : [], docMembers = getDocumentMembersFlat(document2, documentSchema);
+      if (fromId && allToIds != null && allToIds.length) {
+        const transMap = getFieldLanguageMap(
+          documentSchema,
+          docMembers,
+          fromId,
+          allToIds.filter((toId) => fromId !== toId),
+          (_b2 = config == null ? void 0 : config.translationOutputs) != null ? _b2 : defaultLanguageOutputs
+        );
+        setFieldLanguageMaps(transMap);
+      } else
+        setFieldLanguageMaps(void 0);
+    },
+    [config]
+  ), toggleToLanguage = useCallback(
+    (toggledLang, toLanguages2, languages2) => {
+      if (!languages2 || !fromLanguage)
+        return;
+      const wasSelected = !!(toLanguages2 != null && toLanguages2.find((l) => l.id === toggledLang.id)), newToLangs = languages2.filter(
+        (anyLang) => !!(toLanguages2 != null && toLanguages2.find(
+          (selectedLang) => toggledLang.id !== selectedLang.id && selectedLang.id === anyLang.id
+        )) || toggledLang.id === anyLang.id && !wasSelected
+      );
+      setToLanguages(newToLangs), setPreferredToFieldLanguages(
+        fromLanguage.id,
+        newToLangs.map((l) => l.id)
+      );
+    },
+    [fromLanguage]
+  ), openFieldTranslation = useCallback(
+    async (params) => {
+      setDialogOpen(!0);
+      const languageParams = getLanguageParams(config == null ? void 0 : config.selectLanguageParams, params.document), languages2 = await (typeof (config == null ? void 0 : config.languages) == "function" ? config == null ? void 0 : config.languages(languageClient, languageParams) : Promise.resolve(config == null ? void 0 : config.languages));
+      setLanguages(languages2), setFieldTranslationParams(params);
+      const fromLanguage2 = languages2 == null ? void 0 : languages2[0];
+      fromLanguage2 ? selectFromLanguage(fromLanguage2, languages2, params) : console.error("No languages available for selected language params", languageParams);
+    },
+    [selectFromLanguage, config, languageClient]
+  ), contextValue = useMemo(() => ({
+    openFieldTranslation,
+    translationLoading: !1
+  }), [openFieldTranslation]), runDisabled = !fromLanguage || !(toLanguages != null && toLanguages.length) || !(fieldLanguageMaps != null && fieldLanguageMaps.length) || !documentId || !hasValuesToTranslate(fieldLanguageMaps, fromLanguage, fieldTranslationParams.translatePath), onRunTranslation = useCallback(() => {
+    const translatePath = fieldTranslationParams == null ? void 0 : fieldTranslationParams.translatePath;
+    fieldLanguageMaps && documentId && translatePath && runTranslate({
+      documentId,
+      translatePath,
+      fieldLanguageMap: fieldLanguageMaps.map((map) => ({
+        ...map,
+        // eslint-disable-next-line max-nested-callbacks
+        outputs: map.outputs.filter((out) => !!(toLanguages != null && toLanguages.find((l) => l.id === out.id)))
+      })),
+      conditionalMembers: fieldTranslationParams == null ? void 0 : fieldTranslationParams.conditionalMembers
+    }), close();
+  }, [
+    fieldLanguageMaps,
+    documentId,
+    runTranslate,
+    close,
+    toLanguages,
+    fieldTranslationParams == null ? void 0 : fieldTranslationParams.translatePath,
+    fieldTranslationParams == null ? void 0 : fieldTranslationParams.conditionalMembers
+  ]), runButton = /* @__PURE__ */ jsx(
+    Button,
+    {
+      text: "Translate",
+      tone: "primary",
+      icon: PlayIcon,
+      style: { width: "100%" },
+      disabled: runDisabled,
+      onClick: onRunTranslation
+    }
+  );
+  return /* @__PURE__ */ jsxs(FieldTranslationContext.Provider, { value: contextValue, children: [
+    dialogOpen ? /* @__PURE__ */ jsx(
+      Dialog,
+      {
+        id,
+        width: 1,
+        open: dialogOpen,
+        onClose: close,
+        header: "Translate fields",
+        footer: /* @__PURE__ */ jsx(Flex, { justify: "space-between", padding: 2, flex: 1, children: runDisabled ? /* @__PURE__ */ jsx(
+          Tooltip,
+          {
+            content: /* @__PURE__ */ jsx(Flex, { padding: 2, children: /* @__PURE__ */ jsx(Text, { children: "There is nothing to translate in the selected from-language." }) }),
+            placement: "top",
+            children: /* @__PURE__ */ jsx(Flex, { flex: 1, children: runButton })
+          }
+        ) : runButton }),
+        children: languages ? /* @__PURE__ */ jsxs(Flex, { padding: 4, gap: 5, align: "flex-start", justify: "center", children: [
+          /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+            /* @__PURE__ */ jsx(Box, { marginBottom: 2, children: /* @__PURE__ */ jsx(Text, { weight: "semibold", children: "From" }) }),
+            languages == null ? void 0 : languages.map((radioLanguage) => /* @__PURE__ */ jsx(
+              FromLanguageRadio,
+              {
+                radioLanguage,
+                fromLanguage,
+                selectFromLanguage,
+                languages,
+                fieldTranslationParams
+              },
+              radioLanguage.id
+            ))
+          ] }),
+          /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+            /* @__PURE__ */ jsx(Box, { marginBottom: 2, children: /* @__PURE__ */ jsx(Text, { weight: "semibold", children: "To" }) }),
+            languages.map((checkboxLanguage) => /* @__PURE__ */ jsx(
+              ToLanguageCheckbox,
+              {
+                checkboxLanguage,
+                fromLanguage,
+                toLanguages,
+                toggleToLanguage,
+                languages
+              },
+              checkboxLanguage.id
+            ))
+          ] })
+        ] }) : /* @__PURE__ */ jsxs(Flex, { padding: 4, gap: 2, align: "flex-start", justify: "center", children: [
+          /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Spinner, {}) }),
+          /* @__PURE__ */ jsx(Text, { children: "Loading languages..." })
+        ] })
+      }
+    ) : null,
+    props.children
+  ] });
+}
+function ToLanguageCheckbox(props) {
+  var _a;
+  const { checkboxLanguage, fromLanguage, toLanguages, toggleToLanguage, languages } = props, langId = checkboxLanguage.id, onChange = useCallback(
+    () => toggleToLanguage(checkboxLanguage, toLanguages, languages),
+    [toggleToLanguage, checkboxLanguage, toLanguages, languages]
+  );
+  return /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      gap: 3,
+      align: "center",
+      as: "label",
+      style: langId === (fromLanguage == null ? void 0 : fromLanguage.id) ? { opacity: 0.5 } : void 0,
+      children: [
+        /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            name: "toLang",
+            value: langId,
+            checked: langId !== (fromLanguage == null ? void 0 : fromLanguage.id) && !!(toLanguages != null && toLanguages.find((tl) => tl.id === langId)),
+            onChange,
+            disabled: langId === (fromLanguage == null ? void 0 : fromLanguage.id)
+          }
+        ),
+        /* @__PURE__ */ jsx(Text, { muted: langId === (fromLanguage == null ? void 0 : fromLanguage.id), children: (_a = checkboxLanguage.title) != null ? _a : langId })
+      ]
+    },
+    langId
+  );
+}
+function FromLanguageRadio(props) {
+  var _a;
+  const { languages, radioLanguage, selectFromLanguage, fromLanguage, fieldTranslationParams } = props, langId = radioLanguage.id, onChange = useCallback(
+    () => selectFromLanguage(radioLanguage, languages, fieldTranslationParams),
+    [selectFromLanguage, radioLanguage, languages, fieldTranslationParams]
+  );
+  return /* @__PURE__ */ jsxs(Flex, { gap: 3, align: "center", as: "label", children: [
+    /* @__PURE__ */ jsx(
+      Radio,
+      {
+        name: "fromLang",
+        value: langId,
+        checked: langId === (fromLanguage == null ? void 0 : fromLanguage.id),
+        onChange
+      }
+    ),
+    /* @__PURE__ */ jsx(Text, { children: (_a = radioLanguage.title) != null ? _a : radioLanguage.id })
+  ] }, langId);
+}
+function AssistLayout(props) {
+  const [connectors, setConnectors] = useState([]);
+  return /* @__PURE__ */ jsx(AiAssistanceConfigProvider, { config: props.config, children: /* @__PURE__ */ jsx(RunInstructionProvider, { children: /* @__PURE__ */ jsx(FieldTranslationProvider, { children: /* @__PURE__ */ jsxs(ConnectorsProvider, { onConnectorsChange: setConnectors, children: [
+    props.renderDefault(props),
+    /* @__PURE__ */ jsx(ThemeProvider, { tone: "default", children: /* @__PURE__ */ jsx(AssistConnectorsOverlay, { connectors }) })
+  ] }) }) }) });
+}
+const WrapPreCard = styled(Card)`
+  & pre {
+    white-space: pre-wrap !important;
+  }
+`;
+function SafeValueInput(props) {
+  return /* @__PURE__ */ jsx(ErrorWrapper, { onChange: props.onChange, children: /* @__PURE__ */ jsx(PteValueFixer, { ...props }) });
+}
+function ErrorWrapper(props) {
+  const { onChange } = props, [error, setError] = useState(), catchError2 = useCallback((params) => {
+    setError(params.error);
+  }, []), unsetValue = useCallback(() => {
+    onChange(PatchEvent.from(unset())), setError(void 0);
+  }, [onChange]), dismiss = useCallback(() => setError(void 0), []), catcher = /* @__PURE__ */ jsx(ErrorBoundary, { onCatch: catchError2, children: props.children });
+  return error ? /* @__PURE__ */ jsx(Card, { border: !0, tone: "critical", padding: 2, contentEditable: !1, children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+    /* @__PURE__ */ jsx(Text, { muted: !0, weight: "semibold", children: "An error occurred." }),
+    /* @__PURE__ */ jsx(WrapPreCard, { flex: 1, padding: 2, tone: "critical", border: !0, children: catcher }),
+    /* @__PURE__ */ jsxs(Flex, { width: "fill", flex: 1, gap: 3, children: [
+      /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsx(Button, { text: "Dismiss", onClick: dismiss, tone: "primary" }) }),
+      /* @__PURE__ */ jsx(Button, { text: "Unset value", onClick: unsetValue, tone: "critical" })
+    ] })
+  ] }) }) : catcher;
+}
+function PteValueFixer(props) {
+  const isPortableText = useMemo(
+    () => isArraySchemaType(props.schemaType) && isPortableTextArray(props.schemaType),
+    [props.schemaType]
+  ), value = props.value;
+  return isPortableText && value && !value.length ? props.renderDefault({ ...props, value: void 0 }) : props.renderDefault(props);
+}
+function AssistFormBlock(props) {
+  const presence = useAssistPresence(props.path, !0), { onChange } = useFormCallbacks(), key = props.value._key, localOnChange = useCallback(
+    (patchEvent) => {
+      key && onChange(PatchEvent.from(patchEvent).prefixAll({ _key: key }));
+    },
+    [onChange, key]
+  ), singlePresence = presence[0];
+  return /* @__PURE__ */ jsx(ErrorWrapper, { onChange: localOnChange, children: /* @__PURE__ */ jsxs(Flex, { align: "center", justify: "space-between", children: [
+    /* @__PURE__ */ jsx(Box, { flex: 1, children: props.renderDefault(props) }),
+    singlePresence && /* @__PURE__ */ jsx(AiFieldPresence, { presence: singlePresence })
+  ] }) });
+}
+function AssistItem(props) {
+  const { path } = props, presence = useAssistPresence(path, !0);
+  return /* @__PURE__ */ jsxs(Flex, { align: "center", width: "fill", style: { position: "relative" }, children: [
+    /* @__PURE__ */ jsx(Box, { flex: 1, children: props.renderDefault({ ...props }) }),
+    presence.map((pre) => /* @__PURE__ */ jsx(Box, { style: { position: "absolute", right: 35 }, children: /* @__PURE__ */ jsx(AiFieldPresence, { presence: pre }) }, pre.user.id))
+  ] });
+}
+const InlineBlockValueContext = createContext(void 0);
+function AssistInlineFormBlock(props) {
+  return /* @__PURE__ */ jsx(InlineBlockValueContext.Provider, { value: props.value, children: /* @__PURE__ */ jsx(Fragment, { children: props.renderDefault(props) }) });
+}
+function FieldRefPreview(props) {
+  var _a, _b, _c, _d;
+  const documentSchema = (_a = useContext(SelectedFieldContext)) == null ? void 0 : _a.documentSchema, path = (_c = (_b = useContext(InlineBlockValueContext)) == null ? void 0 : _b.path) != null ? _c : props.path, selectedField = useSelectedField(documentSchema, path);
+  return /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "center", style: { width: "100%" }, children: [
+    /* @__PURE__ */ jsx(Flex, { flex: 1, gap: 2, align: "center", paddingY: 3, paddingX: 1, children: /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { size: 1, textOverflow: "ellipsis", children: (_d = selectedField == null ? void 0 : selectedField.title) != null ? _d : "Select field" }) }) }),
+    /* @__PURE__ */ jsx(Fragment, { children: props.actions })
+  ] });
+}
+function HiddenFieldTitle(props) {
+  return props.renderDefault({ ...props, title: "", level: props.level - 2, changed: !1 });
+}
+function IconInput(props) {
+  const { value, onChange } = props, id = useId(), items = useMemo(
+    () => Object.entries(icons).map(([key, icon]) => /* @__PURE__ */ jsx(IconItem, { iconKey: key, icon, onChange }, key)),
+    [onChange]
+  ), selectedIcon = useMemo(() => getIcon(value), [value]);
+  return /* @__PURE__ */ jsx(
+    MenuButton,
+    {
+      button: /* @__PURE__ */ jsx(Button, { icon: selectedIcon, title: "Select icon", padding: 3, mode: "ghost", radius: 1 }),
+      id,
+      menu: /* @__PURE__ */ jsx(Menu, { style: { maxHeight: 300 }, children: items }),
+      popover: { portal: !0 }
+    }
+  );
+}
+function IconItem({
+  icon,
+  iconKey: key,
+  onChange
+}) {
+  const onClick = useCallback(() => onChange(set(key)), [onChange, key]);
+  return /* @__PURE__ */ jsx(MenuItem, { icon, title: key, text: key, onClick });
+}
+function getIcon(iconName) {
+  var _a, _b;
+  return (_b = (_a = Object.entries(icons).find(([key]) => key === iconName)) == null ? void 0 : _a[1]) != null ? _b : icons.sparkles;
+}
+function InstructionVisibility(props) {
+  const { value, onChange } = props, user = useCurrentUser(), handleChange = useCallback(() => {
+    var _a;
+    const newValue = value ? "" : (_a = user == null ? void 0 : user.id) != null ? _a : "";
+    onChange(newValue ? set(newValue) : unset());
+  }, [onChange, user, value]), id = useId();
+  return /* @__PURE__ */ jsx(Card, { children: /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "flex-start", children: [
+    /* @__PURE__ */ jsx("div", { style: { margin: "-3px 0" }, children: /* @__PURE__ */ jsx(
+      Switch,
+      {
+        ...props.elementProps,
+        id,
+        value: `${!value}`,
+        checked: !value,
+        onChange: handleChange,
+        disabled: props.elementProps.readOnly
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, weight: "medium", children: /* @__PURE__ */ jsx("label", { htmlFor: id, children: "Make visible to all Studio members" }) })
+  ] }) });
+}
+function FieldRefPathInput(props) {
+  var _a;
+  const documentSchema = (_a = useContext(SelectedFieldContext)) == null ? void 0 : _a.documentSchema, typePath = useContext(TypePathContext), ref = useRef(null), id = useId(), { onChange } = props;
+  useEffect(() => {
+    var _a2, _b;
+    (_b = (_a2 = ref.current) == null ? void 0 : _a2.querySelector("input")) == null || _b.focus();
+  }, []);
+  const onSelect = useCallback((path) => onChange(set(path)), [onChange]), filter2 = useCallback(
+    (field) => {
+      if (!field.key.includes("|") || !typePath)
+        return !0;
+      if (field.key.includes("|") && !typePath.includes("|"))
+        return !1;
+      const fieldSegments = field.key.split("."), lastArrayItemIndex = fieldSegments.findLastIndex((s) => s.includes("|")), mustStartWith = fieldSegments.slice(0, lastArrayItemIndex + 1).join(".");
+      return typePath.startsWith(mustStartWith);
+    },
+    [typePath]
+  );
+  return documentSchema ? /* @__PURE__ */ jsx(Box, { flex: 1, style: { minWidth: 300 }, ref, children: /* @__PURE__ */ jsx(
+    FieldAutocomplete,
+    {
+      id,
+      schemaType: documentSchema,
+      onSelect,
+      fieldPath: props.value,
+      filter: filter2
+    }
+  ) }) : props.renderDefault(props);
+}
+function findFieldMember(members, fieldName) {
+  return members.find(
+    (m) => m.kind === "field" && m.name === fieldName || m.kind === "error" && m.fieldName === fieldName
+  );
+}
+function findFieldsetMember(members, fieldsetName) {
+  return members.find(
+    (m) => m.kind === "fieldSet" && m.fieldSet.name === fieldsetName
+  );
+}
+function InstructionInput(props) {
+  return /* @__PURE__ */ jsxs(Stack, { space: [4, 4, 4, 5], children: [
+    /* @__PURE__ */ jsx(NameField, { ...props }),
+    /* @__PURE__ */ jsx(ShareField, { ...props }),
+    /* @__PURE__ */ jsx(ObjectMember, { fieldName: "prompt", ...props }),
+    /* @__PURE__ */ jsx(ObjectMember, { fieldName: "output", ...props })
+  ] });
+}
+function ObjectMember({ fieldName, ...props }) {
+  const member = findFieldMember(props.members, fieldName);
+  return member ? /* @__PURE__ */ jsx(ObjectInputMember, { ...props, member }) : null;
+}
+const NONE = [];
+function NameField(props) {
+  var _a;
+  const fieldsetMember = findFieldsetMember(props.members, "appearance"), titleId = useId(), members = (_a = fieldsetMember == null ? void 0 : fieldsetMember.fieldSet.members) != null ? _a : NONE, iconMember = findFieldMember(members, "icon"), titleMember = findFieldMember(members, "title"), titlePlaceholder = "Untitled", moddedTitleMember = useMemo(() => {
+    if (titleMember)
+      return titleMember.kind === "error" ? titleMember : {
+        ...titleMember,
+        field: {
+          ...titleMember == null ? void 0 : titleMember.field,
+          schemaType: {
+            ...titleMember == null ? void 0 : titleMember.field.schemaType,
+            placeholder: titlePlaceholder
+          }
+        }
+      };
+  }, [titleMember, titlePlaceholder]);
+  return /* @__PURE__ */ jsx(Stack, { space: 5, children: /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+    /* @__PURE__ */ jsx(Flex, { gap: 1, children: /* @__PURE__ */ jsx(Text, { as: "label", weight: "semibold", size: 1, htmlFor: titleId, children: "Name" }) }),
+    /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: "How this instruction appears in menus" }),
+    /* @__PURE__ */ jsxs(Flex, { align: "center", children: [
+      iconMember && /* @__PURE__ */ jsx(Box, { flex: "none", children: /* @__PURE__ */ jsx(ObjectInputMember, { ...props, member: iconMember }) }),
+      moddedTitleMember && /* @__PURE__ */ jsx(Box, { flex: 1, style: { marginLeft: -1 }, children: /* @__PURE__ */ jsx(ObjectInputMember, { ...props, member: moddedTitleMember }) })
+    ] })
+  ] }) });
+}
+function ShareField(props) {
+  var _a;
+  const fieldsetMember = findFieldsetMember(props.members, "appearance"), members = (_a = fieldsetMember == null ? void 0 : fieldsetMember.fieldSet.members) != null ? _a : NONE, visibilityMember = findFieldMember(members, "userId");
+  return /* @__PURE__ */ jsx(Fragment, { children: visibilityMember && /* @__PURE__ */ jsx(ObjectInputMember, { ...props, member: visibilityMember }) });
+}
+function InstructionOutputField(props) {
+  var _a;
+  const { fieldSchema } = (_a = useContext(SelectedFieldContext)) != null ? _a : {};
+  return !fieldSchema || !(isObjectSchemaType(fieldSchema) || isArrayOfObjectsSchemaType(fieldSchema)) ? null : /* @__PURE__ */ jsx(EnabledOutputField, { ...props, fieldSchema, children: props.children });
+}
+function EnabledOutputField({
+  fieldSchema,
+  ...props
+}) {
+  var _a;
+  const [open, setOpen] = useState(!!((_a = props.value) != null && _a.length)), onExpand = useCallback(() => setOpen(!0), []), onCollapse = useCallback(() => setOpen(!1), []);
+  return props.renderDefault({
+    ...props,
+    collapsible: !0,
+    onExpand,
+    onCollapse,
+    collapsed: !open,
+    level: 1,
+    title: isObjectSchemaType(fieldSchema) ? "Allowed fields" : "Allowed types"
+  });
+}
+function InstructionOutputInput(props) {
+  var _a;
+  const { fieldSchema } = (_a = useContext(SelectedFieldContext)) != null ? _a : {};
+  return fieldSchema ? isObjectSchemaType(fieldSchema) ? /* @__PURE__ */ jsx(ObjectOutputInput, { ...props, fieldSchema }) : isArrayOfObjectsSchemaType(fieldSchema) ? /* @__PURE__ */ jsx(ArrayOutputInput, { ...props, fieldSchema }) : null : null;
+}
+function useEmptySelectAllValue(value, allowedValues, onChange) {
+  useEffect(() => {
+    var _a, _b;
+    const validValues = value == null ? void 0 : value.filter(
+      (v) => allowedValues.find(
+        (f) => f.name === (v._type === outputFieldTypeName ? v.relativePath : v.type)
+      )
+    ), valueLength = (_a = value == null ? void 0 : value.length) != null ? _a : 0, validLength = (_b = validValues == null ? void 0 : validValues.length) != null ? _b : 0;
+    (!validLength && valueLength || validLength >= allowedValues.length) && onChange(PatchEvent.from([unset()]));
+  }, [allowedValues, value, onChange]);
+}
+function ObjectOutputInput({
+  fieldSchema,
+  ...props
+}) {
+  const { value, onChange } = props, fields = useMemo(
+    () => fieldSchema.fields.filter((field) => isAssistSupported(field.type)),
+    [fieldSchema.fields]
+  );
+  useEmptySelectAllValue(value, fields, onChange);
+  const onSelectChange = useCallback(
+    (checked, selectedValue) => {
+      if (checked)
+        if (value != null && value.length)
+          onChange(PatchEvent.from(unset([{ _key: selectedValue }])));
+        else {
+          const items = fields.filter((f) => f.name !== selectedValue).map(
+            (field) => typed({
+              _key: field.name,
+              _type: "sanity.assist.output.field",
+              relativePath: field.name
+            })
+          );
+          onChange(PatchEvent.from([setIfMissing([]), insert(items, "after", [-1])]));
+        }
+      else {
+        const patchValue = {
+          _key: selectedValue,
+          _type: "sanity.assist.output.field",
+          relativePath: selectedValue
+        };
+        onChange(PatchEvent.from([setIfMissing([]), insert([patchValue], "after", [-1])]));
+      }
+    },
+    [onChange, value, fields]
+  );
+  return /* @__PURE__ */ jsx(Stack, { space: 2, children: fields.map((field) => {
+    var _a;
+    return /* @__PURE__ */ jsx(Flex, { align: "center", gap: 2, children: /* @__PURE__ */ jsx(
+      Selectable,
+      {
+        value: field.name,
+        title: (_a = field.type.title) != null ? _a : field.name,
+        arrayValue: value,
+        onChange: onSelectChange
+      }
+    ) }, field.name);
+  }) });
+}
+function ArrayOutputInput({
+  fieldSchema,
+  ...props
+}) {
+  const { value, onChange } = props, ofItems = useMemo(
+    () => fieldSchema.of.filter((itemType) => isAssistSupported(itemType)),
+    [fieldSchema.of]
+  );
+  useEmptySelectAllValue(value, ofItems, onChange);
+  const onSelectChange = useCallback(
+    (checked, selectedValue) => {
+      if (checked)
+        if (value != null && value.length)
+          onChange(PatchEvent.from(unset([{ _key: selectedValue }])));
+        else {
+          const items = ofItems.filter((f) => f.name !== selectedValue).map(
+            (field) => typed({
+              _key: field.name,
+              _type: "sanity.assist.output.type",
+              type: field.name
+            })
+          );
+          onChange(PatchEvent.from([setIfMissing([]), insert(items, "after", [-1])]));
+        }
+      else {
+        const patchValue = {
+          _key: selectedValue,
+          _type: "sanity.assist.output.type",
+          type: selectedValue
+        };
+        onChange(PatchEvent.from([setIfMissing([]), insert([patchValue], "after", [-1])]));
+      }
+    },
+    [onChange, value, ofItems]
+  );
+  return /* @__PURE__ */ jsx(Stack, { space: 2, children: ofItems.map((itemType) => {
+    var _a;
+    return /* @__PURE__ */ jsx(Flex, { children: /* @__PURE__ */ jsx(
+      Selectable,
+      {
+        value: itemType.name,
+        title: isType(itemType, "block") ? "Text" : (_a = itemType.title) != null ? _a : itemType.name,
+        arrayValue: value,
+        onChange: onSelectChange
+      }
+    ) }, itemType.name);
+  }) });
+}
+function Selectable({
+  title,
+  arrayValue,
+  value,
+  onChange
+}) {
+  const checked = !(arrayValue != null && arrayValue.length) || !!(arrayValue != null && arrayValue.find((v) => v._key === value)), handleChange = useCallback(() => onChange(checked, value), [onChange, checked, value]);
+  return /* @__PURE__ */ jsxs(Flex, { gap: 2, align: "flex-start", children: [
+    /* @__PURE__ */ jsx(Checkbox, { checked, onChange: handleChange }),
+    /* @__PURE__ */ jsx(Card, { marginTop: 1, onClick: handleChange, children: /* @__PURE__ */ jsx(Text, { style: { cursor: "default" }, size: 1, children: title }) })
+  ] });
+}
+function getRandomValues(typedArray) {
+  const crypto = typeof window < "u" && "crypto" in window ? window.crypto : globalThis.crypto;
+  if (!crypto || !crypto.getRandomValues)
+    throw new Error("WebCrypto not available in this environment");
+  return crypto.getRandomValues(typedArray);
+}
+function whatwgRNG(length = 16) {
+  const rnds8 = new Uint8Array(length);
+  return getRandomValues(rnds8), rnds8;
+}
+const getByteHexTable = /* @__PURE__ */ (() => {
+  let table;
+  return () => {
+    if (table)
+      return table;
+    table = [];
+    for (let i = 0; i < 256; ++i)
+      table[i] = (i + 256).toString(16).substring(1);
+    return table;
+  };
+})();
+function randomKey(length) {
+  const table = getByteHexTable();
+  return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
+}
+const PteMods = styled(Box)`
+  & [data-testid='pt-editor__toolbar-card'] > div > div:last-child {
+    display: none;
+  }
+  & [data-testid='pt-editor'] {
+    min-height: 300px;
+  }
+  & [data-testid='pt-editor'] .pt-inline-object * {
+    max-width: 400px;
+  }
+`;
+function PromptInput(props) {
+  return useOnlyInlineBlocks(props), /* @__PURE__ */ jsx(PteMods, { children: props.renderDefault(props) });
+}
+function useOnlyInlineBlocks(props) {
+  useEffect(() => {
+    var _a;
+    let needsFix = !1;
+    const val = ((_a = props.value) != null ? _a : []).map((block) => block._type === "block" ? block : (needsFix = !0, typed({
+      _key: randomKey(12),
+      _type: "block",
+      level: 0,
+      markDefs: [],
+      style: "normal",
+      children: [block]
+    })));
+    needsFix && props.onChange(set(val));
+  }, []);
+}
+function InstructionsArrayField(props) {
+  return props.renderDefault({
+    ...props,
+    title: " "
+  });
+}
+function InstructionsArrayInput(props) {
+  const user = useCurrentUser(), originalValue = props.value, originalMembers = props.members, value = useMemo(
+    () => (originalValue != null ? originalValue : []).filter((v) => !v.userId || v.userId === (user == null ? void 0 : user.id)),
+    [originalValue, user]
+  ), members = useMemo(
+    () => (originalMembers != null ? originalMembers : []).filter((v) => {
+      var _a;
+      if (v.kind === "error")
+        return !0;
+      const value2 = (_a = v == null ? void 0 : v.item) == null ? void 0 : _a.value;
+      return !value2.userId || value2.userId === (user == null ? void 0 : user.id);
+    }),
+    [originalMembers, user]
+  );
+  return props.renderDefault({ ...props, value, members });
+}
+function HideReferenceChangedBannerInput(props) {
+  const ref = useRef(null);
+  return useEffect(() => {
+    var _a;
+    const parent = (_a = ref.current) == null ? void 0 : _a.closest('[data-testid="pane-content"]');
+    if (!parent)
+      return;
+    const style = document.createElement("style"), parentId = `id-${Math.random()}`.replace(".", "-");
+    parent.id = parentId, style.innerText = `
+      #${parentId} [data-testid="reference-changed-banner"] { display: none; }
+    `, parent.prepend(style);
+  }, [ref]), /* @__PURE__ */ jsx(Box, { ref, children: props.renderDefault(props) });
+}
+const contextDocumentSchema = defineType({
+  type: "document",
+  name: contextDocumentTypeName,
+  title: "AI context",
+  liveEdit: !0,
+  icon: TokenIcon,
+  components: {
+    input: HideReferenceChangedBannerInput
+  },
+  fields: [
+    defineField({
+      type: "string",
+      name: "title",
+      title: "Title"
+    }),
+    defineField({
+      name: "context",
+      type: "array",
+      title: "Context",
+      of: [
+        defineArrayMember({
+          type: "block",
+          styles: [{ title: "Normal", value: "normal" }],
+          lists: [],
+          marks: {
+            decorators: [],
+            annotations: []
+          }
+        })
+      ]
+    })
+  ],
+  preview: {
+    select: {
+      title: "title",
+      context: "context"
+    },
+    prepare({ title, context }) {
+      var _a;
+      const text = context == null ? void 0 : context.flatMap((block) => block == null ? void 0 : block.children).flatMap((child) => {
+        var _a2;
+        return (_a2 = child == null ? void 0 : child.text) == null ? void 0 : _a2.split(" ");
+      }).filter(Boolean), words = (_a = text == null ? void 0 : text.length) != null ? _a : 0;
+      return {
+        title,
+        subtitle: `Words: ${words}`,
+        media: DocumentTextIcon
+      };
+    }
+  }
+}), fieldReference = defineType({
+  type: "object",
+  name: fieldReferenceTypeName,
+  title: "Field",
+  icon: ThListIcon,
+  fields: [
+    defineField({
+      type: "string",
+      name: "path",
+      title: "Field",
+      components: {
+        input: FieldRefPathInput
+      },
+      validation: (rule) => rule.custom((value, context) => {
+        var _a;
+        if (!value)
+          return "Please select a field";
+        try {
+          const docId = (_a = context.document) == null ? void 0 : _a._id;
+          if (!docId)
+            return "Field reference cannot be used outside document inspector context. Could not resolve document id.";
+          const targetDocType = docId.replace(new RegExp(`^${assistDocumentIdPrefix}`), ""), schema = context.schema.get(targetDocType);
+          return schema ? getFieldRefsWithDocument(schema).find((r) => r.key === value) ? !0 : `Field with path "${value}" does not exist in the schema.` : `Field reference cannot be used outside document inspector context. Could not resolve schema: ${targetDocType}`;
+        } catch (e) {
+          return console.error("Failed to resolve field reference", e), "Invalid field reference.";
+        }
+      })
+    })
+  ],
+  preview: {
+    select: {
+      path: "path"
+    },
+    prepare({ path }) {
+      return {
+        title: path,
+        path,
+        icon: CodeIcon
+      };
+    }
+  },
+  components: {
+    preview: FieldRefPreview
+  },
+  options: {
+    modal: {
+      type: "popover"
+    }
+  }
+}), userInput = defineType({
+  type: "object",
+  name: userInputTypeName,
+  title: "User input",
+  icon: ComposeIcon,
+  fields: [
+    defineField({
+      type: "string",
+      name: "message",
+      title: "User input title",
+      placeholder: "Provide instruction text",
+      description: "The header above the user input text field",
+      validation: (rule) => rule.required()
+    }),
+    defineField({
+      type: "text",
+      rows: 3,
+      name: "description",
+      title: "User input description",
+      description: "The description above the user input text field"
+    })
+  ],
+  preview: {
+    select: {
+      title: "message"
+    }
+  },
+  options: {
+    modal: {
+      type: "popover",
+      width: 1
+    }
+  }
+}), promptContext = defineType({
+  type: "object",
+  name: instructionContextTypeName,
+  title: contextDocumentSchema.title,
+  icon: contextDocumentSchema.icon,
+  fields: [
+    defineField({
+      type: "reference",
+      name: "reference",
+      to: [{ type: contextDocumentSchema.name }],
+      title: "Context",
+      description: "The referenced context will be inserted into the instruction",
+      validation: (rule) => rule.required(),
+      components: {
+        input: function(props) {
+          return /* @__PURE__ */ jsx(Box, { style: { maxWidth: 300 }, children: props.renderDefault(props) });
+        }
+      }
+    })
+  ],
+  preview: {
+    select: {
+      ref: "reference._ref",
+      title: "reference.title",
+      context: "reference.context"
+    },
+    prepare(select) {
+      var _a, _b, _c, _d;
+      return select.ref ? (_d = (_c = (_b = (_a = contextDocumentSchema) == null ? void 0 : _a.preview) == null ? void 0 : _b.prepare) == null ? void 0 : _c.call(_b, select)) != null ? _d : select : { title: "No reference selected", media: contextDocumentSchema.icon };
+    }
+  },
+  options: {
+    modal: {
+      type: "popover",
+      width: "auto"
+    }
+  }
+}), prompt = defineType({
+  type: "array",
+  name: promptTypeName,
+  title: "Prompt",
+  of: [
+    defineArrayMember({
+      type: "block",
+      styles: [{ title: "Normal", value: "normal" }],
+      lists: [],
+      marks: {
+        decorators: [],
+        annotations: []
+      },
+      of: [
+        defineArrayMember({
+          type: fieldReference.name
+        }),
+        defineArrayMember({
+          type: promptContext.name
+        }),
+        defineArrayMember({
+          type: userInput.name
+        })
+      ]
+    })
+    /*    defineArrayMember({
+      type: fieldReference.name,
+    }),
+    defineArrayMember({
+      type: promptContext.name,
+    }),
+    defineArrayMember({
+      type: userInput.name,
+    }),*/
+  ]
+}), outputFieldType = defineType({
+  type: "object",
+  name: outputFieldTypeName,
+  title: "Output field",
+  fields: [
+    defineField({
+      type: "string",
+      name: "path",
+      title: "Path"
+    })
+  ]
+}), outputTypeType = defineType({
+  type: "object",
+  name: outputTypeTypeName,
+  title: "Output type",
+  fields: [
+    defineField({
+      type: "string",
+      name: "type",
+      title: "Type"
+    })
+  ]
+}), instruction = defineType({
+  type: "object",
+  name: instructionTypeName,
+  title: "Instruction",
+  fieldsets: [
+    { name: "appearance", title: "Appearance", options: { collapsible: !0, collapsed: !0 } }
+  ],
+  preview: {
+    select: {
+      icon: "icon",
+      title: "title",
+      userId: "userId"
+    },
+    prepare: ({ icon, title, userId }) => ({
+      title,
+      icon: icon ? icons[icon] : SparklesIcon,
+      userId
+    })
+  },
+  components: {
+    input: InstructionInput,
+    preview: (props) => /* @__PURE__ */ jsxs(Flex, { gap: 3, align: "center", padding: 2, children: [
+      props.icon && /* @__PURE__ */ jsx(Box, { flex: "none", children: /* @__PURE__ */ jsx(Text, { size: 1, children: createElement(props.icon) }) }),
+      /* @__PURE__ */ jsx(Stack, { flex: 1, space: 2, children: /* @__PURE__ */ jsx(Text, { size: 1, textOverflow: "ellipsis", weight: "medium", children: getInstructionTitle(props) }) }),
+      props.userId && /* @__PURE__ */ jsx(Text, { size: 1, children: /* @__PURE__ */ jsx(
+        Tooltip,
+        {
+          content: /* @__PURE__ */ jsx(Text, { size: 1, children: "Only visible to you" }),
+          padding: 2,
+          placement: "top",
+          portal: !0,
+          children: /* @__PURE__ */ jsx(LockIcon, {})
+        }
+      ) })
+    ] })
+  },
+  fields: [
+    defineField({
+      type: prompt.name,
+      name: "prompt",
+      title: "Instruction",
+      description: /* @__PURE__ */ jsxs(Fragment, { children: [
+        "Learn from",
+        " ",
+        /* @__PURE__ */ jsxs("a", { href: instructionGuideUrl, target: "_blank", rel: "noreferrer", children: [
+          "our instruction guide ",
+          /* @__PURE__ */ jsx(ArrowRightIcon, {})
+        ] })
+      ] }),
+      components: {
+        input: PromptInput
+      }
+    }),
+    defineField({
+      type: "string",
+      name: "icon",
+      title: "Icon",
+      fieldset: "appearance",
+      components: {
+        field: HiddenFieldTitle,
+        input: IconInput
+      }
+    }),
+    defineField({
+      type: "string",
+      name: "title",
+      title: "Title",
+      fieldset: "appearance",
+      components: {
+        field: HiddenFieldTitle
+      }
+    }),
+    defineField({
+      type: "string",
+      name: "userId",
+      title: "Visibility",
+      fieldset: "appearance",
+      components: {
+        field: HiddenFieldTitle,
+        input: InstructionVisibility
+      },
+      initialValue: (params, context) => {
+        var _a, _b;
+        return (_b = (_a = context.currentUser) == null ? void 0 : _a.id) != null ? _b : "";
+      },
+      readOnly: (context) => {
+        var _a, _b, _c;
+        return !!((_a = context.parent) != null && _a.createdById && ((_b = context.parent) == null ? void 0 : _b.createdById) !== ((_c = context.currentUser) == null ? void 0 : _c.id));
+      }
+    }),
+    defineField({
+      type: "string",
+      name: "createdById",
+      title: "Created by",
+      hidden: !0,
+      fieldset: "appearance",
+      initialValue: (params, context) => {
+        var _a, _b;
+        return (_b = (_a = context.currentUser) == null ? void 0 : _a.id) != null ? _b : "";
+      }
+    }),
+    defineField({
+      type: "array",
+      name: "output",
+      title: "Output filter",
+      components: {
+        input: InstructionOutputInput,
+        field: InstructionOutputField
+      },
+      of: [
+        defineArrayMember({ type: outputFieldType.name }),
+        defineArrayMember({ type: outputTypeType.name })
+      ]
+    })
+  ]
+}), fieldInstructions = defineType({
+  type: "object",
+  name: assistFieldTypeName,
+  title: "Field prompt",
+  /*  components: {
+    input: FieldPromptInput,
+  },*/
+  fields: [
+    defineField({
+      type: "string",
+      name: "path",
+      title: "Path",
+      readOnly: !0,
+      hidden: !0
+    }),
+    defineField({
+      type: "array",
+      name: "instructions",
+      title: "Instructions",
+      of: [{ type: instruction.name }],
+      components: {
+        field: InstructionsArrayField,
+        input: InstructionsArrayInput
+      }
+    })
+  ],
+  preview: {
+    select: {
+      title: "path"
+    }
+  }
+}), assistDocumentSchema = defineType({
+  //NOTE: this is a document type. Using object here ensures it does not appear in structure menus
+  type: "object",
+  liveEdit: !0,
+  name: assistDocumentTypeName,
+  title: "AI Document",
+  components: {
+    input: AssistDocumentForm,
+    field: (props) => props.renderDefault({ ...props, title: "" })
+  },
+  fields: [
+    defineField({
+      type: "string",
+      name: "title",
+      title: "Title"
+    }),
+    defineField({
+      type: "array",
+      name: "fields",
+      title: "Fields",
+      of: [{ type: fieldInstructions.name }]
+    })
+  ],
+  preview: {
+    select: {
+      title: "title"
+    }
+  }
+}), instructionTask = defineType({
+  type: "object",
+  name: instructionTaskTypeName,
+  title: "Instruction task",
+  fields: [
+    defineField({
+      type: "string",
+      name: "path",
+      title: "Path"
+    }),
+    defineField({
+      type: "string",
+      name: "instructionKey",
+      title: "Instruction key"
+    }),
+    defineField({
+      type: "datetime",
+      name: "started",
+      title: "Started"
+    }),
+    defineField({
+      type: "datetime",
+      name: "updated",
+      title: "Updated"
+    }),
+    defineField({
+      type: "string",
+      name: "info",
+      title: "Info"
+    })
+  ]
+}), documentInstructionStatus = defineType({
+  //NOTE: this is a document type. Using object here ensures it does not appear in structure menus
+  type: "object",
+  liveEdit: !0,
+  name: assistTasksStatusTypeName,
+  title: "Document instruction status",
+  fields: [
+    defineField({
+      type: "array",
+      name: "tasks",
+      title: "Tasks",
+      of: [{ type: instructionTask.name }]
+    })
+  ]
+});
+function excludeComments(type) {
+  var _a, _b, _c;
+  const existingRender = (_a = type == null ? void 0 : type.components) == null ? void 0 : _a.field;
+  return {
+    ...type,
+    ..."components" in type ? {
+      components: {
+        ...type.components,
+        field: (props) => {
+          const newProps = { ...props, __internal_comments: void 0 };
+          return typeof existingRender == "function" ? existingRender(newProps) : props.renderDefault(newProps);
+        }
+      }
+    } : {},
+    ..."fields" in type ? {
+      // recursively disable comments in fields
+      fields: (_b = type.fields) == null ? void 0 : _b.map((field) => excludeComments(field))
+    } : {},
+    ..."of" in type ? {
+      // recursively disable comments in array items
+      of: (_c = type.of) == null ? void 0 : _c.map((arrayItemType) => excludeComments(arrayItemType))
+    } : {}
+  };
+}
+const instructionForm = [
+  fieldInstructions,
+  instruction,
+  fieldReference,
+  prompt,
+  userInput,
+  promptContext
+].map(excludeComments), schemaTypes = [
+  ...instructionForm,
+  outputFieldType,
+  outputTypeType,
+  assistDocumentSchema,
+  documentInstructionStatus,
+  instructionTask,
+  contextDocumentSchema
+];
+function useAssistDocumentContextValue(documentId, documentSchemaType) {
+  const { published, draft } = useEditState(
+    getPublishedId(documentId),
+    documentSchemaType.name,
+    "low"
+  ), assistableDocumentId = (draft == null ? void 0 : draft._id) || (published == null ? void 0 : published._id) || documentId, documentIsNew = !(draft != null && draft._id) && !(published != null && published._id), documentIsAssistable = isDocAssistable(documentSchemaType, published, draft), { params } = useAiPaneRouter(), selectedPath = params[fieldPathParam], { openInspector, closeInspector, inspector, onChange: documentOnChange } = useDocumentPane(), assistDocument = useStudioAssistDocument({
+    documentId,
+    schemaType: documentSchemaType
+  });
+  return useMemo(() => {
+    const base = {
+      documentId,
+      assistableDocumentId,
+      documentSchemaType,
+      documentIsNew,
+      documentIsAssistable,
+      openInspector,
+      closeInspector,
+      inspector,
+      documentOnChange,
+      selectedPath
+    };
+    return assistDocument ? {
+      ...base,
+      loading: !1,
+      assistDocument
+    } : { ...base, loading: !0, assistDocument: void 0 };
+  }, [
+    assistDocument,
+    documentIsAssistable,
+    documentId,
+    assistableDocumentId,
+    documentSchemaType,
+    documentIsNew,
+    openInspector,
+    closeInspector,
+    inspector,
+    documentOnChange,
+    selectedPath
+  ]);
+}
+function useAssistSupported(path, schemaType) {
+  return useMemo(() => isAssistSupported(schemaType), [schemaType]);
+}
+const translateActions = {
+  name: "sanity-assist-translate",
+  useAction(props) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const { config, status } = useAiAssistanceConfig(), apiClient = useApiClient(config == null ? void 0 : config.__customApiClient), {
+      schemaType: fieldSchemaType,
+      path,
+      documentId,
+      documentSchemaType,
+      documentIsAssistable
+    } = props, isDocumentLevel = path.length === 0, readOnly = fieldSchemaType.readOnly === !0, docTransTypes = (_b = (_a = config.translate) == null ? void 0 : _a.document) == null ? void 0 : _b.documentTypes, options2 = fieldSchemaType == null ? void 0 : fieldSchemaType.options, addFieldAction = isDocumentLevel || ((_c = options2 == null ? void 0 : options2.aiAssist) == null ? void 0 : _c.translateAction), fieldTransEnabled = addFieldAction && documentSchemaType && ((_f = (_e = (_d = config.translate) == null ? void 0 : _d.field) == null ? void 0 : _e.documentTypes) == null ? void 0 : _f.includes(documentSchemaType.name)), documentTranslationEnabled = addFieldAction && documentSchemaType && (!docTransTypes && isAssistSupported(fieldSchemaType) || (docTransTypes == null ? void 0 : docTransTypes.includes(documentSchemaType.name)));
+    if (documentSchemaType && (documentTranslationEnabled || fieldTransEnabled)) {
+      const { value: documentValue, onChange: documentOnChange, formState } = useDocumentPane(), docRef = useRef(documentValue);
+      docRef.current = documentValue;
+      const formStateRef = useRef(formState);
+      formStateRef.current = formState;
+      const translationApi = useTranslate(apiClient), translate = useDraftDelayedTask({
+        documentOnChange,
+        isDocAssistable: documentIsAssistable != null ? documentIsAssistable : !1,
+        task: translationApi.translate
+      }), languagePath = (_h = (_g = config.translate) == null ? void 0 : _g.document) == null ? void 0 : _h.languageField, translateDocumentAction = useMemo(() => {
+        if (!languagePath || !documentTranslationEnabled)
+          return;
+        const title = path.length ? "Translate" : "Translate document";
+        return {
+          type: "action",
+          icon: translationApi.loading ? () => /* @__PURE__ */ jsx(Box, { style: { height: 17 }, children: /* @__PURE__ */ jsx(Spinner, { style: { transform: "translateY(6px)" } }) }) : TranslateIcon,
+          title,
+          onAction: () => {
+            translationApi.loading || !languagePath || !documentId || translate({
+              languagePath,
+              translatePath: path,
+              documentId: documentId != null ? documentId : "",
+              conditionalMembers: formStateRef.current ? getConditionalMembers(formStateRef.current) : []
+            });
+          },
+          renderAsButton: !0,
+          disabled: translationApi.loading || readOnly
+        };
+      }, [
+        languagePath,
+        translate,
+        documentId,
+        translationApi.loading,
+        documentTranslationEnabled,
+        path,
+        readOnly
+      ]), fieldTranslate = useFieldTranslation(), openFieldTranslation = useDraftDelayedTask({
+        documentOnChange,
+        isDocAssistable: documentIsAssistable != null ? documentIsAssistable : !1,
+        task: fieldTranslate.openFieldTranslation
+      }), translateFieldsAction = useMemo(
+        () => fieldTransEnabled ? {
+          type: "action",
+          icon: fieldTranslate.translationLoading ? () => /* @__PURE__ */ jsx(Box, { style: { height: 17 }, children: /* @__PURE__ */ jsx(Spinner, { style: { transform: "translateY(6px)" } }) }) : TranslateIcon,
+          title: "Translate fields...",
+          onAction: () => {
+            fieldTranslate.translationLoading || !documentId || (formStateRef.current && getConditionalMembers(formStateRef.current), openFieldTranslation({
+              document: docRef.current,
+              documentSchema: documentSchemaType,
+              translatePath: path,
+              conditionalMembers: formStateRef.current ? getConditionalMembers(formStateRef.current) : []
+            }));
+          },
+          renderAsButton: !0,
+          disabled: fieldTranslate.translationLoading || readOnly
+        } : void 0,
+        [
+          openFieldTranslation,
+          documentSchemaType,
+          documentId,
+          fieldTranslate.translationLoading,
+          fieldTransEnabled,
+          path,
+          readOnly
+        ]
+      );
+      return useMemo(() => {
+        if (status != null && status.initialized)
+          return {
+            type: "group",
+            icon: () => null,
+            title: "Translation",
+            children: [translateDocumentAction, translateFieldsAction].filter(
+              (c) => !!c
+            ),
+            expanded: !0
+          };
+      }, [translateDocumentAction, translateFieldsAction, status]);
+    }
+  }
+}, ImageContext = createContext({});
+function ImageContextProvider(props) {
+  var _a, _b;
+  const { schemaType, path, value, readOnly } = props, assetRef = (_a = value == null ? void 0 : value.asset) == null ? void 0 : _a._ref, [assetRefState, setAssetRefState] = useState(assetRef), { documentId, documentSchemaType } = useAssistDocumentContext(), { config, status } = useAiAssistanceConfig(), apiClient = useApiClient(config == null ? void 0 : config.__customApiClient), { generateCaption } = useGenerateCaption(apiClient), { isSyncing } = useSyncState(publicId(documentId), documentSchemaType.name), isShowingOlderRevision = !!((_b = usePaneRouter().params) != null && _b.rev);
+  useEffect(() => {
+    const descriptionField = getDescriptionFieldOption(schemaType);
+    assetRef && documentId && descriptionField && assetRef !== assetRefState && !isSyncing && !isShowingOlderRevision && !readOnly && (setAssetRefState(assetRef), canUseAssist(status) && generateCaption({ path: pathToString([...path, descriptionField]), documentId }));
+  }, [
+    schemaType,
+    path,
+    assetRef,
+    assetRefState,
+    documentId,
+    generateCaption,
+    isSyncing,
+    status,
+    readOnly,
+    isShowingOlderRevision
+  ]);
+  const context = useMemo(() => {
+    const descriptionField = getDescriptionFieldOption(schemaType), imageInstructionField = getImageInstructionFieldOption(schemaType);
+    return {
+      imageDescriptionPath: descriptionField ? pathToString([...path, descriptionField]) : void 0,
+      imageInstructionPath: imageInstructionField ? pathToString([...path, imageInstructionField]) : void 0,
+      assetRef
+    };
+  }, [schemaType, path, assetRef]);
+  return /* @__PURE__ */ jsx(ImageContext.Provider, { value: context, children: props.renderDefault(props) });
+}
+const generateCaptionsActions = {
+  name: "sanity-assist-generate-captions",
+  useAction(props) {
+    const pathKey = usePathKey(props.path), { openInspector } = useDocumentPane(), { config, status } = useAiAssistanceConfig(), apiClient = useApiClient(config == null ? void 0 : config.__customApiClient), { generateCaption, loading } = useGenerateCaption(apiClient), imageContext = useContext(ImageContext);
+    if (imageContext && pathKey === (imageContext == null ? void 0 : imageContext.imageDescriptionPath)) {
+      const { documentId } = useAssistDocumentContext();
+      return useMemo(() => ({
+        type: "action",
+        icon: loading ? () => /* @__PURE__ */ jsx(Box, { style: { height: 17 }, children: /* @__PURE__ */ jsx(Spinner, { style: { transform: "translateY(6px)" } }) }) : ImageIcon,
+        title: "Generate image description",
+        onAction: () => {
+          if (!loading) {
+            if (!canUseAssist(status)) {
+              openInspector(aiInspectorId, {
+                [fieldPathParam]: pathKey,
+                [instructionParam]: void 0
+              });
+              return;
+            }
+            generateCaption({ path: pathKey, documentId: documentId != null ? documentId : "" });
+          }
+        },
+        renderAsButton: !0,
+        disabled: loading,
+        hidden: !imageContext.assetRef
+      }), [generateCaption, pathKey, documentId, loading, imageContext, status, openInspector]);
+    }
+  }
+}, generateImagActions = {
+  name: "sanity-assist-generate-image",
+  useAction(props) {
+    const pathKey = usePathKey(props.path), { config } = useAiAssistanceConfig(), apiClient = useApiClient(config == null ? void 0 : config.__customApiClient), { generateImage, loading } = useGenerateImage(apiClient), imageContext = useContext(ImageContext);
+    if (imageContext && pathKey === (imageContext == null ? void 0 : imageContext.imageInstructionPath)) {
+      const { documentId } = useAssistDocumentContext();
+      return useMemo(() => ({
+        type: "action",
+        icon: loading ? () => /* @__PURE__ */ jsx(Box, { style: { height: 17 }, children: /* @__PURE__ */ jsx(Spinner, { style: { transform: "translateY(6px)" } }) }) : ImageIcon,
+        title: "Generate image from prompt",
+        onAction: () => {
+          loading || generateImage({ path: pathKey, documentId: documentId != null ? documentId : "" });
+        },
+        renderAsButton: !0,
+        disabled: loading
+      }), [generateImage, pathKey, documentId, loading]);
+    }
+  }
+};
+function PrivateIcon() {
+  return /* @__PURE__ */ jsx(
+    Tooltip,
+    {
+      content: /* @__PURE__ */ jsx(Text, { size: 1, style: { whiteSpace: "nowrap" }, children: "Only visible to you" }),
+      fallbackPlacements: ["bottom"],
+      padding: 2,
+      placement: "top",
+      portal: !0,
+      children: /* @__PURE__ */ jsx(LockIcon, {})
+    }
+  );
+}
+const assistFieldActions = {
+  name: "sanity-assist-actions",
+  useAction(props) {
+    const { schemaType } = props, isDocumentLevel = props.path.length === 0, {
+      assistDocument,
+      documentIsNew,
+      documentIsAssistable,
+      openInspector,
+      closeInspector,
+      inspector,
+      documentOnChange,
+      documentSchemaType,
+      documentId,
+      selectedPath,
+      assistableDocumentId
+    } = (
+      // document field actions do not have access to the document context
+      // conditional hook _should_ be safe here since the logical path will be stable
+      isDocumentLevel ? (
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        useAssistDocumentContextValue(props.documentId, schemaType)
+      ) : (
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        useAssistDocumentContext()
+      )
+    ), { value: docValue, formState } = useDocumentPane(), formStateRef = useRef(formState);
+    formStateRef.current = formState;
+    const currentUser = useCurrentUser(), isHidden = !assistDocument, pathKey = usePathKey(props.path), typePath = useTypePath(docValue, pathKey), assistDocumentId2 = assistDocument == null ? void 0 : assistDocument._id, assistableDocId = getAssistableDocId(documentSchemaType, documentId), { requestRunInstruction } = useRequestRunInstruction({
+      documentOnChange,
+      isDocAssistable: documentIsAssistable != null ? documentIsAssistable : !1
+    }), isSelectable = !!useSelectedField(documentSchemaType, typePath), assistSupported = useAssistSupported(props.path, schemaType) && isSelectable && isSchemaAssistEnabled(documentSchemaType) && schemaType.readOnly !== !0, fieldAssist = useMemo(
+      () => {
+        var _a;
+        return ((_a = assistDocument == null ? void 0 : assistDocument.fields) != null ? _a : []).find(
+          (f) => f.path === typePath || pathKey === documentRootKey && f.path === pathKey
+        );
+      },
+      [assistDocument == null ? void 0 : assistDocument.fields, pathKey, typePath]
+    ), fieldAssistKey = fieldAssist == null ? void 0 : fieldAssist._key, isSelected = (inspector == null ? void 0 : inspector.name) === aiInspectorId && pathKey === selectedPath, imageCaptionAction = generateCaptionsActions.useAction(props), imageGenAction = generateImagActions.useAction(props), translateAction = translateActions.useAction(
+      typed({
+        ...props,
+        documentId: assistableDocumentId,
+        documentIsAssistable,
+        documentSchemaType
+      })
+    ), manageInstructions = useCallback(
+      () => isSelected ? closeInspector(aiInspectorId) : openInspector(aiInspectorId, {
+        [fieldPathParam]: pathKey,
+        [instructionParam]: void 0
+      }),
+      [openInspector, closeInspector, isSelected, pathKey]
+    ), onInstructionAction = useCallback(
+      (instruction2) => {
+        !pathKey || !fieldAssistKey || !assistDocumentId2 || !assistableDocId || requestRunInstruction({
+          documentId: assistableDocId,
+          assistDocumentId: assistDocumentId2,
+          path: pathKey,
+          typePath,
+          instruction: instruction2,
+          conditionalMembers: formStateRef.current ? getConditionalMembers(formStateRef.current) : []
+        });
+      },
+      [requestRunInstruction, assistableDocId, pathKey, typePath, assistDocumentId2, fieldAssistKey]
+    ), privateInstructions = useMemo(
+      () => {
+        var _a;
+        return ((_a = fieldAssist == null ? void 0 : fieldAssist.instructions) == null ? void 0 : _a.filter((i) => i.userId && i.userId === (currentUser == null ? void 0 : currentUser.id))) || [];
+      },
+      [fieldAssist == null ? void 0 : fieldAssist.instructions, currentUser]
+    ), sharedInstructions = useMemo(
+      () => {
+        var _a;
+        return ((_a = fieldAssist == null ? void 0 : fieldAssist.instructions) == null ? void 0 : _a.filter((i) => !i.userId)) || [];
+      },
+      [fieldAssist == null ? void 0 : fieldAssist.instructions]
+    ), instructions = useMemo(
+      () => [...privateInstructions, ...sharedInstructions],
+      [privateInstructions, sharedInstructions]
+    ), runInstructionsGroup = useMemo(() => instructions != null && instructions.length || imageCaptionAction || translateAction || imageGenAction ? {
+      type: "group",
+      icon: () => null,
+      title: "Run instructions",
+      children: [
+        ...(instructions == null ? void 0 : instructions.map(
+          (instruction2) => instructionItem({
+            instruction: instruction2,
+            isPrivate: !!(instruction2.userId && instruction2.userId === (currentUser == null ? void 0 : currentUser.id)),
+            onInstructionAction,
+            hidden: isHidden,
+            documentIsNew: !!documentIsNew,
+            assistSupported
+          })
+        )) || [],
+        imageCaptionAction,
+        imageGenAction
+      ].filter((a) => !!a),
+      expanded: !0
+    } : void 0, [
+      instructions,
+      currentUser == null ? void 0 : currentUser.id,
+      onInstructionAction,
+      isHidden,
+      documentIsNew,
+      assistSupported,
+      imageCaptionAction,
+      translateAction,
+      imageGenAction
+    ]), instructionsLength = (instructions == null ? void 0 : instructions.length) || 0, manageInstructionsItem = useMemo(
+      () => ({
+        type: "action",
+        icon: ControlsIcon,
+        title: "Manage instructions",
+        onAction: manageInstructions,
+        selected: isSelected
+      }),
+      [manageInstructions, isSelected]
+    ), group = useMemo(
+      () => ({
+        type: "group",
+        icon: SparklesIcon,
+        title: pluginTitleShort,
+        children: [
+          runInstructionsGroup,
+          translateAction,
+          assistSupported && manageInstructionsItem
+        ].filter((c) => !!c).filter((c) => c.type === "group" ? c.children.length : !0),
+        expanded: !1,
+        renderAsButton: !0,
+        hidden: !assistSupported && !imageCaptionAction && !translateAction && !imageGenAction
+      }),
+      [
+        //documentIsNew,
+        runInstructionsGroup,
+        manageInstructionsItem,
+        assistSupported,
+        imageCaptionAction,
+        translateAction,
+        imageGenAction
+      ]
+    ), emptyAction = useMemo(
+      () => ({
+        type: "action",
+        hidden: !assistSupported,
+        icon: SparklesIcon,
+        onAction: manageInstructions,
+        renderAsButton: !0,
+        title: pluginTitleShort,
+        selected: isSelected
+      }),
+      [assistSupported, manageInstructions, isSelected]
+    );
+    return instructionsLength === 0 && !imageCaptionAction && !translateAction && !imageGenAction ? emptyAction : group;
+  }
+};
+function instructionItem(props) {
+  const { hidden, isPrivate, onInstructionAction, assistSupported, instruction: instruction2 } = props;
+  return {
+    type: "action",
+    icon: getIcon(instruction2.icon),
+    iconRight: isPrivate ? PrivateIcon : void 0,
+    title: getInstructionTitle(instruction2),
+    onAction: () => onInstructionAction(instruction2),
+    disabled: !assistSupported,
+    hidden
+  };
+}
+function AssistDocumentContextProvider(props) {
+  const { documentId, schemaType } = props, value = useAssistDocumentContextValue(documentId, schemaType);
+  return /* @__PURE__ */ jsx(AssistDocumentContext.Provider, { value, children: props.children });
+}
+const NO_TASKS = [];
+function useInstructionToaster(documentId, documentSchemaType) {
+  const assistDocument = useStudioAssistDocument({ documentId, schemaType: documentSchemaType }), assistDocLoaded = !!assistDocument, currentUser = useCurrentUser(), toast = useToast(), tasks = assistDocument == null ? void 0 : assistDocument.tasks, previousTasks = useRef("initial");
+  useEffect(() => {
+    var _a;
+    if (assistDocLoaded) {
+      if (previousTasks.current !== "initial") {
+        const prevTaskByKey = Object.fromEntries(
+          ((_a = previousTasks.current) != null ? _a : NO_TASKS).map((run) => [run._key, run])
+        ), endedTasks = tasks == null ? void 0 : tasks.filter((task) => task.startedByUserId === (currentUser == null ? void 0 : currentUser.id)).filter((task) => {
+          const prevTask = prevTaskByKey[task._key];
+          return !prevTask && task.ended || !(prevTask != null && prevTask.ended) && task.ended;
+        }).filter((task) => task.ended && isAfter(addSeconds(new Date(task.ended), 30), /* @__PURE__ */ new Date()));
+        endedTasks == null || endedTasks.forEach((task) => {
+          var _a2, _b;
+          const title = (_a2 = task.title) != null ? _a2 : getInstructionTitle(task.instruction);
+          task.reason === "error" ? toast.push({
+            title: `Failed: ${title}`,
+            status: "error",
+            description: `Instruction failed. ${(_b = task.message) != null ? _b : ""}`,
+            closable: !0,
+            duration: 1e4
+          }) : task.reason === "timeout" ? toast.push({
+            title: `Timeout: ${title}`,
+            status: "error",
+            description: "Instruction timed out.",
+            closable: !0
+          }) : task.reason === "success" ? toast.push({
+            title: `Success: ${title}`,
+            status: "success",
+            description: "Instruction completed.",
+            closable: !0
+          }) : task.reason === "aborted" && toast.push({
+            title: `Canceled: ${title}`,
+            status: "warning",
+            description: "Instruction canceled.",
+            closable: !0
+          });
+        });
+      }
+      previousTasks.current = tasks;
+    }
+  }, [tasks, previousTasks, toast, currentUser, assistDocLoaded]);
+}
+function AssistDocumentInputWrapper(props) {
+  var _a;
+  if (!isType(props.schemaType, "document") && props.id !== "root" && props.id !== assistFormId)
+    return /* @__PURE__ */ jsx(AssistInput, { ...props });
+  const documentId = (_a = props.value) == null ? void 0 : _a._id;
+  return documentId ? /* @__PURE__ */ jsx(AssistDocumentInput, { ...props, documentId }) : props.renderDefault(props);
+}
+function AssistDocumentInput({ documentId, ...props }) {
+  useInstructionToaster(documentId, props.schemaType);
+  const schemaType = useMemo(() => props.schemaType.name !== assistDocumentTypeName ? props.schemaType : {
+    ...props.schemaType,
+    type: {
+      ...props.schemaType.type,
+      // compatability with i18nArrays plugin that requires this to be document
+      name: "document"
+    }
+  }, [props.schemaType]);
+  return /* @__PURE__ */ jsx(FirstAssistedPathProvider, { members: props.members, children: /* @__PURE__ */ jsx(AssistDocumentContextProvider, { schemaType, documentId, children: props.renderDefault({
+    ...props,
+    schemaType
+  }) }) });
+}
+function AssistInput(props) {
+  const { zIndex } = useLayer(), { paneKey } = useDocumentPane(), pathKey = usePathKey(props.path);
+  return /* @__PURE__ */ jsx(ConnectFromRegion, { _key: `${paneKey}_${pathKey}`, zIndex, style: { minWidth: 0 }, children: props.renderDefault(props) });
+}
+function createAssistDocumentPresence(documentId, schemaType) {
+  return function() {
+    return documentId ? /* @__PURE__ */ jsx(AssistDocumentPresence, { documentId, schemaType }) : null;
+  };
+}
+function AssistDocumentPresence(props) {
+  const { assistDocument } = useAssistDocumentContextValue(
+    props.documentId,
+    props.schemaType
+  ), anyPresence = useMemo(() => {
+    var _a, _b, _c, _d;
+    const anyPresence2 = (_b = (_a = assistDocument == null ? void 0 : assistDocument.tasks) == null ? void 0 : _a.filter((run) => !run.ended && !run.reason)) == null ? void 0 : _b.flatMap((run) => {
+      var _a2;
+      return (_a2 = run.presence) != null ? _a2 : [];
+    }).find((f) => f.started && (/* @__PURE__ */ new Date()).getTime() - new Date(f.started).getTime() < 3e4);
+    if (anyPresence2)
+      return aiPresence(anyPresence2, []);
+    const anyRun = (_d = (_c = assistDocument == null ? void 0 : assistDocument.tasks) == null ? void 0 : _c.filter((run) => !run.ended && !run.reason)) == null ? void 0 : _d.find((f) => f.started && (/* @__PURE__ */ new Date()).getTime() - new Date(f.started).getTime() < 3e4);
+    return anyRun ? aiPresence(
+      {
+        started: anyRun.started,
+        path: documentRootKey,
+        _key: anyRun._key,
+        _type: fieldPresenceTypeName
+      },
+      []
+    ) : void 0;
+  }, [assistDocument == null ? void 0 : assistDocument.tasks]);
+  return /* @__PURE__ */ jsx(Card, { children: /* @__PURE__ */ jsx(Flex, { flex: 1, justify: "flex-end", children: /* @__PURE__ */ jsx(Flex, { gap: 2, align: "center", children: anyPresence && /* @__PURE__ */ jsx(AiFieldPresence, { presence: anyPresence }) }) }) });
+}
+const assist = definePlugin((config) => {
+  const configWithDefaults = config != null ? config : {};
+  return {
+    name: packageName,
+    schema: {
+      types: schemaTypes
+    },
+    i18n: {
+      bundles: [{}]
+    },
+    document: {
+      inspectors: (prev, context) => {
+        const documentType = context.documentType, docSchema = context.schema.get(documentType);
+        return docSchema && isSchemaAssistEnabled(docSchema) ? [...prev, assistInspector] : prev;
+      },
+      unstable_fieldActions: (prev, { documentType, schema }) => {
+        if (documentType === assistDocumentTypeName)
+          return [];
+        const docSchema = schema.get(documentType);
+        return docSchema && isSchemaAssistEnabled(docSchema) ? [...prev, assistFieldActions] : prev;
+      },
+      unstable_languageFilter: (prev, { documentId, schema, schemaType }) => {
+        if (schemaType === assistDocumentTypeName)
+          return [];
+        const docSchema = schema.get(schemaType);
+        return docSchema && isObjectSchemaType(docSchema) && isSchemaAssistEnabled(docSchema) ? [...prev, createAssistDocumentPresence(documentId, docSchema)] : prev;
+      }
+    },
+    studio: {
+      components: {
+        layout: function(props) {
+          return /* @__PURE__ */ jsx(AssistLayout, { ...props, config: configWithDefaults });
+        }
+      }
+    },
+    form: {
+      components: {
+        input: AssistDocumentInputWrapper,
+        field: AssistFieldWrapper,
+        item: AssistItem,
+        block: AssistFormBlock,
+        inlineBlock: AssistInlineFormBlock
+      }
+    },
+    plugins: [
+      definePlugin({
+        name: `${packageName}/safe-value-input`,
+        form: { components: { input: SafeValueInput } }
+      })(),
+      definePlugin({
+        name: `${packageName}/generate-caption`,
+        form: {
+          components: {
+            input: (props) => {
+              const { schemaType } = props;
+              return isImage(schemaType) ? /* @__PURE__ */ jsx(ImageContextProvider, { ...props }) : props.renderDefault(props);
+            }
+          }
+        }
+      })()
+    ]
+  };
+});
+export {
+  SchemaTypeTool,
+  assist,
+  contextDocumentTypeName,
+  defaultLanguageOutputs
+};
+//# sourceMappingURL=index.mjs.map