@dxos/plugin-space 0.10.0 → 0.11.1

package/dist/lib/chunk-app-graph-builder.mjs

@@ -0,0 +1,1056 @@
+import { a as SHARED } from "./chunk-types.mjs";
+import { n as getSpaceDisplayName, r as makeCreateObjectEntryForDatabaseType } from "./chunk-util.mjs";
+import { t as resolveCollectionObjectPath } from "./chunk-collection-path.mjs";
+import { Capability } from "@dxos/app-framework";
+import { Position, createFilename, isNonNullable } from "@dxos/util";
+import { meta } from "#meta";
+import { AppAnnotation, AppCapabilities, AppNode, AppNodeMatcher, AppSpace, GraphPath, LayoutOperation, UrlResolution } from "@dxos/app-toolkit";
+import * as Effect from "effect/Effect";
+import { SpaceState, isSpace } from "@dxos/client/echo";
+import { Operation } from "@dxos/compute";
+import { Annotation, Collection, Database, Entity, Filter, Obj, Query, Scope, Type } from "@dxos/echo";
+import { SpaceOperation } from "#operations";
+import { SpaceArchive } from "@dxos/protocols/proto/dxos/client/services";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import { Expando, ViewAnnotation, getTypeURIFromQuery } from "@dxos/schema";
+import { SETTINGS_SECTION_ID, SETTINGS_SECTION_TYPE, SPACE_HOME_NODE_TYPE, SPACE_TYPE, SpaceCapabilities } from "#types";
+import * as Option from "effect/Option";
+import { HiddenAnnotation } from "@dxos/echo/Annotation";
+import { SpaceId } from "@dxos/keys";
+import * as Match from "effect/Match";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { CreateAtom, Graph, GraphBuilder, Node, NodeMatcher } from "@dxos/plugin-graph";
+import { MigrationVersionAnnotation, Migrations } from "@dxos/migrations";
+import { isLabel, toLocalizedString } from "@dxos/ui-types/translations";
+//#region src/capabilities/app-graph-builder/extensions/shared.ts
+var DATABASE_SECTION_TYPE = `${meta.profile.key}.database`;
+var COLLECTIONS_SECTION_TYPE = `${meta.profile.key}.collections`;
+/** Tags every type node under the Database section — both static (compile-time) and database (dynamic) schemas. */
+var SCHEMA_NODE_TYPE = `${meta.profile.key}.static-schema`;
+/** Shared translation namespace descriptor. */
+var META_NS = { ns: meta.profile.key };
+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 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.targetVersion && Annotation.get(space.properties, MigrationVersionAnnotation).pipe(Option.getOrUndefined) !== 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);
+};
+/**
+* Builds an index of view objects by scanning view-annotated schemas and resolving the target
+* type URI from each view's query AST. Only straightforward views whose query resolves to a
+* type URI via getTypeURIFromQuery are included.
+*/
+var buildViewIndex = (get, space, schemas) => {
+	const viewSchemas = schemas.filter((schema) => ViewAnnotation.has(schema));
+	const viewsByTypeUri = /* @__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(space.db.query(filter).atom);
+		for (const viewObject of viewObjects) {
+			if (!Obj.isObject(viewObject)) continue;
+			const holderType = Obj.getType(viewObject);
+			const path = holderType ? ViewAnnotation.get(Type.getSchema(holderType)).pipe(Option.getOrElse(() => [])) : [];
+			if (path.length === 0) continue;
+			let holder = get(Obj.atom(viewObject));
+			for (const segment of path) holder = holder == null || typeof holder !== "object" ? void 0 : holder[segment];
+			if (holder != null) viewObjectIds.add(viewObject.id);
+			const typeUri = getTypeURIFromQuery((holder != null ? get(Obj.atom(holder)) : void 0)?.query?.ast);
+			if (typeUri) {
+				const existing = viewsByTypeUri.get(typeUri) ?? [];
+				existing.push(viewObject);
+				viewsByTypeUri.set(typeUri, existing);
+			}
+		}
+	}
+	return {
+		typeUrisWithViews: new Set(viewsByTypeUri.keys()),
+		getViewsForTypeUri: (typeUri) => viewsByTypeUri.get(typeUri) ?? [],
+		isView: (object) => viewObjectIds.has(object.id)
+	};
+};
+//#endregion
+//#region src/capabilities/app-graph-builder/extensions/spaces.ts
+var SPACE_HOME_NODE_LABEL = ["space-home-node.label", { ns: meta.profile.key }];
+/** Creates space-related extensions: primary actions, space nodes, space actions, and the Home node. */
+var createSpaceExtensions = Effect.fnUntraced(function* () {
+	const capabilities = yield* Capability.Service;
+	return yield* Effect.all([
+		GraphBuilder.createExtension({
+			id: "spaceHome",
+			position: Position.first,
+			url: {
+				key: "home",
+				kind: "singleton",
+				path: []
+			},
+			match: AppNodeMatcher.whenSpace,
+			connector: (space) => Effect.succeed([{
+				id: GraphPath.SPACE_HOME_SEGMENT,
+				type: SPACE_HOME_NODE_TYPE,
+				data: SPACE_HOME_NODE_TYPE,
+				properties: {
+					label: SPACE_HOME_NODE_LABEL,
+					icon: "ph--house--regular",
+					iconHue: "emerald",
+					position: Position.first,
+					draggable: false,
+					droppable: false,
+					space
+				}
+			}])
+		}),
+		GraphBuilder.createExtension({
+			id: "primaryActions",
+			position: 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: meta.profile.key }],
+						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: meta.profile.key }],
+						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: meta.profile.key }],
+						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 = AppSpace.getActiveSpace(client, capabilities) ?? AppSpace.getPersonalSpace(client);
+						if (space) yield* Operation.invoke(SpaceOperation.ExportSpace, {
+							space,
+							format: SpaceArchive.Format.BINARY
+						});
+					}),
+					properties: {
+						label: ["export-space-binary.label", { ns: meta.profile.key }],
+						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 = AppSpace.getActiveSpace(client, capabilities) ?? AppSpace.getPersonalSpace(client);
+						if (space) yield* Operation.invoke(SpaceOperation.ExportSpace, {
+							space,
+							format: SpaceArchive.Format.JSON
+						});
+					}),
+					properties: {
+						label: ["export-space-json.label", { ns: meta.profile.key }],
+						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 = AppSpace.getActiveSpace(client, capabilities) ?? AppSpace.getPersonalSpace(client);
+						if (space) yield* Operation.invoke(SpaceOperation.OpenMembers, { space });
+					}),
+					properties: {
+						label: ["share-space.label", { ns: meta.profile.key }],
+						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 = AppSpace.getActiveSpace(client, capabilities) ?? AppSpace.getPersonalSpace(client);
+						if (space) yield* Operation.invoke(SpaceOperation.OpenSettings, { space });
+					}),
+					properties: {
+						label: ["open-current-space-settings.label", { ns: meta.profile.key }],
+						icon: "ph--faders--regular",
+						keyBinding: {
+							macos: "meta+shift+,",
+							windows: "ctrl+shift+,"
+						}
+					}
+				})
+			])
+		}),
+		GraphBuilder.createExtension({
+			id: "spaces",
+			match: NodeMatcher.whenRoot,
+			connector: (_node, get) => {
+				const [client] = capabilities.getAll(ClientCapabilities.Client);
+				if (!client) return Effect.succeed([]);
+				const stateAtom = capabilities.get(SpaceCapabilities.State);
+				const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
+				const spaces = get(CreateAtom.fromObservable(client.spaces));
+				const personalSpace = AppSpace.getPersonalSpace(client);
+				if (!spaces || !personalSpace) return Effect.succeed([]);
+				get(capabilities.get(SpaceCapabilities.Settings));
+				const state = get(stateAtom);
+				const ephemeralState = get(ephemeralAtom);
+				try {
+					const [spacesOrder] = get(personalSpace.db.query(Filter.type(Expando.Expando, { key: SHARED })).atom);
+					const { graph } = capabilities.get(AppCapabilities.AppGraph);
+					const order = (spacesOrder ? get(Obj.atom(spacesOrder)) : void 0)?.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() === SpaceState.SPACE_READY) get(Obj.atom(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) => spaceStates[idx] === SpaceState.SPACE_READY).filter((space) => space.tags.length === 0 || AppSpace.isPersonalSpace(space) || AppSpace.isExemplarSpace(space)).map((space) => constructSpaceNode({
+						space,
+						navigable: ephemeralState.navigableCollections,
+						personal: AppSpace.isPersonalSpace(space),
+						namesCache: state.spaceNames,
+						graph,
+						spacesOrder
+					})));
+				} catch {
+					return Effect.succeed([]);
+				}
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: GraphPath.GroupSegments.communications,
+			match: AppNodeMatcher.whenSpace,
+			connector: (space) => Effect.succeed([AppNode.makeGroup({
+				id: GraphPath.GroupSegments.communications,
+				type: GraphPath.GroupTypes.communications,
+				label: ["nav-tree-group-comm.label", { ns: meta.profile.key }],
+				space,
+				position: 100
+			})])
+		}),
+		GraphBuilder.createExtension({
+			id: "actions",
+			match: AppNodeMatcher.whenSpace,
+			actions: (space, get) => {
+				const [client] = get(capabilities.atom(ClientCapabilities.Client));
+				const ephemeralState = get(capabilities.get(SpaceCapabilities.EphemeralState));
+				if (!client) return Effect.succeed([]);
+				get(CreateAtom.fromObservable(space.state));
+				if (space.state.get() === SpaceState.SPACE_READY) get(Obj.atom(space.properties));
+				return Effect.succeed(constructSpaceActions({
+					space,
+					migrating: ephemeralState.sdkMigrationRunning[space.id]
+				}));
+			}
+		})
+	]);
+});
+/** Builds an app-graph node for a space, including settings children and optional rearrange handler. */
+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));
+				Obj.update(spacesOrder, (spacesOrder) => {
+					spacesOrder.order = nextOrder.map(({ id }) => id);
+				});
+			};
+			spaceRearrangeCache.set(space.id, onRearrange);
+		}
+	}
+	return Node.make({
+		id: space.id,
+		type: SPACE_TYPE,
+		cacheable: AppNode.CACHEABLE_PROPS,
+		data: space,
+		properties: {
+			label: getSpaceDisplayName(space, {
+				personal,
+				namesCache
+			}),
+			description: space.state.get() === SpaceState.SPACE_READY && space.properties.description,
+			hue: space.state.get() === SpaceState.SPACE_READY && space.properties.hue,
+			icon: space.state.get() === SpaceState.SPACE_READY && space.properties.icon ? `ph--${space.properties.icon}--regular` : void 0,
+			iconHue: space.state.get() === SpaceState.SPACE_READY && space.properties.iconHue,
+			disabled: !navigable || space.state.get() !== SpaceState.SPACE_READY || hasPendingMigration,
+			disposition: "workspace",
+			testId: "spacePlugin.space",
+			onRearrange,
+			canDrop: CAN_DROP_SPACE
+		}
+	});
+};
+/** Builds the action list for a space node (migrate, create object, rename). */
+var constructSpaceActions = ({ space, migrating }) => {
+	const state = space.state.get();
+	const hasPendingMigration = checkPendingMigration(space);
+	const isMigrating = migrating || Migrations.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 === SpaceState.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;
+};
+//#endregion
+//#region src/capabilities/app-graph-builder/extensions/database.ts
+/** Creates database extensions: types section, schema nodes, schema children, and schema actions. */
+var createDatabaseExtensions = Effect.fnUntraced(function* () {
+	const capabilities = yield* Capability.Service;
+	return yield* Effect.all([
+		GraphBuilder.createExtension({
+			id: GraphPath.GroupSegments.system,
+			match: AppNodeMatcher.whenSpace,
+			connector: (space) => Effect.succeed([AppNode.makeGroup({
+				id: GraphPath.GroupSegments.system,
+				type: GraphPath.GroupTypes.system,
+				label: ["nav-tree-group-system.label", { ns: meta.profile.key }],
+				space,
+				position: 900
+			})])
+		}),
+		GraphBuilder.createExtension({
+			id: "databaseSection",
+			match: AppNodeMatcher.whenNavTreeGroup(GraphPath.GroupTypes.system),
+			connector: (space) => {
+				return Effect.succeed([AppNode.makeSection({
+					id: GraphPath.Segments.database,
+					type: DATABASE_SECTION_TYPE,
+					label: ["database-section.label", { ns: meta.profile.key }],
+					icon: "ph--database--regular",
+					space,
+					testId: "spacePlugin.databaseSection"
+				})]);
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: "database",
+			url: {
+				key: "type",
+				kind: "item",
+				path: [GraphPath.GroupSegments.system, GraphPath.Segments.database]
+			},
+			match: (node) => {
+				const space = isSpace(node.properties.space) ? node.properties.space : void 0;
+				return node.type === DATABASE_SECTION_TYPE && space ? Option.some(space) : Option.none();
+			},
+			connector: (space, get) => {
+				const settingsAtom = get(capabilities.atom(SpaceCapabilities.Settings)).at(0);
+				const showHidden = settingsAtom ? get(settingsAtom).showHidden : false;
+				const allSchemas = get(space.db.query(Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry())).atom);
+				const userSchemas = allSchemas.filter((type) => {
+					if (Type.isRelation(type)) return false;
+					if (Type.isTypeKind(type)) return false;
+					const schema = Type.getSchema(type);
+					if (!showHidden && HiddenAnnotation.get(schema).pipe(Option.getOrElse(() => false))) return false;
+					if (Type.getTypename(type) === Type.getTypename(Collection.Collection)) return false;
+					return true;
+				});
+				const viewIndex = buildViewIndex(get, space, allSchemas);
+				const visibleSchemas = userSchemas.filter((schema) => {
+					if (Type.getDatabase(schema) != null) return true;
+					const typeUri = Type.getURI(schema);
+					const objects = get(space.db.query(Filter.type(typeUri)).atom);
+					if (ViewAnnotation.has(schema)) return objects.some((obj) => !viewIndex.isView(obj));
+					return objects.length > 0 || viewIndex.typeUrisWithViews.has(typeUri);
+				});
+				const translator = get(capabilities.atom(AppCapabilities.Translator)).at(0);
+				const labelOf = (node) => {
+					const label = node.properties?.label;
+					if (translator && isLabel(label)) return toLocalizedString(label, translator.t);
+					return node.data ? Type.getTypename(node.data) : "";
+				};
+				return Effect.succeed(visibleSchemas.map((schema) => createSchemaNode({
+					schema,
+					space,
+					get
+				})).toSorted((nodeA, nodeB) => labelOf(nodeA).localeCompare(labelOf(nodeB))));
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: "schemaChildren",
+			url: {
+				key: "view",
+				kind: "item",
+				path: [GraphPath.GroupSegments.system, GraphPath.Segments.database]
+			},
+			match: (node) => {
+				const space = isSpace(node.properties.space) ? node.properties.space : void 0;
+				return node.type === SCHEMA_NODE_TYPE && space && Type.isType(node.data) ? Option.some({
+					space,
+					schema: node.data
+				}) : Option.none();
+			},
+			connector: ({ space, schema }, get) => {
+				const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+				const schemas = client ? get(client.graph.registry.query(Filter.type(Type.Type)).atom) : [];
+				const typeUri = Type.getURI(schema);
+				const viewNodes = buildViewIndex(get, space, schemas).getViewsForTypeUri(typeUri).map((object) => AppNode.makeObject({
+					get,
+					db: space.db,
+					object,
+					draggable: false,
+					droppable: false
+				})).filter(isNonNullable);
+				return Effect.succeed(viewNodes);
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: "databaseObjects",
+			url: {
+				key: "db",
+				kind: "item",
+				path: [GraphPath.GroupSegments.system, GraphPath.Segments.database]
+			},
+			match: (node) => {
+				const space = isSpace(node.properties.space) ? node.properties.space : void 0;
+				return node.type === SCHEMA_NODE_TYPE && space && Type.isType(node.data) ? Option.some({
+					space,
+					schema: node.data
+				}) : Option.none();
+			},
+			connector: ({ space, schema }, get) => {
+				const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+				const schemas = client ? get(client.graph.registry.query(Filter.type(Type.Type)).atom) : [];
+				const typeUri = Type.getURI(schema);
+				const viewIndex = buildViewIndex(get, space, schemas);
+				const objects = get(space.db.query(Query.select(Filter.type(typeUri)).from(space.db, { includeFeeds: true })).atom);
+				return Effect.succeed(objects.filter((object) => !viewIndex.isView(object)).map((object) => AppNode.makeObject({
+					get,
+					db: space.db,
+					object,
+					disposition: "hidden",
+					draggable: false,
+					droppable: false
+				})).filter(isNonNullable));
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: "schemaActions",
+			match: (node) => {
+				const space = isSpace(node.properties.space) ? node.properties.space : void 0;
+				return space && Type.isType(node.data) ? Option.some({
+					space,
+					schema: node.data
+				}) : Option.none();
+			},
+			actions: ({ space, schema }, get) => {
+				const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+				const schemas = client ? get(client.graph.registry.query(Filter.type(Type.Type)).atom) : [];
+				const targetUri = Type.getURI(schema);
+				const viewIndex = buildViewIndex(get, space, schemas);
+				const deletable = Type.getDatabase(schema) != null && viewIndex.getViewsForTypeUri(targetUri).length === 0;
+				return Effect.succeed(createSchemaActions({
+					type: schema,
+					space,
+					deletable,
+					capabilities
+				}));
+			}
+		})
+	]);
+});
+/** Builds a graph node for a schema in the Types subtree. */
+var createSchemaNode = ({ schema, space, get }) => {
+	const typename = Type.getTypename(schema);
+	const slug = GraphPath.getTypeSlug(schema);
+	const iconAnnotation = Type.getDatabase(schema) == null ? Option.getOrUndefined(Annotation.IconAnnotation.get(Type.getSchema(schema))) : void 0;
+	const { label, nodeId } = Match.value(schema).pipe(Match.when((value) => Type.getDatabase(value) != null, (mutableSchema) => {
+		return {
+			label: get(Entity.atom(mutableSchema)).name || ["object-name.placeholder", { ns: Type.getTypename(Type.Type) }],
+			nodeId: slug
+		};
+	}), Match.orElse(() => ({
+		label: AppNode.getDynamicLabel("typename.label", typename, {
+			count: 2,
+			defaultValue: typename
+		}),
+		nodeId: slug
+	})));
+	const icon = Type.getDatabase(schema) != null ? "ph--cube--regular" : iconAnnotation?.icon ?? "ph--circle-dashed--regular";
+	const iconHue = Type.getDatabase(schema) != null ? "neutral" : iconAnnotation?.hue;
+	return Node.make({
+		id: nodeId,
+		type: SCHEMA_NODE_TYPE,
+		data: schema,
+		properties: {
+			label,
+			icon,
+			iconHue,
+			testId: `spacePlugin.schemaNode.${typename}`,
+			selectable: true,
+			draggable: false,
+			droppable: false,
+			childrenDroppable: false,
+			space
+		}
+	});
+};
+/** Builds schema actions (add view, rename, delete, snapshot). */
+var createSchemaActions = ({ type, space, deletable, capabilities }) => {
+	const typename = Type.getTypename(type);
+	const resolvedEntry = capabilities.getAll(SpaceCapabilities.CreateObjectEntry).find((entry) => entry.id === typename) ?? (Type.getDatabase(type) != null && Type.isObject(type) ? makeCreateObjectEntryForDatabaseType(type) : void 0);
+	const createObjectFn = resolvedEntry?.createObject;
+	const inputSchema = resolvedEntry?.inputSchema;
+	return [
+		...createObjectFn ? [Node.makeAction({
+			id: SpaceOperation.OpenCreateObject.meta.key,
+			data: Effect.fnUntraced(function* () {
+				if (inputSchema) yield* Operation.invoke(SpaceOperation.OpenCreateObject, {
+					target: space.db,
+					typename
+				});
+				else {
+					const result = yield* createObjectFn({}, {
+						db: space.db,
+						target: space.db
+					}).pipe(Effect.provideService(Capability.Service, capabilities));
+					if (result.subject.length > 0) yield* Operation.invoke(LayoutOperation.Open, {
+						subject: [...result.subject],
+						navigation: "immediate"
+					});
+				}
+			}),
+			properties: {
+				label: AppNode.getDynamicLabel("add-object.label", Type.getDatabase(type) != null ? meta.profile.key : typename),
+				icon: "ph--plus--regular",
+				disposition: "list-item-primary",
+				testId: "spacePlugin.createObject"
+			}
+		})] : [],
+		Node.makeAction({
+			id: `${SpaceOperation.AddObject.meta.key}-view`,
+			data: () => Operation.invoke(SpaceOperation.OpenCreateObject, {
+				target: space.db,
+				views: true,
+				initialFormValues: { typename: Type.getURI(type) }
+			}),
+			properties: {
+				label: ADD_VIEW_TO_SCHEMA_LABEL,
+				icon: "ph--circles-three-plus--regular",
+				disposition: "list-item",
+				testId: "spacePlugin.addViewToSchema"
+			}
+		}),
+		Node.makeAction({
+			id: SpaceOperation.RenameObject.meta.key,
+			data: (params) => Type.getDatabase(type) != null ? Operation.invoke(SpaceOperation.RenameObject, {
+				object: type,
+				caller: `${params?.caller}:${params?.parent?.id}`
+			}) : Effect.fail(/* @__PURE__ */ new Error("Cannot rename immutable schema")),
+			properties: {
+				label: AppNode.getDynamicLabel("rename-object.label", Type.getTypename(Type.Type)),
+				icon: "ph--pencil-simple-line--regular",
+				disabled: Type.getDatabase(type) == null,
+				disposition: "list-item",
+				testId: "spacePlugin.renameObject"
+			}
+		}),
+		Node.makeAction({
+			id: SpaceOperation.RemoveObjects.meta.key,
+			data: () => Type.getDatabase(type) != null ? Operation.invoke(SpaceOperation.RemoveObjects, { objects: [type] }) : Effect.succeed(void 0),
+			properties: {
+				label: AppNode.getDynamicLabel("delete-object.label", Type.getTypename(Type.Type)),
+				icon: "ph--trash--regular",
+				disposition: "list-item",
+				disabled: !deletable,
+				testId: "spacePlugin.deleteObject"
+			}
+		}),
+		Node.makeAction({
+			id: SpaceOperation.Snapshot.meta.key,
+			data: Effect.fnUntraced(function* () {
+				const result = yield* Operation.invoke(SpaceOperation.Snapshot, {
+					db: space.db,
+					query: Query.select(Filter.type(type)).ast
+				});
+				if (result.snapshot) yield* Effect.tryPromise(() => downloadBlob(result.snapshot, createFilename({
+					parts: [space.id, Type.getTypename(type)],
+					ext: "json"
+				})));
+			}),
+			properties: {
+				label: SNAPSHOT_BY_SCHEMA_LABEL,
+				icon: "ph--camera--regular",
+				disposition: "list-item"
+			}
+		})
+	];
+};
+//#endregion
+//#region src/capabilities/app-graph-builder/extensions/collections.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/capabilities/app-graph-builder/extensions/collections.ts";
+/** Creates collection-related extensions: collections section, collections, objects, and object actions. */
+/**
+* A collection is always a navigation target; what differs is what navigating to it shows. When a
+* plugin renders collections as their own article (stack, simple-layout) that article wins, otherwise
+* the deck opens the collection's contents. Returning `undefined` leaves the ordinary open in place.
+*/
+var collectionDeck = (object, hasCollectionArticle) => !hasCollectionArticle && Obj.instanceOf(Collection.Collection, object) ? { initial: "children" } : void 0;
+var createCollectionExtensions = Effect.fnUntraced(function* ({ shareableLinkOrigin }) {
+	const capabilities = yield* Capability.Service;
+	return yield* Effect.all([
+		GraphBuilder.createExtension({
+			id: GraphPath.GroupSegments.content,
+			match: AppNodeMatcher.whenSpace,
+			connector: (space) => Effect.succeed([AppNode.makeGroup({
+				id: GraphPath.GroupSegments.content,
+				type: GraphPath.GroupTypes.content,
+				label: ["nav-tree-group-content.label", { ns: meta.profile.key }],
+				space,
+				position: 200
+			})])
+		}),
+		GraphBuilder.createExtension({
+			id: "collectionsSection",
+			match: AppNodeMatcher.whenNavTreeGroup(GraphPath.GroupTypes.content),
+			connector: (space, get) => {
+				get(Obj.atom(space.properties));
+				const collectionRef = Annotation.get(space.properties, AppAnnotation.RootCollectionAnnotation).pipe(Option.getOrUndefined);
+				if (collectionRef) get(Obj.atom(collectionRef));
+				const rootCollection = collectionRef?.target;
+				const collectionPartials = rootCollection ? AppNode.getCollectionGraphNodePartials({
+					db: space.db,
+					collection: rootCollection
+				}) : void 0;
+				return Effect.succeed([Node.make({
+					id: GraphPath.Segments.collections,
+					type: COLLECTIONS_SECTION_TYPE,
+					data: null,
+					properties: {
+						label: ["collections-section.label", { ns: meta.profile.key }],
+						icon: "ph--folder--regular",
+						iconHue: "indigo",
+						role: "branch",
+						testId: "spacePlugin.collectionsSection",
+						draggable: false,
+						droppable: false,
+						space,
+						...collectionPartials
+					}
+				})]);
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: "collections",
+			url: {
+				key: "object",
+				kind: "item",
+				path: [GraphPath.GroupSegments.content, GraphPath.Segments.collections]
+			},
+			match: (node) => {
+				const space = isSpace(node.properties.space) ? node.properties.space : void 0;
+				return node.type === COLLECTIONS_SECTION_TYPE && space ? Option.some(space) : Option.none();
+			},
+			connector: (space, get) => {
+				const ephemeralState = get(capabilities.get(SpaceCapabilities.EphemeralState));
+				get(Obj.atom(space.properties));
+				const collectionRef = Annotation.get(space.properties, AppAnnotation.RootCollectionAnnotation).pipe(Option.getOrUndefined);
+				const collection = collectionRef ? get(Obj.atom(collectionRef)) : void 0;
+				if (!collection) return Effect.succeed([]);
+				const objects = (collection.objects ?? []).map((ref) => {
+					get(Obj.atom(ref));
+					return ref.target;
+				}).filter(isNonNullable);
+				return Effect.succeed(objects.map((object) => AppNode.makeObject({
+					get,
+					db: space.db,
+					object,
+					navigable: true,
+					deck: collectionDeck(object, ephemeralState.navigableCollections),
+					canDrop: AppNode.CAN_DROP_COLLECTION_ITEM,
+					onRearrange: collectionRef?.target ? AppNode.makeCollectionRearrangeCallback(collectionRef.target) : void 0
+				})).filter(isNonNullable));
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: "objects",
+			url: {
+				key: "object",
+				kind: "item",
+				path: ({ id, workspace }) => Effect.gen(function* () {
+					if (!SpaceId.isValid(workspace)) return null;
+					const space = capabilities.get(ClientCapabilities.Client).spaces.get(workspace);
+					if (!space) return null;
+					return (yield* resolveCollectionObjectPath({ objectId: id }).pipe(Effect.provide(Database.layer(space.db)))) ?? null;
+				})
+			},
+			match: (node) => Obj.instanceOf(Collection.Collection, node.data) ? Option.some(node.data) : Option.none(),
+			connector: (collection, get) => {
+				const ephemeralState = get(capabilities.get(SpaceCapabilities.EphemeralState));
+				const db = Obj.getDatabase(collection);
+				const objects = (get(Obj.atom(collection)).objects ?? []).map((ref) => {
+					get(Obj.atom(ref));
+					return ref.target;
+				}).filter(isNonNullable);
+				return Effect.succeed(objects.map((object) => db && AppNode.makeObject({
+					get,
+					object,
+					db,
+					navigable: true,
+					deck: collectionDeck(object, ephemeralState.navigableCollections),
+					canDrop: AppNode.CAN_DROP_COLLECTION_ITEM,
+					onRearrange: AppNode.makeCollectionRearrangeCallback(collection)
+				})).filter(isNonNullable));
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: "objectActions",
+			match: (node) => {
+				return node.data != null && Obj.getDatabase(node.data) && Obj.isObject(node.data) && Obj.getTypename(node.data) === node.type ? Option.some({
+					object: node.data,
+					nodeId: node.id
+				}) : Option.none();
+			},
+			actions: ({ object, nodeId }, get) => {
+				const deletable = !Type.isType(object);
+				const [appGraph] = get(capabilities.atom(AppCapabilities.AppGraph));
+				const ephemeralState = get(capabilities.get(SpaceCapabilities.EphemeralState));
+				if (!appGraph) return Effect.succeed([]);
+				const parentId = nodeId.substring(0, nodeId.lastIndexOf("/"));
+				const parentNode = Option.getOrUndefined(Graph.getNode(appGraph.graph, parentId));
+				const parentCollection = parentNode && Obj.instanceOf(Collection.Collection, parentNode.data) ? parentNode.data : void 0;
+				return Effect.succeed(constructObjectActions({
+					object,
+					nodeId,
+					deletable,
+					navigable: ephemeralState.navigableCollections,
+					shareableLinkOrigin,
+					parentCollection
+				}));
+			}
+		}),
+		GraphBuilder.createExtension({
+			id: "collectionsSectionActions",
+			match: (node) => {
+				const space = isSpace(node.properties.space) ? node.properties.space : void 0;
+				return node.type === COLLECTIONS_SECTION_TYPE && space ? Option.some(space) : Option.none();
+			},
+			actions: (space) => Effect.succeed([Node.makeAction({
+				id: SpaceOperation.OpenCreateObject.meta.key,
+				data: () => Effect.gen(function* () {
+					const rootCollection = Annotation.get(space.properties, AppAnnotation.RootCollectionAnnotation).pipe(Option.getOrUndefined)?.target;
+					yield* Operation.invoke(SpaceOperation.OpenCreateObject, {
+						target: rootCollection ?? space.db,
+						targetNodeId: GraphPath.getCollectionsPath(space.id)
+					});
+				}),
+				properties: {
+					label: CREATE_OBJECT_IN_COLLECTION_LABEL,
+					icon: "ph--plus--regular",
+					disposition: "list-item-primary",
+					testId: "spacePlugin.createObject"
+				}
+			})])
+		})
+	]);
+});
+/** Builds the action list for an ECHO object node. */
+var constructObjectActions = ({ object, nodeId, deletable = true, navigable = false, shareableLinkOrigin, parentCollection }) => {
+	invariant(Obj.getDatabase(object), "Database not found", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 329,
+		S: void 0,
+		A: ["db", "'Database not found'"]
+	});
+	const typename = Obj.getTypename(object);
+	invariant(typename, "Object has no typename", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 331,
+		S: void 0,
+		A: ["typename", "'Object has no typename'"]
+	});
+	return [
+		...Obj.instanceOf(Collection.Collection, object) ? [Node.makeAction({
+			id: SpaceOperation.OpenCreateObject.meta.key,
+			data: () => Operation.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"
+			}
+		})] : [],
+		Node.makeAction({
+			id: SpaceOperation.RenameObject.meta.key,
+			data: (params) => Operation.invoke(SpaceOperation.RenameObject, {
+				object,
+				caller: `${params?.caller}:${params?.parent?.id}`
+			}),
+			properties: {
+				label: AppNode.getDynamicLabel("rename-object.label", typename, { defaultValue: "Rename" }),
+				icon: "ph--pencil-simple-line--regular",
+				disposition: "list-item",
+				testId: "spacePlugin.renameObject"
+			}
+		}),
+		Node.makeAction({
+			id: SpaceOperation.RemoveObjects.meta.key,
+			data: () => Operation.invoke(SpaceOperation.RemoveObjects, {
+				objects: [object],
+				target: parentCollection
+			}),
+			properties: {
+				label: AppNode.getDynamicLabel("delete-object.label", typename, { defaultValue: "Delete" }),
+				icon: "ph--trash--regular",
+				disposition: "list-item",
+				disabled: !deletable,
+				testId: "spacePlugin.deleteObject"
+			}
+		}),
+		...navigable || !Obj.instanceOf(Collection.Collection, object) ? [Node.makeAction({
+			id: "copyLink",
+			data: () => Effect.gen(function* () {
+				const builder = yield* Capability.get(AppCapabilities.AppGraph);
+				const path = UrlResolution.getShareableLinkPath(builder, nodeId);
+				if (Option.isNone(path)) {
+					log.warn("object has no URL representation; cannot copy link", { nodeId }, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file,
+						L: 383,
+						S: this
+					});
+					return;
+				}
+				const url = new URL(path.value, shareableLinkOrigin);
+				yield* Effect.promise(() => navigator.clipboard.writeText(url.toString()));
+			}),
+			properties: {
+				label: COPY_LINK_LABEL,
+				icon: "ph--link--regular",
+				disposition: "list-item",
+				testId: "spacePlugin.copyLink"
+			}
+		})] : [],
+		Node.makeAction({
+			id: LayoutOperation.Expose.meta.key,
+			data: () => Operation.invoke(LayoutOperation.Expose, { subject: GraphPath.getObjectPathFromObject(object) }),
+			properties: {
+				label: EXPOSE_OBJECT_LABEL,
+				icon: "ph--eye--regular",
+				disposition: "heading-list-item",
+				testId: "spacePlugin.exposeObject"
+			}
+		})
+	];
+};
+//#endregion
+//#region src/capabilities/app-graph-builder/extensions/companions.ts
+/** Creates companion panel extensions: object settings, related, and selected-objects. */
+var createCompanionExtensions = Effect.fnUntraced(function* () {
+	return yield* Effect.all([
+		GraphBuilder.createExtension({
+			id: "settings",
+			match: NodeMatcher.whenEchoObjectMatches,
+			connector: (node) => Effect.succeed([AppNode.makeCompanion({
+				variant: "settings",
+				label: ["object-properties.label", { ns: meta.profile.key }],
+				icon: "ph--sliders--regular",
+				data: "settings",
+				position: Position.last
+			})])
+		}),
+		GraphBuilder.createExtension({
+			id: "related",
+			match: NodeMatcher.whenEchoObjectMatches,
+			connector: (node) => Effect.succeed([AppNode.makeCompanion({
+				variant: "related",
+				label: ["companion-related.label", { ns: meta.profile.key }],
+				icon: "ph--graph--regular",
+				data: "related",
+				position: Position.last
+			})])
+		}),
+		GraphBuilder.createExtension({
+			id: "selectedObjects",
+			match: (node) => {
+				if (Type.isType(node.data)) return Option.some(node);
+				if (!Obj.isObject(node.data)) return Option.none();
+				const type = Obj.getType(node.data);
+				const path = type ? ViewAnnotation.get(Type.getSchema(type)).pipe(Option.getOrElse(() => [])) : [];
+				if (!(type && path.length > 0 ? ViewAnnotation.hasRefAlongPath(node.data, path) : false)) return Option.none();
+				return Option.some(node);
+			},
+			connector: (node) => Effect.succeed([AppNode.makeCompanion({
+				variant: "selected-objects",
+				label: ["companion-selected-objects.label", { ns: meta.profile.key }],
+				icon: "ph--tree-view--regular",
+				data: "selected-objects"
+			})])
+		})
+	]);
+});
+//#endregion
+//#region src/capabilities/app-graph-builder/extensions/settings.ts
+/**
+* Settings section attached directly under each Space node, plus its children.
+*
+* The virtual `settings` section is pinned to the top via `position: Position.first`
+* so it sits above the un-positioned middle band (collections, mailboxes,
+* automations, integrations, etc.). It groups the panels contributed by this
+* plugin (general, members) and by other plugins (automation, functions).
+*/
+var createSettingsExtensions = Effect.fnUntraced(function* () {
+	return [
+		yield* GraphBuilder.createExtension({
+			id: "settingsSection",
+			match: AppNodeMatcher.whenSpace,
+			connector: (space) => Effect.succeed([AppNode.makeSection({
+				id: SETTINGS_SECTION_ID,
+				type: SETTINGS_SECTION_TYPE,
+				label: ["settings-section.label", { ns: meta.profile.key }],
+				icon: "ph--sliders--regular",
+				iconHue: "emerald",
+				space,
+				position: Position.first,
+				testId: "spacePlugin.settings"
+			})])
+		}),
+		yield* GraphBuilder.createExtension({
+			id: "settingsGeneral",
+			url: {
+				key: "settings",
+				kind: "singleton",
+				path: [SETTINGS_SECTION_ID]
+			},
+			match: AppNodeMatcher.whenSpaceSettings,
+			connector: (space) => Effect.succeed([Node.make({
+				id: "settings",
+				type: `${meta.profile.key}.general`,
+				data: `${meta.profile.key}.general`,
+				properties: {
+					label: ["space-settings-properties.label", { ns: meta.profile.key }],
+					icon: "ph--brackets-curly--regular",
+					iconHue: "emerald",
+					space,
+					position: Position.first,
+					testId: "spacePlugin.general"
+				}
+			})])
+		}),
+		yield* GraphBuilder.createExtension({
+			id: "settingsMembers",
+			url: {
+				key: "members",
+				kind: "singleton",
+				path: [SETTINGS_SECTION_ID]
+			},
+			match: AppNodeMatcher.whenSpaceSettings,
+			connector: (space) => Effect.succeed(AppSpace.isPersonalSpace(space) ? [] : [Node.make({
+				id: "members",
+				type: `${meta.profile.key}.members`,
+				data: `${meta.profile.key}.members`,
+				properties: {
+					label: ["members-panel.label", { ns: meta.profile.key }],
+					icon: "ph--users--regular",
+					iconHue: "emerald",
+					space,
+					position: Position.first,
+					testId: "spacePlugin.members"
+				}
+			})])
+		})
+	];
+});
+//#endregion
+//#region src/capabilities/app-graph-builder/app-graph-builder.ts
+var app_graph_builder_default = Capability.makeModule(Effect.fnUntraced(function* ({ shareableLinkOrigin = window.location.origin } = {}) {
+	const extensions = yield* Effect.all([
+		createSpaceExtensions(),
+		createSettingsExtensions(),
+		createDatabaseExtensions(),
+		createCollectionExtensions({ shareableLinkOrigin }),
+		createCompanionExtensions()
+	]);
+	return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions.flat());
+}));
+//#endregion
+export { app_graph_builder_default as default };
+
+//# sourceMappingURL=chunk-app-graph-builder.mjs.map