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

package/dist/lib/node-esm/open-OI24QNTO.mjs

@@ -1,28 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  renderByline
-} from "./chunk-O533NBMK.mjs";
-import {
-  Open
-} from "./chunk-7UIZWCD4.mjs";
-import "./chunk-HSLMI22Q.mjs";
-
-// src/operations/open.ts
-import * as Effect from "effect/Effect";
-import { Operation } from "@dxos/compute";
-import { Database, Feed, Filter } from "@dxos/echo";
-import { Message } from "@dxos/types";
-var handler = Open.pipe(Operation.withHandler(Effect.fn(function* ({ transcript }) {
-  const transcriptObj = yield* Database.load(transcript);
-  const feed = yield* Database.load(transcriptObj.feed);
-  const messages = yield* Feed.runQuery(feed, Filter.type(Message.Message));
-  const content = messages.flatMap((message, index) => renderByline([])(message, index)).join("\n\n");
-  return {
-    content
-  };
-})));
-var open_default = handler;
-export {
-  open_default as default
-};
-//# sourceMappingURL=open-OI24QNTO.mjs.map

package/dist/lib/node-esm/open-OI24QNTO.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/operations/open.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Operation } from '@dxos/compute';\nimport { Database, Feed, Filter } from '@dxos/echo';\nimport { Message } from '@dxos/types';\n\nimport { renderByline } from '../util';\nimport { Open } from './definitions';\n\nconst handler: Operation.WithHandler<typeof Open> = Open.pipe(\n  Operation.withHandler(\n    Effect.fn(function* ({ transcript }) {\n      const transcriptObj = yield* Database.load(transcript);\n      const feed = yield* Database.load(transcriptObj.feed);\n      const messages = yield* Feed.runQuery(feed, Filter.type(Message.Message));\n      const content = messages\n        .flatMap((message: Message.Message, index: number) => renderByline([])(message, index))\n        .join('\\n\\n');\n      return { content };\n    }),\n  ),\n);\n\nexport default handler;\n"],
-  "mappings": ";;;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAC1B,SAASC,UAAUC,MAAMC,cAAc;AACvC,SAASC,eAAe;AAKxB,IAAMC,UAA8CC,KAAKC,KACvDC,UAAUC,YACDC,UAAG,WAAW,EAAEC,WAAU,GAAE;AACjC,QAAMC,gBAAgB,OAAOC,SAASC,KAAKH,UAAAA;AAC3C,QAAMI,OAAO,OAAOF,SAASC,KAAKF,cAAcG,IAAI;AACpD,QAAMC,WAAW,OAAOC,KAAKC,SAASH,MAAMI,OAAOC,KAAKC,QAAQA,OAAO,CAAA;AACvE,QAAMC,UAAUN,SACbO,QAAQ,CAACC,SAA0BC,UAAkBC,aAAa,CAAA,CAAE,EAAEF,SAASC,KAAAA,CAAAA,EAC/EE,KAAK,MAAA;AACR,SAAO;IAAEL;EAAQ;AACnB,CAAA,CAAA,CAAA;AAIJ,IAAA,eAAejB;",
-  "names": ["Effect", "Operation", "Database", "Feed", "Filter", "Message", "handler", "Open", "pipe", "Operation", "withHandler", "fn", "transcript", "transcriptObj", "Database", "load", "feed", "messages", "Feed", "runQuery", "Filter", "type", "Message", "content", "flatMap", "message", "index", "renderByline", "join"]
-}

package/dist/lib/node-esm/operations/index.mjs

@@ -1,14 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  definitions_exports
-} from "../chunk-7UIZWCD4.mjs";
-import "../chunk-HSLMI22Q.mjs";
-
-// src/operations/index.ts
-import { OperationHandlerSet } from "@dxos/compute";
-var TranscriptionOperationHandlerSet = OperationHandlerSet.lazy(() => import("../create-A5QHNWRF.mjs"), () => import("../open-OI24QNTO.mjs"), () => import("../summarize-3UNN24I2.mjs"));
-export {
-  definitions_exports as TranscriptOperation,
-  TranscriptionOperationHandlerSet
-};
-//# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/operations/index.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/operations/index.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { OperationHandlerSet } from '@dxos/compute';\n\nexport * as TranscriptOperation from './definitions';\n\nexport const TranscriptionOperationHandlerSet = OperationHandlerSet.lazy(\n  () => import('./create'),\n  () => import('./open'),\n  () => import('./summarize'),\n);\n"],
-  "mappings": ";;;;;;;AAIA,SAASA,2BAA2B;AAI7B,IAAMC,mCAAmCD,oBAAoBE,KAClE,MAAM,OAAO,wBAAA,GACb,MAAM,OAAO,sBAAA,GACb,MAAM,OAAO,2BAAA,CAAA;",
-  "names": ["OperationHandlerSet", "TranscriptionOperationHandlerSet", "lazy"]
-}

package/dist/lib/node-esm/summarize-3UNN24I2.mjs

@@ -1,79 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  Summarize
-} from "./chunk-7UIZWCD4.mjs";
-import "./chunk-HSLMI22Q.mjs";
-
-// src/operations/summarize.ts
-import * as Array from "effect/Array";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import { AiService, ConsolePrinter, ToolExecutionService, ToolResolverService } from "@dxos/ai";
-import { AiRequest, GenerationObserver } from "@dxos/assistant";
-import { Trace, Operation, OperationRegistry } from "@dxos/compute";
-import { Database } from "@dxos/echo";
-import { trim } from "@dxos/util";
-var handler = Summarize.pipe(Operation.withHandler(Effect.fnUntraced(function* ({ transcript, notes }) {
-  const result = yield* new AiRequest({
-    observer: GenerationObserver.fromPrinter(new ConsolePrinter({
-      tag: "summarize"
-    }))
-  }).run({
-    prompt: `Transcript: ${transcript}
-
-Notes: ${notes}`,
-    history: [],
-    system: systemPrompt
-  });
-  const summary = Function.pipe(result, Array.findLast((msg) => msg.sender.role === "assistant" && msg.blocks.some((block) => block._tag === "text")), Option.flatMap((msg) => Function.pipe(msg.blocks, Array.findLast((block) => block._tag === "text"), Option.map((block) => block.text))), Option.getOrThrowWith(() => new Error("No summary found")));
-  return {
-    summary
-  };
-}, Effect.provide(Layer.mergeAll(AiService.model("@anthropic/claude-sonnet-4-0"), ToolResolverService.layerEmpty, ToolExecutionService.layerEmpty, Trace.writerLayerNoop, Database.notAvailable, Layer.succeed(Operation.Service, {
-  invoke: () => Effect.die("Not available."),
-  schedule: () => Effect.die("Not available."),
-  invokePromise: async () => ({
-    error: new Error("Not available.")
-  })
-}), Layer.succeed(OperationRegistry.Service, {
-  resolve: () => Effect.succeed(void 0)
-}))))));
-var summarize_default = handler;
-var systemPrompt = trim`
-  You are a helpful assistant that summarizes transcripts of meetings.
-
-  # Goal
-  Create a markdown summary of the meeting transcript with text notes provided.
-  Notes are very important so make sure to include them in the summary if they contain meaningful information.
-
-  # Formatting
-  - Format the summary as a markdown document without extra comments like "Here is the summary of the transcript:".
-  - Use markdown formatting for headings and bullet points.
-  - Format the summary as a list of key points and takeaways.
-  - All names of people should be in bold.
-
-  # Note Taking
-  - Correlate items in the summary with the person of origin to build a coherent narrative.
-  - Include short quotes verbatim where appropriate. Especially when concerned with design decisions and problem descriptions.
-
-  # Tasks
-  At the end of the summary include tasks.
-  Extract only the tasks that are:
-  - Directly actionable.
-  - Clearly assigned to a person or team (or can easily be inferred).
-  - Strongly implied by the conversation and/or user note (no speculative tasks).
-  - Specific enough that someone reading them would know exactly what to do next.
-
-  Format all tasks as markdown checkboxes using the syntax:
-  - [ ] Task description.
-
-  Additional information can be included (indented).
-
-  If no actionable tasks are found, omit this tasks section.
-`;
-export {
-  summarize_default as default
-};
-//# sourceMappingURL=summarize-3UNN24I2.mjs.map

package/dist/lib/node-esm/summarize-3UNN24I2.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/operations/summarize.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Array from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as Function from 'effect/Function';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\n\nimport { AiService, ConsolePrinter, ToolExecutionService, ToolResolverService } from '@dxos/ai';\nimport { AiRequest, GenerationObserver } from '@dxos/assistant';\nimport { Trace, Operation, OperationRegistry } from '@dxos/compute';\nimport { Database } from '@dxos/echo';\nimport { trim } from '@dxos/util';\n\nimport { Summarize } from './definitions';\n\n/**\n * Summarize a transcript of a meeting.\n */\nconst handler: Operation.WithHandler<typeof Summarize> = Summarize.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(\n      function* ({ transcript, notes }) {\n        const result = yield* new AiRequest({\n          observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'summarize' })),\n        }).run({\n          prompt: `Transcript: ${transcript}\\n\\nNotes: ${notes}`,\n          history: [],\n          system: systemPrompt,\n        });\n\n        const summary = Function.pipe(\n          result,\n          Array.findLast((msg) => msg.sender.role === 'assistant' && msg.blocks.some((block) => block._tag === 'text')),\n          Option.flatMap((msg) =>\n            Function.pipe(\n              msg.blocks,\n              Array.findLast((block) => block._tag === 'text'),\n              Option.map((block) => block.text),\n            ),\n          ),\n          Option.getOrThrowWith(() => new Error('No summary found')),\n        );\n\n        return { summary };\n      },\n      Effect.provide(\n        Layer.mergeAll(\n          AiService.model('@anthropic/claude-sonnet-4-0'),\n          ToolResolverService.layerEmpty,\n          ToolExecutionService.layerEmpty,\n          Trace.writerLayerNoop,\n          Database.notAvailable,\n          Layer.succeed(Operation.Service, {\n            invoke: () => Effect.die('Not available.'),\n            schedule: () => Effect.die('Not available.'),\n            invokePromise: async () => ({ error: new Error('Not available.') }),\n          } as any),\n          Layer.succeed(OperationRegistry.Service, { resolve: () => Effect.succeed(undefined) } as any),\n        ),\n      ),\n    ),\n  ),\n);\n\nexport default handler;\n\nconst systemPrompt = trim`\n  You are a helpful assistant that summarizes transcripts of meetings.\n\n  # Goal\n  Create a markdown summary of the meeting transcript with text notes provided.\n  Notes are very important so make sure to include them in the summary if they contain meaningful information.\n\n  # Formatting\n  - Format the summary as a markdown document without extra comments like \"Here is the summary of the transcript:\".\n  - Use markdown formatting for headings and bullet points.\n  - Format the summary as a list of key points and takeaways.\n  - All names of people should be in bold.\n\n  # Note Taking\n  - Correlate items in the summary with the person of origin to build a coherent narrative.\n  - Include short quotes verbatim where appropriate. Especially when concerned with design decisions and problem descriptions.\n\n  # Tasks\n  At the end of the summary include tasks.\n  Extract only the tasks that are:\n  - Directly actionable.\n  - Clearly assigned to a person or team (or can easily be inferred).\n  - Strongly implied by the conversation and/or user note (no speculative tasks).\n  - Specific enough that someone reading them would know exactly what to do next.\n\n  Format all tasks as markdown checkboxes using the syntax:\n  - [ ] Task description.\n\n  Additional information can be included (indented).\n\n  If no actionable tasks are found, omit this tasks section.\n`;\n"],
-  "mappings": ";;;;;;;AAIA,YAAYA,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,cAAc;AAC1B,YAAYC,WAAW;AACvB,YAAYC,YAAY;AAExB,SAASC,WAAWC,gBAAgBC,sBAAsBC,2BAA2B;AACrF,SAASC,WAAWC,0BAA0B;AAC9C,SAASC,OAAOC,WAAWC,yBAAyB;AACpD,SAASC,gBAAgB;AACzB,SAASC,YAAY;AAOrB,IAAMC,UAAmDC,UAAUC,KACjEC,UAAUC,YACDC,kBACL,WAAW,EAAEC,YAAYC,MAAK,GAAE;AAC9B,QAAMC,SAAS,OAAO,IAAIC,UAAU;IAClCC,UAAUC,mBAAmBC,YAAY,IAAIC,eAAe;MAAEC,KAAK;IAAY,CAAA,CAAA;EACjF,CAAA,EAAGC,IAAI;IACLC,QAAQ,eAAeV,UAAAA;;SAAwBC,KAAAA;IAC/CU,SAAS,CAAA;IACTC,QAAQC;EACV,CAAA;AAEA,QAAMC,UAAmBlB,cACvBM,QACMa,eAAS,CAACC,QAAQA,IAAIC,OAAOC,SAAS,eAAeF,IAAIG,OAAOC,KAAK,CAACC,UAAUA,MAAMC,SAAS,MAAA,CAAA,GAC9FC,eAAQ,CAACP,QACLpB,cACPoB,IAAIG,QACEJ,eAAS,CAACM,UAAUA,MAAMC,SAAS,MAAA,GAClCE,WAAI,CAACH,UAAUA,MAAMI,IAAI,CAAA,CAAA,GAG7BC,sBAAe,MAAM,IAAIC,MAAM,kBAAA,CAAA,CAAA;AAGxC,SAAO;IAAEb;EAAQ;AACnB,GACOc,eACCC,eACJC,UAAUC,MAAM,8BAAA,GAChBC,oBAAoBC,YACpBC,qBAAqBD,YACrBE,MAAMC,iBACNC,SAASC,cACHC,cAAQ1C,UAAU2C,SAAS;EAC/BC,QAAQ,MAAaC,WAAI,gBAAA;EACzBC,UAAU,MAAaD,WAAI,gBAAA;EAC3BE,eAAe,aAAa;IAAEC,OAAO,IAAIlB,MAAM,gBAAA;EAAkB;AACnE,CAAA,GACMY,cAAQO,kBAAkBN,SAAS;EAAEO,SAAS,MAAaR,eAAQS,MAAAA;AAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAO9F,IAAA,oBAAetD;AAEf,IAAMmB,eAAeoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
-  "names": ["Array", "Effect", "Function", "Layer", "Option", "AiService", "ConsolePrinter", "ToolExecutionService", "ToolResolverService", "AiRequest", "GenerationObserver", "Trace", "Operation", "OperationRegistry", "Database", "trim", "handler", "Summarize", "pipe", "Operation", "withHandler", "fnUntraced", "transcript", "notes", "result", "AiRequest", "observer", "GenerationObserver", "fromPrinter", "ConsolePrinter", "tag", "run", "prompt", "history", "system", "systemPrompt", "summary", "findLast", "msg", "sender", "role", "blocks", "some", "block", "_tag", "flatMap", "map", "text", "getOrThrowWith", "Error", "provide", "mergeAll", "AiService", "model", "ToolResolverService", "layerEmpty", "ToolExecutionService", "Trace", "writerLayerNoop", "Database", "notAvailable", "succeed", "Service", "invoke", "die", "schedule", "invokePromise", "error", "OperationRegistry", "resolve", "undefined", "trim"]
-}

package/dist/lib/node-esm/types/index.mjs

@@ -1,11 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  TRANSCRIPTION_URL,
-  TranscriptionCapabilities
-} from "../chunk-KO3IOD2O.mjs";
-import "../chunk-HSLMI22Q.mjs";
-export {
-  TRANSCRIPTION_URL,
-  TranscriptionCapabilities
-};
-//# sourceMappingURL=index.mjs.map

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

@@ -1,6 +0,0 @@
-import React from 'react';
-import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { type Transcript } from '@dxos/types';
-export type TranscriptionContainerProps = AppSurface.ObjectArticleProps<Transcript.Transcript>;
-export declare const TranscriptionContainer: ({ role, subject: transcript, attendableId }: TranscriptionContainerProps) => React.JSX.Element;
-//# sourceMappingURL=TranscriptionContainer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"TranscriptionContainer.d.ts","sourceRoot":"","sources":["../../../../../src/containers/TranscriptionContainer/TranscriptionContainer.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIvD,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAO5D,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAAC,kBAAkB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;AAE/F,eAAO,MAAM,sBAAsB,gDAAiD,2BAA2B,sBAe9G,CAAC"}

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

@@ -1,2 +0,0 @@
-export { TranscriptionContainer as default } from './TranscriptionContainer';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/containers/TranscriptionContainer/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,sBAAsB,IAAI,OAAO,EAAE,MAAM,0BAA0B,CAAC"}

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

@@ -1,8 +0,0 @@
-import type { Obj } from '@dxos/echo';
-import { type Queue } from '@dxos/react-client/echo';
-import { type ChunkRenderer, SerializationModel } from '../model';
-/**
- * Model adapter for a queue.
- */
-export declare const useQueueModelAdapter: <T extends Obj.Unknown>(renderer: ChunkRenderer<T>, queue: Queue<T> | undefined, initialChunks?: T[]) => SerializationModel<T>;
-//# sourceMappingURL=useQueueModelAdapter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useQueueModelAdapter.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useQueueModelAdapter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,KAAK,aAAa,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,GAAG,CAAC,OAAO,YAC9C,aAAa,CAAC,CAAC,CAAC,SACnB,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,kBACZ,CAAC,EAAE,KACjB,kBAAkB,CAAC,CAAC,CA+CtB,CAAC"}

package/dist/types/src/operations/definitions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../../src/operations/definitions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAO,MAAM,YAAY,CAAC;AAOjD,eAAO,MAAM,MAAM;;;;;;;;;;;;;SASjB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAO9B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEnF,eAAO,MAAM,IAAI;;;;;;;;;;;;uCAef,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;uBAoBpB,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC,CAAC;AAEH,MAAM,MAAM,8BAA8B,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEnG,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAShC,CAAC"}

package/dist/types/src/stories/MicrophoneTranscription.stories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MicrophoneTranscription.stories.d.ts","sourceRoot":"","sources":["../../../../src/stories/MicrophoneTranscription.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,KAAoD,MAAM,OAAO,CAAC;AA6BzE,OAAO,EAAE,KAAK,wBAAwB,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAetF,KAAK,iBAAiB,GAAG;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC9C,cAAc,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IACnD,gBAAgB,CAAC,EAAE,qBAAqB,CAAC;IACzC,gBAAgB,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;CAC1C,CAAC;AAwHF,QAAA,MAAM,IAAI;;yGAhHP,iBAAiB;;CAuJiB,CAAC;eAEvB,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnC,eAAO,MAAM,OAAO,EAAE,KAYrB,CAAC;AAkBF,eAAO,MAAM,eAAe,EAAE,KAY7B,CAAC"}

package/dist/types/src/stories/useIsSpeaking.d.ts

@@ -1,3 +0,0 @@
-import '@dxos-theme';
-export declare const useIsSpeaking: (track?: MediaStreamTrack) => boolean;
-//# sourceMappingURL=useIsSpeaking.d.ts.map

package/dist/types/src/stories/useIsSpeaking.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useIsSpeaking.d.ts","sourceRoot":"","sources":["../../../../src/stories/useIsSpeaking.tsx"],"names":[],"mappings":"AAIA,OAAO,aAAa,CAAC;AAQrB,eAAO,MAAM,aAAa,WAAY,gBAAgB,YA2BrD,CAAC"}

package/dist/types/src/types/capabilities.d.ts

@@ -1,19 +0,0 @@
-import { Capability } from '@dxos/app-framework';
-import { type MediaStreamRecorderProps, type Transcriber, type TranscriberProps, type TranscriptMessageEnricher, type TranscriptionManager } from '../transcriber';
-export declare namespace TranscriptionCapabilities {
-    type GetTranscriberProps = {
-        audioStreamTrack: MediaStreamTrack;
-        recorderConfig?: Partial<MediaStreamRecorderProps['config']>;
-        transcriberConfig?: Partial<TranscriberProps['config']>;
-        onSegments: TranscriberProps['onSegments'];
-        transcribe?: TranscriberProps['transcribe'];
-    };
-    type GetTranscriber = (props: GetTranscriberProps) => Transcriber;
-    type GetTranscriptionManagerProps = {
-        messageEnricher?: TranscriptMessageEnricher;
-    };
-    type GetTranscriptionManager = (props: GetTranscriptionManagerProps) => TranscriptionManager;
-    const Transcriber: Capability.InterfaceDef<GetTranscriber>;
-    const TranscriptionManager: Capability.InterfaceDef<GetTranscriptionManager>;
-}
-//# sourceMappingURL=capabilities.d.ts.map

package/dist/types/src/types/capabilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/types/capabilities.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAIjD,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EAC1B,MAAM,gBAAgB,CAAC;AAExB,yBAAiB,yBAAyB,CAAC,CAAC;IAC1C,KAAY,mBAAmB,GAAG;QAChC,gBAAgB,EAAE,gBAAgB,CAAC;QACnC,cAAc,CAAC,EAAE,OAAO,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC7D,iBAAiB,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC;QACxD,UAAU,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAC3C,UAAU,CAAC,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;KAC7C,CAAC;IAEF,KAAY,cAAc,GAAG,CAAC,KAAK,EAAE,mBAAmB,KAAK,WAAW,CAAC;IAEzE,KAAY,4BAA4B,GAAG;QACzC,eAAe,CAAC,EAAE,yBAAyB,CAAC;KAC7C,CAAC;IAEF,KAAY,uBAAuB,GAAG,CAAC,KAAK,EAAE,4BAA4B,KAAK,oBAAoB,CAAC;IAE7F,MAAM,WAAW,yCAAuE,CAAC;IAEzF,MAAM,oBAAoB,kDAEhC,CAAC;CACH"}

package/dist/types/src/types/defs.d.ts

@@ -1,5 +0,0 @@
-/**
- * Endpoint to the calls service.
- */
-export declare const TRANSCRIPTION_URL = "https://calls-service.dxos.workers.dev";
-//# sourceMappingURL=defs.d.ts.map

package/dist/types/src/types/defs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defs.d.ts","sourceRoot":"","sources":["../../../../src/types/defs.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,eAAO,MAAM,iBAAiB,2CAA2C,CAAC"}

package/src/containers/TranscriptionContainer/TranscriptionContainer.tsx

@@ -1,35 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import React from 'react';
-
-import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { Feed, Obj } from '@dxos/echo';
-import { useMembers, useQueue } from '@dxos/react-client/echo';
-import { Panel } from '@dxos/react-ui';
-import { type Message, type Transcript } from '@dxos/types';
-
-import { Transcription } from '#components';
-import { useQueueModelAdapter } from '#hooks';
-
-import { renderByline } from '../../util';
-
-export type TranscriptionContainerProps = AppSurface.ObjectArticleProps<Transcript.Transcript>;
-
-export const TranscriptionContainer = ({ role, subject: transcript, attendableId }: TranscriptionContainerProps) => {
-  const db = Obj.getDatabase(transcript);
-  const members = useMembers(db?.spaceId).map((member) => member.identity);
-  const feed = transcript.feed.target;
-  const queueDxn = feed ? Feed.getQueueDxn(feed) : undefined;
-  const queue = useQueue<Message.Message>(queueDxn, { pollInterval: 1_000 });
-  const model = useQueueModelAdapter(renderByline(members), queue);
-
-  return (
-    <Panel.Root role={role}>
-      <Panel.Content asChild>
-        <Transcription attendableId={attendableId} model={model} transcript={transcript} />
-      </Panel.Content>
-    </Panel.Root>
-  );
-};

package/src/containers/TranscriptionContainer/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export { TranscriptionContainer as default } from './TranscriptionContainer';

package/src/hooks/useQueueModelAdapter.ts

@@ -1,66 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useEffect, useMemo, useState } from 'react';
-
-import type { Obj } from '@dxos/echo';
-import { type Queue } from '@dxos/react-client/echo';
-
-import { type ChunkRenderer, SerializationModel } from '../model';
-
-/**
- * Model adapter for a queue.
- */
-export const useQueueModelAdapter = <T extends Obj.Unknown>(
-  renderer: ChunkRenderer<T>,
-  queue: Queue<T> | undefined,
-  initialChunks: T[] = [],
-): SerializationModel<T> => {
-  const model = useMemo(() => new SerializationModel<T>(renderer, initialChunks), [queue]);
-  const [loaded, setLoaded] = useState(false);
-
-  // Set initial blocks.
-  useEffect(() => {
-    if (!queue) {
-      return;
-    }
-
-    const update = () => {
-      for (const block of queue?.objects ?? []) {
-        model.appendChunk(block);
-      }
-
-      setLoaded(true);
-    };
-
-    // TODO(burdon): This is a hack to ensure the queue is loaded.
-    let i: NodeJS.Timeout | undefined;
-    if (queue.isLoading) {
-      i = setInterval(() => {
-        if (!queue?.isLoading) {
-          clearInterval(i);
-          update();
-        }
-      }, 1_000);
-    } else {
-      update();
-    }
-
-    return () => clearTimeout(i);
-  }, [model, queue]);
-
-  // TODO(burdon): Can we listen for queue events?
-  useEffect(() => {
-    if (!loaded || !queue || model.chunks.length === queue.objects.length) {
-      return;
-    }
-
-    const chunk = queue.objects.at(-1);
-    if (chunk) {
-      model.appendChunk(chunk);
-    }
-  }, [model, loaded, queue?.objects.length]);
-
-  return model;
-};

package/src/stories/MicrophoneTranscription.stories.tsx

@@ -1,264 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Meta, type StoryObj } from '@storybook/react-vite';
-import * as Effect from 'effect/Effect';
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-
-import { withPluginManager } from '@dxos/app-framework/testing';
-import { AppActivationEvents } from '@dxos/app-toolkit';
-import {
-  type ExtractionFunction,
-  extractionAnthropicFunction,
-  extractionNerFunction,
-  getNer,
-  processTranscriptMessage,
-} from '@dxos/assistant/extraction';
-import { Filter, type Obj } from '@dxos/echo';
-import { MemoryQueue } from '@dxos/echo-db';
-import { createQueueDXN } from '@dxos/echo/internal';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { ClientPlugin } from '@dxos/plugin-client';
-import { initializeIdentity } from '@dxos/plugin-client/testing';
-import { PreviewPlugin } from '@dxos/plugin-preview';
-import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
-import { IndexKind, useSpaces } from '@dxos/react-client/echo';
-import { withLayout } from '@dxos/react-ui/testing';
-import { TestSchema } from '@dxos/schema/testing';
-import { Message, Organization, Person } from '@dxos/types';
-import { seedTestData } from '@dxos/types/testing';
-
-import { useAudioTrack, useQueueModelAdapter, useTranscriber } from '#hooks';
-import { TestItem } from '#testing';
-
-import { type MediaStreamRecorderProps, type TranscriberProps } from '../transcriber';
-import { TranscriptionPlugin } from '../TranscriptionPlugin';
-import { renderByline } from '../util';
-import { TranscriptionStory } from './TranscriptionStory';
-import { useIsSpeaking } from './useIsSpeaking';
-
-const TRANSCRIBER_CONFIG = {
-  transcribeAfterChunksAmount: 50,
-  prefixBufferChunksAmount: 10,
-};
-
-const RECORDER_CONFIG = {
-  interval: 200,
-};
-
-type DefaultStoryProps = {
-  detectSpeaking?: boolean;
-  transcriberConfig: TranscriberProps['config'];
-  recorderConfig: MediaStreamRecorderProps['config'];
-  audioConstraints?: MediaTrackConstraints;
-  entityExtraction: 'none' | 'ner' | 'llm';
-};
-
-const DefaultStory = ({
-  detectSpeaking,
-  entityExtraction = 'none',
-  transcriberConfig,
-  recorderConfig,
-  audioConstraints,
-}: DefaultStoryProps) => {
-  const [running, setRunning] = useState(false);
-
-  // Audio.
-  const track = useAudioTrack(running, audioConstraints);
-
-  // Speaking.
-  const isSpeaking = detectSpeaking ? useIsSpeaking(track) : true;
-
-  // Queue.
-  // TODO(dmaretskyi): Use space.queues.create() instead.
-  const queueDxn = useMemo(() => createQueueDXN(), []);
-  const queue = useMemo(() => new MemoryQueue<Message.Message>(queueDxn), [queueDxn]);
-  const model = useQueueModelAdapter(renderByline([]), queue);
-  const [space] = useSpaces();
-
-  useEffect(() => {
-    if (!space) {
-      log.warn('no space');
-    }
-  }, [space]);
-
-  // Entity extraction.
-  const { extractionFunction, objects } = useMemo(() => {
-    if (!space) {
-      log.warn('no space');
-      return {};
-    }
-
-    let extractionFunction: ExtractionFunction | undefined;
-    let objects: Promise<Obj.Unknown[]> | undefined;
-
-    if (entityExtraction === 'ner') {
-      // Init model loading. Takes time.
-      void getNer();
-      extractionFunction = extractionNerFunction;
-    } else if (entityExtraction === 'llm') {
-      extractionFunction = extractionAnthropicFunction;
-      objects = space.db
-        .query(
-          Filter.or(
-            Filter.type(Person.Person),
-            Filter.type(Organization.Organization),
-            Filter.type(TestSchema.DocumentType),
-          ),
-        )
-        .run();
-    }
-
-    return { extractionFunction, objects };
-  }, [entityExtraction, space]);
-
-  // Transcriber.
-  const handleSegments = useCallback<TranscriberProps['onSegments']>(
-    async (blocks) => {
-      const message = Message.make({
-        sender: { name: 'You' },
-        created: new Date().toISOString(),
-        blocks,
-      });
-      if (!space) {
-        void queue.append([message]);
-        return;
-      }
-
-      if (entityExtraction !== 'none') {
-        invariant(extractionFunction, 'extractionFunction is required');
-        const result = await processTranscriptMessage({
-          function: extractionFunction,
-          input: {
-            message,
-            objects: await objects,
-          },
-          options: {
-            fallbackToRaw: true,
-            timeout: 30_000,
-          },
-        });
-        void queue.append([result.message]);
-      } else {
-        void queue.append([message]);
-      }
-    },
-    [queue, space],
-  );
-
-  const transcriber = useTranscriber({
-    audioStreamTrack: track,
-    onSegments: handleSegments,
-    transcriberConfig,
-    recorderConfig,
-  });
-  const [isOpen, setIsOpen] = useState(false);
-  useEffect(() => {
-    void transcriber?.open().then(() => setIsOpen(true));
-    return () => {
-      void transcriber?.close().then(() => setIsOpen(false));
-    };
-  }, [transcriber]);
-
-  // Manage transcription state.
-  useEffect(() => {
-    if (running && transcriber?.isOpen && isSpeaking) {
-      transcriber?.startChunksRecording();
-    } else if (!running || !isSpeaking) {
-      transcriber?.stopChunksRecording();
-    }
-  }, [transcriber, running, isOpen, isSpeaking]);
-
-  return <TranscriptionStory model={model} running={running} onRunningChange={setRunning} />;
-};
-
-const meta = {
-  title: 'plugins/plugin-transcription/components/MicrophoneTranscription',
-  render: DefaultStory,
-  decorators: [
-    withLayout({ layout: 'column' }),
-    withPluginManager({
-      plugins: [
-        ...corePlugins(),
-        StorybookPlugin({}),
-        ClientPlugin({
-          types: [TestItem, Person.Person, Organization.Organization, TestSchema.DocumentType],
-          onClientInitialized: ({ client }) =>
-            Effect.gen(function* () {
-              const { personalSpace } = yield* initializeIdentity(client);
-              // TODO(mykola): Make API easier to use.
-              // TODO(mykola): Delete after enabling vector indexing by default.
-              // Enable vector indexing.
-              yield* Effect.promise(() =>
-                client.services.services.QueryService!.setConfig({
-                  enabled: true,
-                  indexes: [
-                    //
-                    { kind: IndexKind.Kind.SCHEMA_MATCH },
-                    { kind: IndexKind.Kind.GRAPH },
-                    { kind: IndexKind.Kind.VECTOR },
-                  ],
-                }),
-              );
-              yield* Effect.promise(() => client.services.services.QueryService!.reindex());
-              yield* Effect.promise(() => seedTestData(personalSpace));
-            }),
-        }),
-
-        PreviewPlugin(),
-        TranscriptionPlugin(),
-      ],
-      fireEvents: [AppActivationEvents.SetupAppGraph],
-    }),
-  ],
-} satisfies Meta<typeof DefaultStory>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const Default: Story = {
-  args: {
-    detectSpeaking: false,
-    entityExtraction: 'none',
-    transcriberConfig: TRANSCRIBER_CONFIG,
-    recorderConfig: RECORDER_CONFIG,
-    audioConstraints: {
-      echoCancellation: false,
-      noiseSuppression: false,
-      autoGainControl: false,
-    },
-  },
-};
-
-// NOTE: We are running out of free quota on hugging face entity extraction.
-// TODO(mykola): Fix hugging face quota issues.
-// export const EntityExtraction: Story = {
-//   args: {
-//     detectSpeaking: true,
-//     entityExtraction: 'ner',
-//     transcriberConfig: TRANSCRIBER_CONFIG,
-//     recorderConfig: RECORDER_CONFIG,
-//     audioConstraints: {
-//       echoCancellation: true,
-//       noiseSuppression: true,
-//       autoGainControl: true,
-//     },
-//   },
-// };
-
-export const SpeechDetection: Story = {
-  args: {
-    detectSpeaking: true,
-    entityExtraction: 'none',
-    transcriberConfig: TRANSCRIBER_CONFIG,
-    recorderConfig: RECORDER_CONFIG,
-    audioConstraints: {
-      echoCancellation: true,
-      noiseSuppression: true,
-      autoGainControl: true,
-    },
-  },
-};