@forwardimpact/pathway 0.25.20 → 0.25.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/pathway",
-  "version": "0.25.20",
+  "version": "0.25.21",
   "description": "Career progression web app and CLI for exploring roles and generating agent teams",
   "license": "Apache-2.0",
   "repository": {

package/src/formatters/index.js

@@ -7,7 +7,6 @@
 
 // Shared utilities
 export * from "./shared.js";
-export * from "./microdata-shared.js";
 
 // Job formatters
 export { jobToMarkdown } from "./job/markdown.js";
@@ -23,15 +22,10 @@ export { progressToDOM } from "./progress/dom.js";
 
 // Driver formatters
 export { driverToDOM } from "./driver/dom.js";
-export {
-  driverListToMicrodata,
-  driverToMicrodata,
-} from "./driver/microdata.js";
 
 // Skill formatters
 export { skillListToMarkdown, skillToMarkdown } from "./skill/markdown.js";
 export { skillToDOM } from "./skill/dom.js";
-export { skillListToMicrodata, skillToMicrodata } from "./skill/microdata.js";
 
 // Behaviour formatters
 export {
@@ -39,10 +33,6 @@ export {
   behaviourToMarkdown,
 } from "./behaviour/markdown.js";
 export { behaviourToDOM } from "./behaviour/dom.js";
-export {
-  behaviourListToMicrodata,
-  behaviourToMicrodata,
-} from "./behaviour/microdata.js";
 
 // Discipline formatters
 export {
@@ -50,23 +40,14 @@ export {
   disciplineToMarkdown,
 } from "./discipline/markdown.js";
 export { disciplineToDOM } from "./discipline/dom.js";
-export {
-  disciplineListToMicrodata,
-  disciplineToMicrodata,
-} from "./discipline/microdata.js";
 
 // Level formatters
 export { levelListToMarkdown, levelToMarkdown } from "./level/markdown.js";
 export { levelToDOM } from "./level/dom.js";
-export { levelListToMicrodata, levelToMicrodata } from "./level/microdata.js";
 
 // Track formatters
 export { trackListToMarkdown, trackToMarkdown } from "./track/markdown.js";
 export { trackToDOM } from "./track/dom.js";
-export { trackListToMicrodata, trackToMicrodata } from "./track/microdata.js";
-
-// Stage formatters
-export { stageListToMicrodata, stageToMicrodata } from "./stage/microdata.js";
 
 // JSON-LD formatters
 export {

package/src/formatters/behaviour/microdata.js

@@ -1,106 +0,0 @@
-/**
- * Behaviour formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with behaviour.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/rdf/
- */
-
-import {
-  openTag,
-  prop,
-  propRaw,
-  metaTag,
-  section,
-  dl,
-  ul,
-  escapeHtml,
-  formatLevelName,
-  htmlDocument,
-} from "../microdata-shared.js";
-import { prepareBehavioursList, prepareBehaviourDetail } from "./shared.js";
-
-/**
- * Format behaviour list as microdata HTML
- * @param {Array} behaviours - Raw behaviour entities
- * @returns {string} HTML with microdata
- */
-export function behaviourListToMicrodata(behaviours) {
-  const { items } = prepareBehavioursList(behaviours);
-
-  const content = items
-    .map(
-      (
-        behaviour,
-      ) => `${openTag("article", { itemtype: "Behaviour", itemid: `#${behaviour.id}` })}
-${prop("h2", "name", behaviour.name)}
-${prop("p", "description", behaviour.truncatedDescription)}
-</article>`,
-    )
-    .join("\n");
-
-  return htmlDocument(
-    "Behaviours",
-    `<main>
-<h1>Behaviours</h1>
-${content}
-</main>`,
-  );
-}
-
-/**
- * Format behaviour detail as microdata HTML
- * @param {Object} behaviour - Raw behaviour entity
- * @param {Object} context - Additional context
- * @param {Array} context.drivers - All drivers
- * @returns {string} HTML with microdata
- */
-export function behaviourToMicrodata(behaviour, { drivers }) {
-  const view = prepareBehaviourDetail(behaviour, { drivers });
-
-  if (!view) return "";
-
-  const sections = [];
-
-  // Maturity descriptions - uses MaturityDescriptions itemtype
-  const maturityPairs = Object.entries(view.maturityDescriptions).map(
-    ([maturity, desc]) => ({
-      term: formatLevelName(maturity),
-      definition: desc,
-      itemprop: `${maturity.replace(/_([a-z])/g, (_, c) => c.toUpperCase())}Description`,
-    }),
-  );
-  sections.push(
-    section(
-      "Maturity Levels",
-      `${openTag("div", { itemtype: "MaturityDescriptions", itemprop: "maturityDescriptions" })}
-${dl(maturityPairs)}
-</div>`,
-      2,
-    ),
-  );
-
-  // Related drivers
-  if (view.relatedDrivers.length > 0) {
-    const driverItems = view.relatedDrivers.map(
-      (d) => `<a href="#${escapeHtml(d.id)}">${escapeHtml(d.name)}</a>`,
-    );
-    sections.push(section("Linked to Drivers", ul(driverItems), 2));
-  }
-
-  const body = `<main>
-${openTag("article", { itemtype: "Behaviour", itemid: `#${view.id}` })}
-${prop("h1", "name", view.name)}
-${metaTag("id", view.id)}
-${propRaw(
-  "div",
-  "human",
-  `${openTag("div", { itemtype: "BehaviourHumanSection" })}
-${prop("p", "description", view.description)}
-${sections.join("\n")}
-</div>`,
-)}
-</article>
-</main>`;
-
-  return htmlDocument(view.name, body);
-}

package/src/formatters/discipline/microdata.js

@@ -1,117 +0,0 @@
-/**
- * Discipline formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with discipline.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/rdf/
- */
-
-import {
-  openTag,
-  prop,
-  metaTag,
-  linkTag,
-  section,
-  ul,
-  escapeHtml,
-  htmlDocument,
-} from "../microdata-shared.js";
-import { prepareDisciplinesList, prepareDisciplineDetail } from "./shared.js";
-
-/**
- * Format discipline list as microdata HTML
- * @param {Array} disciplines - Raw discipline entities
- * @returns {string} HTML with microdata
- */
-export function disciplineListToMicrodata(disciplines) {
-  const { items } = prepareDisciplinesList(disciplines);
-
-  const content = items
-    .map(
-      (
-        d,
-      ) => `${openTag("article", { itemtype: "Discipline", itemid: `#${d.id}` })}
-${prop("h2", "specialization", d.name)}
-<p>Core: ${d.coreSkillsCount} | Supporting: ${d.supportingSkillsCount} | Broad: ${d.broadSkillsCount}</p>
-</article>`,
-    )
-    .join("\n");
-
-  return htmlDocument(
-    "Disciplines",
-    `<main>
-<h1>Disciplines</h1>
-${content}
-</main>`,
-  );
-}
-
-/**
- * Format discipline detail as microdata HTML
- * @param {Object} discipline - Raw discipline entity
- * @param {Object} context - Additional context
- * @param {Array} context.skills - All skills
- * @param {Array} context.behaviours - All behaviours
- * @param {boolean} [context.showBehaviourModifiers=true] - Whether to show behaviour modifiers section
- * @returns {string} HTML with microdata
- */
-export function disciplineToMicrodata(
-  discipline,
-  { skills, behaviours, showBehaviourModifiers = true } = {},
-) {
-  const view = prepareDisciplineDetail(discipline, { skills, behaviours });
-
-  if (!view) return "";
-
-  const sections = [];
-
-  // Core skills - using coreSkills property
-  if (view.coreSkills.length > 0) {
-    const skillLinks = view.coreSkills.map(
-      (s) =>
-        `${openTag("span", { itemprop: "coreSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
-    );
-    sections.push(section("Core Skills", ul(skillLinks), 2));
-  }
-
-  // Supporting skills - using supportingSkills property
-  if (view.supportingSkills.length > 0) {
-    const skillLinks = view.supportingSkills.map(
-      (s) =>
-        `${openTag("span", { itemprop: "supportingSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
-    );
-    sections.push(section("Supporting Skills", ul(skillLinks), 2));
-  }
-
-  // Broad skills - using broadSkills property
-  if (view.broadSkills.length > 0) {
-    const skillLinks = view.broadSkills.map(
-      (s) =>
-        `${openTag("span", { itemprop: "broadSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
-    );
-    sections.push(section("Broad Skills", ul(skillLinks), 2));
-  }
-
-  // Behaviour modifiers - using BehaviourModifier itemtype
-  if (showBehaviourModifiers && view.behaviourModifiers.length > 0) {
-    const modifierItems = view.behaviourModifiers.map((b) => {
-      const modifierStr = b.modifier > 0 ? `+${b.modifier}` : `${b.modifier}`;
-      return `${openTag("span", { itemtype: "BehaviourModifier", itemprop: "behaviourModifiers" })}
-${linkTag("targetBehaviour", `#${b.id}`)}
-<a href="#${escapeHtml(b.id)}">${escapeHtml(b.name)}</a>: ${openTag("span", { itemprop: "modifierValue" })}${modifierStr}</span>
-</span>`;
-    });
-    sections.push(section("Behaviour Modifiers", ul(modifierItems), 2));
-  }
-
-  const body = `<main>
-${openTag("article", { itemtype: "Discipline", itemid: `#${view.id}` })}
-${prop("h1", "specialization", view.name)}
-${metaTag("id", view.id)}
-${discipline.roleTitle ? prop("p", "roleTitle", discipline.roleTitle) : ""}
-${prop("p", "description", view.description)}
-${sections.join("\n")}
-</article>
-</main>`;
-
-  return htmlDocument(view.name, body);
-}

package/src/formatters/driver/microdata.js

@@ -1,91 +0,0 @@
-/**
- * Driver formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with drivers.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/rdf/
- */
-
-import {
-  openTag,
-  prop,
-  metaTag,
-  section,
-  ul,
-  escapeHtml,
-  htmlDocument,
-} from "../microdata-shared.js";
-import { prepareDriversList, prepareDriverDetail } from "./shared.js";
-
-/**
- * Format driver list as microdata HTML
- * @param {Array} drivers - Raw driver entities
- * @returns {string} HTML with microdata
- */
-export function driverListToMicrodata(drivers) {
-  const { items } = prepareDriversList(drivers);
-
-  const content = items
-    .map(
-      (
-        driver,
-      ) => `${openTag("article", { itemtype: "Driver", itemid: `#${driver.id}` })}
-${prop("h2", "name", driver.name)}
-${prop("p", "description", driver.truncatedDescription)}
-<p>Skills: ${driver.contributingSkillsCount} | Behaviours: ${driver.contributingBehavioursCount}</p>
-</article>`,
-    )
-    .join("\n");
-
-  return htmlDocument(
-    "Drivers",
-    `<main>
-<h1>Drivers</h1>
-${content}
-</main>`,
-  );
-}
-
-/**
- * Format driver detail as microdata HTML
- * @param {Object} driver - Raw driver entity
- * @param {Object} context - Additional context
- * @param {Array} context.skills - All skills
- * @param {Array} context.behaviours - All behaviours
- * @returns {string} HTML with microdata
- */
-export function driverToMicrodata(driver, { skills, behaviours }) {
-  const view = prepareDriverDetail(driver, { skills, behaviours });
-
-  if (!view) return "";
-
-  const sections = [];
-
-  // Contributing skills - using contributingSkills property
-  if (view.contributingSkills.length > 0) {
-    const skillLinks = view.contributingSkills.map(
-      (s) =>
-        `${openTag("span", { itemprop: "contributingSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
-    );
-    sections.push(section("Contributing Skills", ul(skillLinks), 2));
-  }
-
-  // Contributing behaviours - using contributingBehaviours property
-  if (view.contributingBehaviours.length > 0) {
-    const behaviourLinks = view.contributingBehaviours.map(
-      (b) =>
-        `${openTag("span", { itemprop: "contributingBehaviours" })}<a href="#${escapeHtml(b.id)}">${escapeHtml(b.name)}</a></span>`,
-    );
-    sections.push(section("Contributing Behaviours", ul(behaviourLinks), 2));
-  }
-
-  const body = `<main>
-${openTag("article", { itemtype: "Driver", itemid: `#${view.id}` })}
-${prop("h1", "name", view.name)}
-${metaTag("id", view.id)}
-${prop("p", "description", view.description)}
-${sections.join("\n")}
-</article>
-</main>`;
-
-  return htmlDocument(view.name, body);
-}

package/src/formatters/level/microdata.js

@@ -1,141 +0,0 @@
-/**
- * Level formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with levels.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/rdf/
- */
-
-import {
-  openTag,
-  prop,
-  metaTag,
-  linkTag,
-  section,
-  dl,
-  escapeHtml,
-  formatLevelName,
-  htmlDocument,
-} from "../microdata-shared.js";
-import { prepareLevelsList, prepareLevelDetail } from "./shared.js";
-
-/**
- * Format level list as microdata HTML
- * @param {Array} levels - Raw level entities
- * @returns {string} HTML with microdata
- */
-export function levelListToMicrodata(levels) {
-  const { items } = prepareLevelsList(levels);
-
-  const content = items
-    .map(
-      (g) => `${openTag("article", { itemtype: "Level", itemid: `#${g.id}` })}
-${prop("h2", "id", g.id)}
-<p>${escapeHtml(g.displayName)}</p>
-${g.typicalExperienceRange ? prop("p", "typicalExperienceRange", g.typicalExperienceRange) : ""}
-${metaTag("ordinalRank", String(g.ordinalRank))}
-</article>`,
-    )
-    .join("\n");
-
-  return htmlDocument(
-    "Levels",
-    `<main>
-<h1>Levels</h1>
-${content}
-</main>`,
-  );
-}
-
-/**
- * Format level detail as microdata HTML
- * @param {Object} level - Raw level entity
- * @returns {string} HTML with microdata
- */
-export function levelToMicrodata(level) {
-  const view = prepareLevelDetail(level);
-
-  if (!view) return "";
-
-  const sections = [];
-
-  // Titles section
-  if (view.professionalTitle || view.managementTitle) {
-    const titlePairs = [];
-    if (view.professionalTitle) {
-      titlePairs.push({
-        term: "Professional Track",
-        definition: view.professionalTitle,
-        itemprop: "professionalTitle",
-      });
-    }
-    if (view.managementTitle) {
-      titlePairs.push({
-        term: "Management Track",
-        definition: view.managementTitle,
-        itemprop: "managementTitle",
-      });
-    }
-    sections.push(section("Titles", dl(titlePairs), 2));
-  }
-
-  // Base skill proficiencies - using BaseSkillProficiencies itemtype
-  if (
-    view.baseSkillProficiencies &&
-    Object.keys(view.baseSkillProficiencies).length > 0
-  ) {
-    const levelPairs = Object.entries(view.baseSkillProficiencies).map(
-      ([type, level]) => ({
-        term: formatLevelName(type),
-        definition: formatLevelName(level),
-        itemprop: type,
-      }),
-    );
-    sections.push(
-      section(
-        "Base Skill Proficiencies",
-        `${openTag("div", { itemtype: "BaseSkillProficiencies", itemprop: "baseSkillProficiencies" })}
-${dl(levelPairs)}
-</div>`,
-        2,
-      ),
-    );
-  }
-
-  // Base behaviour maturity - link to BehaviourMaturity
-  if (view.baseBehaviourMaturity) {
-    const maturityContent = `${linkTag("baseBehaviourMaturity", `#${level.baseBehaviourMaturity}`)}
-<p>${formatLevelName(level.baseBehaviourMaturity)}</p>`;
-    sections.push(section("Base Behaviour Maturity", maturityContent, 2));
-  }
-
-  // Expectations - using LevelExpectations itemtype
-  if (view.expectations && Object.keys(view.expectations).length > 0) {
-    const expectationPairs = Object.entries(view.expectations).map(
-      ([key, value]) => ({
-        term: formatLevelName(key),
-        definition: value,
-        itemprop: key,
-      }),
-    );
-    sections.push(
-      section(
-        "Expectations",
-        `${openTag("div", { itemtype: "LevelExpectations", itemprop: "expectations" })}
-${dl(expectationPairs)}
-</div>`,
-        2,
-      ),
-    );
-  }
-
-  const body = `<main>
-${openTag("article", { itemtype: "Level", itemid: `#${view.id}` })}
-<h1>${prop("span", "id", view.id)} — ${escapeHtml(view.displayName)}</h1>
-${metaTag("ordinalRank", String(view.ordinalRank))}
-${view.typicalExperienceRange ? prop("p", "typicalExperienceRange", `Experience: ${view.typicalExperienceRange}`) : ""}
-${sections.join("\n")}
-</article>
-</main>`;
-
-  return htmlDocument(`${view.id} - ${view.displayName}`, body);
-}

package/src/formatters/microdata-shared.js

@@ -1,184 +0,0 @@
-/**
- * Shared microdata HTML utilities
- *
- * Helper functions for generating clean, class-less HTML with microdata attributes
- * aligned with the RDF schema at https://www.forwardimpact.team/schema/rdf/
- */
-
-const VOCAB_BASE = "https://www.forwardimpact.team/schema/rdf/";
-
-/**
- * Create an opening tag with microdata attributes
- * @param {string} tag - HTML tag name
- * @param {Object} [attrs] - Optional attributes
- * @param {string} [attrs.itemtype] - Microdata type (without vocab prefix)
- * @param {string} [attrs.itemprop] - Microdata property name
- * @param {string} [attrs.itemid] - Microdata item ID
- * @returns {string}
- */
-export function openTag(tag, attrs = {}) {
-  const parts = [tag];
-
-  if (attrs.itemtype) {
-    parts.push(`itemscope`);
-    parts.push(`itemtype="${VOCAB_BASE}${attrs.itemtype}"`);
-  }
-
-  if (attrs.itemprop) {
-    parts.push(`itemprop="${attrs.itemprop}"`);
-  }
-
-  if (attrs.itemid) {
-    parts.push(`itemid="${attrs.itemid}"`);
-  }
-
-  return `<${parts.join(" ")}>`;
-}
-
-/**
- * Create a self-closing meta element with microdata
- * @param {string} itemprop - Property name
- * @param {string} content - Content value
- * @returns {string}
- */
-export function metaTag(itemprop, content) {
-  return `<meta itemprop="${itemprop}" content="${escapeAttr(content)}">`;
-}
-
-/**
- * Create a link element with microdata
- * @param {string} itemprop - Property name
- * @param {string} href - Link target
- * @returns {string}
- */
-export function linkTag(itemprop, href) {
-  return `<link itemprop="${itemprop}" href="${escapeAttr(href)}">`;
-}
-
-/**
- * Wrap content in an element with itemprop
- * @param {string} tag - HTML tag name
- * @param {string} itemprop - Property name
- * @param {string} content - Content to wrap
- * @returns {string}
- */
-export function prop(tag, itemprop, content) {
-  return `<${tag} itemprop="${itemprop}">${escapeHtml(content)}</${tag}>`;
-}
-
-/**
- * Wrap raw HTML content in an element with itemprop (no escaping)
- * @param {string} tag - HTML tag name
- * @param {string} itemprop - Property name
- * @param {string} html - HTML content to wrap
- * @returns {string}
- */
-export function propRaw(tag, itemprop, html) {
-  return `<${tag} itemprop="${itemprop}">${html}</${tag}>`;
-}
-
-/**
- * Create a section with optional heading
- * @param {string} heading - Section heading text
- * @param {string} content - Section content
- * @param {number} [level=2] - Heading level (2-6)
- * @returns {string}
- */
-export function section(heading, content, level = 2) {
-  const hTag = `h${Math.min(Math.max(level, 1), 6)}`;
-  return `<section>
-<${hTag}>${escapeHtml(heading)}</${hTag}>
-${content}
-</section>`;
-}
-
-/**
- * Create an unordered list
- * @param {string[]} items - List items (already HTML)
- * @param {string} [itemprop] - Optional property for list items
- * @returns {string}
- */
-export function ul(items, itemprop) {
-  if (!items.length) return "";
-  const lis = items
-    .map((item) =>
-      itemprop ? `<li itemprop="${itemprop}">${item}</li>` : `<li>${item}</li>`,
-    )
-    .join("\n");
-  return `<ul>\n${lis}\n</ul>`;
-}
-
-/**
- * Create a definition list from key-value pairs
- * @param {Array<{term: string, definition: string, itemprop?: string}>} pairs
- * @returns {string}
- */
-export function dl(pairs) {
-  if (!pairs.length) return "";
-  const content = pairs
-    .map(({ term, definition, itemprop }) => {
-      const dd = itemprop
-        ? `<dd itemprop="${itemprop}">${escapeHtml(definition)}</dd>`
-        : `<dd>${escapeHtml(definition)}</dd>`;
-      return `<dt>${escapeHtml(term)}</dt>\n${dd}`;
-    })
-    .join("\n");
-  return `<dl>\n${content}\n</dl>`;
-}
-
-/**
- * Escape HTML special characters
- * @param {string} str
- * @returns {string}
- */
-export function escapeHtml(str) {
-  if (str == null) return "";
-  return String(str)
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-/**
- * Escape attribute value
- * @param {string} str
- * @returns {string}
- */
-export function escapeAttr(str) {
-  if (str == null) return "";
-  return String(str)
-    .replace(/&/g, "&amp;")
-    .replace(/"/g, "&quot;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-/**
- * Format level name for display (capitalize, replace underscores)
- * @param {string} level
- * @returns {string}
- */
-export function formatLevelName(level) {
-  if (!level) return "";
-  return level.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-
-/**
- * Generate a full microdata HTML document
- * @param {string} title - Document title
- * @param {string} body - Body content
- * @returns {string}
- */
-export function htmlDocument(title, body) {
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>${escapeHtml(title)}</title>
-</head>
-<body>
-${body}
-</body>
-</html>`;
-}

package/src/formatters/skill/microdata.js

@@ -1,151 +0,0 @@
-/**
- * Skill formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with capability.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/rdf/
- */
-
-import {
-  openTag,
-  prop,
-  propRaw,
-  metaTag,
-  section,
-  dl,
-  ul,
-  escapeHtml,
-  formatLevelName,
-  htmlDocument,
-} from "../microdata-shared.js";
-import { prepareSkillsList, prepareSkillDetail } from "./shared.js";
-
-/**
- * Format skill list as microdata HTML
- * @param {Array} skills - Raw skill entities
- * @param {Array} capabilities - Capability entities
- * @returns {string} HTML with microdata
- */
-export function skillListToMicrodata(skills, capabilities) {
-  const { groups, groupOrder } = prepareSkillsList(skills, capabilities);
-
-  const content = groupOrder
-    .map((capability) => {
-      const capabilitySkills = groups[capability];
-      const skillItems = capabilitySkills
-        .map(
-          (
-            skill,
-          ) => `${openTag("article", { itemtype: "Skill", itemid: `#${skill.id}` })}
-${prop("h3", "name", skill.name)}
-${prop("p", "description", skill.truncatedDescription)}
-${metaTag("capability", capability)}
-</article>`,
-        )
-        .join("\n");
-
-      return section(formatLevelName(capability), skillItems, 2);
-    })
-    .join("\n");
-
-  return htmlDocument(
-    "Skills",
-    `<main>
-<h1>Skills</h1>
-${content}
-</main>`,
-  );
-}
-
-/**
- * Format skill detail as microdata HTML
- * @param {Object} skill - Raw skill entity
- * @param {Object} context - Additional context
- * @param {Array} context.disciplines - All disciplines
- * @param {Array} context.tracks - All tracks
- * @param {Array} context.drivers - All drivers
- * @param {Array} context.capabilities - Capability entities
- * @returns {string} HTML with microdata
- */
-export function skillToMicrodata(
-  skill,
-  { disciplines, tracks, drivers, capabilities },
-) {
-  const view = prepareSkillDetail(skill, {
-    disciplines,
-    tracks,
-    drivers,
-    capabilities,
-  });
-
-  if (!view) return "";
-
-  const sections = [];
-
-  // Human-only badge
-  if (view.isHumanOnly) {
-    sections.push(`<p><strong>Human-Only</strong> — Requires interpersonal skills; excluded from agents</p>
-${metaTag("isHumanOnly", "true")}`);
-  }
-
-  // Level descriptions - uses ProficiencyDescriptions itemtype
-  const levelPairs = Object.entries(view.proficiencyDescriptions).map(
-    ([level, desc]) => ({
-      term: formatLevelName(level),
-      definition: desc,
-      itemprop: `${level}Description`,
-    }),
-  );
-  sections.push(
-    section(
-      "Level Descriptions",
-      `${openTag("div", { itemtype: "ProficiencyDescriptions", itemprop: "proficiencyDescriptions" })}
-${dl(levelPairs)}
-</div>`,
-      2,
-    ),
-  );
-
-  // Related disciplines
-  if (view.relatedDisciplines.length > 0) {
-    const disciplineItems = view.relatedDisciplines.map(
-      (d) =>
-        `<a href="#${escapeHtml(d.id)}">${escapeHtml(d.name)}</a> (${escapeHtml(d.skillType)})`,
-    );
-    sections.push(section("Used in Disciplines", ul(disciplineItems), 2));
-  }
-
-  // Related tracks with modifiers
-  if (view.relatedTracks.length > 0) {
-    const trackItems = view.relatedTracks.map((t) => {
-      const modifierStr = t.modifier > 0 ? `+${t.modifier}` : `${t.modifier}`;
-      return `<a href="#${escapeHtml(t.id)}">${escapeHtml(t.name)}</a>: ${modifierStr}`;
-    });
-    sections.push(section("Modified by Tracks", ul(trackItems), 2));
-  }
-
-  // Related drivers
-  if (view.relatedDrivers.length > 0) {
-    const driverItems = view.relatedDrivers.map(
-      (d) => `<a href="#${escapeHtml(d.id)}">${escapeHtml(d.name)}</a>`,
-    );
-    sections.push(section("Linked to Drivers", ul(driverItems), 2));
-  }
-
-  const body = `<main>
-${openTag("article", { itemtype: "Skill", itemid: `#${view.id}` })}
-${prop("h1", "name", view.name)}
-${metaTag("id", view.id)}
-${metaTag("capability", view.capability)}
-${propRaw(
-  "div",
-  "human",
-  `${openTag("div", { itemtype: "SkillHumanSection" })}
-${prop("p", "description", view.description)}
-${sections.join("\n")}
-</div>`,
-)}
-</article>
-</main>`;
-
-  return htmlDocument(view.name, body);
-}

package/src/formatters/stage/microdata.js

@@ -1,116 +0,0 @@
-/**
- * Stage formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with stages.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/rdf/
- */
-
-import {
-  openTag,
-  prop,
-  metaTag,
-  linkTag,
-  section,
-  ul,
-  escapeHtml,
-  htmlDocument,
-} from "../microdata-shared.js";
-import { prepareStagesList, prepareStageDetail } from "./shared.js";
-
-/**
- * Format stage list as microdata HTML
- * @param {Array} stages - Raw stage entities
- * @returns {string} HTML with microdata
- */
-export function stageListToMicrodata(stages) {
-  const { items } = prepareStagesList(stages);
-
-  const content = items
-    .map((stage) => {
-      const handoffText =
-        stage.handoffs.length > 0
-          ? `→ ${stage.handoffs.map((h) => h.target).join(", ")}`
-          : "";
-      return `${openTag("article", { itemtype: "Stage", itemid: `#${stage.id}` })}
-${prop("h2", "name", `${stage.emojiIcon} ${stage.name}`)}
-${prop("p", "description", stage.truncatedDescription)}
-${handoffText ? `<p>Handoffs: ${handoffText}</p>` : ""}
-</article>`;
-    })
-    .join("\n");
-
-  return htmlDocument(
-    "Stages",
-    `<main>
-<h1>Stages</h1>
-${content}
-</main>`,
-  );
-}
-
-/**
- * Format stage detail as microdata HTML
- * @param {Object} stage - Raw stage entity
- * @returns {string} HTML with microdata
- */
-export function stageToMicrodata(stage) {
-  const view = prepareStageDetail(stage);
-
-  if (!view) return "";
-
-  const sections = [];
-
-  // Read checklist
-  if (view.readChecklist.length > 0) {
-    const readItems = view.readChecklist.map((c) => escapeHtml(c));
-    sections.push(
-      section("Read-Then-Do Checklist", ul(readItems, "readChecklist"), 2),
-    );
-  }
-
-  // Constraints
-  if (view.constraints.length > 0) {
-    const constraintItems = view.constraints.map((c) => escapeHtml(c));
-    sections.push(
-      section("Constraints", ul(constraintItems, "constraints"), 2),
-    );
-  }
-
-  // Confirm checklist
-  if (view.confirmChecklist.length > 0) {
-    const confirmItems = view.confirmChecklist.map((c) => escapeHtml(c));
-    sections.push(
-      section(
-        "Do-Then-Confirm Checklist",
-        ul(confirmItems, "confirmChecklist"),
-        2,
-      ),
-    );
-  }
-
-  // Handoffs - using Handoff itemtype
-  if (view.handoffs.length > 0) {
-    const handoffItems = view.handoffs.map(
-      (
-        h,
-      ) => `${openTag("article", { itemtype: "Handoff", itemprop: "handoffs" })}
-${linkTag("targetStage", `#${h.target}`)}
-<p><strong>${prop("span", "label", h.label)}</strong> → ${escapeHtml(h.target)}</p>
-${prop("p", "prompt", h.prompt)}
-</article>`,
-    );
-    sections.push(section("Handoffs", handoffItems.join("\n"), 2));
-  }
-
-  const body = `<main>
-${openTag("article", { itemtype: "Stage", itemid: `#${view.id}` })}
-${prop("h1", "name", view.name)}
-${metaTag("id", view.id)}
-${stage.emojiIcon ? metaTag("emojiIcon", stage.emojiIcon) : ""}
-${prop("p", "description", view.description)}
-${sections.join("\n")}
-</article>
-</main>`;
-
-  return htmlDocument(view.name, body);
-}

package/src/formatters/track/microdata.js

@@ -1,111 +0,0 @@
-/**
- * Track formatting for microdata HTML output
- *
- * Generates clean, class-less HTML with microdata aligned with track.schema.json
- * RDF vocab: https://www.forwardimpact.team/schema/rdf/
- */
-
-import {
-  openTag,
-  prop,
-  metaTag,
-  linkTag,
-  section,
-  ul,
-  escapeHtml,
-  htmlDocument,
-} from "../microdata-shared.js";
-import { prepareTracksList, prepareTrackDetail } from "./shared.js";
-
-/**
- * Format track list as microdata HTML
- * @param {Array} tracks - Raw track entities
- * @returns {string} HTML with microdata
- */
-export function trackListToMicrodata(tracks) {
-  const { items } = prepareTracksList(tracks);
-
-  const content = items
-    .map((track) => {
-      return `${openTag("article", { itemtype: "Track", itemid: `#${track.id}` })}
-${prop("h2", "name", track.name)}
-</article>`;
-    })
-    .join("\n");
-
-  return htmlDocument(
-    "Tracks",
-    `<main>
-<h1>Tracks</h1>
-${content}
-</main>`,
-  );
-}
-
-/**
- * Format track detail as microdata HTML
- * @param {Object} track - Raw track entity
- * @param {Object} context - Additional context
- * @param {Array} context.skills - All skills
- * @param {Array} context.behaviours - All behaviours
- * @param {Array} context.disciplines - All disciplines
- * @returns {string} HTML with microdata
- */
-export function trackToMicrodata(track, { skills, behaviours, disciplines }) {
-  const view = prepareTrackDetail(track, { skills, behaviours, disciplines });
-
-  if (!view) return "";
-
-  const sections = [];
-
-  // Skill modifiers - using SkillModifier itemtype with targetCapability
-  if (view.skillModifiers.length > 0) {
-    const modifierItems = view.skillModifiers.map((m) => {
-      const modifierStr = m.modifier > 0 ? `+${m.modifier}` : `${m.modifier}`;
-
-      if (m.isCapability && m.skills && m.skills.length > 0) {
-        // Capability with expanded skills
-        const skillLinks = m.skills
-          .map(
-            (s) => `<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a>`,
-          )
-          .join(", ");
-        return `${openTag("div", { itemtype: "SkillModifier", itemprop: "skillModifiers" })}
-${linkTag("targetCapability", `#${m.id}`)}
-<strong>${escapeHtml(m.name)} Capability</strong> (${openTag("span", { itemprop: "modifierValue" })}${modifierStr}</span>)
-<p>${skillLinks}</p>
-</div>`;
-      } else {
-        // Individual skill or capability without skills
-        return `${openTag("span", { itemtype: "SkillModifier", itemprop: "skillModifiers" })}
-${linkTag("targetCapability", `#${m.id}`)}
-<strong>${escapeHtml(m.name)}</strong>: ${openTag("span", { itemprop: "modifierValue" })}${modifierStr}</span>
-</span>`;
-      }
-    });
-    sections.push(section("Skill Modifiers", modifierItems.join("\n"), 2));
-  }
-
-  // Behaviour modifiers - using BehaviourModifier itemtype
-  if (view.behaviourModifiers.length > 0) {
-    const modifierItems = view.behaviourModifiers.map((b) => {
-      const modifierStr = b.modifier > 0 ? `+${b.modifier}` : `${b.modifier}`;
-      return `${openTag("span", { itemtype: "BehaviourModifier", itemprop: "behaviourModifiers" })}
-${linkTag("targetBehaviour", `#${b.id}`)}
-<a href="#${escapeHtml(b.id)}">${escapeHtml(b.name)}</a>: ${openTag("span", { itemprop: "modifierValue" })}${modifierStr}</span>
-</span>`;
-    });
-    sections.push(section("Behaviour Modifiers", ul(modifierItems), 2));
-  }
-
-  const body = `<main>
-${openTag("article", { itemtype: "Track", itemid: `#${view.id}` })}
-${prop("h1", "name", view.name)}
-${metaTag("id", view.id)}
-${prop("p", "description", view.description)}
-${sections.join("\n")}
-</article>
-</main>`;
-
-  return htmlDocument(view.name, body);
-}