@dxos/plugin-space 0.8.4-main.72ec0f3 → 0.8.4-main.7996785055

package/dist/lib/node-esm/chunk-QAL755T4.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/capabilities.ts", "../../../src/types/events.ts", "../../../src/types/form.ts", "../../../src/types/types.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Atom } from '@effect-atom/atom-react';\nimport type * as Effect from 'effect/Effect';\nimport * as Schema from 'effect/Schema';\n\nimport { Capability } from '@dxos/app-framework';\nimport { type Space } from '@dxos/client/echo';\nimport { type Database } from '@dxos/echo';\nimport { type Collection } from '@dxos/echo';\nimport { type PublicKey } from '@dxos/keys';\nimport { type Operation } from '@dxos/operation';\nimport { type Label } from '@dxos/ui-types';\nimport { type ComplexMap, type Position } from '@dxos/util';\n\nimport { meta } from '../meta';\n\nimport { type ObjectViewerProps, type SpaceSettingsProps } from './types';\n\nexport namespace SpaceCapabilities {\n  export const Settings = Capability.make<Atom.Writable<SpaceSettingsProps>>(`${meta.id}.capability.settings`);\n\n  /** Schema for persisted space plugin state. */\n  export const StateSchema = Schema.mutable(\n    Schema.Struct({\n      spaceNames: Schema.Record({ key: Schema.String, value: Schema.String }),\n      enabledEdgeReplication: Schema.Boolean,\n    }),\n  );\n\n  export type SpaceState = Schema.Schema.Type<typeof StateSchema>;\n\n  /** Persisted state (stored in KVS/localStorage). */\n  export const State = Capability.make<Atom.Writable<SpaceState>>(`${meta.id}.capability.state`);\n\n  /** Ephemeral space plugin state (not persisted). */\n  export type SpaceEphemeralState = {\n    awaiting: string | undefined;\n    sdkMigrationRunning: Record<string, boolean>;\n    navigableCollections: boolean;\n    viewersByObject: Record<string, ComplexMap<PublicKey, ObjectViewerProps>>;\n    viewersByIdentity: ComplexMap<PublicKey, Set<string>>;\n  };\n\n  /** Transient/ephemeral state (not persisted). */\n  export const EphemeralState = Capability.make<Atom.Writable<SpaceEphemeralState>>(\n    `${meta.id}.capability.ephemeral-state`,\n  );\n\n  export type SettingsSection = { id: string; label: Label; position?: Position };\n  export const SettingsSection = Capability.make<SettingsSection>(`${meta.id}.capability.settings-section`);\n\n  export type OnCreateSpace = (params: {\n    space: Space;\n    isDefault: boolean;\n    rootCollection: Collection.Collection;\n  }) => Effect.Effect<void, Error, Operation.Service>;\n  export const OnCreateSpace = Capability.make<OnCreateSpace>(`${meta.id}.capability.on-space-created`);\n\n  export type OnSchemaAdded = (params: {\n    db: Database.Database;\n    schema: Schema.Schema.AnyNoContext;\n    // TODO(wittjosiah): This is leaky.\n    show?: boolean;\n  }) => Effect.Effect<void, Error, Operation.Service>;\n  export const OnSchemaAdded = Capability.make<OnSchemaAdded>(`${meta.id}.capability.on-schema-added`);\n\n  // TODO(wittjosiah): Replace with migrations, this is not a sustainable solution.\n  export type HandleRepair = (params: { space: Space; isDefault: boolean }) => Promise<void>;\n  export const Repair = Capability.make<HandleRepair>(`${meta.id}.capability.repair`);\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { ActivationEvent } from '@dxos/app-framework';\nimport { AppActivationEvents } from '@dxos/app-toolkit';\n\nimport { meta } from '../meta';\n\nexport namespace SpaceEvents {\n  export const StateReady = AppActivationEvents.createStateEvent(`${meta.id}.event.state-ready`);\n  export const SetupSettingsPanel = ActivationEvent.make(`${meta.id}.event.setup-settings-panel`);\n  export const PersonalSpaceReady = ActivationEvent.make(`${meta.id}.event.default-space-ready`);\n  export const SpaceCreated = ActivationEvent.make(`${meta.id}.event.space-created`);\n  export const SchemaAdded = ActivationEvent.make(`${meta.id}.event.schema-added`);\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\n\nimport { type Space } from '@dxos/client/echo';\nimport { Type } from '@dxos/echo';\nimport { EntityKind, SystemTypeAnnotation, createAnnotationHelper, getTypeAnnotation } from '@dxos/echo/internal';\n\nexport const TypeInputOptions = Schema.Struct({\n  location: Schema.Array(Schema.Literal('database', 'runtime')),\n  kind: Schema.Array(Schema.Literal('system', 'user')),\n});\n\nexport type TypeInputOptions = Schema.Schema.Type<typeof TypeInputOptions>;\n\n/**\n * Used in forms to identify the field representing an object's type and determine which types are shown as options.\n */\nexport const TypeInputOptionsAnnotationId = Symbol.for('@dxos/schema/annotation/TypeInputOptions');\nexport const TypeInputOptionsAnnotation = createAnnotationHelper<TypeInputOptions>(TypeInputOptionsAnnotationId);\n\n// TODO(wittjosiah): This is too complicated and needs to be simplified.\nexport const getTypenames = ({ annotation, space }: { annotation: TypeInputOptions; space?: Space }) => {\n  const includeRuntime = annotation.location.includes('runtime');\n  const includeDatabase = annotation.location.includes('database');\n  const includeSystemType = annotation.kind.includes('system');\n  const includeUserType = annotation.kind.includes('user');\n\n  const runtimeTypenames =\n    includeRuntime && space\n      ? space.db.schemaRegistry\n          .query({ location: ['runtime'] })\n          .runSync()\n          .filter((schema) => {\n            const relation = getTypeAnnotation(schema)?.kind === EntityKind.Relation;\n            if (relation) {\n              return includeSystemType;\n            }\n\n            const system = SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false));\n            if (system) {\n              return includeSystemType;\n            }\n\n            return includeUserType;\n          })\n          .map((schema) => Type.getTypename(schema))\n      : [];\n\n  const databaseTypenames =\n    includeDatabase && space\n      ? space.db.schemaRegistry\n          .query({ location: ['database'] })\n          .runSync()\n          .map((schema) => Type.getTypename(schema))\n      : [];\n\n  return Array.from(new Set<string>([...runtimeTypenames, ...databaseTypenames])).sort();\n};\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Schema from 'effect/Schema';\n\nimport { Capability } from '@dxos/app-framework';\nimport { type PublicKey } from '@dxos/client';\nimport { Database, Obj } from '@dxos/echo';\nimport { Collection } from '@dxos/echo';\nimport { Operation } from '@dxos/operation';\nimport { type ComplexMap } from '@dxos/util';\n\nimport { meta } from '../meta';\n\nexport const SPACE_DIRECTORY_HANDLE = `${meta.id}.directory`;\n\nexport const SPACE_TYPE = 'org.dxos.type.space';\n\n/** Key for the Expando that stores cross-space ordering (must stay stable for persisted data). */\nexport const SHARED = 'shared-spaces';\n\nexport type SpacePluginOptions = {\n  /**\n   * Origin used for shareable links (object copy-link and invitation base).\n   * Defaults to window.location.origin.\n   */\n  shareableLinkOrigin?: string;\n\n  /**\n   * Path appended to shareableLinkOrigin to form the invitation base URL.\n   * Defaults to '/'.\n   */\n  invitationPath?: string;\n\n  /**\n   * Query parameter name for the invitation code.\n   */\n  invitationProp?: string;\n\n  /**\n   * Whether to send observability events.\n   */\n  observability?: boolean;\n};\n\nexport type ObjectViewerProps = {\n  lastSeen: number;\n  currentlyAttended: boolean;\n};\n\nexport type ObjectId = string;\n\nexport type PluginState = {\n  /**\n   * Which objects are currently being viewed by which peers.\n   */\n  viewersByObject: Record<ObjectId, ComplexMap<PublicKey, ObjectViewerProps>>;\n\n  /**\n   * Which peers are currently viewing which objects.\n   */\n  viewersByIdentity: ComplexMap<PublicKey, Set<ObjectId>>;\n\n  /**\n   * Object that was linked to directly but not found and is being awaited.\n   */\n  awaiting: string | undefined;\n\n  /**\n   * Cached space names, used when spaces are closed or loading.\n   */\n  spaceNames: Record<string, string>;\n\n  /**\n   * Which spaces have an SDK migration running currently.\n   */\n  // TODO(wittjosiah): Factor out to sdk. Migration running should probably be a space state.\n  sdkMigrationRunning: Record<string, boolean>;\n\n  /**\n   * Whether or not the user can navigate to collections in the graph.\n   * Determined by whether or not there is an available plugin that can render a collection.\n   */\n  navigableCollections: boolean;\n\n  /**\n   * Tracks whether setting edge replication as default has been run on spaces.\n   */\n  // TODO(wittjosiah): Systematic way to handle migrations of state outside of spaces.\n  enabledEdgeReplication: boolean;\n};\n\nexport const SpaceSettingsSchema = Schema.mutable(\n  Schema.Struct({\n    /**\n     * Show closed spaces.\n     */\n    showHidden: Schema.Boolean,\n  }),\n);\n\nexport type SpaceSettingsProps = Schema.Schema.Type<typeof SpaceSettingsSchema>;\n\n// TODO(wittjosiah): Reconcile with graph export serializers.\n\nexport type SerializerMap = Record<string, TypedObjectSerializer>;\n\nexport interface TypedObjectSerializer<T extends Obj.Unknown = Obj.Unknown> {\n  serialize(params: { object: T }): Promise<string>;\n\n  /**\n   * @param params.content\n   * @param params.space Space to use for deserializing schema references.\n   * @param params.newId Generate new ID for deserialized object.\n   */\n  deserialize(params: { content: string; db: Database.Database; newId?: boolean }): Promise<T>;\n}\n\n/**\n * Result of creating and adding an object.\n */\nexport type CreateObjectResult = {\n  id: string;\n  subject: readonly string[];\n  object: Obj.Unknown;\n};\n\n/**\n * Factory function that creates an object and adds it to a target (database or collection).\n * Returns an Effect that resolves to the created object result with navigation subject.\n */\nexport type CreateObject = (\n  props: any,\n  options: {\n    db: Database.Database;\n    target: Database.Database | Collection.Collection;\n    targetNodeId?: string;\n  },\n) => Effect.Effect<CreateObjectResult, Error, Capability.Service | Operation.Service>;\n\n// TODO(burdon): Move to FormatEnum or SDK.\nexport const IconAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Icon');\nexport const HueAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Hue');\n\n// TOOD(burdon): Use SpacePropertiesSchema.\nexport const SpaceForm = Schema.Struct({\n  name: Schema.optional(Schema.String.annotations({ title: 'Name' })),\n  icon: Schema.optional(Schema.String.annotations({ title: 'Icon', [IconAnnotationId]: true })),\n  hue: Schema.optional(Schema.String.annotations({ title: 'Color', [HueAnnotationId]: true })),\n  edgeReplication: Schema.optional(Schema.Boolean.annotations({ title: 'Enable EDGE Replication' })),\n});\n"],
+  "mappings": "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",
+  "names": ["Schema", "Capability", "SpaceCapabilities", "Settings", "Capability", "make", "meta", "id", "StateSchema", "mutable", "Struct", "spaceNames", "Record", "key", "String", "value", "enabledEdgeReplication", "Boolean", "State", "EphemeralState", "SettingsSection", "OnCreateSpace", "OnSchemaAdded", "Repair", "ActivationEvent", "AppActivationEvents", "SpaceEvents", "StateReady", "AppActivationEvents", "createStateEvent", "meta", "id", "SetupSettingsPanel", "ActivationEvent", "make", "PersonalSpaceReady", "SpaceCreated", "SchemaAdded", "Option", "Schema", "Type", "EntityKind", "SystemTypeAnnotation", "createAnnotationHelper", "getTypeAnnotation", "TypeInputOptions", "Struct", "location", "Array", "Literal", "kind", "TypeInputOptionsAnnotationId", "Symbol", "for", "TypeInputOptionsAnnotation", "createAnnotationHelper", "getTypenames", "annotation", "space", "includeRuntime", "includes", "includeDatabase", "includeSystemType", "includeUserType", "runtimeTypenames", "db", "schemaRegistry", "query", "runSync", "filter", "schema", "relation", "getTypeAnnotation", "EntityKind", "Relation", "system", "SystemTypeAnnotation", "get", "pipe", "getOrElse", "map", "Type", "getTypename", "databaseTypenames", "from", "Set", "sort", "Schema", "SPACE_DIRECTORY_HANDLE", "meta", "id", "SPACE_TYPE", "SHARED", "SpaceSettingsSchema", "mutable", "Struct", "showHidden", "Boolean", "IconAnnotationId", "Symbol", "for", "HueAnnotationId", "SpaceForm", "name", "optional", "String", "annotations", "title", "icon", "hue", "edgeReplication"]
+}

package/dist/lib/node-esm/chunk-QOYEZLA5.mjs

@@ -0,0 +1,120 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/helpers/query.ts
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as EffectFunction from "effect/Function";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as SchemaAST from "effect/SchemaAST";
+import { DXN, Filter, Key, Query } from "@dxos/echo";
+import { ReferenceAnnotationId, getTypeAnnotation, unwrapOptional } from "@dxos/echo/internal";
+import { runAndForwardErrors } from "@dxos/effect";
+import { log } from "@dxos/log";
+import { Person } from "@dxos/types";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/helpers/query.ts";
+var evalQuery = (queryString) => {
+  const globals = {
+    Query,
+    Filter,
+    Person
+  };
+  try {
+    return new Function(...Object.keys(globals), `return ${queryString}`)(...Object.values(globals));
+  } catch (err) {
+    log.catch(err, void 0, {
+      F: __dxlog_file,
+      L: 33,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return Query.select(Filter.nothing());
+  }
+};
+var resolveSchemaWithRegistry = (registry, query) => {
+  const resolve = Effect.fn(function* (dxn) {
+    const typename = DXN.parse(dxn).asTypeDXN()?.type;
+    if (!typename) {
+      return Option.none();
+    }
+    const query2 = registry.query({
+      typename,
+      location: [
+        "database",
+        "runtime"
+      ]
+    });
+    const schemas = yield* Effect.promise(() => query2.run());
+    return Array.head(schemas);
+  });
+  return resolveSchema(query, resolve).pipe(Effect.map((schema) => Option.getOrUndefined(schema)), runAndForwardErrors);
+};
+var resolveSchema = (query, resolve) => {
+  return Match.value(query).pipe(
+    Match.withReturnType(),
+    // TODO(wittjosiah): Reconcile with filter match?
+    Match.when({
+      type: "select"
+    }, ({ filter }) => typenameFromFilter(filter).pipe(Option.map((typename) => resolve(typename)), Option.getOrElse(() => Effect.succeed(Option.none())))),
+    Match.when({
+      type: "filter"
+    }, ({ filter, selection }) => {
+      const filterResult = typenameFromFilter(filter);
+      return Option.isSome(filterResult) ? filterResult.pipe(Option.map((typename) => resolve(typename)), Option.getOrElse(() => Effect.succeed(Option.none()))) : resolveSchema(selection, resolve);
+    }),
+    Match.when({
+      type: "reference-traversal"
+    }, ({ anchor, property }) => resolveSchema(anchor, resolve).pipe(Effect.map((base) => base.pipe(Option.map((schema) => SchemaAST.getPropertySignatures(schema.ast)), Option.flatMap((properties) => Array.findFirst(properties, (p) => p.name === property)), Option.flatMap((property2) => SchemaAST.getAnnotation(ReferenceAnnotationId)(unwrapOptional(property2))), Option.map((annotation) => annotation.typename))), Effect.flatMap(Option.match({
+      onNone: () => Effect.succeed(Option.none()),
+      onSome: (typename) => resolve(DXN.fromTypename(typename).toString())
+    })))),
+    Match.when({
+      type: "relation",
+      filter: Match.defined
+    }, ({ filter }) => typenameFromFilter(filter).pipe(Option.map((typename) => resolve(typename)), Option.getOrElse(() => Effect.succeed(Option.none())))),
+    Match.when({
+      type: "relation-traversal"
+    }, ({ anchor, direction }) => resolveSchema(anchor, resolve).pipe(Effect.map((base) => base.pipe(Option.map((schema) => getTypeAnnotation(schema)), Option.flatMap((annotation) => Option.fromNullable(direction === "source" ? annotation?.sourceSchema : annotation?.targetSchema)))), Effect.flatMap(Option.match({
+      onNone: () => Effect.succeed(Option.none()),
+      onSome: (typename) => resolve(typename)
+    })))),
+    Match.when({
+      type: "options"
+    }, ({ query: query2 }) => resolveSchema(query2, resolve)),
+    Match.orElse((_q) => {
+      return Effect.succeed(Option.none());
+    })
+  );
+};
+var typenameFromFilter = (filter) => Match.value(filter).pipe(Match.withReturnType(), Match.when({
+  type: "object"
+}, ({ typename }) => Option.fromNullable(typename)), Match.when({
+  type: "and"
+}, ({ filters }) => EffectFunction.pipe(filters, Array.map(typenameFromFilter), Array.findFirst(Option.isSome), Option.flatten)), Match.when({
+  type: "or"
+}, ({ filters }) => EffectFunction.pipe(filters, Array.map(typenameFromFilter), Array.findFirst(Option.isSome), Option.flatten)), Match.orElse(() => Option.none()));
+var getQueryTarget = (query, space) => {
+  return Match.value(query).pipe(Match.when({
+    type: "from"
+  }, ({ from }) => {
+    if (from._tag !== "scope") {
+      return space?.db;
+    }
+    const result = Option.fromNullable(from.scope.queues).pipe(Option.flatMap((queues) => Array.head(queues)), Option.flatMap((queueDxn) => Option.fromNullable(DXN.tryParse(String(queueDxn)))), Option.flatMap((parsed) => {
+      const q = parsed.asQueueDXN();
+      if (!q || !Key.ObjectId.isValid(q.queueId)) return Option.none();
+      return Option.fromNullable(space?.queues.get(parsed));
+    }));
+    if (from.scope.queues?.length && Option.isNone(result)) {
+      return void 0;
+    }
+    return Option.getOrElse(result, () => space?.db);
+  }), Match.orElse(() => space?.db));
+};
+
+export {
+  evalQuery,
+  resolveSchemaWithRegistry,
+  getQueryTarget
+};
+//# sourceMappingURL=chunk-QOYEZLA5.mjs.map

package/dist/lib/node-esm/chunk-QOYEZLA5.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/helpers/query.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Array from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as EffectFunction from 'effect/Function';\nimport * as Match from 'effect/Match';\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { DXN, Filter, Key, Query, type QueryAST, type SchemaRegistry } from '@dxos/echo';\nimport {\n  ReferenceAnnotationId,\n  type ReferenceAnnotationValue,\n  getTypeAnnotation,\n  unwrapOptional,\n} from '@dxos/echo/internal';\nimport { runAndForwardErrors } from '@dxos/effect';\nimport { log } from '@dxos/log';\nimport { type Space } from '@dxos/react-client/echo';\nimport { Person } from '@dxos/types';\n\n// TODO(wittjosiah): Factor out and add tests.\n// TODO(wittjosiah): Support arbitrary type imports.\nexport const evalQuery = (queryString: string): Query.Any => {\n  const globals = { Query, Filter, Person };\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-implied-eval\n    return new Function(...Object.keys(globals), `return ${queryString}`)(...Object.values(globals));\n  } catch (err) {\n    log.catch(err);\n    return Query.select(Filter.nothing());\n  }\n};\n\nexport const resolveSchemaWithRegistry = (registry: SchemaRegistry.SchemaRegistry, query: QueryAST.Query) => {\n  const resolve = Effect.fn(function* (dxn: string) {\n    const typename = DXN.parse(dxn).asTypeDXN()?.type;\n    if (!typename) {\n      return Option.none();\n    }\n\n    const query = registry.query({ typename, location: ['database', 'runtime'] });\n    const schemas = yield* Effect.promise(() => query.run());\n    return Array.head(schemas);\n  });\n\n  return resolveSchema(query, resolve).pipe(\n    Effect.map((schema) => Option.getOrUndefined(schema)),\n    runAndForwardErrors,\n  );\n};\n\nconst resolveSchema = (\n  query: QueryAST.Query,\n  resolve: (dxn: string) => Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>>,\n): Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>> => {\n  return Match.value(query).pipe(\n    Match.withReturnType<Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>>>(),\n    // TODO(wittjosiah): Reconcile with filter match?\n    Match.when({ type: 'select' }, ({ filter }) =>\n      typenameFromFilter(filter).pipe(\n        Option.map((typename) => resolve(typename)),\n        Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),\n      ),\n    ),\n    Match.when({ type: 'filter' }, ({ filter, selection }) => {\n      const filterResult = typenameFromFilter(filter);\n      return Option.isSome(filterResult)\n        ? filterResult.pipe(\n            Option.map((typename) => resolve(typename)),\n            Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),\n          )\n        : resolveSchema(selection, resolve);\n    }),\n    Match.when({ type: 'reference-traversal' }, ({ anchor, property }) =>\n      resolveSchema(anchor, resolve).pipe(\n        Effect.map((base) =>\n          base.pipe(\n            Option.map((schema) => SchemaAST.getPropertySignatures(schema.ast)),\n            Option.flatMap((properties) => Array.findFirst(properties, (p) => p.name === property)),\n            Option.flatMap((property) =>\n              SchemaAST.getAnnotation<ReferenceAnnotationValue>(ReferenceAnnotationId)(unwrapOptional(property)),\n            ),\n            Option.map((annotation) => annotation.typename),\n          ),\n        ),\n        Effect.flatMap(\n          Option.match({\n            onNone: () => Effect.succeed(Option.none()),\n            onSome: (typename) => resolve(DXN.fromTypename(typename).toString()),\n          }),\n        ),\n      ),\n    ),\n    Match.when({ type: 'relation', filter: Match.defined }, ({ filter }) =>\n      typenameFromFilter(filter).pipe(\n        Option.map((typename) => resolve(typename)),\n        Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),\n      ),\n    ),\n    Match.when({ type: 'relation-traversal' }, ({ anchor, direction }) =>\n      resolveSchema(anchor, resolve).pipe(\n        Effect.map((base) =>\n          base.pipe(\n            Option.map((schema) => getTypeAnnotation(schema)),\n            Option.flatMap((annotation) =>\n              Option.fromNullable(direction === 'source' ? annotation?.sourceSchema : annotation?.targetSchema),\n            ),\n          ),\n        ),\n        Effect.flatMap(\n          Option.match({\n            onNone: () => Effect.succeed(Option.none()),\n            onSome: (typename) => resolve(typename),\n          }),\n        ),\n      ),\n    ),\n    Match.when({ type: 'options' }, ({ query }) => resolveSchema(query, resolve)),\n    Match.orElse((_q) => {\n      // TODO(wittjosiah): Implement other cases.\n      return Effect.succeed(Option.none());\n    }),\n  );\n};\n\nconst typenameFromFilter = (filter: QueryAST.Filter): Option.Option<string> =>\n  Match.value(filter).pipe(\n    Match.withReturnType<Option.Option<string>>(),\n    Match.when({ type: 'object' }, ({ typename }) => Option.fromNullable(typename)),\n    Match.when({ type: 'and' }, ({ filters }) =>\n      EffectFunction.pipe(filters, Array.map(typenameFromFilter), Array.findFirst(Option.isSome), Option.flatten),\n    ),\n    Match.when({ type: 'or' }, ({ filters }) =>\n      EffectFunction.pipe(filters, Array.map(typenameFromFilter), Array.findFirst(Option.isSome), Option.flatten),\n    ),\n    Match.orElse(() => Option.none()),\n  );\n\n// TODO(wittjosiah): Currently assumes from scope is at the top-level of the ast.\nexport const getQueryTarget = (query: QueryAST.Query, space?: Space) => {\n  return Match.value(query).pipe(\n    Match.when({ type: 'from' }, ({ from }) => {\n      if (from._tag !== 'scope') {\n        return space?.db;\n      }\n      const result = Option.fromNullable(from.scope.queues).pipe(\n        Option.flatMap((queues) => Array.head(queues)),\n        Option.flatMap((queueDxn) => Option.fromNullable(DXN.tryParse(String(queueDxn)))),\n        Option.flatMap((parsed) => {\n          const q = parsed.asQueueDXN();\n          if (!q || !Key.ObjectId.isValid(q.queueId)) return Option.none();\n          return Option.fromNullable(space?.queues.get(parsed));\n        }),\n      );\n      // Skip query when a requested queue is not found (structurally invalid DXN or valid DXN\n      // referencing a queue not present in space.queues, e.g. not yet synced) to avoid 400 errors.\n      // TODO(wittjosiah): Can we handle this upstream?\n      if (from.scope.queues?.length && Option.isNone(result)) {\n        return undefined;\n      }\n      return Option.getOrElse(result, () => space?.db);\n    }),\n    Match.orElse(() => space?.db),\n  );\n};\n"],
+  "mappings": "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",
+  "names": ["Array", "Effect", "EffectFunction", "Match", "Option", "SchemaAST", "DXN", "Filter", "Key", "Query", "ReferenceAnnotationId", "getTypeAnnotation", "unwrapOptional", "runAndForwardErrors", "log", "Person", "evalQuery", "queryString", "globals", "Function", "Object", "keys", "values", "err", "catch", "select", "nothing", "resolveSchemaWithRegistry", "registry", "query", "resolve", "fn", "dxn", "typename", "parse", "asTypeDXN", "type", "none", "location", "schemas", "promise", "run", "head", "resolveSchema", "pipe", "map", "schema", "getOrUndefined", "value", "withReturnType", "when", "filter", "typenameFromFilter", "getOrElse", "succeed", "selection", "filterResult", "isSome", "anchor", "property", "base", "getPropertySignatures", "ast", "flatMap", "properties", "findFirst", "p", "name", "getAnnotation", "annotation", "match", "onNone", "onSome", "fromTypename", "toString", "defined", "direction", "fromNullable", "sourceSchema", "targetSchema", "orElse", "_q", "filters", "flatten", "getQueryTarget", "space", "from", "_tag", "db", "result", "scope", "queues", "queueDxn", "tryParse", "String", "parsed", "q", "asQueueDXN", "ObjectId", "isValid", "queueId", "get", "length", "isNone", "undefined"]
+}

package/dist/lib/node-esm/chunk-UYYUEDNH.mjs

@@ -0,0 +1,166 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  getTypenames
+} from "./chunk-QAL755T4.mjs";
+
+// src/hooks/useActiveSpace.ts
+import { Capabilities } from "@dxos/app-framework";
+import { AppCapabilities, getSpaceIdFromPath } from "@dxos/app-toolkit";
+import { useLayout } from "@dxos/app-toolkit/ui";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import { useSpace } from "@dxos/react-client/echo";
+var getActiveSpace = (capabilities) => {
+  const client = capabilities.get(ClientCapabilities.Client);
+  const registry = capabilities.get(Capabilities.AtomRegistry);
+  const layoutAtom = capabilities.get(AppCapabilities.Layout);
+  const layout = registry.get(layoutAtom);
+  const spaceId = getSpaceIdFromPath(layout.workspace);
+  return spaceId ? client.spaces.get(spaceId) : void 0;
+};
+var useActiveSpace = () => {
+  const layout = useLayout();
+  const spaceId = getSpaceIdFromPath(layout.workspace);
+  return useSpace(spaceId);
+};
+
+// src/hooks/useInputSurfaceLookup.tsx
+import React, { useCallback } from "react";
+import { Surface, usePluginManager } from "@dxos/app-framework/ui";
+var useInputSurfaceLookup = (baseData) => {
+  const pluginManager = usePluginManager();
+  return useCallback(({ schema, prop, fieldProps }) => {
+    const data = {
+      prop,
+      schema,
+      ...baseData
+    };
+    if (Surface.isAvailable(pluginManager.capabilities, {
+      role: "form-input",
+      data
+    })) {
+      return /* @__PURE__ */ React.createElement(Surface.Surface, {
+        role: "form-input",
+        data,
+        ...fieldProps
+      });
+    }
+  }, [
+    pluginManager,
+    baseData
+  ]);
+};
+
+// src/hooks/usePath.ts
+import * as Option from "effect/Option";
+import { useEffect, useState } from "react";
+import { Graph } from "@dxos/plugin-graph";
+var usePath = (graph, id, timeout) => {
+  const [pathState, setPathState] = useState(id ? Graph.getPath(graph, {
+    target: id
+  }) : Option.none());
+  useEffect(() => {
+    if (!id && pathState) {
+      setPathState(Option.none());
+    }
+    if (Option.isSome(pathState) && pathState.value.at(-1) === id || !id) {
+      return;
+    }
+    const frame = requestAnimationFrame(async () => {
+      try {
+        const path = await Graph.waitForPath(graph, {
+          target: id
+        }, {
+          timeout
+        });
+        if (path) {
+          setPathState(Option.some(path));
+        }
+      } catch {
+      }
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [
+    graph,
+    id,
+    timeout,
+    pathState
+  ]);
+  return pathState;
+};
+
+// src/hooks/useRelatedObjects.ts
+import { useMemo } from "react";
+import { Entity, Filter, Ref, Relation } from "@dxos/echo";
+import { useQuery } from "@dxos/react-client/echo";
+import { isNonNullable } from "@dxos/util";
+var useRelatedObjects = (db, record, options = {}) => {
+  const objects = useQuery(db, Filter.everything());
+  return useMemo(() => {
+    if (!record) {
+      return [];
+    }
+    const related = [];
+    if (options.references) {
+      const getReferences = (obj) => {
+        return Object.getOwnPropertyNames(obj).map((name) => obj[name]).filter((value) => Ref.isRef(value));
+      };
+      const references = getReferences(record);
+      const referenceTargets = references.map((ref) => ref.target).filter(isNonNullable);
+      const referenceSources = objects.filter((obj) => {
+        const refs = getReferences(obj);
+        return refs.some((ref) => ref.target === record);
+      });
+      related.push(...referenceTargets, ...referenceSources);
+    }
+    if (options.relations) {
+      const isValidRelation = (obj) => {
+        try {
+          return Relation.isRelation(obj) && Relation.getSource(obj) && Relation.getTarget(obj);
+        } catch {
+          return false;
+        }
+      };
+      const relations = objects.filter(Relation.isRelation).filter((obj) => isValidRelation(obj));
+      const targetObjects = relations.filter((relation) => Relation.getTarget(relation) === record).map((relation) => Relation.getSource(relation));
+      const sourceObjects = relations.filter((relation) => Relation.getSource(relation) === record).map((relation) => Relation.getTarget(relation));
+      related.push(...targetObjects, ...sourceObjects);
+    }
+    return Array.from(new Set(related)).filter((obj) => Entity.getTypename(obj) !== "org.dxos.type.assistant.chat");
+  }, [
+    record,
+    objects,
+    options.references,
+    options.relations
+  ]);
+};
+
+// src/hooks/useTypeOptions.ts
+import { useMemo as useMemo2 } from "react";
+import { useTranslation } from "@dxos/react-ui";
+var useTypeOptions = ({ space, annotation }) => {
+  const { t } = useTranslation();
+  const typenames = getTypenames({
+    annotation,
+    space
+  });
+  return useMemo2(() => typenames.map((typename) => ({
+    value: typename,
+    label: t("typename label", {
+      ns: typename,
+      defaultValue: typename
+    })
+  })).toSorted((a, b) => a.label.localeCompare(b.label)), [
+    t,
+    typenames
+  ]);
+};
+
+export {
+  getActiveSpace,
+  useActiveSpace,
+  useInputSurfaceLookup,
+  usePath,
+  useRelatedObjects,
+  useTypeOptions
+};
+//# sourceMappingURL=chunk-UYYUEDNH.mjs.map

package/dist/lib/node-esm/chunk-UYYUEDNH.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useActiveSpace.ts", "../../../src/hooks/useInputSurfaceLookup.tsx", "../../../src/hooks/usePath.ts", "../../../src/hooks/useRelatedObjects.ts", "../../../src/hooks/useTypeOptions.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capabilities, type CapabilityManager } from '@dxos/app-framework';\nimport { AppCapabilities, getSpaceIdFromPath } from '@dxos/app-toolkit';\nimport { useLayout } from '@dxos/app-toolkit/ui';\nimport { ClientCapabilities } from '@dxos/plugin-client';\nimport { useSpace } from '@dxos/react-client/echo';\n\nexport const getActiveSpace = (capabilities: CapabilityManager.CapabilityManager) => {\n  const client = capabilities.get(ClientCapabilities.Client);\n  const registry = capabilities.get(Capabilities.AtomRegistry);\n  const layoutAtom = capabilities.get(AppCapabilities.Layout);\n  const layout = registry.get(layoutAtom);\n  const spaceId = getSpaceIdFromPath(layout.workspace);\n  return spaceId ? client.spaces.get(spaceId) : undefined;\n};\n\nexport const useActiveSpace = () => {\n  const layout = useLayout();\n  const spaceId = getSpaceIdFromPath(layout.workspace);\n  return useSpace(spaceId);\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport React, { useCallback } from 'react';\n\nimport { Surface, usePluginManager } from '@dxos/app-framework/ui';\nimport { type FormFieldProvider } from '@dxos/react-ui-form';\n\n/**\n * Creates a surface input component based on plugin context.\n * @param baseData Additional data that will be merged with form data and passed to the surface.\n * This allows providing more context to the surface than what's available from the form itself.\n */\n// TODO(burdon): Factor out?\nexport const useInputSurfaceLookup = (baseData?: Record<string, any>): FormFieldProvider => {\n  const pluginManager = usePluginManager();\n  return useCallback<FormFieldProvider>(\n    ({ schema, prop, fieldProps }) => {\n      const data = { prop, schema, ...baseData };\n      if (Surface.isAvailable(pluginManager.capabilities, { role: 'form-input', data })) {\n        return <Surface.Surface role='form-input' data={data} {...fieldProps} />;\n      }\n    },\n    [pluginManager, baseData],\n  );\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport { useEffect, useState } from 'react';\n\nimport { Graph } from '@dxos/plugin-graph';\n\n/**\n * React hook to get a path from the graph.\n *\n * @param graph Graph to find the node in.\n * @param id Id of the node to find a path to.\n * @param timeout Optional timeout in milliseconds to wait for the node to be found.\n * @returns Path if found, undefined otherwise.\n */\n// TODO(wittjosiah): Factor out.\nexport const usePath = (graph: Graph.ReadableGraph, id?: string, timeout?: number): Option.Option<string[]> => {\n  const [pathState, setPathState] = useState<Option.Option<string[]>>(\n    id ? Graph.getPath(graph, { target: id }) : Option.none(),\n  );\n\n  useEffect(() => {\n    if (!id && pathState) {\n      setPathState(Option.none());\n    }\n\n    if ((Option.isSome(pathState) && pathState.value.at(-1) === id) || !id) {\n      return;\n    }\n\n    // Set timeout did not seem to effectively not block the UI thread.\n    const frame = requestAnimationFrame(async () => {\n      try {\n        const path = await Graph.waitForPath(graph, { target: id }, { timeout });\n        if (path) {\n          setPathState(Option.some(path));\n        }\n      } catch {}\n    });\n\n    return () => cancelAnimationFrame(frame);\n  }, [graph, id, timeout, pathState]);\n\n  return pathState;\n};\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { useMemo } from 'react';\n\nimport { type Database, Entity, Filter, Obj, Ref, Relation } from '@dxos/echo';\nimport { useQuery } from '@dxos/react-client/echo';\nimport { isNonNullable } from '@dxos/util';\n\n// TODO(burdon): Factor out (make more generally useful -- e.g., in cards).\n// TODO(wittjosiah): This is a hack. ECHO needs to have a back reference index to easily query for related objects.\nexport const useRelatedObjects = (\n  db?: Database.Database,\n  record?: Obj.Unknown,\n  options: { references?: boolean; relations?: boolean } = {},\n) => {\n  const objects = useQuery(db, Filter.everything());\n  return useMemo(() => {\n    if (!record) {\n      return [];\n    }\n\n    const related: Entity.Unknown[] = [];\n\n    // TODO(burdon): Change Person => Organization to relations.\n    if (options.references) {\n      const getReferences = (obj: Entity.Unknown): Ref.Unknown[] => {\n        return Object.getOwnPropertyNames(obj)\n          .map((name) => obj[name as keyof Obj.Unknown])\n          .filter((value) => Ref.isRef(value)) as Ref.Unknown[];\n      };\n\n      const references = getReferences(record);\n      const referenceTargets = references.map((ref) => ref.target).filter(isNonNullable);\n      const referenceSources = objects.filter((obj) => {\n        const refs = getReferences(obj);\n        return refs.some((ref) => ref.target === record);\n      });\n\n      related.push(...referenceTargets, ...referenceSources);\n    }\n\n    if (options.relations) {\n      // TODO(dmaretskyi): Workaround until https://github.com/dxos/dxos/pull/10100 lands.\n      const isValidRelation = (obj: Relation.Unknown) => {\n        try {\n          return Relation.isRelation(obj) && Relation.getSource(obj) && Relation.getTarget(obj);\n        } catch {\n          return false;\n        }\n      };\n\n      const relations = objects.filter(Relation.isRelation).filter((obj) => isValidRelation(obj));\n      const targetObjects = relations\n        .filter((relation) => Relation.getTarget(relation) === record)\n        .map((relation) => Relation.getSource(relation));\n      const sourceObjects = relations\n        .filter((relation) => Relation.getSource(relation) === record)\n        .map((relation) => Relation.getTarget(relation));\n\n      related.push(...targetObjects, ...sourceObjects);\n    }\n\n    return (\n      Array.from(new Set(related))\n        // TODO(burdon): Hack to filter out chat objects.\n        .filter((obj) => Entity.getTypename(obj) !== 'org.dxos.type.assistant.chat')\n    );\n  }, [record, objects, options.references, options.relations]);\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { useMemo } from 'react';\n\nimport { type Space } from '@dxos/react-client/echo';\nimport { useTranslation } from '@dxos/react-ui';\n\nimport { type TypeInputOptions, getTypenames } from '../types';\n\nexport const useTypeOptions = ({ space, annotation }: { space?: Space; annotation: TypeInputOptions }) => {\n  const { t } = useTranslation();\n  const typenames = getTypenames({ annotation, space });\n  return useMemo(\n    () =>\n      typenames\n        .map((typename) => ({\n          value: typename,\n          label: t('typename label', { ns: typename, defaultValue: typename }),\n        }))\n        .toSorted((a, b) => a.label.localeCompare(b.label)),\n    [t, typenames],\n  );\n};\n"],
+  "mappings": "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",
+  "names": ["Capabilities", "AppCapabilities", "getSpaceIdFromPath", "useLayout", "ClientCapabilities", "useSpace", "getActiveSpace", "capabilities", "client", "get", "ClientCapabilities", "Client", "registry", "Capabilities", "AtomRegistry", "layoutAtom", "AppCapabilities", "Layout", "layout", "spaceId", "getSpaceIdFromPath", "workspace", "spaces", "undefined", "useActiveSpace", "useLayout", "useSpace", "React", "useCallback", "Surface", "usePluginManager", "useInputSurfaceLookup", "baseData", "pluginManager", "usePluginManager", "useCallback", "schema", "prop", "fieldProps", "data", "Surface", "isAvailable", "capabilities", "role", "Option", "useEffect", "useState", "Graph", "usePath", "graph", "id", "timeout", "pathState", "setPathState", "useState", "Graph", "getPath", "target", "none", "useEffect", "isSome", "value", "at", "frame", "requestAnimationFrame", "path", "waitForPath", "some", "cancelAnimationFrame", "useMemo", "Entity", "Filter", "Ref", "Relation", "useQuery", "isNonNullable", "useRelatedObjects", "db", "record", "options", "objects", "useQuery", "Filter", "everything", "useMemo", "related", "references", "getReferences", "obj", "Object", "getOwnPropertyNames", "map", "name", "filter", "value", "Ref", "isRef", "referenceTargets", "ref", "target", "isNonNullable", "referenceSources", "refs", "some", "push", "relations", "isValidRelation", "Relation", "isRelation", "getSource", "getTarget", "targetObjects", "relation", "sourceObjects", "Array", "from", "Set", "Entity", "getTypename", "useMemo", "useTranslation", "useTypeOptions", "space", "annotation", "t", "useTranslation", "typenames", "getTypenames", "useMemo", "map", "typename", "value", "label", "ns", "defaultValue", "toSorted", "a", "b", "localeCompare"]
+}

package/dist/lib/node-esm/chunk-XTWRNSWE.mjs

@@ -0,0 +1,20 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/capabilities/identity-created/index.ts
+import { Capability } from "@dxos/app-framework";
+var IdentityCreated = Capability.lazy("IdentityCreated", () => import("./identity-created-I6NGIIBQ.mjs"));
+
+// src/capabilities/operation-handler/index.ts
+import { Capability as Capability2 } from "@dxos/app-framework";
+var OperationHandler = Capability2.lazy("OperationHandler", () => import("./operation-handler-56C3UMNO.mjs"));
+
+// src/capabilities/undo-mappings/index.ts
+import { Capability as Capability3 } from "@dxos/app-framework";
+var UndoMappings = Capability3.lazy("UndoMappings", () => import("./undo-mappings-DHLKPRDH.mjs"));
+
+export {
+  IdentityCreated,
+  OperationHandler,
+  UndoMappings
+};
+//# sourceMappingURL=chunk-XTWRNSWE.mjs.map

package/dist/lib/node-esm/chunk-XTWRNSWE.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/identity-created/index.ts", "../../../src/capabilities/operation-handler/index.ts", "../../../src/capabilities/undo-mappings/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capability } from '@dxos/app-framework';\n\nexport const IdentityCreated = Capability.lazy('IdentityCreated', () => import('./identity-created'));\n", "// Copyright 2025 DXOS.org\n\nimport { Capability } from '@dxos/app-framework';\nimport { OperationHandlerSet } from '@dxos/operation';\n\nexport const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(\n  'OperationHandler',\n  () => import('./operation-handler'),\n);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capability } from '@dxos/app-framework';\n\nexport const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));\n"],
+  "mappings": ";;;AAIA,SAASA,kBAAkB;AAEpB,IAAMC,kBAAkBC,WAAWC,KAAK,mBAAmB,MAAM,OAAO,iCAAA,CAAA;;;ACJ/E,SAASC,cAAAA,mBAAkB;AAGpB,IAAMC,mBAAmBC,YAAWC,KACzC,oBACA,MAAM,OAAO,kCAAA,CAAA;;;ACHf,SAASC,cAAAA,mBAAkB;AAEpB,IAAMC,eAAeC,YAAWC,KAAK,gBAAgB,MAAM,OAAO,8BAAA,CAAA;",
+  "names": ["Capability", "IdentityCreated", "Capability", "lazy", "Capability", "OperationHandler", "Capability", "lazy", "Capability", "UndoMappings", "Capability", "lazy"]
+}