@dxos/plugin-space 0.6.11 → 0.6.12-main.15a606f

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,2953 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  SPACE_PLUGIN,
+  SPACE_PLUGIN_SHORT_ID,
+  SpaceAction,
+  meta_default
+} from "./chunk-GM2YUC77.mjs";
+import {
+  ActorSchema,
+  ChannelType,
+  CollectionType,
+  ContactType,
+  MessageState,
+  MessageType,
+  SPACE_DIRECTORY_HANDLE,
+  ThreadStatus,
+  ThreadType,
+  parseSpaceInitPlugin
+} from "./chunk-N5VC55UM.mjs";
+
+// packages/plugins/plugin-space/src/SpacePlugin.tsx
+import { effect, signal } from "@preact/signals-core";
+import React18 from "react";
+import { LayoutAction as LayoutAction2, NavigationAction as NavigationAction3, Surface as Surface2, firstIdInPart, openIds, parseGraphPlugin, parseIntentPlugin as parseIntentPlugin3, parseMetadataResolverPlugin, parseNavigationPlugin as parseNavigationPlugin2, resolvePlugin } from "@dxos/app-framework";
+import { EventSubscriptions } from "@dxos/async";
+import { isReactiveObject as isReactiveObject2 } from "@dxos/echo-schema";
+import { LocalStorageStore } from "@dxos/local-storage";
+import { log as log2 } from "@dxos/log";
+import { Migrations as Migrations2 } from "@dxos/migrations";
+import { parseAttentionPlugin } from "@dxos/plugin-attention";
+import { parseClientPlugin } from "@dxos/plugin-client";
+import { createExtension, isGraphNode, memoize as memoize2, toSignal } from "@dxos/plugin-graph";
+import { ObservabilityAction } from "@dxos/plugin-observability/meta";
+import { PublicKey as PublicKey2 } from "@dxos/react-client";
+import { Expando, Filter, SpaceState as SpaceState3, create as create2, fullyQualifiedId as fullyQualifiedId4, getSpace as getSpace4, getTypename as getTypename2, isEchoObject as isEchoObject2, isSpace as isSpace2, loadObjectReferences } from "@dxos/react-client/echo";
+import { Dialog } from "@dxos/react-ui";
+import { ClipboardProvider as ClipboardProvider2, InvitationManager, osTranslations } from "@dxos/shell/react";
+import { ComplexMap as ComplexMap2, nonNullable, reduceGroupBy } from "@dxos/util";
+
+// packages/plugins/plugin-space/src/components/AwaitingObject.tsx
+import { CheckCircle, CircleDashed, CircleNotch } from "@phosphor-icons/react";
+import React, { useEffect, useState } from "react";
+import { parseIntentPlugin, useResolvePlugin, parseNavigationPlugin, NavigationAction } from "@dxos/app-framework";
+import { useClient } from "@dxos/react-client";
+import { fullyQualifiedId, useQuery } from "@dxos/react-client/echo";
+import { Button, Toast, useTranslation } from "@dxos/react-ui";
+import { getSize, mx } from "@dxos/react-ui-theme";
+var WAIT_FOR_OBJECT_TIMEOUT = 18e4;
+var TOAST_TIMEOUT = 24e4;
+var AwaitingObject = ({ id }) => {
+  const [open, setOpen] = useState(true);
+  const [waiting, setWaiting] = useState(true);
+  const [found, setFound] = useState(false);
+  const { t } = useTranslation(SPACE_PLUGIN);
+  const intentPlugin = useResolvePlugin(parseIntentPlugin);
+  const navigationPlugin = useResolvePlugin(parseNavigationPlugin);
+  const client = useClient();
+  const objects = useQuery(client.spaces);
+  useEffect(() => {
+    if (!id) {
+      return;
+    }
+    const timeout = setTimeout(() => {
+      setWaiting(false);
+    }, WAIT_FOR_OBJECT_TIMEOUT);
+    () => clearTimeout(timeout);
+  }, [
+    id
+  ]);
+  useEffect(() => {
+    if (objects.findIndex((object) => fullyQualifiedId(object) === id) > -1) {
+      setFound(true);
+      if (navigationPlugin?.provides.location.active === id) {
+        setOpen(false);
+      }
+    }
+  }, [
+    id,
+    objects,
+    intentPlugin
+  ]);
+  const handleClose = async () => intentPlugin?.provides.intent.dispatch({
+    plugin: SPACE_PLUGIN,
+    action: SpaceAction.WAIT_FOR_OBJECT,
+    data: {
+      id: void 0
+    }
+  });
+  const handleNavigate = () => {
+    void intentPlugin?.provides.intent.dispatch({
+      action: NavigationAction.OPEN,
+      data: {
+        activeParts: {
+          main: [
+            id
+          ]
+        }
+      }
+    });
+    void handleClose();
+  };
+  return /* @__PURE__ */ React.createElement(Toast.Root, {
+    open,
+    duration: TOAST_TIMEOUT,
+    onOpenChange: setOpen
+  }, /* @__PURE__ */ React.createElement(Toast.Body, null, /* @__PURE__ */ React.createElement(Toast.Title, {
+    classNames: "flex items-center gap-2"
+  }, found ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(CheckCircle, {
+    className: getSize(5)
+  }), /* @__PURE__ */ React.createElement("span", null, t("found object label"))) : waiting ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(CircleNotch, {
+    className: mx(getSize(5), "animate-spin")
+  }), /* @__PURE__ */ React.createElement("span", null, t("waiting for object label"))) : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(CircleDashed, {
+    className: getSize(5)
+  }), /* @__PURE__ */ React.createElement("span", null, t("object not found label")))), /* @__PURE__ */ React.createElement(Toast.Description, null, t(found ? "found object description" : waiting ? "waiting for object description" : "object not found description"))), /* @__PURE__ */ React.createElement(Toast.Actions, null, found ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Toast.Action, {
+    altText: t("go to object alt"),
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Button, {
+    variant: "primary",
+    onClick: handleNavigate
+  }, t("go to object label"))), /* @__PURE__ */ React.createElement(Toast.Close, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Button, {
+    onClick: handleClose
+  }, t("close label", {
+    ns: "appkit"
+  })))) : /* @__PURE__ */ React.createElement(Toast.Close, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Button, {
+    onClick: handleClose
+  }, t(waiting ? "close label" : "confirm label", {
+    ns: "appkit"
+  })))));
+};
+
+// packages/plugins/plugin-space/src/components/CollectionMain.tsx
+import React2 from "react";
+import { useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { baseSurface, descriptionText, mx as mx2 } from "@dxos/react-ui-theme";
+var CollectionMain = ({ collection }) => {
+  const { t } = useTranslation2(SPACE_PLUGIN);
+  return /* @__PURE__ */ React2.createElement("div", {
+    role: "none",
+    className: mx2(baseSurface, "min-bs-screen is-full flex items-center justify-center p-8"),
+    "data-testid": "composer.firstRunMessage"
+  }, /* @__PURE__ */ React2.createElement("p", {
+    role: "alert",
+    className: mx2(descriptionText, "border border-dashed border-neutral-400/50 rounded-lg p-8 font-normal text-lg max-is-[24rem] break-words")
+  }, collection.name ?? t("unnamed collection label")));
+};
+
+// packages/plugins/plugin-space/src/components/CollectionSection.tsx
+import React3 from "react";
+import { useTranslation as useTranslation3 } from "@dxos/react-ui";
+var CollectionSection = ({ collection }) => {
+  const { t } = useTranslation3(SPACE_PLUGIN);
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: "min-bs-[3.5rem] grid grid-rows-subgrid grid-cols-subgrid items-center"
+  }, /* @__PURE__ */ React3.createElement("span", {
+    className: "truncate"
+  }, collection.name ?? t("unnamed collection label")));
+};
+
+// packages/plugins/plugin-space/src/components/EmptySpace.tsx
+import React4 from "react";
+import { useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { descriptionText as descriptionText2, mx as mx3 } from "@dxos/react-ui-theme";
+var EmptySpace = () => {
+  const { t } = useTranslation4(SPACE_PLUGIN);
+  return /* @__PURE__ */ React4.createElement("div", {
+    role: "none",
+    className: mx3("p-2 mli-2 mbe-2 text-center border border-dashed border-neutral-400/50 rounded-lg", descriptionText2)
+  }, t("empty space message"));
+};
+
+// packages/plugins/plugin-space/src/components/EmptyTree.tsx
+import React5 from "react";
+import { useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { descriptionText as descriptionText3, mx as mx4 } from "@dxos/react-ui-theme";
+var EmptyTree = () => {
+  const { t } = useTranslation5(SPACE_PLUGIN);
+  return /* @__PURE__ */ React5.createElement("div", {
+    role: "none",
+    className: mx4("p-2 mli-2 mbe-2 text-center border border-dashed border-neutral-400/50 rounded-lg", descriptionText3)
+  }, t("empty tree message"));
+};
+
+// packages/plugins/plugin-space/src/components/MenuFooter.tsx
+import { Planet } from "@phosphor-icons/react";
+import React6 from "react";
+import { getSpace as getSpace2 } from "@dxos/client/echo";
+import { useClient as useClient2 } from "@dxos/react-client";
+import { DropdownMenu, toLocalizedString, useTranslation as useTranslation6 } from "@dxos/react-ui";
+
+// packages/plugins/plugin-space/src/util.tsx
+import { NavigationAction as NavigationAction2 } from "@dxos/app-framework";
+import { create, isReactiveObject, getTypename, getSchema, getEchoObjectAnnotation, EXPANDO_TYPENAME } from "@dxos/echo-schema";
+import { invariant } from "@dxos/invariant";
+import { Migrations } from "@dxos/migrations";
+import { ACTION_TYPE, ACTION_GROUP_TYPE, actionGroupSymbol, getGraph, cleanup, memoize } from "@dxos/plugin-graph";
+import { SpaceState, fullyQualifiedId as fullyQualifiedId2, getSpace, isEchoObject, isSpace } from "@dxos/react-client/echo";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-space/src/util.tsx";
+var SPACES = `${SPACE_PLUGIN}-spaces`;
+var SPACE_TYPE = "dxos.org/type/Space";
+var COMPOSER_SPACE_LOCK = "dxos.org/plugin/space/lock";
+var SHARED = "shared-spaces";
+var EMPTY_ARRAY = [];
+var memoizeQuery = (spaceOrEcho, filter, options) => {
+  const key = isSpace(spaceOrEcho) ? spaceOrEcho.id : void 0;
+  const query = memoize(() => isSpace(spaceOrEcho) ? spaceOrEcho.db.query(filter, options) : spaceOrEcho?.query(filter, options), key);
+  const unsubscribe = memoize(() => query?.subscribe(), key);
+  cleanup(() => unsubscribe?.());
+  return query?.objects ?? EMPTY_ARRAY;
+};
+var getSpaceDisplayName = (space, { personal, namesCache = {} } = {}) => {
+  return space.state.get() === SpaceState.SPACE_READY && (space.properties.name?.length ?? 0) > 0 ? space.properties.name : namesCache[space.id] ? namesCache[space.id] : personal ? [
+    "personal space label",
+    {
+      ns: SPACE_PLUGIN
+    }
+  ] : [
+    "unnamed space label",
+    {
+      ns: SPACE_PLUGIN
+    }
+  ];
+};
+var getCollectionGraphNodePartials = ({ collection, space, resolve }) => {
+  return {
+    acceptPersistenceClass: /* @__PURE__ */ new Set([
+      "echo"
+    ]),
+    acceptPersistenceKey: /* @__PURE__ */ new Set([
+      space.id
+    ]),
+    role: "branch",
+    onRearrangeChildren: (nextOrder) => {
+      collection.objects = nextOrder.filter(isEchoObject);
+    },
+    onTransferStart: (child, index) => {
+      if (!collection.objects.includes(child.data)) {
+        if (typeof index !== "undefined") {
+          collection.objects.splice(index, 0, child.data);
+        } else {
+          collection.objects.push(child.data);
+        }
+      }
+    },
+    onTransferEnd: (child, destination) => {
+      const index = collection.objects.indexOf(child.data);
+      if (index > -1) {
+        collection.objects.splice(index, 1);
+      }
+    },
+    onCopy: async (child, index) => {
+      const newObject = await cloneObject(child.data, resolve);
+      space.db.add(newObject);
+      if (typeof index !== "undefined") {
+        collection.objects.splice(index, 0, newObject);
+      } else {
+        collection.objects.push(newObject);
+      }
+    }
+  };
+};
+var checkPendingMigration = (space) => {
+  return space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION || space.state.get() === SpaceState.SPACE_READY && !!Migrations.versionProperty && space.properties[Migrations.versionProperty] !== Migrations.targetVersion;
+};
+var constructSpaceNode = ({ space, personal, namesCache, resolve }) => {
+  const hasPendingMigration = checkPendingMigration(space);
+  const collection = space.state.get() === SpaceState.SPACE_READY && space.properties[CollectionType.typename];
+  const partials = space.state.get() === SpaceState.SPACE_READY && collection instanceof CollectionType ? getCollectionGraphNodePartials({
+    collection,
+    space,
+    resolve
+  }) : {};
+  return {
+    id: space.id,
+    type: SPACE_TYPE,
+    data: space,
+    properties: {
+      ...partials,
+      label: getSpaceDisplayName(space, {
+        personal,
+        namesCache
+      }),
+      description: space.state.get() === SpaceState.SPACE_READY && space.properties.description,
+      icon: "ph--planet--regular",
+      disabled: space.state.get() !== SpaceState.SPACE_READY || hasPendingMigration,
+      testId: "spacePlugin.space"
+    }
+  };
+};
+var constructSpaceActionGroups = ({ space, dispatch }) => {
+  const state = space.state.get();
+  const hasPendingMigration = checkPendingMigration(space);
+  const getId = (id) => `${id}/${space.id}`;
+  if (state !== SpaceState.SPACE_READY || hasPendingMigration) {
+    return [];
+  }
+  const collection = space.properties[CollectionType.typename];
+  const actions = [
+    {
+      id: getId(SpaceAction.ADD_OBJECT),
+      type: ACTION_GROUP_TYPE,
+      data: actionGroupSymbol,
+      properties: {
+        label: [
+          "create object in space label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--plus--regular",
+        disposition: "toolbar",
+        // TODO(wittjosiah): This is currently a navtree feature. Address this with cmd+k integration.
+        // mainAreaDisposition: 'in-flow',
+        menuType: "searchList",
+        testId: "spacePlugin.createObject"
+      },
+      nodes: [
+        {
+          id: getId(SpaceAction.ADD_OBJECT.replace("object", "collection")),
+          type: ACTION_TYPE,
+          data: () => dispatch([
+            {
+              plugin: SPACE_PLUGIN,
+              action: SpaceAction.ADD_OBJECT,
+              data: {
+                target: collection,
+                object: create(CollectionType, {
+                  objects: [],
+                  views: {}
+                })
+              }
+            },
+            {
+              action: NavigationAction2.OPEN
+            }
+          ]),
+          properties: {
+            label: [
+              "create collection label",
+              {
+                ns: SPACE_PLUGIN
+              }
+            ],
+            icon: "ph--cards-three--regular",
+            testId: "spacePlugin.createCollection"
+          }
+        }
+      ]
+    }
+  ];
+  return actions;
+};
+var constructSpaceActions = ({ space, dispatch, personal, migrating }) => {
+  const state = space.state.get();
+  const hasPendingMigration = checkPendingMigration(space);
+  const getId = (id) => `${id}/${space.id}`;
+  const actions = [];
+  if (hasPendingMigration) {
+    actions.push({
+      id: getId(SpaceAction.MIGRATE),
+      type: ACTION_GROUP_TYPE,
+      data: async () => {
+        await dispatch({
+          plugin: SPACE_PLUGIN,
+          action: SpaceAction.MIGRATE,
+          data: {
+            space
+          }
+        });
+      },
+      properties: {
+        label: [
+          "migrate space label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--database--regular",
+        disposition: "toolbar",
+        mainAreaDisposition: "in-flow",
+        disabled: migrating || Migrations.running(space)
+      }
+    });
+  }
+  if (state === SpaceState.SPACE_READY && !hasPendingMigration) {
+    const locked = space.properties[COMPOSER_SPACE_LOCK];
+    actions.push({
+      id: getId(SpaceAction.SHARE),
+      type: ACTION_TYPE,
+      data: async () => {
+        if (locked) {
+          return;
+        }
+        await dispatch({
+          plugin: SPACE_PLUGIN,
+          action: SpaceAction.SHARE,
+          data: {
+            spaceId: space.id
+          }
+        });
+      },
+      properties: {
+        label: [
+          "share space label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--users--regular",
+        disabled: locked,
+        keyBinding: {
+          macos: "meta+.",
+          windows: "alt+."
+        },
+        mainAreaDisposition: "absent"
+      }
+    }, {
+      id: locked ? getId(SpaceAction.UNLOCK) : getId(SpaceAction.LOCK),
+      type: ACTION_TYPE,
+      data: async () => {
+        await dispatch({
+          plugin: SPACE_PLUGIN,
+          action: locked ? SpaceAction.UNLOCK : SpaceAction.LOCK,
+          data: {
+            space
+          }
+        });
+      },
+      properties: {
+        label: [
+          locked ? "unlock space label" : "lock space label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: locked ? "ph--lock-simple-open--regular" : "ph--lock-simple--regular"
+      }
+    }, {
+      id: getId(SpaceAction.RENAME),
+      type: ACTION_TYPE,
+      data: async (params) => {
+        await dispatch({
+          plugin: SPACE_PLUGIN,
+          action: SpaceAction.RENAME,
+          data: {
+            space,
+            ...params
+          }
+        });
+      },
+      properties: {
+        label: [
+          "rename space label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--pencil-simple-line--regular",
+        keyBinding: {
+          macos: "shift+F6",
+          windows: "shift+F6"
+        },
+        mainAreaDisposition: "absent"
+      }
+    });
+  }
+  if (state !== SpaceState.SPACE_INACTIVE && !hasPendingMigration) {
+    actions.push({
+      id: getId(SpaceAction.CLOSE),
+      type: ACTION_TYPE,
+      data: async () => {
+        await dispatch({
+          plugin: SPACE_PLUGIN,
+          action: SpaceAction.CLOSE,
+          data: {
+            space
+          }
+        });
+      },
+      properties: {
+        label: [
+          "close space label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--x--regular",
+        mainAreaDisposition: "menu",
+        disabled: personal
+      }
+    });
+  }
+  if (state === SpaceState.SPACE_INACTIVE) {
+    actions.push({
+      id: getId(SpaceAction.OPEN),
+      type: ACTION_TYPE,
+      data: async () => {
+        await dispatch({
+          plugin: SPACE_PLUGIN,
+          action: SpaceAction.OPEN,
+          data: {
+            space
+          }
+        });
+      },
+      properties: {
+        label: [
+          "open space label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--clock-counter-clockwise--regular",
+        disposition: "toolbar",
+        mainAreaDisposition: "in-flow"
+      }
+    });
+  }
+  return actions;
+};
+var createObjectNode = ({ object, space, resolve }) => {
+  const type = getTypename(object);
+  if (!type) {
+    return void 0;
+  }
+  const metadata = resolve(type);
+  if (Object.keys(metadata).length === 0) {
+    return void 0;
+  }
+  const partials = object instanceof CollectionType ? getCollectionGraphNodePartials({
+    collection: object,
+    space,
+    resolve
+  }) : metadata.graphProps;
+  return {
+    id: fullyQualifiedId2(object),
+    type,
+    data: object,
+    properties: {
+      ...partials,
+      label: metadata.label?.(object) || object.name || metadata.placeholder || [
+        "unnamed object label",
+        {
+          ns: SPACE_PLUGIN
+        }
+      ],
+      icon: metadata.icon ?? "ph--placeholder--regular",
+      testId: "spacePlugin.object",
+      persistenceClass: "echo",
+      persistenceKey: space?.id
+    }
+  };
+};
+var constructObjectActionGroups = ({ object, dispatch }) => {
+  if (!(object instanceof CollectionType)) {
+    return [];
+  }
+  const collection = object;
+  const getId = (id) => `${id}/${fullyQualifiedId2(object)}`;
+  const actions = [
+    {
+      id: getId(SpaceAction.ADD_OBJECT),
+      type: ACTION_GROUP_TYPE,
+      data: actionGroupSymbol,
+      properties: {
+        label: [
+          "create object in collection label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--plus--regular",
+        disposition: "toolbar",
+        // TODO(wittjosiah): This is currently a navtree feature. Address this with cmd+k integration.
+        // mainAreaDisposition: 'in-flow',
+        menuType: "searchList",
+        testId: "spacePlugin.createObject"
+      },
+      nodes: [
+        {
+          id: getId(SpaceAction.ADD_OBJECT.replace("object", "collection")),
+          type: ACTION_TYPE,
+          data: () => dispatch([
+            {
+              plugin: SPACE_PLUGIN,
+              action: SpaceAction.ADD_OBJECT,
+              data: {
+                target: collection,
+                object: create(CollectionType, {
+                  objects: [],
+                  views: {}
+                })
+              }
+            },
+            {
+              action: NavigationAction2.OPEN
+            }
+          ]),
+          properties: {
+            label: [
+              "create collection label",
+              {
+                ns: SPACE_PLUGIN
+              }
+            ],
+            icon: "ph--cards-three--regular",
+            testId: "spacePlugin.createCollection"
+          }
+        }
+      ]
+    }
+  ];
+  return actions;
+};
+var constructObjectActions = ({ node, dispatch }) => {
+  const object = node.data;
+  const getId = (id) => `${id}/${fullyQualifiedId2(object)}`;
+  const actions = [
+    {
+      id: getId(SpaceAction.RENAME_OBJECT),
+      type: ACTION_TYPE,
+      data: async (params) => {
+        await dispatch({
+          action: SpaceAction.RENAME_OBJECT,
+          data: {
+            object,
+            ...params
+          }
+        });
+      },
+      properties: {
+        label: [
+          object instanceof CollectionType ? "rename collection label" : "rename object label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--pencil-simple-line--regular",
+        // TODO(wittjosiah): Doesn't work.
+        // keyBinding: 'shift+F6',
+        testId: "spacePlugin.renameObject"
+      }
+    },
+    {
+      id: getId(SpaceAction.REMOVE_OBJECT),
+      type: ACTION_TYPE,
+      data: async () => {
+        const graph = getGraph(node);
+        const collection = graph.nodes(node, {
+          relation: "inbound"
+        }).find(({ data }) => data instanceof CollectionType)?.data;
+        await dispatch([
+          {
+            action: SpaceAction.REMOVE_OBJECT,
+            data: {
+              object,
+              collection
+            }
+          }
+        ]);
+      },
+      properties: {
+        label: [
+          object instanceof CollectionType ? "delete collection label" : "delete object label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--trash--regular",
+        keyBinding: object instanceof CollectionType ? void 0 : "shift+meta+Backspace",
+        testId: "spacePlugin.deleteObject"
+      }
+    },
+    {
+      id: getId("copy-link"),
+      type: ACTION_TYPE,
+      data: async () => {
+        const url = `${window.location.origin}/${fullyQualifiedId2(object)}`;
+        await navigator.clipboard.writeText(url);
+      },
+      properties: {
+        label: [
+          "copy link label",
+          {
+            ns: SPACE_PLUGIN
+          }
+        ],
+        icon: "ph--link--regular",
+        testId: "spacePlugin.copyLink"
+      }
+    }
+  ];
+  return actions;
+};
+var getActiveSpace = (graph, active) => {
+  if (!active) {
+    return;
+  }
+  const node = graph.findNode(active);
+  if (!node || !isReactiveObject(node.data)) {
+    return;
+  }
+  return getSpace(node.data);
+};
+var getNestedObjects = async (object, resolve) => {
+  const type = getTypename(object);
+  if (!type) {
+    return [];
+  }
+  const metadata = resolve(type);
+  const loadReferences = metadata.loadReferences;
+  if (typeof loadReferences !== "function") {
+    return [];
+  }
+  const objects = await loadReferences(object);
+  const nested = await Promise.all(objects.map((object2) => getNestedObjects(object2, resolve)));
+  return [
+    ...objects,
+    ...nested.flat()
+  ];
+};
+var cloneObject = async (object, resolve) => {
+  const schema = getSchema(object);
+  const typename = schema ? getEchoObjectAnnotation(schema)?.typename ?? EXPANDO_TYPENAME : EXPANDO_TYPENAME;
+  const metadata = resolve(typename);
+  const serializer = metadata.serializer;
+  invariant(serializer, `No serializer for type: ${typename}`, {
+    F: __dxlog_file,
+    L: 604,
+    S: void 0,
+    A: [
+      "serializer",
+      "`No serializer for type: ${typename}`"
+    ]
+  });
+  const content = await serializer.serialize({
+    object
+  });
+  return serializer.deserialize({
+    content,
+    newId: true
+  });
+};
+
+// packages/plugins/plugin-space/src/components/MenuFooter.tsx
+var MenuFooter = ({ object }) => {
+  const { t } = useTranslation6(SPACE_PLUGIN);
+  const client = useClient2();
+  const space = getSpace2(object);
+  const spaceName = space ? getSpaceDisplayName(space, {
+    personal: client.spaces.default === space
+  }) : "";
+  return space ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(DropdownMenu.Separator, null), /* @__PURE__ */ React6.createElement(DropdownMenu.GroupLabel, null, t("menu footer label")), /* @__PURE__ */ React6.createElement("dl", {
+    className: "pis-2 mbe-2 text-xs grid grid-cols-[max-content_1fr] gap-2"
+  }, /* @__PURE__ */ React6.createElement("dt", {
+    className: "uppercase text-[.75em] tracking-wide font-medium mbs-px self-start"
+  }, t("location label")), /* @__PURE__ */ React6.createElement("dd", {
+    className: "line-clamp-3"
+  }, /* @__PURE__ */ React6.createElement(Planet, {
+    className: "inline-block mie-1"
+  }), toLocalizedString(spaceName, t)))) : null;
+};
+
+// packages/plugins/plugin-space/src/components/MissingObject.tsx
+import React7, { useEffect as useEffect2, useState as useState2 } from "react";
+import { parseIntentPlugin as parseIntentPlugin2, useResolvePlugin as useResolvePlugin2 } from "@dxos/app-framework";
+import { Status, useTranslation as useTranslation7 } from "@dxos/react-ui";
+import { baseSurface as baseSurface2, descriptionText as descriptionText4, mx as mx5 } from "@dxos/react-ui-theme";
+var WAIT_FOR_OBJECT_TIMEOUT2 = 1e3;
+var MissingObject = ({ id }) => {
+  const { t } = useTranslation7(SPACE_PLUGIN);
+  const [waiting, setWaiting] = useState2(false);
+  const intentPlugin = useResolvePlugin2(parseIntentPlugin2);
+  useEffect2(() => {
+    if (!intentPlugin) {
+      return;
+    }
+    const timeout = setTimeout(async () => {
+      setWaiting(true);
+      await intentPlugin.provides.intent.dispatch({
+        plugin: SPACE_PLUGIN,
+        action: SpaceAction.WAIT_FOR_OBJECT,
+        data: {
+          id
+        }
+      });
+    }, WAIT_FOR_OBJECT_TIMEOUT2);
+    return () => clearTimeout(timeout);
+  }, [
+    intentPlugin,
+    id
+  ]);
+  return /* @__PURE__ */ React7.createElement("div", {
+    role: "none",
+    className: mx5(baseSurface2, "min-bs-screen is-full flex items-center justify-center p-8")
+  }, waiting ? /* @__PURE__ */ React7.createElement("p", {
+    role: "alert",
+    className: mx5(descriptionText4, "border border-dashed border-neutral-400/50 rounded-lg flex items-center justify-center p-8 font-normal text-lg")
+  }, t("missing object message")) : /* @__PURE__ */ React7.createElement(Status, {
+    indeterminate: true,
+    "aria-label": "Initializing"
+  }));
+};
+
+// packages/plugins/plugin-space/src/components/PersistenceStatus.tsx
+import { ArrowsCounterClockwise, CheckCircle as CheckCircle2, Warning } from "@phosphor-icons/react";
+import React8, { useEffect as useEffect3, useState as useState3 } from "react";
+import { debounce } from "@dxos/async";
+import { Tooltip, useTranslation as useTranslation8 } from "@dxos/react-ui";
+import { getSize as getSize2, mx as mx6, staticPlaceholderText, warningText } from "@dxos/react-ui-theme";
+var Status2;
+(function(Status3) {
+  Status3[Status3["PERSISTED_LOCALLY"] = 0] = "PERSISTED_LOCALLY";
+  Status3[Status3["PENDING"] = 1] = "PENDING";
+  Status3[Status3["ERROR"] = 2] = "ERROR";
+})(Status2 || (Status2 = {}));
+var PersistenceStatus = ({ db }) => {
+  const { t } = useTranslation8(SPACE_PLUGIN);
+  const [displayMessage, setDisplayMessage] = useState3(false);
+  const [status, naturalSetStatus] = useState3(0);
+  const [prevStatus, setPrevStatus] = useState3(0);
+  const _setStatus = debounce(naturalSetStatus, 500);
+  useEffect3(() => {
+    setPrevStatus(status);
+    if (prevStatus !== status && status === 0) {
+      setDisplayMessage(true);
+      const timeout = setTimeout(() => setDisplayMessage(false), 5e3);
+      return () => clearTimeout(timeout);
+    }
+  }, [
+    status
+  ]);
+  switch (status) {
+    case 2:
+      return /* @__PURE__ */ React8.createElement("div", {
+        className: "flex items-center"
+      }, /* @__PURE__ */ React8.createElement(Warning, {
+        className: mx6(getSize2(4), "me-1")
+      }), /* @__PURE__ */ React8.createElement("span", {
+        className: mx6("text-sm", warningText)
+      }, t("persistence error label")));
+    case 1:
+      return /* @__PURE__ */ React8.createElement("div", {
+        className: "flex items-center"
+      }, /* @__PURE__ */ React8.createElement(ArrowsCounterClockwise, {
+        className: mx6(getSize2(4), "me-1")
+      }), /* @__PURE__ */ React8.createElement("span", {
+        className: mx6("text-sm", staticPlaceholderText)
+      }, t("persistence pending label")));
+    case 0:
+    default:
+      return /* @__PURE__ */ React8.createElement(Tooltip.Root, {
+        delayDuration: 400
+      }, /* @__PURE__ */ React8.createElement(Tooltip.Trigger, {
+        role: "status",
+        className: "flex items-center"
+      }, /* @__PURE__ */ React8.createElement(CheckCircle2, {
+        className: mx6(getSize2(4), "me-1")
+      }), displayMessage && /* @__PURE__ */ React8.createElement("span", {
+        className: mx6("text-sm", staticPlaceholderText)
+      }, t("persisted locally label"))), /* @__PURE__ */ React8.createElement(Tooltip.Portal, null, /* @__PURE__ */ React8.createElement(Tooltip.Content, {
+        classNames: "z-10"
+      }, t("persisted locally message"), /* @__PURE__ */ React8.createElement(Tooltip.Arrow, null))));
+  }
+};
+
+// packages/plugins/plugin-space/src/components/PopoverRenameObject.tsx
+import React9, { useCallback, useRef, useState as useState4 } from "react";
+import { log } from "@dxos/log";
+import { Button as Button2, Input, Popover, useTranslation as useTranslation9 } from "@dxos/react-ui";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-space/src/components/PopoverRenameObject.tsx";
+var PopoverRenameObject = ({ object: obj }) => {
+  const { t } = useTranslation9(SPACE_PLUGIN);
+  const doneButton = useRef(null);
+  const object = obj;
+  const [name, setName] = useState4(object.name || object.title || "");
+  const handleDone = useCallback(() => {
+    try {
+      object.name = name;
+    } catch {
+      try {
+        object.title = name;
+      } catch (err) {
+        log.error("Failed to rename object", {
+          err
+        }, {
+          F: __dxlog_file2,
+          L: 28,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+  }, [
+    object,
+    name
+  ]);
+  return /* @__PURE__ */ React9.createElement("div", {
+    role: "none",
+    className: "p-1 flex gap-2"
+  }, /* @__PURE__ */ React9.createElement("div", {
+    role: "none",
+    className: "flex-1"
+  }, /* @__PURE__ */ React9.createElement(Input.Root, null, /* @__PURE__ */ React9.createElement(Input.Label, {
+    srOnly: true
+  }, t("object name label")), /* @__PURE__ */ React9.createElement(Input.TextInput, {
+    placeholder: t("object title placeholder"),
+    value: name,
+    "data-testid": "spacePlugin.renameObject.input",
+    onChange: ({ target: { value } }) => setName(value),
+    onKeyDown: ({ key }) => key === "Enter" && doneButton.current?.click()
+  }))), /* @__PURE__ */ React9.createElement(Popover.Close, {
+    asChild: true
+  }, /* @__PURE__ */ React9.createElement(Button2, {
+    ref: doneButton,
+    classNames: "self-stretch",
+    onClick: handleDone
+  }, t("done label", {
+    ns: "os"
+  }))));
+};
+
+// packages/plugins/plugin-space/src/components/PopoverRenameSpace.tsx
+import React10, { useCallback as useCallback2, useRef as useRef2, useState as useState5 } from "react";
+import { Button as Button3, Input as Input2, Popover as Popover2, useTranslation as useTranslation10 } from "@dxos/react-ui";
+var PopoverRenameSpace = ({ space }) => {
+  const { t } = useTranslation10(SPACE_PLUGIN);
+  const doneButton = useRef2(null);
+  const [name, setName] = useState5(space.properties.name ?? "");
+  const handleDone = useCallback2(() => {
+    space.properties.name = name;
+  }, [
+    space,
+    name
+  ]);
+  return /* @__PURE__ */ React10.createElement("div", {
+    role: "none",
+    className: "p-1 flex gap-2"
+  }, /* @__PURE__ */ React10.createElement("div", {
+    role: "none",
+    className: "flex-1"
+  }, /* @__PURE__ */ React10.createElement(Input2.Root, null, /* @__PURE__ */ React10.createElement(Input2.Label, {
+    srOnly: true
+  }, t("space name label")), /* @__PURE__ */ React10.createElement(Input2.TextInput, {
+    defaultValue: space.properties.name ?? "",
+    placeholder: t("unnamed space label"),
+    onChange: ({ target: { value } }) => setName(value),
+    // TODO(wittjosiah): Ideally this should access the popover context to close the popover.
+    //   Currently this is not possible because Radix does not expose the popover context.
+    onKeyDown: ({ key }) => key === "Enter" && doneButton.current?.click()
+  }))), /* @__PURE__ */ React10.createElement(Popover2.Close, {
+    asChild: true
+  }, /* @__PURE__ */ React10.createElement(Button3, {
+    ref: doneButton,
+    classNames: "self-stretch",
+    onClick: handleDone
+  }, t("done label", {
+    ns: "os"
+  }))));
+};
+
+// packages/plugins/plugin-space/src/components/ShareSpaceButton.tsx
+import React11 from "react";
+import { useIntentDispatcher } from "@dxos/app-framework";
+import { Button as Button4, useTranslation as useTranslation11 } from "@dxos/react-ui";
+var ShareSpaceButton = ({ spaceId }) => {
+  const dispatch = useIntentDispatcher();
+  return /* @__PURE__ */ React11.createElement(ShareSpaceButtonImpl, {
+    onClick: () => dispatch({
+      action: SpaceAction.SHARE,
+      data: {
+        spaceId
+      }
+    })
+  });
+};
+var ShareSpaceButtonImpl = ({ onClick }) => {
+  const { t } = useTranslation11(SPACE_PLUGIN);
+  return /* @__PURE__ */ React11.createElement(Button4, {
+    "data-testid": "spacePlugin.shareSpaceButton",
+    onClick,
+    classNames: "mli-1"
+  }, t("share space label"));
+};
+
+// packages/plugins/plugin-space/src/components/SpaceMain/SpaceMain.tsx
+import { Command } from "@phosphor-icons/react";
+import React13 from "react";
+import { Surface } from "@dxos/app-framework";
+import { SpaceState as SpaceState2 } from "@dxos/react-client/echo";
+import { Main, useTranslation as useTranslation13 } from "@dxos/react-ui";
+import { getSize as getSize4, mx as mx8, topbarBlockPaddingStart } from "@dxos/react-ui-theme";
+import { ClipboardProvider } from "@dxos/shell/react";
+
+// packages/plugins/plugin-space/src/components/SpaceMain/SpaceMembersSection.tsx
+import { CaretDown, Check, UserPlus, UsersThree } from "@phosphor-icons/react";
+import React12, { useCallback as useCallback3, useState as useState6 } from "react";
+import { LayoutAction, useIntent } from "@dxos/app-framework";
+import { useMembers, SpaceMember, useSpaceInvitations } from "@dxos/react-client/echo";
+import { InvitationEncoder } from "@dxos/react-client/invitations";
+import { Invitation } from "@dxos/react-client/invitations";
+import { Button as Button5, ButtonGroup, DropdownMenu as DropdownMenu2, List, useTranslation as useTranslation12 } from "@dxos/react-ui";
+import { descriptionText as descriptionText5, getSize as getSize3, mx as mx7 } from "@dxos/react-ui-theme";
+import { InvitationListItem, IdentityListItem } from "@dxos/shell/react";
+var activeActionKeyStorageKey = "dxos:react-shell/space-manager/active-action";
+var Presence = SpaceMember.PresenceState;
+var handleCreateInvitationUrl = (invitationCode) => `${origin}?spaceInvitationCode=${invitationCode}`;
+var SpaceMemberList = ({ members }) => {
+  return members.length > 0 ? /* @__PURE__ */ React12.createElement(List, {
+    classNames: "col-start-2 col-end-5 gap-y-1 grid grid-cols-subgrid items-center"
+  }, members.map((member) => /* @__PURE__ */ React12.createElement(IdentityListItem, {
+    classNames: "contents",
+    key: member.identity.identityKey.toHex(),
+    identity: member.identity,
+    presence: member.presence
+  }))) : null;
+};
+var SpaceMembersSection = ({ space }) => {
+  const { t } = useTranslation12(SPACE_PLUGIN);
+  const invitations = useSpaceInvitations(space.key);
+  const { dispatch } = useIntent();
+  const handleCloseDialog = () => dispatch({
+    action: LayoutAction.SET_LAYOUT,
+    data: {
+      element: "dialog",
+      state: false
+    }
+  });
+  const handleInvitationSelect = ({ invitation: invitationObservable }) => {
+    const invitation = invitationObservable.get();
+    void dispatch({
+      action: LayoutAction.SET_LAYOUT,
+      data: {
+        element: "dialog",
+        component: "dxos.org/plugin/space/InvitationManagerDialog",
+        subject: {
+          invitationUrl: handleCreateInvitationUrl(InvitationEncoder.encode(invitation)),
+          send: handleCloseDialog,
+          status: invitation.state,
+          type: invitation.type,
+          authCode: invitation.authCode,
+          id: invitation.invitationId
+        }
+      }
+    });
+  };
+  const inviteActions = {
+    inviteOne: {
+      label: t("invite one label", {
+        ns: "os"
+      }),
+      description: t("invite one description", {
+        ns: "os"
+      }),
+      icon: UserPlus,
+      onClick: useCallback3(() => {
+        space.share?.({
+          type: Invitation.Type.INTERACTIVE,
+          authMethod: Invitation.AuthMethod.SHARED_SECRET
+        });
+      }, [
+        space
+      ])
+    },
+    inviteMany: {
+      label: t("invite many label", {
+        ns: "os"
+      }),
+      description: t("invite many description", {
+        ns: "os"
+      }),
+      icon: UsersThree,
+      onClick: useCallback3(() => {
+        space.share?.({
+          type: Invitation.Type.INTERACTIVE,
+          authMethod: Invitation.AuthMethod.NONE,
+          multiUse: true
+        });
+      }, [
+        space
+      ])
+    }
+  };
+  const [activeActionKey, setInternalActiveActionKey] = useState6(localStorage.getItem(activeActionKeyStorageKey) ?? "inviteOne");
+  const setActiveActionKey = (nextKey) => {
+    setInternalActiveActionKey(nextKey);
+    localStorage.setItem(activeActionKeyStorageKey, nextKey);
+  };
+  const activeAction = inviteActions[activeActionKey] ?? {};
+  const members = useMembers(space.key).reduce((acc, member) => {
+    acc[member.presence].push(member);
+    return acc;
+  }, {
+    [Presence.ONLINE]: [],
+    [Presence.OFFLINE]: []
+  });
+  return /* @__PURE__ */ React12.createElement("section", {
+    className: "mbe-4 col-span-3 grid gap-y-2 grid-cols-subgrid auto-rows-min"
+  }, /* @__PURE__ */ React12.createElement("h2", {
+    className: "contents"
+  }, /* @__PURE__ */ React12.createElement(UsersThree, {
+    weight: "duotone",
+    className: mx7(getSize3(5), "place-self-center")
+  }), /* @__PURE__ */ React12.createElement("span", {
+    className: "text-lg col-span-2"
+  }, t("space members label"))), /* @__PURE__ */ React12.createElement("h3", {
+    className: "col-start-2 col-span-3 text-sm italic text-description"
+  }, t("invitations heading")), invitations.length > 0 && /* @__PURE__ */ React12.createElement(List, {
+    classNames: "col-start-2 col-span-2 gap-y-2 grid grid-cols-[var(--rail-size)_1fr_var(--rail-action)_var(--rail-action)]"
+  }, invitations.map((invitation) => /* @__PURE__ */ React12.createElement(InvitationListItem, {
+    reverseEffects: true,
+    classNames: "pis-0 pie-0 gap-0 col-span-4 grid grid-cols-subgrid",
+    key: invitation.get().invitationId,
+    invitation,
+    send: handleInvitationSelect,
+    createInvitationUrl: handleCreateInvitationUrl
+  }))), /* @__PURE__ */ React12.createElement(ButtonGroup, {
+    classNames: "col-start-2 col-end-4 grid grid-cols-[1fr_var(--rail-action)] place-self-grow gap-px"
+  }, /* @__PURE__ */ React12.createElement(Button5, {
+    classNames: "gap-2",
+    onClick: activeAction.onClick
+  }, /* @__PURE__ */ React12.createElement(activeAction.icon, {
+    className: getSize3(5)
+  }), /* @__PURE__ */ React12.createElement("span", null, t(activeAction.label, {
+    ns: "os"
+  }))), /* @__PURE__ */ React12.createElement(DropdownMenu2.Root, null, /* @__PURE__ */ React12.createElement(DropdownMenu2.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React12.createElement(Button5, {
+    classNames: "pli-0"
+  }, /* @__PURE__ */ React12.createElement(CaretDown, {
+    className: getSize3(4)
+  }))), /* @__PURE__ */ React12.createElement(DropdownMenu2.Content, null, /* @__PURE__ */ React12.createElement(DropdownMenu2.Viewport, null, Object.entries(inviteActions).map(([id, action]) => {
+    return /* @__PURE__ */ React12.createElement(DropdownMenu2.CheckboxItem, {
+      key: id,
+      "aria-labelledby": `${id}__label`,
+      "aria-describedby": `${id}__description`,
+      checked: activeActionKey === id,
+      onCheckedChange: (checked) => checked && setActiveActionKey(id),
+      classNames: "gap-2"
+    }, action.icon && /* @__PURE__ */ React12.createElement(action.icon, {
+      className: getSize3(5)
+    }), /* @__PURE__ */ React12.createElement("div", {
+      role: "none",
+      className: "flex-1 min-is-0 space-b-1"
+    }, /* @__PURE__ */ React12.createElement("p", {
+      id: `${id}__label`
+    }, t(action.label, {
+      ns: "os"
+    })), action.description && /* @__PURE__ */ React12.createElement("p", {
+      id: `${id}__description`,
+      className: descriptionText5
+    }, t(action.description, {
+      ns: "os"
+    }))), /* @__PURE__ */ React12.createElement(DropdownMenu2.ItemIndicator, {
+      asChild: true
+    }, /* @__PURE__ */ React12.createElement(Check, {
+      className: getSize3(4)
+    })));
+  })), /* @__PURE__ */ React12.createElement(DropdownMenu2.Arrow, null)))), members[Presence.ONLINE].length + members[Presence.OFFLINE].length < 1 ? /* @__PURE__ */ React12.createElement("p", {
+    className: mx7(descriptionText5, "text-center is-full mlb-2")
+  }, t("empty space members message", {
+    ns: "os"
+  })) : /* @__PURE__ */ React12.createElement(React12.Fragment, null, /* @__PURE__ */ React12.createElement("h3", {
+    className: "col-start-2 col-end-5 text-sm italic text-description"
+  }, t("active space members heading", {
+    count: members[Presence.ONLINE].length
+  })), /* @__PURE__ */ React12.createElement(SpaceMemberList, {
+    members: members[Presence.ONLINE]
+  }), /* @__PURE__ */ React12.createElement("h3", {
+    className: "col-start-2 col-end-5 text-sm italic text-description"
+  }, t("inactive space members heading", {
+    count: members[Presence.OFFLINE].length
+  })), /* @__PURE__ */ React12.createElement(SpaceMemberList, {
+    members: members[Presence.OFFLINE]
+  })));
+};
+
+// packages/plugins/plugin-space/src/components/SpaceMain/SpaceMain.tsx
+var KeyShortcuts = () => {
+  const { t } = useTranslation13(SPACE_PLUGIN);
+  return /* @__PURE__ */ React13.createElement("section", {
+    className: "mbe-4 col-span-4 md:col-start-5 md:col-end-7 grid grid-cols-subgrid gap-y-2 auto-rows-min"
+  }, /* @__PURE__ */ React13.createElement("h2", {
+    className: "contents"
+  }, /* @__PURE__ */ React13.createElement(Command, {
+    weight: "duotone",
+    className: mx8(getSize4(5), "place-self-center")
+  }), /* @__PURE__ */ React13.createElement("span", {
+    className: "text-lg col-span-2 md:col-span-1"
+  }, t("keyshortcuts label"))), /* @__PURE__ */ React13.createElement("div", {
+    role: "none",
+    className: "col-start-2 col-end-4 md:col-end-5 pie-2"
+  }, /* @__PURE__ */ React13.createElement(Surface, {
+    role: "keyshortcuts"
+  })));
+};
+var spaceMainLayout = "grid gap-y-2 auto-rows-min before:bs-2 before:col-span-5 grid-cols-[var(--rail-size)_var(--rail-size)_1fr_var(--rail-size)] md:grid-cols-[var(--rail-size)_var(--rail-size)_minmax(max-content,1fr)_var(--rail-size)_var(--rail-size)_minmax(max-content,2fr)_var(--rail-size)]";
+var SpaceMain = ({ space, role }) => {
+  const state = space.state.get();
+  const ready = state === SpaceState2.SPACE_READY;
+  const Root = role === "main" ? Main.Content : "div";
+  return /* @__PURE__ */ React13.createElement(ClipboardProvider, null, /* @__PURE__ */ React13.createElement(Root, {
+    ...role === "main" ? {
+      classNames: [
+        topbarBlockPaddingStart,
+        "min-bs-dvh",
+        spaceMainLayout
+      ]
+    } : {
+      role: "none",
+      className: mx8(topbarBlockPaddingStart, "row-span-2", spaceMainLayout)
+    },
+    "data-testid": `spacePlugin.${role}`,
+    "data-isready": ready ? "true" : "false"
+  }, ready && /* @__PURE__ */ React13.createElement(SpaceMembersSection, {
+    space
+  }), /* @__PURE__ */ React13.createElement(KeyShortcuts, null)));
+};
+
+// packages/plugins/plugin-space/src/components/SpacePresence.tsx
+import React14, { useCallback as useCallback4, useEffect as useEffect4, useState as useState7 } from "react";
+import { usePlugin } from "@dxos/app-framework";
+import { generateName } from "@dxos/display-name";
+import { PublicKey, useClient as useClient3 } from "@dxos/react-client";
+import { getSpace as getSpace3, useMembers as useMembers2, fullyQualifiedId as fullyQualifiedId3 } from "@dxos/react-client/echo";
+import { useIdentity } from "@dxos/react-client/halo";
+import { Avatar, AvatarGroup, AvatarGroupItem, Tooltip as Tooltip2, useDensityContext, useTranslation as useTranslation14, List as List2, ListItem, useDefaultValue } from "@dxos/react-ui";
+import { AttentionGlyph } from "@dxos/react-ui-attention";
+import { ComplexMap, keyToFallback } from "@dxos/util";
+var REFRESH_INTERVAL = 5e3;
+var ACTIVITY_DURATION = 3e4;
+var noViewers = new ComplexMap(PublicKey.hash);
+var getName = (identity) => identity.profile?.displayName ?? generateName(identity.identityKey.toHex());
+var SpacePresence = ({ object, spaceKey }) => {
+  const density = useDensityContext();
+  const spacePlugin = usePlugin(SPACE_PLUGIN);
+  const client = useClient3();
+  const identity = useIdentity();
+  const space = spaceKey ? client.spaces.get(spaceKey) : getSpace3(object);
+  const spaceMembers = useMembers2(space?.key);
+  const [_moment, setMoment] = useState7(Date.now());
+  useEffect4(() => {
+    const interval = setInterval(() => setMoment(Date.now()), REFRESH_INTERVAL);
+    return () => clearInterval(interval);
+  }, []);
+  const memberOnline = useCallback4((member) => member.presence === 1, []);
+  const memberIsNotSelf = useCallback4((member) => !identity?.identityKey.equals(member.identity.identityKey), [
+    identity?.identityKey
+  ]);
+  if (!identity || !spacePlugin || !space) {
+    return null;
+  }
+  const spaceState = spacePlugin.provides.space;
+  const currentObjectViewers = spaceState.viewersByObject[fullyQualifiedId3(object)] ?? noViewers;
+  const membersForObject = spaceMembers.filter((member) => memberOnline(member) && memberIsNotSelf(member)).filter((member) => currentObjectViewers.has(member.identity.identityKey)).map((member) => {
+    const objectView = currentObjectViewers.get(member.identity.identityKey);
+    const lastSeen = objectView?.lastSeen ?? -Infinity;
+    const currentlyAttended = objectView?.currentlyAttended ?? false;
+    return {
+      ...member,
+      currentlyAttended,
+      lastSeen
+    };
+  }).toSorted((a, b) => a.lastSeen - b.lastSeen);
+  return density === "fine" ? /* @__PURE__ */ React14.createElement(SmallPresence, {
+    count: membersForObject.length
+  }) : /* @__PURE__ */ React14.createElement(FullPresence, {
+    members: membersForObject
+  });
+};
+var FullPresence = (props) => {
+  const { size = 9, onMemberClick } = props;
+  const members = useDefaultValue(props.members, []);
+  if (members.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React14.createElement(AvatarGroup.Root, {
+    size,
+    classNames: "mbs-2 mie-4",
+    "data-testid": "spacePlugin.presence"
+  }, members.slice(0, 3).map((member, i) => /* @__PURE__ */ React14.createElement(Tooltip2.Root, {
+    key: member.identity.identityKey.toHex()
+  }, /* @__PURE__ */ React14.createElement(Tooltip2.Trigger, null, /* @__PURE__ */ React14.createElement(PrensenceAvatar, {
+    identity: member.identity,
+    group: true,
+    match: member.currentlyAttended,
+    index: members.length - i,
+    onClick: () => onMemberClick?.(member)
+  })), /* @__PURE__ */ React14.createElement(Tooltip2.Portal, null, /* @__PURE__ */ React14.createElement(Tooltip2.Content, {
+    side: "bottom"
+  }, /* @__PURE__ */ React14.createElement("span", null, getName(member.identity)), /* @__PURE__ */ React14.createElement(Tooltip2.Arrow, null))))), members.length > 3 && /* @__PURE__ */ React14.createElement(Tooltip2.Root, null, /* @__PURE__ */ React14.createElement(Tooltip2.Trigger, null, /* @__PURE__ */ React14.createElement(AvatarGroupItem.Root, {
+    status: "inactive"
+  }, /* @__PURE__ */ React14.createElement(Avatar.Frame, {
+    style: {
+      zIndex: members.length - 4
+    }
+  }, /* @__PURE__ */ React14.createElement(Avatar.Fallback, {
+    text: `+${members.length - 3}`
+  })))), /* @__PURE__ */ React14.createElement(Tooltip2.Portal, null, /* @__PURE__ */ React14.createElement(Tooltip2.Content, {
+    side: "bottom"
+  }, /* @__PURE__ */ React14.createElement(Tooltip2.Arrow, null), /* @__PURE__ */ React14.createElement(List2, {
+    classNames: "max-h-56 overflow-y-auto"
+  }, members.map((member) => /* @__PURE__ */ React14.createElement(ListItem.Root, {
+    key: member.identity.identityKey.toHex(),
+    classNames: "flex gap-2 items-center cursor-pointer mbe-2",
+    onClick: () => onMemberClick?.(member),
+    "data-testid": "identity-list-item"
+  }, /* @__PURE__ */ React14.createElement(PrensenceAvatar, {
+    identity: member.identity,
+    showName: true,
+    match: member.currentlyAttended
+  }))))))));
+};
+var PrensenceAvatar = ({ identity, showName, match, group, index, onClick }) => {
+  const Root = group ? AvatarGroupItem.Root : Avatar.Root;
+  const status = match ? "current" : "active";
+  const fallbackValue = keyToFallback(identity.identityKey);
+  return /* @__PURE__ */ React14.createElement(Root, {
+    status,
+    hue: identity.profile?.data?.hue || fallbackValue.hue
+  }, /* @__PURE__ */ React14.createElement(Avatar.Frame, {
+    "data-testid": "spacePlugin.presence.member",
+    "data-status": status,
+    ...index ? {
+      style: {
+        zIndex: index
+      }
+    } : {},
+    onClick: () => onClick?.()
+  }, /* @__PURE__ */ React14.createElement(Avatar.Fallback, {
+    text: identity.profile?.data?.emoji || fallbackValue.emoji
+  })), showName && /* @__PURE__ */ React14.createElement(Avatar.Label, {
+    classNames: "text-sm truncate pli-2"
+  }, getName(identity)));
+};
+var SmallPresenceLive = ({ viewers }) => {
+  const [moment, setMoment] = useState7(Date.now());
+  useEffect4(() => {
+    const interval = setInterval(() => setMoment(Date.now()), REFRESH_INTERVAL);
+    return () => clearInterval(interval);
+  }, []);
+  const activeViewers = viewers ? Array.from(viewers.values()).filter(({ lastSeen }) => moment - lastSeen < ACTIVITY_DURATION) : [];
+  return /* @__PURE__ */ React14.createElement(SmallPresence, {
+    count: activeViewers.length
+  });
+};
+var SmallPresence = ({ count }) => {
+  const { t } = useTranslation14(SPACE_PLUGIN);
+  return /* @__PURE__ */ React14.createElement(Tooltip2.Root, null, /* @__PURE__ */ React14.createElement(Tooltip2.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React14.createElement(AttentionGlyph, {
+    presence: count > 1 ? "many" : count === 1 ? "one" : "none",
+    classNames: "self-center mie-1"
+  })), /* @__PURE__ */ React14.createElement(Tooltip2.Portal, null, /* @__PURE__ */ React14.createElement(Tooltip2.Content, {
+    side: "bottom",
+    classNames: "z-[70]"
+  }, /* @__PURE__ */ React14.createElement("span", null, t("presence label", {
+    count
+  })), /* @__PURE__ */ React14.createElement(Tooltip2.Arrow, null))));
+};
+
+// packages/plugins/plugin-space/src/components/SpaceSettings.tsx
+import React15 from "react";
+import { useIntentDispatcher as useIntentDispatcher2, useResolvePlugins } from "@dxos/app-framework";
+import { SettingsValue } from "@dxos/plugin-settings";
+import { Input as Input3, Select, toLocalizedString as toLocalizedString2, useTranslation as useTranslation15 } from "@dxos/react-ui";
+var SpaceSettings = ({ settings }) => {
+  const { t } = useTranslation15(SPACE_PLUGIN);
+  const dispatch = useIntentDispatcher2();
+  const plugins = useResolvePlugins(parseSpaceInitPlugin);
+  return /* @__PURE__ */ React15.createElement(React15.Fragment, null, /* @__PURE__ */ React15.createElement(SettingsValue, {
+    label: t("show hidden spaces label")
+  }, /* @__PURE__ */ React15.createElement(Input3.Switch, {
+    checked: settings.showHidden,
+    onCheckedChange: (checked) => dispatch({
+      plugin: SPACE_PLUGIN,
+      action: SpaceAction.TOGGLE_HIDDEN,
+      data: {
+        state: !!checked
+      }
+    })
+  })), /* @__PURE__ */ React15.createElement(SettingsValue, {
+    label: t("default on space create label")
+  }, /* @__PURE__ */ React15.createElement(Select.Root, {
+    value: settings.onSpaceCreate,
+    onValueChange: (value) => {
+      settings.onSpaceCreate = value;
+    }
+  }, /* @__PURE__ */ React15.createElement(Select.TriggerButton, null), /* @__PURE__ */ React15.createElement(Select.Portal, null, /* @__PURE__ */ React15.createElement(Select.Content, null, /* @__PURE__ */ React15.createElement(Select.Viewport, null, plugins.map(({ provides: { space: { onSpaceCreate } } }) => /* @__PURE__ */ React15.createElement(Select.Option, {
+    key: onSpaceCreate.action,
+    value: onSpaceCreate.action
+  }, toLocalizedString2(onSpaceCreate.label, t)))))))));
+};
+
+// packages/plugins/plugin-space/src/components/SaveStatus.tsx
+import React16, { useEffect as useEffect5, useState as useState8 } from "react";
+import { Context } from "@dxos/context";
+import { StatusBar } from "@dxos/plugin-status-bar";
+import { useClient as useClient4 } from "@dxos/react-client";
+import { Icon, useTranslation as useTranslation16 } from "@dxos/react-ui";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-space/src/components/SaveStatus.tsx";
+var SaveStatus = () => {
+  const { t } = useTranslation16(SPACE_PLUGIN);
+  const client = useClient4();
+  const [state, setState] = useState8("saved");
+  useEffect5(() => {
+    return createClientSaveTracker(client, (state2) => {
+      setState(state2);
+    });
+  }, []);
+  return /* @__PURE__ */ React16.createElement(StatusBar.Item, {
+    title: state === "saving" ? t("saving label") : t("saved label")
+  }, /* @__PURE__ */ React16.createElement(Icon, {
+    icon: state === "saving" ? "ph--arrows-clockwise--regular" : "ph--check-circle--regular",
+    size: 4
+  }));
+};
+var createClientSaveTracker = (client, cb) => {
+  const unsubscribeCallbacks = {};
+  const state = {};
+  const install = (spaces) => {
+    for (const space of spaces) {
+      if (state[space.id]) {
+        continue;
+      }
+      state[space.id] = "saved";
+      unsubscribeCallbacks[space.id] = createSpaceSaveTracker(space, (s) => {
+        state[space.id] = s;
+        cb(Object.values(state).some((s2) => s2 === "saving") ? "saving" : "saved");
+      });
+    }
+  };
+  client.spaces.subscribe((spaces) => {
+    install(spaces);
+  });
+  install(client.spaces.get());
+  return () => {
+    for (const unsubscribe of Object.values(unsubscribeCallbacks)) {
+      unsubscribe();
+    }
+  };
+};
+var createSpaceSaveTracker = (space, cb) => {
+  const ctx = new Context(void 0, {
+    F: __dxlog_file3,
+    L: 64
+  });
+  void space.waitUntilReady().then(() => {
+    if (ctx.disposed) {
+      return;
+    }
+    let hasUnsavedChanges = false;
+    let lastFlushPromise;
+    space.crud.saveStateChanged.on(ctx, ({ unsavedDocuments }) => {
+      hasUnsavedChanges = unsavedDocuments.length > 0;
+    });
+    space.crud.saveStateChanged.debounce(500).on(ctx, () => {
+      if (hasUnsavedChanges) {
+        lastFlushPromise = void 0;
+        cb("saving");
+      } else {
+        const flushPromise = space.crud.flush();
+        lastFlushPromise = flushPromise;
+        void flushPromise.then(() => {
+          if (lastFlushPromise === flushPromise) {
+            cb("saved");
+          }
+        });
+      }
+    });
+  });
+  return () => {
+    void ctx.dispose();
+  };
+};
+
+// packages/plugins/plugin-space/src/components/SyncStatus/SyncStatus.tsx
+import React17, { useEffect as useEffect7, useState as useState10 } from "react";
+import { StatusBar as StatusBar2 } from "@dxos/plugin-status-bar";
+import { Icon as Icon2, Popover as Popover3, useTranslation as useTranslation17 } from "@dxos/react-ui";
+import { SyntaxHighlighter } from "@dxos/react-ui-syntax-highlighter";
+import { mx as mx9 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-space/src/components/SyncStatus/types.ts
+import { useEffect as useEffect6, useState as useState9 } from "react";
+import { Context as Context2 } from "@dxos/context";
+import { EdgeService } from "@dxos/protocols";
+import { useClient as useClient5 } from "@dxos/react-client";
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-space/src/components/SyncStatus/types.ts";
+var createEmptyEdgeSyncState = () => ({
+  missingOnLocal: 0,
+  missingOnRemote: 0,
+  localDocumentCount: 0,
+  remoteDocumentCount: 0,
+  differentDocuments: 0
+});
+var getSyncSummary = (syncMap) => {
+  return Object.entries(syncMap).reduce((summary, [_spaceId, peerState]) => {
+    summary.missingOnLocal += peerState.missingOnLocal;
+    summary.missingOnRemote += peerState.missingOnRemote;
+    summary.localDocumentCount += peerState.localDocumentCount;
+    summary.remoteDocumentCount += peerState.remoteDocumentCount;
+    summary.differentDocuments += peerState.differentDocuments;
+    return summary;
+  }, createEmptyEdgeSyncState());
+};
+var isEdgePeerId = (peerId, spaceId) => peerId.startsWith(`${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}`);
+var useSyncState = () => {
+  const client = useClient5();
+  const [spaceState, setSpaceState] = useState9({});
+  useEffect6(() => {
+    const ctx = new Context2(void 0, {
+      F: __dxlog_file4,
+      L: 48
+    });
+    const createSubscriptions = (spaces) => {
+      for (const space of spaces) {
+        if (spaceState[space.id]) {
+          continue;
+        }
+        ctx.onDispose(space.crud.subscribeToSyncState(ctx, ({ peers = [] }) => {
+          const syncState = peers.find((state) => isEdgePeerId(state.peerId, space.id));
+          if (syncState) {
+            setSpaceState((spaceState2) => ({
+              ...spaceState2,
+              [space.id]: syncState
+            }));
+          }
+        }));
+      }
+    };
+    createSubscriptions(client.spaces.get());
+    client.spaces.subscribe((spaces) => {
+      createSubscriptions(spaces);
+    });
+    return () => {
+      void ctx.dispose();
+    };
+  }, [
+    client
+  ]);
+  return spaceState;
+};
+
+// packages/plugins/plugin-space/src/components/SyncStatus/SyncStatus.tsx
+var SYNC_STALLED_TIMEOUT = 5e3;
+var styles = {
+  barBg: "bg-neutral-50 dark:bg-green-900 text-black",
+  barFg: "bg-neutral-100 bg-green-500",
+  barHover: "dark:hover:bg-green-500"
+};
+var SyncStatus = () => {
+  const state = useSyncState();
+  return /* @__PURE__ */ React17.createElement(SyncStatusIndicator, {
+    state
+  });
+};
+var SyncStatusIndicator = ({ state }) => {
+  const summary = getSyncSummary(state);
+  const offline = false;
+  const needsToUpload = summary.differentDocuments > 0 || summary.missingOnRemote > 0;
+  const needsToDownload = summary.differentDocuments > 0 || summary.missingOnLocal > 0;
+  const [classNames, setClassNames] = useState10();
+  useEffect7(() => {
+    setClassNames(void 0);
+    if (!needsToUpload && !needsToDownload) {
+      return;
+    }
+    const t = setTimeout(() => {
+      setClassNames("text-orange-500");
+    }, SYNC_STALLED_TIMEOUT);
+    return () => clearTimeout(t);
+  }, [
+    needsToUpload,
+    needsToDownload
+  ]);
+  return /* @__PURE__ */ React17.createElement(StatusBar2.Item, null, /* @__PURE__ */ React17.createElement(Popover3.Root, null, /* @__PURE__ */ React17.createElement(Popover3.Trigger, null, /* @__PURE__ */ React17.createElement(Icon2, {
+    icon: offline ? "ph--cloud-x--regular" : needsToUpload ? "ph--cloud-arrow-up--regular" : needsToDownload ? "ph--cloud-arrow-down--regular" : "ph--cloud-check--regular",
+    size: 4,
+    classNames
+  })), /* @__PURE__ */ React17.createElement(Popover3.Content, null, /* @__PURE__ */ React17.createElement(SyncStatusDetail, {
+    state,
+    summary,
+    debug: false
+  }))));
+};
+var SyncStatusDetail = ({ classNames, state, summary, debug }) => {
+  const { t } = useTranslation17(SPACE_PLUGIN);
+  const entries = Object.entries(state).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return /* @__PURE__ */ React17.createElement("div", {
+    className: mx9("flex flex-col text-xs min-w-[16rem]", classNames)
+  }, /* @__PURE__ */ React17.createElement("h1", {
+    className: "p-2"
+  }, t("sync status title")), /* @__PURE__ */ React17.createElement("div", {
+    className: "flex flex-col gap-[2px] my-[2px]"
+  }, entries.map(([spaceId, state2]) => /* @__PURE__ */ React17.createElement(SpaceRow, {
+    key: spaceId,
+    spaceId,
+    state: state2
+  }))), debug && /* @__PURE__ */ React17.createElement(SyntaxHighlighter, {
+    language: "json"
+  }, JSON.stringify(summary, null, 2)));
+};
+var useActive = (count) => {
+  const [current, setCurrent] = useState10(count);
+  const [active, setActive] = useState10(false);
+  useEffect7(() => {
+    let t;
+    if (count !== current) {
+      setActive(true);
+      setCurrent(count);
+      t && clearTimeout(t);
+      t = setTimeout(() => {
+        setActive(false);
+      }, SYNC_STALLED_TIMEOUT);
+    }
+    return () => {
+      setActive(false);
+      clearTimeout(t);
+    };
+  }, [
+    count,
+    current
+  ]);
+  return active;
+};
+var SpaceRow = ({ spaceId, state: { localDocumentCount, remoteDocumentCount, missingOnLocal, missingOnRemote } }) => {
+  const downActive = useActive(localDocumentCount);
+  const upActive = useActive(remoteDocumentCount);
+  return /* @__PURE__ */ React17.createElement("div", {
+    className: mx9("flex items-center mx-[2px] gap-[2px] cursor-pointer", styles.barHover),
+    title: spaceId,
+    onClick: () => {
+      void navigator.clipboard.writeText(spaceId);
+    }
+  }, /* @__PURE__ */ React17.createElement(Icon2, {
+    icon: "ph--arrow-fat-line-left--regular",
+    size: 3,
+    classNames: mx9(downActive && "animate-[pulse_1s_infinite]")
+  }), /* @__PURE__ */ React17.createElement(Candle, {
+    up: {
+      count: remoteDocumentCount,
+      total: remoteDocumentCount + missingOnRemote
+    },
+    down: {
+      count: localDocumentCount,
+      total: localDocumentCount + missingOnLocal
+    },
+    title: spaceId
+  }), /* @__PURE__ */ React17.createElement(Icon2, {
+    icon: "ph--arrow-fat-line-right--regular",
+    size: 3,
+    classNames: mx9(upActive && "animate-[pulse_1s_step-start_infinite]")
+  }));
+};
+var Candle = ({ classNames, up, down }) => {
+  return /* @__PURE__ */ React17.createElement("div", {
+    className: mx9("grid grid-cols-[1fr_2rem_1fr] w-full h-3", classNames)
+  }, /* @__PURE__ */ React17.createElement(Bar, {
+    classNames: "justify-end",
+    ...up
+  }), /* @__PURE__ */ React17.createElement("div", {
+    className: "relative"
+  }, /* @__PURE__ */ React17.createElement("div", {
+    className: mx9("absolute inset-0 flex items-center justify-center text-xs", styles.barBg)
+  }, up.total)), /* @__PURE__ */ React17.createElement(Bar, down));
+};
+var Bar = ({ classNames, count, total }) => {
+  let p = count / total * 100;
+  if (count < total) {
+    p = Math.min(p, 95);
+  }
+  return /* @__PURE__ */ React17.createElement("div", {
+    className: mx9("relative flex w-full", styles.barBg, classNames)
+  }, /* @__PURE__ */ React17.createElement("div", {
+    className: mx9("shrink-0", styles.barFg),
+    style: {
+      width: `${p}%`
+    }
+  }), count !== total && /* @__PURE__ */ React17.createElement("div", {
+    className: "absolute top-0 bottom-0 flex items-center mx-0.5 text-black text-xs"
+  }, count));
+};
+
+// packages/plugins/plugin-space/src/translations.ts
+var translations_default = [
+  {
+    "en-US": {
+      [SPACE_PLUGIN]: {
+        "plugin name": "Spaces",
+        "first run message": "Nothing selected.",
+        "create space label": "Create a new space",
+        "join space label": "Join a space",
+        "empty space message": "No documents",
+        "empty tree message": "No spaces",
+        "unnamed space label": "New space",
+        "closed space label": "Closed",
+        "loading space label": "Loading space\u2026",
+        "lock space label": "Lock space",
+        "unlock space label": "Unlock space",
+        "rename space label": "Rename space",
+        "active space label": "Active space:",
+        "space name label": "Space name",
+        "object name label": "Object name",
+        "close space label": "Close space",
+        "open space label": "Open space",
+        "export data label": "Export data",
+        "import data label": "Import data",
+        "migrate space label": "Migrate space",
+        "share space": "Share space",
+        "save space to disk label": "Save to disk",
+        "load space from disk label": "Load from disk",
+        "confirm restore title": "Overwrite files in this space?",
+        "confirm restore body": "Restoring from a backup will overwrite the contents of any documents that match.",
+        "upload file message": "Drag file here or click to browse",
+        "object title placeholder": "Type a title here\u2026",
+        "personal space label": "Personal Space",
+        "spaces label": "Spaces",
+        "show hidden spaces label": "Show closed spaces",
+        "save files to directory label": "Save files to disk",
+        "select path label": "Select path",
+        "rename collection label": "Rename collection",
+        "rename object label": "Rename item",
+        "duplicate object label": "Duplicate item",
+        "delete collection label": "Delete collection",
+        "delete object label": "Delete item",
+        "collection deleted label": "Collection deleted",
+        "object deleted label": "Item deleted",
+        "go to object label": "Open item",
+        "found object label": "Ready.",
+        "found object description": "The requested object is now available.",
+        "waiting for object label": "Loading\u2026",
+        "waiting for object description": "The requested object is still being synchronized.",
+        "object not found label": "Nothing found.",
+        "object not found description": "The requested object has not been found yet. Ensure there are enough peers online in the space with an updated copy.",
+        "missing object message": "Object not available.",
+        "missing object description": "The requested object has not been found yet. Ensure there are enough peers online in the space with an updated copy.",
+        "create collection label": "Create collection",
+        "unnamed object label": "New object",
+        "unnamed collection label": "New collection",
+        "create object in space label": "Add to space",
+        "create object in collection label": "Add to collection",
+        "share space label": "Share",
+        "space members label": "Space members",
+        "active space members heading": "Online ({{count}})",
+        "inactive space members heading": "Offline ({{count}})",
+        "presence label_zero": "No other viewers",
+        "presence label_one": "1 other viewer",
+        "presence label_other": "{{count}} other viewers",
+        "persisted locally label": "Changes saved locally.",
+        "persisted locally message": "All changes have been saved to disk on this device.",
+        "persistence pending label": "Saving\u2026",
+        "persistence error label": "Error saving changes.",
+        "more actions label": "More actions",
+        "invitations heading": "Invitations",
+        "keyshortcuts label": "Keyboard shortcuts",
+        "menu footer label": "Details",
+        "location label": "Located in",
+        "space limit label": "Space Limit Reached",
+        "space limit description": "This space has reached the maximum number of objects for the beta. This limit includes deleted objects currently, but those can be permanently removed with the cleanup action.",
+        "space limit close label": "Close",
+        "remove deleted objects label": "Cleanup",
+        "remove deleted objects alt": "Permanently remove deleted objects to free up space.",
+        "copy link label": "Copy link",
+        "default on space create label": "On space create",
+        "sync status title": "Sync status"
+      }
+    }
+  }
+];
+
+// packages/plugins/plugin-space/src/SpacePlugin.tsx
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-space/src/SpacePlugin.tsx";
+var ACTIVE_NODE_BROADCAST_INTERVAL = 3e4;
+var OBJECT_ID_LENGTH = 60;
+var SPACE_MAX_OBJECTS = 500;
+var DIRECTORY_TYPE = "text/directory";
+var parseSpacePlugin = (plugin) => Array.isArray(plugin?.provides.space?.enabled) ? plugin : void 0;
+var SpacePlugin = ({ firstRun, onFirstRun } = {}) => {
+  const settings = new LocalStorageStore(SPACE_PLUGIN, {
+    onSpaceCreate: "dxos.org/plugin/markdown/action/create"
+  });
+  const state = new LocalStorageStore(SPACE_PLUGIN, {
+    awaiting: void 0,
+    spaceNames: {},
+    viewersByObject: {},
+    viewersByIdentity: new ComplexMap2(PublicKey2.hash),
+    sdkMigrationRunning: {}
+  });
+  const subscriptions = new EventSubscriptions();
+  const spaceSubscriptions = new EventSubscriptions();
+  const graphSubscriptions = /* @__PURE__ */ new Map();
+  let clientPlugin;
+  let intentPlugin;
+  let navigationPlugin;
+  let attentionPlugin;
+  const onSpaceReady = async () => {
+    if (!clientPlugin || !navigationPlugin || !attentionPlugin) {
+      return;
+    }
+    const client = clientPlugin.provides.client;
+    const location = navigationPlugin.provides.location;
+    const attention = attentionPlugin.provides.attention;
+    const defaultSpace = client.spaces.default;
+    if (typeof defaultSpace.properties[COMPOSER_SPACE_LOCK] !== "boolean") {
+      defaultSpace.properties[COMPOSER_SPACE_LOCK] = true;
+    }
+    const { objects: [spacesOrder] } = await defaultSpace.db.query(Filter.schema(Expando, {
+      key: SHARED
+    })).run();
+    if (!spacesOrder) {
+      defaultSpace.db.add(create2({
+        key: SHARED,
+        order: []
+      }));
+    }
+    subscriptions.add(client.spaces.subscribe(async (spaces) => {
+      if (defaultSpace.state.get() === SpaceState3.SPACE_REQUIRES_MIGRATION) {
+        await defaultSpace.internal.migrate();
+      }
+      spaces.filter((space) => space.state.get() === SpaceState3.SPACE_READY).forEach((space) => {
+        subscriptions.add(effect(() => {
+          state.values.spaceNames[space.id] = space.properties.name;
+        }));
+      });
+    }).unsubscribe);
+    subscriptions.add(effect(() => {
+      const send = () => {
+        const spaces = client.spaces.get();
+        const identity = client.halo.identity.get();
+        if (identity && location.active) {
+          const ids = openIds(location.active);
+          const idsBySpace = reduceGroupBy(ids, (id) => {
+            const [spaceId] = id.split(":");
+            return spaceId;
+          });
+          for (const space of spaces) {
+            if (!idsBySpace.has(space.id)) {
+              idsBySpace.set(space.id, []);
+            }
+          }
+          for (const [spaceId, ids2] of idsBySpace) {
+            const space = spaces.find((space2) => space2.id === spaceId);
+            if (!space) {
+              continue;
+            }
+            const removed = location.closed ? [
+              location.closed
+            ].flat() : [];
+            void space.postMessage("viewing", {
+              identityKey: identity.identityKey.toHex(),
+              attended: attention.attended ? [
+                ...attention.attended
+              ] : [],
+              added: ids2,
+              // TODO(Zan): When we re-open a part, we should remove it from the removed list in the navigation plugin.
+              removed: removed.filter((id) => !ids2.includes(id))
+            }).catch((err) => {
+              log2.warn("Failed to broadcast active node for presence.", {
+                err: err.message
+              }, {
+                F: __dxlog_file5,
+                L: 225,
+                S: void 0,
+                C: (f, a) => f(...a)
+              });
+            });
+          }
+        }
+      };
+      send();
+      const interval = setInterval(() => send(), ACTIVE_NODE_BROADCAST_INTERVAL);
+      return () => clearInterval(interval);
+    }));
+    subscriptions.add(client.spaces.subscribe((spaces) => {
+      spaceSubscriptions.clear();
+      spaces.forEach((space) => {
+        spaceSubscriptions.add(space.listen("viewing", (message) => {
+          const { added, removed, attended } = message.payload;
+          const identityKey = PublicKey2.safeFrom(message.payload.identityKey);
+          if (identityKey && Array.isArray(added) && Array.isArray(removed)) {
+            added.forEach((id) => {
+              if (typeof id === "string") {
+                if (!(id in state.values.viewersByObject)) {
+                  state.values.viewersByObject[id] = new ComplexMap2(PublicKey2.hash);
+                }
+                state.values.viewersByObject[id].set(identityKey, {
+                  lastSeen: Date.now(),
+                  currentlyAttended: new Set(attended).has(id)
+                });
+                if (!state.values.viewersByIdentity.has(identityKey)) {
+                  state.values.viewersByIdentity.set(identityKey, /* @__PURE__ */ new Set());
+                }
+                state.values.viewersByIdentity.get(identityKey).add(id);
+              }
+            });
+            removed.forEach((id) => {
+              if (typeof id === "string") {
+                state.values.viewersByObject[id]?.delete(identityKey);
+                state.values.viewersByIdentity.get(identityKey)?.delete(id);
+              }
+            });
+          }
+        }));
+      });
+    }).unsubscribe);
+  };
+  return {
+    meta: meta_default,
+    ready: async (plugins) => {
+      settings.prop({
+        key: "showHidden",
+        storageKey: "show-hidden",
+        type: LocalStorageStore.bool({
+          allowUndefined: true
+        })
+      });
+      state.prop({
+        key: "spaceNames",
+        storageKey: "space-names",
+        type: LocalStorageStore.json()
+      });
+      navigationPlugin = resolvePlugin(plugins, parseNavigationPlugin2);
+      attentionPlugin = resolvePlugin(plugins, parseAttentionPlugin);
+      clientPlugin = resolvePlugin(plugins, parseClientPlugin);
+      intentPlugin = resolvePlugin(plugins, parseIntentPlugin3);
+      if (!clientPlugin || !intentPlugin) {
+        return;
+      }
+      const client = clientPlugin.provides.client;
+      const dispatch = intentPlugin.provides.intent.dispatch;
+      const handleFirstRun = async () => {
+        const defaultSpace = client.spaces.default;
+        defaultSpace.properties[CollectionType.typename] = create2(CollectionType, {
+          objects: [],
+          views: {}
+        });
+        if (Migrations2.versionProperty) {
+          defaultSpace.properties[Migrations2.versionProperty] = Migrations2.targetVersion;
+        }
+        await onFirstRun?.({
+          client,
+          dispatch
+        });
+      };
+      client.spaces.isReady.subscribe(async (ready) => {
+        if (ready) {
+          await clientPlugin?.provides.client.spaces.default.waitUntilReady();
+          if (firstRun) {
+            void firstRun?.wait().then(handleFirstRun);
+          } else {
+            await handleFirstRun();
+          }
+          await onSpaceReady();
+        }
+      });
+    },
+    unload: async () => {
+      settings.close();
+      spaceSubscriptions.clear();
+      subscriptions.clear();
+      graphSubscriptions.forEach((cb) => cb());
+      graphSubscriptions.clear();
+    },
+    provides: {
+      space: state.values,
+      settings: settings.values,
+      translations: [
+        ...translations_default,
+        osTranslations
+      ],
+      root: () => state.values.awaiting ? /* @__PURE__ */ React18.createElement(AwaitingObject, {
+        id: state.values.awaiting
+      }) : null,
+      metadata: {
+        records: {
+          [CollectionType.typename]: {
+            placeholder: [
+              "unnamed collection label",
+              {
+                ns: SPACE_PLUGIN
+              }
+            ],
+            icon: "ph--cards-three--regular",
+            // TODO(wittjosiah): Move out of metadata.
+            loadReferences: (collection) => loadObjectReferences(collection, (collection2) => [
+              ...collection2.objects,
+              ...Object.values(collection2.views)
+            ])
+          }
+        }
+      },
+      echo: {
+        schema: [
+          CollectionType
+        ]
+      },
+      surface: {
+        component: ({ data, role, ...rest }) => {
+          const primary = data.active ?? data.object;
+          switch (role) {
+            case "article":
+            case "main":
+              return isSpace2(primary) && primary.state.get() === SpaceState3.SPACE_READY ? /* @__PURE__ */ React18.createElement(Surface2, {
+                data: {
+                  active: primary.properties[CollectionType.typename]
+                },
+                role,
+                ...rest
+              }) : primary instanceof CollectionType ? {
+                node: /* @__PURE__ */ React18.createElement(CollectionMain, {
+                  collection: primary
+                }),
+                disposition: "fallback"
+              } : typeof primary === "string" && primary.length === OBJECT_ID_LENGTH ? /* @__PURE__ */ React18.createElement(MissingObject, {
+                id: primary
+              }) : null;
+            // TODO(burdon): Add role name syntax to minimal plugin docs.
+            case "tree--empty":
+              switch (true) {
+                case data.plugin === SPACE_PLUGIN:
+                  return /* @__PURE__ */ React18.createElement(EmptyTree, null);
+                case (isGraphNode(data.activeNode) && isSpace2(data.activeNode.data)):
+                  return /* @__PURE__ */ React18.createElement(EmptySpace, null);
+                default:
+                  return null;
+              }
+            case "dialog":
+              if (data.component === "dxos.org/plugin/space/InvitationManagerDialog") {
+                return /* @__PURE__ */ React18.createElement(Dialog.Content, null, /* @__PURE__ */ React18.createElement(ClipboardProvider2, null, /* @__PURE__ */ React18.createElement(InvitationManager, {
+                  active: true,
+                  ...data.subject
+                })));
+              } else {
+                return null;
+              }
+            case "popover":
+              if (data.component === "dxos.org/plugin/space/RenameSpacePopover" && isSpace2(data.subject)) {
+                return /* @__PURE__ */ React18.createElement(PopoverRenameSpace, {
+                  space: data.subject
+                });
+              }
+              if (data.component === "dxos.org/plugin/space/RenameObjectPopover" && isReactiveObject2(data.subject)) {
+                return /* @__PURE__ */ React18.createElement(PopoverRenameObject, {
+                  object: data.subject
+                });
+              }
+              return null;
+            case "presence--glyph": {
+              return isReactiveObject2(data.object) ? /* @__PURE__ */ React18.createElement(SmallPresenceLive, {
+                viewers: state.values.viewersByObject[fullyQualifiedId4(data.object)]
+              }) : /* @__PURE__ */ React18.createElement(SmallPresence, {
+                count: 0
+              });
+            }
+            case "navbar-start": {
+              return null;
+            }
+            case "navbar-end": {
+              if (!isEchoObject2(data.object) && !isSpace2(data.object)) {
+                return null;
+              }
+              const space = isSpace2(data.object) ? data.object : getSpace4(data.object);
+              const object = isSpace2(data.object) ? data.object.state.get() === SpaceState3.SPACE_READY ? space?.properties[CollectionType.typename] : void 0 : data.object;
+              return space && object ? {
+                node: /* @__PURE__ */ React18.createElement(React18.Fragment, null, /* @__PURE__ */ React18.createElement(SpacePresence, {
+                  object
+                }), space.properties[COMPOSER_SPACE_LOCK] ? null : /* @__PURE__ */ React18.createElement(ShareSpaceButton, {
+                  spaceId: space.id
+                })),
+                disposition: "hoist"
+              } : null;
+            }
+            case "section":
+              return data.object instanceof CollectionType ? /* @__PURE__ */ React18.createElement(CollectionSection, {
+                collection: data.object
+              }) : null;
+            case "settings":
+              return data.plugin === meta_default.id ? /* @__PURE__ */ React18.createElement(SpaceSettings, {
+                settings: settings.values
+              }) : null;
+            case "menu-footer":
+              if (!isEchoObject2(data.object)) {
+                return null;
+              } else {
+                return /* @__PURE__ */ React18.createElement(MenuFooter, {
+                  object: data.object
+                });
+              }
+            case "status": {
+              return /* @__PURE__ */ React18.createElement(React18.Fragment, null, /* @__PURE__ */ React18.createElement(SyncStatus, null), /* @__PURE__ */ React18.createElement(SaveStatus, null));
+            }
+            default:
+              return null;
+          }
+        }
+      },
+      graph: {
+        builder: (plugins) => {
+          const clientPlugin2 = resolvePlugin(plugins, parseClientPlugin);
+          const metadataPlugin = resolvePlugin(plugins, parseMetadataResolverPlugin);
+          const graphPlugin = resolvePlugin(plugins, parseGraphPlugin);
+          const client = clientPlugin2?.provides.client;
+          const dispatch = intentPlugin?.provides.intent.dispatch;
+          const resolve = metadataPlugin?.provides.metadata.resolver;
+          const graph = graphPlugin?.provides.graph;
+          if (!graph || !dispatch || !resolve || !client) {
+            return [];
+          }
+          return [
+            // Create spaces group node.
+            createExtension({
+              id: `${SPACE_PLUGIN}/root`,
+              filter: (node) => node.id === "root",
+              connector: () => {
+                const isReady = toSignal((onChange) => {
+                  let defaultSpaceUnsubscribe;
+                  client.spaces.isReady.subscribe((ready) => {
+                    if (ready) {
+                      defaultSpaceUnsubscribe = client.spaces.default.state.subscribe(() => onChange()).unsubscribe;
+                    }
+                  });
+                  return () => defaultSpaceUnsubscribe?.();
+                }, () => client.spaces.isReady.get() && client.spaces.default.state.get() === SpaceState3.SPACE_READY);
+                if (!isReady) {
+                  return [];
+                }
+                return [
+                  {
+                    id: SPACES,
+                    type: SPACES,
+                    properties: {
+                      label: [
+                        "spaces label",
+                        {
+                          ns: SPACE_PLUGIN
+                        }
+                      ],
+                      palette: "teal",
+                      testId: "spacePlugin.spaces",
+                      role: "branch",
+                      childrenPersistenceClass: "echo",
+                      onRearrangeChildren: async (nextOrder) => {
+                        graph._sortEdges(SPACES, "outbound", nextOrder.map(({ id }) => id));
+                        const { objects: [spacesOrder] } = await client.spaces.default.db.query(Filter.schema(Expando, {
+                          key: SHARED
+                        })).run();
+                        if (spacesOrder) {
+                          spacesOrder.order = nextOrder.map(({ id }) => id);
+                        } else {
+                          log2.warn("spaces order object not found", void 0, {
+                            F: __dxlog_file5,
+                            L: 524,
+                            S: void 0,
+                            C: (f, a) => f(...a)
+                          });
+                        }
+                      }
+                    }
+                  }
+                ];
+              }
+            }),
+            // Create space nodes.
+            createExtension({
+              id: SPACES,
+              filter: (node) => node.id === SPACES,
+              actions: () => [
+                {
+                  id: SpaceAction.CREATE,
+                  data: async () => {
+                    await dispatch([
+                      {
+                        plugin: SPACE_PLUGIN,
+                        action: SpaceAction.CREATE
+                      },
+                      {
+                        action: NavigationAction3.OPEN
+                      }
+                    ]);
+                  },
+                  properties: {
+                    label: [
+                      "create space label",
+                      {
+                        ns: SPACE_PLUGIN
+                      }
+                    ],
+                    icon: "ph--plus--regular",
+                    disposition: "toolbar",
+                    testId: "spacePlugin.createSpace"
+                  }
+                },
+                {
+                  id: SpaceAction.JOIN,
+                  data: async () => {
+                    await dispatch([
+                      {
+                        plugin: SPACE_PLUGIN,
+                        action: SpaceAction.JOIN
+                      },
+                      {
+                        action: NavigationAction3.OPEN
+                      }
+                    ]);
+                  },
+                  properties: {
+                    label: [
+                      "join space label",
+                      {
+                        ns: SPACE_PLUGIN
+                      }
+                    ],
+                    icon: "ph--sign-in--regular",
+                    testId: "spacePlugin.joinSpace"
+                  }
+                }
+              ],
+              connector: () => {
+                const spaces = toSignal((onChange) => client.spaces.subscribe(() => onChange()).unsubscribe, () => client.spaces.get());
+                const isReady = toSignal((onChange) => client.spaces.isReady.subscribe(() => onChange()).unsubscribe, () => client.spaces.isReady.get());
+                if (!spaces || !isReady) {
+                  return;
+                }
+                const [spacesOrder] = memoizeQuery(client.spaces.default, Filter.schema(Expando, {
+                  key: SHARED
+                }));
+                const order = spacesOrder?.order ?? [];
+                const orderMap = new Map(order.map((id, index) => [
+                  id,
+                  index
+                ]));
+                return [
+                  ...spaces.filter((space) => orderMap.has(space.id)).sort((a, b) => orderMap.get(a.id) - orderMap.get(b.id)),
+                  ...spaces.filter((space) => !orderMap.has(space.id))
+                ].filter((space) => settings.values.showHidden ? true : space.state.get() !== SpaceState3.SPACE_INACTIVE).map((space) => constructSpaceNode({
+                  space,
+                  personal: space === client.spaces.default,
+                  namesCache: state.values.spaceNames,
+                  resolve
+                }));
+              }
+            }),
+            // Find an object by its fully qualified id.
+            createExtension({
+              id: `${SPACE_PLUGIN}/objects`,
+              resolver: ({ id }) => {
+                const [spaceId, objectId] = id.split(":");
+                const space = client.spaces.get().find((space2) => space2.id === spaceId);
+                if (!space) {
+                  return;
+                }
+                const state2 = toSignal((onChange) => space.state.subscribe(() => onChange()).unsubscribe, () => space.state.get(), space.id);
+                if (state2 !== SpaceState3.SPACE_READY) {
+                  return;
+                }
+                const store = memoize2(() => signal(space.db.getObjectById(objectId)), id);
+                memoize2(() => {
+                  if (!store.value) {
+                    void space.db.loadObjectById(objectId).then((o) => store.value = o);
+                  }
+                }, id);
+                const object = store.value;
+                if (!object) {
+                  return;
+                }
+                return createObjectNode({
+                  object,
+                  space,
+                  resolve
+                });
+              }
+            }),
+            // Create space actions and action groups.
+            createExtension({
+              id: `${SPACE_PLUGIN}/actions`,
+              filter: (node) => isSpace2(node.data),
+              actionGroups: ({ node }) => constructSpaceActionGroups({
+                space: node.data,
+                dispatch
+              }),
+              actions: ({ node }) => {
+                const space = node.data;
+                return constructSpaceActions({
+                  space,
+                  dispatch,
+                  personal: space === client.spaces.default,
+                  migrating: state.values.sdkMigrationRunning[space.id]
+                });
+              }
+            }),
+            // Create nodes for objects in the root collection of a space.
+            createExtension({
+              id: `${SPACE_PLUGIN}/root-collection`,
+              filter: (node) => isSpace2(node.data),
+              connector: ({ node }) => {
+                const space = node.data;
+                const state2 = toSignal((onChange) => space.state.subscribe(() => onChange()).unsubscribe, () => space.state.get(), space.id);
+                if (state2 !== SpaceState3.SPACE_READY) {
+                  return;
+                }
+                const collection = space.properties[CollectionType.typename];
+                if (!collection) {
+                  return;
+                }
+                return collection.objects.filter(nonNullable).map((object) => createObjectNode({
+                  object,
+                  space,
+                  resolve
+                })).filter(nonNullable);
+              }
+            }),
+            // Create collection actions and action groups.
+            createExtension({
+              id: `${SPACE_PLUGIN}/object-actions`,
+              filter: (node) => isEchoObject2(node.data),
+              actionGroups: ({ node }) => constructObjectActionGroups({
+                object: node.data,
+                dispatch
+              }),
+              actions: ({ node }) => constructObjectActions({
+                node,
+                dispatch
+              })
+            }),
+            // Create nodes for objects in collections.
+            createExtension({
+              id: `${SPACE_PLUGIN}/collection-objects`,
+              filter: (node) => node.data instanceof CollectionType,
+              connector: ({ node }) => {
+                const collection = node.data;
+                const space = getSpace4(collection);
+                if (!space) {
+                  return;
+                }
+                return collection.objects.filter(nonNullable).map((object) => createObjectNode({
+                  object,
+                  space,
+                  resolve
+                })).filter(nonNullable);
+              }
+            })
+          ];
+        },
+        serializer: (plugins) => {
+          const dispatch = resolvePlugin(plugins, parseIntentPlugin3)?.provides.intent.dispatch;
+          if (!dispatch) {
+            return [];
+          }
+          return [
+            {
+              inputType: SPACES,
+              outputType: DIRECTORY_TYPE,
+              serialize: (node) => ({
+                name: translations_default[0]["en-US"][SPACE_PLUGIN]["spaces label"],
+                data: translations_default[0]["en-US"][SPACE_PLUGIN]["spaces label"],
+                type: DIRECTORY_TYPE
+              }),
+              deserialize: () => {
+              }
+            },
+            {
+              inputType: SPACE_TYPE,
+              outputType: DIRECTORY_TYPE,
+              serialize: (node) => ({
+                name: node.data.properties.name ?? translations_default[0]["en-US"][SPACE_PLUGIN]["unnamed space label"],
+                data: node.data.properties.name ?? translations_default[0]["en-US"][SPACE_PLUGIN]["unnamed space label"],
+                type: DIRECTORY_TYPE
+              }),
+              deserialize: async (data) => {
+                const result = await dispatch({
+                  plugin: SPACE_PLUGIN,
+                  action: SpaceAction.CREATE,
+                  data: {
+                    name: data.name
+                  }
+                });
+                return result?.data.space;
+              }
+            },
+            {
+              inputType: CollectionType.typename,
+              outputType: DIRECTORY_TYPE,
+              serialize: (node) => ({
+                name: node.data.name ?? translations_default[0]["en-US"][SPACE_PLUGIN]["unnamed collection label"],
+                data: node.data.name ?? translations_default[0]["en-US"][SPACE_PLUGIN]["unnamed collection label"],
+                type: DIRECTORY_TYPE
+              }),
+              deserialize: async (data, ancestors) => {
+                const space = ancestors.find(isSpace2);
+                const collection = ancestors.findLast((ancestor) => ancestor instanceof CollectionType) ?? space?.properties[CollectionType.typename];
+                if (!space || !collection) {
+                  return;
+                }
+                const result = await dispatch({
+                  plugin: SPACE_PLUGIN,
+                  action: SpaceAction.ADD_OBJECT,
+                  data: {
+                    target: collection,
+                    object: create2(CollectionType, {
+                      name: data.name,
+                      objects: [],
+                      views: {}
+                    })
+                  }
+                });
+                return result?.data.object;
+              }
+            }
+          ];
+        }
+      },
+      intent: {
+        resolver: async (intent, plugins) => {
+          const clientPlugin2 = resolvePlugin(plugins, parseClientPlugin);
+          const client = clientPlugin2?.provides.client;
+          switch (intent.action) {
+            case SpaceAction.WAIT_FOR_OBJECT: {
+              state.values.awaiting = intent.data?.id;
+              return {
+                data: true
+              };
+            }
+            case SpaceAction.CREATE: {
+              if (!client) {
+                return;
+              }
+              const space = await client.spaces.create(intent.data);
+              await space.waitUntilReady();
+              const collection = create2(CollectionType, {
+                objects: [],
+                views: {}
+              });
+              space.properties[CollectionType.typename] = collection;
+              if (Migrations2.versionProperty) {
+                space.properties[Migrations2.versionProperty] = Migrations2.targetVersion;
+              }
+              return {
+                data: {
+                  space,
+                  id: space.id,
+                  activeParts: {
+                    main: [
+                      space.id
+                    ]
+                  }
+                },
+                intents: [
+                  ...settings.values.onSpaceCreate ? [
+                    [
+                      {
+                        action: settings.values.onSpaceCreate,
+                        data: {
+                          space
+                        }
+                      },
+                      {
+                        action: SpaceAction.ADD_OBJECT,
+                        data: {
+                          target: space
+                        }
+                      },
+                      {
+                        action: NavigationAction3.EXPOSE
+                      }
+                    ]
+                  ] : [],
+                  [
+                    {
+                      action: ObservabilityAction.SEND_EVENT,
+                      data: {
+                        name: "space.create",
+                        properties: {
+                          spaceId: space.id
+                        }
+                      }
+                    }
+                  ]
+                ]
+              };
+            }
+            case SpaceAction.JOIN: {
+              if (client) {
+                const { space } = await client.shell.joinSpace({
+                  invitationCode: intent.data?.invitationCode
+                });
+                if (space) {
+                  return {
+                    data: {
+                      space,
+                      id: space.id,
+                      activeParts: {
+                        main: [
+                          space.id
+                        ]
+                      }
+                    },
+                    intents: [
+                      [
+                        {
+                          action: ObservabilityAction.SEND_EVENT,
+                          data: {
+                            name: "space.join",
+                            properties: {
+                              spaceId: space.id
+                            }
+                          }
+                        }
+                      ]
+                    ]
+                  };
+                }
+              }
+              break;
+            }
+            case SpaceAction.SHARE: {
+              const spaceId = intent.data?.spaceId;
+              if (clientPlugin2 && typeof spaceId === "string") {
+                if (!navigationPlugin?.provides.location.active) {
+                  return;
+                }
+                const target = firstIdInPart(navigationPlugin?.provides.location.active, "main");
+                const result = await clientPlugin2.provides.client.shell.shareSpace({
+                  spaceId,
+                  target
+                });
+                return {
+                  data: result,
+                  intents: [
+                    [
+                      {
+                        action: ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "space.share",
+                          properties: {
+                            spaceId,
+                            members: result.members?.length,
+                            error: result.error?.message,
+                            cancelled: result.cancelled
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              break;
+            }
+            case SpaceAction.LOCK: {
+              const space = intent.data?.space;
+              if (isSpace2(space)) {
+                space.properties[COMPOSER_SPACE_LOCK] = true;
+                return {
+                  data: true,
+                  intents: [
+                    [
+                      {
+                        action: ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "space.lock",
+                          properties: {
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              break;
+            }
+            case SpaceAction.UNLOCK: {
+              const space = intent.data?.space;
+              if (isSpace2(space)) {
+                space.properties[COMPOSER_SPACE_LOCK] = false;
+                return {
+                  data: true,
+                  intents: [
+                    [
+                      {
+                        action: ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "space.unlock",
+                          properties: {
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              break;
+            }
+            case SpaceAction.RENAME: {
+              const { caller, space } = intent.data ?? {};
+              if (typeof caller === "string" && isSpace2(space)) {
+                return {
+                  intents: [
+                    [
+                      {
+                        action: LayoutAction2.SET_LAYOUT,
+                        data: {
+                          element: "popover",
+                          anchorId: `dxos.org/ui/${caller}/${space.id}`,
+                          component: "dxos.org/plugin/space/RenameSpacePopover",
+                          subject: space
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              break;
+            }
+            case SpaceAction.OPEN: {
+              const space = intent.data?.space;
+              if (isSpace2(space)) {
+                await space.open();
+                return {
+                  data: true
+                };
+              }
+              break;
+            }
+            case SpaceAction.CLOSE: {
+              const space = intent.data?.space;
+              if (isSpace2(space)) {
+                await space.close();
+                return {
+                  data: true
+                };
+              }
+              break;
+            }
+            case SpaceAction.MIGRATE: {
+              const space = intent.data?.space;
+              if (isSpace2(space)) {
+                if (space.state.get() === SpaceState3.SPACE_REQUIRES_MIGRATION) {
+                  state.values.sdkMigrationRunning[space.id] = true;
+                  await space.internal.migrate();
+                  state.values.sdkMigrationRunning[space.id] = false;
+                }
+                const result = await Migrations2.migrate(space, intent.data?.version);
+                return {
+                  data: result,
+                  intents: [
+                    [
+                      {
+                        action: ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "space.migrate",
+                          properties: {
+                            spaceId: space.id,
+                            version: intent.data?.version
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              break;
+            }
+            case SpaceAction.ADD_OBJECT: {
+              const object = intent.data?.object ?? intent.data?.result;
+              if (!isReactiveObject2(object)) {
+                return;
+              }
+              const space = isSpace2(intent.data?.target) ? intent.data?.target : getSpace4(intent.data?.target);
+              if (!space) {
+                return;
+              }
+              if (space.db.coreDatabase.getAllObjectIds().length >= SPACE_MAX_OBJECTS) {
+                return {
+                  data: false,
+                  intents: [
+                    [
+                      {
+                        action: LayoutAction2.SET_LAYOUT,
+                        data: {
+                          element: "toast",
+                          subject: {
+                            id: `${SPACE_PLUGIN}/space-limit`,
+                            title: translations_default[0]["en-US"][SPACE_PLUGIN]["space limit label"],
+                            description: translations_default[0]["en-US"][SPACE_PLUGIN]["space limit description"],
+                            duration: 5e3,
+                            icon: "ph--warning--regular",
+                            actionLabel: translations_default[0]["en-US"][SPACE_PLUGIN]["remove deleted objects label"],
+                            actionAlt: translations_default[0]["en-US"][SPACE_PLUGIN]["remove deleted objects alt"],
+                            // TODO(wittjosiah): Use OS namespace.
+                            closeLabel: translations_default[0]["en-US"][SPACE_PLUGIN]["space limit close label"],
+                            onAction: () => space.db.coreDatabase.unlinkDeletedObjects()
+                          }
+                        }
+                      }
+                    ],
+                    [
+                      {
+                        action: ObservabilityAction.SEND_EVENT,
+                        data: {
+                          name: "space.limit",
+                          properties: {
+                            spaceId: space.id
+                          }
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              if (intent.data?.target instanceof CollectionType) {
+                intent.data?.target.objects.push(object);
+              } else if (isSpace2(intent.data?.target)) {
+                const collection = space.properties[CollectionType.typename];
+                if (collection instanceof CollectionType) {
+                  collection.objects.push(object);
+                } else {
+                  const collection2 = create2(CollectionType, {
+                    objects: [
+                      object
+                    ],
+                    views: {}
+                  });
+                  space.properties[CollectionType.typename] = collection2;
+                }
+              }
+              return {
+                data: {
+                  id: fullyQualifiedId4(object),
+                  object,
+                  activeParts: {
+                    main: [
+                      fullyQualifiedId4(object)
+                    ]
+                  }
+                },
+                intents: [
+                  [
+                    {
+                      action: ObservabilityAction.SEND_EVENT,
+                      data: {
+                        name: "space.object.add",
+                        properties: {
+                          spaceId: space.id,
+                          objectId: object.id,
+                          typename: getTypename2(object)
+                        }
+                      }
+                    }
+                  ]
+                ]
+              };
+            }
+            case SpaceAction.REMOVE_OBJECT: {
+              const object = intent.data?.object ?? intent.data?.result;
+              const space = getSpace4(object);
+              if (!(isEchoObject2(object) && space)) {
+                return;
+              }
+              const resolve = resolvePlugin(plugins, parseMetadataResolverPlugin)?.provides.metadata.resolver;
+              const activeParts = navigationPlugin?.provides.location.active;
+              const openObjectIds = new Set(openIds(activeParts ?? {}));
+              if (!intent.undo && resolve) {
+                const parentCollection = intent.data?.collection ?? space.properties[CollectionType.typename];
+                const nestedObjects = await getNestedObjects(object, resolve);
+                const deletionData = {
+                  object,
+                  parentCollection,
+                  index: parentCollection instanceof CollectionType ? parentCollection.objects.indexOf(object) : -1,
+                  nestedObjects,
+                  wasActive: [
+                    object,
+                    ...nestedObjects
+                  ].map((obj) => fullyQualifiedId4(obj)).filter((id) => openObjectIds.has(id))
+                };
+                if (deletionData.wasActive.length > 0) {
+                  await intentPlugin?.provides.intent.dispatch({
+                    action: NavigationAction3.CLOSE,
+                    data: {
+                      activeParts: {
+                        main: deletionData.wasActive,
+                        sidebar: deletionData.wasActive
+                      }
+                    }
+                  });
+                }
+                if (parentCollection instanceof CollectionType) {
+                  const index = parentCollection.objects.indexOf(object);
+                  if (index !== -1) {
+                    parentCollection.objects.splice(index, 1);
+                  }
+                }
+                deletionData.nestedObjects.forEach((obj) => {
+                  space.db.remove(obj);
+                });
+                space.db.remove(object);
+                const undoMessageKey = object instanceof CollectionType ? "collection deleted label" : "object deleted label";
+                return {
+                  data: true,
+                  undoable: {
+                    // Consider using a translation key here.
+                    message: translations_default[0]["en-US"][SPACE_PLUGIN][undoMessageKey],
+                    data: deletionData
+                  }
+                };
+              } else {
+                const undoData = intent.data;
+                if (undoData && isEchoObject2(undoData.object) && undoData.parentCollection instanceof CollectionType) {
+                  const restoredObject = space.db.add(undoData.object);
+                  undoData.nestedObjects.forEach((obj) => {
+                    space.db.add(obj);
+                  });
+                  if (undoData.index !== -1) {
+                    undoData.parentCollection.objects.splice(undoData.index, 0, restoredObject);
+                  }
+                  if (undoData.wasActive.length > 0) {
+                    await intentPlugin?.provides.intent.dispatch({
+                      action: NavigationAction3.OPEN,
+                      data: {
+                        activeParts: {
+                          main: undoData.wasActive
+                        }
+                      }
+                    });
+                  }
+                  return {
+                    data: true
+                  };
+                }
+                return {
+                  data: false
+                };
+              }
+            }
+            case SpaceAction.RENAME_OBJECT: {
+              const object = intent.data?.object ?? intent.data?.result;
+              const caller = intent.data?.caller;
+              if (isReactiveObject2(object) && caller) {
+                return {
+                  intents: [
+                    [
+                      {
+                        action: LayoutAction2.SET_LAYOUT,
+                        data: {
+                          element: "popover",
+                          anchorId: `dxos.org/ui/${caller}/${fullyQualifiedId4(object)}`,
+                          component: "dxos.org/plugin/space/RenameObjectPopover",
+                          subject: object
+                        }
+                      }
+                    ]
+                  ]
+                };
+              }
+              break;
+            }
+            case SpaceAction.DUPLICATE_OBJECT: {
+              const originalObject = intent.data?.object ?? intent.data?.result;
+              const resolve = resolvePlugin(plugins, parseMetadataResolverPlugin)?.provides.metadata.resolver;
+              if (!isEchoObject2(originalObject) || !resolve) {
+                return;
+              }
+              const newObject = await cloneObject(originalObject, resolve);
+              return {
+                intents: [
+                  [
+                    {
+                      action: SpaceAction.ADD_OBJECT,
+                      data: {
+                        object: newObject,
+                        target: intent.data?.target
+                      }
+                    }
+                  ]
+                ]
+              };
+            }
+            case SpaceAction.TOGGLE_HIDDEN: {
+              settings.values.showHidden = intent.data?.state ?? !settings.values.showHidden;
+              return {
+                data: true
+              };
+            }
+          }
+        }
+      }
+    }
+  };
+};
+
+// packages/plugins/plugin-space/src/index.ts
+var src_default = SpacePlugin;
+export {
+  ActorSchema,
+  AwaitingObject,
+  COMPOSER_SPACE_LOCK,
+  ChannelType,
+  CollectionMain,
+  CollectionSection,
+  CollectionType,
+  ContactType,
+  EmptySpace,
+  EmptyTree,
+  FullPresence,
+  MenuFooter,
+  MessageState,
+  MessageType,
+  MissingObject,
+  PersistenceStatus,
+  PopoverRenameObject,
+  PopoverRenameSpace,
+  SHARED,
+  SPACES,
+  SPACE_DIRECTORY_HANDLE,
+  SPACE_PLUGIN,
+  SPACE_PLUGIN_SHORT_ID,
+  SPACE_TYPE,
+  SaveStatus,
+  ShareSpaceButton,
+  ShareSpaceButtonImpl,
+  SmallPresence,
+  SmallPresenceLive,
+  SpaceAction,
+  SpaceMain,
+  SpacePlugin,
+  SpacePresence,
+  SpaceSettings,
+  SyncStatus,
+  SyncStatusDetail,
+  SyncStatusIndicator,
+  ThreadStatus,
+  ThreadType,
+  cloneObject,
+  constructObjectActionGroups,
+  constructObjectActions,
+  constructSpaceActionGroups,
+  constructSpaceActions,
+  constructSpaceNode,
+  createObjectNode,
+  src_default as default,
+  getActiveSpace,
+  getNestedObjects,
+  getSpaceDisplayName,
+  memoizeQuery,
+  parseSpaceInitPlugin,
+  parseSpacePlugin,
+  translations_default as translations
+};
+//# sourceMappingURL=index.mjs.map