@dxos/plugin-space 0.8.4-main.84f28bd → 0.8.4-main.8baae0fced

package/dist/lib/neutral/app-graph-builder-FLUXDLKV.mjs

@@ -0,0 +1,1262 @@
+import {
+  getSpaceDisplayName
+} from "./chunk-2DHCIE27.mjs";
+import {
+  SHARED
+} from "./chunk-K2XBM3E3.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/app-graph-builder/app-graph-builder.ts
+import * as Effect6 from "effect/Effect";
+import { Capability as Capability4 } from "@dxos/app-framework";
+import { AppCapabilities as AppCapabilities3 } from "@dxos/app-toolkit";
+
+// src/capabilities/app-graph-builder/extensions/spaces.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { AppCapabilities, AppNodeMatcher, getActiveSpace, getPersonalSpace, isExemplarSpace, isPersonalSpace } from "@dxos/app-toolkit";
+import { SpaceState as SpaceState2 } from "@dxos/client/echo";
+import { Operation } from "@dxos/compute";
+import { Filter as Filter2, Obj as Obj2 } from "@dxos/echo";
+import { AtomObj as AtomObj2, AtomQuery as AtomQuery2 } from "@dxos/echo-atom";
+import { Migrations as Migrations2 } from "@dxos/migrations";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import { CreateAtom, Graph, GraphBuilder, Node, NodeMatcher } from "@dxos/plugin-graph";
+import { SpaceArchive } from "@dxos/protocols/proto/dxos/client/services";
+import { Expando } from "@dxos/schema";
+import { meta as meta2 } from "#meta";
+import { SpaceOperation } from "#operations";
+import { SPACE_TYPE, SpaceCapabilities } from "#types";
+
+// src/capabilities/app-graph-builder/extensions/shared.ts
+import * as Option from "effect/Option";
+import { SpaceState, isSpace } from "@dxos/client/echo";
+import { Filter, Obj } from "@dxos/echo";
+import { AtomObj, AtomQuery } from "@dxos/echo-atom";
+import { Migrations } from "@dxos/migrations";
+import { ViewAnnotation, getTypenameFromQuery } from "@dxos/schema";
+import { meta } from "#meta";
+import { ACCEPT_ECHO_CLASS, CACHEABLE_PROPS, CAN_DROP_OBJECT, blockInstructionCache, buildCollectionPartials, collectionPartialsCache, createFactory, createObjectNode, getAcceptPersistenceKey, getCollectionGraphNodePartials, getDynamicLabel, rearrangeCache } from "@dxos/app-toolkit";
+var TYPES_SECTION_TYPE = `${meta.id}.types`;
+var COLLECTIONS_SECTION_TYPE = `${meta.id}.collections`;
+var TYPE_COLLECTION_TYPE = `${meta.id}.type-collection`;
+var STATIC_SCHEMA_TYPE = `${meta.id}.static-schema`;
+var META_NS = {
+  ns: meta.id
+};
+var BLOCK_REORDER_ABOVE = (_source, instruction) => instruction.type === "reorder-above";
+var CAN_DROP_SPACE = (source) => Obj.isObject(source.item.data) || isSpace(source.item.data);
+var spaceActionsCache = /* @__PURE__ */ new Map();
+var spaceRearrangeCache = /* @__PURE__ */ new Map();
+var ADD_VIEW_TO_SCHEMA_LABEL = [
+  "add-view-to-schema.label",
+  META_NS
+];
+var COPY_LINK_LABEL = [
+  "copy-link.label",
+  META_NS
+];
+var CREATE_OBJECT_IN_COLLECTION_LABEL = [
+  "create-object-in-collection.label",
+  META_NS
+];
+var CREATE_OBJECT_IN_SPACE_LABEL = [
+  "create-object-in-space.label",
+  META_NS
+];
+var EXPOSE_OBJECT_LABEL = [
+  "expose-object.label",
+  META_NS
+];
+var MIGRATE_SPACE_LABEL = [
+  "migrate-space.label",
+  META_NS
+];
+var REMOVE_FROM_COLLECTION_LABEL = [
+  "remove-from-collection.label",
+  META_NS
+];
+var RENAME_SPACE_LABEL = [
+  "rename-space.label",
+  META_NS
+];
+var SNAPSHOT_BY_SCHEMA_LABEL = [
+  "snapshot-by-schema.label",
+  META_NS
+];
+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 downloadBlob = async (blob, filename) => {
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = filename;
+  document.body.appendChild(anchor);
+  anchor.click();
+  document.body.removeChild(anchor);
+  URL.revokeObjectURL(url);
+};
+var buildViewIndex = (get, space, schemas) => {
+  const viewSchemas = schemas.filter((schema) => ViewAnnotation.has(schema));
+  const viewsByTypename = /* @__PURE__ */ new Map();
+  const viewObjectIds = /* @__PURE__ */ new Set();
+  if (viewSchemas.length > 0) {
+    const filter = Filter.or(...viewSchemas.map((schema) => Filter.type(schema)));
+    const viewObjects = get(AtomQuery.make(space.db, filter));
+    for (const viewObject of viewObjects) {
+      const holderSchema = Obj.getSchema(viewObject);
+      const path = holderSchema ? ViewAnnotation.get(holderSchema).pipe(Option.getOrElse(() => [])) : [];
+      if (path.length === 0) {
+        continue;
+      }
+      const viewSnapshot = get(AtomObj.make(viewObject));
+      let holder = viewSnapshot;
+      for (const segment of path) {
+        holder = holder == null || typeof holder !== "object" ? void 0 : holder[segment];
+      }
+      if (holder != null) {
+        viewObjectIds.add(viewObject.id);
+      }
+      const viewTarget = holder !== void 0 ? get(AtomObj.make(holder)) : void 0;
+      const typename = getTypenameFromQuery(viewTarget?.query?.ast);
+      if (typename) {
+        const existing = viewsByTypename.get(typename) ?? [];
+        existing.push(viewObject);
+        viewsByTypename.set(typename, existing);
+      }
+    }
+  }
+  return {
+    typenamesWithViews: new Set(viewsByTypename.keys()),
+    getViewsForTypename: (typename) => viewsByTypename.get(typename) ?? [],
+    isView: (object) => viewObjectIds.has(object.id)
+  };
+};
+
+// src/capabilities/app-graph-builder/extensions/spaces.ts
+var createSpaceExtensions = Effect.fnUntraced(function* () {
+  const capabilities = yield* Capability.Service;
+  return yield* Effect.all([
+    GraphBuilder.createExtension({
+      id: "primary-actions",
+      position: "first",
+      match: NodeMatcher.whenRoot,
+      actions: () => Effect.succeed([
+        Node.makeAction({
+          id: SpaceOperation.OpenCreateSpace.meta.key,
+          data: () => Operation.invoke(SpaceOperation.OpenCreateSpace),
+          properties: {
+            label: [
+              "create-space.label",
+              {
+                ns: meta2.id
+              }
+            ],
+            icon: "ph--plus--regular",
+            testId: "spacePlugin.createSpace",
+            disposition: "menu"
+          }
+        }),
+        Node.makeAction({
+          id: SpaceOperation.Join.meta.key,
+          data: () => Operation.invoke(SpaceOperation.Join, {}),
+          properties: {
+            label: [
+              "join-space.label",
+              {
+                ns: meta2.id
+              }
+            ],
+            icon: "ph--sign-in--regular",
+            testId: "spacePlugin.joinSpace",
+            disposition: "menu"
+          }
+        }),
+        Node.makeAction({
+          id: SpaceOperation.OpenImportSpace.meta.key,
+          data: () => Operation.invoke(SpaceOperation.OpenImportSpace),
+          properties: {
+            label: [
+              "import-space.label",
+              {
+                ns: meta2.id
+              }
+            ],
+            icon: "ph--upload--regular",
+            testId: "spacePlugin.importSpace"
+          }
+        }),
+        Node.makeAction({
+          id: `${SpaceOperation.ExportSpace.meta.key}.binary`,
+          data: Effect.fnUntraced(function* () {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+            if (space) {
+              yield* Operation.invoke(SpaceOperation.ExportSpace, {
+                space,
+                format: SpaceArchive.Format.BINARY
+              });
+            }
+          }),
+          properties: {
+            label: [
+              "export-space-binary.label",
+              {
+                ns: meta2.id
+              }
+            ],
+            icon: "ph--download--regular",
+            testId: "spacePlugin.exportSpaceBinary"
+          }
+        }),
+        Node.makeAction({
+          id: `${SpaceOperation.ExportSpace.meta.key}.json`,
+          data: Effect.fnUntraced(function* () {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+            if (space) {
+              yield* Operation.invoke(SpaceOperation.ExportSpace, {
+                space,
+                format: SpaceArchive.Format.JSON
+              });
+            }
+          }),
+          properties: {
+            label: [
+              "export-space-json.label",
+              {
+                ns: meta2.id
+              }
+            ],
+            icon: "ph--download--regular",
+            testId: "spacePlugin.exportSpaceJson"
+          }
+        }),
+        Node.makeAction({
+          id: SpaceOperation.OpenMembers.meta.key,
+          data: Effect.fnUntraced(function* () {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+            if (space) {
+              yield* Operation.invoke(SpaceOperation.OpenMembers, {
+                space
+              });
+            }
+          }),
+          properties: {
+            label: [
+              "share-space.label",
+              {
+                ns: meta2.id
+              }
+            ],
+            icon: "ph--users--regular",
+            testId: "spacePlugin.shareSpace",
+            keyBinding: {
+              macos: "meta+.",
+              windows: "alt+."
+            }
+          }
+        }),
+        Node.makeAction({
+          id: SpaceOperation.OpenSettings.meta.key,
+          data: Effect.fnUntraced(function* () {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+            if (space) {
+              yield* Operation.invoke(SpaceOperation.OpenSettings, {
+                space
+              });
+            }
+          }),
+          properties: {
+            label: [
+              "open-current-space-settings.label",
+              {
+                ns: meta2.id
+              }
+            ],
+            icon: "ph--faders--regular",
+            keyBinding: {
+              macos: "meta+shift+,",
+              windows: "ctrl+shift+,"
+            }
+          }
+        })
+      ])
+    }),
+    GraphBuilder.createExtension({
+      id: "spaces",
+      match: NodeMatcher.whenRoot,
+      connector: (_node, get) => {
+        const client = capabilities.get(ClientCapabilities.Client);
+        const stateAtom = capabilities.get(SpaceCapabilities.State);
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const spacesAtom = CreateAtom.fromObservable(client.spaces);
+        const spaces = get(spacesAtom);
+        const personalSpace = getPersonalSpace(client);
+        if (!spaces || !personalSpace) {
+          return Effect.succeed([]);
+        }
+        const settingsAtom = capabilities.get(SpaceCapabilities.Settings);
+        const settings = get(settingsAtom);
+        const state = get(stateAtom);
+        const ephemeralState = get(ephemeralAtom);
+        try {
+          const [spacesOrder] = get(AtomQuery2.make(personalSpace.db, Filter2.type(Expando.Expando, {
+            key: SHARED
+          })));
+          const { graph } = capabilities.get(AppCapabilities.AppGraph);
+          const spacesOrderSnapshot = spacesOrder ? get(AtomObj2.make(spacesOrder)) : void 0;
+          const order = spacesOrderSnapshot?.order ?? [];
+          const orderMap = new Map(order.map((id, index) => [
+            id,
+            index
+          ]));
+          const spaceStates = spaces.map((space) => get(CreateAtom.fromObservable(space.state)));
+          spaces.forEach((space) => {
+            if (space.state.get() === SpaceState2.SPACE_READY) {
+              get(AtomObj2.make(space.properties));
+            }
+          });
+          return Effect.succeed([
+            ...spaces.filter((space) => orderMap.has(space.id)).sort((sortA, sortB) => orderMap.get(sortA.id) - orderMap.get(sortB.id)),
+            ...spaces.filter((space) => !orderMap.has(space.id))
+          ].filter((space, idx) => settings?.showHidden ? true : spaceStates[idx] !== SpaceState2.SPACE_INACTIVE).filter((space) => space.tags.length === 0 || isPersonalSpace(space) || isExemplarSpace(space)).map((space) => constructSpaceNode({
+            space,
+            navigable: ephemeralState.navigableCollections,
+            personal: isPersonalSpace(space),
+            namesCache: state.spaceNames,
+            graph,
+            spacesOrder
+          })));
+        } catch {
+          return Effect.succeed([]);
+        }
+      }
+    }),
+    GraphBuilder.createExtension({
+      id: "actions",
+      match: AppNodeMatcher.whenSpace,
+      actions: (space, get) => {
+        const [client] = get(capabilities.atom(ClientCapabilities.Client));
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        if (!client) {
+          return Effect.succeed([]);
+        }
+        return Effect.succeed(constructSpaceActions({
+          space,
+          migrating: ephemeralState.sdkMigrationRunning[space.id]
+        }));
+      }
+    })
+  ]);
+});
+var constructSpaceNode = ({ space, navigable = false, personal, namesCache, graph, spacesOrder }) => {
+  const hasPendingMigration = checkPendingMigration(space);
+  let onRearrange;
+  if (graph && spacesOrder) {
+    onRearrange = spaceRearrangeCache.get(space.id);
+    if (!onRearrange) {
+      onRearrange = (nextOrder) => {
+        Graph.sortEdges(graph, Node.RootId, "outbound", nextOrder.map(({ id }) => id));
+        Obj2.update(spacesOrder, (spacesOrder2) => {
+          spacesOrder2.order = nextOrder.map(({ id }) => id);
+        });
+      };
+      spaceRearrangeCache.set(space.id, onRearrange);
+    }
+  }
+  return Node.make({
+    id: space.id,
+    type: SPACE_TYPE,
+    cacheable: CACHEABLE_PROPS,
+    data: space,
+    properties: {
+      label: getSpaceDisplayName(space, {
+        personal,
+        namesCache
+      }),
+      description: space.state.get() === SpaceState2.SPACE_READY && space.properties.description,
+      hue: space.state.get() === SpaceState2.SPACE_READY && space.properties.hue,
+      icon: space.state.get() === SpaceState2.SPACE_READY && space.properties.icon ? `ph--${space.properties.icon}--regular` : void 0,
+      iconHue: space.state.get() === SpaceState2.SPACE_READY && space.properties.iconHue,
+      disabled: !navigable || space.state.get() !== SpaceState2.SPACE_READY || hasPendingMigration,
+      disposition: "workspace",
+      testId: "spacePlugin.space",
+      onRearrange,
+      canDrop: CAN_DROP_SPACE
+    }
+  });
+};
+var constructSpaceActions = ({ space, migrating }) => {
+  const state = space.state.get();
+  const hasPendingMigration = checkPendingMigration(space);
+  const isMigrating = migrating || Migrations2.running(space);
+  const cached = spaceActionsCache.get(space.id);
+  if (cached && cached.state === state && cached.hasPendingMigration === hasPendingMigration && cached.migrating === isMigrating) {
+    return cached.actions;
+  }
+  const actions = [];
+  if (hasPendingMigration) {
+    actions.push(Node.make({
+      id: SpaceOperation.Migrate.meta.key,
+      type: Node.ActionGroupType,
+      data: () => Operation.invoke(SpaceOperation.Migrate, {
+        space
+      }),
+      properties: {
+        label: MIGRATE_SPACE_LABEL,
+        icon: "ph--database--regular",
+        disposition: "list-item-primary",
+        disabled: isMigrating
+      }
+    }));
+  }
+  if (state === SpaceState2.SPACE_READY && !hasPendingMigration) {
+    actions.push(Node.makeAction({
+      id: SpaceOperation.OpenCreateObject.meta.key,
+      data: () => Operation.invoke(SpaceOperation.OpenCreateObject, {
+        target: space.db
+      }),
+      properties: {
+        label: CREATE_OBJECT_IN_SPACE_LABEL,
+        icon: "ph--plus--regular",
+        disposition: "list-item-primary",
+        testId: "spacePlugin.createObject"
+      }
+    }), Node.makeAction({
+      id: SpaceOperation.Rename.meta.key,
+      data: (params) => Operation.invoke(SpaceOperation.Rename, {
+        space,
+        caller: `${params?.caller}:${params?.parent?.id}`
+      }),
+      properties: {
+        label: RENAME_SPACE_LABEL,
+        icon: "ph--pencil-simple-line--regular",
+        keyBinding: {
+          macos: "shift+F6",
+          windows: "shift+F6"
+        }
+      }
+    }));
+  }
+  spaceActionsCache.set(space.id, {
+    state,
+    hasPendingMigration,
+    migrating: isMigrating,
+    actions
+  });
+  return actions;
+};
+
+// src/capabilities/app-graph-builder/extensions/types.ts
+import * as Effect2 from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Option2 from "effect/Option";
+import * as Schema from "effect/Schema";
+import { Capability as Capability2 } from "@dxos/app-framework";
+import { AppNode, AppNodeMatcher as AppNodeMatcher2, LayoutOperation, Segments } from "@dxos/app-toolkit";
+import { SpaceState as SpaceState3, isSpace as isSpace2 } from "@dxos/client/echo";
+import { Operation as Operation2 } from "@dxos/compute";
+import { Annotation, Collection, Filter as Filter3, Obj as Obj3, Query, Type } from "@dxos/echo";
+import { AtomObj as AtomObj3, AtomQuery as AtomQuery3 } from "@dxos/echo-atom";
+import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from "@dxos/echo/internal";
+import { ClientCapabilities as ClientCapabilities2 } from "@dxos/plugin-client";
+import { CreateAtom as CreateAtom2, GraphBuilder as GraphBuilder2, Node as Node2 } from "@dxos/plugin-graph";
+import { ViewAnnotation as ViewAnnotation2 } from "@dxos/schema";
+import { createFilename, isNonNullable } from "@dxos/util";
+import { meta as meta3 } from "#meta";
+import { SpaceOperation as SpaceOperation2 } from "#operations";
+import { SpaceCapabilities as SpaceCapabilities2 } from "#types";
+var createTypeExtensions = Effect2.fnUntraced(function* () {
+  const capabilities = yield* Capability2.Service;
+  return yield* Effect2.all([
+    // Types section virtual node under each space.
+    GraphBuilder2.createExtension({
+      id: "types-section",
+      match: AppNodeMatcher2.whenSpace,
+      connector: (space, get) => {
+        const spaceState = get(CreateAtom2.fromObservable(space.state));
+        if (spaceState !== SpaceState3.SPACE_READY) {
+          return Effect2.succeed([]);
+        }
+        return Effect2.succeed([
+          AppNode.makeSection({
+            id: Segments.types,
+            type: TYPES_SECTION_TYPE,
+            label: [
+              "types-section.label",
+              {
+                ns: meta3.id
+              }
+            ],
+            icon: "ph--database--regular",
+            space,
+            position: "last",
+            testId: "spacePlugin.typesSection"
+          })
+        ]);
+      }
+    }),
+    // Schema nodes under the Types virtual node.
+    GraphBuilder2.createExtension({
+      id: "types",
+      match: (node) => {
+        const space = isSpace2(node.properties.space) ? node.properties.space : void 0;
+        return node.type === TYPES_SECTION_TYPE && space ? Option2.some(space) : Option2.none();
+      },
+      connector: (space, get) => {
+        const allSchemas = get(AtomQuery3.fromQuery(space.db.schemaRegistry.query({
+          location: [
+            "database",
+            "runtime"
+          ]
+        })));
+        const userSchemas = allSchemas.filter((schema) => {
+          if (getTypeAnnotation(schema)?.kind === EntityKind.Relation) {
+            return false;
+          }
+          if (SystemTypeAnnotation.get(schema).pipe(Option2.getOrElse(() => false))) {
+            return false;
+          }
+          if (Type.getTypename(schema) === Collection.Collection.typename) {
+            return false;
+          }
+          return true;
+        });
+        const viewIndex = buildViewIndex(get, space, allSchemas);
+        const visibleSchemas = userSchemas.filter((schema) => {
+          if (Type.isMutable(schema)) {
+            return true;
+          }
+          const typename = Type.getTypename(schema);
+          const objects = get(AtomQuery3.make(space.db, Filter3.typename(typename)));
+          if (ViewAnnotation2.has(schema)) {
+            return objects.some((obj) => !viewIndex.isView(obj));
+          }
+          return objects.length > 0 || viewIndex.typenamesWithViews.has(typename);
+        });
+        return Effect2.succeed(visibleSchemas.map((schema) => createSchemaNode({
+          schema,
+          space,
+          get
+        })));
+      }
+    }),
+    // {All} virtual node + view objects under each schema node.
+    GraphBuilder2.createExtension({
+      id: "schema-children",
+      match: (node) => {
+        const space = isSpace2(node.properties.space) ? node.properties.space : void 0;
+        return space && (Obj3.instanceOf(Type.PersistentType, node.data) || Schema.isSchema(node.data)) ? Option2.some({
+          space,
+          schema: node.data
+        }) : Option2.none();
+      },
+      connector: ({ space, schema }, get) => {
+        const client = get(capabilities.atom(ClientCapabilities2.Client)).at(0);
+        const schemas = client ? get(AtomQuery3.fromQuery(client.graph.schemaRegistry.query({
+          location: [
+            "runtime"
+          ]
+        }))) : [];
+        const typename = Schema.isSchema(schema) ? Type.getTypename(schema) : schema.typename;
+        const allNode = Node2.make({
+          id: "all",
+          type: TYPE_COLLECTION_TYPE,
+          data: {
+            space,
+            typename
+          },
+          properties: {
+            label: [
+              "type-collection-all.label",
+              {
+                ns: meta3.id
+              }
+            ],
+            icon: "ph--list--regular",
+            iconHue: "neutral",
+            role: "branch",
+            testId: `spacePlugin.typeCollectionAll.${typename}`,
+            selectable: false,
+            draggable: false,
+            droppable: false,
+            childrenDroppable: false,
+            blockInstruction: BLOCK_REORDER_ABOVE
+          }
+        });
+        const viewIndex = buildViewIndex(get, space, schemas);
+        const viewNodes = viewIndex.getViewsForTypename(typename).map((object) => createObjectNode({
+          db: space.db,
+          object,
+          droppable: false
+        })).filter(isNonNullable);
+        return Effect2.succeed([
+          allNode,
+          ...viewNodes
+        ]);
+      }
+    }),
+    // Objects of the schema type under the {All} node.
+    GraphBuilder2.createExtension({
+      id: "type-collection-objects",
+      match: (node) => {
+        if (node.type !== TYPE_COLLECTION_TYPE || !node.data?.space || !node.data?.typename) {
+          return Option2.none();
+        }
+        return Option2.some({
+          space: node.data.space,
+          typename: node.data.typename
+        });
+      },
+      connector: ({ space, typename }, get) => {
+        const client = get(capabilities.atom(ClientCapabilities2.Client)).at(0);
+        const schemas = client ? get(AtomQuery3.fromQuery(client.graph.schemaRegistry.query({
+          location: [
+            "runtime"
+          ]
+        }))) : [];
+        const viewIndex = buildViewIndex(get, space, schemas);
+        const objects = get(AtomQuery3.make(space.db, Filter3.typename(typename))).filter((object) => !viewIndex.isView(object));
+        return Effect2.succeed(objects.map((object) => {
+          get(AtomObj3.make(object));
+          return createObjectNode({
+            db: space.db,
+            object,
+            droppable: false
+          });
+        }).filter(isNonNullable).toSorted((nodeA, nodeB) => {
+          const labelA = typeof nodeA.properties.label === "string" ? nodeA.properties.label : "";
+          const labelB = typeof nodeB.properties.label === "string" ? nodeB.properties.label : "";
+          return labelA.localeCompare(labelB);
+        }));
+      }
+    }),
+    // Actions for schema nodes.
+    GraphBuilder2.createExtension({
+      id: "schema-actions",
+      match: (node) => {
+        const space = isSpace2(node.properties.space) ? node.properties.space : void 0;
+        return space && Schema.isSchema(node.data) ? Option2.some({
+          space,
+          schema: node.data
+        }) : Option2.none();
+      },
+      actions: ({ space, schema }, get) => {
+        const client = get(capabilities.atom(ClientCapabilities2.Client)).at(0);
+        const schemas = client ? get(AtomQuery3.fromQuery(client.graph.schemaRegistry.query({
+          location: [
+            "runtime"
+          ]
+        }))) : [];
+        const targetTypename = Type.getTypename(schema);
+        const viewIndex = buildViewIndex(get, space, schemas);
+        const deletable = Type.isMutable(schema) && viewIndex.getViewsForTypename(targetTypename).length === 0;
+        return Effect2.succeed(createSchemaActions({
+          schema,
+          space,
+          deletable,
+          capabilities
+        }));
+      }
+    })
+  ]);
+});
+var createSchemaNode = ({ schema, space, get }) => {
+  const typename = Type.getTypename(schema);
+  const iconAnnotation = !Type.isMutable(schema) ? Option2.getOrUndefined(Annotation.IconAnnotation.get(schema)) : void 0;
+  const { label, nodeId } = Match.value(schema).pipe(Match.when(Type.isMutable, (mutableSchema) => {
+    const persistentSchema = mutableSchema.persistentSchema;
+    const snapshot = get(AtomObj3.make(persistentSchema));
+    return {
+      label: snapshot.name || [
+        "object-name.placeholder",
+        {
+          ns: Type.PersistentType.typename
+        }
+      ],
+      nodeId: typename
+    };
+  }), Match.orElse(() => ({
+    label: getDynamicLabel("typename.label", typename, {
+      count: 2,
+      defaultValue: typename
+    }),
+    nodeId: typename
+  })));
+  const icon = Type.isMutable(schema) ? "ph--cube--regular" : iconAnnotation?.icon ?? "ph--placeholder--regular";
+  const iconHue = Type.isMutable(schema) ? "neutral" : iconAnnotation?.hue;
+  return Node2.make({
+    id: nodeId,
+    type: STATIC_SCHEMA_TYPE,
+    data: schema,
+    properties: {
+      label,
+      icon,
+      iconHue,
+      role: "branch",
+      testId: `spacePlugin.schemaNode.${typename}`,
+      selectable: false,
+      draggable: false,
+      droppable: false,
+      childrenDroppable: false,
+      space
+    }
+  });
+};
+var createSchemaActions = ({ schema, space, deletable, capabilities }) => {
+  const typename = Type.getTypename(schema);
+  const createEntry = capabilities.getAll(SpaceCapabilities2.CreateObjectEntry).find((entry) => entry.id === typename);
+  const createObjectFn = createEntry?.createObject;
+  const inputSchema = createEntry?.inputSchema;
+  const actions = [
+    ...createObjectFn ? [
+      Node2.makeAction({
+        id: SpaceOperation2.OpenCreateObject.meta.key,
+        data: Effect2.fnUntraced(function* () {
+          if (inputSchema) {
+            yield* Operation2.invoke(SpaceOperation2.OpenCreateObject, {
+              target: space.db,
+              typename
+            });
+          } else {
+            const result = yield* createObjectFn({}, {
+              db: space.db,
+              target: space.db
+            }).pipe(Effect2.provideService(Capability2.Service, capabilities));
+            if (result.subject.length > 0) {
+              yield* Operation2.invoke(LayoutOperation.Open, {
+                subject: [
+                  ...result.subject
+                ],
+                navigation: "immediate"
+              });
+            }
+          }
+        }),
+        properties: {
+          label: getDynamicLabel("add object label", typename),
+          icon: "ph--plus--regular",
+          disposition: "list-item-primary",
+          testId: "spacePlugin.createObject"
+        }
+      })
+    ] : [],
+    Node2.makeAction({
+      id: `${SpaceOperation2.AddObject.meta.key}-view`,
+      data: () => Operation2.invoke(SpaceOperation2.OpenCreateObject, {
+        target: space.db,
+        views: true,
+        initialFormValues: {
+          typename: Type.getTypename(schema)
+        }
+      }),
+      properties: {
+        label: ADD_VIEW_TO_SCHEMA_LABEL,
+        icon: "ph--circles-three-plus--regular",
+        disposition: "list-item",
+        testId: "spacePlugin.addViewToSchema"
+      }
+    }),
+    Node2.makeAction({
+      id: SpaceOperation2.RenameObject.meta.key,
+      data: (params) => Type.isMutable(schema) ? Operation2.invoke(SpaceOperation2.RenameObject, {
+        object: schema.persistentSchema,
+        caller: `${params?.caller}:${params?.parent?.id}`
+      }) : Effect2.fail(new Error("Cannot rename immutable schema")),
+      properties: {
+        label: getDynamicLabel("rename-object.label", Type.getTypename(Type.PersistentType)),
+        icon: "ph--pencil-simple-line--regular",
+        disabled: !Type.isMutable(schema),
+        disposition: "list-item",
+        testId: "spacePlugin.renameObject"
+      }
+    }),
+    Node2.makeAction({
+      id: SpaceOperation2.RemoveObjects.meta.key,
+      data: () => Type.isMutable(schema) ? Operation2.invoke(SpaceOperation2.RemoveObjects, {
+        objects: [
+          schema.persistentSchema
+        ]
+      }) : Effect2.succeed(void 0),
+      properties: {
+        label: getDynamicLabel("delete object label", Type.getTypename(Type.PersistentType)),
+        icon: "ph--trash--regular",
+        disposition: "list-item",
+        disabled: !deletable,
+        testId: "spacePlugin.deleteObject"
+      }
+    }),
+    Node2.makeAction({
+      id: SpaceOperation2.Snapshot.meta.key,
+      data: Effect2.fnUntraced(function* () {
+        const result = yield* Operation2.invoke(SpaceOperation2.Snapshot, {
+          db: space.db,
+          query: Query.select(Filter3.type(schema)).ast
+        });
+        if (result.snapshot) {
+          yield* Effect2.tryPromise(() => downloadBlob(result.snapshot, createFilename({
+            parts: [
+              space.id,
+              Type.getTypename(schema)
+            ],
+            ext: "json"
+          })));
+        }
+      }),
+      properties: {
+        label: SNAPSHOT_BY_SCHEMA_LABEL,
+        icon: "ph--camera--regular",
+        disposition: "list-item"
+      }
+    })
+  ];
+  return actions;
+};
+
+// src/capabilities/app-graph-builder/extensions/collections.ts
+import * as Effect3 from "effect/Effect";
+import * as Option3 from "effect/Option";
+import { Capabilities, Capability as Capability3 } from "@dxos/app-framework";
+import { AppCapabilities as AppCapabilities2, AppNodeMatcher as AppNodeMatcher3, LayoutOperation as LayoutOperation2, Segments as Segments2, getObjectPathFromObject, toUrlPath } from "@dxos/app-toolkit";
+import { SpaceState as SpaceState4, isSpace as isSpace3 } from "@dxos/client/echo";
+import { Operation as Operation3 } from "@dxos/compute";
+import { Collection as Collection2, Obj as Obj4, Type as Type2 } from "@dxos/echo";
+import { AtomObj as AtomObj4 } from "@dxos/echo-atom";
+import { invariant } from "@dxos/invariant";
+import { CreateAtom as CreateAtom3, Graph as Graph2, GraphBuilder as GraphBuilder3, Node as Node3 } from "@dxos/plugin-graph";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+import { meta as meta4 } from "#meta";
+import { SpaceOperation as SpaceOperation3 } from "#operations";
+import { SpaceCapabilities as SpaceCapabilities3 } from "#types";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/capabilities/app-graph-builder/extensions/collections.ts";
+var createCollectionExtensions = Effect3.fnUntraced(function* ({ shareableLinkOrigin }) {
+  const capabilities = yield* Capability3.Service;
+  return yield* Effect3.all([
+    // Collections section virtual node under each space.
+    GraphBuilder3.createExtension({
+      id: "collections-section",
+      match: AppNodeMatcher3.whenSpace,
+      connector: (space, get) => {
+        const spaceState = get(CreateAtom3.fromObservable(space.state));
+        if (spaceState !== SpaceState4.SPACE_READY) {
+          return Effect3.succeed([]);
+        }
+        const propertiesSnapshot = get(AtomObj4.make(space.properties));
+        const collectionRef = propertiesSnapshot[Collection2.Collection.typename];
+        if (collectionRef) {
+          get(AtomObj4.make(collectionRef));
+        }
+        const rootCollection = collectionRef?.target;
+        const collectionPartials = rootCollection ? getCollectionGraphNodePartials({
+          db: space.db,
+          collection: rootCollection
+        }) : void 0;
+        return Effect3.succeed([
+          Node3.make({
+            id: Segments2.collections,
+            type: COLLECTIONS_SECTION_TYPE,
+            data: null,
+            properties: {
+              label: [
+                "collections-section.label",
+                {
+                  ns: meta4.id
+                }
+              ],
+              icon: "ph--folder--regular",
+              iconHue: "amber",
+              role: "branch",
+              position: "first",
+              testId: "spacePlugin.collectionsSection",
+              draggable: false,
+              droppable: false,
+              space,
+              ...collectionPartials
+            }
+          })
+        ]);
+      }
+    }),
+    // Root collection objects under the Collections virtual node.
+    GraphBuilder3.createExtension({
+      id: "collections",
+      match: (node) => {
+        const space = isSpace3(node.properties.space) ? node.properties.space : void 0;
+        return node.type === COLLECTIONS_SECTION_TYPE && space ? Option3.some(space) : Option3.none();
+      },
+      connector: (space, get) => {
+        const ephemeralAtom = capabilities.get(SpaceCapabilities3.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        const propertiesSnapshot = get(AtomObj4.make(space.properties));
+        const collectionRef = propertiesSnapshot[Collection2.Collection.typename];
+        const collection = collectionRef ? get(AtomObj4.make(collectionRef)) : void 0;
+        if (!collection) {
+          return Effect3.succeed([]);
+        }
+        const rawRefs = collection.objects ?? [];
+        const objects = rawRefs.map((ref) => {
+          get(AtomObj4.make(ref));
+          return ref.target;
+        }).filter(isNonNullable2);
+        return Effect3.succeed(objects.map((object) => createObjectNode({
+          db: space.db,
+          object,
+          navigable: ephemeralState.navigableCollections,
+          parentCollection: collectionRef?.target
+        })).filter(isNonNullable2));
+      }
+    }),
+    // Children of Collection.Collection nodes.
+    GraphBuilder3.createExtension({
+      id: "objects",
+      match: (node) => Obj4.instanceOf(Collection2.Collection, node.data) ? Option3.some(node.data) : Option3.none(),
+      connector: (collection, get) => {
+        const ephemeralAtom = capabilities.get(SpaceCapabilities3.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        const db = Obj4.getDatabase(collection);
+        const collectionSnapshot = get(AtomObj4.make(collection));
+        const refs = collectionSnapshot.objects ?? [];
+        const objects = refs.map((ref) => {
+          get(AtomObj4.make(ref));
+          return ref.target;
+        }).filter(isNonNullable2);
+        return Effect3.succeed(objects.map((object) => db && createObjectNode({
+          object,
+          db,
+          navigable: ephemeralState.navigableCollections,
+          parentCollection: collection
+        })).filter(isNonNullable2));
+      }
+    }),
+    // Object actions.
+    GraphBuilder3.createExtension({
+      id: "object-actions",
+      match: (node) => {
+        return Obj4.isObject(node.data) && Obj4.getTypename(node.data) === node.type && Obj4.getDatabase(node.data) ? Option3.some({
+          object: node.data,
+          nodeId: node.id
+        }) : Option3.none();
+      },
+      actions: ({ object, nodeId }, get) => {
+        const deletable = !Obj4.instanceOf(Type2.PersistentType, object);
+        const [appGraph] = get(capabilities.atom(AppCapabilities2.AppGraph));
+        const ephemeralAtom = capabilities.get(SpaceCapabilities3.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        if (!appGraph) {
+          return Effect3.succeed([]);
+        }
+        const parentId = nodeId.substring(0, nodeId.lastIndexOf("/"));
+        const parentNode = Option3.getOrUndefined(Graph2.getNode(appGraph.graph, parentId));
+        const parentCollection = parentNode && Obj4.instanceOf(Collection2.Collection, parentNode.data) ? parentNode.data : void 0;
+        return Effect3.succeed(constructObjectActions({
+          object,
+          nodeId,
+          deletable,
+          navigable: ephemeralState.navigableCollections,
+          shareableLinkOrigin,
+          parentCollection
+        }));
+      }
+    })
+  ]);
+});
+var constructObjectActions = ({ object, nodeId, deletable = true, navigable = false, shareableLinkOrigin, parentCollection }) => {
+  const db = Obj4.getDatabase(object);
+  invariant(db, "Database not found", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 158, S: void 0, A: ["db", "'Database not found'"] });
+  const typename = Obj4.getTypename(object);
+  invariant(typename, "Object has no typename", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 160, S: void 0, A: ["typename", "'Object has no typename'"] });
+  const actions = [
+    ...Obj4.instanceOf(Collection2.Collection, object) ? [
+      Node3.makeAction({
+        id: SpaceOperation3.OpenCreateObject.meta.key,
+        data: () => Operation3.invoke(SpaceOperation3.OpenCreateObject, {
+          target: object,
+          targetNodeId: nodeId
+        }),
+        properties: {
+          label: CREATE_OBJECT_IN_COLLECTION_LABEL,
+          icon: "ph--plus--regular",
+          disposition: "list-item-primary",
+          testId: "spacePlugin.createObject"
+        }
+      })
+    ] : [],
+    Node3.makeAction({
+      id: SpaceOperation3.RenameObject.meta.key,
+      data: (params) => Operation3.invoke(SpaceOperation3.RenameObject, {
+        object,
+        caller: `${params?.caller}:${params?.parent?.id}`
+      }),
+      properties: {
+        label: getDynamicLabel("rename-object.label", typename, {
+          defaultValue: "Rename"
+        }),
+        icon: "ph--pencil-simple-line--regular",
+        disposition: "list-item",
+        testId: "spacePlugin.renameObject"
+      }
+    }),
+    ...parentCollection && !Obj4.instanceOf(Collection2.Collection, object) ? [
+      Node3.makeAction({
+        id: "remove-from-collection",
+        data: () => Effect3.gen(function* () {
+          const index = parentCollection.objects.findIndex((ref) => ref.target === object);
+          if (index !== -1) {
+            const layout = yield* Capabilities.getAtomValue(AppCapabilities2.Layout);
+            const isActive = layout.active.includes(nodeId);
+            Obj4.update(parentCollection, (parentCollection2) => {
+              parentCollection2.objects.splice(index, 1);
+            });
+            if (isActive) {
+              yield* Operation3.invoke(LayoutOperation2.Open, {
+                subject: [
+                  getObjectPathFromObject(object)
+                ]
+              });
+            }
+          }
+        }),
+        properties: {
+          label: REMOVE_FROM_COLLECTION_LABEL,
+          icon: "ph--minus-circle--regular",
+          disposition: "list-item",
+          testId: "spacePlugin.removeFromCollection"
+        }
+      })
+    ] : [],
+    Node3.makeAction({
+      id: SpaceOperation3.RemoveObjects.meta.key,
+      data: () => Operation3.invoke(SpaceOperation3.RemoveObjects, {
+        objects: [
+          object
+        ],
+        target: parentCollection
+      }),
+      properties: {
+        label: getDynamicLabel("delete object label", typename, {
+          defaultValue: "Delete"
+        }),
+        icon: "ph--trash--regular",
+        disposition: "list-item",
+        disabled: !deletable,
+        testId: "spacePlugin.deleteObject"
+      }
+    }),
+    ...navigable || !Obj4.instanceOf(Collection2.Collection, object) ? [
+      Node3.makeAction({
+        id: "copy-link",
+        data: () => Effect3.promise(async () => {
+          const url = new URL(toUrlPath(nodeId), shareableLinkOrigin);
+          await navigator.clipboard.writeText(url.toString());
+        }),
+        properties: {
+          label: COPY_LINK_LABEL,
+          icon: "ph--link--regular",
+          disposition: "list-item",
+          testId: "spacePlugin.copyLink"
+        }
+      })
+    ] : [],
+    Node3.makeAction({
+      id: LayoutOperation2.Expose.meta.key,
+      data: () => Operation3.invoke(LayoutOperation2.Expose, {
+        subject: getObjectPathFromObject(object)
+      }),
+      properties: {
+        label: EXPOSE_OBJECT_LABEL,
+        icon: "ph--eye--regular",
+        disposition: "heading-list-item",
+        testId: "spacePlugin.exposeObject"
+      }
+    })
+  ];
+  return actions;
+};
+
+// src/capabilities/app-graph-builder/extensions/companions.ts
+import * as Effect4 from "effect/Effect";
+import * as Option4 from "effect/Option";
+import { AppNode as AppNode2 } from "@dxos/app-toolkit";
+import { Obj as Obj5 } from "@dxos/echo";
+import { GraphBuilder as GraphBuilder4, NodeMatcher as NodeMatcher2 } from "@dxos/plugin-graph";
+import { linkedSegment } from "@dxos/react-ui-attention";
+import { ViewAnnotation as ViewAnnotation3 } from "@dxos/schema";
+import { meta as meta5 } from "#meta";
+var createCompanionExtensions = Effect4.fnUntraced(function* () {
+  return yield* Effect4.all([
+    // Object settings plank companion.
+    GraphBuilder4.createExtension({
+      id: "settings",
+      match: NodeMatcher2.whenEchoObjectMatches,
+      connector: (node) => Effect4.succeed([
+        AppNode2.makeCompanion({
+          id: linkedSegment("settings"),
+          label: [
+            "object-properties.label",
+            {
+              ns: meta5.id
+            }
+          ],
+          icon: "ph--sliders--regular",
+          data: "settings",
+          position: "last"
+        })
+      ])
+    }),
+    // Related objects plank companion.
+    GraphBuilder4.createExtension({
+      id: "related",
+      match: NodeMatcher2.whenEchoObjectMatches,
+      connector: (node) => Effect4.succeed([
+        AppNode2.makeCompanion({
+          id: linkedSegment("related"),
+          label: [
+            "companion-related.label",
+            {
+              ns: meta5.id
+            }
+          ],
+          icon: "ph--graph--regular",
+          data: "related",
+          position: "last"
+        })
+      ])
+    }),
+    // View selected objects companion.
+    GraphBuilder4.createExtension({
+      id: "selected-objects",
+      match: (node) => {
+        if (!Obj5.isObject(node.data)) {
+          return Option4.none();
+        }
+        const schema = Obj5.getSchema(node.data);
+        const path = schema ? ViewAnnotation3.get(schema).pipe(Option4.getOrElse(() => [])) : [];
+        const isEchoViewBacked = schema && path.length > 0 ? ViewAnnotation3.hasRefAlongPath(node.data, path) : false;
+        if (!isEchoViewBacked) {
+          return Option4.none();
+        }
+        return Option4.some(node);
+      },
+      connector: (node) => Effect4.succeed([
+        AppNode2.makeCompanion({
+          id: linkedSegment("selected-objects"),
+          label: [
+            "companion-selected-objects.label",
+            {
+              ns: meta5.id
+            }
+          ],
+          icon: "ph--tree-view--regular",
+          data: "selected-objects"
+        })
+      ])
+    })
+  ]);
+});
+
+// src/capabilities/app-graph-builder/extensions/settings.ts
+import * as Effect5 from "effect/Effect";
+import * as Option5 from "effect/Option";
+import { AppNode as AppNode3, AppNodeMatcher as AppNodeMatcher4, isPersonalSpace as isPersonalSpace2 } from "@dxos/app-toolkit";
+import { isSpace as isSpace4 } from "@dxos/client/echo";
+import { GraphBuilder as GraphBuilder5, Node as Node4 } from "@dxos/plugin-graph";
+import { meta as meta6 } from "#meta";
+import { SETTINGS_SECTION_TYPE } from "#types";
+var createSettingsExtensions = Effect5.fnUntraced(function* () {
+  const sectionExtension = yield* GraphBuilder5.createExtension({
+    id: "settings-section",
+    match: AppNodeMatcher4.whenSpace,
+    connector: (space) => Effect5.succeed([
+      AppNode3.makeSection({
+        id: "settings",
+        type: SETTINGS_SECTION_TYPE,
+        label: [
+          "settings-section.label",
+          {
+            ns: meta6.id
+          }
+        ],
+        icon: "ph--sliders--regular",
+        iconHue: "indigo",
+        space,
+        position: "first",
+        testId: "spacePlugin.settings"
+      })
+    ])
+  });
+  const childrenExtension = yield* GraphBuilder5.createExtension({
+    id: "settings-sections",
+    match: (node) => {
+      const space = isSpace4(node.properties.space) ? node.properties.space : void 0;
+      return node.type === SETTINGS_SECTION_TYPE && space ? Option5.some(space) : Option5.none();
+    },
+    connector: (space) => {
+      const personal = isPersonalSpace2(space);
+      return Effect5.succeed([
+        Node4.make({
+          id: "general",
+          type: `${meta6.id}.general`,
+          data: `${meta6.id}.general`,
+          properties: {
+            label: [
+              "space-settings-properties.label",
+              {
+                ns: meta6.id
+              }
+            ],
+            icon: "ph--brackets-curly--regular",
+            iconHue: "indigo",
+            space,
+            testId: "spacePlugin.general"
+          }
+        }),
+        ...!personal ? [
+          Node4.make({
+            id: "members",
+            type: `${meta6.id}.members`,
+            data: `${meta6.id}.members`,
+            properties: {
+              label: [
+                "members-panel.label",
+                {
+                  ns: meta6.id
+                }
+              ],
+              icon: "ph--users--regular",
+              iconHue: "indigo",
+              space,
+              testId: "spacePlugin.members"
+            }
+          })
+        ] : []
+      ]);
+    }
+  });
+  return [
+    sectionExtension,
+    childrenExtension
+  ];
+});
+
+// src/capabilities/app-graph-builder/app-graph-builder.ts
+var app_graph_builder_default = Capability4.makeModule(Effect6.fnUntraced(function* ({ shareableLinkOrigin = window.location.origin } = {}) {
+  const extensions = yield* Effect6.all([
+    createSpaceExtensions(),
+    createSettingsExtensions(),
+    createTypeExtensions(),
+    createCollectionExtensions({
+      shareableLinkOrigin
+    }),
+    createCompanionExtensions()
+  ]);
+  return Capability4.contributes(AppCapabilities3.AppGraphBuilder, extensions.flat());
+}));
+export {
+  app_graph_builder_default as default
+};
+//# sourceMappingURL=app-graph-builder-FLUXDLKV.mjs.map