@deckflow/deckuse-pptx 1.0.0 → 1.1.0

package/dist/adapter.js

@@ -1,23 +1,84 @@
-import { randomUUID } from 'node:crypto';
-import { copyFile, mkdir, readFile, rename } from 'node:fs/promises';
-import { basename, dirname, join, resolve } from 'node:path';
+import { copyFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { err, ok, } from '@deckflow/deckuse-core';
 import { OpcArchive } from '@deckflow/deckuse-opc';
-import { buildIndex, findIndexed, matchesSelector } from './indexer.js';
+import { isIntegerRevision, nextRevision } from '@deckflow/deckuse-workspace';
+import { cNvPrIdOf, resolveTarget, targetPathForItem, uidForItem, } from './addressing.js';
+import { editionMetadata } from './edition.js';
+import { buildIndex, findIndexed, matchesSelector, mergeSlides } from './indexer.js';
+import { loadIndex } from './index-sync.js';
 import { mutate } from './mutations.js';
-import { deckuseDir, packagePath, persist, readIndex, readManifest, revision, } from './workspace.js';
-const VERSION = '0.3.0';
+import { resolveProperties } from './resolve-properties.js';
+import { initializeWorkspace, packagePath, persistWrite, readHistory, readManifest, revision, sourceDir, undoWrites, withWriteLock, } from './workspace.js';
+const VERSION = '0.5.0';
+const WRITE_TYPES = new Set([
+    'setText',
+    'replaceText',
+    'setTransform',
+    'setProperties',
+    'set',
+    'xfrmSet',
+    'zMove',
+    'add',
+    'addSlide',
+    'addShape',
+    'remove',
+    'replacePicture',
+    'duplicate',
+    'batch',
+    'applyTransaction',
+]);
 export const pptxCapabilities = {
+    protocol: '2.0',
+    ...editionMetadata,
     slides: { add: true, duplicate: true, remove: true },
-    elements: ['shape', 'textbox', 'connector', 'group', 'picture', 'table', 'chart'],
+    // Master/layout/theme: list + resolve only in community; writes gated in mutations.
+    masters: { list: true, edit: false },
+    layouts: { list: true, edit: false },
+    theme: { list: true, edit: false },
+    elements: [
+        'shape',
+        'textbox',
+        'connector',
+        'group',
+        'picture',
+        'video',
+        'audio',
+        'table',
+        'chart',
+    ],
     pictureInput: ['base64', 'path'],
     picture: { replacePicture: true, cleanupUnreferencedMedia: true },
-    chart: { title: true, seriesCache: true, embeddedWorkbook: false },
+    media: { video: true, audio: true, autoPoster: true },
+    chart: {
+        create: true,
+        families: ['bar', 'column', 'line', 'pie'],
+        basicOnly: true,
+        title: true,
+        seriesCache: true,
+        seriesColor: true,
+        textColor: true,
+        gapWidth: true,
+        showMajorGridlines: true,
+        fill: true,
+        embeddedWorkbook: false,
+    },
+    table: {
+        insertRow: true,
+        deleteRow: true,
+        insertColumn: true,
+        deleteColumn: true,
+        cellFill: true,
+    },
+    placeholder: { index: true, address: true, roleOnAdd: true },
+    hyperlink: { set: true, clear: true },
+    notes: { ensureOnWrite: true },
     properties: {
         text: true,
         name: true,
         srgbClr: true,
         fill: true,
+        fillTransparency: true,
         stroke: true,
         textColor: true,
         fontFamily: true,
@@ -26,6 +87,30 @@ export const pptxCapabilities = {
         italic: true,
         underline: true,
         hidden: true,
+        paragraphAlign: true,
+        paragraphLevel: true,
+        bullet: true,
+        hyperlink: true,
+        dotted: [
+            'font.family',
+            'font.size',
+            'font.weight',
+            'font.italic',
+            'font.underline',
+            'font.color',
+            'fill.color',
+            'fill.kind',
+            'fill.transparency',
+            'line.color',
+            'line.kind',
+            'line.width',
+            'text.value',
+            'visible',
+            'paragraph.align',
+            'paragraph.level',
+            'bullet',
+            'hyperlink',
+        ],
         aliases: {
             stroke: ['border', 'outline', 'line'],
             fontFamily: ['font', 'typeface'],
@@ -34,23 +119,206 @@ export const pptxCapabilities = {
         },
     },
     query: { matchAll: ['*', 'all'], textRegex: true, hasText: true },
-    text: { setText: true, replaceText: true },
-    commit: { overwrite: true },
+    text: { setText: true, replaceText: true, multiParagraph: true },
+    history: { undo: true },
+    addressing: { targetPath: true, uid: true, placeholder: true, notes: true },
+    resolve: { effective: true, direct: true, both: true, provenance: true },
     preservation: 'unknown parts and untouched XML are preserved; ZIP entries are recompressed',
 };
+const openWorkspaceArchive = async (workspace) => OpcArchive.openDirectory(sourceDir(workspace));
+const validateArchive = (archive) => {
+    const diagnostics = [];
+    for (const [source, rels] of archive.relationships)
+        for (const rel of rels)
+            if (!rel.external && rel.resolvedTarget && !archive.getPart(rel.resolvedTarget))
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'BROKEN_RELATIONSHIP',
+                    message: `Missing target ${rel.resolvedTarget}`,
+                    details: { source, relationshipId: rel.id },
+                });
+    return diagnostics;
+};
+const slidesFromOutcome = (outcome) => outcome?.slides ?? [];
+const assertExpectRevision = (command, current) => {
+    if (command.expectRevision !== undefined) {
+        const expected = String(command.expectRevision);
+        if (expected !== current && expected !== 'latest')
+            return err('TRANSACTION_CONFLICT', `Expected revision ${expected}, current ${current}`);
+    }
+    if (command.transactionId !== undefined &&
+        command.transactionId !== current &&
+        command.transactionId !== 'latest')
+        return err('TRANSACTION_CONFLICT', `Expected transactionId ${current}`);
+    return undefined;
+};
+const listResource = (index, resource, slide) => {
+    if (resource === 'slides') {
+        return index.elements
+            .filter((item) => item.kind === 'slide')
+            .map((item, i) => ({
+            target: `slide:${i + 1}`,
+            uid: uidForItem(item),
+            index: i + 1,
+            slideId: item.slideId,
+            name: item.name,
+            titlePreview: item.text?.slice(0, 80),
+            partUri: item.partUri,
+        }));
+    }
+    if (resource === 'shapes') {
+        if (slide === undefined)
+            return err('INVALID_COMMAND', 'list shapes requires --slide', [], {
+                hint: 'deckuse list shapes --slide <n> --json',
+            });
+        const slides = index.elements.filter((item) => item.kind === 'slide');
+        const slideItem = slides[slide - 1];
+        if (!slideItem)
+            return err('TARGET_NOT_FOUND', `slide:${slide} does not exist`, [], {
+                target: `slide:${slide}`,
+            });
+        return index.elements
+            .filter((item) => item.partUri === slideItem.partUri &&
+            !['slide', 'notes', 'master', 'layout', 'theme', 'tableCell'].includes(item.kind))
+            .map((item, z) => ({
+            target: targetPathForItem(index, item),
+            uid: uidForItem(item),
+            id: cNvPrIdOf(item),
+            name: item.name,
+            kind: item.kind,
+            role: item.payload?.['placeholder'] ?? item.payload?.['role'],
+            bbox: item.transform,
+            zOrder: z,
+            textPreview: item.text?.slice(0, 80),
+            parentId: item.parentId,
+        }));
+    }
+    if (resource === 'layouts' || resource === 'masters') {
+        const kind = resource === 'layouts' ? 'layout' : 'master';
+        return index.elements
+            .filter((item) => item.kind === kind)
+            .map((item) => ({
+            target: targetPathForItem(index, item),
+            uid: uidForItem(item),
+            name: item.partUri.split('/').pop()?.replace(/\.xml$/, ''),
+            partUri: item.partUri,
+        }));
+    }
+    return index.elements
+        .filter((item) => item.kind === 'theme')
+        .map((item) => ({
+        target: 'theme',
+        uid: uidForItem(item),
+        partUri: item.partUri,
+        colors: item.payload?.['colors'],
+    }));
+};
+const transactionOpsToAtomic = (ops, workspaceId, transactionId) => {
+    const commands = [];
+    for (const op of ops) {
+        const kind = String(op['op'] ?? op['type'] ?? '');
+        const base = {
+            version: '2.0',
+            workspaceId,
+            transactionId,
+        };
+        if (kind === 'add-shape' || kind === 'addShape') {
+            const shapeType = String(op['shapeType'] ?? op['type'] ?? 'text');
+            const allowed = new Set([
+                'text',
+                'rect',
+                'rounded-rect',
+                'ellipse',
+                'line',
+                'image',
+                'group',
+                'table',
+                'chart',
+                'video',
+                'audio',
+            ]);
+            if (!allowed.has(shapeType))
+                return err('UNSUPPORTED_CAPABILITY', `Unsupported shape type: ${shapeType}`);
+            commands.push({
+                ...base,
+                type: 'addShape',
+                slide: Number(op['slide']),
+                shapeType: shapeType,
+                ...(typeof op['name'] === 'string' ? { name: op['name'] } : {}),
+                ...(typeof op['role'] === 'string' ? { role: op['role'] } : {}),
+                ...(typeof op['x'] === 'number' ? { x: op['x'] } : {}),
+                ...(typeof op['y'] === 'number' ? { y: op['y'] } : {}),
+                ...(typeof op['width'] === 'number' ? { width: op['width'] } : {}),
+                ...(typeof op['height'] === 'number' ? { height: op['height'] } : {}),
+                ...(typeof op['file'] === 'string' ? { file: op['file'] } : {}),
+                ...(typeof op['text'] === 'string' ? { text: op['text'] } : {}),
+                ...(Array.isArray(op['rows']) ? { rows: op['rows'] } : {}),
+                ...(typeof op['chartType'] === 'string'
+                    ? { chartType: op['chartType'] }
+                    : {}),
+                ...(op['data'] !== undefined && typeof op['data'] === 'object' && op['data'] !== null
+                    ? {
+                        data: op['data'],
+                    }
+                    : {}),
+            });
+            continue;
+        }
+        if (kind === 'set-text' || kind === 'setText') {
+            commands.push({
+                ...base,
+                type: 'setText',
+                target: String(op['target']),
+                value: String(op['value'] ?? op['text'] ?? ''),
+            });
+            continue;
+        }
+        if (kind === 'set') {
+            const { op: _op, type: _type, target, ...rest } = op;
+            const properties = op['properties'] ?? rest;
+            const cleaned = { ...properties };
+            delete cleaned['target'];
+            delete cleaned['op'];
+            delete cleaned['type'];
+            commands.push({
+                ...base,
+                type: 'set',
+                target: String(target),
+                properties: cleaned,
+                scope: 'local',
+            });
+            continue;
+        }
+        if (kind === 'add-slide' || kind === 'addSlide') {
+            commands.push({
+                ...base,
+                type: 'addSlide',
+                ...(typeof op['after'] === 'number' ? { after: op['after'] } : {}),
+                ...(typeof op['layout'] === 'string' ? { layout: op['layout'] } : {}),
+                ...(typeof op['name'] === 'string' ? { name: op['name'] } : {}),
+            });
+            continue;
+        }
+        if (kind === 'remove') {
+            commands.push({ ...base, type: 'remove', target: String(op['target']) });
+            continue;
+        }
+        return err('UNSUPPORTED_CAPABILITY', `Unsupported transaction op: ${kind || '(missing)'}`);
+    }
+    return ok(commands);
+};
 export const pptxAdapter = {
     format: 'pptx',
     version: VERSION,
     async init(command) {
         try {
             const workspace = resolve(command.workspaceId);
-            await mkdir(deckuseDir(workspace), { recursive: true });
             const archive = await OpcArchive.openFile(resolve(command.source));
             if (!archive.getPart('/ppt/presentation.xml'))
                 return err('VALIDATION_FAILED', 'Not a PPTX presentation');
             const created = new Date().toISOString(), rev = revision();
             const manifest = {
-                schemaVersion: '1.0',
+                schemaVersion: '2.0',
                 workspaceId: workspace,
                 format: 'pptx',
                 source: resolve(command.source),
@@ -61,8 +329,15 @@ export const pptxAdapter = {
                 files: [],
                 metadata: { capabilities: pptxCapabilities },
             };
-            const saved = await persist(workspace, archive, manifest, buildIndex(archive, workspace, rev), { type: 'init', source: command.source });
-            return ok(saved);
+            const index = buildIndex(archive, workspace, rev);
+            const saved = await initializeWorkspace(workspace, archive, manifest, index);
+            return ok({
+                workspaceId: saved.workspaceId,
+                format: saved.format,
+                source: saved.source,
+                revision: saved.revision,
+                elementCount: index.elements.length,
+            });
         }
         catch (cause) {
             return err('IO_ERROR', cause instanceof Error ? cause.message : 'PPTX init failed');
@@ -71,15 +346,135 @@ export const pptxAdapter = {
     async execute(command) {
         const workspace = resolve(command.workspaceId);
         try {
-            const manifest = await readManifest(workspace), archive = await OpcArchive.openFile(packagePath(workspace));
-            let index;
-            try {
-                index = await readIndex(workspace);
+            if (command.type === 'undo') {
+                return await withWriteLock(workspace, async () => {
+                    try {
+                        const result = await undoWrites(workspace, command.steps);
+                        return ok(result);
+                    }
+                    catch (cause) {
+                        return err('VALIDATION_FAILED', cause instanceof Error ? cause.message : 'Undo failed');
+                    }
+                });
+            }
+            if (command.type === 'history') {
+                const { records, total } = await readHistory(workspace, command.limit, command.offset);
+                const filtered = command.slide !== undefined
+                    ? records.filter((record) => record.slides.includes(command.slide))
+                    : records;
+                return ok({ records: filtered, total: command.slide !== undefined ? filtered.length : total });
             }
-            catch {
-                index = buildIndex(archive, manifest.workspaceId, manifest.revision);
+            const manifest = await readManifest(workspace);
+            if (manifest.schemaVersion !== '2.0' || !isIntegerRevision(manifest.revision)) {
+                if (command.type === 'status') {
+                    return ok({
+                        workspaceId: workspace,
+                        format: manifest.format,
+                        revision: manifest.revision,
+                        schemaVersion: manifest.schemaVersion,
+                        compatible: false,
+                        hint: 'Re-run deckuse init to upgrade this workspace to protocol 2.0.',
+                        capabilities: manifest.metadata?.['capabilities'],
+                    });
+                }
+            }
+            const archive = await openWorkspaceArchive(workspace);
+            const index = await loadIndex(workspace, archive, manifest, { persist: true });
+            if (command.type === 'status') {
+                return ok({
+                    workspaceId: workspace,
+                    format: manifest.format,
+                    revision: manifest.revision,
+                    schemaVersion: manifest.schemaVersion,
+                    compatible: true,
+                    adapterVersion: manifest.adapterVersion,
+                    source: manifest.source,
+                    package: packagePath(workspace),
+                    elementCount: index.elements.length,
+                    capabilities: pptxCapabilities,
+                    ...editionMetadata,
+                    branch: 'main',
+                });
+            }
+            if (command.type === 'list') {
+                const listed = listResource(index, command.resource, command.slide);
+                if (listed && typeof listed === 'object' && 'ok' in listed && listed.ok === false)
+                    return listed;
+                return ok({ resource: command.resource, items: listed });
+            }
+            if (command.type === 'get') {
+                const resolved = resolveTarget(index, command.target);
+                if (!resolved.ok)
+                    return resolved;
+                const details = resolveProperties(archive, resolved.value, {
+                    resolve: command.resolve,
+                    ...(command.props ? { props: command.props } : {}),
+                    provenance: command.provenance ?? true,
+                });
+                return ok(details);
+            }
+            if (command.type === 'search') {
+                const items = index.elements.filter((item) => {
+                    if (command.kind === 'text') {
+                        if (!item.text)
+                            return false;
+                        if (command.query && !item.text.toLowerCase().includes(command.query.toLowerCase()))
+                            return false;
+                    }
+                    else {
+                        if (command.name && item.name !== command.name)
+                            return false;
+                        if (command.query &&
+                            !(item.name ?? '').toLowerCase().includes(command.query.toLowerCase()))
+                            return false;
+                    }
+                    return true;
+                });
+                if (command.kind === 'shape' && command.name) {
+                    const named = items.filter((item) => item.name === command.name);
+                    if (named.length > 1)
+                        return err('AMBIGUOUS_NAME', `Shape name is ambiguous: ${command.name}`);
+                }
+                return ok({
+                    matches: items.slice(0, command.limit).map((item) => ({
+                        target: targetPathForItem(index, item),
+                        uid: uidForItem(item),
+                        name: item.name,
+                        kind: item.kind,
+                        text: item.text?.slice(0, 200),
+                        context: item.partUri,
+                    })),
+                });
             }
             if (command.type === 'inspect') {
+                if (command.target) {
+                    const resolved = resolveTarget(index, command.target);
+                    if (!resolved.ok)
+                        return resolved;
+                    const details = resolveProperties(archive, resolved.value, {
+                        resolve: 'both',
+                        provenance: true,
+                    });
+                    return ok({
+                        target: resolved.value.target,
+                        uid: resolved.value.uid,
+                        kind: resolved.value.item.kind,
+                        name: resolved.value.item.name,
+                        partUri: resolved.value.item.partUri,
+                        transform: resolved.value.item.transform,
+                        visualTree: command.visualTree
+                            ? index.elements
+                                .filter((item) => item.partUri === resolved.value.item.partUri)
+                                .map((item) => ({
+                                target: targetPathForItem(index, item),
+                                kind: item.kind,
+                                name: item.name,
+                            }))
+                            : undefined,
+                        properties: details.properties,
+                        warnings: details.warnings,
+                    });
+                }
                 if (command.ref) {
                     const item = findIndexed(index, command.ref);
                     return item ? ok(item) : err('ELEMENT_NOT_FOUND', 'Element reference was not found');
@@ -98,88 +493,126 @@ export const pptxAdapter = {
                 return item
                     ? ok({
                         ref: item.ref,
+                        target: targetPathForItem(index, item),
+                        uid: uidForItem(item),
                         slide: item.slideId,
                         text: item.text ?? '',
                         kind: item.kind,
                         geometry: item.transform,
                         location: item.location,
-                        payload: item.kind === 'chart' || item.kind === 'picture' ? item.payload : undefined,
+                        payload: item.kind === 'chart' ||
+                            item.kind === 'picture' ||
+                            item.kind === 'video' ||
+                            item.kind === 'audio'
+                            ? item.payload
+                            : undefined,
                     })
                     : err('ELEMENT_NOT_FOUND', 'Element reference was not found');
             }
             if (command.type === 'validate') {
-                const diagnostics = [];
-                for (const [source, rels] of archive.relationships)
-                    for (const rel of rels)
-                        if (!rel.external && rel.resolvedTarget && !archive.getPart(rel.resolvedTarget))
-                            diagnostics.push({
-                                severity: 'error',
-                                code: 'BROKEN_RELATIONSHIP',
-                                message: `Missing target ${rel.resolvedTarget}`,
-                                details: { source, relationshipId: rel.id },
-                            });
+                const diagnostics = validateArchive(archive);
                 return diagnostics.length
                     ? err('VALIDATION_FAILED', 'PPTX validation failed', diagnostics)
-                    : ok({ valid: true, revision: index.revision, capabilities: pptxCapabilities });
+                    : ok({
+                        valid: true,
+                        revision: index.revision,
+                        capabilities: pptxCapabilities,
+                    });
             }
-            if (command.type === 'commit') {
-                if (command.transactionId !== manifest.revision && command.transactionId !== 'latest')
-                    return err('TRANSACTION_CONFLICT', `Expected transactionId ${manifest.revision}`);
-                const destination = resolve(command.destination ??
-                    join(dirname(manifest.source), `${basename(manifest.source, '.pptx')}.deckuse.pptx`));
-                if (!command.overwrite) {
-                    try {
-                        await readFile(destination);
-                        return err('IO_ERROR', `Destination exists: ${destination}`);
-                    }
-                    catch (error) {
-                        if (error.code !== 'ENOENT')
-                            throw error;
-                    }
-                }
-                await mkdir(dirname(destination), { recursive: true });
-                const temp = `${destination}.${randomUUID()}.tmp`;
-                await copyFile(packagePath(workspace), temp);
-                await OpcArchive.openFile(temp);
-                await rename(temp, destination);
-                return ok({ destination, revision: manifest.revision });
+            if (command.type === 'export') {
+                if (command.revision !== undefined && String(command.revision) !== manifest.revision)
+                    return err('UNSUPPORTED_CAPABILITY', 'Export of historical revisions is not available in Phase 1a', [], { hint: 'Omit --revision to export the current workspace package.' });
+                const output = resolve(command.output);
+                await copyFile(packagePath(workspace), output);
+                return ok({
+                    output,
+                    revision: manifest.revision,
+                });
             }
-            if (command.transactionId !== manifest.revision && command.transactionId !== 'latest')
-                return err('TRANSACTION_CONFLICT', `Expected transactionId ${manifest.revision}`);
-            if (command.type === 'batch') {
-                const working = await OpcArchive.open(await archive.toUint8Array()), results = [], diagnostics = [];
-                for (const nested of command.commands) {
-                    const result = await mutate(nested, working, index);
-                    diagnostics.push(...result.diagnostics);
-                    if (!result.ok) {
-                        if (!command.atomic && results.length) {
-                            const rev = revision();
-                            await persist(workspace, working, manifest, buildIndex(working, manifest.workspaceId, rev), { ...command, partial: true, failed: nested.type });
-                            return err('VALIDATION_FAILED', 'Non-atomic batch partially applied', [
-                                ...diagnostics,
-                                {
-                                    severity: 'warning',
-                                    code: 'PARTIAL_BATCH_APPLIED',
-                                    message: `${String(results.length)} operation(s) were committed before failure`,
-                                },
-                            ]);
-                        }
-                        return result;
+            if (!WRITE_TYPES.has(command.type))
+                return err('INVALID_COMMAND', `Unsupported command type: ${command.type}`);
+            const conflict = assertExpectRevision(command, manifest.revision);
+            if (conflict)
+                return conflict;
+            return await withWriteLock(workspace, async () => {
+                const currentManifest = await readManifest(workspace);
+                const locked = assertExpectRevision(command, currentManifest.revision);
+                if (locked)
+                    return locked;
+                const working = await openWorkspaceArchive(workspace);
+                const currentIndex = await loadIndex(workspace, working, currentManifest);
+                const runBatch = async (nestedCommands, dryRun, operation) => {
+                    const results = [];
+                    const diagnostics = [];
+                    const slidePages = [];
+                    const changedTargets = [];
+                    const changedParts = [];
+                    for (const nested of nestedCommands) {
+                        const result = await mutate(nested, working, currentIndex);
+                        diagnostics.push(...result.diagnostics);
+                        if (!result.ok)
+                            return result;
+                        results.push(result.value);
+                        slidePages.push(...slidesFromOutcome(result.value));
+                        if (result.value.changedTargets)
+                            changedTargets.push(...result.value.changedTargets);
+                        if (result.value.changedParts)
+                            changedParts.push(...result.value.changedParts);
                     }
-                    results.push(result.value);
+                    const validation = validateArchive(working);
+                    if (validation.length)
+                        return err('VALIDATION_FAILED', 'PPTX validation failed', validation);
+                    if (dryRun)
+                        return ok({
+                            results,
+                            revision: currentManifest.revision,
+                            dryRun: true,
+                            changedTargets: [...new Set(changedTargets)],
+                            changedParts: [...new Set(changedParts)],
+                            affectedSlides: mergeSlides(slidePages),
+                        }, diagnostics);
+                    const rev = nextRevision(currentManifest.revision);
+                    const nextIndex = buildIndex(working, currentManifest.workspaceId, rev);
+                    const saved = await persistWrite(workspace, working, currentManifest, nextIndex, operation, mergeSlides(slidePages));
+                    return ok({
+                        results,
+                        revision: saved.revision,
+                        changedTargets: [...new Set(changedTargets)],
+                        changedParts: [...new Set(changedParts)],
+                        affectedSlides: mergeSlides(slidePages),
+                    }, diagnostics);
+                };
+                if (command.type === 'applyTransaction') {
+                    const mapped = transactionOpsToAtomic(command.operations, command.workspaceId, command.transactionId);
+                    if (!mapped.ok)
+                        return mapped;
+                    return runBatch(mapped.value, command.dryRun, command);
+                }
+                if (command.type === 'batch') {
+                    return runBatch(command.commands, command.dryRun, command);
                 }
+                const result = await mutate(command, working, currentIndex);
+                if (!result.ok)
+                    return result;
+                const validation = validateArchive(working);
+                if (validation.length)
+                    return err('VALIDATION_FAILED', 'PPTX validation failed', validation);
                 if (command.dryRun)
-                    return ok({ results, revision: manifest.revision, dryRun: true }, diagnostics);
-                const rev = revision(), saved = await persist(workspace, working, manifest, buildIndex(working, manifest.workspaceId, rev), command);
-                return ok({ results, revision: saved.revision }, diagnostics);
-            }
-            const working = await OpcArchive.open(await archive.toUint8Array()), result = await mutate(command, working, index);
-            if (!result.ok)
-                return result;
-            if (command.dryRun)
-                return ok({ ...result.value, revision: manifest.revision, dryRun: true }, result.diagnostics);
-            const rev = revision(), saved = await persist(workspace, working, manifest, buildIndex(working, manifest.workspaceId, rev), command);
-            return ok({ ...result.value, revision: saved.revision }, result.diagnostics);
+                    return ok({
+                        ...result.value,
+                        revision: currentManifest.revision,
+                        dryRun: true,
+                        affectedSlides: slidesFromOutcome(result.value),
+                    }, result.diagnostics);
+                const rev = nextRevision(currentManifest.revision);
+                const nextIndex = buildIndex(working, currentManifest.workspaceId, rev);
+                const saved = await persistWrite(workspace, working, currentManifest, nextIndex, command, slidesFromOutcome(result.value));
+                return ok({
+                    ...result.value,
+                    revision: saved.revision,
+                    affectedSlides: slidesFromOutcome(result.value),
+                }, result.diagnostics);
+            });
         }
         catch (cause) {
             return err('IO_ERROR', cause instanceof Error ? cause.message : 'PPTX operation failed');