@jasonshimmy/vite-plugin-cer-app 0.23.1 → 0.24.0

package/src/types/config.ts

@@ -1,371 +0,0 @@
-import type { RouterConfig } from '@jasonshimmy/custom-elements-runtime/router'
-import type { IncomingMessage } from 'node:http'
-
-// ─── Observability hook context types ─────────────────────────────────────────
-
-/**
- * Context passed to the `onError` hook.
- * `type` indicates which layer the error originated from so reporters can
- * tag or route errors appropriately.
- */
-export interface ErrorHookContext {
-  /** The layer that threw the error. */
-  type: 'loader' | 'render' | 'middleware'
-  /** The request URL pathname (e.g. `/about`). */
-  path: string
-  /** The raw Node.js incoming request. */
-  req: IncomingMessage
-}
-
-/**
- * Context passed to the `onRequest` hook.
- * Fires at the start of every SSR request, before the route is matched
- * or the loader runs.
- */
-export interface RequestHookContext {
-  /** The request URL pathname (e.g. `/about`). */
-  path: string
-  /** HTTP method in upper-case (e.g. `'GET'`). */
-  method: string
-  /** The raw Node.js incoming request. */
-  req: IncomingMessage
-}
-
-/**
- * Context passed to the `onResponse` hook.
- * Fires after the response has been sent (both success and error paths).
- * Use this for latency tracking and request logging.
- */
-export interface ResponseHookContext {
-  /** The request URL pathname (e.g. `/about`). */
-  path: string
-  /** HTTP method in upper-case (e.g. `'GET'`). */
-  method: string
-  /** Final HTTP status code written to the response. */
-  statusCode: number
-  /** Request duration in milliseconds from the first byte received to `res.end()`. */
-  duration: number
-  /** The raw Node.js incoming request. */
-  req: IncomingMessage
-}
-
-// ─── OAuth / Auth types ───────────────────────────────────────────────────────
-
-/** Token payload returned by an OAuth provider after a successful authorization code exchange. */
-export interface OAuthTokens {
-  accessToken: string
-  refreshToken?: string
-  expiresIn?: number
-  tokenType: string
-}
-
-/** Configuration for a single OAuth 2.0 provider (Google, GitHub, Discord, or a custom provider). */
-export interface OAuthProviderConfig {
-  /** OAuth application client ID. */
-  clientId: string
-  /** OAuth application client secret. Never serialized into the client bundle. */
-  clientSecret: string
-  /** Override the default OAuth scopes for this provider. */
-  scope?: string[]
-  /** Override the provider's authorization endpoint URL (custom/self-hosted providers). */
-  authorizationUrl?: string
-  /** Override the provider's token exchange endpoint URL. */
-  tokenUrl?: string
-  /** Override the provider's user-info endpoint URL. */
-  userInfoUrl?: string
-  /**
-   * Transform the raw provider profile into the object stored in the auth session.
-   * Return any serializable object — it becomes `useAuth().user` on both server and client.
-   * If omitted the framework normalises the profile to `{ provider, id, name, email, avatar }`.
-   */
-  mapUser?: (profile: Record<string, unknown>, tokens: OAuthTokens) => Record<string, unknown>
-}
-
-/** Authentication configuration. Enables OAuth login flows and auto-generates `/api/auth/*` routes. */
-export interface AuthConfig {
-  /**
-   * OAuth provider configurations keyed by provider name.
-   * Built-in providers: `'google'`, `'github'`, `'discord'`.
-   * Custom providers must supply `authorizationUrl`, `tokenUrl`, and `userInfoUrl`.
-   */
-  providers?: {
-    google?: OAuthProviderConfig
-    github?: OAuthProviderConfig
-    discord?: OAuthProviderConfig
-    [key: string]: OAuthProviderConfig | undefined
-  }
-  /** Path to redirect to after a successful login. Defaults to `'/'`. */
-  redirectAfterLogin?: string
-  /** Path to redirect to after logout. Defaults to `'/'`. */
-  redirectAfterLogout?: string
-  /**
-   * Session cookie name used to store the authenticated user.
-   * Defaults to `'auth'`. Must not collide with other `useSession()` names.
-   */
-  sessionKey?: string
-}
-
-/** Internationalisation routing configuration. When set, locale-aware URL routes are generated and `useLocale()` is enabled. */
-export interface I18nConfig {
-  /**
-   * All supported locale codes. e.g. `['en', 'fr', 'de']`.
-   */
-  locales: string[]
-  /**
-   * The default locale. Used as the fallback when no locale is detected in the URL.
-   */
-  defaultLocale: string
-  /**
-   * URL strategy for locale routing.
-   * - `'prefix'`                — every locale (including default) gets a URL prefix: `/en/about`, `/fr/about`
-   * - `'prefix_except_default'` — default locale has no prefix (`/about`), others do (`/fr/about`). **Default.**
-   * - `'no_prefix'`             — locale is not reflected in the URL (read from cookie or header only)
-   */
-  strategy?: 'prefix' | 'prefix_except_default' | 'no_prefix'
-}
-
-/** Global Static Site Generation (SSG) configuration. Controls which routes are pre-rendered and at what concurrency. */
-export interface SsgConfig {
-  /**
-   * Routes to pre-render.
-   * - `'auto'` (default) — pre-render every static route discovered in `app/pages/`.
-   * - `string[]` — explicit list of paths (e.g. `['/about', '/contact']`).
-   */
-  routes?: 'auto' | string[]
-  /** Maximum number of pages rendered in parallel. Defaults to `1`. Increase for faster SSG builds at the cost of higher memory usage. */
-  concurrency?: number
-  /** When `true`, unenumerated routes fall back to SSR at runtime instead of returning 404. */
-  fallback?: boolean
-}
-
-/** JIT (Just-In-Time) CSS configuration for shadow-DOM style injection. */
-export interface JitCssConfig {
-  /** Additional glob patterns for content files scanned by the JIT CSS engine. */
-  content?: string[]
-  /** Enable the extended color palette. Defaults to `false`. */
-  extendedColors?: boolean
-  /**
-   * Project-specific color families registered in the JIT CSS engine at both
-   * build time and runtime. Each key is a color family name (e.g. `brand`);
-   * its value is a map of scale steps to CSS color values.
-   *
-   * Color family names must be a single lowercase word (no hyphens). Shades
-   * can be any string key — numeric steps (`'500'`) or semantic names
-   * (`'DEFAULT'`, `'on'`, `'container'`). When no shade is specified in a
-   * utility class (e.g. `bg-brand`), the `DEFAULT` shade is used.
-   *
-   * @example
-   * ```ts
-   * customColors: {
-   *   brand: { '100': '#ede9fe', '500': '#7c3aed', '900': '#4c1d95' },
-   *   surface: { DEFAULT: 'var(--md-sys-color-surface)' },
-   * }
-   * ```
-   */
-  customColors?: Record<string, Record<string, string>>
-}
-
-/** Fine-grained control over which auto-import categories are injected into page/layout/component files. All categories are enabled by default. */
-export interface AutoImportsConfig {
-  /** Auto-import components defined in `app/components/`. Defaults to `true`. */
-  components?: boolean
-  /** Auto-import framework composables (`useHead`, `useState`, etc.). Defaults to `true`. */
-  composables?: boolean
-  /** Auto-import template directives (`when`, `each`, `bind`). Defaults to `true`. */
-  directives?: boolean
-  /** Auto-import runtime primitives (`component`, `html`, `ref`, etc.). Defaults to `true`. */
-  runtime?: boolean
-}
-
-/** Arbitrary public runtime values serialized into the virtual module at build time. Available on both server and client via `useRuntimeConfig().public`. */
-export interface RuntimePublicConfig {
-  [key: string]: unknown
-}
-
-/** Server-only secrets resolved from `process.env` at startup. Never serialized into the client bundle. Available via `useRuntimeConfig().private` in loaders and server middleware only. */
-export interface RuntimePrivateConfig {
-  /**
-   * HMAC-SHA-256 signing secret(s) for `useSession()`.
-   *
-   * Pass a single string for simple usage, or an **array** to support secret
-   * rotation without logging everyone out:
-   * - The **first** element is the active key — new sessions are signed with it.
-   * - Subsequent elements are accepted for **verification only** — old sessions
-   *   signed with them continue to work until they expire.
-   *
-   * ```ts
-   * // cer.config.ts
-   * runtimeConfig: {
-   *   private: {
-   *     sessionSecret: [
-   *       process.env.SESSION_SECRET_NEW!,  // signs new sessions
-   *       process.env.SESSION_SECRET_OLD!,  // still accepted during rotation
-   *     ],
-   *   },
-   * }
-   * ```
-   */
-  sessionSecret?: string | string[]
-  [key: string]: string | string[] | undefined
-}
-
-/** Runtime configuration split into `public` (client + server) and `private` (server-only) sections. */
-export interface RuntimeConfig {
-  /**
-   * Public runtime config — available on both server and client via
-   * `useRuntimeConfig().public`. Values are serialized into the virtual module
-   * at build time, so only use static/env-var values here.
-   *
-   * @example
-   * runtimeConfig: {
-   *   public: {
-   *     apiBase: process.env.VITE_API_BASE ?? 'https://api.example.com',
-   *   }
-   * }
-   */
-  public?: RuntimePublicConfig
-  /**
-   * Server-only secrets — never serialized into the client bundle.
-   * Declare keys with empty-string defaults here; at server startup each key
-   * is resolved from `process.env[KEY]` (case-insensitive, ALL_CAPS preferred).
-   *
-   * @example
-   * runtimeConfig: {
-   *   private: { dbUrl: '', secretKey: '' },
-   * }
-   */
-  private?: RuntimePrivateConfig
-}
-
-/** Root configuration object for `cer.config.ts`. Pass to `defineConfig()` for type-safe configuration. */
-export interface CerAppConfig {
-  mode?: 'spa' | 'ssr' | 'ssg'
-  srcDir?: string // defaults to 'app'
-  /** File-based content layer configuration. Reads from `content/` at the project root by default. */
-  content?: import('./content.js').CerContentConfig
-  /**
-   * Internationalisation (i18n) routing configuration.
-   * When set, the framework generates locale-aware URL routes and enables `useLocale()`.
-   *
-   * @example
-   * ```ts
-   * i18n: {
-   *   locales: ['en', 'fr', 'de'],
-   *   defaultLocale: 'en',
-   *   strategy: 'prefix_except_default',
-   * }
-   * ```
-   */
-  i18n?: I18nConfig
-  ssg?: SsgConfig
-  router?: Pick<RouterConfig, 'base' | 'scrollToFragment'>
-  jitCss?: JitCssConfig
-  autoImports?: AutoImportsConfig
-  port?: number
-  /**
-   * Runtime configuration accessible via `useRuntimeConfig()`.
-   * Only `public` values are exposed to the client; keep secrets
-   * out of `public`.
-   */
-  runtimeConfig?: RuntimeConfig
-  /**
-   * Deployment platform adapter.
-   * When set, `cer-app build` automatically runs the adapter after the build
-   * completes, producing the platform-specific output alongside `dist/`.
-   *
-   * Built-in string values:
-   * - `'vercel'`     — Vercel Build Output API v3 (`.vercel/output/`)
-   * - `'netlify'`    — Netlify Functions v2 + `netlify.toml`
-   * - `'cloudflare'` — Cloudflare Pages `_worker.js` + `wrangler.toml`
-   *
-   * Pass a function for a **custom adapter** (Railway, Fly.io, bare Node, Docker, …):
-   * ```ts
-   * adapter: async (root) => {
-   *   // root is the absolute project root directory
-   *   // dist/client/ and dist/server/ are already present after the build
-   *   await myPlatformDeploy(root)
-   * }
-   * ```
-   *
-   * You can also run the built-in adapters independently with `cer-app adapt --platform <name>`.
-   */
-  adapter?: 'vercel' | 'netlify' | 'cloudflare' | ((root: string) => Promise<void>)
-  /**
-   * Authentication configuration.
-   * Enables OAuth login flows via `useAuth()` and auto-generates
-   * `/api/auth/:provider`, `/api/auth/callback/:provider`, and `/api/auth/logout` routes.
-   *
-   * @example
-   * ```ts
-   * import { defineConfig, defineOAuthProvider } from '@jasonshimmy/vite-plugin-cer-app'
-   *
-   * export default defineConfig({
-   *   auth: {
-   *     providers: {
-   *       github: defineOAuthProvider({
-   *         clientId: process.env.GITHUB_CLIENT_ID!,
-   *         clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-   *       }),
-   *     },
-   *   },
-   * })
-   * ```
-   */
-  auth?: AuthConfig
-  /**
-   * Called when an error is caught by the framework's SSR error boundaries
-   * (loader throws, render crash, or server middleware throws). Use this to
-   * forward errors to Sentry, Datadog, or any other error-reporting service.
-   *
-   * Errors in this hook are silently swallowed so they cannot crash the request handler.
-   *
-   * @example
-   * ```ts
-   * import * as Sentry from '@sentry/node'
-   * export default defineConfig({
-   *   onError(err, ctx) {
-   *     Sentry.captureException(err, { tags: { type: ctx.type, path: ctx.path } })
-   *   },
-   * })
-   * ```
-   */
-  onError?: (err: unknown, ctx: ErrorHookContext) => void | Promise<void>
-  /**
-   * Called at the start of every SSR request, before route matching and the loader.
-   * Use this for request logging or to initialise per-request APM transactions.
-   *
-   * Errors in this hook are silently swallowed.
-   */
-  onRequest?: (ctx: RequestHookContext) => void | Promise<void>
-  /**
-   * Called after every SSR response is sent (both success and error paths).
-   * `ctx.duration` contains the elapsed milliseconds from first byte to `res.end()`.
-   * Use this for latency tracking and access logging.
-   *
-   * Errors in this hook are silently swallowed.
-   */
-  onResponse?: (ctx: ResponseHookContext) => void | Promise<void>
-}
-
-/**
- * Define the framework configuration with full TypeScript intellisense.
- * This is a pass-through helper — it returns `config` unchanged and exists
- * solely to provide type checking and IDE autocompletion in `cer.config.ts`.
- *
- * @example
- * ```ts
- * // cer.config.ts
- * import { defineConfig } from '@jasonshimmy/vite-plugin-cer-app'
- *
- * export default defineConfig({
- *   mode: 'ssr',
- *   runtimeConfig: {
- *     public: { apiBase: 'https://api.example.com' },
- *     private: { dbUrl: '' },
- *   },
- * })
- * ```
- */
-export function defineConfig(config: CerAppConfig): CerAppConfig {
-  return config
-}

package/src/types/content.ts

@@ -1,66 +0,0 @@
-/** Heading extracted from Markdown during parsing. The `id` is slugified from the heading text and added as an HTML `id` attribute. */
-export interface ContentHeading {
-  depth: 1 | 2 | 3 | 4 | 5 | 6
-  /** Slugified heading text — matches the `id` attribute in the rendered body HTML. */
-  id: string
-  /** Plain text of the heading. */
-  text: string
-}
-
-/**
- * Lean per-document metadata — returned by `.find()` and `.count()`.
- * Kept small deliberately: no `body`, no `toc`, no `excerpt`.
- * Use `description` for listing previews; set it in frontmatter.
- */
-export interface ContentMeta {
-  /** URL path (e.g. `"/blog/hello"`). */
-  _path: string
-  /** Source file type. */
-  _type: 'markdown' | 'json'
-  title?: string
-  /** Use for listing previews — included in search index. */
-  description?: string
-  date?: string
-  draft?: boolean
-  /** Any other frontmatter key. */
-  [key: string]: unknown
-}
-
-/**
- * Full document — returned by `.first()`.
- * Superset of `ContentMeta`; includes `body`, `toc`, `_file`, and optional `excerpt`.
- */
-export interface ContentItem extends ContentMeta {
-  /** Relative path from `content/` at the project root (e.g. `"blog/hello.md"`). */
-  _file: string
-  /** Rendered HTML (Markdown) or the raw file contents (JSON files). */
-  body: string
-  /** Extracted headings. Empty array for JSON files. */
-  toc: ContentHeading[]
-  /** HTML content before `<!-- more -->`. Absent when the marker is not present. */
-  excerpt?: string
-}
-
-/**
- * Search result item returned by `useContentSearch()`.
- * Contains only the MiniSearch stored fields: `_path`, `title`, `description`.
- */
-export interface ContentSearchResult {
-  _path: string
-  title: string
-  description?: string
-}
-
-/** Content layer configuration. Controls the directory and draft behaviour. */
-export interface CerContentConfig {
-  /**
-   * Content directory relative to the project root. Defaults to `'content'`,
-   * which resolves to `{root}/content/` — at the same level as `app/`, `server/`, and `public/`.
-   */
-  dir?: string
-  /**
-   * When `true`, draft items (`draft: true` in frontmatter) are included in
-   * production builds. Defaults to `false`.
-   */
-  drafts?: boolean
-}

package/src/types/index.ts

@@ -1,7 +0,0 @@
-export type { CerAppConfig, SsgConfig, JitCssConfig, AutoImportsConfig, RuntimeConfig, RuntimePublicConfig, RuntimePrivateConfig, I18nConfig, ErrorHookContext, RequestHookContext, ResponseHookContext } from './config.js'
-export { defineConfig } from './config.js'
-export type { HydrateStrategy, SsgPathsContext, PageSsgConfig, PageMeta, PageLoaderContext, PageLoader } from './page.js'
-export type { ApiRequest, ApiResponse, ApiHandler, ApiContext } from './api.js'
-export type { AppContext, AppPlugin } from './plugin.js'
-export type { MiddlewareFn, GuardResult, ServerMiddleware } from './middleware.js'
-export type { LocaleComposable } from '../runtime/composables/use-locale.js'

package/src/types/middleware.ts

@@ -1,63 +0,0 @@
-import type { RouteState } from '@jasonshimmy/custom-elements-runtime/router'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-
-/**
- * Return value from a route middleware function:
- * - `true`   — allow navigation
- * - `false`  — block navigation
- * - `string` — redirect to that path
- */
-export type GuardResult = boolean | string | Promise<boolean | string>
-
-/**
- * Route middleware function.
- *
- * Return `true`/`false`/a redirect path to guard navigation, **or** call
- * `next()` to explicitly pass control to the next middleware in the chain
- * (useful for wrapper middleware that needs to run code before AND after
- * downstream middleware completes).
- *
- * @example — guard
- * ```ts
- * export default defineMiddleware((to, from) => {
- *   if (!isLoggedIn()) return '/login'
- *   return true
- * })
- * ```
- *
- * @example — wrapper with next()
- * ```ts
- * export default defineMiddleware(async (to, from, next) => {
- *   console.time('nav')
- *   await next()
- *   console.timeEnd('nav')
- * })
- * ```
- */
-export type MiddlewareFn = (
-  to: RouteState,
-  from: RouteState | null,
-  next: () => Promise<void>,
-) => GuardResult | void
-
-/**
- * Server middleware function. Receives the raw Node.js `req`/`res` pair and a `next`
- * callback. Call `next()` to pass control to the next middleware in the chain,
- * or call `next(err)` to signal an error (sets the response status from `err.status`,
- * defaulting to 500).
- *
- * Defined with `defineServerMiddleware()` and placed in `app/middleware/`.
- *
- * @example
- * ```ts
- * export default defineServerMiddleware((req, res, next) => {
- *   res.setHeader('X-Request-Id', crypto.randomUUID())
- *   next()
- * })
- * ```
- */
-export type ServerMiddleware = (
-  req: IncomingMessage,
-  res: ServerResponse,
-  next: (err?: unknown) => void,
-) => void | Promise<void>

package/src/types/page.ts

@@ -1,117 +0,0 @@
-import type { IncomingMessage } from 'node:http'
-
-/**
- * Controls when the client-side JS activates a pre-rendered page component.
- *
- * - `'load'`    — activate immediately on page load (default).
- * - `'idle'`    — defer until `requestIdleCallback` fires (browser idle time).
- * - `'visible'` — defer until `cer-layout-view` enters the viewport (IntersectionObserver).
- * - `'none'`    — never activate; SSR HTML is served as static markup with no JS.
- */
-export type HydrateStrategy = 'load' | 'idle' | 'visible' | 'none'
-
-/** Context object passed to a page's `ssg.paths()` function. Contains resolved route params for one path variant. */
-export interface SsgPathsContext {
-  params: Record<string, string>
-}
-
-/** Per-page SSG / ISR configuration. Export as `export const meta = { ssg: { ... } }` from any page file. */
-export interface PageSsgConfig {
-  /**
-   * Factory that returns the set of param combinations to pre-render for dynamic routes.
-   * Required for dynamic routes (e.g. `/posts/[slug]`) — without it the route is skipped
-   * during the static build.
-   *
-   * @example
-   * ```ts
-   * export const meta = {
-   *   ssg: {
-   *     paths: async () => {
-   *       const slugs = await fetchAllSlugs()
-   *       return slugs.map(slug => ({ params: { slug } }))
-   *     },
-   *   },
-   * }
-   * ```
-   */
-  paths?: () => Promise<SsgPathsContext[]> | SsgPathsContext[]
-  /**
-   * Seconds before a cached SSR response is stale and should be re-rendered.
-   * Enables Incremental Static Regeneration (ISR) in the preview server and
-   * any production adapter that reads `meta.ssg.revalidate`.
-   *
-   * @example export const meta = { ssg: { revalidate: 60 } }
-   */
-  revalidate?: number
-}
-
-/**
- * Per-page metadata. Export as `export const meta = { ... }` from any page file.
- * Values are read at build time and embedded into the route manifest.
- */
-export interface PageMeta {
-  /** Layout component to wrap this page. Must match a file in `app/layouts/`. Defaults to `'default'`. */
-  layout?: string
-  /** Named middleware files from `app/middleware/` to run before this route activates. */
-  middleware?: string[]
-  hydrate?: HydrateStrategy
-  ssg?: PageSsgConfig
-  /**
-   * CSS transition name applied to the page during route changes.
-   * Set to `true` to use the default 'page' transition name.
-   * The framework adds/removes `[data-transition="<name>"]` on the root element
-   * so you can target it with CSS animations.
-   *
-   * @example export const meta = { transition: 'fade' }
-   */
-  transition?: string | boolean
-  /**
-   * Per-route rendering strategy. Overrides the global `mode` for this route.
-   *
-   * - `'server'` — always render server-side, never pre-render. In SSG mode
-   *   the route is skipped during the static build.
-   * - `'static'` — always serve pre-rendered static HTML. In the SSR preview
-   *   server the pre-rendered file is served from disk; falls back to SSR if
-   *   not found.
-   * - `'spa'`    — client-only. In SSR mode the server returns the SPA shell
-   *   (index.html) without rendering. In SSG mode the route is skipped.
-   *
-   * @example export const meta = { render: 'server' }
-   */
-  render?: 'static' | 'server' | 'spa'
-}
-
-/**
- * Context object passed to a page's `loader` function.
- * Available on the server only — the loader runs before the page component renders.
- */
-export interface PageLoaderContext<P extends Record<string, string> = Record<string, string>> {
-  params: P
-  query: Record<string, string>
-  /** Present during SSR/SSG server render. Absent (`undefined`) during client-side navigation. */
-  req?: IncomingMessage
-}
-
-/**
- * Server-side data loader for a page. Export as `export const loader` (or `export async function loader`)
- * from any page file. The returned object is:
- * - Made available via `usePageData()` inside the page component.
- * - Primitive values are also forwarded as element attributes so `useProps()` works.
- * - Serialized into `window.__CER_DATA__` for client-side hydration.
- *
- * Throwing an error (with an optional `.status` property) renders the page's error component
- * and sets the HTTP response status code.
- *
- * @example
- * ```ts
- * export const loader: PageLoader<{ slug: string }, { post: Post }> = async ({ params }) => {
- *   const post = await fetchPost(params.slug)
- *   if (!post) throw Object.assign(new Error('Not found'), { status: 404 })
- *   return { post }
- * }
- * ```
- */
-export type PageLoader<
-  P extends Record<string, string> = Record<string, string>,
-  D = Record<string, unknown>,
-> = (ctx: PageLoaderContext<P>) => Promise<D> | D

package/src/types/plugin.ts

@@ -1,34 +0,0 @@
-import type { Router } from '@jasonshimmy/custom-elements-runtime/router'
-import type { CerAppConfig } from './config.js'
-
-/**
- * Application context passed to each plugin's `setup()` function.
- * Use it to provide values to the component tree, access the router,
- * or read the resolved config.
- */
-export interface AppContext {
-  provide(key: PropertyKey, value: unknown): void
-  router: Router
-  config: CerAppConfig
-}
-
-/**
- * A framework plugin. Plugins run once at app startup (both server and client) before
- * the first route renders. Use them for global setup: registering provide/inject values,
- * subscribing to router events, or initialising third-party libraries.
- *
- * @example
- * ```ts
- * // app/plugins/analytics.ts
- * export default {
- *   name: 'analytics',
- *   async setup({ router }) {
- *     router.subscribe(({ path }) => trackPageView(path))
- *   },
- * } satisfies AppPlugin
- * ```
- */
-export interface AppPlugin {
-  name: string
-  setup(app: AppContext): void | Promise<void>
-}

package/tsconfig.build.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "exclude": ["node_modules", "dist", "src/cli/create/templates", "src/__tests__"]
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022", "DOM"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "src/cli/create/templates"]
-}