@happier-dev/stack 0.1.0-preview.5.1

package/scripts/utils/server/prisma_import.test.mjs

@@ -0,0 +1,78 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  importPrismaClientForHappyServerLight,
+  importPrismaClientFromGeneratedSqlite,
+  importPrismaClientFromNodeModules,
+} from './prisma_import.mjs';
+
+async function writeJson(path, obj) {
+  await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+async function withPrismaFixture(run) {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-prisma-import-'));
+  try {
+    await run(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+async function writeModulePackageJson(dir) {
+  await writeJson(join(dir, 'package.json'), { type: 'module' });
+}
+
+async function writePrismaNodeModule(dir, body = 'export class PrismaClient {}\n') {
+  await mkdir(join(dir, 'node_modules', '@prisma', 'client'), { recursive: true });
+  await writeJson(join(dir, 'node_modules', '@prisma', 'client', 'package.json'), {
+    name: '@prisma/client',
+    type: 'module',
+    main: './index.js',
+  });
+  await writeFile(join(dir, 'node_modules', '@prisma', 'client', 'index.js'), body, 'utf-8');
+}
+
+test('importPrismaClientFromNodeModules imports PrismaClient via node_modules resolution', async () => {
+  await withPrismaFixture(async (dir) => {
+    await writePrismaNodeModule(dir);
+    const PrismaClient = await importPrismaClientFromNodeModules({ dir });
+    assert.equal(typeof PrismaClient, 'function');
+    assert.equal(PrismaClient.name, 'PrismaClient');
+  });
+});
+
+test('importPrismaClientFromGeneratedSqlite imports PrismaClient from generated/sqlite-client', async () => {
+  await withPrismaFixture(async (dir) => {
+    await writeModulePackageJson(dir);
+    await mkdir(join(dir, 'generated', 'sqlite-client'), { recursive: true });
+    await writeFile(join(dir, 'generated', 'sqlite-client', 'index.js'), 'export class PrismaClient {}\n', 'utf-8');
+
+    const PrismaClient = await importPrismaClientFromGeneratedSqlite({ dir });
+    assert.equal(typeof PrismaClient, 'function');
+    assert.equal(PrismaClient.name, 'PrismaClient');
+  });
+});
+
+test('importPrismaClientForHappyServerLight uses node_modules Prisma client even if legacy sqlite artifacts exist', async () => {
+  await withPrismaFixture(async (dir) => {
+    await writeModulePackageJson(dir);
+    await mkdir(join(dir, 'prisma', 'sqlite'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+    await mkdir(join(dir, 'generated', 'sqlite-client'), { recursive: true });
+    await writeFile(join(dir, 'generated', 'sqlite-client', 'index.js'), 'export class PrismaClient {}\n', 'utf-8');
+
+    // Also create a node_modules PrismaClient; the light flavor should use it.
+    await writePrismaNodeModule(dir, 'export class PrismaClient { static which = "node_modules"; }\n');
+
+    const PrismaClient = await importPrismaClientForHappyServerLight({ serverDir: dir });
+    assert.equal(typeof PrismaClient, 'function');
+    assert.equal(PrismaClient.name, 'PrismaClient');
+    assert.equal(PrismaClient.which, 'node_modules');
+  });
+});

package/scripts/utils/server/server.mjs

@@ -0,0 +1,109 @@
+import { setTimeout as delay } from 'node:timers/promises';
+
+export function getServerComponentName({ kv } = {}) {
+  const fromArgRaw = kv?.get('--server')?.trim() ? kv.get('--server').trim() : '';
+  const fromEnvRaw = process.env.HAPPIER_STACK_SERVER_COMPONENT?.trim() ? process.env.HAPPIER_STACK_SERVER_COMPONENT.trim() : '';
+  const raw = fromArgRaw || fromEnvRaw || 'happier-server-light';
+  const v = raw.toLowerCase();
+  if (v === 'light' || v === 'server-light' || v === 'happier-server-light' || v === 'happy-server-light') {
+    return 'happier-server-light';
+  }
+  if (v === 'server' || v === 'full' || v === 'happier-server' || v === 'happy-server') {
+    return 'happier-server';
+  }
+  if (v === 'both') {
+    return 'both';
+  }
+  // Allow explicit component dir names (advanced).
+  return raw;
+}
+
+export async function fetchHappierHealth(baseUrl) {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), 1500);
+  try {
+    const url = baseUrl.replace(/\/+$/, '') + '/health';
+    const res = await fetch(url, { method: 'GET', signal: ctl.signal });
+    const text = await res.text();
+    let json = null;
+    try {
+      json = text ? JSON.parse(text) : null;
+    } catch {
+      json = null;
+    }
+    return { ok: res.ok, status: res.status, json, text };
+  } catch {
+    return { ok: false, status: null, json: null, text: null };
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+export async function isHappierServerRunning(baseUrl) {
+  const health = await fetchHappierHealth(baseUrl);
+  if (!health.ok) return false;
+  // Both happier-server and happier-server-light use `service: 'happier-server'` today.
+  // Treat any ok health response as "running" to avoid duplicate spawns.
+  const svc = typeof health.json?.service === 'string' ? health.json.service : '';
+  const status = typeof health.json?.status === 'string' ? health.json.status : '';
+  if (svc && svc !== 'happier-server') {
+    return false;
+  }
+  if (status && status !== 'ok') {
+    return false;
+  }
+  return true;
+}
+
+export async function waitForHappierHealthOk(baseUrl, { timeoutMs = 60_000, intervalMs = 300 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    // eslint-disable-next-line no-await-in-loop
+    const health = await fetchHappierHealth(baseUrl);
+    if (health.ok) return true;
+    // eslint-disable-next-line no-await-in-loop
+    await delay(intervalMs);
+  }
+  return false;
+}
+
+export async function waitForServerReady(url) {
+  const deadline = Date.now() + 60_000;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(url, { method: 'GET' });
+      const text = await res.text();
+      if (res.ok && text.includes('Welcome to Happier Server!')) {
+        return;
+      }
+    } catch {
+      // ignore
+    }
+    await delay(300);
+  }
+  throw new Error(`Timed out waiting for server at ${url}`);
+}
+
+// Used for UI readiness checks (Expo / gateway / server). Treat any HTTP response as "up".
+export async function waitForHttpOk(url, { timeoutMs = 15_000, intervalMs = 250 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const ctl = new AbortController();
+      const t = setTimeout(() => ctl.abort(), Math.min(2500, Math.max(250, intervalMs)));
+      try {
+        const res = await fetch(url, { method: 'GET', signal: ctl.signal });
+        if (res.status >= 100 && res.status < 600) {
+          return;
+        }
+      } finally {
+        clearTimeout(t);
+      }
+    } catch {
+      // ignore
+    }
+    // eslint-disable-next-line no-await-in-loop
+    await delay(intervalMs);
+  }
+  throw new Error(`Timed out waiting for HTTP response from ${url} after ${timeoutMs}ms`);
+}

package/scripts/utils/server/ui_build_check.mjs

@@ -0,0 +1,37 @@
+import { cmd } from '../ui/layout.mjs';
+
+export function validateUiServingConfig({
+  serverComponentName,
+  serveUiWanted,
+  uiRequired,
+  uiBuildDir,
+  uiBuildDirExists,
+  uiIndexExists,
+} = {}) {
+  const serve = Boolean(serveUiWanted);
+  if (!serve) {
+    return { serveUi: false, warning: null };
+  }
+
+  const dir = String(uiBuildDir ?? '').trim();
+  const exists = Boolean(uiBuildDirExists);
+  const hasIndex = Boolean(uiIndexExists);
+  const required = uiRequired == null ? true : Boolean(uiRequired);
+
+  if (!dir || !exists) {
+    if (required || serverComponentName === 'happier-server-light') {
+      throw new Error(`[local] UI build directory not found at ${dir || '(unset)'}.\nRun: ${cmd('hstack build')}`);
+    }
+    return { serveUi: false, warning: dir ? `UI build dir missing at ${dir}; UI serving will be disabled` : 'UI build dir unset; UI serving will be disabled' };
+  }
+
+  if (!hasIndex) {
+    const indexPath = `${dir.replace(/\/+$/, '')}/index.html`;
+    if (required || serverComponentName === 'happier-server-light') {
+      throw new Error(`[local] UI build is incomplete (missing ${indexPath}).\nRun: ${cmd('hstack build')}`);
+    }
+    return { serveUi: false, warning: `UI index.html missing at ${indexPath}; UI serving will be disabled` };
+  }
+
+  return { serveUi: true, warning: null };
+}

package/scripts/utils/server/ui_build_check.test.mjs

@@ -0,0 +1,70 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { validateUiServingConfig } from './ui_build_check.mjs';
+
+test('validateUiServingConfig returns disabled/no-warning when UI serving is not requested', () => {
+  const res = validateUiServingConfig({
+    serverComponentName: 'happier-server',
+    serveUiWanted: false,
+    uiBuildDir: '',
+    uiBuildDirExists: false,
+    uiIndexExists: false,
+  });
+  assert.deepEqual(res, { serveUi: false, warning: null });
+});
+
+test('validateUiServingConfig fails closed for server-light when index.html is missing', () => {
+  assert.throws(
+    () =>
+      validateUiServingConfig({
+        serverComponentName: 'happier-server-light',
+        serveUiWanted: true,
+        uiBuildDir: '/tmp/ui',
+        uiBuildDirExists: true,
+        uiIndexExists: false,
+      }),
+    /hstack build/i
+  );
+});
+
+test('validateUiServingConfig warns+disables UI for full server when index.html is missing', () => {
+  const res = validateUiServingConfig({
+    serverComponentName: 'happier-server',
+    serveUiWanted: true,
+    uiRequired: false,
+    uiBuildDir: '/tmp/ui',
+    uiBuildDirExists: true,
+    uiIndexExists: false,
+  });
+  assert.equal(res.serveUi, false);
+  assert.match(res.warning ?? '', /index\.html/i);
+});
+
+test('validateUiServingConfig warns+disables UI for full server when build dir is missing', () => {
+  const res = validateUiServingConfig({
+    serverComponentName: 'happier-server',
+    serveUiWanted: true,
+    uiRequired: false,
+    uiBuildDir: '/tmp/missing-ui',
+    uiBuildDirExists: false,
+    uiIndexExists: false,
+  });
+  assert.equal(res.serveUi, false);
+  assert.match(res.warning ?? '', /build dir/i);
+});
+
+test('validateUiServingConfig fails closed when UI is required (even for full server)', () => {
+  assert.throws(
+    () =>
+      validateUiServingConfig({
+        serverComponentName: 'happier-server',
+        serveUiWanted: true,
+        uiRequired: true,
+        uiBuildDir: '/tmp/ui',
+        uiBuildDirExists: true,
+        uiIndexExists: false,
+      }),
+    /hstack build/i
+  );
+});

package/scripts/utils/server/ui_env.mjs

@@ -0,0 +1,13 @@
+export function resolveServerUiEnv({ serveUi, uiBuildDir, uiPrefix, uiBuildDirExists }) {
+  if (!serveUi) return {};
+  if (!uiBuildDirExists) return {};
+  if (!uiBuildDir) return {};
+
+  // Set both full and light UI env vars (full/light share UI config resolution).
+  return {
+    HAPPIER_SERVER_UI_DIR: uiBuildDir,
+    HAPPIER_SERVER_UI_PREFIX: uiPrefix,
+    HAPPIER_SERVER_LIGHT_UI_DIR: uiBuildDir,
+    HAPPIER_SERVER_LIGHT_UI_PREFIX: uiPrefix,
+  };
+}

package/scripts/utils/server/ui_env.test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { resolveServerUiEnv } from './ui_env.mjs';
+
+test('resolveServerUiEnv returns empty when UI serving is disabled', () => {
+  assert.deepEqual(
+    resolveServerUiEnv({
+      serveUi: false,
+      uiBuildDir: '/tmp/ui',
+      uiPrefix: '/',
+      uiBuildDirExists: true,
+    }),
+    {}
+  );
+});
+
+test('resolveServerUiEnv returns empty when UI build dir is missing', () => {
+  assert.deepEqual(
+    resolveServerUiEnv({
+      serveUi: true,
+      uiBuildDir: '/tmp/ui',
+      uiPrefix: '/',
+      uiBuildDirExists: false,
+    }),
+    {}
+  );
+});
+
+test('resolveServerUiEnv returns empty when UI build dir is empty', () => {
+  assert.deepEqual(
+    resolveServerUiEnv({
+      serveUi: true,
+      uiBuildDir: '',
+      uiPrefix: '/',
+      uiBuildDirExists: true,
+    }),
+    {}
+  );
+});
+
+test('resolveServerUiEnv sets both full and light env keys when enabled', () => {
+  assert.deepEqual(
+    resolveServerUiEnv({
+      serveUi: true,
+      uiBuildDir: '/tmp/ui',
+      uiPrefix: '/ui',
+      uiBuildDirExists: true,
+    }),
+    {
+      HAPPIER_SERVER_UI_DIR: '/tmp/ui',
+      HAPPIER_SERVER_UI_PREFIX: '/ui',
+      HAPPIER_SERVER_LIGHT_UI_DIR: '/tmp/ui',
+      HAPPIER_SERVER_LIGHT_UI_PREFIX: '/ui',
+    }
+  );
+});

package/scripts/utils/server/urls.mjs

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync } from 'node:fs';
+
+import { getStackName, resolveStackEnvPath } from '../paths/paths.mjs';
+import { preferStackLocalhostUrl } from '../paths/localhost_host.mjs';
+import { resolvePublicServerUrl } from '../../tailscale.mjs';
+import { resolveServerPortFromEnv } from './port.mjs';
+import { normalizeUrlNoTrailingSlash } from '../net/url.mjs';
+
+function stackEnvExplicitlySetsPublicUrl({ env, stackName }) {
+  try {
+    const envPath =
+      (env.HAPPIER_STACK_ENV_FILE ?? '').toString().trim() ||
+      resolveStackEnvPath(stackName).envPath;
+    if (!envPath || !existsSync(envPath)) return false;
+    const raw = readFileSync(envPath, 'utf-8');
+    return /^HAPPIER_STACK_SERVER_URL=/m.test(raw);
+  } catch {
+    return false;
+  }
+}
+
+function stackEnvExplicitlySetsWebappUrl({ env, stackName }) {
+  try {
+    const envPath =
+      (env.HAPPIER_STACK_ENV_FILE ?? '').toString().trim() ||
+      resolveStackEnvPath(stackName).envPath;
+    if (!envPath || !existsSync(envPath)) return false;
+    const raw = readFileSync(envPath, 'utf-8');
+    return /^HAPPIER_WEBAPP_URL=/m.test(raw);
+  } catch {
+    return false;
+  }
+}
+
+export function getPublicServerUrlEnvOverride({ env = process.env, serverPort, stackName = null } = {}) {
+  const name =
+    (stackName ?? '').toString().trim() ||
+    (env.HAPPIER_STACK_STACK ?? '').toString().trim() ||
+    getStackName(env);
+  const defaultPublicUrl = `http://localhost:${serverPort}`;
+
+  let envPublicUrl = (env.HAPPIER_STACK_SERVER_URL ?? '').toString().trim() || '';
+  envPublicUrl = normalizeUrlNoTrailingSlash(envPublicUrl);
+
+  // Safety: for non-main stacks, ignore a global SERVER_URL unless it was explicitly set in the stack env file.
+  if (name !== 'main' && envPublicUrl && !stackEnvExplicitlySetsPublicUrl({ env, stackName: name })) {
+    envPublicUrl = '';
+  }
+
+  return { defaultPublicUrl, envPublicUrl, publicServerUrl: envPublicUrl || defaultPublicUrl };
+}
+
+export function getWebappUrlEnvOverride({ env = process.env, stackName = null } = {}) {
+  const name =
+    (stackName ?? '').toString().trim() ||
+    (env.HAPPIER_STACK_STACK ?? '').toString().trim() ||
+    getStackName(env);
+
+  let envWebappUrl = (env.HAPPIER_WEBAPP_URL ?? '').toString().trim() || '';
+
+  // Safety: ignore a global HAPPIER_WEBAPP_URL unless it was explicitly set in the stack env file.
+  // This prevents surprising launches of the hosted app due to shell env leakage.
+  if (envWebappUrl && !stackEnvExplicitlySetsWebappUrl({ env, stackName: name })) {
+    envWebappUrl = '';
+  }
+
+  return { envWebappUrl };
+}
+
+export async function resolveServerUrls({ env = process.env, serverPort, allowEnable = true } = {}) {
+  const internalServerUrl = `http://127.0.0.1:${serverPort}`;
+  const stackName =
+    (env.HAPPIER_STACK_STACK ?? '').toString().trim() ||
+    getStackName(env);
+  const { defaultPublicUrl, envPublicUrl } = getPublicServerUrlEnvOverride({ env, serverPort });
+  const resolved = await resolvePublicServerUrl({
+    internalServerUrl,
+    defaultPublicUrl,
+    envPublicUrl,
+    allowEnable,
+    stackName,
+  });
+  const publicServerUrl = normalizeUrlNoTrailingSlash(
+    await preferStackLocalhostUrl(resolved.publicServerUrl, { stackName })
+  );
+  return {
+    internalServerUrl,
+    defaultPublicUrl,
+    envPublicUrl,
+    publicServerUrl,
+    publicServerUrlSource: resolved.source,
+  };
+}
+
+export function getInternalServerUrl({ env = process.env, defaultPort = 3005 } = {}) {
+  const port = resolveServerPortFromEnv({ env, defaultPort });
+  return { port, internalServerUrl: `http://127.0.0.1:${port}` };
+}
+
+export { resolveServerPortFromEnv };

package/scripts/utils/server/validate.mjs

@@ -0,0 +1,60 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function detectServerComponentDirMismatch({ rootDir, serverComponentName, serverDir }) {
+  // Repo-only model: server flavors share the same monorepo checkout/worktree.
+  // The previous "mismatch" check was specific to the legacy multi-repo components layout.
+  void rootDir;
+  void serverComponentName;
+  void serverDir;
+  return null;
+}
+
+export function assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir }) {
+  void rootDir;
+  void serverComponentName;
+  void serverDir;
+}
+
+function detectPrismaProvider(schemaText) {
+  // Best-effort parse of:
+  // datasource db { provider = "sqlite" ... }
+  const m = schemaText.match(/datasource\s+db\s*\{[\s\S]*?\bprovider\s*=\s*\"([a-zA-Z0-9_-]+)\"/m);
+  return m?.[1] ?? '';
+}
+
+export function assertServerPrismaProviderMatches({ serverComponentName, serverDir }) {
+  const schemaPath = join(serverDir, 'prisma', 'schema.prisma');
+
+  let schemaText = '';
+  try {
+    schemaText = readFileSync(schemaPath, 'utf-8');
+  } catch {
+    // If it doesn't exist, skip validation; not every server component necessarily uses Prisma.
+    return;
+  }
+
+  const provider = detectPrismaProvider(schemaText);
+  if (!provider) return;
+
+  // Happier server flavors share a single server package in the monorepo.
+  // Both the full server and the current light server use a Postgres schema (light runs via embedded PGlite).
+  if (serverComponentName === 'happier-server-light') {
+    if (provider !== 'postgresql') {
+      throw new Error(
+        `[server] happier-server-light expects Prisma datasource provider \"postgresql\", but found \"${provider}\" in:\n` +
+          `- ${schemaPath}\n` +
+          `Fix: point happier-server-light at a checkout that includes the current light flavor implementation (PGlite) and uses the Postgres schema.`
+      );
+    }
+    return;
+  }
+
+  if (serverComponentName === 'happier-server' && provider === 'sqlite') {
+    throw new Error(
+      `[server] happier-server expects Prisma datasource provider \"postgresql\", but found \"sqlite\" in:\n` +
+        `- ${schemaPath}\n` +
+        `Fix: point happier-server at a checkout that uses the Postgres schema.`
+    );
+  }
+}

package/scripts/utils/server/validate.test.mjs

@@ -0,0 +1,76 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { assertServerPrismaProviderMatches } from './validate.mjs';
+
+const PG_SCHEMA = `
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+`.trim();
+
+const SQLITE_SCHEMA = `
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+`.trim();
+
+async function writeSchemas({ dir, schemaPrisma, schemaSqlitePrisma }) {
+  const prismaDir = join(dir, 'prisma');
+  await mkdir(prismaDir, { recursive: true });
+  if (schemaPrisma != null) {
+    await writeFile(join(prismaDir, 'schema.prisma'), schemaPrisma + '\n', 'utf-8');
+  }
+  if (schemaSqlitePrisma != null) {
+    await mkdir(join(prismaDir, 'sqlite'), { recursive: true });
+    await writeFile(join(prismaDir, 'sqlite', 'schema.prisma'), schemaSqlitePrisma + '\n', 'utf-8');
+  }
+}
+
+async function withValidateDir(run) {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-validate-'));
+  try {
+    await run(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+test('assertServerPrismaProviderMatches accepts happier-server-light when schema.prisma is postgresql', async () => {
+  await withValidateDir(async (dir) => {
+    await writeSchemas({ dir, schemaPrisma: PG_SCHEMA, schemaSqlitePrisma: SQLITE_SCHEMA });
+    assert.doesNotThrow(() => assertServerPrismaProviderMatches({ serverComponentName: 'happier-server-light', serverDir: dir }));
+  });
+});
+
+test('assertServerPrismaProviderMatches rejects happier-server-light when schema.prisma is sqlite', async () => {
+  await withValidateDir(async (dir) => {
+    await writeSchemas({ dir, schemaPrisma: SQLITE_SCHEMA, schemaSqlitePrisma: SQLITE_SCHEMA });
+    assert.throws(() => assertServerPrismaProviderMatches({ serverComponentName: 'happier-server-light', serverDir: dir }));
+  });
+});
+
+test('assertServerPrismaProviderMatches rejects happier-server when schema.prisma is sqlite', async () => {
+  await withValidateDir(async (dir) => {
+    await writeSchemas({ dir, schemaPrisma: SQLITE_SCHEMA, schemaSqlitePrisma: null });
+    assert.throws(() => assertServerPrismaProviderMatches({ serverComponentName: 'happier-server', serverDir: dir }));
+  });
+});
+
+test('assertServerPrismaProviderMatches accepts happier-server when schema.prisma is postgresql', async () => {
+  await withValidateDir(async (dir) => {
+    await writeSchemas({ dir, schemaPrisma: PG_SCHEMA, schemaSqlitePrisma: null });
+    assert.doesNotThrow(() => assertServerPrismaProviderMatches({ serverComponentName: 'happier-server', serverDir: dir }));
+  });
+});
+
+test('assertServerPrismaProviderMatches is a no-op when schema.prisma is missing', async () => {
+  await withValidateDir(async (dir) => {
+    assert.doesNotThrow(() => assertServerPrismaProviderMatches({ serverComponentName: 'happier-server-light', serverDir: dir }));
+  });
+});