@oyolincc/create 0.0.0-dev-20260513110237 → 0.0.0-dev-20260918103756

package/templates/hono-server/apps/server/vite.config.ts

@@ -0,0 +1,79 @@
+import { defineConfig, type Plugin } from 'vite-plus'
+import { packConfig } from '@oyolincc/dev-config'
+import devServer from '@hono/vite-dev-server'
+import nodeAdapter from '@hono/vite-dev-server/node'
+import { loadEnvSync } from '@oyolincc/env-loader'
+import path from 'node:path'
+// import { builtinModules } from 'node:module'
+
+const __dirname = import.meta.dirname
+const isServe = !!process.env.VITE_PUBLIC_DEV_SERVE
+const workersDir = path.resolve(__dirname, 'dist/workers')
+
+function virtualWorkers(kind: 'dev' | 'pack'): Plugin {
+  const virtualId = 'virtual:workers'
+  const resolvedId = `\0${virtualId}`
+
+  return {
+    name: 'virtual-workers',
+    resolveId(id) {
+      if (id === virtualId) return resolvedId
+      return null
+    },
+    load(id) {
+      if (id !== resolvedId) return null
+      // vp dev / test: Piscina cannot follow Vite's module graph; pack --watch writes dist/workers.
+      if (kind === 'dev') {
+        return `export default ${JSON.stringify(workersDir)}`
+      }
+      // vp pack: inlined into the server entry, so import.meta.dirname is dist/.
+      return "import path from 'node:path'\nexport default path.join(import.meta.dirname, 'workers')"
+    },
+  }
+}
+
+export default defineConfig(() => {
+  return {
+    plugins: [
+      virtualWorkers('dev'),
+      {
+        name: 'node-bootstrap',
+        async configureServer() {
+          loadEnvSync({
+            preset: 'server',
+          })
+        },
+      },
+      devServer({
+        entry: './src/adapters/nodejs/entry.ts',
+        adapter: nodeAdapter(),
+      }) as Plugin,
+    ],
+    pack: {
+      ...packConfig,
+      plugins: [virtualWorkers('pack')],
+      entry: {
+        ...(isServe
+          ? {}
+          : {
+              nodeMain: './src/adapters/nodejs/bootstrap.ts',
+            }),
+        nodeEntry: './src/adapters/nodejs/entry.ts',
+        'workers/example-worker': './src/infra/work-runner/example/worker-entry.ts',
+      },
+      // deps: {
+      //   neverBundle: [...builtinModules],
+      // },
+    },
+    resolve: {
+      alias: {
+        '@': path.resolve(__dirname, './src'),
+        '@error-categories': path.resolve(__dirname, './src/shared/errors/defs/index.ts'),
+      },
+    },
+    server: {
+      port: Number(process.env.NODE_PORT) || 6464,
+      host: true,
+    },
+  }
+})

package/templates/hono-server/docker/.env.example

@@ -0,0 +1,4 @@
+COMPOSE_APP_NS=hono-server-local
+SERVER_IMAGE=repo/hono-server
+SERVER_BUILD_TAG=local
+

package/templates/hono-server/docker/README.md

@@ -0,0 +1,5 @@
+# Docker
+
+Copy `docker/.env.example` to `docker/.env` and `envs/.env.example.server` to `envs/.env.server`. Build with `bash scripts/build-docker-server.sh`, then run `docker/local/local-app-deploy.sh`. Production Compose lives under `docker/prod`; copy `.env.example.server` to `.env.server` before use.
+
+The image is a Turbo-pruned, multi-stage production deployment. It validates the Node entry and Example worker artifacts, runs as a non-root user, and checks `/health`.

package/templates/hono-server/docker/local/compose.local.app.yml

@@ -0,0 +1,21 @@
+name: ${COMPOSE_APP_NS:-hono-server-local}
+
+services:
+  server:
+    image: ${SERVER_IMAGE:-repo/hono-server}:${SERVER_BUILD_TAG:?SERVER_BUILD_TAG is required}
+    container_name: ${COMPOSE_APP_NS:-hono-server-local}-server
+    restart: unless-stopped
+    env_file:
+      - ../../envs/.env.server
+    ports:
+      - '6464:6464'
+    healthcheck:
+      test:
+        [
+          'CMD-SHELL',
+          'node -e "require(''http'').get(''http://127.0.0.1:6464/health'',r=>process.exit(r.statusCode<500?0:1)).on(''error'',()=>process.exit(1))"',
+        ]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+      start_period: 30s

package/templates/hono-server/docker/local/local-app-deploy.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DOCKER_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+compose_args=(-f "${SCRIPT_DIR}/compose.local.app.yml")
+if [ -f "${DOCKER_DIR}/.env" ]; then compose_args+=(--env-file "${DOCKER_DIR}/.env"); fi
+docker compose "${compose_args[@]}" up -d --no-deps server
+

package/templates/hono-server/docker/local/local-app-down.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DOCKER_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+compose_args=(-f "${SCRIPT_DIR}/compose.local.app.yml")
+if [ -f "${DOCKER_DIR}/.env" ]; then compose_args+=(--env-file "${DOCKER_DIR}/.env"); fi
+docker compose "${compose_args[@]}" down --remove-orphans
+

package/templates/hono-server/docker/prod/.env.example.server

@@ -0,0 +1,11 @@
+NODE_PORT=6464
+SERVER_ENV=main
+LOGGER_DIR=./logs
+LOGGER_FILE_BASE=app
+CORS_DOMAINS='*'
+# MIN_THREADS=1
+# MAX_THREADS=4
+# CONCURRENT_TASKS_PER_WORKER=1
+# MAX_QUEUE=12
+# WORKER_TASK_TIMEOUT_MS=30000
+

package/templates/hono-server/docker/prod/compose.prod.stack.yml

@@ -0,0 +1,21 @@
+name: ${COMPOSE_APP_NS:-hono-server-prod}
+
+services:
+  server:
+    image: ${SERVER_IMAGE:-repo/hono-server}:${SERVER_BUILD_TAG:?SERVER_BUILD_TAG is required}
+    container_name: ${COMPOSE_APP_NS:-hono-server-prod}-server
+    restart: unless-stopped
+    env_file:
+      - ./.env.server
+    ports:
+      - '6464:6464'
+    healthcheck:
+      test:
+        [
+          'CMD-SHELL',
+          'node -e "require(''http'').get(''http://127.0.0.1:6464/health'',r=>process.exit(r.statusCode<500?0:1)).on(''error'',()=>process.exit(1))"',
+        ]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+      start_period: 30s

package/templates/hono-server/docker/prod/update.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+compose_args=(-f "${SCRIPT_DIR}/compose.prod.stack.yml")
+if [ -f "${SCRIPT_DIR}/.env.docker" ]; then compose_args+=(--env-file "${SCRIPT_DIR}/.env.docker"); fi
+docker compose "${compose_args[@]}" up --pull=always --remove-orphans -d --no-deps server
+

package/templates/hono-server/docker/server.Dockerfile

@@ -0,0 +1,40 @@
+# syntax=docker/dockerfile:1
+FROM node:22.22.1-slim AS base
+
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME/bin:$PATH"
+RUN npm install --global pnpm@11.25.0 turbo@2.9.14
+WORKDIR /app
+
+FROM base AS prepare
+COPY . .
+RUN turbo prune @repo/server --docker
+
+FROM base AS builder
+ENV TURBO_TELEMETRY_DISABLED=1
+ENV VP_GIT_HOOKS=0
+COPY --from=prepare /app/out/json/ .
+RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --frozen-lockfile
+COPY --from=prepare /app/out/full/ .
+RUN pnpm exec turbo build
+
+FROM builder AS packager
+RUN pnpm --filter=@repo/server --prod --legacy deploy /app/deploy
+RUN test -f /app/deploy/dist/nodeMain.mjs && \
+    test -f /app/deploy/dist/nodeEntry.mjs && \
+    test -f /app/deploy/dist/workers/example-worker.mjs
+
+FROM base AS runner
+ENV NODE_ENV=production
+ENV NODE_PORT=6464
+RUN groupadd --system --gid 1001 nodejs \
+  && useradd --system --uid 1001 --gid nodejs --home-dir /app server \
+  && mkdir -p /app/logs \
+  && chown server:nodejs /app/logs
+COPY --from=packager --chown=server:nodejs /app/deploy ./
+USER server
+EXPOSE 6464
+HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --retries=3 \
+  CMD node -e "require('http').get('http://127.0.0.1:6464/health',r=>process.exit(r.statusCode<500?0:1)).on('error',()=>process.exit(1))"
+CMD ["node", "--import", "dotenv/config", "dist/nodeMain.mjs"]
+

package/templates/hono-server/docker/server.Dockerfile.dockerignore

@@ -0,0 +1,23 @@
+**/.DS_Store
+**/node_modules
+.git
+**/.gitignore
+plop/
+**/dist
+.agents
+.vscode
+.cursor
+**/*.log
+**/.turbo
+**/.env
+**/.env.*
+**/__test__
+**/__tests__
+**/*.test.ts
+**/coverage
+.idea
+docker/
+docs/
+.scratch/
+.changeset/
+

package/templates/hono-server/docs/agents/domain.md

@@ -0,0 +1,41 @@
+# Domain Docs
+
+How the engineering skills should consume this repo's domain documentation when exploring the codebase.
+
+## Before exploring, read these
+
+- **`CONTEXT-MAP.md`** at the repo root. It points at the `CONTEXT.md` file for each relevant app or library context; read the entries relevant to the topic.
+- **`docs/adr/`** — read ADRs that touch the area you're about to work in.
+- Context-specific `docs/adr/` directories — check the ADR directory alongside the relevant context when one exists.
+
+If any of these files don't exist, **proceed silently**. Don't flag their absence; don't suggest creating them upfront. The `/domain-modeling` skill (reached via `/grill-with-docs` and `/improve-codebase-architecture`) creates them lazily when terms or decisions actually get resolved.
+
+## File structure
+
+This repo uses a multi-context layout:
+
+```text
+/
+├── CONTEXT-MAP.md                  ← index of all contexts
+├── docs/adr/                       ← system-wide decisions
+├── apps/
+│   └── <app>/
+│       ├── CONTEXT.md
+│       └── docs/adr/               ← app-specific decisions
+└── libs/
+    └── <library>/
+        ├── CONTEXT.md
+        └── docs/adr/               ← library-specific decisions
+```
+
+## Use the glossary's vocabulary
+
+When your output names a domain concept (in an issue title, a refactor proposal, a hypothesis, a test name), use the term as defined in the relevant context's `CONTEXT.md`. Don't drift to synonyms the glossary explicitly avoids.
+
+If the concept you need isn't in the relevant glossary yet, that's a signal — either you're inventing language the project doesn't use (reconsider) or there's a real gap (note it for `/domain-modeling`).
+
+## Flag ADR conflicts
+
+If your output contradicts an existing ADR, surface it explicitly rather than silently overriding:
+
+> _Contradicts ADR-0007 (event-sourced orders) — but worth reopening because…_

package/templates/hono-server/docs/agents/issue-tracker.md

@@ -0,0 +1,30 @@
+# Issue tracker: Local Markdown
+
+Issues and specs for this repo live as markdown files in `.scratch/`.
+
+## Conventions
+
+- One feature per directory: `.scratch/<feature-slug>/`
+- The spec is `.scratch/<feature-slug>/spec.md`
+- Implementation issues are one file per ticket at `.scratch/<feature-slug>/issues/<NN>-<slug>.md`, numbered from `01` — never a single combined tickets file
+- Triage state is recorded as a `Status:` line near the top of each issue file (see `triage-labels.md` for the role strings)
+- Comments and conversation history append to the bottom of the file under a `## Comments` heading
+
+## When a skill says "publish to the issue tracker"
+
+Create a new file under `.scratch/<feature-slug>/` (creating the directory if needed).
+
+## When a skill says "fetch the relevant ticket"
+
+Read the file at the referenced path. The user will normally pass the path or the issue number directly.
+
+## Wayfinding operations
+
+Used by `/wayfinder`. The **map** is a file with one **child** file per ticket.
+
+- **Map**: `.scratch/<effort>/map.md` — the Notes / Decisions-so-far / Fog body.
+- **Child ticket**: `.scratch/<effort>/issues/NN-<slug>.md`, numbered from `01`, with the question in the body. A `Type:` line records the ticket type (`research`/`prototype`/`grilling`/`task`); a `Status:` line records `claimed`/`resolved`.
+- **Blocking**: a `Blocked by: NN, NN` line near the top. A ticket is unblocked when every file it lists is `resolved`.
+- **Frontier**: scan `.scratch/<effort>/issues/` for files that are open, unblocked, and unclaimed; first by number wins.
+- **Claim**: set `Status: claimed` and save before any work.
+- **Resolve**: append the answer under an `## Answer` heading, set `Status: resolved`, then append a context pointer (gist + link) to the map's Decisions-so-far in `map.md`.

package/templates/hono-server/docs/agents/triage-labels.md

@@ -0,0 +1,15 @@
+# Triage Labels
+
+The skills speak in terms of five canonical triage roles. This file maps those roles to the actual label strings used in this repo's issue tracker.
+
+| Label in mattpocock/skills | Label in our tracker | Meaning                                  |
+| -------------------------- | -------------------- | ---------------------------------------- |
+| `needs-triage`             | `needs-triage`       | Maintainer needs to evaluate this issue  |
+| `needs-info`               | `needs-info`         | Waiting on reporter for more information |
+| `ready-for-agent`          | `ready-for-agent`    | Fully specified, ready for an AFK agent  |
+| `ready-for-human`          | `ready-for-human`    | Requires human implementation            |
+| `wontfix`                  | `wontfix`            | Will not be actioned                     |
+
+When a skill mentions a role (e.g. "apply the AFK-ready triage label"), use the corresponding label string from this table.
+
+Edit the right-hand column to match whatever vocabulary you actually use.

package/templates/hono-server/envs/.env.example.server

@@ -0,0 +1,12 @@
+NODE_PORT=6464
+SERVER_ENV=local
+LOGGER_DIR=./logs
+LOGGER_FILE_BASE=app
+# LOGGER_LEVEL=debug
+CORS_DOMAINS='*'
+# MIN_THREADS=1
+# MAX_THREADS=4
+# CONCURRENT_TASKS_PER_WORKER=1
+# MAX_QUEUE=12
+# WORKER_TASK_TIMEOUT_MS=30000
+

package/templates/hono-server/libs/definition/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@repo/definition",
+  "version": "0.0.0",
+  "private": true,
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./backend": "./dist/backend.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  },
+  "dependencies": {
+    "change-case": "catalog:shared",
+    "valibot": "catalog:shared"
+  },
+  "devDependencies": {
+    "@oyolincc/dev-config": "catalog:",
+    "@types/node": "catalog:",
+    "typescript": "catalog:",
+    "vite-plus": "catalog:"
+  }
+}

package/templates/hono-server/libs/definition/src/backend.ts

@@ -0,0 +1,2 @@
+export * from './modules'
+export * from './configs'

package/templates/hono-server/libs/definition/src/configs/defs/log.ts

@@ -0,0 +1,53 @@
+import * as v from 'valibot'
+import { defineSchemaConfig, defineStaticConfig } from '../proto'
+
+export const $S_LogRollSchemaConfig = v.object({
+  loggerDir: v.optional(v.string(), './logs'),
+  loggerFileBase: v.optional(
+    v.pipe(v.string(), v.minLength(1, 'loggerFileBase must be at least 1 character long')),
+    'app',
+  ),
+})
+export type LogRollSchemaConfig = v.InferOutput<typeof $S_LogRollSchemaConfig>
+export const logRollSchemaConfig = defineSchemaConfig($S_LogRollSchemaConfig)
+
+export const $S_LogBaseConfig = v.object({
+  loggerLevel: v.optional(
+    v.picklist(['trace', 'debug', 'info', 'warn', 'error', 'fatal', 'silent']),
+  ),
+})
+export type LogBaseConfig = v.InferOutput<typeof $S_LogBaseConfig>
+export const logBaseConfig = defineSchemaConfig($S_LogBaseConfig)
+
+// https://github.com/mcollina/pino-roll#options
+export interface LogRollRawConfig {
+  frequency: number | string
+  extension: string
+  size: number | string
+  maxFiles: number
+  mkdir: boolean
+  dateFormat: string
+}
+export const logRollRawConfig = defineStaticConfig<LogRollRawConfig>(() => ({
+  frequency: 'daily' as const,
+  extension: '.log',
+  size: '10M',
+  maxFiles: 30,
+  mkdir: true,
+  dateFormat: 'yyyy-MM-dd',
+}))
+
+export interface LogPrettyRawConfig {
+  colorize: boolean
+  singleLine: boolean
+  levelFirst: boolean
+  translateTime: string
+  ignore: string
+}
+export const logPrettyRawConfig = defineStaticConfig<LogPrettyRawConfig>(() => ({
+  colorize: true,
+  singleLine: true,
+  levelFirst: true,
+  translateTime: 'SYS:yyyy-mm-dd HH:MM:ss',
+  ignore: 'pid,hostname',
+}))

package/templates/hono-server/libs/definition/src/configs/defs/middleware.ts

@@ -0,0 +1,16 @@
+import * as v from 'valibot'
+import { defineSchemaConfig } from '../proto'
+
+export const $S_CORSConfig = v.object({
+  domains: v.pipe(
+    v.optional(v.string()),
+    v.transform((val) =>
+      String(val || '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean),
+    ),
+  ) as v.GenericSchema<string | undefined, string[]>,
+})
+export type CORSConfig = v.InferOutput<typeof $S_CORSConfig>
+export const corsConfig = defineSchemaConfig($S_CORSConfig)

package/templates/hono-server/libs/definition/src/configs/defs/runtime.ts

@@ -0,0 +1,11 @@
+import * as v from 'valibot'
+import { defineSchemaConfig } from '../proto'
+
+export const $S_RuntimeConfig = v.object({
+  serverEnv: v.optional(
+    v.union([v.literal('local'), v.literal('test'), v.literal('staging'), v.literal('main')]),
+    'local',
+  ),
+})
+export type RuntimeConfig = v.InferOutput<typeof $S_RuntimeConfig>
+export const runtimeConfig = defineSchemaConfig($S_RuntimeConfig)

package/templates/hono-server/libs/definition/src/configs/defs/worker.ts

@@ -0,0 +1,29 @@
+import * as v from 'valibot'
+import { defineSchemaConfig } from '../proto'
+import { availableParallelism } from 'node:os'
+
+const workerNumber = (minimum: number, name: string) =>
+  v.pipe(
+    v.union([v.string(), v.number()]),
+    v.transform((value) => Number(value)),
+    v.integer(`${name} must be an integer`),
+    v.minValue(minimum, `${name} must be at least ${minimum}`),
+  )
+
+export const $S_WorkerConfig = v.object({
+  /** Worker 池启动时至少保留的 Worker 数量。 */
+  minThreads: v.optional(workerNumber(1, 'minThreads'), 1),
+  /** Worker 池允许创建的最大 Worker 数量。 */
+  maxThreads: v.optional(workerNumber(1, 'maxThreads'), Math.max(2, availableParallelism() + 1)),
+  /** 每个 Worker 可同时执行的任务数量。 */
+  concurrentTasksPerWorker: v.optional(workerNumber(1, 'concurrentTasksPerWorker'), 1),
+  /** Runner 等待队列允许容纳的最大任务数量。 */
+  maxQueue: v.optional(workerNumber(0, 'maxQueue'), 12),
+
+  /** 非 Piscina 官方配置，任务从提交到完成的最长时间，0 表示不限制。 */
+  workerTaskTimeoutMs: v.optional(workerNumber(0, 'workerTaskTimeoutMs'), 30_000),
+})
+
+export type WorkerConfig = v.InferOutput<typeof $S_WorkerConfig>
+
+export const workerConfig = defineSchemaConfig($S_WorkerConfig)

package/templates/hono-server/libs/definition/src/configs/index.ts

@@ -0,0 +1,4 @@
+export * from './defs/runtime'
+export * from './defs/log'
+export * from './defs/middleware'
+export * from './defs/worker'

package/templates/hono-server/libs/definition/src/configs/proto.ts

@@ -0,0 +1,81 @@
+import { camelCase, constantCase, kebabCase, snakeCase } from 'change-case'
+import { type ObjectEntries, type ObjectSchema, type InferOutput, parse } from 'valibot'
+
+export type ConfigType = 'static' | 'schema'
+export type ContextCase = 'kebab' | 'camel' | 'env' | 'constantCase' | 'snake' | 'raw'
+
+const rawCaser = (str: string) => str || ''
+
+const caserMap: Record<ContextCase, (str: string) => string> = {
+  kebab: kebabCase,
+  camel: camelCase,
+  env: constantCase,
+  constantCase: constantCase,
+  snake: snakeCase,
+  raw: rawCaser,
+}
+
+export interface ConfigResolver<TParams, TValue> {
+  (...args: undefined extends TParams ? [params?: TParams] : [params: TParams]): TValue
+}
+
+export interface SchemaConfigResolverParams {
+  context: Record<string, any>
+  matchContextKey?: ContextCase | ((str: string) => string)
+}
+export type SchemaConfigResolver<TSchema extends ObjectSchema<ObjectEntries, any>> = ConfigResolver<
+  SchemaConfigResolverParams,
+  InferOutput<TSchema>
+>
+
+export interface AppConfig<TKind extends ConfigType, R extends ConfigResolver<any, any>> {
+  kind: TKind
+  resolve: R
+}
+
+export type StaticAppConfig<TValue> = AppConfig<'static', ConfigResolver<undefined, TValue>>
+
+export type SchemaAppConfig<TSchema extends ObjectSchema<ObjectEntries, any>> = AppConfig<
+  'schema',
+  SchemaConfigResolver<TSchema>
+> & {
+  schema: TSchema
+}
+
+export const createSchemaResolver = <TSchema extends ObjectSchema<ObjectEntries, any>>(
+  schema: TSchema,
+): SchemaConfigResolver<TSchema> => {
+  return ({ context, matchContextKey }) => {
+    const caser =
+      typeof matchContextKey === 'function'
+        ? matchContextKey
+        : (matchContextKey && caserMap[matchContextKey]) || rawCaser
+
+    const depKeys = Object.keys(schema.entries)
+    const filteredInput: Record<string, any> = {}
+    for (const key of depKeys) {
+      const fromKey = caser(key)
+      if (fromKey) filteredInput[key] = context[fromKey]
+    }
+
+    const parsed = parse(schema, filteredInput)
+    return parsed
+  }
+}
+
+export const defineStaticConfig = <TValue>(resolver: () => TValue): StaticAppConfig<TValue> => {
+  return {
+    kind: 'static',
+    resolve: resolver,
+  }
+}
+
+export const defineSchemaConfig = <TSchema extends ObjectSchema<ObjectEntries, any>>(
+  schema: TSchema,
+): SchemaAppConfig<TSchema> => {
+  return {
+    kind: 'schema',
+    schema: schema,
+    resolve: createSchemaResolver(schema),
+  }
+}

package/templates/hono-server/libs/definition/src/configs/schema.ts

@@ -0,0 +1,23 @@
+import * as v from 'valibot'
+
+export const $S_NonEmptyString = v.pipe(v.string(), v.minLength(1))
+
+export const $S_BooleanString = v.pipe(
+  v.optional(
+    v.pipe(
+      v.string(),
+      v.check((value) => value === 'true' || value === 'false', 'Expected true or false'),
+    ),
+  ),
+  v.transform((value) => value !== 'false'),
+)
+
+export const $S_NumberString = (defaultValue: number) =>
+  v.optional(
+    v.pipe(
+      v.string(),
+      v.check((value) => Number.isFinite(Number(value)), 'Expected a numeric string'),
+      v.transform(Number),
+    ),
+    String(defaultValue),
+  )

package/templates/hono-server/libs/definition/src/modules/example/index.ts

@@ -0,0 +1,16 @@
+export type Example = {
+  id: string
+  message: string
+  createdAt: string
+  updatedAt: string
+}
+
+export type CreateExampleInput = Pick<Example, 'message'>
+
+export type ProcessExampleInput = Pick<Example, 'message'>
+
+export type ProcessExampleOutput = {
+  original: string
+  normalized: string
+  length: number
+}

package/templates/hono-server/libs/definition/src/modules/index.ts

@@ -0,0 +1 @@
+export * from './example'

package/templates/hono-server/libs/definition/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "@oyolincc/dev-config/tsconfig.bundler.json",
+  "files": [],
+  "include": ["src", "./*.ts", "./*.mts"]
+}

package/templates/hono-server/libs/definition/vite.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'vite-plus'
+import { packConfig } from '@oyolincc/dev-config'
+
+export default defineConfig({
+  pack: {
+    ...packConfig,
+    entry: {
+      backend: 'src/backend.ts',
+    },
+    exports: true,
+  },
+})

package/templates/hono-server/oyo.config.json

@@ -0,0 +1,11 @@
+{
+  "env": {
+    "dir": "./envs/",
+    "presets": {
+      "server": [".env.server"]
+    }
+  },
+  "codeGenerator": {
+    "root": "."
+  }
+}