@dxos/plugin-space 0.8.4-main.c4373fc → 0.8.4-main.d05673bc65

package/dist/lib/node-esm/app-graph-builder-WTM6SSX7.mjs

@@ -0,0 +1,1204 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  getActiveSpace
+} from "./chunk-2OLR2ZKH.mjs";
+import {
+  SHARED,
+  getSpaceDisplayName
+} from "./chunk-GEGWQVZX.mjs";
+import {
+  SPACE_TYPE,
+  SpaceCapabilities,
+  SpaceOperation
+} from "./chunk-EVNSLSQS.mjs";
+import {
+  meta
+} from "./chunk-63N5JJXI.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 AppCapabilities4 } 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 } from "@dxos/app-toolkit";
+import { SpaceState as SpaceState2 } from "@dxos/client/echo";
+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 { Operation } from "@dxos/operation";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import { CreateAtom, Graph, GraphBuilder, Node, NodeMatcher } from "@dxos/plugin-graph";
+import { Expando } from "@dxos/schema";
+
+// 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 { 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 whenSpace = (node) => node.type === SPACE_TYPE && isSpace(node.data) ? Option.some(node.data) : Option.none();
+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 SETTINGS_PANEL_LABEL = [
+  "settings panel 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.get(schema).pipe(Option.getOrElse(() => false)));
+  const viewsByTypename = /* @__PURE__ */ new Map();
+  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 viewSnapshot = get(AtomObj.make(viewObject));
+      const viewRef = viewSnapshot.view;
+      const viewTarget = viewRef ? get(AtomObj.make(viewRef)) : 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) ?? []
+  };
+};
+
+// 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: `${meta.id}.primary-actions`,
+      position: "hoist",
+      match: NodeMatcher.whenRoot,
+      actions: () => Effect.succeed([
+        {
+          id: SpaceOperation.OpenCreateSpace.meta.key,
+          data: () => Operation.invoke(SpaceOperation.OpenCreateSpace),
+          properties: {
+            label: [
+              "create space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--plus--regular",
+            testId: "spacePlugin.createSpace",
+            disposition: "menu"
+          }
+        },
+        {
+          id: SpaceOperation.Join.meta.key,
+          data: () => Operation.invoke(SpaceOperation.Join, {}),
+          properties: {
+            label: [
+              "join space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--sign-in--regular",
+            testId: "spacePlugin.joinSpace",
+            disposition: "menu"
+          }
+        },
+        {
+          id: SpaceOperation.OpenMembers.meta.key,
+          data: Effect.fnUntraced(function* () {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = getActiveSpace(capabilities) ?? client.spaces.default;
+            yield* Operation.invoke(SpaceOperation.OpenMembers, {
+              space
+            });
+          }),
+          properties: {
+            label: [
+              "share space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--users--regular",
+            testId: "spacePlugin.shareSpace",
+            keyBinding: {
+              macos: "meta+.",
+              windows: "alt+."
+            }
+          }
+        },
+        {
+          id: SpaceOperation.OpenSettings.meta.key,
+          data: Effect.fnUntraced(function* () {
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = getActiveSpace(capabilities) ?? client.spaces.default;
+            yield* Operation.invoke(SpaceOperation.OpenSettings, {
+              space
+            });
+          }),
+          properties: {
+            label: [
+              "open current space settings label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--faders--regular",
+            keyBinding: {
+              macos: "meta+shift+,",
+              windows: "ctrl+shift+,"
+            }
+          }
+        }
+      ])
+    }),
+    GraphBuilder.createExtension({
+      id: `${meta.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 isReadyAtom = CreateAtom.fromObservable(client.spaces.isReady);
+        const spaces = get(spacesAtom);
+        const isReady = get(isReadyAtom);
+        if (!spaces || !isReady) {
+          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(client.spaces.default.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).map((space) => constructSpaceNode({
+            space,
+            navigable: ephemeralState.navigableCollections,
+            personal: space === client.spaces.default,
+            namesCache: state.spaceNames,
+            graph,
+            spacesOrder
+          })));
+        } catch {
+          return Effect.succeed([]);
+        }
+      }
+    }),
+    GraphBuilder.createExtension({
+      id: `${meta.id}.actions`,
+      match: 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.change(spacesOrder, (mutableOrder) => {
+          mutableOrder.order = nextOrder.map(({ id }) => id);
+        });
+      };
+      spaceRearrangeCache.set(space.id, onRearrange);
+    }
+  }
+  return {
+    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
+    },
+    nodes: [
+      {
+        id: "settings",
+        type: `${meta.id}.settings`,
+        data: null,
+        properties: {
+          label: SETTINGS_PANEL_LABEL,
+          icon: "ph--faders--regular",
+          disposition: "alternate-tree"
+        }
+      }
+    ]
+  };
+};
+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({
+      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({
+      id: SpaceOperation.OpenCreateObject.meta.key,
+      type: Node.ActionType,
+      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"
+      }
+    }, {
+      id: SpaceOperation.Rename.meta.key,
+      type: Node.ActionType,
+      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 { AppCapabilities as AppCapabilities2, LayoutOperation, Segments } from "@dxos/app-toolkit";
+import { SpaceState as SpaceState3, isSpace as isSpace2 } from "@dxos/client/echo";
+import { Collection, Filter as Filter3, Obj as Obj3, Query, Type } from "@dxos/echo";
+import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from "@dxos/echo/internal";
+import { AtomObj as AtomObj3, AtomQuery as AtomQuery3 } from "@dxos/echo-atom";
+import { Operation as Operation2 } from "@dxos/operation";
+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";
+var createTypeExtensions = Effect2.fnUntraced(function* () {
+  const capabilities = yield* Capability2.Service;
+  const resolve = (_get) => (typename) => capabilities.getAll(AppCapabilities2.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+  return yield* Effect2.all([
+    // Types section virtual node under each space.
+    GraphBuilder2.createExtension({
+      id: `${meta.id}.types-section`,
+      match: whenSpace,
+      connector: (space, get) => {
+        const spaceState = get(CreateAtom2.fromObservable(space.state));
+        if (spaceState !== SpaceState3.SPACE_READY) {
+          return Effect2.succeed([]);
+        }
+        return Effect2.succeed([
+          {
+            id: Segments.types,
+            type: TYPES_SECTION_TYPE,
+            data: null,
+            properties: {
+              label: [
+                "types section label",
+                {
+                  ns: meta.id
+                }
+              ],
+              icon: "ph--shapes--regular",
+              iconHue: "neutral",
+              role: "branch",
+              testId: "spacePlugin.typesSection",
+              draggable: false,
+              droppable: false,
+              space
+            }
+          }
+        ]);
+      }
+    }),
+    // Schema nodes under the Types virtual node.
+    GraphBuilder2.createExtension({
+      id: `${meta.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) => {
+        get(AtomQuery3.make(space.db, Filter3.type(Type.PersistentType)));
+        get(capabilities.atom(AppCapabilities2.Schema));
+        const allSchemas = space.db.schemaRegistry.query({
+          location: [
+            "runtime",
+            "database"
+          ]
+        }).runSync();
+        const userSchemas = allSchemas.filter((schema) => {
+          if (getTypeAnnotation(schema)?.kind === EntityKind.Relation) {
+            return false;
+          }
+          if (SystemTypeAnnotation.get(schema).pipe(Option2.getOrElse(() => false))) {
+            return false;
+          }
+          if (ViewAnnotation2.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)));
+          return objects.length > 0 || viewIndex.typenamesWithViews.has(typename);
+        });
+        return Effect2.succeed(visibleSchemas.map((schema) => createSchemaNode({
+          schema,
+          space,
+          resolve: resolve(get),
+          get
+        })));
+      }
+    }),
+    // {All} virtual node + view objects under each schema node.
+    GraphBuilder2.createExtension({
+      id: `${meta.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?.graph.schemaRegistry.query({
+          location: [
+            "runtime"
+          ]
+        }).runSync() ?? [];
+        const typename = Schema.isSchema(schema) ? Type.getTypename(schema) : schema.typename;
+        const allNode = {
+          id: "all",
+          type: TYPE_COLLECTION_TYPE,
+          data: {
+            space,
+            typename
+          },
+          properties: {
+            label: [
+              "type collection all label",
+              {
+                ns: meta.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,
+          resolve: resolve(get),
+          droppable: false
+        })).filter(isNonNullable);
+        return Effect2.succeed([
+          allNode,
+          ...viewNodes
+        ]);
+      }
+    }),
+    // Objects of the schema type under the {All} node.
+    GraphBuilder2.createExtension({
+      id: `${meta.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 objects = get(AtomQuery3.make(space.db, Filter3.typename(typename)));
+        return Effect2.succeed(objects.map((object) => {
+          get(AtomObj3.make(object));
+          return createObjectNode({
+            db: space.db,
+            object,
+            resolve: resolve(get),
+            droppable: false
+          });
+        }).filter(isNonNullable));
+      }
+    }),
+    // Actions for schema nodes.
+    GraphBuilder2.createExtension({
+      id: `${meta.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?.graph.schemaRegistry.query({
+          location: [
+            "runtime"
+          ]
+        }).runSync() ?? [];
+        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,
+          resolve: resolve(get)
+        }));
+      }
+    })
+  ]);
+});
+var createSchemaNode = ({ schema, space, resolve, get }) => {
+  const typename = Type.getTypename(schema);
+  const metadata = resolve(typename);
+  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,
+      default: typename
+    }),
+    nodeId: typename
+  })));
+  const icon = Type.isMutable(schema) ? "ph--cube--regular" : metadata.icon ?? "ph--placeholder--regular";
+  const iconHue = Type.isMutable(schema) ? "neutral" : metadata.iconHue;
+  return {
+    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, resolve }) => {
+  const typename = Type.getTypename(schema);
+  const metadata = resolve(typename);
+  const createObjectFn = metadata.createObject;
+  const inputSchema = metadata.inputSchema;
+  const actions = [
+    ...createObjectFn ? [
+      {
+        id: SpaceOperation.OpenCreateObject.meta.key,
+        type: Node2.ActionType,
+        data: Effect2.fnUntraced(function* () {
+          if (inputSchema) {
+            yield* Operation2.invoke(SpaceOperation.OpenCreateObject, {
+              target: space.db,
+              typename
+            });
+          } else {
+            const createdObject = yield* createObjectFn({}, {
+              db: space.db
+            });
+            const addResult = yield* Operation2.invoke(SpaceOperation.AddObject, {
+              target: space.db,
+              hidden: true,
+              object: createdObject
+            });
+            if (addResult.subject) {
+              yield* Operation2.invoke(LayoutOperation.Open, {
+                subject: addResult.subject
+              });
+            }
+          }
+        }),
+        properties: {
+          label: getDynamicLabel("add object label", typename),
+          icon: "ph--plus--regular",
+          disposition: "list-item-primary",
+          testId: "spacePlugin.createObject"
+        }
+      }
+    ] : [],
+    {
+      id: `${SpaceOperation.AddObject.meta.key}-view`,
+      type: Node2.ActionType,
+      data: () => Operation2.invoke(SpaceOperation.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"
+      }
+    },
+    {
+      id: SpaceOperation.RenameObject.meta.key,
+      type: Node2.ActionType,
+      data: (params) => Type.isMutable(schema) ? Operation2.invoke(SpaceOperation.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"
+      }
+    },
+    {
+      id: SpaceOperation.RemoveObjects.meta.key,
+      type: Node2.ActionType,
+      data: () => Type.isMutable(schema) ? Operation2.invoke(SpaceOperation.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"
+      }
+    },
+    {
+      id: SpaceOperation.Snapshot.meta.key,
+      type: Node2.ActionType,
+      data: Effect2.fnUntraced(function* () {
+        const result = yield* Operation2.invoke(SpaceOperation.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 AppCapabilities3, LayoutOperation as LayoutOperation2, Segments as Segments2, getObjectPathFromObject } from "@dxos/app-toolkit";
+import { SpaceState as SpaceState4, getSpace, isSpace as isSpace3 } from "@dxos/client/echo";
+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 { Operation as Operation3 } from "@dxos/operation";
+import { CreateAtom as CreateAtom3, Graph as Graph2, GraphBuilder as GraphBuilder3, Node as Node3 } from "@dxos/plugin-graph";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+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;
+  const resolve = (get) => (typename) => capabilities.getAll(AppCapabilities3.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+  return yield* Effect3.all([
+    // Collections section virtual node under each space.
+    GraphBuilder3.createExtension({
+      id: `${meta.id}.collections-section`,
+      match: 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({
+          collection: rootCollection,
+          db: space.db,
+          resolve: resolve(get)
+        }) : void 0;
+        return Effect3.succeed([
+          {
+            id: Segments2.collections,
+            type: COLLECTIONS_SECTION_TYPE,
+            data: null,
+            properties: {
+              label: [
+                "collections section label",
+                {
+                  ns: meta.id
+                }
+              ],
+              icon: "ph--folder--regular",
+              iconHue: "neutral",
+              role: "branch",
+              position: "hoist",
+              testId: "spacePlugin.collectionsSection",
+              draggable: false,
+              droppable: false,
+              space,
+              ...collectionPartials
+            }
+          }
+        ]);
+      }
+    }),
+    // Root collection objects under the Collections virtual node.
+    GraphBuilder3.createExtension({
+      id: `${meta.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(SpaceCapabilities.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,
+          resolve: resolve(get),
+          navigable: ephemeralState.navigableCollections,
+          parentCollection: collectionRef?.target
+        })).filter(isNonNullable2));
+      }
+    }),
+    // Children of Collection.Collection nodes.
+    GraphBuilder3.createExtension({
+      id: `${meta.id}.objects`,
+      match: (node) => Obj4.instanceOf(Collection2.Collection, node.data) ? Option3.some(node.data) : Option3.none(),
+      connector: (collection, get) => {
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+        const ephemeralState = get(ephemeralAtom);
+        const space = getSpace(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) => space && createObjectNode({
+          object,
+          db: space.db,
+          resolve: resolve(get),
+          navigable: ephemeralState.navigableCollections,
+          parentCollection: collection
+        })).filter(isNonNullable2));
+      }
+    }),
+    // Object actions.
+    GraphBuilder3.createExtension({
+      id: `${meta.id}.object-actions`,
+      match: (node) => {
+        const space = getSpace(node.data);
+        return space && Obj4.isObject(node.data) && Obj4.getTypename(node.data) === node.type ? Option3.some({
+          space,
+          object: node.data,
+          nodeId: node.id
+        }) : Option3.none();
+      },
+      actions: ({ space, object, nodeId }, get) => {
+        const deletable = !Obj4.instanceOf(Type2.PersistentType, object);
+        const [appGraph] = get(capabilities.atom(AppCapabilities3.AppGraph));
+        const ephemeralAtom = capabilities.get(SpaceCapabilities.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,
+          resolve: resolve(get),
+          deletable,
+          navigable: ephemeralState.navigableCollections,
+          shareableLinkOrigin,
+          parentCollection
+        }));
+      }
+    })
+  ]);
+});
+var constructObjectActions = ({ object, nodeId, resolve, deletable = true, navigable = false, shareableLinkOrigin, parentCollection }) => {
+  const db = Obj4.getDatabase(object);
+  invariant(db, "Database not found", {
+    F: __dxlog_file,
+    L: 238,
+    S: void 0,
+    A: [
+      "db",
+      "'Database not found'"
+    ]
+  });
+  const typename = Obj4.getTypename(object);
+  invariant(typename, "Object has no typename", {
+    F: __dxlog_file,
+    L: 240,
+    S: void 0,
+    A: [
+      "typename",
+      "'Object has no typename'"
+    ]
+  });
+  const actions = [
+    ...Obj4.instanceOf(Collection2.Collection, object) ? [
+      {
+        id: SpaceOperation.OpenCreateObject.meta.key,
+        type: Node3.ActionType,
+        data: () => Operation3.invoke(SpaceOperation.OpenCreateObject, {
+          target: object,
+          targetNodeId: nodeId
+        }),
+        properties: {
+          label: CREATE_OBJECT_IN_COLLECTION_LABEL,
+          icon: "ph--plus--regular",
+          disposition: "list-item-primary",
+          testId: "spacePlugin.createObject"
+        }
+      }
+    ] : [],
+    {
+      id: SpaceOperation.RenameObject.meta.key,
+      type: Node3.ActionType,
+      data: (params) => Operation3.invoke(SpaceOperation.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) ? [
+      {
+        id: "remove-from-collection",
+        type: Node3.ActionType,
+        data: () => Effect3.gen(function* () {
+          const index = parentCollection.objects.findIndex((ref) => ref.target === object);
+          if (index !== -1) {
+            const layout = yield* Capabilities.getAtomValue(AppCapabilities3.Layout);
+            const isActive = layout.active.includes(nodeId);
+            Obj4.change(parentCollection, (mutable) => {
+              mutable.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"
+        }
+      }
+    ] : [],
+    {
+      id: SpaceOperation.RemoveObjects.meta.key,
+      type: Node3.ActionType,
+      data: () => Operation3.invoke(SpaceOperation.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) ? [
+      {
+        id: "copy-link",
+        type: Node3.ActionType,
+        data: () => Effect3.promise(async () => {
+          const url = `${shareableLinkOrigin}/${db.spaceId}/${Obj4.getDXN(object).toString()}`;
+          await navigator.clipboard.writeText(url);
+        }),
+        properties: {
+          label: COPY_LINK_LABEL,
+          icon: "ph--link--regular",
+          disposition: "list-item",
+          testId: "spacePlugin.copyLink"
+        }
+      }
+    ] : [],
+    {
+      id: LayoutOperation2.Expose.meta.key,
+      type: Node3.ActionType,
+      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 { COMPANION_PREFIX } from "@dxos/app-toolkit";
+import { Obj as Obj5 } from "@dxos/echo";
+import { PLANK_COMPANION_TYPE } from "@dxos/plugin-deck/types";
+import { GraphBuilder as GraphBuilder4, NodeMatcher as NodeMatcher2 } from "@dxos/plugin-graph";
+import { ViewAnnotation as ViewAnnotation3 } from "@dxos/schema";
+var createCompanionExtensions = Effect4.fnUntraced(function* () {
+  return yield* Effect4.all([
+    // Object settings plank companion.
+    GraphBuilder4.createExtension({
+      id: `${meta.id}.settings`,
+      match: NodeMatcher2.whenEchoObjectMatches,
+      connector: (node) => Effect4.succeed([
+        {
+          id: `${COMPANION_PREFIX}settings`,
+          type: PLANK_COMPANION_TYPE,
+          data: "settings",
+          properties: {
+            label: [
+              "object settings label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--sliders--regular",
+            disposition: "hidden",
+            position: "fallback"
+          }
+        }
+      ])
+    }),
+    // View selected objects companion.
+    GraphBuilder4.createExtension({
+      id: `${meta.id}.selected-objects`,
+      match: (node) => {
+        if (!Obj5.isObject(node.data)) {
+          return Option4.none();
+        }
+        const schema = Obj5.getSchema(node.data);
+        const isView = Option4.fromNullable(schema).pipe(Option4.flatMap((candidate) => ViewAnnotation3.get(candidate)), Option4.getOrElse(() => false));
+        if (!isView) {
+          return Option4.none();
+        }
+        return Option4.some(node);
+      },
+      connector: (node) => Effect4.succeed([
+        {
+          id: `${COMPANION_PREFIX}selected-objects`,
+          type: PLANK_COMPANION_TYPE,
+          data: "selected-objects",
+          properties: {
+            label: [
+              "companion selected objects label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--tree-view--regular",
+            disposition: "hidden"
+          }
+        }
+      ])
+    })
+  ]);
+});
+
+// src/capabilities/app-graph-builder/extensions/settings.ts
+import * as Effect5 from "effect/Effect";
+import { GraphBuilder as GraphBuilder5, NodeMatcher as NodeMatcher3 } from "@dxos/plugin-graph";
+var createSettingsExtensions = Effect5.fnUntraced(function* () {
+  const extension = yield* GraphBuilder5.createExtension({
+    id: `${meta.id}.settings-sections`,
+    match: NodeMatcher3.whenNodeType(`${meta.id}.settings`),
+    connector: (node) => Effect5.succeed([
+      {
+        id: `${meta.id}.general`,
+        type: `${meta.id}.general`,
+        data: `${meta.id}.general`,
+        properties: {
+          label: [
+            "space settings properties label",
+            {
+              ns: meta.id
+            }
+          ],
+          icon: "ph--sliders--regular",
+          position: "hoist",
+          testId: "spacePlugin.general"
+        }
+      },
+      {
+        id: `${meta.id}.members`,
+        type: `${meta.id}.members`,
+        data: `${meta.id}.members`,
+        properties: {
+          label: [
+            "members panel label",
+            {
+              ns: meta.id
+            }
+          ],
+          icon: "ph--users--regular",
+          position: "hoist",
+          testId: "spacePlugin.members"
+        }
+      },
+      {
+        id: `${meta.id}.schema`,
+        type: `${meta.id}.schema`,
+        data: `${meta.id}.schema`,
+        properties: {
+          label: [
+            "space settings schema label",
+            {
+              ns: meta.id
+            }
+          ],
+          icon: "ph--shapes--regular",
+          testId: "spacePlugin.schema"
+        }
+      }
+    ])
+  });
+  return [
+    extension
+  ];
+});
+
+// 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(),
+    createTypeExtensions(),
+    createCollectionExtensions({
+      shareableLinkOrigin
+    }),
+    createCompanionExtensions(),
+    createSettingsExtensions()
+  ]);
+  return Capability4.contributes(AppCapabilities4.AppGraphBuilder, extensions.flat());
+}));
+export {
+  app_graph_builder_default as default
+};
+//# sourceMappingURL=app-graph-builder-WTM6SSX7.mjs.map