@happyvertical/smrt-template-sveltekit 0.30.0

package/template/src/hooks.server.ts

@@ -0,0 +1,136 @@
+/**
+ * SvelteKit server hooks.
+ *
+ * Pre-wired with:
+ *   1. `enableTenancy()` — registers the @happyvertical/smrt-tenancy
+ *      interceptor with `GlobalInterceptors` at priority 100, so any class
+ *      decorated with `@TenantScoped` is auto-filtered by the tenant in
+ *      AsyncLocalStorage. Idempotent — safe to call on every module load.
+ *   2. A subdomain-based tenant resolver (`tenancyHandle`) — if the URL has
+ *      a leading subdomain (e.g. `acme.demo.local`), the request runs inside
+ *      `withTenant({ tenantId: 'acme' })`.
+ *   3. `createSessionHandler({ enterTenantContext: true })` from
+ *      @happyvertical/smrt-users/sveltekit — populates
+ *      `event.locals.{user, permissions, tenantId, sessionId}` and pushes
+ *      the session's tenant into the AsyncLocalStorage context.
+ *   4. `reconcileTenantLocals` — final reconciliation step. The session
+ *      handler initializes `event.locals.tenantId = null` before reading
+ *      the session, so for unauthenticated public requests it clobbers the
+ *      subdomain value set by step 2. This handle restores the subdomain
+ *      tenant on `event.locals.tenantId` when no session tenant set it,
+ *      so layout/page/action code reads a consistent value regardless of
+ *      auth state.
+ *
+ * To swap the resolution strategy, edit `src/lib/server/tenancy.ts`.
+ */
+
+import { sequence } from '@sveltejs/kit/hooks';
+import type { Handle, RequestEvent } from '@sveltejs/kit';
+
+import { createSessionHandler } from '@happyvertical/smrt-users/sveltekit';
+import {
+  createSvelteKitHandle,
+  enableTenancy,
+  getCurrentTenant,
+} from '@happyvertical/smrt-tenancy';
+
+import { resolveTenant } from '$lib/server/tenancy';
+import { getSmrtConfig } from '$lib/server/smrt';
+
+// Register the tenancy interceptor globally. Idempotent — `enableTenancy()`
+// guards against duplicate registration internally.
+enableTenancy();
+
+// Both upstream factories (`createSvelteKitHandle` from smrt-tenancy and
+// `createSessionHandler` from smrt-users/sveltekit) declare a structural
+// event type with `locals: Record<string, unknown>` to avoid taking a
+// hard dependency on `@sveltejs/kit`. SvelteKit's own `Handle` expects
+// `event.locals: App.Locals` — a strict named interface without an
+// index signature — so the two shapes aren't directly assignable under
+// strict typechecking. The casts below adapt the upstream return types
+// to SvelteKit's `Handle` once. Runtime behaviour is unchanged; the
+// types still flow through `Handle` to the `sequence(...)` composition.
+
+/**
+ * Subdomain → tenantId handle. Runs BEFORE the session handler so generated
+ * routes have a tenant in context even for unauthenticated public requests
+ * (e.g. tenant-scoped catalog endpoints). If a session also carries a
+ * tenant, the session handler's inner `withTenant()` will override.
+ */
+const tenancyHandle = createSvelteKitHandle({
+  resolveTenantId: async (event) => {
+    // The createSvelteKitHandle adapter passes a structural event; our
+    // resolver accepts that same shape.
+    const result = await resolveTenant(event as RequestEvent);
+    return result.tenantId;
+  },
+}) as unknown as Handle;
+
+/**
+ * Session handle from @happyvertical/smrt-users. `enterTenantContext: true`
+ * makes it call `enterTenantContext()` after loading the session, so
+ * downstream code sees the *session's* tenant id when one is present.
+ */
+const sessionHandle = createSessionHandler({
+  ...getSmrtConfig('Session'),
+  enterTenantContext: true,
+}) as unknown as Handle;
+
+/**
+ * Final reconciliation: read the active AsyncLocalStorage tenant (already
+ * set correctly by tenancyHandle + sessionHandle, with session winning
+ * over subdomain when both are present) and align BOTH `event.locals.tenantId`
+ * AND `event.locals.tenantContext` to it.
+ *
+ * Two failure modes this guards against:
+ *
+ *   1. **Public requests with a subdomain.** `createSessionHandler` resets
+ *      `event.locals.tenantId` to `null` before checking for a session
+ *      cookie. With no session, the session handler returns without
+ *      repopulating it, so the subdomain-resolved tenant goes missing
+ *      from layouts/actions even though the ALS context (set by
+ *      `tenancyHandle`) still carries it.
+ *   2. **Authenticated requests where the session's tenant differs from
+ *      the subdomain.** The session handler calls `withTenant(sessionCtx, ...)`
+ *      — switching the ALS context to the session tenant — and updates
+ *      `event.locals.tenantId` to match. But it does NOT touch
+ *      `event.locals.tenantContext`, which is still the subdomain context
+ *      previously written by `tenancyHandle`. Layouts/actions reading
+ *      `tenantContext` would then see stale permissions/superAdminBypass
+ *      that don't match the tenant their queries are scoped to.
+ *
+ * Reading the live ALS context here and writing it back to BOTH
+ * `locals.tenantId` and `locals.tenantContext` keeps the three vantage
+ * points (locals.tenantId, locals.tenantContext, ALS-scoped queries) in
+ * sync regardless of auth state.
+ *
+ * **ALS-scope dependency:** this handle reads `getCurrentTenant()` from
+ * AsyncLocalStorage, which only works because both upstream handles
+ * call `resolve(event)` *inside* their own ALS scope:
+ *   - `createSvelteKitHandle` (smrt-tenancy) wraps in `withTenant(ctx, () => resolve(event))`.
+ *   - `createSessionHandler` (smrt-users) wraps in `withSessionPermissionContext`,
+ *     which internally calls `withTenant(sessionCtx, fn)` when the session
+ *     has a tenantId.
+ * If a future refactor moved either handle's `resolve()` call outside
+ * its ALS scope, `getCurrentTenant()` here would return `undefined` and
+ * the reconciliation would silently no-op. We deliberately do NOT fall
+ * back to `event.locals.tenantId` here — that would re-introduce the
+ * stale-tenantContext bug from the subdomain handler. If the upstream
+ * scoping ever changes, this handle should be updated to read from a
+ * dedicated cross-handler carrier (e.g. `event.locals._tenantSource`)
+ * rather than guessing.
+ */
+const reconcileTenantLocals: Handle = async ({ event, resolve }) => {
+  const activeContext = getCurrentTenant();
+  if (activeContext) {
+    event.locals.tenantId = activeContext.tenantId;
+    event.locals.tenantContext = activeContext;
+  }
+  return resolve(event);
+};
+
+export const handle: Handle = sequence(
+  tenancyHandle,
+  sessionHandle,
+  reconcileTenantLocals,
+);

package/template/src/lib/objects/Item.ts

@@ -0,0 +1,44 @@
+/**
+ * Example SMRT Object
+ *
+ * This is a sample SMRT object to demonstrate the pattern.
+ * Rename or replace this with your own objects.
+ */
+
+import { SmrtObject, smrt } from '@happyvertical/smrt-core';
+
+@smrt({
+  api: {
+    include: ['list', 'get', 'create', 'update', 'delete', 'summarize'],
+  },
+  cli: { include: ['list', 'get', 'summarize'] },
+})
+export class Item extends SmrtObject {
+  /** Item title */
+  title: string = '';
+
+  /** Item description */
+  description: string = '';
+
+  /** Status of the item */
+  status: string = 'draft';
+
+  /** When the item was published */
+  publishedAt: Date | null = null;
+
+  /**
+   * AI-powered summarization
+   */
+  async summarize(): Promise<string> {
+    return await this.do('Create a brief summary of this item');
+  }
+
+  /**
+   * Mark item as published
+   */
+  async publish(): Promise<void> {
+    this.status = 'published';
+    this.publishedAt = new Date();
+    await this.save();
+  }
+}

package/template/src/lib/objects/index.ts

@@ -0,0 +1,8 @@
+/**
+ * SMRT Objects Index
+ *
+ * Export all SMRT objects from this file.
+ * They will be automatically registered and available for CLI/API/MCP.
+ */
+
+export { Item } from './Item.js';

package/template/src/lib/server/smrt.ts

@@ -0,0 +1,81 @@
+/**
+ * Centralized SMRT Configuration
+ *
+ * This file provides configuration for all SMRT objects in your project.
+ * Import this file in your routes to get properly configured collections.
+ */
+
+import { ObjectRegistry, type SmrtClassOptions } from '@happyvertical/smrt-core';
+
+// Import all SMRT objects to register them
+import '../objects/index.js';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __smrtGetRequestScopedDatabase:
+    | (() => SmrtClassOptions['db'] | undefined)
+    | undefined;
+}
+
+/**
+ * Per-object configuration overrides
+ *
+ * Use this to configure specific objects differently from defaults.
+ * Example:
+ *   AuditLog: { db: { url: process.env.AUDIT_DB_URL!, type: 'postgres' } }
+ */
+const objectOverrides: Record<string, Partial<SmrtClassOptions>> = {
+  // Add object-specific overrides here
+};
+
+/**
+ * Get default configuration for SMRT objects
+ */
+function getDefaultConfig(): SmrtClassOptions {
+  return {
+    db: {
+      url: process.env.DATABASE_URL || './data/app.db',
+      type: (process.env.DATABASE_TYPE as 'sqlite' | 'postgres') || 'sqlite',
+    },
+    ai: process.env.OPENAI_API_KEY
+      ? {
+          type: 'openai',
+          apiKey: process.env.OPENAI_API_KEY,
+        }
+      : undefined,
+  };
+}
+
+function getRequestScopedDatabase(): SmrtClassOptions['db'] | undefined {
+  const getter = globalThis.__smrtGetRequestScopedDatabase;
+  return typeof getter === 'function' ? getter() : undefined;
+}
+
+/**
+ * Get configuration for a specific SMRT class
+ */
+export function getSmrtConfig(className: string): SmrtClassOptions {
+  const defaults = getDefaultConfig();
+  const override = objectOverrides[className];
+  return override ? { ...defaults, ...override } : defaults;
+}
+
+/**
+ * Get a collection instance for a SMRT class
+ *
+ * Usage in routes:
+ *   const products = await getCollection<Product>('Product');
+ *   const items = await products.list();
+ */
+export async function getCollection<T>(className: string) {
+  const config = getSmrtConfig(className);
+  const objectOverride = objectOverrides[className];
+  const requestScopedDb = objectOverride?.db
+    ? undefined
+    : getRequestScopedDatabase();
+
+  return await ObjectRegistry.getCollection<T>(className, {
+    ...config,
+    db: requestScopedDb ?? config.db,
+  });
+}

package/template/src/lib/server/tenancy.ts

@@ -0,0 +1,267 @@
+/**
+ * Tenant resolution for SvelteKit requests.
+ *
+ * This file is intentionally pluggable — consumers can swap the strategy
+ * function without forking. The shipped default is subdomain-based:
+ *
+ *   acme.demo.local       → tenantId='acme'
+ *   www.demo.local        → tenantId=null
+ *   demo.local            → tenantId=null
+ *   localhost / 127.0.0.1 → tenantId=null
+ *
+ * The resolver's signature is intentionally minimal — it accepts a
+ * SvelteKit-like `RequestEvent` (typed structurally so this module has zero
+ * `@sveltejs/kit` runtime dependency) and returns a synchronous result.
+ *
+ * @example Swap to path-prefix resolution
+ * ```ts
+ * // src/lib/server/tenancy.ts (your project)
+ * import { createTenantResolver, pathPrefixStrategy } from './tenancy';
+ *
+ * export const resolveTenant = createTenantResolver(pathPrefixStrategy);
+ * ```
+ *
+ * @example Swap to header-based resolution
+ * ```ts
+ * import { createTenantResolver, headerStrategy } from './tenancy';
+ *
+ * export const resolveTenant = createTenantResolver(
+ *   headerStrategy({ headerName: 'x-tenant-id' }),
+ * );
+ * ```
+ *
+ * @example Compose your own
+ * ```ts
+ * import { createTenantResolver, subdomainStrategy } from './tenancy';
+ *
+ * export const resolveTenant = createTenantResolver((event) => {
+ *   // Try subdomain first, then fall back to a header
+ *   const fromSubdomain = subdomainStrategy(event);
+ *   if (fromSubdomain.tenantId) return fromSubdomain;
+ *   return { tenantId: event.request.headers.get('x-tenant-id') };
+ * });
+ * ```
+ */
+
+/**
+ * Structural SvelteKit RequestEvent — only the bits we need for tenant
+ * resolution. Keeping this minimal means the module has no @sveltejs/kit
+ * runtime import, which keeps tests + non-SvelteKit consumers happy.
+ */
+export interface TenantResolverEvent {
+  url: URL;
+  request: { headers: Headers };
+  params?: Record<string, string | undefined>;
+}
+
+/**
+ * Resolution result. `null` means "no tenant for this request".
+ */
+export interface TenantResolution {
+  tenantId: string | null;
+}
+
+/**
+ * A resolver strategy is just a function from event → resolution. Sync or
+ * async — the dispatcher awaits the return value.
+ */
+export type TenantResolverStrategy = (
+  event: TenantResolverEvent,
+) => TenantResolution | Promise<TenantResolution>;
+
+/**
+ * Hostnames that should never produce a tenant id, regardless of how many
+ * dots they contain. Treats `localhost`, `127.0.0.1`, and `::1` as
+ * tenant-less so local dev "just works" until you set up a wildcard DNS
+ * entry like `*.demo.local → 127.0.0.1`.
+ */
+const ROOT_LIKE_HOSTS = new Set(['localhost', '127.0.0.1', '::1']);
+
+/**
+ * Subdomain labels that are *never* tenant slugs even if they appear in the
+ * leading position. Consumers can pass their own list to
+ * {@link subdomainStrategyWith} if they need to extend this.
+ */
+const DEFAULT_RESERVED_SUBDOMAINS = new Set(['www', 'api', 'app']);
+
+/**
+ * Strategy: extract the tenant id from the leading subdomain.
+ *
+ * Behavior:
+ *   - `acme.demo.local`            → `{ tenantId: 'acme' }`
+ *   - `acme.beta.demo.local`       → `{ tenantId: 'acme' }`  (only leading label)
+ *   - `www.demo.local`             → `{ tenantId: null }`    (reserved)
+ *   - `demo.local`                 → `{ tenantId: null }`    (no leading subdomain)
+ *   - `localhost`                  → `{ tenantId: null }`
+ *   - `127.0.0.1` or any IPv4/IPv6 → `{ tenantId: null }`
+ */
+export const subdomainStrategy: TenantResolverStrategy = (event) => {
+  return subdomainStrategyWith()(event);
+};
+
+/**
+ * Customizable subdomain strategy. Use this if you need to extend the
+ * reserved-subdomain list (e.g. to also reject `admin.demo.local`) or
+ * to deploy on a multi-label public suffix like `example.co.uk` where
+ * a naive label count would treat the apex itself as a tenant.
+ *
+ * The supplied `reservedSubdomains` are **merged with** the built-in
+ * defaults (`www`, `api`, `app`) — `www`, `api`, and `app` always stay
+ * reserved regardless of what you pass. Pass `[]` or omit the option
+ * if you only need the defaults; the merge is additive-only. Replacing
+ * the default list outright is not currently supported via this
+ * strategy — fork the function or wire your own `TenantResolverStrategy`
+ * if you need that.
+ *
+ * `baseDomain` (strongly recommended for production) anchors the apex.
+ * When set, the strategy strips the matching suffix and treats whatever
+ * leading labels remain as the tenant. `example.co.uk` with
+ * `baseDomain: 'example.co.uk'` → no tenant; `acme.example.co.uk` →
+ * `'acme'`. Without `baseDomain` the strategy falls back to a label-
+ * count heuristic that works for `.com`/`.net`/`.dev`-style single-
+ * label TLDs but mis-identifies multi-label public suffixes (`.co.uk`,
+ * `.com.au`, `.gov.uk`, …) as tenant subdomains.
+ */
+export function subdomainStrategyWith(opts?: {
+  reservedSubdomains?: Iterable<string>;
+  /**
+   * Apex domain to anchor tenant detection against. Highly recommended
+   * for production deployments on multi-label public suffixes
+   * (`example.co.uk`, `example.com.au`, …). When set, a request for
+   * exactly that host returns `{ tenantId: null }`, and a request for
+   * `<tenant>.<baseDomain>` returns `{ tenantId: '<tenant>' }`. Subdomain
+   * resolution stops being label-count-dependent.
+   */
+  baseDomain?: string;
+}): TenantResolverStrategy {
+  const reserved = new Set<string>(DEFAULT_RESERVED_SUBDOMAINS);
+  if (opts?.reservedSubdomains) {
+    for (const s of opts.reservedSubdomains) {
+      reserved.add(s.toLowerCase());
+    }
+  }
+  const baseDomain = opts?.baseDomain?.toLowerCase().replace(/^\.+|\.+$/g, '');
+
+  return (event) => {
+    const hostname = event.url.hostname.toLowerCase();
+
+    if (ROOT_LIKE_HOSTS.has(hostname)) {
+      return { tenantId: null };
+    }
+
+    // Reject bare IPv4 (e.g. `192.168.1.10`) — never a tenant subdomain.
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) {
+      return { tenantId: null };
+    }
+
+    // Preferred path: caller supplied a baseDomain. Strip it and read
+    // whatever's left as the tenant. This works correctly for both
+    // simple TLDs (`example.com`) and multi-label public suffixes
+    // (`example.co.uk`).
+    if (baseDomain) {
+      if (hostname === baseDomain) {
+        return { tenantId: null };
+      }
+      const suffix = `.${baseDomain}`;
+      if (hostname.endsWith(suffix)) {
+        const leading = hostname.slice(0, -suffix.length);
+        // Take only the first label of whatever's left so
+        // `acme.beta.example.co.uk` still resolves to `acme`.
+        const candidate = leading.split('.')[0];
+        if (!candidate || reserved.has(candidate)) {
+          return { tenantId: null };
+        }
+        return { tenantId: candidate };
+      }
+      // Host doesn't match the configured apex — out of scope for this
+      // strategy, treat as tenant-less rather than guess.
+      return { tenantId: null };
+    }
+
+    // Fallback path: no baseDomain configured. Use a label-count
+    // heuristic that works for single-label TLDs. **This is incorrect
+    // for multi-label public suffixes** (`example.co.uk` has three
+    // labels and would be misread as `example` being a tenant on the
+    // `co.uk` root). Pass `baseDomain` to opt out of the heuristic on
+    // any production deployment that uses such a TLD.
+    const labels = hostname.split('.');
+
+    // Need at least 3 labels for a tenant subdomain: <tenant>.<root>.<tld>.
+    // `demo.local` (2 labels) has no subdomain.
+    if (labels.length < 3) {
+      return { tenantId: null };
+    }
+
+    const candidate = labels[0];
+    if (!candidate || reserved.has(candidate)) {
+      return { tenantId: null };
+    }
+
+    return { tenantId: candidate };
+  };
+}
+
+/**
+ * Strategy: extract the tenant id from a path prefix like `/t/<slug>/...`.
+ * The prefix is configurable; default is `/t/`.
+ *
+ * @example
+ * ```ts
+ * // matches  /t/acme/dashboard  → tenantId='acme'
+ * createTenantResolver(pathPrefixStrategy());
+ *
+ * // matches  /tenant/acme/...   → tenantId='acme'
+ * createTenantResolver(pathPrefixStrategy({ prefix: '/tenant/' }));
+ * ```
+ */
+export function pathPrefixStrategy(opts?: {
+  prefix?: string;
+}): TenantResolverStrategy {
+  const prefix = opts?.prefix ?? '/t/';
+  return (event) => {
+    const path = event.url.pathname;
+    if (!path.startsWith(prefix)) {
+      return { tenantId: null };
+    }
+    const rest = path.slice(prefix.length);
+    const slug = rest.split('/')[0];
+    return { tenantId: slug && slug.length > 0 ? slug : null };
+  };
+}
+
+/**
+ * Strategy: read the tenant id from a request header.
+ *
+ * @example
+ * ```ts
+ * createTenantResolver(headerStrategy({ headerName: 'x-tenant-id' }));
+ * ```
+ */
+export function headerStrategy(opts?: {
+  headerName?: string;
+}): TenantResolverStrategy {
+  const headerName = opts?.headerName ?? 'x-tenant-id';
+  return (event) => {
+    const value = event.request.headers.get(headerName);
+    return { tenantId: value && value.length > 0 ? value : null };
+  };
+}
+
+/**
+ * Wrap any strategy into a resolver. This is a thin factory — its purpose
+ * is to give consumers a single, stable entry point (`resolveTenant`) they
+ * can swap by changing only the argument.
+ */
+export function createTenantResolver(
+  strategy: TenantResolverStrategy,
+): (event: TenantResolverEvent) => Promise<TenantResolution> {
+  return async (event) => {
+    return await strategy(event);
+  };
+}
+
+/**
+ * Default resolver used by `hooks.server.ts`. Swap the argument to
+ * `createTenantResolver()` (or replace this export) to change strategies.
+ */
+export const resolveTenant = createTenantResolver(subdomainStrategy);

package/template/src/routes/+page.svelte

@@ -0,0 +1,108 @@
+<script lang="ts">
+  let items: any[] = $state([]);
+  let loading = $state(true);
+  let error: string | null = $state(null);
+
+  $effect(() => {
+    fetchItems();
+  });
+
+  async function fetchItems() {
+    try {
+      const response = await fetch('/api/items');
+      const data = await response.json();
+      items = data.items || [];
+    } catch (e) {
+      error = e instanceof Error ? e.message : 'Failed to fetch items';
+    } finally {
+      loading = false;
+    }
+  }
+</script>
+
+<svelte:head>
+  <title>SMRT SvelteKit App</title>
+</svelte:head>
+
+<main>
+  <h1>Welcome to SMRT + SvelteKit</h1>
+
+  <section>
+    <h2>Items</h2>
+
+    {#if loading}
+      <p>Loading...</p>
+    {:else if error}
+      <p class="error">{error}</p>
+    {:else if items.length === 0}
+      <p>No items yet. Create your first item!</p>
+    {:else}
+      <ul>
+        {#each items as item}
+          <li>
+            <strong>{item.title}</strong>
+            <span class="status">{item.status}</span>
+          </li>
+        {/each}
+      </ul>
+    {/if}
+  </section>
+
+  <section>
+    <h2>Getting Started</h2>
+    <ul>
+      <li>Edit <code>src/lib/objects/Item.ts</code> to customize your SMRT object</li>
+      <li>Run <code>smrt objects</code> to see registered objects</li>
+      <li>Run <code>smrt generate-routes</code> to regenerate API routes</li>
+      <li>API routes are auto-generated in <code>src/routes/api/</code></li>
+    </ul>
+  </section>
+</main>
+
+<style>
+  main {
+    max-width: 800px;
+    margin: 0 auto;
+    padding: 2rem;
+    font-family: system-ui, -apple-system, sans-serif;
+  }
+
+  h1 {
+    color: #667eea;
+  }
+
+  section {
+    margin: 2rem 0;
+    padding: 1rem;
+    background: #f5f5f5;
+    border-radius: var(--smrt-radius-md, 8px);
+  }
+
+  .error {
+    color: #c33;
+  }
+
+  .status {
+    font-size: 0.8em;
+    background: #e0e0e0;
+    padding: 2px 8px;
+    border-radius: var(--smrt-radius-sm, 4px);
+    margin-left: 8px;
+  }
+
+  code {
+    background: #e0e0e0;
+    padding: 2px 6px;
+    border-radius: var(--smrt-radius-sm, 4px);
+    font-size: 0.9em;
+  }
+
+  ul {
+    list-style: disc;
+    padding-left: 1.5rem;
+  }
+
+  li {
+    margin: 0.5rem 0;
+  }
+</style>

package/template/svelte.config.js

@@ -0,0 +1,16 @@
+import adapter from '@sveltejs/adapter-auto';
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+  preprocess: vitePreprocess(),
+
+  kit: {
+    adapter: adapter(),
+    alias: {
+      $lib: 'src/lib',
+    },
+  },
+};
+
+export default config;

package/template/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "moduleResolution": "bundler",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}