@chengxianglibra/dsh-data-analysis 0.1.1 → 0.1.2

package/lib/environment/runtime.js

@@ -11,38 +11,41 @@ import { FixedSubprocessPolicy } from "./subprocess.js";
 export const SHARED_PYTHON_SPEC = '3.10';
 const PINNED_MARIVO_VERSION = MARIVO_VERSION;
 export const SHARED_MARIVO_PACKAGE_SPEC = MARIVO_PACKAGE_SPEC;
-export const REPORT_KIT_DISTRIBUTION = 'dsh-data-analysis-report-kit';
-export const REPORT_KIT_VERSION = '3.0.0';
-export const REPORT_KIT_PANDAS_RANGE = '>=2.2.0,<3.0.0';
-export const REPORT_KIT_WHEEL_FILENAME = 'dsh_data_analysis_report_kit-3.0.0-py3-none-any.whl';
+export const PRESENTATION_KIT_DISTRIBUTION = 'dsh-data-analysis-presentation-kit';
+export const PRESENTATION_KIT_VERSION = '1.1.0';
+export const PRESENTATION_KIT_PANDAS_RANGE = '>=2.2.0,<3.0.0';
+export const PRESENTATION_KIT_WHEEL_FILENAME = 'dsh_data_analysis_presentation_kit-1.1.0-py3-none-any.whl';
 export const DEFAULT_SHARED_RUNTIME_INSTALL_TIMEOUT_MS = 600_000;
 const INSTALLATION_SCHEMA = RUNTIME_INSTALLATION_VERSION;
 const INSTALLATION_FILENAME = 'installation.json';
 const SKILL_NAMES = ['marivo-analysis', 'marivo-semantic'];
-const REPORT_ADAPTER_KIND = 'dsh-data-analysis-report-transport-adapter';
 const PROBE_SCRIPT = String.raw `
 import json
 import os
 import sys
+from importlib.metadata import distribution
 import marivo
+from marivo.semantic.definition import SemanticDefinition
 import pandas
-import dsh_data_analysis_report
+import dsh_data_analysis_presentation
 from packaging.specifiers import SpecifierSet
 from packaging.version import Version
 
+presentation_distribution = distribution("dsh-data-analysis-presentation-kit")
+
 print(json.dumps({
     "python_executable": os.path.abspath(sys.executable),
     "marivo_version": marivo.__version__,
     "package_path": os.path.abspath(marivo.__file__ or ""),
     "pandas_version": pandas.__version__,
     "pandas_supported": Version(pandas.__version__) in SpecifierSet(">=2.2.0,<3.0.0"),
-    "report_kit_version": dsh_data_analysis_report.__version__,
-    "report_kit_package_path": os.path.abspath(dsh_data_analysis_report.__file__ or ""),
-    "report_kit_public_imports": all(callable(value) for value in (
-        dsh_data_analysis_report.emit_computed,
-        dsh_data_analysis_report.emit_dataset,
-        dsh_data_analysis_report.emit_session_trace,
-    )),
+    "presentation_kit_version": dsh_data_analysis_presentation.__version__,
+    "presentation_kit_distribution_version": presentation_distribution.version,
+    "presentation_kit_package_path": os.path.abspath(dsh_data_analysis_presentation.__file__ or ""),
+    "presentation_kit_import_identity": os.path.realpath(dsh_data_analysis_presentation.__file__ or "") == os.path.realpath(
+        presentation_distribution.locate_file("dsh_data_analysis_presentation/__init__.py")
+    ),
+    "presentation_kit_public_imports": callable(dsh_data_analysis_presentation.write_dataset),
 }, sort_keys=True))
 `.trim();
 const PYTHON_VERSION_SCRIPT = String.raw `
@@ -56,8 +59,8 @@ print(json.dumps({
     "prefix": os.path.abspath(sys.prefix),
 }, sort_keys=True))
 `.trim();
-function administratorRepair(executable, reportKitWheel) {
-    const dependencies = [SHARED_MARIVO_PACKAGE_SPEC, `pandas${REPORT_KIT_PANDAS_RANGE}`];
+function administratorRepair(executable, presentationKitWheel) {
+    const dependencies = [SHARED_MARIVO_PACKAGE_SPEC, `pandas${PRESENTATION_KIT_PANDAS_RANGE}`];
     const commands = [
         {
             executable,
@@ -65,7 +68,7 @@ function administratorRepair(executable, reportKitWheel) {
         },
         {
             executable,
-            args: ['-m', 'pip', 'install', '--no-deps', reportKitWheel],
+            args: ['-m', 'pip', 'install', '--no-deps', presentationKitWheel],
         },
     ];
     const commandText = (command) => [command.executable, ...command.args].map((value) => JSON.stringify(value)).join(' ');
@@ -90,22 +93,22 @@ function normalizeAbsolute(name, value) {
 function defaultRuntimeRoot() {
     return path.join(resolveDshHome(), 'dsh-data-analysis', 'runtimes', 'marivo');
 }
-function bundledReportKitWheel() {
-    return fileURLToPath(new URL(`../../python/report-kit/dist/${REPORT_KIT_WHEEL_FILENAME}`, import.meta.url));
+function bundledPresentationKitWheel() {
+    return fileURLToPath(new URL(`../../python/presentation-kit/dist/${PRESENTATION_KIT_WHEEL_FILENAME}`, import.meta.url));
 }
-async function assertReportKitWheel(filename) {
+async function assertPresentationKitWheel(filename) {
     const selected = path.normalize(path.resolve(filename));
-    if (path.basename(selected) !== REPORT_KIT_WHEEL_FILENAME) {
-        throw new MarivoEnvironmentError('shared-runtime-report-kit-wheel-invalid', `Bundled report-kit wheel must be named ${REPORT_KIT_WHEEL_FILENAME}`, { expectedWheel: REPORT_KIT_WHEEL_FILENAME, actualWheel: path.basename(selected) });
+    if (path.basename(selected) !== PRESENTATION_KIT_WHEEL_FILENAME) {
+        throw new MarivoEnvironmentError('shared-runtime-presentation-kit-wheel-invalid', `Bundled presentation-kit wheel must be named ${PRESENTATION_KIT_WHEEL_FILENAME}`, { expectedWheel: PRESENTATION_KIT_WHEEL_FILENAME, actualWheel: path.basename(selected) });
     }
     try {
         if (!(await stat(selected)).isFile())
             throw new Error('not a file');
     }
     catch (cause) {
-        throw new MarivoEnvironmentError('shared-runtime-report-kit-wheel-unavailable', `Bundled report-kit wheel is unavailable: ${selected}`, {
-            distribution: REPORT_KIT_DISTRIBUTION,
-            version: REPORT_KIT_VERSION,
+        throw new MarivoEnvironmentError('shared-runtime-presentation-kit-wheel-unavailable', `Bundled presentation-kit wheel is unavailable: ${selected}`, {
+            distribution: PRESENTATION_KIT_DISTRIBUTION,
+            version: PRESENTATION_KIT_VERSION,
             wheel: selected,
         }, { cause });
     }
@@ -153,7 +156,7 @@ function parseJsonObject(stage, result) {
         throw new MarivoEnvironmentError('shared-runtime-install-failed', `Shared Marivo runtime stage returned invalid JSON: ${stage}`, { stage, stdout: boundedText(result.stdout), stderr: boundedText(result.stderr) }, { cause });
     }
 }
-async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, reportKitWheel, administrator, expectedMarivoVersion) {
+async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, presentationKitWheel, administrator, expectedMarivoVersion) {
     const canonical = await assertExecutable(executable);
     const policy = new FixedSubprocessPolicy(runtimeRoot, environment);
     const result = await policy.run({
@@ -161,15 +164,15 @@ async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, rep
         args: ['-c', PROBE_SCRIPT],
         limits: { timeoutMs, stdoutMaxBytes: 16_384, stderrMaxBytes: 16_384 },
     });
-    const repair = administrator ? administratorRepair(canonical, reportKitWheel) : undefined;
+    const repair = administrator ? administratorRepair(canonical, presentationKitWheel) : undefined;
     if (administrator && result.exitCode !== 0) {
-        throw new MarivoEnvironmentError('shared-runtime-package-unavailable', `Administrator Python must provide Marivo ${PINNED_MARIVO_VERSION}, pandas ${REPORT_KIT_PANDAS_RANGE}, and ${REPORT_KIT_DISTRIBUTION} ${REPORT_KIT_VERSION}. ${repair.message}`, {
+        throw new MarivoEnvironmentError('shared-runtime-package-unavailable', `Administrator Python must provide Marivo ${PINNED_MARIVO_VERSION}, pandas ${PRESENTATION_KIT_PANDAS_RANGE}, and ${PRESENTATION_KIT_DISTRIBUTION} ${PRESENTATION_KIT_VERSION}. ${repair.message}`, {
             pythonExecutable: canonical,
             marivoVersion: PINNED_MARIVO_VERSION,
-            pandasRange: REPORT_KIT_PANDAS_RANGE,
-            reportKitDistribution: REPORT_KIT_DISTRIBUTION,
-            reportKitVersion: REPORT_KIT_VERSION,
-            reportKitWheel: reportKitWheel,
+            pandasRange: PRESENTATION_KIT_PANDAS_RANGE,
+            presentationKitDistribution: PRESENTATION_KIT_DISTRIBUTION,
+            presentationKitVersion: PRESENTATION_KIT_VERSION,
+            presentationKitWheel: presentationKitWheel,
             exitCode: result.exitCode,
             stderr: boundedText(result.stderr),
             repairCommands: repair.commands,
@@ -184,12 +187,15 @@ async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, rep
         typeof probe.pandas_version !== 'string' ||
         probe.pandas_version.length === 0 ||
         typeof probe.pandas_supported !== 'boolean' ||
-        typeof probe.report_kit_version !== 'string' ||
-        probe.report_kit_version.length === 0 ||
-        typeof probe.report_kit_package_path !== 'string' ||
-        probe.report_kit_package_path.length === 0 ||
-        probe.report_kit_public_imports !== true) {
-        throw new MarivoEnvironmentError('shared-runtime-identity-mismatch', 'Shared Runtime returned an incomplete package identity', { probe });
+        typeof probe.presentation_kit_version !== 'string' ||
+        probe.presentation_kit_version.length === 0 ||
+        typeof probe.presentation_kit_distribution_version !== 'string' ||
+        probe.presentation_kit_distribution_version.length === 0 ||
+        typeof probe.presentation_kit_package_path !== 'string' ||
+        probe.presentation_kit_package_path.length === 0 ||
+        probe.presentation_kit_import_identity !== true ||
+        probe.presentation_kit_public_imports !== true) {
+        throw new MarivoEnvironmentError('shared-runtime-identity-mismatch', 'Shared Runtime returned an incomplete or mismatched package identity', { probe, ...(repair === undefined ? {} : { repairCommands: repair.commands }) });
     }
     const actualPython = await realpath(path.resolve(probe.python_executable));
     const selectedPython = await realpath(canonical);
@@ -202,18 +208,20 @@ async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, rep
         });
     }
     if (!probe.pandas_supported) {
-        throw new MarivoEnvironmentError('shared-runtime-pandas-unsupported', `Shared Runtime pandas ${probe.pandas_version} is unsupported; install ${REPORT_KIT_PANDAS_RANGE}.${repair === undefined ? '' : ` ${repair.message}`}`, {
-            supportedPandasRange: REPORT_KIT_PANDAS_RANGE,
+        throw new MarivoEnvironmentError('shared-runtime-pandas-unsupported', `Shared Runtime pandas ${probe.pandas_version} is unsupported; install ${PRESENTATION_KIT_PANDAS_RANGE}.${repair === undefined ? '' : ` ${repair.message}`}`, {
+            supportedPandasRange: PRESENTATION_KIT_PANDAS_RANGE,
             actualPandasVersion: probe.pandas_version,
             ...(repair === undefined ? {} : { repairCommands: repair.commands }),
         });
     }
-    if (probe.report_kit_version !== REPORT_KIT_VERSION) {
-        throw new MarivoEnvironmentError('shared-runtime-report-kit-unsupported', `Shared Runtime report kit ${probe.report_kit_version} is unsupported; install ${REPORT_KIT_VERSION} from ${reportKitWheel}.${repair === undefined ? '' : ` ${repair.message}`}`, {
-            supportedReportKitVersion: REPORT_KIT_VERSION,
-            actualReportKitVersion: probe.report_kit_version,
-            reportKitPackagePath: probe.report_kit_package_path,
-            reportKitWheel,
+    if (probe.presentation_kit_version !== PRESENTATION_KIT_VERSION ||
+        probe.presentation_kit_distribution_version !== PRESENTATION_KIT_VERSION) {
+        throw new MarivoEnvironmentError('shared-runtime-presentation-kit-unsupported', `Shared Runtime presentation kit module ${probe.presentation_kit_version} and distribution ${probe.presentation_kit_distribution_version} must both be ${PRESENTATION_KIT_VERSION}; install from ${presentationKitWheel}.${repair === undefined ? '' : ` ${repair.message}`}`, {
+            supportedPresentationKitVersion: PRESENTATION_KIT_VERSION,
+            actualPresentationKitVersion: probe.presentation_kit_version,
+            actualPresentationKitDistributionVersion: probe.presentation_kit_distribution_version,
+            presentationKitPackagePath: probe.presentation_kit_package_path,
+            presentationKitWheel,
             ...(repair === undefined ? {} : { repairCommands: repair.commands }),
         });
     }
@@ -230,9 +238,11 @@ async function probeRuntime(runtimeRoot, executable, environment, timeoutMs, rep
         package_path: path.resolve(probe.package_path),
         pandas_version: probe.pandas_version,
         pandas_supported: probe.pandas_supported,
-        report_kit_version: probe.report_kit_version,
-        report_kit_package_path: path.resolve(probe.report_kit_package_path),
-        report_kit_public_imports: true,
+        presentation_kit_version: probe.presentation_kit_version,
+        presentation_kit_distribution_version: probe.presentation_kit_distribution_version,
+        presentation_kit_package_path: path.resolve(probe.presentation_kit_package_path),
+        presentation_kit_import_identity: true,
+        presentation_kit_public_imports: true,
     };
 }
 async function validateSkills(skillsRoot) {
@@ -308,12 +318,12 @@ async function readInstallation(runtimeRoot) {
             'marivoVersion',
             'packagePath',
             'pythonExecutable',
-            'reportAdapterKind',
-            'reportKitPackagePath',
-            'reportKitVersion',
+            'presentationKitDistribution',
+            'presentationKitPackagePath',
+            'presentationKitVersion',
             'schema',
             'skillsRoot',
-        ];
+        ].sort();
         if (fields.length !== expectedFields.length ||
             fields.some((field, index) => field !== expectedFields[index]) ||
             record.schema !== INSTALLATION_SCHEMA ||
@@ -323,11 +333,11 @@ async function readInstallation(runtimeRoot) {
             record.pythonExecutable.length === 0 ||
             typeof record.packagePath !== 'string' ||
             record.packagePath.length === 0 ||
-            record.reportAdapterKind !== REPORT_ADAPTER_KIND ||
-            typeof record.reportKitVersion !== 'string' ||
-            record.reportKitVersion.length === 0 ||
-            typeof record.reportKitPackagePath !== 'string' ||
-            record.reportKitPackagePath.length === 0 ||
+            record.presentationKitDistribution !== PRESENTATION_KIT_DISTRIBUTION ||
+            typeof record.presentationKitVersion !== 'string' ||
+            record.presentationKitVersion.length === 0 ||
+            typeof record.presentationKitPackagePath !== 'string' ||
+            record.presentationKitPackagePath.length === 0 ||
             typeof record.skillsRoot !== 'string' ||
             record.skillsRoot.length === 0)
             return undefined;
@@ -349,13 +359,13 @@ async function writeInstallation(runtimeRoot, record) {
     await rename(temporary, installationPath);
     return installationPath;
 }
-async function validatedExisting(runtimeRoot, configuredPython, environment, timeoutMs, reportKitWheel) {
+async function validatedExisting(runtimeRoot, configuredPython, environment, timeoutMs, presentationKitWheel) {
     const record = await readInstallation(runtimeRoot);
     if (record === undefined)
         return undefined;
     if (record.marivoVersion !== PINNED_MARIVO_VERSION)
         return undefined;
-    if (record.reportKitVersion !== REPORT_KIT_VERSION)
+    if (record.presentationKitVersion !== PRESENTATION_KIT_VERSION)
         return undefined;
     const expectedPython = configuredPython ?? venvPython(runtimeRoot);
     const expectedSkillsRoot = path.join(runtimeRoot, 'skills');
@@ -365,10 +375,11 @@ async function validatedExisting(runtimeRoot, configuredPython, environment, tim
         const selectedPython = await assertExecutable(expectedPython);
         if (path.normalize(record.pythonExecutable) !== selectedPython)
             return undefined;
-        const probe = await probeRuntime(runtimeRoot, selectedPython, environment, timeoutMs, reportKitWheel, configuredPython !== undefined, record.marivoVersion);
+        const probe = await probeRuntime(runtimeRoot, selectedPython, environment, timeoutMs, presentationKitWheel, configuredPython !== undefined, record.marivoVersion);
         if (path.normalize(probe.package_path) !== path.normalize(record.packagePath))
             return undefined;
-        if (path.normalize(probe.report_kit_package_path) !== path.normalize(record.reportKitPackagePath))
+        if (path.normalize(probe.presentation_kit_package_path) !==
+            path.normalize(record.presentationKitPackagePath))
             return undefined;
         await validateSkills(record.skillsRoot);
         return {
@@ -376,8 +387,8 @@ async function validatedExisting(runtimeRoot, configuredPython, environment, tim
             pythonExecutable: probe.python_executable,
             marivoVersion: probe.marivo_version,
             packagePath: probe.package_path,
-            reportKitVersion: probe.report_kit_version,
-            reportKitPackagePath: probe.report_kit_package_path,
+            presentationKitVersion: probe.presentation_kit_version,
+            presentationKitPackagePath: probe.presentation_kit_package_path,
             skillsRoot: record.skillsRoot,
             installationPath: path.join(runtimeRoot, INSTALLATION_FILENAME),
         };
@@ -451,7 +462,7 @@ async function backupInvalidRuntime(runtimeRoot) {
     }
     await rename(runtimeRoot, `${runtimeRoot}.invalid-${Date.now()}-${randomUUID()}`);
 }
-async function installManagedRuntime(runtimeRoot, uvExecutable, reportKitWheel, environment, timeoutMs) {
+async function installManagedRuntime(runtimeRoot, uvExecutable, presentationKitWheel, environment, timeoutMs) {
     const policy = new FixedSubprocessPolicy(runtimeRoot, environment);
     const limits = { timeoutMs, stdoutMaxBytes: 1_048_576, stderrMaxBytes: 1_048_576 };
     requireSuccess('install managed Python', await policy.run({
@@ -492,12 +503,12 @@ async function installManagedRuntime(runtimeRoot, uvExecutable, reportKitWheel,
         args: ['pip', 'install', '--python', executable, '--upgrade', SHARED_MARIVO_PACKAGE_SPEC],
         limits,
     }));
-    requireSuccess(`install report kit ${REPORT_KIT_VERSION}`, await policy.run({
+    requireSuccess(`install presentation kit ${PRESENTATION_KIT_VERSION}`, await policy.run({
         executable: uvExecutable,
-        args: ['pip', 'install', '--python', executable, '--no-deps', reportKitWheel],
+        args: ['pip', 'install', '--python', executable, '--no-deps', presentationKitWheel],
         limits,
     }));
-    return probeRuntime(runtimeRoot, executable, environment, timeoutMs, reportKitWheel, false, PINNED_MARIVO_VERSION);
+    return probeRuntime(runtimeRoot, executable, environment, timeoutMs, presentationKitWheel, false, PINNED_MARIVO_VERSION);
 }
 /** Ensure and validate the one DSH-home-owned Marivo installation. */
 export async function ensureSharedMarivoRuntime(config = {}, options = {}) {
@@ -511,33 +522,33 @@ export async function ensureSharedMarivoRuntime(config = {}, options = {}) {
         ? 'uv'
         : normalizeAbsolute('uvExecutable', config.uvExecutable);
     const timeoutMs = positiveTimeout(config.installTimeoutMs);
-    const reportKitWheel = path.normalize(path.resolve(options.reportKitWheelPath ?? bundledReportKitWheel()));
-    const existing = await validatedExisting(runtimeRoot, configuredPython, options.environment, timeoutMs, reportKitWheel);
+    const presentationKitWheel = path.normalize(path.resolve(options.presentationKitWheelPath ?? bundledPresentationKitWheel()));
+    const existing = await validatedExisting(runtimeRoot, configuredPython, options.environment, timeoutMs, presentationKitWheel);
     if (existing !== undefined)
         return existing;
     await mkdir(path.dirname(runtimeRoot), { recursive: true });
     const lockPath = `${runtimeRoot}.install-lock`;
     const release = await acquireLock(lockPath, timeoutMs, options.waitIntervalMs ?? 100);
     try {
-        const afterLock = await validatedExisting(runtimeRoot, configuredPython, options.environment, timeoutMs, reportKitWheel);
+        const afterLock = await validatedExisting(runtimeRoot, configuredPython, options.environment, timeoutMs, presentationKitWheel);
         if (afterLock !== undefined)
             return afterLock;
         if (configuredPython === undefined)
-            await assertReportKitWheel(reportKitWheel);
+            await assertPresentationKitWheel(presentationKitWheel);
         await backupInvalidRuntime(runtimeRoot);
         await mkdir(runtimeRoot, { recursive: true });
         const probe = configuredPython === undefined
-            ? await installManagedRuntime(runtimeRoot, uvExecutable, reportKitWheel, options.environment, timeoutMs)
-            : await probeRuntime(runtimeRoot, configuredPython, options.environment, timeoutMs, reportKitWheel, true, PINNED_MARIVO_VERSION);
+            ? await installManagedRuntime(runtimeRoot, uvExecutable, presentationKitWheel, options.environment, timeoutMs)
+            : await probeRuntime(runtimeRoot, configuredPython, options.environment, timeoutMs, presentationKitWheel, true, PINNED_MARIVO_VERSION);
         const skillsRoot = await syncSkills(runtimeRoot, probe.package_path);
         const record = {
             schema: INSTALLATION_SCHEMA,
             marivoVersion: probe.marivo_version,
             pythonExecutable: probe.python_executable,
             packagePath: probe.package_path,
-            reportAdapterKind: REPORT_ADAPTER_KIND,
-            reportKitVersion: probe.report_kit_version,
-            reportKitPackagePath: probe.report_kit_package_path,
+            presentationKitDistribution: PRESENTATION_KIT_DISTRIBUTION,
+            presentationKitVersion: probe.presentation_kit_version,
+            presentationKitPackagePath: probe.presentation_kit_package_path,
             skillsRoot,
         };
         const installationPath = await writeInstallation(runtimeRoot, record);
@@ -546,8 +557,8 @@ export async function ensureSharedMarivoRuntime(config = {}, options = {}) {
             pythonExecutable: probe.python_executable,
             marivoVersion: probe.marivo_version,
             packagePath: probe.package_path,
-            reportKitVersion: probe.report_kit_version,
-            reportKitPackagePath: probe.report_kit_package_path,
+            presentationKitVersion: probe.presentation_kit_version,
+            presentationKitPackagePath: probe.presentation_kit_package_path,
             skillsRoot,
             installationPath,
         };

package/lib/environment/subprocess.js

@@ -71,7 +71,7 @@ export class FixedSubprocessPolicy {
                 shell: false,
                 windowsHide: true,
                 detached: process.platform !== 'win32',
-                stdio: ['ignore', 'pipe', 'pipe'],
+                stdio: ['pipe', 'pipe', 'pipe'],
             });
             let child;
             try {
@@ -84,6 +84,9 @@ export class FixedSubprocessPolicy {
                 }));
                 return;
             }
+            // A child may reject its input before all bytes are written. Do not log payloads.
+            child.stdin.on('error', () => { });
+            child.stdin.end(request.stdin);
             const stdout = [];
             const stderr = [];
             let stdoutBytes = 0;
@@ -127,6 +130,8 @@ export class FixedSubprocessPolicy {
             timeout.unref();
             const onAbort = () => terminate(new MarivoEnvironmentError('subprocess-cancelled', 'Marivo subprocess was cancelled'));
             request.signal?.addEventListener('abort', onAbort, { once: true });
+            if (request.signal?.aborted)
+                onAbort();
             child.stdout.on('data', (chunk) => {
                 stdoutBytes += chunk.byteLength;
                 if (stdoutBytes > limits.stdoutMaxBytes) {

package/lib/environment/summary.js

@@ -10,9 +10,9 @@ export function environmentPayload(runtime, environment) {
             version: environment.binding.marivoVersion,
             packagePath: environment.binding.packagePath,
         },
-        reportKit: {
-            version: runtime.reportKitVersion,
-            packagePath: runtime.reportKitPackagePath,
+        presentationKit: {
+            version: runtime.presentationKitVersion,
+            packagePath: runtime.presentationKitPackagePath,
         },
         fingerprint: environment.binding.fingerprint,
     };

package/lib/environment/workspace.js

@@ -38,6 +38,11 @@ export class MarivoWorkspaceEnvironmentManager {
             binding = bindMarivoEnvironment({
                 projectRoot: canonicalRoot,
                 pythonExecutable: this.runtime.pythonExecutable,
+            }, {
+                presentationKit: {
+                    version: this.runtime.presentationKitVersion,
+                    packagePath: this.runtime.presentationKitPackagePath,
+                },
             });
             this.#bindings.set(canonicalRoot, binding);
         }

package/lib/index.js

@@ -3,5 +3,5 @@ export * from "./compatibility.js";
 export * from "./datasource/index.js";
 export * from "./disclosure/index.js";
 export * from "./environment/index.js";
-export * from "./evidence/index.js";
 export { apply, Config, inject, installMarivoPlugin, name } from "./plugin.js";
+export * from "./presentation/index.js";