@jjlmoya/utils-civic 1.5.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-civic",
-    "version": "1.5.0",
+    "version": "1.7.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -3,11 +3,13 @@ import { civicPriorityMatrix } from '../tool/civic-priority-matrix/entry';
 import { electionSeatApportionmentCalculator } from '../tool/election-seat-apportionment-calculator/entry';
 import { referendumThresholdCalculator } from '../tool/referendum-threshold-calculator/entry';
 import { voteSeatDisproportionalityAnalyzer } from '../tool/vote-seat-disproportionality-analyzer/entry';
+import { participatoryBudgetAllocator } from '../tool/participatory-budget-allocator/entry';
+import { publicBudgetAnalyzer } from '../tool/public-budget-analyzer/entry';
 import type { CategoryLocaleContent, KnownLocale } from '../types';
 
 export const civicCategory = {
   icon: 'mdi:bank-outline',
-  tools: [civicPriorityMatrix, coalitionMajorityCalculator, electionSeatApportionmentCalculator, referendumThresholdCalculator, voteSeatDisproportionalityAnalyzer],
+  tools: [civicPriorityMatrix, coalitionMajorityCalculator, electionSeatApportionmentCalculator, referendumThresholdCalculator, voteSeatDisproportionalityAnalyzer, participatoryBudgetAllocator, publicBudgetAnalyzer],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     de: () => import('./i18n/de').then((m) => m.content),

package/src/entries.ts

@@ -11,6 +11,8 @@ import { civicPriorityMatrix } from './tool/civic-priority-matrix/entry';
 import { electionSeatApportionmentCalculator } from './tool/election-seat-apportionment-calculator/entry';
 import { referendumThresholdCalculator } from './tool/referendum-threshold-calculator/entry';
 import { voteSeatDisproportionalityAnalyzer } from './tool/vote-seat-disproportionality-analyzer/entry';
+import { participatoryBudgetAllocator } from './tool/participatory-budget-allocator/entry';
+import { publicBudgetAnalyzer } from './tool/public-budget-analyzer/entry';
 
 export const ALL_ENTRIES = [
   coalitionMajorityCalculator,
@@ -18,4 +20,6 @@ export const ALL_ENTRIES = [
   electionSeatApportionmentCalculator,
   referendumThresholdCalculator,
   voteSeatDisproportionalityAnalyzer,
+  participatoryBudgetAllocator,
+  publicBudgetAnalyzer,
 ];

package/src/index.ts

@@ -5,6 +5,7 @@ export { electionSeatApportionmentCalculator, ELECTION_SEAT_APPORTIONMENT_CALCUL
 export { referendumThresholdCalculator, REFERENDUM_THRESHOLD_CALCULATOR_TOOL } from './tool/referendum-threshold-calculator';
 export { civicPriorityMatrix, CIVIC_PRIORITY_MATRIX_TOOL } from './tool/civic-priority-matrix';
 export { voteSeatDisproportionalityAnalyzer, VOTE_SEAT_DISPROPORTIONALITY_ANALYZER_TOOL } from './tool/vote-seat-disproportionality-analyzer';
+export { participatoryBudgetAllocator, PARTICIPATORY_BUDGET_ALLOCATOR_TOOL } from './tool/participatory-budget-allocator';
 
 export type {
   KnownLocale,

package/src/tests/locale_completeness.test.ts

@@ -18,6 +18,6 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(5);
+    expect(ALL_TOOLS.length).toBe(7);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { civicCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(5);
+      expect(ALL_TOOLS.length).toBe(7);
     });
 
     it('civicCategory should be defined', () => {

package/src/tool/participatory-budget-allocator/bibliography.astro

@@ -0,0 +1,6 @@
+---
+import { Bibliography } from '@jjlmoya/utils-shared';
+import { bibliography } from './bibliography';
+---
+
+<Bibliography links={bibliography} />

package/src/tool/participatory-budget-allocator/bibliography.ts

@@ -0,0 +1,8 @@
+import type { BibliographyEntry } from '../../types';
+
+const bibliographyTrace = [
+  { name: 'Northeastern University, Lecture 35 Dynamic Programming', url: 'https://course.khoury.northeastern.edu/cs2510a/lecture35.html', region: 'United States', originalLanguage: 'English', supports: 'The 0/1 knapsack model and dynamic programming search.' },
+  { name: 'Ville de Paris, Budget participatif 2022 Guide du dépôt de projets', url: 'https://cdn.paris.fr/paris/2022/01/04/86f0051197c40fe872c29bac1e98c335.pdf', region: 'France', originalLanguage: 'French', supports: 'The practical context of submitting and costing participatory budget projects.' },
+];
+
+export const bibliography: BibliographyEntry[] = bibliographyTrace.map(({ name, url }) => ({ name, url }));

package/src/tool/participatory-budget-allocator/component.astro

@@ -0,0 +1,61 @@
+---
+import type { ParticipatoryBudgetUI } from './ui';
+import './participatory-budget-allocator.css';
+
+interface Props {
+  ui: ParticipatoryBudgetUI;
+}
+
+const { ui } = Astro.props as Props;
+---
+
+<div class="participatory-budget-tool" data-participatory-budget-tool>
+  <div class="allocation-layout">
+    <form class="allocation-form" data-allocation-form>
+      <label class="budget-field">{ui.budgetLabel}<input name="budget" type="number" min="0" max="20000" step="0.01" value="12000" required /><span class="field-help">{ui.budgetHelp}</span></label>
+      <div class="proposal-heading"><h2>{ui.proposalsHeading}</h2><button class="add-proposal" type="button" data-add-proposal>{ui.addProposal}</button></div>
+      <div class="proposal-rows" data-proposal-rows>
+        <div class="proposal-row" data-proposal-row>
+          <label class="proposal-name">{ui.proposalNameLabel}<input data-proposal-name type="text" value="Pocket park seating" required /></label>
+          <label>{ui.proposalCostLabel}<input data-proposal-cost type="number" min="0" step="0.01" value="3500" required /></label>
+          <label>{ui.proposalScoreLabel}<input data-proposal-score type="number" min="0" step="1" value="86" required /></label>
+          <button class="remove-proposal" type="button" data-remove-proposal>{ui.removeProposal}</button>
+        </div>
+        <div class="proposal-row" data-proposal-row>
+          <label class="proposal-name">{ui.proposalNameLabel}<input data-proposal-name type="text" value="Safer school crossing" required /></label>
+          <label>{ui.proposalCostLabel}<input data-proposal-cost type="number" min="0" step="0.01" value="6200" required /></label>
+          <label>{ui.proposalScoreLabel}<input data-proposal-score type="number" min="0" step="1" value="100" required /></label>
+          <button class="remove-proposal" type="button" data-remove-proposal>{ui.removeProposal}</button>
+        </div>
+        <div class="proposal-row" data-proposal-row>
+          <label class="proposal-name">{ui.proposalNameLabel}<input data-proposal-name type="text" value="Community tool library" required /></label>
+          <label>{ui.proposalCostLabel}<input data-proposal-cost type="number" min="0" step="0.01" value="4200" required /></label>
+          <label>{ui.proposalScoreLabel}<input data-proposal-score type="number" min="0" step="1" value="74" required /></label>
+          <button class="remove-proposal" type="button" data-remove-proposal>{ui.removeProposal}</button>
+        </div>
+      </div>
+      <p class="calculate-note">{ui.calculateNote}</p>
+      <div class="form-actions"><button class="secondary-action" type="button" data-load-example>{ui.loadExample}</button><button class="print-action" type="button" data-print>{ui.printAction}</button></div>
+      <p class="tool-status" data-status role="status"></p>
+    </form>
+    <section class="allocation-result" aria-live="polite" aria-labelledby="allocation-result-heading">
+      <div class="result-heading"><h2 id="allocation-result-heading">{ui.resultHeading}</h2></div>
+      <div data-scene></div>
+      <div data-result></div>
+    </section>
+  </div>
+  <div class="guardrails" aria-label="Method and limits">
+    <article class="guardrail"><span class="guardrail-index">01</span><h2>{ui.methodHeading}</h2><p>{ui.methodText}</p></article>
+    <article class="guardrail"><span class="guardrail-index">02</span><h2>{ui.limitsHeading}</h2><p>{ui.limitsText}</p></article>
+    <article class="guardrail"><span class="guardrail-index">03</span><h2>{ui.warningsHeading}</h2><p>{ui.warningsText}</p></article>
+  </div>
+  <script is:inline type="application/json" data-participatory-budget-config set:html={JSON.stringify({ ui })}></script>
+</div>
+
+<script>
+  import { mountParticipatoryBudgetTool } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-participatory-budget-tool]');
+  const config = root?.querySelector<HTMLScriptElement>('[data-participatory-budget-config]');
+  if (root && config) mountParticipatoryBudgetTool(root, JSON.parse(config.textContent || '{}').ui);
+</script>

package/src/tool/participatory-budget-allocator/contract.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { PARTICIPATORY_BUDGET_ALLOCATOR_TOOL, participatoryBudgetAllocator } from './index';
+
+describe('participatory budget allocator runtime contract', () => {
+  it('exposes all locale loaders and the three page component loaders', async () => {
+    const content = await participatoryBudgetAllocator.i18n.en?.();
+    expect(content?.slug).toBe('participatory-budget-allocator');
+    expect(Object.keys(participatoryBudgetAllocator.i18n)).toEqual(['en', 'de', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh']);
+    expect(typeof PARTICIPATORY_BUDGET_ALLOCATOR_TOOL.Component).toBe('function');
+    expect(typeof PARTICIPATORY_BUDGET_ALLOCATOR_TOOL.SEOComponent).toBe('function');
+    expect(typeof PARTICIPATORY_BUDGET_ALLOCATOR_TOOL.BibliographyComponent).toBe('function');
+  });
+});

package/src/tool/participatory-budget-allocator/controller.ts

@@ -0,0 +1,108 @@
+import { allocateBudget, getExampleInput, type AllocationInput, type ProposalInput } from './logic';
+import { renderAllocationResult, renderAllocationScene } from './dom-views';
+import { loadSavedInput, saveInput } from './storage';
+import type { ParticipatoryBudgetUI } from './ui';
+
+function numberValue(form: HTMLFormElement, name: string): number {
+  const field = form.elements.namedItem(name) as HTMLInputElement | null;
+  return parseNumber(field?.value ?? '');
+}
+
+function parseNumber(value: string): number {
+  return value.trim() ? Number(value) : Number.NaN;
+}
+
+function fieldValue(value: string): string {
+  return value === 'NaN' ? '' : value;
+}
+
+function readRows(form: HTMLFormElement): ProposalInput[] {
+  return [...form.querySelectorAll<HTMLElement>('[data-proposal-row]')].map((row) => ({
+    name: (row.querySelector('[data-proposal-name]') as HTMLInputElement)?.value ?? '',
+    cost: parseNumber((row.querySelector('[data-proposal-cost]') as HTMLInputElement)?.value ?? ''),
+    score: parseNumber((row.querySelector('[data-proposal-score]') as HTMLInputElement)?.value ?? ''),
+  }));
+}
+
+function readInput(form: HTMLFormElement): AllocationInput {
+  return { budget: numberValue(form, 'budget'), proposals: readRows(form) };
+}
+
+function createField(label: string, value: string, className: string, marker: string): HTMLLabelElement {
+  const labelNode = document.createElement('label');
+  labelNode.className = className;
+  labelNode.innerHTML = `${label}<input data-${marker} type="${marker === 'proposal-name' ? 'text' : 'number'}" ${marker === 'proposal-name' ? '' : 'min="0" step="0.01"'} value="${fieldValue(value).replace(/"/g, '&quot;')}" required>`;
+  return labelNode;
+}
+
+function addRow(container: HTMLElement, proposal: ProposalInput, ui: ParticipatoryBudgetUI): void {
+  const row = document.createElement('div');
+  row.className = 'proposal-row';
+  row.dataset.proposalRow = 'true';
+  row.append(createField(ui.proposalNameLabel, proposal.name, 'proposal-name', 'proposal-name'), createField(ui.proposalCostLabel, String(proposal.cost), 'proposal-cost', 'proposal-cost'), createField(ui.proposalScoreLabel, String(proposal.score), 'proposal-score', 'proposal-score'));
+  const remove = document.createElement('button');
+  remove.type = 'button';
+  remove.className = 'remove-proposal';
+  remove.dataset.removeProposal = 'true';
+  remove.textContent = ui.removeProposal;
+  row.append(remove);
+  container.append(row);
+}
+
+function setRows(container: HTMLElement, proposals: ProposalInput[], ui: ParticipatoryBudgetUI): void {
+  container.replaceChildren();
+  proposals.forEach((proposal) => addRow(container, proposal, ui));
+}
+
+function setInput(form: HTMLFormElement, input: AllocationInput, container: HTMLElement, ui: ParticipatoryBudgetUI): void {
+  (form.elements.namedItem('budget') as HTMLInputElement).value = String(input.budget);
+  setRows(container, input.proposals, ui);
+}
+
+function markFormFeedback(form: HTMLFormElement, input: AllocationInput, ui: ParticipatoryBudgetUI): void {
+  [...form.querySelectorAll<HTMLElement>('[data-proposal-row]')].forEach((row, index) => {
+    row.classList.remove('proposal-over-budget', 'proposal-invalid');
+    row.querySelector('[data-row-warning]')?.remove();
+    const proposal = input.proposals[index];
+    if (!proposal) return;
+    const message = getRowWarning(proposal, input.budget, ui);
+    if (!message) return;
+    row.classList.add(Number.isFinite(proposal.cost) && proposal.cost > input.budget ? 'proposal-over-budget' : 'proposal-invalid');
+    const warning = document.createElement('span');
+    warning.className = 'row-warning';
+    warning.dataset.rowWarning = 'true';
+    warning.textContent = message;
+    row.append(warning);
+  });
+}
+
+function getRowWarning(proposal: ProposalInput, budget: number, ui: ParticipatoryBudgetUI): string {
+  if (!Number.isFinite(proposal.cost) || !Number.isFinite(proposal.score) || !proposal.name.trim()) return ui.invalidProposal;
+  if (Number.isFinite(budget) && proposal.cost > budget) return ui.costExceedsBudget;
+  return '';
+}
+
+function update(root: HTMLElement, form: HTMLFormElement, ui: ParticipatoryBudgetUI): void {
+  const input = readInput(form);
+  markFormFeedback(form, input, ui);
+  const result = allocateBudget(input);
+  saveInput(input);
+  root.querySelector<HTMLElement>('[data-scene]')!.innerHTML = renderAllocationScene(result, ui);
+  root.querySelector<HTMLElement>('[data-result]')!.innerHTML = renderAllocationResult(result, ui);
+  root.querySelector<HTMLElement>('[data-status]')!.textContent = ui.statusSaved;
+}
+
+export function mountParticipatoryBudgetTool(root: HTMLElement, ui: ParticipatoryBudgetUI): void {
+  const form = root.querySelector<HTMLFormElement>('[data-allocation-form]');
+  const rows = root.querySelector<HTMLElement>('[data-proposal-rows]');
+  if (!form || !rows) return;
+  const saved = loadSavedInput();
+  if (saved) setInput(form, saved, rows, ui);
+  const refresh = () => update(root, form, ui);
+  form.addEventListener('input', refresh);
+  root.querySelector('[data-add-proposal]')?.addEventListener('click', () => { addRow(rows, { name: '', cost: Number.NaN, score: Number.NaN }, ui); refresh(); });
+  root.addEventListener('click', (event) => { const target = event.target as HTMLElement; if (target.matches('[data-remove-proposal]')) { target.closest('[data-proposal-row]')?.remove(); refresh(); } });
+  root.querySelector('[data-load-example]')?.addEventListener('click', () => { setInput(form, getExampleInput(), rows, ui); refresh(); });
+  root.querySelector('[data-print]')?.addEventListener('click', () => window.print());
+  refresh();
+}

package/src/tool/participatory-budget-allocator/dom-views.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { renderAllocationScene } from './dom-views';
+import { allocateBudget } from './logic';
+import { ui } from './ui';
+
+describe('participatory budget visual scene', () => {
+  it('renders one funded segment and the exact remaining percentage', () => {
+    const result = allocateBudget({ budget: 5000, proposals: [{ name: 'Community tool library', cost: 4200, score: 74 }, { name: 'Library ramp', cost: 1000, score: 20 }] });
+    const scene = renderAllocationScene(result, ui);
+    expect(scene.match(/class="scene-tile"/g)).toHaveLength(1);
+    expect(scene).toContain('--tile-width:84%');
+    expect(scene).toContain('--tile-width:16%');
+  });
+});

package/src/tool/participatory-budget-allocator/dom-views.ts

@@ -0,0 +1,58 @@
+import { getAllocationStatus, getProposalStatusDetail } from './evaluator';
+import type { ParticipatoryBudgetUI } from './ui';
+import type { AllocationResult, ProposalResult } from './logic';
+
+function escapeHtml(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+
+function formatMoney(value: number): string {
+  return new Intl.NumberFormat('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 }).format(value);
+}
+
+function statusLabel(status: ProposalResult['status'], ui: ParticipatoryBudgetUI): string {
+  if (status === 'selected') return ui.selectedStatus;
+  if (status === 'too-expensive') return ui.tooExpensiveStatus;
+  if (status === 'invalid') return ui.invalidStatus;
+  return ui.notSelectedStatus;
+}
+
+function renderTile(proposal: ProposalResult, ui: ParticipatoryBudgetUI): string {
+  return `<li class="mosaic-tile ${proposal.status}"><div class="tile-top"><strong>${escapeHtml(proposal.name)}</strong><span class="tile-status">${escapeHtml(statusLabel(proposal.status, ui))}</span></div><div class="tile-data"><span>${formatMoney(proposal.cost)}</span><span>${escapeHtml(ui.scoreLabel)} ${proposal.score}</span></div><p><b>${escapeHtml(ui.reasonLabel)}:</b> ${escapeHtml(proposal.reason || getProposalStatusDetail(proposal.status))}</p></li>`;
+}
+
+function renderScene(result: AllocationResult, ui: ParticipatoryBudgetUI): string {
+  const percentage = result.totals.budget > 0 ? Math.min(100, Math.max(0, result.totals.spent / result.totals.budget * 100)) : 0;
+  const tiles = result.selected.map((proposal) => `<span class="scene-tile" style="--tile-width:${proposal.cost / Math.max(result.totals.budget, 1) * 100}%" title="${escapeHtml(proposal.name)}"></span>`).join('');
+  const remainder = `<span class="scene-remainder" style="--tile-width:${Math.max(0, result.totals.remaining) / Math.max(result.totals.budget, 1) * 100}%" title="${escapeHtml(ui.remainingLabel)}"></span>`;
+  return `<div class="capacity-scene"><div class="scene-caption"><span>${escapeHtml(ui.allocationLabel)}</span><b>${percentage.toFixed(0)}%</b></div><div class="capacity-track"><div class="capacity-segments">${tiles}${remainder}</div></div><div class="scene-caption scene-footer"><span>${escapeHtml(ui.budgetUsedLabel)} ${formatMoney(result.totals.spent)}</span><span>${escapeHtml(ui.budgetLeftLabel)} ${formatMoney(result.totals.remaining)}</span></div></div>`;
+}
+
+function renderMetrics(result: AllocationResult, ui: ParticipatoryBudgetUI): string {
+  return `<div class="result-metrics"><div><span>${escapeHtml(ui.spentLabel)}</span><strong>${formatMoney(result.totals.spent)}</strong></div><div><span>${escapeHtml(ui.remainingLabel)}</span><strong>${formatMoney(result.totals.remaining)}</strong></div><div><span>${escapeHtml(ui.scoreLabel)}</span><strong>${result.totals.score}</strong></div><div><span>${escapeHtml(ui.proposalCountLabel)}</span><strong>${result.totals.selectedCount}</strong></div></div>`;
+}
+
+function renderWarnings(result: AllocationResult, ui: ParticipatoryBudgetUI): string {
+  const messages = result.errors.map((error) => getErrorMessage(error, ui));
+  if (result.warnings.includes('no-proposals')) messages.push(ui.noProposalsWarning);
+  if (result.warnings.includes('no-feasible-proposal')) messages.push(ui.noFeasibleWarning);
+  return messages.length ? `<div class="result-warning" role="alert">${messages.map((message) => `<p>${escapeHtml(message)}</p>`).join('')}</div>` : '';
+}
+
+function getErrorMessage(error: string, ui: ParticipatoryBudgetUI): string {
+  if (error === 'invalid-budget') return ui.invalidBudget;
+  if (error === 'budget-too-large') return ui.budgetTooLarge;
+  return ui.invalidProposal;
+}
+
+export function renderAllocationResult(result: AllocationResult, ui: ParticipatoryBudgetUI): string {
+  const status = getAllocationStatus(result);
+  const statusClass = `status-${status.tone}`;
+  const selected = result.selected.length ? result.selected.map((proposal) => renderTile(proposal, ui)).join('') : `<li class="empty-list">${escapeHtml(ui.emptyResult)}</li>`;
+  const excluded = result.excluded.map((proposal) => renderTile(proposal, ui)).join('');
+  return `<div class="result-summary ${statusClass}"><div class="status-line"><span class="status-dot"></span><strong>${escapeHtml(status.title)}</strong></div><p>${escapeHtml(status.detail)}</p></div>${renderWarnings(result, ui)}${renderMetrics(result, ui)}<div class="result-section"><h3>${escapeHtml(ui.selectedTilesLabel)}</h3><ul class="mosaic-list">${selected}</ul></div><div class="result-section excluded-section"><h3>${escapeHtml(ui.excludedLabel)}</h3><ul class="mosaic-list">${excluded || `<li class="empty-list">${escapeHtml(ui.emptyResult)}</li>`}</ul></div><p class="tie-break"><b>${escapeHtml(ui.tieBreakLabel)}:</b> ${escapeHtml(result.tieBreak)}</p>`;
+}
+
+export function renderAllocationScene(result: AllocationResult, ui: ParticipatoryBudgetUI): string {
+  return renderScene(result, ui);
+}

package/src/tool/participatory-budget-allocator/entry.ts

@@ -0,0 +1,27 @@
+import type { CivicToolEntry, ToolLocaleContent } from '../../types';
+import type { ParticipatoryBudgetUI } from './ui';
+
+export type ParticipatoryBudgetLocaleContent = ToolLocaleContent<ParticipatoryBudgetUI>;
+
+export const participatoryBudgetAllocator: CivicToolEntry<ParticipatoryBudgetUI> = {
+  id: 'participatory-budget-allocator',
+  phase: 'localized',
+  icons: { bg: 'mdi:bank-outline', fg: 'mdi:shape-outline' },
+  i18n: {
+    en: () => import('./i18n/en').then((module) => module.content),
+    de: () => import('./i18n/de').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/participatory-budget-allocator/evaluator.ts

@@ -0,0 +1,24 @@
+import type { AllocationResult, ProposalStatus } from './logic';
+
+export interface AllocationStatus {
+  tone: 'positive' | 'warning' | 'danger' | 'neutral';
+  title: string;
+  detail: string;
+}
+const statusCopy: Record<ProposalStatus, string> = {
+  selected: 'This proposal belongs to the selected best feasible combination.',
+  'too-expensive': 'This proposal cannot fit within the budget by itself.',
+  'not-selected': 'This proposal was left out because another feasible combination scores better.',
+  invalid: 'Correct this row before reading an allocation.',
+};
+
+export function getProposalStatusDetail(status: ProposalStatus): string {
+  return statusCopy[status];
+}
+
+export function getAllocationStatus(result: AllocationResult): AllocationStatus {
+  if (!result.valid) return { tone: 'danger', title: 'Check the allocation inputs', detail: 'The model cannot compare proposals until the budget and every row are valid.' };
+  if (result.warnings.includes('no-proposals')) return { tone: 'neutral', title: 'Waiting for proposals', detail: 'Add complete proposals to build the allocation mosaic.' };
+  if (result.warnings.includes('no-feasible-proposal')) return { tone: 'warning', title: 'Nothing fits yet', detail: 'Increase the budget or review proposal costs before interpreting the score.' };
+  return { tone: 'positive', title: 'Feasible allocation found', detail: 'The funded set stays within the ceiling and follows the visible tie-break rule.' };
+}

package/src/tool/participatory-budget-allocator/i18n/de.ts

@@ -0,0 +1,44 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { ParticipatoryBudgetLocaleContent } from '../entry';
+import type { ParticipatoryBudgetUI } from '../ui';
+
+const ui: ParticipatoryBudgetUI = {
+  budgetLabel: 'Verfügbares Budget', budgetHelp: 'Verwende eine Währung und gib die Obergrenze ein, die nicht überschritten werden darf.', proposalsHeading: 'Vorschläge mit vergleichbarer Punktzahl hinzufügen', proposalNameLabel: 'Name des Vorschlags', proposalCostLabel: 'Kosten', proposalScoreLabel: 'Stimmen oder Nutzwert', addProposal: 'Vorschlag hinzufügen', removeProposal: 'Entfernen', calculateNote: 'Die Auswahl wird beim Bearbeiten aktualisiert. Jeder Vorschlag wird vollständig finanziert oder ausgeschlossen.', loadExample: 'Beispiel laden', printAction: 'Prüfblatt drucken', resultHeading: 'Budgetmosaik', emptyResult: 'Füge Vorschläge hinzu, um eine passende vollständige Auswahl zu sehen.', excludedLabel: 'Nicht finanziert', spentLabel: 'Gesamtkosten', remainingLabel: 'Übriges Budget', scoreLabel: 'Gesamtpunktzahl', proposalCountLabel: 'Vorschläge', selectedStatus: 'Finanziert', tooExpensiveStatus: 'Passt nicht', notSelectedStatus: 'Ausgeschlossen', invalidStatus: 'Korrektur nötig', reasonLabel: 'Warum', methodHeading: 'Angewandte Methode', methodText: 'Das Tool löst ein 0/1-Rucksackproblem. Jeder Vorschlag hat Kosten und eine vergleichbare Punktzahl. Es prüft zulässige Kombinationen, maximiert die Punktzahl und verwendet danach niedrigere Kosten, weniger Vorschläge und die Eingabereihenfolge als eindeutige Gleichstandsregeln.', limitsHeading: 'Was dieses Tool nicht tut', limitsText: 'Es entscheidet nicht, ob ein Vorschlag gerecht, legal, förderfähig, umsetzbar oder gesellschaftlich vorzuziehen ist. Es ersetzt weder Beteiligungsregeln noch eine Abstimmung.', warningsHeading: 'Sonderfälle und Datenwarnungen', warningsText: 'Halte Punktzahlen vergleichbar und verwende dieselbe Kostenbasis. Nullwerte, doppelte Namen, unvollständige Schätzungen, Abhängigkeiten und teilbare Vorteile brauchen eine menschliche Prüfung.', noProposalsWarning: 'Es wurden keine Vorschläge eingegeben.', noFeasibleWarning: 'Kein Vorschlag passt in das verfügbare Budget.', invalidBudget: 'Gib ein nicht negatives Budget ein. Das Browsermodell akzeptiert bis zu 20.000,00 in der gewählten Währung.', budgetTooLarge: 'Das Budget überschreitet die Modellgrenze von 20.000,00. Verringere die Obergrenze oder teile die Runde.', invalidProposal: 'Jede Zeile braucht einen Namen, nicht negative Kosten und eine nicht negative Punktzahl.', costExceedsBudget: 'Diese Kosten überschreiten das verfügbare Budget. Der Vorschlag kann nicht ausgewählt werden.', tieBreakLabel: 'Eindeutige Regel', budgetUsedLabel: 'verwendet', budgetLeftLabel: 'übrig', selectedTilesLabel: 'Ausgewählte Felder', allocationLabel: 'Budgetkapazität', statusSaved: 'Entwurf lokal in diesem Browser gespeichert.',
+};
+
+const faq = [
+  { question: 'Was optimiert dieser Verteiler?', answer: 'Er wählt eine zulässige Menge vollständiger Vorschläge, die die von dir angegebene Gesamtpunktzahl maximiert, ohne die Obergrenze zu überschreiten. Ob diese Punktzahl fair oder sinnvoll ist, entscheidet das Tool nicht.' },
+  { question: 'Warum sind Vorschläge ganz oder gar nicht ausgewählt?', answer: 'Das Modell ist ein 0/1-Modell. Jeder Vorschlag wird zu seinen vollen Kosten umgesetzt oder ausgeschlossen, was für Projekte passt, deren Nutzen von einer vollständigen Umsetzung abhängt.' },
+  { question: 'Was passiert bei gleicher Punktzahl?', answer: 'Dann werden zuerst die niedrigeren Gesamtkosten, danach weniger Vorschläge und schließlich die frühere Eingabereihenfolge gewählt. Die Regel bleibt nachvollziehbar.' },
+  { question: 'Kann das Ergebnis ein echtes Budget entscheiden?', answer: 'Nein. Es ist ein transparentes Szenario. Prüfe Förderfähigkeit, Abhängigkeiten, Umsetzungskapazität, Kostenbasis und das offizielle Verfahren.' },
+];
+const howTo = [
+  { name: 'Obergrenze festlegen', text: 'Gib den verfügbaren Betrag für diese Runde ein und halte die Währungsbasis einheitlich.' },
+  { name: 'Vollständige Vorschläge ergänzen', text: 'Gib jeden Vorschlag einmal mit vollständigen Kosten und einer vergleichbaren Stimmen- oder Nutzwertzahl ein.' },
+  { name: 'Mosaik prüfen', text: 'Prüfe finanzierte Vorschläge, Punktzahl, Kosten und Restbudget beim Aktualisieren der Zeilen.' },
+  { name: 'Ausschlüsse lesen', text: 'Unterscheide Vorschläge, die allein zu teuer sind, von solchen, die gegen eine bessere zulässige Kombination verloren haben.' },
+  { name: 'Menschliche Prüfung anwenden', text: 'Vergleiche das Szenario vor einer Sitzung mit Regeln, Abhängigkeiten, Kapazität und Betroffenen.' },
+];
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Verteiler für partizipative Budgets', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', description: 'Wähle vollständige öffentliche Vorschläge unter einer festen Budgetgrenze mit einer transparenten Optimierungsregel.', url: 'https://gamebob.dev/de/partizipative-budgetvergabe', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+const faqSchema: FAQPage = { '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) };
+const howToSchema: HowTo = { '@type': 'HowTo', name: 'Ein partizipatives Budget verteilen', step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })) };
+
+export const content: ParticipatoryBudgetLocaleContent = { slug: 'partizipative-budgetvergabe', title: 'Verteiler für partizipative Budgets', description: 'Wähle vollständige Vorschläge unter einer festen Budgetgrenze, maximiere eine erklärte Punktzahl und sieh Kosten und Grund jedes Ausschlusses.', ui, seo: [
+  { type: 'title', text: 'Eine Budgetgrenze in ein nachvollziehbares Szenario verwandeln', level: 2 },
+  { type: 'paragraph', html: 'Bei einer öffentlichen Budgetrunde gibt es oft mehr sinnvolle Vorschläge als verfügbares Geld. Dieser Verteiler macht den Zielkonflikt sichtbar: Grenze eingeben, vollständige Vorschläge ergänzen und eine vergleichbare Stimmen- oder Nutzwertzahl vergeben. Das Ergebnis zeigt eine zulässige Auswahl statt eine undurchsichtige Einzelentscheidung.' },
+  { type: 'title', text: 'So wird die Auswahl berechnet', level: 2 },
+  { type: 'paragraph', html: 'Das Modell ist ein 0/1-Rucksackproblem. Der Browser vergleicht Kombinationen bis zur Obergrenze und behält die mit der höchsten Punktzahl. Bei Gleichstand gelten niedrigere Kosten, weniger Vorschläge und frühere Eingabereihenfolge. Die Punktzahl ist dein erklärtes Ziel, keine unabhängige Messung des öffentlichen Werts.' },
+  { type: 'table', headers: ['Feld', 'Bedeutung', 'Prüffrage'], rows: [['Kosten', 'Voller Betrag für die Umsetzung', 'Sind alle Zeilen gleich kalkuliert?'], ['Punktzahl', 'Eingegebene Stimmen oder Nutzwert', 'Sind die Werte zwischen Vorschlägen vergleichbar?'], ['Budget', 'Maximale Summe der Auswahl', 'Enthält die Grenze dieselben Kosten wie jede Zeile?'], ['Ausschluss', 'Allein zu teuer oder von einer besseren Kombination geschlagen', 'Ist der Grund mathematisch oder politisch zu prüfen?']] },
+  { type: 'title', text: 'Eingaben vorbereiten, die nicht irreführen', level: 2 },
+  { type: 'list', items: ['Prüfe die Förderfähigkeit aller Vorschläge für dieselbe Runde.', 'Nutze vollständige Umsetzungskosten oder echte unabhängige Projektstufen.', 'Dokumentiere, wie Stimmen oder Nutzwerte entstanden sind.', 'Prüfe Abhängigkeiten, Wartung, rechtliche Fragen und Kapazität getrennt.', 'Bewahre Auswahl und Ausschlussgründe als Beratungsprotokoll auf.'] },
+  { type: 'tip', title: 'Eine Punktzahl ist ein gewähltes Ziel', html: 'Bei Stimmen maximiert das Ergebnis die Gesamtstimmen. Bei einer Nutzwertbewertung maximiert es diese Bewertung. Eine andere Punktzahl stellt eine andere Frage, daher sollte ihre Methode mit dem Ergebnis gespeichert werden.' },
+  { type: 'title', text: 'Finanzierte und ausgeschlossene Mengen lesen', level: 2 },
+  { type: 'paragraph', html: 'Finanzierte Vorschläge zeigen Gesamtkosten, Punktzahl und Restbudget. Ein Vorschlag, der nicht passt, ist allein teurer als die Obergrenze. Ein ausgeschlossener Vorschlag könnte allein passen, gehört aber unter dem gewählten Ziel und der Gleichstandsregel nicht zur besten Kombination. Das sind unterschiedliche Gespräche.' },
+  { type: 'title', text: 'Grenzen und nächste Prüfungen', level: 2 },
+  { type: 'paragraph', html: 'Der Verteiler bewertet weder Gerechtigkeit zwischen Stadtteilen noch Lieferrisiko, Abhängigkeiten oder rechtliche Zulässigkeit. Das Browsermodell ist auf 20.000,00 in der gewählten Währung begrenzt, damit die exakte Suche reaktionsfähig bleibt.' },
+  { type: 'paragraph', html: 'Eine Kombination mit hohem Score ist nur so belastbar wie ihre Kostenannahmen und die Regeln für die Score-Erhebung.' },
+  { type: 'title', text: 'Restbudget als Gesprächsanlass nutzen', level: 2 },
+  { type: 'paragraph', html: 'Ein Restbetrag kann bedeuten, dass kein weiterer Vorschlag verbessert, was bereits ausgewählt wurde. Er kann aber auch auf einen fehlenden Vorschlag oder ein bewusst reserviertes Budget hinweisen.' },
+  { type: 'tip', title: 'Vor der Entscheidung prüfen', html: 'Lies die mathematische Auswahl zusammen mit den offiziellen Teilnahmebedingungen und den Stimmen der betroffenen Menschen.' },
+], faq, bibliography, howTo, schemas: [softwareApplication, faqSchema, howToSchema] as unknown as Record<string, unknown>[] };

package/src/tool/participatory-budget-allocator/i18n/en.ts

@@ -0,0 +1,79 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { ParticipatoryBudgetLocaleContent } from '../entry';
+import { ui } from '../ui';
+
+const softwareApplication: SoftwareApplication = {
+  '@type': 'SoftwareApplication',
+  name: 'Participatory Budget Allocator',
+  applicationCategory: 'EducationalApplication',
+  operatingSystem: 'Any',
+  description: 'Select whole public budget proposals under a fixed ceiling with a transparent optimization rule.',
+  url: 'https://gamebob.dev/en/participatory-budget-allocator',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+};
+
+const faqPage: FAQPage = {
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: 'What does this allocator optimize?', acceptedAnswer: { '@type': 'Answer', text: 'It selects a feasible set of whole proposals that maximizes the total score you provide, without exceeding the budget ceiling. It does not decide whether the score is fair or meaningful.' } },
+    { '@type': 'Question', name: 'Why are proposals all or nothing?', acceptedAnswer: { '@type': 'Answer', text: 'The first version uses a 0/1 model. A proposal is either selected at its full cost or excluded, which fits projects that cannot be delivered in a useful fraction.' } },
+    { '@type': 'Question', name: 'What happens when two allocations have the same score?', acceptedAnswer: { '@type': 'Answer', text: 'The tool first chooses the lower total cost, then fewer proposals, then the earlier input order. The tie breaker is shown so another reviewer can reproduce the result.' } },
+    { '@type': 'Question', name: 'Can this result decide a real public budget?', acceptedAnswer: { '@type': 'Answer', text: 'No. It is a transparent scenario model. Check the applicable participation rules, proposal eligibility, dependencies, delivery capacity, currency basis, and official decision process.' } },
+  ],
+};
+
+const howTo: HowTo = {
+  '@type': 'HowTo',
+  name: 'Allocate a fixed participatory budget',
+  step: [
+    { '@type': 'HowToStep', name: 'Set the ceiling', text: 'Enter the amount available for this allocation round and keep the currency basis consistent.' },
+    { '@type': 'HowToStep', name: 'Add complete proposals', text: 'Enter each proposal once with a name, full cost, and comparable votes or benefit score.' },
+    { '@type': 'HowToStep', name: 'Inspect the mosaic', text: 'Review the funded set, total score, cost, and remaining budget as the rows update.' },
+    { '@type': 'HowToStep', name: 'Read exclusions', text: 'Open the not funded list to distinguish proposals that cannot fit from proposals that lost to a better feasible combination.' },
+    { '@type': 'HowToStep', name: 'Apply human checks', text: 'Compare the scenario with eligibility, dependencies, delivery capacity, and the official participation rules before using it in a meeting.' },
+  ],
+};
+
+export const content: ToolLocaleContent<ParticipatoryBudgetLocaleContent['ui']> = {
+  slug: 'participatory-budget-allocator',
+  title: 'Participatory Budget Allocator',
+  description: 'Select whole proposals under a fixed budget ceiling, maximize a declared score, and see the cost and reason behind every exclusion.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Turn a Budget Ceiling Into a Reproducible Scenario', level: 2 },
+    { type: 'paragraph', html: 'A public budget round often contains more worthwhile proposals than the available money can cover. This allocator makes the trade off explicit: enter the ceiling, add complete proposals, and assign each one a comparable votes or benefit score. The result shows a feasible set rather than hiding the selection behind a single recommendation.' },
+    { type: 'paragraph', html: 'The model treats every proposal as whole. It either funds the full cost or leaves the proposal out. That matters for a crossing, a tool library, or a park improvement whose usefulness depends on delivery as a complete project. If a project can be split into independently useful stages, enter those stages as separate proposals only when the real process allows that.' },
+    { type: 'title', text: 'How the Selection Is Calculated', level: 2 },
+    { type: 'paragraph', html: 'The calculation is a 0/1 knapsack model. For every proposal, the browser compares combinations that stay at or below the ceiling and keeps the combination with the largest total score. It then applies a visible deterministic tie breaker: lower total cost, fewer selected proposals, and earlier input order. The score is your declared objective, not an independent measure of public value.' },
+    { type: 'table', headers: ['Decision field', 'Meaning', 'Review question'], rows: [['Cost', 'Full amount required to deliver the proposal', 'Are all rows priced on the same basis?'], ['Score', 'Votes or benefit value supplied by the user', 'Can these values be compared across proposals?'], ['Budget', 'Maximum total cost of selected proposals', 'Does the ceiling include the same costs as each row?'], ['Exclusion', 'Too expensive alone or beaten by a better feasible set', 'Is the reason mathematical or does it need a policy review?']] },
+    { type: 'title', text: 'Prepare Inputs That Do Not Mislead', level: 2 },
+    { type: 'paragraph', html: 'Use one cost basis and one scoring rule for the entire list. Mixing a construction estimate with a recurring annual cost can make a mathematically tidy selection unusable. Likewise, votes collected under different questions or benefit scores assigned by different panels should not be merged without an explicit decision.' },
+    { type: 'list', items: ['Confirm that every proposal is eligible for the same funding round.', 'Use a full delivery cost or split a project into real independent stages.', 'Record how votes or benefit scores were produced before importing them.', 'Check dependencies, maintenance costs, legal checks, and delivery capacity separately.', 'Save the funded set and the excluded reasons as a review record, not as a final mandate.'] },
+    { type: 'tip', title: 'A score is an objective you chose', html: 'If the score represents votes, the result maximizes total votes. If it represents a benefit assessment, the result maximizes that assessment. Changing the score changes the question, so keep the scoring method alongside the output.' },
+    { type: 'title', text: 'Read the Funded and Excluded Sets', level: 2 },
+    { type: 'paragraph', html: 'The funded proposals fill the capacity band and show total cost, score, and remaining budget. A proposal marked cannot fit costs more than the ceiling by itself. A proposal marked left out could fit by itself but is not in the best combination under the selected objective and tie breaker. These are different operational conversations.' },
+    { type: 'paragraph', html: 'A zero remaining budget is not automatically better than a small remainder. The model values score first, so it may leave money unused when no available proposal improves the objective without forcing out a higher scoring combination. Use the remainder to ask whether another eligible proposal is missing or whether the ceiling is intentionally reserved.' },
+    { type: 'title', text: 'Limits and Next Checks', level: 2 },
+    { type: 'paragraph', html: 'The allocator does not judge fairness between neighborhoods, estimate delivery risk, detect conflicts between projects, or determine legal eligibility. It also cannot tell whether the scoring method captures unrepresented needs. The browser model is intentionally bounded to a budget of 20,000.00 in the chosen currency so that the exact search remains responsive.' },
+    { type: 'tip', title: 'Use two scenarios when priorities are contested', html: 'Run the same proposals with the actual vote score and with a separately agreed benefit score. Compare which proposals change status, then discuss the assumptions that caused the change instead of presenting either scenario as a neutral truth.' },
+  ],
+  faq: [
+    { question: 'What does this allocator optimize?', answer: 'It selects a feasible set of whole proposals that maximizes the total score you provide without exceeding the ceiling. It does not decide whether the score is fair or meaningful.' },
+    { question: 'Why are proposals all or nothing?', answer: 'The first version uses a 0/1 model. A proposal is either selected at its full cost or excluded, which fits projects that cannot be delivered in a useful fraction.' },
+    { question: 'What happens when two allocations have the same score?', answer: 'The tool chooses lower total cost, then fewer proposals, then earlier input order. The tie breaker is shown so another reviewer can reproduce the result.' },
+    { question: 'Can this result decide a real public budget?', answer: 'No. It is a transparent scenario model. Check eligibility, dependencies, delivery capacity, currency basis, and the official decision process.' },
+  ],
+  bibliography,
+  howTo: [
+    { name: 'Set the ceiling', text: 'Enter the amount available for this allocation round and keep the currency basis consistent.' },
+    { name: 'Add complete proposals', text: 'Enter each proposal once with a name, full cost, and comparable votes or benefit score.' },
+    { name: 'Inspect the mosaic', text: 'Review the funded set, total score, cost, and remaining budget as the rows update.' },
+    { name: 'Read exclusions', text: 'Distinguish proposals that cannot fit from proposals that lost to a better feasible combination.' },
+    { name: 'Apply human checks', text: 'Compare the scenario with eligibility, dependencies, delivery capacity, and official participation rules.' },
+  ],
+  schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};
+
+export const englishContent: ParticipatoryBudgetLocaleContent = content;

package/src/tool/participatory-budget-allocator/i18n/es.ts

@@ -0,0 +1,43 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { ParticipatoryBudgetLocaleContent } from '../entry';
+import type { ParticipatoryBudgetUI } from '../ui';
+
+const ui: ParticipatoryBudgetUI = {
+  budgetLabel: 'Presupuesto disponible', budgetHelp: 'Usa una moneda y escribe el tope que no debe superarse.', proposalsHeading: 'Añade propuestas con una puntuación comparable', proposalNameLabel: 'Nombre de la propuesta', proposalCostLabel: 'Coste', proposalScoreLabel: 'Votos o puntuación de beneficio', addProposal: 'Añadir propuesta', removeProposal: 'Eliminar', calculateNote: 'La selección se actualiza mientras editas las filas. Cada propuesta se financia completa o queda fuera.', loadExample: 'Cargar ejemplo', printAction: 'Imprimir hoja de revisión', resultHeading: 'Mosaico presupuestario', emptyResult: 'Añade propuestas para ver qué conjunto completo cabe en el presupuesto.', excludedLabel: 'No financiada', spentLabel: 'Coste total', remainingLabel: 'Presupuesto restante', scoreLabel: 'Puntuación total', proposalCountLabel: 'propuestas', selectedStatus: 'Financiada', tooExpensiveStatus: 'No cabe', notSelectedStatus: 'Fuera', invalidStatus: 'Corregir', reasonLabel: 'Por qué', methodHeading: 'Método aplicado', methodText: 'La herramienta resuelve un modelo de mochila 0/1. Cada propuesta tiene un coste y una puntuación comparable. Busca combinaciones viables, maximiza la puntuación y después usa menor coste, menos propuestas y el orden de entrada como desempates deterministas.', limitsHeading: 'Lo que esta herramienta no hace', limitsText: 'No decide si una propuesta es justa, legal, elegible, ejecutable o socialmente preferible. No sustituye las reglas del presupuesto participativo ni una votación.', warningsHeading: 'Casos límite y avisos de datos', warningsText: 'Mantén comparables las puntuaciones y usa la misma base de costes. Los ceros, nombres duplicados, estimaciones incompletas, dependencias y beneficios divisibles requieren revisión humana.', noProposalsWarning: 'No se han introducido propuestas.', noFeasibleWarning: 'Ninguna propuesta cabe en el presupuesto disponible.', invalidBudget: 'Introduce un presupuesto no negativo. El modelo del navegador acepta hasta 20.000,00 en la moneda elegida.', budgetTooLarge: 'El presupuesto supera el límite del modelo de 20.000,00. Reduce el tope o divide el ejercicio.', invalidProposal: 'Cada fila necesita un nombre, un coste no negativo y una puntuación no negativa.', costExceedsBudget: 'Este coste supera el presupuesto disponible. La propuesta no puede seleccionarse.', tieBreakLabel: 'Regla determinista', budgetUsedLabel: 'usado', budgetLeftLabel: 'restante', selectedTilesLabel: 'Bloques seleccionados', allocationLabel: 'Capacidad presupuestaria', statusSaved: 'Borrador guardado localmente en este navegador.',
+};
+const faq = [
+  { question: '¿Qué optimiza este asignador?', answer: 'Elige un conjunto viable de propuestas completas que maximiza la puntuación total que introduces sin superar el tope. No decide si esa puntuación es justa o significativa.' },
+  { question: '¿Por qué las propuestas son todo o nada?', answer: 'La primera versión usa un modelo 0/1. Cada propuesta se financia por su coste completo o se excluye, algo adecuado para proyectos cuyo valor depende de ejecutarlos enteros.' },
+  { question: '¿Qué ocurre si dos asignaciones tienen la misma puntuación?', answer: 'Se elige primero el menor coste total, después menos propuestas y, por último, el orden de entrada más temprano. Así otra persona puede reproducir el desempate.' },
+  { question: '¿Puede este resultado decidir un presupuesto real?', answer: 'No. Es un escenario transparente. Comprueba elegibilidad, dependencias, capacidad de ejecución, base monetaria y proceso oficial.' },
+];
+const howTo = [
+  { name: 'Fija el tope', text: 'Introduce el importe disponible para esta ronda y mantén constante la base monetaria.' },
+  { name: 'Añade propuestas completas', text: 'Introduce cada propuesta una vez con su coste completo y una puntuación comparable.' },
+  { name: 'Inspecciona el mosaico', text: 'Revisa conjunto financiado, puntuación, coste y presupuesto restante mientras cambian las filas.' },
+  { name: 'Lee las exclusiones', text: 'Distingue las propuestas que no caben por sí solas de las que pierden frente a una combinación viable mejor.' },
+  { name: 'Aplica controles humanos', text: 'Compara el escenario con elegibilidad, dependencias, capacidad y reglas oficiales antes de usarlo en una reunión.' },
+];
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Asignador de presupuesto participativo', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', description: 'Selecciona propuestas públicas completas bajo un tope presupuestario con una regla de optimización transparente.', url: 'https://gamebob.dev/es/asignador-presupuesto-participativo', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+const faqSchema: FAQPage = { '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) };
+const howToSchema: HowTo = { '@type': 'HowTo', name: 'Asignar un presupuesto participativo limitado', step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })) };
+
+export const content: ParticipatoryBudgetLocaleContent = { slug: 'asignador-presupuesto-participativo', title: 'Asignador de presupuesto participativo', description: 'Selecciona propuestas completas bajo un presupuesto fijo, maximiza una puntuación declarada y entiende el coste y el motivo de cada exclusión.', ui, seo: [
+  { type: 'title', text: 'Convierte un tope presupuestario en un escenario reproducible', level: 2 },
+  { type: 'paragraph', html: 'En una ronda de presupuesto público suele haber más propuestas valiosas que dinero disponible. Este asignador hace explícito el intercambio: introduce el tope, añade propuestas completas y asigna a cada una votos o una puntuación de beneficio comparable. El resultado muestra un conjunto viable, no una recomendación opaca.' },
+  { type: 'title', text: 'Cómo se calcula la selección', level: 2 },
+  { type: 'paragraph', html: 'El modelo es una mochila 0/1. El navegador compara combinaciones que no superan el tope y conserva la de mayor puntuación total. Después aplica un desempate visible y determinista: menor coste, menos propuestas y orden de entrada. La puntuación es el objetivo que declaras, no una medida independiente del valor público.' },
+  { type: 'table', headers: ['Campo', 'Significado', 'Pregunta de revisión'], rows: [['Coste', 'Importe completo para entregar la propuesta', '¿Todas las filas usan la misma base?'], ['Puntuación', 'Votos o valor de beneficio aportado', '¿Se pueden comparar entre propuestas?'], ['Presupuesto', 'Coste total máximo de la selección', '¿El tope incluye los mismos costes que cada fila?'], ['Exclusión', 'No cabe por sí sola o pierde ante un conjunto mejor', '¿El motivo es matemático o necesita revisión política?']] },
+  { type: 'title', text: 'Prepara entradas que no engañen', level: 2 },
+  { type: 'list', items: ['Confirma que todas las propuestas son elegibles para la misma ronda.', 'Usa el coste completo o divide solo en fases realmente independientes.', 'Registra cómo se produjeron los votos o las puntuaciones.', 'Comprueba dependencias, mantenimiento, legalidad y capacidad por separado.', 'Guarda la selección y los motivos de exclusión como acta de revisión.'] },
+  { type: 'tip', title: 'Una puntuación es un objetivo elegido', html: 'Si representa votos, el resultado maximiza votos totales. Si representa beneficio, maximiza esa evaluación. Cambiar la puntuación cambia la pregunta, así que conserva el método junto al resultado.' },
+  { type: 'title', text: 'Lee los conjuntos financiado y excluido', level: 2 },
+  { type: 'paragraph', html: 'Las propuestas financiadas muestran coste total, puntuación y presupuesto restante. Una propuesta que no cabe cuesta más que el tope por sí sola. Una propuesta fuera podría caber sola, pero no forma parte de la mejor combinación bajo el objetivo y el desempate elegidos. Son conversaciones operativas distintas.' },
+  { type: 'title', text: 'Límites y siguientes comprobaciones', level: 2 },
+  { type: 'paragraph', html: 'El asignador no juzga la justicia entre barrios, el riesgo de ejecución, los conflictos entre proyectos ni la elegibilidad legal. Tampoco sabe si la puntuación representa necesidades ausentes. El modelo del navegador está limitado a 20.000,00 para mantener rápida la búsqueda exacta.' },
+  { type: 'paragraph', html: 'Una combinación con mucha puntuación solo es sólida si sus costes y la forma de obtener las puntuaciones también lo son.' },
+  { type: 'title', text: 'Usa el presupuesto restante para conversar', level: 2 },
+  { type: 'paragraph', html: 'Un sobrante puede indicar que ningún proyecto adicional mejora la selección actual. También puede señalar que falta una propuesta elegible o que se ha reservado dinero de forma intencionada.' },
+  { type: 'tip', title: 'Revisa antes de decidir', html: 'Lee la selección matemática junto con las reglas oficiales de participación y las voces de las personas afectadas.' },
+], faq, bibliography, howTo, schemas: [softwareApplication, faqSchema, howToSchema] as unknown as Record<string, unknown>[] };