@lxpack/scorm 0.1.1 → 0.2.1

package/README.md

@@ -5,15 +5,16 @@
 [![License](https://img.shields.io/github/license/eddiethedean/lxpack)](https://github.com/eddiethedean/lxpack/blob/main/LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org/)
 
-SCORM 1.2 and standalone HTML export for LXPack courses.
+SCORM 1.2, SCORM 2004 (multi-SCO), and standalone HTML export for LXPack courses.
 
-Part of [LXPack](https://github.com/eddiethedean/lxpack) — an AI-native learning experience compiler and runtime.
+Part of [LXPack](https://github.com/eddiethedean/lxpack) — an AI-native learning experience compiler and runtime (**v0.2.0**).
 
 | Related | Package |
 |---------|---------|
 | CLI | [`@lxpack/cli`](../cli/README.md) |
 | Manifest validation | [`@lxpack/validators`](../validators/README.md) |
 | Embedded client | [`@lxpack/runtime`](../runtime/README.md) |
+| Components bundle | [`@lxpack/components`](../components/README.md) |
 
 ## Install
 
@@ -25,6 +26,8 @@ Requires Node.js 20+.
 
 ## Usage
 
+### SCORM 1.2 or standalone ZIP
+
 ```ts
 import { readFile } from "node:fs/promises";
 import type { CourseManifest } from "@lxpack/validators";
@@ -44,6 +47,7 @@ const assessmentBundle = await buildRuntimeAssessmentBundle(courseDir, manifest)
 
 const runtimeClientJs = await readFile("path/to/client.js", "utf8");
 const runtimeCss = await readFile("path/to/styles.css", "utf8");
+const componentsJs = await readFile("path/to/bundle.js", "utf8"); // optional
 
 await packageCourse({
   courseDir,
@@ -52,10 +56,31 @@ await packageCourse({
   outputPath: "/path/to/output/course-scorm12.zip",
   runtimeClientJs,
   runtimeCss,
+  componentsJs,
+  assessmentBundle,
+});
+```
+
+### SCORM 2004 multi-SCO
+
+```ts
+import { packageScorm2004, buildScoIndexHtml, listCourseActivities } from "@lxpack/scorm";
+
+const activities = listCourseActivities(manifest);
+
+await packageScorm2004({
+  courseDir,
+  manifest,
+  outputPath: "/path/to/output/course-scorm2004.zip",
+  runtimeClientJs,
+  runtimeCss,
+  componentsJs,
   assessmentBundle,
 });
 ```
 
+Each activity gets `sco/<activityId>/index.html` (via `buildScoIndexHtml`). Shared assets include `lxpack-runtime.js` and `lxpack-components.js`. `generateScorm2004Manifest` emits `imsmanifest.xml` with IMS Simple Sequencing metadata.
+
 ### Standalone directory
 
 ```ts
@@ -66,6 +91,7 @@ await packageStandaloneDir({
   outputDir: "/path/to/output/standalone",
   runtimeClientJs,
   runtimeCss,
+  componentsJs,
   assessmentBundle,
 });
 ```
@@ -77,16 +103,21 @@ Most users should use `lxpack build` from [`@lxpack/cli`](../cli/README.md) inst
 | Export | Description |
 |--------|-------------|
 | `packageCourse(options)` | Build a SCORM 1.2 or standalone ZIP |
-| `packageStandaloneDir(options)` | Write an unpacked directory (ZIP or SCORM layout) |
+| `packageScorm2004(options)` | Build a SCORM 2004 multi-SCO ZIP |
+| `packageStandaloneDir(options)` | Write an unpacked directory |
+| `listCourseActivities(manifest)` | Ordered activities for multi-SCO layout |
 | `generateImsManifest(manifest, files)` | SCORM 1.2 `imsmanifest.xml` |
-| `buildIndexHtml(options)` | Course shell HTML with embedded config |
+| `generateScorm2004Manifest(...)` | SCORM 2004 manifest with sequencing |
+| `buildIndexHtml(options)` | Single-SCO course shell HTML |
+| `buildScoIndexHtml(options)` | Per-activity launch HTML for SCORM 2004 |
+| `scoLaunchPath(activityId)` | Relative launch path (`sco/<id>/index.html`) |
 | `buildRuntimeConfig(options)` | Config object passed to `safeJsonForHtml` |
 | `collectFiles(courseDir, baseDir)` | Course assets for packaging (respects skip rules) |
 | `shouldSkipCourseFile(rel)` | Whether a relative path is omitted from exports |
 | `buildManifestFileList(courseFiles)` | File list for `imsmanifest.xml` |
 | `safeJsonForHtml(value)` | JSON safe for `<script type="application/json">` blocks |
 | `courseSlug(manifest)` | Stable slug for ZIP names and manifest identifiers |
-| `ExportTarget` | `"scorm12"` \| `"standalone"` |
+| `ExportTarget` | `"scorm12"` \| `"scorm2004"` \| `"standalone"` |
 
 ### `PackageOptions`
 
@@ -94,28 +125,30 @@ Most users should use `lxpack build` from [`@lxpack/cli`](../cli/README.md) inst
 |-------|-------------|
 | `courseDir` | Course root directory |
 | `manifest` | Parsed `course.yaml` |
-| `outputPath` | Destination ZIP path (`packageCourse`) |
-| `target` | `scorm12` or `standalone` |
+| `outputPath` | Destination ZIP path |
+| `target` | `scorm12`, `scorm2004`, or `standalone` |
 | `runtimeClientJs` | Contents of `@lxpack/runtime/client` bundle |
 | `runtimeCss` | Runtime stylesheet |
-| `assessmentBundle` | Optional; from `buildRuntimeAssessmentBundle()` |
+| `componentsJs` | Optional `@lxpack/components/bundle` for component lessons |
+| `assessmentBundle` | From `buildRuntimeAssessmentBundle()` (assessments, keys, configs, feedback) |
 
 ## What gets packaged
 
 **Included**
 
-- Lessons, interactions, and assets referenced by the manifest
-- `index.html` — shell with embedded manifest + assessment config
+- Lessons, interactions, assets, and component overrides referenced by the manifest
 - `lxpack-runtime.js` — browser client bundle
-- `imsmanifest.xml` — SCORM 1.2 target only
+- `lxpack-components.js` — when component lessons are used
+- **SCORM 1.2 / standalone:** root `index.html` with embedded config
+- **SCORM 2004:** `sco/<activityId>/index.html` per activity + `imsmanifest.xml`
 
 **Excluded** (`shouldSkipCourseFile`)
 
 - `course.yaml`, `lxpack.config.json`, `.lxpack/`
 - `assessments/**` — author YAML; assessments are embedded in config instead
-- Root `index.html` if present (packager generates the entry page)
+- Root `index.html` if present (packager generates entry pages)
 
-Answer keys are only present inside the JSON config block (with `<` escaped via `safeJsonForHtml`), not as downloadable files.
+Answer keys and feedback text are only present inside the JSON config block (with `<` escaped via `safeJsonForHtml`), not as downloadable files.
 
 ## Development
 
@@ -130,6 +163,8 @@ pnpm --filter @lxpack/scorm typecheck
 ## Links
 
 - [LXPack repository](https://github.com/eddiethedean/lxpack)
+- [Documentation index](https://github.com/eddiethedean/lxpack/blob/main/docs/README.md)
+- [Roadmap & phases](https://github.com/eddiethedean/lxpack/blob/main/docs/ROADMAP.md)
 - [Changelog](https://github.com/eddiethedean/lxpack/blob/main/CHANGELOG.md)
 
 ## License

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { CourseManifest, RuntimeAssessmentBundle } from '@lxpack/validators';
+export { CourseActivity, enumerateActivities as listCourseActivities } from '@lxpack/validators';
 
 declare function manifestIdentifier(manifest: CourseManifest): string;
 declare function generateImsManifest(manifest: CourseManifest, files: string[], launchUrl?: string): string;
@@ -6,19 +7,27 @@ declare function generateImsManifest(manifest: CourseManifest, files: string[],
 interface BuildHtmlOptions {
     manifest: CourseManifest;
     runtimeCss: string;
-    mode: "standalone" | "scorm12";
+    mode: "standalone" | "scorm12" | "scorm2004";
+    activityId?: string;
     assessmentBundle?: RuntimeAssessmentBundle;
+    componentsScript?: string;
 }
-declare function buildRuntimeConfig(options: BuildHtmlOptions): {
-    manifest: CourseManifest;
-    baseUrl: string;
-    mode: BuildHtmlOptions["mode"];
-    assessments?: RuntimeAssessmentBundle["assessments"];
-    answerKeys?: RuntimeAssessmentBundle["answerKeys"];
-};
+declare function buildRuntimeConfig(options: BuildHtmlOptions): Record<string, unknown>;
+declare function buildScoIndexHtml(options: BuildHtmlOptions & {
+    activityId: string;
+}): string;
 declare function buildIndexHtml(options: BuildHtmlOptions): string;
 
-type ExportTarget = "scorm12" | "standalone";
+interface PageTemplateOptions {
+    title: string;
+    runtimeCss: string;
+    configJson: string;
+    runtimeScript: string;
+    componentsScript?: string;
+}
+declare function buildLearnerPageHtml(options: PageTemplateOptions): string;
+
+type ExportTarget = "scorm12" | "scorm2004" | "standalone";
 interface PackageOptions {
     courseDir: string;
     manifest: CourseManifest;
@@ -26,6 +35,7 @@ interface PackageOptions {
     target: ExportTarget;
     runtimeClientJs: string;
     runtimeCss: string;
+    componentsBundleJs?: string;
     assessmentBundle?: RuntimeAssessmentBundle;
 }
 declare function shouldSkipCourseFile(rel: string): boolean;
@@ -36,6 +46,22 @@ declare function collectFiles(dir: string, baseDir: string): Promise<Array<{
 declare function buildManifestFileList(courseFiles: Array<{
     path: string;
 }>): string[];
+interface PackageSink {
+    writeFile(relPath: string, content: string | Buffer): Promise<void>;
+}
+declare function assemblePackage(options: Omit<PackageOptions, "outputPath">, sink: PackageSink): Promise<{
+    fileCount: number;
+}>;
+declare function packageScorm2004(options: PackageOptions): Promise<{
+    outputPath: string;
+    fileCount: number;
+}>;
+declare function packageScorm2004Dir(options: Omit<PackageOptions, "outputPath"> & {
+    outputDir: string;
+}): Promise<{
+    outputDir: string;
+    fileCount: number;
+}>;
 declare function packageCourse(options: PackageOptions): Promise<{
     outputPath: string;
     fileCount: number;
@@ -47,10 +73,19 @@ declare function packageStandaloneDir(options: Omit<PackageOptions, "outputPath"
     fileCount: number;
 }>;
 
+/** Omit embedded quiz data from lesson SCOs; limit assessment SCOs to one quiz. */
+declare function sliceAssessmentBundleForActivity(bundle: RuntimeAssessmentBundle, activityId: string, activityKind: "lesson" | "assessment"): RuntimeAssessmentBundle;
+
 /** JSON safe to embed in HTML script blocks (prevents `</script>` breakout). */
 declare function safeJsonForHtml(value: unknown): string;
 
 /** Stable slug for ZIP filenames and SCORM identifiers. */
 declare function courseSlug(manifest: CourseManifest): string;
 
-export { type BuildHtmlOptions, type ExportTarget, type PackageOptions, buildIndexHtml, buildManifestFileList, buildRuntimeConfig, collectFiles, courseSlug, generateImsManifest, manifestIdentifier, packageCourse, packageStandaloneDir, safeJsonForHtml, shouldSkipCourseFile };
+declare function scoLaunchPath(activityId: string): string;
+declare function buildScorm2004ManifestFiles(manifest: CourseManifest, courseFiles: string[], hasComponentsBundle?: boolean): string[];
+declare function generateScorm2004Manifest(manifest: CourseManifest, courseFiles: string[], options?: {
+    hasComponentsBundle?: boolean;
+}): string;
+
+export { type BuildHtmlOptions, type ExportTarget, type PackageOptions, type PackageSink, type PageTemplateOptions, assemblePackage, buildIndexHtml, buildLearnerPageHtml, buildManifestFileList, buildRuntimeConfig, buildScoIndexHtml, buildScorm2004ManifestFiles, collectFiles, courseSlug, generateImsManifest, generateScorm2004Manifest, manifestIdentifier, packageCourse, packageScorm2004, packageScorm2004Dir, packageStandaloneDir, safeJsonForHtml, scoLaunchPath, shouldSkipCourseFile, sliceAssessmentBundleForActivity };

package/dist/index.js

@@ -57,49 +57,183 @@ function safeJsonForHtml(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c");
 }
 
-// src/build-html.ts
-function buildRuntimeConfig(options) {
-  const { manifest, mode, assessmentBundle } = options;
-  return {
-    manifest,
-    baseUrl: ".",
-    mode,
-    ...assessmentBundle ? {
-      assessments: assessmentBundle.assessments,
-      answerKeys: assessmentBundle.answerKeys
-    } : {}
-  };
-}
-function buildIndexHtml(options) {
-  const { manifest, runtimeCss } = options;
-  const config = safeJsonForHtml(buildRuntimeConfig(options));
+// src/page-template.ts
+import { escapeHtml } from "@lxpack/validators";
+function buildLearnerPageHtml(options) {
+  const componentsTag = options.componentsScript ? `<script type="module" src="${escapeHtml(options.componentsScript)}"></script>` : "";
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${escapeHtml(manifest.title)}</title>
-  <style>${runtimeCss}</style>
+  <title>${escapeHtml(options.title)}</title>
+  <style>${options.runtimeCss}</style>
 </head>
 <body>
   <div id="lxpack-app"></div>
-  <script type="application/json" id="lxpack-config">${config}</script>
+  <script type="application/json" id="lxpack-config">${options.configJson}</script>
   <script>
     window.__LXPACK_CONFIG__ = JSON.parse(document.getElementById('lxpack-config').textContent);
   </script>
-  <script type="module" src="./lxpack-runtime.js"></script>
+  ${componentsTag}
+  <script type="module" src="${escapeHtml(options.runtimeScript)}"></script>
 </body>
 </html>`;
 }
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+
+// src/build-html.ts
+function buildRuntimeConfig(options) {
+  const { manifest, mode, assessmentBundle, activityId } = options;
+  return {
+    manifest,
+    baseUrl: activityId ? "../.." : ".",
+    mode,
+    ...activityId ? { activityId } : {},
+    ...assessmentBundle ? {
+      ...Object.keys(assessmentBundle.assessments).length ? { assessments: assessmentBundle.assessments } : {},
+      ...Object.keys(assessmentBundle.answerKeys).length ? { answerKeys: assessmentBundle.answerKeys } : {},
+      ...Object.keys(assessmentBundle.configs ?? {}).length ? { assessmentConfigs: assessmentBundle.configs } : {},
+      ...Object.keys(assessmentBundle.feedback ?? {}).length ? { assessmentFeedback: assessmentBundle.feedback } : {}
+    } : {}
+  };
+}
+function buildScoIndexHtml(options) {
+  const { manifest, runtimeCss, activityId, componentsScript } = options;
+  const config = safeJsonForHtml(buildRuntimeConfig({ ...options, activityId }));
+  return buildLearnerPageHtml({
+    title: `${manifest.title} \u2014 ${activityId}`,
+    runtimeCss,
+    configJson: config,
+    runtimeScript: "../../lxpack-runtime.js",
+    componentsScript
+  });
+}
+function buildIndexHtml(options) {
+  const { manifest, runtimeCss, componentsScript } = options;
+  const config = safeJsonForHtml(buildRuntimeConfig(options));
+  return buildLearnerPageHtml({
+    title: manifest.title,
+    runtimeCss,
+    configJson: config,
+    runtimeScript: "./lxpack-runtime.js",
+    componentsScript
+  });
 }
 
 // src/package.ts
-import { readFile, readdir, writeFile, mkdir, cp } from "fs/promises";
+import { readFile, readdir, writeFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 import { dirname, join, relative } from "path";
 import JSZip from "jszip";
+
+// src/assessment-slice.ts
+function sliceAssessmentBundleForActivity(bundle, activityId, activityKind) {
+  if (activityKind === "assessment") {
+    const assessment = bundle.assessments[activityId];
+    if (!assessment) {
+      return { assessments: {}, answerKeys: {}, configs: {}, feedback: {} };
+    }
+    return {
+      assessments: { [activityId]: assessment },
+      answerKeys: bundle.answerKeys[activityId] ? { [activityId]: bundle.answerKeys[activityId] } : {},
+      configs: bundle.configs[activityId] ? { [activityId]: bundle.configs[activityId] } : {},
+      feedback: bundle.feedback[activityId] ? { [activityId]: bundle.feedback[activityId] } : {}
+    };
+  }
+  return {
+    assessments: {},
+    answerKeys: {},
+    configs: {},
+    feedback: {}
+  };
+}
+
+// src/activities.ts
+import {
+  enumerateActivities
+} from "@lxpack/validators";
+
+// src/scorm2004-manifest.ts
+function escapeXml2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function scoLaunchPath(activityId) {
+  return `sco/${activityId}/index.html`;
+}
+function buildScorm2004ManifestFiles(manifest, courseFiles, hasComponentsBundle = false) {
+  const activities = enumerateActivities(manifest);
+  const scoFiles = activities.map((a) => scoLaunchPath(a.id));
+  return [
+    "lxpack-runtime.js",
+    ...hasComponentsBundle ? ["lxpack-components.js"] : [],
+    ...scoFiles,
+    ...courseFiles
+  ];
+}
+function generateScorm2004Manifest(manifest, courseFiles, options) {
+  const hasComponentsBundle = options?.hasComponentsBundle ?? false;
+  const identifier = manifestIdentifier(manifest);
+  const orgId = `${identifier}-org`;
+  const activities = enumerateActivities(manifest);
+  const itemEntries = activities.map((activity) => {
+    const itemId = `item_${activity.id}`;
+    const resourceId = `res_${activity.id}`;
+    const sequencing = activity.kind === "assessment" ? `
+        <imsss:sequencing>
+          <imsss:deliveryControls tracked="true" completionSetByContent="true" objectiveSetByContent="true"/>
+        </imsss:sequencing>` : `
+        <imsss:sequencing>
+          <imsss:deliveryControls tracked="true" completionSetByContent="true"/>
+        </imsss:sequencing>`;
+    return `      <item identifier="${escapeXml2(itemId)}" identifierref="${escapeXml2(resourceId)}">
+        <title>${escapeXml2(activity.title)}</title>${sequencing}
+      </item>`;
+  }).join("\n");
+  const resources = activities.map((activity) => {
+    const resourceId = `res_${activity.id}`;
+    const href = scoLaunchPath(activity.id);
+    const componentFile = hasComponentsBundle ? `
+      <file href="lxpack-components.js"/>` : "";
+    return `    <resource identifier="${escapeXml2(resourceId)}" type="webcontent" adlcp:scormType="sco" href="${escapeXml2(href)}">
+      <file href="${escapeXml2(href)}"/>
+      <file href="lxpack-runtime.js"/>${componentFile}
+    </resource>`;
+  }).join("\n");
+  const orgSequencing = `
+    <imsss:sequencing>
+      <imsss:controlMode choice="true" flow="true"/>
+    </imsss:sequencing>`;
+  const uniqueCourseFiles = [...new Set(courseFiles)].filter((f) => !f.startsWith("sco/")).map(
+    (href) => `      <file href="${escapeXml2(href)}"/>`
+  ).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="${escapeXml2(identifier)}" version="${escapeXml2(manifest.version)}"
+  xmlns="http://www.imsglobal.org/xsd/imscp_v1p1"
+  xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_v1p3"
+  xmlns:adlseq="http://www.adlnet.org/xsd/adlseq_v1p3"
+  xmlns:imsss="http://www.imsglobal.org/xsd/imsss"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <metadata>
+    <schema>ADL SCORM</schema>
+    <schemaversion>2004 4th Edition</schemaversion>
+  </metadata>
+  <organizations default="${escapeXml2(orgId)}">
+    <organization identifier="${escapeXml2(orgId)}">
+      <title>${escapeXml2(manifest.title)}</title>${orgSequencing}
+${itemEntries}
+    </organization>
+  </organizations>
+  <resources>
+${resources}
+    <resource identifier="shared_assets" type="webcontent" adlcp:scormType="asset">
+${uniqueCourseFiles}
+      <file href="lxpack-runtime.js"/>${hasComponentsBundle ? '\n      <file href="lxpack-components.js"/>' : ""}
+    </resource>
+  </resources>
+</manifest>`;
+}
+
+// src/package.ts
 var SKIP_FILES = /* @__PURE__ */ new Set([
   "course.yaml",
   "lxpack.config.ts",
@@ -140,38 +274,119 @@ async function collectFiles(dir, baseDir) {
 function buildManifestFileList(courseFiles) {
   return ["index.html", "lxpack-runtime.js", ...courseFiles.map((f) => f.path)];
 }
-async function packageCourse(options) {
+async function writeSingleScoArtifacts(options) {
   const {
     courseDir,
     manifest,
-    outputPath,
     target,
     runtimeClientJs,
     runtimeCss,
-    assessmentBundle
+    assessmentBundle,
+    componentsBundleJs,
+    writeFile: writeArtifact
   } = options;
-  const zip = new JSZip();
   const mode = target === "scorm12" ? "scorm12" : "standalone";
   const courseFiles = await collectFiles(courseDir, courseDir);
+  let fileCount = 0;
   for (const file of courseFiles) {
     const content = await readFile(file.fullPath);
-    zip.file(file.path, content);
+    await writeArtifact(file.path, content);
+    fileCount++;
   }
   const indexHtml = buildIndexHtml({
     manifest,
     runtimeCss,
     mode,
-    assessmentBundle
+    assessmentBundle,
+    componentsScript: componentsBundleJs ? "./lxpack-components.js" : void 0
   });
-  zip.file("index.html", indexHtml);
-  zip.file("lxpack-runtime.js", runtimeClientJs);
+  await writeArtifact("index.html", indexHtml);
+  await writeArtifact("lxpack-runtime.js", runtimeClientJs);
+  fileCount += 2;
+  if (componentsBundleJs) {
+    await writeArtifact("lxpack-components.js", componentsBundleJs);
+    fileCount++;
+  }
   if (target === "scorm12") {
     const manifestFiles = buildManifestFileList(courseFiles);
-    zip.file(
+    await writeArtifact(
       "imsmanifest.xml",
       generateImsManifest(manifest, manifestFiles)
     );
+    fileCount++;
+  }
+  return { fileCount };
+}
+async function assemblePackage(options, sink) {
+  if (options.target === "scorm2004") {
+    return writeScorm2004Artifacts({ ...options, writeFile: sink.writeFile });
   }
+  return writeSingleScoArtifacts({ ...options, writeFile: sink.writeFile });
+}
+async function writeScorm2004Artifacts(options) {
+  const {
+    courseDir,
+    manifest,
+    runtimeClientJs,
+    runtimeCss,
+    componentsBundleJs,
+    assessmentBundle,
+    writeFile: writeArtifact
+  } = options;
+  const courseFiles = await collectFiles(courseDir, courseDir);
+  let fileCount = 0;
+  for (const file of courseFiles) {
+    const content = await readFile(file.fullPath);
+    await writeArtifact(file.path, content);
+    fileCount++;
+  }
+  await writeArtifact("lxpack-runtime.js", runtimeClientJs);
+  fileCount++;
+  if (componentsBundleJs) {
+    await writeArtifact("lxpack-components.js", componentsBundleJs);
+    fileCount++;
+  }
+  const activities = enumerateActivities(manifest);
+  for (const activity of activities) {
+    const scoBundle = assessmentBundle != null ? sliceAssessmentBundleForActivity(
+      assessmentBundle,
+      activity.id,
+      activity.kind
+    ) : void 0;
+    const html = buildScoIndexHtml({
+      manifest,
+      runtimeCss,
+      mode: "scorm2004",
+      activityId: activity.id,
+      assessmentBundle: scoBundle,
+      componentsScript: componentsBundleJs ? "../../lxpack-components.js" : void 0
+    });
+    await writeArtifact(`sco/${activity.id}/index.html`, html);
+    fileCount++;
+  }
+  const manifestFiles = buildScorm2004ManifestFiles(
+    manifest,
+    courseFiles.map((f) => f.path),
+    Boolean(componentsBundleJs)
+  );
+  await writeArtifact(
+    "imsmanifest.xml",
+    generateScorm2004Manifest(manifest, manifestFiles, {
+      hasComponentsBundle: Boolean(componentsBundleJs)
+    })
+  );
+  fileCount++;
+  return { fileCount };
+}
+async function packageScorm2004(options) {
+  const { outputPath, ...rest } = options;
+  const zip = new JSZip();
+  const { fileCount } = await writeScorm2004Artifacts({
+    ...rest,
+    writeFile: async (relPath, content) => {
+      zip.file(relPath, content);
+    }
+  });
   const buffer = await zip.generateAsync({
     type: "nodebuffer",
     compression: "DEFLATE"
@@ -179,7 +394,44 @@ async function packageCourse(options) {
   await writeFile(outputPath, buffer);
   return {
     outputPath,
-    fileCount: Object.keys(zip.files).length
+    fileCount: Object.keys(zip.files).length || fileCount
+  };
+}
+async function packageScorm2004Dir(options) {
+  const { outputDir, ...rest } = options;
+  await mkdir(outputDir, { recursive: true });
+  const { fileCount } = await writeScorm2004Artifacts({
+    ...rest,
+    writeFile: async (relPath, content) => {
+      const dest = join(outputDir, relPath);
+      const destDir = dirname(dest);
+      if (!existsSync(destDir)) {
+        await mkdir(destDir, { recursive: true });
+      }
+      await writeFile(dest, content);
+    }
+  });
+  return { outputDir, fileCount };
+}
+async function packageCourse(options) {
+  if (options.target === "scorm2004") {
+    return packageScorm2004(options);
+  }
+  const { outputPath, ...rest } = options;
+  const zip = new JSZip();
+  const { fileCount } = await assemblePackage(rest, {
+    writeFile: async (relPath, content) => {
+      zip.file(relPath, content);
+    }
+  });
+  const buffer = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE"
+  });
+  await writeFile(outputPath, buffer);
+  return {
+    outputPath,
+    fileCount: Object.keys(zip.files).length || fileCount
   };
 }
 async function packageStandaloneDir(options) {
@@ -190,50 +442,57 @@ async function packageStandaloneDir(options) {
     target,
     runtimeClientJs,
     runtimeCss,
-    assessmentBundle
+    assessmentBundle,
+    componentsBundleJs
   } = options;
   await mkdir(outputDir, { recursive: true });
-  const mode = target === "scorm12" ? "scorm12" : "standalone";
-  const courseFiles = await collectFiles(courseDir, courseDir);
-  let fileCount = 0;
-  for (const file of courseFiles) {
-    const dest = join(outputDir, file.path);
-    const destDir = dirname(dest);
-    if (!existsSync(destDir)) {
-      await mkdir(destDir, { recursive: true });
+  const { fileCount } = await assemblePackage(
+    {
+      courseDir,
+      manifest,
+      target,
+      runtimeClientJs,
+      runtimeCss,
+      assessmentBundle,
+      componentsBundleJs
+    },
+    {
+      writeFile: async (relPath, content) => {
+        const dest = join(outputDir, relPath);
+        const destDir = dirname(dest);
+        if (!existsSync(destDir)) {
+          await mkdir(destDir, { recursive: true });
+        }
+        if (typeof content === "string") {
+          await writeFile(dest, content);
+        } else {
+          await writeFile(dest, content);
+        }
+      }
     }
-    await cp(file.fullPath, dest);
-    fileCount++;
-  }
-  const indexHtml = buildIndexHtml({
-    manifest,
-    runtimeCss,
-    mode,
-    assessmentBundle
-  });
-  await writeFile(join(outputDir, "index.html"), indexHtml);
-  await writeFile(join(outputDir, "lxpack-runtime.js"), runtimeClientJs);
-  fileCount += 2;
-  if (target === "scorm12") {
-    const manifestFiles = buildManifestFileList(courseFiles);
-    await writeFile(
-      join(outputDir, "imsmanifest.xml"),
-      generateImsManifest(manifest, manifestFiles)
-    );
-    fileCount++;
-  }
+  );
   return { outputDir, fileCount };
 }
 export {
+  assemblePackage,
   buildIndexHtml,
+  buildLearnerPageHtml,
   buildManifestFileList,
   buildRuntimeConfig,
+  buildScoIndexHtml,
+  buildScorm2004ManifestFiles,
   collectFiles,
   courseSlug,
   generateImsManifest,
+  generateScorm2004Manifest,
+  enumerateActivities as listCourseActivities,
   manifestIdentifier,
   packageCourse,
+  packageScorm2004,
+  packageScorm2004Dir,
   packageStandaloneDir,
   safeJsonForHtml,
-  shouldSkipCourseFile
+  scoLaunchPath,
+  shouldSkipCourseFile,
+  sliceAssessmentBundleForActivity
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lxpack/scorm",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "SCORM and standalone HTML export for LXPack",
   "license": "Apache-2.0",
   "repository": {
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "jszip": "^3.10.1",
-    "@lxpack/validators": "0.1.1"
+    "@lxpack/validators": "0.2.1"
   },
   "devDependencies": {
     "@types/node": "^22.13.10",