wand-decks-kit 0.9.0 → 0.11.0

package/examples/template.json

@@ -665,6 +665,106 @@
         }
       ]
     },
+    {
+      "layout": "flowCompare",
+      "tag": "Why three years of AI spend has not moved the operating line",
+      "titleText": "Every AI tool you own ends at a person.",
+      "lanes": [
+        {
+          "label": "Today — AI as a tool",
+          "caption": "Capacity = your people. Four of five steps wait on a person; that person is the ceiling.",
+          "steps": [
+            {
+              "who": "Person",
+              "step": "Notices",
+              "human": true
+            },
+            {
+              "who": "Person",
+              "step": "Gathers context",
+              "human": true
+            },
+            {
+              "who": "Person",
+              "step": "Instructs",
+              "human": true
+            },
+            {
+              "who": "AI",
+              "step": "Drafts"
+            },
+            {
+              "who": "Person",
+              "step": "Checks",
+              "human": true
+            }
+          ]
+        },
+        {
+          "label": "With Wand — AI as labor",
+          "caption": "Capacity = people + agents. The person moves from every step to the one step that needs judgment.",
+          "steps": [
+            {
+              "who": "Agent",
+              "step": "Notices"
+            },
+            {
+              "who": "Agent",
+              "step": "Plans"
+            },
+            {
+              "who": "Agent",
+              "step": "Executes"
+            },
+            {
+              "who": "Agent",
+              "step": "Grades"
+            },
+            {
+              "who": "Manager",
+              "step": "Approves",
+              "human": true
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "layout": "timeline",
+      "tag": "Transformation journey",
+      "titleText": "The transformation timeline.",
+      "subtitleText": "From the starting line, month over month, compounding.",
+      "phases": [
+        {
+          "when": "3–6 months",
+          "label": "Foundation",
+          "bullets": [
+            "A core transformation team of 7–10 people",
+            "One registry covering people and agents",
+            "5–10 core processes rebuilt for the dual workforce",
+            "Dozens of agents in production with named managers"
+          ]
+        },
+        {
+          "when": "6–12 months",
+          "label": "Scale",
+          "bullets": [
+            "Agents across dozens of core functions",
+            "Management structure rebalanced; spans widened",
+            "Hundreds of agents in production"
+          ]
+        },
+        {
+          "when": "12–24 months",
+          "label": "Accelerate",
+          "bullets": [
+            "Most processes designed for a dual workforce from the start",
+            "Whole functions run by agent teams",
+            "Cost per unit of work structurally below the market"
+          ]
+        }
+      ]
+    },
     {
       "layout": "closing",
       "eyebrow": "THE CLOSE",

package/lib/layouts_consult.js

@@ -215,7 +215,7 @@ module.exports = function attach(W) {
       });
       s.addShape("roundRect", {
         x: L + LAB, y: ry, w: COL, h: trh, rectRadius: radius(COL, trh),
-        fill: { color: dark ? T.cardMuted : T.surface }, line: { width: 0 },
+        fill: { color: dark ? T.cardMuted : T.surface }, line: { type: "none" },
       });
       s.addText(row.left, {
         x: L + LAB + 0.18, y: ry, w: COL - 0.36, h: trh, margin: 0, isTextBox: true,

package/lib/pdf.js

@@ -112,6 +112,37 @@ class Doc {
     return this;
   }
 
+  /**
+   * A filled triangle in its box, pointing up — or right when rotated 90°, the
+   * way a flow connector is drawn. Matches pptxgenjs's "triangle" + rotate.
+   */
+  triangle({ x, y, w, h, fill, rotate = 0 }) {
+    const o = this.page.ops;
+    const pts = rotate === 90
+      ? [[x, y], [x + w, y + h / 2], [x, y + h]]
+      : [[x, y + h], [x + w / 2, y], [x + w, y + h]];
+    o.push(`${rgb(fill || "000000")} rg`,
+      pts.map(([px, py], i) => `${num(px * PT)} ${num(this._y(py))} ${i ? "l" : "m"}`).join(" ") + " h f");
+    return this;
+  }
+
+  /** A filled polygon, optionally translucent — an area chart's fill. */
+  poly({ points, fill, opacity }) {
+    const o = this.page.ops;
+    const soft = opacity != null && opacity < 1;
+    if (soft) o.push("q", `/${this._alpha(opacity)} gs`);
+    o.push(`${rgb(fill || "000000")} rg`,
+      points.map(([px, py], i) => `${num(px * PT)} ${num(this._y(py))} ${i ? "l" : "m"}`).join(" ") + " h f");
+    if (soft) o.push("Q");
+    return this;
+  }
+
+  /** Width of a string in inches, for centring a label without drawing it. */
+  measure(str, { stem, size }) {
+    const F = this._font(stem);
+    return (F.font.layout(String(str)).advanceWidth / F.font.unitsPerEm) * size / 72;
+  }
+
   line({ x1, y1, x2, y2, color = "000000", width = 0.75 }) {
     this.page.ops.push(`${rgb(color)} RG`, `${num(width)} w`,
       `${num(x1 * PT)} ${num(this._y(y1))} m ${num(x2 * PT)} ${num(this._y(y2))} l S`);

package/lib/render_pdf.js

@@ -140,6 +140,7 @@ function renderTrace(trace, out, opts = {}) {
       if (sh.kind === "shape") drawShape(d, sh);
       else if (sh.kind === "image") drawImage(d, sh, missing);
       else if (sh.kind === "text") drawText(d, sh);
+      else if (sh.kind === "chart") drawChart(d, sh);
     }
   }
   fs.writeFileSync(out, d.toBuffer());
@@ -152,6 +153,7 @@ function drawShape(d, sh) {
   const stroke = sh.line && sh.line.width ? (sh.line.color || "000000").replace(/^#/, "") : null;
   const box = { x: sh.x || 0, y: sh.y || 0, w: sh.w || 0, h: sh.h || 0 };
   if (sh.type === "ellipse") return d.ellipse({ ...box, fill, stroke, lineWidth: (sh.line && sh.line.width) || 0.75 });
+  if (sh.type === "triangle") return d.triangle({ ...box, fill, rotate: sh.rotate || 0 });
   d.rect({
     ...box, fill, stroke,
     lineWidth: (sh.line && sh.line.width) || 0.75,
@@ -161,6 +163,68 @@ function drawShape(d, sh) {
   });
 }
 
+/** Round up to a gridline-friendly maximum: 87 -> 100, 3.2 -> 4, 460 -> 500. */
+function niceMax(v) {
+  if (!(v > 0)) return 1;
+  const p = Math.pow(10, Math.floor(Math.log10(v))), m = v / p;
+  return (m <= 1 ? 1 : m <= 2 ? 2 : m <= 2.5 ? 2.5 : m <= 5 ? 5 : 10) * p;
+}
+
+/**
+ * The chart as PowerPoint draws it: legend on top, four gridlines, category
+ * labels under the plot. Not pixel-identical to PowerPoint's own layout — close
+ * enough that a slide which reads here reads there.
+ */
+function drawChart(d, sh) {
+  const c = sh.chart || {}, labels = c.labels || [], series = c.series || [];
+  const stem = "Geist-Regular", sz = 7;
+  const legendH = c.legend ? 0.26 : 0, padL = 0.40, padB = 0.26;
+  const px = sh.x + padL, py = sh.y + legendH + 0.06, pw = sh.w - padL - 0.08, ph = sh.h - legendH - padB - 0.06;
+  const max = c.yMax || niceMax(Math.max(0, ...series.flatMap((x) => x.values || [])));
+  const fmt = (v) => (Math.round(v * 100) / 100).toString();
+  for (let k = 0; k <= 4; k++) {
+    const gy = py + ph - (ph * k) / 4;
+    d.line({ x1: px, y1: gy, x2: px + pw, y2: gy, color: c.grid || "5B4BB0", width: 0.5 });
+    const lab = fmt((max * k) / 4);
+    d.text(lab, { x: px - 0.08 - d.measure(lab, { stem, size: sz }), y: gy + 0.03, stem, size: sz, color: c.ink || "BBBBBB" });
+  }
+  const n = labels.length, bar = c.kind === "bar";
+  const xAt = (i) => bar ? px + (pw / n) * (i + 0.5) : px + (n > 1 ? (pw * i) / (n - 1) : pw / 2);
+  const yAt = (v) => py + ph - (ph * Math.min(v, max)) / max;
+  labels.forEach((l, i) => {
+    const w = d.measure(l, { stem, size: sz });
+    const lx = Math.min(Math.max(xAt(i) - w / 2, px), px + pw - w);
+    d.text(l, { x: lx, y: py + ph + 0.17, stem, size: sz, color: c.ink || "BBBBBB" });
+  });
+  series.forEach((ser, si) => {
+    const col = (c.colors && c.colors[si]) || "8B7CF6", vals = ser.values || [];
+    if (bar) {
+      const slot = pw / n, group = slot * 0.62, bw = group / series.length;
+      vals.forEach((v, i) => {
+        const bx = px + slot * i + (slot - group) / 2 + bw * si;
+        d.rect({ x: bx, y: yAt(v), w: bw * 0.92, h: py + ph - yAt(v), fill: col });
+      });
+      return;
+    }
+    if (c.kind === "area") {
+      d.poly({ points: [[xAt(0), py + ph], ...vals.map((v, i) => [xAt(i), yAt(v)]), [xAt(vals.length - 1), py + ph]],
+               fill: col, opacity: 0.45 });
+    }
+    if (c.kind === "area") return;   // PowerPoint's area chart has no outline
+    for (let i = 1; i < vals.length; i++) {
+      d.line({ x1: xAt(i - 1), y1: yAt(vals[i - 1]), x2: xAt(i), y2: yAt(vals[i]), color: col, width: ser.emph ? 2.5 : 2 });
+    }
+  });
+  if (c.legend) {
+    let lx = px;
+    series.forEach((ser, si) => {
+      d.rect({ x: lx, y: sh.y + 0.08, w: 0.1, h: 0.1, fill: (c.colors && c.colors[si]) || "8B7CF6" });
+      d.text(ser.name, { x: lx + 0.15, y: sh.y + 0.17, stem, size: 8, color: c.ink || "BBBBBB" });
+      lx += 0.15 + d.measure(ser.name, { stem, size: 8 }) + 0.3;
+    });
+  }
+}
+
 function drawImage(d, sh, missing) {
   const box = { x: sh.x || 0, y: sh.y || 0, w: sh.w || 0, h: sh.h || 0 };
   if (sh.data) {                                   // a recoloured glyph, inline

package/lib/schema.js

@@ -27,6 +27,8 @@ const COMMON = {
   subtitleText: str({ note: "the lede under the title" }),
   deck: str({ note: "overrides the deck-level footer" }),
   confidential: str(),
+  notes: s("notes", { note: 'speaker notes — a string, or { time: "00:21 to 00:25", core: true, text, watch }' }),
+  backup: s("boolean", { note: "a hidden slide after the closing; its footer says BACKUP" }),
 };
 
 const L = {
@@ -43,7 +45,8 @@ const L = {
   divider: {
     use: "Section breaks. Always dark, keeps the tag, drops the footer. Prose goes in `body`",
     bleed: true,
-    fields: { eyebrow: str(), titleText: s("title", req()), body: str() },
+    fields: { eyebrow: str(), titleText: s("title", req()), body: str(),
+              part: str({ note: '"Part II" — set before the body as "Part II  ·  <body>"' }) },
   },
   closing: {
     use: "Last slide. Always dark, centred, full bleed",
@@ -54,7 +57,7 @@ const L = {
   /* ----------------------------------------------------- guideline (0.9) */
   agenda: {
     use: "What we'll cover — 2–5 numbered cards in a row",
-    fields: { items: s("object[]", req({ min: 2, max: 5, of: { title: str(req()), body: str() } })) },
+    fields: { items: s("object[]", req({ min: 2, max: 5, of: { title: str(req()), body: str(), meta: str({ note: '"15 min"' }) } })) },
   },
   team: {
     use: "Who's in the room — 2–4 people, each with a headshot slot the user fills",
@@ -70,7 +73,33 @@ const L = {
   },
   coDelivery: {
     use: "Up to six numbered rows in two columns — a co-delivery model, operating principles",
-    fields: { items: s("object[]", req({ min: 2, max: 6, of: { title: str(req()), body: str(req()) } })) },
+    fields: { items: s("object[]", req({ min: 2, max: 6, of: { title: str(req()), body: str(req()), meta: str({ note: '"15 min" — makes it the session agenda' }) } })) },
+  },
+  flowCompare: {
+    use: "Two lanes of steps — today vs with Wand. Mark the steps a person does `human: true`",
+    fields: { lanes: s("object[]", req({ min: 2, max: 2, of: {
+      label: str(req()), caption: str(),
+      steps: s("object[]", req({ min: 3, max: 5, of: { who: str(), step: str(req()), human: s("boolean") } })),
+    } })) },
+  },
+  chart: {
+    use: "A native chart the seller can edit in PowerPoint — line, area or bar — with up to two argument blocks beside or below it",
+    fields: {
+      kind: str({ note: '"line" (default), "area" or "bar"' }),
+      labels: s("string[]", req({ min: 2, max: 12, note: "the categories along the bottom" })),
+      series: s("object[]", req({ min: 1, max: 3, of: {
+        name: str(req()), values: s("number[]", req()), emph: s("boolean"),
+      } })),
+      yMax: s("number"), yLabel: str(),
+      side: s("object[]", { max: 2, of: { title: str(req()), body: str(req()) } }),
+      sidePlace: str({ note: '"right" (default) or "below"' }),
+    },
+  },
+  timeline: {
+    use: "A journey in 2–4 phases on a line — months, a label, bullets",
+    fields: { phases: s("object[]", req({ min: 2, max: 4, of: {
+      when: str(), label: str(req()), bullets: s("string[]", { max: 6 }),
+    } })) },
   },
 
   /* --------------------------------------------------------------- content */
@@ -320,8 +349,10 @@ const TYPEOF = {
   boolean: (v) => typeof v === "boolean",
   title: (v) => typeof v === "string" || (Array.isArray(v) && v.every((x) => typeof x === "string")),
   "string[]": (v) => Array.isArray(v) && v.every((x) => typeof x === "string"),
+  "number[]": (v) => Array.isArray(v) && v.every((x) => typeof x === "number" && Number.isFinite(x)),
   "object[]": (v) => Array.isArray(v) && v.every((x) => x && typeof x === "object" && !Array.isArray(x)),
   object: (v) => v && typeof v === "object" && !Array.isArray(v),
+  notes: (v) => typeof v === "string" || (v && typeof v === "object" && !Array.isArray(v)),
 };
 
 function checkFields(defs, value, path, errs, warns) {
@@ -395,6 +426,23 @@ function validate(spec) {
     seen.push(sl.layout);
   });
 
+  // a chart whose series do not match its labels draws a line that ends early
+  spec.slides.forEach((x, i) => {
+    if (x.layout !== "chart" || !Array.isArray(x.labels) || !Array.isArray(x.series)) return;
+    x.series.forEach((ser) => {
+      if (Array.isArray(ser.values) && ser.values.length !== x.labels.length)
+        errs.push(`S${i + 1} chart series "${ser.name}" has ${ser.values.length} values for ${x.labels.length} labels`);
+    });
+  });
+
+  // backups live after the close — hidden, so they never interrupt the room
+  const closeAt = spec.slides.findIndex((x) => x.layout === "closing");
+  spec.slides.forEach((x, i) => {
+    if (x.backup && closeAt >= 0 && i < closeAt) warns.push(`S${i + 1} is a backup slide before the closing — move it after S${closeAt + 1}`);
+    if (x.notes && typeof x.notes === "object" && x.notes.time && !/\d\d:\d\d/.test(x.notes.time))
+      warns.push(`S${i + 1} notes.time "${x.notes.time}" is not a time window — use "00:21 to 00:25"`);
+  });
+
   // §5: vary the layouts, alternate the themes
   const distinct = new Set(seen).size;
   if (spec.slides.length >= 10 && distinct < 8) {

package/lib/trace.js

@@ -18,7 +18,12 @@ function fakeSlide() {
     addImage(o)       { shapes.push({ kind: "image", ...o }); return api; },
     addText(t, o)     { shapes.push({ kind: "text", runs: normaliseRuns(t), ...o }); return api; },
     addNotes()        { return api; },
-    addChart()        { return api; },
+    // a chart is recorded by what it shows, so the PDF and preview can draw
+    // the same thing PowerPoint will
+    addChart(type, data, o = {}) {
+      shapes.push({ kind: "chart", type, x: o.x, y: o.y, w: o.w, h: o.h, chart: o._wand || { kind: type, series: data } });
+      return api;
+    },
   };
   Object.defineProperty(api, "background", {
     get() { return api._bg; },
@@ -52,7 +57,7 @@ function fakePres() {
 function trace(W, spec) {
   const pres = fakePres();
   pres.layout = "LAYOUT_16x9";
-  const total = spec.slides.length;
+  const total = spec.slides.filter((x) => !x.backup).length;
   let n = 0;
   const errors = [];
 
@@ -63,12 +68,12 @@ function trace(W, spec) {
       return;
     }
     const fullBleed = ["cover", "divider", "closing"].includes(sl.layout);
-    n += 1;
-    const args = { ...sl, n, total };
+    const args = { ...sl, n: sl.backup ? null : ++n, total };
     if (!fullBleed) {
       args.deck = sl.deck || spec.deck;
       args.confidential = sl.confidential || spec.confidential;
     }
+    W.context({ confidential: args.confidential || "STRICTLY CONFIDENTIAL" });
     try { fn(pres, args); }
     catch (e) { errors.push(`slide ${i + 1} (${sl.layout}): ${e.message}`); }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wand-decks-kit",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Rebuilds or authors a client-ready .pptx on the Wand design system: measured fit, embedded Geist, verbatim content.",
   "license": "SEE LICENSE IN PROMPT.md",
   "bin": {

package/preview/preview.css

@@ -90,6 +90,8 @@ header input[type="range"] { width: 120px; accent-color: var(--accent); }
 
 .sh.rect      { border-radius: 0; }
 .sh.roundRect { border-radius: calc(var(--in) * .10); }
+/* flow connectors: pptxgenjs triangle rotated 90 points right */
+.sh.triangle  { clip-path: polygon(0 0, 100% 50%, 0 100%); }
 .sh.ellipse   { border-radius: 50%; }
 
 .sh.image { object-fit: contain; }

package/preview/preview.js

@@ -95,7 +95,10 @@
 
       const s = document.createElement("div");
       const bg = sl.background && sl.background.color;
-      s.className = "slide " + (bg && bg.toUpperCase() === "0F0C26" ? "dark" : "light");
+      // by luminance, not by one hex: the dark ground moved from 0F0C26 to
+      // 240F48 in 0.9 and every dark slide previewed as light
+      const lum = bg ? (parseInt(bg.slice(0, 2), 16) * 299 + parseInt(bg.slice(2, 4), 16) * 587 + parseInt(bg.slice(4, 6), 16) * 114) / 1000 : 255;
+      s.className = "slide " + (lum < 90 ? "dark" : "light");
       if (flag.checked) s.classList.add("flag");
       if (grid.checked) s.classList.add("grid");
       s.title = sl.layout;
@@ -109,6 +112,8 @@
           el.src = sh.data ? "data:" + sh.data
                  : sh.path ? (T.assetsBase || "../assets/") + sh.path.split(/[\\/]assets[\\/]/).pop()
                  : "";
+        } else if (sh.kind === "chart") {
+          el = chartEl(sh);
         } else if (sh.kind === "text") {
           el = textEl(sh);
         } else {
@@ -145,6 +150,49 @@
     });
   }
 
+  /** The same chart the PDF draws, as SVG in inches. */
+  function chartEl(sh) {
+    const c = sh.chart || {}, labels = c.labels || [], series = c.series || [];
+    const NS = "http://www.w3.org/2000/svg", W = sh.w, H = sh.h;
+    const svg = document.createElementNS(NS, "svg");
+    svg.setAttribute("class", "sh chart"); svg.setAttribute("viewBox", `0 0 ${W} ${H}`);
+    const add = (tag, a, txt) => { const e = document.createElementNS(NS, tag); for (const k in a) e.setAttribute(k, a[k]); if (txt != null) e.textContent = txt; svg.appendChild(e); return e; };
+    const legendH = c.legend ? 0.26 : 0, padL = 0.40, padB = 0.26;
+    const px = padL, py = legendH + 0.06, pw = W - padL - 0.08, ph = H - legendH - padB - 0.06;
+    const all = series.flatMap((x) => x.values || []);
+    const nice = (v) => { if (!(v > 0)) return 1; const p = Math.pow(10, Math.floor(Math.log10(v))), m = v / p; return (m <= 1 ? 1 : m <= 2 ? 2 : m <= 2.5 ? 2.5 : m <= 5 ? 5 : 10) * p; };
+    const max = c.yMax || nice(Math.max(0, ...all)), ink = "#" + (c.ink || "BBBBBB"), grid = "#" + (c.grid || "5B4BB0");
+    for (let k = 0; k <= 4; k++) {
+      const gy = py + ph - (ph * k) / 4;
+      add("line", { x1: px, y1: gy, x2: px + pw, y2: gy, stroke: grid, "stroke-width": 0.007 });
+      add("text", { x: px - 0.08, y: gy + 0.03, "text-anchor": "end", "font-size": 0.1, fill: ink, "font-family": "Geist" }, String(Math.round((max * k) / 4 * 100) / 100));
+    }
+    const n = labels.length, bar = c.kind === "bar";
+    const xAt = (i) => bar ? px + (pw / n) * (i + 0.5) : px + (n > 1 ? (pw * i) / (n - 1) : pw / 2);
+    const yAt = (v) => py + ph - (ph * Math.min(v, max)) / max;
+    labels.forEach((l, i) => add("text", { x: xAt(i), y: py + ph + 0.17, "text-anchor": "middle", "font-size": 0.1, fill: ink, "font-family": "Geist" }, l));
+    series.forEach((ser, si) => {
+      const col = "#" + ((c.colors && c.colors[si]) || "8B7CF6"), vals = ser.values || [];
+      if (bar) {
+        const slot = pw / n, group = slot * 0.62, bw = group / series.length;
+        vals.forEach((v, i) => add("rect", { x: px + slot * i + (slot - group) / 2 + bw * si, y: yAt(v), width: bw * 0.92, height: py + ph - yAt(v), fill: col }));
+        return;
+      }
+      const pts = vals.map((v, i) => `${xAt(i)},${yAt(v)}`).join(" ");
+      if (c.kind === "area") add("polygon", { points: `${xAt(0)},${py + ph} ${pts} ${xAt(vals.length - 1)},${py + ph}`, fill: col, "fill-opacity": 0.45 });
+      if (c.kind !== "area") add("polyline", { points: pts, fill: "none", stroke: col, "stroke-width": ser.emph ? 0.035 : 0.028 });
+    });
+    if (c.legend) {
+      let lx = px;
+      series.forEach((ser, si) => {
+        add("rect", { x: lx, y: 0.08, width: 0.1, height: 0.1, fill: "#" + ((c.colors && c.colors[si]) || "8B7CF6") });
+        add("text", { x: lx + 0.15, y: 0.17, "font-size": 0.11, fill: ink, "font-family": "Geist" }, ser.name);
+        lx += 0.15 + ser.name.length * 0.065 + 0.3;
+      });
+    }
+    return svg;
+  }
+
   /** Browser-side overflow detection: does the laid-out text exceed its box? */
   function markOverflow(slideEl) {
     slideEl.querySelectorAll(".sh.text").forEach((el) => {

package/qa_coverage.py

@@ -62,6 +62,13 @@ def strings_from_pptx(path):
                         paras.append("".join(runs))
                 if paras:
                     out.append((i, " ".join(paras)))
+        # Chart series names and category labels live in ppt/charts, not on the
+        # slide. A rebuilt chart that drops a series name must still fail here.
+        for n in sorted(x for x in z.namelist() if re.fullmatch(r"ppt/charts/chart\d+\.xml", x)):
+            vals = re.findall(r"<c:v>([^<]*)</c:v>|<a:t>([^<]*)</a:t>", z.read(n).decode("utf8", "ignore"))
+            words = [a or b for a, b in vals if (a or b).strip() and not re.fullmatch(r"[-\d.,%]+", a or b)]
+            if words:
+                out.append((0, " ".join(words)))
     return out
 
 

package/tools/brandlint.py

@@ -23,7 +23,9 @@ z = zipfile.ZipFile(deck)
 names = sorted((n for n in z.namelist() if re.fullmatch(r"ppt/slides/slide\d+\.xml", n)),
                key=lambda n: int(re.findall(r"\d+", n)[0]))
 pres = z.read("ppt/presentation.xml").decode()
-cx, cy = (int(v) for v in re.search(r'<p:sldSz cx="(\d+)" cy="(\d+)"', pres).groups())
+# attribute order varies by writer — the Kearney deck writes cy before cx
+tag = re.search(r"<p:sldSz[^>]*>", pres).group(0)
+cx, cy = (int(re.search(rf'{k}="(\d+)"', tag).group(1)) for k in ("cx", "cy"))
 canvas_ok = abs(cx / 914400 - 10) < 0.01 and abs(cy / 914400 - 5.625) < 0.01
 
 bad = 0

package/wand.js

@@ -10,11 +10,14 @@
  *   node wand.js doctor                      what works here, and what does not
  *   node wand.js rebuild source.pptx         phases 0-3: extract, then the worksheet
  *   node wand.js layouts [name]              the catalog, with every field
-  node wand.js glyphs  [search]            the named icon set
+ *   node wand.js glyphs  [search]            the named icon set
  *   node wand.js validate work/deck.json     fields and counts, before the build
  *   node wand.js preview  work/deck.json     browser preview at the 10in grid
  *   node wand.js ship     work/deck.json     build .pptx and .pdf, then every gate
-  node wand.js spec     deck.pptx          read back the spec a built deck carries
+ *   node wand.js show     deck.pptx [n]      one line per slide, or slide n's fields
+ *   node wand.js edit     deck.pptx --set 4.titleText="..."   patch a kit-built deck, rebuild, gate
+ *   node wand.js audit    any.pptx           every spec-free gate, incl. brand, on any deck
+ *   node wand.js spec     deck.pptx          read back the spec a built deck carries
  *
  * `rebuild` and `ship` are the two that matter. Everything else is a stage of
  * one of them, exposed so a failure can be re-run on its own.
@@ -254,6 +257,100 @@ function ship(specPath, outArg) {
   return gates.some(([, ok]) => ok === false) ? 1 : 0;
 }
 
+/* --------------------------------------------------------------- show/edit */
+
+/**
+ * Why these exist: a salesperson's edits are small — a date, a name, a title —
+ * and the old path cost two full copies of the spec in the context (read it,
+ * write it back) plus a rebuild. A 40 KB spec is ~10K tokens each way.
+ * `show` prints one line per slide, or one slide's fields; `edit` patches the
+ * spec the deck carries inside itself and ships. An edit costs a command line.
+ */
+function specOf(file) {
+  const f = path.resolve(file);
+  if (f.endsWith(".json")) return JSON.parse(fs.readFileSync(f, "utf8"));
+  const z = readZip(f);
+  if (!z.has("wand/spec.json")) die(`${rel(f)} carries no spec — it was not built by this kit.\n` +
+    "Edit it directly with the pptx tools, then run `node wand.js audit` on it (SKILL.md, \"Edit a deck they attached\").");
+  return JSON.parse(z.text("wand/spec.json"));
+}
+
+function oneLine(sl) {
+  // titleText arrays are runs of one line; titleLines are separate lines
+  const t = sl.titleText || sl.titleLines || sl.line1 || "";
+  const title = (Array.isArray(t) ? t.join(sl.titleLines && !sl.titleText ? " " : "") : String(t)).replace(/\s+/g, " ");
+  const bits = [sl.backup ? "BACKUP" : null, sl.notes ? "notes" : null, sl.dark === false ? "light" : null].filter(Boolean);
+  return `${sl.layout.padEnd(15)} ${title.slice(0, 64)}${bits.length ? "  [" + bits.join(", ") + "]" : ""}`;
+}
+
+function show(file, which) {
+  const spec = specOf(file);
+  if (which == null) {
+    console.log(`${spec.deck || "(untitled)"} — ${spec.slides.length} slides`);
+    spec.slides.forEach((sl, i) => console.log(`  ${String(i + 1).padStart(2)}  ${oneLine(sl)}`));
+    console.log("\nnode wand.js show <deck> <n>   for one slide's fields");
+    return 0;
+  }
+  const sl = spec.slides[Number(which) - 1];
+  if (!sl) die(`no slide ${which} — the deck has ${spec.slides.length}`);
+  console.log(JSON.stringify(sl, null, 1));
+  return 0;
+}
+
+/** "4.items.2.body" sets slide 4, item 2, body. 1-based, the way the room counts. */
+function setPath(spec, dotted, value) {
+  const [n, ...keys] = dotted.split(".");
+  let node = spec.slides[Number(n) - 1];
+  if (!node) die(`--set ${dotted}: no slide ${n}`);
+  if (!keys.length) die(`--set ${dotted}: name a field, e.g. ${n}.titleText`);
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = /^\d+$/.test(keys[i]) ? Number(keys[i]) - 1 : keys[i];
+    if (node[k] == null) node[k] = /^\d+$/.test(keys[i + 1]) ? [] : {};
+    node = node[k];
+  }
+  const last = keys[keys.length - 1];
+  node[/^\d+$/.test(last) ? Number(last) - 1 : last] = value;
+}
+
+/** Deck_v2.pptx -> Deck_v3.pptx; Deck.pptx -> Deck_v2.pptx. Never overwrite the input. */
+function nextVersion(file) {
+  const ext = path.extname(file), base = file.slice(0, -ext.length);
+  const m = /_v(\d+)$/.exec(base);
+  return m ? `${base.slice(0, m.index)}_v${Number(m[1]) + 1}${ext}` : `${base}_v2${ext}`;
+}
+
+function edit(file, args) {
+  const spec = specOf(file);
+  const changed = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--set") {
+      const arg = args[++i] || "", eq = arg.indexOf("=");
+      if (eq < 1) die(`--set wants N.path=value, got "${arg}"`);
+      const key = arg.slice(0, eq), raw = arg.slice(eq + 1);
+      let val; try { val = JSON.parse(raw); } catch { val = raw; }   // arrays, numbers, booleans parse; prose stays prose
+      setPath(spec, key, val); changed.push(`set ${key}`);
+    } else if (a === "--del") {
+      const n = Number(args[++i]); spec.slides.splice(n - 1, 1); changed.push(`deleted S${n}`);
+    } else if (a === "--move") {
+      const from = Number(args[++i]), to = Number(args[++i]);
+      const [sl] = spec.slides.splice(from - 1, 1); spec.slides.splice(to - 1, 0, sl); changed.push(`moved S${from} to ${to}`);
+    } else if (a === "--add") {
+      const at = Number(args[++i]); spec.slides.splice(at - 1, 0, JSON.parse(args[++i])); changed.push(`added S${at}`);
+    }
+  }
+  if (!changed.length) die("nothing to do — pass --set, --del, --move or --add");
+  console.log(changed.map((c) => "  " + c).join("\n"));
+  const work = path.join(path.dirname(path.resolve(file)), "work");
+  fs.mkdirSync(work, { recursive: true });
+  const specPath = path.join(work, "deck.json");
+  fs.writeFileSync(specPath, JSON.stringify(spec, null, 2));
+  if (args.includes("--dry")) { show(specPath); return validate(specPath) ? 1 : 0; }
+  const oi = args.indexOf("-o");
+  const out = oi >= 0 ? path.resolve(args[oi + 1]) : nextVersion(path.resolve(file));
+  return ship(specPath, out);
+}
+
 /**
  * Every gate that does not need a spec, on any .pptx.
  *
@@ -359,6 +456,13 @@ function inspect(file) {
     errs.push('fonts embedded but saveSubsetFonts is not "0" - digits garble in exported PDFs');
   }
   if (!fonts.length) errs.push("no embedded fonts - this renders as Arial on the client's machine");
+  // pptxgenjs writes its default outline — 1pt #333333 — whenever a shape asks
+  // for `line: { width: 0 }`. No Wand token is 333333, so this is always a leak.
+  let leaks = 0;
+  for (const name of z.names.filter((n) => /^ppt\/slides\/slide\d+\.xml$/.test(n))) {
+    leaks += (z.text(name).match(/<a:ln w="12700"><a:solidFill><a:srgbClr val="333333"\/>/g) || []).length;
+  }
+  if (leaks) errs.push(`${leaks} shape(s) carry pptxgenjs's default 1pt #333333 outline — a layout used line:{width:0}; use line:{type:"none"}`);
   errs.forEach((e) => console.log(`  ERROR ${e}`));
   console.log(`file        : ${slides.length} slides, ${media.length} media, ${fonts.length} font parts / ` +
               `${families} families` + (errs.length ? ` - ${errs.length} problem(s) above` : " - clean"));
@@ -486,6 +590,16 @@ to.
     process.exit(0);
   }
 
+  case "show": {
+    if (!positional[0]) die("usage: node wand.js show <deck.pptx|deck.json> [slide]");
+    process.exit(show(positional[0], positional[1]));
+  }
+
+  case "edit": {
+    if (!positional[0]) die("usage: node wand.js edit <deck.pptx> --set N.path=value [--del N] [--move N M] [--add N '<json>'] [-o out.pptx] [--dry]");
+    process.exit(edit(positional[0], rest));
+  }
+
   case "inspect":
     if (!positional[0]) die("usage: node wand.js inspect <deck.pptx>");
     process.exit(inspect(path.resolve(positional[0])) ? 1 : 0);