happy-stacks 0.2.0 → 0.4.0

package/scripts/utils/expo/metro_ports.mjs

@@ -0,0 +1,114 @@
+import { isTcpPortFree, pickNextFreeTcpPort } from '../net/ports.mjs';
+
+function hashStringToInt(s) {
+  let h = 0;
+  const str = String(s ?? '');
+  for (let i = 0; i < str.length; i++) {
+    h = (h * 31 + str.charCodeAt(i)) >>> 0;
+  }
+  return h >>> 0;
+}
+
+function coercePositiveInt(v) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+export function resolveStablePortStart({
+  env = process.env,
+  stackName,
+  baseKey,
+  rangeKey,
+  defaultBase,
+  defaultRange,
+}) {
+  const baseRaw = (env[baseKey] ?? '').toString().trim();
+  const rangeRaw = (env[rangeKey] ?? '').toString().trim();
+  const base = coercePositiveInt(baseRaw) ?? defaultBase;
+  const range = coercePositiveInt(rangeRaw) ?? defaultRange;
+  return base + (hashStringToInt(stackName) % range);
+}
+
+export async function pickMetroPort({
+  startPort,
+  forcedPort,
+  reservedPorts = new Set(),
+  host = '127.0.0.1',
+} = {}) {
+  const forced = coercePositiveInt(forcedPort);
+  if (forced) {
+    const ok = await isTcpPortFree(forced, { host });
+    if (ok) return forced;
+  }
+  return await pickNextFreeTcpPort(startPort, { reservedPorts, host });
+}
+
+export function wantsStablePortStrategy({ env = process.env, strategyKey, legacyStrategyKey } = {}) {
+  const raw = (env[strategyKey] ?? env[legacyStrategyKey] ?? 'ephemeral').toString().trim() || 'ephemeral';
+  return raw === 'stable';
+}
+
+export async function pickUiDevMetroPort({
+  env = process.env,
+  stackMode,
+  stackName,
+  reservedPorts = new Set(),
+  host = '127.0.0.1',
+} = {}) {
+  // Legacy alias: UI dev Metro is now the unified Expo dev server port.
+  return await pickExpoDevMetroPort({ env, stackMode, stackName, reservedPorts, host });
+}
+
+export async function pickMobileDevMetroPort({
+  env = process.env,
+  stackMode,
+  stackName,
+  reservedPorts = new Set(),
+  host = '127.0.0.1',
+} = {}) {
+  // Legacy alias: mobile dev Metro is now the unified Expo dev server port.
+  return await pickExpoDevMetroPort({ env, stackMode, stackName, reservedPorts, host });
+}
+
+export async function pickExpoDevMetroPort({
+  env = process.env,
+  stackMode,
+  stackName,
+  reservedPorts = new Set(),
+  host = '127.0.0.1',
+} = {}) {
+  const forcedPort =
+    (env.HAPPY_STACKS_EXPO_DEV_PORT ??
+      env.HAPPY_LOCAL_EXPO_DEV_PORT ??
+      // Back-compat: older knobs.
+      env.HAPPY_STACKS_UI_DEV_PORT ??
+      env.HAPPY_LOCAL_UI_DEV_PORT ??
+      env.HAPPY_STACKS_MOBILE_DEV_PORT ??
+      env.HAPPY_LOCAL_MOBILE_DEV_PORT ??
+      env.HAPPY_STACKS_MOBILE_PORT ??
+      env.HAPPY_LOCAL_MOBILE_PORT ??
+      '')
+      .toString()
+      .trim() || '';
+
+  const stable =
+    stackMode &&
+    wantsStablePortStrategy({
+      env,
+      strategyKey: 'HAPPY_STACKS_EXPO_DEV_PORT_STRATEGY',
+      legacyStrategyKey: 'HAPPY_LOCAL_EXPO_DEV_PORT_STRATEGY',
+    });
+  const startPort = stable
+    ? resolveStablePortStart({
+        env,
+        stackName,
+        baseKey: 'HAPPY_STACKS_EXPO_DEV_PORT_BASE',
+        rangeKey: 'HAPPY_STACKS_EXPO_DEV_PORT_RANGE',
+        defaultBase: 8081,
+        defaultRange: 1000,
+      })
+    : 8081;
+
+  return await pickMetroPort({ startPort, forcedPort, reservedPorts, host });
+}
+

package/scripts/utils/fs/json.mjs

@@ -0,0 +1,25 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+
+export async function readJsonIfExists(path, { defaultValue = null } = {}) {
+  try {
+    const p = String(path ?? '').trim();
+    if (!p || !existsSync(p)) return defaultValue;
+    const raw = await readFile(p, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return defaultValue;
+  }
+}
+
+export async function writeJsonAtomic(path, value) {
+  const p = String(path ?? '').trim();
+  if (!p) throw new Error('writeJsonAtomic: path is required');
+  const dir = dirname(p);
+  await mkdir(dir, { recursive: true }).catch(() => {});
+  const tmp = join(dir, `.tmp.${Date.now()}.${Math.random().toString(16).slice(2)}.json`);
+  await writeFile(tmp, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+  await rename(tmp, p);
+}
+

package/scripts/utils/fs/ops.mjs

@@ -0,0 +1,29 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile } from 'node:fs/promises';
+
+export async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+
+export async function readTextIfExists(path) {
+  try {
+    const p = String(path ?? '').trim();
+    if (!p || !existsSync(p)) return null;
+    const raw = await readFile(p, 'utf-8');
+    const t = raw.trim();
+    return t ? t : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function readTextOrEmpty(path) {
+  try {
+    const p = String(path ?? '').trim();
+    if (!p || !existsSync(p)) return '';
+    return await readFile(p, 'utf-8');
+  } catch {
+    return '';
+  }
+}
+

package/scripts/utils/fs/package_json.mjs

@@ -0,0 +1,8 @@
+import { readJsonIfExists } from './json.mjs';
+
+export async function readPackageJsonVersion(path) {
+  const pkg = await readJsonIfExists(path, { defaultValue: null });
+  const v = String(pkg?.version ?? '').trim();
+  return v || null;
+}
+

package/scripts/utils/fs/tail.mjs

@@ -0,0 +1,12 @@
+import { readFile } from 'node:fs/promises';
+
+export async function readLastLines(path, lines = 60) {
+  try {
+    const raw = await readFile(path, 'utf-8');
+    const parts = raw.split('\n');
+    return parts.slice(Math.max(0, parts.length - lines)).join('\n');
+  } catch {
+    return null;
+  }
+}
+

package/scripts/utils/git/git.mjs

@@ -0,0 +1,67 @@
+import { runCapture } from '../proc/proc.mjs';
+
+export async function gitCapture({ cwd, args }) {
+  return String(await runCapture('git', args, { cwd }));
+}
+
+export async function gitOk({ cwd, args }) {
+  try {
+    await runCapture('git', args, { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function normalizeRemoteName({ cwd, remote }) {
+  const want = String(remote ?? '').trim();
+  if (!want) return want;
+
+  if (await gitOk({ cwd, args: ['remote', 'get-url', want] })) return want;
+
+  // Treat origin/fork as interchangeable if one exists.
+  if (want === 'origin' && (await gitOk({ cwd, args: ['remote', 'get-url', 'fork'] }))) return 'fork';
+  if (want === 'fork' && (await gitOk({ cwd, args: ['remote', 'get-url', 'origin'] }))) return 'origin';
+
+  return want;
+}
+
+export async function resolveRemoteDefaultBranch({ cwd, remote }) {
+  const r = String(remote ?? '').trim();
+  if (!r) return 'main';
+
+  // Prefer refs/remotes/<remote>/HEAD when available.
+  try {
+    const headRef = (await gitCapture({ cwd, args: ['symbolic-ref', '-q', '--short', `refs/remotes/${r}/HEAD`] })).trim();
+    if (headRef.startsWith(`${r}/`)) {
+      return headRef.slice(r.length + 1);
+    }
+  } catch {
+    // ignore
+  }
+
+  // Fallback: parse `git remote show` output.
+  try {
+    const out = await gitCapture({ cwd, args: ['remote', 'show', r] });
+    for (const line of out.split('\n')) {
+      const m = line.match(/^\s*HEAD branch:\s*(.+)\s*$/);
+      if (m?.[1]) return m[1].trim();
+    }
+  } catch {
+    // ignore
+  }
+
+  return 'main';
+}
+
+export async function ensureRemoteRefAvailable({ cwd, remote, branch }) {
+  const r = String(remote ?? '').trim();
+  const b = String(branch ?? '').trim();
+  if (!r || !b) return false;
+  const ref = `refs/remotes/${r}/${b}`;
+  if (await gitOk({ cwd, args: ['show-ref', '--verify', '--quiet', ref] })) return true;
+  // Best-effort fetch of the default branch.
+  await gitCapture({ cwd, args: ['fetch', '--quiet', r, b] }).catch(() => '');
+  return await gitOk({ cwd, args: ['show-ref', '--verify', '--quiet', ref] });
+}
+

package/scripts/utils/git/refs.mjs

@@ -0,0 +1,26 @@
+export function parseGithubPullRequest(input) {
+  const raw = (input ?? '').trim();
+  if (!raw) return null;
+  if (/^\d+$/.test(raw)) {
+    return { number: Number(raw), owner: null, repo: null };
+  }
+  // https://github.com/<owner>/<repo>/pull/<num>
+  const m = raw.match(/github\.com\/(?<owner>[^/]+)\/(?<repo>[^/]+)\/pull\/(?<num>\d+)/);
+  if (!m?.groups?.num) return null;
+  return {
+    number: Number(m.groups.num),
+    owner: m.groups.owner ?? null,
+    repo: m.groups.repo ?? null,
+  };
+}
+
+export function sanitizeSlugPart(s) {
+  return (s ?? '')
+    .toString()
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._/-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+

package/scripts/utils/{worktrees.mjs → git/worktrees.mjs}

@@ -1,8 +1,8 @@
 import { readdir } from 'node:fs/promises';
 import { isAbsolute, join, resolve } from 'node:path';
-import { getComponentsDir } from './paths.mjs';
-import { pathExists } from './fs.mjs';
-import { run, runCapture } from './proc.mjs';
+import { getComponentsDir } from '../paths/paths.mjs';
+import { pathExists } from '../fs/fs.mjs';
+import { run, runCapture } from '../proc/proc.mjs';
 
 export function parseGithubOwner(remoteUrl) {
   const raw = (remoteUrl ?? '').trim();
@@ -15,28 +15,28 @@ export function parseGithubOwner(remoteUrl) {
   return m?.groups?.owner ?? null;
 }
 
-export function getWorktreesRoot(rootDir) {
-  return join(getComponentsDir(rootDir), '.worktrees');
+export function getWorktreesRoot(rootDir, env = process.env) {
+  return join(getComponentsDir(rootDir, env), '.worktrees');
 }
 
-export function componentRepoDir(rootDir, component) {
-  return join(getComponentsDir(rootDir), component);
+export function componentRepoDir(rootDir, component, env = process.env) {
+  return join(getComponentsDir(rootDir, env), component);
 }
 
-export function isComponentWorktreePath({ rootDir, component, dir }) {
+export function isComponentWorktreePath({ rootDir, component, dir, env = process.env }) {
   const raw = String(dir ?? '').trim();
   if (!raw) return false;
   const abs = resolve(raw);
-  const root = resolve(join(getWorktreesRoot(rootDir), component)) + '/';
+  const root = resolve(join(getWorktreesRoot(rootDir, env), component)) + '/';
   return abs.startsWith(root);
 }
 
-export function worktreeSpecFromDir({ rootDir, component, dir }) {
+export function worktreeSpecFromDir({ rootDir, component, dir, env = process.env }) {
   const raw = String(dir ?? '').trim();
   if (!raw) return null;
-  if (!isComponentWorktreePath({ rootDir, component, dir: raw })) return null;
+  if (!isComponentWorktreePath({ rootDir, component, dir: raw, env })) return null;
   const abs = resolve(raw);
-  const root = resolve(join(getWorktreesRoot(rootDir), component)) + '/';
+  const root = resolve(join(getWorktreesRoot(rootDir, env), component)) + '/';
   const rel = abs.slice(root.length).split('/').filter(Boolean);
   if (rel.length < 2) return null;
   // rel = [owner, ...branchParts]
@@ -69,17 +69,18 @@ export async function createWorktreeFromBaseWorktree({
   baseWorktreeSpec,
   remoteName = 'upstream',
   depsMode = '',
+  env = process.env,
 }) {
   const args = ['wt', 'new', component, slug, `--remote=${remoteName}`, `--base-worktree=${baseWorktreeSpec}`];
   if (depsMode) args.push(`--deps=${depsMode}`);
-  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), ...args], { cwd: rootDir });
+  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), ...args], { cwd: rootDir, env });
 
-  const repoDir = componentRepoDir(rootDir, component);
+  const repoDir = componentRepoDir(rootDir, component, env);
   const owner = await getRemoteOwner({ repoDir, remoteName });
-  return join(getWorktreesRoot(rootDir), component, owner, ...slug.split('/'));
+  return join(getWorktreesRoot(rootDir, env), component, owner, ...slug.split('/'));
 }
 
-export function resolveComponentSpecToDir({ rootDir, component, spec }) {
+export function resolveComponentSpecToDir({ rootDir, component, spec, env = process.env }) {
   const raw = (spec ?? '').trim();
   if (!raw || raw === 'default') {
     return null;
@@ -88,11 +89,11 @@ export function resolveComponentSpecToDir({ rootDir, component, spec }) {
     return raw;
   }
   // Treat as <owner>/<branch...> under components/.worktrees/<component>/...
-  return join(getWorktreesRoot(rootDir), component, ...raw.split('/'));
+  return join(getWorktreesRoot(rootDir, env), component, ...raw.split('/'));
 }
 
-export async function listWorktreeSpecs({ rootDir, component }) {
-  const dir = join(getWorktreesRoot(rootDir), component);
+export async function listWorktreeSpecs({ rootDir, component, env = process.env }) {
+  const dir = join(getWorktreesRoot(rootDir, env), component);
   const specs = [];
   try {
     const walk = async (d, prefixParts) => {
@@ -125,10 +126,13 @@ export async function getRemoteOwner({ repoDir, remoteName = 'upstream' }) {
   return owner;
 }
 
-export async function createWorktree({ rootDir, component, slug, remoteName = 'upstream' }) {
+export async function createWorktree({ rootDir, component, slug, remoteName = 'upstream', env = process.env }) {
   // Create without modifying env.local (unless caller passes --use elsewhere).
-  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), 'wt', 'new', component, slug, `--remote=${remoteName}`], { cwd: rootDir });
-  const repoDir = componentRepoDir(rootDir, component);
+  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), 'wt', 'new', component, slug, `--remote=${remoteName}`], {
+    cwd: rootDir,
+    env,
+  });
+  const repoDir = componentRepoDir(rootDir, component, env);
   const owner = await getRemoteOwner({ repoDir, remoteName });
-  return join(getWorktreesRoot(rootDir), component, owner, ...slug.split('/'));
+  return join(getWorktreesRoot(rootDir, env), component, owner, ...slug.split('/'));
 }

package/scripts/utils/handy_master_secret.mjs

@@ -3,8 +3,8 @@ import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { parseDotenv } from './dotenv.mjs';
-import { resolveStackEnvPath } from './paths.mjs';
+import { parseDotenv } from './env/dotenv.mjs';
+import { resolveStackEnvPath } from './paths/paths.mjs';
 import { getLegacyHappyBaseDir, isLegacyAuthSourceName } from './auth_sources.mjs';
 
 async function readTextIfExists(path) {

package/scripts/utils/mobile/config.mjs

@@ -0,0 +1,31 @@
+import { sanitizeBundleIdSegment, sanitizeUrlScheme } from './identifiers.mjs';
+
+export function resolveMobileExpoConfig({ env = process.env } = {}) {
+  const user = sanitizeBundleIdSegment(env.USER ?? env.USERNAME ?? 'user');
+  const defaultLocalBundleId = `com.happy.local.${user}.dev`;
+
+  const appEnv = env.APP_ENV ?? env.HAPPY_STACKS_APP_ENV ?? env.HAPPY_LOCAL_APP_ENV ?? 'development';
+  const iosAppName = (env.HAPPY_STACKS_IOS_APP_NAME ?? env.HAPPY_LOCAL_IOS_APP_NAME ?? '').toString();
+  const iosBundleId = (env.HAPPY_STACKS_IOS_BUNDLE_ID ?? env.HAPPY_LOCAL_IOS_BUNDLE_ID ?? defaultLocalBundleId).toString();
+  // Happy Stacks convention:
+  // - dev-client QR should open a dedicated "Happy Stacks Dev" app (not a per-stack release build)
+  // - so default to a stable happy-stacks-specific scheme unless explicitly overridden.
+  const scheme = sanitizeUrlScheme(
+    (env.HAPPY_STACKS_MOBILE_SCHEME ??
+      env.HAPPY_LOCAL_MOBILE_SCHEME ??
+      env.HAPPY_STACKS_DEV_CLIENT_SCHEME ??
+      env.HAPPY_LOCAL_DEV_CLIENT_SCHEME ??
+      'happystacks-dev')
+      .toString()
+  );
+  const host = (env.HAPPY_STACKS_MOBILE_HOST ?? env.HAPPY_LOCAL_MOBILE_HOST ?? 'lan').toString();
+
+  return {
+    appEnv,
+    iosAppName,
+    iosBundleId,
+    scheme,
+    host,
+  };
+}
+

package/scripts/utils/mobile/dev_client_links.mjs

@@ -0,0 +1,60 @@
+import { getEnvValueAny } from '../env/values.mjs';
+import { pickLanIpv4 } from '../net/lan_ip.mjs';
+import { resolveMobileExpoConfig } from './config.mjs';
+
+function normalizeHostMode(raw) {
+  const v = String(raw ?? '').trim().toLowerCase();
+  if (v === 'localhost' || v === 'local') return 'localhost';
+  if (v === 'lan' || v === 'ip') return 'lan';
+  if (v === 'tunnel') return 'tunnel';
+  return v || 'lan';
+}
+
+export function resolveMobileHostMode(env = process.env) {
+  // Prefer explicit host vars (so TUI/setup-pr match the same knobs Expo uses).
+  const raw =
+    getEnvValueAny(env, ['HAPPY_STACKS_MOBILE_HOST', 'HAPPY_LOCAL_MOBILE_HOST']) ||
+    resolveMobileExpoConfig({ env }).host ||
+    'lan';
+  return normalizeHostMode(raw);
+}
+
+export function resolveMobileScheme(env = process.env) {
+  return String(resolveMobileExpoConfig({ env }).scheme || '').trim();
+}
+
+export function resolveMetroUrlForMobile({ env = process.env, port }) {
+  const p = Number(port);
+  if (!Number.isFinite(p) || p <= 0) return '';
+
+  const mode = resolveMobileHostMode(env);
+  if (mode === 'localhost') {
+    return `http://localhost:${p}`;
+  }
+  if (mode === 'lan') {
+    const ip = pickLanIpv4();
+    return `http://${ip || 'localhost'}:${p}`;
+  }
+  // Tunnel URLs are controlled by Expo; we can't reliably derive them locally.
+  // Fall back to localhost so the URL is at least correct for the host machine.
+  return `http://localhost:${p}`;
+}
+
+export function resolveDevClientDeepLink({ scheme, metroUrl }) {
+  const s = String(scheme ?? '').trim();
+  const url = String(metroUrl ?? '').trim();
+  if (!url) return '';
+  if (!s) return url;
+  return `${s}://expo-development-client/?url=${encodeURIComponent(url)}`;
+}
+
+export function resolveMobileQrPayload({ env = process.env, port }) {
+  const metroUrl = resolveMetroUrlForMobile({ env, port });
+  const scheme = resolveMobileScheme(env);
+  const deepLink = resolveDevClientDeepLink({ scheme, metroUrl });
+  // Match Expo CLI / @expo/cli UrlCreator: QR encodes the dev-client deep link.
+  // Note: iOS Camera will still offer to open custom schemes when the app is installed.
+  const payload = deepLink || metroUrl;
+  return { scheme, metroUrl, deepLink, payload };
+}
+

package/scripts/utils/mobile/identifiers.mjs

@@ -0,0 +1,47 @@
+function sanitizeToken(raw, { allowDots = false } = {}) {
+  const s = (raw ?? '').toString().trim().toLowerCase();
+  const re = allowDots ? /[^a-z0-9.-]+/g : /[^a-z0-9-]+/g;
+  const out = s.replace(re, '-').replace(/^-+|-+$/g, '').replace(/-+/g, '-');
+  return out;
+}
+
+export function sanitizeBundleIdSegment(s) {
+  const seg = sanitizeToken(s, { allowDots: false });
+  if (!seg) return 'app';
+  // Bundle id segments should not start with a digit; prefix if needed.
+  return /^[a-z]/.test(seg) ? seg : `s${seg}`;
+}
+
+export function sanitizeUrlScheme(s) {
+  // iOS URL schemes must start with a letter and may contain letters/digits/+.-.
+  const raw = (s ?? '').toString().trim().toLowerCase();
+  const cleaned = raw.replace(/[^a-z0-9+.-]+/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '');
+  if (!cleaned) return 'happystacks-dev';
+  return /^[a-z]/.test(cleaned) ? cleaned : `h${cleaned}`;
+}
+
+export function stackSlugForMobileIds(stackName) {
+  const raw = (stackName ?? '').toString().trim();
+  return sanitizeBundleIdSegment(raw || 'stack');
+}
+
+export function defaultDevClientIdentity({ user = null } = {}) {
+  const u = sanitizeBundleIdSegment(user ?? 'user');
+  return {
+    iosAppName: 'Happy Stacks Dev',
+    iosBundleId: `com.happystacks.dev.${u}`,
+    scheme: 'happystacks-dev',
+  };
+}
+
+export function defaultStackReleaseIdentity({ stackName, user = null, appName = null } = {}) {
+  const slug = stackSlugForMobileIds(stackName);
+  const u = sanitizeBundleIdSegment(user ?? 'user');
+  const label = (appName ?? '').toString().trim();
+  return {
+    iosAppName: label || `Happy (${stackName})`,
+    iosBundleId: `com.happystacks.stack.${u}.${slug}`,
+    scheme: sanitizeUrlScheme(`happystacks-${slug}`),
+  };
+}
+

package/scripts/utils/mobile/identifiers.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  defaultDevClientIdentity,
+  defaultStackReleaseIdentity,
+  sanitizeBundleIdSegment,
+  sanitizeUrlScheme,
+  stackSlugForMobileIds,
+} from './identifiers.mjs';
+
+test('sanitizeBundleIdSegment produces a safe segment', () => {
+  assert.equal(sanitizeBundleIdSegment('  PR272-107  '), 'pr272-107');
+  assert.equal(sanitizeBundleIdSegment('---'), 'app');
+  assert.equal(sanitizeBundleIdSegment('123'), 's123');
+});
+
+test('sanitizeUrlScheme produces a safe scheme', () => {
+  assert.equal(sanitizeUrlScheme('HappyStacks-Dev'), 'happystacks-dev');
+  assert.equal(sanitizeUrlScheme('123bad'), 'h123bad');
+  assert.equal(sanitizeUrlScheme(''), 'happystacks-dev');
+});
+
+test('stackSlugForMobileIds derives a stable slug', () => {
+  assert.equal(stackSlugForMobileIds('pr272-107-fixes-2026-01-15'), 'pr272-107-fixes-2026-01-15');
+  assert.equal(stackSlugForMobileIds('  Weird Name  '), 'weird-name');
+});
+
+test('defaultDevClientIdentity is stable and safe', () => {
+  const id = defaultDevClientIdentity({ user: 'Leeroy' });
+  assert.equal(id.iosAppName, 'Happy Stacks Dev');
+  assert.equal(id.scheme, 'happystacks-dev');
+  assert.equal(id.iosBundleId, 'com.happystacks.dev.leeroy');
+});
+
+test('defaultStackReleaseIdentity is per-stack', () => {
+  const id = defaultStackReleaseIdentity({ stackName: 'pr272-107', user: 'Leeroy' });
+  assert.equal(id.iosBundleId, 'com.happystacks.stack.leeroy.pr272-107');
+  assert.equal(id.scheme, 'happystacks-pr272-107');
+  assert.equal(id.iosAppName, 'Happy (pr272-107)');
+});
+