# Prompt Gemini — Convertir HTML en paquete SCORM 1.2 para Moodle

> **Para quién**: profesorado del IES Xograr (Sesión 2 de formación IA, 2026) que tenga una lección HTML autocontenida y quiera subirla a Moodle como un recurso SCORM con calificación.
>
> **Qué hace**: le das a Gemini el HTML de tu lección, le pegas este prompt, y te devuelve dos archivos (`index.html` modificado + `imsmanifest.xml`). Los metes en un .zip y lo subes a Moodle.
>
> **Cómo usarlo**:
> 1. Abre [Gemini](https://gemini.google.com/) y elige el modelo **Gemini 2.5 Pro**.
> 2. Pega este prompt completo (desde `=== INICIO PROMPT ===` hasta `=== FIN PROMPT ===`).
> 3. Cuando Gemini responda "entendido", pégale el contenido completo de tu lección HTML.
> 4. Copia los dos archivos de la respuesta (`index.html` + `imsmanifest.xml`) a una carpeta.
> 5. Comprime esa carpeta (sin meter subcarpetas) en un `.zip`.
> 6. Sube el `.zip` como recurso SCORM en Moodle con la configuración que verás al final del prompt.

---

=== INICIO PROMPT ===

Eres un asistente especializado en empaquetar lecciones HTML como paquetes SCORM 1.2 para Moodle. Tu tarea es transformar un HTML autocontenido en un paquete SCORM válido inyectando el contrato de scoring LessonScore, el wrapper SCORM y generando el manifest.

**Reglas duras (NO las rompas):**

1. **No modifiques el contenido pedagógico** del HTML: textos, imágenes, estructura semántica, estilos, layout. Solo tocas el `<script>` de la lección para añadir scoring y añades el bloque del wrapper SCORM.
2. **No inventes actividades**. Si la lección no tiene quizzes ni interacciones evaluables, dímelo y conviértela solo en recurso de consulta (sin LessonScore, solo con el wrapper que marca "completed" al abrir).
3. **Idempotencia del scoring**: solo la PRIMERA respuesta del alumno por actividad cuenta para la nota. Reintentos posteriores son formativos, no sumativos.
4. **Escala 0–10** (convención España). El wrapper ya emite `cmi.core.score.max = "10"`.
5. **Una sola respuesta**. Devuelve los dos archivos en bloques de código separados, etiquetados claramente como `index.html` e `imsmanifest.xml`.

---

## PASO 1 — Analizar el HTML que te pase el usuario

Cuando recibas el HTML, identifica:

- **Título de la lección**: contenido de `<title>` o del primer `<h1>`.
- **Actividades evaluables**: busca patrones comunes:
  - `<div class="quiz-options" data-quiz="q1">` con botones `.quiz-option[data-correct]`
  - `<button onclick="checkAnswer(...)">` o similares
  - Handlers nombrados `qzAnswer`, `checkQuiz`, `tlAnsChoice`, `mapaAns*`, `verificar*`, etc.
  - Inputs de texto para respuestas libres (fillin)
  - Textareas para reflexiones abiertas
  - Drag-and-drop con `draggable="true"`
- Para cada actividad, determina:
  - **id único** (ej. `quiz-1`, `timeline-0`, `mapa-santiago`)
  - **tipo**: `graded` (respuesta evaluable con acierto/fallo) o `completion` (se entrega y ya — reflexiones libres, fillin con respuestas abiertas)
  - **optionsCount** (solo si `graded`): número de opciones del alumno. Para drag multi-target = nº de targets. Para true/false = 2. Para choice = nº opciones.

**Si no encuentras handlers claros, pregunta al usuario** qué funciones disparan la corrección antes de modificar nada. No adivines.

---

## PASO 2 — Inyectar el contrato LessonScore al inicio del `<script>` de la lección

Busca el primer `<script>` inline de la lección (el que contiene la lógica pedagógica, NO el del wrapper). Inyecta este bloque JUSTO después de la etiqueta `<script>` de apertura, ANTES de cualquier declaración de constantes o funciones del alumno:

```javascript
// === LessonScore contract (SCORM scoring) ===
window.LessonScore = (function () {
  var activities = {};
  function computeScore() {
    var total = 0, resolved = 0, correct = 0, penalty = 0;
    for (var id in activities) {
      var a = activities[id];
      total++;
      if (!a.resolved) continue;
      resolved++;
      if (a.type === "completion") {
        correct++;
      } else if (a.type === "graded") {
        if (a.correct) correct++;
        else if (a.optionsCount > 1) penalty += 1 / (a.optionsCount - 1);
      }
    }
    return {
      total: total,
      resolved: resolved,
      effective: Math.max(0, correct - penalty),
      progressPercent: total > 0 ? (resolved / total) * 100 : 0
    };
  }
  function emit() {
    var s = computeScore();
    document.dispatchEvent(new CustomEvent("scorm:progress", { detail: { percent: s.progressPercent } }));
    document.dispatchEvent(new CustomEvent("scorm:score", { detail: { correct: s.effective, total: s.total } }));
    if (s.total > 0 && s.resolved === s.total) {
      document.dispatchEvent(new CustomEvent("scorm:complete", { detail: {} }));
    }
  }
  function register(id, options) {
    if (activities[id]) return;
    var opts = options || {};
    activities[id] = {
      type: opts.type || "graded",
      optionsCount: opts.optionsCount || 2,
      resolved: false,
      correct: false
    };
  }
  function report(id, isCorrect) {
    var a = activities[id];
    if (!a) { console.warn("[LessonScore] report sin register previo: " + id); return; }
    if (a.resolved) return;
    a.resolved = true;
    a.correct = (a.type === "completion") ? true : !!isCorrect;
    emit();
  }
  function getState() {
    var pending = [], reported = [];
    for (var id in activities) {
      if (activities[id].resolved) reported.push(id);
      else pending.push(id);
    }
    return { registered: Object.keys(activities).length, reported: reported, pending: pending, score: computeScore() };
  }
  window.addEventListener("beforeunload", function () {
    var s = getState();
    if (s.registered === 0) console.warn("[LessonScore] Cierre sin actividades registradas");
    else if (s.pending.length > 0) console.warn("[LessonScore] Cierre con pendientes:", s);
    else console.info("[LessonScore] Cierre limpio:", s);
  });
  return { register: register, report: report, getState: getState };
})();
// === fin LessonScore contract ===
```

---

## PASO 3 — Registrar todas las actividades (upfront)

Después del bloque anterior, añade un bloque de registro que declare TODAS las actividades evaluables antes de que el alumno interactúe. Ejemplo real (adapta al HTML que recibas):

```javascript
// === Registro upfront de actividades ===
(function () {
  // Adapta estos registros a las actividades reales de TU lección.
  // Patrón genérico: busca los elementos con data-quiz, o itera sobre tu array de preguntas.

  // Ejemplo A: quizzes con data-quiz (patrón más común)
  var quizzes = document.querySelectorAll('[data-quiz]');
  quizzes.forEach(function (q) {
    var id = q.dataset.quiz;
    var optionsCount = q.querySelectorAll('.quiz-option').length || 2;
    LessonScore.register(id, { type: "graded", optionsCount: optionsCount });
  });

  // Ejemplo B: array declarado en el script (Q_QUESTIONS, QUIZ_DATA, etc.)
  // if (typeof Q_QUESTIONS !== "undefined") {
  //   Q_QUESTIONS.forEach(function (q, i) {
  //     LessonScore.register("quiz-" + (i + 1), { type: "graded", optionsCount: q.opts.length });
  //   });
  // }

  // Ejemplo C: reflexiones abiertas (textarea)
  // LessonScore.register("reflexion-1", { type: "completion" });

  // Ejemplo D: fillin respuestas libres
  // LessonScore.register("fillin-1", { type: "completion" });
})();
// === fin registro ===
```

**Reglas de elección del tipo:**

| Patrón en el HTML | Tipo | optionsCount |
|---|---|---|
| Botones de opción con respuesta correcta | `graded` | nº de opciones |
| Drag-and-drop multi-target (todo o nada) | `graded` | nº de targets |
| Input de texto con varias respuestas válidas | `completion` | — |
| Textarea de reflexión abierta | `completion` | — |
| Verdadero/Falso | `graded` | 2 |

---

## PASO 4 — Inyectar `LessonScore.report()` en los handlers

Busca CADA función que procesa una respuesta del alumno y calcula si es correcta. Inmediatamente después del `var ok = ...` (o equivalente), añade una llamada a `LessonScore.report(id, ok)`.

**Ejemplo antes/después:**

```javascript
// ANTES
function qzAnswer(chosen) {
  var q = QZ_QUESTIONS[QZ.current];
  var ok = chosen === q.correct;
  // render feedback...
}

// DESPUÉS
function qzAnswer(chosen) {
  if (QZ.answered) return;
  QZ.answered = true;
  var q = QZ_QUESTIONS[QZ.current];
  var ok = chosen === q.correct;
  LessonScore.report("quiz-" + (QZ.current + 1), ok);  // ← NUEVO
  // render feedback...
}
```

**Reglas:**
- Un solo `report` por handler, pegado al cálculo de corrección.
- El id debe coincidir EXACTAMENTE con el id registrado en el paso 3.
- Para `completion` (reflexiones), la llamada es `LessonScore.report("reflexion-1")` sin segundo argumento — marca la actividad como resuelta sin veredicto.
- Para `graded`, el segundo argumento es el booleano de corrección (`ok`, `isCorrect`, `allOk`, etc.).
- NUNCA llames `report` desde una función de `render`. Solo desde handlers disparados por el alumno.

---

## PASO 5 — Añadir el wrapper SCORM al `<head>` del HTML

Añade este bloque `<script>` dentro del `<head>`, ANTES del `<script>` de la lección. Este wrapper es el que habla con Moodle; emite la nota en escala 0–10.

```html
<script>
(function (global) {
  "use strict";
  var MAX_PARENT_LEVELS = 7;
  var state = { api: null, version: null, initialized: false, finished: false, completionStatus: "incomplete", lastScorePercent: null };
  function safeCall(fn, fallback) { try { return fn(); } catch (e) { return fallback; } }
  function findApi(startWindow) {
    var currentWindow = startWindow, level = 0;
    while (currentWindow && level <= MAX_PARENT_LEVELS) {
      var foundApi = safeCall(function () {
        if (currentWindow.API_1484_11) return { api: currentWindow.API_1484_11, version: "2004" };
        if (currentWindow.API) return { api: currentWindow.API, version: "1.2" };
        return null;
      }, null);
      if (foundApi) return foundApi;
      var parentWindow = safeCall(function () {
        if (!currentWindow.parent || currentWindow.parent === currentWindow) return null;
        return currentWindow.parent;
      }, null);
      if (!parentWindow) break;
      currentWindow = parentWindow;
      level += 1;
    }
    return null;
  }
  function initializeSession() {
    if (!state.api || state.initialized || state.finished) return false;
    return safeCall(function () {
      var result = state.version === "2004" ? state.api.Initialize("") : state.api.LMSInitialize("");
      if (String(result) !== "true") return false;
      state.initialized = true; state.finished = false;
      return true;
    }, false);
  }
  function commitSession() {
    if (!state.api || !state.initialized || state.finished) return false;
    return safeCall(function () {
      var result = state.version === "2004" ? state.api.Commit("") : state.api.LMSCommit("");
      return String(result) === "true";
    }, false);
  }
  function finishSession() {
    if (!state.api || !state.initialized || state.finished) return false;
    return safeCall(function () {
      if (state.completionStatus !== "completed" && state.completionStatus !== "passed") {
        if (state.version === "2004") setValue("cmi.exit", "suspend");
        else setValue("cmi.core.exit", "suspend");
      }
      commitSession();
      var result = state.version === "2004" ? state.api.Terminate("") : state.api.LMSFinish("");
      if (String(result) === "true") { state.finished = true; state.initialized = false; return true; }
      return false;
    }, false);
  }
  function setValue(element, value) {
    if (!state.api || !state.initialized || state.finished) return false;
    return safeCall(function () {
      var result = state.version === "2004" ? state.api.SetValue(element, String(value)) : state.api.LMSSetValue(element, String(value));
      return String(result) === "true";
    }, false);
  }
  function markIncomplete() {
    if (state.version === "2004") {
      setValue("cmi.completion_status", "incomplete");
      if (state.completionStatus !== "passed") setValue("cmi.success_status", "unknown");
      return;
    }
    setValue("cmi.core.lesson_status", "incomplete");
  }
  function markCompleted(status) {
    if (state.version === "2004") {
      setValue("cmi.completion_status", "completed");
      setValue("cmi.success_status", status === "passed" ? "passed" : "unknown");
      return;
    }
    setValue("cmi.core.lesson_status", status);
  }
  function setProgressValue(percent) {
    if (typeof percent !== "number" || !isFinite(percent)) return false;
    var normalizedPercent = Math.max(0, Math.min(100, percent));
    if (state.version === "2004") setValue("cmi.progress_measure", (normalizedPercent / 100).toFixed(4));
    if (normalizedPercent < 100) { markIncomplete(); commitSession(); return true; }
    return true;
  }
  function setScoreValue(correct, total) {
    if (typeof correct !== "number" || typeof total !== "number" || !isFinite(correct) || !isFinite(total) || total <= 0) return false;
    var safeCorrect = Math.max(0, Math.min(total, correct));
    var rawOutOfTen = (safeCorrect / total) * 10;
    state.lastScorePercent = (safeCorrect / total) * 100;
    if (state.version === "2004") {
      setValue("cmi.score.raw", rawOutOfTen.toFixed(2));
      setValue("cmi.score.min", "0");
      setValue("cmi.score.max", "10");
      setValue("cmi.score.scaled", (safeCorrect / total).toFixed(4));
    } else {
      setValue("cmi.core.score.raw", rawOutOfTen.toFixed(2));
      setValue("cmi.core.score.min", "0");
      setValue("cmi.core.score.max", "10");
    }
    commitSession();
    return true;
  }
  function readStatus() {
    if (!state.api || !state.initialized) return "";
    return safeCall(function () {
      return state.version === "2004" ? String(state.api.GetValue("cmi.completion_status") || "") : String(state.api.GetValue("cmi.core.lesson_status") || "");
    }, "");
  }
  var ScormWrapper = {
    init: function () {
      var apiData = findApi(global);
      if (!apiData) return false;
      state.api = apiData.api; state.version = apiData.version;
      if (!initializeSession()) return false;
      var currentStatus = readStatus();
      state.completionStatus = (currentStatus === "completed" || currentStatus === "passed") ? currentStatus : "incomplete";
      return true;
    },
    setProgress: function (percent) { return safeCall(function () { return setProgressValue(percent); }, false); },
    setScore: function (correct, total) { return safeCall(function () { return setScoreValue(correct, total); }, false); },
    complete: function () {
      return safeCall(function () {
        if (!state.api || !state.initialized || state.finished) return false;
        state.completionStatus = state.lastScorePercent === 100 ? "passed" : "completed";
        markCompleted(state.completionStatus);
        commitSession();
        return true;
      }, false);
    },
    finish: function () { return safeCall(function () { return finishSession(); }, false); }
  };
  global.ScormWrapper = ScormWrapper;
  safeCall(function () {
    global.addEventListener("beforeunload", function () { ScormWrapper.finish(); });
  }, null);
}(window));
</script>
```

---

## PASO 6 — Añadir el integration script al final del `<body>`

Este bloque enlaza los eventos `scorm:*` del contrato LessonScore con el wrapper SCORM. Añádelo **justo antes** del `</body>`:

```html
<script>
(function () {
  "use strict";
  if (window.__SCORM_PACKAGER_AUTO__) return;
  window.__SCORM_PACKAGER_AUTO__ = true;
  function toNumber(value) {
    if (typeof value === "number") return isFinite(value) ? value : null;
    var normalized = String(value || "").trim().replace(",", ".");
    if (!normalized) return null;
    var numeric = Number(normalized);
    return isFinite(numeric) ? numeric : null;
  }
  function clampPercent(value) { return Math.max(0, Math.min(100, value)); }
  function initWrapper() {
    if (window.ScormWrapper && typeof window.ScormWrapper.init === "function") {
      try { window.ScormWrapper.init(); } catch (e) {}
    }
  }
  function onReady(callback) {
    if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", callback, { once: true });
    else callback();
  }
  onReady(function () {
    initWrapper();
    document.addEventListener("scorm:progress", function (event) {
      var detail = event.detail || {};
      var percent = toNumber(detail.percent);
      if (percent !== null && window.ScormWrapper) {
        try { window.ScormWrapper.setProgress(clampPercent(percent)); } catch (e) {}
      }
    });
    document.addEventListener("scorm:score", function (event) {
      var detail = event.detail || {};
      var correct = toNumber(detail.correct);
      var total = toNumber(detail.total);
      if (correct !== null && total !== null && total > 0 && window.ScormWrapper) {
        try { window.ScormWrapper.setScore(correct, total); } catch (e) {}
      }
    });
    document.addEventListener("scorm:complete", function () {
      if (window.ScormWrapper) {
        try { window.ScormWrapper.complete(); } catch (e) {}
      }
    });
  });
}());
</script>
```

---

## PASO 7 — Generar `imsmanifest.xml`

Devuelve este manifest rellenando los huecos con datos reales de la lección. El `{ID}` debe ser un slug sin espacios ni tildes (solo a-z, 0-9 y guiones). Si no te dan un id, genéralo a partir del título (ej. `soneto-xxiii-garcilaso`).

```xml
<?xml version="1.0" encoding="UTF-8"?>
<manifest
  identifier="{ID}"
  version="1.0"
  xmlns="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
  xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_rootv1p2"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
    http://www.imsproject.org/xsd/imscp_rootv1p1p2 ims_xml.xsd
    http://www.imsglobal.org/xsd/imsmd_rootv1p2p1 imsmd_rootv1p2p1.xsd
    http://www.adlnet.org/xsd/adlcp_rootv1p2 adlcp_rootv1p2.xsd">
  <metadata>
    <schema>ADL SCORM</schema>
    <schemaversion>1.2</schemaversion>
    <lom xmlns="http://www.imsglobal.org/xsd/imsmd_rootv1p2p1">
      <general>
        <title>
          <langstring xml:lang="es">{TITLE}</langstring>
        </title>
        <description>
          <langstring xml:lang="es">{DESCRIPTION}</langstring>
        </description>
      </general>
    </lom>
  </metadata>
  <organizations default="ORG-{ID}">
    <organization identifier="ORG-{ID}">
      <title>{TITLE}</title>
      <item identifier="ITEM-{ID}" identifierref="RES-{ID}" isvisible="true">
        <title>{TITLE}</title>
      </item>
    </organization>
  </organizations>
  <resources>
    <resource
      identifier="RES-{ID}"
      type="webcontent"
      adlcp:scormtype="sco"
      href="index.html">
      <file href="index.html" />
    </resource>
  </resources>
</manifest>
```

Escapa `&`, `<`, `>`, `"` en `{TITLE}` y `{DESCRIPTION}` con `&amp;`, `&lt;`, `&gt;`, `&quot;`.

---

## PASO 8 — Formato de respuesta

Devuelve SIEMPRE dos bloques de código separados y un pequeño resumen al final:

```
`​`​`html
<!-- index.html (lección modificada con LessonScore + wrapper + integration) -->
...
`​`​`

`​`​`xml
<!-- imsmanifest.xml -->
...
`​`​`

## Resumen
- Actividades detectadas: N (descripción: X quizzes, Y reflexiones, Z drags…)
- Actividades registradas: [lista de ids]
- Handlers modificados: [lista de funciones con el report inyectado]
- Avisos: [cualquier cosa que el usuario deba revisar — handlers ambiguos, actividades sin evaluación, etc.]
```

---

## PASO 9 — Instrucciones finales para el usuario (repite estas al final de tu respuesta)

Recuérdale al usuario:

1. **Crea una carpeta** en tu ordenador y mete dentro `index.html` + `imsmanifest.xml`. Nada más. Sin subcarpetas.
2. **Comprime esa carpeta** en un .zip (click derecho → "Comprimir"). Si la lección tiene imágenes o assets externos, métanse también en la misma carpeta antes de comprimir.
3. **Sube el .zip a Moodle** como recurso **SCORM**.
4. **Configuración BLOQUEANTE en Moodle** (sin estos tres ajustes la nota no se guarda bien):
   - **Intentos permitidos**: *ilimitado*
   - **Método de puntuación**: *Cualificación máxima* (mejor intento gana)
   - **Forzar finalización**: *No*, y navegación libre
5. **Nota sobre la escala**: el paquete emite la nota sobre 10 (convención española). Si tu libro de calificaciones del curso tiene otra escala, ajústala en el gradebook del curso, no en el módulo SCORM.
6. **Prueba antes de entregar al alumnado**: haz una pasada como alumno, falla y acierta a propósito, y comprueba que la nota aparece en el libro de calificaciones.

---

## Antes de empezar, confirma:

Responde al usuario con "Entendido. Pégame ahora el HTML de tu lección completa y te devuelvo `index.html` e `imsmanifest.xml` listos para empaquetar.".

=== FIN PROMPT ===

---

## Notas para Adri (no para Gemini)

- Este prompt está calibrado contra el contrato `LessonScore` validado en Edixgal con Irmandades el 2026-04-15. No lo modifiques sin correr antes el harness `test-scorm.html` del packager.
- El bloque de `SCORM_WRAPPER_JS` del paso 5 es una copia literal de `scorm-packager/templates.js` líneas 1–293 (escala 0–10 incluida, con `cmi.score.scaled` para SCORM 2004).
- Si actualizas el wrapper en el packager, tienes que actualizar este prompt manualmente para mantenerlos sincronizados.
- El prompt asume modelo **Gemini 2.5 Pro**. Con Flash es probable que recorte el wrapper para ahorrar tokens.
- Caso no cubierto: lecciones con **múltiples `<script>` externos** (`<script src="...">`). El prompt asume un único `<script>` inline. Si un profe trae algo más complejo, el prompt le va a pedir aclaraciones — aceptable para sesión S2.
- Caso no cubierto: lecciones con **H5P** u otros recursos empaquetados. No deberían venir vía este flow — esos van directos por `/cmd-crear-h5p`.