deckjsx 0.5.0 → 0.6.0

package/README.md

@@ -7,18 +7,19 @@ The intended architecture is:
 
 ```text
 JSX
-  -> Presentation IR
-  -> Backend
-       |- PptxGenJS backend
-       `- OOXML direct backend (future)
+  -> Author Tree
+  -> Semantic Author Graph
+  -> Output Projection
+  -> Output Writer
 ```
 
 This project is being designed as a compiler, not as a thin `PptxGenJS` wrapper.
-The API uses a class-based compiler with callback-based `.add()`, `.render()`, and `.output()`.
-Authoring uses typed JSX elements with a `style` object prop.
+The API uses a class-based compiler with callback-based `.add()`, `.compile()`, `.project()`, and
+`.render()`. Authoring uses typed JSX elements with CSS-like style and class semantics.
 
 The implementation preserves the compiler model with explicit module boundaries for authoring,
-style normalization, layout, IR, backend emission, and Node runtime output.
+semantic graph construction, style resolution, output projection, writer adapters, and runtime
+output.
 
 ## Install
 
@@ -26,7 +27,7 @@ style normalization, layout, IR, backend emission, and Node runtime output.
 npm install deckjsx
 ```
 
-The package currently targets Node.js output and ships a `pptxgenjs` backend.
+The package currently targets PPTX output and ships a temporary `pptxgenjs` writer adapter.
 
 ## Usage
 
@@ -59,8 +60,7 @@ deck.add(({ composition }) => (
 
       <section style={{ display: "grid", gridTemplateColumns: "1fr 1fr", columnGap: 0.35 }}>
         <p style={{ fontSize: 18, color: "#334155", fit: "shrink" }}>
-          Author slides with typed JSX, inspect the generated IR, and emit PPTX files through the
-          backend boundary.
+          Author slides with typed JSX, inspect the projected document model, and render PPTX files.
         </p>
         <figure style={{ backgroundColor: "#E0F2FE", borderRadius: 0.15, padding: 0.25 }}>
           <img src="chart.png" style={{ width: "100%", height: "100%", fit: "contain" }} />
@@ -78,12 +78,12 @@ deck.add(({ composition }) => (
   </Slide>
 ));
 
-const ir = deck.render();
-await deck.output({ backend: "pptxgenjs", output: "quarterly-review.pptx" });
+const project = deck.project();
+await deck.render({ output: "quarterly-review.pptx" });
 ```
 
-Use `deck.render()` for tests, snapshots, and backend-independent inspection. Use
-`deck.output({ backend: "pptxgenjs", output })` when writing a PowerPoint file.
+Use `deck.compile()` for authoring semantics, `deck.project()` for output-facing inspection, and
+`deck.render({ output })` when writing a PowerPoint file.
 
 ## JSX elements
 
@@ -118,7 +118,13 @@ Image elements compile to images and require either `src` or `data`:
 ```
 
 Primitive string and number children inside view-like elements are normalized to implicit text
-nodes. Inline rich text with `span` is intentionally reserved for a later release.
+nodes. Inline rich text uses `span` inside text-like elements:
+
+```tsx
+<p>
+  Revenue grew <span style={{ color: "#16A34A", fontWeight: 700 }}>12%</span>.
+</p>
+```
 
 ## View Layout Semantics
 

package/dist/{pptxgenjs-BTMKb1WX.mjs → adapter-BbtteJ7s.mjs}

@@ -25,9 +25,64 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
-//#region src/types.ts
-const EMU_PER_INCH = 914400;
-const POINTS_PER_INCH = 72;
+//#region src/diagnostics/format.ts
+function formatSpan(path) {
+	return `  at ${path}`;
+}
+function formatDiagnostic(diagnostic) {
+	const lines = [`${diagnostic.severity}[${diagnostic.code}]: ${diagnostic.title}`];
+	if (diagnostic.message) lines.push(`  ${diagnostic.message}`);
+	for (const label of diagnostic.labels) {
+		lines.push(formatSpan(label.path));
+		lines.push(`   = ${label.message}`);
+	}
+	for (const note of diagnostic.notes ?? []) lines.push(`note: ${note}`);
+	for (const help of diagnostic.help ?? []) lines.push(`help: ${help}`);
+	return lines.join("\n");
+}
+function formatDiagnostics(diagnostics) {
+	return diagnostics.items.map((item) => formatDiagnostic(item)).join("\n\n");
+}
+//#endregion
+//#region src/diagnostics/errors.ts
+var DeckDiagnosticError = class extends Error {
+	diagnostics;
+	constructor(message, diagnostics) {
+		super(message);
+		this.name = "DeckDiagnosticError";
+		this.diagnostics = diagnostics;
+	}
+};
+var SemanticGraphDiagnosticError = class extends DeckDiagnosticError {
+	constructor(diagnostics) {
+		super(formatDiagnostics(diagnostics), diagnostics);
+		this.name = "SemanticGraphDiagnosticError";
+	}
+};
+var CompositionDiagnosticError = class extends DeckDiagnosticError {
+	constructor(diagnostics) {
+		super(formatDiagnostics(diagnostics), diagnostics);
+		this.name = "CompositionDiagnosticError";
+	}
+};
+var StyleDiagnosticError = class extends DeckDiagnosticError {
+	constructor(diagnostics) {
+		super(formatDiagnostics(diagnostics), diagnostics);
+		this.name = "StyleDiagnosticError";
+	}
+};
+//#endregion
+//#region src/diagnostics/index.ts
+function createDiagnostics(items = []) {
+	return {
+		items,
+		hasErrors: items.some((item) => item.severity === "error"),
+		hasWarnings: items.some((item) => item.severity === "warning")
+	};
+}
+function diagnostic(input) {
+	return input;
+}
 //#endregion
 //#region node_modules/inherits/inherits_browser.js
 var require_inherits_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -10314,9 +10369,13 @@ var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = JSZip;
 }));
 //#endregion
-//#region src/backends/pptxgenjs-xml-patches.ts
+//#region src/types.ts
 var import_dist = require_dist();
 var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
+const EMU_PER_INCH = 914400;
+const POINTS_PER_INCH = 72;
+//#endregion
+//#region src/writers/pptxgenjs-xml-patches.ts
 function emuToInches$1(value) {
 	return value / EMU_PER_INCH;
 }
@@ -10717,14 +10776,15 @@ function patchSlideBlocks(xml, patch) {
 	}
 	return patchedXml;
 }
-function buildSlideXmlPatchPlan(slideIR) {
-	const images = [...collectBackgroundLayerImages(slideIR.backgroundLayers), ...collectRenderableImages(slideIR.nodes)];
-	const texts = collectRenderableTextNodes(slideIR.nodes);
+function buildSlideXmlPatchPlan(slidePart) {
+	const slide = slidePart.payload;
+	const images = [...collectBackgroundLayerImages(slide.backgroundLayers), ...collectRenderableImages(slide.elements)];
+	const texts = collectRenderableTextNodes(slide.elements);
 	return {
 		pictureSrcRects: images.map((image) => resolveImageSrcRect(image)),
-		shapeFills: [...slideIR.backgroundLayers?.map((layer) => buildBackgroundLayerFillXml(layer)) ?? [], ...collectShapeFillPatches(slideIR.nodes)],
-		shapeLines: collectShapeLinePatches(slideIR.nodes),
-		slideBackgroundFill: buildGradientFillXml(slideIR.background),
+		shapeFills: [...slide.backgroundLayers?.map((layer) => buildBackgroundLayerFillXml(layer)) ?? [], ...collectShapeFillPatches(slide.elements)],
+		shapeLines: collectShapeLinePatches(slide.elements),
+		slideBackgroundFill: buildGradientFillXml(slide.background),
 		textIndentsEmu: texts.map((text) => text.style.textIndentPt === void 0 ? void 0 : pointsToEmu$1(text.style.textIndentPt))
 	};
 }
@@ -10765,10 +10825,10 @@ function applySlideXmlPatchPlan(slideXml, plan) {
 		}
 	});
 }
-async function patchPresentationXml(data, ir) {
+async function patchPresentationXml(data, projection) {
 	const zip = await import_lib.default.loadAsync(data);
-	for (const [slideIndex, slideIR] of ir.slides.entries()) {
-		const patchPlan = buildSlideXmlPatchPlan(slideIR);
+	for (const [slideIndex, slide] of projection.slides.entries()) {
+		const patchPlan = buildSlideXmlPatchPlan(slide);
 		if (!hasSlideXmlPatchPlan(patchPlan)) continue;
 		const slidePath = `ppt/slides/slide${slideIndex + 1}.xml`;
 		const slideFile = zip.file(slidePath);
@@ -10779,7 +10839,8 @@ async function patchPresentationXml(data, ir) {
 	return zip.generateAsync({ type: "uint8array" });
 }
 //#endregion
-//#region src/backends/pptxgenjs.ts
+//#region src/writers/pptxgenjs.ts
+const PPTX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
 const TRANSPARENT_FILL = {
 	color: "FFFFFF",
 	transparency: 100
@@ -10789,7 +10850,6 @@ const TRANSPARENT_LINE = {
 	transparency: 100,
 	width: 0
 };
-const PPTX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
 function resolvePptxGenJSConstructor(moduleValue) {
 	if (typeof moduleValue === "function") return moduleValue;
 	if (typeof moduleValue === "object" && moduleValue !== null && "default" in moduleValue) {
@@ -10799,6 +10859,11 @@ function resolvePptxGenJSConstructor(moduleValue) {
 	throw new Error("Unable to resolve PptxGenJS constructor.");
 }
 const PptxGenJS = resolvePptxGenJSConstructor(PptxGenJSModule);
+function normalizeBuffer(data) {
+	if (data instanceof Uint8Array) return data;
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	throw new Error("Unsupported PptxGenJS output type received.");
+}
 function emuToInches(value) {
 	return value / EMU_PER_INCH;
 }
@@ -10814,14 +10879,6 @@ function combineTransparency(transparency, opacity) {
 function combineOpacities(parentOpacity, nodeOpacity) {
 	return (parentOpacity ?? 1) * (nodeOpacity ?? 1);
 }
-function normalizeBuffer(data) {
-	if (data instanceof Uint8Array) return data;
-	if (data instanceof ArrayBuffer) return new Uint8Array(data);
-	throw new Error("Unsupported PptxGenJS output type received.");
-}
-function assertNever(value) {
-	throw new Error(`Unhandled PptxGenJS backend value: ${String(value)}`);
-}
 function mapShapeName(shape, radiusEmu) {
 	if (shape === "rect") return radiusEmu && radiusEmu > 0 ? "roundRect" : "rect";
 	if (shape === "ellipse") return "ellipse";
@@ -10829,15 +10886,11 @@ function mapShapeName(shape, radiusEmu) {
 }
 function toPptxFill(fill, opacity) {
 	if (!fill) return;
-	switch (fill.kind) {
-		case "solid": return {
-			color: fill.color,
-			transparency: combineTransparency(fill.transparency, opacity)
-		};
-		case "linear-gradient":
-		case "radial-gradient": return TRANSPARENT_FILL;
-		default: return assertNever(fill);
-	}
+	if (fill.kind !== "solid") return TRANSPARENT_FILL;
+	return {
+		color: fill.color,
+		transparency: combineTransparency(fill.transparency, opacity)
+	};
 }
 function toPptxLine(stroke, opacity) {
 	if (!stroke) return;
@@ -10859,6 +10912,14 @@ function toPptxShadow(shadow, opacity) {
 		angle: shadow.angle
 	};
 }
+function toPptxUnderline(style) {
+	if (!style.underline && !style.underlineStyle && !style.underlineColor) return;
+	if (!style.underlineStyle && !style.underlineColor) return style.underline;
+	return {
+		...style.underlineStyle ? { style: style.underlineStyle } : {},
+		...style.underlineColor ? { color: style.underlineColor } : {}
+	};
+}
 function toPptxBullet(list) {
 	if (!list) return;
 	if (list.type === "none") return false;
@@ -10876,21 +10937,6 @@ function toPptxBullet(list) {
 		...list.indentPt !== void 0 ? { indent: list.indentPt } : {}
 	};
 }
-function toPptxUnderline(style) {
-	if (!style.underline && !style.underlineStyle && !style.underlineColor) return;
-	if (!style.underlineStyle && !style.underlineColor) return style.underline;
-	return {
-		...style.underlineStyle ? { style: style.underlineStyle } : {},
-		...style.underlineColor ? { color: style.underlineColor } : {}
-	};
-}
-function toPptxTabStops(tabStops) {
-	if (!tabStops || tabStops.length === 0) return;
-	return tabStops.map((tabStop) => ({
-		position: tabStop.positionIn,
-		...tabStop.alignment ? { alignment: tabStop.alignment } : {}
-	}));
-}
 function toPptxTextRunOptions(style) {
 	if (!style) return;
 	const options = {
@@ -10906,27 +10952,26 @@ function toPptxTextRunOptions(style) {
 		subscript: style.subscript,
 		breakLine: false
 	};
-	if (Object.values(options).every((value) => value === void 0 || value === false)) return;
-	return options;
+	return Object.values(options).every((value) => value === void 0 || value === false) ? void 0 : options;
 }
-function emitOutlineShape(slide, shapeName, frame, outline, radiusEmu, effectiveOpacity, rotation, flipH, flipV) {
-	if (!outline) return;
-	const insetEmu = pointsToEmu(outline.widthPt) / 2;
+function emitOutlineShape(slide, shapeName, node, effectiveOpacity) {
+	if (!node.outline) return;
+	const insetEmu = pointsToEmu(node.outline.widthPt) / 2;
 	slide.addShape(shapeName, {
-		x: emuToInches(frame.xEmu - insetEmu),
-		y: emuToInches(frame.yEmu - insetEmu),
-		w: emuToInches(frame.widthEmu + insetEmu * 2),
-		h: emuToInches(frame.heightEmu + insetEmu * 2),
+		x: emuToInches(node.frame.xEmu - insetEmu),
+		y: emuToInches(node.frame.yEmu - insetEmu),
+		w: emuToInches(node.frame.widthEmu + insetEmu * 2),
+		h: emuToInches(node.frame.heightEmu + insetEmu * 2),
 		fill: TRANSPARENT_FILL,
-		line: toPptxLine(outline, effectiveOpacity),
-		radius: radiusEmu ? emuToInches(radiusEmu + insetEmu) : void 0,
-		rotate: rotation,
-		flipH,
-		flipV
+		line: toPptxLine(node.outline, effectiveOpacity),
+		radius: node.radiusEmu ? emuToInches(node.radiusEmu + insetEmu) : void 0,
+		rotate: node.rotation,
+		flipH: node.flipH,
+		flipV: node.flipV
 	});
 }
-function emitEdgeStrokes(slide, frame, edgeStrokes, effectiveOpacity, rotation, flipH, flipV) {
-	if (!edgeStrokes) return;
+function emitEdgeStrokes(slide, node, effectiveOpacity) {
+	if (!node.edgeStrokes) return;
 	const emitLine = (stroke, xEmu, yEmu, widthEmu, heightEmu) => {
 		if (!stroke) return;
 		slide.addShape("line", {
@@ -10935,19 +10980,19 @@ function emitEdgeStrokes(slide, frame, edgeStrokes, effectiveOpacity, rotation,
 			w: emuToInches(widthEmu),
 			h: emuToInches(heightEmu),
 			line: toPptxLine(stroke, effectiveOpacity),
-			rotate: rotation,
-			flipH,
-			flipV
+			rotate: node.rotation,
+			flipH: node.flipH,
+			flipV: node.flipV
 		});
 	};
-	emitLine(edgeStrokes.top, frame.xEmu, frame.yEmu, frame.widthEmu, 0);
-	emitLine(edgeStrokes.right, frame.xEmu + frame.widthEmu, frame.yEmu, 0, frame.heightEmu);
-	emitLine(edgeStrokes.bottom, frame.xEmu, frame.yEmu + frame.heightEmu, frame.widthEmu, 0);
-	emitLine(edgeStrokes.left, frame.xEmu, frame.yEmu, 0, frame.heightEmu);
+	emitLine(node.edgeStrokes.top, node.frame.xEmu, node.frame.yEmu, node.frame.widthEmu, 0);
+	emitLine(node.edgeStrokes.right, node.frame.xEmu + node.frame.widthEmu, node.frame.yEmu, 0, node.frame.heightEmu);
+	emitLine(node.edgeStrokes.bottom, node.frame.xEmu, node.frame.yEmu + node.frame.heightEmu, node.frame.widthEmu, 0);
+	emitLine(node.edgeStrokes.left, node.frame.xEmu, node.frame.yEmu, 0, node.frame.heightEmu);
 }
-function emitBackgroundLayers(slide, frame, backgroundLayers, shapeName, radiusEmu, effectiveOpacity, rotation, flipH, flipV) {
-	if (!backgroundLayers || backgroundLayers.length === 0) return;
-	for (const layer of backgroundLayers) {
+function emitBackgroundLayers(slide, node, shapeName, effectiveOpacity) {
+	if (!node.backgroundLayers || node.backgroundLayers.length === 0) return;
+	for (const layer of node.backgroundLayers) {
 		if (isBackgroundImageLayer(layer)) {
 			for (const tile of expandBackgroundImageLayer(layer)) slide.addImage({
 				x: emuToInches(tile.frame.xEmu),
@@ -10957,13 +11002,13 @@ function emitBackgroundLayers(slide, frame, backgroundLayers, shapeName, radiusE
 				path: tile.source.kind === "path" ? tile.source.path : void 0,
 				data: tile.source.kind === "data" ? tile.source.data : void 0,
 				transparency: combineTransparency(layer.transparency, effectiveOpacity),
-				rotate: rotation,
-				flipH,
-				flipV
+				rotate: node.rotation,
+				flipH: node.flipH,
+				flipV: node.flipV
 			});
 			continue;
 		}
-		const layerFrame = "frame" in layer && layer.frame ? layer.frame : frame;
+		const layerFrame = "frame" in layer && layer.frame ? layer.frame : node.frame;
 		slide.addShape(shapeName, {
 			x: emuToInches(layerFrame.xEmu),
 			y: emuToInches(layerFrame.yEmu),
@@ -10971,18 +11016,19 @@ function emitBackgroundLayers(slide, frame, backgroundLayers, shapeName, radiusE
 			h: emuToInches(layerFrame.heightEmu),
 			fill: toPptxFill(layer, effectiveOpacity),
 			line: TRANSPARENT_LINE,
-			radius: radiusEmu ? emuToInches(radiusEmu) : void 0,
-			rotate: rotation,
-			flipH,
-			flipV
+			radius: node.radiusEmu ? emuToInches(node.radiusEmu) : void 0,
+			rotate: node.rotation,
+			flipH: node.flipH,
+			flipV: node.flipV
 		});
 	}
 }
 function emitText(slide, node, inheritedOpacity) {
 	const effectiveOpacity = combineOpacities(inheritedOpacity, node.opacity);
-	emitOutlineShape(slide, node.radiusEmu && node.radiusEmu > 0 ? "roundRect" : "rect", node.frame, node.outline, node.radiusEmu, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	emitEdgeStrokes(slide, node.frame, node.edgeStrokes, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	emitBackgroundLayers(slide, node.frame, node.backgroundLayers, node.radiusEmu && node.radiusEmu > 0 ? "roundRect" : "rect", node.radiusEmu, effectiveOpacity, node.rotation, node.flipH, node.flipV);
+	const shapeName = node.radiusEmu && node.radiusEmu > 0 ? "roundRect" : "rect";
+	emitOutlineShape(slide, shapeName, node, effectiveOpacity);
+	emitEdgeStrokes(slide, node, effectiveOpacity);
+	emitBackgroundLayers(slide, node, shapeName, effectiveOpacity);
 	const textContent = node.content.runs ? node.content.runs.map((run) => {
 		const options = toPptxTextRunOptions(run.style);
 		return {
@@ -11009,7 +11055,10 @@ function emitText(slide, node, inheritedOpacity) {
 		lineSpacingMultiple: node.style.lineSpacingMultiple,
 		paraSpaceBefore: node.style.paragraphSpacingBefore,
 		paraSpaceAfter: node.style.paragraphSpacingAfter,
-		tabStops: toPptxTabStops(node.style.tabStops),
+		tabStops: node.style.tabStops?.map((tabStop) => ({
+			position: tabStop.positionIn,
+			...tabStop.alignment ? { alignment: tabStop.alignment } : {}
+		})),
 		charSpacing: node.style.charSpacing,
 		bullet: toPptxBullet(node.style.list),
 		rtlMode: node.style.rtlMode,
@@ -11018,7 +11067,7 @@ function emitText(slide, node, inheritedOpacity) {
 		subscript: node.style.subscript,
 		fit: node.style.fit,
 		wrap: node.style.wrap,
-		shape: node.radiusEmu && node.radiusEmu > 0 ? "roundRect" : "rect",
+		shape: shapeName,
 		fill: toPptxFill(node.fill, effectiveOpacity),
 		line: toPptxLine(node.stroke, effectiveOpacity),
 		shadow: toPptxShadow(node.shadow, effectiveOpacity),
@@ -11050,10 +11099,11 @@ function emitImage(slide, node, inheritedOpacity) {
 }
 function emitShape(slide, node, inheritedOpacity) {
 	const effectiveOpacity = combineOpacities(inheritedOpacity, node.opacity);
-	emitOutlineShape(slide, mapShapeName(node.shape, node.radiusEmu), node.frame, node.outline, node.radiusEmu, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	emitEdgeStrokes(slide, node.frame, node.edgeStrokes, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	emitBackgroundLayers(slide, node.frame, node.backgroundLayers, mapShapeName(node.shape, node.radiusEmu), node.radiusEmu, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	slide.addShape(mapShapeName(node.shape, node.radiusEmu), {
+	const shapeName = mapShapeName(node.shape, node.radiusEmu);
+	emitOutlineShape(slide, shapeName, node, effectiveOpacity);
+	emitEdgeStrokes(slide, node, effectiveOpacity);
+	emitBackgroundLayers(slide, node, shapeName, effectiveOpacity);
+	slide.addShape(shapeName, {
 		x: emuToInches(node.frame.xEmu),
 		y: emuToInches(node.frame.yEmu),
 		w: emuToInches(node.frame.widthEmu),
@@ -11069,10 +11119,11 @@ function emitShape(slide, node, inheritedOpacity) {
 }
 function emitGroup(slide, node, inheritedOpacity) {
 	const effectiveOpacity = combineOpacities(inheritedOpacity, node.opacity);
-	emitOutlineShape(slide, mapShapeName("rect", node.radiusEmu), node.frame, node.outline, node.radiusEmu, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	emitEdgeStrokes(slide, node.frame, node.edgeStrokes, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	emitBackgroundLayers(slide, node.frame, node.backgroundLayers, mapShapeName("rect", node.radiusEmu), node.radiusEmu, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	if (node.fill || node.stroke || node.shadow) slide.addShape(mapShapeName("rect", node.radiusEmu), {
+	const shapeName = mapShapeName("rect", node.radiusEmu);
+	emitOutlineShape(slide, shapeName, node, effectiveOpacity);
+	emitEdgeStrokes(slide, node, effectiveOpacity);
+	emitBackgroundLayers(slide, node, shapeName, effectiveOpacity);
+	if (node.fill || node.stroke || node.shadow) slide.addShape(shapeName, {
 		x: emuToInches(node.frame.xEmu),
 		y: emuToInches(node.frame.yEmu),
 		w: emuToInches(node.frame.widthEmu),
@@ -11084,60 +11135,110 @@ function emitGroup(slide, node, inheritedOpacity) {
 		flipH: node.flipH,
 		flipV: node.flipV
 	});
-	for (const child of node.children) emitNode(slide, child, effectiveOpacity);
+	for (const child of node.children) emitElement(slide, child, effectiveOpacity);
 }
-function emitNode(slide, node, inheritedOpacity) {
+function emitElement(slide, node, inheritedOpacity) {
 	if (node.visibility === "hidden") return;
 	switch (node.kind) {
 		case "group":
 			emitGroup(slide, node, inheritedOpacity);
 			return;
-		case "text":
-			emitText(slide, node, inheritedOpacity);
-			return;
 		case "image":
 			emitImage(slide, node, inheritedOpacity);
 			return;
 		case "shape":
 			emitShape(slide, node, inheritedOpacity);
 			return;
-		default: assertNever(node);
+		case "text":
+			emitText(slide, node, inheritedOpacity);
+			return;
 	}
 }
-function pptxgenjsBackend() {
+function emitSlideBackgroundLayers(slide, projection, backgroundLayers) {
+	if (!backgroundLayers || backgroundLayers.length === 0) return;
+	for (const layer of backgroundLayers) {
+		if (isBackgroundImageLayer(layer)) {
+			for (const tile of expandBackgroundImageLayer(layer)) slide.addImage({
+				x: emuToInches(tile.frame.xEmu),
+				y: emuToInches(tile.frame.yEmu),
+				w: emuToInches(tile.frame.widthEmu),
+				h: emuToInches(tile.frame.heightEmu),
+				path: tile.source.kind === "path" ? tile.source.path : void 0,
+				data: tile.source.kind === "data" ? tile.source.data : void 0,
+				transparency: layer.transparency
+			});
+			continue;
+		}
+		const layerFrame = "frame" in layer && layer.frame ? layer.frame : {
+			xEmu: 0,
+			yEmu: 0,
+			widthEmu: projection.size.widthEmu,
+			heightEmu: projection.size.heightEmu
+		};
+		slide.addShape("rect", {
+			x: emuToInches(layerFrame.xEmu),
+			y: emuToInches(layerFrame.yEmu),
+			w: emuToInches(layerFrame.widthEmu),
+			h: emuToInches(layerFrame.heightEmu),
+			fill: toPptxFill(layer),
+			line: TRANSPARENT_LINE
+		});
+	}
+}
+function adapterDiagnostics() {
+	return createDiagnostics([diagnostic({
+		severity: "warning",
+		code: "W_PPTXGENJS_TEMPORARY_ADAPTER",
+		title: "pptxgenjs adapter is temporary",
+		message: "The pptxgenjs adapter consumes the Pptx Package Model directly, but it cannot serialize every projected package-part detail yet.",
+		labels: [{
+			path: "render.adapter",
+			message: "Some package metadata is adapter-limited."
+		}]
+	})]);
+}
+async function renderPptxPackageWithPptxGenjs(projection) {
+	const pptx = new PptxGenJS();
+	const layoutName = "DECKJSX_CUSTOM";
+	pptx.defineLayout({
+		name: layoutName,
+		width: projection.size.widthEmu / EMU_PER_INCH,
+		height: projection.size.heightEmu / EMU_PER_INCH
+	});
+	pptx.layout = layoutName;
+	if (projection.meta?.author) pptx.author = projection.meta.author;
+	if (projection.meta?.title) pptx.title = projection.meta.title;
+	if (projection.meta?.subject) pptx.subject = projection.meta.subject;
+	for (const slidePart of projection.slides) {
+		const slide = pptx.addSlide();
+		if (slidePart.payload.background) slide.background = toPptxFill(slidePart.payload.background);
+		emitSlideBackgroundLayers(slide, projection, slidePart.payload.backgroundLayers);
+		for (const element of slidePart.payload.elements) emitElement(slide, element);
+	}
+	const bytes = await patchPresentationXml(normalizeBuffer(await pptx.write({ outputType: "uint8array" })), projection);
+	return {
+		diagnostics: adapterDiagnostics(),
+		artifact: {
+			format: "pptx",
+			mediaType: PPTX_MIME_TYPE,
+			extension: "pptx",
+			bytes
+		}
+	};
+}
+//#endregion
+//#region src/adapter.ts
+function pptxgenjs(options = {}) {
 	return {
+		kind: "deckjsx.writerAdapter",
 		name: "pptxgenjs",
-		async emit(ir) {
-			const pptx = new PptxGenJS();
-			const layoutName = "DECKJSX_CUSTOM";
-			pptx.defineLayout({
-				name: layoutName,
-				width: ir.size.widthEmu / EMU_PER_INCH,
-				height: ir.size.heightEmu / EMU_PER_INCH
-			});
-			pptx.layout = layoutName;
-			if (ir.meta?.author) pptx.author = ir.meta.author;
-			if (ir.meta?.title) pptx.title = ir.meta.title;
-			if (ir.meta?.subject) pptx.subject = ir.meta.subject;
-			for (const slideIR of ir.slides) {
-				const slide = pptx.addSlide();
-				if (slideIR.background) slide.background = toPptxFill(slideIR.background);
-				emitBackgroundLayers(slide, {
-					xEmu: 0,
-					yEmu: 0,
-					widthEmu: ir.size.widthEmu,
-					heightEmu: ir.size.heightEmu
-				}, slideIR.backgroundLayers, "rect");
-				for (const node of slideIR.nodes) emitNode(slide, node);
-			}
-			return {
-				kind: "buffer",
-				mimeType: PPTX_MIME_TYPE,
-				data: await patchPresentationXml(normalizeBuffer(await pptx.write({ outputType: "uint8array" })), ir),
-				extension: "pptx"
-			};
+		projectionFormat: "pptx",
+		format: "pptx",
+		options,
+		async render(projection) {
+			return renderPptxPackageWithPptxGenjs(projection);
 		}
 	};
 }
 //#endregion
-export { EMU_PER_INCH as n, POINTS_PER_INCH as r, pptxgenjsBackend as t };
+export { diagnostic as a, SemanticGraphDiagnosticError as c, formatDiagnostics as d, createDiagnostics as i, StyleDiagnosticError as l, EMU_PER_INCH as n, CompositionDiagnosticError as o, POINTS_PER_INCH as r, DeckDiagnosticError as s, pptxgenjs as t, formatDiagnostic as u };

package/dist/adapter-C8xw46nz.d.mts

@@ -0,0 +1,22 @@
+import { Yt as Diagnostics } from "./index-C5l8PX5V.mjs";
+import { F as OutputFormat, L as ProjectionFormat, s as PptxPackageModel, z as RenderedArtifact } from "./pptx-PzEK54aA.mjs";
+
+//#region src/adapter.d.ts
+type RenderOptions = {
+  readonly output?: string;
+};
+type WriterAdapterResult<TFormat extends OutputFormat = OutputFormat> = {
+  readonly diagnostics: Diagnostics;
+  readonly artifact?: RenderedArtifact<TFormat>;
+};
+type WriterAdapter<TProjection = unknown, TFormat extends OutputFormat = OutputFormat> = {
+  readonly kind: "deckjsx.writerAdapter";
+  readonly name: string;
+  readonly projectionFormat: ProjectionFormat;
+  readonly format: TFormat;
+  readonly options: RenderOptions;
+  render(projection: TProjection): Promise<WriterAdapterResult<TFormat>>;
+};
+declare function pptxgenjs(options?: RenderOptions): WriterAdapter<PptxPackageModel, "pptx">;
+//#endregion
+export { pptxgenjs as i, WriterAdapter as n, WriterAdapterResult as r, RenderOptions as t };

package/dist/adapter.d.mts

@@ -0,0 +1,2 @@
+import { i as pptxgenjs, n as WriterAdapter, r as WriterAdapterResult, t as RenderOptions } from "./adapter-C8xw46nz.mjs";
+export { RenderOptions, WriterAdapter, WriterAdapterResult, pptxgenjs };

package/dist/adapter.mjs

@@ -0,0 +1,2 @@
+import { t as pptxgenjs } from "./adapter-BbtteJ7s.mjs";
+export { pptxgenjs };