@softize/opus 8.6.6

package/src/vite/design.ts

@@ -0,0 +1,652 @@
+/**
+ * opusDesign() — plugin vite que sobe o runtime Opus DENTRO do dev server e
+ * serve `/api` in-process no preview de design.
+ *
+ * Por quê: o preview de design precisa ser AUTOSSUFICIENTE e isolado de prod.
+ * Antes, o dev server proxeava `/api` pra um backend real — o que vaza escrita
+ * pra prod e exige infra de pé pra desenhar tela. Com o plugin, `vite --mode
+ * design` monta o runtime (driver `nodeServer`) no próprio dev server: os
+ * `mockHandler` dos contratos respondem (`OPUS_MODE=design`), qualquer proxy
+ * configurado é DESLIGADO (prefixo ex-proxy sem cobertura responde 503 em
+ * envelope, nunca vaza), e o Maestro sonda `GET /__opus/design` pra saber que
+ * o preview está montado.
+ *
+ * Invariante: o runtime de design é request/response — reactions e schedules
+ * dos entries são IGNORADOS (não registrados), senão o `start()` exige
+ * eventbus/scheduler adapters que o design não tem por que montar.
+ *
+ * Uso (vite.config.ts do app):
+ *   import { opusDesign } from '@softize/opus/vite'
+ *   export default defineConfig({ plugins: [react(), opusDesign()] })
+ *   // vite --mode design
+ */
+
+import { readdirSync, readFileSync } from 'node:fs'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import path from 'node:path'
+import type { Plugin, ViteDevServer } from 'vite'
+import {
+  createRuntime,
+  error,
+  flattenDomain,
+  isDomainConfig,
+  isReaction,
+  isSchedule,
+  type ActionDef,
+  type AuthAdapter,
+  type ErrorInput,
+  type LoaderResolver,
+  type Runtime,
+  type RuntimeSetup,
+  type User,
+} from '../core/index.ts'
+import { mittEvents } from '../events/drivers/mitt.ts'
+import { nodeServer, type NodeServerHandle } from '../server/drivers/node.ts'
+import { serializeResult } from '../server/index.ts'
+// Import relativo de propósito: `memStorage` é harness de teste, não superfície
+// pública de runtime — o plugin o reusa sem promover export novo.
+import { memStorage } from '../testing/index.ts'
+
+// =============================================================================
+// Options
+// =============================================================================
+
+export type DesignStubHandler = (
+  req: IncomingMessage,
+  res: ServerResponse,
+) => void | Promise<void>
+
+export interface OpusDesignOptions {
+  /**
+   * Entry(s) com os registráveis do design. Default './opus.config.ts'.
+   *
+   * Entry ESTÁTICO: módulo que default-exporta `{ domains: DomainConfig[] }`
+   * (shape do opus.config) OU um array de DomainConfig/ActionDef/contratos.
+   *
+   * Entry GLOB (contém `*`, ex.: 'src/domains/*\/contract.ts'): expandido a
+   * CADA rebuild — domínio novo entra no ar ao salvar o arquivo, sem editar
+   * entry nenhum. Dos módulos casados entram os exports (default e named) com
+   * shape de registrável; schemas/helpers exportados junto ficam de fora.
+   * Pode misturar estáticos e globs no array.
+   */
+  entry?: string | string[]
+
+  /** Prefixo do path. Default '/api'. */
+  apiPrefix?: string
+
+  /**
+   * Sessão fixa do preview. Default `{ id: 'design' }` — `execute()` exige
+   * user pra action não-public. `null` explícito simula anônimo.
+   */
+  user?: User | null
+
+  /** Tenant da sessão de design. Default null. */
+  tenantId?: string | null
+
+  /** Resolvers da DSL `loads` — domínio bound com `loads` falha ANTES do mock sem resolver. */
+  loaders?: Record<string, LoaderResolver>
+
+  /**
+   * Handlers raw por prefixo (podem streamar SSE). Mais-específico vence:
+   * um stub em '/api/auth' sombreia o '/api' do runtime.
+   */
+  stubs?: Record<string, DesignStubHandler>
+
+  /**
+   * Monta o /api também no dev NORMAL (handler real, sem OPUS_MODE).
+   * Default false — devBackend puro não é design (sem sonda, proxy intacto).
+   */
+  devBackend?: boolean
+
+  /** Overrides do setup do runtime de design (adapters extras etc). */
+  runtime?: Partial<RuntimeSetup>
+}
+
+// =============================================================================
+// designAuth
+// =============================================================================
+
+/**
+ * AuthAdapter de design: ignora o request e devolve a sessão fixa do preview,
+ * com `can` liberado — autorização de verdade é preocupação do backend real.
+ */
+export function designAuth(
+  opts: { user?: User | null; tenantId?: string | null } = {},
+): AuthAdapter {
+  const user = opts.user === undefined ? { id: 'design' } : opts.user
+  const tenantId = opts.tenantId ?? null
+  return {
+    name: 'design',
+    kind: 'auth',
+    resolveContext: async () => ({ user, tenantId, can: () => true }),
+  }
+}
+
+// =============================================================================
+// Plugin
+// =============================================================================
+
+const PROBE_PATH = '/__opus/design'
+
+// Paths default que o mountEndpoints do driver monta — o middleware precisa
+// deixá-los chegar no handler (moram fora do apiPrefix).
+const RUNTIME_ENDPOINT_PATHS = new Set(['/health', '/ready', '/openapi.json'])
+
+interface DesignState {
+  handle: NodeServerHandle
+  runtime: Runtime
+  actions: ActionDef[]
+}
+
+export function opusDesign(options: OpusDesignOptions = {}): Plugin {
+  const apiPrefix = options.apiPrefix ?? '/api'
+  const entries = Array.isArray(options.entry)
+    ? options.entry
+    : [options.entry ?? './opus.config.ts']
+  const devBackend = options.devBackend === true
+  // Mais-específico primeiro: prefixo mais longo vence.
+  const stubEntries = Object.entries(options.stubs ?? {}).sort(
+    (a, b) => b[0].length - a[0].length,
+  )
+  const opusVersion = readOpusVersion()
+
+  let exProxyPrefixes: string[] = []
+  let current: Promise<DesignState> | undefined
+  let stale = false
+
+  return {
+    name: 'opus-design',
+
+    apply(_config, env) {
+      return env.command === 'serve' && (env.mode === 'design' || devBackend)
+    },
+
+    config(config, env) {
+      // O pacote embarca TS source: externalizado no SSR, o node recusa TS sob
+      // node_modules — e o entry importa @softize/opus. noExternal faz o vite
+      // transformar o pacote no ssrLoadModule (vale pro dev normal com devBackend).
+      const ssr = (config.ssr ??= {})
+      if (ssr.noExternal !== true) {
+        const prev =
+          ssr.noExternal === undefined
+            ? []
+            : Array.isArray(ssr.noExternal)
+              ? ssr.noExternal
+              : [ssr.noExternal]
+        ssr.noExternal = [...prev, '@softize/opus']
+      }
+
+      if (env.mode !== 'design') return
+      // 1) Guarda os prefixos que iam pra proxy — sem cobertura viram 503 explícito.
+      exProxyPrefixes = Object.keys(config.server?.proxy ?? {})
+      // 2) Mata o proxy: fecha o vazamento preview→prod pra QUALQUER prefixo.
+      if (config.server?.proxy !== undefined) config.server.proxy = undefined
+      // 3) O execute() roteia handler×mockHandler lendo OPUS_MODE (isOpusDesignMode);
+      //    com o runtime local, o preview fica autossuficiente.
+      process.env.OPUS_MODE = 'design'
+    },
+
+    configureServer(server) {
+      const isDesign = server.config.mode === 'design'
+      const logger = server.config.logger
+      // Um rebuild-por-404 por ciclo de staleness (rearma quando o watcher marca
+      // stale de novo) — cura o "domínio novo dá 404" sem virar rebuild-storm.
+      let unknownRetryDone = false
+
+      const boot = async (): Promise<DesignState> => {
+        const registrables: unknown[] = []
+        for (const entry of entries) {
+          if (isGlobPattern(entry)) {
+            registrables.push(...(await loadGlobEntry(server, entry)))
+          } else {
+            registrables.push(...(await loadEntry(server, entry)))
+          }
+        }
+        const { actions, dropped } = collectActions(registrables)
+
+        const handle = nodeServer({ apiPrefix })
+        const runtime = createRuntime({
+          server: handle.adapter,
+          auth: designAuth({ user: options.user, tenantId: options.tenantId }),
+          eventBus: mittEvents(),
+          storage: memStorage(),
+          // SEM `data` de propósito: design não toca ctx.db — handler real sem
+          // mock falhando é o sinal certo de que falta mockar.
+          ...options.runtime,
+          config: { env: 'development', dev: true, ...options.runtime?.config },
+        })
+        if (options.loaders !== undefined) runtime.registerLoaders(options.loaders)
+        runtime.register(actions)
+
+        if (dropped > 0) {
+          logger.info(
+            `[opus-design] ${dropped} reaction(s)/schedule(s) ignorada(s) — o runtime de design é request/response.`,
+          )
+        }
+        if (isDesign) {
+          for (const action of actions) {
+            if (action.mockHandler === undefined) {
+              logger.warn(
+                `[opus-design] Action "${action.name}" sem mockHandler — em design cai no handler real e pode falhar sem adapters.`,
+              )
+            }
+          }
+        }
+
+        await runtime.start()
+        handle.adapter.mountEndpoints({ health: true, ready: true, openapi: true })
+        return { handle, runtime, actions }
+      }
+
+      // Promise-mutex: requests em voo aguardam o MESMO boot; rebuild (stale)
+      // descarta o runtime anterior antes de reconstruir — register/start não
+      // são re-entrantes.
+      const ensureBoot = (): Promise<DesignState> => {
+        if (current !== undefined && !stale) return current
+        stale = false
+        const previous = current
+        current = (async () => {
+          if (previous !== undefined) {
+            const old = await previous.catch(() => undefined)
+            if (old !== undefined) await old.runtime.dispose().catch(() => undefined)
+          }
+          try {
+            return await boot()
+          } catch (err) {
+            // Falha fica retriable: a próxima request tenta reconstruir.
+            stale = true
+            logger.error(`[opus-design] Boot do runtime de design falhou: ${String(err)}`)
+            throw err
+          }
+        })()
+        current.catch(() => undefined)
+        return current
+      }
+
+      // Boot eager: o custo de carregar o entry acontece no subir do server,
+      // não na primeira request.
+      void ensureBoot().catch(() => undefined)
+
+      // HMR — dois critérios; a próxima request reconstrói do zero (lazy):
+      //   change: arquivo com módulo no graph (ou o próprio entry) invalida;
+      //   add/unlink: QUALQUER arquivo sob o root (fora node_modules/.git) —
+      //   arquivo novo nunca importado não está no graph, e é exatamente ele
+      //   que um entry glob precisa enxergar. Over-invalidation é barata.
+      const entryPaths = new Set(
+        entries
+          .filter((entry) => !isGlobPattern(entry))
+          .map((entry) => path.resolve(server.config.root, entry)),
+      )
+      // Specs dos entries glob. O watcher do vite só cobre o root, mas um glob
+      // pode apontar pra FORA dele (ex.: '../../services/*/contract.ts', caso GB):
+      // mandamos o chokidar observar o PREFIXO ESTÁTICO de cada glob — o mesmo que
+      // o expandGlob anda, nunca o mundo — pra change/unlink lá também invalidar.
+      const globSpecs = entries
+        .filter(isGlobPattern)
+        .map((pattern) => globSpec(server.config.root, pattern))
+      for (const { prefixDir } of globSpecs) server.watcher.add(prefixDir)
+      const matchesGlob = (file: string): boolean => {
+        const rel = path.relative(server.config.root, file).split(path.sep).join('/')
+        return globSpecs.some((spec) => spec.re.test(rel))
+      }
+      const markStale = (): void => {
+        if (current === undefined) return
+        stale = true
+        unknownRetryDone = false
+      }
+      const onChange = (file: string): void => {
+        const mods = server.moduleGraph.getModulesByFile(file)
+        const known = (mods !== undefined && mods.size > 0) || entryPaths.has(file)
+        // Um mock casando um glob pra fora do root pode não estar no module graph —
+        // o match do glob é o sinal (editar o mock invalida o runtime de design).
+        if (!known && !matchesGlob(file)) return
+        markStale()
+      }
+      const onAddOrUnlink = (file: string): void => {
+        // Casou um glob (in ou out do root): invalida — unlink de contrato some do
+        // rebuild seguinte (sem action fantasma); add entra. Precede a checagem de
+        // root, que rejeita `../` — senão a remoção lá fora nunca invalidaria.
+        if (matchesGlob(file)) {
+          markStale()
+          return
+        }
+        const rel = path.relative(server.config.root, file)
+        if (rel.startsWith('..') || path.isAbsolute(rel)) return
+        const segments = rel.split(path.sep)
+        if (segments.includes('node_modules') || segments.includes('.git')) return
+        markStale()
+      }
+      server.watcher.on('change', onChange)
+      server.watcher.on('add', onAddOrUnlink)
+      server.watcher.on('unlink', onAddOrUnlink)
+
+      const respondProbe = async (res: ServerResponse): Promise<void> => {
+        const payload: Record<string, unknown> = {
+          design: true,
+          opus: opusVersion,
+          stubs: stubEntries.map(([prefix]) => ({ prefix })),
+        }
+        try {
+          const state = await ensureBoot()
+          const unmocked = state.actions.filter((a) => a.mockHandler === undefined)
+          payload.runtime = {
+            prefix: apiPrefix,
+            actions: state.actions.length,
+            mocked: state.actions.length - unmocked.length,
+            unmocked: unmocked.map((a) => a.name),
+          }
+        } catch (err) {
+          payload.error = String(err)
+        }
+        res.statusCode = 200
+        res.setHeader('content-type', 'application/json; charset=utf-8')
+        res.setHeader('cache-control', 'no-store')
+        res.end(JSON.stringify(payload))
+      }
+
+      // Registrado DIRETO no body do hook: no vite 5/6 esses middlewares rodam
+      // antes do proxy interno e do transform.
+      server.middlewares.use((req, res, next) => {
+        const pathname = new URL(req.url ?? '/', 'http://localhost').pathname
+
+        // 1. Stubs primeiro (mais-específico primeiro) — um stub em /api/auth
+        //    sombreia o /api do runtime.
+        for (const [prefix, fn] of stubEntries) {
+          if (matchesPrefix(pathname, prefix)) {
+            if (isDesign) res.setHeader('x-opus-design', '1')
+            try {
+              Promise.resolve(fn(req, res)).catch(next)
+            } catch (err) {
+              next(err)
+            }
+            return
+          }
+        }
+
+        // 2. Protocolo: /api + endpoints do runtime. Aguarda o boot.
+        if (matchesPrefix(pathname, apiPrefix) || RUNTIME_ENDPOINT_PATHS.has(pathname)) {
+          void (async () => {
+            let state: DesignState
+            try {
+              state = await ensureBoot()
+            } catch (err) {
+              sendEnvelope(res, 503, {
+                code: 'design.boot_failed',
+                category: 'dependency',
+                message: `Design runtime failed to boot: ${String(err)}`,
+              })
+              return
+            }
+
+            const method = req.method ?? 'GET'
+            if (matchesPrefix(pathname, apiPrefix) && !state.handle.hasRoute(method, pathname)) {
+              // 404 que se cura: action desconhecida pode ser só staleness que o
+              // watcher não viu (domínio recém-criado). Força UM rebuild por
+              // ciclo (mutex = ensureBoot) e re-tenta o match uma vez.
+              if (!unknownRetryDone) {
+                unknownRetryDone = true
+                stale = true
+              }
+              state = (await ensureBoot().catch(() => undefined)) ?? state
+              if (!state.handle.hasRoute(method, pathname)) {
+                sendEnvelope(res, 404, {
+                  code: 'design.action_not_found',
+                  category: 'not_found',
+                  message:
+                    `Rota ${method} ${pathname} não registrada no runtime do opusDesign — ` +
+                    `confira se o contrato está exportado pelo entry (${entries.join(', ')}); ` +
+                    `domínio novo exige registro lá (ou use entry glob).`,
+                })
+                return
+              }
+            }
+
+            if (isDesign) res.setHeader('x-opus-design', '1')
+            state.handle.handler(req, res, next)
+          })()
+          return
+        }
+
+        // 3. Sonda — o contrato com o Maestro (mínimo garantido: design true).
+        if (isDesign && req.method === 'GET' && pathname === PROBE_PATH) {
+          void respondProbe(res)
+          return
+        }
+
+        // 4. Prefixo ex-proxy sem cobertura: falha explícita em envelope,
+        //    nunca vazamento pra prod.
+        if (isDesign) {
+          const orphan = exProxyPrefixes.find((p) => matchesPrefix(pathname, p))
+          if (orphan !== undefined) {
+            sendEnvelope(res, 503, {
+              code: 'design.no_backend',
+              category: 'dependency',
+              message: `No backend for "${orphan}" in design mode — add a stub or serve it from the opus runtime`,
+            })
+            return
+          }
+        }
+
+        next()
+      })
+    },
+
+    async closeBundle() {
+      const state = current === undefined ? undefined : await current.catch(() => undefined)
+      current = undefined
+      if (state !== undefined) await state.runtime.dispose().catch(() => undefined)
+    },
+  }
+}
+
+// =============================================================================
+// Entry loading
+// =============================================================================
+
+/**
+ * Carrega um entry pelo pipeline SSR do vite — respeita aliases e TS do app.
+ * Isolado nesta função de propósito: no vite 7 o sucessor é
+ * `server.environments.ssr` (module runner); quando o piso de versão subir,
+ * a troca acontece só aqui.
+ */
+async function loadEntry(server: ViteDevServer, entry: string): Promise<unknown[]> {
+  const mod = (await server.ssrLoadModule(normalizeEntryUrl(entry))) as Record<string, unknown>
+  const root = mod.default ?? mod.config
+  if (Array.isArray(root)) return root
+  if (
+    typeof root === 'object' &&
+    root !== null &&
+    Array.isArray((root as { domains?: unknown }).domains)
+  ) {
+    return (root as { domains: unknown[] }).domains
+  }
+  if (isDomainConfig(root)) return [root]
+  throw error({
+    code: 'design.invalid_entry',
+    category: 'internal',
+    message: `Entry "${entry}" must default-export { domains: [...] } or an array of registrables`,
+  })
+}
+
+function normalizeEntryUrl(entry: string): string {
+  if (path.isAbsolute(entry)) return entry
+  return `/${entry.replace(/^\.\//, '')}`
+}
+
+function isGlobPattern(entry: string): boolean {
+  return entry.includes('*')
+}
+
+/**
+ * Entry por glob: expande o padrão A CADA boot — domínio novo entra no rebuild
+ * seguinte sem editar entry nenhum (o watcher de `add` já invalida na criação
+ * do arquivo). Cada match carrega pelo pipeline SSR; dos exports entram só os
+ * com shape de registrável (schemas/helpers exportados junto ficam de fora).
+ */
+async function loadGlobEntry(server: ViteDevServer, pattern: string): Promise<unknown[]> {
+  const out = new Set<unknown>()
+  for (const file of expandGlob(server.config.root, pattern)) {
+    const mod = (await server.ssrLoadModule(file)) as Record<string, unknown>
+    for (const item of registrablesOfModule(mod)) out.add(item)
+  }
+  return [...out]
+}
+
+/**
+ * Matcher próprio de propósito (sem dep nova): `*` casa um segmento (sem '/'),
+ * `**` casa qualquer profundidade. Cobre o entry por pasta de domínio; padrão
+ * exótico não suportado = aponte entries estáticos.
+ */
+function globToRegExp(pattern: string): RegExp {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+  // `\u0000` como placeholder do `**`: nunca ocorre num path real.
+  const body = escaped
+    .replace(/\*\*/g, '\u0000')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\u0000/g, '.*')
+  return new RegExp(`^${body}$`)
+}
+
+interface GlobSpec {
+  /** Regex que casa o path RELATIVO ao root (posix), inclusive `../` pra fora. */
+  re: RegExp
+  /** Prefixo estático do padrão (absoluto): `path.join(root, ...estáticos)`. É o
+   *  ponto de partida do walk E o caminho que o watcher observa. */
+  prefixDir: string
+}
+
+/**
+ * O par (regex, prefixo estático) de um glob relativo ao `root`. Isolado pra ser
+ * reusado: o `expandGlob` anda a partir do prefixo, e o `configureServer` manda o
+ * chokidar observar o MESMO prefixo (globs pra fora do root inclusos) — um cálculo
+ * só decide o que carregar E o que vigiar, sem observar o mundo.
+ */
+function globSpec(root: string, pattern: string): GlobSpec {
+  const normalized = pattern.replace(/^\.\//, '').replace(/^\/+/, '')
+  const re = globToRegExp(normalized)
+  const staticSegments: string[] = []
+  for (const segment of normalized.split('/')) {
+    if (segment.includes('*')) break
+    staticSegments.push(segment)
+  }
+  return { re, prefixDir: path.join(root, ...staticSegments) }
+}
+
+function expandGlob(root: string, pattern: string): string[] {
+  const { re, prefixDir } = globSpec(root, pattern)
+  const matches: string[] = []
+  const walk = (dir: string): void => {
+    let dirents
+    try {
+      dirents = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const dirent of dirents) {
+      if (dirent.name === 'node_modules' || dirent.name === '.git') continue
+      const full = path.join(dir, dirent.name)
+      if (dirent.isDirectory()) {
+        walk(full)
+      } else if (re.test(path.relative(root, full).split(path.sep).join('/'))) {
+        matches.push(full)
+      }
+    }
+  }
+  walk(prefixDir)
+  return matches.sort()
+}
+
+const ACTION_KINDS = new Set(['simple', 'form', 'list', 'view'])
+
+/** Registrável por shape: domínio, reaction/schedule (contados e dropados no
+ *  collect) ou action/contrato (`name` + `kind` canônico). */
+function isRegistrable(value: unknown): boolean {
+  if (typeof value !== 'object' || value === null) return false
+  if (isDomainConfig(value) || isReaction(value) || isSchedule(value)) return true
+  const candidate = value as { name?: unknown; kind?: unknown }
+  return (
+    typeof candidate.name === 'string' &&
+    typeof candidate.kind === 'string' &&
+    ACTION_KINDS.has(candidate.kind)
+  )
+}
+
+/** Colhe registráveis de um módulo do glob: named e default; arrays e o shape
+ *  `{ domains }` são desdobrados; o resto (schemas, helpers) fica de fora. */
+function registrablesOfModule(mod: Record<string, unknown>): unknown[] {
+  const out = new Set<unknown>()
+  const add = (value: unknown): void => {
+    if (Array.isArray(value)) {
+      for (const item of value) add(item)
+      return
+    }
+    if (isRegistrable(value)) {
+      out.add(value)
+      return
+    }
+    if (typeof value === 'object' && value !== null && Array.isArray((value as { domains?: unknown }).domains)) {
+      add((value as { domains: unknown[] }).domains)
+    }
+  }
+  for (const value of Object.values(mod)) add(value)
+  return [...out]
+}
+
+/** Achata os registráveis em actions; reactions/schedules ficam de fora (contados). */
+function collectActions(items: unknown[]): { actions: ActionDef[]; dropped: number } {
+  const actions: ActionDef[] = []
+  let dropped = 0
+  for (const item of items) {
+    if (typeof item !== 'object' || item === null) continue
+    if (isDomainConfig(item)) {
+      const flat = flattenDomain(item)
+      actions.push(...flat.actions)
+      dropped += flat.reactions.length + flat.schedules.length
+      continue
+    }
+    if (isReaction(item) || isSchedule(item)) {
+      dropped += 1
+      continue
+    }
+    // ActionDef ou contrato (sem handler): em design o mockHandler responde.
+    actions.push(item as ActionDef)
+  }
+  return { actions, dropped }
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function matchesPrefix(pathname: string, prefix: string): boolean {
+  return pathname === prefix || pathname.startsWith(`${prefix}/`)
+}
+
+/** Envelope opus com `meta` completo — o fetch client só reconhece envelope com `meta`. */
+function sendEnvelope(res: ServerResponse, status: number, input: ErrorInput): void {
+  res.statusCode = status
+  res.setHeader('content-type', 'application/json; charset=utf-8')
+  res.end(
+    JSON.stringify(
+      serializeResult({
+        ok: false,
+        error: error(input),
+        meta: { actionId: crypto.randomUUID(), action: 'opus.design', durationMs: 0 },
+      }),
+    ),
+  )
+}
+
+function readOpusVersion(): string {
+  // `import.meta.url` sobrevive ao bundling do vite.config (o vite injeta a
+  // URL original do arquivo), então o package.json resolve do source real.
+  try {
+    const pkg = JSON.parse(
+      readFileSync(new URL('../../package.json', import.meta.url), 'utf8'),
+    ) as { version?: string }
+    return pkg.version ?? '0.0.0'
+    /* v8 ignore next 3 — defensivo; o package.json viaja junto do source */
+  } catch {
+    return '0.0.0'
+  }
+}

package/src/vite/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @softize/opus/vite — plugins vite do Opus.
+ *
+ * `opusDesign()` sobe o runtime em modo design dentro do dev server (preview
+ * isolado de prod); `designAuth()` é o AuthAdapter de sessão fixa que ele usa.
+ */
+export { designAuth, opusDesign } from './design.ts'
+export type { DesignStubHandler, OpusDesignOptions } from './design.ts'