@deckflow/deckuse 1.2.1 → 1.3.0

package/dist/pptx/adapter.js

@@ -0,0 +1,807 @@
+import { copyFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { err, ok, } from '../core/index.js';
+import { OpcArchive } from '../opc/index.js';
+import { isIntegerRevision, nextRevision } from '../workspace/index.js';
+import { cNvPrIdOf, resolveTarget, targetPathForItem, uidForItem } from './addressing.js';
+import { editionCapabilities, editionMetadata } from './edition.js';
+import { buildIndex, findIndexed, matchesSelector, mergeSlides } from './indexer.js';
+import { loadIndex } from './index-sync.js';
+import { layoutDisplayName, layoutListMeta, orderedLayouts, slideLayoutPart, } from './layout-ref.js';
+import { mutate } from './mutations.js';
+import { resolveProperties } from './resolve-properties.js';
+import { syncAppSlideCounts } from './slides.js';
+import { initializeWorkspace, isPackageStale, packagePath, persistWrite, readHistory, readManifest, repackWorkspace, revision, sourceDir, undoWrites, withWriteLock, } from './workspace.js';
+import { NS, descendants } from './xml.js';
+const VERSION = '0.5.0';
+const WRITE_TYPES = new Set([
+    'setText',
+    'replaceText',
+    'setTransform',
+    'setProperties',
+    'set',
+    'xfrmSet',
+    'setTableLayout',
+    'zMove',
+    'alignElements',
+    'add',
+    'addSlide',
+    'setSlideLayout',
+    'addShape',
+    'remove',
+    'replacePicture',
+    'duplicate',
+    'batch',
+    'applyTransaction',
+]);
+export const pptxCapabilities = {
+    protocol: '2.0',
+    ...editionMetadata,
+    slides: { add: true, duplicate: true, remove: true, setLayout: true },
+    // Master/layout/theme: list always. `edit` flags are status metadata only —
+    // writes require a registered PptxEditionExtension (never opened by flags alone).
+    masters: { list: true, edit: editionCapabilities.mastersEdit },
+    layouts: { list: true, edit: editionCapabilities.layoutsEdit },
+    theme: { list: true, edit: editionCapabilities.themeEdit },
+    elements: [
+        'shape',
+        'textbox',
+        'connector',
+        'group',
+        'picture',
+        'video',
+        'audio',
+        'table',
+        'chart',
+    ],
+    pictureInput: ['base64', 'path'],
+    picture: { replacePicture: true, cleanupUnreferencedMedia: true },
+    media: { video: true, audio: true, autoPoster: true },
+    chart: {
+        create: true,
+        families: ['bar', 'column', 'line', 'pie', 'combo'],
+        basicOnly: editionCapabilities.chartBasicOnly,
+        title: true,
+        seriesCache: true,
+        seriesColor: true,
+        textColor: true,
+        gapWidth: true,
+        showMajorGridlines: true,
+        showDataLabels: true,
+        valueFormatCode: true,
+        comboDualAxis: true,
+        fill: true,
+        embeddedWorkbook: false,
+    },
+    table: {
+        insertRow: true,
+        deleteRow: true,
+        insertColumn: true,
+        deleteColumn: true,
+        cellFill: true,
+        heightAuto: true,
+        themes: ['minimal', 'zebra'],
+        alignColumns: 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,
+        fontSize: true,
+        bold: true,
+        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'],
+            fontSize: ['size'],
+            textColor: ['fontColor'],
+        },
+    },
+    query: { matchAll: ['*', 'all'], textRegex: true, hasText: true },
+    text: {
+        setText: true,
+        replaceText: true,
+        multiParagraph: true,
+        richRuns: true,
+        paragraphBlocks: true,
+    },
+    geometry: {
+        units: ['emu', 'px', 'pt', 'cm', 'mm', 'in', '%'],
+        alignElements: true,
+        cornerRadius: true,
+    },
+    textBox: { wrap: true, anchor: true },
+    measure: { heuristic: true },
+    shapes: {
+        lineIsStraightConnector: true,
+        elbowConnector: true,
+        curvedConnector: true,
+        arrows: ['rightArrow', 'leftArrow', 'upArrow', 'downArrow'],
+        flow: [
+            'chevron',
+            'homePlate',
+            'trapezoid',
+            'triangle',
+            'rtTriangle',
+            'circularArrow',
+            'curvedRightArrow',
+            'curvedLeftArrow',
+        ],
+    },
+    history: { undo: true },
+    addressing: { targetPath: true, uid: true, placeholder: true, notes: true, runFocus: true },
+    resolve: { effective: true, direct: true, both: true, provenance: true },
+    preservation: 'unknown parts and untouched XML are preserved; ZIP entries are recompressed',
+    propertyVocabulary: {
+        note: 'Prefer deckuse schema --json for full command schemas. Capabilities flags are coarse.',
+        paragraphAlign: {
+            key: 'paragraph.align',
+            values: ['l', 'ctr', 'r', 'just'],
+            aliases: { left: 'l', center: 'ctr', right: 'r', justify: 'just' },
+        },
+        richText: {
+            blocks: 'one paragraph per block; optional runs[] for intra-paragraph styling',
+            runTarget: 'slide:N/shape:X/run:K for setProperties on a single run',
+        },
+    },
+};
+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 },
+                });
+    // ZIP entries that differ only by case collide on macOS/Windows extract.
+    const seenNames = new Map();
+    for (const name of archive.parts.keys()) {
+        const key = name.toLowerCase();
+        const previous = seenNames.get(key);
+        if (previous) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'CASE_COLLIDING_PARTS',
+                message: `Parts ${previous} and ${name} differ only by case (PowerPoint will prompt to repair on case-insensitive systems)`,
+                details: { parts: [previous, name] },
+            });
+        }
+        else {
+            seenNames.set(key, name);
+        }
+    }
+    // app.xml <Slides> must match p:sldIdLst only — not p14:sectionLst/p14:sldId.
+    const appPart = archive.getPart('/docProps/app.xml');
+    if (appPart && archive.getPart('/ppt/presentation.xml')) {
+        const presentation = archive.readXml('/ppt/presentation.xml');
+        const list = descendants(presentation, 'sldIdLst').find((el) => el.namespaceURI === NS.p);
+        const slideCount = list
+            ? descendants(list, 'sldId').filter((el) => el.namespaceURI === NS.p).length
+            : 0;
+        const app = archive.readXml('/docProps/app.xml');
+        const slidesEl = descendants(app, 'Slides').find((node) => !node.namespaceURI ||
+            node.namespaceURI ===
+                'http://schemas.openxmlformats.org/officeDocument/2006/extended-properties');
+        const declared = slidesEl?.textContent?.trim();
+        if (declared !== undefined && declared !== '' && Number(declared) !== slideCount) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'SLIDE_COUNT_MISMATCH',
+                message: `docProps/app.xml <Slides> is ${declared} but presentation has ${String(slideCount)} p:sldId entries (PowerPoint will prompt to repair)`,
+                details: { declared: Number(declared), actual: slideCount },
+            });
+        }
+    }
+    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 = (archive, index, resource, slide) => {
+    if (resource === 'paragraphs' ||
+        resource === 'tables' ||
+        resource === 'sections' ||
+        resource === 'styles' ||
+        resource === 'bookmarks') {
+        return err('UNSUPPORTED_CAPABILITY', `list ${resource} is a Word resource and is not available for PPTX`, [], { hint: 'Use slides, shapes, layouts, masters, or theme.' });
+    }
+    if (resource === 'slides') {
+        const layouts = orderedLayouts(index);
+        const layoutIndexByPart = new Map(layouts.map((item, i) => [item.partUri, i + 1]));
+        return index.elements
+            .filter((item) => item.kind === 'slide')
+            .map((item, i) => {
+            const layoutPart = slideLayoutPart(archive, item.partUri);
+            const layout = layoutPart !== undefined
+                ? {
+                    target: `layout:${layoutPart
+                        .split('/')
+                        .pop()
+                        ?.replace(/\.xml$/i, '') ?? layoutPart}`,
+                    displayName: layoutDisplayName(archive, layoutPart),
+                    ...(layoutIndexByPart.has(layoutPart)
+                        ? { index: layoutIndexByPart.get(layoutPart) }
+                        : {}),
+                }
+                : undefined;
+            return {
+                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,
+                ...(layout !== undefined ? { layout } : {}),
+            };
+        });
+    }
+    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,
+            ...(item.kind === 'chart'
+                ? {
+                    chartVariant: item.payload?.['chartVariant'] === 'basic' ||
+                        item.payload?.['chartVariant'] === 'advanced'
+                        ? item.payload['chartVariant']
+                        : 'advanced',
+                }
+                : {}),
+        }));
+    }
+    if (resource === 'layouts' || resource === 'masters') {
+        if (resource === 'layouts') {
+            return orderedLayouts(index).map((item, i) => ({
+                ...layoutListMeta(archive, item, i + 1),
+                uid: uidForItem(item),
+            }));
+        }
+        const kind = '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',
+                'connector',
+                'elbow',
+                'elbow-connector',
+                'curved-connector',
+                'arrow',
+                'right-arrow',
+                'left-arrow',
+                'up-arrow',
+                'down-arrow',
+                'chevron',
+                'pentagon',
+                'trapezoid',
+                'triangle',
+                'rt-triangle',
+                'circular-arrow',
+                'curved-right-arrow',
+                'curved-left-arrow',
+                '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);
+            const archive = await OpcArchive.openFile(resolve(command.source));
+            if (!archive.getPart('/ppt/presentation.xml'))
+                return err('VALIDATION_FAILED', 'Not a PPTX presentation');
+            // Real-world decks (templates, iSlide, etc.) often ship stale app.xml <Slides>.
+            // Normalize on import so validate / first writes are not blocked by pre-existing drift.
+            syncAppSlideCounts(archive);
+            const created = new Date().toISOString(), rev = revision();
+            const manifest = {
+                schemaVersion: '2.0',
+                workspaceId: workspace,
+                format: 'pptx',
+                source: resolve(command.source),
+                revision: rev,
+                createdAt: created,
+                updatedAt: created,
+                adapterVersion: VERSION,
+                files: [],
+                metadata: { capabilities: pptxCapabilities },
+            };
+            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');
+        }
+    },
+    async execute(command) {
+        const workspace = resolve(command.workspaceId);
+        try {
+            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,
+                });
+            }
+            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),
+                    packageStale: await isPackageStale(workspace, manifest),
+                    elementCount: index.elements.length,
+                    capabilities: pptxCapabilities,
+                    ...editionMetadata,
+                    branch: 'main',
+                });
+            }
+            if (command.type === 'list') {
+                const listed = listResource(archive, 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');
+                }
+                return ok({
+                    document: { format: 'pptx', revision: index.revision, capabilities: pptxCapabilities },
+                    elements: index.elements,
+                });
+            }
+            if (command.type === 'query')
+                return ok(index.elements
+                    .filter((item) => matchesSelector(item, command.selector))
+                    .slice(0, command.limit));
+            if (command.type === 'getText') {
+                const item = findIndexed(index, command.ref);
+                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.kind === 'video' ||
+                            item.kind === 'audio'
+                            ? item.payload
+                            : undefined,
+                    })
+                    : err('ELEMENT_NOT_FOUND', 'Element reference was not found');
+            }
+            if (command.type === 'validate') {
+                const diagnostics = validateArchive(archive);
+                return diagnostics.length
+                    ? err('VALIDATION_FAILED', 'PPTX validation failed', diagnostics)
+                    : ok({
+                        valid: true,
+                        revision: index.revision,
+                        capabilities: pptxCapabilities,
+                    });
+            }
+            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);
+                const fromPackage = command.fromPackage === true;
+                let repacked = false;
+                let exportRevision = manifest.revision;
+                if (!fromPackage) {
+                    const packed = await repackWorkspace(workspace);
+                    exportRevision = packed.manifest.revision;
+                    repacked = true;
+                }
+                await copyFile(packagePath(workspace), output);
+                return ok({
+                    output,
+                    revision: exportRevision,
+                    repacked,
+                    fromPackage,
+                });
+            }
+            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);
+                let currentIndex = await loadIndex(workspace, working, currentManifest);
+                const STRUCTURAL_TYPES = new Set([
+                    'addShape',
+                    'addSlide',
+                    'setSlideLayout',
+                    'remove',
+                    'duplicate',
+                    'add',
+                    'replacePicture',
+                ]);
+                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);
+                        if (STRUCTURAL_TYPES.has(nested.type)) {
+                            currentIndex = buildIndex(working, currentManifest.workspaceId, currentManifest.revision);
+                        }
+                    }
+                    // Heal pre-existing app.xml drift (and Notes) before the integrity gate.
+                    syncAppSlideCounts(working);
+                    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;
+                // Heal pre-existing app.xml drift (and Notes) before the integrity gate.
+                syncAppSlideCounts(working);
+                const validation = validateArchive(working);
+                if (validation.length)
+                    return err('VALIDATION_FAILED', 'PPTX validation failed', validation);
+                if (command.dryRun)
+                    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');
+        }
+    },
+};
+//# sourceMappingURL=adapter.js.map