@jokerized/decksmith 0.9.7 → 0.9.8

package/dist/cli.js

@@ -23530,9 +23530,9 @@ function literalFindings(storyboard, source, opts = {}) {
     prevKey = { id: beat2.id, key };
   });
   const tables = beats.filter((b) => b.literal?.kind === "table");
-  if (tables.length > 1)
+  for (const t2 of tables.slice(1))
     out.push(
-      `The plan draws ${tables.length} tables (${tables.map((b) => b.id).join(", ")}). A table reads like a report: keep at most one, and draw the others as what they list \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
+      `${t2.id} draws a table, and so does ${tables[0]?.id}. A table reads like a report: keep at most one, and draw this one as what it lists \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
     );
   const byVectors = /* @__PURE__ */ new Map();
   for (const b of beats) {
@@ -23541,20 +23541,20 @@ function literalFindings(storyboard, source, opts = {}) {
     const key = JSON.stringify(l.vectors.map((v) => v.values));
     byVectors.set(key, [...byVectors.get(key) ?? [], b.id]);
   }
-  for (const ids of byVectors.values())
-    if (ids.length > 1)
+  for (const [first, ...rest] of byVectors.values())
+    for (const id2 of rest)
       out.push(
-        `${ids.join(" and ")} run operate on the same vectors, so the deck shows one chart twice. Give the second beat's chain to the first (one longer chain), or draw the second another way.`
+        `${id2} runs operate on the same vectors as ${first}, so the deck shows one chart twice. Give its chain to ${first} (one longer chain), or draw ${id2} another way.`
       );
   const forms = /* @__PURE__ */ new Map();
   for (const b of beats) {
     const f = b.literal && wordForm(b.literal);
     if (f) forms.set(f, [...forms.get(f) ?? [], b.id]);
   }
-  for (const [f, ids] of forms)
-    if (ids.length > 1)
+  for (const [f, [first, ...rest]] of forms)
+    for (const id2 of rest)
       out.push(
-        `The plan draws \`${f}\` ${ids.length} times (${ids.join(", ")}). It draws no picture, so a second one is the same slide again: keep it on one beat, and draw the others another way or with \`literal\` null.`
+        `${id2} draws \`${f}\`, as ${first} already does. It draws no picture, so a second one is the same slide again: draw ${id2} another way, or with \`literal\` null.`
       );
   return out;
 }
@@ -25008,13 +25008,39 @@ function operateVariants(v) {
   return [only(OPERATE_CHAIN, OPERATE_TERMS), only(OPERATE_TERMS)];
 }
 function schemaFor(prefs, source) {
-  return splitOperate(
-    hideFromPlanner(
-      forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
-      plannerInvisible(prefs, source)
+  return shareLiteral(
+    splitOperate(
+      hideFromPlanner(
+        forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
+        plannerInvisible(prefs, source)
+      )
     )
   );
 }
+function shareLiteral(schema) {
+  const root = schema;
+  const variants = root.properties.beats.items.anyOf;
+  const literal = variants[0]?.properties.literal;
+  if (!literal) return schema;
+  const one2 = JSON.stringify(literal);
+  if (!variants.every((v) => JSON.stringify(v.properties.literal) === one2))
+    throw new Error("schemaFor: the beat variants carry different `literal` schemas.");
+  const ref = { $ref: "#/$defs/literal" };
+  return {
+    ...root,
+    $defs: { literal },
+    properties: {
+      ...root.properties,
+      beats: {
+        ...root.properties.beats,
+        items: {
+          ...root.properties.beats.items,
+          anyOf: variants.map((v) => ({ ...v, properties: { ...v.properties, literal: ref } }))
+        }
+      }
+    }
+  };
+}
 var SCHEMA = schemaFor(prefsSchema.parse({}));
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});

package/dist/index.js

@@ -25877,9 +25877,9 @@ function literalFindings(storyboard, source, opts = {}) {
     prevKey = { id: beat2.id, key };
   });
   const tables = beats.filter((b) => b.literal?.kind === "table");
-  if (tables.length > 1)
+  for (const t2 of tables.slice(1))
     out.push(
-      `The plan draws ${tables.length} tables (${tables.map((b) => b.id).join(", ")}). A table reads like a report: keep at most one, and draw the others as what they list \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
+      `${t2.id} draws a table, and so does ${tables[0]?.id}. A table reads like a report: keep at most one, and draw this one as what it lists \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
     );
   const byVectors = /* @__PURE__ */ new Map();
   for (const b of beats) {
@@ -25888,20 +25888,20 @@ function literalFindings(storyboard, source, opts = {}) {
     const key = JSON.stringify(l.vectors.map((v) => v.values));
     byVectors.set(key, [...byVectors.get(key) ?? [], b.id]);
   }
-  for (const ids of byVectors.values())
-    if (ids.length > 1)
+  for (const [first, ...rest] of byVectors.values())
+    for (const id2 of rest)
       out.push(
-        `${ids.join(" and ")} run operate on the same vectors, so the deck shows one chart twice. Give the second beat's chain to the first (one longer chain), or draw the second another way.`
+        `${id2} runs operate on the same vectors as ${first}, so the deck shows one chart twice. Give its chain to ${first} (one longer chain), or draw ${id2} another way.`
       );
   const forms = /* @__PURE__ */ new Map();
   for (const b of beats) {
     const f = b.literal && wordForm(b.literal);
     if (f) forms.set(f, [...forms.get(f) ?? [], b.id]);
   }
-  for (const [f, ids] of forms)
-    if (ids.length > 1)
+  for (const [f, [first, ...rest]] of forms)
+    for (const id2 of rest)
       out.push(
-        `The plan draws \`${f}\` ${ids.length} times (${ids.join(", ")}). It draws no picture, so a second one is the same slide again: keep it on one beat, and draw the others another way or with \`literal\` null.`
+        `${id2} draws \`${f}\`, as ${first} already does. It draws no picture, so a second one is the same slide again: draw ${id2} another way, or with \`literal\` null.`
       );
   return out;
 }
@@ -27355,13 +27355,39 @@ function operateVariants(v) {
   return [only(OPERATE_CHAIN, OPERATE_TERMS), only(OPERATE_TERMS)];
 }
 function schemaFor(prefs, source) {
-  return splitOperate(
-    hideFromPlanner(
-      forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
-      plannerInvisible(prefs, source)
+  return shareLiteral(
+    splitOperate(
+      hideFromPlanner(
+        forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
+        plannerInvisible(prefs, source)
+      )
     )
   );
 }
+function shareLiteral(schema) {
+  const root = schema;
+  const variants = root.properties.beats.items.anyOf;
+  const literal = variants[0]?.properties.literal;
+  if (!literal) return schema;
+  const one2 = JSON.stringify(literal);
+  if (!variants.every((v) => JSON.stringify(v.properties.literal) === one2))
+    throw new Error("schemaFor: the beat variants carry different `literal` schemas.");
+  const ref = { $ref: "#/$defs/literal" };
+  return {
+    ...root,
+    $defs: { literal },
+    properties: {
+      ...root.properties,
+      beats: {
+        ...root.properties.beats,
+        items: {
+          ...root.properties.beats.items,
+          anyOf: variants.map((v) => ({ ...v, properties: { ...v.properties, literal: ref } }))
+        }
+      }
+    }
+  };
+}
 var SCHEMA = schemaFor(prefsSchema.parse({}));
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});

package/dist/mcp.js

@@ -24389,9 +24389,9 @@ function literalFindings(storyboard, source, opts = {}) {
     prevKey = { id: beat.id, key };
   });
   const tables = beats.filter((b) => b.literal?.kind === "table");
-  if (tables.length > 1)
+  for (const t2 of tables.slice(1))
     out.push(
-      `The plan draws ${tables.length} tables (${tables.map((b) => b.id).join(", ")}). A table reads like a report: keep at most one, and draw the others as what they list \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
+      `${t2.id} draws a table, and so does ${tables[0]?.id}. A table reads like a report: keep at most one, and draw this one as what it lists \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
     );
   const byVectors = /* @__PURE__ */ new Map();
   for (const b of beats) {
@@ -24400,20 +24400,20 @@ function literalFindings(storyboard, source, opts = {}) {
     const key = JSON.stringify(l.vectors.map((v) => v.values));
     byVectors.set(key, [...byVectors.get(key) ?? [], b.id]);
   }
-  for (const ids of byVectors.values())
-    if (ids.length > 1)
+  for (const [first, ...rest] of byVectors.values())
+    for (const id2 of rest)
       out.push(
-        `${ids.join(" and ")} run operate on the same vectors, so the deck shows one chart twice. Give the second beat's chain to the first (one longer chain), or draw the second another way.`
+        `${id2} runs operate on the same vectors as ${first}, so the deck shows one chart twice. Give its chain to ${first} (one longer chain), or draw ${id2} another way.`
       );
   const forms = /* @__PURE__ */ new Map();
   for (const b of beats) {
     const f = b.literal && wordForm(b.literal);
     if (f) forms.set(f, [...forms.get(f) ?? [], b.id]);
   }
-  for (const [f, ids] of forms)
-    if (ids.length > 1)
+  for (const [f, [first, ...rest]] of forms)
+    for (const id2 of rest)
       out.push(
-        `The plan draws \`${f}\` ${ids.length} times (${ids.join(", ")}). It draws no picture, so a second one is the same slide again: keep it on one beat, and draw the others another way or with \`literal\` null.`
+        `${id2} draws \`${f}\`, as ${first} already does. It draws no picture, so a second one is the same slide again: draw ${id2} another way, or with \`literal\` null.`
       );
   return out;
 }
@@ -25825,13 +25825,39 @@ function operateVariants(v) {
   return [only(OPERATE_CHAIN, OPERATE_TERMS), only(OPERATE_TERMS)];
 }
 function schemaFor(prefs, source) {
-  return splitOperate(
-    hideFromPlanner(
-      forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
-      plannerInvisible(prefs, source)
+  return shareLiteral(
+    splitOperate(
+      hideFromPlanner(
+        forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
+        plannerInvisible(prefs, source)
+      )
     )
   );
 }
+function shareLiteral(schema2) {
+  const root2 = schema2;
+  const variants = root2.properties.beats.items.anyOf;
+  const literal = variants[0]?.properties.literal;
+  if (!literal) return schema2;
+  const one2 = JSON.stringify(literal);
+  if (!variants.every((v) => JSON.stringify(v.properties.literal) === one2))
+    throw new Error("schemaFor: the beat variants carry different `literal` schemas.");
+  const ref = { $ref: "#/$defs/literal" };
+  return {
+    ...root2,
+    $defs: { literal },
+    properties: {
+      ...root2.properties,
+      beats: {
+        ...root2.properties.beats,
+        items: {
+          ...root2.properties.beats.items,
+          anyOf: variants.map((v) => ({ ...v, properties: { ...v.properties, literal: ref } }))
+        }
+      }
+    }
+  };
+}
 var SCHEMA = schemaFor(prefsSchema.parse({}));
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jokerized/decksmith",
-  "version": "0.9.7",
+  "version": "0.9.8",
   "description": "Turn a source document into an animated explanation deck.",
   "type": "module",
   "license": "MIT",