reigncode-app 1.3.2

package/src/utils/server-health.ts

@@ -0,0 +1,91 @@
+import { usePlatform } from "@/context/platform"
+import type { ServerConnection } from "@/context/server"
+import { createSdkForServer } from "./server"
+
+export type ServerHealth = { healthy: boolean; version?: string }
+
+interface CheckServerHealthOptions {
+  timeoutMs?: number
+  signal?: AbortSignal
+  retryCount?: number
+  retryDelayMs?: number
+}
+
+const defaultTimeoutMs = 3000
+const defaultRetryCount = 2
+const defaultRetryDelayMs = 100
+
+function timeoutSignal(timeoutMs: number) {
+  const timeout = (AbortSignal as unknown as { timeout?: (ms: number) => AbortSignal }).timeout
+  if (timeout) {
+    try {
+      return {
+        signal: timeout.call(AbortSignal, timeoutMs),
+        clear: undefined as (() => void) | undefined,
+      }
+    } catch {}
+  }
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  return { signal: controller.signal, clear: () => clearTimeout(timer) }
+}
+
+function wait(ms: number, signal?: AbortSignal) {
+  return new Promise<void>((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"))
+      return
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort)
+      resolve()
+    }, ms)
+    const onAbort = () => {
+      clearTimeout(timer)
+      reject(new DOMException("Aborted", "AbortError"))
+    }
+    signal?.addEventListener("abort", onAbort, { once: true })
+  })
+}
+
+function retryable(error: unknown, signal?: AbortSignal) {
+  if (signal?.aborted) return false
+  if (!(error instanceof Error)) return false
+  if (error.name === "AbortError" || error.name === "TimeoutError") return false
+  if (error instanceof TypeError) return true
+  return /network|fetch|econnreset|econnrefused|enotfound|timedout/i.test(error.message)
+}
+
+export async function checkServerHealth(
+  server: ServerConnection.HttpBase,
+  fetch: typeof globalThis.fetch,
+  opts?: CheckServerHealthOptions,
+): Promise<ServerHealth> {
+  const timeout = opts?.signal ? undefined : timeoutSignal(opts?.timeoutMs ?? defaultTimeoutMs)
+  const signal = opts?.signal ?? timeout?.signal
+  const retryCount = opts?.retryCount ?? defaultRetryCount
+  const retryDelayMs = opts?.retryDelayMs ?? defaultRetryDelayMs
+  const next = (count: number, error: unknown) => {
+    if (count >= retryCount || !retryable(error, signal)) return Promise.resolve({ healthy: false } as const)
+    return wait(retryDelayMs * (count + 1), signal)
+      .then(() => attempt(count + 1))
+      .catch(() => ({ healthy: false }))
+  }
+  const attempt = (count: number): Promise<ServerHealth> =>
+    createSdkForServer({
+      server,
+      fetch,
+      signal,
+    })
+      .global.health()
+      .then((x) => (x.error ? next(count, x.error) : { healthy: x.data?.healthy === true, version: x.data?.version }))
+      .catch((error) => next(count, error))
+  return attempt(0).finally(() => timeout?.clear?.())
+}
+
+export function useCheckServerHealth() {
+  const platform = usePlatform()
+  const fetcher = platform.fetch ?? globalThis.fetch
+
+  return (http: ServerConnection.HttpBase) => checkServerHealth(http, fetcher)
+}

package/src/utils/server.ts

@@ -0,0 +1,22 @@
+import { createOpencodeClient } from "@reign-labs/sdk/v2/client"
+import type { ServerConnection } from "@/context/server"
+
+export function createSdkForServer({
+  server,
+  ...config
+}: Omit<NonNullable<Parameters<typeof createOpencodeClient>[0]>, "baseUrl"> & {
+  server: ServerConnection.HttpBase
+}) {
+  const auth = (() => {
+    if (!server.password) return
+    return {
+      Authorization: `Basic ${btoa(`${server.username ?? "opencode"}:${server.password}`)}`,
+    }
+  })()
+
+  return createOpencodeClient({
+    ...config,
+    headers: { ...config.headers, ...auth },
+    baseUrl: server.url,
+  })
+}

package/src/utils/solid-dnd.tsx

@@ -0,0 +1,49 @@
+import { useDragDropContext } from "@thisbeyond/solid-dnd"
+import type { Transformer } from "@thisbeyond/solid-dnd"
+import { createRoot, onCleanup, type JSXElement } from "solid-js"
+
+type DragEvent = { draggable?: { id?: unknown } }
+
+const isDragEvent = (event: unknown): event is DragEvent => {
+  if (typeof event !== "object" || event === null) return false
+  return "draggable" in event
+}
+
+export const getDraggableId = (event: unknown): string | undefined => {
+  if (!isDragEvent(event)) return undefined
+  const draggable = event.draggable
+  if (!draggable) return undefined
+  return typeof draggable.id === "string" ? draggable.id : undefined
+}
+
+const createTransformer = (id: string, axis: "x" | "y"): Transformer => ({
+  id,
+  order: 100,
+  callback: (transform) => (axis === "x" ? { ...transform, x: 0 } : { ...transform, y: 0 }),
+})
+
+const createAxisConstraint = (axis: "x" | "y", transformerId: string) => (): JSXElement => {
+  const context = useDragDropContext()
+  if (!context) return null
+  const [, { onDragStart, onDragEnd, addTransformer, removeTransformer }] = context
+  const transformer = createTransformer(transformerId, axis)
+  const dispose = createRoot((dispose) => {
+    onDragStart((event) => {
+      const id = getDraggableId(event)
+      if (!id) return
+      addTransformer("draggables", id, transformer)
+    })
+    onDragEnd((event) => {
+      const id = getDraggableId(event)
+      if (!id) return
+      removeTransformer("draggables", id, transformer.id)
+    })
+    return dispose
+  })
+  onCleanup(dispose)
+  return null
+}
+
+export const ConstrainDragXAxis = createAxisConstraint("x", "constrain-x-axis")
+
+export const ConstrainDragYAxis = createAxisConstraint("y", "constrain-y-axis")

package/src/utils/sound.ts

@@ -0,0 +1,117 @@
+import alert01 from "@reign-labs/ui/audio/alert-01.aac"
+import alert02 from "@reign-labs/ui/audio/alert-02.aac"
+import alert03 from "@reign-labs/ui/audio/alert-03.aac"
+import alert04 from "@reign-labs/ui/audio/alert-04.aac"
+import alert05 from "@reign-labs/ui/audio/alert-05.aac"
+import alert06 from "@reign-labs/ui/audio/alert-06.aac"
+import alert07 from "@reign-labs/ui/audio/alert-07.aac"
+import alert08 from "@reign-labs/ui/audio/alert-08.aac"
+import alert09 from "@reign-labs/ui/audio/alert-09.aac"
+import alert10 from "@reign-labs/ui/audio/alert-10.aac"
+import bipbop01 from "@reign-labs/ui/audio/bip-bop-01.aac"
+import bipbop02 from "@reign-labs/ui/audio/bip-bop-02.aac"
+import bipbop03 from "@reign-labs/ui/audio/bip-bop-03.aac"
+import bipbop04 from "@reign-labs/ui/audio/bip-bop-04.aac"
+import bipbop05 from "@reign-labs/ui/audio/bip-bop-05.aac"
+import bipbop06 from "@reign-labs/ui/audio/bip-bop-06.aac"
+import bipbop07 from "@reign-labs/ui/audio/bip-bop-07.aac"
+import bipbop08 from "@reign-labs/ui/audio/bip-bop-08.aac"
+import bipbop09 from "@reign-labs/ui/audio/bip-bop-09.aac"
+import bipbop10 from "@reign-labs/ui/audio/bip-bop-10.aac"
+import nope01 from "@reign-labs/ui/audio/nope-01.aac"
+import nope02 from "@reign-labs/ui/audio/nope-02.aac"
+import nope03 from "@reign-labs/ui/audio/nope-03.aac"
+import nope04 from "@reign-labs/ui/audio/nope-04.aac"
+import nope05 from "@reign-labs/ui/audio/nope-05.aac"
+import nope06 from "@reign-labs/ui/audio/nope-06.aac"
+import nope07 from "@reign-labs/ui/audio/nope-07.aac"
+import nope08 from "@reign-labs/ui/audio/nope-08.aac"
+import nope09 from "@reign-labs/ui/audio/nope-09.aac"
+import nope10 from "@reign-labs/ui/audio/nope-10.aac"
+import nope11 from "@reign-labs/ui/audio/nope-11.aac"
+import nope12 from "@reign-labs/ui/audio/nope-12.aac"
+import staplebops01 from "@reign-labs/ui/audio/staplebops-01.aac"
+import staplebops02 from "@reign-labs/ui/audio/staplebops-02.aac"
+import staplebops03 from "@reign-labs/ui/audio/staplebops-03.aac"
+import staplebops04 from "@reign-labs/ui/audio/staplebops-04.aac"
+import staplebops05 from "@reign-labs/ui/audio/staplebops-05.aac"
+import staplebops06 from "@reign-labs/ui/audio/staplebops-06.aac"
+import staplebops07 from "@reign-labs/ui/audio/staplebops-07.aac"
+import yup01 from "@reign-labs/ui/audio/yup-01.aac"
+import yup02 from "@reign-labs/ui/audio/yup-02.aac"
+import yup03 from "@reign-labs/ui/audio/yup-03.aac"
+import yup04 from "@reign-labs/ui/audio/yup-04.aac"
+import yup05 from "@reign-labs/ui/audio/yup-05.aac"
+import yup06 from "@reign-labs/ui/audio/yup-06.aac"
+
+export const SOUND_OPTIONS = [
+  { id: "alert-01", label: "sound.option.alert01", src: alert01 },
+  { id: "alert-02", label: "sound.option.alert02", src: alert02 },
+  { id: "alert-03", label: "sound.option.alert03", src: alert03 },
+  { id: "alert-04", label: "sound.option.alert04", src: alert04 },
+  { id: "alert-05", label: "sound.option.alert05", src: alert05 },
+  { id: "alert-06", label: "sound.option.alert06", src: alert06 },
+  { id: "alert-07", label: "sound.option.alert07", src: alert07 },
+  { id: "alert-08", label: "sound.option.alert08", src: alert08 },
+  { id: "alert-09", label: "sound.option.alert09", src: alert09 },
+  { id: "alert-10", label: "sound.option.alert10", src: alert10 },
+  { id: "bip-bop-01", label: "sound.option.bipbop01", src: bipbop01 },
+  { id: "bip-bop-02", label: "sound.option.bipbop02", src: bipbop02 },
+  { id: "bip-bop-03", label: "sound.option.bipbop03", src: bipbop03 },
+  { id: "bip-bop-04", label: "sound.option.bipbop04", src: bipbop04 },
+  { id: "bip-bop-05", label: "sound.option.bipbop05", src: bipbop05 },
+  { id: "bip-bop-06", label: "sound.option.bipbop06", src: bipbop06 },
+  { id: "bip-bop-07", label: "sound.option.bipbop07", src: bipbop07 },
+  { id: "bip-bop-08", label: "sound.option.bipbop08", src: bipbop08 },
+  { id: "bip-bop-09", label: "sound.option.bipbop09", src: bipbop09 },
+  { id: "bip-bop-10", label: "sound.option.bipbop10", src: bipbop10 },
+  { id: "staplebops-01", label: "sound.option.staplebops01", src: staplebops01 },
+  { id: "staplebops-02", label: "sound.option.staplebops02", src: staplebops02 },
+  { id: "staplebops-03", label: "sound.option.staplebops03", src: staplebops03 },
+  { id: "staplebops-04", label: "sound.option.staplebops04", src: staplebops04 },
+  { id: "staplebops-05", label: "sound.option.staplebops05", src: staplebops05 },
+  { id: "staplebops-06", label: "sound.option.staplebops06", src: staplebops06 },
+  { id: "staplebops-07", label: "sound.option.staplebops07", src: staplebops07 },
+  { id: "nope-01", label: "sound.option.nope01", src: nope01 },
+  { id: "nope-02", label: "sound.option.nope02", src: nope02 },
+  { id: "nope-03", label: "sound.option.nope03", src: nope03 },
+  { id: "nope-04", label: "sound.option.nope04", src: nope04 },
+  { id: "nope-05", label: "sound.option.nope05", src: nope05 },
+  { id: "nope-06", label: "sound.option.nope06", src: nope06 },
+  { id: "nope-07", label: "sound.option.nope07", src: nope07 },
+  { id: "nope-08", label: "sound.option.nope08", src: nope08 },
+  { id: "nope-09", label: "sound.option.nope09", src: nope09 },
+  { id: "nope-10", label: "sound.option.nope10", src: nope10 },
+  { id: "nope-11", label: "sound.option.nope11", src: nope11 },
+  { id: "nope-12", label: "sound.option.nope12", src: nope12 },
+  { id: "yup-01", label: "sound.option.yup01", src: yup01 },
+  { id: "yup-02", label: "sound.option.yup02", src: yup02 },
+  { id: "yup-03", label: "sound.option.yup03", src: yup03 },
+  { id: "yup-04", label: "sound.option.yup04", src: yup04 },
+  { id: "yup-05", label: "sound.option.yup05", src: yup05 },
+  { id: "yup-06", label: "sound.option.yup06", src: yup06 },
+] as const
+
+export type SoundOption = (typeof SOUND_OPTIONS)[number]
+export type SoundID = SoundOption["id"]
+
+const soundById = Object.fromEntries(SOUND_OPTIONS.map((s) => [s.id, s.src])) as Record<SoundID, string>
+
+export function soundSrc(id: string | undefined) {
+  if (!id) return
+  if (!(id in soundById)) return
+  return soundById[id as SoundID]
+}
+
+export function playSound(src: string | undefined) {
+  if (typeof Audio === "undefined") return
+  if (!src) return
+  const audio = new Audio(src)
+  audio.play().catch(() => undefined)
+
+  // Return a cleanup function to pause the sound.
+  return () => {
+    audio.pause()
+    audio.currentTime = 0
+  }
+}

package/src/utils/terminal-writer.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test"
+import { terminalWriter } from "./terminal-writer"
+
+describe("terminalWriter", () => {
+  test("buffers and flushes once per schedule", () => {
+    const calls: string[] = []
+    const scheduled: VoidFunction[] = []
+    const writer = terminalWriter(
+      (data, done) => {
+        calls.push(data)
+        done?.()
+      },
+      (flush) => scheduled.push(flush),
+    )
+
+    writer.push("a")
+    writer.push("b")
+    writer.push("c")
+
+    expect(calls).toEqual([])
+    expect(scheduled).toHaveLength(1)
+
+    scheduled[0]?.()
+    expect(calls).toEqual(["abc"])
+  })
+
+  test("flush is a no-op when empty", () => {
+    const calls: string[] = []
+    const writer = terminalWriter(
+      (data, done) => {
+        calls.push(data)
+        done?.()
+      },
+      (flush) => flush(),
+    )
+    writer.flush()
+    expect(calls).toEqual([])
+  })
+
+  test("flush waits for pending write completion", () => {
+    const calls: string[] = []
+    let done: VoidFunction | undefined
+    const writer = terminalWriter(
+      (data, finish) => {
+        calls.push(data)
+        done = finish
+      },
+      (flush) => flush(),
+    )
+
+    writer.push("a")
+
+    let settled = false
+    writer.flush(() => {
+      settled = true
+    })
+
+    expect(calls).toEqual(["a"])
+    expect(settled).toBe(false)
+
+    done?.()
+    expect(settled).toBe(true)
+  })
+})

package/src/utils/terminal-writer.ts

@@ -0,0 +1,65 @@
+export function terminalWriter(
+  write: (data: string, done?: VoidFunction) => void,
+  schedule: (flush: VoidFunction) => void = queueMicrotask,
+) {
+  let chunks: string[] | undefined
+  let waits: VoidFunction[] | undefined
+  let scheduled = false
+  let writing = false
+
+  const settle = () => {
+    if (scheduled || writing || chunks?.length) return
+    const list = waits
+    if (!list?.length) return
+    waits = undefined
+    for (const fn of list) {
+      fn()
+    }
+  }
+
+  const run = () => {
+    if (writing) return
+    scheduled = false
+    const items = chunks
+    if (!items?.length) {
+      settle()
+      return
+    }
+    chunks = undefined
+    writing = true
+    write(items.join(""), () => {
+      writing = false
+      if (chunks?.length) {
+        if (scheduled) return
+        scheduled = true
+        schedule(run)
+        return
+      }
+      settle()
+    })
+  }
+
+  const push = (data: string) => {
+    if (!data) return
+    if (chunks) chunks.push(data)
+    else chunks = [data]
+
+    if (scheduled || writing) return
+    scheduled = true
+    schedule(run)
+  }
+
+  const flush = (done?: VoidFunction) => {
+    if (!scheduled && !writing && !chunks?.length) {
+      done?.()
+      return
+    }
+    if (done) {
+      if (waits) waits.push(done)
+      else waits = [done]
+    }
+    run()
+  }
+
+  return { push, flush }
+}

package/src/utils/time.ts

@@ -0,0 +1,22 @@
+type TimeKey =
+  | "common.time.justNow"
+  | "common.time.minutesAgo.short"
+  | "common.time.hoursAgo.short"
+  | "common.time.daysAgo.short"
+
+type Translate = (key: TimeKey, params?: Record<string, string | number>) => string
+
+export function getRelativeTime(dateString: string, t: Translate): string {
+  const date = new Date(dateString)
+  const now = new Date()
+  const diffMs = now.getTime() - date.getTime()
+  const diffSeconds = Math.floor(diffMs / 1000)
+  const diffMinutes = Math.floor(diffSeconds / 60)
+  const diffHours = Math.floor(diffMinutes / 60)
+  const diffDays = Math.floor(diffHours / 24)
+
+  if (diffSeconds < 60) return t("common.time.justNow")
+  if (diffMinutes < 60) return t("common.time.minutesAgo.short", { count: diffMinutes })
+  if (diffHours < 24) return t("common.time.hoursAgo.short", { count: diffHours })
+  return t("common.time.daysAgo.short", { count: diffDays })
+}

package/src/utils/uuid.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { uuid } from "./uuid"
+
+const cryptoDescriptor = Object.getOwnPropertyDescriptor(globalThis, "crypto")
+const secureDescriptor = Object.getOwnPropertyDescriptor(globalThis, "isSecureContext")
+const randomDescriptor = Object.getOwnPropertyDescriptor(Math, "random")
+
+const setCrypto = (value: Partial<Crypto>) => {
+  Object.defineProperty(globalThis, "crypto", {
+    configurable: true,
+    value: value as Crypto,
+  })
+}
+
+const setSecure = (value: boolean) => {
+  Object.defineProperty(globalThis, "isSecureContext", {
+    configurable: true,
+    value,
+  })
+}
+
+const setRandom = (value: () => number) => {
+  Object.defineProperty(Math, "random", {
+    configurable: true,
+    value,
+  })
+}
+
+afterEach(() => {
+  if (cryptoDescriptor) {
+    Object.defineProperty(globalThis, "crypto", cryptoDescriptor)
+  }
+
+  if (secureDescriptor) {
+    Object.defineProperty(globalThis, "isSecureContext", secureDescriptor)
+  }
+
+  if (!secureDescriptor) {
+    delete (globalThis as { isSecureContext?: boolean }).isSecureContext
+  }
+
+  if (randomDescriptor) {
+    Object.defineProperty(Math, "random", randomDescriptor)
+  }
+})
+
+describe("uuid", () => {
+  test("uses randomUUID in secure contexts", () => {
+    setCrypto({ randomUUID: () => "00000000-0000-0000-0000-000000000000" })
+    setSecure(true)
+    expect(uuid()).toBe("00000000-0000-0000-0000-000000000000")
+  })
+
+  test("falls back in insecure contexts", () => {
+    setCrypto({ randomUUID: () => "00000000-0000-0000-0000-000000000000" })
+    setSecure(false)
+    setRandom(() => 0.5)
+    expect(uuid()).toBe("8")
+  })
+
+  test("falls back when randomUUID throws", () => {
+    setCrypto({
+      randomUUID: () => {
+        throw new DOMException("Failed", "OperationError")
+      },
+    })
+    setSecure(true)
+    setRandom(() => 0.5)
+    expect(uuid()).toBe("8")
+  })
+
+  test("falls back when randomUUID is unavailable", () => {
+    setCrypto({})
+    setSecure(true)
+    setRandom(() => 0.5)
+    expect(uuid()).toBe("8")
+  })
+})

package/src/utils/uuid.ts

@@ -0,0 +1,12 @@
+const fallback = () => Math.random().toString(16).slice(2)
+
+export function uuid() {
+  const c = globalThis.crypto
+  if (!c || typeof c.randomUUID !== "function") return fallback()
+  if (typeof globalThis.isSecureContext === "boolean" && !globalThis.isSecureContext) return fallback()
+  try {
+    return c.randomUUID()
+  } catch {
+    return fallback()
+  }
+}

package/src/utils/worktree.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test"
+import { Worktree } from "./worktree"
+
+const dir = (name: string) => `/tmp/opencode-worktree-${name}-${crypto.randomUUID()}`
+
+describe("Worktree", () => {
+  test("normalizes trailing slashes", () => {
+    const key = dir("normalize")
+    Worktree.ready(`${key}/`)
+
+    expect(Worktree.get(key)).toEqual({ status: "ready" })
+  })
+
+  test("pending does not overwrite a terminal state", () => {
+    const key = dir("pending")
+    Worktree.failed(key, "boom")
+    Worktree.pending(key)
+
+    expect(Worktree.get(key)).toEqual({ status: "failed", message: "boom" })
+  })
+
+  test("wait resolves shared pending waiter when ready", async () => {
+    const key = dir("wait-ready")
+    Worktree.pending(key)
+
+    const a = Worktree.wait(key)
+    const b = Worktree.wait(`${key}/`)
+
+    expect(a).toBe(b)
+
+    Worktree.ready(key)
+
+    expect(await a).toEqual({ status: "ready" })
+    expect(await b).toEqual({ status: "ready" })
+  })
+
+  test("wait resolves with failure message", async () => {
+    const key = dir("wait-failed")
+    const waiting = Worktree.wait(key)
+
+    Worktree.failed(key, "permission denied")
+
+    expect(await waiting).toEqual({ status: "failed", message: "permission denied" })
+    expect(await Worktree.wait(key)).toEqual({ status: "failed", message: "permission denied" })
+  })
+})

package/src/utils/worktree.ts

@@ -0,0 +1,73 @@
+const normalize = (directory: string) => directory.replace(/[\\/]+$/, "")
+
+type State =
+  | {
+      status: "pending"
+    }
+  | {
+      status: "ready"
+    }
+  | {
+      status: "failed"
+      message: string
+    }
+
+const state = new Map<string, State>()
+const waiters = new Map<
+  string,
+  {
+    promise: Promise<State>
+    resolve: (state: State) => void
+  }
+>()
+
+function deferred() {
+  const box = { resolve: (_: State) => {} }
+  const promise = new Promise<State>((resolve) => {
+    box.resolve = resolve
+  })
+  return { promise, resolve: box.resolve }
+}
+
+export const Worktree = {
+  get(directory: string) {
+    return state.get(normalize(directory))
+  },
+  pending(directory: string) {
+    const key = normalize(directory)
+    const current = state.get(key)
+    if (current && current.status !== "pending") return
+    state.set(key, { status: "pending" })
+  },
+  ready(directory: string) {
+    const key = normalize(directory)
+    const next = { status: "ready" } as const
+    state.set(key, next)
+    const waiter = waiters.get(key)
+    if (!waiter) return
+    waiters.delete(key)
+    waiter.resolve(next)
+  },
+  failed(directory: string, message: string) {
+    const key = normalize(directory)
+    const next = { status: "failed", message } as const
+    state.set(key, next)
+    const waiter = waiters.get(key)
+    if (!waiter) return
+    waiters.delete(key)
+    waiter.resolve(next)
+  },
+  wait(directory: string) {
+    const key = normalize(directory)
+    const current = state.get(key)
+    if (current && current.status !== "pending") return Promise.resolve(current)
+
+    const existing = waiters.get(key)
+    if (existing) return existing.promise
+
+    const waiter = deferred()
+
+    waiters.set(key, waiter)
+    return waiter.promise
+  },
+}

package/sst-env.d.ts

@@ -0,0 +1,10 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+/* biome-ignore-all lint: auto-generated */
+
+/// <reference path="../../sst-env.d.ts" />
+
+import "sst"
+export {}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "composite": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "strict": true,
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "outDir": "node_modules/.ts-dist",
+    "isolatedModules": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src", "package.json"],
+  "exclude": ["dist", "ts-dist"]
+}