@scalar/api-client 3.3.1 → 3.4.0

package/dist/v2/features/app/components/SidebarDocument.vue.script.js

@@ -0,0 +1,137 @@
+import { Fragment, createBlock, createElementBlock, createElementVNode, createSlots, createTextVNode, createVNode, defineComponent, openBlock, renderList, toDisplayString, unref, withCtx, withKeys, withModifiers } from "vue";
+import { ScalarIconButton, ScalarSidebarButton, ScalarSidebarItem, ScalarSidebarNestedItems } from "@scalar/components";
+import { ScalarIconCaretLeft, ScalarIconDotsThree, ScalarIconGearSix, ScalarIconMagnifyingGlass, ScalarIconPlus } from "@scalar/icons";
+import { SidebarItem, filterItems } from "@scalar/sidebar";
+//#region src/v2/features/app/components/SidebarDocument.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "flex items-center gap-1" };
+var _hoisted_2 = {
+	key: 1,
+	class: "text-c-3 px-3 py-1 text-xs"
+};
+var SidebarDocument_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "SidebarDocument",
+	props: {
+		item: {},
+		active: { type: Boolean },
+		open: { type: Boolean },
+		loading: { type: Boolean },
+		isDroppable: { type: Function },
+		isExpanded: { type: Function },
+		isSelected: { type: Function }
+	},
+	emits: [
+		"back",
+		"click",
+		"openSettings",
+		"search",
+		"createOperation",
+		"addEmptyFolder",
+		"openMenu",
+		"selectItem",
+		"toggleGroup",
+		"dragEnd"
+	],
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		const handleDragEnd = (draggingItem, hoveredItem) => emit("dragEnd", draggingItem, hoveredItem);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(ScalarSidebarNestedItems), {
+				active: __props.active,
+				controlled: "",
+				open: __props.open,
+				onBack: _cache[6] || (_cache[6] = ($event) => emit("back")),
+				onClick: _cache[7] || (_cache[7] = ($event) => emit("click", __props.item))
+			}, createSlots({
+				back: withCtx(() => [createElementVNode("div", _hoisted_1, [
+					createVNode(unref(ScalarSidebarButton), {
+						is: "button",
+						class: "text-sidebar-c-1 font-sidebar-active hover:text-sidebar-c-1 flex-1",
+						onClick: _cache[0] || (_cache[0] = ($event) => emit("back"))
+					}, {
+						icon: withCtx(() => [createVNode(unref(ScalarIconCaretLeft), { class: "text-sidebar-c-2 -m-px size-4" })]),
+						default: withCtx(() => [_cache[9] || (_cache[9] = createTextVNode(" Back ", -1))]),
+						_: 1
+					}),
+					createVNode(unref(ScalarIconButton), {
+						icon: unref(ScalarIconGearSix),
+						label: "Collection settings",
+						size: "sm",
+						onClick: _cache[1] || (_cache[1] = ($event) => emit("openSettings"))
+					}, null, 8, ["icon"]),
+					createVNode(unref(ScalarIconButton), {
+						icon: unref(ScalarIconMagnifyingGlass),
+						label: "Search collection",
+						size: "sm",
+						onClick: _cache[2] || (_cache[2] = ($event) => emit("search"))
+					}, null, 8, ["icon"]),
+					createVNode(unref(ScalarIconButton), {
+						class: "rounded-full border",
+						icon: unref(ScalarIconPlus),
+						label: "Add operation",
+						size: "sm",
+						onClick: _cache[3] || (_cache[3] = ($event) => emit("createOperation", __props.item))
+					}, null, 8, ["icon"])
+				])]),
+				items: withCtx(() => [__props.item.navigation?.children?.length ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(unref(filterItems)("client", __props.item.navigation.children), (child) => {
+					return openBlock(), createBlock(unref(SidebarItem), {
+						key: child.id,
+						isDroppable: __props.isDroppable,
+						isExpanded: __props.isExpanded,
+						isSelected: __props.isSelected,
+						item: child,
+						layout: "client",
+						onOnDragEnd: handleDragEnd,
+						onSelectItem: _cache[4] || (_cache[4] = (id) => emit("selectItem", id)),
+						onToggleGroup: _cache[5] || (_cache[5] = (id) => emit("toggleGroup", id))
+					}, {
+						decorator: withCtx(({ item: entry }) => [createVNode(unref(ScalarIconButton), {
+							"aria-expanded": "false",
+							"aria-haspopup": "menu",
+							class: "bg-b-2",
+							icon: unref(ScalarIconDotsThree),
+							label: "More options",
+							size: "sm",
+							variant: "ghost",
+							weight: "bold",
+							onClick: withModifiers((e) => emit("openMenu", e, entry), ["stop"]),
+							onKeydown: [
+								withKeys(withModifiers((e) => emit("openMenu", e, entry), ["stop"]), ["down"]),
+								withKeys(withModifiers((e) => emit("openMenu", e, entry), ["stop"]), ["enter"]),
+								withKeys(withModifiers((e) => emit("openMenu", e, entry), ["stop"]), ["space"]),
+								withKeys(withModifiers((e) => emit("openMenu", e, entry), ["stop"]), ["up"])
+							]
+						}, null, 8, [
+							"icon",
+							"onClick",
+							"onKeydown"
+						])]),
+						empty: withCtx(({ item: emptyItem }) => [createVNode(unref(ScalarSidebarItem), {
+							is: "button",
+							onClick: ($event) => emit("addEmptyFolder", emptyItem)
+						}, {
+							icon: withCtx(() => [createVNode(unref(ScalarIconPlus))]),
+							default: withCtx(() => [..._cache[10] || (_cache[10] = [createTextVNode("Add operation", -1)])]),
+							_: 1
+						}, 8, ["onClick"])]),
+						_: 1
+					}, 8, [
+						"isDroppable",
+						"isExpanded",
+						"isSelected",
+						"item"
+					]);
+				}), 128)) : (openBlock(), createElementBlock("li", _hoisted_2, " Empty document "))]),
+				default: withCtx(() => [createElementVNode("span", null, toDisplayString(__props.item.title), 1)]),
+				_: 2
+			}, [__props.loading ? {
+				name: "aside",
+				fn: withCtx(() => [_cache[8] || (_cache[8] = createElementVNode("span", { class: "text-c-3 text-xs" }, "Loading…", -1))]),
+				key: "0"
+			} : void 0]), 1032, ["active", "open"]);
+		};
+	}
+});
+//#endregion
+export { SidebarDocument_vue_vue_type_script_setup_true_lang_default as default };
+
+//# sourceMappingURL=SidebarDocument.vue.script.js.map

package/dist/v2/features/app/components/SidebarDocument.vue.script.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SidebarDocument.vue.script.js","names":[],"sources":["../../../../../src/v2/features/app/components/SidebarDocument.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport {\n  ScalarIconButton,\n  ScalarSidebarButton,\n  ScalarSidebarItem,\n  ScalarSidebarNestedItems,\n} from '@scalar/components'\nimport {\n  ScalarIconCaretLeft,\n  ScalarIconDotsThree,\n  ScalarIconGearSix,\n  ScalarIconMagnifyingGlass,\n  ScalarIconPlus,\n} from '@scalar/icons'\nimport {\n  filterItems,\n  SidebarItem,\n  type DraggingItem,\n  type HoveredItem,\n} from '@scalar/sidebar'\nimport type { TraversedEntry } from '@scalar/workspace-store/schemas/navigation'\n\nimport type { SidebarDocumentItem } from '@/v2/features/app/hooks/use-sidebar-documents'\n\nconst { item, active, open, loading } = defineProps<{\n  /** The document row to render. */\n  item: SidebarDocumentItem\n  /** Whether the document row is the currently active sidebar entry. */\n  active: boolean\n  /** Whether the document is drilled-in (its children are shown). */\n  open: boolean\n  /** Whether the document is currently being fetched from the registry. */\n  loading?: boolean\n  /** Predicate to check whether a child entry can be dropped on a target. */\n  isDroppable: (draggingItem: DraggingItem, hoveredItem: HoveredItem) => boolean\n  /** Predicate to check whether a child entry is currently expanded. */\n  isExpanded: (id: string) => boolean\n  /** Predicate to check whether a child entry is currently selected. */\n  isSelected: (id: string) => boolean\n}>()\n\nconst emit = defineEmits<{\n  /** Navigate back from the drilled-in document view. */\n  (event: 'back'): void\n  /** The document row was clicked. */\n  (event: 'click', item: SidebarDocumentItem): void\n  /** Open the document (collection) settings. */\n  (event: 'openSettings'): void\n  /** Open the per-document search modal. */\n  (event: 'search'): void\n  /** Create a new operation in this document. */\n  (event: 'createOperation', item: SidebarDocumentItem): void\n  /** Add an operation inside an empty tag/folder. */\n  (event: 'addEmptyFolder', item: TraversedEntry): void\n  /** Open the contextual \"more\" menu for a child entry. */\n  (\n    event: 'openMenu',\n    nativeEvent: MouseEvent | KeyboardEvent,\n    entry: TraversedEntry,\n  ): void\n  /** A child entry was selected. */\n  (event: 'selectItem', id: string): void\n  /** A child group was toggled. */\n  (event: 'toggleGroup', id: string): void\n  /** A drag-and-drop operation has completed. */\n  (\n    event: 'dragEnd',\n    draggingItem: DraggingItem,\n    hoveredItem: HoveredItem,\n  ): boolean\n}>()\n\nconst handleDragEnd = (\n  draggingItem: DraggingItem,\n  hoveredItem: HoveredItem,\n): boolean => emit('dragEnd', draggingItem, hoveredItem)\n</script>\n\n<template>\n  <ScalarSidebarNestedItems\n    :active=\"active\"\n    controlled\n    :open=\"open\"\n    @back=\"emit('back')\"\n    @click=\"emit('click', item)\">\n    <span>{{ item.title }}</span>\n    <template\n      v-if=\"loading\"\n      #aside>\n      <span class=\"text-c-3 text-xs\">Loading…</span>\n    </template>\n    <!-- Document back row -->\n    <template #back>\n      <div class=\"flex items-center gap-1\">\n        <ScalarSidebarButton\n          is=\"button\"\n          class=\"text-sidebar-c-1 font-sidebar-active hover:text-sidebar-c-1 flex-1\"\n          @click=\"emit('back')\">\n          <template #icon>\n            <ScalarIconCaretLeft class=\"text-sidebar-c-2 -m-px size-4\" />\n          </template>\n          Back\n        </ScalarSidebarButton>\n        <ScalarIconButton\n          :icon=\"ScalarIconGearSix\"\n          label=\"Collection settings\"\n          size=\"sm\"\n          @click=\"emit('openSettings')\" />\n        <ScalarIconButton\n          :icon=\"ScalarIconMagnifyingGlass\"\n          label=\"Search collection\"\n          size=\"sm\"\n          @click=\"emit('search')\" />\n        <ScalarIconButton\n          class=\"rounded-full border\"\n          :icon=\"ScalarIconPlus\"\n          label=\"Add operation\"\n          size=\"sm\"\n          @click=\"emit('createOperation', item)\" />\n      </div>\n    </template>\n    <!-- Document items (operations, tags, examples) -->\n    <template #items>\n      <template v-if=\"item.navigation?.children?.length\">\n        <SidebarItem\n          v-for=\"child in filterItems('client', item.navigation.children)\"\n          :key=\"child.id\"\n          :isDroppable=\"isDroppable\"\n          :isExpanded=\"isExpanded\"\n          :isSelected=\"isSelected\"\n          :item=\"child\"\n          layout=\"client\"\n          @onDragEnd=\"handleDragEnd\"\n          @selectItem=\"(id: string) => emit('selectItem', id)\"\n          @toggleGroup=\"(id: string) => emit('toggleGroup', id)\">\n          <!--\n            Per-item \"more\" dropdown for tags, operations and examples\n            (add / edit / delete…). The dropdown is rendered once at the\n            sidebar root and anchors itself to whichever icon button opened\n            it. Operation settings live on the operation header (next to the\n            environment selector), not here.\n          -->\n          <template #decorator=\"{ item: entry }\">\n            <ScalarIconButton\n              aria-expanded=\"false\"\n              aria-haspopup=\"menu\"\n              class=\"bg-b-2\"\n              :icon=\"ScalarIconDotsThree\"\n              label=\"More options\"\n              size=\"sm\"\n              variant=\"ghost\"\n              weight=\"bold\"\n              @click.stop=\"(e: MouseEvent) => emit('openMenu', e, entry)\"\n              @keydown.down.stop=\"\n                (e: KeyboardEvent) => emit('openMenu', e, entry)\n              \"\n              @keydown.enter.stop=\"\n                (e: KeyboardEvent) => emit('openMenu', e, entry)\n              \"\n              @keydown.space.stop=\"\n                (e: KeyboardEvent) => emit('openMenu', e, entry)\n              \"\n              @keydown.up.stop=\"\n                (e: KeyboardEvent) => emit('openMenu', e, entry)\n              \" />\n          </template>\n          <!--\n            Empty tag / folder slot. Matches the \"Add operation\" affordance\n            from the old sidebar so users can create an operation directly\n            inside the hovered tag.\n          -->\n          <template #empty=\"{ item: emptyItem }\">\n            <ScalarSidebarItem\n              is=\"button\"\n              @click=\"emit('addEmptyFolder', emptyItem)\">\n              <template #icon>\n                <ScalarIconPlus />\n              </template>\n              <template #default>Add operation</template>\n            </ScalarSidebarItem>\n          </template>\n        </SidebarItem>\n      </template>\n      <li\n        v-else\n        class=\"text-c-3 px-3 py-1 text-xs\">\n        Empty document\n      </li>\n    </template>\n  </ScalarSidebarNestedItems>\n</template>\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCA,MAAM,OAAO;EA+Bb,MAAM,iBACJ,cACA,gBACY,KAAK,WAAW,cAAc,YAAW;;uBAIrD,YA8G2B,MAAA,yBAAA,EAAA;IA7GxB,QAAQ,QAAA;IACT,YAAA;IACC,MAAM,QAAA;IACN,QAAI,OAAA,OAAA,OAAA,MAAA,WAAE,KAAI,OAAA;IACV,SAAK,OAAA,OAAA,OAAA,MAAA,WAAE,KAAI,SAAU,QAAA,KAAI;;IAQf,MAAI,cA2BP,CA1BN,mBA0BM,OA1BN,YA0BM;KAzBJ,YAQsB,MAAA,oBAAA,EAAA;MAPpB,IAAG;MACH,OAAM;MACL,SAAK,OAAA,OAAA,OAAA,MAAA,WAAE,KAAI,OAAA;;MACD,MAAI,cACgD,CAA7D,YAA6D,MAAA,oBAAA,EAAA,EAAxC,OAAM,iCAA+B,CAAA,CAAA,CAAA;6BAG9D,CAAA,OAAA,OAAA,OAAA,KAAA,gBAFa,UAEb,GAAA,EAAA,CAAA;;;KACA,YAIkC,MAAA,iBAAA,EAAA;MAH/B,MAAM,MAAA,kBAAiB;MACxB,OAAM;MACN,MAAK;MACJ,SAAK,OAAA,OAAA,OAAA,MAAA,WAAE,KAAI,eAAA;;KACd,YAI4B,MAAA,iBAAA,EAAA;MAHzB,MAAM,MAAA,0BAAyB;MAChC,OAAM;MACN,MAAK;MACJ,SAAK,OAAA,OAAA,OAAA,MAAA,WAAE,KAAI,SAAA;;KACd,YAK2C,MAAA,iBAAA,EAAA;MAJzC,OAAM;MACL,MAAM,MAAA,eAAc;MACrB,OAAM;MACN,MAAK;MACJ,SAAK,OAAA,OAAA,OAAA,MAAA,WAAE,KAAI,mBAAoB,QAAA,KAAI;;;IAI/B,OAAK,cA4DH,CA3DK,QAAA,KAAK,YAAY,UAAU,UAAA,UAAA,KAAA,EACzC,mBAyDc,UAAA,EAAA,KAAA,GAAA,EAAA,WAxDI,MAAA,YAAW,CAAA,UAAW,QAAA,KAAK,WAAW,SAAQ,GAAvD,UAAK;yBADd,YAyDc,MAAA,YAAA,EAAA;MAvDX,KAAK,MAAM;MACX,aAAa,QAAA;MACb,YAAY,QAAA;MACZ,YAAY,QAAA;MACZ,MAAM;MACP,QAAO;MACN,aAAW;MACX,cAAU,OAAA,OAAA,OAAA,MAAG,OAAe,KAAI,cAAe,GAAE;MACjD,eAAW,OAAA,OAAA,OAAA,MAAG,OAAe,KAAI,eAAgB,GAAE;;MAQzC,WAAS,SAsBZ,EAAA,MAtBsB,YAAK,CACjC,YAqBM,MAAA,iBAAA,EAAA;OApBJ,iBAAc;OACd,iBAAc;OACd,OAAM;OACL,MAAM,MAAA,oBAAmB;OAC1B,OAAM;OACN,MAAK;OACL,SAAQ;OACR,QAAO;OACN,SAAK,eAAQ,MAAkB,KAAI,YAAa,GAAG,MAAK,EAAA,CAAA,OAAA,CAAA;OACxD,WAAO;gCAA8B,MAAqB,KAAI,YAAa,GAAG,MAAK,EAAA,CAAA,OAAA,CAAA,EAAA,CAAA,OAAA,CAAA;gCAG7C,MAAqB,KAAI,YAAa,GAAG,MAAK,EAAA,CAAA,OAAA,CAAA,EAAA,CAAA,QAAA,CAAA;gCAG9C,MAAqB,KAAI,YAAa,GAAG,MAAK,EAAA,CAAA,OAAA,CAAA,EAAA,CAAA,QAAA,CAAA;gCAGjD,MAAqB,KAAI,YAAa,GAAG,MAAK,EAAA,CAAA,OAAA,CAAA,EAAA,CAAA,KAAA,CAAA;;;;;;;MAS3E,OAAK,SAQM,EAAA,MARI,gBAAS,CACjC,YAOoB,MAAA,kBAAA,EAAA;OANlB,IAAG;OACF,UAAK,WAAE,KAAI,kBAAmB,UAAS;;OAC7B,MAAI,cACK,CAAlB,YAAkB,MAAA,eAAA,CAAA,CAAA,CAAA;OAET,SAAO,cAAc,CAAA,GAAA,OAAA,QAAA,OAAA,MAAA,CAAA,gBAAb,iBAAa,GAAA,CAAA,EAAA,CAAA;;;;;;;;;;8BAKxC,mBAIK,MAJL,YAEqC,mBAErC,EAAA,CAAA;2BAtG2B,CAA7B,mBAA6B,QAAA,MAAA,gBAApB,QAAA,KAAK,MAAK,EAAA,EAAA,CAAA,CAAA;;OAEX,QAAA,UAAA;UACL;sBAC6C,CAAA,OAAA,OAAA,OAAA,KAA9C,mBAA8C,QAAA,EAAxC,OAAM,oBAAkB,EAAC,YAAQ,GAAA,EAAA,CAAA"}

package/dist/v2/features/app/helpers/check-version-conflict.d.ts

@@ -0,0 +1,51 @@
+import type { WorkspaceStore } from '@scalar/workspace-store/client';
+import type { ImportDocumentFromRegistry } from '../../../../v2/types/configuration';
+/** Result returned by `checkVersionConflict`. */
+type CheckVersionConflictResult = {
+    ok: true;
+    hasConflict: boolean;
+    /**
+     * `true` when the result was already cached on the document for the
+     * current registry hash and we did not have to fetch / recompute.
+     */
+    fromCache: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Compute (or reuse a cached) conflict-check result for a registry-backed
+ * workspace document and persist it on `x-scalar-registry-meta`.
+ *
+ * The check is a three-way merge between:
+ *  - the original document (last-known remote, kept in
+ *    `workspaceStore.getOriginalDocument`),
+ *  - the editable workspace document (with the user's local edits),
+ *  - the freshly-fetched remote document advertised at `registryCommitHash`.
+ *
+ * The result is cached on the document under
+ * `x-scalar-registry-meta.{conflictCheckedAgainstHash, hasConflict}` so
+ * subsequent renders can short-circuit. The cache is only valid while
+ * `conflictCheckedAgainstHash === registryCommitHash`.
+ *
+ * Writing to `x-scalar-registry-meta` does not flip the document's
+ * `x-scalar-is-dirty` flag (the workspace store excludes registry meta from
+ * the dirty tracker), so this side effect is safe to perform in the
+ * background.
+ */
+export declare const checkVersionConflict: ({ workspaceStore, fetcher, documentName, namespace, slug, version, registryCommitHash, }: {
+    workspaceStore: WorkspaceStore;
+    fetcher: ImportDocumentFromRegistry;
+    /** Name of the workspace document the cache lives on. */
+    documentName: string;
+    namespace: string;
+    slug: string;
+    version: string;
+    /**
+     * Commit hash advertised by the registry for this version. The conflict
+     * cache is keyed on this hash; passing `undefined` skips the check.
+     */
+    registryCommitHash?: string;
+}) => Promise<CheckVersionConflictResult>;
+export {};
+//# sourceMappingURL=check-version-conflict.d.ts.map

package/dist/v2/features/app/helpers/check-version-conflict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-version-conflict.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/check-version-conflict.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAEpE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAA;AAI1E,iDAAiD;AACjD,KAAK,0BAA0B,GAC3B;IACE,EAAE,EAAE,IAAI,CAAA;IACR,WAAW,EAAE,OAAO,CAAA;IACpB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAA;CACnB,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,GAAU,0FAQxC;IACD,cAAc,EAAE,cAAc,CAAA;IAC9B,OAAO,EAAE,0BAA0B,CAAA;IACnC,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B,KAAG,OAAO,CAAC,0BAA0B,CAiDrC,CAAA"}

package/dist/v2/features/app/helpers/check-version-conflict.js

@@ -0,0 +1,79 @@
+import { detectDocumentConflicts } from "./detect-document-conflicts.js";
+//#region src/v2/features/app/helpers/check-version-conflict.ts
+/**
+* Compute (or reuse a cached) conflict-check result for a registry-backed
+* workspace document and persist it on `x-scalar-registry-meta`.
+*
+* The check is a three-way merge between:
+*  - the original document (last-known remote, kept in
+*    `workspaceStore.getOriginalDocument`),
+*  - the editable workspace document (with the user's local edits),
+*  - the freshly-fetched remote document advertised at `registryCommitHash`.
+*
+* The result is cached on the document under
+* `x-scalar-registry-meta.{conflictCheckedAgainstHash, hasConflict}` so
+* subsequent renders can short-circuit. The cache is only valid while
+* `conflictCheckedAgainstHash === registryCommitHash`.
+*
+* Writing to `x-scalar-registry-meta` does not flip the document's
+* `x-scalar-is-dirty` flag (the workspace store excludes registry meta from
+* the dirty tracker), so this side effect is safe to perform in the
+* background.
+*/
+var checkVersionConflict = async ({ workspaceStore, fetcher, documentName, namespace, slug, version, registryCommitHash }) => {
+	if (!registryCommitHash) return {
+		ok: false,
+		error: "No registry commit hash available for this version."
+	};
+	const document = workspaceStore.workspace.documents[documentName];
+	if (!document) return {
+		ok: false,
+		error: `Document "${documentName}" is not loaded in the workspace.`
+	};
+	const meta = document["x-scalar-registry-meta"];
+	if (meta?.conflictCheckedAgainstHash === registryCommitHash && typeof meta?.hasConflict === "boolean") return {
+		ok: true,
+		hasConflict: meta.hasConflict,
+		fromCache: true
+	};
+	const original = workspaceStore.getOriginalDocument(documentName);
+	if (!original) return {
+		ok: false,
+		error: `Original document for "${documentName}" is unavailable.`
+	};
+	const result = await fetcher({
+		namespace,
+		slug,
+		version
+	});
+	if (!result.ok) return {
+		ok: false,
+		error: `Failed to fetch document: ${result.error || "Unknown error"}`
+	};
+	const hasConflict = detectDocumentConflicts({
+		original,
+		local: document,
+		remote: result.data
+	});
+	document["x-scalar-registry-meta"] = {
+		...meta ?? {
+			namespace,
+			slug,
+			version
+		},
+		namespace,
+		slug,
+		version,
+		conflictCheckedAgainstHash: registryCommitHash,
+		hasConflict
+	};
+	return {
+		ok: true,
+		hasConflict,
+		fromCache: false
+	};
+};
+//#endregion
+export { checkVersionConflict };
+
+//# sourceMappingURL=check-version-conflict.js.map

package/dist/v2/features/app/helpers/check-version-conflict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-version-conflict.js","names":[],"sources":["../../../../../src/v2/features/app/helpers/check-version-conflict.ts"],"sourcesContent":["import type { WorkspaceStore } from '@scalar/workspace-store/client'\n\nimport type { ImportDocumentFromRegistry } from '@/v2/types/configuration'\n\nimport { detectDocumentConflicts } from './detect-document-conflicts'\n\n/** Result returned by `checkVersionConflict`. */\ntype CheckVersionConflictResult =\n  | {\n      ok: true\n      hasConflict: boolean\n      /**\n       * `true` when the result was already cached on the document for the\n       * current registry hash and we did not have to fetch / recompute.\n       */\n      fromCache: boolean\n    }\n  | { ok: false; error: string }\n\n/**\n * Compute (or reuse a cached) conflict-check result for a registry-backed\n * workspace document and persist it on `x-scalar-registry-meta`.\n *\n * The check is a three-way merge between:\n *  - the original document (last-known remote, kept in\n *    `workspaceStore.getOriginalDocument`),\n *  - the editable workspace document (with the user's local edits),\n *  - the freshly-fetched remote document advertised at `registryCommitHash`.\n *\n * The result is cached on the document under\n * `x-scalar-registry-meta.{conflictCheckedAgainstHash, hasConflict}` so\n * subsequent renders can short-circuit. The cache is only valid while\n * `conflictCheckedAgainstHash === registryCommitHash`.\n *\n * Writing to `x-scalar-registry-meta` does not flip the document's\n * `x-scalar-is-dirty` flag (the workspace store excludes registry meta from\n * the dirty tracker), so this side effect is safe to perform in the\n * background.\n */\nexport const checkVersionConflict = async ({\n  workspaceStore,\n  fetcher,\n  documentName,\n  namespace,\n  slug,\n  version,\n  registryCommitHash,\n}: {\n  workspaceStore: WorkspaceStore\n  fetcher: ImportDocumentFromRegistry\n  /** Name of the workspace document the cache lives on. */\n  documentName: string\n  namespace: string\n  slug: string\n  version: string\n  /**\n   * Commit hash advertised by the registry for this version. The conflict\n   * cache is keyed on this hash; passing `undefined` skips the check.\n   */\n  registryCommitHash?: string\n}): Promise<CheckVersionConflictResult> => {\n  if (!registryCommitHash) {\n    return { ok: false, error: 'No registry commit hash available for this version.' }\n  }\n\n  const document = workspaceStore.workspace.documents[documentName]\n  if (!document) {\n    return { ok: false, error: `Document \"${documentName}\" is not loaded in the workspace.` }\n  }\n\n  const meta = document['x-scalar-registry-meta']\n\n  // Cache hit - the previous check was performed against the registry hash\n  // we are being asked about, so we can return the stored result without\n  // touching the network.\n  if (meta?.conflictCheckedAgainstHash === registryCommitHash && typeof meta?.hasConflict === 'boolean') {\n    return { ok: true, hasConflict: meta.hasConflict, fromCache: true }\n  }\n\n  const original = workspaceStore.getOriginalDocument(documentName)\n  if (!original) {\n    return { ok: false, error: `Original document for \"${documentName}\" is unavailable.` }\n  }\n\n  const result = await fetcher({ namespace, slug, version })\n  if (!result.ok) {\n    return { ok: false, error: `Failed to fetch document: ${result.error || 'Unknown error'}` }\n  }\n\n  const hasConflict = detectDocumentConflicts({\n    original: original as Record<string, unknown>,\n    local: document as unknown as Record<string, unknown>,\n    remote: result.data,\n  })\n\n  // Persist the cache on the document. The workspace store's dirty tracker\n  // skips `x-scalar-registry-meta` writes, so this does not mark the\n  // document as having local edits.\n  const next = {\n    ...(meta ?? { namespace, slug, version }),\n    namespace,\n    slug,\n    version,\n    conflictCheckedAgainstHash: registryCommitHash,\n    hasConflict,\n  }\n  document['x-scalar-registry-meta'] = next\n\n  return { ok: true, hasConflict, fromCache: false }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,uBAAuB,OAAO,EACzC,gBACA,SACA,cACA,WACA,MACA,SACA,yBAcyC;AACzC,KAAI,CAAC,mBACH,QAAO;EAAE,IAAI;EAAO,OAAO;EAAuD;CAGpF,MAAM,WAAW,eAAe,UAAU,UAAU;AACpD,KAAI,CAAC,SACH,QAAO;EAAE,IAAI;EAAO,OAAO,aAAa,aAAa;EAAoC;CAG3F,MAAM,OAAO,SAAS;AAKtB,KAAI,MAAM,+BAA+B,sBAAsB,OAAO,MAAM,gBAAgB,UAC1F,QAAO;EAAE,IAAI;EAAM,aAAa,KAAK;EAAa,WAAW;EAAM;CAGrE,MAAM,WAAW,eAAe,oBAAoB,aAAa;AACjE,KAAI,CAAC,SACH,QAAO;EAAE,IAAI;EAAO,OAAO,0BAA0B,aAAa;EAAoB;CAGxF,MAAM,SAAS,MAAM,QAAQ;EAAE;EAAW;EAAM;EAAS,CAAC;AAC1D,KAAI,CAAC,OAAO,GACV,QAAO;EAAE,IAAI;EAAO,OAAO,6BAA6B,OAAO,SAAS;EAAmB;CAG7F,MAAM,cAAc,wBAAwB;EAChC;EACV,OAAO;EACP,QAAQ,OAAO;EAChB,CAAC;AAaF,UAAS,4BARI;EACX,GAAI,QAAQ;GAAE;GAAW;GAAM;GAAS;EACxC;EACA;EACA;EACA,4BAA4B;EAC5B;EACD;AAGD,QAAO;EAAE,IAAI;EAAM;EAAa,WAAW;EAAO"}

package/dist/v2/features/app/helpers/compute-version-status.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Sync status surfaced for a registry-backed document version.
+ *
+ * - `synced`: local commit hash matches the registry's, no local edits since
+ *   the last save. Nothing to push or pull.
+ * - `push`: the workspace document has changes the registry has not seen
+ *   yet. This covers two cases:
+ *   1. Hashes match but the document is dirty (the user has edited it).
+ *   2. The document is a brand-new draft - it has registry coordinates but
+ *      no commit hash on either side, meaning it has never been pushed.
+ * - `pull`: registry advertises a different commit hash than the locally
+ *   stored one *and* we have not detected a merge conflict (or have not
+ *   checked yet). Pulling the upstream version is safe.
+ * - `conflict`: registry advertises a different commit hash than the local
+ *   one *and* a previous conflict check (cached on the document) determined
+ *   that merging the upstream version with the local edits would produce
+ *   conflicts. The user has to resolve them manually.
+ * - `unknown`: the version is not loaded into the workspace store yet, so
+ *   there is nothing local to compare against.
+ */
+export type VersionStatus = 'synced' | 'push' | 'pull' | 'conflict' | 'unknown';
+/**
+ * Derive the sync status for a single registry-backed version from cached
+ * inputs. Pure and synchronous - the conflict check itself is performed
+ * elsewhere (`check-version-conflict`) and persisted on the document so this
+ * function only has to read the cached result.
+ */
+export declare const computeVersionStatus: ({ isLoaded, localHash, registryHash, isDirty, conflictCheckedAgainstHash, hasConflict, }: {
+    /** True when the version has a corresponding workspace document. */
+    isLoaded: boolean;
+    /** Commit hash recorded on the local workspace document, if any. */
+    localHash?: string;
+    /** Commit hash advertised by the registry for this version, if any. */
+    registryHash?: string;
+    /** Whether the workspace document has uncommitted local edits. */
+    isDirty?: boolean;
+    /**
+     * Registry hash that the cached `hasConflict` flag was computed against.
+     * The cache is only valid while it matches `registryHash`.
+     */
+    conflictCheckedAgainstHash?: string;
+    /** Cached outcome of the last conflict check. */
+    hasConflict?: boolean;
+}) => VersionStatus;
+//# sourceMappingURL=compute-version-status.d.ts.map

package/dist/v2/features/app/helpers/compute-version-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-version-status.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/compute-version-status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAA;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,0FAOlC;IACD,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAA;IACjB,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,kEAAkE;IAClE,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;OAGG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAA;IACnC,iDAAiD;IACjD,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,KAAG,aAsBH,CAAA"}

package/dist/v2/features/app/helpers/compute-version-status.js

@@ -0,0 +1,18 @@
+//#region src/v2/features/app/helpers/compute-version-status.ts
+/**
+* Derive the sync status for a single registry-backed version from cached
+* inputs. Pure and synchronous - the conflict check itself is performed
+* elsewhere (`check-version-conflict`) and persisted on the document so this
+* function only has to read the cached result.
+*/
+var computeVersionStatus = ({ isLoaded, localHash, registryHash, isDirty, conflictCheckedAgainstHash, hasConflict }) => {
+	if (!isLoaded) return "unknown";
+	const isConflictActive = hasConflict && conflictCheckedAgainstHash === registryHash;
+	if (!registryHash) return isDirty || !localHash ? "push" : "synced";
+	if (localHash === registryHash) return isDirty ? "push" : "synced";
+	return isConflictActive ? "conflict" : "pull";
+};
+//#endregion
+export { computeVersionStatus };
+
+//# sourceMappingURL=compute-version-status.js.map

package/dist/v2/features/app/helpers/compute-version-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-version-status.js","names":[],"sources":["../../../../../src/v2/features/app/helpers/compute-version-status.ts"],"sourcesContent":["/**\n * Sync status surfaced for a registry-backed document version.\n *\n * - `synced`: local commit hash matches the registry's, no local edits since\n *   the last save. Nothing to push or pull.\n * - `push`: the workspace document has changes the registry has not seen\n *   yet. This covers two cases:\n *   1. Hashes match but the document is dirty (the user has edited it).\n *   2. The document is a brand-new draft - it has registry coordinates but\n *      no commit hash on either side, meaning it has never been pushed.\n * - `pull`: registry advertises a different commit hash than the locally\n *   stored one *and* we have not detected a merge conflict (or have not\n *   checked yet). Pulling the upstream version is safe.\n * - `conflict`: registry advertises a different commit hash than the local\n *   one *and* a previous conflict check (cached on the document) determined\n *   that merging the upstream version with the local edits would produce\n *   conflicts. The user has to resolve them manually.\n * - `unknown`: the version is not loaded into the workspace store yet, so\n *   there is nothing local to compare against.\n */\nexport type VersionStatus = 'synced' | 'push' | 'pull' | 'conflict' | 'unknown'\n\n/**\n * Derive the sync status for a single registry-backed version from cached\n * inputs. Pure and synchronous - the conflict check itself is performed\n * elsewhere (`check-version-conflict`) and persisted on the document so this\n * function only has to read the cached result.\n */\nexport const computeVersionStatus = ({\n  isLoaded,\n  localHash,\n  registryHash,\n  isDirty,\n  conflictCheckedAgainstHash,\n  hasConflict,\n}: {\n  /** True when the version has a corresponding workspace document. */\n  isLoaded: boolean\n  /** Commit hash recorded on the local workspace document, if any. */\n  localHash?: string\n  /** Commit hash advertised by the registry for this version, if any. */\n  registryHash?: string\n  /** Whether the workspace document has uncommitted local edits. */\n  isDirty?: boolean\n  /**\n   * Registry hash that the cached `hasConflict` flag was computed against.\n   * The cache is only valid while it matches `registryHash`.\n   */\n  conflictCheckedAgainstHash?: string\n  /** Cached outcome of the last conflict check. */\n  hasConflict?: boolean\n}): VersionStatus => {\n  // 1. Foundation check\n  if (!isLoaded) {\n    return 'unknown'\n  }\n\n  // 2. Cache Validation: Determine if we have a valid, active conflict\n  const isConflictActive = hasConflict && conflictCheckedAgainstHash === registryHash\n\n  // 3. Scenario: Nothing on the Registry\n  if (!registryHash) {\n    // If no remote hash exists, it's either a fresh draft (push) or a local-only change\n    return isDirty || !localHash ? 'push' : 'synced'\n  }\n\n  // 4. Scenario: Matches Registry\n  if (localHash === registryHash) {\n    return isDirty ? 'push' : 'synced'\n  }\n  // 5. Scenario: Hash Mismatch (or no localHash but registryHash exists)\n  // At this point, localHash !== registryHash and registryHash exists.\n  return isConflictActive ? 'conflict' : 'pull'\n}\n"],"mappings":";;;;;;;AA4BA,IAAa,wBAAwB,EACnC,UACA,WACA,cACA,SACA,4BACA,kBAiBmB;AAEnB,KAAI,CAAC,SACH,QAAO;CAIT,MAAM,mBAAmB,eAAe,+BAA+B;AAGvE,KAAI,CAAC,aAEH,QAAO,WAAW,CAAC,YAAY,SAAS;AAI1C,KAAI,cAAc,aAChB,QAAO,UAAU,SAAS;AAI5B,QAAO,mBAAmB,aAAa"}

package/dist/v2/features/app/helpers/create-draft-registry-document.d.ts

@@ -0,0 +1,39 @@
+import type { WorkspaceStore } from '@scalar/workspace-store/client';
+/** Result of attempting to create a draft registry document. */
+type CreateDraftRegistryDocumentResult = {
+    ok: true;
+    documentName: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Create a draft workspace document for a brand-new registry version.
+ *
+ * The draft is seeded from an existing workspace document (typically the
+ * currently active version) so the user has something to start from rather
+ * than a blank schema. We pull the seed via `getEditableDocument`, which
+ * already returns a clean OpenAPI body (internal extensions like
+ * `x-scalar-is-dirty`, `x-scalar-navigation`, and the original-document hash
+ * are stripped, and `$ref`s are restored), so we only need to stamp the new
+ * `info.version` and let `addDocument` do the rest. The `meta` we pass in
+ * overrides any leftover `x-scalar-registry-meta` from the seed during the
+ * spread that `addInMemoryDocument` performs.
+ *
+ * Crucially, we do not record a `commitHash` in `x-scalar-registry-meta` -
+ * a missing hash is what marks the document as a "draft" the user has not
+ * yet pushed to the registry. If the registry later advertises a hash for
+ * this version, the existing version-status pipeline picks it up and
+ * surfaces the regular pull / conflict flow.
+ */
+export declare const createDraftRegistryDocument: ({ workspaceStore, namespace, slug, version, seedDocumentName, }: {
+    workspaceStore: WorkspaceStore;
+    namespace: string;
+    slug: string;
+    /** Version string the user just typed in the create-version modal. */
+    version: string;
+    /** Name of the workspace document whose contents we branch off for the draft. */
+    seedDocumentName: string;
+}) => Promise<CreateDraftRegistryDocumentResult>;
+export {};
+//# sourceMappingURL=create-draft-registry-document.d.ts.map

package/dist/v2/features/app/helpers/create-draft-registry-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-draft-registry-document.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/create-draft-registry-document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAIpE,gEAAgE;AAChE,KAAK,iCAAiC,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1G;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,2BAA2B,GAAU,iEAM/C;IACD,cAAc,EAAE,cAAc,CAAA;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAA;IACf,iFAAiF;IACjF,gBAAgB,EAAE,MAAM,CAAA;CACzB,KAAG,OAAO,CAAC,iCAAiC,CAwD5C,CAAA"}

package/dist/v2/features/app/helpers/create-draft-registry-document.js

@@ -0,0 +1,64 @@
+import { generateUniqueSlug } from "../../command-palette/helpers/generate-unique-slug.js";
+//#region src/v2/features/app/helpers/create-draft-registry-document.ts
+/**
+* Create a draft workspace document for a brand-new registry version.
+*
+* The draft is seeded from an existing workspace document (typically the
+* currently active version) so the user has something to start from rather
+* than a blank schema. We pull the seed via `getEditableDocument`, which
+* already returns a clean OpenAPI body (internal extensions like
+* `x-scalar-is-dirty`, `x-scalar-navigation`, and the original-document hash
+* are stripped, and `$ref`s are restored), so we only need to stamp the new
+* `info.version` and let `addDocument` do the rest. The `meta` we pass in
+* overrides any leftover `x-scalar-registry-meta` from the seed during the
+* spread that `addInMemoryDocument` performs.
+*
+* Crucially, we do not record a `commitHash` in `x-scalar-registry-meta` -
+* a missing hash is what marks the document as a "draft" the user has not
+* yet pushed to the registry. If the registry later advertises a hash for
+* this version, the existing version-status pipeline picks it up and
+* surfaces the regular pull / conflict flow.
+*/
+var createDraftRegistryDocument = async ({ workspaceStore, namespace, slug, version, seedDocumentName }) => {
+	const cloned = await workspaceStore.getEditableDocument(seedDocumentName);
+	if (!cloned) return {
+		ok: false,
+		error: `Seed document "${seedDocumentName}" is not loaded in the workspace.`
+	};
+	cloned.info = {
+		...cloned.info ?? { title: "" },
+		version
+	};
+	const documentName = await generateUniqueSlug(`${cloned.info.title?.trim() || slug}-${version}`, new Set(Object.keys(workspaceStore.workspace.documents)));
+	if (!documentName) return {
+		ok: false,
+		error: "Failed to generate a unique name for the new version."
+	};
+	try {
+		if (!await workspaceStore.addDocument({
+			name: documentName,
+			document: cloned,
+			meta: { "x-scalar-registry-meta": {
+				namespace,
+				slug,
+				version
+			} }
+		})) return {
+			ok: false,
+			error: "Failed to add the new version to the workspace."
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: error instanceof Error ? error.message : "Failed to add the new version to the workspace."
+		};
+	}
+	return {
+		ok: true,
+		documentName
+	};
+};
+//#endregion
+export { createDraftRegistryDocument };
+
+//# sourceMappingURL=create-draft-registry-document.js.map

package/dist/v2/features/app/helpers/create-draft-registry-document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-draft-registry-document.js","names":[],"sources":["../../../../../src/v2/features/app/helpers/create-draft-registry-document.ts"],"sourcesContent":["import type { WorkspaceStore } from '@scalar/workspace-store/client'\n\nimport { generateUniqueSlug } from '@/v2/features/command-palette/helpers/generate-unique-slug'\n\n/** Result of attempting to create a draft registry document. */\ntype CreateDraftRegistryDocumentResult = { ok: true; documentName: string } | { ok: false; error: string }\n\n/**\n * Create a draft workspace document for a brand-new registry version.\n *\n * The draft is seeded from an existing workspace document (typically the\n * currently active version) so the user has something to start from rather\n * than a blank schema. We pull the seed via `getEditableDocument`, which\n * already returns a clean OpenAPI body (internal extensions like\n * `x-scalar-is-dirty`, `x-scalar-navigation`, and the original-document hash\n * are stripped, and `$ref`s are restored), so we only need to stamp the new\n * `info.version` and let `addDocument` do the rest. The `meta` we pass in\n * overrides any leftover `x-scalar-registry-meta` from the seed during the\n * spread that `addInMemoryDocument` performs.\n *\n * Crucially, we do not record a `commitHash` in `x-scalar-registry-meta` -\n * a missing hash is what marks the document as a \"draft\" the user has not\n * yet pushed to the registry. If the registry later advertises a hash for\n * this version, the existing version-status pipeline picks it up and\n * surfaces the regular pull / conflict flow.\n */\nexport const createDraftRegistryDocument = async ({\n  workspaceStore,\n  namespace,\n  slug,\n  version,\n  seedDocumentName,\n}: {\n  workspaceStore: WorkspaceStore\n  namespace: string\n  slug: string\n  /** Version string the user just typed in the create-version modal. */\n  version: string\n  /** Name of the workspace document whose contents we branch off for the draft. */\n  seedDocumentName: string\n}): Promise<CreateDraftRegistryDocumentResult> => {\n  const cloned = await workspaceStore.getEditableDocument(seedDocumentName)\n  if (!cloned) {\n    return {\n      ok: false,\n      error: `Seed document \"${seedDocumentName}\" is not loaded in the workspace.`,\n    }\n  }\n\n  // Stamp the user-typed version onto the document itself so the rendered\n  // OpenAPI matches the registry coordinates. `info` is required by the\n  // OpenAPI schema, but we still guard against an unusually shaped seed.\n  cloned.info = { ...(cloned.info ?? { title: '' }), version }\n\n  // Compose the workspace key as `slug(title)-slug(version)`\n  // so the url will be like /workspace/acme/pets-api-1.0.0\n  const title = cloned.info.title?.trim() || slug\n  const documentName = await generateUniqueSlug(\n    `${title}-${version}`,\n    new Set(Object.keys(workspaceStore.workspace.documents)),\n  )\n\n  if (!documentName) {\n    return {\n      ok: false,\n      error: 'Failed to generate a unique name for the new version.',\n    }\n  }\n\n  try {\n    const ok = await workspaceStore.addDocument({\n      name: documentName,\n      document: cloned,\n      meta: {\n        'x-scalar-registry-meta': {\n          namespace,\n          slug,\n          version,\n        },\n      },\n    })\n\n    if (!ok) {\n      return {\n        ok: false,\n        error: 'Failed to add the new version to the workspace.',\n      }\n    }\n  } catch (error) {\n    return {\n      ok: false,\n      error: error instanceof Error ? error.message : 'Failed to add the new version to the workspace.',\n    }\n  }\n\n  return { ok: true, documentName }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,8BAA8B,OAAO,EAChD,gBACA,WACA,MACA,SACA,uBASgD;CAChD,MAAM,SAAS,MAAM,eAAe,oBAAoB,iBAAiB;AACzE,KAAI,CAAC,OACH,QAAO;EACL,IAAI;EACJ,OAAO,kBAAkB,iBAAiB;EAC3C;AAMH,QAAO,OAAO;EAAE,GAAI,OAAO,QAAQ,EAAE,OAAO,IAAI;EAAG;EAAS;CAK5D,MAAM,eAAe,MAAM,mBACzB,GAFY,OAAO,KAAK,OAAO,MAAM,IAAI,KAEhC,GAAG,WACZ,IAAI,IAAI,OAAO,KAAK,eAAe,UAAU,UAAU,CAAC,CACzD;AAED,KAAI,CAAC,aACH,QAAO;EACL,IAAI;EACJ,OAAO;EACR;AAGH,KAAI;AAaF,MAAI,CAZO,MAAM,eAAe,YAAY;GAC1C,MAAM;GACN,UAAU;GACV,MAAM,EACJ,0BAA0B;IACxB;IACA;IACA;IACD,EACF;GACF,CAAC,CAGA,QAAO;GACL,IAAI;GACJ,OAAO;GACR;UAEI,OAAO;AACd,SAAO;GACL,IAAI;GACJ,OAAO,iBAAiB,QAAQ,MAAM,UAAU;GACjD;;AAGH,QAAO;EAAE,IAAI;EAAM;EAAc"}

package/dist/v2/features/app/helpers/create-temp-operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-temp-operation.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/create-temp-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AA+BvE;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAC9B,cAAc,MAAM,EACpB,SAAS;IACP,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC1B,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB,SA+BF,CAAA"}
+{"version":3,"file":"create-temp-operation.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/create-temp-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AA+BvE;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAC9B,cAAc,MAAM,EACpB,SAAS;IACP,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC1B,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB,SAyBF,CAAA"}

package/dist/v2/features/app/helpers/create-temp-operation.js

@@ -12,8 +12,8 @@
 * @returns A unique operation path (e.g., "/temp1234abcd")
 */
 var generateUniquePath = (existingPaths, attempts = 0) => {
-	if (attempts > 10) return "/temp-path";
-	const path = `/temp${crypto.randomUUID().slice(0, 8)}`;
+	if (attempts > 10) return "/_scalar_temp";
+	const path = `/_scalar_temp${crypto.randomUUID().slice(0, 8)}`;
 	if (existingPaths.has(path)) return generateUniquePath(existingPaths, attempts + 1);
 	return path;
 };
@@ -35,16 +35,13 @@ var createTempOperation = (documentName, options) => {
 			tags: options.tags ?? []
 		},
 		callback: (success) => {
-			if (success) options.eventBus.emit("ui:navigate", {
+			if (!success) return;
+			options.eventBus.emit("ui:navigate", {
 				page: "example",
 				documentSlug: documentName,
 				path: uniquePath,
 				method: "get",
-				exampleName: "default",
-				callback: async () => {
-					await new Promise((resolve) => requestAnimationFrame(resolve));
-					options.eventBus.emit("ui:focus:address-bar", { clear: true });
-				}
+				exampleName: "default"
 			});
 		}
 	});

package/dist/v2/features/app/helpers/create-temp-operation.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-temp-operation.js","names":[],"sources":["../../../../../src/v2/features/app/helpers/create-temp-operation.ts"],"sourcesContent":["import type { WorkspaceEventBus } from '@scalar/workspace-store/events'\n\n/**\n * Generates a unique temporary operation path for a new operation.\n * Tries up to 10 times to generate a non-colliding path, then falls back to a static path.\n *\n * Example:\n * const existingPaths = new Set(['/tempabcd1234', '/tempdeadbeef']);\n * const newPath = generateUniquePath('my-doc', existingPaths); // e.g. \"/tempa1b2c3d4\"\n *\n * @param existingPaths - Set of paths already present in the document to avoid collisions\n * @param attempts - Used internally to limit recursion (default: 0)\n * @returns A unique operation path (e.g., \"/temp1234abcd\")\n */\nconst generateUniquePath = (existingPaths: Set<string>, attempts: number = 0) => {\n  if (attempts > 10) {\n    // After 10 failed attempts, fallback to a generic path\n    return '/temp-path'\n  }\n\n  // Generate a random path using a truncated UUID for uniqueness\n  const path = `/temp${crypto.randomUUID().slice(0, 8)}`\n\n  if (existingPaths.has(path)) {\n    // If path exists, try again recursively with incremented attempts\n    return generateUniquePath(existingPaths, attempts + 1)\n  }\n\n  return path\n}\n\n/**\n * Creates a temporary operation with a unique path, emits its creation on the event bus,\n * then navigates to the operation and focuses the address bar if successful.\n * @param documentName - The name of the document to add the operation to\n * @param existingPaths - Set of existing operation paths for uniqueness checking\n * @param eventBus - The workspace event bus to emit events on\n */\nexport const createTempOperation = (\n  documentName: string,\n  options: {\n    existingPaths: Set<string>\n    eventBus: WorkspaceEventBus\n    tags?: string[]\n  },\n) => {\n  const uniquePath = generateUniquePath(options.existingPaths)\n\n  options.eventBus.emit('operation:create:operation', {\n    documentName,\n    path: uniquePath,\n    method: 'get',\n    operation: {\n      summary: 'New operation',\n      tags: options.tags ?? [],\n    },\n    callback: (success) => {\n      if (success) {\n        options.eventBus.emit('ui:navigate', {\n          page: 'example',\n          documentSlug: documentName,\n          path: uniquePath,\n          method: 'get',\n          exampleName: 'default',\n          callback: async () => {\n            await new Promise((resolve) => requestAnimationFrame(resolve))\n            // Focus the address bar, clearing its contents after navigation\n            options.eventBus.emit('ui:focus:address-bar', {\n              clear: true,\n            })\n          },\n        })\n      }\n    },\n  })\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,IAAM,sBAAsB,eAA4B,WAAmB,MAAM;AAC/E,KAAI,WAAW,GAEb,QAAO;CAIT,MAAM,OAAO,QAAQ,OAAO,YAAY,CAAC,MAAM,GAAG,EAAE;AAEpD,KAAI,cAAc,IAAI,KAAK,CAEzB,QAAO,mBAAmB,eAAe,WAAW,EAAE;AAGxD,QAAO;;;;;;;;;AAUT,IAAa,uBACX,cACA,YAKG;CACH,MAAM,aAAa,mBAAmB,QAAQ,cAAc;AAE5D,SAAQ,SAAS,KAAK,8BAA8B;EAClD;EACA,MAAM;EACN,QAAQ;EACR,WAAW;GACT,SAAS;GACT,MAAM,QAAQ,QAAQ,EAAE;GACzB;EACD,WAAW,YAAY;AACrB,OAAI,QACF,SAAQ,SAAS,KAAK,eAAe;IACnC,MAAM;IACN,cAAc;IACd,MAAM;IACN,QAAQ;IACR,aAAa;IACb,UAAU,YAAY;AACpB,WAAM,IAAI,SAAS,YAAY,sBAAsB,QAAQ,CAAC;AAE9D,aAAQ,SAAS,KAAK,wBAAwB,EAC5C,OAAO,MACR,CAAC;;IAEL,CAAC;;EAGP,CAAC"}
+{"version":3,"file":"create-temp-operation.js","names":[],"sources":["../../../../../src/v2/features/app/helpers/create-temp-operation.ts"],"sourcesContent":["import type { WorkspaceEventBus } from '@scalar/workspace-store/events'\n\n/**\n * Generates a unique temporary operation path for a new operation.\n * Tries up to 10 times to generate a non-colliding path, then falls back to a static path.\n *\n * Example:\n * const existingPaths = new Set(['/tempabcd1234', '/tempdeadbeef']);\n * const newPath = generateUniquePath('my-doc', existingPaths); // e.g. \"/tempa1b2c3d4\"\n *\n * @param existingPaths - Set of paths already present in the document to avoid collisions\n * @param attempts - Used internally to limit recursion (default: 0)\n * @returns A unique operation path (e.g., \"/temp1234abcd\")\n */\nconst generateUniquePath = (existingPaths: Set<string>, attempts: number = 0) => {\n  if (attempts > 10) {\n    // After 10 failed attempts, fallback to a generic path\n    return '/_scalar_temp'\n  }\n\n  // Generate a random path using a truncated UUID for uniqueness\n  const path = `/_scalar_temp${crypto.randomUUID().slice(0, 8)}`\n\n  if (existingPaths.has(path)) {\n    // If path exists, try again recursively with incremented attempts\n    return generateUniquePath(existingPaths, attempts + 1)\n  }\n\n  return path\n}\n\n/**\n * Creates a temporary operation with a unique path, emits its creation on the event bus,\n * then navigates to the operation and focuses the address bar if successful.\n * @param documentName - The name of the document to add the operation to\n * @param existingPaths - Set of existing operation paths for uniqueness checking\n * @param eventBus - The workspace event bus to emit events on\n */\nexport const createTempOperation = (\n  documentName: string,\n  options: {\n    existingPaths: Set<string>\n    eventBus: WorkspaceEventBus\n    tags?: string[]\n  },\n) => {\n  const uniquePath = generateUniquePath(options.existingPaths)\n\n  options.eventBus.emit('operation:create:operation', {\n    documentName,\n    path: uniquePath,\n    method: 'get',\n    operation: {\n      summary: 'New operation',\n      tags: options.tags ?? [],\n    },\n    callback: (success) => {\n      if (!success) {\n        return\n      }\n      options.eventBus.emit('ui:navigate', {\n        page: 'example',\n        documentSlug: documentName,\n        path: uniquePath,\n        method: 'get',\n        exampleName: 'default',\n      })\n    },\n  })\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,IAAM,sBAAsB,eAA4B,WAAmB,MAAM;AAC/E,KAAI,WAAW,GAEb,QAAO;CAIT,MAAM,OAAO,gBAAgB,OAAO,YAAY,CAAC,MAAM,GAAG,EAAE;AAE5D,KAAI,cAAc,IAAI,KAAK,CAEzB,QAAO,mBAAmB,eAAe,WAAW,EAAE;AAGxD,QAAO;;;;;;;;;AAUT,IAAa,uBACX,cACA,YAKG;CACH,MAAM,aAAa,mBAAmB,QAAQ,cAAc;AAE5D,SAAQ,SAAS,KAAK,8BAA8B;EAClD;EACA,MAAM;EACN,QAAQ;EACR,WAAW;GACT,SAAS;GACT,MAAM,QAAQ,QAAQ,EAAE;GACzB;EACD,WAAW,YAAY;AACrB,OAAI,CAAC,QACH;AAEF,WAAQ,SAAS,KAAK,eAAe;IACnC,MAAM;IACN,cAAc;IACd,MAAM;IACN,QAAQ;IACR,aAAa;IACd,CAAC;;EAEL,CAAC"}

package/dist/v2/features/app/helpers/detect-document-conflicts.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Detect whether merging an upstream document with the local edits would
+ * produce conflicts.
+ *
+ * The check is a classic three-way comparison:
+ *  1. Diff the original (last-known remote) document against the local
+ *     editable copy - this captures the user's edits.
+ *  2. Diff the original against the new remote document - this captures the
+ *     upstream changes.
+ *  3. Run `merge` from `@scalar/json-magic/diff` over both diff lists. The
+ *     merge yields a `conflicts` array for paths that were touched by both
+ *     sides in incompatible ways. Any non-empty array means the user must
+ *     resolve the conflicts manually.
+ *
+ * The function is pure - callers are responsible for fetching the remote
+ * document and persisting the result on the workspace document.
+ */
+export declare const detectDocumentConflicts: ({ original, local, remote, }: {
+    /** Last-known remote document (the baseline both sides diverged from). */
+    original: Record<string, unknown>;
+    /** Current editable workspace document, including any local edits. */
+    local: Record<string, unknown>;
+    /** Newly-fetched remote document we want to merge in. */
+    remote: Record<string, unknown>;
+}) => boolean;
+//# sourceMappingURL=detect-document-conflicts.d.ts.map

package/dist/v2/features/app/helpers/detect-document-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-document-conflicts.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/detect-document-conflicts.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB,GAAI,8BAIrC;IACD,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAChC,KAAG,OAKH,CAAA"}

package/dist/v2/features/app/helpers/detect-document-conflicts.js

@@ -0,0 +1,27 @@
+import { diff, merge } from "@scalar/json-magic/diff";
+//#region src/v2/features/app/helpers/detect-document-conflicts.ts
+/**
+* Detect whether merging an upstream document with the local edits would
+* produce conflicts.
+*
+* The check is a classic three-way comparison:
+*  1. Diff the original (last-known remote) document against the local
+*     editable copy - this captures the user's edits.
+*  2. Diff the original against the new remote document - this captures the
+*     upstream changes.
+*  3. Run `merge` from `@scalar/json-magic/diff` over both diff lists. The
+*     merge yields a `conflicts` array for paths that were touched by both
+*     sides in incompatible ways. Any non-empty array means the user must
+*     resolve the conflicts manually.
+*
+* The function is pure - callers are responsible for fetching the remote
+* document and persisting the result on the workspace document.
+*/
+var detectDocumentConflicts = ({ original, local, remote }) => {
+	const { conflicts } = merge(diff(original, local), diff(original, remote));
+	return conflicts.length > 0;
+};
+//#endregion
+export { detectDocumentConflicts };
+
+//# sourceMappingURL=detect-document-conflicts.js.map

package/dist/v2/features/app/helpers/detect-document-conflicts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-document-conflicts.js","names":[],"sources":["../../../../../src/v2/features/app/helpers/detect-document-conflicts.ts"],"sourcesContent":["import { diff, merge } from '@scalar/json-magic/diff'\n\n/**\n * Detect whether merging an upstream document with the local edits would\n * produce conflicts.\n *\n * The check is a classic three-way comparison:\n *  1. Diff the original (last-known remote) document against the local\n *     editable copy - this captures the user's edits.\n *  2. Diff the original against the new remote document - this captures the\n *     upstream changes.\n *  3. Run `merge` from `@scalar/json-magic/diff` over both diff lists. The\n *     merge yields a `conflicts` array for paths that were touched by both\n *     sides in incompatible ways. Any non-empty array means the user must\n *     resolve the conflicts manually.\n *\n * The function is pure - callers are responsible for fetching the remote\n * document and persisting the result on the workspace document.\n */\nexport const detectDocumentConflicts = ({\n  original,\n  local,\n  remote,\n}: {\n  /** Last-known remote document (the baseline both sides diverged from). */\n  original: Record<string, unknown>\n  /** Current editable workspace document, including any local edits. */\n  local: Record<string, unknown>\n  /** Newly-fetched remote document we want to merge in. */\n  remote: Record<string, unknown>\n}): boolean => {\n  const localChanges = diff(original, local)\n  const remoteChanges = diff(original, remote)\n  const { conflicts } = merge(localChanges, remoteChanges)\n  return conflicts.length > 0\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,IAAa,2BAA2B,EACtC,UACA,OACA,aAQa;CAGb,MAAM,EAAE,cAAc,MAFD,KAAK,UAAU,MAAM,EACpB,KAAK,UAAU,OAAO,CACY;AACxD,QAAO,UAAU,SAAS"}