@sanity/workbench 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/_chunks-es/studio.js

@@ -0,0 +1,892 @@
+import { z } from "zod";
+import { valid, coerce, gt, lt, gte, rsort } from "semver";
+const interfaceBaseFields = {
+  id: z.string(),
+  deployment_id: z.string(),
+  name: z.string(),
+  entry_point: z.string()
+}, PanelInterfaceSchema = z.object({
+  ...interfaceBaseFields,
+  interface_type: z.literal("panel")
+}), WorkerInterfaceSchema = z.object({
+  ...interfaceBaseFields,
+  interface_type: z.literal("worker")
+}), AppInterfaceSchema = z.object({
+  ...interfaceBaseFields,
+  interface_type: z.literal("app")
+}), InterfaceSchema = z.discriminatedUnion("interface_type", [
+  PanelInterfaceSchema,
+  WorkerInterfaceSchema,
+  AppInterfaceSchema
+]), LocalInterfaceSchema = z.discriminatedUnion("interface_type", [
+  PanelInterfaceSchema.omit({ id: !0, deployment_id: !0 }),
+  WorkerInterfaceSchema.omit({ id: !0, deployment_id: !0 }),
+  AppInterfaceSchema.omit({ id: !0, deployment_id: !0 })
+]);
+class AbstractApplication {
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+  /**
+   * Whether the application is served by a local CLI dev server rather than a
+   * deployed remote. Defaults to `false`; user applications flip this when
+   * constructed from a `LocalUserApplication` payload.
+   */
+  get isLocal() {
+    return !1;
+  }
+  /**
+   * Interfaces the application exposes (e.g. dock panels). Defaults to none;
+   * user applications surface what they declared via `unstable_defineApp`.
+   */
+  get interfaces() {
+    return [];
+  }
+  /**
+   * Whether the application has a navigable full-page `app` view (US5, spec 002-workbench-extension-api). Defaults
+   * to `true` — studios, Canvas, and Media Library are always navigable. An SDK
+   * app overrides this to derive it from whether it declares an `app` interface.
+   */
+  get hasAppView() {
+    return !0;
+  }
+  /**
+   * Federation module id of the app's full-page view (`${id}/App`), or `null`
+   * when it can't be federation-loaded: the app isn't federated (Canvas, Media
+   * Library, deployed apps shown in an iframe) or has no app view. Only a
+   * non-null `moduleId` is fetched and rendered by the remotes machine.
+   */
+  get moduleId() {
+    return this.isFederated && this.hasAppView ? `${this.id}/App` : null;
+  }
+  /**
+   * Federation module id of one of this app's panel view components, or `null`
+   * when the app isn't federated (a non-federated app's panels can't be loaded
+   * as remotes).
+   */
+  resolveViewModuleId(view, component) {
+    return this.isFederated ? `${this.id}/views/${view.name}/${component}` : null;
+  }
+  get initials() {
+    const SYMBOLS = /[^\p{Alpha}\p{N}\p{White_Space}]/gu, WHITESPACE = new RegExp("\\p{White_Space}+", "u"), ALPHANUMERIC_SEGMENTS = new RegExp("(\\p{N}+|\\p{Alpha}+)", "gu"), IS_NUMERIC = new RegExp("^\\p{N}+$", "u");
+    if (!this.title) return "";
+    const namesArray = this.title.replace(SYMBOLS, "").split(WHITESPACE).filter(Boolean);
+    if (namesArray.length === 0) return "";
+    if (namesArray.length === 1) {
+      const word = namesArray[0], segments = word.match(ALPHANUMERIC_SEGMENTS) || [];
+      return segments.length === 0 ? "" : segments.length === 1 ? word.length === 1 ? word.toUpperCase() : IS_NUMERIC.test(word) ? `${word.charAt(0)}${word.charAt(1)}`.toUpperCase() : word.charAt(0).toUpperCase() : `${segments[0].charAt(0)}${segments[1].charAt(0)}`.toUpperCase();
+    }
+    return `${namesArray[0].charAt(0)}${namesArray[namesArray.length - 1].charAt(0)}`.toUpperCase();
+  }
+}
+function getSanityDomain() {
+  return getSanityEnv() === "staging" ? "sanity.work" : "sanity.io";
+}
+function getApiHost() {
+  return `https://api.${getSanityDomain()}`;
+}
+function getSanityEnv() {
+  return typeof __SANITY_STAGING__ < "u" && __SANITY_STAGING__ === !0 ? "staging" : "production";
+}
+const OrganizationId = z.string().nonempty().brand("OrganizationId");
+function brandOrganizationId(id) {
+  return OrganizationId.parse(id);
+}
+const OrganizationMember = z.object({
+  sanityUserId: z.string(),
+  isCurrentUser: z.boolean(),
+  user: z.object({
+    id: z.string(),
+    displayName: z.string(),
+    familyName: z.string(),
+    givenName: z.string(),
+    middleName: z.string().nullable(),
+    imageUrl: z.string().nullable(),
+    email: z.string(),
+    loginProvider: z.string()
+  }),
+  roles: z.array(
+    z.object({
+      name: z.string(),
+      title: z.string(),
+      description: z.string().optional()
+    })
+  )
+}), Organization = z.object({
+  id: OrganizationId,
+  name: z.string(),
+  slug: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  dashboardStatus: z.enum(["enabled", "disabled"]),
+  aiFeaturesStatus: z.enum(["enabled", "disabled"]),
+  defaultRoleName: z.string().nullable()
+});
+function parseOrganization(data, options) {
+  const includeMembers = options?.includeMembers ?? !0, includeFeatures = options?.includeFeatures ?? !0, extensions = {
+    ...includeMembers && {
+      members: z.array(OrganizationMember)
+    },
+    ...includeFeatures && {
+      features: z.array(z.string())
+    }
+  };
+  return (Object.keys(extensions).length > 0 ? Organization.extend(extensions) : Organization).parse(data);
+}
+const CanvasId = z.string().nonempty().brand("CanvasId");
+function brandCanvasId(id) {
+  return CanvasId.parse(id);
+}
+const Canvas = z.object({
+  id: CanvasId,
+  organizationId: OrganizationId,
+  status: z.enum(["active", "provisioning"])
+});
+function parseCanvas(data) {
+  return Canvas.parse(data);
+}
+class CanvasApplication extends AbstractApplication {
+  canvas;
+  constructor(canvas) {
+    super("canvas"), this.canvas = canvas;
+  }
+  get id() {
+    return this.canvas.id;
+  }
+  get href() {
+    return "canvas";
+  }
+  get title() {
+    return "Canvas";
+  }
+  get url() {
+    return new URL(
+      `https://canvas.${getSanityDomain()}/o/${this.canvas.organizationId}`
+    );
+  }
+  get isFederated() {
+    return !1;
+  }
+  toProtocolResource() {
+    return {
+      type: "canvas",
+      id: this.id
+    };
+  }
+}
+const MediaLibraryId = z.string().nonempty().brand("MediaLibraryId");
+function brandMediaLibraryId(id) {
+  return MediaLibraryId.parse(id);
+}
+const MediaLibrary = z.object({
+  id: MediaLibraryId,
+  organizationId: OrganizationId,
+  status: z.enum(["active", "provisioning"]),
+  aclMode: z.enum(["private", "public"])
+});
+function parseMediaLibrary(data) {
+  return MediaLibrary.parse(data);
+}
+class MediaLibraryApplication extends AbstractApplication {
+  library;
+  constructor(library) {
+    super("media-library"), this.library = library;
+  }
+  get id() {
+    return this.library.id;
+  }
+  get href() {
+    return "media";
+  }
+  get title() {
+    return "Media Library";
+  }
+  get isFederated() {
+    return !1;
+  }
+  get url() {
+    return new URL(
+      `https://media.${getSanityDomain()}/${this.library.organizationId}`
+    );
+  }
+  toProtocolResource() {
+    return {
+      type: "media-library",
+      id: this.id
+    };
+  }
+}
+const ProjectId = z.string().nonempty().brand("ProjectId");
+function brandProjectId(id) {
+  return ProjectId.parse(id);
+}
+const ProjectMember = z.object({
+  id: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  isCurrentUser: z.boolean(),
+  isRobot: z.boolean(),
+  roles: z.array(
+    z.object({
+      name: z.string(),
+      title: z.string(),
+      description: z.string()
+    })
+  )
+}), Project = z.object({
+  id: ProjectId,
+  displayName: z.string(),
+  studioHost: z.string().nullable(),
+  organizationId: OrganizationId,
+  metadata: z.object({
+    color: z.string().optional(),
+    externalStudioHost: z.string().optional(),
+    initialTemplate: z.string().optional(),
+    cliInitializedAt: z.string().optional(),
+    integration: z.string().optional()
+  }),
+  isBlocked: z.boolean(),
+  isDisabled: z.boolean(),
+  isDisabledByUser: z.boolean(),
+  activityFeedEnabled: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+function parseProject(data, options) {
+  const includeMembers = options?.includeMembers ?? !0, includeFeatures = options?.includeFeatures ?? !0, extensions = {
+    ...includeMembers && { members: z.array(ProjectMember) },
+    ...includeFeatures && { features: z.array(z.string()) }
+  };
+  return (Object.keys(extensions).length > 0 ? Project.extend(extensions) : Project).parse(data);
+}
+const joinUrlPaths = (...paths) => {
+  let nextPath = null;
+  const safeJoinSegments = (segment1, segment2) => segment1 ? segment2 ? segment1.endsWith("/") && segment2.startsWith("/") ? segment1 + segment2.slice(1) : segment1.endsWith("/") || segment2.startsWith("/") ? segment1 + segment2 : `${segment1}/${segment2}` : segment1 : segment2 || "", validPaths = paths.filter(
+    (path) => path != null
+  );
+  for (const path of validPaths)
+    nextPath = safeJoinSegments(
+      nextPath,
+      path instanceof URL ? path.pathname : path
+    );
+  return nextPath ?? "";
+};
+function normalizePath(pathname) {
+  return pathname.startsWith("/") || (pathname = `/${pathname}`), pathname !== "/" && pathname.endsWith("/") && (pathname = pathname.slice(0, -1)), pathname;
+}
+const UserApplicationId = z.string().nonempty().brand("UserApplicationId");
+function brandUserApplicationId(id) {
+  return UserApplicationId.parse(id);
+}
+const LocalUserApplicationBase = z.object({
+  host: z.string(),
+  port: z.number(),
+  /**
+   * Interfaces the app exposes — dock panels (`interface_type: "panel"`) and
+   * background workers (`interface_type: "worker"`), forwarded from the dev
+   * server in one list.
+   */
+  interfaces: z.array(LocalInterfaceSchema).optional(),
+  /** The `deployment.appId` from the application's `sanity.cli.ts`, when set. */
+  id: z.string().optional(),
+  /**
+   * The `api.projectId` from the application's `sanity.cli.ts`. Available
+   * synchronously at dev-server startup (no manifest extraction required), so
+   * the studio's primary project is resolvable from the very first local
+   * application event.
+   */
+  projectId: z.string().optional()
+}), LocalUserApplication = z.discriminatedUnion("type", [
+  LocalUserApplicationBase.extend({
+    type: z.literal("studio"),
+    manifest: z.custom().optional()
+  }),
+  LocalUserApplicationBase.extend({
+    type: z.literal("coreApp"),
+    manifest: z.custom().optional()
+  })
+]), UserApplicationBase = z.object({
+  id: UserApplicationId,
+  appHost: z.string(),
+  urlType: z.enum(["internal", "external"]),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  dashboardStatus: z.enum(["default", "disabled"]),
+  /**
+   * Interfaces the app exposes (dock panels and background workers). Not part
+   * of the manifest.
+   */
+  interfaces: z.array(LocalInterfaceSchema).optional()
+}), ActiveDeployment = z.object({
+  id: z.string(),
+  version: z.string(),
+  isActiveDeployment: z.boolean(),
+  userApplicationId: z.string(),
+  isAutoUpdating: z.boolean().nullable(),
+  size: z.number().nullable(),
+  deployedAt: z.string(),
+  deployedBy: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+class UserApplication extends AbstractApplication {
+  application;
+  id;
+  /**
+   * For local applications (`isLocal === true`), the deployed application
+   * that shares the same `id` — if one was passed at construction. `null`
+   * for deployed applications or when no remote twin was provided.
+   */
+  remoteApplication;
+  #isLocal;
+  constructor(application, type, options = {}) {
+    super(type), this.application = application, this.id = brandUserApplicationId(application.id), this.#isLocal = options.isLocal ?? !1, this.remoteApplication = options.remoteApplication ?? null;
+  }
+  /**
+   * Local dev servers are rendered as federated remotes; deployed applications
+   * are rendered in an iframe.
+   */
+  get isFederated() {
+    return this.isLocal;
+  }
+  get isLocal() {
+    return this.#isLocal;
+  }
+  get interfaces() {
+    return this.application.interfaces ?? [];
+  }
+  /**
+   * @returns A fully resolved URL instance for the application.
+   * For internal applications, constructs a URL using the Sanity studio domain
+   * pattern resolved from the environment at the consuming app's build time.
+   * For external applications (including local dev servers), returns the
+   * provided app host as a URL.
+   */
+  get url() {
+    return this.application.urlType === "internal" ? getSanityEnv() === "production" ? new URL(`https://${this.application.appHost}.sanity.studio`) : new URL(
+      `https://${this.application.appHost}.studio.${getSanityDomain()}`
+    ) : new URL(this.application.appHost);
+  }
+}
+const CoreAppUserApplicationManifest = z.object({
+  version: z.string(),
+  icon: z.string().optional(),
+  title: z.string().optional(),
+  group: z.string().optional(),
+  priority: z.number().optional()
+}), CoreAppUserApplicationBase = UserApplicationBase.extend({
+  title: z.string(),
+  organizationId: OrganizationId,
+  type: z.literal("coreApp")
+}), CoreAppActiveDeployment = ActiveDeployment.extend({
+  manifest: CoreAppUserApplicationManifest.nullable()
+}).nullable(), InternalCoreAppUserApplication = CoreAppUserApplicationBase.extend({
+  urlType: z.literal("internal"),
+  activeDeployment: CoreAppActiveDeployment
+}), ExternalCoreAppUserApplication = CoreAppUserApplicationBase.extend({
+  urlType: z.literal("external"),
+  activeDeployment: CoreAppActiveDeployment
+}), CoreAppUserApplication = z.discriminatedUnion("urlType", [
+  InternalCoreAppUserApplication,
+  ExternalCoreAppUserApplication
+]);
+function parseCoreApplication(data) {
+  return CoreAppUserApplication.parse(data);
+}
+class CoreAppApplication extends UserApplication {
+  activeDeployment;
+  constructor(application, options = {}) {
+    super(application, "coreApp", options), this.activeDeployment = application.activeDeployment;
+  }
+  // Typed `string | null` so the UI-aware remote subclass can override it to
+  // `null` for a non-navigable app (US5, spec 002-workbench-extension-api); the core route itself is always set.
+  get href() {
+    return this.isLocal ? `/local/${this.id}` : `/application/${this.application.id}`;
+  }
+  get title() {
+    return this.manifest?.title ?? this.application.title;
+  }
+  /**
+   * Resolves the core app's manifest from `activeDeployment.manifest`. This
+   * is the canonical (and only) slot for core app manifests — both for
+   * Sanity-deployed apps and for local CLI dev-server apps, which synthesise
+   * a deployment to surface the live manifest.
+   */
+  get manifest() {
+    return this.activeDeployment?.manifest ?? null;
+  }
+  get subtitle() {
+  }
+  get updatedAt() {
+    return this.application.updatedAt;
+  }
+  get(attr) {
+    if (!(attr in this.application))
+      throw new Error(
+        `Attribute ${attr.toString()} does not exist on application ${this.application.id}`
+      );
+    return this.application[attr];
+  }
+  toProtocolResource() {
+    return {
+      ...this.application,
+      type: "application",
+      url: this.url.toString()
+    };
+  }
+}
+const Workspace = z.object({
+  name: z.string(),
+  title: z.string(),
+  subtitle: z.string().optional(),
+  basePath: z.string(),
+  projectId: ProjectId,
+  dataset: z.string().optional(),
+  icon: z.string().nullable().optional()
+}), ServerManifest = z.object({
+  buildId: z.string().optional(),
+  bundleVersion: z.string().optional(),
+  version: z.string().optional(),
+  group: z.string().optional(),
+  priority: z.number().optional(),
+  workspaces: z.array(
+    Workspace.extend({
+      dataset: z.string(),
+      schemaDescriptorId: z.string()
+    })
+  ).optional()
+}), ClientManifest = z.object({
+  version: z.number(),
+  createdAt: z.string(),
+  studioVersion: z.string().optional(),
+  group: z.string().optional(),
+  priority: z.number().optional(),
+  workspaces: z.array(
+    Workspace.extend({
+      schema: z.string(),
+      tools: z.string().optional()
+    })
+  )
+}), StudioUserApplicationBase = UserApplicationBase.extend({
+  title: z.string().nullable(),
+  projectId: ProjectId,
+  type: z.literal("studio"),
+  /**
+   * @deprecated Use `manifestData` instead.
+   */
+  manifest: ClientManifest.nullable(),
+  manifestData: z.object({ value: ClientManifest }).nullable(),
+  autoUpdatingVersion: z.string().nullable(),
+  config: z.object({
+    "live-manifest": z.object({
+      createdAt: z.string(),
+      updatedAt: z.string(),
+      updatedBy: z.string(),
+      value: ServerManifest
+    }).optional()
+  })
+}), InternalStudioUserApplication = StudioUserApplicationBase.extend({
+  urlType: z.literal("internal"),
+  activeDeployment: ActiveDeployment.extend({
+    manifest: ServerManifest.nullable()
+  }).nullable()
+}), ExternalStudioUserApplication = StudioUserApplicationBase.extend({
+  urlType: z.literal("external"),
+  activeDeployment: ActiveDeployment.extend({
+    manifest: ServerManifest.nullable()
+  }).nullable()
+}), StudioUserApplication = z.discriminatedUnion("urlType", [
+  InternalStudioUserApplication,
+  ExternalStudioUserApplication
+]);
+function parseStudioUserApplication(data) {
+  return StudioUserApplication.parse(data);
+}
+class StudioWorkspace extends AbstractApplication {
+  /**
+   * Workspaces always belong to a studio application.
+   * They do not exist on their own & therefore can access
+   * information about the studio they're in via this property.
+   */
+  studioApplication;
+  workspace;
+  project;
+  isDefaultWorkspace;
+  constructor(studioApplication, workspace, project, isDefaultWorkspace) {
+    super("workspace"), this.studioApplication = studioApplication, this.workspace = workspace, this.project = project, this.isDefaultWorkspace = isDefaultWorkspace;
+  }
+  /**
+   * The studio application that this workspace belongs to.
+   */
+  get studio() {
+    return this.studioApplication;
+  }
+  get id() {
+    return StudioWorkspace.makeId(this.studio.id, this.workspace.name);
+  }
+  get href() {
+    return joinUrlPaths(this.studio.href, this.workspace.name);
+  }
+  get title() {
+    return this.isDefaultWorkspace ? this.project.displayName : this.workspace.title;
+  }
+  get subtitle() {
+    return this.isDefaultWorkspace ? (URL.canParse(this.studio.get("appHost")) ? new URL(this.studio.get("appHost")) : this.studio.url).hostname : this.get("subtitle");
+  }
+  get(attr) {
+    return this.workspace[attr];
+  }
+  get isFederated() {
+    return this.studio.isFederated;
+  }
+  /**
+   * With comlink, studio-applications were not considered applications at all, only workspaces. This is partially why
+   * we create default workspaces when the application has no manifest or the manifest has no workspaces.
+   *
+   * Thereby, to create it we depend on a lot of information from the parent application even if it's duplicated across
+   * different workspaces.
+   */
+  toProtocolResource() {
+    return {
+      ...this.workspace,
+      type: "studio",
+      userApplicationId: this.studio.id,
+      // The protocol still types `size`/`isAutoUpdating` as non-nullable,
+      // but the user-applications API reports both as nullable.
+      activeDeployment: this.studio.get(
+        "activeDeployment"
+      ),
+      autoUpdatingVersion: this.studio.get("autoUpdatingVersion"),
+      dashboardStatus: this.studio.get("dashboardStatus"),
+      url: this.studio.url.toString(),
+      href: this.href,
+      id: this.id,
+      hasManifest: !0,
+      hasSchema: !!("schema" in this.workspace && this.workspace.schema),
+      // The protocol resource requires the client-shaped manifest (workspaces
+      // with `schema`). Read those sources directly rather than the unified
+      // `manifest` getter, which may return a `ServerManifest` for studios
+      // with a deployment manifest.
+      manifest: this.studio.get("manifestData")?.value ?? this.studio.get("manifest") ?? null,
+      updatedAt: this.studio.get("updatedAt"),
+      version: this.studio.get("activeDeployment")?.version,
+      urlType: this.studio.get("urlType"),
+      config: this.studio.get("config")
+    };
+  }
+  /**
+   * @returns the URL to the workspace of a studio application.
+   */
+  get url() {
+    const studioUrl = new URL(this.studio.url), normalizedUrlPath = normalizePath(studioUrl.pathname);
+    let finalBasePath = normalizePath(this.get("basePath"));
+    return finalBasePath.startsWith(normalizedUrlPath) && (finalBasePath = finalBasePath.slice(normalizedUrlPath.length)), studioUrl.pathname = joinUrlPaths(normalizedUrlPath, finalBasePath), studioUrl;
+  }
+  static makeId(applicationId, workspaceName) {
+    return `${applicationId}-${workspaceName}`;
+  }
+  static splitId(id) {
+    return id.split(new RegExp(/-(.*)/)).slice(0, 2);
+  }
+}
+const Manifest = z.union([
+  ClientManifest.superRefine((data, ctx) => {
+    data.version || ctx.addIssue({
+      code: "invalid_type",
+      message: "Manifest version is too old",
+      expected: "number"
+    }), data.version < 2 && ctx.addIssue({
+      code: "invalid_value",
+      message: "Manifest version is too old",
+      values: [2, 3]
+    }), data.version >= 3 && !data.studioVersion && ctx.addIssue({
+      code: "invalid_type",
+      message: "Manifest version 3 or higher requires a `studioVersion`",
+      expected: "string"
+    });
+  }),
+  ServerManifest
+]), DEFAULT_WORKSPACE_DATA = {
+  name: "default",
+  title: "Default",
+  basePath: "/"
+};
+class StudioApplication extends UserApplication {
+  /**
+   * Returns a list of studio workspaces based on the application manifest.
+   * If there is no manifest, or alternatively it is not valid, then we create a default workspace.
+   */
+  workspaces = [];
+  project;
+  /**
+   * The projects actually referenced by this studio — the application's own
+   * project plus any project used by a workspace. Preserved so the instance
+   * can be re-constructed (e.g. by dock wrappers) without having to thread
+   * the full organization project list through again.
+   */
+  projects;
+  /**
+   * @param application - The studio application to create a list of workspaces for
+   * @param projects - The projects available in the organization. It's not enough to just pass
+   * the project that associates with the application because that is the project the app is deployed in relation to.
+   * The workspaces may have different projects completely.
+   */
+  constructor(application, projects, options = {}) {
+    super(application, "studio", options);
+    let workspaces = [];
+    const manifest = this.manifest;
+    if (manifest)
+      try {
+        workspaces = Manifest.parse(manifest).workspaces ?? [];
+      } catch (error) {
+        console.warn(
+          `Failed to parse manifest for application ${application.id}`,
+          error
+        );
+      }
+    const workspacesWithProjectsMap = workspaces.reduce((acc, workspace) => {
+      const project2 = projects.find((p) => p.id === workspace.projectId);
+      return project2 ? acc.set(workspace, project2) : console.warn(
+        `Project not found for application ${application.id} and workspace ${workspace.name}. This workspace has been omitted.`
+      ), acc;
+    }, /* @__PURE__ */ new Map()), project = projects.find((p) => p.id === application.projectId);
+    if (!project)
+      throw new Error(`Project not found for application ${application.id}`);
+    workspacesWithProjectsMap.size === 0 && workspacesWithProjectsMap.set(
+      {
+        ...DEFAULT_WORKSPACE_DATA,
+        projectId: application.projectId
+      },
+      project
+    ), this.workspaces = Object.freeze(
+      Array.from(workspacesWithProjectsMap.entries()).map(([workspace, p]) => {
+        const isDefaultWorkspace = workspace.name === DEFAULT_WORKSPACE_DATA.name && workspace.basePath === DEFAULT_WORKSPACE_DATA.basePath && workspace.title === DEFAULT_WORKSPACE_DATA.title;
+        return this.createWorkspace(workspace, p, isDefaultWorkspace);
+      })
+    ), this.project = project;
+    const usedProjects = /* @__PURE__ */ new Set([project]);
+    for (const workspace of this.workspaces)
+      usedProjects.add(workspace.project);
+    this.projects = Array.from(usedProjects);
+  }
+  /**
+   * Factory hook called for each workspace during construction. Subclasses
+   * override this to substitute a `StudioWorkspace` subclass (e.g. a UI-aware
+   * variant in a downstream package) without re-implementing the constructor's
+   * workspace-derivation logic.
+   */
+  createWorkspace(workspace, project, isDefaultWorkspace) {
+    return new StudioWorkspace(this, workspace, project, isDefaultWorkspace);
+  }
+  get href() {
+    return this.isLocal ? `/local/${this.id}` : `/studio/${this.application.id}`;
+  }
+  get title() {
+    return this.get("title") || (this.workspaces.length > 1 && this.get("urlType") === "internal" ? this.project.displayName : this.workspaces[0].title);
+  }
+  get subtitle() {
+    return new URL(this.url).hostname;
+  }
+  get(attr) {
+    if (!(attr in this.application))
+      throw new Error(
+        `Attribute ${attr.toString()} does not exist on studio ${this.application.id}`
+      );
+    return this.application[attr];
+  }
+  /**
+   * Resolves the studio's most authoritative manifest. The lookup order is:
+   *
+   * 1. `activeDeployment.manifest` — deployment manifests are the new
+   *    primitive within Sanity and are preferred whenever available.
+   * 2. `manifestData.value` — fallback to support older studios that
+   *    haven't produced a deployment manifest yet.
+   * 3. `application.manifest` — last-resort legacy field.
+   *
+   * Returns `null` when no manifest is available. The return shape is a
+   * union because the deployment and client manifests are not
+   * interchangeable — consumers that depend on client-only fields (e.g.
+   * `studioVersion`, workspace `schema`) must narrow or read the raw
+   * field they need.
+   */
+  get manifest() {
+    return this.application.activeDeployment?.manifest ?? this.application.manifestData?.value ?? this.application.manifest ?? null;
+  }
+  get hasManifest() {
+    const manifest = this.manifest;
+    return manifest ? typeof manifest.version != "number" || manifest.version >= 2 : !1;
+  }
+  get hasSchema() {
+    if (this.application.activeDeployment?.manifest) return !0;
+    const workspaces = (this.application.manifestData?.value ?? this.application.manifest)?.workspaces ?? [];
+    return workspaces.length === 0 ? !1 : workspaces.every((w) => !!w.schema);
+  }
+  resolveVersion() {
+    let version;
+    if (this.get("urlType") === "internal")
+      version = this.get("activeDeployment")?.version;
+    else {
+      const clientManifest = this.get("manifestData")?.value ?? this.get("manifest");
+      version = clientManifest && "studioVersion" in clientManifest ? clientManifest.studioVersion : void 0;
+    }
+    const bundleVersion = this.get("activeDeployment")?.manifest?.bundleVersion;
+    return bundleVersion && valid(coerce(bundleVersion)) && (!version || version && gt(bundleVersion, version)) && (version = bundleVersion), !version || !valid(coerce(version)) ? null : coerce(version);
+  }
+  get version() {
+    const version = this.resolveVersion();
+    return version ? version.toString() : null;
+  }
+  get compatibilityStatus() {
+    return StudioApplication.resolveCompatibilityStatus(this);
+  }
+  /**
+   * Used to calculate the compatibility status of a given studio application.
+   * Optionally if you've resolved the version elsewhere provide that value to
+   * get the new compatibility status without mutating the application.
+   */
+  static resolveCompatibilityStatus(application, version = application.version) {
+    return version === null || lt(version, StudioApplication.MinimumStudioVersion) ? StudioApplication.CompatibilityStatuses.UNKNOWN : !application.hasSchema || !application.hasManifest || StudioApplication.resolveIssues(application, version).length > 0 ? StudioApplication.CompatibilityStatuses.PARTIALLY_COMPATIBLE : StudioApplication.CompatibilityStatuses.FULLY_COMPATIBLE;
+  }
+  get isAutoRedirecting() {
+    return StudioApplication.resolveIsAutoRedirecting(this);
+  }
+  /**
+   * Mirrors the `isRedirectable` function from Saison defined in
+   * https://github.com/sanity-io/saison/blob/83556405d23e07f6d3a71c76249c67e33fe1101f/src/utils/applications.ts
+   *
+   * Returns whether a studio application is auto-redirecting, meaning it can only be accessed in the context of
+   * Dashboard.
+   */
+  static resolveIsAutoRedirecting(application, versionArg = application.version) {
+    let version = versionArg;
+    if (application.get("urlType") === "external" || !version)
+      return !1;
+    if (!application.get("activeDeployment")?.isAutoUpdating)
+      return gt(version, "3.92.0");
+    const autoUpdatingVersion = application.get("autoUpdatingVersion");
+    if (autoUpdatingVersion) {
+      if (["next", "stable", "latest"].includes(autoUpdatingVersion))
+        return !0;
+      const autoUpdatingVersionPinnedVersion = coerce(autoUpdatingVersion);
+      autoUpdatingVersionPinnedVersion && (version = autoUpdatingVersionPinnedVersion);
+    }
+    return gt(version, StudioApplication.MinimumStudioVersion);
+  }
+  /**
+   * Returns a list of issues that prevent the studio from functioning properly in the Dashboard.
+   * This static value depends on the version of the studio that comes from the `activeDeployment` property.
+   * As such, if the studio is auto-updating, this list will be incorrect & instead you should use
+   * the static method `resolveIssues` to get the correct issues by passing the resolved version.
+   */
+  get issues() {
+    return StudioApplication.resolveIssues(this);
+  }
+  static resolveIssues(application, version = application.version) {
+    const issues = StudioApplication.Features.filter(
+      (feature) => !application.isFeatureSupported(feature.id, version)
+    );
+    return application.hasManifest || issues.push({
+      id: StudioApplication.StudioIssues.ISSUE_MANIFEST
+    }), issues;
+  }
+  isFeatureSupported(feature, version = this.version) {
+    const featureVersion = StudioApplication.Features.find(
+      (_) => _.id === feature
+    )?.version;
+    return !featureVersion || !version ? !1 : gte(version, featureVersion);
+  }
+  toProtocolResource() {
+    throw new Error(
+      "Studio application resources cannot be converted to protocol resources"
+    );
+  }
+  static CompatibilityStatuses = {
+    UNKNOWN: "unknown",
+    PARTIALLY_COMPATIBLE: "partially-compatible",
+    FULLY_COMPATIBLE: "fully-compatible"
+  };
+  static StudioIssues = {
+    ISSUE_ACTIVITY: "ACTIVITY",
+    ISSUE_AGENT: "AGENT",
+    ISSUE_FAVORITES: "FAVORITES",
+    ISSUE_URL_SYNCING: "URL_SYNCING",
+    ISSUE_UI_ADJUSTMENT: "UI_ADJUSTMENT",
+    ISSUE_CONTENT_MAPPING: "CONTENT_MAPPING",
+    ISSUE_LOGIN: "LOGIN",
+    ISSUE_MANIFEST: "MANIFEST"
+  };
+  static Features = [
+    {
+      id: StudioApplication.StudioIssues.ISSUE_AGENT,
+      version: "5.1.0"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_FAVORITES,
+      version: "3.88.1"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_ACTIVITY,
+      version: "3.88.1"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_URL_SYNCING,
+      version: "3.75.0"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_UI_ADJUSTMENT,
+      version: "3.78.1"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_CONTENT_MAPPING,
+      version: "3.68.0"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_LOGIN,
+      version: "2.28.0"
+    }
+  ];
+  static MinimumStudioVersion = "2.28.0";
+  static MinimumStudioVersionWithNoIssues = rsort(
+    StudioApplication.Features.map((feature) => feature.version)
+  ).at(0);
+}
+export {
+  AbstractApplication,
+  ActiveDeployment,
+  CanvasApplication,
+  ClientManifest,
+  CoreAppApplication,
+  CoreAppUserApplicationManifest,
+  InterfaceSchema,
+  LocalInterfaceSchema,
+  LocalUserApplication,
+  MediaLibraryApplication,
+  Organization,
+  OrganizationId,
+  Project,
+  ProjectId,
+  ServerManifest,
+  StudioApplication,
+  StudioUserApplication,
+  StudioWorkspace,
+  UserApplication,
+  UserApplicationBase,
+  UserApplicationId,
+  brandCanvasId,
+  brandMediaLibraryId,
+  brandOrganizationId,
+  brandProjectId,
+  brandUserApplicationId,
+  getApiHost,
+  getSanityDomain,
+  getSanityEnv,
+  joinUrlPaths,
+  parseCanvas,
+  parseCoreApplication,
+  parseMediaLibrary,
+  parseOrganization,
+  parseProject,
+  parseStudioUserApplication
+};
+//# sourceMappingURL=studio.js.map