create-katajs 0.1.0

package/dist/templates/auth-snippets/monorepo/apps/api/src/modules/auth/auth.middleware.ts

@@ -0,0 +1,37 @@
+import { defineMiddleware } from '@katajs/core';
+import type { AuthInstance } from '@{{PROJECT_NAME}}/auth';
+import { UnauthorizedError } from './auth.errors';
+
+type SessionUser = {
+  id: string;
+  email: string;
+  name: string;
+};
+
+declare module 'hono' {
+  interface ContextVariableMap {
+    user: SessionUser;
+  }
+}
+
+/**
+ * Attach the current user (if any) to `c.var.user`. Routes that require
+ * auth should use `requireAuthMiddleware` instead.
+ */
+export const attachUserMiddleware = (auth: AuthInstance) =>
+  defineMiddleware(async (c, next) => {
+    const session = await auth.api.getSession({ headers: c.req.raw.headers });
+    if (session?.user) {
+      c.set('user', session.user as SessionUser);
+    }
+    await next();
+  });
+
+/** Require an authenticated user — throws `UnauthorizedError` if absent. */
+export const requireAuthMiddleware = (auth: AuthInstance) =>
+  defineMiddleware(async (c, next) => {
+    const session = await auth.api.getSession({ headers: c.req.raw.headers });
+    if (!session?.user) throw new UnauthorizedError();
+    c.set('user', session.user as SessionUser);
+    await next();
+  });

package/dist/templates/auth-snippets/monorepo/apps/api/src/modules/auth/auth.routes.ts

@@ -0,0 +1,7 @@
+import { Hono } from 'hono';
+import type { AppEnv } from '../../app';
+
+export const authRoutes = new Hono<AppEnv>().all('/*', async (c) => {
+  const auth = c.var.container.resolve('authInstance');
+  return auth.handler(c.req.raw);
+});

package/dist/templates/auth-snippets/monorepo/apps/api/src/modules/auth/index.ts

@@ -0,0 +1,29 @@
+import { defineModule } from '@katajs/core';
+import * as schema from '@{{PROJECT_NAME}}/db';
+import type { DrizzleClient } from '@katajs/drizzle';
+import { createAuth, type AuthInstance } from '@{{PROJECT_NAME}}/auth';
+import { authRoutes } from './auth.routes';
+
+export const authModule = defineModule({
+  name: 'auth',
+  provides: {
+    authInstance: (c): AuthInstance =>
+      createAuth(
+        c.db as DrizzleClient<typeof schema>,
+        c.env as { BETTER_AUTH_SECRET?: string; BETTER_AUTH_URL?: string },
+      ),
+  },
+  requires: [] as const,
+  routes: authRoutes,
+  prefix: '/auth',
+  // katajs:module-consumer
+});
+
+/** Services this module contributes to the container's `Registry`. */
+export type AuthRegistry = {
+  authInstance: AuthInstance;
+};
+
+export type { AuthInstance } from '@{{PROJECT_NAME}}/auth';
+export { UnauthorizedError } from './auth.errors';
+export { attachUserMiddleware, requireAuthMiddleware } from './auth.middleware';

package/dist/templates/auth-snippets/monorepo/packages/auth/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@{{PROJECT_NAME}}/auth",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@{{PROJECT_NAME}}/db": "workspace:*",
+    "@katajs/drizzle": "^0.1.0",
+    "better-auth": "^1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3"
+  }
+}

package/dist/templates/auth-snippets/monorepo/packages/auth/src/auth.ts

@@ -0,0 +1,40 @@
+import { betterAuth } from 'better-auth';
+import { drizzleAdapter as betterAuthDrizzleAdapter } from 'better-auth/adapters/drizzle';
+import type { DrizzleClient } from '@katajs/drizzle';
+import * as schema from '@{{PROJECT_NAME}}/db';
+
+/**
+ * Build a Better Auth instance bound to a request-scoped Drizzle client.
+ * Called per-request from the auth module's `provides` factory.
+ *
+ * Note: Better Auth has its *own* `drizzleAdapter` (imported as
+ * `betterAuthDrizzleAdapter`) — distinct from `@katajs/drizzle`'s
+ * `drizzleAdapter`. The naming overlap is unavoidable.
+ */
+export function createAuth(
+  db: DrizzleClient<typeof schema>,
+  env: { BETTER_AUTH_SECRET?: string; BETTER_AUTH_URL?: string },
+) {
+  return betterAuth({
+    database: betterAuthDrizzleAdapter(db, {
+      provider: 'pg',
+      schema: {
+        user: schema.user,
+        session: schema.session,
+        account: schema.account,
+        verification: schema.verification,
+      },
+    }),
+    secret: env.BETTER_AUTH_SECRET,
+    baseURL: env.BETTER_AUTH_URL,
+    emailAndPassword: { enabled: true },
+  });
+}
+
+export type AuthInstance = ReturnType<typeof createAuth>;
+
+export type SessionUser = {
+  id: string;
+  email: string;
+  name: string;
+};

package/dist/templates/auth-snippets/monorepo/packages/auth/src/index.ts

@@ -0,0 +1,2 @@
+export { createAuth } from './auth';
+export type { AuthInstance, SessionUser } from './auth';

package/dist/templates/auth-snippets/monorepo/packages/auth/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src/**/*"]
+}

package/dist/templates/auth-snippets/monorepo/packages/db/src/auth-schema.ts

@@ -0,0 +1,53 @@
+import { boolean, pgTable, text, timestamp } from 'drizzle-orm/pg-core';
+
+/**
+ * Better Auth tables. The exact column shape is dictated by Better Auth's
+ * Drizzle adapter — keep these in sync with `better-auth` releases. Run
+ * `pnpm db:generate` (from the workspace root) after changes.
+ */
+export const user = pgTable('user', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  email: text('email').notNull().unique(),
+  emailVerified: boolean('email_verified').notNull().default(false),
+  image: text('image'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const session = pgTable('session', {
+  id: text('id').primaryKey(),
+  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+  token: text('token').notNull().unique(),
+  ipAddress: text('ip_address'),
+  userAgent: text('user_agent'),
+  userId: text('user_id')
+    .notNull()
+    .references(() => user.id, { onDelete: 'cascade' }),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const account = pgTable('account', {
+  id: text('id').primaryKey(),
+  accountId: text('account_id').notNull(),
+  providerId: text('provider_id').notNull(),
+  userId: text('user_id')
+    .notNull()
+    .references(() => user.id, { onDelete: 'cascade' }),
+  accessToken: text('access_token'),
+  refreshToken: text('refresh_token'),
+  idToken: text('id_token'),
+  password: text('password'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const verification = pgTable('verification', {
+  id: text('id').primaryKey(),
+  identifier: text('identifier').notNull(),
+  value: text('value').notNull(),
+  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});

package/dist/templates/monorepo/.github/workflows/deploy.yml

@@ -0,0 +1,39 @@
+name: Deploy
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+concurrency:
+  group: deploy-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  deploy:
+    name: Typecheck + deploy apps/api
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Typecheck
+        run: pnpm typecheck
+
+      - name: Deploy
+        run: pnpm --filter @{{PROJECT_NAME}}/api deploy
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

package/dist/templates/monorepo/README.md

@@ -0,0 +1,91 @@
+# {{PROJECT_NAME}}
+
+A katajs monorepo. One Hono+Workers API, a typed RPC client, and a shared Drizzle schema package.
+
+## Layout
+
+```
+{{PROJECT_NAME}}/
+├── apps/
+│   └── api/                  ← Hono + Cloudflare Workers app (deploys to CF)
+├── packages/
+│   ├── db/                   ← Drizzle schema + migrations (shared)
+│   └── api-client/           ← typed Hono RPC client (export AppType + factory)
+├── pnpm-workspace.yaml
+├── turbo.json
+└── package.json              ← delegating scripts
+```
+
+Why this layout: schema and client types are shared across the workspace; deployable units (the API today, queue workers tomorrow) live in `apps/`. Both consume the packages via `workspace:*` protocol.
+
+## Quickstart
+
+```bash
+# Install all workspace deps
+pnpm install
+
+# Generate migration SQL from the Drizzle schema
+pnpm db:generate
+
+# Apply migrations to your local Postgres (set up your .dev.vars first)
+pnpm db:migrate
+
+# Run the API in dev (Wrangler watches packages/db too)
+pnpm dev
+```
+
+`http://localhost:8787/health` should return `{ ok: true }` once the API is up.
+
+## Common commands
+
+| Command | What it does |
+|---|---|
+| `pnpm dev` | `turbo run dev` — runs `wrangler dev` in `apps/api` |
+| `pnpm typecheck` | typechecks every package in parallel (cached) |
+| `pnpm test` | runs vitest in every package that has tests |
+| `pnpm graph` | regenerates `apps/api/graph.html` from the module graph |
+| `pnpm db:generate` | drizzle-kit generate in `packages/db` |
+| `pnpm db:migrate` | drizzle-kit migrate against `packages/db/drizzle.config.ts` |
+| `pnpm deploy` | `wrangler deploy` in `apps/api` |
+
+## Adding modules and services
+
+The katajs CLI works inside the API:
+
+```bash
+cd apps/api
+pnpm katajs add module billing
+pnpm katajs add service archived --in posts
+pnpm katajs add route delete /:id --in users
+```
+
+Or from the root, the CLI walks down to find the API project automatically (planned for Phase 2).
+
+## Using the API client elsewhere
+
+When you build a frontend (TanStack Start, Next.js, etc.) or a separate worker that calls the API, depend on `@{{PROJECT_NAME}}/api-client`:
+
+```ts
+import { createApiClient } from '@{{PROJECT_NAME}}/api-client';
+import type { AppType } from '@{{PROJECT_NAME}}/api';
+
+const api = createApiClient<AppType>('https://api.example.com');
+const res = await api.posts.$post({ json: { title: 't', body: 'b' } });
+const data = await res.json();  // typed end-to-end
+```
+
+The client is generic over the API's `AppType`, so the package itself has zero workspace coupling — the consumer brings its own `AppType`. This is also the home for future cross-cutting client concerns (auth header injection, retry policy, error parsing).
+
+## What's where
+
+- **Drizzle schema** lives in `packages/db/src/schema.ts`. All apps import it from `@{{PROJECT_NAME}}/db`.
+- **Migration SQL** lives in `packages/db/migrations/` (generated by `drizzle-kit`).
+- **Drizzle config** lives in `packages/db/drizzle.config.ts`. Reads connection string from env.
+- **Modules** live in `apps/api/src/modules/`.
+- **Hono app + `createApp({...})`** lives in `apps/api/src/app.ts`.
+
+## Deploy
+
+GitHub Actions workflow at `.github/workflows/deploy.yml` typechecks and deploys `apps/api` on push to `main`. You'll need a `CLOUDFLARE_API_TOKEN` secret with permissions to deploy your Worker.
+
+For migrations, run `pnpm db:migrate` against your production database from your CI or a one-shot local command — it's not currently part of the deploy workflow.

package/dist/templates/monorepo/_gitignore

@@ -0,0 +1,12 @@
+node_modules/
+dist/
+.turbo/
+.wrangler/
+.dev.vars
+.env
+.env.*
+!.env.example
+*.log
+.DS_Store
+coverage/
+*.tsbuildinfo

package/dist/templates/monorepo/apps/api/_dev.vars.example

@@ -0,0 +1,7 @@
+# Local-only secrets for `wrangler dev`. Copy this file to `.dev.vars`
+# and fill in real values. The `.dev.vars` file is gitignored.
+#
+# DATABASE_URL is read by drizzle-kit (run from packages/db) for migrations.
+# Wrangler reads HYPERDRIVE.localConnectionString from wrangler.jsonc instead.
+
+DATABASE_URL="postgres://postgres:postgres@localhost:5432/{{PROJECT_NAME}}_dev"

package/dist/templates/monorepo/apps/api/_gitignore

@@ -0,0 +1,7 @@
+node_modules/
+dist/
+.wrangler/
+.dev.vars
+.turbo/
+*.tsbuildinfo
+graph.html

package/dist/templates/monorepo/apps/api/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@{{PROJECT_NAME}}/api",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "graph": "tsx scripts/graph.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@{{PROJECT_NAME}}/db": "workspace:*",
+    "@hono/zod-validator": "^0.4.1",
+    "@katajs/core": "^0.1.0",
+    "@katajs/drizzle": "^0.1.0",
+    "drizzle-orm": "^0.36.4",
+    "hono": "^4.6.10",
+    "pg": "^8.13.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20241112.0",
+    "@katajs/cli": "^0.1.0",
+    "@types/node": "^22.9.0",
+    "@types/pg": "^8.11.10",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3",
+    "wrangler": "^3.86.0"
+  }
+}

package/dist/templates/monorepo/apps/api/scripts/graph.ts

@@ -0,0 +1,19 @@
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { inspectModules } from '@katajs/core';
+
+import { modules } from './modules';
+
+const here = fileURLToPath(new URL('.', import.meta.url));
+const out = resolve(here, '..', 'graph.html');
+
+const insp = inspectModules(modules);
+writeFileSync(out, insp.html({ title: '{{PROJECT_NAME}} — module graph' }));
+
+// eslint-disable-next-line no-console
+console.log(`✓ wrote ${out}`);
+// eslint-disable-next-line no-console
+console.log(
+  `  ${insp.modules.length} modules • ${insp.edges.length} dependencies • ${insp.routes.length} routes`,
+);

package/dist/templates/monorepo/apps/api/scripts/modules.ts

@@ -0,0 +1,7 @@
+import { postsModule } from '../src/modules/posts/index';
+// katajs:graph-imports
+
+export const modules = [
+  postsModule,
+  // katajs:graph-modules
+];

package/dist/templates/monorepo/apps/api/src/app.ts

@@ -0,0 +1,42 @@
+import { createApp, type RequestVariables } from '@katajs/core';
+import { drizzleAdapter } from '@katajs/drizzle';
+import * as schema from '@{{PROJECT_NAME}}/db';
+
+import { postsModule } from './modules/posts/index';
+// katajs:module-imports
+
+export type Bindings = {
+  HYPERDRIVE: Hyperdrive;
+};
+
+export type AppEnv = {
+  Bindings: Bindings;
+  Variables: RequestVariables;
+};
+
+const { app, queue } = createApp({
+  bindings: {} as Bindings,
+  db: drizzleAdapter({ schema }),
+  modules: [
+    postsModule,
+    // katajs:modules
+  ],
+  // Producer manifest. Each entry surfaces a typed wrapper at
+  // c.var.queues.<name>.send(body), validated against the schema.
+  queues: {
+    // katajs:queues
+  },
+  // Define your HTTP surface here. Add `.get()` / `.post()` for ad-hoc routes
+  // (health checks, webhooks) and `.route(prefix, module.routes)` per module.
+  routes: (base) =>
+    base
+      .get('/health', (c) =>
+        c.json({ ok: true, requestId: c.var.requestId }),
+      )
+      .route(postsModule.prefix, postsModule.routes),
+  // katajs:routes
+});
+
+export { queue };
+export default app;
+export type AppType = typeof app;

package/dist/templates/monorepo/apps/api/src/index.ts

@@ -0,0 +1,7 @@
+import app, { queue } from './app';
+
+// Worker default export. `queue` is undefined when no module declares a
+// `consumer:` field; Cloudflare Workers handles either case fine.
+export default { fetch: app.fetch, queue };
+
+export type { AppType, AppEnv, Bindings } from './app';

package/dist/templates/monorepo/apps/api/src/modules/posts/index.ts

@@ -0,0 +1,31 @@
+import { defineModule } from '@katajs/core';
+import { makePostRepository, type PostRepository } from './posts.repository';
+import { makePostService, type PostsService } from './posts.service';
+// katajs:module-service-imports
+import { postsRoutes } from './posts.routes';
+
+export const postsModule = defineModule({
+  name: 'posts',
+  provides: {
+    postRepository: (c): PostRepository => makePostRepository(c.db),
+    postService: (c): PostsService => makePostService(c),
+    // katajs:module-provides
+  },
+  requires: [] as const,
+  routes: postsRoutes,
+  prefix: '/posts',
+  // katajs:module-consumer
+});
+
+/**
+ * Services this module contributes to the container's `Registry`. Compose it
+ * in `app.ts` via `interface Registry extends PostsRegistry {}`. Adding a new
+ * module is one extra `extends` clause — no key-by-key bookkeeping.
+ */
+export type PostsRegistry = {
+  postRepository: PostRepository;
+  postService: PostsService;
+  // katajs:module-registry
+};
+
+export type { PostRepository, PostsService };

package/dist/templates/monorepo/apps/api/src/modules/posts/posts.errors.ts

@@ -0,0 +1,15 @@
+import { AppError } from '@katajs/core';
+
+export class PostNotFoundError extends AppError {
+  override readonly status = 404;
+  override readonly code = 'post_not_found';
+  override readonly publicMessage = 'Post not found';
+
+  constructor(public readonly postId: string) {
+    super(`Post ${postId} not found`);
+  }
+
+  override get publicPayload() {
+    return { postId: this.postId };
+  }
+}

package/dist/templates/monorepo/apps/api/src/modules/posts/posts.repository.ts

@@ -0,0 +1,22 @@
+import { eq } from 'drizzle-orm';
+import type { DrizzleClientOrTx } from '@katajs/drizzle';
+import { posts, type NewPost, type Post } from '@{{PROJECT_NAME}}/db';
+import * as schema from '@{{PROJECT_NAME}}/db';
+
+type Schema = typeof schema;
+
+export function makePostRepository(dbOrTx: DrizzleClientOrTx<Schema>) {
+  return {
+    async findById(id: string): Promise<Post | undefined> {
+      const rows = await dbOrTx.select().from(posts).where(eq(posts.id, id)).limit(1);
+      return rows[0];
+    },
+    async insert(input: NewPost): Promise<Post> {
+      const [row] = await dbOrTx.insert(posts).values(input).returning();
+      if (!row) throw new Error('insert returned no row');
+      return row;
+    },
+  };
+}
+
+export type PostRepository = ReturnType<typeof makePostRepository>;

package/dist/templates/monorepo/apps/api/src/modules/posts/posts.routes.ts

@@ -0,0 +1,20 @@
+import { Hono } from 'hono';
+import { validate } from '@katajs/core';
+import type { AppEnv } from '../../app';
+import { CreatePostSchema, PostIdParam } from './posts.schema';
+
+export const postsRoutes = new Hono<AppEnv>()
+  .get('/:id', ...validate({ param: PostIdParam }), async (c) => {
+    const { id } = c.req.valid('param');
+    const service = c.var.resolve('postService');
+    const post = await service.getById(id);
+    return c.json({ post });
+  })
+  .post('/', ...validate({ body: CreatePostSchema }), async (c) => {
+    const input = c.req.valid('json');
+    const service = c.var.resolve('postService');
+    const post = await service.create(input);
+    return c.json({ post }, 201);
+  })
+  // katajs:module-routes
+  ;

package/dist/templates/monorepo/apps/api/src/modules/posts/posts.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const CreatePostSchema = z.object({
+  title: z.string().min(1).max(200),
+  body: z.string().min(1).max(10_000),
+  authorId: z.string().min(1),
+});
+export type CreatePostInput = z.infer<typeof CreatePostSchema>;
+
+export const PostIdParam = z.object({
+  id: z.string().uuid(),
+});
+export type PostIdParamInput = z.infer<typeof PostIdParam>;

package/dist/templates/monorepo/apps/api/src/modules/posts/posts.service.ts

@@ -0,0 +1,26 @@
+import type { RequestContainer } from '@katajs/core';
+import { PostNotFoundError } from './posts.errors';
+import type { CreatePostInput } from './posts.schema';
+import type { Post } from '@{{PROJECT_NAME}}/db';
+
+export type PostsService = {
+  getById(id: string): Promise<Post>;
+  create(input: CreatePostInput): Promise<Post>;
+};
+
+export function makePostService(c: RequestContainer): PostsService {
+  return {
+    async getById(id) {
+      const repo = c.resolve('postRepository');
+      const post = await repo.findById(id);
+      if (!post) throw new PostNotFoundError(id);
+      return post;
+    },
+    async create(input) {
+      return c.withTransaction(async (tx) => {
+        const repo = tx.resolve('postRepository');
+        return repo.insert(input);
+      });
+    },
+  };
+}

package/dist/templates/monorepo/apps/api/src/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Module augmentations for `@katajs/core`. Picked up automatically by
+ * tsconfig's `include` glob — no runtime import needed. Co-locate everything
+ * that teaches the framework about this app's concrete types here.
+ *
+ * The `katajs:registry-imports` and `katajs:registry` markers below are used
+ * by `katajs add module` to insert new module registry entries automatically.
+ */
+import type { DrizzleClient } from '@katajs/drizzle';
+import type * as schema from '@{{PROJECT_NAME}}/db';
+import type { Bindings } from './app';
+
+import type { PostsRegistry } from './modules/posts/index';
+// katajs:registry-imports
+
+declare module '@katajs/core' {
+  interface AppDb extends DrizzleClient<typeof schema> {}
+  interface AppEnv extends Bindings {}
+  interface Registry
+    extends PostsRegistry
+    // katajs:registry
+  {}
+
+  // Typed producer queues. Each entry maps a queue name to its body type so
+  // c.var.queues.<name>.send(body) is fully typed.
+  interface QueuesRegistry {
+    // katajs:queues-registry
+  }
+}

package/dist/templates/monorepo/apps/api/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "types": ["@cloudflare/workers-types", "node"]
+  },
+  "include": ["src/**/*", "scripts/**/*"]
+}