Fix correction import schema and update dependencies

[DickHorner]

This pull request introduces several improvements and fixes across the codebase, with a focus on enhancing the exams correction import/export workflow, updating dependencies, and clarifying documentation for multi-bundle correction exports. The most significant changes include support for batch importing correction bundles, clearer prompt and contract templates for multi-bundle exports, and dependency updates for security and compatibility.

Exams Correction Import/Export Improvements:

• Added support for batch importing correction bundles via a new executeMany method in ImportKbrCorrectionBundleUseCase and corresponding input/output types. This allows importing multiple bundles in a single operation, improving efficiency and consistency. (modules/exams/src/use-cases/import-kbr-correction-bundle.use-case.ts, apps/teacher-ui/src/composables/useExamsBridge.ts, [1] [2] [3] [4]
• Added a test for batch import functionality to ensure correct behavior when importing multiple correction bundles. (modules/exams/tests/import-kbr-correction-bundle-batch.use-case.test.ts, modules/exams/tests/import-kbr-correction-bundle-batch.use-case.test.tsR1-R172)

Prompt and Contract Template Clarifications:

• Updated prompt and contract templates to clarify that the Ende Korrektur command must export a JSON array of import bundles (one per resolved Leistung), not a single object or wrapper. Added stricter requirements for output format and included the import bundle schema in the prompt for better guidance. (modules/exams/rule-packs/default/contract.template.md, modules/exams/rule-packs/default/prompt.template.md, modules/exams/src/rule-packs/default-pack.ts, modules/exams/src/use-cases/export-correction-session.use-case.ts, [1] [2] [3] [4] [5] [6] [7] [8] [9]
• Enhanced related tests to verify the presence of new schema and instructions in generated prompt artifacts. (modules/exams/tests/export-correction-session.use-case.test.ts, modules/exams/tests/export-correction-session.use-case.test.tsR211-R217)

Dependency Updates:

• Updated various dependencies and devDependencies for security, bug fixes, and compatibility, including @types/node, better-sqlite3, vite, vue-i18n, vue-router, and others across multiple package.json files. [1] [2] [3] [4] [5] [6] [7]## Summary

Linked issue(s)

• Closes #
• Related to #

Checklist

• Scope is focused and intentional
• At least one non-author human review approval (or emergency hotfix rationale documented)
• Docs updated (README/docs/roadmap) where needed
• npm run lint:docs passes
• npm run typecheck passes
• npm run test passes
• npm run build passes

Testing evidence

Architecture and risk notes

• Module boundaries preserved (apps -> modules -> packages)
• No hidden breaking changes
• Local-first / iPadOS Safari behavior considered

Module proposal impact (if applicable)

• Subject:
• School form:
• New module/plugin contracts affected:

Screenshots / recordings (if UI change)

[github-advanced-security]

You are seeing this message because GitHub Code Scanning has recently been set up for this repository, or this pull request contains the workflow file for the Code Scanning tool.

What Enabling Code Scanning Means:

• The 'Security' tab will display more code scanning analysis results (e.g., for the default branch).
• Depending on your configuration and choice of analysis tool, future pull requests will be annotated with code scanning analysis results.
• You will be able to see the analysis results for the pull request's branch on this overview once the scans have completed and the checks have passed.

For more information about GitHub Code Scanning, check out the documentation.

[gemini-code-assist]

Code Review

This pull request introduces support for batch importing correction bundles by adding a new executeMany method to the ImportKbrCorrectionBundleUseCase and updating the exams bridge composable to handle arrays of bundles. It also updates the default rule pack prompt templates to specify that Ende Korrektur should return a JSON array of import bundles, and includes corresponding unit tests. The review comments point out opportunities to clean up payload objects by destructuring unused properties (such as removing the redundant bundle or bundles array when forwarding inputs) and raise a critical architectural consideration regarding transaction handling and partial failures during sequential batch imports.

[gemini-code-assist]

When input.bundle is an array, spreading input directly into executeMany means the duplicate bundle property (which is the array) is still passed along with the new bundles property. Destructuring bundle out of input first keeps the payload clean and avoids passing redundant properties.

Suggested change

	importCorrectionBundle: (input) => {
	if (Array.isArray(input.bundle)) {
	return importKbrCorrectionBundleUseCase.executeMany({
	...input,
	bundles: input.bundle
	});
	}
	return importKbrCorrectionBundleUseCase.execute(input);
	},
	importCorrectionBundle: (input) => {
	if (Array.isArray(input.bundle)) {
	const { bundle, ...rest } = input;
	return importKbrCorrectionBundleUseCase.executeMany({
	...rest,
	bundles: bundle
	});
	}
	return importKbrCorrectionBundleUseCase.execute(input);
	},

[gemini-code-assist]

Spreading input directly into this.execute passes the entire bundles array to each individual execute call as an extra property, which is unnecessary and can be avoided by destructuring bundles first.

Additionally, since this method processes multiple bundles sequentially using await in a loop, any error thrown by a single bundle (e.g., validation failure or database error) will abort the entire batch import midway. This can leave the database in a partially imported state. Consider wrapping the batch execution in a database transaction if atomicity is required, or catching errors per bundle to allow successful ones to complete while returning a list of failed imports.

Suggested change

	async executeMany(input: ImportKbrCorrectionBundleBatchInput): Promise<ImportKbrCorrectionBundleBatchResult> {
	const results: ImportKbrCorrectionBundleResult[] = [];
	for (const bundle of input.bundles) {
	results.push(await this.execute({ ...input, bundle }));
	}
	return {
	results,
	importedBundleCount: results.length,
	importedTaskScoreCount: results.reduce((sum, result) => sum + result.importedTaskScoreCount, 0),
	skippedTaskScoreCount: results.reduce((sum, result) => sum + result.skippedTaskScoreCount, 0),
	uncertainties: results.flatMap((result) => result.uncertainties)
	};
	}
	async executeMany(input: ImportKbrCorrectionBundleBatchInput): Promise<ImportKbrCorrectionBundleBatchResult> {
	const { bundles, ...rest } = input;
	const results: ImportKbrCorrectionBundleResult[] = [];
	for (const bundle of bundles) {
	results.push(await this.execute({ ...rest, bundle }));
	}
	return {
	results,
	importedBundleCount: results.length,
	importedTaskScoreCount: results.reduce((sum, result) => sum + result.importedTaskScoreCount, 0),
	skippedTaskScoreCount: results.reduce((sum, result) => sum + result.skippedTaskScoreCount, 0),
	uncertainties: results.flatMap((result) => result.uncertainties)
	};
	}