@scalar/api-client 3.6.1 → 3.8.1

package/dist/v2/features/app/hooks/use-document-sync.js

@@ -1,448 +0,0 @@
-import { useActiveDocumentVersion } from "./use-active-document-version.js";
-import { messageForFetchError, messageForPublishDocumentError, messageForPublishVersionError } from "../helpers/registry-error-messages.js";
-import { useNetworkStatus } from "./use-network-status.js";
-import { computed, ref } from "vue";
-import { useModal } from "@scalar/components";
-import { useToasts } from "@scalar/use-toasts";
-import { apply } from "@scalar/json-magic/diff";
-import { deepClone } from "@scalar/workspace-store/helpers/deep-clone";
-//#region src/v2/features/app/hooks/use-document-sync.ts
-/**
-* Default namespaces state surfaced when the host application has not
-* wired a registry adapter up yet. Keeping this as a constant (rather
-* than recomputing every render) lets the publish modal mount with a
-* stable reference and avoids triggering its `watch` for nothing.
-*/
-var EMPTY_NAMESPACES_STATE = {
-	status: "success",
-	namespaces: []
-};
-/**
-* Owns the document-level sync flow for the API client header: save,
-* revert, pull, push, and first-time publish. The top-level `App.vue`
-* was accumulating all five flows alongside its routing / layout glue,
-* which made the file hard to reason about in isolation - extracting
-* the registry-bound logic into a single hook keeps the component
-* declarative and gives the flow a single place to test against.
-*
-* The hook owns:
-*  - the visibility computeds for each header action cluster,
-*  - the network-aware enable / disable gates (`canPullActiveDocument`,
-*    `canPushActiveDocument`),
-*  - the modal states for the publish + sync-conflict flows,
-*  - the pending pull state captured while the three-way merge editor
-*    is open,
-*  - and every async handler invoked from the header buttons / modals.
-*/
-var useDocumentSync = ({ app, registry, registryDocuments }) => {
-	const { toast } = useToasts();
-	/**
-	* Resolves the registry meta and sync status for the active document.
-	* The breadcrumb already drives this composable for its version picker;
-	* we reuse it here so the header action cluster reads from exactly the
-	* same `pull` / `push` / `synced` source of truth that the picker rows
-	* and the inline status icons do.
-	*/
-	const { activeRegistryMeta, activeVersion } = useActiveDocumentVersion({
-		app,
-		registryDocuments
-	});
-	const publishDocumentModalState = useModal();
-	const syncConflictModalState = useModal();
-	/** Whether the route currently resolves to a document. */
-	const hasActiveDocument = computed(() => Boolean(app.activeEntities.documentSlug.value));
-	/** Whether the active document has unsaved local edits. */
-	const isActiveDocumentDirty = computed(() => app.store.value?.workspace.activeDocument?.["x-scalar-is-dirty"] === true);
-	/**
-	* Save / Revert cluster for local workspaces. Mirrors the save-prompt UX
-	* of the document collection page: Save is always mounted while a doc is
-	* active and gets disabled when there is nothing to persist; Revert only
-	* shows up while the document is dirty.
-	*/
-	const showLocalSaveActions = computed(() => !app.workspace.isTeamWorkspace.value && hasActiveDocument.value);
-	/**
-	* Pull / Push cluster for team workspace documents that already have a
-	* registry relationship. The same `Revert` button as local workspaces
-	* sits in front of it so a dirty document can be discarded without going
-	* through the registry round-trip.
-	*/
-	const showTeamSyncActions = computed(() => app.workspace.isTeamWorkspace.value && hasActiveDocument.value && Boolean(activeRegistryMeta.value));
-	/**
-	* Publish cluster for team workspace documents that do not yet have a
-	* registry entry. We surface it as a single "Publish" affordance instead
-	* of the Pull / Push pair because there is no upstream version to sync
-	* against - the action is simply "create the registry version".
-	*/
-	const showTeamPublishAction = computed(() => app.workspace.isTeamWorkspace.value && hasActiveDocument.value && !activeRegistryMeta.value);
-	/**
-	* Reactive online / offline status for the browser. Registry-bound
-	* actions (Pull, Push, Publish) all need a live network connection, so
-	* we surface a single source of truth here and let the per-action
-	* `canX` computeds AND the icon swaps below consume it.
-	*/
-	const { isOnline, isOffline } = useNetworkStatus();
-	/**
-	* Pull is enabled while the registry advertises a different commit hash
-	* than the local one, regardless of whether the local document is dirty.
-	* `conflict` is treated the same as `pull` here so the user can always
-	* reach the conflict-resolution flow from the header. We additionally
-	* gate on `isOnline` so the button stops responding the moment the
-	* browser reports an offline transition - any click we accepted would
-	* fail the `fetchDocument` adapter call anyway.
-	*/
-	const canPullActiveDocument = computed(() => {
-		if (!isOnline.value) return false;
-		const status = activeVersion.value?.status;
-		return status === "pull" || status === "conflict";
-	});
-	/**
-	* Push is only enabled when the document is dirty *and* there are no
-	* upstream changes - mirroring `computeVersionStatus`'s `'push'` outcome,
-	* which already encodes that combination. Pushing while upstream has
-	* moved on would clobber the registry version, so we lock the button
-	* until the user has pulled / resolved. We also gate on `isOnline` so a
-	* disconnected client cannot trigger a publish attempt that we know
-	* will fail.
-	*/
-	const canPushActiveDocument = computed(() => isOnline.value && activeVersion.value?.status === "push");
-	/**
-	* Truthy when *any* trailing action cluster is renderable. Used to gate
-	* the leading edge of the header end slot (and the divider against the
-	* consumer-provided `header-end` cluster) without re-deriving the same
-	* conditions in the template.
-	*/
-	const hasHeaderActionCluster = computed(() => showLocalSaveActions.value || showTeamSyncActions.value || showTeamPublishAction.value);
-	const handleSaveDocument = async () => {
-		const slug = app.activeEntities.documentSlug.value;
-		if (!slug || !app.store.value) return;
-		await app.store.value.saveDocument(slug);
-	};
-	const handleRevertDocument = async () => {
-		const slug = app.activeEntities.documentSlug.value;
-		if (!slug || !app.store.value) return;
-		await app.store.value.revertDocumentChanges(slug);
-	};
-	const pendingPullState = ref(null);
-	/**
-	* Stamp the registry's advertised commit hash onto the active document
-	* after a successful pull. Extracted out of `handlePullDocument`
-	* because the post-rebase work happens in two different places now:
-	* inline when the rebase auto-merges cleanly, and from the conflict
-	* modal's `applyChanges` callback once the user has resolved everything
-	* by hand.
-	*
-	* We only update when the listing actually advertised a hash and the
-	* meta still has a concrete `version` to write into; otherwise we leave
-	* the previous value alone so a missing hash does not erase one we
-	* already had.
-	*
-	* We deliberately do *not* call `saveDocument` here: `rebaseDocument`
-	* has already written the merged content to `originalDocuments` and
-	* decided whether the document should stay dirty (local edits folded on
-	* top of upstream) or clean (pure fast-forward). Calling `saveDocument`
-	* would clobber that dirty flag and make the push button disappear
-	* whenever a rebase replayed local commits.
-	*/
-	const stampPostPullCommitHash = (params) => {
-		const { meta, slug, incomingCommitHash } = params;
-		const store = app.store.value;
-		if (!store) return;
-		if (!incomingCommitHash || incomingCommitHash === meta.commitHash || !meta.version) return;
-		store.updateDocument(slug, "x-scalar-registry-meta", {
-			...meta,
-			version: meta.version,
-			commitHash: incomingCommitHash
-		});
-	};
-	/**
-	* Pulls the active document's latest version from the registry and
-	* rebases local edits on top of it.
-	*
-	* The flow mirrors a `git pull --rebase`:
-	*  1. Fetch the upstream snapshot for the active version through the
-	*     registry adapter.
-	*  2. Hand the snapshot to `workspaceStore.rebaseDocument`, which
-	*     diffs it against the last saved baseline and the in-memory
-	*     edits so local work is preserved.
-	*  3. Apply the auto-merged diffs immediately when the rebase has no
-	*     conflicts. When `result.conflicts` is non-empty we open the
-	*     three-way merge editor instead and let the user resolve every
-	*     conflict by hand; the editor's `applyChanges` callback is what
-	*     actually commits the rebase in that branch.
-	*/
-	const handlePullDocument = async () => {
-		if (!canPullActiveDocument.value) return;
-		const meta = activeRegistryMeta.value;
-		const slug = app.activeEntities.documentSlug.value;
-		const store = app.store.value;
-		if (!meta || !slug || !registry || !store) return;
-		const fetched = await registry.fetchDocument({
-			namespace: meta.namespace,
-			slug: meta.slug,
-			version: meta.version
-		});
-		if (!fetched.ok) {
-			toast(messageForFetchError(fetched.error, fetched.message), "error");
-			return;
-		}
-		const result = await store.rebaseDocument({
-			name: slug,
-			document: fetched.data.document
-		});
-		const incomingCommitHash = fetched.data.versionSha;
-		if (!result.ok) {
-			if (result.type === "NO_CHANGES_DETECTED") {
-				stampPostPullCommitHash({
-					meta,
-					slug,
-					incomingCommitHash
-				});
-				app.eventBus.emit("hooks:on:rebase:document:complete", { meta: { documentName: slug } });
-				toast("Already up to date with the registry.", "info");
-				return;
-			}
-			if (result.type === "CORRUPTED_STATE") {
-				toast("The document state appears to be missing locally. Try reloading the workspace.", "error");
-				return;
-			}
-			toast(`Pull failed: ${result.message}`, "error");
-			return;
-		}
-		if (result.conflicts.length > 0) {
-			const originalDocument = store.getOriginalDocument(slug) ?? {};
-			pendingPullState.value = {
-				rebaseResult: {
-					originalDocument,
-					resolvedDocument: apply(deepClone(originalDocument), result.changes),
-					conflicts: result.conflicts,
-					applyChanges: result.applyChanges
-				},
-				meta,
-				slug,
-				incomingCommitHash
-			};
-			syncConflictModalState.show();
-			return;
-		}
-		await result.applyChanges({ resolvedConflicts: [] });
-		stampPostPullCommitHash({
-			meta,
-			slug,
-			incomingCommitHash
-		});
-		app.eventBus.emit("hooks:on:rebase:document:complete", { meta: { documentName: slug } });
-		toast("Pulled latest changes from the registry.", "info");
-	};
-	/**
-	* Apply callback wired up to `SyncConflictResolutionEditor`. The user
-	* has resolved every conflict at this point, so the merge editor hands
-	* us back the fully resolved document. We commit it through the same
-	* `applyChanges` the rebase exposed, then stamp the upstream commit
-	* hash and toast - exactly like the auto-merge branch above.
-	*/
-	const handleSyncConflictApplyChanges = async ({ resolvedDocument }) => {
-		const pending = pendingPullState.value;
-		if (!pending) return;
-		await pending.rebaseResult.applyChanges({ resolvedDocument });
-		stampPostPullCommitHash({
-			meta: pending.meta,
-			slug: pending.slug,
-			incomingCommitHash: pending.incomingCommitHash
-		});
-		syncConflictModalState.hide();
-		app.eventBus.emit("hooks:on:rebase:document:complete", { meta: { documentName: pending.slug } });
-		pendingPullState.value = null;
-		toast("Pulled latest changes from the registry.", "info");
-	};
-	/**
-	* Reset the pending pull when the conflict modal closes without an
-	* apply. The workspace store only mutates inside `applyChanges`, so
-	* dropping the captured rebase result is enough to leave the local
-	* document untouched.
-	*/
-	const handleSyncConflictModalClose = () => {
-		pendingPullState.value = null;
-	};
-	/**
-	* Pushes the active document up to the registry as the next commit on
-	* the current version.
-	*
-	* The local `commitHash` is sent along with the publish call so the
-	* registry can do optimistic concurrency: a `CONFLICT` response means
-	* somebody pushed in the meantime and the user is expected to pull
-	* before retrying. On success two writes happen locally:
-	*
-	*  1. The freshly returned commit hash is stamped onto the active
-	*     document's `x-scalar-registry-meta` so subsequent sync checks
-	*     compare against the right base. This write goes through
-	*     `updateDocument`, which is metadata-only and does not flip the
-	*     dirty flag.
-	*  2. `saveDocument` promotes the active document to the new saved
-	*     baseline (and clears `x-scalar-is-dirty`), so a later revert
-	*     restores to the post-push state instead of pre-push edits.
-	*/
-	const handlePushDocument = async () => {
-		if (!canPushActiveDocument.value) return;
-		const meta = activeRegistryMeta.value;
-		const slug = app.activeEntities.documentSlug.value;
-		const store = app.store.value;
-		if (!meta || !slug || !registry || !store) return;
-		const { namespace, slug: registrySlug, version } = meta;
-		if (!version) {
-			toast("This document is missing a version - cannot push without one.", "error");
-			return;
-		}
-		const documentBody = await store.getEditableDocument(slug);
-		if (!documentBody) {
-			toast("Could not read the active document. Please reload and try again.", "error");
-			return;
-		}
-		const result = await registry.publishVersion({
-			namespace,
-			slug: registrySlug,
-			version,
-			commitHash: meta.commitHash,
-			document: documentBody
-		});
-		if (!result.ok) {
-			if (result.error === "CONFLICT") await registry.refreshDocuments?.();
-			toast(messageForPublishVersionError(result.error, result.message), "error");
-			return;
-		}
-		store.updateDocument(slug, "x-scalar-registry-meta", {
-			...meta,
-			version,
-			commitHash: result.data.commitHash
-		});
-		await store.saveDocument(slug);
-		await registry.refreshDocuments?.();
-		toast("Pushed changes to the registry.", "info");
-	};
-	/**
-	* Reactive view of the namespaces the user can publish to. Falls back
-	* to an empty success state when no adapter is wired up so the publish
-	* modal can still mount without `null`-checks.
-	*/
-	const registryNamespaces = computed(() => registry?.namespaces ?? EMPTY_NAMESPACES_STATE);
-	/**
-	* Default slug surfaced inside the publish modal. The active document's
-	* title is the most recognisable value so we pre-slugify it; the user
-	* can still rewrite it before confirming.
-	*/
-	const publishDefaultSlug = computed(() => {
-		const title = app.store.value?.workspace.activeDocument?.info?.title;
-		return typeof title === "string" ? title : "";
-	});
-	/**
-	* Default version surfaced inside the publish modal. Mirrors the
-	* document's `info.version` when one is set so the form opens
-	* pre-filled with what the user has been working with locally.
-	*/
-	const publishDefaultVersion = computed(() => {
-		const value = app.store.value?.workspace.activeDocument?.info?.version;
-		return typeof value === "string" && value.trim().length > 0 ? value : "1.0.0";
-	});
-	/**
-	* Opens the publish modal for the active document. The actual publish
-	* call happens in `handlePublishDocumentSubmit` once the user has
-	* confirmed their inputs.
-	*/
-	const handlePublishDocument = () => {
-		if (!registry) return;
-		publishDocumentModalState.show();
-	};
-	/**
-	* Submit handler invoked by the publish modal once the user confirms
-	* the namespace, slug, and version. We:
-	*
-	*  1. Apply the chosen `version` to `info.version` locally so the
-	*     document we send to the registry already advertises the right
-	*     version field.
-	*  2. Snapshot the editable document and call `registry.publishDocument`
-	*     with the meta plus the document body.
-	*  3. On success: stamp the new registry meta onto the active
-	*     document and `saveDocument` so it becomes the new baseline. The
-	*     modal is closed via the `done` callback.
-	*  4. On failure: forward the discriminated error code to the modal
-	*     so the user sees a meaningful inline message and can fix the
-	*     input without losing what they typed.
-	*/
-	const handlePublishDocumentSubmit = async ({ input, done }) => {
-		const documentSlug = app.activeEntities.documentSlug.value;
-		const store = app.store.value;
-		if (!registry || !documentSlug || !store) {
-			done({
-				ok: false,
-				message: "Cannot publish - the workspace is not ready yet. Please try again in a moment."
-			});
-			return;
-		}
-		const activeDocument = store.workspace.documents[documentSlug];
-		if (!activeDocument) {
-			done({
-				ok: false,
-				message: "Could not read the active document. Please reload the workspace and try again."
-			});
-			return;
-		}
-		const documentBody = await store.getEditableDocument(documentSlug);
-		if (!documentBody) {
-			done({
-				ok: false,
-				message: "Could not read the active document. Please reload the workspace and try again."
-			});
-			return;
-		}
-		documentBody.info.version = input.version;
-		const result = await registry.publishDocument({
-			...input,
-			document: documentBody
-		});
-		if (!result.ok) {
-			done({
-				ok: false,
-				message: messageForPublishDocumentError(result.error, result.message)
-			});
-			return;
-		}
-		activeDocument.info.version = input.version;
-		store.updateDocument(documentSlug, "x-scalar-registry-meta", {
-			namespace: input.namespace,
-			slug: input.slug,
-			version: input.version,
-			...result.data.commitHash ? { commitHash: result.data.commitHash } : {}
-		});
-		await store.saveDocument(documentSlug);
-		toast(`Published to ${input.namespace}/${input.slug}.`, "info");
-		done({ ok: true });
-	};
-	return {
-		showLocalSaveActions,
-		showTeamSyncActions,
-		showTeamPublishAction,
-		hasHeaderActionCluster,
-		isActiveDocumentDirty,
-		isOnline,
-		isOffline,
-		canPullActiveDocument,
-		canPushActiveDocument,
-		publishDocumentModalState,
-		syncConflictModalState,
-		pendingPullState,
-		publishDefaultSlug,
-		publishDefaultVersion,
-		registryNamespaces,
-		handleSaveDocument,
-		handleRevertDocument,
-		handlePullDocument,
-		handlePushDocument,
-		handlePublishDocument,
-		handlePublishDocumentSubmit,
-		handleSyncConflictApplyChanges,
-		handleSyncConflictModalClose
-	};
-};
-//#endregion
-export { useDocumentSync };
-
-//# sourceMappingURL=use-document-sync.js.map

package/dist/v2/features/app/hooks/use-document-sync.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-document-sync.js","names":[],"sources":["../../../../../src/v2/features/app/hooks/use-document-sync.ts"],"sourcesContent":["import { useModal } from '@scalar/components'\nimport { apply, type merge } from '@scalar/json-magic/diff'\nimport { useToasts } from '@scalar/use-toasts'\nimport { deepClone } from '@scalar/workspace-store/helpers/deep-clone'\nimport { type ComputedRef, type Ref, computed, ref } from 'vue'\n\nimport type { AppState } from '@/v2/features/app/app-state'\nimport {\n  messageForFetchError,\n  messageForPublishDocumentError,\n  messageForPublishVersionError,\n} from '@/v2/features/app/helpers/registry-error-messages'\nimport { useActiveDocumentVersion } from '@/v2/features/app/hooks/use-active-document-version'\nimport { useNetworkStatus } from '@/v2/features/app/hooks/use-network-status'\nimport type { RegistryAdapter, RegistryDocumentsState, RegistryNamespacesState } from '@/v2/types/configuration'\n\n/**\n * Default namespaces state surfaced when the host application has not\n * wired a registry adapter up yet. Keeping this as a constant (rather\n * than recomputing every render) lets the publish modal mount with a\n * stable reference and avoids triggering its `watch` for nothing.\n */\nconst EMPTY_NAMESPACES_STATE: RegistryNamespacesState = {\n  status: 'success',\n  namespaces: [],\n}\n\n/**\n * Registry meta as it was when a pull began. Captures the same shape\n * `activeRegistryMeta` returns so we can hand it to the post-pull\n * commit-hash stamp without re-deriving (and possibly missing) it once\n * the rebase has finished mutating the active document.\n */\ntype PendingPullRegistryMeta = NonNullable<ReturnType<typeof useActiveDocumentVersion>['activeRegistryMeta']['value']>\n\n/**\n * In-flight pull state captured while the three-way merge editor is on\n * screen. We need to hold onto the rebase result (so the user-resolved\n * document can still be applied), the registry meta and slug we were\n * pulling against, and the upstream commit hash advertised by the\n * listing - none of those are reachable from inside the conflict\n * modal once the surrounding closure has unwound.\n *\n * `null` while no pull is awaiting user input. The modal-close handler\n * resets it so a dismissed pull cleanly aborts without applying any\n * changes (the workspace store only mutates when `applyChanges` is\n * actually invoked).\n */\ntype PendingPullState = {\n  rebaseResult: {\n    originalDocument: Record<string, unknown>\n    resolvedDocument: Record<string, unknown>\n    conflicts: ReturnType<typeof merge>['conflicts']\n    applyChanges: (input: { resolvedDocument: Record<string, unknown> }) => Promise<void>\n  }\n  meta: PendingPullRegistryMeta\n  slug: string\n  incomingCommitHash: string | undefined\n}\n\n/**\n * Owns the document-level sync flow for the API client header: save,\n * revert, pull, push, and first-time publish. The top-level `App.vue`\n * was accumulating all five flows alongside its routing / layout glue,\n * which made the file hard to reason about in isolation - extracting\n * the registry-bound logic into a single hook keeps the component\n * declarative and gives the flow a single place to test against.\n *\n * The hook owns:\n *  - the visibility computeds for each header action cluster,\n *  - the network-aware enable / disable gates (`canPullActiveDocument`,\n *    `canPushActiveDocument`),\n *  - the modal states for the publish + sync-conflict flows,\n *  - the pending pull state captured while the three-way merge editor\n *    is open,\n *  - and every async handler invoked from the header buttons / modals.\n */\nexport const useDocumentSync = ({\n  app,\n  registry,\n  registryDocuments,\n}: {\n  app: AppState\n  /** Registry adapter wired up by the host application; `undefined` when registry features are disabled. */\n  registry: RegistryAdapter | undefined\n  /** Reactive accessor — components pass a getter so the hook stays prop-driven. */\n  registryDocuments: () => RegistryDocumentsState\n}): {\n  /** Whether the local-workspace Save / Revert cluster should mount. */\n  showLocalSaveActions: ComputedRef<boolean>\n  /** Whether the team-workspace Pull / Push cluster should mount. */\n  showTeamSyncActions: ComputedRef<boolean>\n  /** Whether the team-workspace Publish cluster (no registry meta yet) should mount. */\n  showTeamPublishAction: ComputedRef<boolean>\n  /** Truthy when at least one of the action clusters is renderable. */\n  hasHeaderActionCluster: ComputedRef<boolean>\n  /** Whether the active document has unsaved local edits. */\n  isActiveDocumentDirty: ComputedRef<boolean>\n  /** Reactive online status. */\n  isOnline: Ref<boolean>\n  /** Reactive offline status (inverse of `isOnline`). */\n  isOffline: ComputedRef<boolean>\n  /** Whether the pull button should be clickable. */\n  canPullActiveDocument: ComputedRef<boolean>\n  /** Whether the push button should be clickable. */\n  canPushActiveDocument: ComputedRef<boolean>\n  /** Modal state for the first-time publish modal. */\n  publishDocumentModalState: ReturnType<typeof useModal>\n  /** Modal state for the three-way merge editor. */\n  syncConflictModalState: ReturnType<typeof useModal>\n  /** In-flight pull state shared with the three-way merge editor. */\n  pendingPullState: Ref<PendingPullState | null>\n  /** Default slug pre-filled into the publish modal. */\n  publishDefaultSlug: ComputedRef<string>\n  /** Default version pre-filled into the publish modal. */\n  publishDefaultVersion: ComputedRef<string>\n  /** Reactive view of the namespaces the user can publish to. */\n  registryNamespaces: ComputedRef<RegistryNamespacesState>\n  /** Persists local edits on the active document. */\n  handleSaveDocument: () => Promise<void>\n  /** Discards local edits and restores the saved baseline. */\n  handleRevertDocument: () => Promise<void>\n  /** Pulls the active document from the registry and rebases local edits. */\n  handlePullDocument: () => Promise<void>\n  /** Publishes the active document as the next commit on the current registry version. */\n  handlePushDocument: () => Promise<void>\n  /** Opens the publish modal for the active document. */\n  handlePublishDocument: () => void\n  /** Submit handler invoked by the publish modal once the user confirms their inputs. */\n  handlePublishDocumentSubmit: (params: {\n    input: { namespace: string; slug: string; version: string }\n    done: (outcome: { ok: true } | { ok: false; message: string }) => void\n  }) => Promise<void>\n  /** Apply callback wired up to the three-way merge editor. */\n  handleSyncConflictApplyChanges: (params: { resolvedDocument: Record<string, unknown> }) => Promise<void>\n  /** Reset the pending pull when the conflict modal closes without an apply. */\n  handleSyncConflictModalClose: () => void\n} => {\n  const { toast } = useToasts()\n\n  /**\n   * Resolves the registry meta and sync status for the active document.\n   * The breadcrumb already drives this composable for its version picker;\n   * we reuse it here so the header action cluster reads from exactly the\n   * same `pull` / `push` / `synced` source of truth that the picker rows\n   * and the inline status icons do.\n   */\n  const { activeRegistryMeta, activeVersion } = useActiveDocumentVersion({\n    app,\n    registryDocuments,\n  })\n\n  const publishDocumentModalState = useModal()\n  const syncConflictModalState = useModal()\n\n  /** Whether the route currently resolves to a document. */\n  const hasActiveDocument = computed(() => Boolean(app.activeEntities.documentSlug.value))\n\n  /** Whether the active document has unsaved local edits. */\n  const isActiveDocumentDirty = computed(\n    () => app.store.value?.workspace.activeDocument?.['x-scalar-is-dirty'] === true,\n  )\n\n  /**\n   * Save / Revert cluster for local workspaces. Mirrors the save-prompt UX\n   * of the document collection page: Save is always mounted while a doc is\n   * active and gets disabled when there is nothing to persist; Revert only\n   * shows up while the document is dirty.\n   */\n  const showLocalSaveActions = computed(() => !app.workspace.isTeamWorkspace.value && hasActiveDocument.value)\n\n  /**\n   * Pull / Push cluster for team workspace documents that already have a\n   * registry relationship. The same `Revert` button as local workspaces\n   * sits in front of it so a dirty document can be discarded without going\n   * through the registry round-trip.\n   */\n  const showTeamSyncActions = computed(\n    () => app.workspace.isTeamWorkspace.value && hasActiveDocument.value && Boolean(activeRegistryMeta.value),\n  )\n\n  /**\n   * Publish cluster for team workspace documents that do not yet have a\n   * registry entry. We surface it as a single \"Publish\" affordance instead\n   * of the Pull / Push pair because there is no upstream version to sync\n   * against - the action is simply \"create the registry version\".\n   */\n  const showTeamPublishAction = computed(\n    () => app.workspace.isTeamWorkspace.value && hasActiveDocument.value && !activeRegistryMeta.value,\n  )\n\n  /**\n   * Reactive online / offline status for the browser. Registry-bound\n   * actions (Pull, Push, Publish) all need a live network connection, so\n   * we surface a single source of truth here and let the per-action\n   * `canX` computeds AND the icon swaps below consume it.\n   */\n  const { isOnline, isOffline } = useNetworkStatus()\n\n  /**\n   * Pull is enabled while the registry advertises a different commit hash\n   * than the local one, regardless of whether the local document is dirty.\n   * `conflict` is treated the same as `pull` here so the user can always\n   * reach the conflict-resolution flow from the header. We additionally\n   * gate on `isOnline` so the button stops responding the moment the\n   * browser reports an offline transition - any click we accepted would\n   * fail the `fetchDocument` adapter call anyway.\n   */\n  const canPullActiveDocument = computed(() => {\n    if (!isOnline.value) {\n      return false\n    }\n    const status = activeVersion.value?.status\n    return status === 'pull' || status === 'conflict'\n  })\n\n  /**\n   * Push is only enabled when the document is dirty *and* there are no\n   * upstream changes - mirroring `computeVersionStatus`'s `'push'` outcome,\n   * which already encodes that combination. Pushing while upstream has\n   * moved on would clobber the registry version, so we lock the button\n   * until the user has pulled / resolved. We also gate on `isOnline` so a\n   * disconnected client cannot trigger a publish attempt that we know\n   * will fail.\n   */\n  const canPushActiveDocument = computed(() => isOnline.value && activeVersion.value?.status === 'push')\n\n  /**\n   * Truthy when *any* trailing action cluster is renderable. Used to gate\n   * the leading edge of the header end slot (and the divider against the\n   * consumer-provided `header-end` cluster) without re-deriving the same\n   * conditions in the template.\n   */\n  const hasHeaderActionCluster = computed(\n    () => showLocalSaveActions.value || showTeamSyncActions.value || showTeamPublishAction.value,\n  )\n\n  const handleSaveDocument = async (): Promise<void> => {\n    const slug = app.activeEntities.documentSlug.value\n    if (!slug || !app.store.value) {\n      return\n    }\n    await app.store.value.saveDocument(slug)\n  }\n\n  const handleRevertDocument = async (): Promise<void> => {\n    const slug = app.activeEntities.documentSlug.value\n    if (!slug || !app.store.value) {\n      return\n    }\n    await app.store.value.revertDocumentChanges(slug)\n  }\n\n  const pendingPullState = ref<PendingPullState | null>(null)\n\n  /**\n   * Stamp the registry's advertised commit hash onto the active document\n   * after a successful pull. Extracted out of `handlePullDocument`\n   * because the post-rebase work happens in two different places now:\n   * inline when the rebase auto-merges cleanly, and from the conflict\n   * modal's `applyChanges` callback once the user has resolved everything\n   * by hand.\n   *\n   * We only update when the listing actually advertised a hash and the\n   * meta still has a concrete `version` to write into; otherwise we leave\n   * the previous value alone so a missing hash does not erase one we\n   * already had.\n   *\n   * We deliberately do *not* call `saveDocument` here: `rebaseDocument`\n   * has already written the merged content to `originalDocuments` and\n   * decided whether the document should stay dirty (local edits folded on\n   * top of upstream) or clean (pure fast-forward). Calling `saveDocument`\n   * would clobber that dirty flag and make the push button disappear\n   * whenever a rebase replayed local commits.\n   */\n  const stampPostPullCommitHash = (params: {\n    meta: PendingPullRegistryMeta\n    slug: string\n    incomingCommitHash: string | undefined\n  }): void => {\n    const { meta, slug, incomingCommitHash } = params\n    const store = app.store.value\n    if (!store) {\n      return\n    }\n    if (!incomingCommitHash || incomingCommitHash === meta.commitHash || !meta.version) {\n      return\n    }\n    store.updateDocument(slug, 'x-scalar-registry-meta', {\n      ...meta,\n      version: meta.version,\n      commitHash: incomingCommitHash,\n    })\n  }\n\n  /**\n   * Pulls the active document's latest version from the registry and\n   * rebases local edits on top of it.\n   *\n   * The flow mirrors a `git pull --rebase`:\n   *  1. Fetch the upstream snapshot for the active version through the\n   *     registry adapter.\n   *  2. Hand the snapshot to `workspaceStore.rebaseDocument`, which\n   *     diffs it against the last saved baseline and the in-memory\n   *     edits so local work is preserved.\n   *  3. Apply the auto-merged diffs immediately when the rebase has no\n   *     conflicts. When `result.conflicts` is non-empty we open the\n   *     three-way merge editor instead and let the user resolve every\n   *     conflict by hand; the editor's `applyChanges` callback is what\n   *     actually commits the rebase in that branch.\n   */\n  const handlePullDocument = async (): Promise<void> => {\n    // ScalarButton renders `:disabled` as `aria-disabled` only - the\n    // underlying element still receives clicks - so we mirror the same\n    // gate the button reads from to block accidental triggers (offline,\n    // already up to date, or no active version).\n    if (!canPullActiveDocument.value) {\n      return\n    }\n    const meta = activeRegistryMeta.value\n    const slug = app.activeEntities.documentSlug.value\n    const store = app.store.value\n    if (!meta || !slug || !registry || !store) {\n      return\n    }\n\n    const fetched = await registry.fetchDocument({\n      namespace: meta.namespace,\n      slug: meta.slug,\n      version: meta.version,\n    })\n    if (!fetched.ok) {\n      toast(messageForFetchError(fetched.error, fetched.message), 'error')\n      return\n    }\n\n    // Feed the fetched document inline so `rebaseDocument` skips its own\n    // network round-trip and treats the registry response as the new\n    // upstream baseline.\n    const result = await store.rebaseDocument({\n      name: slug,\n      document: fetched.data.document,\n    })\n\n    // Snapshot the registry-advertised hash before we kick off the fetch.\n    // The version listing is the source of truth for \"what hash we are\n    // pulling against\" - the per-document fetch payload itself does not\n    // carry one - and `activeVersion` may re-derive once `rebaseDocument`\n    // mutates the active document, so we capture it up front.\n    const incomingCommitHash = fetched.data.versionSha\n\n    if (!result.ok) {\n      if (result.type === 'NO_CHANGES_DETECTED') {\n        // Already up to date payload-wise. Still refresh the commit hash\n        // because the listing might advertise a re-encoded hash even when\n        // the bytes are identical, so the sync indicator can clear.\n        stampPostPullCommitHash({ meta, slug, incomingCommitHash })\n        // External consumers subscribe to this hook to react to any\n        // rebase landing on the active document - including the no-op\n        // case where local matched upstream - so we keep the emit on\n        // this branch in line with the legacy `DocumentCollection.vue`\n        // sync flow.\n        app.eventBus.emit('hooks:on:rebase:document:complete', {\n          meta: { documentName: slug },\n        })\n        toast('Already up to date with the registry.', 'info')\n        return\n      }\n      if (result.type === 'CORRUPTED_STATE') {\n        toast('The document state appears to be missing locally. Try reloading the workspace.', 'error')\n        return\n      }\n      toast(`Pull failed: ${result.message}`, 'error')\n      return\n    }\n\n    // Conflicts: stash everything we will need after the user has\n    // resolved them and hand control to the three-way merge editor. The\n    // commit-hash stamp and the success toast happen from the modal's\n    // apply callback, mirroring the auto-merge branch below.\n    if (result.conflicts.length > 0) {\n      const originalDocument = store.getOriginalDocument(slug) ?? {}\n      pendingPullState.value = {\n        rebaseResult: {\n          originalDocument,\n          resolvedDocument: apply(deepClone(originalDocument), result.changes),\n          conflicts: result.conflicts,\n          applyChanges: result.applyChanges,\n        },\n        meta,\n        slug,\n        incomingCommitHash,\n      }\n      syncConflictModalState.show()\n      return\n    }\n\n    // No conflicts: apply the auto-merged diffs directly.\n    await result.applyChanges({ resolvedConflicts: [] })\n\n    stampPostPullCommitHash({ meta, slug, incomingCommitHash })\n\n    // Public lifecycle hook for downstream consumers (analytics, custom\n    // refresh logic, ...). Emitted after the rebase has been committed\n    // and the post-pull commit hash has been stamped so any handler\n    // re-reading the active document sees the post-rebase state.\n    app.eventBus.emit('hooks:on:rebase:document:complete', {\n      meta: { documentName: slug },\n    })\n\n    toast('Pulled latest changes from the registry.', 'info')\n  }\n\n  /**\n   * Apply callback wired up to `SyncConflictResolutionEditor`. The user\n   * has resolved every conflict at this point, so the merge editor hands\n   * us back the fully resolved document. We commit it through the same\n   * `applyChanges` the rebase exposed, then stamp the upstream commit\n   * hash and toast - exactly like the auto-merge branch above.\n   */\n  const handleSyncConflictApplyChanges = async ({\n    resolvedDocument,\n  }: {\n    resolvedDocument: Record<string, unknown>\n  }): Promise<void> => {\n    const pending = pendingPullState.value\n    if (!pending) {\n      return\n    }\n\n    await pending.rebaseResult.applyChanges({ resolvedDocument })\n    stampPostPullCommitHash({\n      meta: pending.meta,\n      slug: pending.slug,\n      incomingCommitHash: pending.incomingCommitHash,\n    })\n\n    syncConflictModalState.hide()\n    // Mirror the auto-merge branch above: external listeners subscribe\n    // to this hook to react to any successful rebase, regardless of\n    // whether the user had to resolve conflicts to get there.\n    app.eventBus.emit('hooks:on:rebase:document:complete', {\n      meta: { documentName: pending.slug },\n    })\n    pendingPullState.value = null\n\n    toast('Pulled latest changes from the registry.', 'info')\n  }\n\n  /**\n   * Reset the pending pull when the conflict modal closes without an\n   * apply. The workspace store only mutates inside `applyChanges`, so\n   * dropping the captured rebase result is enough to leave the local\n   * document untouched.\n   */\n  const handleSyncConflictModalClose = (): void => {\n    pendingPullState.value = null\n  }\n\n  /**\n   * Pushes the active document up to the registry as the next commit on\n   * the current version.\n   *\n   * The local `commitHash` is sent along with the publish call so the\n   * registry can do optimistic concurrency: a `CONFLICT` response means\n   * somebody pushed in the meantime and the user is expected to pull\n   * before retrying. On success two writes happen locally:\n   *\n   *  1. The freshly returned commit hash is stamped onto the active\n   *     document's `x-scalar-registry-meta` so subsequent sync checks\n   *     compare against the right base. This write goes through\n   *     `updateDocument`, which is metadata-only and does not flip the\n   *     dirty flag.\n   *  2. `saveDocument` promotes the active document to the new saved\n   *     baseline (and clears `x-scalar-is-dirty`), so a later revert\n   *     restores to the post-push state instead of pre-push edits.\n   */\n  const handlePushDocument = async (): Promise<void> => {\n    // Same `aria-disabled`-only caveat as Pull: short-circuit on the\n    // computed gate so a click on a visually disabled button cannot\n    // sneak past and hit the registry adapter.\n    if (!canPushActiveDocument.value) {\n      return\n    }\n    const meta = activeRegistryMeta.value\n    const slug = app.activeEntities.documentSlug.value\n    const store = app.store.value\n    if (!meta || !slug || !registry || !store) {\n      return\n    }\n\n    // `version` is required on the registry meta schema but the surrounding\n    // composable types it as optional, so we narrow it explicitly here.\n    const { namespace, slug: registrySlug, version } = meta\n    if (!version) {\n      toast('This document is missing a version - cannot push without one.', 'error')\n      return\n    }\n\n    // `commitHash` is intentionally allowed to be missing here. A\n    // brand-new local version (e.g. one the user just created against an\n    // existing registry document) has no upstream hash yet, so we forward\n    // `undefined` to the registry and let it skip the optimistic\n    // concurrency check for this first push. Subsequent pushes get\n    // anchored once the registry hands back the new hash below.\n\n    // Snapshot the editable document so the registry receives the\n    // current in-memory state - this is what the user just confirmed they\n    // want to push, before `saveDocument` rewrites the baseline.\n    const documentBody = await store.getEditableDocument(slug)\n    if (!documentBody) {\n      toast('Could not read the active document. Please reload and try again.', 'error')\n      return\n    }\n\n    const result = await registry.publishVersion({\n      namespace,\n      slug: registrySlug,\n      version,\n      commitHash: meta.commitHash,\n      document: documentBody as Record<string, unknown>,\n    })\n    if (!result.ok) {\n      // CONFLICT means our local commit hash is stale - somebody pushed\n      // in the meantime. Force a registry-listing refresh so the\n      // host's cache picks up the new upstream commit hash; once that\n      // lands `computeVersionStatus` will see `localHash !== registryHash`\n      // and naturally flip the Pull button on, no separate \"needs pull\"\n      // overlay required. The host adapter is free to skip the hook\n      // (it is optional), in which case the user falls back to waiting\n      // for the listing's normal refetch interval.\n      if (result.error === 'CONFLICT') {\n        await registry.refreshDocuments?.()\n      }\n      toast(messageForPublishVersionError(result.error, result.message), 'error')\n      return\n    }\n\n    // Stamp the new commit hash before saving so the freshly published\n    // hash is part of the new baseline.\n    store.updateDocument(slug, 'x-scalar-registry-meta', {\n      ...meta,\n      version,\n      commitHash: result.data.commitHash,\n    })\n\n    await store.saveDocument(slug)\n\n    // Ask the host to refetch its registry listing so the cached\n    // registry commit hash catches up with the one we just wrote\n    // locally. Without this, `computeVersionStatus` compares our fresh\n    // `localHash` against the stale listing hash, concludes the hashes\n    // diverged, and re-enables the Pull button right after a successful\n    // push. Mirrors the CONFLICT branch above; the hook is optional so\n    // hosts that do not wire it up simply wait for the next poll.\n    await registry.refreshDocuments?.()\n\n    toast('Pushed changes to the registry.', 'info')\n  }\n\n  /**\n   * Reactive view of the namespaces the user can publish to. Falls back\n   * to an empty success state when no adapter is wired up so the publish\n   * modal can still mount without `null`-checks.\n   */\n  const registryNamespaces = computed<RegistryNamespacesState>(() => registry?.namespaces ?? EMPTY_NAMESPACES_STATE)\n\n  /**\n   * Default slug surfaced inside the publish modal. The active document's\n   * title is the most recognisable value so we pre-slugify it; the user\n   * can still rewrite it before confirming.\n   */\n  const publishDefaultSlug = computed(() => {\n    const title = app.store.value?.workspace.activeDocument?.info?.title\n    return typeof title === 'string' ? title : ''\n  })\n\n  /**\n   * Default version surfaced inside the publish modal. Mirrors the\n   * document's `info.version` when one is set so the form opens\n   * pre-filled with what the user has been working with locally.\n   */\n  const publishDefaultVersion = computed(() => {\n    const value = app.store.value?.workspace.activeDocument?.info?.version\n    return typeof value === 'string' && value.trim().length > 0 ? value : '1.0.0'\n  })\n\n  /**\n   * Opens the publish modal for the active document. The actual publish\n   * call happens in `handlePublishDocumentSubmit` once the user has\n   * confirmed their inputs.\n   */\n  const handlePublishDocument = (): void => {\n    if (!registry) {\n      return\n    }\n    publishDocumentModalState.show()\n  }\n\n  /**\n   * Submit handler invoked by the publish modal once the user confirms\n   * the namespace, slug, and version. We:\n   *\n   *  1. Apply the chosen `version` to `info.version` locally so the\n   *     document we send to the registry already advertises the right\n   *     version field.\n   *  2. Snapshot the editable document and call `registry.publishDocument`\n   *     with the meta plus the document body.\n   *  3. On success: stamp the new registry meta onto the active\n   *     document and `saveDocument` so it becomes the new baseline. The\n   *     modal is closed via the `done` callback.\n   *  4. On failure: forward the discriminated error code to the modal\n   *     so the user sees a meaningful inline message and can fix the\n   *     input without losing what they typed.\n   */\n  const handlePublishDocumentSubmit = async ({\n    input,\n    done,\n  }: {\n    input: { namespace: string; slug: string; version: string }\n    done: (outcome: { ok: true } | { ok: false; message: string }) => void\n  }): Promise<void> => {\n    const documentSlug = app.activeEntities.documentSlug.value\n    const store = app.store.value\n    if (!registry || !documentSlug || !store) {\n      done({\n        ok: false,\n        message: 'Cannot publish - the workspace is not ready yet. Please try again in a moment.',\n      })\n      return\n    }\n\n    // Mirror the chosen version onto `info.version` BEFORE snapshotting\n    // the document so the registry receives a body whose `info.version`\n    // already matches what the modal advertised. We write the field\n    // directly (rather than replacing the whole `info` object) to keep\n    // the workspace store's reactive proxy intact for any other\n    // subscribers watching `info.title`, contact info, etc.\n    const activeDocument = store.workspace.documents[documentSlug]\n    if (!activeDocument) {\n      done({\n        ok: false,\n        message: 'Could not read the active document. Please reload the workspace and try again.',\n      })\n      return\n    }\n\n    const documentBody = await store.getEditableDocument(documentSlug)\n    if (!documentBody) {\n      done({\n        ok: false,\n        message: 'Could not read the active document. Please reload the workspace and try again.',\n      })\n      return\n    }\n\n    // Update the document version of the document body (this is not the actual active document but a deep clone)\n    documentBody.info.version = input.version\n\n    const result = await registry.publishDocument({\n      ...input,\n      document: documentBody as Record<string, unknown>,\n    })\n    if (!result.ok) {\n      done({\n        ok: false,\n        message: messageForPublishDocumentError(result.error, result.message),\n      })\n      return\n    }\n\n    // Now update the actual active document version with the new version\n    activeDocument.info.version = input.version\n\n    // Stamp the registry meta on the active document. The registry may\n    // or may not have advertised a commit hash for the freshly created\n    // entry; persist it when present so subsequent sync checks compare\n    // against the right base.\n    store.updateDocument(documentSlug, 'x-scalar-registry-meta', {\n      namespace: input.namespace,\n      slug: input.slug,\n      version: input.version,\n      ...(result.data.commitHash ? { commitHash: result.data.commitHash } : {}),\n    })\n\n    await store.saveDocument(documentSlug)\n\n    toast(`Published to ${input.namespace}/${input.slug}.`, 'info')\n    done({ ok: true })\n  }\n\n  return {\n    showLocalSaveActions,\n    showTeamSyncActions,\n    showTeamPublishAction,\n    hasHeaderActionCluster,\n    isActiveDocumentDirty,\n    isOnline,\n    isOffline,\n    canPullActiveDocument,\n    canPushActiveDocument,\n    publishDocumentModalState,\n    syncConflictModalState,\n    pendingPullState,\n    publishDefaultSlug,\n    publishDefaultVersion,\n    registryNamespaces,\n    handleSaveDocument,\n    handleRevertDocument,\n    handlePullDocument,\n    handlePushDocument,\n    handlePublishDocument,\n    handlePublishDocumentSubmit,\n    handleSyncConflictApplyChanges,\n    handleSyncConflictModalClose,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAsBA,IAAM,yBAAkD;CACtD,QAAQ;CACR,YAAY,EAAE;CACf;;;;;;;;;;;;;;;;;;AAoDD,IAAa,mBAAmB,EAC9B,KACA,UACA,wBAyDG;CACH,MAAM,EAAE,UAAU,WAAW;;;;;;;;CAS7B,MAAM,EAAE,oBAAoB,kBAAkB,yBAAyB;EACrE;EACA;EACD,CAAC;CAEF,MAAM,4BAA4B,UAAU;CAC5C,MAAM,yBAAyB,UAAU;;CAGzC,MAAM,oBAAoB,eAAe,QAAQ,IAAI,eAAe,aAAa,MAAM,CAAC;;CAGxF,MAAM,wBAAwB,eACtB,IAAI,MAAM,OAAO,UAAU,iBAAiB,yBAAyB,KAC5E;;;;;;;CAQD,MAAM,uBAAuB,eAAe,CAAC,IAAI,UAAU,gBAAgB,SAAS,kBAAkB,MAAM;;;;;;;CAQ5G,MAAM,sBAAsB,eACpB,IAAI,UAAU,gBAAgB,SAAS,kBAAkB,SAAS,QAAQ,mBAAmB,MAAM,CAC1G;;;;;;;CAQD,MAAM,wBAAwB,eACtB,IAAI,UAAU,gBAAgB,SAAS,kBAAkB,SAAS,CAAC,mBAAmB,MAC7F;;;;;;;CAQD,MAAM,EAAE,UAAU,cAAc,kBAAkB;;;;;;;;;;CAWlD,MAAM,wBAAwB,eAAe;AAC3C,MAAI,CAAC,SAAS,MACZ,QAAO;EAET,MAAM,SAAS,cAAc,OAAO;AACpC,SAAO,WAAW,UAAU,WAAW;GACvC;;;;;;;;;;CAWF,MAAM,wBAAwB,eAAe,SAAS,SAAS,cAAc,OAAO,WAAW,OAAO;;;;;;;CAQtG,MAAM,yBAAyB,eACvB,qBAAqB,SAAS,oBAAoB,SAAS,sBAAsB,MACxF;CAED,MAAM,qBAAqB,YAA2B;EACpD,MAAM,OAAO,IAAI,eAAe,aAAa;AAC7C,MAAI,CAAC,QAAQ,CAAC,IAAI,MAAM,MACtB;AAEF,QAAM,IAAI,MAAM,MAAM,aAAa,KAAK;;CAG1C,MAAM,uBAAuB,YAA2B;EACtD,MAAM,OAAO,IAAI,eAAe,aAAa;AAC7C,MAAI,CAAC,QAAQ,CAAC,IAAI,MAAM,MACtB;AAEF,QAAM,IAAI,MAAM,MAAM,sBAAsB,KAAK;;CAGnD,MAAM,mBAAmB,IAA6B,KAAK;;;;;;;;;;;;;;;;;;;;;CAsB3D,MAAM,2BAA2B,WAIrB;EACV,MAAM,EAAE,MAAM,MAAM,uBAAuB;EAC3C,MAAM,QAAQ,IAAI,MAAM;AACxB,MAAI,CAAC,MACH;AAEF,MAAI,CAAC,sBAAsB,uBAAuB,KAAK,cAAc,CAAC,KAAK,QACzE;AAEF,QAAM,eAAe,MAAM,0BAA0B;GACnD,GAAG;GACH,SAAS,KAAK;GACd,YAAY;GACb,CAAC;;;;;;;;;;;;;;;;;;CAmBJ,MAAM,qBAAqB,YAA2B;AAKpD,MAAI,CAAC,sBAAsB,MACzB;EAEF,MAAM,OAAO,mBAAmB;EAChC,MAAM,OAAO,IAAI,eAAe,aAAa;EAC7C,MAAM,QAAQ,IAAI,MAAM;AACxB,MAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,MAClC;EAGF,MAAM,UAAU,MAAM,SAAS,cAAc;GAC3C,WAAW,KAAK;GAChB,MAAM,KAAK;GACX,SAAS,KAAK;GACf,CAAC;AACF,MAAI,CAAC,QAAQ,IAAI;AACf,SAAM,qBAAqB,QAAQ,OAAO,QAAQ,QAAQ,EAAE,QAAQ;AACpE;;EAMF,MAAM,SAAS,MAAM,MAAM,eAAe;GACxC,MAAM;GACN,UAAU,QAAQ,KAAK;GACxB,CAAC;EAOF,MAAM,qBAAqB,QAAQ,KAAK;AAExC,MAAI,CAAC,OAAO,IAAI;AACd,OAAI,OAAO,SAAS,uBAAuB;AAIzC,4BAAwB;KAAE;KAAM;KAAM;KAAoB,CAAC;AAM3D,QAAI,SAAS,KAAK,qCAAqC,EACrD,MAAM,EAAE,cAAc,MAAM,EAC7B,CAAC;AACF,UAAM,yCAAyC,OAAO;AACtD;;AAEF,OAAI,OAAO,SAAS,mBAAmB;AACrC,UAAM,kFAAkF,QAAQ;AAChG;;AAEF,SAAM,gBAAgB,OAAO,WAAW,QAAQ;AAChD;;AAOF,MAAI,OAAO,UAAU,SAAS,GAAG;GAC/B,MAAM,mBAAmB,MAAM,oBAAoB,KAAK,IAAI,EAAE;AAC9D,oBAAiB,QAAQ;IACvB,cAAc;KACZ;KACA,kBAAkB,MAAM,UAAU,iBAAiB,EAAE,OAAO,QAAQ;KACpE,WAAW,OAAO;KAClB,cAAc,OAAO;KACtB;IACD;IACA;IACA;IACD;AACD,0BAAuB,MAAM;AAC7B;;AAIF,QAAM,OAAO,aAAa,EAAE,mBAAmB,EAAE,EAAE,CAAC;AAEpD,0BAAwB;GAAE;GAAM;GAAM;GAAoB,CAAC;AAM3D,MAAI,SAAS,KAAK,qCAAqC,EACrD,MAAM,EAAE,cAAc,MAAM,EAC7B,CAAC;AAEF,QAAM,4CAA4C,OAAO;;;;;;;;;CAU3D,MAAM,iCAAiC,OAAO,EAC5C,uBAGmB;EACnB,MAAM,UAAU,iBAAiB;AACjC,MAAI,CAAC,QACH;AAGF,QAAM,QAAQ,aAAa,aAAa,EAAE,kBAAkB,CAAC;AAC7D,0BAAwB;GACtB,MAAM,QAAQ;GACd,MAAM,QAAQ;GACd,oBAAoB,QAAQ;GAC7B,CAAC;AAEF,yBAAuB,MAAM;AAI7B,MAAI,SAAS,KAAK,qCAAqC,EACrD,MAAM,EAAE,cAAc,QAAQ,MAAM,EACrC,CAAC;AACF,mBAAiB,QAAQ;AAEzB,QAAM,4CAA4C,OAAO;;;;;;;;CAS3D,MAAM,qCAA2C;AAC/C,mBAAiB,QAAQ;;;;;;;;;;;;;;;;;;;;CAqB3B,MAAM,qBAAqB,YAA2B;AAIpD,MAAI,CAAC,sBAAsB,MACzB;EAEF,MAAM,OAAO,mBAAmB;EAChC,MAAM,OAAO,IAAI,eAAe,aAAa;EAC7C,MAAM,QAAQ,IAAI,MAAM;AACxB,MAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,MAClC;EAKF,MAAM,EAAE,WAAW,MAAM,cAAc,YAAY;AACnD,MAAI,CAAC,SAAS;AACZ,SAAM,iEAAiE,QAAQ;AAC/E;;EAaF,MAAM,eAAe,MAAM,MAAM,oBAAoB,KAAK;AAC1D,MAAI,CAAC,cAAc;AACjB,SAAM,oEAAoE,QAAQ;AAClF;;EAGF,MAAM,SAAS,MAAM,SAAS,eAAe;GAC3C;GACA,MAAM;GACN;GACA,YAAY,KAAK;GACjB,UAAU;GACX,CAAC;AACF,MAAI,CAAC,OAAO,IAAI;AASd,OAAI,OAAO,UAAU,WACnB,OAAM,SAAS,oBAAoB;AAErC,SAAM,8BAA8B,OAAO,OAAO,OAAO,QAAQ,EAAE,QAAQ;AAC3E;;AAKF,QAAM,eAAe,MAAM,0BAA0B;GACnD,GAAG;GACH;GACA,YAAY,OAAO,KAAK;GACzB,CAAC;AAEF,QAAM,MAAM,aAAa,KAAK;AAS9B,QAAM,SAAS,oBAAoB;AAEnC,QAAM,mCAAmC,OAAO;;;;;;;CAQlD,MAAM,qBAAqB,eAAwC,UAAU,cAAc,uBAAuB;;;;;;CAOlH,MAAM,qBAAqB,eAAe;EACxC,MAAM,QAAQ,IAAI,MAAM,OAAO,UAAU,gBAAgB,MAAM;AAC/D,SAAO,OAAO,UAAU,WAAW,QAAQ;GAC3C;;;;;;CAOF,MAAM,wBAAwB,eAAe;EAC3C,MAAM,QAAQ,IAAI,MAAM,OAAO,UAAU,gBAAgB,MAAM;AAC/D,SAAO,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC,SAAS,IAAI,QAAQ;GACtE;;;;;;CAOF,MAAM,8BAAoC;AACxC,MAAI,CAAC,SACH;AAEF,4BAA0B,MAAM;;;;;;;;;;;;;;;;;;CAmBlC,MAAM,8BAA8B,OAAO,EACzC,OACA,WAImB;EACnB,MAAM,eAAe,IAAI,eAAe,aAAa;EACrD,MAAM,QAAQ,IAAI,MAAM;AACxB,MAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,OAAO;AACxC,QAAK;IACH,IAAI;IACJ,SAAS;IACV,CAAC;AACF;;EASF,MAAM,iBAAiB,MAAM,UAAU,UAAU;AACjD,MAAI,CAAC,gBAAgB;AACnB,QAAK;IACH,IAAI;IACJ,SAAS;IACV,CAAC;AACF;;EAGF,MAAM,eAAe,MAAM,MAAM,oBAAoB,aAAa;AAClE,MAAI,CAAC,cAAc;AACjB,QAAK;IACH,IAAI;IACJ,SAAS;IACV,CAAC;AACF;;AAIF,eAAa,KAAK,UAAU,MAAM;EAElC,MAAM,SAAS,MAAM,SAAS,gBAAgB;GAC5C,GAAG;GACH,UAAU;GACX,CAAC;AACF,MAAI,CAAC,OAAO,IAAI;AACd,QAAK;IACH,IAAI;IACJ,SAAS,+BAA+B,OAAO,OAAO,OAAO,QAAQ;IACtE,CAAC;AACF;;AAIF,iBAAe,KAAK,UAAU,MAAM;AAMpC,QAAM,eAAe,cAAc,0BAA0B;GAC3D,WAAW,MAAM;GACjB,MAAM,MAAM;GACZ,SAAS,MAAM;GACf,GAAI,OAAO,KAAK,aAAa,EAAE,YAAY,OAAO,KAAK,YAAY,GAAG,EAAE;GACzE,CAAC;AAEF,QAAM,MAAM,aAAa,aAAa;AAEtC,QAAM,gBAAgB,MAAM,UAAU,GAAG,MAAM,KAAK,IAAI,OAAO;AAC/D,OAAK,EAAE,IAAI,MAAM,CAAC;;AAGpB,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD"}

package/dist/v2/features/app/hooks/use-document-watcher.d.ts

@@ -1,30 +0,0 @@
-import type { WorkspaceStore } from '@scalar/workspace-store/client';
-import { type MaybeRefOrGetter } from 'vue';
-/**
- * Watches the specified document in the workspace store and periodically rebases it with its remote source.
- *
- * This utility sets up a watcher on the given document. If the document specifies an 'x-scalar-original-source-url'
- * and watch mode is enabled, this hook polls the remote source and calls `store.rebaseDocument`.
- * If rebase conflicts are detected, it applies automatic conflict resolution by preferring remote changes.
- * Uses exponential backoff on failures to avoid overwhelming the server.
- *
- * @param params - Configuration object for the document watcher.
- * @param params.documentName - The name/key of the document to watch and rebase.
- * @param params.store - The WorkspaceStore instance.
- * @param params.initialTimeout - Initial delay before the first poll attempt (default: 5000ms).
- *
- * @example
- * ```ts
- * import { useDocumentWatcher } from '@/hooks/use-document-watcher'
- * import { useScalarWorkspaceStore } from '@scalar/workspace-store'
- *
- * const store = useScalarWorkspaceStore()
- * useDocumentWatcher({ documentName: 'myApi', store })
- * ```
- */
-export declare const useDocumentWatcher: ({ documentName, store, initialTimeout, }: {
-    documentName: MaybeRefOrGetter<string | undefined>;
-    store: MaybeRefOrGetter<WorkspaceStore | null>;
-    initialTimeout?: number;
-}) => void;
-//# sourceMappingURL=use-document-watcher.d.ts.map

package/dist/v2/features/app/hooks/use-document-watcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-document-watcher.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/hooks/use-document-watcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAA6C,MAAM,KAAK,CAAA;AA6FtF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB,GAAI,0CAIhC;IACD,YAAY,EAAE,gBAAgB,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IAClD,KAAK,EAAE,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,KAAG,IA6FH,CAAA"}