@dxos/plugin-transcription 0.8.4-main.abd8ff62ef → 0.8.4-main.bc2380dfbc

package/src/stories/common.ts

@@ -0,0 +1,233 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// Helpers shared between LiveTranscription / FileTranscription stories.
+// Each "live" story differs only in its *audio source* (mic vs file); everything else —
+// the local in-memory message buffer, the transcriber lifecycle, and the plugin-manager
+// decorator stack — is identical and lives here.
+
+import { type Decorator } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AppActivationEvents } from '@dxos/app-toolkit';
+import { scheduleTask } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { Obj } from '@dxos/echo';
+import { SpeakingMonitor } from '@dxos/plugin-calls';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { IndexKind } from '@dxos/react-client/echo';
+import { withLayout } from '@dxos/react-ui/testing';
+import { Message, Organization, Person } from '@dxos/types';
+import { seedTestData } from '@dxos/types/testing';
+
+import { useFeedModelAdapter, useTranscriber } from '#hooks';
+import { TestItem } from '#testing';
+import { type TranscriptionCapabilities } from '#types';
+
+import { type Transcriber, type TranscriberProps } from '../transcriber';
+import { TranscriptionPlugin } from '../TranscriptionPlugin';
+import { renderByline } from '../util';
+
+export const useIsSpeaking = (track?: MediaStreamTrack) => {
+  const [isSpeaking, setIsSpeaking] = useState(false);
+  const speakingMonitor = useMemo(() => {
+    if (!track) {
+      return;
+    }
+
+    return new SpeakingMonitor(track);
+  }, [track]);
+
+  useEffect(() => {
+    if (!speakingMonitor) {
+      return;
+    }
+
+    const ctx = new Context();
+    scheduleTask(ctx, async () => {
+      speakingMonitor.speakingChanged.on(ctx, () => setIsSpeaking(speakingMonitor.isSpeaking));
+      await speakingMonitor.open();
+      ctx.onDispose(() => speakingMonitor.close());
+    });
+
+    return () => {
+      void ctx.dispose();
+    };
+  }, [speakingMonitor]);
+
+  return isSpeaking;
+};
+
+//
+// Message model.
+//
+
+/**
+ * In-memory message buffer + model adapter for storybook use (production wires up a real
+ * space-backed `Feed`). Returns the renderable `model` plus an `appendMessage` callback.
+ */
+export const useStoryMessageModel = () => {
+  const [messages, setMessages] = useState<Message.Message[]>([]);
+  const appendMessage = useCallback((message: Message.Message) => setMessages((prev) => [...prev, message]), []);
+  const model = useFeedModelAdapter(renderByline([]), messages);
+  return { model, appendMessage };
+};
+
+/**
+ * Wraps blocks in a `Message.Message` with the given sender and appends it to the local buffer.
+ * Provided as a convenience for stories that don't need entity-extraction or custom enrichment.
+ */
+export const useStoryAppendSegments = (
+  appendMessage: (message: Message.Message) => void,
+  sender: Message.Message['sender'] = {},
+): TranscriberProps['onSegments'] =>
+  useCallback<TranscriberProps['onSegments']>(
+    async (blocks) => {
+      appendMessage(
+        Obj.make(Message.Message, {
+          created: new Date().toISOString(),
+          sender,
+          blocks,
+        }),
+      );
+    },
+    [appendMessage, sender],
+  );
+
+//
+// Transcriber lifecycle.
+//
+
+export type UseStoryTranscriberOptions = Pick<
+  TranscriptionCapabilities.GetTranscriberProps,
+  'transcriberConfig' | 'recorderConfig' | 'onSegments'
+> & {
+  audioStreamTrack?: MediaStreamTrack;
+  /** Whether the user has the toolbar toggle on. */
+  running: boolean;
+  /** Voice-activity flag — chunks recording only fires while `true`. */
+  isSpeaking: boolean;
+};
+
+/**
+ * Drives the transcriber's open/close + chunk-recording lifecycle off `running`,
+ * the open flag, and an `isSpeaking` voice-activity gate. Returns the transcriber instance
+ * (`undefined` until the capability resolves and an audio track is available).
+ */
+export const useStoryTranscriber = ({
+  audioStreamTrack,
+  running,
+  isSpeaking,
+  transcriberConfig,
+  recorderConfig,
+  onSegments,
+}: UseStoryTranscriberOptions): Transcriber | undefined => {
+  const transcriber = useTranscriber({
+    audioStreamTrack,
+    onSegments,
+    transcriberConfig,
+    recorderConfig,
+  });
+
+  // Open the transcriber when it becomes available; close on teardown.
+  // `tokenRef` is a per-effect identity so a late `close()` completion from a stale
+  // transcriber instance can't clobber `isOpen` after a newer instance has opened.
+  const [isOpen, setIsOpen] = useState(false);
+  const tokenRef = useRef<symbol | null>(null);
+  useEffect(() => {
+    if (!transcriber) {
+      return;
+    }
+    const token = Symbol();
+    tokenRef.current = token;
+    void transcriber.open().then(
+      () => tokenRef.current === token && setIsOpen(true),
+      () => tokenRef.current === token && setIsOpen(false),
+    );
+    return () => {
+      void transcriber.close().then(() => {
+        if (tokenRef.current === token) {
+          setIsOpen(false);
+        }
+      });
+    };
+  }, [transcriber]);
+
+  // Start/stop chunk recording based on running + open + isSpeaking.
+  useEffect(() => {
+    if (!transcriber || !isOpen) {
+      return;
+    }
+    if (running && isSpeaking) {
+      transcriber.startChunksRecording();
+    } else {
+      transcriber.stopChunksRecording();
+    }
+  }, [transcriber, isOpen, running, isSpeaking]);
+
+  return transcriber;
+};
+
+//
+// Plugin manager decorator.
+//
+
+export type StoryDecoratorsOptions = {
+  /**
+   * Enable schema/graph/vector indexes after the client boots; needed for entity-extraction
+   * queries over seeded `Person` / `Organization` objects.
+   * @default false
+   */
+  enableVectorIndex?: boolean;
+};
+
+/**
+ * Standard plugin-manager decorator for transcription stories: core plugins,
+ * `ClientPlugin` with `Person`/`Organization`/`TestItem` schemas + seeded test data, plus
+ * the `PreviewPlugin` and `TranscriptionPlugin`. Toggle `enableVectorIndex` for entity-extraction.
+ */
+export const createStoryDecorators = ({ enableVectorIndex = false }: StoryDecoratorsOptions = {}): Decorator[] => [
+  withLayout({ layout: 'column' }),
+  withPluginManager({
+    plugins: [
+      ...corePlugins(),
+      StorybookPlugin({}),
+      ClientPlugin({
+        types: [TestItem, Person.Person, Organization.Organization],
+        onClientInitialized: ({ client }) =>
+          Effect.gen(function* () {
+            const { personalSpace } = yield* initializeIdentity(client);
+            if (enableVectorIndex) {
+              yield* enableQueryIndexes(client.services.services);
+            }
+            yield* Effect.promise(() => seedTestData(personalSpace));
+          }),
+      }),
+      PreviewPlugin(),
+      TranscriptionPlugin(),
+    ],
+    fireEvents: [AppActivationEvents.SetupAppGraph],
+  }),
+];
+
+// TODO(mykola): Make API easier to use.
+// TODO(mykola): Delete after enabling vector indexing by default.
+const enableQueryIndexes = (services: { QueryService?: any }) =>
+  Effect.gen(function* () {
+    yield* Effect.promise(() =>
+      services.QueryService!.setConfig({
+        enabled: true,
+        indexes: [
+          { kind: IndexKind.Kind.SCHEMA_MATCH },
+          { kind: IndexKind.Kind.GRAPH },
+          { kind: IndexKind.Kind.VECTOR },
+        ],
+      }),
+    );
+    yield* Effect.promise(() => services.QueryService!.reindex());
+  });

package/src/testing/testing.ts

@@ -2,19 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 import { useEffect, useMemo, useState } from 'react';
 
 import { extractionAnthropicFunction, processTranscriptMessage } from '@dxos/assistant/extraction';
 import { scheduleTaskInterval } from '@dxos/async';
-import { Filter, type Queue } from '@dxos/client/echo';
+import { createFeedServiceLayer, type Space } from '@dxos/client/echo';
 import { Context } from '@dxos/context';
-import { type Key, Obj, Ref, Type } from '@dxos/echo';
-import { createQueueDXN } from '@dxos/echo/internal';
+import { Feed, Filter, Obj, Ref, Type } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
 import { IdentityDid } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { random } from '@dxos/random';
-import { type Space, useQueue } from '@dxos/react-client/echo';
 import { TestSchema } from '@dxos/schema/testing';
 import { type ContentBlock, Message, Organization, Person } from '@dxos/types';
 import { seedTestData } from '@dxos/types/testing';
@@ -139,71 +139,64 @@ class EntityExtractionMessageBuilder extends AbstractMessageBuilder {
 
 type UseTestTranscriptionQueue = (
   space: Space | undefined,
-  queueId?: Key.ObjectId,
   running?: boolean,
   interval?: number,
-) => Queue<Message.Message> | undefined;
+) => Feed.Feed | undefined;
 
 /**
- * Test transcriptionqueue.
+ * Test transcription feed.
  */
 export const useTestTranscriptionQueue: UseTestTranscriptionQueue = (
   space: Space | undefined,
-  queueId?: Key.ObjectId,
   running = true,
   interval = 1_000,
 ) => {
-  // TODO(dmaretskyi): Use space.queues.create() instead.
-  const queueDxn = useMemo(() => (space ? createQueueDXN(space.id, queueId) : undefined), [space, queueId]);
-  const queue = useQueue<Message.Message>(queueDxn);
+  const feed = useMemo(() => (space ? space.db.add(Feed.make({ name: 'transcription' })) : undefined), [space]);
   const builder = useMemo(() => new MessageBuilder(space), [space]);
 
   useEffect(() => {
-    if (!queue || !running) {
+    if (!space || !feed || !running) {
       return;
     }
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
 
     const i = setInterval(() => {
       void builder.createMessage(Math.ceil(Math.random() * 3)).then(async (message) => {
-        await queue.append([Obj.make(Message.Message, message)]);
+        await Feed.append(feed, [message]).pipe(Effect.provide(feedServiceLayer), runAndForwardErrors);
       });
     }, interval);
     return () => clearInterval(i);
-  }, [queue, running, interval]);
+  }, [space, feed, running, interval]);
 
-  return queue;
+  return feed;
 };
 
 /**
- * Test transcription queue.
+ * Test transcription feed with entity extraction.
  */
 // TODO(burdon): Reconcile with useTestTranscriptionQueue.
 export const useTestTranscriptionQueueWithEntityExtraction: UseTestTranscriptionQueue = (
   space: Space | undefined,
-  queueId?: Key.ObjectId,
   running = true,
   interval = 1_000,
 ) => {
-  // TODO(dmaretskyi): Use space.queues.create() instead.
-  const queueDxn = useMemo(() => (space ? createQueueDXN(space.id, queueId) : undefined), [space, queueId]);
-  const queue = useQueue<Message.Message>(queueDxn);
+  const feed = useMemo(() => (space ? space.db.add(Feed.make({ name: 'transcription' })) : undefined), [space]);
   const [builder] = useState(() => new EntityExtractionMessageBuilder());
 
   useEffect(() => {
-    if (!queue || !running) {
+    if (!space || !feed || !running) {
       return;
     }
 
-    if (space) {
-      void builder.connect(space);
-    }
+    void builder.connect(space);
 
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
     const ctx = new Context();
     scheduleTaskInterval(
       ctx,
       async () => {
         const message = await builder.createMessage();
-        void queue.append([Obj.make(Message.Message, message)]);
+        await Feed.append(feed, [message]).pipe(Effect.provide(feedServiceLayer), runAndForwardErrors);
       },
       interval,
     );
@@ -211,7 +204,7 @@ export const useTestTranscriptionQueueWithEntityExtraction: UseTestTranscription
     return () => {
       void ctx.dispose();
     };
-  }, [space, queue, running, interval]);
+  }, [space, feed, running, interval]);
 
-  return queue;
+  return feed;
 };

package/src/transcriber/transcriber.test.ts

@@ -31,10 +31,10 @@ describe('alignWhisperSegments', () => {
       0,
     );
     expect(result.transcripts).toEqual([]);
-    expect(result.lastUsedTimestamp).toBeUndefined();
+    expect(result.lastTimestamp).toBeUndefined();
   });
 
-  test('absolute-timestamps and deduplicates segments against lastUsedTimestamp', ({ expect }) => {
+  test('absolute-timestamps and deduplicates segments against lastTimestamp', ({ expect }) => {
     const segments: WhisperSegment[] = [
       segment({
         text: 'hello world',
@@ -52,15 +52,15 @@ describe('alignWhisperSegments', () => {
     expect(first.transcripts[0]._tag).toBe('transcript');
     expect(first.transcripts[0].text).toBe('hello world');
     expect(new Date(first.transcripts[0].started).getTime()).toBe(T0);
-    expect(first.lastUsedTimestamp).toBe(T0 + 1_000);
+    expect(first.lastTimestamp).toBe(T0 + 1_000);
 
-    // Same segments, same chunk start: every word's absolute start is < lastUsedTimestamp -> filtered out.
-    const second = alignWhisperSegments(segments, [chunk(0)], first.lastUsedTimestamp!);
+    // Same segments, same chunk start: every word's absolute start is < lastTimestamp -> filtered out.
+    const second = alignWhisperSegments(segments, [chunk(0)], first.lastTimestamp!);
     expect(second.transcripts).toEqual([]);
-    expect(second.lastUsedTimestamp).toBeUndefined();
+    expect(second.lastTimestamp).toBeUndefined();
   });
 
-  test('keeps later words when earlier words fall before lastUsedTimestamp', ({ expect }) => {
+  test('keeps later words when earlier words fall before lastTimestamp', ({ expect }) => {
     const segments: WhisperSegment[] = [
       segment({
         text: 'old new',
@@ -78,10 +78,10 @@ describe('alignWhisperSegments', () => {
     expect(result.transcripts).toHaveLength(1);
     expect(result.transcripts[0].text).toBe('new');
     expect(new Date(result.transcripts[0].started).getTime()).toBe(T0 + 1_500);
-    expect(result.lastUsedTimestamp).toBe(T0 + 2_000);
+    expect(result.lastTimestamp).toBe(T0 + 2_000);
   });
 
-  test('drops segments that end before lastUsedTimestamp', ({ expect }) => {
+  test('drops segments that end before lastTimestamp', ({ expect }) => {
     const segments: WhisperSegment[] = [
       segment({
         text: 'stale',

package/src/transcriber/transcriber.ts

@@ -10,11 +10,14 @@ import { log } from '@dxos/log';
 import { trace } from '@dxos/tracing';
 import { type ContentBlock } from '@dxos/types';
 
-import { TRANSCRIPTION_URL } from '#types';
-
 import { mergeFloat64Arrays } from '../util';
 import { type AudioChunk, type AudioRecorder } from './audio-recorder';
 
+/**
+ * Endpoint to the calls service.
+ */
+const DEFAULT_TRANSCRIPTION_URL = 'https://calls-service.dxos.workers.dev';
+
 export type WhisperWord = {
   word: string;
 
@@ -96,7 +99,7 @@ export type TranscriberProps = {
  */
 export class Transcriber extends Resource {
   private _audioChunks: AudioChunk[] = [];
-  private _lastUsedTimestamp = 0;
+  private _lastTimestamp = 0;
 
   private readonly _openTrigger = new Trigger({ autoReset: true });
 
@@ -217,7 +220,8 @@ export class Transcriber extends Resource {
     if (this._transcribeFn) {
       segments = await this._transcribeFn(audio);
     } else {
-      const endpoint = this._config.endpoint ?? TRANSCRIPTION_URL;
+      // TODO(burdon): Create separate endpoint?
+      const endpoint = this._config.endpoint ?? DEFAULT_TRANSCRIPTION_URL;
       const response = await fetch(`${endpoint}/transcribe`, {
         method: 'POST',
         body: JSON.stringify({ audio }),
@@ -238,15 +242,15 @@ export class Transcriber extends Resource {
     }
 
     log.info('transcription response', { segments: segments.length });
-
     return segments as WhisperSegment[];
   }
 
   private _alignSegments(segments: WhisperSegment[], originalChunks: AudioChunk[]): ContentBlock.Transcript[] {
-    const result = alignWhisperSegments(segments, originalChunks, this._lastUsedTimestamp);
-    if (result.lastUsedTimestamp !== undefined) {
-      this._lastUsedTimestamp = result.lastUsedTimestamp;
+    const result = alignWhisperSegments(segments, originalChunks, this._lastTimestamp);
+    if (result.lastTimestamp !== undefined) {
+      this._lastTimestamp = result.lastTimestamp;
     }
+
     return result.transcripts;
   }
 }
@@ -257,14 +261,14 @@ export class Transcriber extends Resource {
  *
  * @param segments - Raw segments returned by the Whisper service for `originalChunks`.
  * @param originalChunks - Chunks fed into the transcription request (used for the zero timestamp).
- * @param lastUsedTimestamp - Most recent absolute timestamp already emitted; segments whose end
+ * @param lastTimestamp - Most recent absolute timestamp already emitted; segments whose end
  *   falls strictly before this point are deduped out, as are individual words whose start does.
  */
 export const alignWhisperSegments = (
   segments: WhisperSegment[],
   originalChunks: AudioChunk[],
-  lastUsedTimestamp: number,
-): { transcripts: ContentBlock.Transcript[]; lastUsedTimestamp?: number } => {
+  lastTimestamp: number,
+): { transcripts: ContentBlock.Transcript[]; lastTimestamp?: number } => {
   if (originalChunks.length === 0) {
     return { transcripts: [] };
   }
@@ -272,9 +276,9 @@ export const alignWhisperSegments = (
   const zeroTimestamp = originalChunks[0].timestamp;
 
   const filteredSegments = segments
-    .filter((segment) => zeroTimestamp + segment.end * 1_000 >= lastUsedTimestamp)
+    .filter((segment) => zeroTimestamp + segment.end * 1_000 >= lastTimestamp)
     .map((segment) => {
-      const words = segment.words.filter((word) => zeroTimestamp + word.start * 1_000 >= lastUsedTimestamp);
+      const words = segment.words.filter((word) => zeroTimestamp + word.start * 1_000 >= lastTimestamp);
       return {
         ...segment,
         words,
@@ -289,11 +293,11 @@ export const alignWhisperSegments = (
   }
 
   return {
+    lastTimestamp: zeroTimestamp + filteredSegments.at(-1)!.end * 1_000,
     transcripts: filteredSegments.map((segment) => ({
       _tag: 'transcript',
       started: new Date(zeroTimestamp + segment.start * 1_000).toISOString(),
       text: segment.text.trim(),
     })),
-    lastUsedTimestamp: zeroTimestamp + filteredSegments.at(-1)!.end * 1_000,
   };
 };

package/src/transcriber/transcription-manager.ts

@@ -3,11 +3,14 @@
 //
 
 import { Atom, type Registry } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import { synchronized } from '@dxos/async';
+import { createFeedServiceLayer, type Space } from '@dxos/client/echo';
 import { Resource } from '@dxos/context';
-import { Obj } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-db';
+import { Feed, Obj } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
 import { type EdgeHttpClient } from '@dxos/react-edge-client';
 import { type ContentBlock, Message } from '@dxos/types';
 
@@ -37,7 +40,7 @@ export type TranscriptionManagerOptions = {
   registry: Registry.Registry;
 
   /**
-   * Enrich the message before it is written to the transcription queue.
+   * Enrich the message before it is written to the transcription feed.
    */
   messageEnricher?: TranscriptMessageEnricher;
 };
@@ -53,7 +56,8 @@ export class TranscriptionManager extends Resource {
   private _identityDid?: string = undefined;
   private _mediaRecorder?: MediaStreamRecorder = undefined;
   private _transcriber?: Transcriber = undefined;
-  private _queue?: Queue<Message.Message> = undefined;
+  private _feed?: Feed.Feed = undefined;
+  private _feedServiceLayer?: Layer.Layer<Feed.FeedService> = undefined;
   private _enabledAtom = Atom.make(false);
 
   constructor(options: TranscriptionManagerOptions) {
@@ -71,8 +75,9 @@ export class TranscriptionManager extends Resource {
     return this._registry.get(this._enabledAtom);
   }
 
-  setQueue(queue: Queue<Message.Message>): this {
-    this._queue = queue;
+  setFeed(space: Space, feed: Feed.Feed): this {
+    this._feed = feed;
+    this._feedServiceLayer = createFeedServiceLayer(space.queues);
     return this;
   }
 
@@ -132,7 +137,7 @@ export class TranscriptionManager extends Resource {
       return;
     }
 
-    // Reinitialize transcriber if queue or media stream track has changed.
+    // Reinitialize transcriber if feed or media stream track has changed.
     let needReinit = false;
     if (this._audioStreamTrack !== this._mediaRecorder?.mediaStreamTrack) {
       this._mediaRecorder = new MediaStreamRecorder({
@@ -161,7 +166,7 @@ export class TranscriptionManager extends Resource {
   }
 
   private async _onSegments(segments: ContentBlock.Transcript[]): Promise<void> {
-    if (!this.isOpen || !this._queue) {
+    if (!this.isOpen || !this._feed || !this._feedServiceLayer) {
       return;
     }
 
@@ -175,6 +180,6 @@ export class TranscriptionManager extends Resource {
       block = await this._messageEnricher(block);
     }
 
-    await this._queue.append([block]);
+    await Feed.append(this._feed, [block]).pipe(Effect.provide(this._feedServiceLayer), runAndForwardErrors);
   }
 }

package/src/translations.ts

@@ -17,6 +17,9 @@ export const translations = [
         'bookmark.button': 'Bookmark',
         'scroll-to-end.label': 'Scroll to latest',
 
+        'start-recording.label': 'Start recording',
+        'stop-recording.label': 'Stop recording',
+
         'settings.entity-extraction.label': 'Entity extraction',
       },
     },

package/src/{operations/definitions.ts → types/TranscriptOperation.ts}

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Schema from 'effect/Schema';
 
 import { AiService } from '@dxos/ai';

package/src/types/TranscriptionCapabilities.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import { Capability } from '@dxos/app-framework';
+
+import { meta } from '#meta';
+
+import {
+  type MediaStreamRecorderProps,
+  type Transcriber as TranscriberType,
+  type TranscriberProps,
+  type TranscriptMessageEnricher,
+  type TranscriptionManager as TranscriptionManagerType,
+} from '../transcriber';
+
+export type GetTranscriberProps = {
+  audioStreamTrack: MediaStreamTrack;
+  recorderConfig?: Partial<MediaStreamRecorderProps['config']>;
+  transcriberConfig?: Partial<TranscriberProps['config']>;
+  onSegments: TranscriberProps['onSegments'];
+  transcribe?: TranscriberProps['transcribe'];
+};
+
+export type GetTranscriber = (props: GetTranscriberProps) => TranscriberType;
+
+export type GetTranscriptionManagerProps = {
+  messageEnricher?: TranscriptMessageEnricher;
+};
+
+export type GetTranscriptionManager = (props: GetTranscriptionManagerProps) => TranscriptionManagerType;
+
+export const Transcriber = Capability.make<GetTranscriber>(`${meta.id}.capability.transcriber`);
+
+export const TranscriptionManager = Capability.make<GetTranscriptionManager>(
+  `${meta.id}.capability.transcription-manager`,
+);

package/src/types/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './capabilities';
-export * from './defs';
+export * as TranscriptionCapabilities from './TranscriptionCapabilities';
+export * as TranscriptOperation from './TranscriptOperation';

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/blueprints/transcription-blueprint.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Blueprint, Template } from '@dxos/compute';\nimport { trim } from '@dxos/util';\n\nimport { TranscriptOperation } from '#operations';\n\nconst BLUEPRINT_KEY = 'org.dxos.blueprint.transcription';\n\nconst make = () =>\n  Blueprint.make({\n    key: BLUEPRINT_KEY,\n    name: 'Transcription',\n    tools: Blueprint.toolDefinitions({ operations: [TranscriptOperation.Open, TranscriptOperation.Summarize] }),\n    instructions: Template.make({\n      source: trim`\n        You can open and summarize a meeting transcript.\n      `,\n    }),\n  });\n\nconst blueprint: Blueprint.Definition = {\n  key: BLUEPRINT_KEY,\n  make,\n};\n\nexport default blueprint;\n"],
-  "mappings": ";;;AAIA,SAASA,WAAWC,gBAAgB;AACpC,SAASC,YAAY;AAErB,SAASC,2BAA2B;AAEpC,IAAMC,gBAAgB;AAEtB,IAAMC,OAAO,MACXL,UAAUK,KAAK;EACbC,KAAKF;EACLG,MAAM;EACNC,OAAOR,UAAUS,gBAAgB;IAAEC,YAAY;MAACP,oBAAoBQ;MAAMR,oBAAoBS;;EAAW,CAAA;EACzGC,cAAcZ,SAASI,KAAK;IAC1BS,QAAQZ;;;EAGV,CAAA;AACF,CAAA;AAEF,IAAMa,YAAkC;EACtCT,KAAKF;EACLC;AACF;AAEA,IAAA,kCAAeU;",
-  "names": ["Blueprint", "Template", "trim", "TranscriptOperation", "BLUEPRINT_KEY", "make", "key", "name", "tools", "toolDefinitions", "operations", "Open", "Summarize", "instructions", "source", "blueprint"]
-}

package/dist/lib/browser/chunk-3L623EVL.mjs

@@ -1,17 +0,0 @@
-// src/types/capabilities.ts
-import { Capability } from "@dxos/app-framework";
-import { meta } from "#meta";
-(function(TranscriptionCapabilities2) {
-  TranscriptionCapabilities2.Transcriber = Capability.make(`${meta.id}.capability.transcriber`);
-  TranscriptionCapabilities2.TranscriptionManager = Capability.make(`${meta.id}.capability.transcription-manager`);
-})(TranscriptionCapabilities || (TranscriptionCapabilities = {}));
-var TranscriptionCapabilities;
-
-// src/types/defs.ts
-var TRANSCRIPTION_URL = "https://calls-service.dxos.workers.dev";
-
-export {
-  TranscriptionCapabilities,
-  TRANSCRIPTION_URL
-};
-//# sourceMappingURL=chunk-3L623EVL.mjs.map