@scalar/api-client 3.6.1 → 3.8.1

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

@@ -1 +0,0 @@
-{"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.\n *\n * `registryCommitHash` is the hash advertised by the registry version\n * listing and acts as the pre-fetch cache key: when it matches the\n * previously stored `conflictCheckedAgainstHash`, we return the cached\n * result without touching the network. After a fresh fetch, the cache\n * is rewritten with the authoritative `versionSha` returned alongside\n * the document body so subsequent comparisons settle on the hash the\n * registry actually served.\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.document,\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: result.data.versionSha,\n    hasConflict,\n  }\n  document['x-scalar-registry-meta'] = next\n\n  return { ok: true, hasConflict, fromCache: false }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,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,KAAK;EACrB,CAAC;AAaF,UAAS,4BARI;EACX,GAAI,QAAQ;GAAE;GAAW;GAAM;GAAS;EACxC;EACA;EACA;EACA,4BAA4B,OAAO,KAAK;EACxC;EACD;AAGD,QAAO;EAAE,IAAI;EAAM;EAAa,WAAW;EAAO"}

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

@@ -1,45 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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-api-client-app.d.ts

@@ -1,59 +0,0 @@
-import type { ClientPlugin } from '@scalar/oas-utils/helpers';
-import type { Theme } from '@scalar/themes';
-import type { RegistryAdapter } from '../../../../v2/types/configuration';
-import type { ClientLayout } from '../../../../v2/types/layout';
-import type { ApiClientOptions } from '../../../../v2/types/options';
-type CreateApiClientOptions = {
-    /**
-     * The layout of the client, limited to web or desktop in app
-     * @see {@link ClientLayout}
-     *
-     * @default 'desktop'
-     */
-    layout: Exclude<ClientLayout, 'modal'>;
-    /**
-     * Api client plugins to include in the app
-     */
-    plugins?: ClientPlugin[];
-    /**
-     * Custom themes to include in the app
-     */
-    customThemes?: Theme[];
-    /**
-     * Fallback theme slug to use if no theme is selected for the workspace
-     * @default 'default'
-     */
-    fallbackThemeSlug?: () => string;
-    /**
-     * Adapter wiring the API client up to an external registry. The
-     * adapter bundles the registry document list, the per-document fetch
-     * callback (used for syncing) and the publish callback used to create
-     * a brand-new registry version. Optional at the top level - omit to
-     * opt out of registry features entirely.
-     */
-    registry?: RegistryAdapter;
-    /**
-     * Whether or not to send telemetry events.
-     */
-    telemetry?: boolean;
-    /** Runtime behaviour overrides */
-    options?: ApiClientAppOptions;
-};
-/**
- * Runtime behaviour overrides shared between createApiClientApp and createAppState.
- * Derived from the canonical ApiClientOptions to guarantee structural compatibility.
- */
-export type ApiClientAppOptions = Pick<ApiClientOptions, 'customFetch' | 'oauth2RedirectUri'>;
-/**
- * Creates the appropriate router with the appropriate routes based on the layout
- */
-export declare const createAppRouter: (layout: CreateApiClientOptions["layout"]) => import("vue-router").Router;
-/**
- * Create the API Client with router and passes in the workspace store as a prop
- */
-export declare const createApiClientApp: (el: HTMLElement | null, { layout, plugins, customThemes, fallbackThemeSlug, registry, telemetry, options, }: CreateApiClientOptions) => Promise<{
-    app: import("vue").App<Element>;
-    state: import("../../../../v2/features/app/app-state.js").AppState;
-} | undefined>;
-export {};
-//# sourceMappingURL=create-api-client-app.d.ts.map

package/dist/v2/features/app/helpers/create-api-client-app.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-api-client-app.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/create-api-client-app.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAO3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAI1D,KAAK,sBAAsB,GAAG;IAC5B;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,CAAA;IACtC;;OAEG;IACH,OAAO,CAAC,EAAE,YAAY,EAAE,CAAA;IACxB;;OAEG;IACH,YAAY,CAAC,EAAE,KAAK,EAAE,CAAA;IACtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,MAAM,CAAA;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAA;IAC1B;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,kCAAkC;IAClC,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,gBAAgB,EAAE,aAAa,GAAG,mBAAmB,CAAC,CAAA;AAE7F;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,sBAAsB,CAAC,QAAQ,CAAC,gCAQvE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,IAAI,WAAW,GAAG,IAAI,EACtB,qFAQG,sBAAsB;;;cAuC1B,CAAA"}

package/dist/v2/features/app/helpers/create-api-client-app.js

@@ -1,55 +0,0 @@
-import { createAppState } from "../app-state.js";
-import { useCommandPaletteState } from "../../command-palette/hooks/use-command-palette-state.js";
-import App_default from "../App.vue.js";
-import { ROUTES } from "./routes.js";
-import { createApp } from "vue";
-import { createRouter, createWebHashHistory, createWebHistory } from "vue-router";
-//#region src/v2/features/app/helpers/create-api-client-app.ts
-/**
-* Creates the appropriate router with the appropriate routes based on the layout
-*/
-var createAppRouter = (layout) => {
-	if (layout === "web") return createRouter({
-		history: createWebHistory(),
-		routes: ROUTES
-	});
-	return createRouter({
-		history: createWebHashHistory(),
-		routes: ROUTES
-	});
-};
-/**
-* Create the API Client with router and passes in the workspace store as a prop
-*/
-var createApiClientApp = async (el, { layout = "desktop", plugins, customThemes, fallbackThemeSlug, registry, telemetry = true, options }) => {
-	const router = createAppRouter(layout);
-	const state = await createAppState({
-		router,
-		customThemes,
-		fallbackThemeSlug,
-		telemetryDefault: telemetry,
-		options
-	});
-	const commandPaletteState = useCommandPaletteState();
-	const app = createApp(App_default, {
-		layout,
-		plugins,
-		getAppState: () => state,
-		getCommandPaletteState: () => commandPaletteState,
-		registry
-	});
-	app.use(router);
-	if (!el) {
-		console.error("[@scalar/api-client-modal] Could not create the API client.", "Invalid HTML element provided.", "Read more: https://github.com/scalar/scalar/tree/main/packages/api-client");
-		return;
-	}
-	app.mount(el);
-	return {
-		app,
-		state
-	};
-};
-//#endregion
-export { createApiClientApp, createAppRouter };
-
-//# sourceMappingURL=create-api-client-app.js.map

package/dist/v2/features/app/helpers/create-api-client-app.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-api-client-app.js","names":[],"sources":["../../../../../src/v2/features/app/helpers/create-api-client-app.ts"],"sourcesContent":["import type { ClientPlugin } from '@scalar/oas-utils/helpers'\nimport type { Theme } from '@scalar/themes'\nimport { createApp } from 'vue'\nimport { createRouter as createVueRouter, createWebHashHistory, createWebHistory } from 'vue-router'\n\nimport App from '@/v2/features/app/App.vue'\nimport { createAppState } from '@/v2/features/app/app-state'\nimport { ROUTES } from '@/v2/features/app/helpers/routes'\nimport type { RegistryAdapter } from '@/v2/types/configuration'\nimport type { ClientLayout } from '@/v2/types/layout'\nimport type { ApiClientOptions } from '@/v2/types/options'\n\nimport { useCommandPaletteState } from '../../command-palette/hooks/use-command-palette-state'\n\ntype CreateApiClientOptions = {\n  /**\n   * The layout of the client, limited to web or desktop in app\n   * @see {@link ClientLayout}\n   *\n   * @default 'desktop'\n   */\n  layout: Exclude<ClientLayout, 'modal'>\n  /**\n   * Api client plugins to include in the app\n   */\n  plugins?: ClientPlugin[]\n  /**\n   * Custom themes to include in the app\n   */\n  customThemes?: Theme[]\n  /**\n   * Fallback theme slug to use if no theme is selected for the workspace\n   * @default 'default'\n   */\n  fallbackThemeSlug?: () => string\n  /**\n   * Adapter wiring the API client up to an external registry. The\n   * adapter bundles the registry document list, the per-document fetch\n   * callback (used for syncing) and the publish callback used to create\n   * a brand-new registry version. Optional at the top level - omit to\n   * opt out of registry features entirely.\n   */\n  registry?: RegistryAdapter\n  /**\n   * Whether or not to send telemetry events.\n   */\n  telemetry?: boolean\n  /** Runtime behaviour overrides */\n  options?: ApiClientAppOptions\n}\n\n/**\n * Runtime behaviour overrides shared between createApiClientApp and createAppState.\n * Derived from the canonical ApiClientOptions to guarantee structural compatibility.\n */\nexport type ApiClientAppOptions = Pick<ApiClientOptions, 'customFetch' | 'oauth2RedirectUri'>\n\n/**\n * Creates the appropriate router with the appropriate routes based on the layout\n */\nexport const createAppRouter = (layout: CreateApiClientOptions['layout']) => {\n  // Web uses the standard HTML5 history API\n  if (layout === 'web') {\n    return createVueRouter({ history: createWebHistory(), routes: ROUTES })\n  }\n\n  // Electron app has to use the webHashHistory due to file routing\n  return createVueRouter({ history: createWebHashHistory(), routes: ROUTES })\n}\n\n/**\n * Create the API Client with router and passes in the workspace store as a prop\n */\nexport const createApiClientApp = async (\n  el: HTMLElement | null,\n  {\n    layout = 'desktop',\n    plugins,\n    customThemes,\n    fallbackThemeSlug,\n    registry,\n    telemetry = true,\n    options,\n  }: CreateApiClientOptions,\n) => {\n  // Add the router\n  const router = createAppRouter(layout)\n  const state = await createAppState({\n    router,\n    customThemes,\n    fallbackThemeSlug,\n    telemetryDefault: telemetry,\n    options,\n  })\n  const commandPaletteState = useCommandPaletteState()\n\n  // Pass in our initial props at the top level\n  const app = createApp(App, {\n    layout,\n    plugins,\n    getAppState: () => state,\n    getCommandPaletteState: () => commandPaletteState,\n    registry,\n  })\n  app.use(router)\n\n  // Mount the vue app\n  if (!el) {\n    console.error(\n      '[@scalar/api-client-modal] Could not create the API client.',\n      'Invalid HTML element provided.',\n      'Read more: https://github.com/scalar/scalar/tree/main/packages/api-client',\n    )\n\n    return\n  }\n  app.mount(el)\n\n  return {\n    app,\n    state,\n  }\n}\n"],"mappings":";;;;;;;;;;AA4DA,IAAa,mBAAmB,WAA6C;AAE3E,KAAI,WAAW,MACb,QAAO,aAAgB;EAAE,SAAS,kBAAkB;EAAE,QAAQ;EAAQ,CAAC;AAIzE,QAAO,aAAgB;EAAE,SAAS,sBAAsB;EAAE,QAAQ;EAAQ,CAAC;;;;;AAM7E,IAAa,qBAAqB,OAChC,IACA,EACE,SAAS,WACT,SACA,cACA,mBACA,UACA,YAAY,MACZ,cAEC;CAEH,MAAM,SAAS,gBAAgB,OAAO;CACtC,MAAM,QAAQ,MAAM,eAAe;EACjC;EACA;EACA;EACA,kBAAkB;EAClB;EACD,CAAC;CACF,MAAM,sBAAsB,wBAAwB;CAGpD,MAAM,MAAM,UAAU,aAAK;EACzB;EACA;EACA,mBAAmB;EACnB,8BAA8B;EAC9B;EACD,CAAC;AACF,KAAI,IAAI,OAAO;AAGf,KAAI,CAAC,IAAI;AACP,UAAQ,MACN,+DACA,kCACA,4EACD;AAED;;AAEF,KAAI,MAAM,GAAG;AAEb,QAAO;EACL;EACA;EACD"}

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

@@ -1,39 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,64 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,14 +0,0 @@
-import type { WorkspaceEventBus } from '@scalar/workspace-store/events';
-/**
- * Creates a temporary operation with a unique path, emits its creation on the event bus,
- * then navigates to the operation and focuses the address bar if successful.
- * @param documentName - The name of the document to add the operation to
- * @param existingPaths - Set of existing operation paths for uniqueness checking
- * @param eventBus - The workspace event bus to emit events on
- */
-export declare const createTempOperation: (documentName: string, options: {
-    existingPaths: Set<string>;
-    eventBus: WorkspaceEventBus;
-    tags?: string[];
-}) => void;
-//# sourceMappingURL=create-temp-operation.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,52 +0,0 @@
-//#region src/v2/features/app/helpers/create-temp-operation.ts
-/**
-* Generates a unique temporary operation path for a new operation.
-* Tries up to 10 times to generate a non-colliding path, then falls back to a static path.
-*
-* Example:
-* const existingPaths = new Set(['/tempabcd1234', '/tempdeadbeef']);
-* const newPath = generateUniquePath('my-doc', existingPaths); // e.g. "/tempa1b2c3d4"
-*
-* @param existingPaths - Set of paths already present in the document to avoid collisions
-* @param attempts - Used internally to limit recursion (default: 0)
-* @returns A unique operation path (e.g., "/temp1234abcd")
-*/
-var generateUniquePath = (existingPaths, attempts = 0) => {
-	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;
-};
-/**
-* Creates a temporary operation with a unique path, emits its creation on the event bus,
-* then navigates to the operation and focuses the address bar if successful.
-* @param documentName - The name of the document to add the operation to
-* @param existingPaths - Set of existing operation paths for uniqueness checking
-* @param eventBus - The workspace event bus to emit events on
-*/
-var createTempOperation = (documentName, options) => {
-	const uniquePath = generateUniquePath(options.existingPaths);
-	options.eventBus.emit("operation:create:operation", {
-		documentName,
-		path: uniquePath,
-		method: "get",
-		operation: {
-			summary: "New operation",
-			tags: options.tags ?? []
-		},
-		callback: (success) => {
-			if (!success) return;
-			options.eventBus.emit("ui:navigate", {
-				page: "example",
-				documentSlug: documentName,
-				path: uniquePath,
-				method: "get",
-				exampleName: "default"
-			});
-		}
-	});
-};
-//#endregion
-export { createTempOperation };
-
-//# sourceMappingURL=create-temp-operation.js.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,27 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dist/v2/features/app/helpers/filter-workspaces.d.ts

@@ -1,49 +0,0 @@
-/**
- * Filters workspaces to show only those accessible to the current team.
- *
- * A workspace is accessible if:
- * - Its teamSlug matches the current team, OR
- * - Its teamSlug is 'local' (local workspaces are always accessible)
- *
- * @param workspaces - Array of workspaces to filter
- * @param currentTeamSlug - The currently active team identifier
- * @returns Filtered array of workspaces accessible to the current team
- *
- * @example
- * ```ts
- * const workspaces = [
- *   { id: '1', teamSlug: 'local', name: 'Local' },
- *   { id: '2', teamSlug: 'team-a', name: 'Team A' },
- *   { id: '3', teamSlug: 'team-b', name: 'Team B' },
- * ]
- *
- * filterWorkspacesByTeam(workspaces, 'team-a')
- * // => [{ id: '1', teamSlug: 'local' }, { id: '2', teamSlug: 'team-a' }]
- * ```
- */
-export declare const filterWorkspacesByTeam: <T extends {
-    teamSlug: string;
-}>(workspaces: T[], currentTeamSlug: string) => T[];
-/**
- * Checks if a workspace can be loaded by the current team.
- *
- * A workspace can be loaded if:
- * - Its teamSlug matches the current team, OR
- * - Its teamSlug is 'local' (local workspaces are always accessible)
- *
- * This is used during route changes to prevent users from accessing
- * workspaces that do not belong to their active team.
- *
- * @param workspaceTeamSlug - The team identifier of the workspace to check
- * @param currentTeamSlug - The currently active team identifier
- * @returns true if the workspace can be loaded, false otherwise
- *
- * @example
- * ```ts
- * canLoadWorkspace('team-a', 'team-a') // => true
- * canLoadWorkspace('local', 'team-a')  // => true
- * canLoadWorkspace('team-b', 'team-a') // => false
- * ```
- */
-export declare const canLoadWorkspace: (workspaceTeamSlug: string, currentTeamSlug: string) => boolean;
-//# sourceMappingURL=filter-workspaces.d.ts.map

package/dist/v2/features/app/helpers/filter-workspaces.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filter-workspaces.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/filter-workspaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,EACnE,YAAY,CAAC,EAAE,EACf,iBAAiB,MAAM,KACtB,CAAC,EAEH,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,GAAI,mBAAmB,MAAM,EAAE,iBAAiB,MAAM,KAAG,OAErF,CAAA"}

package/dist/v2/features/app/helpers/filter-workspaces.js

@@ -1,55 +0,0 @@
-//#region src/v2/features/app/helpers/filter-workspaces.ts
-/**
-* Filters workspaces to show only those accessible to the current team.
-*
-* A workspace is accessible if:
-* - Its teamSlug matches the current team, OR
-* - Its teamSlug is 'local' (local workspaces are always accessible)
-*
-* @param workspaces - Array of workspaces to filter
-* @param currentTeamSlug - The currently active team identifier
-* @returns Filtered array of workspaces accessible to the current team
-*
-* @example
-* ```ts
-* const workspaces = [
-*   { id: '1', teamSlug: 'local', name: 'Local' },
-*   { id: '2', teamSlug: 'team-a', name: 'Team A' },
-*   { id: '3', teamSlug: 'team-b', name: 'Team B' },
-* ]
-*
-* filterWorkspacesByTeam(workspaces, 'team-a')
-* // => [{ id: '1', teamSlug: 'local' }, { id: '2', teamSlug: 'team-a' }]
-* ```
-*/
-var filterWorkspacesByTeam = (workspaces, currentTeamSlug) => {
-	return workspaces.filter((workspace) => canLoadWorkspace(workspace.teamSlug, currentTeamSlug));
-};
-/**
-* Checks if a workspace can be loaded by the current team.
-*
-* A workspace can be loaded if:
-* - Its teamSlug matches the current team, OR
-* - Its teamSlug is 'local' (local workspaces are always accessible)
-*
-* This is used during route changes to prevent users from accessing
-* workspaces that do not belong to their active team.
-*
-* @param workspaceTeamSlug - The team identifier of the workspace to check
-* @param currentTeamSlug - The currently active team identifier
-* @returns true if the workspace can be loaded, false otherwise
-*
-* @example
-* ```ts
-* canLoadWorkspace('team-a', 'team-a') // => true
-* canLoadWorkspace('local', 'team-a')  // => true
-* canLoadWorkspace('team-b', 'team-a') // => false
-* ```
-*/
-var canLoadWorkspace = (workspaceTeamSlug, currentTeamSlug) => {
-	return workspaceTeamSlug === currentTeamSlug || workspaceTeamSlug === "local";
-};
-//#endregion
-export { canLoadWorkspace, filterWorkspacesByTeam };
-
-//# sourceMappingURL=filter-workspaces.js.map

package/dist/v2/features/app/helpers/filter-workspaces.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"filter-workspaces.js","names":[],"sources":["../../../../../src/v2/features/app/helpers/filter-workspaces.ts"],"sourcesContent":["/**\n * Filters workspaces to show only those accessible to the current team.\n *\n * A workspace is accessible if:\n * - Its teamSlug matches the current team, OR\n * - Its teamSlug is 'local' (local workspaces are always accessible)\n *\n * @param workspaces - Array of workspaces to filter\n * @param currentTeamSlug - The currently active team identifier\n * @returns Filtered array of workspaces accessible to the current team\n *\n * @example\n * ```ts\n * const workspaces = [\n *   { id: '1', teamSlug: 'local', name: 'Local' },\n *   { id: '2', teamSlug: 'team-a', name: 'Team A' },\n *   { id: '3', teamSlug: 'team-b', name: 'Team B' },\n * ]\n *\n * filterWorkspacesByTeam(workspaces, 'team-a')\n * // => [{ id: '1', teamSlug: 'local' }, { id: '2', teamSlug: 'team-a' }]\n * ```\n */\nexport const filterWorkspacesByTeam = <T extends { teamSlug: string }>(\n  workspaces: T[],\n  currentTeamSlug: string,\n): T[] => {\n  return workspaces.filter((workspace) => canLoadWorkspace(workspace.teamSlug, currentTeamSlug))\n}\n\n/**\n * Checks if a workspace can be loaded by the current team.\n *\n * A workspace can be loaded if:\n * - Its teamSlug matches the current team, OR\n * - Its teamSlug is 'local' (local workspaces are always accessible)\n *\n * This is used during route changes to prevent users from accessing\n * workspaces that do not belong to their active team.\n *\n * @param workspaceTeamSlug - The team identifier of the workspace to check\n * @param currentTeamSlug - The currently active team identifier\n * @returns true if the workspace can be loaded, false otherwise\n *\n * @example\n * ```ts\n * canLoadWorkspace('team-a', 'team-a') // => true\n * canLoadWorkspace('local', 'team-a')  // => true\n * canLoadWorkspace('team-b', 'team-a') // => false\n * ```\n */\nexport const canLoadWorkspace = (workspaceTeamSlug: string, currentTeamSlug: string): boolean => {\n  return workspaceTeamSlug === currentTeamSlug || workspaceTeamSlug === 'local'\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,0BACX,YACA,oBACQ;AACR,QAAO,WAAW,QAAQ,cAAc,iBAAiB,UAAU,UAAU,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwBhG,IAAa,oBAAoB,mBAA2B,oBAAqC;AAC/F,QAAO,sBAAsB,mBAAmB,sBAAsB"}

package/dist/v2/features/app/helpers/get-route-param.d.ts

@@ -1,7 +0,0 @@
-import type { HttpMethod } from '@scalar/helpers/http/http-methods';
-import type { RouteLocationNormalizedGeneric } from 'vue-router';
-import type { ScalarClientAppRouteParams } from '../../../../v2/features/app/helpers/routes.js';
-/** Extracts a string parameter from the route */
-export declare function getRouteParam(paramName: 'method', route: RouteLocationNormalizedGeneric | null): HttpMethod | undefined;
-export declare function getRouteParam(paramName: Exclude<ScalarClientAppRouteParams, 'method'>, route: RouteLocationNormalizedGeneric | null): string | undefined;
-//# sourceMappingURL=get-route-param.d.ts.map

package/dist/v2/features/app/helpers/get-route-param.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-route-param.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/helpers/get-route-param.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAA;AAEhE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAA;AAElF,iDAAiD;AACjD,wBAAgB,aAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,8BAA8B,GAAG,IAAI,GAAG,UAAU,GAAG,SAAS,CAAA;AACxH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,OAAO,CAAC,0BAA0B,EAAE,QAAQ,CAAC,EACxD,KAAK,EAAE,8BAA8B,GAAG,IAAI,GAC3C,MAAM,GAAG,SAAS,CAAA"}