coursecode 0.1.57 → 0.1.59

package/framework/js/utilities/utilities.js

@@ -44,10 +44,15 @@ export function deepClone(obj) {
     }
     
     const clonedObj = {};
-    for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            clonedObj[key] = deepClone(obj[key]);
-        }
+    for (const key of Object.keys(obj)) {
+        // defineProperty avoids invoking Object.prototype.__proto__ when state
+        // originated from JSON containing that literal key.
+        Object.defineProperty(clonedObj, key, {
+            value: deepClone(obj[key]),
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
     }
     return clonedObj;
 }
@@ -241,7 +246,7 @@ export function waitFor(condition, timeout = 5000, interval = 100) {
  * @returns {Object} The merged target object
  */
 export function deepMerge(target, ...sources) {
-    if (!target || typeof target !== 'object' || Array.isArray(target)) {
+    if (!isPlainObject(target)) {
         throw new Error('deepMerge: target must be a plain object');
     }
 
@@ -251,22 +256,23 @@ export function deepMerge(target, ...sources) {
 
     const source = sources.shift();
 
-    if (source && typeof source === 'object' && !Array.isArray(source)) {
-        for (const key in source) {
-            if (source.hasOwnProperty(key)) {
-                const sourceValue = source[key];
-                const targetValue = target[key];
-
-                if (sourceValue && typeof sourceValue === 'object' && !Array.isArray(sourceValue)) {
-                    // Recursive merge for plain objects
-                    if (!targetValue || typeof targetValue !== 'object' || Array.isArray(targetValue)) {
-                        target[key] = {};
-                    }
-                    deepMerge(target[key], sourceValue);
-                } else {
-                    // Direct assignment for primitives, arrays, and other types
-                    target[key] = sourceValue;
+    if (isPlainObject(source)) {
+        for (const key of Object.keys(source)) {
+            if (key === '__proto__' || key === 'prototype' || key === 'constructor') {
+                throw new Error(`deepMerge: unsafe key "${key}" is not allowed`);
+            }
+
+            const sourceValue = source[key];
+            const targetValue = target[key];
+
+            if (isPlainObject(sourceValue)) {
+                if (!isPlainObject(targetValue)) {
+                    target[key] = {};
                 }
+                deepMerge(target[key], sourceValue);
+            } else {
+                // Direct assignment for primitives, arrays, and non-plain objects
+                target[key] = sourceValue;
             }
         }
     }
@@ -274,6 +280,12 @@ export function deepMerge(target, ...sources) {
     return deepMerge(target, ...sources);
 }
 
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object') return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+
 /**
  * Shuffle an array using Fisher-Yates algorithm (creates new array).
  * @param {Array} array - Array to shuffle

package/framework/js/utilities/view-manager.js

@@ -1,8 +1,9 @@
 import { eventBus } from '../core/event-bus.js';
 import { logger } from './logger.js';
 import { validateRenderedHTML } from '../validation/html-validators.js';
-import { initializeDeclarativeComponents } from './ui-initializer.js';
+import { cleanupDeclarativeComponents, initializeDeclarativeComponents } from './ui-initializer.js';
 import { courseConfig } from '../../../course/course-config.js';
+import { rewritePortableAssetAttributes } from './portable-assets.js';
 
 /**
  * Creates a view manager for a given container element.
@@ -78,9 +79,20 @@ export function createViewManager(container, scope = 'local') {
         // Auto-wrap content with content-width class if configured and not already wrapped
         newElement = autoWrapContentIfNeeded(newElement, name);
 
+        // Convert copied course assets to embedded data URLs before components
+        // initialize and begin loading media in a portable HTML export.
+        rewritePortableAssetAttributes(newElement);
+
         // Validate rendered HTML for common issues BEFORE adding to DOM
         validateRenderedContent(newElement, name);
 
+        // Release component resources before removing the old view. Some
+        // components subscribe to document-level events or own media managers,
+        // so removing their DOM alone is not sufficient cleanup.
+        if (oldElement) {
+            cleanupDeclarativeComponents(oldElement);
+        }
+
         // Clear container and add new view
         container.innerHTML = '';
         container.appendChild(newElement);
@@ -243,6 +255,9 @@ export function createViewManager(container, scope = 'local') {
             if (currentElement && typeof currentView.onHide === 'function') {
                 currentView.onHide(currentElement);
             }
+            if (currentElement) {
+                cleanupDeclarativeComponents(currentElement);
+            }
         }
         container.innerHTML = '';
         currentViewName = null;

package/framework/js/validation/scorm-validators.js

@@ -229,6 +229,75 @@ export function formatLearnerResponseForScorm(interactionType, response) {
     }
 }
 
+/** SCORM 1.2 interaction vocabulary (RTE 1.2.7). */
+export const SCORM_12_INTERACTION_TYPES = [
+    'true-false',
+    'choice',
+    'fill-in',
+    'matching',
+    'performance',
+    'likert',
+    'sequencing',
+    'numeric'
+];
+
+/**
+ * Converts framework/SCORM 2004 interaction data to the materially different
+ * SCORM 1.2 vocabulary and response syntax.
+ *
+ * The framework keeps one lossless internal representation. Unsupported 2004
+ * types are represented as fill-in rows in the optional native 1.2 interaction
+ * array; the original record remains intact in suspend_data.
+ */
+export function serializeInteractionForScorm12(interaction) {
+    const type = SCORM_12_INTERACTION_TYPES.includes(interaction.type)
+        ? interaction.type
+        : 'fill-in';
+
+    const convertResponse = value => {
+        if (value === null || value === undefined) return '';
+        let serialized = String(value);
+
+        if (interaction.type === 'true-false') {
+            const normalized = serialized.toLowerCase().trim();
+            if (normalized === 'true' || normalized === 't' || normalized === '1') return 't';
+            if (normalized === 'false' || normalized === 'f' || normalized === '0') return 'f';
+            return '';
+        }
+
+        if (interaction.type === 'choice' || interaction.type === 'sequencing') {
+            serialized = serialized.replaceAll('[,]', ',');
+        } else if (interaction.type === 'matching') {
+            serialized = serialized.replaceAll('[.]', '.').replaceAll('[,]', ',');
+        }
+
+        // CMIString values in SCORM 1.2 are ASCII. Escape non-ASCII code units
+        // instead of submitting an invalid value that strict LMSs reject.
+        return serialized.replace(/[^\x00-\x7F]/g, char =>
+            `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`
+        );
+    };
+
+    const result = interaction.result === 'incorrect'
+        ? 'wrong'
+        : interaction.result;
+
+    return {
+        ...interaction,
+        id: convertResponse(interaction.id),
+        type,
+        learner_response: convertResponse(interaction.learner_response),
+        result,
+        correct_responses: interaction.correct_responses?.map(item => {
+            if (typeof item === 'object' && item !== null && 'pattern' in item) {
+                return { ...item, pattern: convertResponse(item.pattern) };
+            }
+            return convertResponse(item);
+        }),
+        objectives: interaction.objectives?.map(convertResponse)
+    };
+}
+
 /**
  * SCORM 2004 4th Edition valid completion status values.
  * @constant {string[]}

package/framework/version.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.1.57",
+  "version": "0.1.59",
   "name": "CourseCode Framework",
   "description": "Multi-format course authoring and learner runtime framework",
-  "released": "2026-07-11",
+  "released": "2026-07-13",
   "formats": [
     "SCORM 2004 4th Edition",
     "SCORM 1.2",

package/lib/authoring-api.js

@@ -965,7 +965,32 @@ export async function getWorkflowStatus(port = 4173) {
     // Infer stage
     let stage, stageNumber, nextAction, recommendedTool;
 
-    if (checklist.hasSlides && checklist.hasCourseConfig) {
+    const isPowerPointImport = checklist.source === 'powerpoint-import';
+    const needsReferenceConversion = checklist.hasRawRefs && !checklist.hasConvertedRefs && !isPowerPointImport;
+    const needsOutline = checklist.hasConvertedRefs && !checklist.hasOutline && !isPowerPointImport;
+    const hasNoAuthoringInputs = !checklist.hasRawRefs && !checklist.hasConvertedRefs && !checklist.hasOutline && !isPowerPointImport;
+
+    if (needsReferenceConversion) {
+        stage = 'source-ingestion';
+        stageNumber = 1;
+        nextAction = 'Convert reference files to markdown: coursecode convert';
+        recommendedTool = 'coursecode_workflow_status';
+    } else if (needsOutline) {
+        stage = 'outline-creation';
+        stageNumber = 2;
+        nextAction = 'Create course outline from reference materials. Stage instructions have all file paths.';
+        recommendedTool = 'coursecode_workflow_status';
+    } else if (hasNoAuthoringInputs) {
+        stage = 'source-ingestion';
+        stageNumber = 1;
+        nextAction = 'Add reference files (PDF, DOCX, PPTX, MD) to course/references/ and run coursecode convert';
+        recommendedTool = 'coursecode_workflow_status';
+    } else if (checklist.hasOutline && (!checklist.hasSlides || !checklist.hasCourseConfig)) {
+        stage = 'course-building';
+        stageNumber = 3;
+        nextAction = 'Build slide files and course-config.js based on the outline. Stage instructions have all file paths.';
+        recommendedTool = 'coursecode_workflow_status';
+    } else if (checklist.hasSlides && checklist.hasCourseConfig) {
         // Course is built — run lint to decide polish vs export
         let lintPassed = false;
         try {
@@ -993,21 +1018,6 @@ export async function getWorkflowStatus(port = 4173) {
             }
             recommendedTool = 'coursecode_lint';
         }
-    } else if (!checklist.hasRawRefs && !checklist.hasConvertedRefs) {
-        stage = 'source-ingestion';
-        stageNumber = 1;
-        nextAction = 'Add reference files (PDF, DOCX, PPTX, MD) to course/references/ and run coursecode convert';
-        recommendedTool = 'coursecode_workflow_status';
-    } else if (checklist.hasRawRefs && !checklist.hasConvertedRefs) {
-        stage = 'source-ingestion';
-        stageNumber = 1;
-        nextAction = 'Convert reference files to markdown: coursecode convert';
-        recommendedTool = 'coursecode_workflow_status';
-    } else if (!checklist.hasOutline) {
-        stage = 'outline-creation';
-        stageNumber = 2;
-        nextAction = 'Create course outline from reference materials. Stage instructions have all file paths.';
-        recommendedTool = 'coursecode_workflow_status';
     } else {
         stage = 'course-building';
         stageNumber = 3;
@@ -1050,7 +1060,7 @@ export async function buildCourse(options = {}) {
         const child = spawn('npx', ['vite', 'build'], {
             cwd: courseRoot,
             env,
-            shell: true,
+            shell: process.platform === 'win32',
             stdio: ['ignore', 'pipe', 'pipe']
         });
 
@@ -1059,6 +1069,16 @@ export async function buildCourse(options = {}) {
 
         child.stdout.on('data', (data) => { _stdout += data.toString(); });
         child.stderr.on('data', (data) => { stderr += data.toString(); });
+        child.on('error', (error) => {
+            const duration = ((Date.now() - startTime) / 1000).toFixed(1) + 's';
+            resolve({
+                success: false,
+                error: error.message,
+                errors: [error.message],
+                warnings: [],
+                duration
+            });
+        });
 
         child.on('close', (code) => {
             const duration = ((Date.now() - startTime) / 1000).toFixed(1) + 's';
@@ -1235,4 +1255,3 @@ export async function generateNarration(options = {}) {
         });
     });
 }
-

package/lib/build-linter.js

@@ -12,7 +12,7 @@
 import fs from 'fs';
 import path from 'path';
 import { parseSlideSource, extractAssessment } from './course-parser.js';
-import { getEngagementTrackingMap, getRegisteredComponentTypes } from './schema-extractor.js';
+import { getAllIcons, getEngagementTrackingMap, getRegisteredComponentTypes } from './schema-extractor.js';
 import { getValidCssClasses, lintCssSelectors } from './css-index.js';
 import {
   parseSlideNarration,
@@ -51,7 +51,7 @@ const DYNAMIC_CLASSES = new Set([
   // Component-internal classes — styled via [data-component] selectors in individual component CSS files
   'intro-card', 'card-icon',
   // Interaction-internal classes — used by interaction JS for DOM structure
-  'drag-drop', 'matching-items', 'matching-targets',
+  'drag-drop', 'matching-items', 'matching-targets', 'image-container', 'hotspot-feedback',
   // Slide-specific JS selectors — queried by slide scripts for event binding
   'resources', 'complete-remedial-btn',
 ]);
@@ -93,6 +93,7 @@ export async function lintCourse(courseConfig, coursePath) {
     slideFilesOnDisk
   );
   warnings.push(...globalWarnings);
+  validateMenuIcons(courseConfig, coursePath, warnings);
 
   // Build valid CSS class index once for all slides
   const validCssIndex = getValidCssClasses();
@@ -219,8 +220,12 @@ async function validateSlide(slide, coursePath, objectiveIds, errors, warnings,
     if (interaction.id) {
       registerInteractionId(interaction.id, slide.id, 'DOM Interaction', interactionIdRegistry, errors);
     }
+    validateInteractionSchema(slide.id, interaction, errors);
+    validateInteractionAssetReferences(slide.id, interaction, coursePath, errors);
   }
 
+  validateDirectAssetReferences(slide.id, slideData.elements || [], coursePath, errors);
+
   // Static CSS class validation — checks class attributes in source template
   validateCssClassesStatic(slide.id, source, validCssIndex, warnings);
 
@@ -244,6 +249,191 @@ function validateRequirementContent(slideId, requirement, slideData, engagementT
   }
 }
 
+function schemaTypeMatches(value, expectedType) {
+  if (Array.isArray(expectedType)) {
+    return expectedType.some(type => schemaTypeMatches(value, type));
+  }
+  if (expectedType === 'array') return Array.isArray(value);
+  if (expectedType === 'object') return value !== null && typeof value === 'object' && !Array.isArray(value);
+  if (expectedType === 'number') return typeof value === 'number' && Number.isFinite(value);
+  return typeof value === expectedType;
+}
+
+function validateSchemaValue(reference, value, definition, errors, enforceRequiredChildren = true) {
+  if (!definition || value === undefined) return;
+
+  if (definition.type && !schemaTypeMatches(value, definition.type)) {
+    const actualType = Array.isArray(value) ? 'array' : value === null ? 'null' : typeof value;
+    const expectedType = Array.isArray(definition.type) ? definition.type.join(' or ') : definition.type;
+    errors.push(`${reference} must be ${expectedType}, got ${actualType}.`);
+    return;
+  }
+
+  if (definition.enum && !definition.enum.includes(value)) {
+    errors.push(`${reference} must be one of: ${definition.enum.join(', ')}.`);
+  }
+
+  if (Array.isArray(value)) {
+    if (definition.minItems != null && value.length < definition.minItems) {
+      errors.push(`${reference} must contain at least ${definition.minItems} item(s).`);
+    }
+    if (definition.itemSchema) {
+      value.forEach((item, index) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) return;
+        for (const [key, childDefinition] of Object.entries(definition.itemSchema)) {
+          if (childDefinition.required && !Object.hasOwn(item, key)) {
+            errors.push(`${reference}[${index}] is missing required property "${key}".`);
+            continue;
+          }
+          validateSchemaValue(`${reference}[${index}].${key}`, item[key], childDefinition, errors);
+        }
+      });
+    }
+  }
+
+  if (definition.type === 'object' && definition.valueSchema) {
+    for (const [key, childDefinition] of Object.entries(definition.valueSchema)) {
+      if (enforceRequiredChildren && childDefinition.required && !Object.hasOwn(value, key)) {
+        errors.push(`${reference} is missing required property "${key}".`);
+        continue;
+      }
+      validateSchemaValue(`${reference}.${key}`, value[key], childDefinition, errors);
+    }
+  }
+
+  if (definition.type === 'object' && definition.mapValueSchema) {
+    for (const [key, childValue] of Object.entries(value)) {
+      validateSchemaValue(`${reference}.${key}`, childValue, definition.mapValueSchema, errors);
+    }
+  }
+}
+
+/**
+ * Validate statically parsed interaction values against the registered schema.
+ * Top-level missing values are skipped because they may be supplied by a runtime
+ * variable that the lightweight source parser cannot resolve. Known literal
+ * values, nested objects, and array items are validated fully.
+ */
+export function validateInteractionSchema(slideId, interaction, errors) {
+  const properties = interaction?.schema?.properties;
+  if (!properties) return;
+
+  for (const [key, definition] of Object.entries(properties)) {
+    if (!Object.hasOwn(interaction, key)) continue;
+    validateSchemaValue(`Slide "${slideId}" interaction "${interaction.id}" property "${key}"`, interaction[key], definition, errors);
+  }
+}
+
+const DIRECT_ASSET_ATTRIBUTES = new Set([
+  'src', 'href', 'poster', 'data-src', 'data-audio-src', 'data-video-src',
+  'data-video-poster', 'data-video-captions', 'data-lightbox-src',
+  'data-lightbox-thumbnail', 'data-md-src'
+]);
+const NATIVE_ASSET_ATTRIBUTES = new Set(['src', 'href', 'poster']);
+
+function isExternalAssetReference(reference) {
+  return /^(?:data:|blob:|https?:|mailto:|tel:|#|\/\/|@)/i.test(reference);
+}
+
+function assetPathForReference(reference, coursePath, directHtml) {
+  if (typeof reference !== 'string' || !reference || reference.includes('${')) return null;
+  if (isExternalAssetReference(reference)) return null;
+
+  const clean = reference.split('#', 1)[0].split('?', 1)[0].replace(/\\/g, '/');
+  const withoutDot = clean.replace(/^\.\//, '');
+
+  if (directHtml && withoutDot.startsWith('assets/')) {
+    return {
+      error: `Direct HTML asset path "${reference}" will not exist in LMS packages. Use "course/${withoutDot}".`
+    };
+  }
+
+  let relativePath = null;
+  if (withoutDot.startsWith('course/assets/')) {
+    relativePath = withoutDot.slice('course/assets/'.length);
+  } else if (!directHtml && withoutDot.startsWith('assets/')) {
+    relativePath = withoutDot.slice('assets/'.length);
+  } else if (!directHtml && !withoutDot.startsWith('/') && !withoutDot.startsWith('../')) {
+    relativePath = withoutDot;
+  }
+
+  if (!relativePath) return null;
+  return { filePath: path.join(coursePath, 'assets', relativePath), relativePath };
+}
+
+function validateAssetReference(slideId, reference, coursePath, directHtml, errors) {
+  const resolved = assetPathForReference(reference, coursePath, directHtml);
+  if (!resolved) return;
+  if (resolved.error) {
+    errors.push(`Slide "${slideId}": ${resolved.error}`);
+    return;
+  }
+  if (!fs.existsSync(resolved.filePath)) {
+    errors.push(`Slide "${slideId}": local course asset not found: course/assets/${resolved.relativePath}`);
+  }
+}
+
+export function validateDirectAssetReferences(slideId, elements, coursePath, errors) {
+  for (const element of elements || []) {
+    for (const [attribute, value] of Object.entries(element.attributes || {})) {
+      if (!DIRECT_ASSET_ATTRIBUTES.has(attribute)) continue;
+      const componentOwnsHref = attribute === 'href' && element.attributes?.['data-component'] === 'lightbox';
+      validateAssetReference(
+        slideId,
+        value,
+        coursePath,
+        NATIVE_ASSET_ATTRIBUTES.has(attribute) && !componentOwnsHref,
+        errors
+      );
+    }
+  }
+}
+
+export function validateInteractionAssetReferences(slideId, interaction, coursePath, errors) {
+  const visit = (value, key = '') => {
+    if (!value || typeof value !== 'object') return;
+    for (const [childKey, childValue] of Object.entries(value)) {
+      if (childKey === 'schema') continue;
+      if (childKey === 'src' && typeof childValue === 'string') {
+        validateAssetReference(slideId, childValue, coursePath, false, errors);
+      } else if (childValue && typeof childValue === 'object') {
+        visit(childValue, childKey || key);
+      }
+    }
+  };
+  visit(interaction);
+}
+
+function customIconNames(coursePath) {
+  const iconFile = path.join(coursePath, 'icons.js');
+  if (!fs.existsSync(iconFile)) return [];
+  const source = fs.readFileSync(iconFile, 'utf-8');
+  const declaration = source.match(/export\s+const\s+customIcons\s*=\s*\{([\s\S]*?)\n\};/);
+  if (!declaration) return [];
+  return [...declaration[1].matchAll(/^\s*['"]([^'"]+)['"]\s*:/gm)].map(match => match[1]);
+}
+
+function isEmojiIcon(value) {
+  return /^[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1FA00}-\u{1FAFF}]/u.test(value);
+}
+
+export function validateMenuIcons(courseConfig, coursePath, warnings) {
+  const validIcons = new Set([...Object.keys(getAllIcons()), ...customIconNames(coursePath)]);
+  const inspectIcon = (icon, owner) => {
+    if (typeof icon !== 'string' || !icon || validIcons.has(icon) || isEmojiIcon(icon)) return;
+    warnings.push(`Unknown menu icon "${icon}" on ${owner}. Add it to course/icons.js or use a registered icon.`);
+  };
+
+  const walk = items => {
+    for (const item of items || []) {
+      inspectIcon(item.menu?.icon, `${item.type || 'item'} "${item.id || item.title || 'unknown'}"`);
+      if (item.children) walk(item.children);
+    }
+  };
+  walk(courseConfig.structure);
+  inspectIcon(courseConfig.navigation?.documentGallery?.icon, 'navigation.documentGallery');
+}
+
 /**
  * Static CSS class validation — extracts class="..." values from slide source
  * and checks them against the valid CSS class index built from PostCSS.

package/lib/build-packaging.js

@@ -28,8 +28,30 @@ function sanitizeTitle(title) {
 
 function withClientCredentials(externalUrl, clientId, token) {
     if (!clientId || !token) return externalUrl;
-    const separator = externalUrl.includes('?') ? '&' : '?';
-    return `${externalUrl}${separator}clientId=${encodeURIComponent(clientId)}&token=${encodeURIComponent(token)}`;
+    const url = new URL(externalUrl);
+    url.searchParams.set('clientId', clientId);
+    url.searchParams.set('token', token);
+    return url.toString();
+}
+
+function validateExternalUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    } catch {
+        throw new Error(`externalUrl must be an absolute URL, received: ${value}`);
+    }
+    const localHttp = url.protocol === 'http:' && ['localhost', '127.0.0.1', '::1'].includes(url.hostname);
+    if (url.protocol !== 'https:' && !localHttp) {
+        throw new Error('externalUrl must use HTTPS (HTTP is allowed only for local development)');
+    }
+    if (url.hash) {
+        throw new Error('externalUrl must not contain a URL fragment because launch credentials would not reach the server');
+    }
+    if (url.username || url.password) {
+        throw new Error('externalUrl must not embed HTTP credentials');
+    }
+    return url;
 }
 
 function zipDirectory(sourceDir, zipFilePath) {
@@ -55,6 +77,7 @@ export function validateExternalHostingConfig(config) {
     if (!config.externalUrl) {
         throw new Error(`${config.lmsFormat} format requires 'externalUrl' in course-config.js`);
     }
+    validateExternalUrl(config.externalUrl);
 
     if (config.accessControl?.enforcement !== 'server') {
         throw new Error(`${config.lmsFormat} requires accessControl.enforcement = 'server'. Browser-only token checks are not secure.`);
@@ -164,6 +187,10 @@ export async function createProxyPackage({ rootDir, config, clientId = null, tok
 
         let proxyHtml = fs.readFileSync(path.join(templatesDir, 'proxy.html'), 'utf-8');
         proxyHtml = proxyHtml.replace('{{EXTERNAL_URL_JSON}}', JSON.stringify(externalUrl));
+        proxyHtml = proxyHtml.replace(
+            '{{BASE_FORMAT_JSON}}',
+            JSON.stringify(config.lmsFormat === 'scorm1.2-proxy' ? 'scorm1.2' : 'scorm2004')
+        );
         fs.writeFileSync(path.join(proxyDir, 'proxy.html'), proxyHtml);
 
         fs.copyFileSync(path.join(templatesDir, 'scorm-bridge.js'), path.join(proxyDir, 'scorm-bridge.js'));
@@ -172,6 +199,22 @@ export async function createProxyPackage({ rootDir, config, clientId = null, tok
         const { filename, content } = generateManifest(config.lmsFormat, config, [], { externalUrl: config.externalUrl });
         fs.writeFileSync(path.join(proxyDir, filename), content);
 
+        const schemasDir = path.join(PACKAGE_ROOT, 'schemas');
+        for (const entry of fs.readdirSync(schemasDir, { withFileTypes: true })) {
+            if (entry.isFile() && /\.(?:xsd|dtd|xml)$/i.test(entry.name)) {
+                fs.copyFileSync(path.join(schemasDir, entry.name), path.join(proxyDir, entry.name));
+            }
+        }
+        fs.cpSync(path.join(schemasDir, 'common'), path.join(proxyDir, 'common'), { recursive: true });
+
+        const required = config.lmsFormat === 'scorm1.2-proxy'
+            ? ['imsmanifest.xml', 'proxy.html', 'scorm-bridge.js', 'pipwerks.js', 'imscp_rootv1p1p2.xsd', 'adlcp_rootv1p2.xsd', 'ims_xml.xsd']
+            : ['imsmanifest.xml', 'proxy.html', 'scorm-bridge.js', 'pipwerks.js', 'imscp_v1p1.xsd', 'adlcp_v1p3.xsd', 'imsss_v1p0.xsd'];
+        const missing = required.filter(file => !fs.existsSync(path.join(proxyDir, file)));
+        if (missing.length > 0 || proxyHtml.includes('{{')) {
+            throw new Error(`Proxy package validation failed: ${missing.length ? `missing ${missing.join(', ')}` : 'unresolved template placeholder'}`);
+        }
+
         if (fs.existsSync(zipFilePath)) fs.unlinkSync(zipFilePath);
         const bytes = await zipDirectory(proxyDir, zipFilePath);
         const sizeKB = (bytes / 1024).toFixed(1);
@@ -206,7 +249,8 @@ export async function createRemotePackage({ rootDir, config, clientId = null, to
         const bytes = await zipDirectory(remoteDir, zipFilePath);
         const sizeKB = (bytes / 1024).toFixed(1);
         console.warn(`📦 Created ${zipFileName} (${sizeKB} KB) - Upload to LMS`);
-        console.warn(`   AU URL points to: ${externalUrl.replace(/\/$/, '')}/index.html`);
+        const auUrl = content.match(/<url>([^<]+)<\/url>/)?.[1] || externalUrl;
+        console.warn(`   AU URL points to: ${auUrl}`);
         return zipFilePath;
     } finally {
         if (fs.existsSync(remoteDir)) fs.rmSync(remoteDir, { recursive: true });