Initial silicon sampling lab deploy

.gitignore

@@ -0,0 +1,10 @@
+.env
+.env.*
+!.env.example
+node_modules/
+__pycache__/
+*.pyc
+static/immersive/
+runs/
+data/nemotron_personas_korea/
+.DS_Store

Dockerfile

@@ -0,0 +1,23 @@
+FROM node:22-bookworm-slim
+
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+ENV HOST=0.0.0.0
+ENV SILICON_LLM_MAX_AGENTS=3000
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends python3 python3-pip git curl \
+  && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY package.json package-lock.json* ./
+RUN npm ci
+
+COPY requirements.txt ./
+RUN pip3 install --break-system-packages --no-cache-dir -r requirements.txt
+
+COPY . .
+RUN npm run build
+
+EXPOSE 7860
+CMD ["python3", "server.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,53 @@
 ---
 title: Silicon Sampling Lab
-emoji: 🌖
+emoji: 📊
 colorFrom: blue
-colorTo: purple
+colorTo: indigo
 sdk: docker
-pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Silicon Sampling Lab
+
+Korean silicon-sampling web app for running persona-agent survey simulations with OpenAI API calls.
+
+This repository contains only the silicon sampling app:
+
+- React/Vite frontend
+- Python standard-library HTTP server
+- LLM-backed silicon sampling runtime
+- local Nemotron-Personas-Korea dataset helpers
+
+It does not include the broader multi-framework social simulation UI.
+
+## Local Run
+
+```bash
+npm ci
+npm run build
+python3 -m pip install -r requirements.txt
+OPENAI_API_KEY=... python3 server.py --host 127.0.0.1 --port 8765
+```
+
+Open:
+
+```text
+http://127.0.0.1:8765/silicon/
+```
+
+## Hugging Face Spaces
+
+This repo is configured as a Docker Space. Set `OPENAI_API_KEY` as a Space secret, not as a committed file.
+
+The app listens on port `7860`.
+
+## Optional Nemotron Dataset
+
+The app works with fallback distributions if the local dataset is not present. To enable local Nemotron-Personas-Korea metadata and sampling:
+
+```bash
+python3 scripts/download_nemotron_personas_korea.py
+python3 scripts/build_nemotron_persona_index.py
+```
+
+Downloaded dataset files are intentionally ignored by git.

frontend/src/main.tsx

@@ -0,0 +1,10 @@
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { SiliconSamplingApp } from "./silicon/SiliconSamplingApp";
+import "./styles.css";
+
+createRoot(document.getElementById("root") as HTMLElement).render(
+  <React.StrictMode>
+    <SiliconSamplingApp />
+  </React.StrictMode>,
+);

frontend/src/silicon/SiliconCharts.tsx

@@ -0,0 +1,339 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { BarChart } from "echarts/charts";
+import { GridComponent, TooltipComponent } from "echarts/components";
+import { init, use } from "echarts/core";
+import { CanvasRenderer } from "echarts/renderers";
+import { AGE_BANDS, GENDERS } from "./data";
+import { resultBreakdown } from "./simulate";
+import type { PersonaDimensionId, SiliconResult, SyntheticRespondent } from "./types";
+
+use([BarChart, GridComponent, TooltipComponent, CanvasRenderer]);
+
+interface SiliconChartsProps {
+  result: SiliconResult;
+}
+
+type Breakdown = "overall" | "gender" | "age" | "region" | PersonaDimensionId;
+type MetricMode = "mean" | "positive";
+
+const BREAKDOWN_MODES: Array<{ id: Breakdown; label: string }> = [
+  { id: "overall", label: "전체" },
+  { id: "gender", label: "성별" },
+  { id: "age", label: "연령대" },
+  { id: "region", label: "지역" },
+  { id: "occupation", label: "직업" },
+  { id: "education", label: "학력" },
+  { id: "housing", label: "주거" },
+  { id: "marital", label: "혼인" },
+  { id: "family", label: "가구" },
+];
+
+export function SiliconCharts({ result }: SiliconChartsProps) {
+  const [selectedQuestionId, setSelectedQuestionId] = useState(result.config.questions[0]?.id || "");
+  const [breakdown, setBreakdown] = useState<Breakdown>("overall");
+  const [metricMode, setMetricMode] = useState<MetricMode>("mean");
+  const selectedQuestion = result.config.questions.find((question) => question.id === selectedQuestionId) || result.config.questions[0];
+  const selectedStat = result.questionStats.find((stat) => stat.questionId === selectedQuestion?.id);
+  const isLikert = selectedQuestion?.kind === "likert";
+  const breakdownRows = useMemo(
+    () => isLikert && breakdown !== "overall" ? resultBreakdown(result, selectedQuestion.id, breakdown) : [],
+    [breakdown, isLikert, result, selectedQuestion?.id],
+  );
+
+  useEffect(() => {
+    if (!result.config.questions.some((question) => question.id === selectedQuestionId)) {
+      setSelectedQuestionId(result.config.questions[0]?.id || "");
+    }
+  }, [result, selectedQuestionId]);
+
+  if (!selectedQuestion) return null;
+
+  return (
+    <section className="silicon-explorer" data-testid="silicon-charts">
+      <div className="explorer-toolbar">
+        <div>
+          <span>question</span>
+          <strong>문항별 결과 탐색</strong>
+        </div>
+        <div className="result-mode-buttons">
+          {BREAKDOWN_MODES.map((mode) => (
+            <button key={mode.id} type="button" className={breakdown === mode.id ? "active" : ""} onClick={() => setBreakdown(mode.id)}>
+              {mode.label}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      <div className="question-tabs">
+        {result.config.questions.map((question) => (
+          <button
+            key={question.id}
+            type="button"
+            className={[
+              selectedQuestion.id === question.id ? "active" : "",
+              question.kind === "likert" ? "kind-likert" : "kind-open",
+            ].filter(Boolean).join(" ")}
+            onClick={() => {
+              setSelectedQuestionId(question.id);
+              if (question.kind === "open") setBreakdown("overall");
+            }}
+          >
+            <span>{question.kind === "likert" ? `${question.scale}점 Likert` : "Open-ended"}</span>
+            <strong>{question.title}</strong>
+          </button>
+        ))}
+      </div>
+
+      {isLikert ? (
+        <>
+          <div className="metric-tabs">
+            <button type="button" className={metricMode === "mean" ? "active" : ""} onClick={() => setMetricMode("mean")}>평균</button>
+            <button type="button" className={metricMode === "positive" ? "active" : ""} onClick={() => setMetricMode("positive")}>긍정률</button>
+          </div>
+          <div className="silicon-chart-grid single">
+            {breakdown === "overall" ? (
+              <ChartCard
+                title="응답 분포"
+                subtitle={selectedQuestion.title}
+                option={{
+                  color: ["#5b6ee1"],
+                  tooltip: tooltip(),
+                  grid: grid(),
+                  xAxis: { type: "category", data: selectedStat?.distribution?.map((item) => `${item.value}`) || [], axisLabel: axisLabel() },
+                  yAxis: { type: "value", axisLabel: axisLabel(), splitLine: splitLine() },
+                  series: [{
+                    type: "bar",
+                    data: selectedStat?.distribution?.map((item) => item.count) || [],
+                    barWidth: "52%",
+                    itemStyle: { borderRadius: [8, 8, 0, 0] },
+                  }],
+                }}
+              />
+            ) : (
+              <ChartCard
+                title={`${modeLabel(breakdown)} ${metricMode === "mean" ? "평균" : "긍정률"}`}
+                subtitle={selectedQuestion.title}
+                option={breakdownOption(breakdownRows, metricMode)}
+              />
+            )}
+            <MetricPanel
+              mean={selectedStat?.mean}
+              positiveShare={selectedStat?.positiveShare}
+              count={result.likertAnswers.filter((answer) => answer.questionId === selectedQuestion.id).length}
+              scale={selectedQuestion.scale || 5}
+            />
+            <ResponseTable result={result} questionId={selectedQuestion.id} />
+          </div>
+        </>
+      ) : (
+        <div className="silicon-chart-grid open-only">
+          <OpenAnswerPanel result={result} questionId={selectedQuestion.id} />
+          <ResponseTable result={result} questionId={selectedQuestion.id} />
+        </div>
+      )}
+    </section>
+  );
+}
+
+function MetricPanel({ mean, positiveShare, count, scale }: { mean?: number; positiveShare?: number; count: number; scale: number }) {
+  return (
+    <section className="silicon-chart-card metric-card">
+      <header>
+        <span>selected question</span>
+        <strong>요약 지표</strong>
+      </header>
+      <div className="metric-card-grid">
+        <MetricItem label="응답 수" value={`${count.toLocaleString()}개`} />
+        <MetricItem label="척도" value={`${scale}점`} />
+        <MetricItem label="평균" value={formatNumber(mean)} />
+        <MetricItem label="긍정률" value={formatPercent(positiveShare)} />
+      </div>
+    </section>
+  );
+}
+
+function OpenAnswerPanel({ result, questionId }: { result: SiliconResult; questionId: string }) {
+  const answers = result.openAnswers.filter((answer) => answer.questionId === questionId);
+  return (
+    <section className="silicon-open-panel" data-testid="silicon-open-answers">
+      <header>
+        <span>open-ended answers</span>
+        <strong>실제 LLM 답안</strong>
+      </header>
+      <div className="silicon-answer-list">
+        {answers.slice(0, 18).map((answer) => {
+          const respondent = result.respondents.find((item) => item.id === answer.respondentId);
+          return (
+            <article key={`${answer.questionId}-${answer.respondentId}`}>
+              <span>{respondent?.id} · {respondent?.locationLabel} · {labelOf(AGE_BANDS, respondent?.age)} · {labelOf(GENDERS, respondent?.gender)} · {personaSummary(respondent)}</span>
+              <p>{answer.text}</p>
+            </article>
+          );
+        })}
+      </div>
+    </section>
+  );
+}
+
+function ChartCard({ title, subtitle, option }: { title: string; subtitle: string; option: Record<string, unknown> }) {
+  const ref = useRef<HTMLDivElement | null>(null);
+  useEffect(() => {
+    if (!ref.current) return undefined;
+    const chart = init(ref.current, undefined, { renderer: "canvas" });
+    chart.setOption({ backgroundColor: "transparent", ...option });
+    const observer = new ResizeObserver(() => chart.resize());
+    observer.observe(ref.current);
+    return () => {
+      observer.disconnect();
+      chart.dispose();
+    };
+  }, [option]);
+  return (
+    <section className="silicon-chart-card">
+      <header>
+        <span>{subtitle}</span>
+        <strong>{title}</strong>
+      </header>
+      <div ref={ref} className="silicon-chart" />
+    </section>
+  );
+}
+
+function ResponseTable({ result, questionId }: { result: SiliconResult; questionId: string }) {
+  const question = result.config.questions.find((item) => item.id === questionId);
+  if (!question) return null;
+  const likertByRespondent = new Map(result.likertAnswers.filter((answer) => answer.questionId === questionId).map((answer) => [answer.respondentId, answer.value]));
+  const openByRespondent = new Map(result.openAnswers.filter((answer) => answer.questionId === questionId).map((answer) => [answer.respondentId, answer.text]));
+  const rows = result.respondents
+    .map((respondent) => ({
+      respondent,
+      value: question.kind === "likert" ? likertByRespondent.get(respondent.id) : openByRespondent.get(respondent.id),
+    }))
+    .filter((row) => row.value !== undefined);
+  return (
+    <section className="silicon-response-table-card" data-testid="silicon-response-table">
+      <header>
+        <span>response table</span>
+        <strong>문항별 개별 응답과 persona 속성</strong>
+      </header>
+      <div className="silicon-response-table-scroll">
+        <table className="silicon-response-table">
+          <thead>
+            <tr>
+              <th>응답자</th>
+              <th>인구통계</th>
+              <th>직업</th>
+              <th>학력</th>
+              <th>주거</th>
+              <th>혼인</th>
+              <th>가구</th>
+              <th>{question.kind === "likert" ? "점수" : "답변"}</th>
+            </tr>
+          </thead>
+          <tbody>
+            {rows.map(({ respondent, value }) => (
+              <tr key={`${questionId}-${respondent.id}`}>
+                <td>{respondent.id}</td>
+                <td>{respondent.locationLabel} · {labelOf(AGE_BANDS, respondent.age)} · {labelOf(GENDERS, respondent.gender)}</td>
+                <td>{respondent.personaLabels.occupation || "-"}</td>
+                <td>{respondent.personaLabels.education || "-"}</td>
+                <td>{respondent.personaLabels.housing || "-"}</td>
+                <td>{respondent.personaLabels.marital || "-"}</td>
+                <td>{respondent.personaLabels.family || "-"}</td>
+                <td>{question.kind === "likert" ? `${value}점` : String(value)}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+    </section>
+  );
+}
+
+function MetricItem({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="metric-card-item">
+      <span>{label}</span>
+      <strong>{value}</strong>
+    </div>
+  );
+}
+
+function breakdownOption(rows: ReturnType<typeof resultBreakdown>, metricMode: MetricMode) {
+  const isPositive = metricMode === "positive";
+  return {
+    color: [isPositive ? "#f08a6c" : "#5b6ee1"],
+    tooltip: tooltip((value) => isPositive ? `${Math.round(Number(value) * 100)}%` : `${Number(value).toFixed(2)}`),
+    grid: { ...grid(), left: 68 },
+    xAxis: {
+      type: "value",
+      max: isPositive ? 1 : undefined,
+      axisLabel: { ...axisLabel(), formatter: isPositive ? (value: number) => `${Math.round(value * 100)}%` : undefined },
+      splitLine: splitLine(),
+    },
+    yAxis: { type: "category", data: rows.map((item) => item.label), axisLabel: axisLabel() },
+    series: [{
+      type: "bar",
+      data: rows.map((item) => Number((isPositive ? item.positiveShare : item.mean).toFixed(3))),
+      barWidth: "54%",
+      itemStyle: { borderRadius: [0, 8, 8, 0] },
+    }],
+  };
+}
+
+function tooltip(formatter?: (value: unknown) => string) {
+  return {
+    trigger: "item",
+    backgroundColor: "rgba(255, 255, 255, .96)",
+    borderColor: "rgba(84, 96, 137, .18)",
+    textStyle: { color: "#18213a" },
+    valueFormatter: formatter,
+  };
+}
+
+function grid() {
+  return { left: 34, right: 18, top: 28, bottom: 32 };
+}
+
+function axisLabel() {
+  return { color: "rgba(24, 33, 58, .58)", fontSize: 11 };
+}
+
+function splitLine() {
+  return { lineStyle: { color: "rgba(84, 96, 137, .12)" } };
+}
+
+function labelOf<T extends string>(items: Array<{ id: T; label: string }>, id?: T) {
+  return items.find((item) => item.id === id)?.label || id || "-";
+}
+
+function modeLabel(mode: Breakdown) {
+  if (mode === "gender") return "성별";
+  if (mode === "age") return "연령대";
+  if (mode === "region") return "지역";
+  if (mode === "occupation") return "직업";
+  if (mode === "education") return "학력";
+  if (mode === "housing") return "주거";
+  if (mode === "marital") return "혼인";
+  if (mode === "family") return "가구";
+  return "전체";
+}
+
+function personaSummary(respondent?: SyntheticRespondent) {
+  if (!respondent) return "persona 없음";
+  return [
+    respondent.personaLabels.occupation,
+    respondent.personaLabels.education,
+    respondent.personaLabels.housing,
+    respondent.personaLabels.marital,
+    respondent.personaLabels.family,
+  ].filter(Boolean).join(" · ") || "persona 없음";
+}
+
+function formatNumber(value?: number) {
+  return typeof value === "number" && Number.isFinite(value) ? value.toFixed(2) : "-";
+}
+
+function formatPercent(value?: number) {
+  return typeof value === "number" && Number.isFinite(value) ? `${Math.round(value * 100)}%` : "-";
+}

frontend/src/silicon/SiliconSamplingApp.tsx

@@ -0,0 +1,1043 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { BarChart3, ChevronDown, ListChecks, Play, Plus, RotateCw, SlidersHorizontal, Wand2 } from "lucide-react";
+import { AGE_BANDS, GENDERS, LOCATION_OPTIONS, PERSONA_OPTIONS, SURVEY_BANK } from "./data";
+import { SiliconCharts } from "./SiliconCharts";
+import { selectedWeightTotal } from "./simulate";
+import type { AgeBandId, GenderId, LocationId, LocationOption, PersonaAttributeId, PersonaDimensionId, QuestionKind, RegionId, SiliconConfig, SiliconResult, SurveyQuestion, WeightedPick } from "./types";
+
+declare global {
+  interface Window {
+    __siliconValidation?: {
+      getState: () => Record<string, unknown>;
+      run: () => void;
+    };
+  }
+}
+
+const SAMPLE_PRESETS = [10, 20, 100, 1000, 3000];
+const MIN_SAMPLE_SIZE = 1;
+const MAX_SAMPLE_SIZE = 3000;
+const SIDO_LOCATION_OPTIONS = LOCATION_OPTIONS.filter((location) => location.level === "sido");
+const FALLBACK_NEMOTRON_COLUMNS = [
+  "professional_persona",
+  "sports_persona",
+  "arts_persona",
+  "travel_persona",
+  "culinary_persona",
+  "family_persona",
+  "persona",
+  "cultural_background",
+  "skills_and_expertise",
+  "skills_and_expertise_list",
+  "hobbies_and_interests",
+  "hobbies_and_interests_list",
+  "career_goals_and_ambitions",
+  "sex",
+  "age",
+  "marital_status",
+  "military_status",
+  "family_type",
+  "housing_type",
+  "education_level",
+  "bachelors_field",
+  "occupation",
+  "district",
+  "province",
+  "country",
+];
+const TEXT_NEMOTRON_COLUMNS = new Set([
+  "persona",
+  "professional_persona",
+  "sports_persona",
+  "arts_persona",
+  "travel_persona",
+  "culinary_persona",
+  "family_persona",
+  "cultural_background",
+  "skills_and_expertise",
+  "skills_and_expertise_list",
+  "hobbies_and_interests",
+  "hobbies_and_interests_list",
+  "career_goals_and_ambitions",
+]);
+const NEMOTRON_COLUMN_LABELS: Record<string, string> = {
+  professional_persona: "직업 서사",
+  sports_persona: "스포츠 관심",
+  arts_persona: "예술 관심",
+  travel_persona: "여행 성향",
+  culinary_persona: "식생활 성향",
+  family_persona: "가족 서사",
+  persona: "종합 페르소나",
+  cultural_background: "문화 배경",
+  skills_and_expertise: "기술/전문성",
+  skills_and_expertise_list: "기술 목록",
+  hobbies_and_interests: "취미/관심사",
+  hobbies_and_interests_list: "취미 목록",
+  career_goals_and_ambitions: "진로 목표",
+  sex: "성별",
+  age: "나이",
+  marital_status: "혼인 상태",
+  military_status: "병역 상태",
+  family_type: "가구 형태",
+  housing_type: "주거 형태",
+  education_level: "학력",
+  bachelors_field: "전공",
+  occupation: "직업",
+  district: "시군구",
+  province: "시도",
+  country: "국가",
+};
+const PERSONA_DIMENSIONS: Array<{ id: PersonaDimensionId; label: string }> = [
+  { id: "occupation", label: "직업" },
+  { id: "education", label: "학력" },
+  { id: "housing", label: "주거" },
+  { id: "marital", label: "혼인" },
+  { id: "family", label: "가구" },
+];
+
+type CountRow = { value: string; count: number };
+type NemotronMetadata = {
+  columns?: string[];
+  sex_counts?: CountRow[];
+  age_buckets?: CountRow[];
+  province_counts?: CountRow[];
+  district_counts_by_province?: Record<string, CountRow[]>;
+  occupation_counts?: CountRow[];
+  education_counts?: CountRow[];
+};
+
+export function SiliconSamplingApp() {
+  const [sampleSize, setSampleSize] = useState(10);
+  const previousSampleSize = useRef(10);
+  const [genderPicks, setGenderPicks] = useState(() => emptyPicks(GENDERS));
+  const [agePicks, setAgePicks] = useState(() => emptyPicks(AGE_BANDS));
+  const [locationOptions, setLocationOptions] = useState<LocationOption[]>(() => SIDO_LOCATION_OPTIONS);
+  const [locationPicks, setLocationPicks] = useState(() => emptyPicks(SIDO_LOCATION_OPTIONS));
+  const [personaPicks, setPersonaPicks] = useState(() => emptyPicks(PERSONA_OPTIONS));
+  const [nemotronColumns, setNemotronColumns] = useState(() => FALLBACK_NEMOTRON_COLUMNS);
+  const [selectedNemotronFields, setSelectedNemotronFields] = useState(() => FALLBACK_NEMOTRON_COLUMNS);
+  const [datasetMetadata, setDatasetMetadata] = useState<NemotronMetadata | null>(null);
+  const [selectedQuestionIds, setSelectedQuestionIds] = useState<string[]>([]);
+  const [customQuestions, setCustomQuestions] = useState<SurveyQuestion[]>([]);
+  const [customTitle, setCustomTitle] = useState("");
+  const [customKind, setCustomKind] = useState<QuestionKind>("likert");
+  const [customScale, setCustomScale] = useState<4 | 5 | 7>(5);
+  const [questionBankOpen, setQuestionBankOpen] = useState(true);
+  const [seed, setSeed] = useState(20260629);
+  const [result, setResult] = useState<SiliconResult | null>(null);
+  const [isRunning, setIsRunning] = useState(false);
+  const [runStatus, setRunStatus] = useState("설정을 선택한 뒤 실행하세요.");
+  const [defaultRatioStatus, setDefaultRatioStatus] = useState("응답자 수를 정한 뒤 기본 비율을 적용할 수 있습니다.");
+  const questions = useMemo(
+    () => [...SURVEY_BANK.filter((question) => selectedQuestionIds.includes(question.id)), ...customQuestions],
+    [customQuestions, selectedQuestionIds],
+  );
+  const config = useMemo<SiliconConfig>(() => ({
+    sampleSize,
+    genders: genderPicks,
+    ages: agePicks,
+    locations: locationPicks,
+    locationOptions,
+    personaAttributes: personaPicks,
+    nemotronFields: selectedNemotronFields,
+    questions,
+    seed,
+  }), [agePicks, genderPicks, locationOptions, locationPicks, personaPicks, questions, sampleSize, seed, selectedNemotronFields]);
+  const likertCount = questions.filter((question) => question.kind === "likert").length;
+  const openCount = questions.filter((question) => question.kind === "open").length;
+  const displayLikertCount = result ? result.config.questions.filter((question) => question.kind === "likert").length : likertCount;
+  const displayOpenCount = result ? result.config.questions.filter((question) => question.kind === "open").length : openCount;
+  const displayLocationCount = result ? result.regionStats.filter((item) => item.respondents > 0).length : locationPicks.filter((item) => item.enabled).length;
+  const missingRequirements = missingRunRequirements(genderPicks, agePicks, locationPicks, questions);
+  const canRun = !isRunning && missingRequirements.length === 0;
+
+  useEffect(() => {
+    let cancelled = false;
+    fetch("/api/persona-dataset/metadata")
+      .then((response) => response.ok ? response.json() : Promise.reject(new Error(`HTTP ${response.status}`)))
+      .then((metadata: NemotronMetadata) => {
+        if (cancelled) return;
+        const columns = usableNemotronColumns(metadata.columns);
+        const nextLocationOptions = buildLocationOptionsFromMetadata(metadata);
+        setDatasetMetadata(metadata);
+        setNemotronColumns(columns);
+        setSelectedNemotronFields((fields) => {
+          const current = fields.length ? fields : columns;
+          const selectedEverything = current.length === nemotronColumns.length && nemotronColumns.every((column) => current.includes(column));
+          return selectedEverything ? columns : current.filter((field) => columns.includes(field));
+        });
+        setLocationOptions(nextLocationOptions);
+        setLocationPicks((picks) => mergePicks(nextLocationOptions, picks));
+      })
+      .catch(() => {
+        if (!cancelled) setDatasetMetadata(null);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  useEffect(() => {
+    const previous = previousSampleSize.current;
+    if (previous === sampleSize) return;
+    setGenderPicks((picks) => rescalePicksToTotal(picks, sampleSize));
+    setAgePicks((picks) => rescalePicksToTotal(picks, sampleSize));
+    setLocationPicks((picks) => rescalePicksToTotal(picks, sampleSize));
+    setPersonaPicks((picks) => rescalePersonaPicksToTotal(picks, sampleSize));
+    previousSampleSize.current = sampleSize;
+  }, [sampleSize]);
+
+  const run = async () => {
+    if (!canRun) {
+      setRunStatus(`실행 전 필요 항목: ${missingRequirements.join(", ")}`);
+      return;
+    }
+    setIsRunning(true);
+    setResult(null);
+    setRunStatus("페르소나별 LLM agent가 모든 문항에 답하는 중입니다.");
+    try {
+      const response = await fetch("/api/silicon/llm-run", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ config: { ...config, seed: seed + 1 }, execution: { max_agents: sampleSize } }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload?.error || `HTTP ${response.status}`);
+      setResult(payload as SiliconResult);
+      setSeed((value) => value + 1);
+      setRunStatus("시뮬레이션이 완료되었습니다.");
+    } catch (error) {
+      setRunStatus(`LLM 시뮬레이션 실패: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      setIsRunning(false);
+    }
+  };
+  const reset = () => {
+    setSampleSize(10);
+    previousSampleSize.current = 10;
+    setGenderPicks(emptyPicks(GENDERS));
+    setAgePicks(emptyPicks(AGE_BANDS));
+    setLocationPicks(emptyPicks(locationOptions));
+    setPersonaPicks(emptyPicks(PERSONA_OPTIONS));
+    setSelectedNemotronFields(nemotronColumns);
+    setSelectedQuestionIds([]);
+    setCustomQuestions([]);
+    setCustomTitle("");
+    setCustomKind("likert");
+    setCustomScale(5);
+    setSeed(20260629);
+    setResult(null);
+    setIsRunning(false);
+    setRunStatus("설정을 선택한 뒤 실행하세요.");
+    setDefaultRatioStatus("모든 선택값을 초기화했습니다.");
+  };
+  const applyDefaultRatios = async () => {
+    setDefaultRatioStatus("Nemotron-Personas-Korea metadata를 불러오는 중입니다.");
+    try {
+      const metadata = datasetMetadata || await fetchMetadata();
+      const columns = usableNemotronColumns(metadata.columns);
+      const nextLocationOptions = buildLocationOptionsFromMetadata(metadata);
+      const hadAllColumnsSelected = selectedNemotronFields.length === nemotronColumns.length && nemotronColumns.every((column) => selectedNemotronFields.includes(column));
+      const effectiveFields = hadAllColumnsSelected ? columns : selectedNemotronFields.filter((field) => columns.includes(field));
+      const fieldSet = new Set(effectiveFields);
+      setDatasetMetadata(metadata);
+      setNemotronColumns(columns);
+      setSelectedNemotronFields(effectiveFields);
+      setLocationOptions(nextLocationOptions);
+      setGenderPicks(fieldSet.has("sex") ? applyCountsToPicks(GENDERS, metadata.sex_counts, mapSexCount, sampleSize) : emptyPicks(GENDERS));
+      setAgePicks(fieldSet.has("age") ? applyCountsToPicks(AGE_BANDS, metadata.age_buckets, mapAgeCount, sampleSize) : emptyPicks(AGE_BANDS));
+      setLocationPicks(fieldSet.has("province") ? applyCountsToPicks(nextLocationOptions, metadata.province_counts, mapProvinceCount, sampleSize) : emptyPicks(nextLocationOptions));
+      setPersonaPicks(applyPersonaDefaults(metadata, fieldSet, sampleSize));
+      setDefaultRatioStatus(`선택된 Nemotron 컬럼 ${effectiveFields.length}개 기준으로 ${sampleSize.toLocaleString()}명을 할당했습니다.`);
+      setRunStatus("기본 비율이 적용되었습니다. 문항을 확인하고 실행하세요.");
+    } catch (error) {
+      const fieldSet = new Set(selectedNemotronFields);
+      setGenderPicks(fieldSet.has("sex") ? defaultCountPicks(GENDERS, sampleSize) : emptyPicks(GENDERS));
+      setAgePicks(fieldSet.has("age") ? defaultCountPicks(AGE_BANDS, sampleSize) : emptyPicks(AGE_BANDS));
+      setLocationPicks(fieldSet.has("province") ? defaultCountPicks(SIDO_LOCATION_OPTIONS, sampleSize) : emptyPicks(locationOptions));
+      setPersonaPicks(applyPersonaDefaults({}, fieldSet, sampleSize));
+      setDefaultRatioStatus(`metadata를 불러오지 못해 내장 기본 비율을 적용했습니다.`);
+      setRunStatus("내장 기본 비율이 적용되었습니다. 문항을 확인하고 실행하세요.");
+    }
+  };
+  const addCustomQuestion = () => {
+    const title = customTitle.trim();
+    if (!title) return;
+    const question: SurveyQuestion = {
+      id: `custom_${Date.now().toString(36)}`,
+      title,
+      source: "사용자 추가 문항",
+      category: customKind === "likert" ? "사용자 Likert" : "사용자 자유응답",
+      kind: customKind,
+      scale: customKind === "likert" ? customScale : undefined,
+      lowLabel: customKind === "likert" ? "낮음" : undefined,
+      highLabel: customKind === "likert" ? "높음" : undefined,
+    };
+    setCustomQuestions((items) => [...items, question]);
+    setCustomTitle("");
+  };
+
+  useEffect(() => {
+    window.__siliconValidation = {
+      getState: () => ({
+        sampleSize,
+        genderEnabled: genderPicks.filter((item) => item.enabled).length,
+        ageEnabled: agePicks.filter((item) => item.enabled).length,
+        locationEnabled: locationPicks.filter((item) => item.enabled).length,
+        personaEnabled: personaPicks.filter((item) => item.enabled).length,
+        nemotronColumns: nemotronColumns.length,
+        nemotronSelected: selectedNemotronFields.length,
+        locationOptionCount: locationOptions.length,
+        districtOptionCount: locationOptions.filter((location) => location.level === "district").length,
+        questionCount: questions.length,
+        likertCount,
+        openCount,
+        resultQuestionCount: result?.config.questions.length || 0,
+        resultLikertCount: result?.config.questions.filter((question) => question.kind === "likert").length || 0,
+        resultOpenCount: result?.config.questions.filter((question) => question.kind === "open").length || 0,
+        respondentCount: result?.respondents.length || 0,
+        genderCounts: result ? countBy(result.respondents.map((respondent) => respondent.gender)) : {},
+        genderAllocations: Object.fromEntries(genderPicks.filter((item) => item.enabled).map((item) => [item.id, item.weight])),
+        openAnswerCount: result?.openAnswers.length || 0,
+        regionStats: result?.regionStats.length || 0,
+        isRunning,
+        hasResult: Boolean(result),
+        setupMode: !isRunning && !result,
+        chartCards: document.querySelectorAll(".silicon-chart-card").length,
+        customQuestionVisible: customQuestions.length ? Boolean(document.querySelector("[data-testid='silicon-custom-question-list']")) : true,
+        samplePresetLabels: SAMPLE_PRESETS.map((value) => `${value}명`),
+        questionBankOpen,
+      }),
+      run,
+    };
+  }, [agePicks, customQuestions.length, genderPicks, isRunning, likertCount, locationOptions, locationPicks, nemotronColumns.length, openCount, personaPicks, questionBankOpen, questions.length, result, sampleSize, selectedNemotronFields.length]);
+
+  return (
+    <main className={!isRunning && !result ? "silicon-shell setup-only" : "silicon-shell has-results"}>
+      <section className="silicon-config">
+        <header className="silicon-hero">
+          <a href="/" className="silicon-brand">
+            <span />
+            <strong>Silicon Sampling Lab</strong>
+          </a>
+          <h1>한국 설문 Silicon Sampling</h1>
+          <p>성별, 연령, 지역, 문항을 토글과 숫자로 설정한 뒤 실행해 통계 결과를 확인합니다.</p>
+          <div className="silicon-actions">
+            <button data-testid="silicon-run-button" type="button" onClick={run} className="primary" disabled={!canRun}><Play size={16} /> 시뮬레이션 실행</button>
+            <button data-testid="silicon-reset-button" type="button" onClick={reset}><RotateCw size={16} /> 초기화</button>
+          </div>
+          <div className={isRunning ? "silicon-run-chip running" : "silicon-run-chip"} data-testid="silicon-run-status">{runStatus}</div>
+        </header>
+
+        <div className="silicon-setup-grid">
+        <section className="silicon-card sample-card">
+          <div className="silicon-section-head">
+            <SlidersHorizontal size={16} />
+            <div>
+              <span>sample size</span>
+              <strong>응답자 수</strong>
+            </div>
+          </div>
+          <div className="sample-presets">
+            {SAMPLE_PRESETS.map((value) => (
+              <button key={value} type="button" className={sampleSize === value ? "active" : ""} onClick={() => setSampleSize(value)}>{value.toLocaleString()}명</button>
+            ))}
+          </div>
+          <label className="number-field">
+            <span>직접 입력</span>
+            <input data-testid="silicon-sample-input" type="number" min={MIN_SAMPLE_SIZE} max={MAX_SAMPLE_SIZE} step={1} value={sampleSize} onChange={(event) => setSampleSize(clampNumber(event.target.value, MIN_SAMPLE_SIZE, MAX_SAMPLE_SIZE))} />
+          </label>
+          <div className="default-ratio-box">
+            <button data-testid="silicon-default-ratio-button" type="button" onClick={applyDefaultRatios}><Wand2 size={15} /> 기본 비율 적용</button>
+            <span>{defaultRatioStatus}</span>
+          </div>
+        </section>
+
+        <ToggleGroup title="성별" subtitle="복수 선택, 실제 명수 합계 기준" items={GENDERS} picks={genderPicks} onChange={setGenderPicks} total={selectedWeightTotal(genderPicks)} sampleSize={sampleSize} />
+        <ToggleGroup title="연령" subtitle="20대, 30대 단위, 실제 명수 합계 기준" items={AGE_BANDS} picks={agePicks} onChange={setAgePicks} total={selectedWeightTotal(agePicks)} sampleSize={sampleSize} />
+        <LocationSelector picks={locationPicks} onChange={setLocationPicks} sampleSize={sampleSize} locationOptions={locationOptions} />
+        <PersonaSelector picks={personaPicks} onChange={setPersonaPicks} sampleSize={sampleSize} />
+        <NemotronColumnSelector columns={nemotronColumns} selected={selectedNemotronFields} onChange={setSelectedNemotronFields} />
+
+        <section className="silicon-card question-card">
+          <div className="silicon-section-head">
+            <ListChecks size={16} />
+            <div>
+              <span>survey items</span>
+              <strong>대표 설문 문항</strong>
+            </div>
+            <button
+              type="button"
+              className={questionBankOpen ? "question-bank-toggle open" : "question-bank-toggle"}
+              data-testid="survey-bank-toggle"
+              aria-expanded={questionBankOpen}
+              onClick={() => setQuestionBankOpen((value) => !value)}
+            >
+              <ChevronDown size={15} />
+              {questionBankOpen ? "접기" : "열기"}
+            </button>
+          </div>
+          {questionBankOpen ? (
+            <div className="question-bank" data-testid="survey-bank-list">
+              {SURVEY_BANK.map((question) => (
+                <button
+                  key={question.id}
+                  type="button"
+                  className={[
+                    selectedQuestionIds.includes(question.id) ? "selected" : "",
+                    question.kind === "likert" ? "kind-likert" : "kind-open",
+                  ].filter(Boolean).join(" ")}
+                  onClick={() => setSelectedQuestionIds((ids) => ids.includes(question.id) ? ids.filter((id) => id !== question.id) : [...ids, question.id])}
+                >
+                  <span>{question.category} · {question.kind === "likert" ? `${question.scale}점` : "자유응답"}</span>
+                  <strong>{question.title}</strong>
+                  <em>{question.source}</em>
+                </button>
+              ))}
+            </div>
+          ) : null}
+          <div className="custom-question">
+            <div className="custom-kind">
+              <button type="button" className={customKind === "likert" ? "active" : ""} onClick={() => setCustomKind("likert")}>Likert</button>
+              <button type="button" className={customKind === "open" ? "active" : ""} onClick={() => setCustomKind("open")}>Open-ended</button>
+              {customKind === "likert" ? (
+                <select value={customScale} onChange={(event) => setCustomScale(Number(event.target.value) as 4 | 5 | 7)}>
+                  <option value={4}>4점</option>
+                  <option value={5}>5점</option>
+                  <option value={7}>7점</option>
+                </select>
+              ) : null}
+            </div>
+            <label>
+              <span>문항 추가</span>
+              <input data-testid="silicon-custom-question-input" value={customTitle} onChange={(event) => setCustomTitle(event.target.value)} placeholder="예: 지역 의료 접근성에 만족하십니까?" />
+            </label>
+            <button data-testid="silicon-custom-question-add" type="button" onClick={addCustomQuestion}><Plus size={15} /> 추가</button>
+          </div>
+          {customQuestions.length ? (
+            <div className="custom-question-list" data-testid="silicon-custom-question-list">
+              <span>추가한 문항</span>
+              {customQuestions.map((question) => (
+                <article key={question.id} className={question.kind === "likert" ? "kind-likert" : "kind-open"}>
+                  <em>{question.kind === "likert" ? `${question.scale}점 Likert` : "Open-ended"}</em>
+                  <strong>{question.title}</strong>
+                </article>
+              ))}
+            </div>
+          ) : null}
+        </section>
+        </div>
+      </section>
+
+      {(isRunning || result) ? <section className="silicon-results">
+        <header className="silicon-result-head">
+          <div>
+            <span>result dashboard</span>
+            <h2>{result ? `${result.respondents.length.toLocaleString()}명 결과` : "실행 대기"}</h2>
+          </div>
+          <div className="result-stats">
+            <span><strong>{displayLikertCount}</strong> Likert</span>
+            <span><strong>{displayOpenCount}</strong> open-ended</span>
+            <span><strong>{displayLocationCount}</strong> locations</span>
+          </div>
+        </header>
+        {isRunning ? <SimulationRunning status={runStatus} /> : null}
+        {!isRunning && !result ? <SimulationEmptyState /> : null}
+        {result ? (
+          <>
+          <section className="silicon-summary-panel">
+            <header>
+              <BarChart3 size={16} />
+              <div>
+                <span>statistical readout</span>
+                <strong>주요 결과</strong>
+              </div>
+            </header>
+            <Metric label="평균 점수" value={formatNumber(result.questionStats.find((item) => item.questionId === result.primaryQuestionId)?.mean)} />
+            <Metric label="긍정 응답률" value={formatPercent(result.questionStats.find((item) => item.questionId === result.primaryQuestionId)?.positiveShare)} />
+            <Metric label="자유응답 수" value={`${result.openAnswers.length.toLocaleString()}개`} />
+            <Metric label="최다 응답 지역" value={topRegion(result)} />
+            <div className="method-note">
+              <BarChart3 size={15} />
+              <span>가중 토글 분포에서 persona-agent를 만들고, 각 agent가 모든 문항에 LLM으로 응답한 뒤 문항별 통계를 집계합니다.</span>
+            </div>
+          </section>
+          <SiliconCharts result={result} />
+          </>
+        ) : null}
+      </section> : null}
+    </main>
+  );
+}
+
+function ToggleGroup<T extends GenderId | AgeBandId>({
+  title,
+  subtitle,
+  items,
+  picks,
+  onChange,
+  total,
+  sampleSize,
+  compact = false,
+}: {
+  title: string;
+  subtitle: string;
+  items: Array<{ id: T; label: string; defaultWeight: number }>;
+  picks: WeightedPick<T>[];
+  onChange: (next: WeightedPick<T>[]) => void;
+  total: number;
+  sampleSize: number;
+  compact?: boolean;
+}) {
+  const update = (id: T, patch: Partial<WeightedPick<T>>) => onChange(picks.map((pick) => pick.id === id ? { ...pick, ...patch } : pick));
+  return (
+    <section className="silicon-card">
+      <div className="toggle-head">
+        <div>
+          <span>{subtitle}</span>
+          <strong>{title}</strong>
+        </div>
+        <em>합계 {total.toLocaleString()}명</em>
+      </div>
+      <div className={compact ? "toggle-grid compact" : "toggle-grid"}>
+        {items.map((item) => {
+          const pick = picks.find((entry) => entry.id === item.id) || { id: item.id, enabled: false, weight: item.defaultWeight };
+          return (
+            <div key={item.id} className={pick.enabled ? "toggle-chip active" : "toggle-chip"}>
+              <button type="button" onClick={() => update(item.id, { enabled: !pick.enabled })}>{item.label}</button>
+              <input
+                aria-label={`${item.label} 명수`}
+                type="number"
+                min={0}
+                max={sampleSize}
+                value={pick.enabled ? pick.weight : ""}
+                disabled={!pick.enabled}
+                onChange={(event) => update(item.id, { weight: clampNumber(event.target.value, 0, sampleSize) })}
+              />
+              <span className="estimate-count">{pick.enabled ? formatShare(pick.weight, sampleSize) : ""}</span>
+            </div>
+          );
+        })}
+      </div>
+    </section>
+  );
+}
+
+function LocationSelector({
+  picks,
+  onChange,
+  sampleSize,
+  locationOptions,
+}: {
+  picks: WeightedPick<LocationId>[];
+  onChange: (next: WeightedPick<LocationId>[]) => void;
+  sampleSize: number;
+  locationOptions: LocationOption[];
+}) {
+  const [sidoOpen, setSidoOpen] = useState(false);
+  const [activeParent, setActiveParent] = useState<RegionId | null>(null);
+  const selectedParents = locationOptions
+    .filter((location) => location.level === "sido" && picks.find((pick) => pick.id === location.id)?.enabled)
+    .map((location) => location.id as RegionId);
+  const enabledCount = picks.filter((pick) => pick.enabled).length;
+  useEffect(() => {
+    if (enabledCount > 0) setSidoOpen(true);
+  }, [enabledCount]);
+  useEffect(() => {
+    if (activeParent && selectedParents.includes(activeParent)) return;
+    setActiveParent(selectedParents[0] || null);
+  }, [activeParent, selectedParents]);
+  const sidoOptions = locationOptions.filter((location) => location.level === "sido");
+  const activeDistricts = activeParent
+    ? locationOptions.filter((location) => location.level === "district" && location.parentRegion === activeParent)
+    : [];
+  const total = selectedWeightTotal(picks);
+  const update = (id: LocationId, patch: Partial<WeightedPick<LocationId>>) => {
+    const option = locationOptions.find((location) => location.id === id);
+    const next = picks.map((pick) => {
+      if (pick.id === id) return { ...pick, ...patch };
+      if (option?.level === "sido" && patch.enabled === false) {
+        const child = locationOptions.find((location) => location.id === pick.id);
+        if (child?.level === "district" && child.parentRegion === option.parentRegion) return { ...pick, enabled: false };
+      }
+      return pick;
+    });
+    if (option?.level === "sido" && patch.enabled !== false) setActiveParent(option.parentRegion);
+    onChange(next);
+  };
+  return (
+    <section className="silicon-card location-card">
+      <div className="toggle-head">
+        <div>
+          <span>시도를 먼저 선택하면 해당 시도의 실제 Nemotron 세부지역만 표시</span>
+          <strong>지역</strong>
+        </div>
+        <em>합계 {total.toLocaleString()}명</em>
+      </div>
+      <div className="location-tabs">
+        <button type="button" className={sidoOpen ? "active" : ""} data-testid="location-tab-sido" onClick={() => setSidoOpen((value) => !value)}>시도 선택</button>
+      </div>
+      {sidoOpen ? (
+        <div className="location-toggle-grid" data-testid="silicon-location-allocation">
+          {sidoOptions.map((location) => (
+            <WeightedOptionChip
+              key={location.id}
+              item={location}
+              pick={picks.find((pick) => pick.id === location.id) || { id: location.id, enabled: false, weight: location.defaultWeight }}
+              onChange={(patch) => update(location.id, patch)}
+              sampleSize={sampleSize}
+            />
+          ))}
+        </div>
+      ) : (
+        <p className="selector-empty-note" data-testid="silicon-location-empty">시도 선택을 누르면 목록이 열립니다.</p>
+      )}
+      {selectedParents.length ? (
+        <div className="location-detail-panel">
+          <div className="location-detail-tabs" data-testid="silicon-location-parent-tabs">
+            {selectedParents.map((parent) => (
+              <button key={parent} type="button" className={activeParent === parent ? "active" : ""} data-testid={`location-parent-${parent}`} onClick={() => setActiveParent(parent)}>
+                {locationLabel(parent)}
+              </button>
+            ))}
+          </div>
+          {activeDistricts.length ? (
+            <div className="location-toggle-grid detail-grid" data-testid="silicon-location-detail-allocation">
+              {activeDistricts.map((location) => (
+                <WeightedOptionChip
+                  key={location.id}
+                  item={location}
+                  pick={picks.find((pick) => pick.id === location.id) || { id: location.id, enabled: false, weight: location.defaultWeight }}
+                  onChange={(patch) => update(location.id, patch)}
+                  sampleSize={sampleSize}
+                />
+              ))}
+            </div>
+          ) : (
+            <p className="selector-empty-note">선택한 시도에 연결된 세부지역이 없습니다.</p>
+          )}
+        </div>
+      ) : null}
+    </section>
+  );
+}
+
+function PersonaSelector({ picks, onChange, sampleSize }: { picks: WeightedPick<PersonaAttributeId>[]; onChange: (next: WeightedPick<PersonaAttributeId>[]) => void; sampleSize: number }) {
+  const [dimension, setDimension] = useState<PersonaDimensionId>("occupation");
+  const available = PERSONA_OPTIONS.filter((option) => option.dimension === dimension);
+  const total = selectedWeightTotal(picks.filter((pick) => available.some((option) => option.id === pick.id)));
+  const update = (id: PersonaAttributeId, patch: Partial<WeightedPick<PersonaAttributeId>>) => onChange(picks.map((pick) => pick.id === id ? { ...pick, ...patch } : pick));
+  return (
+    <section className="silicon-card persona-card">
+      <div className="toggle-head">
+        <div>
+          <span>직업, 학력, 주거 등 persona 항목별 실제 명수 선택</span>
+          <strong>페르소나 속성</strong>
+        </div>
+        <em>{dimensionLabel(dimension)} 합계 {total.toLocaleString()}명</em>
+      </div>
+      <div className="location-tabs">
+        {PERSONA_DIMENSIONS.map((item) => (
+          <button key={item.id} type="button" className={dimension === item.id ? "active" : ""} data-testid={`persona-tab-${item.id}`} onClick={() => setDimension(item.id)}>{item.label}</button>
+        ))}
+      </div>
+      <div className="location-toggle-grid persona-toggle-grid" data-testid="silicon-persona-allocation">
+        {available.map((option) => (
+          <WeightedOptionChip
+            key={option.id}
+            item={option}
+            pick={picks.find((pick) => pick.id === option.id) || { id: option.id, enabled: false, weight: option.defaultWeight }}
+            onChange={(patch) => update(option.id, patch)}
+            sampleSize={sampleSize}
+          />
+        ))}
+      </div>
+    </section>
+  );
+}
+
+function NemotronColumnSelector({
+  columns,
+  selected,
+  onChange,
+}: {
+  columns: string[];
+  selected: string[];
+  onChange: (next: string[]) => void;
+}) {
+  const selectedSet = new Set(selected);
+  const demographicColumns = columns.filter((column) => !TEXT_NEMOTRON_COLUMNS.has(column));
+  const textColumns = columns.filter((column) => TEXT_NEMOTRON_COLUMNS.has(column));
+  const toggle = (column: string) => {
+    onChange(selectedSet.has(column) ? selected.filter((item) => item !== column) : [...selected, column]);
+  };
+  return (
+    <section className="silicon-card nemotron-card">
+      <div className="toggle-head">
+        <div>
+          <span>기본 전체 적용, 필요한 컬럼만 해제 가능</span>
+          <strong>Nemotron 컬럼</strong>
+        </div>
+        <em>{selected.length}/{columns.length}개</em>
+      </div>
+      <div className="nemotron-actions">
+        <button data-testid="nemotron-select-all" type="button" onClick={() => onChange(columns)}>전체 선택</button>
+        <button data-testid="nemotron-select-text" type="button" onClick={() => onChange(textColumns)}>텍스트만</button>
+        <button data-testid="nemotron-clear" type="button" onClick={() => onChange([])}>모두 해제</button>
+      </div>
+      <div className="nemotron-column-section">
+        <span>분포/필터 컬럼</span>
+        <div className="nemotron-column-grid" data-testid="nemotron-demographic-columns">
+          {demographicColumns.map((column) => (
+            <button key={column} type="button" className={selectedSet.has(column) ? "active" : ""} data-testid={`nemotron-column-${column}`} onClick={() => toggle(column)}>
+              {nemotronColumnLabel(column)}
+            </button>
+          ))}
+        </div>
+      </div>
+      <div className="nemotron-column-section">
+        <span>자연어 persona 컬럼</span>
+        <div className="nemotron-column-grid" data-testid="nemotron-text-columns">
+          {textColumns.map((column) => (
+            <button key={column} type="button" className={selectedSet.has(column) ? "active" : ""} data-testid={`nemotron-column-${column}`} onClick={() => toggle(column)}>
+              {nemotronColumnLabel(column)}
+            </button>
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+}
+
+function WeightedOptionChip<T extends string>({
+  item,
+  pick,
+  onChange,
+  sampleSize,
+}: {
+  item: { id: T; label: string; defaultWeight: number };
+  pick: WeightedPick<T>;
+  onChange: (patch: Partial<WeightedPick<T>>) => void;
+  sampleSize: number;
+}) {
+  return (
+    <div className={pick.enabled ? "toggle-chip active" : "toggle-chip"} data-testid={`weighted-option-${item.id}`}>
+      <button type="button" data-testid={`weighted-option-button-${item.id}`} onClick={() => onChange({ enabled: !pick.enabled, weight: pick.weight || defaultCountFromShare(item.defaultWeight, sampleSize) })}>{item.label}</button>
+      <input
+        aria-label={`${item.label} 명수`}
+        type="number"
+        min={0}
+        max={sampleSize}
+        value={pick.enabled ? pick.weight : ""}
+        disabled={!pick.enabled}
+        onChange={(event) => onChange({ weight: clampNumber(event.target.value, 0, sampleSize) })}
+      />
+      <span className="estimate-count">{pick.enabled ? formatShare(pick.weight, sampleSize) : ""}</span>
+    </div>
+  );
+}
+
+function SimulationEmptyState() {
+  return (
+    <section className="silicon-state-panel" data-testid="silicon-empty-state">
+      <BarChart3 size={22} />
+      <div>
+        <span>ready</span>
+        <strong>설정을 마친 뒤 시뮬레이션을 실행하세요.</strong>
+        <p>결과는 실행이 끝난 뒤 문항과 분석축을 선택해서 보는 탐색형 대시보드로 표시됩니다.</p>
+      </div>
+    </section>
+  );
+}
+
+function SimulationRunning({ status }: { status: string }) {
+  return (
+    <section className="silicon-state-panel running" data-testid="silicon-running-state">
+      <div className="silicon-spinner" />
+      <div>
+        <span>running</span>
+        <strong>{status}</strong>
+        <p>각 persona-agent가 선택된 모든 문항에 답하고, 결과를 문항별로 추출하고 있습니다.</p>
+      </div>
+    </section>
+  );
+}
+
+function Metric({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="silicon-metric">
+      <span>{label}</span>
+      <strong>{value}</strong>
+    </div>
+  );
+}
+
+function topRegion(result: SiliconResult) {
+  const top = [...result.regionStats].sort((a, b) => b.respondents - a.respondents)[0];
+  return top ? `${top.label} ${top.respondents.toLocaleString()}명` : "-";
+}
+
+function countBy(values: string[]) {
+  return values.reduce<Record<string, number>>((counts, value) => {
+    counts[value] = (counts[value] || 0) + 1;
+    return counts;
+  }, {});
+}
+
+function formatNumber(value?: number) {
+  return typeof value === "number" && Number.isFinite(value) ? value.toFixed(2) : "-";
+}
+
+function formatPercent(value?: number) {
+  return typeof value === "number" && Number.isFinite(value) ? `${Math.round(value * 100)}%` : "-";
+}
+
+function formatShare(count: number, sampleSize: number) {
+  if (!sampleSize) return "0%";
+  const share = count / sampleSize * 100;
+  return `${share.toFixed(1).replace(/\.0$/, "")}%`;
+}
+
+function defaultCountFromShare(share: number, sampleSize: number) {
+  return Math.max(1, Math.round(sampleSize * Math.max(0, share) / 100));
+}
+
+function clampNumber(value: string, min: number, max: number) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return min;
+  return Math.max(min, Math.min(max, Math.round(number)));
+}
+
+function emptyPicks<T extends string>(items: Array<{ id: T; defaultWeight: number }>): WeightedPick<T>[] {
+  return items.map((item) => ({ id: item.id, enabled: false, weight: 0 }));
+}
+
+function defaultCountPicks<T extends string>(items: Array<{ id: T; defaultWeight: number }>, targetTotal: number): WeightedPick<T>[] {
+  const counts = allocateCounts(new Map(items.map((item) => [item.id, Math.max(0, item.defaultWeight)])), targetTotal);
+  return items.map((item) => ({ id: item.id, enabled: Boolean(counts.get(item.id)), weight: counts.get(item.id) || 0 }));
+}
+
+function missingRunRequirements(
+  genders: WeightedPick<GenderId>[],
+  ages: WeightedPick<AgeBandId>[],
+  locations: WeightedPick<LocationId>[],
+  questions: SurveyQuestion[],
+) {
+  const missing: string[] = [];
+  if (selectedWeightTotal(genders) <= 0) missing.push("성별");
+  if (selectedWeightTotal(ages) <= 0) missing.push("연령");
+  if (selectedWeightTotal(locations) <= 0) missing.push("지역");
+  if (!questions.length) missing.push("문항");
+  return missing;
+}
+
+function applyCountsToPicks<T extends string>(
+  items: Array<{ id: T; defaultWeight: number }>,
+  counts: CountRow[] | undefined,
+  mapper: (value: string) => T | null,
+  targetTotal: number,
+): WeightedPick<T>[] {
+  const validIds = new Set(items.map((item) => item.id));
+  const bucketCounts = new Map<T, number>();
+  for (const row of counts || []) {
+    const id = mapper(String(row.value || ""));
+    if (!id || !validIds.has(id)) continue;
+    bucketCounts.set(id, (bucketCounts.get(id) || 0) + Number(row.count || 0));
+  }
+  const weights = allocateCounts(bucketCounts, targetTotal);
+  return items.map((item) => ({
+    id: item.id,
+    enabled: Boolean(weights.get(item.id)),
+    weight: weights.get(item.id) || 0,
+  }));
+}
+
+function usableNemotronColumns(columns: unknown) {
+  if (!Array.isArray(columns)) return FALLBACK_NEMOTRON_COLUMNS;
+  const usable = columns.map((column) => String(column)).filter((column) => column !== "uuid");
+  return usable.length ? usable : FALLBACK_NEMOTRON_COLUMNS;
+}
+
+async function fetchMetadata(): Promise<NemotronMetadata> {
+  const response = await fetch("/api/persona-dataset/metadata");
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  return response.json();
+}
+
+function buildLocationOptionsFromMetadata(metadata: NemotronMetadata): LocationOption[] {
+  const rowCount = (metadata.province_counts || []).reduce((sum, row) => sum + Math.max(0, Number(row.count || 0)), 0);
+  const districtOptions: LocationOption[] = [];
+  const seen = new Set(SIDO_LOCATION_OPTIONS.map((location) => location.id));
+  for (const [province, rows] of Object.entries(metadata.district_counts_by_province || {})) {
+    const parentRegion = mapProvinceCount(province) as RegionId | null;
+    if (!parentRegion) continue;
+    for (const row of rows || []) {
+      const raw = String(row.value || "").trim();
+      if (!raw) continue;
+      const id = `district_${parentRegion}_${slugLocationId(raw)}`;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const count = Math.max(0, Number(row.count || 0));
+      districtOptions.push({
+        id,
+        label: stripDistrictPrefix(raw),
+        short: stripDistrictPrefix(raw),
+        defaultWeight: rowCount ? count / rowCount * 100 : 1,
+        parentRegion,
+        level: "district",
+        group: `${locationLabel(parentRegion)} 세부`,
+      });
+    }
+  }
+  return [...SIDO_LOCATION_OPTIONS, ...districtOptions];
+}
+
+function mergePicks<T extends string>(items: Array<{ id: T }>, current: WeightedPick<T>[]) {
+  const currentById = new Map(current.map((pick) => [pick.id, pick]));
+  return items.map((item) => currentById.get(item.id) || { id: item.id, enabled: false, weight: 0 });
+}
+
+function rescalePicksToTotal<T extends string>(picks: WeightedPick<T>[], targetTotal: number) {
+  const active = picks.filter((pick) => pick.enabled && pick.weight > 0);
+  if (!active.length) return picks;
+  const counts = allocateCounts(new Map(active.map((pick) => [pick.id, pick.weight])), targetTotal);
+  return picks.map((pick) => pick.enabled ? { ...pick, weight: counts.get(pick.id) || 0 } : pick);
+}
+
+function rescalePersonaPicksToTotal(picks: WeightedPick<PersonaAttributeId>[], targetTotal: number) {
+  let next = picks;
+  for (const dimension of PERSONA_DIMENSIONS) {
+    const ids = new Set(PERSONA_OPTIONS.filter((option) => option.dimension === dimension.id).map((option) => option.id));
+    const dimensionPicks = next.filter((pick) => ids.has(pick.id));
+    const rescaled = new Map(rescalePicksToTotal(dimensionPicks, targetTotal).map((pick) => [pick.id, pick]));
+    next = next.map((pick) => rescaled.get(pick.id) || pick);
+  }
+  return next;
+}
+
+function slugLocationId(value: string) {
+  return value.trim().replace(/[^0-9A-Za-z가-힣]+/g, "_").replace(/^_+|_+$/g, "");
+}
+
+function stripDistrictPrefix(value: string) {
+  return value.replace(/^[^-]+-/, "");
+}
+
+function allocateCounts<T extends string>(counts: Map<T, number>, targetTotal: number) {
+  const total = [...counts.values()].reduce((sum, count) => sum + Math.max(0, count), 0);
+  if (total <= 0) return new Map<T, number>();
+  const rows = [...counts.entries()].map(([id, count]) => {
+    const raw = Math.max(0, count) / total * targetTotal;
+    return { id, floor: Math.floor(raw), remainder: raw - Math.floor(raw) };
+  });
+  let used = rows.reduce((sum, row) => sum + row.floor, 0);
+  for (const row of rows.sort((a, b) => b.remainder - a.remainder)) {
+    if (used >= targetTotal) break;
+    row.floor += 1;
+    used += 1;
+  }
+  return new Map(rows.filter((row) => row.floor > 0).map((row) => [row.id, row.floor]));
+}
+
+function mapSexCount(value: string): GenderId | null {
+  if (value.includes("남")) return "male";
+  if (value.includes("여")) return "female";
+  return null;
+}
+
+function mapAgeCount(value: string): AgeBandId | null {
+  if (value === "20s") return "20s";
+  if (value === "30s") return "30s";
+  if (value === "40s") return "40s";
+  if (value === "50s") return "50s";
+  if (value === "60_plus" || value === "60plus") return "60plus";
+  return null;
+}
+
+function mapProvinceCount(value: string): LocationId | null {
+  const normalized = value.replace(/\s/g, "");
+  const provinceMap: Record<string, LocationId> = {
+    서울: "seoul",
+    부산: "busan",
+    대구: "daegu",
+    인천: "incheon",
+    광주: "gwangju",
+    대전: "daejeon",
+    울산: "ulsan",
+    세종: "sejong",
+    경기: "gyeonggi",
+    강원: "gangwon",
+    충북: "chungbuk",
+    충청북: "chungbuk",
+    충청북도: "chungbuk",
+    충남: "chungnam",
+    충청남: "chungnam",
+    충청남도: "chungnam",
+    전북: "jeonbuk",
+    전라북: "jeonbuk",
+    전라북도: "jeonbuk",
+    전남: "jeonnam",
+    전라남: "jeonnam",
+    전라남도: "jeonnam",
+    경북: "gyeongbuk",
+    경상북: "gyeongbuk",
+    경상북도: "gyeongbuk",
+    경남: "gyeongnam",
+    경상남: "gyeongnam",
+    경상남도: "gyeongnam",
+    제주: "jeju",
+  };
+  return provinceMap[normalized] || null;
+}
+
+function applyPersonaDefaults(metadata: { occupation_counts?: CountRow[]; education_counts?: CountRow[] }, selectedFields: Set<string>, targetTotal: number) {
+  const occupationOptions = PERSONA_OPTIONS.filter((option) => option.dimension === "occupation");
+  const educationOptions = PERSONA_OPTIONS.filter((option) => option.dimension === "education");
+  const occupation = selectedFields.has("occupation")
+    ? metadata.occupation_counts ? applyCountsToPicks(occupationOptions, metadata.occupation_counts, mapOccupationCount, targetTotal) : defaultCountPicks(occupationOptions, targetTotal)
+    : emptyPicks(occupationOptions);
+  const education = selectedFields.has("education_level")
+    ? metadata.education_counts ? applyCountsToPicks(educationOptions, metadata.education_counts, mapEducationCount, targetTotal) : defaultCountPicks(educationOptions, targetTotal)
+    : emptyPicks(educationOptions);
+  const staticDimensions = [
+    ...(selectedFields.has("housing_type") ? defaultCountPicks(PERSONA_OPTIONS.filter((option) => option.dimension === "housing"), targetTotal) : emptyPicks(PERSONA_OPTIONS.filter((option) => option.dimension === "housing"))),
+    ...(selectedFields.has("marital_status") ? defaultCountPicks(PERSONA_OPTIONS.filter((option) => option.dimension === "marital"), targetTotal) : emptyPicks(PERSONA_OPTIONS.filter((option) => option.dimension === "marital"))),
+    ...(selectedFields.has("family_type") ? defaultCountPicks(PERSONA_OPTIONS.filter((option) => option.dimension === "family"), targetTotal) : emptyPicks(PERSONA_OPTIONS.filter((option) => option.dimension === "family"))),
+  ];
+  const merged = new Map<PersonaAttributeId, WeightedPick<PersonaAttributeId>>();
+  [...occupation, ...education, ...staticDimensions].forEach((pick) => merged.set(pick.id, pick));
+  return PERSONA_OPTIONS.map((option) => merged.get(option.id) || { id: option.id, enabled: false, weight: option.defaultWeight });
+}
+
+function mapOccupationCount(value: string): PersonaAttributeId | null {
+  const text = value.toLowerCase();
+  if (text.includes("학생")) return "occ_student";
+  if (text.includes("주부")) return "occ_homemaker";
+  if (text.includes("자영") || text.includes("사업")) return "occ_self_employed";
+  if (text.includes("무직") || text.includes("은퇴")) return "occ_retired";
+  if (/(사무|경리|비서|회계|기획|행정|법률)/.test(text)) return "occ_office";
+  if (/(서비스|판매|영업|상담|조리|주방|음식|청소|경비)/.test(text)) return "occ_service";
+  if (/(전문|교사|교육|훈련|간호|의사|연구|마케팅)/.test(text)) return "occ_professional";
+  if (/(기술|생산|운전|기계|전기|산업|안전|하역|적재|지게차|철도)/.test(text)) return "occ_technical";
+  return null;
+}
+
+function mapEducationCount(value: string): PersonaAttributeId | null {
+  if (value.includes("대학원")) return "edu_graduate";
+  if (value.includes("4년제")) return "edu_bachelor";
+  if (value.includes("전문대") || value.includes("대학교")) return "edu_college";
+  if (value.includes("고등") || value.includes("중학") || value.includes("초등") || value.includes("무학")) return "edu_high_school";
+  return null;
+}
+
+function dimensionLabel(dimension: PersonaDimensionId) {
+  return PERSONA_DIMENSIONS.find((item) => item.id === dimension)?.label || dimension;
+}
+
+function locationLabel(id: RegionId) {
+  return LOCATION_OPTIONS.find((location) => location.id === id)?.label || id;
+}
+
+function nemotronColumnLabel(column: string) {
+  return NEMOTRON_COLUMN_LABELS[column] || column;
+}

frontend/src/silicon/data.ts

@@ -0,0 +1,203 @@
+import type { AgeBandId, GenderId, LocationOption, PersonaOption, RegionId, RegionOption, SurveyQuestion, ToggleOption } from "./types";
+
+export const GENDERS: ToggleOption<GenderId>[] = [
+  { id: "male", label: "남성", short: "남", defaultWeight: 49 },
+  { id: "female", label: "여성", short: "여", defaultWeight: 51 },
+  { id: "no_response", label: "응답 안 함", short: "무응답", defaultWeight: 1 },
+];
+
+export const AGE_BANDS: ToggleOption<AgeBandId>[] = [
+  { id: "20s", label: "20대", short: "20", defaultWeight: 18 },
+  { id: "30s", label: "30대", short: "30", defaultWeight: 19 },
+  { id: "40s", label: "40대", short: "40", defaultWeight: 21 },
+  { id: "50s", label: "50대", short: "50", defaultWeight: 22 },
+  { id: "60plus", label: "60대 이상", short: "60+", defaultWeight: 20 },
+];
+
+export const REGIONS: RegionOption[] = [
+  { id: "seoul", label: "서울", short: "서울", defaultWeight: 18, x: -0.28, y: 0.92, mapLabelX: 38, mapLabelY: 31 },
+  { id: "busan", label: "부산", short: "부산", defaultWeight: 7, x: 0.22, y: -0.75, mapLabelX: 61, mapLabelY: 77 },
+  { id: "daegu", label: "대구", short: "대구", defaultWeight: 5, x: 0.1, y: -0.18, mapLabelX: 58, mapLabelY: 61 },
+  { id: "incheon", label: "인천", short: "인천", defaultWeight: 6, x: -0.48, y: 0.83, mapLabelX: 31, mapLabelY: 34 },
+  { id: "gwangju", label: "광주", short: "광주", defaultWeight: 3, x: -0.43, y: -0.57, mapLabelX: 33, mapLabelY: 72 },
+  { id: "daejeon", label: "대전", short: "대전", defaultWeight: 3, x: -0.23, y: 0.2, mapLabelX: 41, mapLabelY: 51 },
+  { id: "ulsan", label: "울산", short: "울산", defaultWeight: 2, x: 0.31, y: -0.55, mapLabelX: 66, mapLabelY: 70 },
+  { id: "sejong", label: "세종", short: "세종", defaultWeight: 1, x: -0.3, y: 0.34, mapLabelX: 39, mapLabelY: 46 },
+  { id: "gyeonggi", label: "경기", short: "경기", defaultWeight: 26, x: -0.21, y: 0.72, mapLabelX: 42, mapLabelY: 38 },
+  { id: "gangwon", label: "강원", short: "강원", defaultWeight: 3, x: 0.1, y: 1.04, mapLabelX: 57, mapLabelY: 27 },
+  { id: "chungbuk", label: "충북", short: "충북", defaultWeight: 3, x: -0.08, y: 0.47, mapLabelX: 48, mapLabelY: 43 },
+  { id: "chungnam", label: "충남", short: "충남", defaultWeight: 4, x: -0.39, y: 0.32, mapLabelX: 34, mapLabelY: 48 },
+  { id: "jeonbuk", label: "전북", short: "전북", defaultWeight: 3, x: -0.31, y: -0.18, mapLabelX: 38, mapLabelY: 61 },
+  { id: "jeonnam", label: "전남", short: "전남", defaultWeight: 4, x: -0.42, y: -0.78, mapLabelX: 34, mapLabelY: 78 },
+  { id: "gyeongbuk", label: "경북", short: "경북", defaultWeight: 5, x: 0.13, y: 0.18, mapLabelX: 59, mapLabelY: 52 },
+  { id: "gyeongnam", label: "경남", short: "경남", defaultWeight: 6, x: 0.02, y: -0.64, mapLabelX: 53, mapLabelY: 73 },
+  { id: "jeju", label: "제주", short: "제주", defaultWeight: 1, x: -0.42, y: -1.54, mapLabelX: 33, mapLabelY: 92 },
+];
+
+export const LOCATION_OPTIONS: LocationOption[] = [
+  ...REGIONS.map((region) => ({
+    id: region.id,
+    label: region.label,
+    short: region.short,
+    defaultWeight: region.defaultWeight,
+    parentRegion: region.id,
+    level: "sido" as const,
+    group: "시도",
+  })),
+  { id: "seoul_core", label: "서울 도심권", short: "서울도심", defaultWeight: 6, parentRegion: "seoul", level: "district", group: "서울 세부" },
+  { id: "seoul_gangnam", label: "서울 강남권", short: "강남권", defaultWeight: 7, parentRegion: "seoul", level: "district", group: "서울 세부" },
+  { id: "seoul_gangbuk", label: "서울 강북권", short: "강북권", defaultWeight: 5, parentRegion: "seoul", level: "district", group: "서울 세부" },
+  { id: "seoul_west", label: "서울 서남권", short: "서남권", defaultWeight: 5, parentRegion: "seoul", level: "district", group: "서울 세부" },
+  { id: "gyeonggi_south", label: "경기 남부", short: "경기남부", defaultWeight: 14, parentRegion: "gyeonggi", level: "district", group: "경기 세부" },
+  { id: "gyeonggi_north", label: "경기 북부", short: "경기북부", defaultWeight: 7, parentRegion: "gyeonggi", level: "district", group: "경기 세부" },
+  { id: "gyeonggi_west", label: "경기 서부", short: "경기서부", defaultWeight: 5, parentRegion: "gyeonggi", level: "district", group: "경기 세부" },
+  { id: "incheon_core", label: "인천 도심권", short: "인천도심", defaultWeight: 4, parentRegion: "incheon", level: "district", group: "광역시 세부" },
+  { id: "busan_core", label: "부산 도심권", short: "부산도심", defaultWeight: 4, parentRegion: "busan", level: "district", group: "광역시 세부" },
+  { id: "busan_east", label: "부산 동부권", short: "부산동부", defaultWeight: 3, parentRegion: "busan", level: "district", group: "광역시 세부" },
+  { id: "daegu_core", label: "대구권", short: "대구권", defaultWeight: 4, parentRegion: "daegu", level: "district", group: "광역시 세부" },
+  { id: "daejeon_core", label: "대전권", short: "대전권", defaultWeight: 3, parentRegion: "daejeon", level: "district", group: "광역시 세부" },
+  { id: "gwangju_core", label: "광주권", short: "광주권", defaultWeight: 3, parentRegion: "gwangju", level: "district", group: "광역시 세부" },
+  { id: "ulsan_core", label: "울산권", short: "울산권", defaultWeight: 2, parentRegion: "ulsan", level: "district", group: "광역시 세부" },
+  { id: "chungcheong_north", label: "충청 북부", short: "충청북부", defaultWeight: 3, parentRegion: "chungbuk", level: "district", group: "권역 세부" },
+  { id: "chungcheong_south", label: "충청 남부", short: "충청남부", defaultWeight: 4, parentRegion: "chungnam", level: "district", group: "권역 세부" },
+  { id: "jeolla_north", label: "전북권", short: "전북권", defaultWeight: 3, parentRegion: "jeonbuk", level: "district", group: "권역 세부" },
+  { id: "jeolla_south", label: "전남권", short: "전남권", defaultWeight: 4, parentRegion: "jeonnam", level: "district", group: "권역 세부" },
+  { id: "gyeongsang_north", label: "경북권", short: "경북권", defaultWeight: 5, parentRegion: "gyeongbuk", level: "district", group: "권역 세부" },
+  { id: "gyeongsang_south", label: "경남권", short: "경남권", defaultWeight: 6, parentRegion: "gyeongnam", level: "district", group: "권역 세부" },
+  { id: "gangwon_yeongseo", label: "강원 영서", short: "영서", defaultWeight: 2, parentRegion: "gangwon", level: "district", group: "강원/제주 세부" },
+  { id: "gangwon_yeongdong", label: "강원 영동", short: "영동", defaultWeight: 1, parentRegion: "gangwon", level: "district", group: "강원/제주 세부" },
+  { id: "jeju_core", label: "제주권", short: "제주권", defaultWeight: 1, parentRegion: "jeju", level: "district", group: "강원/제주 세부" },
+];
+
+export const PERSONA_OPTIONS: PersonaOption[] = [
+  { id: "occ_office", label: "사무/관리직", short: "사무", defaultWeight: 18, dimension: "occupation", group: "직업" },
+  { id: "occ_service", label: "서비스/판매직", short: "서비스", defaultWeight: 16, dimension: "occupation", group: "직업" },
+  { id: "occ_professional", label: "전문직", short: "전문", defaultWeight: 13, dimension: "occupation", group: "직업" },
+  { id: "occ_self_employed", label: "자영업", short: "자영업", defaultWeight: 10, dimension: "occupation", group: "직업" },
+  { id: "occ_student", label: "학생", short: "학생", defaultWeight: 9, dimension: "occupation", group: "직업" },
+  { id: "occ_homemaker", label: "전업주부", short: "주부", defaultWeight: 9, dimension: "occupation", group: "직업" },
+  { id: "occ_technical", label: "기술/생산직", short: "기술", defaultWeight: 14, dimension: "occupation", group: "직업" },
+  { id: "occ_retired", label: "은퇴/무직", short: "은퇴", defaultWeight: 11, dimension: "occupation", group: "직업" },
+  { id: "edu_high_school", label: "고졸 이하", short: "고졸", defaultWeight: 34, dimension: "education", group: "학력" },
+  { id: "edu_college", label: "전문대/대학 재학", short: "대학", defaultWeight: 18, dimension: "education", group: "학력" },
+  { id: "edu_bachelor", label: "대졸", short: "대졸", defaultWeight: 39, dimension: "education", group: "학력" },
+  { id: "edu_graduate", label: "대학원 이상", short: "대학원", defaultWeight: 9, dimension: "education", group: "학력" },
+  { id: "housing_apartment", label: "아파트", short: "아파트", defaultWeight: 52, dimension: "housing", group: "주거" },
+  { id: "housing_house", label: "단독/다가구", short: "단독", defaultWeight: 24, dimension: "housing", group: "주거" },
+  { id: "housing_officetel", label: "오피스텔/원룸", short: "원룸", defaultWeight: 14, dimension: "housing", group: "주거" },
+  { id: "housing_other", label: "기타 주거", short: "기타", defaultWeight: 10, dimension: "housing", group: "주거" },
+  { id: "marital_single", label: "미혼", short: "미혼", defaultWeight: 34, dimension: "marital", group: "혼인" },
+  { id: "marital_married", label: "기혼", short: "기혼", defaultWeight: 57, dimension: "marital", group: "혼인" },
+  { id: "marital_divorced", label: "이혼/별거", short: "이혼", defaultWeight: 6, dimension: "marital", group: "혼인" },
+  { id: "marital_widowed", label: "사별", short: "사별", defaultWeight: 3, dimension: "marital", group: "혼인" },
+  { id: "family_single", label: "1인 가구", short: "1인", defaultWeight: 34, dimension: "family", group: "가구" },
+  { id: "family_couple", label: "부부 가구", short: "부부", defaultWeight: 22, dimension: "family", group: "가구" },
+  { id: "family_children", label: "자녀 동거", short: "자녀", defaultWeight: 34, dimension: "family", group: "가구" },
+  { id: "family_extended", label: "확대 가족", short: "확대", defaultWeight: 10, dimension: "family", group: "가구" },
+];
+
+export const SURVEY_BANK: SurveyQuestion[] = [
+  {
+    id: "president_approval",
+    title: "현 정부 국정 운영을 어떻게 평가하십니까?",
+    source: "한국갤럽형 직무평가 문항",
+    category: "정치/국정",
+    kind: "likert",
+    scale: 4,
+    lowLabel: "매우 부정",
+    highLabel: "매우 긍정",
+  },
+  {
+    id: "party_trust",
+    title: "주요 정당이 국민 의견을 잘 반영한다고 보십니까?",
+    source: "선거 여론조사형 정당 신뢰 문항",
+    category: "정치/정당",
+    kind: "likert",
+    scale: 5,
+    lowLabel: "전혀 아니다",
+    highLabel: "매우 그렇다",
+  },
+  {
+    id: "economic_outlook",
+    title: "향후 1년 한국 경제가 좋아질 것이라고 보십니까?",
+    source: "경제전망 여론조사형 문항",
+    category: "경제",
+    kind: "likert",
+    scale: 5,
+    lowLabel: "매우 나빠짐",
+    highLabel: "매우 좋아짐",
+  },
+  {
+    id: "household_life",
+    title: "현재 가계 생활 형편에 얼마나 만족하십니까?",
+    source: "사회조사형 생활만족 문항",
+    category: "생활",
+    kind: "likert",
+    scale: 5,
+    lowLabel: "매우 불만족",
+    highLabel: "매우 만족",
+  },
+  {
+    id: "institution_trust",
+    title: "국회, 언론, 행정부 등 공공기관을 전반적으로 신뢰하십니까?",
+    source: "한국사회종합조사형 신뢰 문항",
+    category: "사회 신뢰",
+    kind: "likert",
+    scale: 5,
+    lowLabel: "전혀 신뢰 안 함",
+    highLabel: "매우 신뢰",
+  },
+  {
+    id: "low_birth_policy",
+    title: "저출산 대응 정책이 실제 삶에 도움이 된다고 보십니까?",
+    source: "정책 체감도 조사형 문항",
+    category: "정책",
+    kind: "likert",
+    scale: 5,
+    lowLabel: "전혀 도움 안 됨",
+    highLabel: "매우 도움 됨",
+  },
+  {
+    id: "climate_policy",
+    title: "탄소 감축을 위해 비용 부담이 늘어나는 정책에 동의하십니까?",
+    source: "환경 인식조사형 문항",
+    category: "환경",
+    kind: "likert",
+    scale: 5,
+    lowLabel: "전혀 동의 안 함",
+    highLabel: "매우 동의",
+  },
+  {
+    id: "news_reliability",
+    title: "온라인 뉴스와 유튜브 정치 정보를 신뢰하십니까?",
+    source: "미디어 이용조사형 문항",
+    category: "미디어",
+    kind: "likert",
+    scale: 5,
+    lowLabel: "전혀 신뢰 안 함",
+    highLabel: "매우 신뢰",
+  },
+  {
+    id: "top_social_issue",
+    title: "한국 사회가 가장 먼저 해결해야 할 문제는 무엇이라고 보십니까?",
+    source: "한국갤럽형 현안 자유응답",
+    category: "오픈엔드",
+    kind: "open",
+  },
+  {
+    id: "local_priority",
+    title: "거주 지역에서 가장 시급한 공공서비스 개선은 무엇입니까?",
+    source: "지방정부 만족도 자유응답",
+    category: "오픈엔드",
+    kind: "open",
+  },
+  {
+    id: "policy_request",
+    title: "새 정부나 지방자치단체에 가장 바라는 정책을 적어주십시오.",
+    source: "선거 후 정책 요구 자유응답",
+    category: "오픈엔드",
+    kind: "open",
+  },
+];
+
+export const DEFAULT_QUESTION_IDS = ["president_approval", "economic_outlook", "institution_trust", "top_social_issue"];

frontend/src/silicon/simulate.ts

@@ -0,0 +1,430 @@
+import { AGE_BANDS, GENDERS, LOCATION_OPTIONS, PERSONA_OPTIONS, REGIONS } from "./data";
+import type {
+  AgeBandId,
+  GenderId,
+  LikertAnswer,
+  LocationId,
+  OpenAnswer,
+  PersonaAttributeId,
+  PersonaDimensionId,
+  QuestionStat,
+  RegionId,
+  RegionStat,
+  SiliconConfig,
+  SiliconResult,
+  SurveyQuestion,
+  SyntheticRespondent,
+  WeightedPick,
+} from "./types";
+
+const REGION_TENDENCY: Record<RegionId, number> = {
+  seoul: 0.03,
+  busan: -0.02,
+  daegu: -0.08,
+  incheon: 0.01,
+  gwangju: 0.1,
+  daejeon: 0.02,
+  ulsan: -0.03,
+  sejong: 0.04,
+  gyeonggi: 0.02,
+  gangwon: -0.02,
+  chungbuk: -0.01,
+  chungnam: -0.02,
+  jeonbuk: 0.06,
+  jeonnam: 0.08,
+  gyeongbuk: -0.07,
+  gyeongnam: -0.04,
+  jeju: 0.05,
+};
+
+const AGE_TENDENCY: Record<AgeBandId, number> = {
+  "20s": 0.03,
+  "30s": 0.01,
+  "40s": 0,
+  "50s": -0.01,
+  "60plus": -0.02,
+};
+
+const THEMES = ["물가", "주거", "일자리", "돌봄", "교통", "의료", "지역경제", "교육", "기후", "정치 신뢰"];
+const PERSONA_DIMENSIONS: PersonaDimensionId[] = ["occupation", "education", "housing", "marital", "family"];
+
+export function defaultPicks<T extends string>(items: Array<{ id: T; defaultWeight: number }>): WeightedPick<T>[] {
+  return items.map((item) => ({ id: item.id, enabled: true, weight: item.defaultWeight }));
+}
+
+export function simulateSiliconSampling(config: SiliconConfig): SiliconResult {
+  const rand = mulberry32(config.seed);
+  const respondents: SyntheticRespondent[] = [];
+  const likertAnswers: LikertAnswer[] = [];
+  const openAnswers: OpenAnswer[] = [];
+  const likertQuestions = config.questions.filter((question) => question.kind === "likert");
+  const openQuestions = config.questions.filter((question) => question.kind === "open");
+  const genderPool = buildAllocationPool(config.genders, config.sampleSize, "female", rand);
+  const agePool = buildAllocationPool(config.ages, config.sampleSize, "40s", rand);
+  const locationPool = buildAllocationPool(config.locations, config.sampleSize, "seoul", rand);
+  const personaPools = buildPersonaPools(config.personaAttributes, config.sampleSize, rand);
+
+  for (let index = 0; index < config.sampleSize; index += 1) {
+    const gender = genderPool[index] || "female";
+    const age = agePool[index] || "40s";
+    const location = locationPool[index] || "seoul";
+    const locationOption = locationOptionOf(location, config.locationOptions);
+    const persona = personaAttributesFromPools(personaPools, index);
+    const respondent = buildRespondent(index, gender, age, locationOption.id, locationOption.parentRegion, locationOption.label, persona, rand);
+    respondents.push(respondent);
+    for (const question of likertQuestions) {
+      likertAnswers.push({
+        respondentId: respondent.id,
+        questionId: question.id,
+        value: answerLikert(question, respondent, rand),
+      });
+    }
+    for (const question of openQuestions) {
+      openAnswers.push({
+        respondentId: respondent.id,
+        questionId: question.id,
+        ...answerOpen(question, respondent, rand),
+      });
+    }
+  }
+
+  const primaryQuestionId = likertQuestions[0]?.id ?? null;
+  return {
+    config,
+    respondents,
+    likertAnswers,
+    openAnswers,
+    regionStats: buildRegionStats(config.locations, config.locationOptions, respondents, likertAnswers, openAnswers, likertQuestions[0]),
+    questionStats: buildQuestionStats(config.questions, likertAnswers),
+    primaryQuestionId,
+  };
+}
+
+function buildRespondent(
+  index: number,
+  gender: GenderId,
+  age: AgeBandId,
+  location: LocationId,
+  region: RegionId,
+  locationLabel: string,
+  persona: ReturnType<typeof pickPersonaAttributes>,
+  rand: () => number,
+): SyntheticRespondent {
+  const regionBias = REGION_TENDENCY[region] || 0;
+  const ageBias = AGE_TENDENCY[age] || 0;
+  const genderBias = gender === "female" ? 0.015 : gender === "male" ? -0.01 : 0;
+  const personaBias = personaBiases(persona.attributes);
+  const economicAnxiety = clamp01(0.5 + (age === "30s" || age === "40s" ? 0.08 : 0) + (region === "seoul" || region === "gyeonggi" ? 0.04 : 0) + personaBias.anxiety + noise(rand, 0.18));
+  const trust = clamp01(0.48 + regionBias + ageBias + genderBias + personaBias.trust - economicAnxiety * 0.08 + noise(rand, 0.16));
+  const participation = clamp01(0.5 + (age === "60plus" ? 0.12 : 0) + (age === "20s" ? -0.06 : 0) + Math.abs(regionBias) * 0.4 + personaBias.participation + noise(rand, 0.14));
+  return {
+    id: `R${String(index + 1).padStart(4, "0")}`,
+    gender,
+    age,
+    region,
+    location,
+    locationLabel,
+    personaAttributes: persona.attributes,
+    personaLabels: persona.labels,
+    segment: segmentLabel(trust, economicAnxiety, participation),
+    trust,
+    economicAnxiety,
+    participation,
+  };
+}
+
+function answerLikert(question: SurveyQuestion, respondent: SyntheticRespondent, rand: () => number) {
+  const scale = question.scale || 5;
+  let score = scale / 2 + 0.5;
+  const trustTerm = (respondent.trust - 0.5) * scale * 0.8;
+  const anxietyTerm = (respondent.economicAnxiety - 0.5) * scale * 0.58;
+  const participationTerm = (respondent.participation - 0.5) * scale * 0.32;
+  const regionTerm = (REGION_TENDENCY[respondent.region] || 0) * scale;
+
+  if (question.id.includes("approval") || question.id.includes("trust")) score += trustTerm + regionTerm;
+  else if (question.id.includes("economic") || question.id.includes("household")) score += -anxietyTerm + trustTerm * 0.28;
+  else if (question.id.includes("climate")) score += participationTerm + (respondent.age === "20s" ? 0.35 : 0) - (respondent.age === "60plus" ? 0.18 : 0);
+  else if (question.id.includes("birth")) score += -anxietyTerm * 0.35 + (respondent.age === "30s" ? -0.18 : 0.08);
+  else if (question.id.includes("news")) score += trustTerm * 0.35 - (respondent.age === "20s" ? 0.1 : 0) + (respondent.age === "60plus" ? 0.15 : 0);
+  else score += trustTerm * 0.35 - anxietyTerm * 0.18;
+
+  score += noise(rand, scale * 0.36);
+  return Math.max(1, Math.min(scale, Math.round(score)));
+}
+
+function answerOpen(question: SurveyQuestion, respondent: SyntheticRespondent, rand: () => number): { text: string; theme: string } {
+  const region = labelOf(REGIONS, respondent.region);
+  const age = labelOf(AGE_BANDS, respondent.age);
+  const occupation = respondent.personaLabels.occupation ? ` ${respondent.personaLabels.occupation}` : "";
+  let theme = THEMES[Math.floor(rand() * THEMES.length)];
+  if (respondent.economicAnxiety > 0.68) theme = rand() > 0.5 ? "물가" : "주거";
+  if (respondent.age === "20s" || respondent.age === "30s") theme = rand() > 0.45 ? "일자리" : "주거";
+  if (respondent.age === "60plus") theme = rand() > 0.5 ? "의료" : "돌봄";
+  if (question.id.includes("local")) theme = rand() > 0.5 ? "교통" : "지역경제";
+  if (question.id.includes("policy")) theme = rand() > 0.5 ? "주거" : "정치 신뢰";
+
+  const tone = respondent.trust > 0.58 ? "지금보다 체감 가능한 방식으로 확대되면 좋겠습니다" : "구호보다 실제 집행과 설명이 먼저 필요합니다";
+  const text = `${region} 거주 ${age}${occupation} 응답자로서 ${theme} 문제가 가장 크게 느껴집니다. ${tone}.`;
+  return { theme, text };
+}
+
+function buildRegionStats(
+  locations: WeightedPick<LocationId>[],
+  locationOptions: SiliconConfig["locationOptions"],
+  respondents: SyntheticRespondent[],
+  likertAnswers: LikertAnswer[],
+  openAnswers: OpenAnswer[],
+  primaryQuestion?: SurveyQuestion,
+): RegionStat[] {
+  const primaryQuestionId = primaryQuestion?.id ?? null;
+  const scale = primaryQuestion?.scale || 5;
+  const positiveCut = Math.max(3, Math.ceil(scale * 0.7));
+  const enabledLocations = locations.filter((location) => location.enabled && location.weight > 0);
+  return enabledLocations.map((locationPick) => {
+    const option = locationOptionOf(locationPick.id, locationOptions);
+    const people = respondents.filter((respondent) => respondent.location === option.id);
+    const ids = new Set(people.map((respondent) => respondent.id));
+    const answers = primaryQuestionId ? likertAnswers.filter((answer) => answer.questionId === primaryQuestionId && ids.has(answer.respondentId)) : [];
+    return {
+      region: option.id,
+      parentRegion: option.parentRegion,
+      label: option.label,
+      respondents: people.length,
+      mean: mean(answers.map((answer) => answer.value)),
+      scale,
+      positiveShare: answers.length ? answers.filter((answer) => answer.value >= positiveCut).length / answers.length : 0,
+      openCount: openAnswers.filter((answer) => ids.has(answer.respondentId)).length,
+    };
+  });
+}
+
+function buildQuestionStats(questions: SurveyQuestion[], likertAnswers: LikertAnswer[]): QuestionStat[] {
+  return questions.map((question) => {
+    if (question.kind === "open") return { questionId: question.id, title: question.title, kind: "open" };
+    const scale = question.scale || 5;
+    const answers = likertAnswers.filter((answer) => answer.questionId === question.id);
+    const distribution = Array.from({ length: scale }, (_, index) => {
+      const value = index + 1;
+      const count = answers.filter((answer) => answer.value === value).length;
+      return { value, count, share: answers.length ? count / answers.length : 0 };
+    });
+    const positiveCut = Math.max(3, Math.ceil(scale * 0.7));
+    return {
+      questionId: question.id,
+      title: question.title,
+      kind: "likert",
+      scale,
+      mean: mean(answers.map((answer) => answer.value)),
+      positiveShare: answers.length ? answers.filter((answer) => answer.value >= positiveCut).length / answers.length : 0,
+      distribution,
+    };
+  });
+}
+
+export function groupBreakdown(result: SiliconResult, dimension: "gender" | "age") {
+  const primary = result.primaryQuestionId;
+  if (!primary) return [];
+  const answerByRespondent = new Map(result.likertAnswers.filter((answer) => answer.questionId === primary).map((answer) => [answer.respondentId, answer.value]));
+  const options = dimension === "gender" ? GENDERS : AGE_BANDS;
+  return options.map((option) => {
+    const people = result.respondents.filter((respondent) => respondent[dimension] === option.id);
+    const values = people.map((respondent) => answerByRespondent.get(respondent.id)).filter((value): value is number => typeof value === "number");
+    return {
+      id: option.id,
+      label: option.label,
+      respondents: people.length,
+      mean: mean(values),
+    };
+  });
+}
+
+export function resultBreakdown(result: SiliconResult, questionId: string, dimension: "gender" | "age" | "region" | PersonaDimensionId) {
+  const question = result.config.questions.find((item) => item.id === questionId);
+  if (!question || question.kind !== "likert") return [];
+  const answers = result.likertAnswers.filter((answer) => answer.questionId === questionId);
+  const valuesByRespondent = new Map(answers.map((answer) => [answer.respondentId, answer.value]));
+  const scale = question.scale || 5;
+  const positiveCut = Math.max(3, Math.ceil(scale * 0.7));
+  const options = dimension === "gender"
+    ? GENDERS.map((option) => ({ id: option.id, label: option.label }))
+    : dimension === "age"
+      ? AGE_BANDS.map((option) => ({ id: option.id, label: option.label }))
+      : dimension === "region"
+        ? result.regionStats.map((option) => ({ id: option.region, label: option.label }))
+        : personaBreakdownOptions(result, dimension);
+  return options.map((option) => {
+    const id = option.id;
+    const label = option.label;
+    const people = result.respondents.filter((respondent) => {
+      if (dimension === "gender") return respondent.gender === id;
+      if (dimension === "age") return respondent.age === id;
+      if (dimension === "region") return respondent.location === id;
+      return respondent.personaAttributes[dimension] === id;
+    });
+    const values = people.map((respondent) => valuesByRespondent.get(respondent.id)).filter((value): value is number => typeof value === "number");
+    return {
+      id,
+      label,
+      respondents: people.length,
+      mean: mean(values),
+      positiveShare: values.length ? values.filter((value) => value >= positiveCut).length / values.length : 0,
+    };
+  }).filter((item) => item.respondents > 0);
+}
+
+function personaBreakdownOptions(result: SiliconResult, dimension: PersonaDimensionId) {
+  const rows = new Map<string, { id: string; label: string }>();
+  for (const respondent of result.respondents) {
+    const id = respondent.personaAttributes[dimension];
+    if (!id) continue;
+    rows.set(id, { id, label: respondent.personaLabels[dimension] || id });
+  }
+  return [...rows.values()];
+}
+
+export function selectedWeightTotal<T extends string>(picks: WeightedPick<T>[]) {
+  return picks.filter((pick) => pick.enabled).reduce((total, pick) => total + Math.max(0, pick.weight), 0);
+}
+
+function pickWeighted<T extends string>(items: WeightedPick<T>[], rand: () => number, fallback: T): T {
+  const enabled = items.filter((item) => item.enabled && item.weight > 0);
+  const total = selectedWeightTotal(enabled);
+  if (!enabled.length || total <= 0) return fallback;
+  let cursor = rand() * total;
+  for (const item of enabled) {
+    cursor -= item.weight;
+    if (cursor <= 0) return item.id;
+  }
+  return enabled[enabled.length - 1].id;
+}
+
+function buildAllocationPool<T extends string>(items: WeightedPick<T>[], targetSize: number, fallback: T, rand: () => number): T[] {
+  const enabled = items.filter((item) => item.enabled && item.weight > 0);
+  if (!enabled.length) return Array.from({ length: targetSize }, () => fallback);
+  const allocations = allocatePickCounts(enabled, targetSize);
+  const pool: T[] = [];
+  for (const item of enabled) {
+    const count = allocations.get(item.id) || 0;
+    for (let index = 0; index < count; index += 1) pool.push(item.id);
+  }
+  while (pool.length < targetSize) pool.push(fallback);
+  shuffle(pool, rand);
+  return pool.slice(0, targetSize);
+}
+
+function allocatePickCounts<T extends string>(items: WeightedPick<T>[], targetSize: number) {
+  const total = items.reduce((sum, item) => sum + Math.max(0, item.weight), 0);
+  if (total <= 0) return new Map<T, number>();
+  const rows = items.map((item) => {
+    const raw = Math.max(0, item.weight) / total * targetSize;
+    return { id: item.id, floor: Math.floor(raw), remainder: raw - Math.floor(raw) };
+  });
+  let used = rows.reduce((sum, row) => sum + row.floor, 0);
+  for (const row of rows.sort((a, b) => b.remainder - a.remainder)) {
+    if (used >= targetSize) break;
+    row.floor += 1;
+    used += 1;
+  }
+  return new Map(rows.map((row) => [row.id, row.floor]));
+}
+
+function shuffle<T>(items: T[], rand: () => number) {
+  for (let index = items.length - 1; index > 0; index -= 1) {
+    const swapIndex = Math.floor(rand() * (index + 1));
+    [items[index], items[swapIndex]] = [items[swapIndex], items[index]];
+  }
+}
+
+function locationOptionOf(id: LocationId, options: SiliconConfig["locationOptions"] = LOCATION_OPTIONS) {
+  return options.find((location) => location.id === id) || LOCATION_OPTIONS.find((location) => location.id === "seoul")!;
+}
+
+function pickPersonaAttributes(items: WeightedPick<PersonaAttributeId>[], rand: () => number) {
+  const attributes: Partial<Record<PersonaDimensionId, PersonaAttributeId>> = {};
+  const labels: Partial<Record<PersonaDimensionId, string>> = {};
+  for (const dimension of PERSONA_DIMENSIONS) {
+    const options = PERSONA_OPTIONS.filter((option) => option.dimension === dimension);
+    const picks = items.filter((item) => options.some((option) => option.id === item.id));
+    const picked = pickWeighted(picks, rand, "" as PersonaAttributeId);
+    if (!picked) continue;
+    const option = PERSONA_OPTIONS.find((candidate) => candidate.id === picked);
+    if (!option) continue;
+    attributes[dimension] = option.id;
+    labels[dimension] = option.label;
+  }
+  return { attributes, labels };
+}
+
+function buildPersonaPools(items: WeightedPick<PersonaAttributeId>[], targetSize: number, rand: () => number) {
+  const pools = new Map<PersonaDimensionId, PersonaAttributeId[]>();
+  for (const dimension of PERSONA_DIMENSIONS) {
+    const options = PERSONA_OPTIONS.filter((option) => option.dimension === dimension);
+    const picks = items.filter((item) => options.some((option) => option.id === item.id));
+    pools.set(dimension, buildAllocationPool(picks, targetSize, "" as PersonaAttributeId, rand));
+  }
+  return pools;
+}
+
+function personaAttributesFromPools(pools: Map<PersonaDimensionId, PersonaAttributeId[]>, index: number) {
+  const attributes: Partial<Record<PersonaDimensionId, PersonaAttributeId>> = {};
+  const labels: Partial<Record<PersonaDimensionId, string>> = {};
+  for (const dimension of PERSONA_DIMENSIONS) {
+    const picked = pools.get(dimension)?.[index];
+    if (!picked) continue;
+    const option = PERSONA_OPTIONS.find((candidate) => candidate.id === picked);
+    if (!option) continue;
+    attributes[dimension] = option.id;
+    labels[dimension] = option.label;
+  }
+  return { attributes, labels };
+}
+
+function personaBiases(attributes: Partial<Record<PersonaDimensionId, PersonaAttributeId>>) {
+  let trust = 0;
+  let anxiety = 0;
+  let participation = 0;
+  if (attributes.occupation === "occ_self_employed") anxiety += 0.05;
+  if (attributes.occupation === "occ_student") participation += 0.03;
+  if (attributes.occupation === "occ_retired") participation += 0.04;
+  if (attributes.occupation === "occ_professional") trust += 0.02;
+  if (attributes.education === "edu_graduate" || attributes.education === "edu_bachelor") participation += 0.02;
+  if (attributes.housing === "housing_officetel") anxiety += 0.03;
+  if (attributes.family === "family_children") anxiety += 0.02;
+  if (attributes.family === "family_single") participation -= 0.01;
+  return { trust, anxiety, participation };
+}
+
+function labelOf<T extends string>(items: Array<{ id: T; label: string }>, id: T) {
+  return items.find((item) => item.id === id)?.label || id;
+}
+
+function segmentLabel(trust: number, anxiety: number, participation: number) {
+  if (anxiety > 0.68) return "생활압박층";
+  if (trust > 0.6 && participation > 0.55) return "제도참여층";
+  if (trust < 0.42) return "불신/관망층";
+  if (participation > 0.64) return "고관여층";
+  return "중도실용층";
+}
+
+function mean(values: number[]) {
+  return values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : 0;
+}
+
+function noise(rand: () => number, span: number) {
+  return (rand() - 0.5) * span * 2;
+}
+
+function clamp01(value: number) {
+  return Math.max(0, Math.min(1, value));
+}
+
+function mulberry32(seed: number) {
+  let state = seed >>> 0;
+  return () => {
+    state += 0x6d2b79f5;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}

frontend/src/silicon/types.ts

@@ -0,0 +1,139 @@
+export type GenderId = "male" | "female" | "no_response";
+export type AgeBandId = "20s" | "30s" | "40s" | "50s" | "60plus";
+export type RegionId =
+  | "seoul"
+  | "busan"
+  | "daegu"
+  | "incheon"
+  | "gwangju"
+  | "daejeon"
+  | "ulsan"
+  | "sejong"
+  | "gyeonggi"
+  | "gangwon"
+  | "chungbuk"
+  | "chungnam"
+  | "jeonbuk"
+  | "jeonnam"
+  | "gyeongbuk"
+  | "gyeongnam"
+  | "jeju";
+export type LocationId = string;
+export type LocationLevel = "sido" | "district";
+export type PersonaDimensionId = "occupation" | "education" | "housing" | "marital" | "family";
+export type PersonaAttributeId = string;
+
+export type QuestionKind = "likert" | "open";
+
+export interface ToggleOption<T extends string> {
+  id: T;
+  label: string;
+  short: string;
+  defaultWeight: number;
+}
+
+export interface RegionOption extends ToggleOption<RegionId> {
+  x: number;
+  y: number;
+  mapLabelX: number;
+  mapLabelY: number;
+}
+
+export interface LocationOption extends ToggleOption<LocationId> {
+  parentRegion: RegionId;
+  level: LocationLevel;
+  group: string;
+}
+
+export interface PersonaOption extends ToggleOption<PersonaAttributeId> {
+  dimension: PersonaDimensionId;
+  group: string;
+}
+
+export interface SurveyQuestion {
+  id: string;
+  title: string;
+  source: string;
+  category: string;
+  kind: QuestionKind;
+  scale?: 4 | 5 | 7;
+  lowLabel?: string;
+  highLabel?: string;
+}
+
+export interface WeightedPick<T extends string> {
+  id: T;
+  enabled: boolean;
+  weight: number;
+}
+
+export interface SiliconConfig {
+  sampleSize: number;
+  genders: WeightedPick<GenderId>[];
+  ages: WeightedPick<AgeBandId>[];
+  locations: WeightedPick<LocationId>[];
+  locationOptions: LocationOption[];
+  personaAttributes: WeightedPick<PersonaAttributeId>[];
+  nemotronFields: string[];
+  questions: SurveyQuestion[];
+  seed: number;
+}
+
+export interface SyntheticRespondent {
+  id: string;
+  gender: GenderId;
+  age: AgeBandId;
+  region: RegionId;
+  location: LocationId;
+  locationLabel: string;
+  personaAttributes: Partial<Record<PersonaDimensionId, PersonaAttributeId>>;
+  personaLabels: Partial<Record<PersonaDimensionId, string>>;
+  segment: string;
+  trust: number;
+  economicAnxiety: number;
+  participation: number;
+}
+
+export interface LikertAnswer {
+  respondentId: string;
+  questionId: string;
+  value: number;
+}
+
+export interface OpenAnswer {
+  respondentId: string;
+  questionId: string;
+  text: string;
+  theme: string;
+}
+
+export interface RegionStat {
+  region: LocationId;
+  parentRegion: RegionId;
+  label: string;
+  respondents: number;
+  mean: number;
+  scale: number;
+  positiveShare: number;
+  openCount: number;
+}
+
+export interface QuestionStat {
+  questionId: string;
+  title: string;
+  kind: QuestionKind;
+  scale?: number;
+  mean?: number;
+  positiveShare?: number;
+  distribution?: Array<{ value: number; count: number; share: number }>;
+}
+
+export interface SiliconResult {
+  config: SiliconConfig;
+  respondents: SyntheticRespondent[];
+  likertAnswers: LikertAnswer[];
+  openAnswers: OpenAnswer[];
+  regionStats: RegionStat[];
+  questionStats: QuestionStat[];
+  primaryQuestionId: string | null;
+}

frontend/src/styles.css

@@ -0,0 +1,1298 @@
+:root {
+  color-scheme: light;
+  font-family: "Aptos", "IBM Plex Sans KR", "IBM Plex Sans", "Helvetica Neue", sans-serif;
+  background: #f8fafc;
+  color: #18213a;
+  text-rendering: geometricPrecision;
+  font-synthesis: none;
+  --ink: #07100f;
+  --panel: rgba(6, 13, 13, 0.42);
+  --panel-strong: rgba(6, 13, 13, 0.58);
+  --line: rgba(237, 244, 231, 0.13);
+  --text: #f6f1e6;
+  --muted: rgba(246, 241, 230, 0.62);
+  --soft: rgba(246, 241, 230, 0.08);
+  --accent: #78d6b4;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body,
+#root {
+  width: 100%;
+  min-width: 0;
+  min-height: 100%;
+  margin: 0;
+}
+
+body {
+  overflow-x: hidden;
+}
+
+button,
+a {
+  font: inherit;
+  -webkit-tap-highlight-color: transparent;
+}
+
+button {
+  cursor: pointer;
+}
+.silicon-shell {
+  min-height: 100vh;
+  display: grid;
+  grid-template-columns: minmax(340px, 420px) minmax(0, 1fr);
+  background:
+    radial-gradient(circle at 70% 8%, rgba(127, 156, 255, 0.14), transparent 34%),
+    radial-gradient(circle at 20% 78%, rgba(217, 162, 79, 0.1), transparent 28%),
+    linear-gradient(135deg, #101017 0%, #171722 48%, #14151d 100%);
+  color: #f6f1e6;
+}
+
+.silicon-shell.setup-only {
+  display: block;
+}
+
+.silicon-shell.setup-only .silicon-config {
+  position: relative;
+  height: auto;
+  max-width: 1320px;
+  margin: 0 auto;
+  border-right: 0;
+  background: transparent;
+}
+
+.silicon-setup-grid {
+  display: block;
+}
+
+.silicon-shell.setup-only .silicon-setup-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 12px;
+  align-items: start;
+}
+
+.silicon-shell.setup-only .silicon-card {
+  margin-top: 0;
+}
+
+.silicon-shell.setup-only .silicon-hero {
+  margin-bottom: 12px;
+}
+
+.silicon-shell.setup-only .location-card,
+.silicon-shell.setup-only .persona-card,
+.silicon-shell.setup-only .nemotron-card,
+.silicon-shell.setup-only .question-card {
+  grid-column: span 3;
+}
+
+.silicon-config {
+  position: sticky;
+  top: 0;
+  height: 100vh;
+  overflow: auto;
+  border-right: 1px solid rgba(246, 241, 230, 0.11);
+  padding: 18px;
+  background: rgba(13, 13, 20, 0.66);
+}
+
+.silicon-hero,
+.silicon-card,
+.silicon-result-head,
+.silicon-summary-panel,
+.silicon-chart-card,
+.silicon-open-panel {
+  border: 1px solid rgba(246, 241, 230, 0.12);
+  border-radius: 18px;
+  background: rgba(246, 241, 230, 0.055);
+  box-shadow: 0 20px 70px rgba(0, 0, 0, 0.22);
+  backdrop-filter: blur(18px) saturate(1.1);
+}
+
+.silicon-hero {
+  padding: 16px;
+}
+
+.silicon-brand {
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+  color: #f6f1e6;
+  text-decoration: none;
+}
+
+.silicon-brand span {
+  width: 34px;
+  height: 34px;
+  border: 1px solid rgba(246, 241, 230, 0.22);
+  border-radius: 10px;
+  background:
+    linear-gradient(90deg, transparent 45%, rgba(246, 241, 230, .5) 46%, rgba(246, 241, 230, .5) 54%, transparent 55%),
+    linear-gradient(0deg, transparent 45%, rgba(246, 241, 230, .5) 46%, rgba(246, 241, 230, .5) 54%, transparent 55%),
+    linear-gradient(135deg, #7f9cff, #d9a24f);
+}
+
+.silicon-hero h1 {
+  margin: 18px 0 8px;
+  font-size: clamp(30px, 4vw, 48px);
+  line-height: 0.96;
+  letter-spacing: 0;
+}
+
+.silicon-hero p {
+  margin: 0;
+  color: rgba(246, 241, 230, 0.66);
+  line-height: 1.45;
+}
+
+.silicon-actions,
+.sample-presets,
+.custom-kind,
+.result-stats {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.silicon-actions {
+  margin-top: 16px;
+}
+
+.silicon-actions button,
+.sample-presets button,
+.custom-kind button,
+.custom-question > button {
+  min-height: 38px;
+  border: 1px solid rgba(246, 241, 230, 0.13);
+  border-radius: 999px;
+  padding: 8px 12px;
+  background: rgba(246, 241, 230, 0.08);
+  color: #f6f1e6;
+  font-weight: 850;
+}
+
+.silicon-actions .primary,
+.sample-presets button.active,
+.custom-kind button.active {
+  border-color: rgba(127, 156, 255, 0.68);
+  background: rgba(127, 156, 255, 0.2);
+}
+
+.silicon-actions button:disabled {
+  cursor: not-allowed;
+  opacity: 0.52;
+}
+
+.silicon-run-chip {
+  margin-top: 12px;
+  border: 1px solid rgba(246, 241, 230, 0.11);
+  border-radius: 12px;
+  padding: 9px 10px;
+  background: rgba(246, 241, 230, 0.05);
+  color: rgba(246, 241, 230, 0.68);
+  font-size: 12px;
+  line-height: 1.35;
+}
+
+.silicon-run-chip.running {
+  border-color: rgba(217, 162, 79, 0.5);
+  background: rgba(217, 162, 79, 0.12);
+  color: rgba(246, 241, 230, 0.86);
+}
+
+.silicon-card {
+  margin-top: 12px;
+  padding: 14px;
+}
+
+.default-ratio-box {
+  display: grid;
+  gap: 8px;
+  margin-top: 12px;
+  border-top: 1px solid rgba(246, 241, 230, 0.09);
+  padding-top: 12px;
+}
+
+.default-ratio-box button {
+  min-height: 38px;
+  border: 1px solid rgba(217, 162, 79, 0.42);
+  border-radius: 999px;
+  padding: 8px 12px;
+  background: rgba(217, 162, 79, 0.13);
+  color: #f6f1e6;
+  font-weight: 850;
+}
+
+.default-ratio-box span {
+  color: rgba(246, 241, 230, 0.62);
+  font-size: 12px;
+  line-height: 1.4;
+}
+
+.silicon-section-head,
+.silicon-summary-panel header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.question-card .silicon-section-head {
+  justify-content: space-between;
+}
+
+.silicon-section-head span,
+.toggle-head span,
+.silicon-result-head span,
+.silicon-summary-panel header span,
+.silicon-chart-card header span,
+.silicon-open-panel header span {
+  display: block;
+  color: rgba(246, 241, 230, 0.56);
+  font-size: 11px;
+  font-weight: 850;
+  letter-spacing: 0.07em;
+  text-transform: uppercase;
+}
+
+.silicon-section-head strong,
+.toggle-head strong,
+.silicon-summary-panel header strong,
+.silicon-chart-card header strong,
+.silicon-open-panel header strong {
+  display: block;
+  margin-top: 2px;
+  font-size: 16px;
+}
+
+.sample-presets {
+  margin-top: 12px;
+}
+
+.number-field,
+.custom-question label {
+  display: grid;
+  gap: 6px;
+  margin-top: 12px;
+}
+
+.number-field span,
+.custom-question label span {
+  color: rgba(246, 241, 230, 0.58);
+  font-size: 11px;
+  font-weight: 800;
+}
+
+.number-field input,
+.toggle-chip input,
+.custom-question input,
+.custom-kind select {
+  min-width: 0;
+  border: 1px solid rgba(246, 241, 230, 0.13);
+  border-radius: 10px;
+  background: rgba(5, 12, 12, 0.62);
+  color: #f6f1e6;
+  padding: 9px 10px;
+  outline: none;
+}
+
+.number-field input:focus,
+.toggle-chip input:focus,
+.custom-question input:focus,
+.custom-kind select:focus {
+  border-color: rgba(127, 156, 255, 0.68);
+}
+
+.toggle-head {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.toggle-head em {
+  border: 1px solid rgba(246, 241, 230, 0.12);
+  border-radius: 999px;
+  padding: 5px 8px;
+  color: rgba(246, 241, 230, 0.64);
+  font-size: 11px;
+  font-style: normal;
+  font-weight: 850;
+}
+
+.toggle-head em.warn {
+  border-color: rgba(217, 162, 79, 0.42);
+  color: rgba(246, 241, 230, 0.78);
+}
+
+.toggle-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.toggle-grid.compact {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.toggle-chip {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 54px;
+  gap: 6px;
+  align-items: center;
+  border: 1px solid rgba(246, 241, 230, 0.1);
+  border-radius: 12px;
+  padding: 6px;
+  background: rgba(246, 241, 230, 0.045);
+}
+
+.toggle-chip.active {
+  border-color: rgba(127, 156, 255, 0.5);
+  background: rgba(127, 156, 255, 0.13);
+}
+
+.toggle-chip button {
+  min-height: 34px;
+  border: 0;
+  border-radius: 9px;
+  background: transparent;
+  color: #f6f1e6;
+  font-weight: 850;
+  text-align: left;
+}
+
+.toggle-chip input {
+  height: 34px;
+  padding: 6px;
+  text-align: center;
+}
+
+.toggle-chip input:disabled {
+  opacity: 0.34;
+}
+
+.estimate-count {
+  grid-column: 1 / -1;
+  min-height: 14px;
+  color: rgba(246, 241, 230, 0.56);
+  font-size: 11px;
+  font-weight: 780;
+}
+
+.question-bank {
+  display: grid;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.question-bank button {
+  display: grid;
+  gap: 4px;
+  border: 1px solid rgba(246, 241, 230, 0.1);
+  border-radius: 12px;
+  background: rgba(246, 241, 230, 0.045);
+  color: #f6f1e6;
+  padding: 10px;
+  text-align: left;
+}
+
+.question-bank button.selected {
+  border-color: rgba(127, 156, 255, 0.56);
+  background: rgba(127, 156, 255, 0.14);
+}
+
+.question-bank button.kind-likert {
+  border-left: 4px solid rgba(127, 156, 255, 0.8);
+}
+
+.question-bank button.kind-open {
+  border-left: 4px solid rgba(217, 162, 79, 0.86);
+}
+
+.question-bank span,
+.question-bank em {
+  color: rgba(246, 241, 230, 0.58);
+  font-size: 11px;
+  font-style: normal;
+}
+
+.question-bank strong {
+  line-height: 1.3;
+}
+
+.custom-question {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 8px;
+  margin-top: 14px;
+  border-top: 1px solid rgba(246, 241, 230, 0.1);
+  padding-top: 12px;
+}
+
+.custom-kind {
+  grid-column: 1 / -1;
+}
+
+.question-bank-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  margin-left: auto;
+  border: 1px solid rgba(84, 96, 137, 0.16);
+  border-radius: 999px;
+  padding: 7px 10px;
+  background: #f5f7fc;
+  color: #273047;
+  font-size: 12px;
+  font-weight: 850;
+}
+
+.question-bank-toggle svg {
+  transition: transform 0.16s ease;
+}
+
+.question-bank-toggle.open svg {
+  transform: rotate(180deg);
+}
+
+.silicon-results {
+  min-width: 0;
+  padding: 18px;
+}
+
+.silicon-result-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 14px;
+  align-items: center;
+  padding: 14px 16px;
+}
+
+.silicon-result-head h2 {
+  margin: 2px 0 0;
+  font-size: clamp(28px, 4vw, 58px);
+  line-height: 0.96;
+}
+
+.result-stats span {
+  border: 1px solid rgba(246, 241, 230, 0.12);
+  border-radius: 999px;
+  padding: 7px 10px;
+  background: rgba(246, 241, 230, 0.06);
+  color: rgba(246, 241, 230, 0.68);
+  font-size: 12px;
+  font-weight: 800;
+}
+
+.result-stats strong {
+  color: #f6f1e6;
+}
+
+.silicon-summary-panel,
+.silicon-chart-card,
+.silicon-open-panel {
+  padding: 14px;
+}
+
+.silicon-open-panel header,
+.silicon-chart-card header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.method-note {
+  border: 1px solid rgba(246, 241, 230, 0.1);
+  border-radius: 999px;
+  padding: 7px 9px;
+  background: rgba(246, 241, 230, 0.055);
+}
+
+.silicon-summary-panel {
+  display: grid;
+  align-content: start;
+  gap: 10px;
+  margin-top: 12px;
+}
+
+.silicon-metric {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  border-bottom: 1px solid rgba(246, 241, 230, 0.09);
+  padding: 10px 0;
+}
+
+.silicon-metric span {
+  color: rgba(246, 241, 230, 0.6);
+  font-size: 12px;
+  font-weight: 780;
+}
+
+.silicon-metric strong {
+  font-size: 19px;
+}
+
+.method-note {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  border-radius: 13px;
+  color: rgba(246, 241, 230, 0.68);
+  font-size: 12px;
+  line-height: 1.45;
+}
+
+.silicon-chart-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 12px;
+  margin-top: 12px;
+}
+
+.silicon-chart-grid.single {
+  grid-template-columns: minmax(0, 1.35fr) minmax(280px, 0.65fr);
+}
+
+.silicon-chart-card {
+  min-width: 0;
+}
+
+.silicon-chart-card.wide,
+.silicon-open-panel {
+  grid-column: span 2;
+}
+
+.silicon-chart {
+  height: 260px;
+  margin-top: 10px;
+}
+
+.silicon-open-panel {
+  min-width: 0;
+}
+
+.silicon-answer-list {
+  display: grid;
+  gap: 8px;
+  max-height: 324px;
+  overflow: auto;
+  margin-top: 10px;
+}
+
+.silicon-answer-list article {
+  display: grid;
+  gap: 5px;
+  border: 1px solid rgba(246, 241, 230, 0.1);
+  border-radius: 12px;
+  padding: 10px;
+  background: rgba(246, 241, 230, 0.045);
+}
+
+.silicon-answer-list span {
+  color: rgba(246, 241, 230, 0.55);
+  font-size: 11px;
+  font-weight: 780;
+}
+
+.silicon-answer-list p {
+  margin: 0;
+  color: rgba(246, 241, 230, 0.84);
+  font-size: 13px;
+  line-height: 1.45;
+}
+
+.silicon-answer-list article strong {
+  width: fit-content;
+  border-radius: 999px;
+  padding: 4px 7px;
+  background: rgba(127, 156, 255, 0.16);
+  color: #b7c4ff;
+  font-size: 11px;
+}
+
+.location-tabs,
+.result-mode-buttons,
+.metric-tabs {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.location-tabs button,
+.result-mode-buttons button,
+.metric-tabs button {
+  min-height: 34px;
+  border: 1px solid rgba(246, 241, 230, 0.12);
+  border-radius: 999px;
+  padding: 7px 10px;
+  background: rgba(246, 241, 230, 0.06);
+  color: #f6f1e6;
+  font-size: 12px;
+  font-weight: 850;
+}
+
+.location-tabs button.active,
+.result-mode-buttons button.active,
+.metric-tabs button.active {
+  border-color: rgba(127, 156, 255, 0.58);
+  background: rgba(127, 156, 255, 0.16);
+}
+
+.location-toggle-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 8px;
+  max-height: 320px;
+  overflow: auto;
+  margin-top: 10px;
+  padding-right: 4px;
+}
+
+.location-detail-panel {
+  margin-top: 12px;
+  border-top: 1px solid rgba(246, 241, 230, 0.09);
+  padding-top: 12px;
+}
+
+.location-detail-tabs {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.location-detail-tabs button,
+.nemotron-actions button,
+.nemotron-column-grid button {
+  border: 1px solid rgba(246, 241, 230, 0.12);
+  border-radius: 999px;
+  background: rgba(246, 241, 230, 0.055);
+  color: #f6f1e6;
+  font-size: 12px;
+  font-weight: 820;
+}
+
+.location-detail-tabs button {
+  min-height: 30px;
+  padding: 6px 10px;
+}
+
+.location-detail-tabs button.active,
+.nemotron-column-grid button.active {
+  border-color: rgba(127, 156, 255, 0.58);
+  background: rgba(127, 156, 255, 0.16);
+}
+
+.detail-grid {
+  max-height: 220px;
+}
+
+.selector-empty-note {
+  margin: 12px 0 0;
+  border: 1px dashed rgba(246, 241, 230, 0.16);
+  border-radius: 14px;
+  padding: 14px;
+  color: #a8a3b8;
+  background: rgba(246, 241, 230, 0.035);
+  font-size: 12px;
+  font-weight: 760;
+}
+
+.persona-toggle-grid {
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+
+.nemotron-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.nemotron-actions button {
+  min-height: 32px;
+  padding: 6px 10px;
+}
+
+.nemotron-column-section {
+  margin-top: 12px;
+}
+
+.nemotron-column-section > span {
+  display: block;
+  margin-bottom: 8px;
+  color: rgba(246, 241, 230, 0.58);
+  font-size: 11px;
+  font-weight: 850;
+  letter-spacing: 0.07em;
+  text-transform: uppercase;
+}
+
+.nemotron-column-grid {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.nemotron-column-grid button {
+  min-height: 32px;
+  padding: 6px 10px;
+  color: rgba(246, 241, 230, 0.74);
+}
+
+.silicon-shell.has-results .location-toggle-grid,
+.silicon-shell.has-results .persona-toggle-grid {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  max-height: 240px;
+}
+
+.silicon-state-panel {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  margin-top: 12px;
+  border: 1px solid rgba(246, 241, 230, 0.12);
+  border-radius: 18px;
+  padding: 18px;
+  background: rgba(246, 241, 230, 0.055);
+}
+
+.silicon-state-panel span,
+.explorer-toolbar span,
+.question-tabs span,
+.metric-card-item span {
+  display: block;
+  color: rgba(246, 241, 230, 0.56);
+  font-size: 11px;
+  font-weight: 850;
+  letter-spacing: 0.07em;
+  text-transform: uppercase;
+}
+
+.silicon-state-panel strong {
+  display: block;
+  margin-top: 2px;
+  font-size: 18px;
+}
+
+.silicon-state-panel p {
+  margin: 6px 0 0;
+  color: rgba(246, 241, 230, 0.62);
+  font-size: 13px;
+  line-height: 1.45;
+}
+
+.silicon-spinner {
+  width: 34px;
+  height: 34px;
+  flex: 0 0 auto;
+  border: 3px solid rgba(246, 241, 230, 0.16);
+  border-top-color: #d9a24f;
+  border-radius: 999px;
+  animation: silicon-spin 0.9s linear infinite;
+}
+
+@keyframes silicon-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.silicon-explorer {
+  margin-top: 12px;
+}
+
+.explorer-toolbar {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  align-items: flex-start;
+  border: 1px solid rgba(246, 241, 230, 0.12);
+  border-radius: 18px;
+  padding: 14px;
+  background: rgba(246, 241, 230, 0.055);
+}
+
+.explorer-toolbar strong {
+  display: block;
+  margin-top: 3px;
+  font-size: 17px;
+}
+
+.question-tabs {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.question-tabs button {
+  display: grid;
+  gap: 5px;
+  min-height: 84px;
+  border: 1px solid rgba(246, 241, 230, 0.1);
+  border-radius: 14px;
+  padding: 10px;
+  background: rgba(246, 241, 230, 0.045);
+  color: #f6f1e6;
+  text-align: left;
+}
+
+.question-tabs button.kind-likert {
+  border-top: 3px solid rgba(127, 156, 255, 0.82);
+}
+
+.question-tabs button.kind-open {
+  border-top: 3px solid rgba(217, 162, 79, 0.9);
+}
+
+.question-tabs button.active {
+  border-color: rgba(246, 241, 230, 0.22);
+  background: rgba(246, 241, 230, 0.09);
+}
+
+.question-tabs strong {
+  line-height: 1.28;
+}
+
+.metric-card-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+  margin-top: 12px;
+}
+
+.metric-card-item {
+  border: 1px solid rgba(246, 241, 230, 0.1);
+  border-radius: 14px;
+  padding: 12px;
+  background: rgba(246, 241, 230, 0.045);
+}
+
+.metric-card-item strong {
+  display: block;
+  margin-top: 8px;
+  font-size: 24px;
+}
+
+/* Silicon Sampling: light research-dashboard theme */
+.silicon-shell {
+  background:
+    linear-gradient(180deg, rgba(247, 249, 255, 0.94), rgba(255, 255, 255, 0.98)),
+    #f8fafc;
+  color: #18213a;
+}
+
+.silicon-config {
+  border-right-color: rgba(84, 96, 137, 0.16);
+  background: rgba(248, 250, 252, 0.86);
+}
+
+.silicon-hero,
+.silicon-card,
+.silicon-result-head,
+.silicon-summary-panel,
+.silicon-chart-card,
+.silicon-open-panel,
+.explorer-toolbar,
+.silicon-response-table-card,
+.silicon-state-panel {
+  border-color: rgba(84, 96, 137, 0.14);
+  background: rgba(255, 255, 255, 0.92);
+  box-shadow: 0 18px 48px rgba(39, 55, 96, 0.1);
+  backdrop-filter: blur(18px) saturate(1.08);
+}
+
+.silicon-brand {
+  color: #18213a;
+}
+
+.silicon-brand span {
+  border-color: rgba(91, 110, 225, 0.24);
+  background:
+    linear-gradient(90deg, transparent 45%, rgba(255, 255, 255, .82) 46%, rgba(255, 255, 255, .82) 54%, transparent 55%),
+    linear-gradient(0deg, transparent 45%, rgba(255, 255, 255, .82) 46%, rgba(255, 255, 255, .82) 54%, transparent 55%),
+    linear-gradient(135deg, #5b6ee1, #f08a6c);
+}
+
+.silicon-hero p,
+.default-ratio-box span,
+.silicon-run-chip,
+.silicon-metric span,
+.method-note,
+.silicon-state-panel p,
+.estimate-count,
+.question-bank span,
+.question-bank em,
+.number-field span,
+.custom-question label span,
+.nemotron-column-section > span,
+.silicon-section-head span,
+.toggle-head span,
+.silicon-result-head span,
+.silicon-summary-panel header span,
+.silicon-chart-card header span,
+.silicon-open-panel header span,
+.silicon-state-panel span,
+.explorer-toolbar span,
+.question-tabs span,
+.metric-card-item span {
+  color: rgba(24, 33, 58, 0.58);
+}
+
+.silicon-section-head strong,
+.toggle-head strong,
+.silicon-summary-panel header strong,
+.silicon-chart-card header strong,
+.silicon-open-panel header strong,
+.silicon-state-panel strong,
+.explorer-toolbar strong,
+.question-tabs strong,
+.metric-card-item strong,
+.silicon-metric strong {
+  color: #18213a;
+}
+
+.silicon-actions button,
+.sample-presets button,
+.custom-kind button,
+.custom-question > button,
+.default-ratio-box button,
+.location-tabs button,
+.result-mode-buttons button,
+.metric-tabs button,
+.location-detail-tabs button,
+.nemotron-actions button,
+.nemotron-column-grid button {
+  border-color: rgba(84, 96, 137, 0.16);
+  background: #f5f7fc;
+  color: #273047;
+}
+
+.silicon-actions .primary,
+.sample-presets button.active,
+.custom-kind button.active,
+.location-tabs button.active,
+.result-mode-buttons button.active,
+.metric-tabs button.active,
+.location-detail-tabs button.active,
+.nemotron-column-grid button.active {
+  border-color: rgba(91, 110, 225, 0.44);
+  background: #eef1ff;
+  color: #3647bf;
+}
+
+.silicon-actions .primary {
+  background: linear-gradient(135deg, #5364d8, #6f7deb);
+  color: #fff;
+  box-shadow: 0 10px 24px rgba(83, 100, 216, 0.24);
+}
+
+.default-ratio-box {
+  border-top-color: rgba(84, 96, 137, 0.12);
+}
+
+.default-ratio-box button {
+  border-color: rgba(240, 138, 108, 0.34);
+  background: #fff3ee;
+  color: #af4f37;
+}
+
+.silicon-run-chip,
+.method-note,
+.selector-empty-note {
+  border-color: rgba(84, 96, 137, 0.13);
+  background: #f7f8fc;
+}
+
+.silicon-run-chip.running {
+  border-color: rgba(240, 138, 108, 0.42);
+  background: #fff3ee;
+  color: #9a4a33;
+}
+
+.number-field input,
+.toggle-chip input,
+.custom-question input,
+.custom-kind select {
+  border-color: rgba(84, 96, 137, 0.18);
+  background: #fff;
+  color: #18213a;
+}
+
+.number-field input:focus,
+.toggle-chip input:focus,
+.custom-question input:focus,
+.custom-kind select:focus {
+  border-color: rgba(91, 110, 225, 0.6);
+  box-shadow: 0 0 0 3px rgba(91, 110, 225, 0.1);
+}
+
+.toggle-head em,
+.result-stats span {
+  border-color: rgba(84, 96, 137, 0.15);
+  background: #f7f8fc;
+  color: rgba(24, 33, 58, 0.62);
+}
+
+.result-stats strong {
+  color: #3647bf;
+}
+
+.toggle-chip,
+.question-bank button,
+.question-tabs button,
+.metric-card-item,
+.silicon-answer-list article {
+  border-color: rgba(84, 96, 137, 0.13);
+  background: #fbfcff;
+}
+
+.toggle-chip.active,
+.question-bank button.selected {
+  border-color: rgba(91, 110, 225, 0.38);
+  background: #eef1ff;
+}
+
+.toggle-chip button,
+.question-bank button,
+.question-tabs button {
+  color: #18213a;
+}
+
+.question-bank button.kind-likert,
+.question-tabs button.kind-likert {
+  border-left-color: #5b6ee1;
+  border-top-color: #5b6ee1;
+}
+
+.question-bank button.kind-open,
+.question-tabs button.kind-open {
+  border-left-color: #f08a6c;
+  border-top-color: #f08a6c;
+}
+
+.question-tabs button.active {
+  border-color: rgba(91, 110, 225, 0.38);
+  background: linear-gradient(180deg, #f3f5ff, #ffffff);
+}
+
+.silicon-metric {
+  border-bottom-color: rgba(84, 96, 137, 0.12);
+}
+
+.silicon-chart-grid.open-only {
+  grid-template-columns: 1fr;
+}
+
+.silicon-chart-grid.open-only .silicon-open-panel,
+.silicon-chart-grid.open-only .silicon-response-table-card,
+.silicon-response-table-card {
+  grid-column: 1 / -1;
+}
+
+.silicon-answer-list span {
+  color: rgba(24, 33, 58, 0.56);
+}
+
+.silicon-answer-list p {
+  color: rgba(24, 33, 58, 0.82);
+}
+
+.silicon-spinner {
+  border-color: rgba(84, 96, 137, 0.16);
+  border-top-color: #5b6ee1;
+}
+
+.custom-question-list {
+  display: grid;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.custom-question-list > span {
+  color: rgba(24, 33, 58, 0.58);
+  font-size: 11px;
+  font-weight: 850;
+  letter-spacing: 0.07em;
+  text-transform: uppercase;
+}
+
+.custom-question-list article {
+  display: grid;
+  gap: 4px;
+  border: 1px solid rgba(84, 96, 137, 0.13);
+  border-radius: 12px;
+  padding: 10px;
+  background: #fbfcff;
+}
+
+.custom-question-list article.kind-likert {
+  border-left: 4px solid #5b6ee1;
+}
+
+.custom-question-list article.kind-open {
+  border-left: 4px solid #f08a6c;
+}
+
+.custom-question-list em {
+  color: rgba(24, 33, 58, 0.56);
+  font-size: 11px;
+  font-style: normal;
+  font-weight: 800;
+}
+
+.custom-question-list strong {
+  color: #18213a;
+  font-size: 13px;
+}
+
+.silicon-response-table-card {
+  min-width: 0;
+  padding: 14px;
+}
+
+.silicon-response-table-card header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.silicon-response-table-scroll {
+  max-height: 340px;
+  margin-top: 12px;
+  overflow: auto;
+  border: 1px solid rgba(84, 96, 137, 0.12);
+  border-radius: 14px;
+}
+
+.silicon-response-table {
+  width: 100%;
+  min-width: 940px;
+  border-collapse: collapse;
+  background: #fff;
+  font-size: 12px;
+}
+
+.silicon-response-table th,
+.silicon-response-table td {
+  border-bottom: 1px solid rgba(84, 96, 137, 0.1);
+  padding: 10px;
+  text-align: left;
+  vertical-align: top;
+}
+
+.silicon-response-table th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  background: #f5f7fc;
+  color: rgba(24, 33, 58, 0.64);
+  font-size: 11px;
+  font-weight: 850;
+}
+
+.silicon-response-table td {
+  color: rgba(24, 33, 58, 0.8);
+  line-height: 1.4;
+}
+
+@media (max-width: 1280px) {
+  .silicon-shell {
+    grid-template-columns: 380px minmax(0, 1fr);
+  }
+
+  .silicon-shell.setup-only .silicon-setup-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .silicon-shell.setup-only .location-card,
+  .silicon-shell.setup-only .persona-card,
+  .silicon-shell.setup-only .nemotron-card,
+  .silicon-shell.setup-only .question-card {
+    grid-column: span 2;
+  }
+
+  .silicon-chart-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .question-tabs {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 980px) {
+  .silicon-shell {
+    display: block;
+  }
+
+  .silicon-shell.setup-only .silicon-setup-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .silicon-shell.setup-only .location-card,
+  .silicon-shell.setup-only .persona-card,
+  .silicon-shell.setup-only .nemotron-card,
+  .silicon-shell.setup-only .question-card {
+    grid-column: auto;
+  }
+
+  .silicon-config {
+    position: relative;
+    height: auto;
+    border-right: 0;
+    border-bottom: 1px solid rgba(246, 241, 230, 0.11);
+  }
+
+  .silicon-chart-grid.single,
+  .explorer-toolbar {
+    grid-template-columns: 1fr;
+  }
+
+  .silicon-chart-grid.single,
+  .explorer-toolbar {
+    display: grid;
+  }
+}
+
+@media (max-width: 640px) {
+  .silicon-config,
+  .silicon-results {
+    padding: 10px;
+  }
+
+  .silicon-result-head,
+  .silicon-open-panel header,
+  .silicon-chart-card header {
+    display: grid;
+  }
+
+  .toggle-grid,
+  .toggle-grid.compact,
+  .silicon-chart-grid,
+  .silicon-chart-grid.single,
+  .location-toggle-grid,
+  .question-tabs,
+  .metric-card-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .silicon-chart-card.wide,
+  .silicon-open-panel {
+    grid-column: auto;
+  }
+
+  .custom-question {
+    grid-template-columns: 1fr;
+  }
+}

frontend/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="ko">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Silicon Sampling Lab</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/frontend/src/main.tsx"></script>
+  </body>
+</html>

package-lock.json

@@ -0,0 +1,1034 @@
+{
+  "name": "silicon-sampling-lab",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "silicon-sampling-lab",
+      "version": "1.0.0",
+      "dependencies": {
+        "echarts": "^6.1.0",
+        "lucide-react": "^1.22.0",
+        "react": "^19.2.7",
+        "react-dom": "^19.2.7"
+      },
+      "devDependencies": {
+        "@types/react": "^19.2.17",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react": "^6.0.3",
+        "typescript": "^6.0.3",
+        "vite": "^8.1.0"
+      }
+    },
+    "node_modules/@emnapi/core": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.1.tgz",
+      "integrity": "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.2",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/core/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.1.tgz",
+      "integrity": "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.2.tgz",
+      "integrity": "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.6.tgz",
+      "integrity": "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.3"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
+      }
+    },
+    "node_modules/@oxc-project/types": {
+      "version": "0.137.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.137.0.tgz",
+      "integrity": "sha512-WT+Gb24i8hmvo85AIv2oEYouEXkRlKAlT9WaCa3TfLgNCN+GhrJOGZuIlMouAh38Qe4QOx26eUOVsq70qXrywA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
+    },
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.1.3.tgz",
+      "integrity": "sha512-DT6Z3PhvioeHMvxo+xHc3KtqggrI7CCTXCmC2h/5zUlp5jVitv7XEy+9q5/7v8IolhlioawpMo8Kg0EEBy7J0g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.1.3.tgz",
+      "integrity": "sha512-0NwgwsjM7LrsuVnXMK3koTpagBNOhloc/BNjKqZjv4V5zI5r13qx69uVhRx+o5Z0yy4Hzq+lpy7TAgUG/ocvrw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.1.3.tgz",
+      "integrity": "sha512-YtiBp4disu6V560loT6PjMdiRaWmVvDNrUunAalbiFx2ggeJwxdAsgZMcoGP17uyAsTwAj5V1niksxlHnVQ1Sw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.1.3.tgz",
+      "integrity": "sha512-yD3EkEdXk2LypPxnf/kSZHirarsI8gcPzc62SukhR9VJTyvV+F9Q/GxWNuCojc7sXyuVC4DxRGhdDK4X8VSsbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.1.3.tgz",
+      "integrity": "sha512-c+8vieQbsD7HNAHKIA34w0GJ9FedFFuJGD+7E6vz7Q3uqAIugL5p45fhlsj4UaAsHpcmlqugBWMhA0/j7o0sIg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.1.3.tgz",
+      "integrity": "sha512-50jD0uUwLvur7Zz9LHz17kaAdTPjn5wN93hEgjvmYFRZwiR7ZJYovTd5ipyWJDAnXKvZ+wgc+/Ika6dwSF5OcA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.1.3.tgz",
+      "integrity": "sha512-BO9+oPL8K9poZJBfYPsXNtYjPE5uM3qeehT3aFcW4LITOl+iSqhp0abzjR2nWBUNjIZeKXjAEWBZ64WjNoHd6w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.1.3.tgz",
+      "integrity": "sha512-f3VpLB1vQ0Eo6ecr/6cekLnvYMFF4YBFoVGkfkvPLq1bAkbAwHYQPZKoAmG6OJyTcxxoC+AvezGx/S1obNC0Mw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.1.3.tgz",
+      "integrity": "sha512-AmurZ26Pqx/RI9N1gzEOCklkKXl927yjfXWUUS0O7Puh8ARM/Ob8qfrD3qnWksScdw6cSrW5PSHE9DyLu7+PtA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.1.3.tgz",
+      "integrity": "sha512-JJpqs8bRGITDOdbkNKnlojzBabbOHrqjSvDr0IVsZObE1lBcPjxItUEY9eWIDbxaJ3cGrXPWGfGkIxFijg/URg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.1.3.tgz",
+      "integrity": "sha512-rSJcdjPxzA/by/6/rYs+v+bXU7UjvnbUWz8MJb6kh6+knqB1dCrtHg0uu7C/4haqJvqdkYHQ5IGn+tCH9GLW/g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.1.3.tgz",
+      "integrity": "sha512-hQ3/PYkDJICgevvyNcVrihVeqq7k1Pp3VZ9lY+dauAYUJKO+auqApvANhvR1An9BhmqYKvW2Mu1F9u4DXSMLxQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.1.3.tgz",
+      "integrity": "sha512-Elcv/BtML9lXrV6JuKITc/grN2kYV9gjsQpW8Jfw4ioK0TOkjBjye0nnyqQNy9STNaI20lXNaQBRrD5gSgR0Yg==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "1.11.1",
+        "@emnapi/runtime": "1.11.1",
+        "@napi-rs/wasm-runtime": "^1.1.6"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.1.3.tgz",
+      "integrity": "sha512-2DrEfhluH9yhiaFApmsjsjwrSYbNcY1oFTzYSP1a535jDbV98zCFanA/96TBUd0iDFcxGmw9QRExwGCXz3U+/g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.1.3.tgz",
+      "integrity": "sha512-OL4OMk7UPXOeVGGd3qo5zJyPIljf4AFgk5QAkPPS+OoLuOOozhuaQGC18MxVTnw/06q93gShAJzlwnSCY9YtqA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.3",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.3.tgz",
+      "integrity": "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tybys/wasm-util/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.17",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
+      "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.0.3.tgz",
+      "integrity": "sha512-vmFvco5/QuC2f9Oj+wTk0+9XeDFkHxSamwZKYc7MxYwKICfvUvlMhqKI0VuICPltGqh1neqBKDvO4kes1ya8vg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rolldown/pluginutils": "^1.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0",
+        "babel-plugin-react-compiler": "^1.0.0",
+        "vite": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@rolldown/plugin-babel": {
+          "optional": true
+        },
+        "babel-plugin-react-compiler": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/echarts": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/echarts/-/echarts-6.1.0.tgz",
+      "integrity": "sha512-q0yaFPggC9FUdsWH4blavRWFmxdrIodbkoKNAjJudAI6CA9gNPxHtV2RcZNEepZVlk4yvBYkOkbk6HIVpIyHZA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "2.3.0",
+        "zrender": "6.1.0"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lucide-react": {
+      "version": "1.22.0",
+      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-1.22.0.tgz",
+      "integrity": "sha512-c9o3l0PiNcgOQDW4F31BEYHudE7kgxVt3o30qMl36ZPwTxXlGB4QnLilhERvVM4uh/pl5MDyY1/gzZSYcHDtBg==",
+      "license": "ISC",
+      "peerDependencies": {
+        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.15",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.15.tgz",
+      "integrity": "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.16",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.16.tgz",
+      "integrity": "sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz",
+      "integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz",
+      "integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.7"
+      }
+    },
+    "node_modules/rolldown": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.1.3.tgz",
+      "integrity": "sha512-1F1eEtUBtFvcGm1HQ9TiUIUHPQG7mSAODrhIzjxoUEFuo8OcbrGLiVLkevNgj84TE4lnHvnumwFjhJO5Eu135g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/types": "=0.137.0",
+        "@rolldown/pluginutils": "^1.0.0"
+      },
+      "bin": {
+        "rolldown": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@rolldown/binding-android-arm64": "1.1.3",
+        "@rolldown/binding-darwin-arm64": "1.1.3",
+        "@rolldown/binding-darwin-x64": "1.1.3",
+        "@rolldown/binding-freebsd-x64": "1.1.3",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.1.3",
+        "@rolldown/binding-linux-arm64-gnu": "1.1.3",
+        "@rolldown/binding-linux-arm64-musl": "1.1.3",
+        "@rolldown/binding-linux-ppc64-gnu": "1.1.3",
+        "@rolldown/binding-linux-s390x-gnu": "1.1.3",
+        "@rolldown/binding-linux-x64-gnu": "1.1.3",
+        "@rolldown/binding-linux-x64-musl": "1.1.3",
+        "@rolldown/binding-openharmony-arm64": "1.1.3",
+        "@rolldown/binding-wasm32-wasi": "1.1.3",
+        "@rolldown/binding-win32-arm64-msvc": "1.1.3",
+        "@rolldown/binding-win32-x64-msvc": "1.1.3"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.0.tgz",
+      "integrity": "sha512-N82ooyxVNm6h1riLCoyS9e3fuJ3AMG2zIZs2Gd1ATcSFjSA23Q0fzjjZeh0jbJvWVDZ0cJT8yaNNaaXHzueNjg==",
+      "license": "0BSD"
+    },
+    "node_modules/typescript": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+      "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/vite": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.1.0.tgz",
+      "integrity": "sha512-BuJcQK/56NQTWDGn4ABea3q4SSBdNPWwNZKTkkUpcMPnLoquSYH8llRtSUIgoL1KSCpHt5eghLShn50mH36y7Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.4",
+        "postcss": "^8.5.15",
+        "rolldown": "~1.1.2",
+        "tinyglobby": "^0.2.17"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.3.0",
+        "esbuild": "^0.27.0 || ^0.28.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/zrender": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/zrender/-/zrender-6.1.0.tgz",
+      "integrity": "sha512-oEGMDB6pOP2S6OwRR4PdVv610zrjnA3Bh+JnSG12fYJlBKjtNAoEb5fSUoCOOINlH96I2fU38/A2UpRKs67xYQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tslib": "2.3.0"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,25 @@
+{
+  "name": "silicon-sampling-lab",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite --host 127.0.0.1 --port 5190",
+    "build": "tsc -p tsconfig.json && vite build",
+    "preview": "vite preview --host 127.0.0.1 --port 5191",
+    "start": "python3 server.py --host 0.0.0.0 --port ${PORT:-8765}"
+  },
+  "dependencies": {
+    "echarts": "^6.1.0",
+    "lucide-react": "^1.22.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.3",
+    "typescript": "^6.0.3",
+    "vite": "^8.1.0"
+  }
+}

persona_dataset.py

@@ -0,0 +1,838 @@
+"""Local Nemotron-Personas-Korea dataset support for the simulation UI.
+
+The dataset is intentionally treated as a local asset after download. Runtime
+sampling reads downloaded parquet shards through DuckDB; it does not call the
+Hugging Face dataset viewer for rows.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+import time
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+APP_DIR = Path(__file__).resolve().parent
+DATASET_ID = "nvidia/Nemotron-Personas-Korea"
+DATASET_CONFIG = "default"
+DATASET_SPLIT = "train"
+DATA_DIR = Path(os.getenv("NEMOTRON_KOREA_DATA_DIR", APP_DIR / "data" / "nemotron_personas_korea")).expanduser()
+PARQUET_DIR = DATA_DIR / "parquet"
+MANIFEST_PATH = DATA_DIR / "manifest.json"
+DUCKDB_PATH = DATA_DIR / "personas.duckdb"
+
+DATASET_COLUMNS = [
+    "uuid",
+    "professional_persona",
+    "sports_persona",
+    "arts_persona",
+    "travel_persona",
+    "culinary_persona",
+    "family_persona",
+    "persona",
+    "cultural_background",
+    "skills_and_expertise",
+    "skills_and_expertise_list",
+    "hobbies_and_interests",
+    "hobbies_and_interests_list",
+    "career_goals_and_ambitions",
+    "sex",
+    "age",
+    "marital_status",
+    "military_status",
+    "family_type",
+    "housing_type",
+    "education_level",
+    "bachelors_field",
+    "occupation",
+    "district",
+    "province",
+    "country",
+]
+
+TEXT_FIELDS = [
+    "persona",
+    "professional_persona",
+    "family_persona",
+    "cultural_background",
+    "skills_and_expertise",
+    "hobbies_and_interests",
+    "career_goals_and_ambitions",
+    "sports_persona",
+    "arts_persona",
+    "travel_persona",
+    "culinary_persona",
+]
+
+DEFAULT_SELECTED_FIELDS = [
+    "persona",
+    "professional_persona",
+    "family_persona",
+    "hobbies_and_interests",
+    "skills_and_expertise",
+    "career_goals_and_ambitions",
+]
+
+SEX_ALIASES = {
+    "여성": "여자",
+    "여": "여자",
+    "여자": "여자",
+    "female": "여자",
+    "f": "여자",
+    "woman": "여자",
+    "women": "여자",
+    "남성": "남자",
+    "남": "남자",
+    "남자": "남자",
+    "male": "남자",
+    "m": "남자",
+    "man": "남자",
+    "men": "남자",
+}
+
+PROVINCE_ALIASES = {
+    "seoul": "서울",
+    "서울시": "서울",
+    "서울특별시": "서울",
+    "busan": "부산",
+    "부산시": "부산",
+    "부산광역시": "부산",
+    "gyeonggi": "경기",
+    "gyeonggi-do": "경기",
+    "경기도": "경기",
+    "incheon": "인천",
+    "daegu": "대구",
+    "daejeon": "대전",
+    "gwangju": "광주",
+    "ulsan": "울산",
+    "sejong": "세종",
+    "jeju": "제주",
+    "jeju-do": "제주",
+    "강원도": "강원",
+    "chungcheongnam-do": "충청남",
+    "chungcheongbuk-do": "충청북",
+    "jeollanam-do": "전라남",
+    "jeollabuk-do": "전북",
+    "gyeongsangnam-do": "경상남",
+    "gyeongsangbuk-do": "경상북",
+}
+
+CATEGORICAL_FIELDS = [
+    "sex",
+    "marital_status",
+    "military_status",
+    "family_type",
+    "housing_type",
+    "education_level",
+    "bachelors_field",
+    "occupation",
+    "district",
+    "province",
+    "country",
+]
+
+SAMPLING_FIELDS = [
+    "uuid",
+    "sex",
+    "age",
+    "marital_status",
+    "military_status",
+    "family_type",
+    "housing_type",
+    "education_level",
+    "bachelors_field",
+    "occupation",
+    "district",
+    "province",
+    "country",
+    *TEXT_FIELDS,
+]
+
+
+class PersonaDatasetError(RuntimeError):
+    """Raised when the local dataset is unavailable or cannot be queried."""
+
+
+def _duckdb_module() -> Any:
+    try:
+        import duckdb  # type: ignore
+    except ModuleNotFoundError as exc:
+        raise PersonaDatasetError(
+            "duckdb is required for local Nemotron sampling. Install it in the "
+            "Python environment that runs social-sim-ui: python -m pip install duckdb"
+        ) from exc
+    return duckdb
+
+
+def _json_url(url: str, timeout: int = 60) -> Any:
+    request = urllib.request.Request(url, headers={"User-Agent": "social-sim-ui/0.1"})
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def _parquet_glob() -> str:
+    return str(PARQUET_DIR / "*.parquet")
+
+
+def _safe_sql_literal(value: str) -> str:
+    return "'" + value.replace("'", "''") + "'"
+
+
+def _read_manifest() -> dict[str, Any] | None:
+    if not MANIFEST_PATH.exists():
+        return None
+    try:
+        return json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def fetch_manifest() -> dict[str, Any]:
+    """Fetch and persist a parquet URL manifest from Hugging Face."""
+
+    url = f"https://huggingface.co/api/datasets/{DATASET_ID}/parquet"
+    payload = _json_url(url)
+    urls = payload.get(DATASET_CONFIG, {}).get(DATASET_SPLIT)
+    if not isinstance(urls, list) or not urls:
+        raise PersonaDatasetError(f"Could not find {DATASET_CONFIG}/{DATASET_SPLIT} parquet URLs for {DATASET_ID}")
+    manifest = {
+        "dataset_id": DATASET_ID,
+        "config": DATASET_CONFIG,
+        "split": DATASET_SPLIT,
+        "fetched_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "parquet_urls": urls,
+        "columns": DATASET_COLUMNS,
+        "license": "cc-by-4.0",
+    }
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    MANIFEST_PATH.write_text(json.dumps(manifest, indent=2, ensure_ascii=False), encoding="utf-8")
+    return manifest
+
+
+def download_dataset(*, force: bool = False, limit_shards: int | None = None) -> dict[str, Any]:
+    """Download parquet shards locally.
+
+    ``limit_shards`` is for smoke tests. Production use should leave it unset.
+    """
+
+    manifest = _read_manifest() or fetch_manifest()
+    urls = list(manifest.get("parquet_urls") or [])
+    if limit_shards is not None:
+        urls = urls[: max(0, int(limit_shards))]
+    if not urls:
+        raise PersonaDatasetError("manifest contains no parquet URLs")
+    PARQUET_DIR.mkdir(parents=True, exist_ok=True)
+    downloaded: list[dict[str, Any]] = []
+    skipped: list[dict[str, Any]] = []
+    for idx, url in enumerate(urls):
+        target = PARQUET_DIR / f"{idx}.parquet"
+        if target.exists() and target.stat().st_size > 0 and not force:
+            skipped.append({"shard": idx, "path": str(target), "bytes": target.stat().st_size})
+            continue
+        tmp = target.with_suffix(".parquet.tmp")
+        request = urllib.request.Request(url, headers={"User-Agent": "social-sim-ui/0.1"})
+        with urllib.request.urlopen(request, timeout=120) as response, tmp.open("wb") as handle:
+            while True:
+                chunk = response.read(1024 * 1024)
+                if not chunk:
+                    break
+                handle.write(chunk)
+        tmp.replace(target)
+        downloaded.append({"shard": idx, "path": str(target), "bytes": target.stat().st_size})
+    return {
+        "dataset_id": DATASET_ID,
+        "data_dir": str(DATA_DIR),
+        "manifest": str(MANIFEST_PATH),
+        "downloaded": downloaded,
+        "skipped": skipped,
+        "status": dataset_status(),
+    }
+
+
+def dataset_status() -> dict[str, Any]:
+    files = sorted(PARQUET_DIR.glob("*.parquet")) if PARQUET_DIR.exists() else []
+    total_bytes = sum(path.stat().st_size for path in files if path.exists())
+    duckdb_available = True
+    duckdb_error = ""
+    try:
+        _duckdb_module()
+    except PersonaDatasetError as exc:
+        duckdb_available = False
+        duckdb_error = str(exc)
+    manifest = _read_manifest()
+    expected_shards = len(manifest.get("parquet_urls", [])) if manifest else None
+    return {
+        "dataset_id": DATASET_ID,
+        "config": DATASET_CONFIG,
+        "split": DATASET_SPLIT,
+        "license": "cc-by-4.0",
+        "data_dir": str(DATA_DIR),
+        "manifest_exists": MANIFEST_PATH.exists(),
+        "parquet_dir": str(PARQUET_DIR),
+        "parquet_shards": len(files),
+        "expected_shards": expected_shards,
+        "download_complete": bool(files) and expected_shards is not None and len(files) >= expected_shards,
+        "downloaded_bytes": total_bytes,
+        "duckdb_available": duckdb_available,
+        "duckdb_error": duckdb_error,
+        "duckdb_path": str(DUCKDB_PATH),
+        "columns": DATASET_COLUMNS,
+        "default_selected_fields": DEFAULT_SELECTED_FIELDS,
+    }
+
+
+def _connect_duckdb() -> Any:
+    duckdb = _duckdb_module()
+    if not PARQUET_DIR.exists() or not list(PARQUET_DIR.glob("*.parquet")):
+        raise PersonaDatasetError(
+            f"No local parquet shards found in {PARQUET_DIR}. Run scripts/download_nemotron_personas_korea.py first."
+        )
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    conn = duckdb.connect(str(DUCKDB_PATH))
+    conn.execute(
+        f"CREATE OR REPLACE VIEW personas AS SELECT * FROM read_parquet({_safe_sql_literal(_parquet_glob())})"
+    )
+    return conn
+
+
+def dataset_metadata() -> dict[str, Any]:
+    status = dataset_status()
+    if not status["parquet_shards"]:
+        return {**status, "available": False, "error": "dataset parquet files are not downloaded"}
+    conn = _connect_duckdb()
+    try:
+        row_count = int(conn.execute("SELECT count(*) FROM personas").fetchone()[0])
+        sex_counts = _top_counts(conn, "sex", 20)
+        province_counts = _top_counts(conn, "province", 40)
+        district_counts_by_province = _district_counts_by_province(conn)
+        education_counts = _top_counts(conn, "education_level", 30)
+        occupation_counts = _top_counts(conn, "occupation", 40)
+        age_buckets = conn.execute(
+            """
+            SELECT
+              CASE
+                WHEN TRY_CAST(age AS INTEGER) IS NULL THEN 'unknown'
+                WHEN TRY_CAST(age AS INTEGER) < 20 THEN 'under_20'
+                WHEN TRY_CAST(age AS INTEGER) < 30 THEN '20s'
+                WHEN TRY_CAST(age AS INTEGER) < 40 THEN '30s'
+                WHEN TRY_CAST(age AS INTEGER) < 50 THEN '40s'
+                WHEN TRY_CAST(age AS INTEGER) < 60 THEN '50s'
+                ELSE '60_plus'
+              END AS bucket,
+              count(*) AS count
+            FROM personas
+            GROUP BY bucket
+            ORDER BY count DESC
+            """
+        ).fetchall()
+    finally:
+        conn.close()
+    return {
+        **status,
+        "available": True,
+        "row_count": row_count,
+        "sex_counts": sex_counts,
+        "province_counts": province_counts,
+        "district_counts_by_province": district_counts_by_province,
+        "education_counts": education_counts,
+        "occupation_counts": occupation_counts,
+        "age_buckets": [{"value": value, "count": int(count)} for value, count in age_buckets],
+    }
+
+
+def _top_counts(conn: Any, field: str, limit: int) -> list[dict[str, Any]]:
+    if field not in CATEGORICAL_FIELDS:
+        return []
+    rows = conn.execute(
+        f"""
+        SELECT {field} AS value, count(*) AS count
+        FROM personas
+        WHERE {field} IS NOT NULL AND CAST({field} AS VARCHAR) != ''
+        GROUP BY {field}
+        ORDER BY count DESC, value
+        LIMIT ?
+        """,
+        [int(limit)],
+    ).fetchall()
+    return [{"value": str(value), "count": int(count)} for value, count in rows]
+
+
+def _district_counts_by_province(conn: Any) -> dict[str, list[dict[str, Any]]]:
+    rows = conn.execute(
+        """
+        SELECT province, district, count(*) AS count
+        FROM personas
+        WHERE province IS NOT NULL
+          AND district IS NOT NULL
+          AND CAST(province AS VARCHAR) != ''
+          AND CAST(district AS VARCHAR) != ''
+        GROUP BY province, district
+        ORDER BY province, count DESC, district
+        """
+    ).fetchall()
+    grouped: dict[str, list[dict[str, Any]]] = {}
+    for province, district, count in rows:
+        province_text = str(province)
+        grouped.setdefault(province_text, []).append({"value": str(district), "count": int(count)})
+    return grouped
+
+
+def build_index() -> dict[str, Any]:
+    """Create a small DuckDB database with a persistent parquet-backed view."""
+
+    conn = _connect_duckdb()
+    try:
+        row_count = int(conn.execute("SELECT count(*) FROM personas").fetchone()[0])
+        conn.execute("CREATE TABLE IF NOT EXISTS dataset_cache_metadata(key VARCHAR PRIMARY KEY, value VARCHAR)")
+        conn.execute(
+            "INSERT OR REPLACE INTO dataset_cache_metadata VALUES (?, ?)",
+            ["row_count", str(row_count)],
+        )
+        conn.execute(
+            "INSERT OR REPLACE INTO dataset_cache_metadata VALUES (?, ?)",
+            ["built_at", time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())],
+        )
+    finally:
+        conn.close()
+    return {"duckdb_path": str(DUCKDB_PATH), "row_count": row_count, "status": dataset_status()}
+
+
+def sample_personas(spec: dict[str, Any] | None = None) -> dict[str, Any]:
+    spec = spec or {}
+    total = _bounded_int(spec.get("total_agents"), 10, minimum=1, maximum=_max_dataset_agents(spec))
+    seed = str(spec.get("seed", 7))
+    selected_fields = _selected_fields(spec.get("selected_fields"))
+    base_filters = _normalize_filters(spec.get("filters") if isinstance(spec.get("filters"), dict) else {})
+    groups = _normalize_sampling_groups(spec.get("groups") if isinstance(spec.get("groups"), list) else [])
+    conn = _connect_duckdb()
+    try:
+        rows: list[dict[str, Any]] = []
+        seen: set[str] = set()
+        allocations = _allocate_group_counts(total, groups)
+        if allocations:
+            for idx, group in enumerate(allocations):
+                merged_filters = {**base_filters, **group["filters"]}
+                sampled = _query_sample(
+                    conn,
+                    count=group["count"],
+                    seed=f"{seed}:group:{idx}:{group['label']}",
+                    filters=merged_filters,
+                    selected_fields=selected_fields,
+                    exclude_uuids=seen,
+                )
+                for row in sampled:
+                    row["_sampling_group"] = group["label"]
+                    seen.add(str(row.get("uuid", "")))
+                rows.extend(sampled)
+        if len(rows) < total:
+            top_up = _query_sample(
+                conn,
+                count=total - len(rows),
+                seed=f"{seed}:topup",
+                filters=base_filters,
+                selected_fields=selected_fields,
+                exclude_uuids=seen,
+            )
+            rows.extend(top_up)
+    finally:
+        conn.close()
+    agents = project_rows_to_agents(
+        rows[:total],
+        scenario_text=str(spec.get("scenario_text") or ""),
+        policy_text=str(spec.get("policy_text") or ""),
+        decision_task=spec.get("decision_task") if isinstance(spec.get("decision_task"), dict) else None,
+        selected_fields=selected_fields,
+    )
+    return {
+        "dataset_id": DATASET_ID,
+        "requested_agents": total,
+        "sampled_rows": len(rows[:total]),
+        "selected_fields": selected_fields,
+        "filters": base_filters,
+        "groups": groups,
+        "agents": agents,
+        "population": {
+            "total_agents": len(agents),
+            "groups": _groups_from_agents(agents),
+            "persona_source": {
+                "type": "nemotron_korea",
+                "dataset_id": DATASET_ID,
+                "selected_fields": selected_fields,
+                "filters": base_filters,
+                "groups": groups,
+            },
+        },
+    }
+
+
+def _max_dataset_agents(spec: dict[str, Any]) -> int:
+    try:
+        value = int(spec.get("max_agents", os.getenv("SOCIAL_SIM_DATASET_AGENT_LIMIT", "5000")))
+    except (TypeError, ValueError):
+        value = 5000
+    return max(1, min(100000, value))
+
+
+def _selected_fields(raw: Any) -> list[str]:
+    if not isinstance(raw, list):
+        return list(DEFAULT_SELECTED_FIELDS)
+    fields = [str(field) for field in raw if str(field) in TEXT_FIELDS]
+    return fields or list(DEFAULT_SELECTED_FIELDS)
+
+
+def _normalize_filters(filters: dict[str, Any]) -> dict[str, Any]:
+    normalized: dict[str, Any] = {}
+    for key, value in filters.items():
+        normalized[str(key)] = _normalize_filter_value(str(key), value)
+    return normalized
+
+
+def _normalize_sampling_groups(groups: list[Any]) -> list[Any]:
+    normalized: list[Any] = []
+    for item in groups:
+        if not isinstance(item, dict):
+            continue
+        group = dict(item)
+        if isinstance(group.get("filters"), dict):
+            group["filters"] = _normalize_filters(group["filters"])
+        normalized.append(group)
+    return normalized
+
+
+def _normalize_filter_value(field: str, value: Any) -> Any:
+    if isinstance(value, list):
+        return [_normalize_filter_value(field, item) for item in value]
+    text = str(value).strip() if value is not None else ""
+    if not text:
+        return value
+    lowered = text.lower()
+    if field == "sex":
+        return SEX_ALIASES.get(lowered, SEX_ALIASES.get(text, text))
+    if field == "province":
+        return PROVINCE_ALIASES.get(lowered, PROVINCE_ALIASES.get(text, text))
+    return value
+
+
+def _allocate_group_counts(total: int, groups: list[Any]) -> list[dict[str, Any]]:
+    valid: list[dict[str, Any]] = []
+    for idx, item in enumerate(groups):
+        if not isinstance(item, dict):
+            continue
+        filters = _normalize_filters(item.get("filters") if isinstance(item.get("filters"), dict) else {})
+        label = str(item.get("label") or f"group_{idx + 1}")
+        count = _int_or_none(item.get("count"))
+        ratio = _float_or_none(item.get("ratio"))
+        valid.append({"label": label, "filters": filters, "count": count, "ratio": ratio})
+    if not valid:
+        return []
+    fixed_total = sum(item["count"] for item in valid if isinstance(item.get("count"), int) and item["count"] > 0)
+    ratio_items = [item for item in valid if not isinstance(item.get("count"), int) or item["count"] <= 0]
+    remaining = max(0, total - fixed_total)
+    ratio_sum = sum(max(0.0, float(item.get("ratio") or 0.0)) for item in ratio_items)
+    allocated: list[dict[str, Any]] = []
+    for item in valid:
+        if isinstance(item.get("count"), int) and item["count"] > 0:
+            count = min(item["count"], total)
+            fraction = 0.0
+        elif ratio_sum > 0:
+            raw = remaining * max(0.0, float(item.get("ratio") or 0.0)) / ratio_sum
+            count = int(math.floor(raw))
+            fraction = raw - count
+        else:
+            raw = remaining / max(1, len(ratio_items))
+            count = int(math.floor(raw))
+            fraction = raw - count
+        allocated.append({"label": item["label"], "filters": item["filters"], "count": count, "_fraction": fraction})
+    while sum(item["count"] for item in allocated) < total:
+        target = max(allocated, key=lambda item: item.get("_fraction", 0.0))
+        target["count"] += 1
+        target["_fraction"] = 0.0
+    while sum(item["count"] for item in allocated) > total:
+        target = max(allocated, key=lambda item: item["count"])
+        target["count"] -= 1
+    return [{key: value for key, value in item.items() if key != "_fraction" and item["count"] > 0} for item in allocated]
+
+
+def _query_sample(
+    conn: Any,
+    *,
+    count: int,
+    seed: str,
+    filters: dict[str, Any],
+    selected_fields: list[str],
+    exclude_uuids: set[str],
+) -> list[dict[str, Any]]:
+    if count <= 0:
+        return []
+    columns = _query_columns(selected_fields)
+    where_sql, params = _where_clause(filters, exclude_uuids)
+    params.extend([str(seed), int(count)])
+    rows = conn.execute(
+        f"""
+        SELECT {", ".join(columns)}
+        FROM personas
+        {where_sql}
+        ORDER BY hash(CAST(uuid AS VARCHAR) || CAST(? AS VARCHAR))
+        LIMIT ?
+        """,
+        params,
+    ).fetchall()
+    names = [column.split(" AS ")[-1] if " AS " in column else column for column in columns]
+    return [dict(zip(names, row)) for row in rows]
+
+
+def _query_columns(selected_fields: list[str]) -> list[str]:
+    base = [
+        "uuid",
+        "sex",
+        "age",
+        "marital_status",
+        "military_status",
+        "family_type",
+        "housing_type",
+        "education_level",
+        "bachelors_field",
+        "occupation",
+        "district",
+        "province",
+        "country",
+    ]
+    for field in selected_fields:
+        if field not in base:
+            base.append(field)
+    return base
+
+
+def _where_clause(filters: dict[str, Any], exclude_uuids: set[str]) -> tuple[str, list[Any]]:
+    clauses: list[str] = []
+    params: list[Any] = []
+    for field in CATEGORICAL_FIELDS:
+        if field not in filters:
+            continue
+        value = filters.get(field)
+        if isinstance(value, list):
+            clean_values = [str(item) for item in value if str(item).strip()]
+            if clean_values:
+                placeholders = ", ".join("?" for _ in clean_values)
+                clauses.append(f"CAST({field} AS VARCHAR) IN ({placeholders})")
+                params.extend(clean_values)
+        elif value not in {None, ""}:
+            clauses.append(f"CAST({field} AS VARCHAR) = ?")
+            params.append(str(value))
+    age_min = _int_or_none(filters.get("age_min"))
+    age_max = _int_or_none(filters.get("age_max"))
+    if age_min is not None:
+        clauses.append("TRY_CAST(age AS INTEGER) >= ?")
+        params.append(age_min)
+    if age_max is not None:
+        clauses.append("TRY_CAST(age AS INTEGER) <= ?")
+        params.append(age_max)
+    occupation_query = str(filters.get("occupation_query") or "").strip().lower()
+    if occupation_query:
+        clauses.append("(lower(CAST(occupation AS VARCHAR)) LIKE ? OR lower(CAST(professional_persona AS VARCHAR)) LIKE ?)")
+        pattern = f"%{occupation_query}%"
+        params.extend([pattern, pattern])
+    keyword_query = str(filters.get("keyword_query") or "").strip().lower()
+    if keyword_query:
+        text_expr = " || ' ' || ".join(f"coalesce(CAST({field} AS VARCHAR), '')" for field in TEXT_FIELDS[:7])
+        clauses.append(f"lower({text_expr}) LIKE ?")
+        params.append(f"%{keyword_query}%")
+    if exclude_uuids:
+        placeholders = ", ".join("?" for _ in exclude_uuids)
+        clauses.append(f"CAST(uuid AS VARCHAR) NOT IN ({placeholders})")
+        params.extend(sorted(exclude_uuids))
+    if not clauses:
+        return "", params
+    return "WHERE " + " AND ".join(clauses), params
+
+
+def project_rows_to_agents(
+    rows: list[dict[str, Any]],
+    *,
+    scenario_text: str = "",
+    policy_text: str = "",
+    decision_task: dict[str, Any] | None = None,
+    selected_fields: list[str] | None = None,
+) -> list[dict[str, Any]]:
+    selected_fields = selected_fields or DEFAULT_SELECTED_FIELDS
+    agents: list[dict[str, Any]] = []
+    for idx, row in enumerate(rows, start=1):
+        text = " ".join(str(row.get(field) or "") for field in TEXT_FIELDS)
+        dimensions = _infer_behavior_dimensions(row, text)
+        baseline = _baseline_from_dimensions(dimensions)
+        location = " ".join(str(row.get(key) or "").strip() for key in ["province", "district"] if row.get(key)).strip()
+        occupation = str(row.get("occupation") or "").strip()
+        age = str(row.get("age") or "").strip()
+        sex = str(row.get("sex") or "").strip()
+        role_parts = [part for part in [location, f"{age}세" if age else "", sex, occupation] if part]
+        role = " ".join(role_parts) or "Nemotron persona participant"
+        persona_type = _slugify(
+            "_".join(str(part) for part in [row.get("province"), row.get("occupation"), row.get("age")] if part),
+            f"nemotron_persona_{idx}",
+        )
+        prompt_card = build_prompt_card(row, selected_fields=selected_fields)
+        agents.append(
+            {
+                "agent_id": f"agent_{idx:04d}",
+                "name": f"Persona {idx:04d}",
+                "persona_type": persona_type,
+                "role": role,
+                "goal": _goal_from_context(row, scenario_text, policy_text, decision_task),
+                "persona_description": prompt_card,
+                "baseline_usage": baseline,
+                "behavior_dimensions": dimensions,
+                "traits": _traits_from_row(row, dimensions),
+                "state": {
+                    "activation": "eligible",
+                    "last_numeric_decision": None,
+                    "memory_summary": "",
+                },
+                "persona_source": {
+                    "type": "nemotron_korea",
+                    "dataset_id": DATASET_ID,
+                    "uuid": str(row.get("uuid") or ""),
+                    "sampling_group": str(row.get("_sampling_group") or ""),
+                    "selected_fields": selected_fields,
+                },
+            }
+        )
+    return agents
+
+
+def build_prompt_card(row: dict[str, Any], *, selected_fields: list[str] | None = None, field_limit: int = 360) -> str:
+    selected_fields = selected_fields or DEFAULT_SELECTED_FIELDS
+    lines = [
+        f"성별: {_clip(row.get('sex'), 80)}",
+        f"연령: {_clip(row.get('age'), 80)}",
+        f"지역: {_clip(' '.join(str(row.get(key) or '') for key in ['country', 'province', 'district']).strip(), 140)}",
+        f"학력/전공: {_clip(' / '.join(str(row.get(key) or '') for key in ['education_level', 'bachelors_field']).strip(' /'), 180)}",
+        f"직업: {_clip(row.get('occupation'), 180)}",
+        f"가족/주거: {_clip(' / '.join(str(row.get(key) or '') for key in ['marital_status', 'family_type', 'housing_type']).strip(' /'), 180)}",
+    ]
+    for field in selected_fields:
+        value = _clip(row.get(field), field_limit)
+        if value:
+            lines.append(f"{field}: {value}")
+    return "\n".join(line for line in lines if not line.endswith(": "))
+
+
+def _infer_behavior_dimensions(row: dict[str, Any], text: str) -> dict[str, float]:
+    lowered = text.lower()
+    age = _int_or_none(row.get("age")) or 40
+    occupation = str(row.get("occupation") or "").lower()
+    education = str(row.get("education_level") or "").lower()
+    family = str(row.get("family_type") or "").lower()
+    cooperation_terms = ["봉사", "지역", "가족", "교육", "상담", "간호", "의료", "협력", "community", "team", "mentor"]
+    self_terms = ["창업", "투자", "영업", "관리자", "경영", "ambition", "entrepreneur", "business", "sales", "finance"]
+    risk_terms = ["안전", "의료", "법", "회계", "보험", "품질", "security", "compliance", "risk"]
+    authority_terms = ["군", "공무", "교사", "관리", "법", "행정", "manager", "government", "military", "teacher"]
+    social_terms = ["예술", "스포츠", "여행", "요리", "가족", "커뮤니티", "media", "arts", "sports", "travel"]
+    cooperation = 0.45 + 0.08 * _contains_any(lowered, cooperation_terms) + 0.06 * bool(family)
+    self_interest = 0.45 + 0.1 * _contains_any(lowered + " " + occupation, self_terms)
+    risk_aversion = 0.42 + 0.12 * _contains_any(lowered + " " + occupation, risk_terms) + min(0.16, max(0, age - 35) / 200)
+    authority = 0.42 + 0.12 * _contains_any(lowered + " " + occupation + " " + education, authority_terms) + min(0.12, max(0, age - 30) / 250)
+    social = 0.42 + 0.12 * _contains_any(lowered, social_terms)
+    if age < 30:
+        social += 0.05
+        risk_aversion -= 0.03
+    if "single" in family or "미혼" in family:
+        self_interest += 0.04
+    return {
+        "cooperation": _clamp01(cooperation),
+        "self_interest": _clamp01(self_interest),
+        "risk_aversion": _clamp01(risk_aversion),
+        "authority_respect": _clamp01(authority),
+        "social_influence": _clamp01(social),
+    }
+
+
+def _traits_from_row(row: dict[str, Any], dimensions: dict[str, float]) -> dict[str, Any]:
+    return {
+        "demographic": {
+            "sex": row.get("sex"),
+            "age": row.get("age"),
+            "province": row.get("province"),
+            "district": row.get("district"),
+            "occupation": row.get("occupation"),
+            "education_level": row.get("education_level"),
+        },
+        "behavior_projection": dimensions,
+    }
+
+
+def _goal_from_context(
+    row: dict[str, Any],
+    scenario_text: str,
+    policy_text: str,
+    decision_task: dict[str, Any] | None,
+) -> str:
+    task_text = ""
+    if decision_task:
+        task_text = str(decision_task.get("action_prompt") or decision_task.get("metric_name") or "")
+    occupation = str(row.get("occupation") or "participant").strip()
+    context = _clip(task_text or scenario_text or policy_text, 220)
+    if context:
+        return f"{occupation} 관점에서 {context}에 대해 개인 상황과 사회적 결과를 함께 고려한다."
+    return f"{occupation} 관점에서 개인 상황과 사회적 결과를 함께 고려한다."
+
+
+def _baseline_from_dimensions(dimensions: dict[str, float]) -> int:
+    raw = 6.0 + 3.2 * dimensions["self_interest"] - 2.0 * dimensions["cooperation"] - 1.4 * dimensions["risk_aversion"]
+    return max(0, min(12, int(round(raw))))
+
+
+def _groups_from_agents(agents: list[dict[str, Any]]) -> dict[str, int]:
+    groups: dict[str, int] = {}
+    for agent in agents:
+        key = str(agent.get("persona_type") or "nemotron_persona")
+        groups[key] = groups.get(key, 0) + 1
+    return groups
+
+
+def _contains_any(text: str, terms: list[str]) -> int:
+    return 1 if any(term.lower() in text for term in terms) else 0
+
+
+def _clip(value: Any, limit: int) -> str:
+    text = str(value or "").strip()
+    if len(text) <= limit:
+        return text
+    return text[: limit - 3].rstrip() + "..."
+
+
+def _slugify(value: Any, fallback: str) -> str:
+    text = str(value or "").strip().lower()
+    text = re.sub(r"[^0-9a-zA-Z가-힣]+", "_", text).strip("_")
+    if not text:
+        return fallback
+    return text[:80]
+
+
+def _bounded_int(value: Any, default: int, *, minimum: int, maximum: int) -> int:
+    parsed = _int_or_none(value)
+    if parsed is None:
+        parsed = default
+    return max(minimum, min(maximum, parsed))
+
+
+def _int_or_none(value: Any) -> int | None:
+    try:
+        return int(float(value))
+    except (TypeError, ValueError):
+        return None
+
+
+def _float_or_none(value: Any) -> float | None:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _clamp01(value: float) -> float:
+    return round(max(0.0, min(1.0, float(value))), 3)

requirements.txt

@@ -0,0 +1,2 @@
+openai>=1.0.0
+duckdb>=1.0.0

scripts/build_nemotron_persona_index.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""Build/check the local DuckDB view for Nemotron-Personas-Korea."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+
+APP_DIR = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(APP_DIR))
+
+from persona_dataset import build_index, dataset_metadata  # noqa: E402
+
+
+def main() -> int:
+    index_payload = build_index()
+    metadata = dataset_metadata()
+    print(json.dumps({"index": index_payload, "metadata": metadata}, indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/download_nemotron_personas_korea.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Download nvidia/Nemotron-Personas-Korea parquet shards for local use."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+APP_DIR = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(APP_DIR))
+
+from persona_dataset import download_dataset, fetch_manifest  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--force", action="store_true", help="Redownload shards that already exist.")
+    parser.add_argument(
+        "--limit-shards",
+        type=int,
+        default=None,
+        help="Download only the first N shards for smoke tests. Omit for the full dataset.",
+    )
+    parser.add_argument("--manifest-only", action="store_true", help="Fetch manifest without downloading parquet.")
+    args = parser.parse_args()
+    if args.manifest_only:
+        payload = fetch_manifest()
+    else:
+        payload = download_dataset(force=args.force, limit_shards=args.limit_shards)
+    print(json.dumps(payload, indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/test_silicon_llm_runtime.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Unit tests for dynamic LLM-backed silicon sampling runtime."""
+
+from __future__ import annotations
+
+import json
+import sys
+import unittest
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from silicon_llm import (  # noqa: E402
+    build_silicon_llm_response_contract,
+    parse_silicon_agent_response,
+    run_silicon_llm_sampling,
+)
+
+
+QUESTIONS = [
+    {
+        "id": "q_likert_5",
+        "title": "현 정부 국정 운영을 어떻게 평가하십니까?",
+        "kind": "likert",
+        "scale": 5,
+        "lowLabel": "매우 부정",
+        "highLabel": "매우 긍정",
+    },
+    {
+        "id": "q_likert_4",
+        "title": "지역 의료 접근성에 만족하십니까?",
+        "kind": "likert",
+        "scale": 4,
+    },
+    {
+        "id": "q_open",
+        "title": "가장 먼저 해결해야 할 문제는 무엇입니까?",
+        "kind": "open",
+    },
+]
+
+
+class FakeLLM:
+    def __init__(self) -> None:
+        self.calls: list[dict[str, Any]] = []
+
+    def complete_agent(self, *, agent: dict[str, Any], questions: list[dict[str, Any]], response_contract: dict[str, Any]) -> str:
+        self.calls.append({"agent": agent, "questions": questions, "response_contract": response_contract})
+        return json.dumps(
+            {
+                "answers": {
+                    "q_likert_5": {"value": 4, "reason": "정책 평가는 대체로 긍정적입니다."},
+                    "q_likert_4": {"value": 2, "reason": "의료 접근성은 지역에 따라 부족합니다."},
+                    "q_open": {"text": "물가와 의료 접근성 개선이 가장 시급합니다.", "theme": "의료"},
+                }
+            },
+            ensure_ascii=False,
+        )
+
+
+class SiliconLLMRuntimeTests(unittest.TestCase):
+    def test_contract_is_dynamic_for_question_mix(self) -> None:
+        contract = build_silicon_llm_response_contract(QUESTIONS)
+
+        answer_properties = contract["schema"]["properties"]["answers"]["properties"]
+        self.assertEqual(set(answer_properties), {"q_likert_5", "q_likert_4", "q_open"})
+        self.assertEqual(answer_properties["q_likert_5"]["properties"]["value"]["minimum"], 1)
+        self.assertEqual(answer_properties["q_likert_5"]["properties"]["value"]["maximum"], 5)
+        self.assertEqual(answer_properties["q_likert_4"]["properties"]["value"]["maximum"], 4)
+        self.assertIn("text", answer_properties["q_open"]["required"])
+
+    def test_parser_extracts_all_dynamic_answers_from_fenced_json(self) -> None:
+        raw = """
+        생각 과정은 생략합니다.
+        ```json
+        {
+          "answers": {
+            "q_likert_5": {"value": "5", "reason": "강한 긍정"},
+            "q_likert_4": {"score": 3, "reason": "보통 이상"},
+            "q_open": {"answer": "교통과 돌봄이 필요합니다", "topic": "교통"}
+          }
+        }
+        ```
+        """
+        parsed = parse_silicon_agent_response(raw, QUESTIONS, respondent_id="R0001")
+
+        self.assertEqual(len(parsed["likertAnswers"]), 2)
+        self.assertEqual(len(parsed["openAnswers"]), 1)
+        self.assertEqual(parsed["likertAnswers"][0]["value"], 5)
+        self.assertEqual(parsed["likertAnswers"][1]["value"], 3)
+        self.assertEqual(parsed["openAnswers"][0]["theme"], "교통")
+
+    def test_runtime_calls_one_llm_agent_for_all_questions_and_builds_stats(self) -> None:
+        fake = FakeLLM()
+        payload = {
+            "config": {
+                "sampleSize": 2,
+                "genders": [{"id": "male", "enabled": True, "weight": 1}, {"id": "female", "enabled": True, "weight": 1}],
+                "ages": [{"id": "30s", "enabled": True, "weight": 2}],
+                "locations": [{"id": "seoul", "enabled": True, "weight": 2}],
+                "locationOptions": [{"id": "seoul", "label": "서울", "parentRegion": "seoul", "level": "sido", "defaultWeight": 100, "short": "서울", "group": "시도"}],
+                "personaAttributes": [{"id": "occ_office", "enabled": True, "weight": 2}],
+                "nemotronFields": ["persona", "sex", "age"],
+                "questions": QUESTIONS,
+                "seed": 42,
+            },
+            "execution": {"max_agents": 2},
+        }
+
+        result = run_silicon_llm_sampling(payload, llm=fake)
+
+        self.assertEqual(len(fake.calls), 2)
+        self.assertTrue(all(len(call["questions"]) == 3 for call in fake.calls))
+        self.assertEqual(len(result["respondents"]), 2)
+        self.assertEqual(len(result["likertAnswers"]), 4)
+        self.assertEqual(len(result["openAnswers"]), 2)
+        self.assertEqual([stat["questionId"] for stat in result["questionStats"]], ["q_likert_5", "q_likert_4", "q_open"])
+        self.assertEqual(result["questionStats"][0]["distribution"][3]["count"], 2)
+        self.assertEqual(result["regionStats"][0]["respondents"], 2)
+        self.assertEqual(result["llmTrace"]["calls"], 2)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

scripts/validate_silicon_llm_api.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Run small real-API validation for dynamic silicon sampling."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from silicon_llm import resolve_openai_api_key, run_silicon_llm_sampling  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--agents", type=int, default=5)
+    parser.add_argument("--model", default="gpt-4o-mini")
+    parser.add_argument("--out", default="")
+    args = parser.parse_args()
+    if not resolve_openai_api_key():
+        print(json.dumps({"ok": False, "error": "OPENAI_API_KEY or .env OPENAI_API_KEY is required"}, ensure_ascii=False, indent=2))
+        return 1
+    out_dir = Path(args.out) if args.out else ROOT / "runs" / f"silicon_llm_api_validation_{timestamp()}"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    report: dict[str, Any] = {"ok": False, "model": args.model, "agents": args.agents, "cases": []}
+    for case in validation_cases():
+        payload = base_payload(args.agents, case["questions"], model=args.model)
+        started = time.time()
+        try:
+            result = run_silicon_llm_sampling(payload)
+            checks = validate_result(case["case_id"], result, case["questions"], args.agents)
+            report["cases"].append(
+                {
+                    "case_id": case["case_id"],
+                    "ok": all(check["ok"] for check in checks),
+                    "elapsed_seconds": round(time.time() - started, 2),
+                    "questions": [{"id": item["id"], "kind": item["kind"], "scale": item.get("scale")} for item in case["questions"]],
+                    "checks": checks,
+                    "llmTrace": {
+                        key: value
+                        for key, value in result.get("llmTrace", {}).items()
+                        if key != "rawResponses"
+                    },
+                    "sample_open_answers": result.get("openAnswers", [])[:3],
+                    "questionStats": result.get("questionStats", []),
+                }
+            )
+        except Exception as exc:  # noqa: BLE001
+            report["cases"].append({"case_id": case["case_id"], "ok": False, "error": f"{type(exc).__name__}: {exc}"})
+    report["ok"] = bool(report["cases"]) and all(case.get("ok") for case in report["cases"])
+    (out_dir / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps({"ok": report["ok"], "out": str(out_dir / "report.json"), "cases": report["cases"]}, ensure_ascii=False, indent=2))
+    return 0 if report["ok"] else 1
+
+
+def validation_cases() -> list[dict[str, Any]]:
+    return [
+        {
+            "case_id": "mixed_policy_trust",
+            "questions": [
+                likert("approval_5", "현 정부 국정 운영을 어떻게 평가하십니까?", 5),
+                likert("medical_access_4", "거주 지역 의료 접근성에 만족하십니까?", 4),
+                open_q("local_problem", "거주 지역에서 가장 먼저 해결해야 할 문제는 무엇입니까?"),
+            ],
+        },
+        {
+            "case_id": "open_only_priorities",
+            "questions": [
+                open_q("top_issue", "한국 사회가 가장 먼저 해결해야 할 문제는 무엇이라고 보십니까?"),
+                open_q("policy_request", "새 정부나 지방자치단체에 가장 바라는 정책을 적어주십시오."),
+            ],
+        },
+        {
+            "case_id": "multi_scale_likert",
+            "questions": [
+                likert("vote_turnout_4", "다음 지방선거에 투표할 가능성이 얼마나 높습니까?", 4),
+                likert("party_reflects_5", "주요 정당이 국민 의견을 잘 반영한다고 보십니까?", 5),
+                likert("climate_cost_7", "탄소 감축 비용 부담 정책에 어느 정도 동의하십니까?", 7),
+            ],
+        },
+        {
+            "case_id": "custom_korean_mix",
+            "questions": [
+                likert("custom_transport_safety", "출퇴근길 대중교통 안전에 만족하십니까?", 5),
+                open_q("custom_one_sentence", "본인의 생활에서 가장 크게 체감되는 정책 문제를 한 문장으로 적어주십시오."),
+                likert("custom_media_trust", "온라인 뉴스와 유튜브 정치 정보를 신뢰하십니까?", 5),
+            ],
+        },
+        {
+            "case_id": "many_questions_mix",
+            "questions": [
+                likert("economy_next_year", "향후 1년 한국 경제가 좋아질 것이라고 보십니까?", 5),
+                likert("household_life", "현재 가계 생활 형편에 얼마나 만족하십니까?", 5),
+                likert("institution_trust", "국회, 언론, 행정부 등 공공기관을 전반적으로 신뢰하십니까?", 5),
+                open_q("free_reason", "그렇게 응답한 가장 큰 이유를 적어주십시오."),
+            ],
+        },
+    ]
+
+
+def likert(question_id: str, title: str, scale: int) -> dict[str, Any]:
+    return {"id": question_id, "title": title, "source": "API validation", "category": "검증", "kind": "likert", "scale": scale}
+
+
+def open_q(question_id: str, title: str) -> dict[str, Any]:
+    return {"id": question_id, "title": title, "source": "API validation", "category": "검증", "kind": "open"}
+
+
+def base_payload(agent_count: int, questions: list[dict[str, Any]], *, model: str) -> dict[str, Any]:
+    return {
+        "config": {
+            "sampleSize": agent_count,
+            "genders": [{"id": "male", "enabled": True, "weight": agent_count // 2}, {"id": "female", "enabled": True, "weight": agent_count - agent_count // 2}],
+            "ages": [{"id": "30s", "enabled": True, "weight": 2}, {"id": "50s", "enabled": True, "weight": agent_count - 2}],
+            "locations": [{"id": "seoul", "enabled": True, "weight": 3}, {"id": "busan", "enabled": True, "weight": agent_count - 3}],
+            "locationOptions": [
+                {"id": "seoul", "label": "서울", "parentRegion": "seoul", "level": "sido", "defaultWeight": 60, "short": "서울", "group": "시도"},
+                {"id": "busan", "label": "부산", "parentRegion": "busan", "level": "sido", "defaultWeight": 40, "short": "부산", "group": "시도"},
+            ],
+            "personaAttributes": [
+                {"id": "occ_office", "enabled": True, "weight": 2},
+                {"id": "occ_student", "enabled": True, "weight": agent_count - 2},
+                {"id": "edu_bachelor", "enabled": True, "weight": agent_count},
+            ],
+            "nemotronFields": ["persona", "sex", "age", "province", "occupation", "education_level"],
+            "questions": questions,
+            "seed": 20260630,
+        },
+        "execution": {"max_agents": agent_count, "model": model, "timeout_seconds": 90},
+    }
+
+
+def validate_result(case_id: str, result: dict[str, Any], questions: list[dict[str, Any]], agent_count: int) -> list[dict[str, Any]]:
+    checks: list[dict[str, Any]] = []
+    likert_questions = [item for item in questions if item["kind"] == "likert"]
+    open_questions = [item for item in questions if item["kind"] == "open"]
+    checks.append(check("respondent_count", len(result.get("respondents", [])) == agent_count, {"count": len(result.get("respondents", [])), "expected": agent_count}))
+    checks.append(check("one_llm_call_per_agent", result.get("llmTrace", {}).get("calls") == agent_count, result.get("llmTrace", {})))
+    checks.append(check("all_questions_in_config", [item["id"] for item in result.get("config", {}).get("questions", [])] == [item["id"] for item in questions], None))
+    checks.append(check("likert_answer_count", len(result.get("likertAnswers", [])) == agent_count * len(likert_questions), {"count": len(result.get("likertAnswers", [])), "expected": agent_count * len(likert_questions)}))
+    checks.append(check("open_answer_count", len(result.get("openAnswers", [])) == agent_count * len(open_questions), {"count": len(result.get("openAnswers", [])), "expected": agent_count * len(open_questions)}))
+    checks.append(check("question_stats_count", len(result.get("questionStats", [])) == len(questions), {"count": len(result.get("questionStats", [])), "expected": len(questions)}))
+    checks.append(check("parse_issues_empty", not result.get("llmTrace", {}).get("parseIssues"), result.get("llmTrace", {}).get("parseIssues")))
+    for question in likert_questions:
+        question_id = question["id"]
+        scale = int(question.get("scale") or 5)
+        values = [int(answer["value"]) for answer in result.get("likertAnswers", []) if answer.get("questionId") == question_id]
+        stat = next((item for item in result.get("questionStats", []) if item.get("questionId") == question_id), {})
+        checks.append(check(f"{case_id}:{question_id}:value_range", len(values) == agent_count and all(1 <= value <= scale for value in values), {"values": values, "scale": scale}))
+        checks.append(check(f"{case_id}:{question_id}:distribution_sum", sum(item.get("count", 0) for item in stat.get("distribution", [])) == agent_count, stat.get("distribution")))
+    for question in open_questions:
+        answers = [answer for answer in result.get("openAnswers", []) if answer.get("questionId") == question["id"]]
+        checks.append(check(f"{case_id}:{question['id']}:open_text_theme", len(answers) == agent_count and all(answer.get("text") and answer.get("theme") for answer in answers), answers[:2]))
+    expected_primary = next((item["id"] for item in likert_questions), None)
+    checks.append(check("primary_question_dynamic", result.get("primaryQuestionId") == expected_primary, {"actual": result.get("primaryQuestionId"), "expected": expected_primary}))
+    return checks
+
+
+def check(name: str, ok: bool, detail: Any) -> dict[str, Any]:
+    return {"name": name, "ok": bool(ok), "detail": detail}
+
+
+def timestamp() -> str:
+    return time.strftime("%Y%m%d%H%M%S")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

server.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import json
+import os
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import urlparse
+
+from persona_dataset import PersonaDatasetError, dataset_metadata, dataset_status, sample_personas
+from silicon_llm import resolve_openai_api_key, run_silicon_llm_sampling
+
+
+APP_DIR = Path(__file__).resolve().parent
+STATIC_DIR = APP_DIR / "static" / "immersive"
+
+
+def read_body(handler: BaseHTTPRequestHandler) -> dict:
+    length = int(handler.headers.get("content-length") or 0)
+    if length <= 0:
+        return {}
+    raw = handler.rfile.read(length).decode("utf-8")
+    return json.loads(raw) if raw else {}
+
+
+def write_json(handler: BaseHTTPRequestHandler, payload: dict, status: HTTPStatus = HTTPStatus.OK) -> None:
+    data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    handler.send_response(status)
+    handler.send_header("content-type", "application/json; charset=utf-8")
+    handler.send_header("content-length", str(len(data)))
+    handler.end_headers()
+    handler.wfile.write(data)
+
+
+def content_type(path: Path) -> str:
+    suffix = path.suffix.lower()
+    return {
+        ".html": "text/html; charset=utf-8",
+        ".js": "text/javascript; charset=utf-8",
+        ".css": "text/css; charset=utf-8",
+        ".json": "application/json; charset=utf-8",
+        ".svg": "image/svg+xml",
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".webp": "image/webp",
+    }.get(suffix, "application/octet-stream")
+
+
+def serve_file(handler: BaseHTTPRequestHandler, path: Path) -> None:
+    if not path.exists() or not path.is_file():
+        handler.send_error(HTTPStatus.NOT_FOUND)
+        return
+    data = path.read_bytes()
+    handler.send_response(HTTPStatus.OK)
+    handler.send_header("content-type", content_type(path))
+    handler.send_header("content-length", str(len(data)))
+    handler.end_headers()
+    handler.wfile.write(data)
+
+
+class Handler(BaseHTTPRequestHandler):
+    def log_message(self, fmt: str, *args: object) -> None:
+        print("%s - - %s" % (self.address_string(), fmt % args), flush=True)
+
+    def do_GET(self) -> None:
+        parsed = urlparse(self.path)
+        path = parsed.path
+        if path == "/api/status":
+            return write_json(
+                self,
+                {
+                    "ok": True,
+                    "openai_api_key_set": bool(resolve_openai_api_key()),
+                    "dataset": dataset_status(),
+                },
+            )
+        if path == "/api/persona-dataset/metadata":
+            try:
+                return write_json(self, dataset_metadata())
+            except PersonaDatasetError as exc:
+                return write_json(self, {"available": False, "error": str(exc), "status": dataset_status()})
+        if path in {"/", "/silicon", "/silicon/"}:
+            return serve_file(self, STATIC_DIR / "index.html")
+        target = (STATIC_DIR / path.lstrip("/")).resolve()
+        if STATIC_DIR.resolve() in target.parents or target == STATIC_DIR.resolve():
+            return serve_file(self, target)
+        self.send_error(HTTPStatus.NOT_FOUND)
+
+    def do_POST(self) -> None:
+        parsed = urlparse(self.path)
+        payload = read_body(self)
+        if parsed.path == "/api/persona-dataset/sample":
+            try:
+                return write_json(self, sample_personas(payload))
+            except PersonaDatasetError as exc:
+                return write_json(self, {"error": str(exc), "status": dataset_status()}, HTTPStatus.BAD_REQUEST)
+        if parsed.path == "/api/silicon/llm-run":
+            try:
+                return write_json(self, run_silicon_llm_sampling(payload))
+            except ValueError as exc:
+                return write_json(self, {"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            except RuntimeError as exc:
+                return write_json(self, {"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+        self.send_error(HTTPStatus.NOT_FOUND)
+
+
+def main() -> int:
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default=os.getenv("HOST", "127.0.0.1"))
+    parser.add_argument("--port", type=int, default=int(os.getenv("PORT", "8765")))
+    args = parser.parse_args()
+    server = ThreadingHTTPServer((args.host, args.port), Handler)
+    print(f"Silicon Sampling Lab running at http://{args.host}:{args.port}", flush=True)
+    print(f"OpenAI API key available: {bool(resolve_openai_api_key())}", flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nShutting down.", flush=True)
+    finally:
+        server.server_close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

silicon_llm.py

@@ -0,0 +1,420 @@
+"""LLM-backed silicon sampling runtime.
+
+Each sampled persona is treated as one respondent-agent. The agent receives all
+selected survey questions in one prompt and must return one structured answer
+per question. The parser and aggregation are question-driven, so Likert/open
+question mixes can change without adding scenario-specific code.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+GENDER_LABELS = {"male": "남성", "female": "여성", "no_response": "응답 안 함"}
+AGE_LABELS = {"20s": "20대", "30s": "30대", "40s": "40대", "50s": "50대", "60plus": "60대 이상"}
+PERSONA_LABELS = {
+    "occ_office": "사무/관리직",
+    "occ_service": "서비스/판매직",
+    "occ_professional": "전문직",
+    "occ_self_employed": "자영업",
+    "occ_student": "학생",
+    "occ_homemaker": "전업주부",
+    "occ_technical": "기술/생산직",
+    "occ_retired": "은퇴/무직",
+    "edu_high_school": "고졸 이하",
+    "edu_college": "전문대/대학 재학",
+    "edu_bachelor": "대졸",
+    "edu_graduate": "대학원 이상",
+    "housing_apartment": "아파트",
+    "housing_house": "단독/다가구",
+    "housing_officetel": "오피스텔/원룸",
+    "housing_other": "기타 주거",
+    "marital_single": "미혼",
+    "marital_married": "기혼",
+    "marital_divorced": "이혼/별거",
+    "marital_widowed": "사별",
+    "family_single": "1인 가구",
+    "family_couple": "부부 가구",
+    "family_children": "자녀 동거",
+    "family_extended": "확대 가족",
+}
+PERSONA_DIMENSIONS = {
+    "occupation": ["occ_office", "occ_service", "occ_professional", "occ_self_employed", "occ_student", "occ_homemaker", "occ_technical", "occ_retired"],
+    "education": ["edu_high_school", "edu_college", "edu_bachelor", "edu_graduate"],
+    "housing": ["housing_apartment", "housing_house", "housing_officetel", "housing_other"],
+    "marital": ["marital_single", "marital_married", "marital_divorced", "marital_widowed"],
+    "family": ["family_single", "family_couple", "family_children", "family_extended"],
+}
+
+
+@dataclass
+class OpenAILLM:
+    model: str = "gpt-4o-mini"
+    temperature: float = 0.2
+    timeout: float = 60.0
+
+    def complete_agent(self, *, agent: dict[str, Any], questions: list[dict[str, Any]], response_contract: dict[str, Any]) -> str:
+        from openai import OpenAI
+
+        api_key = resolve_openai_api_key()
+        if not api_key:
+            raise RuntimeError("OPENAI_API_KEY or OPENAI_API_KEY_FILE is required for silicon LLM sampling")
+        client = OpenAI(api_key=api_key)
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    "당신은 한국 설문조사의 가상 응답자입니다. "
+                    "주어진 persona와 인구통계 정보를 일관되게 반영해 모든 문항에 답하십시오. "
+                    "반드시 JSON만 반환하십시오. Likert 문항은 해당 척도 범위의 정수 value를, "
+                    "open-ended 문항은 한국어 text와 짧은 theme를 반환하십시오."
+                ),
+            },
+            {
+                "role": "user",
+                "content": json.dumps(
+                    {
+                        "agent": agent,
+                        "questions": questions,
+                        "required_json_contract": response_contract,
+                    },
+                    ensure_ascii=False,
+                ),
+            },
+        ]
+        kwargs: dict[str, Any] = {"max_completion_tokens": 1800}
+        if self.model.startswith("gpt-5"):
+            kwargs["reasoning_effort"] = "minimal"
+        else:
+            kwargs["temperature"] = self.temperature
+        response = client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            response_format={"type": "json_object"},
+            timeout=self.timeout,
+            **kwargs,
+        )
+        return response.choices[0].message.content or "{}"
+
+
+def resolve_openai_api_key() -> str | None:
+    key = os.getenv("OPENAI_API_KEY")
+    if key:
+        return key.strip()
+    path = os.getenv("OPENAI_API_KEY_FILE")
+    if path:
+        try:
+            return Path(path).expanduser().read_text(encoding="utf-8").strip().splitlines()[0].strip()
+        except (OSError, IndexError):
+            pass
+    for env_path in [Path(__file__).resolve().parent / ".env", Path.cwd() / ".env"]:
+        try:
+            if not env_path.exists():
+                continue
+            for line in env_path.read_text(encoding="utf-8").splitlines():
+                stripped = line.strip()
+                if not stripped or stripped.startswith("#") or "=" not in stripped:
+                    continue
+                name, value = stripped.split("=", 1)
+                if name.strip() == "OPENAI_API_KEY":
+                    return value.strip().strip('"').strip("'")
+        except OSError:
+            continue
+    return None
+
+
+def build_silicon_llm_response_contract(questions: list[dict[str, Any]]) -> dict[str, Any]:
+    answer_properties: dict[str, Any] = {}
+    for question in questions:
+        question_id = str(question.get("id") or "")
+        if not question_id:
+            continue
+        if question.get("kind") == "open":
+            answer_properties[question_id] = {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string"},
+                    "theme": {"type": "string"},
+                },
+                "required": ["text", "theme"],
+                "additionalProperties": True,
+            }
+        else:
+            scale = int(question.get("scale") or 5)
+            answer_properties[question_id] = {
+                "type": "object",
+                "properties": {
+                    "value": {"type": "integer", "minimum": 1, "maximum": scale},
+                    "reason": {"type": "string"},
+                },
+                "required": ["value"],
+                "additionalProperties": True,
+            }
+    return {
+        "name": "silicon_agent_answers",
+        "schema": {
+            "type": "object",
+            "properties": {
+                "answers": {
+                    "type": "object",
+                    "properties": answer_properties,
+                    "required": list(answer_properties),
+                    "additionalProperties": False,
+                }
+            },
+            "required": ["answers"],
+            "additionalProperties": False,
+        },
+    }
+
+
+def parse_silicon_agent_response(raw: str, questions: list[dict[str, Any]], *, respondent_id: str) -> dict[str, Any]:
+    payload = extract_json(raw)
+    answers = payload.get("answers") if isinstance(payload, dict) else None
+    if isinstance(answers, list):
+        answers = {str(item.get("questionId") or item.get("id") or ""): item for item in answers if isinstance(item, dict)}
+    if not isinstance(answers, dict):
+        answers = {}
+
+    likert_answers: list[dict[str, Any]] = []
+    open_answers: list[dict[str, Any]] = []
+    issues: list[dict[str, Any]] = []
+    for question in questions:
+        question_id = str(question.get("id") or "")
+        answer = answers.get(question_id)
+        if not isinstance(answer, dict):
+            issues.append({"questionId": question_id, "type": "missing_answer"})
+            answer = {}
+        if question.get("kind") == "open":
+            text = str(answer.get("text") or answer.get("answer") or answer.get("response") or "").strip()
+            theme = str(answer.get("theme") or answer.get("topic") or infer_theme(text)).strip() or "기타"
+            if not text:
+                text = "응답을 생성하지 못했습니다."
+                issues.append({"questionId": question_id, "type": "empty_open_text"})
+            open_answers.append({"respondentId": respondent_id, "questionId": question_id, "text": text, "theme": theme[:40]})
+        else:
+            scale = int(question.get("scale") or 5)
+            value = coerce_int(answer.get("value", answer.get("score", answer.get("rating"))), default=math.ceil(scale / 2))
+            value = max(1, min(scale, value))
+            likert_answers.append({"respondentId": respondent_id, "questionId": question_id, "value": value})
+    return {"likertAnswers": likert_answers, "openAnswers": open_answers, "issues": issues}
+
+
+def run_silicon_llm_sampling(payload: dict[str, Any], *, llm: Any | None = None) -> dict[str, Any]:
+    config = dict(payload.get("config") or payload)
+    questions = [dict(item) for item in config.get("questions", []) if isinstance(item, dict)]
+    if not questions:
+        raise ValueError("config.questions is required")
+    sample_size = bounded_int(config.get("sampleSize"), 5, minimum=1, maximum=20000)
+    execution = payload.get("execution") if isinstance(payload.get("execution"), dict) else {}
+    max_agents = bounded_int(execution.get("max_agents"), int(os.getenv("SILICON_LLM_MAX_AGENTS", "3000")), minimum=1, maximum=20000)
+    if sample_size > max_agents:
+        raise ValueError(f"LLM silicon sampling requested {sample_size} agents but max_agents is {max_agents}")
+
+    respondents = build_respondents(config, sample_size)
+    response_contract = build_silicon_llm_response_contract(questions)
+    model = str(execution.get("model") or os.getenv("SILICON_LLM_MODEL", "gpt-4o-mini"))
+    llm = llm or OpenAILLM(model=model, timeout=float(execution.get("timeout_seconds") or 60))
+    likert_answers: list[dict[str, Any]] = []
+    open_answers: list[dict[str, Any]] = []
+    parse_issues: list[dict[str, Any]] = []
+    raw_responses: list[dict[str, str]] = []
+
+    for respondent in respondents:
+        raw = llm.complete_agent(agent=respondent, questions=questions, response_contract=response_contract)
+        raw_responses.append({"respondentId": respondent["id"], "text": raw[:4000]})
+        parsed = parse_silicon_agent_response(raw, questions, respondent_id=respondent["id"])
+        likert_answers.extend(parsed["likertAnswers"])
+        open_answers.extend(parsed["openAnswers"])
+        parse_issues.extend({"respondentId": respondent["id"], **issue} for issue in parsed["issues"])
+
+    primary_question_id = next((str(item.get("id")) for item in questions if item.get("kind") != "open"), None)
+    result = {
+        "config": config,
+        "respondents": respondents,
+        "likertAnswers": likert_answers,
+        "openAnswers": open_answers,
+        "regionStats": build_region_stats(config, respondents, likert_answers, open_answers, questions),
+        "questionStats": build_question_stats(questions, likert_answers),
+        "primaryQuestionId": primary_question_id,
+        "llmTrace": {
+            "engine": "openai_chat_completions" if isinstance(llm, OpenAILLM) else "injected_llm",
+            "model": model,
+            "calls": len(respondents),
+            "questionsPerCall": len(questions),
+            "parseIssues": parse_issues,
+            "rawResponses": raw_responses,
+        },
+    }
+    return result
+
+
+def build_respondents(config: dict[str, Any], sample_size: int) -> list[dict[str, Any]]:
+    genders = allocation_pool(config.get("genders"), sample_size, "female")
+    ages = allocation_pool(config.get("ages"), sample_size, "40s")
+    locations = allocation_pool(config.get("locations"), sample_size, "seoul")
+    persona_pools = {dimension: allocation_pool([pick for pick in config.get("personaAttributes", []) if pick.get("id") in ids], sample_size, "") for dimension, ids in PERSONA_DIMENSIONS.items()}
+    location_options = {str(item.get("id")): item for item in config.get("locationOptions", []) if isinstance(item, dict)}
+    respondents: list[dict[str, Any]] = []
+    for index in range(sample_size):
+        location_id = str(locations[index] or "seoul")
+        location = location_options.get(location_id, {"id": location_id, "label": location_id, "parentRegion": "seoul"})
+        persona_attributes: dict[str, str] = {}
+        persona_labels: dict[str, str] = {}
+        for dimension, pool in persona_pools.items():
+            picked = str(pool[index] or "")
+            if not picked:
+                continue
+            persona_attributes[dimension] = picked
+            persona_labels[dimension] = PERSONA_LABELS.get(picked, picked)
+        respondents.append(
+            {
+                "id": f"R{index + 1:04d}",
+                "gender": str(genders[index] or "female"),
+                "genderLabel": GENDER_LABELS.get(str(genders[index]), str(genders[index])),
+                "age": str(ages[index] or "40s"),
+                "ageLabel": AGE_LABELS.get(str(ages[index]), str(ages[index])),
+                "region": str(location.get("parentRegion") or location_id),
+                "location": location_id,
+                "locationLabel": str(location.get("label") or location_id),
+                "personaAttributes": persona_attributes,
+                "personaLabels": persona_labels,
+                "segment": ", ".join(persona_labels.values()) or "일반 응답자",
+                "trust": 0.5,
+                "economicAnxiety": 0.5,
+                "participation": 0.5,
+            }
+        )
+    return respondents
+
+
+def allocation_pool(items: Any, target_size: int, fallback: str) -> list[str]:
+    source = [item for item in items or [] if isinstance(item, dict) and item.get("enabled") and float_or_zero(item.get("weight")) > 0]
+    if not source:
+        return [fallback for _ in range(target_size)]
+    total = sum(float_or_zero(item.get("weight")) for item in source)
+    rows = []
+    for item in source:
+        raw = float_or_zero(item.get("weight")) / total * target_size
+        rows.append({"id": str(item.get("id")), "floor": math.floor(raw), "remainder": raw - math.floor(raw)})
+    used = sum(row["floor"] for row in rows)
+    for row in sorted(rows, key=lambda item: item["remainder"], reverse=True):
+        if used >= target_size:
+            break
+        row["floor"] += 1
+        used += 1
+    pool: list[str] = []
+    for row in rows:
+        pool.extend([row["id"]] * int(row["floor"]))
+    while len(pool) < target_size:
+        pool.append(fallback)
+    return pool[:target_size]
+
+
+def build_question_stats(questions: list[dict[str, Any]], likert_answers: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    stats: list[dict[str, Any]] = []
+    for question in questions:
+        question_id = str(question.get("id"))
+        if question.get("kind") == "open":
+            stats.append({"questionId": question_id, "title": question.get("title", question_id), "kind": "open"})
+            continue
+        scale = int(question.get("scale") or 5)
+        values = [int(answer["value"]) for answer in likert_answers if answer.get("questionId") == question_id]
+        distribution = [{"value": value, "count": values.count(value), "share": values.count(value) / len(values) if values else 0} for value in range(1, scale + 1)]
+        positive_cut = max(3, math.ceil(scale * 0.7))
+        stats.append(
+            {
+                "questionId": question_id,
+                "title": question.get("title", question_id),
+                "kind": "likert",
+                "scale": scale,
+                "mean": sum(values) / len(values) if values else 0,
+                "positiveShare": len([value for value in values if value >= positive_cut]) / len(values) if values else 0,
+                "distribution": distribution,
+            }
+        )
+    return stats
+
+
+def build_region_stats(config: dict[str, Any], respondents: list[dict[str, Any]], likert_answers: list[dict[str, Any]], open_answers: list[dict[str, Any]], questions: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    primary = next((question for question in questions if question.get("kind") != "open"), None)
+    primary_id = str(primary.get("id")) if primary else None
+    scale = int(primary.get("scale") or 5) if primary else 5
+    positive_cut = max(3, math.ceil(scale * 0.7))
+    stats: list[dict[str, Any]] = []
+    for pick in config.get("locations", []):
+        if not isinstance(pick, dict) or not pick.get("enabled"):
+            continue
+        location_id = str(pick.get("id"))
+        people = [respondent for respondent in respondents if respondent.get("location") == location_id]
+        ids = {respondent["id"] for respondent in people}
+        values = [int(answer["value"]) for answer in likert_answers if answer.get("questionId") == primary_id and answer.get("respondentId") in ids]
+        label = next((str(item.get("label")) for item in config.get("locationOptions", []) if isinstance(item, dict) and str(item.get("id")) == location_id), location_id)
+        parent = next((str(item.get("parentRegion")) for item in config.get("locationOptions", []) if isinstance(item, dict) and str(item.get("id")) == location_id), location_id)
+        stats.append(
+            {
+                "region": location_id,
+                "parentRegion": parent,
+                "label": label,
+                "respondents": len(people),
+                "mean": sum(values) / len(values) if values else 0,
+                "scale": scale,
+                "positiveShare": len([value for value in values if value >= positive_cut]) / len(values) if values else 0,
+                "openCount": len([answer for answer in open_answers if answer.get("respondentId") in ids]),
+            }
+        )
+    return stats
+
+
+def extract_json(text: str) -> Any:
+    text = (text or "").strip()
+    if not text:
+        raise ValueError("empty model response")
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+    fenced = re.search(r"```(?:json)?\s*(.*?)```", text, flags=re.DOTALL | re.IGNORECASE)
+    if fenced:
+        return json.loads(fenced.group(1).strip())
+    start = text.find("{")
+    end = text.rfind("}")
+    if start != -1 and end != -1 and end > start:
+        return json.loads(text[start : end + 1])
+    raise ValueError(f"could not extract JSON from model response: {text[:200]}")
+
+
+def infer_theme(text: str) -> str:
+    for token in ["물가", "의료", "교통", "주거", "돌봄", "일자리", "교육", "환경", "경제"]:
+        if token in text:
+            return token
+    return "기타"
+
+
+def coerce_int(value: Any, *, default: int) -> int:
+    try:
+        return int(round(float(value)))
+    except (TypeError, ValueError):
+        return default
+
+
+def bounded_int(value: Any, default: int, *, minimum: int, maximum: int) -> int:
+    try:
+        parsed = int(float(value))
+    except (TypeError, ValueError):
+        parsed = default
+    return max(minimum, min(maximum, parsed))
+
+
+def float_or_zero(value: Any) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return 0.0

tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  },
+  "include": ["frontend/src", "vite.config.ts"],
+  "references": []
+}

vite.config.ts

@@ -0,0 +1,33 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+export default defineConfig({
+  root: ".",
+  base: "/",
+  plugins: [react()],
+  server: {
+    host: "127.0.0.1",
+    port: 5190,
+    strictPort: true,
+    proxy: {
+      "/api": "http://127.0.0.1:8765",
+    },
+  },
+  build: {
+    outDir: "static/immersive",
+    emptyOutDir: true,
+    manifest: true,
+    chunkSizeWarningLimit: 700,
+    rolldownOptions: {
+      output: {
+        codeSplitting: {
+          groups: [
+            { name: "vendor-react", test: /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/ },
+            { name: "vendor-echarts", test: /[\\/]node_modules[\\/]echarts[\\/]/ },
+            { name: "vendor-zrender", test: /[\\/]node_modules[\\/]zrender[\\/]/ },
+          ],
+        },
+      },
+    },
+  },
+});