実験の割り当てが同じ端末に偏る — 100万件のIDで確かめたハッシュ選定と salt の位置

function overlap(fn, saltA, saltB) {
  let a = 0, both = 0;
  for (let i = 0; i < N; i++) {
    const inA = fn(saltA + ids[i]) % 100 < 10;
    if (inA) {
      a++;
      if (fn(saltB + ids[i]) % 100 < 10) both++;
    }
  }
  return { aPct: (a / N) * 100, conditional: (both / a) * 100 };
}

const diffs = new Set();
for (let i = 0; i < 20000; i++) {
  const d = (javaHash('exp_paywall_v2:' + ids[i]) - javaHash('exp_onboard_v3:' + ids[i])) >>> 0;
  diffs.add(d);
}
console.log(diffs.size); // → 1

function fmix32(h) {
  h ^= h >>> 16;
  h = Math.imul(h, 0x85ebca6b);
  h ^= h >>> 13;
  h = Math.imul(h, 0xc2b2ae35);
  h ^= h >>> 16;
  return h >>> 0;
}
const bucketHash = (s) => fmix32(fnv1a(s));

// src/experiments/bucketing.ts
const FNV_OFFSET = 0x811c9dc5;
const FNV_PRIME = 0x01000193;
export const BUCKET_RESOLUTION = 10_000; // 0.01% 刻み
 
function fnv1a32(input: string): number {
  let h = FNV_OFFSET;
  for (let i = 0; i < input.length; i++) {
    h ^= input.charCodeAt(i);
    h = Math.imul(h, FNV_PRIME); // 通常の * では 2^53 を超えて桁落ちする
  }
  return h >>> 0;
}
 
function fmix32(h: number): number {
  h ^= h >>> 16;
  h = Math.imul(h, 0x85ebca6b);
  h ^= h >>> 13;
  h = Math.imul(h, 0xc2b2ae35);
  h ^= h >>> 16;
  return h >>> 0;
}
 
/** 実験キーと端末IDから 0〜9999 のバケット番号を返す（同期・決定論的） */
export function bucketOf(experimentKey: string, unitId: string): number {
  if (!experimentKey || !unitId) {
    // 空文字を許すと全端末が同じバケットへ落ちる。設定ミスを黙って通さない
    throw new Error(`bucketOf: empty key or unitId (key="${experimentKey}")`);
  }
  return fmix32(fnv1a32(`${experimentKey}:${unitId}`)) % BUCKET_RESOLUTION;
}
 
export type Variant<T extends string> = { name: T; weight: number };
 
/**
 * 重み付きで変種を選ぶ。weight の合計は 10000 でなくてもよく、
 * 合計に満たない分は最初の要素（＝対照群）へ寄せる。
 */
export function pickVariant<T extends string>(
  experimentKey: string,
  unitId: string,
  variants: readonly Variant<T>[],
): T {
  if (variants.length === 0) throw new Error(`pickVariant: no variants for "${experimentKey}"`);
  const total = variants.reduce((sum, v) => sum + v.weight, 0);
  if (total > BUCKET_RESOLUTION) {
    throw new Error(`pickVariant: weights exceed ${BUCKET_RESOLUTION} in "${experimentKey}"`);
  }
 
  const bucket = bucketOf(experimentKey, unitId);
  let cursor = 0;
  for (const v of variants) {
    cursor += v.weight;
    if (bucket < cursor) return v.name;
  }
  return variants[0].name; // 割り当て外＝対照群
}
 
/** 段階拡大用。ratioBps は 0〜10000（10000 = 100%）。比率を上げても外へ出ない */
export function isInRollout(flagKey: string, unitId: string, ratioBps: number): boolean {
  const clamped = Math.max(0, Math.min(BUCKET_RESOLUTION, Math.floor(ratioBps)));
  return bucketOf(flagKey, unitId) < clamped;
}

// src/experiments/unit-id.ts
import * as SecureStore from 'expo-secure-store';
import AsyncStorage from '@react-native-async-storage/async-storage';
import * as Crypto from 'expo-crypto';
 
const KEY = 'exp.unit_id.v1';
let cached: string | null = null;
 
export function getUnitIdSync(): string | null {
  return cached; // 起動直後の同期評価はこちらを使う
}
 
export async function loadUnitId(): Promise<string> {
  if (cached) return cached;
 
  // 1) Keychain / Keystore（再インストールでも iOS では残る）
  try {
    const secure = await SecureStore.getItemAsync(KEY);
    if (secure) return (cached = await mirror(secure));
  } catch (e) {
    // 端末のロック状態などで読めないことがある。ここで落とさない
    console.warn('[exp] secure read failed', e);
  }
 
  // 2) AsyncStorage（Keychain が読めなかったときの控え）
  try {
    const plain = await AsyncStorage.getItem(KEY);
    if (plain) return (cached = await mirror(plain));
  } catch (e) {
    console.warn('[exp] async read failed', e);
  }
 
  // 3) 新規発行
  const fresh = Crypto.randomUUID();
  return (cached = await mirror(fresh));
}
 
async function mirror(id: string): Promise<string> {
  await Promise.allSettled([
    SecureStore.setItemAsync(KEY, id),
    AsyncStorage.setItem(KEY, id),
  ]);
  return id;
}

// src/experiments/use-variant.ts
import { useMemo } from 'react';
import { getUnitIdSync } from './unit-id';
import { pickVariant, type Variant } from './bucketing';
 
export function useVariant<T extends string>(
  experimentKey: string,
  variants: readonly Variant<T>[],
): T {
  const unitId = getUnitIdSync();
  return useMemo(() => {
    if (!unitId) return variants[0].name; // 未読込のあいだは対照群で描く
    return pickVariant(experimentKey, unitId, variants);
  }, [experimentKey, unitId, variants]);
}