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

package/dist/types/src/components/ObjectDetails/BaseObjectSettings.stories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseObjectSettings.stories.d.ts","sourceRoot":"","sources":["../../../../../src/components/ObjectDetails/BaseObjectSettings.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAA8B,MAAM,OAAO,CAAC;AA8BnD,QAAA,MAAM,IAAI;;eAEyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBD,CAAC;AAEtC,eAAe,IAAI,CAAC;AAEpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnC,eAAO,MAAM,OAAO,EAAE,KAAU,CAAC"}

package/dist/types/src/components/ObjectDetails/ForeignKeys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ForeignKeys.d.ts","sourceRoot":"","sources":["../../../../../src/components/ObjectDetails/ForeignKeys.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAsB,MAAM,OAAO,CAAC;AAE3C,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AAKtC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC;CAC1C,CAAC;AAGF,eAAO,MAAM,WAAW,GAAI,oBAAoB,gBAAgB,sBAQ/D,CAAC"}

package/dist/types/src/components/ObjectDetails/index.d.ts

@@ -1,3 +0,0 @@
-export * from './BaseObjectSettings';
-export * from './ForeignKeys';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/components/ObjectDetails/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ObjectDetails/index.ts"],"names":[],"mappings":"AAIA,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC"}

package/dist/types/src/components/ObjectForm/ObjectForm.d.ts

@@ -1,9 +0,0 @@
-import * as Schema from 'effect/Schema';
-import React from 'react';
-import { Obj } from '@dxos/echo';
-export type ObjectFormProps = {
-    schema: Schema.Schema.AnyNoContext;
-    object: Obj.Unknown;
-};
-export declare const ObjectForm: ({ object, schema }: ObjectFormProps) => React.JSX.Element;
-//# sourceMappingURL=ObjectForm.d.ts.map

package/dist/types/src/components/ObjectForm/ObjectForm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectForm.d.ts","sourceRoot":"","sources":["../../../../../src/components/ObjectForm/ObjectForm.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAA+B,MAAM,OAAO,CAAC;AAEpD,OAAO,EAAO,GAAG,EAAkB,MAAM,YAAY,CAAC;AAQtD,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;IACnC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,oBAAoB,eAAe,sBA8E7D,CAAC"}

package/dist/types/src/components/ObjectForm/index.d.ts

@@ -1,2 +0,0 @@
-export * from './ObjectForm';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/components/ObjectForm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ObjectForm/index.ts"],"names":[],"mappings":"AAIA,cAAc,cAAc,CAAC"}

package/dist/types/src/containers/ObjectDetails/ObjectDetails.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
-import { type Obj } from '@dxos/echo';
-export type ObjectDetailsProps = SurfaceComponentProps<Obj.Unknown>;
-export declare const ObjectDetails: React.ForwardRefExoticComponent<{
-    role?: string;
-    attendableId?: string;
-    subject: Obj.Unknown;
-} & React.RefAttributes<HTMLDivElement>>;
-//# sourceMappingURL=ObjectDetails.d.ts.map

package/dist/types/src/containers/ObjectDetails/ObjectDetails.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectDetails.d.ts","sourceRoot":"","sources":["../../../../../src/containers/ObjectDetails/ObjectDetails.tsx"],"names":[],"mappings":"AAIA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAGnD,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AAKtC,MAAM,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAEpE,eAAO,MAAM,aAAa;;;;wCAoBzB,CAAC"}

package/dist/types/src/containers/ObjectDetails/index.d.ts

@@ -1,3 +0,0 @@
-import { ObjectDetails } from './ObjectDetails';
-export default ObjectDetails;
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/containers/ObjectDetails/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/containers/ObjectDetails/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,eAAe,aAAa,CAAC"}

package/dist/types/src/containers/ObjectRenamePopover/ObjectRenamePopover.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-import { Obj } from '@dxos/echo';
-export declare const OBJECT_RENAME_POPOVER: string;
-export declare const ObjectRenamePopover: ({ object }: {
-    object: Obj.Unknown;
-}) => React.JSX.Element;
-//# sourceMappingURL=ObjectRenamePopover.d.ts.map

package/dist/types/src/containers/ObjectRenamePopover/ObjectRenamePopover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectRenamePopover.d.ts","sourceRoot":"","sources":["../../../../../src/containers/ObjectRenamePopover/ObjectRenamePopover.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAwC,MAAM,OAAO,CAAC;AAI7D,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAOjC,eAAO,MAAM,qBAAqB,QAAmC,CAAC;AAEtE,eAAO,MAAM,mBAAmB,GAAI,YAAY;IAAE,MAAM,EAAE,GAAG,CAAC,OAAO,CAAA;CAAE,sBAkCtE,CAAC"}

package/dist/types/src/containers/ObjectRenamePopover/index.d.ts

@@ -1,3 +0,0 @@
-import { ObjectRenamePopover } from './ObjectRenamePopover';
-export default ObjectRenamePopover;
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/containers/ObjectRenamePopover/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/containers/ObjectRenamePopover/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,eAAe,mBAAmB,CAAC"}

package/dist/types/src/containers/SpacePluginSettings/SpacePluginSettings.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import { type SpaceSettingsProps } from '../../types';
-export type SpacePluginSettingsComponentProps = {
-    settings: SpaceSettingsProps;
-    onSettingsChange: (fn: (current: SpaceSettingsProps) => SpaceSettingsProps) => void;
-};
-export declare const SpacePluginSettings: ({ settings, onSettingsChange }: SpacePluginSettingsComponentProps) => React.JSX.Element;
-//# sourceMappingURL=SpacePluginSettings.d.ts.map

package/dist/types/src/containers/SpacePluginSettings/SpacePluginSettings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SpacePluginSettings.d.ts","sourceRoot":"","sources":["../../../../../src/containers/SpacePluginSettings/SpacePluginSettings.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAS1B,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGtE,MAAM,MAAM,iCAAiC,GAAG;IAC9C,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,gBAAgB,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,kBAAkB,KAAK,IAAI,CAAC;CACrF,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,gCAAgC,iCAAiC,sBA2CpG,CAAC"}

package/dist/types/src/containers/SpacePluginSettings/index.d.ts

@@ -1,3 +0,0 @@
-import { SpacePluginSettings } from './SpacePluginSettings';
-export default SpacePluginSettings;
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/containers/SpacePluginSettings/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/containers/SpacePluginSettings/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,eAAe,mBAAmB,CAAC"}

package/dist/types/src/helpers/index.d.ts

@@ -1,2 +0,0 @@
-export * from './query';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/helpers/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/helpers/index.ts"],"names":[],"mappings":"AAIA,cAAc,SAAS,CAAC"}

package/dist/types/src/helpers/query.d.ts

@@ -1,7 +0,0 @@
-import type * as Schema from 'effect/Schema';
-import { Query, type QueryAST, type SchemaRegistry } from '@dxos/echo';
-import { type Space } from '@dxos/react-client/echo';
-export declare const evalQuery: (queryString: string) => Query.Any;
-export declare const resolveSchemaWithRegistry: (registry: SchemaRegistry.SchemaRegistry, query: QueryAST.Query) => Promise<Schema.Schema.AnyNoContext | undefined>;
-export declare const getQueryTarget: (query: QueryAST.Query, space?: Space) => import("@dxos/echo/Database").Database | import("@dxos/echo-db").Queue<import("@dxos/echo/Entity").Unknown> | undefined;
-//# sourceMappingURL=query.d.ts.map

package/dist/types/src/helpers/query.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../src/helpers/query.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C,OAAO,EAAoB,KAAK,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AASzF,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAKrD,eAAO,MAAM,SAAS,GAAI,aAAa,MAAM,KAAG,KAAK,CAAC,GASrD,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,UAAU,cAAc,CAAC,cAAc,EAAE,OAAO,QAAQ,CAAC,KAAK,oDAgBvG,CAAC;AAuFF,eAAO,MAAM,cAAc,GAAI,OAAO,QAAQ,CAAC,KAAK,EAAE,QAAQ,KAAK,4HAyBlE,CAAC"}

package/dist/types/src/helpers/query.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=query.test.d.ts.map

package/dist/types/src/helpers/query.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../../../../src/helpers/query.test.ts"],"names":[],"mappings":""}

package/dist/types/src/hooks/useActiveSpace.d.ts

@@ -1,4 +0,0 @@
-import { type CapabilityManager } from '@dxos/app-framework';
-export declare const getActiveSpace: (capabilities: CapabilityManager.CapabilityManager) => import("@dxos/client-protocol").Space | undefined;
-export declare const useActiveSpace: () => import("@dxos/client-protocol").Space | undefined;
-//# sourceMappingURL=useActiveSpace.d.ts.map

package/dist/types/src/hooks/useActiveSpace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useActiveSpace.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useActiveSpace.ts"],"names":[],"mappings":"AAIA,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAM3E,eAAO,MAAM,cAAc,GAAI,cAAc,iBAAiB,CAAC,iBAAiB,sDAO/E,CAAC;AAEF,eAAO,MAAM,cAAc,yDAI1B,CAAC"}

package/dist/types/src/hooks/useTypeOptions.d.ts

@@ -1,10 +0,0 @@
-import { type Space } from '@dxos/react-client/echo';
-import { type TypeInputOptions } from '../types';
-export declare const useTypeOptions: ({ space, annotation }: {
-    space?: Space;
-    annotation: TypeInputOptions;
-}) => {
-    value: string;
-    label: string;
-}[];
-//# sourceMappingURL=useTypeOptions.d.ts.map

package/dist/types/src/hooks/useTypeOptions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTypeOptions.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useTypeOptions.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,UAAU,CAAC;AAE/D,eAAO,MAAM,cAAc,GAAI,uBAAuB;IAAE,KAAK,CAAC,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,gBAAgB,CAAA;CAAE;;;GAapG,CAAC"}

package/src/capabilities/app-graph-builder/extensions/types.ts

@@ -1,421 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Atom } from '@effect-atom/atom-react';
-import * as Effect from 'effect/Effect';
-import * as Match from 'effect/Match';
-import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
-
-import { Capability } from '@dxos/app-framework';
-import { AppCapabilities, LayoutOperation, Segments } from '@dxos/app-toolkit';
-import { type Space, SpaceState, isSpace } from '@dxos/client/echo';
-import { Collection, Filter, Obj, Query, Type } from '@dxos/echo';
-import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
-import { AtomObj, AtomQuery } from '@dxos/echo-atom';
-import { Operation } from '@dxos/operation';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { CreateAtom, GraphBuilder, Node } from '@dxos/plugin-graph';
-import { ViewAnnotation } from '@dxos/schema';
-import { createFilename, isNonNullable } from '@dxos/util';
-
-import { meta } from '../../../meta';
-import { SpaceOperation } from '../../../types';
-
-import {
-  ADD_VIEW_TO_SCHEMA_LABEL,
-  BLOCK_REORDER_ABOVE,
-  type MetadataResolver,
-  SNAPSHOT_BY_SCHEMA_LABEL,
-  STATIC_SCHEMA_TYPE,
-  TYPES_SECTION_TYPE,
-  TYPE_COLLECTION_TYPE,
-  buildViewIndex,
-  createObjectNode,
-  downloadBlob,
-  getDynamicLabel,
-  whenSpace,
-} from './shared';
-
-//
-// Extension Factory
-//
-
-/** Creates type-related extensions: types section, schema nodes, schema children, and schema actions. */
-export const createTypeExtensions = Effect.fnUntraced(function* () {
-  const capabilities = yield* Capability.Service;
-
-  const resolve = (_get: any) => (typename: string) =>
-    capabilities.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
-
-  return yield* Effect.all([
-    // Types section virtual node under each space.
-    GraphBuilder.createExtension({
-      id: `${meta.id}.types-section`,
-      match: whenSpace,
-      connector: (space, get) => {
-        const spaceState = get(CreateAtom.fromObservable(space.state));
-        if (spaceState !== SpaceState.SPACE_READY) {
-          return Effect.succeed([]);
-        }
-
-        return Effect.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.
-    GraphBuilder.createExtension({
-      id: `${meta.id}.types`,
-      match: (node) => {
-        const space = isSpace(node.properties.space) ? node.properties.space : undefined;
-        return node.type === TYPES_SECTION_TYPE && space ? Option.some(space) : Option.none();
-      },
-      connector: (space, get) => {
-        // TODO(wittjosiah): Make schema queries reactive to simplify this.
-        // Reactive subscription to database schema objects so the connector re-runs on schema changes.
-        get(AtomQuery.make(space.db, Filter.type(Type.PersistentType)));
-        // Reactive subscription to client/plugin-contributed schemas so the connector re-runs when new schemas or static schemas are added.
-        get(capabilities.atom(AppCapabilities.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(Option.getOrElse(() => false))) {
-            return false;
-          }
-          if (ViewAnnotation.get(schema).pipe(Option.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(AtomQuery.make(space.db, Filter.typename(typename)));
-          return objects.length > 0 || viewIndex.typenamesWithViews.has(typename);
-        });
-
-        return Effect.succeed(
-          visibleSchemas.map((schema) => createSchemaNode({ schema, space, resolve: resolve(get), get })),
-        );
-      },
-    }),
-
-    // {All} virtual node + view objects under each schema node.
-    GraphBuilder.createExtension({
-      id: `${meta.id}.schema-children`,
-      match: (node) => {
-        const space = isSpace(node.properties.space) ? node.properties.space : undefined;
-        return space && (Obj.instanceOf(Type.PersistentType, node.data) || Schema.isSchema(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?.graph.schemaRegistry.query({ location: ['runtime'] }).runSync() ?? [];
-
-        const typename = Schema.isSchema(schema) ? Type.getTypename(schema as Type.AnyObj) : schema.typename;
-
-        // {All} virtual node.
-        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,
-          },
-        };
-
-        // View objects for this schema.
-        const viewIndex = buildViewIndex(get, space, schemas);
-        const viewNodes = viewIndex
-          .getViewsForTypename(typename)
-          .map((object: Obj.Unknown) =>
-            createObjectNode({
-              db: space.db,
-              object,
-              resolve: resolve(get),
-              droppable: false,
-            }),
-          )
-          .filter(isNonNullable);
-
-        return Effect.succeed([allNode, ...viewNodes]);
-      },
-    }),
-
-    // Objects of the schema type under the {All} node.
-    GraphBuilder.createExtension({
-      id: `${meta.id}.type-collection-objects`,
-      match: (node) => {
-        if (node.type !== TYPE_COLLECTION_TYPE || !node.data?.space || !node.data?.typename) {
-          return Option.none();
-        }
-        return Option.some({ space: node.data.space as Space, typename: node.data.typename as string });
-      },
-      connector: ({ space, typename }, get) => {
-        const objects = get(AtomQuery.make(space.db, Filter.typename(typename)));
-
-        return Effect.succeed(
-          objects
-            .map((object: Obj.Unknown) => {
-              get(AtomObj.make(object));
-              return createObjectNode({
-                db: space.db,
-                object,
-                resolve: resolve(get),
-                droppable: false,
-              });
-            })
-            .filter(isNonNullable),
-        );
-      },
-    }),
-
-    // Actions for schema nodes.
-    GraphBuilder.createExtension({
-      id: `${meta.id}.schema-actions`,
-      match: (node) => {
-        const space = isSpace(node.properties.space) ? node.properties.space : undefined;
-        return space && Schema.isSchema(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?.graph.schemaRegistry.query({ location: ['runtime'] }).runSync() ?? [];
-
-        const targetTypename = Type.getTypename(schema as Type.AnyObj);
-        const viewIndex = buildViewIndex(get, space, schemas);
-        const deletable =
-          Type.isMutable(schema as Type.AnyObj) && viewIndex.getViewsForTypename(targetTypename).length === 0;
-
-        return Effect.succeed(
-          createSchemaActions({
-            schema: schema as Type.AnyObj,
-            space,
-            deletable,
-            resolve: resolve(get),
-          }),
-        );
-      },
-    }),
-  ]);
-});
-
-//
-// Helpers
-//
-
-/** Builds a graph node for a schema in the Types subtree. */
-const createSchemaNode = ({
-  schema,
-  space,
-  resolve,
-  get,
-}: {
-  schema: Type.AnyEntity;
-  space: Space;
-  resolve: MetadataResolver;
-  get: Atom.Context;
-}): Node.Node => {
-  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(AtomObj.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,
-    },
-  };
-};
-
-/** Builds schema actions (add view, rename, delete, snapshot). */
-const createSchemaActions = ({
-  schema,
-  space,
-  deletable,
-  resolve,
-}: {
-  schema: Type.AnyObj;
-  space: Space;
-  deletable: boolean;
-  resolve: MetadataResolver;
-}) => {
-  const typename = Type.getTypename(schema);
-  const metadata = resolve(typename);
-  const createObjectFn = metadata.createObject;
-  const inputSchema = metadata.inputSchema;
-
-  const actions: Node.NodeArg<Node.ActionData<Operation.Service>>[] = [
-    ...(createObjectFn
-      ? [
-          {
-            id: SpaceOperation.OpenCreateObject.meta.key,
-            type: Node.ActionType,
-            data: Effect.fnUntraced(function* () {
-              if (inputSchema) {
-                yield* Operation.invoke(SpaceOperation.OpenCreateObject, {
-                  target: space.db,
-                  typename,
-                });
-              } else {
-                const createdObject = yield* createObjectFn({}, { db: space.db }) as Effect.Effect<
-                  Obj.Unknown,
-                  Error,
-                  never
-                >;
-                const addResult = yield* Operation.invoke(SpaceOperation.AddObject, {
-                  target: space.db,
-                  hidden: true,
-                  object: createdObject,
-                });
-                if (addResult.subject) {
-                  yield* Operation.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: Node.ActionType,
-      data: () =>
-        Operation.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: Node.ActionType,
-      data: (params?: Node.InvokeProps) =>
-        Type.isMutable(schema)
-          ? Operation.invoke(SpaceOperation.RenameObject, {
-              object: (schema as Type.RuntimeType).persistentSchema as any,
-              caller: `${params?.caller}:${params?.parent?.id}`,
-            })
-          : Effect.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: Node.ActionType,
-      data: () =>
-        Type.isMutable(schema)
-          ? Operation.invoke(SpaceOperation.RemoveObjects, {
-              objects: [(schema as Type.RuntimeType).persistentSchema as Obj.Unknown],
-            })
-          : Effect.succeed(undefined),
-      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: Node.ActionType,
-      data: Effect.fnUntraced(function* () {
-        const result = yield* Operation.invoke(SpaceOperation.Snapshot, {
-          db: space.db,
-          query: Query.select(Filter.type(schema)).ast,
-        });
-        if (result.snapshot) {
-          yield* Effect.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;
-};