@dxos/plugin-thread 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/types/ThreadCapabilities.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+import type * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { type Obj } from '@dxos/echo';
+import { type Channel, type Message } from '@dxos/types';
+
+import { meta } from '#meta';
+
+/**
+ * A pluggable message backend for a `Channel`. Providers are contributed by
+ * plugins and resolved by `Channel.backend.kind`.
+ */
+export interface ChannelBackendProvider {
+  /** Stable backend id; matches `Channel.backend.kind`. */
+  kind: string;
+  /** Human-readable label shown in the create-channel form. */
+  label: string;
+  /** Icon name (phosphor) for the create-channel form. */
+  icon?: string;
+  /**
+   * Per-backend create-form inputs (a struct; excludes the `kind` discriminant
+   * and the channel `name`, which the panel adds). Empty struct when the backend
+   * needs no extra input (e.g. the local feed).
+   */
+  createFields: Schema.Schema.AnyNoContext;
+  /** Builds the provider's config object from the collected create-form inputs. */
+  makeConfig: (options: Record<string, unknown>) => Obj.Any;
+  /**
+   * Subscribes to the channel's messages. Invokes `onMessages` with the current
+   * list immediately and on every change. Returns an unsubscribe function.
+   */
+  subscribe: (channel: Channel.Channel, onMessages: (messages: readonly Message.Message[]) => void) => () => void;
+  /** Sends a message through the backend. */
+  send: (channel: Channel.Channel, message: Message.Message) => Effect.Effect<void, Error, Capability.Service>;
+  /** Whether the channel is read-only. Defaults to "channel has foreign-key Obj.Meta". */
+  readOnly?: (channel: Channel.Channel) => boolean;
+}
+
+/** Registry of channel-message backends. Collect with `Capability.getAll`. */
+export const ChannelBackend = Capability.make<ChannelBackendProvider>(`${meta.id}.capability.channel-backend`);

package/src/types/ThreadOperation.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Key, Type, DXN } from '@dxos/echo';
+import { Actor, Channel } from '@dxos/types';
+
+import { meta } from '#meta';
+
+const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
+
+export const CreateChannel = Operation.make({
+  meta: { key: makeKey('createChannel'), name: 'Create Channel', icon: 'ph--hash--regular' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    spaceId: Key.SpaceId,
+    name: Schema.optional(Schema.String),
+    /** Backend provider id; defaults to the local feed backend. */
+    kind: Schema.optional(Schema.String),
+    /** Per-backend create options passed to the provider's makeConfig. */
+    options: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+  }),
+  output: Schema.Struct({
+    object: Type.getSchema(Channel.Channel),
+  }),
+});
+
+export const AppendChannelMessage = Operation.make({
+  meta: {
+    key: makeKey('appendChannelMessage'),
+    name: 'Append Channel Message',
+    icon: 'ph--chat-text--regular',
+  },
+  // Note: Feed.FeedService is provided inside the handler from space.queues, not at the
+  // operation level — the runtime can't fulfill it without a space context.
+  services: [Capability.Service],
+  input: Schema.Struct({
+    channel: Type.getSchema(Channel.Channel),
+    sender: Actor.Actor,
+    text: Schema.String,
+  }),
+  output: Schema.Void,
+});

package/src/types/channel-backend.test.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { Feed } from '@dxos/echo';
+
+import { buildChannelFormSchema, resolveProvider } from './channel-backend';
+import * as ThreadCapabilities from './ThreadCapabilities';
+
+describe('channel-backend helpers', () => {
+  test('resolveProvider finds by kind', ({ expect }) => {
+    const providers = [fakeProvider('a', Schema.Struct({})), fakeProvider('b', Schema.Struct({}))];
+    expect(resolveProvider(providers, 'b')?.kind).to.eq('b');
+    expect(resolveProvider(providers, 'missing')).to.be.undefined;
+  });
+
+  test('buildChannelFormSchema with a single empty-field provider is just a name field', ({ expect }) => {
+    const schema = buildChannelFormSchema([fakeProvider('feed', Schema.Struct({}))]);
+    const value = Schema.decodeUnknownSync(schema)({ name: 'general' });
+    expect(value.name).to.eq('general');
+    expect(value.backend).to.be.undefined;
+  });
+
+  test('buildChannelFormSchema with multiple providers builds a discriminated backend union', ({ expect }) => {
+    const schema = buildChannelFormSchema([
+      fakeProvider('feed', Schema.Struct({})),
+      fakeProvider('atproto', Schema.Struct({ channelId: Schema.String })),
+    ]);
+    const feedValue = Schema.decodeUnknownSync(schema)({ name: 'x', backend: { kind: 'feed' } });
+    expect(feedValue.backend.kind).to.eq('feed');
+    const atValue = Schema.decodeUnknownSync(schema)({ name: 'y', backend: { kind: 'atproto', channelId: 'c' } });
+    expect(atValue.backend.kind).to.eq('atproto');
+    expect(atValue.backend.channelId).to.eq('c');
+  });
+});
+
+const fakeProvider = (kind: string, fields: Schema.Schema.AnyNoContext): ThreadCapabilities.ChannelBackendProvider => ({
+  kind,
+  label: kind,
+  createFields: fields,
+  makeConfig: () => Feed.make(),
+  subscribe: () => () => {},
+  send: () => Effect.void,
+});

package/src/types/channel-backend.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import * as ThreadCapabilities from './ThreadCapabilities';
+
+/** Finds the provider matching a `Channel.backend.kind`. */
+export const resolveProvider = (
+  providers: readonly ThreadCapabilities.ChannelBackendProvider[],
+  kind: string,
+): ThreadCapabilities.ChannelBackendProvider | undefined => providers.find((provider) => provider.kind === kind);
+
+/** Throws if two providers share a `kind` (which would make resolution order-dependent). */
+export const assertUniqueKinds = (providers: readonly ThreadCapabilities.ChannelBackendProvider[]): void => {
+  const seen = new Set<string>();
+  for (const provider of providers) {
+    if (seen.has(provider.kind)) {
+      throw new Error(`Duplicate channel backend kind: ${provider.kind}`);
+    }
+    seen.add(provider.kind);
+  }
+};
+
+/**
+ * Builds the create-channel form schema from the registered providers.
+ *
+ * With a single provider whose create-fields are empty the form is just a
+ * `name` field (today's behaviour). With multiple providers (or extra fields)
+ * it becomes `{ name?, backend: Union(<{ kind: Literal(p.kind) } & p.createFields>) }`,
+ * which react-ui-form renders as a `kind` Select plus the selected branch's fields.
+ */
+export const buildChannelFormSchema = (
+  providers: readonly ThreadCapabilities.ChannelBackendProvider[],
+): Schema.Schema.AnyNoContext => {
+  assertUniqueKinds(providers);
+  const needsSelector = providers.length > 1 || providers.some((provider) => fieldCount(provider.createFields) > 0);
+  if (!needsSelector) {
+    return Schema.Struct({ name: Schema.optional(Schema.String) });
+  }
+
+  const branches = providers.map((provider) =>
+    Schema.extend(Schema.Struct({ kind: Schema.Literal(provider.kind) }), provider.createFields),
+  );
+  const backend = branches.length === 1 ? branches[0] : Schema.Union(...branches);
+  return Schema.Struct({
+    name: Schema.optional(Schema.String),
+    backend,
+  });
+};
+
+const fieldCount = (schema: Schema.Schema.AnyNoContext): number => SchemaAST.getPropertySignatures(schema.ast).length;

package/src/types/index.ts

@@ -2,6 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './capabilities';
-export * as Channel from './Channel';
-export * from './types';
+export * from './channel-backend';
+export * as ThreadCapabilities from './ThreadCapabilities';
+export * as ThreadOperation from './ThreadOperation';

package/src/util.ts

@@ -2,37 +2,54 @@
 // Copyright 2024 DXOS.org
 //
 
-import * as Match from 'effect/Match';
-
 import { generateName } from '@dxos/display-name';
-import { type PublicKey } from '@dxos/react-client';
 import { type Identity } from '@dxos/react-client/halo';
-import { type Selection } from '@dxos/react-ui-attention';
 import { type MessageMetadata } from '@dxos/react-ui-thread';
-import { hexToFallback } from '@dxos/util';
+import { hexToFallback, toFallback } from '@dxos/util';
 
-export type MessagePropertiesProvider = (identityKey: PublicKey | undefined) => MessageMetadata;
+/**
+ * Stable hash for an arbitrary string — used as the avatar-fallback seed for
+ * external senders who have no DXOS identity (e.g. Slack/Discord-synced
+ * messages). djb2-ish, only stability matters.
+ *
+ * Coerced to unsigned 32-bit via `>>> 0` because `toFallback` does a plain
+ * modulo against `idEmoji.length * idHue.length` and JavaScript's `%`
+ * preserves the sign of the dividend — a negative hash would index
+ * `idEmoji[-x]` and `idHue[-x]` to `undefined`, causing the avatar to fall
+ * through to `Avatar.Content`'s default red/ghost.
+ */
+const hashString = (s: string): number => {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = (h * 31 + s.charCodeAt(i)) | 0;
+  }
+  return h >>> 0;
+};
 
-export const getMessageMetadata = (id: string, identity?: Identity): MessageMetadata => {
-  const fallback = hexToFallback(identity?.identityKey.toHex() ?? '0');
+export const getMessageMetadata = (
+  id: string,
+  identity?: Identity,
+  /**
+   * Externally-sourced sender info (Slack/Discord/etc). Used only when no
+   * matching DXOS `identity` is available — provides `name`/`email` for the
+   * author label and a stable seed for the avatar fallback.
+   */
+  fallbackSender?: { name?: string; email?: string },
+): MessageMetadata => {
+  const fallback = identity?.identityKey
+    ? hexToFallback(identity.identityKey.toHex())
+    : toFallback(hashString(fallbackSender?.name ?? fallbackSender?.email ?? '0'));
   return {
     id,
     authorId: identity?.did,
     authorName:
       identity?.profile?.displayName ??
-      (identity?.identityKey ? generateName(identity.identityKey.toHex()) : undefined),
+      (identity?.identityKey ? generateName(identity.identityKey.toHex()) : undefined) ??
+      fallbackSender?.name ??
+      fallbackSender?.email,
     authorAvatarProps: {
       hue: identity?.profile?.data?.hue ?? fallback.hue,
       emoji: identity?.profile?.data?.emoji ?? fallback.emoji,
     },
   };
 };
-
-export const getAnchor = Match.type<Selection | undefined>().pipe(
-  Match.when({ mode: 'single' }, (s) => s.id),
-  Match.when({ mode: 'multi' }, (s) => (s.ids.length > 0 ? s.ids.join(',') : undefined)),
-  Match.when({ mode: 'range' }, (s) => (s.from && s.to ? `${s.from}:${s.to}` : undefined)),
-  Match.when({ mode: 'multi-range' }, (s) => s.ranges[0] && `${s.ranges[0].from}:${s.ranges[0].to}`),
-  Match.when(undefined, () => undefined),
-  Match.exhaustive,
-);

package/src/vite-env.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="vite/client" />
+
+//
+// Copyright 2026 DXOS.org
+//
+
+declare module '*.mdl?raw' {
+  const content: string;
+  export default content;
+}

package/dist/lib/browser/add-message-VPPFFLFL.mjs

@@ -1,97 +0,0 @@
-import {
-  AddMessage
-} from "./chunk-VPM44Z35.mjs";
-import {
-  ThreadCapabilities
-} from "./chunk-MESW3R4Q.mjs";
-import "./chunk-J5LGTIGS.mjs";
-
-// src/operations/add-message.ts
-import * as Effect from "effect/Effect";
-import { Capabilities, Capability } from "@dxos/app-framework";
-import { Obj, Ref, Relation } from "@dxos/echo";
-import { invariant } from "@dxos/invariant";
-import { Operation } from "@dxos/operation";
-import { ObservabilityOperation } from "@dxos/plugin-observability/operations";
-import { SpaceOperation } from "@dxos/plugin-space/operations";
-import { AnchoredTo, Message } from "@dxos/types";
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-thread/src/operations/add-message.ts";
-var handler = AddMessage.pipe(Operation.withHandler(Effect.fnUntraced(function* ({ anchor, subject, sender, text }) {
-  const registry = yield* Capability.get(Capabilities.AtomRegistry);
-  const stateAtom = yield* Capability.get(ThreadCapabilities.State);
-  const thread = Relation.getSource(anchor);
-  const subjectId = Obj.getDXN(subject).toString();
-  const db = Obj.getDatabase(subject);
-  invariant(db, "Database not found", {
-    F: __dxlog_file,
-    L: 26,
-    S: this,
-    A: [
-      "db",
-      "'Database not found'"
-    ]
-  });
-  const message = Obj.make(Message.Message, {
-    created: (/* @__PURE__ */ new Date()).toISOString(),
-    sender,
-    blocks: [
-      {
-        _tag: "text",
-        text
-      }
-    ]
-  });
-  Obj.change(thread, (thread2) => {
-    thread2.messages.push(Ref.make(message));
-  });
-  const state = registry.get(stateAtom);
-  const draft = state.drafts[subjectId]?.find((a) => a.id === anchor.id);
-  if (draft) {
-    Obj.change(thread, (thread2) => {
-      thread2.status = "active";
-    });
-    registry.set(stateAtom, {
-      ...state,
-      drafts: {
-        ...state.drafts,
-        [subjectId]: state.drafts[subjectId]?.filter((a) => a.id !== anchor.id)
-      }
-    });
-    yield* Operation.invoke(SpaceOperation.AddObject, {
-      object: thread,
-      target: db,
-      hidden: true
-    });
-    yield* Operation.invoke(SpaceOperation.AddRelation, {
-      db,
-      schema: AnchoredTo.AnchoredTo,
-      source: thread,
-      target: subject,
-      fields: {
-        anchor: draft.anchor
-      }
-    });
-    yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-      name: "threads.create",
-      properties: {
-        spaceId: db.spaceId,
-        threadId: thread.id
-      }
-    });
-  }
-  yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-    name: "threads.message.add",
-    properties: {
-      spaceId: db.spaceId,
-      threadId: thread.id,
-      threadLength: thread.messages.length,
-      messageId: message.id,
-      messageLength: text.length
-    }
-  });
-})));
-var add_message_default = handler;
-export {
-  add_message_default as default
-};
-//# sourceMappingURL=add-message-VPPFFLFL.mjs.map

package/dist/lib/browser/add-message-VPPFFLFL.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/operations/add-message.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { Obj, Ref, Relation } from '@dxos/echo';\nimport { invariant } from '@dxos/invariant';\nimport { Operation } from '@dxos/operation';\nimport { ObservabilityOperation } from '@dxos/plugin-observability/operations';\nimport { SpaceOperation } from '@dxos/plugin-space/operations';\nimport { AnchoredTo, Message, Thread } from '@dxos/types';\n\nimport { ThreadCapabilities } from '../types';\nimport { AddMessage } from './definitions';\n\nconst handler: Operation.WithHandler<typeof AddMessage> = AddMessage.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ anchor, subject, sender, text }) {\n      const registry = yield* Capability.get(Capabilities.AtomRegistry);\n      const stateAtom = yield* Capability.get(ThreadCapabilities.State);\n      const thread = Relation.getSource(anchor) as Thread.Thread;\n      const subjectId = Obj.getDXN(subject).toString();\n      const db = Obj.getDatabase(subject);\n      invariant(db, 'Database not found');\n\n      const message = Obj.make(Message.Message, {\n        created: new Date().toISOString(),\n        sender,\n        blocks: [{ _tag: 'text', text }],\n      });\n      Obj.change(thread, (thread) => {\n        thread.messages.push(Ref.make(message));\n      });\n\n      const state = registry.get(stateAtom);\n      const draft = state.drafts[subjectId]?.find((a: { id: string }) => a.id === anchor.id);\n      if (draft) {\n        Obj.change(thread, (thread) => {\n          thread.status = 'active';\n        });\n        registry.set(stateAtom, {\n          ...state,\n          drafts: {\n            ...state.drafts,\n            [subjectId]: state.drafts[subjectId]?.filter((a: { id: string }) => a.id !== anchor.id),\n          },\n        });\n        yield* Operation.invoke(SpaceOperation.AddObject, { object: thread, target: db, hidden: true });\n        yield* Operation.invoke(SpaceOperation.AddRelation, {\n          db,\n          schema: AnchoredTo.AnchoredTo,\n          source: thread,\n          target: subject,\n          fields: { anchor: draft.anchor },\n        });\n        yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n          name: 'threads.create',\n          properties: {\n            spaceId: db.spaceId,\n            threadId: thread.id,\n          },\n        });\n      }\n\n      yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n        name: 'threads.message.add',\n        properties: {\n          spaceId: db.spaceId,\n          threadId: thread.id,\n          threadLength: thread.messages.length,\n          messageId: message.id,\n          messageLength: text.length,\n        },\n      });\n    }),\n  ),\n);\n\nexport default handler;\n"],
-  "mappings": ";;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,cAAcC,kBAAkB;AACzC,SAASC,KAAKC,KAAKC,gBAAgB;AACnC,SAASC,iBAAiB;AAC1B,SAASC,iBAAiB;AAC1B,SAASC,8BAA8B;AACvC,SAASC,sBAAsB;AAC/B,SAASC,YAAYC,eAAuB;;AAK5C,IAAMC,UAAoDC,WAAWC,KACnEC,UAAUC,YACDC,kBAAW,WAAW,EAAEC,QAAQC,SAASC,QAAQC,KAAI,GAAE;AAC5D,QAAMC,WAAW,OAAOC,WAAWC,IAAIC,aAAaC,YAAY;AAChE,QAAMC,YAAY,OAAOJ,WAAWC,IAAII,mBAAmBC,KAAK;AAChE,QAAMC,SAASC,SAASC,UAAUd,MAAAA;AAClC,QAAMe,YAAYC,IAAIC,OAAOhB,OAAAA,EAASiB,SAAQ;AAC9C,QAAMC,KAAKH,IAAII,YAAYnB,OAAAA;AAC3BoB,YAAUF,IAAI,sBAAA;;;;;;;;;AAEd,QAAMG,UAAUN,IAAIO,KAAKC,QAAQA,SAAS;IACxCC,UAAS,oBAAIC,KAAAA,GAAOC,YAAW;IAC/BzB;IACA0B,QAAQ;MAAC;QAAEC,MAAM;QAAQ1B;MAAK;;EAChC,CAAA;AACAa,MAAIc,OAAOlB,QAAQ,CAACA,YAAAA;AAClBA,IAAAA,QAAOmB,SAASC,KAAKC,IAAIV,KAAKD,OAAAA,CAAAA;EAChC,CAAA;AAEA,QAAMY,QAAQ9B,SAASE,IAAIG,SAAAA;AAC3B,QAAM0B,QAAQD,MAAME,OAAOrB,SAAAA,GAAYsB,KAAK,CAACC,MAAsBA,EAAEC,OAAOvC,OAAOuC,EAAE;AACrF,MAAIJ,OAAO;AACTnB,QAAIc,OAAOlB,QAAQ,CAACA,YAAAA;AAClBA,MAAAA,QAAO4B,SAAS;IAClB,CAAA;AACApC,aAASqC,IAAIhC,WAAW;MACtB,GAAGyB;MACHE,QAAQ;QACN,GAAGF,MAAME;QACT,CAACrB,SAAAA,GAAYmB,MAAME,OAAOrB,SAAAA,GAAY2B,OAAO,CAACJ,MAAsBA,EAAEC,OAAOvC,OAAOuC,EAAE;MACxF;IACF,CAAA;AACA,WAAO1C,UAAU8C,OAAOC,eAAeC,WAAW;MAAEC,QAAQlC;MAAQmC,QAAQ5B;MAAI6B,QAAQ;IAAK,CAAA;AAC7F,WAAOnD,UAAU8C,OAAOC,eAAeK,aAAa;MAClD9B;MACA+B,QAAQC,WAAWA;MACnBC,QAAQxC;MACRmC,QAAQ9C;MACRoD,QAAQ;QAAErD,QAAQmC,MAAMnC;MAAO;IACjC,CAAA;AACA,WAAOH,UAAUyD,SAASC,uBAAuBC,WAAW;MAC1DC,MAAM;MACNC,YAAY;QACVC,SAASxC,GAAGwC;QACZC,UAAUhD,OAAO2B;MACnB;IACF,CAAA;EACF;AAEA,SAAO1C,UAAUyD,SAASC,uBAAuBC,WAAW;IAC1DC,MAAM;IACNC,YAAY;MACVC,SAASxC,GAAGwC;MACZC,UAAUhD,OAAO2B;MACjBsB,cAAcjD,OAAOmB,SAAS+B;MAC9BC,WAAWzC,QAAQiB;MACnByB,eAAe7D,KAAK2D;IACtB;EACF,CAAA;AACF,CAAA,CAAA,CAAA;AAIJ,IAAA,sBAAepE;",
-  "names": ["Effect", "Capabilities", "Capability", "Obj", "Ref", "Relation", "invariant", "Operation", "ObservabilityOperation", "SpaceOperation", "AnchoredTo", "Message", "handler", "AddMessage", "pipe", "Operation", "withHandler", "fnUntraced", "anchor", "subject", "sender", "text", "registry", "Capability", "get", "Capabilities", "AtomRegistry", "stateAtom", "ThreadCapabilities", "State", "thread", "Relation", "getSource", "subjectId", "Obj", "getDXN", "toString", "db", "getDatabase", "invariant", "message", "make", "Message", "created", "Date", "toISOString", "blocks", "_tag", "change", "messages", "push", "Ref", "state", "draft", "drafts", "find", "a", "id", "status", "set", "filter", "invoke", "SpaceOperation", "AddObject", "object", "target", "hidden", "AddRelation", "schema", "AnchoredTo", "source", "fields", "schedule", "ObservabilityOperation", "SendEvent", "name", "properties", "spaceId", "threadId", "threadLength", "length", "messageId", "messageLength"]
-}

package/dist/lib/browser/blueprints/index.mjs

@@ -1,37 +0,0 @@
-import "../chunk-J5LGTIGS.mjs";
-
-// src/blueprints/thread-blueprint.ts
-import { Blueprint, Template } from "@dxos/blueprints";
-import { trim } from "@dxos/util";
-import { ThreadOperation } from "#operations";
-var BLUEPRINT_KEY = "org.dxos.blueprint.thread";
-var make = () => Blueprint.make({
-  key: BLUEPRINT_KEY,
-  name: "Thread",
-  tools: Blueprint.toolDefinitions({
-    operations: [
-      ThreadOperation.CreateProposals
-    ]
-  }),
-  instructions: Template.make({
-    // TODO(wittjosiah): Move example to function input schema annotation.
-    source: trim`
-        You can update markdown documents via proposals.
-        For each diff, respond with the smallest possible matching span.
-        For example:
-          - "There is a tyop in this sentence."
-          + "There is a typo in this sentence."
-          - "This id goof."
-          + "This is good."
-      `
-  })
-});
-var blueprint = {
-  key: BLUEPRINT_KEY,
-  make
-};
-var thread_blueprint_default = blueprint;
-export {
-  thread_blueprint_default as ThreadBlueprint
-};
-//# sourceMappingURL=index.mjs.map

package/dist/lib/browser/blueprints/index.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/blueprints/thread-blueprint.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type AppCapabilities } from '@dxos/app-toolkit';\nimport { Blueprint, Template } from '@dxos/blueprints';\nimport { trim } from '@dxos/util';\n\nimport { ThreadOperation } from '#operations';\n\nconst BLUEPRINT_KEY = 'org.dxos.blueprint.thread';\n\nconst make = () =>\n  Blueprint.make({\n    key: BLUEPRINT_KEY,\n    name: 'Thread',\n    tools: Blueprint.toolDefinitions({ operations: [ThreadOperation.CreateProposals] }),\n    instructions: Template.make({\n      // TODO(wittjosiah): Move example to function input schema annotation.\n      source: trim`\n        You can update markdown documents via proposals.\n        For each diff, respond with the smallest possible matching span.\n        For example:\n          - \"There is a tyop in this sentence.\"\n          + \"There is a typo in this sentence.\"\n          - \"This id goof.\"\n          + \"This is good.\"\n      `,\n    }),\n  });\n\nconst blueprint: AppCapabilities.BlueprintDefinition = {\n  key: BLUEPRINT_KEY,\n  make,\n};\n\nexport default blueprint;\n"],
-  "mappings": ";;;AAKA,SAASA,WAAWC,gBAAgB;AACpC,SAASC,YAAY;AAErB,SAASC,uBAAuB;AAEhC,IAAMC,gBAAgB;AAEtB,IAAMC,OAAO,MACXC,UAAUD,KAAK;EACbE,KAAKH;EACLI,MAAM;EACNC,OAAOH,UAAUI,gBAAgB;IAAEC,YAAY;MAACC,gBAAgBC;;EAAiB,CAAA;EACjFC,cAAcC,SAASV,KAAK;;IAE1BW,QAAQC;;;;;;;;;EASV,CAAA;AACF,CAAA;AAEF,IAAMC,YAAiD;EACrDX,KAAKH;EACLC;AACF;AAEA,IAAA,2BAAea;",
-  "names": ["Blueprint", "Template", "trim", "ThreadOperation", "BLUEPRINT_KEY", "make", "Blueprint", "key", "name", "tools", "toolDefinitions", "operations", "ThreadOperation", "CreateProposals", "instructions", "Template", "source", "trim", "blueprint"]
-}

package/dist/lib/browser/chunk-MESW3R4Q.mjs

@@ -1,61 +0,0 @@
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/types/capabilities.ts
-import { Capability } from "@dxos/app-framework";
-import { meta } from "#meta";
-(function(ThreadCapabilities2) {
-  ThreadCapabilities2.Settings = Capability.make(`${meta.id}.capability.settings`);
-  ThreadCapabilities2.CallManager = Capability.make(`${meta.id}.capability.call-manager`);
-  ThreadCapabilities2.CallExtension = Capability.make(`${meta.id}.capability.call-extension`);
-  ThreadCapabilities2.State = Capability.make(`${meta.id}.capability.state`);
-  ThreadCapabilities2.ViewState = Capability.make(`${meta.id}.capability.view-state`);
-})(ThreadCapabilities || (ThreadCapabilities = {}));
-var ThreadCapabilities;
-
-// src/types/Channel.ts
-var Channel_exports = {};
-__export(Channel_exports, {
-  Channel: () => Channel,
-  make: () => make
-});
-import * as Schema from "effect/Schema";
-import { Annotation, Obj, Ref, Type } from "@dxos/echo";
-import { FormInputAnnotation } from "@dxos/echo/internal";
-import { Thread } from "@dxos/types";
-var Channel = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  defaultThread: Ref.Ref(Thread.Thread).pipe(FormInputAnnotation.set(false)),
-  // TODO(wittjosiah): Should be an "ordered collection".
-  threads: Ref.Ref(Thread.Thread).pipe(Schema.Array, FormInputAnnotation.set(false))
-}).pipe(Type.object({
-  typename: "org.dxos.type.channel",
-  version: "0.1.0"
-}), Annotation.IconAnnotation.set({
-  icon: "ph--hash--regular",
-  hue: "rose"
-}));
-var make = (props = {}) => Obj.make(Channel, {
-  ...props,
-  defaultThread: Ref.make(Obj.make(Thread.Thread, {
-    messages: [],
-    status: "active"
-  })),
-  threads: []
-});
-
-// src/types/Settings.ts
-var Settings_exports = {};
-__export(Settings_exports, {
-  Settings: () => Settings
-});
-import * as Schema2 from "effect/Schema";
-var Settings = Schema2.mutable(Schema2.Struct({}));
-
-export {
-  ThreadCapabilities,
-  Channel_exports,
-  Settings_exports
-};
-//# sourceMappingURL=chunk-MESW3R4Q.mjs.map

package/dist/lib/browser/chunk-MESW3R4Q.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/capabilities.ts", "../../../src/types/Channel.ts", "../../../src/types/Settings.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Atom } from '@effect-atom/atom-react';\n\nimport { Capability } from '@dxos/app-framework';\n\nimport { meta } from '#meta';\n\nimport { type CallManager, type CallState, type MediaState } from '../calls';\nimport { type Channel, type ThreadState, type ViewStore } from '../types';\nimport * as Settings from './Settings';\n\nexport namespace ThreadCapabilities {\n  export const Settings = Capability.make<Atom.Writable<Settings.Settings>>(`${meta.id}.capability.settings`);\n  export const CallManager = Capability.make<CallManager>(`${meta.id}.capability.call-manager`);\n\n  // TODO(burdon): Better way to define specific extensions for meeting companions.\n  // TODO(burdon): This brings in deps from ../calls; how should we manage/minimize explicit type exposure to other plugins?\n  // TODO(wittjosiah): These callbacks could be intents once we support broadcast.\n  export type CallProperties = {\n    onJoin: (state: { channel?: Channel.Channel; roomId?: string }) => Promise<void>;\n    onLeave: (roomId?: string) => Promise<void>;\n    onCallStateUpdated: (callState: CallState) => Promise<void>;\n    onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;\n  };\n\n  export const CallExtension = Capability.make<CallProperties>(`${meta.id}.capability.call-extension`);\n\n  /** Thread state (drafts, toolbar state, current selection). */\n  export const State = Capability.make<Atom.Writable<ThreadState>>(`${meta.id}.capability.state`);\n\n  /** Per-subject view state (e.g., showResolvedThreads). */\n  export const ViewState = Capability.make<Atom.Writable<ViewStore>>(`${meta.id}.capability.view-state`);\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { Annotation, Obj, Ref, Type } from '@dxos/echo';\nimport { FormInputAnnotation } from '@dxos/echo/internal';\nimport { Thread } from '@dxos/types';\n\n// TODO(burdon): What is the difference between Thread and Channel.\nexport const Channel = Schema.Struct({\n  name: Schema.optional(Schema.String),\n  defaultThread: Ref.Ref(Thread.Thread).pipe(FormInputAnnotation.set(false)),\n  // TODO(wittjosiah): Should be an \"ordered collection\".\n  threads: Ref.Ref(Thread.Thread).pipe(Schema.Array, FormInputAnnotation.set(false)),\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.channel',\n    version: '0.1.0',\n  }),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--hash--regular',\n    hue: 'rose',\n  }),\n);\n\nexport interface Channel extends Schema.Schema.Type<typeof Channel> {}\n\nexport const make = (props: Pick<Obj.MakeProps<typeof Channel>, 'name'> = {}) =>\n  Obj.make(Channel, {\n    ...props,\n    defaultThread: Ref.make(Obj.make(Thread.Thread, { messages: [], status: 'active' })),\n    threads: [],\n  });\n", "//\n// Copyright 2023 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nexport const Settings = Schema.mutable(Schema.Struct({}));\nexport interface Settings extends Schema.Schema.Type<typeof Settings> {}\n"],
-  "mappings": ";;;;;AAMA,SAASA,kBAAkB;AAE3B,SAASC,YAAY;UAMJC,qBAAAA;sBACFC,WAAWC,WAAWC,KAAuC,GAAGC,KAAKC,EAAE,sBAAsB;sBAC7FC,cAAcJ,WAAWC,KAAkB,GAAGC,KAAKC,EAAE,0BAA0B;sBAY/EE,gBAAgBL,WAAWC,KAAqB,GAAGC,KAAKC,EAAE,4BAA4B;sBAGtFG,QAAQN,WAAWC,KAAiC,GAAGC,KAAKC,EAAE,mBAAmB;sBAGjFI,YAAYP,WAAWC,KAA+B,GAAGC,KAAKC,EAAE,wBAAwB;AACvG,GArBiBL,uBAAAA,qBAAAA,CAAAA,EAAAA;;;;ACdjB;;;;;AAMA,YAAYU,YAAY;AAExB,SAASC,YAAYC,KAAKC,KAAKC,YAAY;AAC3C,SAASC,2BAA2B;AACpC,SAASC,cAAc;AAGhB,IAAMC,UAAiBC,cAAO;EACnCC,MAAaC,gBAAgBC,aAAM;EACnCC,eAAeC,IAAIA,IAAIC,OAAOA,MAAM,EAAEC,KAAKC,oBAAoBC,IAAI,KAAA,CAAA;;EAEnEC,SAASL,IAAIA,IAAIC,OAAOA,MAAM,EAAEC,KAAYI,cAAOH,oBAAoBC,IAAI,KAAA,CAAA;AAC7E,CAAA,EAAGF,KACDK,KAAKC,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACAC,WAAWC,eAAeR,IAAI;EAC5BS,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAKK,IAAMC,OAAO,CAACC,QAAqD,CAAC,MACzEC,IAAIF,KAAKrB,SAAS;EAChB,GAAGsB;EACHjB,eAAeC,IAAIe,KAAKE,IAAIF,KAAKd,OAAOA,QAAQ;IAAEiB,UAAU,CAAA;IAAIC,QAAQ;EAAS,CAAA,CAAA;EACjFd,SAAS,CAAA;AACX,CAAA;;;ACpCF;;;;AAMA,YAAYe,aAAY;AAEjB,IAAMC,WAAkBC,gBAAeC,eAAO,CAAC,CAAA,CAAA;",
-  "names": ["Capability", "meta", "ThreadCapabilities", "Settings", "Capability", "make", "meta", "id", "CallManager", "CallExtension", "State", "ViewState", "Schema", "Annotation", "Obj", "Ref", "Type", "FormInputAnnotation", "Thread", "Channel", "Struct", "name", "optional", "String", "defaultThread", "Ref", "Thread", "pipe", "FormInputAnnotation", "set", "threads", "Array", "Type", "object", "typename", "version", "Annotation", "IconAnnotation", "icon", "hue", "make", "props", "Obj", "messages", "status", "Schema", "Settings", "mutable", "Struct"]
-}