@batonfx/foldkit 0.4.0 → 0.4.1

package/src/connection.ts

@@ -1,133 +0,0 @@
-import { Cause, Context, Effect, Layer, Option, Ref, Result, Schema, Stream } from "effect"
-import { Socket } from "effect/unstable/socket"
-import { m } from "foldkit/message"
-import type { CallableTaggedStruct } from "foldkit/schema"
-import { Client, Wire } from "@batonfx/transport"
-
-/** @experimental */
-export const ConnectionOpened: CallableTaggedStruct<"ConnectionOpened", {}> = m("ConnectionOpened")
-
-/** @experimental */
-export const ConnectionLost: CallableTaggedStruct<"ConnectionLost", {}> = m("ConnectionLost")
-
-/** @experimental */
-export const ConnectionFailed: CallableTaggedStruct<"ConnectionFailed", { reason: typeof Schema.String }> = m(
-  "ConnectionFailed",
-  { reason: Schema.String },
-)
-
-/** @experimental */
-export type Incoming =
-  | Wire.LooseServerFrameType
-  | typeof ConnectionOpened.Type
-  | typeof ConnectionLost.Type
-  | typeof ConnectionFailed.Type
-
-/** @experimental */
-export const Incoming: Schema.Schema<Incoming> = Schema.Union([
-  Wire.LooseServerFrame,
-  ConnectionOpened,
-  ConnectionLost,
-  ConnectionFailed,
-])
-
-/** @experimental */
-export class SendFailed extends Schema.TaggedErrorClass<SendFailed>()("@batonfx/foldkit/SendFailed", {
-  reason: Schema.String,
-}) {}
-
-/** @experimental */
-export interface Interface {
-  readonly frames: (options: {
-    readonly sessionId: string
-    readonly afterSeq?: number
-  }) => Stream.Stream<Incoming, never>
-  readonly send: (frame: Wire.ClientFrameType) => Effect.Effect<void, SendFailed>
-}
-
-/** @experimental */
-export class AgentConnection extends Context.Service<AgentConnection, Interface>()(
-  "@batonfx/foldkit/AgentConnection",
-) {}
-
-interface ActiveConnection {
-  readonly sessionId: string
-  readonly connection: Client.Connection
-}
-
-const reasonFrom = (error: unknown): string => {
-  if (error instanceof SendFailed) return error.reason
-  if (error instanceof Error) return error.message
-  return String(error)
-}
-
-const statusIncoming = (status: Client.ConnectionStatus): Option.Option<Incoming> => {
-  switch (status._tag) {
-    case "Open":
-      return Option.some(ConnectionOpened())
-    case "Reconnecting":
-    case "Closed":
-      return Option.some(ConnectionLost())
-    case "Connecting":
-      return Option.none()
-  }
-}
-
-/** @experimental */
-export const testLayer = (implementation: Interface): Layer.Layer<AgentConnection> =>
-  Layer.succeed(AgentConnection, AgentConnection.of(implementation))
-
-/** @experimental */
-export const layerWebSocket = (options: {
-  readonly url: string
-}): Layer.Layer<AgentConnection, never, Socket.WebSocketConstructor> =>
-  Layer.effect(
-    AgentConnection,
-    Effect.gen(function* () {
-      const client = yield* Client.AgentClient
-      const active = yield* Ref.make<Option.Option<ActiveConnection>>(Option.none())
-
-      const clearActive = (connection: Client.Connection) =>
-        Ref.update(active, (current) =>
-          Option.isSome(current) && current.value.connection === connection ? Option.none() : current,
-        )
-
-      return AgentConnection.of({
-        frames: ({ sessionId }) =>
-          Stream.unwrap(
-            Effect.gen(function* () {
-              const connection = yield* client.connect({ url: options.url, sessionId })
-              yield* Ref.set(active, Option.some({ sessionId, connection }))
-              yield* Effect.addFinalizer(() => clearActive(connection))
-              const statuses = connection.status.pipe(
-                Stream.filterMap((status) =>
-                  Option.match(statusIncoming(status), {
-                    onNone: () => Result.fail(undefined),
-                    onSome: Result.succeed,
-                  }),
-                ),
-              )
-              const frames = connection.frames.pipe(
-                Stream.map((frame): Incoming => frame),
-                Stream.catchCause((cause) =>
-                  Stream.succeed(ConnectionFailed({ reason: reasonFrom(Cause.squash(cause)) })),
-                ),
-              )
-              return statuses.pipe(Stream.merge(frames))
-            }),
-          ),
-        send: (frame) =>
-          Ref.get(active).pipe(
-            Effect.flatMap(
-              Option.match({
-                onNone: () => Effect.fail(new SendFailed({ reason: "No active agent connection" })),
-                onSome: ({ connection }) =>
-                  connection
-                    .send(frame)
-                    .pipe(Effect.mapError((error) => new SendFailed({ reason: reasonFrom(error) }))),
-              }),
-            ),
-          ),
-      })
-    }),
-  ).pipe(Layer.provide(Client.layerWebSocket))

package/src/index.ts

@@ -1,2 +0,0 @@
-export * as Chat from "./chat"
-export * as Connection from "./connection"

package/test/chat.scene.test.ts

@@ -1,152 +0,0 @@
-// @vitest-environment happy-dom
-
-import { Chat, Connection } from "../src/index"
-import { Wire } from "@batonfx/transport"
-import { Response } from "effect/unstable/ai"
-import type { Document, Html } from "foldkit/html"
-import { html } from "foldkit/html"
-import { Command, click, expect, placeholder, role, scene, type } from "foldkit/scene"
-import type { SceneSimulation } from "foldkit/scene"
-import { describe, test } from "vitest"
-
-const sessionId = "foldkit-scene-session"
-
-const eventFrame = (seq: number, event: Wire.EventType): Wire.LooseServerFrameType => ({ _tag: "Event", seq, event })
-
-const toolCall = Response.makePart("tool-call", {
-  id: "lookup-1",
-  name: "lookup",
-  params: { query: "baton foldkit" },
-  providerExecuted: false,
-})
-
-const toolResult = Response.makePart("tool-result", {
-  id: "lookup-1",
-  name: "lookup",
-  result: { answer: "transport binding" },
-  encodedResult: { answer: "transport binding" },
-  isFailure: false,
-  providerExecuted: false,
-  preliminary: false,
-})
-
-const frames: ReadonlyArray<Wire.LooseServerFrameType> = [
-  eventFrame(0, { _tag: "TurnStarted", turn: 0 }),
-  eventFrame(1, { _tag: "ModelPart", turn: 0, part: toolCall }),
-  eventFrame(2, { _tag: "ToolExecutionStarted", turn: 0, call: toolCall }),
-  eventFrame(3, { _tag: "ToolExecutionCompleted", turn: 0, call: toolCall, result: toolResult }),
-  eventFrame(4, { _tag: "TurnCompleted", turn: 0 }),
-  eventFrame(5, { _tag: "TurnStarted", turn: 1 }),
-  eventFrame(6, {
-    _tag: "ModelPart",
-    turn: 1,
-    part: Response.makePart("reasoning-delta", { id: "reasoning-1", delta: "Check the transport stream." }),
-  }),
-  eventFrame(7, {
-    _tag: "ModelPart",
-    turn: 1,
-    part: Response.makePart("text-delta", { id: "answer-1", delta: "Final answer" }),
-  }),
-  eventFrame(8, { _tag: "TurnCompleted", turn: 1 }),
-  eventFrame(9, { _tag: "Completed", turns: 2, text: "Final answer" }),
-]
-
-const reduceMessage = (model: Chat.Model, message: Chat.Message): Chat.Model => Chat.update(model, message)[0]
-
-const withModel = <Model>(initialModel: Model) =>
-  Object.assign(
-    <M, Message, OutMessage = undefined>(simulation: SceneSimulation<M, Message, OutMessage>) =>
-      ({ ...simulation, model: initialModel }) as unknown as SceneSimulation<M, Message, OutMessage>,
-    { _phantomModel: undefined },
-  )
-
-const scriptedModel = (): Chat.Model => {
-  let model = Chat.initialModel(null)
-  model = reduceMessage(model, Chat.OpenedSession({ sessionId }))
-  model = reduceMessage(model, Chat.ReceivedAgent({ incoming: Connection.ConnectionOpened() }))
-  model = reduceMessage(model, Chat.ChangedDraft({ text: "Render this run" }))
-  model = reduceMessage(model, Chat.SubmittedMessage())
-  for (const frame of frames) {
-    model = reduceMessage(model, Chat.ReceivedAgent({ incoming: frame }))
-  }
-  return model
-}
-
-const rowView = (item: Chat.ConversationItem): Html => {
-  const h = html<Chat.Message>()
-  switch (item._tag) {
-    case "UserConversationItem":
-      return h.section([h.Role("article"), h.AriaLabel("User message")], [item.entry.text])
-    case "AssistantConversationItem":
-      return h.section(
-        [h.Role("article"), h.AriaLabel("Assistant message")],
-        [item.entry.reasoning ?? "", item.entry.text],
-      )
-    case "ToolConversationItem":
-      return h.section(
-        [h.Role("article"), h.AriaLabel(`Tool ${item.entry.name}`), h.DataAttribute("status", item.status)],
-        [item.entry.name, item.status, item.input, JSON.stringify(item.entry.outcome)],
-      )
-    case "StreamingConversationItem":
-      return h.section([h.Role("article"), h.AriaLabel("Streaming assistant message")], [item.reasoning, item.text])
-    case "WaitingConversationItem":
-      return h.section([h.Role("status")], ["Thinking"])
-    case "ApprovalConversationItem":
-      return h.section([h.Role("article"), h.AriaLabel("Approval required")], [item.toolName])
-    case "FailureConversationItem":
-      return h.section([h.Role("alert")], [item.message])
-  }
-}
-
-const view = (model: Chat.Model): Document => {
-  const h = html<Chat.Message>()
-  return {
-    title: "Chat scene",
-    body: h.main(
-      [],
-      [
-        h.div([h.Role("log")], Chat.conversationItems(model).map(rowView)),
-        h.form(
-          [h.OnSubmit(Chat.SubmittedMessage())],
-          [
-            h.input([
-              h.AriaLabel("Message"),
-              h.Placeholder("Message"),
-              h.Value(model.draft),
-              h.OnInput((text) => Chat.ChangedDraft({ text })),
-            ]),
-            h.button([h.Type("submit")], ["Send"]),
-          ],
-        ),
-      ],
-    ),
-  }
-}
-
-describe("Chat Scene", () => {
-  test("renders scripted stream rows for user, tool execution, and assistant completion", () => {
-    scene(
-      { update: Chat.update, view },
-      withModel(scriptedModel()),
-      expect(role("article", { name: "User message" })).toContainText("Render this run"),
-      expect(role("article", { name: "Tool lookup" })).toContainText("lookup"),
-      expect(role("article", { name: "Tool lookup" })).toContainText("output-available"),
-      expect(role("article", { name: "Tool lookup" })).toContainText('"answer":"transport binding"'),
-      expect(role("article", { name: "Assistant message" })).toContainText("Check the transport stream."),
-      expect(role("article", { name: "Assistant message" })).toContainText("Final answer"),
-    )
-  })
-
-  test("send message dispatches the Baton send command", () => {
-    const model = reduceMessage(Chat.initialModel(null), Chat.OpenedSession({ sessionId }))
-    scene(
-      { update: Chat.update, view },
-      withModel(model),
-      type(placeholder("Message"), "hello baton"),
-      click(role("button", { name: "Send" })),
-      Command.expectExact(Chat.SendUserMessage({ sessionId, text: "hello baton" })),
-      Command.resolve(Chat.SendUserMessage({ sessionId, text: "hello baton" }), Chat.SentUserMessage()),
-      expect(role("article", { name: "User message" })).toContainText("hello baton"),
-    )
-  })
-})

package/test/chat.story.test.ts

@@ -1,110 +0,0 @@
-import { Chat } from "../src/index"
-import { Wire } from "@batonfx/transport"
-import { Response } from "effect/unstable/ai"
-import { Command, expectOutMessage, message, model, story } from "foldkit/story"
-import type { StorySimulation } from "foldkit/story"
-import { describe, expect, test } from "vitest"
-
-const sessionId = "foldkit-story-session"
-
-const eventFrame = (seq: number, event: Wire.EventType): Wire.LooseServerFrameType => ({ _tag: "Event", seq, event })
-
-const receivedFrame = (frame: Wire.LooseServerFrameType) => Chat.ReceivedAgent({ incoming: frame })
-
-const withModel = <Model>(initialModel: Model) =>
-  Object.assign(
-    <M, Message, OutMessage = undefined>(simulation: StorySimulation<M, Message, OutMessage>) =>
-      ({ ...simulation, model: initialModel }) as unknown as StorySimulation<M, Message, OutMessage>,
-    { _phantomModel: undefined },
-  )
-
-const toolCall = Response.makePart("tool-call", {
-  id: "lookup-1",
-  name: "lookup",
-  params: { query: "baton foldkit" },
-  providerExecuted: false,
-})
-
-const toolResult = Response.makePart("tool-result", {
-  id: "lookup-1",
-  name: "lookup",
-  result: { answer: "transport binding" },
-  encodedResult: { answer: "transport binding" },
-  isFailure: false,
-  providerExecuted: false,
-  preliminary: false,
-})
-
-const frames: ReadonlyArray<Wire.LooseServerFrameType> = [
-  eventFrame(0, { _tag: "TurnStarted", turn: 0 }),
-  eventFrame(1, { _tag: "ModelPart", turn: 0, part: toolCall }),
-  eventFrame(2, { _tag: "ToolExecutionStarted", turn: 0, call: toolCall }),
-  eventFrame(3, { _tag: "ToolProgress", turn: 0, toolCallId: "lookup-1", message: "looking up" }),
-  eventFrame(4, { _tag: "ToolExecutionCompleted", turn: 0, call: toolCall, result: toolResult }),
-  eventFrame(5, { _tag: "TurnCompleted", turn: 0 }),
-  eventFrame(6, { _tag: "TurnStarted", turn: 1 }),
-  eventFrame(7, {
-    _tag: "ModelPart",
-    turn: 1,
-    part: Response.makePart("reasoning-delta", { id: "reasoning-1", delta: "Check the transport stream." }),
-  }),
-  eventFrame(8, {
-    _tag: "ModelPart",
-    turn: 1,
-    part: Response.makePart("text-delta", { id: "answer-1", delta: "Final answer" }),
-  }),
-  eventFrame(9, { _tag: "TurnCompleted", turn: 1 }),
-  eventFrame(10, { _tag: "Completed", turns: 2, text: "Final answer" }),
-]
-
-describe("Chat Story", () => {
-  test("scripted agent frames drive tool call, execution, and completion state", () => {
-    story(
-      Chat.update,
-      withModel(Chat.initialModel(null)),
-      message(Chat.OpenedSession({ sessionId })),
-      model((currentModel) => {
-        expect(currentModel.sessionId).toBe(sessionId)
-        expect(currentModel.connection).toBe("connecting")
-      }),
-      message(Chat.ChangedDraft({ text: "Render this run" })),
-      message(Chat.SubmittedMessage()),
-      Command.expectExact(Chat.SendUserMessage({ sessionId, text: "Render this run" })),
-      Command.resolve(Chat.SendUserMessage({ sessionId, text: "Render this run" }), Chat.SentUserMessage()),
-      message(receivedFrame(frames[0]!)),
-      message(receivedFrame(frames[1]!)),
-      model((currentModel) => {
-        const tool = currentModel.entries[1]
-        if (tool?._tag !== "ToolEntry") throw new Error("expected tool call entry")
-        expect(Chat.toolStatusOf(tool)).toBe("input-streaming")
-      }),
-      message(receivedFrame(frames[2]!)),
-      model((currentModel) => {
-        const tool = currentModel.entries[1]
-        if (tool?._tag !== "ToolEntry") throw new Error("expected executing tool entry")
-        expect(Chat.toolStatusOf(tool)).toBe("input-available")
-      }),
-      ...frames.slice(3).map((frame) => message(receivedFrame(frame))),
-      expectOutMessage(Chat.RunCompleted({ text: "Final answer" })),
-      model((currentModel) => {
-        expect(currentModel.run).toEqual(Chat.Idle())
-        expect(currentModel.streaming).toBeNull()
-        expect(Chat.conversationItems(currentModel).map((item) => item._tag)).toEqual([
-          "UserConversationItem",
-          "ToolConversationItem",
-          "AssistantConversationItem",
-        ])
-
-        const tool = currentModel.entries[1]
-        if (tool?._tag !== "ToolEntry") throw new Error("expected completed tool entry")
-        expect(tool.progress).toEqual(["looking up"])
-        expect(Chat.toolStatusOf(tool)).toBe("output-available")
-
-        const assistant = currentModel.entries[2]
-        expect(assistant).toEqual(
-          Chat.AssistantEntry({ text: "Final answer", reasoning: "Check the transport stream." }),
-        )
-      }),
-    )
-  })
-})

package/test/chat.test.ts

@@ -1,154 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import { Effect, Option, Schema, Stream } from "effect"
-import { Response } from "effect/unstable/ai"
-import { Wire } from "@batonfx/transport"
-import { Chat, Connection } from "../src/index"
-
-const eventFrame = (seq: number, event: Wire.EventType): Wire.LooseServerFrameType => ({ _tag: "Event", seq, event })
-
-const updateWith = (model: Chat.Model, incoming: Connection.Incoming) =>
-  Chat.update(model, Chat.ReceivedAgent({ incoming }))
-
-describe("Chat", () => {
-  it("folds a full run into display entries and a completion out-message", () => {
-    let model = Chat.initialModel("s-chat")
-    let out: Option.Option<Chat.OutMessage> = Option.none()
-
-    ;[model, , out] = updateWith(model, eventFrame(0, { _tag: "TurnStarted", turn: 0 }))
-    expect(model.run).toEqual({ _tag: "Running", turn: 0 })
-    expect(model.streaming).toEqual({ turn: 0, text: "", reasoning: "" })
-    expect(Option.isNone(out)).toBe(true)
-    ;[model] = updateWith(
-      model,
-      eventFrame(1, {
-        _tag: "ModelPart",
-        turn: 0,
-        part: Response.makePart("text-delta", { id: "text-1", delta: "Hello " }),
-      }),
-    )
-    ;[model] = updateWith(
-      model,
-      eventFrame(2, {
-        _tag: "ModelPart",
-        turn: 0,
-        part: Response.makePart("text-delta", { id: "text-1", delta: "world" }),
-      }),
-    )
-
-    const call = Response.makePart("tool-call", {
-      id: "call-1",
-      name: "lookup",
-      params: { q: "baton" },
-      providerExecuted: false,
-    })
-    ;[model] = updateWith(model, eventFrame(3, { _tag: "ModelPart", turn: 0, part: call }))
-    expect(model.entries).toEqual([
-      {
-        _tag: "ToolEntry",
-        callId: "call-1",
-        name: "lookup",
-        params: { q: "baton" },
-        phase: "called",
-        outcome: { _tag: "Pending" },
-        progress: [],
-      },
-    ])
-    const pendingTool = model.entries[0]
-    if (pendingTool?._tag !== "ToolEntry") throw new Error("expected pending tool entry")
-    expect(Chat.toolStatusOf(pendingTool)).toBe("input-streaming")
-
-    const result = Response.makePart("tool-result", {
-      id: "call-1",
-      name: "lookup",
-      result: { ok: true },
-      encodedResult: { ok: true },
-      isFailure: false,
-      providerExecuted: false,
-      preliminary: false,
-    })
-    ;[model] = updateWith(model, eventFrame(4, { _tag: "ToolExecutionCompleted", turn: 0, call, result }))
-    expect(model.entries[0]).toMatchObject({
-      _tag: "ToolEntry",
-      phase: "executing",
-      outcome: { _tag: "Completed", isFailure: false, result: { ok: true } },
-    })
-    const completedTool = model.entries[0]
-    if (completedTool?._tag !== "ToolEntry") throw new Error("expected completed tool entry")
-    expect(Chat.toolStatusOf(completedTool)).toBe("output-available")
-    ;[model] = updateWith(model, eventFrame(5, { _tag: "TurnCompleted", turn: 0 }))
-    expect(model.streaming).toBeNull()
-    expect(model.entries[1]).toEqual({ _tag: "AssistantEntry", text: "Hello world", reasoning: null })
-    ;[model, , out] = updateWith(model, eventFrame(6, { _tag: "Completed", turns: 1, text: "Done" }))
-    expect(model.run).toEqual({ _tag: "Idle" })
-    expect(Option.getOrUndefined(out)).toEqual({ _tag: "RunCompleted", text: "Done" })
-  })
-
-  it("drops replayed frames whose seq is not newer than lastSeq", () => {
-    const model = { ...Chat.initialModel("s-chat"), lastSeq: 5, entries: [Chat.UserEntry({ text: "already" })] }
-    const [next, commands, out] = updateWith(model, eventFrame(5, { _tag: "TurnStarted", turn: 1 }))
-
-    expect(next).toEqual(model)
-    expect(commands).toEqual([])
-    expect(Option.isNone(out)).toBe(true)
-  })
-
-  it("surfaces approval suspension and emits approval commands", () => {
-    let model = Chat.initialModel("s-chat")
-    let out: Option.Option<Chat.OutMessage> = Option.none()
-    ;[model, , out] = updateWith(
-      model,
-      Schema.decodeUnknownSync(Wire.LooseServerFrame)({
-        _tag: "Suspended",
-        seq: 0,
-        suspension: {
-          _tag: "@batonfx/core/AgentSuspended",
-          token: "approval-token",
-          reason: "approval",
-          tool_call_id: "call-approval",
-          tool_name: "lookup",
-          tool_params: { q: "baton" },
-        },
-      }),
-    )
-
-    expect(model.run).toEqual({
-      _tag: "AwaitingApproval",
-      token: "approval-token",
-      toolName: "lookup",
-      params: { q: "baton" },
-    })
-    expect(Option.getOrUndefined(out)).toEqual({ _tag: "ApprovalRequired" })
-
-    const [, commands] = Chat.update(model, Chat.ClickedApprove())
-    expect(commands).toHaveLength(1)
-    expect(commands[0]?.name).toBe("ResolveApproval")
-    expect(commands[0]?.args).toEqual({
-      sessionId: "s-chat",
-      token: "approval-token",
-      approved: true,
-      reason: null,
-    })
-  })
-
-  it.effect("converts command send failures into FailedAgentCommand messages", () =>
-    Effect.gen(function* () {
-      let model = Chat.initialModel("s-chat")
-      ;[model] = Chat.update(model, Chat.ChangedDraft({ text: "hello" }))
-      const [next, commands] = Chat.update(model, Chat.SubmittedMessage())
-
-      expect(next.draft).toBe("")
-      expect(next.entries).toEqual([Chat.UserEntry({ text: "hello" })])
-      expect(commands).toHaveLength(1)
-      const message = yield* commands[0]!.effect
-
-      expect(message).toEqual({ _tag: "FailedAgentCommand", reason: "offline" })
-    }).pipe(
-      Effect.provide(
-        Connection.testLayer({
-          frames: () => Stream.empty,
-          send: () => Effect.fail(new Connection.SendFailed({ reason: "offline" })),
-        }),
-      ),
-    ),
-  )
-})

package/test/connection.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import { Effect, Stream } from "effect"
-import { Chat, Connection } from "../src/index"
-
-describe("Connection", () => {
-  it.effect("testLayer provides AgentConnection frames and send", () =>
-    Effect.gen(function* () {
-      const incoming = Connection.ConnectionOpened()
-      const frames = yield* Connection.AgentConnection.use((connection) =>
-        connection.frames({ sessionId: "s", afterSeq: 1 }).pipe(Stream.runCollect),
-      )
-      yield* Connection.AgentConnection.use((connection) => connection.send({ _tag: "Cancel", sessionId: "s" }))
-
-      expect(frames).toEqual([incoming])
-    }).pipe(
-      Effect.provide(
-        Connection.testLayer({
-          frames: () => Stream.fromIterable([Connection.ConnectionOpened()]),
-          send: () => Effect.void,
-        }),
-      ),
-    ),
-  )
-
-  it("keeps the chat subscription alive across afterSeq-only changes", () => {
-    const subscription = Chat.subscriptions.agentFrames
-
-    expect(subscription.keepAliveEquivalence?.({ sessionId: "s", afterSeq: 1 }, { sessionId: "s", afterSeq: 2 })).toBe(
-      true,
-    )
-    expect(
-      subscription.keepAliveEquivalence?.({ sessionId: "s-1", afterSeq: 2 }, { sessionId: "s-2", afterSeq: 2 }),
-    ).toBe(false)
-  })
-})

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "."
-  },
-  "include": ["src/**/*.ts", "test/**/*.ts"]
-}