@tangle-network/starter-foundry 0.7.2 → 0.13.0

package/registry/families/orchestrator-with-ui-ts/files/README.md

@@ -0,0 +1,137 @@
+# {{appName}} — Agent Fleet
+
+Multi-agent dashboard scaffold. The app surface is a Next.js App Router app
+that renders a fleet of agents in a rail sidebar, opens per-agent chat tabs,
+and embeds `SandboxWorkbench` from `@tangle-network/sandbox-ui` for the live
+chat + artifact view. Each agent runs in its own Tangle sandbox; this UI
+talks to N sandboxes in parallel.
+
+## What this scaffold gives you
+
+- Fleet landing page (`app/page.tsx`) — rail of agent cards, plus
+  `BillingDashboard` + `UsageChart` panes from `@tangle-network/sandbox-ui/dashboard`
+- Per-agent chat surface (`app/agents/[id]/page.tsx`) — `SandboxWorkbench`
+  driven by one `useSdkSession()` instance per agent
+- Output-block adapter (`lib/parse-blocks.ts` + `lib/blocks-to-artifacts.tsx`,
+  composed in by the `ui-adapter:blocks-renderer` layer) — converts
+  `:::artifact`, `:::escalation`, `:::screener-result`, `:::audio-cue`,
+  `:::suggestion` blocks emitted by your agent-runtime bundles into
+  `SandboxWorkbenchArtifact[]` for the artifact pane
+
+## The roster is the source of truth
+
+Every agent the dashboard knows about is declared in `lib/agent-roster.ts`
+as an `AgentEntry`:
+
+```ts
+export interface AgentEntry {
+  id: string             // unique within the app, used as the route param
+  family: string         // the agent-runtime starter-foundry family
+  displayName: string
+  description: string
+  sandboxId?: string     // populated at runtime once the sandbox is provisioned
+  icon?: string
+}
+```
+
+To add an agent: append a new entry. To remove one: delete the entry. The
+sidebar, agent cards, and `/agents/[id]` route all derive from this list.
+
+`sandboxId` is intentionally optional. Three ways to populate it (see
+`lib/agent-roster.ts` for the full breakdown):
+
+1. **Static config** — hard-code after provisioning sandboxes via the Tangle
+   dashboard or `sandbox` CLI.
+2. **Server-side bootstrap** — replace the static export with a server
+   component that lists your sandboxes and matches by tag.
+3. **Per-agent on-demand** — leave undefined and lazily provision inside
+   `app/agents/[id]/page.tsx`, caching by `AgentEntry.id`.
+
+## Session lifecycle
+
+**Each visit to `/agents/[id]` starts a fresh session.** `useSdkSession()` is
+mounted inside the route component, and the App Router unmounts the component
+when the user navigates away. This is deliberate:
+
+- zero coupling — no global registry to debug
+- cheap memory — idle agents in the sidebar consume nothing
+- obvious semantics — leaving a tab clears its conversation
+
+If you want sessions to persist across navigation (so a half-finished chat
+with the CMO Advisor is still there when you click back from the Recruiter),
+**lift the sessions into a context provider in `app/layout.tsx`**: keep one
+`useSdkSession()` per `AgentEntry` keyed by `id`, expose them via context,
+and have the per-agent page read from the context instead of calling
+`useSdkSession()` directly. The `SandboxWorkbench` props don't change.
+
+For server-side persistence (resume across page reloads / devices), call the
+sandbox-sdk's session-history endpoint on mount and feed it through
+`session.replaceHistory(seeds)`.
+
+## The orchestrator pattern
+
+Each agent in the roster is a separately-deployed agent-runtime bundle running
+in its own Tangle sandbox. The dashboard:
+
+1. Lists all agents from `agent-roster.ts`
+2. On selection, opens a route that mounts a `SandboxWorkbench` for that
+   agent's sandbox
+3. The workbench drives a `useSdkSession()` instance — chat input flows out
+   to the sandbox, SDK events stream back in
+4. The `:::output-block` parser converts agent-runtime output blocks into
+   `SandboxWorkbenchArtifact[]` rendered in the artifact pane
+
+The dashboard is transport-agnostic: this scaffold ships a stub `onSend` that
+echoes back. You wire the real transport — Tangle sandbox-sdk client, custom
+HTTP, websockets — wherever fits your deployment.
+
+## Required env
+
+| Var                  | Purpose                                            |
+| -------------------- | -------------------------------------------------- |
+| `SANDBOX_API_URL`    | Tangle sandbox API base (default `https://api.tangle.tools`) |
+| `SANDBOX_API_TOKEN`  | Bearer token for sandbox provisioning + session calls       |
+
+Per-agent overrides (e.g. distinct tokens or backends per agent) belong on
+the `AgentEntry` itself — extend the type in `lib/agent-roster.ts` and read
+the overrides in `app/agents/[id]/page.tsx`.
+
+## When to use this
+
+| If you have…                                | Use…                          |
+| ------------------------------------------- | ----------------------------- |
+| One agent, one chat surface                 | `agent-with-ui-ts` (simpler)  |
+| N agents, fleet dashboard, per-agent chat   | **this** (`orchestrator-with-ui-ts`) |
+| A sandbox app with no agent on top          | `sandbox-app-ts`              |
+
+## Composition example
+
+```
+orchestrator-with-ui-ts
+  + agent-runtime-cmo-advisor-ts
+  + agent-runtime-recruiter-ts
+  + agent-runtime-business-partner-ts
+= a fleet management UI for marketing / recruiting / exec coaching
+```
+
+Each agent-runtime bundle compiles to its own deployable; this scaffold is the
+operator-facing dashboard that talks to all three.
+
+## Commands
+
+```bash
+pnpm install
+pnpm dev      # next dev on port {{port}}
+pnpm build    # next build
+pnpm start    # next start (production server)
+pnpm typecheck
+```
+
+## Extension points
+
+- `lib/agent-roster.ts` — add / remove agents
+- `app/agents/[id]/page.tsx` — wire real `onSend` transport, customize the
+  workbench layout
+- `lib/blocks-to-artifacts.tsx` — register custom block kinds via
+  `registerBlockMapper(...)` if your bundles emit domain-specific blocks
+- `app/layout.tsx` — lift sessions into a provider for cross-route persistence

package/registry/families/orchestrator-with-ui-ts/files/app/agents/[id]/page.tsx

@@ -0,0 +1,124 @@
+'use client'
+
+import Link from 'next/link'
+import { notFound, useParams } from 'next/navigation'
+import { useEffect, useMemo, useState } from 'react'
+import { SandboxWorkbench } from '@tangle-network/sandbox-ui/workspace'
+import type { SandboxWorkbenchArtifact } from '@tangle-network/sandbox-ui/workspace'
+import { useSdkSession } from '@tangle-network/sandbox-ui/sdk-hooks'
+import { findAgent } from '../../../src/lib/agent-roster'
+import { makeArtifactStreamAdapter } from '../../../src/lib/blocks-to-artifacts'
+
+// === Session lifecycle =====================================================
+//
+// `useSdkSession()` is mounted INSIDE this route component. Next.js App
+// Router unmounts the component when the user navigates away (e.g. back to
+// /agents/<other> or /), so the in-memory session is dropped. Each visit to
+// /agents/[id] starts fresh.
+//
+// This is the right default for a scaffold:
+//   • zero coupling — no global session registry to debug
+//   • cheap memory — N agents idle in the sidebar consume nothing
+//   • obvious semantics — closing a tab clears the conversation
+//
+// If you need persistence across navigation, lift the session map into a
+// context provider in app/layout.tsx (one useSdkSession() per AgentEntry,
+// keyed by id) and read from it here. See README.md → 'Session lifecycle'.
+//
+// Server-side persistence (resume the same SDK conversation across page
+// reloads, browsers, devices) is a separate concern: hydrate the session via
+// `replaceHistory` from the sandbox-sdk's session-history endpoint on mount.
+
+export default function AgentChatPage() {
+  const params = useParams<{ id: string }>()
+  const agent = findAgent(params.id)
+
+  // App Router signals 404 via notFound(); call BEFORE any hooks that depend
+  // on `agent` to keep the hooks-order rule happy.
+  if (!agent) {
+    notFound()
+  }
+
+  const session = useSdkSession()
+  const [artifacts, setArtifacts] = useState<SandboxWorkbenchArtifact[]>([])
+  const [activeArtifactId, setActiveArtifactId] = useState<string | undefined>()
+
+  // One adapter per route mount — the closure preserves last-text/last-artifacts
+  // across re-renders so partial streams don't cause flicker.
+  const adapter = useMemo(() => makeArtifactStreamAdapter(), [])
+
+  // Re-feed the adapter whenever the active assistant message's text changes.
+  useEffect(() => {
+    const id = session.activeAssistantMessageId
+    if (!id) return
+    const parts = session.partMap[id] ?? []
+    const text = parts
+      .filter((part) => part.type === 'text')
+      .map((part) => (part.type === 'text' ? part.text : ''))
+      .join('')
+    const next = adapter.feed(text)
+    setArtifacts(next)
+    if (!activeArtifactId && next.length > 0) {
+      setActiveArtifactId(next[0].id)
+    }
+  }, [session.partMap, session.activeAssistantMessageId, adapter, activeArtifactId])
+
+  // TODO(operator): wire onSend to your sandbox transport. The agent's
+  // sandboxId lives on `agent.sandboxId` once provisioned (see
+  // lib/agent-roster.ts → 'Wiring sandboxId').
+  const handleSend = (text: string) => {
+    session.appendUserMessage({ content: text })
+    session.beginAssistantMessage()
+    session.applySdkEvent({
+      type: 'message.part.updated',
+      data: {
+        part: {
+          type: 'text',
+          text: `[stub] Wire app/agents/[id]/page.tsx → onSend to your sandbox transport. Received: ${text}`,
+        },
+      },
+    })
+    session.completeAssistantMessage()
+  }
+
+  return (
+    <div className='flex min-h-screen flex-col bg-[hsl(var(--background))] text-[hsl(var(--foreground))]'>
+      <header className='flex items-center justify-between border-b border-[hsl(var(--border))] px-6 py-4'>
+        <div className='flex items-center gap-3'>
+          <Link
+            href='/'
+            className='text-sm text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--foreground))]'
+          >
+            ← Back to fleet
+          </Link>
+          <span className='text-2xl' aria-hidden>
+            {agent.icon ?? '🤖'}
+          </span>
+          <div>
+            <h1 className='text-lg font-semibold'>{agent.displayName}</h1>
+            <p className='font-mono text-xs text-[hsl(var(--muted-foreground))]'>
+              {agent.family}
+              {agent.sandboxId ? ` · ${agent.sandboxId}` : ' · unprovisioned'}
+            </p>
+          </div>
+        </div>
+      </header>
+
+      <div className='flex-1'>
+        <SandboxWorkbench
+          title={agent.displayName}
+          subtitle={agent.description}
+          session={{
+            messages: session.messages,
+            partMap: session.partMap,
+            isStreaming: session.isStreaming,
+            onSend: handleSend,
+          }}
+          artifacts={artifacts}
+          activeArtifactId={activeArtifactId}
+          onArtifactChange={setActiveArtifactId}
+        />
+      </div>
+    </div>
+  )
+}

package/registry/families/orchestrator-with-ui-ts/files/app/globals.css

@@ -0,0 +1,38 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* sandbox-ui theme tokens — overrideable per app. The sandbox-ui dashboard
+ * components read these CSS custom properties; if you swap in your own design
+ * system, replace these values rather than rewriting the components. */
+:root {
+  --background: 0 0% 100%;
+  --foreground: 222 47% 11%;
+  --muted: 210 40% 96%;
+  --muted-foreground: 215 16% 47%;
+  --border: 214 32% 91%;
+  --primary: 222 47% 11%;
+  --primary-foreground: 210 40% 98%;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --background: 222 47% 6%;
+    --foreground: 210 40% 98%;
+    --muted: 217 33% 17%;
+    --muted-foreground: 215 20% 65%;
+    --border: 217 33% 17%;
+    --primary: 210 40% 98%;
+    --primary-foreground: 222 47% 11%;
+  }
+}
+
+html,
+body {
+  height: 100%;
+}
+
+body {
+  background: hsl(var(--background));
+  color: hsl(var(--foreground));
+}

package/registry/families/orchestrator-with-ui-ts/files/app/layout.tsx

@@ -0,0 +1,30 @@
+import type { Metadata, Viewport } from 'next'
+import type { ReactNode } from 'react'
+import './globals.css'
+
+export const metadata: Metadata = {
+  title: '{{appName}} — Agent Fleet',
+  description:
+    'Multi-agent dashboard for the {{appName}} fleet. Each agent runs in its own Tangle sandbox; this UI talks to N sandboxes in parallel.',
+}
+
+export const viewport: Viewport = {
+  width: 'device-width',
+  initialScale: 1,
+}
+
+// Root layout intentionally renders a thin shell. The DashboardLayout (rail
+// sidebar + center pane) lives inside app/page.tsx and app/agents/[id]/page.tsx
+// so each route can decide its own sidebar selection / breadcrumb without
+// fighting a layout-level prop. If you want the DashboardLayout to persist
+// across route transitions (and thereby keep per-agent useSdkSession state
+// alive while the user navigates between agents), lift it here and wrap the
+// children in a SessionProvider that owns one useSdkSession per roster entry.
+// See README.md → 'Session lifecycle' for the trade-off.
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang='en'>
+      <body>{children}</body>
+    </html>
+  )
+}

package/registry/families/orchestrator-with-ui-ts/files/app/page.tsx

@@ -0,0 +1,132 @@
+'use client'
+
+import Link from 'next/link'
+import {
+  BillingDashboard,
+  type BillingBalance,
+  type BillingSubscription,
+  type BillingUsage,
+  UsageChart,
+  type UsageDataPoint,
+} from '@tangle-network/sandbox-ui/dashboard'
+import { agentRoster } from '../src/lib/agent-roster'
+
+// TODO(operator): wire these placeholders to the real Tangle billing /
+// usage APIs. The shapes below match @tangle-network/sandbox-ui/dashboard's
+// expected props — just point at your tenant's data source.
+const placeholderBalance: BillingBalance = {
+  current: 124.5,
+  currency: 'USD',
+  lastUpdated: new Date().toISOString(),
+}
+
+const placeholderSubscription: BillingSubscription = {
+  plan: 'team',
+  status: 'active',
+  renewsAt: new Date(Date.now() + 14 * 24 * 60 * 60 * 1000).toISOString(),
+}
+
+const placeholderUsage: BillingUsage = {
+  period: 'month',
+  amount: 42.18,
+  currency: 'USD',
+  unit: 'compute-hours',
+  quantity: 31.4,
+}
+
+const placeholderUsageSeries: UsageDataPoint[] = Array.from({ length: 14 }).map(
+  (_, i) => ({
+    timestamp: new Date(Date.now() - (13 - i) * 24 * 60 * 60 * 1000).toISOString(),
+    value: Math.round((Math.sin(i / 2) + 1.5) * 10 * 10) / 10,
+  }),
+)
+
+export default function FleetDashboardPage() {
+  return (
+    <div className='flex min-h-screen w-full flex-col bg-[hsl(var(--background))] text-[hsl(var(--foreground))]'>
+      <header className='border-b border-[hsl(var(--border))] px-8 py-6'>
+        <h1 className='text-2xl font-semibold'>{'{{appName}}'}</h1>
+        <p className='text-sm text-[hsl(var(--muted-foreground))]'>
+          Agent fleet — {agentRoster.length} agent
+          {agentRoster.length === 1 ? '' : 's'} ready to dispatch.
+        </p>
+      </header>
+
+      <main className='grid flex-1 gap-8 p-8 lg:grid-cols-[2fr_1fr]'>
+        <section aria-labelledby='roster-heading'>
+          <h2
+            id='roster-heading'
+            className='mb-4 text-lg font-medium text-[hsl(var(--foreground))]'
+          >
+            Agents
+          </h2>
+          <ul className='grid gap-4 sm:grid-cols-2'>
+            {agentRoster.map((agent) => (
+              <li key={agent.id}>
+                <Link
+                  href={`/agents/${agent.id}`}
+                  className='flex h-full flex-col gap-2 rounded-lg border border-[hsl(var(--border))] p-4 transition hover:border-[hsl(var(--primary))]'
+                >
+                  <div className='flex items-center gap-3'>
+                    <span className='text-2xl' aria-hidden>
+                      {agent.icon ?? '🤖'}
+                    </span>
+                    <div className='flex flex-col'>
+                      <span className='font-medium'>{agent.displayName}</span>
+                      <span className='font-mono text-xs text-[hsl(var(--muted-foreground))]'>
+                        {agent.family}
+                      </span>
+                    </div>
+                  </div>
+                  <p className='text-sm text-[hsl(var(--muted-foreground))]'>
+                    {agent.description}
+                  </p>
+                  <div className='mt-auto flex items-center justify-between text-xs text-[hsl(var(--muted-foreground))]'>
+                    <span>
+                      {agent.sandboxId ? (
+                        <span className='inline-flex items-center gap-1'>
+                          <span
+                            className='h-2 w-2 rounded-full bg-emerald-500'
+                            aria-hidden
+                          />
+                          ready
+                        </span>
+                      ) : (
+                        <span className='inline-flex items-center gap-1'>
+                          <span
+                            className='h-2 w-2 rounded-full bg-amber-500'
+                            aria-hidden
+                          />
+                          unprovisioned
+                        </span>
+                      )}
+                    </span>
+                    {/* TODO(operator): replace with real last-run timestamp from your run log. */}
+                    <span>last run: —</span>
+                  </div>
+                </Link>
+              </li>
+            ))}
+          </ul>
+        </section>
+
+        <aside className='flex flex-col gap-6' aria-label='Account overview'>
+          <div>
+            <h2 className='mb-2 text-lg font-medium'>Billing</h2>
+            {/* TODO(operator): swap placeholders for real billing data. */}
+            <BillingDashboard
+              balance={placeholderBalance}
+              subscription={placeholderSubscription}
+              usage={placeholderUsage}
+            />
+          </div>
+          <div>
+            <h2 className='mb-2 text-lg font-medium'>Usage (14d)</h2>
+            {/* TODO(operator): swap placeholders for real usage series. */}
+            <UsageChart data={placeholderUsageSeries} unit='compute-hours' />
+          </div>
+        </aside>
+      </main>
+    </div>
+  )
+}

package/registry/families/orchestrator-with-ui-ts/files/next.config.mjs

@@ -0,0 +1,21 @@
+// next.config.mjs — orchestrator-with-ui-ts
+//
+// transpilePackages is required so Next can consume the ESM-only
+// @tangle-network/sandbox-ui + sandbox-sdk packages from node_modules without
+// the App Router complaining about untranspiled package exports.
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+  transpilePackages: [
+    '@tangle-network/sandbox-ui',
+    '@tangle-network/sandbox-sdk',
+  ],
+  experimental: {
+    serverActions: {
+      bodySizeLimit: '2mb',
+    },
+  },
+}
+
+export default nextConfig

package/registry/families/orchestrator-with-ui-ts/files/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev -p {{port}}",
+    "build": "next build",
+    "start": "next start -p {{port}}",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tangle-network/sandbox-ui": "^0.10.3",
+    "@tangle-network/sandbox": "^0.2.1",
+    "next": "^14.2.0",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.47",
+    "tailwindcss": "^3.4.13",
+    "typescript": "^5.9.0"
+  },
+  "overrides": {
+    "vite": "^5.4.10"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
+  }
+}

package/registry/families/orchestrator-with-ui-ts/files/postcss.config.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

package/registry/families/orchestrator-with-ui-ts/files/src/lib/agent-roster.ts

@@ -0,0 +1,86 @@
+// agent-roster.ts — single source of truth for the fleet.
+//
+// This module declares the static list of agents the dashboard renders. Each
+// entry describes ONE agent-runtime bundle that has been (or will be) deployed
+// into its own Tangle sandbox. The dashboard at app/page.tsx renders this list
+// as a grid of agent cards; app/agents/[id]/page.tsx looks up an entry by id
+// and mounts a SandboxWorkbench against that agent's sandbox.
+//
+// === Wiring sandboxId (operator's job) =====================================
+//
+// `sandboxId` is intentionally optional. At scaffold time we don't know which
+// sandbox each agent will run in — that's a per-deployment decision. Three
+// common ways to populate it:
+//
+//   1. Static config: hard-code the sandboxId after the operator provisions
+//      sandboxes by hand (e.g. via the Tangle dashboard or `sandbox` CLI).
+//
+//   2. Server-side bootstrap: replace `agentRoster` with a server component
+//      that calls the Tangle sandbox API on every request, listing the
+//      operator's sandboxes and matching them to roster entries by tag /
+//      label. Wrap this file's export in a Promise<AgentEntry[]> and adapt
+//      the consumers.
+//
+//   3. Per-agent on-demand: leave sandboxId undefined and lazily provision
+//      inside app/agents/[id]/page.tsx the first time the agent is opened.
+//      Cache the result in a server-side store (Redis, KV, D1) keyed by
+//      AgentEntry.id so subsequent visits reuse the same sandbox.
+//
+// The dashboard does NOT call the sandbox-sdk's provisioning API directly
+// from this module — that would couple build-time scaffolding to runtime
+// secrets. Keep secrets server-side; expose only the resolved sandboxId to
+// the client.
+
+export interface AgentEntry {
+  /** Unique within the app. Used as the route param for /agents/[id]. */
+  id: string
+  /**
+   * The starter-foundry agent-runtime family this agent was scaffolded from.
+   * Used for display + as a hint to the orchestrator about which prompt /
+   * tool surface the agent expects. Not a runtime dependency.
+   */
+  family: string
+  /** Human-readable name shown in the sidebar + agent card. */
+  displayName: string
+  /** One-sentence description shown on the agent card. */
+  description: string
+  /**
+   * Resolved Tangle sandbox id once the agent has been provisioned. Undefined
+   * means the agent hasn't been wired up yet — the UI should show a
+   * 'provision' affordance instead of attempting to connect.
+   */
+  sandboxId?: string
+  /** Emoji or icon identifier for the sidebar / card. */
+  icon?: string
+}
+
+export const agentRoster: AgentEntry[] = [
+  {
+    id: 'cmo-advisor',
+    family: 'agent-runtime-cmo-advisor-ts',
+    displayName: 'CMO Advisor',
+    description:
+      'Marketing strategist. Drafts campaign briefs, audience segments, and growth experiments grounded in your product context.',
+    icon: '📣',
+  },
+  {
+    id: 'recruiter',
+    family: 'agent-runtime-recruiter-ts',
+    displayName: 'Recruiter',
+    description:
+      'Sourcing + screening assistant. Builds role specs, screens candidate pipelines, and drafts outreach.',
+    icon: '🧭',
+  },
+  {
+    id: 'business-partner',
+    family: 'agent-runtime-business-partner-ts',
+    displayName: 'Business Partner',
+    description:
+      'Exec coach + thought partner. Pressure-tests strategy, walks through OKRs, and surfaces blind spots.',
+    icon: '🤝',
+  },
+]
+
+export function findAgent(id: string): AgentEntry | undefined {
+  return agentRoster.find((entry) => entry.id === id)
+}

package/registry/families/orchestrator-with-ui-ts/files/tailwind.config.cjs

@@ -0,0 +1,12 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    './app/**/*.{ts,tsx}',
+    './components/**/*.{ts,tsx}',
+    './lib/**/*.{ts,tsx}',
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}

package/registry/families/orchestrator-with-ui-ts/files/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "preserve",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "incremental": true,
+    "noEmit": true,
+    "allowJs": false,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./*"]
+    },
+    "plugins": [{ "name": "next" }]
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}